From 04dd17822334871b23ea2862f7798fb0e0007777 Mon Sep 17 00:00:00 2001
From: hc <hc@nodka.com>
Date: Sat, 11 May 2024 08:53:19 +0000
Subject: [PATCH] change otg to host mode
---
kernel/drivers/power/supply/power_supply_sysfs.c | 739 +++++++++++++++++++++++---------------------------------
1 files changed, 305 insertions(+), 434 deletions(-)
diff --git a/kernel/drivers/power/supply/power_supply_sysfs.c b/kernel/drivers/power/supply/power_supply_sysfs.c
index 8f49aa5..ca6fa09 100644
--- a/kernel/drivers/power/supply/power_supply_sysfs.c
+++ b/kernel/drivers/power/supply/power_supply_sysfs.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0-only
/*
* Sysfs interface for the universal power supply monitor class
*
@@ -7,8 +8,6 @@
* Copyright © 2003 Ian Molton <spyro@f2s.com>
*
* Modified: 2004, Oct Szabolcs Gyurko
- *
- * You may use this code as per GPL version 2
*/
#include <linux/ctype.h>
@@ -19,94 +18,255 @@
#include "power_supply.h"
-/*
- * This is because the name "current" breaks the device attr macro.
- * The "current" word resolves to "(get_current())" so instead of
- * "current" "(get_current())" appears in the sysfs.
- *
- * The source of this definition is the device.h which calls __ATTR
- * macro in sysfs.h which calls the __stringify macro.
- *
- * Only modification that the name is not tried to be resolved
- * (as a macro let's say).
- */
+#define MAX_PROP_NAME_LEN 30
-#define POWER_SUPPLY_ATTR(_name) \
-{ \
- .attr = { .name = #_name }, \
- .show = power_supply_show_property, \
- .store = power_supply_store_property, \
+struct power_supply_attr {
+ const char *prop_name;
+ char attr_name[MAX_PROP_NAME_LEN + 1];
+ struct device_attribute dev_attr;
+ const char * const *text_values;
+ int text_values_len;
+};
+
+#define _POWER_SUPPLY_ATTR(_name, _text, _len) \
+[POWER_SUPPLY_PROP_ ## _name] = \
+{ \
+ .prop_name = #_name, \
+ .attr_name = #_name "\0", \
+ .text_values = _text, \
+ .text_values_len = _len, \
}
-static struct device_attribute power_supply_attrs[];
+#define POWER_SUPPLY_ATTR(_name) _POWER_SUPPLY_ATTR(_name, NULL, 0)
+#define _POWER_SUPPLY_ENUM_ATTR(_name, _text) \
+ _POWER_SUPPLY_ATTR(_name, _text, ARRAY_SIZE(_text))
+#define POWER_SUPPLY_ENUM_ATTR(_name) \
+ _POWER_SUPPLY_ENUM_ATTR(_name, POWER_SUPPLY_ ## _name ## _TEXT)
-static const char * const power_supply_type_text[] = {
- "Unknown", "Battery", "UPS", "Mains", "USB",
- "USB_DCP", "USB_CDP", "USB_ACA", "USB_C",
- "USB_PD", "USB_PD_DRP", "BrickID",
- "USB_HVDCP", "USB_HVDCP_3", "USB_HVDCP_3P5", "Wireless", "USB_FLOAT",
- "BMS", "Parallel", "Main", "USB_C_UFP", "USB_C_DFP",
- "Charge_Pump",
+static const char * const POWER_SUPPLY_TYPE_TEXT[] = {
+ [POWER_SUPPLY_TYPE_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_TYPE_BATTERY] = "Battery",
+ [POWER_SUPPLY_TYPE_UPS] = "UPS",
+ [POWER_SUPPLY_TYPE_MAINS] = "Mains",
+ [POWER_SUPPLY_TYPE_USB] = "USB",
+ [POWER_SUPPLY_TYPE_USB_DCP] = "USB_DCP",
+ [POWER_SUPPLY_TYPE_USB_CDP] = "USB_CDP",
+ [POWER_SUPPLY_TYPE_USB_ACA] = "USB_ACA",
+ [POWER_SUPPLY_TYPE_USB_TYPE_C] = "USB_C",
+ [POWER_SUPPLY_TYPE_USB_PD] = "USB_PD",
+ [POWER_SUPPLY_TYPE_USB_PD_DRP] = "USB_PD_DRP",
+ [POWER_SUPPLY_TYPE_APPLE_BRICK_ID] = "BrickID",
+ [POWER_SUPPLY_TYPE_WIRELESS] = "Wireless",
+#if defined(CONFIG_NO_GKI)
+ [POWER_SUPPLY_TYPE_CHARGE_PUMP] = "Charge_Pump",
+#endif
};
-static const char * const power_supply_usb_type_text[] = {
- "Unknown", "SDP", "DCP", "CDP", "ACA", "C",
- "PD", "PD_DRP", "PD_PPS", "BrickID"
+static const char * const POWER_SUPPLY_USB_TYPE_TEXT[] = {
+ [POWER_SUPPLY_USB_TYPE_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_USB_TYPE_SDP] = "SDP",
+ [POWER_SUPPLY_USB_TYPE_DCP] = "DCP",
+ [POWER_SUPPLY_USB_TYPE_CDP] = "CDP",
+ [POWER_SUPPLY_USB_TYPE_ACA] = "ACA",
+ [POWER_SUPPLY_USB_TYPE_C] = "C",
+ [POWER_SUPPLY_USB_TYPE_PD] = "PD",
+ [POWER_SUPPLY_USB_TYPE_PD_DRP] = "PD_DRP",
+ [POWER_SUPPLY_USB_TYPE_PD_PPS] = "PD_PPS",
+ [POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID] = "BrickID",
};
-static const char * const power_supply_status_text[] = {
- "Unknown", "Charging", "Discharging", "Not charging", "Full"
+static const char * const POWER_SUPPLY_STATUS_TEXT[] = {
+ [POWER_SUPPLY_STATUS_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_STATUS_CHARGING] = "Charging",
+ [POWER_SUPPLY_STATUS_DISCHARGING] = "Discharging",
+ [POWER_SUPPLY_STATUS_NOT_CHARGING] = "Not charging",
+ [POWER_SUPPLY_STATUS_FULL] = "Full",
};
-static const char * const power_supply_charge_type_text[] = {
- "Unknown", "N/A", "Trickle", "Fast", "Taper"
+static const char * const POWER_SUPPLY_CHARGE_TYPE_TEXT[] = {
+ [POWER_SUPPLY_CHARGE_TYPE_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_CHARGE_TYPE_NONE] = "N/A",
+ [POWER_SUPPLY_CHARGE_TYPE_TRICKLE] = "Trickle",
+ [POWER_SUPPLY_CHARGE_TYPE_FAST] = "Fast",
+ [POWER_SUPPLY_CHARGE_TYPE_STANDARD] = "Standard",
+ [POWER_SUPPLY_CHARGE_TYPE_ADAPTIVE] = "Adaptive",
+ [POWER_SUPPLY_CHARGE_TYPE_CUSTOM] = "Custom",
+ [POWER_SUPPLY_CHARGE_TYPE_LONGLIFE] = "Long Life",
+ [POWER_SUPPLY_CHARGE_TYPE_TAPER] = "Taper",
};
-static const char * const power_supply_health_text[] = {
- "Unknown", "Good", "Overheat", "Dead", "Over voltage",
- "Unspecified failure", "Cold", "Watchdog timer expire",
- "Safety timer expire", "Over current", "Warm", "Cool", "Hot"
+static const char * const POWER_SUPPLY_HEALTH_TEXT[] = {
+ [POWER_SUPPLY_HEALTH_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_HEALTH_GOOD] = "Good",
+ [POWER_SUPPLY_HEALTH_OVERHEAT] = "Overheat",
+ [POWER_SUPPLY_HEALTH_DEAD] = "Dead",
+ [POWER_SUPPLY_HEALTH_OVERVOLTAGE] = "Over voltage",
+ [POWER_SUPPLY_HEALTH_UNSPEC_FAILURE] = "Unspecified failure",
+ [POWER_SUPPLY_HEALTH_COLD] = "Cold",
+ [POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE] = "Watchdog timer expire",
+ [POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE] = "Safety timer expire",
+ [POWER_SUPPLY_HEALTH_OVERCURRENT] = "Over current",
+ [POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED] = "Calibration required",
+ [POWER_SUPPLY_HEALTH_WARM] = "Warm",
+ [POWER_SUPPLY_HEALTH_COOL] = "Cool",
+ [POWER_SUPPLY_HEALTH_HOT] = "Hot",
};
-static const char * const power_supply_technology_text[] = {
- "Unknown", "NiMH", "Li-ion", "Li-poly", "LiFe", "NiCd",
- "LiMn"
+static const char * const POWER_SUPPLY_TECHNOLOGY_TEXT[] = {
+ [POWER_SUPPLY_TECHNOLOGY_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_TECHNOLOGY_NiMH] = "NiMH",
+ [POWER_SUPPLY_TECHNOLOGY_LION] = "Li-ion",
+ [POWER_SUPPLY_TECHNOLOGY_LIPO] = "Li-poly",
+ [POWER_SUPPLY_TECHNOLOGY_LiFe] = "LiFe",
+ [POWER_SUPPLY_TECHNOLOGY_NiCd] = "NiCd",
+ [POWER_SUPPLY_TECHNOLOGY_LiMn] = "LiMn",
};
-static const char * const power_supply_capacity_level_text[] = {
- "Unknown", "Critical", "Low", "Normal", "High", "Full"
+static const char * const POWER_SUPPLY_CAPACITY_LEVEL_TEXT[] = {
+ [POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL] = "Critical",
+ [POWER_SUPPLY_CAPACITY_LEVEL_LOW] = "Low",
+ [POWER_SUPPLY_CAPACITY_LEVEL_NORMAL] = "Normal",
+ [POWER_SUPPLY_CAPACITY_LEVEL_HIGH] = "High",
+ [POWER_SUPPLY_CAPACITY_LEVEL_FULL] = "Full",
};
-static const char * const power_supply_scope_text[] = {
- "Unknown", "System", "Device"
+static const char * const POWER_SUPPLY_SCOPE_TEXT[] = {
+ [POWER_SUPPLY_SCOPE_UNKNOWN] = "Unknown",
+ [POWER_SUPPLY_SCOPE_SYSTEM] = "System",
+ [POWER_SUPPLY_SCOPE_DEVICE] = "Device",
};
-static const char * const power_supply_usbc_text[] = {
- "Nothing attached", "Sink attached", "Powered cable w/ sink",
- "Debug Accessory", "Audio Adapter", "Powered cable w/o sink",
- "Source attached (default current)",
- "Source attached (medium current)",
- "Source attached (high current)",
- "Debug Accessory Mode (default current)",
- "Debug Accessory Mode (medium current)",
- "Debug Accessory Mode (high current)",
- "Non compliant",
- "Non compliant (Rp-Default/Rp-Default)",
- "Non compliant (Rp-1.5A/Rp-1.5A)",
- "Non compliant (Rp-3A/Rp-3A)"
+static struct power_supply_attr power_supply_attrs[] = {
+ /* Properties of type `int' */
+ POWER_SUPPLY_ENUM_ATTR(STATUS),
+ POWER_SUPPLY_ENUM_ATTR(CHARGE_TYPE),
+ POWER_SUPPLY_ENUM_ATTR(HEALTH),
+ POWER_SUPPLY_ATTR(PRESENT),
+ POWER_SUPPLY_ATTR(ONLINE),
+ POWER_SUPPLY_ATTR(AUTHENTIC),
+ POWER_SUPPLY_ENUM_ATTR(TECHNOLOGY),
+ POWER_SUPPLY_ATTR(CYCLE_COUNT),
+ POWER_SUPPLY_ATTR(VOLTAGE_MAX),
+ POWER_SUPPLY_ATTR(VOLTAGE_MIN),
+ POWER_SUPPLY_ATTR(VOLTAGE_MAX_DESIGN),
+ POWER_SUPPLY_ATTR(VOLTAGE_MIN_DESIGN),
+ POWER_SUPPLY_ATTR(VOLTAGE_NOW),
+ POWER_SUPPLY_ATTR(VOLTAGE_AVG),
+ POWER_SUPPLY_ATTR(VOLTAGE_OCV),
+ POWER_SUPPLY_ATTR(VOLTAGE_BOOT),
+ POWER_SUPPLY_ATTR(CURRENT_MAX),
+ POWER_SUPPLY_ATTR(CURRENT_NOW),
+ POWER_SUPPLY_ATTR(CURRENT_AVG),
+ POWER_SUPPLY_ATTR(CURRENT_BOOT),
+ POWER_SUPPLY_ATTR(POWER_NOW),
+ POWER_SUPPLY_ATTR(POWER_AVG),
+ POWER_SUPPLY_ATTR(CHARGE_FULL_DESIGN),
+ POWER_SUPPLY_ATTR(CHARGE_EMPTY_DESIGN),
+ POWER_SUPPLY_ATTR(CHARGE_FULL),
+ POWER_SUPPLY_ATTR(CHARGE_EMPTY),
+ POWER_SUPPLY_ATTR(CHARGE_NOW),
+ POWER_SUPPLY_ATTR(CHARGE_AVG),
+ POWER_SUPPLY_ATTR(CHARGE_COUNTER),
+ POWER_SUPPLY_ATTR(CONSTANT_CHARGE_CURRENT),
+ POWER_SUPPLY_ATTR(CONSTANT_CHARGE_CURRENT_MAX),
+ POWER_SUPPLY_ATTR(CONSTANT_CHARGE_VOLTAGE),
+ POWER_SUPPLY_ATTR(CONSTANT_CHARGE_VOLTAGE_MAX),
+ POWER_SUPPLY_ATTR(CHARGE_CONTROL_LIMIT),
+ POWER_SUPPLY_ATTR(CHARGE_CONTROL_LIMIT_MAX),
+ POWER_SUPPLY_ATTR(CHARGE_CONTROL_START_THRESHOLD),
+ POWER_SUPPLY_ATTR(CHARGE_CONTROL_END_THRESHOLD),
+ POWER_SUPPLY_ATTR(INPUT_CURRENT_LIMIT),
+ POWER_SUPPLY_ATTR(INPUT_VOLTAGE_LIMIT),
+ POWER_SUPPLY_ATTR(INPUT_POWER_LIMIT),
+ POWER_SUPPLY_ATTR(ENERGY_FULL_DESIGN),
+ POWER_SUPPLY_ATTR(ENERGY_EMPTY_DESIGN),
+ POWER_SUPPLY_ATTR(ENERGY_FULL),
+ POWER_SUPPLY_ATTR(ENERGY_EMPTY),
+ POWER_SUPPLY_ATTR(ENERGY_NOW),
+ POWER_SUPPLY_ATTR(ENERGY_AVG),
+ POWER_SUPPLY_ATTR(CAPACITY),
+ POWER_SUPPLY_ATTR(CAPACITY_ALERT_MIN),
+ POWER_SUPPLY_ATTR(CAPACITY_ALERT_MAX),
+ POWER_SUPPLY_ATTR(CAPACITY_ERROR_MARGIN),
+ POWER_SUPPLY_ENUM_ATTR(CAPACITY_LEVEL),
+ POWER_SUPPLY_ATTR(TEMP),
+ POWER_SUPPLY_ATTR(TEMP_MAX),
+ POWER_SUPPLY_ATTR(TEMP_MIN),
+ POWER_SUPPLY_ATTR(TEMP_ALERT_MIN),
+ POWER_SUPPLY_ATTR(TEMP_ALERT_MAX),
+ POWER_SUPPLY_ATTR(TEMP_AMBIENT),
+ POWER_SUPPLY_ATTR(TEMP_AMBIENT_ALERT_MIN),
+ POWER_SUPPLY_ATTR(TEMP_AMBIENT_ALERT_MAX),
+ POWER_SUPPLY_ATTR(TIME_TO_EMPTY_NOW),
+ POWER_SUPPLY_ATTR(TIME_TO_EMPTY_AVG),
+ POWER_SUPPLY_ATTR(TIME_TO_FULL_NOW),
+ POWER_SUPPLY_ATTR(TIME_TO_FULL_AVG),
+ POWER_SUPPLY_ENUM_ATTR(TYPE),
+ POWER_SUPPLY_ATTR(USB_TYPE),
+ POWER_SUPPLY_ENUM_ATTR(SCOPE),
+ POWER_SUPPLY_ATTR(PRECHARGE_CURRENT),
+ POWER_SUPPLY_ATTR(CHARGE_TERM_CURRENT),
+ POWER_SUPPLY_ATTR(CALIBRATE),
+ POWER_SUPPLY_ATTR(MANUFACTURE_YEAR),
+ POWER_SUPPLY_ATTR(MANUFACTURE_MONTH),
+ POWER_SUPPLY_ATTR(MANUFACTURE_DAY),
+#if defined(CONFIG_NO_GKI)
+ /* Charge pump properties */
+ POWER_SUPPLY_ATTR(CP_ALARM_STATUS),
+ POWER_SUPPLY_ATTR(CP_BAT_OVP_ALARM),
+ POWER_SUPPLY_ATTR(CP_BAT_OCP_ALARM),
+ POWER_SUPPLY_ATTR(CP_BAT_UCP_ALARM),
+ POWER_SUPPLY_ATTR(CP_BUS_OVP_ALARM),
+ POWER_SUPPLY_ATTR(CP_BUS_OCP_ALARM),
+ POWER_SUPPLY_ATTR(CP_BAT_THERM_ALARM),
+ POWER_SUPPLY_ATTR(CP_BUS_THERM_ALARM),
+ POWER_SUPPLY_ATTR(CP_DIE_THERM_ALARM),
+ POWER_SUPPLY_ATTR(CP_FAULT_STATUS),
+ POWER_SUPPLY_ATTR(CP_BAT_OVP_FAULT),
+ POWER_SUPPLY_ATTR(CP_BAT_OCP_FAULT),
+ POWER_SUPPLY_ATTR(CP_BUS_OVP_FAULT),
+ POWER_SUPPLY_ATTR(CP_BUS_OCP_FAULT),
+ POWER_SUPPLY_ATTR(CP_BAT_THERM_FAULT),
+ POWER_SUPPLY_ATTR(CP_BUS_THERM_FAULT),
+ POWER_SUPPLY_ATTR(CP_DIE_THERM_FAULT),
+ POWER_SUPPLY_ATTR(CP_VBUS_ERROR_STATUS),
+ POWER_SUPPLY_ATTR(CP_VBUS_HERROR_STATUS),
+ POWER_SUPPLY_ATTR(CP_VBUS_LERROR_STATUS),
+ POWER_SUPPLY_ATTR(CP_CHARGING_ENABLED),
+ POWER_SUPPLY_ATTR(CP_WDT_EN),
+ POWER_SUPPLY_ATTR(CP_VBUS),
+ POWER_SUPPLY_ATTR(CP_IBUS),
+ POWER_SUPPLY_ATTR(CP_SWITCHER_EN),
+ POWER_SUPPLY_ATTR(CP_BAT_TEMPERATURE),
+ POWER_SUPPLY_ATTR(CP_BUS_TEMPERATURE),
+ POWER_SUPPLY_ATTR(CP_DIE_TEMPERATURE),
+ POWER_SUPPLY_ATTR(CP_ISNS),
+ POWER_SUPPLY_ATTR(CP_TOGGLE_SWITCHER),
+ POWER_SUPPLY_ATTR(CP_IRQ_STATUS),
+ POWER_SUPPLY_ATTR(CP_ILIM),
+#endif
+ /* Properties of type `const char *' */
+ POWER_SUPPLY_ATTR(MODEL_NAME),
+ POWER_SUPPLY_ATTR(MANUFACTURER),
+ POWER_SUPPLY_ATTR(SERIAL_NUMBER),
};
-static const char * const power_supply_usbc_pr_text[] = {
- "none", "dual power role", "sink", "source"
-};
+static struct attribute *
+__power_supply_attrs[ARRAY_SIZE(power_supply_attrs) + 1];
-static const char * const power_supply_typec_src_rp_text[] = {
- "Rp-Default", "Rp-1.5A", "Rp-3A"
-};
+static struct power_supply_attr *to_ps_attr(struct device_attribute *attr)
+{
+ return container_of(attr, struct power_supply_attr, dev_attr);
+}
+
+static enum power_supply_property dev_attr_psp(struct device_attribute *attr)
+{
+ return to_ps_attr(attr) - power_supply_attrs;
+}
static ssize_t power_supply_show_usb_type(struct device *dev,
- enum power_supply_usb_type *usb_types,
- ssize_t num_usb_types,
+ const struct power_supply_desc *desc,
union power_supply_propval *value,
char *buf)
{
@@ -115,16 +275,16 @@
bool match = false;
int i;
- for (i = 0; i < num_usb_types; ++i) {
- usb_type = usb_types[i];
+ for (i = 0; i < desc->num_usb_types; ++i) {
+ usb_type = desc->usb_types[i];
if (value->intval == usb_type) {
count += sprintf(buf + count, "[%s] ",
- power_supply_usb_type_text[usb_type]);
+ POWER_SUPPLY_USB_TYPE_TEXT[usb_type]);
match = true;
} else {
count += sprintf(buf + count, "%s ",
- power_supply_usb_type_text[usb_type]);
+ POWER_SUPPLY_USB_TYPE_TEXT[usb_type]);
}
}
@@ -144,7 +304,8 @@
char *buf) {
ssize_t ret;
struct power_supply *psy = dev_get_drvdata(dev);
- enum power_supply_property psp = attr - power_supply_attrs;
+ struct power_supply_attr *ps_attr = to_ps_attr(attr);
+ enum power_supply_property psp = dev_attr_psp(attr);
union power_supply_propval value;
if (psp == POWER_SUPPLY_PROP_TYPE) {
@@ -154,7 +315,8 @@
if (ret < 0) {
if (ret == -ENODATA)
- dev_dbg(dev, "driver has no data for `%s' property\n",
+ dev_dbg_ratelimited(dev,
+ "driver has no data for `%s' property\n",
attr->attr.name);
else if (ret != -ENODEV && ret != -EAGAIN)
dev_err_ratelimited(dev,
@@ -164,61 +326,15 @@
}
}
+ if (ps_attr->text_values_len > 0 &&
+ value.intval < ps_attr->text_values_len && value.intval >= 0) {
+ return sprintf(buf, "%s\n", ps_attr->text_values[value.intval]);
+ }
+
switch (psp) {
- case POWER_SUPPLY_PROP_STATUS:
- ret = sprintf(buf, "%s\n",
- power_supply_status_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_CHARGE_TYPE:
- ret = sprintf(buf, "%s\n",
- power_supply_charge_type_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_HEALTH:
- ret = sprintf(buf, "%s\n",
- power_supply_health_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_TECHNOLOGY:
- ret = sprintf(buf, "%s\n",
- power_supply_technology_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
- ret = sprintf(buf, "%s\n",
- power_supply_capacity_level_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_TYPE:
- case POWER_SUPPLY_PROP_REAL_TYPE:
- ret = sprintf(buf, "%s\n",
- power_supply_type_text[value.intval]);
- break;
case POWER_SUPPLY_PROP_USB_TYPE:
- ret = power_supply_show_usb_type(dev, psy->desc->usb_types,
- psy->desc->num_usb_types,
- &value, buf);
- break;
- case POWER_SUPPLY_PROP_SCOPE:
- ret = sprintf(buf, "%s\n",
- power_supply_scope_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_TYPEC_MODE:
- ret = sprintf(buf, "%s\n",
- power_supply_usbc_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_TYPEC_POWER_ROLE:
- ret = sprintf(buf, "%s\n",
- power_supply_usbc_pr_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_TYPEC_SRC_RP:
- ret = sprintf(buf, "%s\n",
- power_supply_typec_src_rp_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_DIE_HEALTH:
- case POWER_SUPPLY_PROP_SKIN_HEALTH:
- case POWER_SUPPLY_PROP_CONNECTOR_HEALTH:
- ret = sprintf(buf, "%s\n",
- power_supply_health_text[value.intval]);
- break;
- case POWER_SUPPLY_PROP_CHARGE_COUNTER_EXT:
- ret = sprintf(buf, "%lld\n", value.int64val);
+ ret = power_supply_show_usb_type(dev, psy->desc,
+ &value, buf);
break;
case POWER_SUPPLY_PROP_MODEL_NAME ... POWER_SUPPLY_PROP_SERIAL_NUMBER:
ret = sprintf(buf, "%s\n", value.strval);
@@ -235,30 +351,14 @@
const char *buf, size_t count) {
ssize_t ret;
struct power_supply *psy = dev_get_drvdata(dev);
- enum power_supply_property psp = attr - power_supply_attrs;
+ struct power_supply_attr *ps_attr = to_ps_attr(attr);
+ enum power_supply_property psp = dev_attr_psp(attr);
union power_supply_propval value;
- switch (psp) {
- case POWER_SUPPLY_PROP_STATUS:
- ret = sysfs_match_string(power_supply_status_text, buf);
- break;
- case POWER_SUPPLY_PROP_CHARGE_TYPE:
- ret = sysfs_match_string(power_supply_charge_type_text, buf);
- break;
- case POWER_SUPPLY_PROP_HEALTH:
- ret = sysfs_match_string(power_supply_health_text, buf);
- break;
- case POWER_SUPPLY_PROP_TECHNOLOGY:
- ret = sysfs_match_string(power_supply_technology_text, buf);
- break;
- case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
- ret = sysfs_match_string(power_supply_capacity_level_text, buf);
- break;
- case POWER_SUPPLY_PROP_SCOPE:
- ret = sysfs_match_string(power_supply_scope_text, buf);
- break;
- default:
- ret = -EINVAL;
+ ret = -EINVAL;
+ if (ps_attr->text_values_len > 0) {
+ ret = __sysfs_match_string(ps_attr->text_values,
+ ps_attr->text_values_len, buf);
}
/*
@@ -284,255 +384,17 @@
return count;
}
-/* Must be in the same order as POWER_SUPPLY_PROP_* */
-static struct device_attribute power_supply_attrs[] = {
- /* Properties of type `int' */
- POWER_SUPPLY_ATTR(status),
- POWER_SUPPLY_ATTR(charge_type),
- POWER_SUPPLY_ATTR(health),
- POWER_SUPPLY_ATTR(present),
- POWER_SUPPLY_ATTR(online),
- POWER_SUPPLY_ATTR(authentic),
- POWER_SUPPLY_ATTR(technology),
- POWER_SUPPLY_ATTR(cycle_count),
- POWER_SUPPLY_ATTR(voltage_max),
- POWER_SUPPLY_ATTR(voltage_min),
- POWER_SUPPLY_ATTR(voltage_max_design),
- POWER_SUPPLY_ATTR(voltage_min_design),
- POWER_SUPPLY_ATTR(voltage_now),
- POWER_SUPPLY_ATTR(voltage_avg),
- POWER_SUPPLY_ATTR(voltage_ocv),
- POWER_SUPPLY_ATTR(voltage_boot),
- POWER_SUPPLY_ATTR(current_max),
- POWER_SUPPLY_ATTR(current_now),
- POWER_SUPPLY_ATTR(current_avg),
- POWER_SUPPLY_ATTR(current_boot),
- POWER_SUPPLY_ATTR(power_now),
- POWER_SUPPLY_ATTR(power_avg),
- POWER_SUPPLY_ATTR(charge_full_design),
- POWER_SUPPLY_ATTR(charge_empty_design),
- POWER_SUPPLY_ATTR(charge_full),
- POWER_SUPPLY_ATTR(charge_empty),
- POWER_SUPPLY_ATTR(charge_now),
- POWER_SUPPLY_ATTR(charge_avg),
- POWER_SUPPLY_ATTR(charge_counter),
- POWER_SUPPLY_ATTR(constant_charge_current),
- POWER_SUPPLY_ATTR(constant_charge_current_max),
- POWER_SUPPLY_ATTR(constant_charge_voltage),
- POWER_SUPPLY_ATTR(constant_charge_voltage_max),
- POWER_SUPPLY_ATTR(charge_control_limit),
- POWER_SUPPLY_ATTR(charge_control_limit_max),
- POWER_SUPPLY_ATTR(input_current_limit),
- POWER_SUPPLY_ATTR(energy_full_design),
- POWER_SUPPLY_ATTR(energy_empty_design),
- POWER_SUPPLY_ATTR(energy_full),
- POWER_SUPPLY_ATTR(energy_empty),
- POWER_SUPPLY_ATTR(energy_now),
- POWER_SUPPLY_ATTR(energy_avg),
- POWER_SUPPLY_ATTR(capacity),
- POWER_SUPPLY_ATTR(capacity_alert_min),
- POWER_SUPPLY_ATTR(capacity_alert_max),
- POWER_SUPPLY_ATTR(capacity_level),
- POWER_SUPPLY_ATTR(temp),
- POWER_SUPPLY_ATTR(temp_max),
- POWER_SUPPLY_ATTR(temp_min),
- POWER_SUPPLY_ATTR(temp_alert_min),
- POWER_SUPPLY_ATTR(temp_alert_max),
- POWER_SUPPLY_ATTR(temp_ambient),
- POWER_SUPPLY_ATTR(temp_ambient_alert_min),
- POWER_SUPPLY_ATTR(temp_ambient_alert_max),
- POWER_SUPPLY_ATTR(time_to_empty_now),
- POWER_SUPPLY_ATTR(time_to_empty_avg),
- POWER_SUPPLY_ATTR(time_to_full_now),
- POWER_SUPPLY_ATTR(time_to_full_avg),
- POWER_SUPPLY_ATTR(type),
- POWER_SUPPLY_ATTR(usb_type),
- POWER_SUPPLY_ATTR(scope),
- POWER_SUPPLY_ATTR(precharge_current),
- POWER_SUPPLY_ATTR(charge_term_current),
- POWER_SUPPLY_ATTR(calibrate),
- /* Local extensions */
- POWER_SUPPLY_ATTR(usb_hc),
- POWER_SUPPLY_ATTR(usb_otg),
- POWER_SUPPLY_ATTR(charge_enabled),
- POWER_SUPPLY_ATTR(set_ship_mode),
- POWER_SUPPLY_ATTR(real_type),
- POWER_SUPPLY_ATTR(charge_now_raw),
- POWER_SUPPLY_ATTR(charge_now_error),
- POWER_SUPPLY_ATTR(capacity_raw),
- POWER_SUPPLY_ATTR(battery_charging_enabled),
- POWER_SUPPLY_ATTR(charging_enabled),
- POWER_SUPPLY_ATTR(step_charging_enabled),
- POWER_SUPPLY_ATTR(step_charging_step),
- POWER_SUPPLY_ATTR(pin_enabled),
- POWER_SUPPLY_ATTR(input_suspend),
- POWER_SUPPLY_ATTR(input_voltage_regulation),
- POWER_SUPPLY_ATTR(input_current_max),
- POWER_SUPPLY_ATTR(input_current_trim),
- POWER_SUPPLY_ATTR(input_current_settled),
- POWER_SUPPLY_ATTR(input_voltage_settled),
- POWER_SUPPLY_ATTR(bypass_vchg_loop_debouncer),
- POWER_SUPPLY_ATTR(charge_counter_shadow),
- POWER_SUPPLY_ATTR(hi_power),
- POWER_SUPPLY_ATTR(low_power),
- POWER_SUPPLY_ATTR(temp_cool),
- POWER_SUPPLY_ATTR(temp_warm),
- POWER_SUPPLY_ATTR(temp_cold),
- POWER_SUPPLY_ATTR(temp_hot),
- POWER_SUPPLY_ATTR(system_temp_level),
- POWER_SUPPLY_ATTR(resistance),
- POWER_SUPPLY_ATTR(resistance_capacitive),
- POWER_SUPPLY_ATTR(resistance_id),
- POWER_SUPPLY_ATTR(resistance_now),
- POWER_SUPPLY_ATTR(flash_current_max),
- POWER_SUPPLY_ATTR(update_now),
- POWER_SUPPLY_ATTR(esr_count),
- POWER_SUPPLY_ATTR(buck_freq),
- POWER_SUPPLY_ATTR(boost_current),
- POWER_SUPPLY_ATTR(safety_timer_enabled),
- POWER_SUPPLY_ATTR(charge_done),
- POWER_SUPPLY_ATTR(flash_active),
- POWER_SUPPLY_ATTR(flash_trigger),
- POWER_SUPPLY_ATTR(force_tlim),
- POWER_SUPPLY_ATTR(dp_dm),
- POWER_SUPPLY_ATTR(input_current_limited),
- POWER_SUPPLY_ATTR(input_current_now),
- POWER_SUPPLY_ATTR(charge_qnovo_enable),
- POWER_SUPPLY_ATTR(current_qnovo),
- POWER_SUPPLY_ATTR(voltage_qnovo),
- POWER_SUPPLY_ATTR(rerun_aicl),
- POWER_SUPPLY_ATTR(cycle_count_id),
- POWER_SUPPLY_ATTR(safety_timer_expired),
- POWER_SUPPLY_ATTR(restricted_charging),
- POWER_SUPPLY_ATTR(current_capability),
- POWER_SUPPLY_ATTR(typec_mode),
- POWER_SUPPLY_ATTR(typec_cc_orientation),
- POWER_SUPPLY_ATTR(typec_power_role),
- POWER_SUPPLY_ATTR(typec_src_rp),
- POWER_SUPPLY_ATTR(pd_allowed),
- POWER_SUPPLY_ATTR(pd_active),
- POWER_SUPPLY_ATTR(pd_in_hard_reset),
- POWER_SUPPLY_ATTR(pd_current_max),
- POWER_SUPPLY_ATTR(pd_usb_suspend_supported),
- POWER_SUPPLY_ATTR(charger_temp),
- POWER_SUPPLY_ATTR(charger_temp_max),
- POWER_SUPPLY_ATTR(parallel_disable),
- POWER_SUPPLY_ATTR(pe_start),
- POWER_SUPPLY_ATTR(soc_reporting_ready),
- POWER_SUPPLY_ATTR(debug_battery),
- POWER_SUPPLY_ATTR(fcc_delta),
- POWER_SUPPLY_ATTR(icl_reduction),
- POWER_SUPPLY_ATTR(parallel_mode),
- POWER_SUPPLY_ATTR(die_health),
- POWER_SUPPLY_ATTR(connector_health),
- POWER_SUPPLY_ATTR(ctm_current_max),
- POWER_SUPPLY_ATTR(hw_current_max),
- POWER_SUPPLY_ATTR(pr_swap),
- POWER_SUPPLY_ATTR(cc_step),
- POWER_SUPPLY_ATTR(cc_step_sel),
- POWER_SUPPLY_ATTR(sw_jeita_enabled),
- POWER_SUPPLY_ATTR(pd_voltage_max),
- POWER_SUPPLY_ATTR(pd_voltage_min),
- POWER_SUPPLY_ATTR(sdp_current_max),
- POWER_SUPPLY_ATTR(connector_type),
- POWER_SUPPLY_ATTR(parallel_batfet_mode),
- POWER_SUPPLY_ATTR(parallel_fcc_max),
- POWER_SUPPLY_ATTR(min_icl),
- POWER_SUPPLY_ATTR(moisture_detected),
- POWER_SUPPLY_ATTR(batt_profile_version),
- POWER_SUPPLY_ATTR(batt_full_current),
- POWER_SUPPLY_ATTR(recharge_soc),
- POWER_SUPPLY_ATTR(hvdcp_opti_allowed),
- POWER_SUPPLY_ATTR(smb_en_mode),
- POWER_SUPPLY_ATTR(smb_en_reason),
- POWER_SUPPLY_ATTR(esr_actual),
- POWER_SUPPLY_ATTR(esr_nominal),
- POWER_SUPPLY_ATTR(soh),
- POWER_SUPPLY_ATTR(clear_soh),
- POWER_SUPPLY_ATTR(force_recharge),
- POWER_SUPPLY_ATTR(fcc_stepper_enable),
- POWER_SUPPLY_ATTR(toggle_stat),
- POWER_SUPPLY_ATTR(main_fcc_max),
- POWER_SUPPLY_ATTR(fg_reset),
- POWER_SUPPLY_ATTR(qc_opti_disable),
- POWER_SUPPLY_ATTR(cc_soc),
- POWER_SUPPLY_ATTR(batt_age_level),
- POWER_SUPPLY_ATTR(scale_mode_en),
- POWER_SUPPLY_ATTR(voltage_vph),
- POWER_SUPPLY_ATTR(chip_version),
- POWER_SUPPLY_ATTR(therm_icl_limit),
- POWER_SUPPLY_ATTR(dc_reset),
- POWER_SUPPLY_ATTR(voltage_max_limit),
- POWER_SUPPLY_ATTR(real_capacity),
- POWER_SUPPLY_ATTR(force_main_icl),
- POWER_SUPPLY_ATTR(force_main_fcc),
- POWER_SUPPLY_ATTR(comp_clamp_level),
- POWER_SUPPLY_ATTR(adapter_cc_mode),
- POWER_SUPPLY_ATTR(skin_health),
- POWER_SUPPLY_ATTR(charge_disable),
- POWER_SUPPLY_ATTR(adapter_details),
- POWER_SUPPLY_ATTR(dead_battery),
- POWER_SUPPLY_ATTR(voltage_fifo),
- POWER_SUPPLY_ATTR(cc_uah),
- POWER_SUPPLY_ATTR(operating_freq),
- POWER_SUPPLY_ATTR(aicl_delay),
- POWER_SUPPLY_ATTR(aicl_icl),
- POWER_SUPPLY_ATTR(rtx),
- POWER_SUPPLY_ATTR(cutoff_soc),
- POWER_SUPPLY_ATTR(sys_soc),
- POWER_SUPPLY_ATTR(batt_soc),
- /* Capacity Estimation */
- POWER_SUPPLY_ATTR(batt_ce_ctrl),
- POWER_SUPPLY_ATTR(batt_ce_full),
- /* Resistance Estimaton */
- POWER_SUPPLY_ATTR(resistance_avg),
- POWER_SUPPLY_ATTR(batt_res_filt_cnts),
- POWER_SUPPLY_ATTR(aicl_done),
- POWER_SUPPLY_ATTR(voltage_step),
- POWER_SUPPLY_ATTR(otg_fastroleswap),
- POWER_SUPPLY_ATTR(apsd_rerun),
- POWER_SUPPLY_ATTR(apsd_timeout),
- /* Charge pump properties */
- POWER_SUPPLY_ATTR(cp_status1),
- POWER_SUPPLY_ATTR(cp_status2),
- POWER_SUPPLY_ATTR(cp_enable),
- POWER_SUPPLY_ATTR(cp_switcher_en),
- POWER_SUPPLY_ATTR(cp_die_temp),
- POWER_SUPPLY_ATTR(cp_isns),
- POWER_SUPPLY_ATTR(cp_isns_slave),
- POWER_SUPPLY_ATTR(cp_toggle_switcher),
- POWER_SUPPLY_ATTR(cp_irq_status),
- POWER_SUPPLY_ATTR(cp_ilim),
- POWER_SUPPLY_ATTR(irq_status),
- POWER_SUPPLY_ATTR(parallel_output_mode),
- POWER_SUPPLY_ATTR(alignment),
- POWER_SUPPLY_ATTR(moisture_detection_enabled),
- POWER_SUPPLY_ATTR(cc_toggle_enable),
- POWER_SUPPLY_ATTR(fg_type),
- POWER_SUPPLY_ATTR(charger_status),
- /* Local extensions of type int64_t */
- POWER_SUPPLY_ATTR(charge_counter_ext),
- POWER_SUPPLY_ATTR(charge_charger_state),
- /* Properties of type `const char *' */
- POWER_SUPPLY_ATTR(model_name),
- POWER_SUPPLY_ATTR(ptmc_id),
- POWER_SUPPLY_ATTR(manufacturer),
- POWER_SUPPLY_ATTR(battery_type),
- POWER_SUPPLY_ATTR(cycle_counts),
- POWER_SUPPLY_ATTR(serial_number),
-};
-
-static struct attribute *
-__power_supply_attrs[ARRAY_SIZE(power_supply_attrs) + 1];
-
static umode_t power_supply_attr_is_visible(struct kobject *kobj,
struct attribute *attr,
int attrno)
{
- struct device *dev = container_of(kobj, struct device, kobj);
+ struct device *dev = kobj_to_dev(kobj);
struct power_supply *psy = dev_get_drvdata(dev);
umode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
int i;
+
+ if (!power_supply_attrs[attrno].prop_name)
+ return 0;
if (attrno == POWER_SUPPLY_PROP_TYPE)
return mode;
@@ -562,31 +424,69 @@
NULL,
};
+static void str_to_lower(char *str)
+{
+ while (*str) {
+ *str = tolower(*str);
+ str++;
+ }
+}
+
void power_supply_init_attrs(struct device_type *dev_type)
{
int i;
dev_type->groups = power_supply_attr_groups;
- for (i = 0; i < ARRAY_SIZE(power_supply_attrs); i++)
- __power_supply_attrs[i] = &power_supply_attrs[i].attr;
+ for (i = 0; i < ARRAY_SIZE(power_supply_attrs); i++) {
+ struct device_attribute *attr;
+
+ if (!power_supply_attrs[i].prop_name) {
+ pr_warn("%s: Property %d skipped because is is missing from power_supply_attrs\n",
+ __func__, i);
+ sprintf(power_supply_attrs[i].attr_name, "_err_%d", i);
+ } else {
+ str_to_lower(power_supply_attrs[i].attr_name);
+ }
+
+ attr = &power_supply_attrs[i].dev_attr;
+
+ attr->attr.name = power_supply_attrs[i].attr_name;
+ attr->show = power_supply_show_property;
+ attr->store = power_supply_store_property;
+ __power_supply_attrs[i] = &attr->attr;
+ }
}
-static char *kstruprdup(const char *str, gfp_t gfp)
+static int add_prop_uevent(struct device *dev, struct kobj_uevent_env *env,
+ enum power_supply_property prop, char *prop_buf)
{
- char *ret, *ustr;
+ int ret = 0;
+ struct power_supply_attr *pwr_attr;
+ struct device_attribute *dev_attr;
+ char *line;
- ustr = ret = kmalloc(strlen(str) + 1, gfp);
+ pwr_attr = &power_supply_attrs[prop];
+ dev_attr = &pwr_attr->dev_attr;
- if (!ret)
- return NULL;
+ ret = power_supply_show_property(dev, dev_attr, prop_buf);
+ if (ret == -ENODEV || ret == -ENODATA) {
+ /*
+ * When a battery is absent, we expect -ENODEV. Don't abort;
+ * send the uevent with at least the the PRESENT=0 property
+ */
+ return 0;
+ }
- while (*str)
- *ustr++ = toupper(*str++);
+ if (ret < 0)
+ return ret;
- *ustr = 0;
+ line = strchr(prop_buf, '\n');
+ if (line)
+ *line = 0;
- return ret;
+ return add_uevent_var(env, "POWER_SUPPLY_%s=%s",
+ pwr_attr->prop_name, prop_buf);
}
int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env)
@@ -594,7 +494,6 @@
struct power_supply *psy = dev_get_drvdata(dev);
int ret = 0, j;
char *prop_buf;
- char *attrname;
if (!psy || !psy->desc) {
dev_dbg(dev, "No power supply yet\n");
@@ -609,41 +508,13 @@
if (!prop_buf)
return -ENOMEM;
+ ret = add_prop_uevent(dev, env, POWER_SUPPLY_PROP_TYPE, prop_buf);
+ if (ret)
+ goto out;
+
for (j = 0; j < psy->desc->num_properties; j++) {
- struct device_attribute *attr;
- char *line;
-
- attr = &power_supply_attrs[psy->desc->properties[j]];
-
- if (!attr->attr.name) {
- dev_info(dev, "%s:%d FAKE attr.name=NULL skip\n",
- __FILE__, __LINE__);
- continue;
- }
-
- ret = power_supply_show_property(dev, attr, prop_buf);
- if (ret == -ENODEV || ret == -ENODATA) {
- /* When a battery is absent, we expect -ENODEV. Don't abort;
- send the uevent with at least the the PRESENT=0 property */
- ret = 0;
- continue;
- }
-
- if (ret < 0)
- goto out;
-
- line = strchr(prop_buf, '\n');
- if (line)
- *line = 0;
-
- attrname = kstruprdup(attr->attr.name, GFP_KERNEL);
- if (!attrname) {
- ret = -ENOMEM;
- goto out;
- }
-
- ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf);
- kfree(attrname);
+ ret = add_prop_uevent(dev, env, psy->desc->properties[j],
+ prop_buf);
if (ret)
goto out;
}
--
Gitblit v1.6.2