Quelle  cros_charge-control.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  ChromeOS EC driver for charge control
 *
 *  Copyright (C) 2024 Thomas Weißschuh <linux@weissschuh.net>
 */
#include <acpi/battery.h>
#include <linux/container_of.h>
#include <linux/dmi.h>
#include <linux/lockdep.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/platform_device.h>
#include <linux/types.h>

#define EC_CHARGE_CONTROL_BEHAVIOURS (BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO)             | \
      BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE)   | \
      BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_FORCE_DISCHARGE))

/*
 * Semantics of data *returned* from the EC API and Linux sysfs differ
 * slightly, also the v1 API can not return any data.
 * To match the expected sysfs API, data is never read back from the EC but
 * cached in the driver.
 *
 * Changes to the EC bypassing the driver will not be reflected in sysfs.
 * Any change to "charge_behaviour" will synchronize the EC with the driver state.
 */

struct cros_chctl_priv {
 struct device *dev;
 struct cros_ec_device *cros_ec;
 struct acpi_battery_hook battery_hook;
 struct power_supply *hooked_battery;
 u8 cmd_version;

 const struct power_supply_ext *psy_ext;

 struct mutex lock; /* protects fields below and cros_ec */
 enum power_supply_charge_behaviour current_behaviour;
 u8 current_start_threshold, current_end_threshold;
};

static int cros_chctl_send_charge_control_cmd(struct cros_ec_device *cros_ec,
           u8 cmd_version, struct ec_params_charge_control *req)
{
 int ret;
 static const u8 outsizes[] = {
  [1] = offsetof(struct ec_params_charge_control, cmd),
  [2] = sizeof(struct ec_params_charge_control),
  [3] = sizeof(struct ec_params_charge_control),
 };

 ret = cros_ec_cmd(cros_ec, cmd_version, EC_CMD_CHARGE_CONTROL, req,
     outsizes[cmd_version], NULL, 0);

 if (ret < 0)
  return ret;

 return 0;
}

static int cros_chctl_configure_ec(struct cros_chctl_priv *priv)
{
 struct ec_params_charge_control req = {};

 lockdep_assert_held(&priv->lock);

 req.cmd = EC_CHARGE_CONTROL_CMD_SET;

 switch (priv->current_behaviour) {
 case POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO:
  req.mode = CHARGE_CONTROL_NORMAL;
  break;
 case POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE:
  req.mode = CHARGE_CONTROL_IDLE;
  break;
 case POWER_SUPPLY_CHARGE_BEHAVIOUR_FORCE_DISCHARGE:
  req.mode = CHARGE_CONTROL_DISCHARGE;
  break;
 default:
  return -EINVAL;
 }

 if (priv->current_behaviour == POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO &&
     !(priv->current_start_threshold == 0 && priv->current_end_threshold == 100)) {
  req.sustain_soc.lower = priv->current_start_threshold;
  req.sustain_soc.upper = priv->current_end_threshold;
 } else {
  /* Disable charging limits */
  req.sustain_soc.lower = -1;
  req.sustain_soc.upper = -1;
 }

 return cros_chctl_send_charge_control_cmd(priv->cros_ec, priv->cmd_version, &req);
}

static int cros_chctl_psy_ext_get_prop(struct power_supply *psy,
           const struct power_supply_ext *ext,
           void *data,
           enum power_supply_property psp,
           union power_supply_propval *val)
{
 struct cros_chctl_priv *priv = data;

 switch (psp) {
 case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD:
  val->intval = priv->current_start_threshold;
  return 0;
 case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD:
  val->intval = priv->current_end_threshold;
  return 0;
 case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
  val->intval = priv->current_behaviour;
  return 0;
 default:
  return -EINVAL;
 }
}

static int cros_chctl_psy_ext_set_threshold(struct cros_chctl_priv *priv,
         enum power_supply_property psp,
         int val)
{
 int ret;

 if (val < 0 || val > 100)
  return -EINVAL;

 if (psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD) {
  /* Start threshold is not exposed, use fixed value */
  if (priv->cmd_version == 2)
   priv->current_start_threshold = val == 100 ? 0 : val;

  if (val < priv->current_start_threshold)
   return -EINVAL;
  priv->current_end_threshold = val;
 } else {
  if (val > priv->current_end_threshold)
   return -EINVAL;
  priv->current_start_threshold = val;
 }

 if (priv->current_behaviour == POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO) {
  ret = cros_chctl_configure_ec(priv);
  if (ret < 0)
   return ret;
 }

 return 0;
}


static int cros_chctl_psy_ext_set_prop(struct power_supply *psy,
           const struct power_supply_ext *ext,
           void *data,
           enum power_supply_property psp,
           const union power_supply_propval *val)
{
 struct cros_chctl_priv *priv = data;
 int ret;

 guard(mutex)(&priv->lock);

 switch (psp) {
 case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD:
 case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD:
  return cros_chctl_psy_ext_set_threshold(priv, psp, val->intval);
 case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
  priv->current_behaviour = val->intval;
  ret = cros_chctl_configure_ec(priv);
  if (ret < 0)
   return ret;
  return 0;
 default:
  return -EINVAL;
 }
}

static int cros_chctl_psy_prop_is_writeable(struct power_supply *psy,
         const struct power_supply_ext *ext,
         void *data,
         enum power_supply_property psp)
{
 return true;
}

