// SPDX-License-Identifier: GPL-2.0
/*
* USB Power Delivery sysfs entries
*
* Copyright (C) 2022, Intel Corporation
* Author: Heikki Krogerus <[email protected]>
*/
#include <linux/slab.h>
#include <linux/usb/pd.h>
#include "pd.h"
static DEFINE_IDA(pd_ida);
static struct class pd_class = {
.name = "usb_power_delivery",
};
#define to_pdo(o) container_of(o, struct pdo, dev)
struct pdo {
struct device dev;
int object_position;
u32 pdo;
};
static void pdo_release(struct device *dev)
{
kfree(to_pdo(dev));
}
/* -------------------------------------------------------------------------- */
/* Fixed Supply */
static ssize_t
dual_role_power_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_DUAL_ROLE));
}
static DEVICE_ATTR_RO(dual_role_power);
static ssize_t
usb_suspend_supported_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_SUSPEND));
}
static DEVICE_ATTR_RO(usb_suspend_supported);
static ssize_t
higher_capability_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_HIGHER_CAP));
}
static DEVICE_ATTR_RO(higher_capability);
static ssize_t
unconstrained_power_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_EXTPOWER));
}
static DEVICE_ATTR_RO(unconstrained_power);
static ssize_t
usb_communication_capable_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_USB_COMM));
}
static DEVICE_ATTR_RO(usb_communication_capable);
static ssize_t
dual_role_data_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_DATA_SWAP));
}
static DEVICE_ATTR_RO(dual_role_data);
static ssize_t
unchunked_extended_messages_supported_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_UNCHUNK_EXT));
}
static DEVICE_ATTR_RO(unchunked_extended_messages_supported);
static ssize_t
peak_current_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", (to_pdo(dev)->pdo >> PDO_FIXED_PEAK_CURR_SHIFT) & 3);
}
static DEVICE_ATTR_RO(peak_current);
static ssize_t
fast_role_swap_current_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", (to_pdo(dev)->pdo >> PDO_FIXED_FRS_CURR_SHIFT) & 3);
}
static DEVICE_ATTR_RO(fast_role_swap_current);
static ssize_t voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umV\n", pdo_fixed_voltage(to_pdo(dev)->pdo));
}
static DEVICE_ATTR_RO(voltage);
/* Shared with Variable supplies, both source and sink */
static ssize_t current_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umA\n", pdo_max_current(to_pdo(dev)->pdo));
}
/* Shared with Variable type supplies */
static struct device_attribute maximum_current_attr = {
.attr = {
.name = "maximum_current",
.mode = 0444,
},
.show = current_show,
};
static struct device_attribute operational_current_attr = {
.attr = {
.name = "operational_current",
.mode = 0444,
},
.show = current_show,
};
static struct attribute *source_fixed_supply_attrs[] = {
&dev_attr_dual_role_power.attr,
&dev_attr_usb_suspend_supported.attr,
&dev_attr_unconstrained_power.attr,
&dev_attr_usb_communication_capable.attr,
&dev_attr_dual_role_data.attr,
&dev_attr_unchunked_extended_messages_supported.attr,
&dev_attr_peak_current.attr,
&dev_attr_voltage.attr,
&maximum_current_attr.attr,
NULL
};
static umode_t fixed_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n)
{
if (to_pdo(kobj_to_dev(kobj))->object_position &&
attr != &dev_attr_peak_current.attr &&
attr != &dev_attr_voltage.attr &&
attr != &maximum_current_attr.attr &&
attr != &operational_current_attr.attr)
return 0;
return attr->mode;
}
static const struct attribute_group source_fixed_supply_group = {
.is_visible = fixed_attr_is_visible,
.attrs = source_fixed_supply_attrs,
};
__ATTRIBUTE_GROUPS(source_fixed_supply);
static const struct device_type source_fixed_supply_type = {
.name = "pdo",
.release = pdo_release,
.groups = source_fixed_supply_groups,
};
static struct attribute *sink_fixed_supply_attrs[] = {
&dev_attr_dual_role_power.attr,
&dev_attr_higher_capability.attr,
&dev_attr_unconstrained_power.attr,
&dev_attr_usb_communication_capable.attr,
&dev_attr_dual_role_data.attr,
&dev_attr_unchunked_extended_messages_supported.attr,
&dev_attr_fast_role_swap_current.attr,
&dev_attr_voltage.attr,
&operational_current_attr.attr,
NULL
};
static const struct attribute_group sink_fixed_supply_group = {
.is_visible = fixed_attr_is_visible,
.attrs = sink_fixed_supply_attrs,
};
__ATTRIBUTE_GROUPS(sink_fixed_supply);
static const struct device_type sink_fixed_supply_type = {
.name = "pdo",
.release = pdo_release,
.groups = sink_fixed_supply_groups,
};
/* -------------------------------------------------------------------------- */
/* Variable Supply */
static ssize_t
maximum_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umV\n", pdo_max_voltage(to_pdo(dev)->pdo));
}
static DEVICE_ATTR_RO(maximum_voltage);
static ssize_t
minimum_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umV\n", pdo_min_voltage(to_pdo(dev)->pdo));
}
static DEVICE_ATTR_RO(minimum_voltage);
static struct attribute *source_variable_supply_attrs[] = {
&dev_attr_maximum_voltage.attr,
&dev_attr_minimum_voltage.attr,
&maximum_current_attr.attr,
NULL
};
ATTRIBUTE_GROUPS(source_variable_supply);
static const struct device_type source_variable_supply_type = {
.name = "pdo",
.release = pdo_release,
.groups = source_variable_supply_groups,
};
static struct attribute *sink_variable_supply_attrs[] = {
&dev_attr_maximum_voltage.attr,
&dev_attr_minimum_voltage.attr,
&operational_current_attr.attr,
NULL
};
ATTRIBUTE_GROUPS(sink_variable_supply);
static const struct device_type sink_variable_supply_type = {
.name = "pdo",
.release = pdo_release,
.groups = sink_variable_supply_groups,
};
/* -------------------------------------------------------------------------- */
/* Battery */
static ssize_t
maximum_power_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umW\n", pdo_max_power(to_pdo(dev)->pdo));
}
static DEVICE_ATTR_RO(maximum_power);
static ssize_t
operational_power_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umW\n", pdo_max_power(to_pdo(dev)->pdo));
}
static DEVICE_ATTR_RO(operational_power);
static struct attribute *source_battery_attrs[] = {
&dev_attr_maximum_voltage.attr,
&dev_attr_minimum_voltage.attr,
&dev_attr_maximum_power.attr,
NULL
};
ATTRIBUTE_GROUPS(source_battery);
static const struct device_type source_battery_type = {
.name = "pdo",
.release = pdo_release,
.groups = source_battery_groups,
};
static struct attribute *sink_battery_attrs[] = {
&dev_attr_maximum_voltage.attr,
&dev_attr_minimum_voltage.attr,
&dev_attr_operational_power.attr,
NULL
};
ATTRIBUTE_GROUPS(sink_battery);
static const struct device_type sink_battery_type = {
.name = "pdo",
.release = pdo_release,
.groups = sink_battery_groups,
};
/* -------------------------------------------------------------------------- */
/* Standard Power Range (SPR) Programmable Power Supply (PPS) */
static ssize_t
pps_power_limited_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & BIT(27)));
}
static DEVICE_ATTR_RO(pps_power_limited);
static ssize_t
pps_max_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umV\n", pdo_pps_apdo_max_voltage(to_pdo(dev)->pdo));
}
static ssize_t
pps_min_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umV\n", pdo_pps_apdo_min_voltage(to_pdo(dev)->pdo));
}
static ssize_t
pps_max_current_show(struct device *dev, struct device_attribute *attr, char *buf)
{
return sysfs_emit(buf, "%umA\n", pdo_pps_apdo_max_current(to_pdo(dev)->pdo));
}
static struct device_attribute pps_max_voltage_attr = {
.attr = {
.name = "maximum_voltage",
.mode = 0444,
},
.show = pps_max_voltage_show,
};
static struct device_attribute pps_min_voltage_attr = {
.attr = {
.name = "minimum_voltage",
.mode = 0444,
},
.show = pps_min_voltage_show,
};
static struct device_attribute pps_max_current_attr = {
.attr = {
.name = "maximum_current",
.mode = 0444,
},
.show = pps_max_current_show,
};
static struct attribute *source_pps_attrs[] = {
&dev_attr_pps_power_limited.attr,
&pps_max_voltage_attr.attr,
&pps_min_voltage_attr.attr,
&pps_max_current_attr.attr,
NULL
};
ATTRIBUTE_GROUPS(source_pps);
static const struct device_type source_pps_type = {
.name = "pdo",
.release = pdo_release,
.groups = source_pps_groups,
};
static struct attribute *sink_pps_attrs[] = {
&pps_max_voltage_attr.attr,
&pps_min_voltage_attr.attr,
&pps_max_current_attr.attr,
NULL
};
ATTRIBUTE_GROUPS(sink_pps);
static const struct device_type sink_pps_type = {
.name = "pdo",
.release = pdo_release,
.groups = sink_pps_groups,
};
/* -------------------------------------------------------------------------- */
static const char * const supply_name[] = {
[PDO_TYPE_FIXED] = "fixed_supply",
[PDO_TYPE_BATT] = "battery",
[PDO_TYPE_VAR] = "variable_supply",
};
static const char * const apdo_supply_name[] = {
[APDO_TYPE_PPS] = "programmable_supply",
};
static const struct device_type *source_type[] = {
[PDO_TYPE_FIXED] = &source_fixed_supply_type,
[PDO_TYPE_BATT] = &source_battery_type,
[PDO_TYPE_VAR] = &source_variable_supply_type,
};
static const struct device_type *source_apdo_type[] = {
[APDO_TYPE_PPS] = &source_pps_type,
};
static const struct device_type *sink_type[] = {
[PDO_TYPE_FIXED] = &sink_fixed_supply_type,
[PDO_TYPE_BATT] = &sink_battery_type,
[PDO_TYPE_VAR] = &sink_variable_supply_type,
};
static const struct device_type *sink_apdo_type[] = {
[APDO_TYPE_PPS] = &sink_pps_type,
};
/* REVISIT: Export when EPR_*_Capabilities need to be supported. */
static int add_pdo(struct usb_power_delivery_capabilities *cap, u32 pdo, int position)
{
const struct device_type *type;
const char *name;
struct pdo *p;
int ret;
p = kzalloc(sizeof(*p), GFP_KERNEL);
if (!p)
return -ENOMEM;
p->pdo = pdo;
p->object_position = position;
if (pdo_type(pdo) == PDO_TYPE_APDO) {
/* FIXME: Only PPS supported for now! Skipping others. */
if (pdo_apdo_type(pdo) > APDO_TYPE_PPS) {
dev_warn(&cap->dev, "Unknown APDO type. PDO 0x%08x\n", pdo);
kfree(p);
return 0;
}
if (is_source(cap->role))
type = source_apdo_type[pdo_apdo_type(pdo)];
else
type = sink_apdo_type[pdo_apdo_type(pdo)];
name = apdo_supply_name[pdo_apdo_type(pdo)];
} else {
if (is_source(cap->role))
type = source_type[pdo_type(pdo)];
else
type = sink_type[pdo_type(pdo)];
name = supply_name[pdo_type(pdo)];
}
p->dev.parent = &cap->dev;
p->dev.type = type;
dev_set_name(&p->dev, "%u:%s", position + 1, name);
ret = device_register(&p->dev);
if (ret) {
put_device(&p->dev);
return ret;
}
return 0;
}
static int remove_pdo(struct device *dev, void *data)
{
device_unregister(dev);
return 0;
}
/* -------------------------------------------------------------------------- */
static const char * const cap_name[] = {
[TYPEC_SINK] = "sink-capabilities",
[TYPEC_SOURCE] = "source-capabilities",
};
static void pd_capabilities_release(struct device *dev)
{
kfree(to_usb_power_delivery_capabilities(dev));
}
static const struct device_type pd_capabilities_type = {
.name = "capabilities",
.release = pd_capabilities_release,
};
/**
* usb_power_delivery_register_capabilities - Register a set of capabilities.
* @pd: The USB PD instance that the capabilities belong to.
* @desc: Description of the Capabilities Message.
*
* This function registers a Capabilities Message described in @desc. The
* capabilities will have their own sub-directory under @pd in sysfs.
*
* The function returns pointer to struct usb_power_delivery_capabilities, or
* ERR_PRT(errno).
*/
struct usb_power_delivery_capabilities *
usb_power_delivery_register_capabilities(struct usb_power_delivery *pd,
struct usb_power_delivery_capabilities_desc *desc)
{
struct usb_power_delivery_capabilities *cap;
int ret;
int i;
cap = kzalloc(sizeof(*cap), GFP_KERNEL);
if (!cap)
return ERR_PTR(-ENOMEM);
cap->pd = pd;
cap->role = desc->role;
cap->dev.parent = &pd->dev;
cap->dev.type = &pd_capabilities_type;
dev_set_name(&cap->dev, "%s", cap_name[cap->role]);
ret = device_register(&cap->dev);
if (ret) {
put_device(&cap->dev);
return ERR_PTR(ret);
}
for (i = 0; i < PDO_MAX_OBJECTS && desc->pdo[i]; i++) {
ret = add_pdo(cap, desc->pdo[i], i);
if (ret) {
usb_power_delivery_unregister_capabilities(cap);
return ERR_PTR(ret);
}
}
return cap;
}
EXPORT_SYMBOL_GPL(usb_power_delivery_register_capabilities);
/**
* usb_power_delivery_unregister_capabilities - Unregister a set of capabilities
* @cap: The capabilities
*/
void usb_power_delivery_unregister_capabilities(struct usb_power_delivery_capabilities *cap)
{
if (!cap)
return;
device_for_each_child(&cap->dev, NULL, remove_pdo);
device_unregister(&cap->dev);
}
EXPORT_SYMBOL_GPL(usb_power_delivery_unregister_capabilities);
/* -------------------------------------------------------------------------- */
static ssize_t revision_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct usb_power_delivery *pd = to_usb_power_delivery(dev);
return sysfs_emit(buf, "%u.%u\n", (pd->revision >> 8) & 0xff, (pd->revision >> 4) & 0xf);
}
static DEVICE_ATTR_RO(revision);
static ssize_t version_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct usb_power_delivery *pd = to_usb_power_delivery(dev);
return sysfs_emit(buf, "%u.%u\n", (pd->version >> 8) & 0xff, (pd->version >> 4) & 0xf);
}
static DEVICE_ATTR_RO(version);
static struct attribute *pd_attrs[] = {
&dev_attr_revision.attr,
&dev_attr_version.attr,
NULL
};
static umode_t pd_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n)
{
struct usb_power_delivery *pd = to_usb_power_delivery(kobj_to_dev(kobj));
if (attr == &dev_attr_version.attr && !pd->version)
return 0;
return attr->mode;
}
static const struct attribute_group pd_group = {
.is_visible = pd_attr_is_visible,
.attrs = pd_attrs,
};
__ATTRIBUTE_GROUPS(pd);
static void pd_release(struct device *dev)
{
struct usb_power_delivery *pd = to_usb_power_delivery(dev);
ida_free(&pd_ida, pd->id);
kfree(pd);
}
static const struct device_type pd_type = {
.name = "usb_power_delivery",
.release = pd_release,
.groups = pd_groups,
};
struct usb_power_delivery *usb_power_delivery_find(const char *name)
{
struct device *dev;
dev = class_find_device_by_name(&pd_class, name);
return dev ? to_usb_power_delivery(dev) : NULL;
}
/**
* usb_power_delivery_register - Register USB Power Delivery Support.
* @parent: Parent device.
* @desc: Description of the USB PD contract.
*
* This routine can be used to register USB Power Delivery capabilities that a
* device or devices can support. These capabilities represent all the
* capabilities that can be negotiated with a partner, so not only the Power
* Capabilities that are negotiated using the USB PD Capabilities Message.
*
* The USB Power Delivery Support object that this routine generates can be used
* as the parent object for all the actual USB Power Delivery Messages and
* objects that can be negotiated with the partner.
*
* Returns handle to struct usb_power_delivery or ERR_PTR.
*/
struct usb_power_delivery *
usb_power_delivery_register(struct device *parent, struct usb_power_delivery_desc *desc)
{
struct usb_power_delivery *pd;
int ret;
pd = kzalloc(sizeof(*pd), GFP_KERNEL);
if (!pd)
return ERR_PTR(-ENOMEM);
ret = ida_alloc(&pd_ida, GFP_KERNEL);
if (ret < 0) {
kfree(pd);
return ERR_PTR(ret);
}
pd->id = ret;
pd->revision = desc->revision;
pd->version = desc->version;
pd->dev.parent = parent;
pd->dev.type = &pd_type;
pd->dev.class = &pd_class;
dev_set_name(&pd->dev, "pd%d", pd->id);
ret = device_register(&pd->dev);
if (ret) {
put_device(&pd->dev);
return ERR_PTR(ret);
}
return pd;
}
EXPORT_SYMBOL_GPL(usb_power_delivery_register);
/**
* usb_power_delivery_unregister - Unregister USB Power Delivery Support.
* @pd: The USB PD contract.
*/
void usb_power_delivery_unregister(struct usb_power_delivery *pd)
{
if (IS_ERR_OR_NULL(pd))
return;
device_unregister(&pd->dev);
}
EXPORT_SYMBOL_GPL(usb_power_delivery_unregister);
/**
* usb_power_delivery_link_device - Link device to its USB PD object.
* @pd: The USB PD instance.
* @dev: The device.
*
* This function can be used to create a symlink named "usb_power_delivery" for
* @dev that points to @pd.
*/
int usb_power_delivery_link_device(struct usb_power_delivery *pd, struct device *dev)
{
int ret;
if (IS_ERR_OR_NULL(pd) || !dev)
return 0;
ret = sysfs_create_link(&dev->kobj, &pd->dev.kobj, "usb_power_delivery");
if (ret)
return ret;
get_device(&pd->dev);
get_device(dev);
return 0;
}
EXPORT_SYMBOL_GPL(usb_power_delivery_link_device);
/**
* usb_power_delivery_unlink_device - Unlink device from its USB PD object.
* @pd: The USB PD instance.
* @dev: The device.
*
* Remove the symlink that was previously created with pd_link_device().
*/
void usb_power_delivery_unlink_device(struct usb_power_delivery *pd, struct device *dev)
{
if (IS_ERR_OR_NULL(pd) || !dev)
return;
sysfs_remove_link(&dev->kobj, "usb_power_delivery");
put_device(&pd->dev);
put_device(dev);
}
EXPORT_SYMBOL_GPL(usb_power_delivery_unlink_device);
/* -------------------------------------------------------------------------- */
int __init usb_power_delivery_init(void)
{
return class_register(&pd_class);
}
void __exit usb_power_delivery_exit(void)
{
ida_destroy(&pd_ida);
class_unregister(&pd_class);
}
Codebase Browser
linux