lkml.org 
[lkml]   [2018]   [Jul]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH v4 2/3] power: supply: add cros-ec USBPD charger driver.
Hi,

On Wed, May 02, 2018 at 05:44:17PM +0200, Enric Balletbo i Serra wrote:
> From: Sameer Nanda <snanda@chromium.org>
>
> This driver gets various bits of information about what is connected to
> USB PD ports from the EC and converts that into power_supply properties.
>
> Signed-off-by: Sameer Nanda <snanda@chromium.org>
> Signed-off-by: Enric Balletbo i Serra <enric.balletbo@collabora.com>
> Acked-by: Lee Jones <lee.jones@linaro.org>
> ---

Thanks, queued.

-- Sebastian

>
> Changes in v4:
> - [2/3] Drop cros_ec_device->charger as is not used.
>
> Changes in v3:
> - [2/3] Add missing POWER_SUPPLY_PROP_USB_TYPE and a list of supported USB types.
> - [2/3] Fix SPDX header -> GPL-2.0+
> - [2/3] Unregister blocking_notifier_chain on remove.
>
> Changes in v2:
> - [2/3] Add SPDX header, use devm_ variant and drop .owner
> - [2/3] Removed the PD log functionality (will be send on a follow up patch)
> - [2/3] Removed the extra custom sysfs attributes (will be send on a follow up patch)
>
> drivers/power/supply/Kconfig | 10 +
> drivers/power/supply/Makefile | 1 +
> drivers/power/supply/cros_usbpd-charger.c | 544 ++++++++++++++++++++++
> 3 files changed, 555 insertions(+)
> create mode 100644 drivers/power/supply/cros_usbpd-charger.c
>
> diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig
> index 428b426842f4..046eb23ba6f0 100644
> --- a/drivers/power/supply/Kconfig
> +++ b/drivers/power/supply/Kconfig
> @@ -624,4 +624,14 @@ config CHARGER_RT9455
> help
> Say Y to enable support for Richtek RT9455 battery charger.
>
> +config CHARGER_CROS_USBPD
> + tristate "ChromeOS EC based USBPD charger"
> + depends on MFD_CROS_EC
> + default n
> + help
> + Say Y here to enable ChromeOS EC based USBPD charger
> + driver. This driver gets various bits of information about
> + what is connected to USB PD ports from the EC and converts
> + that into power_supply properties.
> +
> endif # POWER_SUPPLY
> diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile
> index e83aa843bcc6..907e26f824b2 100644
> --- a/drivers/power/supply/Makefile
> +++ b/drivers/power/supply/Makefile
> @@ -83,3 +83,4 @@ obj-$(CONFIG_CHARGER_TPS65090) += tps65090-charger.o
> obj-$(CONFIG_CHARGER_TPS65217) += tps65217_charger.o
> obj-$(CONFIG_AXP288_FUEL_GAUGE) += axp288_fuel_gauge.o
> obj-$(CONFIG_AXP288_CHARGER) += axp288_charger.o
> +obj-$(CONFIG_CHARGER_CROS_USBPD) += cros_usbpd-charger.o
> diff --git a/drivers/power/supply/cros_usbpd-charger.c b/drivers/power/supply/cros_usbpd-charger.c
> new file mode 100644
> index 000000000000..3a0c96fd1bc1
> --- /dev/null
> +++ b/drivers/power/supply/cros_usbpd-charger.c
> @@ -0,0 +1,544 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Power supply driver for ChromeOS EC based USB PD Charger.
> + *
> + * Copyright (c) 2014 - 2018 Google, Inc
> + */
> +
> +#include <linux/module.h>
> +#include <linux/mfd/cros_ec.h>
> +#include <linux/mfd/cros_ec_commands.h>
> +#include <linux/platform_device.h>
> +#include <linux/power_supply.h>
> +#include <linux/slab.h>
> +
> +#define CHARGER_DIR_NAME "CROS_USBPD_CHARGER%d"
> +#define CHARGER_DIR_NAME_LENGTH sizeof(CHARGER_DIR_NAME)
> +#define CHARGER_CACHE_UPDATE_DELAY msecs_to_jiffies(500)
> +#define CHARGER_MANUFACTURER_MODEL_LENGTH 32
> +
> +#define DRV_NAME "cros-usbpd-charger"
> +
> +struct port_data {
> + int port_number;
> + char name[CHARGER_DIR_NAME_LENGTH];
> + char manufacturer[CHARGER_MANUFACTURER_MODEL_LENGTH];
> + char model_name[CHARGER_MANUFACTURER_MODEL_LENGTH];
> + struct power_supply *psy;
> + struct power_supply_desc psy_desc;
> + int psy_usb_type;
> + int psy_online;
> + int psy_status;
> + int psy_current_max;
> + int psy_voltage_max_design;
> + int psy_voltage_now;
> + int psy_power_max;
> + struct charger_data *charger;
> + unsigned long last_update;
> +};
> +
> +struct charger_data {
> + struct device *dev;
> + struct cros_ec_dev *ec_dev;
> + struct cros_ec_device *ec_device;
> + int num_charger_ports;
> + int num_registered_psy;
> + struct port_data *ports[EC_USB_PD_MAX_PORTS];
> + struct notifier_block notifier;
> +};
> +
> +static enum power_supply_property cros_usbpd_charger_props[] = {
> + POWER_SUPPLY_PROP_ONLINE,
> + POWER_SUPPLY_PROP_STATUS,
> + POWER_SUPPLY_PROP_CURRENT_MAX,
> + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
> + POWER_SUPPLY_PROP_VOLTAGE_NOW,
> + POWER_SUPPLY_PROP_MODEL_NAME,
> + POWER_SUPPLY_PROP_MANUFACTURER,
> + POWER_SUPPLY_PROP_USB_TYPE
> +};
> +
> +static enum power_supply_usb_type cros_usbpd_charger_usb_types[] = {
> + POWER_SUPPLY_USB_TYPE_UNKNOWN,
> + POWER_SUPPLY_USB_TYPE_SDP,
> + POWER_SUPPLY_USB_TYPE_DCP,
> + POWER_SUPPLY_USB_TYPE_CDP,
> + POWER_SUPPLY_USB_TYPE_C,
> + POWER_SUPPLY_USB_TYPE_PD,
> + POWER_SUPPLY_USB_TYPE_PD_DRP,
> + POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID
> +};
> +
> +static int cros_usbpd_charger_ec_command(struct charger_data *charger,
> + unsigned int version,
> + unsigned int command,
> + void *outdata,
> + unsigned int outsize,
> + void *indata,
> + unsigned int insize)
> +{
> + struct cros_ec_dev *ec_dev = charger->ec_dev;
> + struct cros_ec_command *msg;
> + int ret;
> +
> + msg = kzalloc(sizeof(*msg) + max(outsize, insize), GFP_KERNEL);
> + if (!msg)
> + return -ENOMEM;
> +
> + msg->version = version;
> + msg->command = ec_dev->cmd_offset + command;
> + msg->outsize = outsize;
> + msg->insize = insize;
> +
> + if (outsize)
> + memcpy(msg->data, outdata, outsize);
> +
> + ret = cros_ec_cmd_xfer_status(charger->ec_device, msg);
> + if (ret >= 0 && insize)
> + memcpy(indata, msg->data, insize);
> +
> + kfree(msg);
> + return ret;
> +}
> +
> +static int cros_usbpd_charger_get_num_ports(struct charger_data *charger)
> +{
> + struct ec_response_usb_pd_ports resp;
> + int ret;
> +
> + ret = cros_usbpd_charger_ec_command(charger, 0, EC_CMD_USB_PD_PORTS,
> + NULL, 0, &resp, sizeof(resp));
> + if (ret < 0) {
> + dev_err(charger->dev,
> + "Unable to get the number or ports (err:0x%x)\n", ret);
> + return ret;
> + }
> +
> + return resp.num_ports;
> +}
> +
> +static int cros_usbpd_charger_get_discovery_info(struct port_data *port)
> +{
> + struct charger_data *charger = port->charger;
> + struct ec_params_usb_pd_discovery_entry resp;
> + struct ec_params_usb_pd_info_request req;
> + int ret;
> +
> + req.port = port->port_number;
> +
> + ret = cros_usbpd_charger_ec_command(charger, 0,
> + EC_CMD_USB_PD_DISCOVERY,
> + &req, sizeof(req),
> + &resp, sizeof(resp));
> + if (ret < 0) {
> + dev_err(charger->dev,
> + "Unable to query discovery info (err:0x%x)\n", ret);
> + return ret;
> + }
> +
> + dev_dbg(charger->dev, "Port %d: VID = 0x%x, PID=0x%x, PTYPE=0x%x\n",
> + port->port_number, resp.vid, resp.pid, resp.ptype);
> +
> + snprintf(port->manufacturer, sizeof(port->manufacturer), "%x",
> + resp.vid);
> + snprintf(port->model_name, sizeof(port->model_name), "%x", resp.pid);
> +
> + return 0;
> +}
> +
> +static int cros_usbpd_charger_get_power_info(struct port_data *port)
> +{
> + struct charger_data *charger = port->charger;
> + struct ec_response_usb_pd_power_info resp;
> + struct ec_params_usb_pd_power_info req;
> + int last_psy_status, last_psy_usb_type;
> + struct device *dev = charger->dev;
> + int ret;
> +
> + req.port = port->port_number;
> + ret = cros_usbpd_charger_ec_command(charger, 0,
> + EC_CMD_USB_PD_POWER_INFO,
> + &req, sizeof(req),
> + &resp, sizeof(resp));
> + if (ret < 0) {
> + dev_err(dev, "Unable to query PD power info (err:0x%x)\n", ret);
> + return ret;
> + }
> +
> + last_psy_status = port->psy_status;
> + last_psy_usb_type = port->psy_usb_type;
> +
> + switch (resp.role) {
> + case USB_PD_PORT_POWER_DISCONNECTED:
> + port->psy_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
> + port->psy_online = 0;
> + break;
> + case USB_PD_PORT_POWER_SOURCE:
> + port->psy_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
> + port->psy_online = 0;
> + break;
> + case USB_PD_PORT_POWER_SINK:
> + port->psy_status = POWER_SUPPLY_STATUS_CHARGING;
> + port->psy_online = 1;
> + break;
> + case USB_PD_PORT_POWER_SINK_NOT_CHARGING:
> + port->psy_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
> + port->psy_online = 1;
> + break;
> + default:
> + dev_err(dev, "Unknown role %d\n", resp.role);
> + break;
> + }
> +
> + port->psy_voltage_max_design = resp.meas.voltage_max;
> + port->psy_voltage_now = resp.meas.voltage_now;
> + port->psy_current_max = resp.meas.current_max;
> + port->psy_power_max = resp.max_power;
> +
> + switch (resp.type) {
> + case USB_CHG_TYPE_BC12_SDP:
> + case USB_CHG_TYPE_VBUS:
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP;
> + break;
> + case USB_CHG_TYPE_NONE:
> + /*
> + * For dual-role devices when we are a source, the firmware
> + * reports the type as NONE. Report such chargers as type
> + * USB_PD_DRP.
> + */
> + if (resp.role == USB_PD_PORT_POWER_SOURCE && resp.dualrole)
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_PD_DRP;
> + else
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP;
> + break;
> + case USB_CHG_TYPE_OTHER:
> + case USB_CHG_TYPE_PROPRIETARY:
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID;
> + break;
> + case USB_CHG_TYPE_C:
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_C;
> + break;
> + case USB_CHG_TYPE_BC12_DCP:
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_DCP;
> + break;
> + case USB_CHG_TYPE_BC12_CDP:
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_CDP;
> + break;
> + case USB_CHG_TYPE_PD:
> + if (resp.dualrole)
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_PD_DRP;
> + else
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_PD;
> + break;
> + case USB_CHG_TYPE_UNKNOWN:
> + /*
> + * While the EC is trying to determine the type of charger that
> + * has been plugged in, it will report the charger type as
> + * unknown. Additionally since the power capabilities are
> + * unknown, report the max current and voltage as zero.
> + */
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
> + port->psy_voltage_max_design = 0;
> + port->psy_current_max = 0;
> + break;
> + default:
> + dev_err(dev, "Port %d: default case!\n", port->port_number);
> + port->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP;
> + }
> +
> + port->psy_desc.type = POWER_SUPPLY_TYPE_USB;
> +
> + dev_dbg(dev,
> + "Port %d: type=%d vmax=%d vnow=%d cmax=%d clim=%d pmax=%d\n",
> + port->port_number, resp.type, resp.meas.voltage_max,
> + resp.meas.voltage_now, resp.meas.current_max,
> + resp.meas.current_lim, resp.max_power);
> +
> + /*
> + * If power supply type or status changed, explicitly call
> + * power_supply_changed. This results in udev event getting generated
> + * and allows user mode apps to react quicker instead of waiting for
> + * their next poll of power supply status.
> + */
> + if (last_psy_usb_type != port->psy_usb_type ||
> + last_psy_status != port->psy_status)
> + power_supply_changed(port->psy);
> +
> + return 0;
> +}
> +
> +static int cros_usbpd_charger_get_port_status(struct port_data *port,
> + bool ratelimit)
> +{
> + int ret;
> +
> + if (ratelimit &&
> + time_is_after_jiffies(port->last_update +
> + CHARGER_CACHE_UPDATE_DELAY))
> + return 0;
> +
> + ret = cros_usbpd_charger_get_power_info(port);
> + if (ret < 0)
> + return ret;
> +
> + ret = cros_usbpd_charger_get_discovery_info(port);
> + port->last_update = jiffies;
> +
> + return ret;
> +}
> +
> +static void cros_usbpd_charger_power_changed(struct power_supply *psy)
> +{
> + struct port_data *port = power_supply_get_drvdata(psy);
> + struct charger_data *charger = port->charger;
> + int i;
> +
> + for (i = 0; i < charger->num_registered_psy; i++)
> + cros_usbpd_charger_get_port_status(charger->ports[i], false);
> +}
> +
> +static int cros_usbpd_charger_get_prop(struct power_supply *psy,
> + enum power_supply_property psp,
> + union power_supply_propval *val)
> +{
> + struct port_data *port = power_supply_get_drvdata(psy);
> + struct charger_data *charger = port->charger;
> + struct cros_ec_device *ec_device = charger->ec_device;
> + struct device *dev = charger->dev;
> + int ret;
> +
> + /* Only refresh ec_port_status for dynamic properties */
> + switch (psp) {
> + case POWER_SUPPLY_PROP_ONLINE:
> + /*
> + * If mkbp_event_supported, then we can be assured that
> + * the driver's state for the online property is consistent
> + * with the hardware. However, if we aren't event driven,
> + * the optimization before to skip an ec_port_status get
> + * and only returned cached values of the online property will
> + * cause a delay in detecting a cable attach until one of the
> + * other properties are read.
> + *
> + * Allow an ec_port_status refresh for online property check
> + * if we're not already online to check for plug events if
> + * not mkbp_event_supported.
> + */
> + if (ec_device->mkbp_event_supported || port->psy_online)
> + break;
> + case POWER_SUPPLY_PROP_CURRENT_MAX:
> + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
> + case POWER_SUPPLY_PROP_VOLTAGE_NOW:
> + ret = cros_usbpd_charger_get_port_status(port, true);
> + if (ret < 0) {
> + dev_err(dev, "Failed to get port status (err:0x%x)\n",
> + ret);
> + return -EINVAL;
> + }
> + break;
> + default:
> + break;
> + }
> +
> + switch (psp) {
> + case POWER_SUPPLY_PROP_ONLINE:
> + val->intval = port->psy_online;
> + break;
> + case POWER_SUPPLY_PROP_STATUS:
> + val->intval = port->psy_status;
> + break;
> + case POWER_SUPPLY_PROP_CURRENT_MAX:
> + val->intval = port->psy_current_max * 1000;
> + break;
> + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
> + val->intval = port->psy_voltage_max_design * 1000;
> + break;
> + case POWER_SUPPLY_PROP_VOLTAGE_NOW:
> + val->intval = port->psy_voltage_now * 1000;
> + break;
> + case POWER_SUPPLY_PROP_USB_TYPE:
> + val->intval = port->psy_usb_type;
> + break;
> + case POWER_SUPPLY_PROP_MODEL_NAME:
> + val->strval = port->model_name;
> + break;
> + case POWER_SUPPLY_PROP_MANUFACTURER:
> + val->strval = port->manufacturer;
> + break;
> + default:
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int cros_usbpd_charger_ec_event(struct notifier_block *nb,
> + unsigned long queued_during_suspend,
> + void *_notify)
> +{
> + struct cros_ec_device *ec_device;
> + struct charger_data *charger;
> + struct device *dev;
> + u32 host_event;
> +
> + charger = container_of(nb, struct charger_data, notifier);
> + ec_device = charger->ec_device;
> + dev = charger->dev;
> +
> + host_event = cros_ec_get_host_event(ec_device);
> + if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU)) {
> + cros_usbpd_charger_power_changed(charger->ports[0]->psy);
> + return NOTIFY_OK;
> + } else {
> + return NOTIFY_DONE;
> + }
> +}
> +
> +static void cros_usbpd_charger_unregister_notifier(void *data)
> +{
> + struct charger_data *charger = data;
> + struct cros_ec_device *ec_device = charger->ec_device;
> +
> + blocking_notifier_chain_unregister(&ec_device->event_notifier,
> + &charger->notifier);
> +}
> +
> +static int cros_usbpd_charger_probe(struct platform_device *pd)
> +{
> + struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent);
> + struct cros_ec_device *ec_device = ec_dev->ec_dev;
> + struct power_supply_desc *psy_desc;
> + struct device *dev = &pd->dev;
> + struct charger_data *charger;
> + struct power_supply *psy;
> + struct port_data *port;
> + int ret = -EINVAL;
> + int i;
> +
> + charger = devm_kzalloc(dev, sizeof(struct charger_data),
> + GFP_KERNEL);
> + if (!charger)
> + return -ENOMEM;
> +
> + charger->dev = dev;
> + charger->ec_dev = ec_dev;
> + charger->ec_device = ec_device;
> +
> + platform_set_drvdata(pd, charger);
> +
> + charger->num_charger_ports = cros_usbpd_charger_get_num_ports(charger);
> + if (charger->num_charger_ports <= 0) {
> + /*
> + * This can happen on a system that doesn't support USB PD.
> + * Log a message, but no need to warn.
> + */
> + dev_info(dev, "No charging ports found\n");
> + ret = -ENODEV;
> + goto fail_nowarn;
> + }
> +
> + for (i = 0; i < charger->num_charger_ports; i++) {
> + struct power_supply_config psy_cfg = {};
> +
> + port = devm_kzalloc(dev, sizeof(struct port_data), GFP_KERNEL);
> + if (!port) {
> + ret = -ENOMEM;
> + goto fail;
> + }
> +
> + port->charger = charger;
> + port->port_number = i;
> + sprintf(port->name, CHARGER_DIR_NAME, i);
> +
> + psy_desc = &port->psy_desc;
> + psy_desc->name = port->name;
> + psy_desc->type = POWER_SUPPLY_TYPE_USB;
> + psy_desc->get_property = cros_usbpd_charger_get_prop;
> + psy_desc->external_power_changed =
> + cros_usbpd_charger_power_changed;
> + psy_desc->properties = cros_usbpd_charger_props;
> + psy_desc->num_properties =
> + ARRAY_SIZE(cros_usbpd_charger_props);
> + psy_desc->usb_types = cros_usbpd_charger_usb_types;
> + psy_desc->num_usb_types =
> + ARRAY_SIZE(cros_usbpd_charger_usb_types);
> + psy_cfg.drv_data = port;
> +
> + psy = devm_power_supply_register_no_ws(dev, psy_desc,
> + &psy_cfg);
> + if (IS_ERR(psy)) {
> + dev_err(dev, "Failed to register power supply\n");
> + continue;
> + }
> + port->psy = psy;
> +
> + charger->ports[charger->num_registered_psy++] = port;
> + }
> +
> + if (!charger->num_registered_psy) {
> + ret = -ENODEV;
> + dev_err(dev, "No power supplies registered\n");
> + goto fail;
> + }
> +
> + if (ec_device->mkbp_event_supported) {
> + /* Get PD events from the EC */
> + charger->notifier.notifier_call = cros_usbpd_charger_ec_event;
> + ret = blocking_notifier_chain_register(
> + &ec_device->event_notifier,
> + &charger->notifier);
> + if (ret < 0) {
> + dev_warn(dev, "failed to register notifier\n");
> + } else {
> + ret = devm_add_action_or_reset(dev,
> + cros_usbpd_charger_unregister_notifier,
> + charger);
> + if (ret < 0)
> + goto fail;
> + }
> + }
> +
> + return 0;
> +
> +fail:
> + WARN(1, "%s: Failing probe (err:0x%x)\n", dev_name(dev), ret);
> +
> +fail_nowarn:
> + dev_info(dev, "Failing probe (err:0x%x)\n", ret);
> + return ret;
> +}
> +
> +#ifdef CONFIG_PM_SLEEP
> +static int cros_usbpd_charger_resume(struct device *dev)
> +{
> + struct charger_data *charger = dev_get_drvdata(dev);
> + int i;
> +
> + if (!charger)
> + return 0;
> +
> + for (i = 0; i < charger->num_registered_psy; i++) {
> + power_supply_changed(charger->ports[i]->psy);
> + charger->ports[i]->last_update =
> + jiffies - CHARGER_CACHE_UPDATE_DELAY;
> + }
> +
> + return 0;
> +}
> +#endif
> +
> +static SIMPLE_DEV_PM_OPS(cros_usbpd_charger_pm_ops, NULL,
> + cros_usbpd_charger_resume);
> +
> +static struct platform_driver cros_usbpd_charger_driver = {
> + .driver = {
> + .name = DRV_NAME,
> + .pm = &cros_usbpd_charger_pm_ops,
> + },
> + .probe = cros_usbpd_charger_probe
> +};
> +
> +module_platform_driver(cros_usbpd_charger_driver);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("ChromeOS EC USBPD charger");
> +MODULE_ALIAS("platform:" DRV_NAME);
> --
> 2.17.0
>
>
> --
> To unsubscribe, send mail to kernel-unsubscribe@lists.collabora.co.uk.
[unhandled content-type:application/pgp-signature]
\
 
 \ /
  Last update: 2018-07-05 17:12    [W:0.144 / U:0.384 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site