#define DEFINE_CROS_CHCTL_POWER_SUPPLY_EXTENSION(_name, ...)   \
 static const enum power_supply_property _name ## _props[] = {  \
  __VA_ARGS__,       \
 };         \
          \
 static const struct power_supply_ext _name = {    \
  .name   = "cros-charge-control",  \
  .properties  = _name ## _props,   \
  .num_properties  = ARRAY_SIZE(_name ## _props),  \
  .charge_behaviours = EC_CHARGE_CONTROL_BEHAVIOURS,  \
  .get_property  = cros_chctl_psy_ext_get_prop,  \
  .set_property  = cros_chctl_psy_ext_set_prop,  \
  .property_is_writeable = cros_chctl_psy_prop_is_writeable, \
 }

DEFINE_CROS_CHCTL_POWER_SUPPLY_EXTENSION(cros_chctl_psy_ext_v1,
 POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR
);

DEFINE_CROS_CHCTL_POWER_SUPPLY_EXTENSION(cros_chctl_psy_ext_v2,
 POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR,
 POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD
);

DEFINE_CROS_CHCTL_POWER_SUPPLY_EXTENSION(cros_chctl_psy_ext_v3,
 POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR,
 POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD,
 POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD
);

static int cros_chctl_add_battery(struct power_supply *battery, struct acpi_battery_hook *hook)
{
 struct cros_chctl_priv *priv = container_of(hook, struct cros_chctl_priv, battery_hook);

 if (priv->hooked_battery)
  return 0;

 priv->hooked_battery = battery;
 return power_supply_register_extension(battery, priv->psy_ext, priv->dev, priv);
}

static int cros_chctl_remove_battery(struct power_supply *battery, struct acpi_battery_hook *hook)
{
 struct cros_chctl_priv *priv = container_of(hook, struct cros_chctl_priv, battery_hook);

 if (priv->hooked_battery == battery) {
  power_supply_unregister_extension(battery, priv->psy_ext);
  priv->hooked_battery = NULL;
 }

 return 0;
}

static bool probe_with_fwk_charge_control;
module_param(probe_with_fwk_charge_control, bool, 0644);
MODULE_PARM_DESC(probe_with_fwk_charge_control,
   "Probe the driver in the presence of the custom Framework EC charge control");

static int cros_chctl_fwk_charge_control_versions(struct cros_ec_device *cros_ec)
{
 if (!dmi_match(DMI_SYS_VENDOR, "Framework"))
  return 0;

 return cros_ec_get_cmd_versions(cros_ec, 0x3E03 /* FW_EC_CMD_CHARGE_LIMIT */);
}

static int cros_chctl_probe(struct platform_device *pdev)
{
 struct device *dev = &pdev->dev;
 struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent);
 struct cros_ec_device *cros_ec = ec_dev->ec_dev;
 struct cros_chctl_priv *priv;
 int ret;

 ret = cros_chctl_fwk_charge_control_versions(cros_ec);
 if (ret < 0)
  return ret;
 if (ret > 0 && !probe_with_fwk_charge_control) {
  dev_info(dev, "Framework charge control detected, preventing load\n");
  return -ENODEV;
 }

 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 if (!priv)
  return -ENOMEM;

 ret = devm_mutex_init(dev, &priv->lock);
 if (ret)
  return ret;

 ret = cros_ec_get_cmd_versions(cros_ec, EC_CMD_CHARGE_CONTROL);
 if (ret < 0)
  return ret;
 else if (ret & EC_VER_MASK(3))
  priv->cmd_version = 3;
 else if (ret & EC_VER_MASK(2))
  priv->cmd_version = 2;
 else if (ret & EC_VER_MASK(1))
  priv->cmd_version = 1;
 else
  return -ENODEV;

 dev_dbg(dev, "Command version: %u\n", (unsigned int)priv->cmd_version);

 priv->dev = dev;
 priv->cros_ec = cros_ec;

 if (priv->cmd_version == 1)
  priv->psy_ext = &cros_chctl_psy_ext_v1;
 else if (priv->cmd_version == 2)
  priv->psy_ext = &cros_chctl_psy_ext_v2;
 else
  priv->psy_ext = &cros_chctl_psy_ext_v3;

 priv->battery_hook.name = dev_name(dev);
 priv->battery_hook.add_battery = cros_chctl_add_battery;
 priv->battery_hook.remove_battery = cros_chctl_remove_battery;

 priv->current_behaviour = POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO;
 priv->current_start_threshold = 0;
 priv->current_end_threshold = 100;

 /* Bring EC into well-known state */
 scoped_guard(mutex, &priv->lock)
  ret = cros_chctl_configure_ec(priv);
 if (ret < 0)
  return ret;

 return devm_battery_hook_register(dev, &priv->battery_hook);
}

static const struct platform_device_id cros_chctl_id[] = {
 { "cros-charge-control", 0 },
 {}
};

static struct platform_driver cros_chctl_driver = {
 .driver.name = "cros-charge-control",
 .probe  = cros_chctl_probe,
 .id_table = cros_chctl_id,
};
module_platform_driver(cros_chctl_driver);

MODULE_DEVICE_TABLE(platform, cros_chctl_id);
MODULE_DESCRIPTION("ChromeOS EC charge control");
MODULE_AUTHOR("Thomas Weißschuh ");
MODULE_LICENSE("GPL");