#include <linux/acpi.h>
#include <linux/bits.h>
#include <linux/dmi.h>
#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/power_supply.h>
#include <linux/sysfs.h>
#include <acpi/battery.h>
#define AYANEO_PWM_ENABLE_REG 0x4A
#define AYANEO_PWM_REG 0x4B
#define AYANEO_PWM_MODE_AUTO 0x00
#define AYANEO_PWM_MODE_MANUAL 0x01
#define AYANEO_FAN_REG 0x76
#define EC_CHARGE_CONTROL_BEHAVIOURS \
(BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO) | \
BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE))
#define AYANEO_CHARGE_REG 0x1e
#define AYANEO_CHARGE_VAL_AUTO 0xaa
#define AYANEO_CHARGE_VAL_INHIBIT 0x55
#define AYANEO_POWER_REG 0x2d
#define AYANEO_POWER_OFF 0xfe
#define AYANEO_POWER_ON 0xff
#define AYANEO_MODULE_REG 0x2f
#define AYANEO_MODULE_LEFT BIT(0)
#define AYANEO_MODULE_RIGHT BIT(1)
#define AYANEO_MODULE_MASK (AYANEO_MODULE_LEFT | AYANEO_MODULE_RIGHT)
struct ayaneo_ec_quirk {
bool has_fan_control;
bool has_charge_control;
bool has_magic_modules;
};
struct ayaneo_ec_platform_data {
struct platform_device *pdev;
struct ayaneo_ec_quirk *quirks;
struct acpi_battery_hook battery_hook;
struct mutex hwmon_lock;
bool restore_charge_limit;
bool restore_pwm;
};
static const struct ayaneo_ec_quirk quirk_fan = {
.has_fan_control = true,
};
static const struct ayaneo_ec_quirk quirk_charge_limit = {
.has_fan_control = true,
.has_charge_control = true,
};
static const struct ayaneo_ec_quirk quirk_ayaneo3 = {
.has_fan_control = true,
.has_charge_control = true,
.has_magic_modules = true,
};
static const struct dmi_system_id dmi_table[] = {
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_MATCH(DMI_BOARD_NAME, "AYANEO 2"),
},
.driver_data = (void *)&quirk_fan,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_MATCH(DMI_BOARD_NAME, "FLIP"),
},
.driver_data = (void *)&quirk_fan,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_MATCH(DMI_BOARD_NAME, "GEEK"),
},
.driver_data = (void *)&quirk_fan,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AIR"),
},
.driver_data = (void *)&quirk_charge_limit,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AIR 1S"),
},
.driver_data = (void *)&quirk_charge_limit,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AB05-Mendocino"),
},
.driver_data = (void *)&quirk_charge_limit,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AIR Pro"),
},
.driver_data = (void *)&quirk_charge_limit,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_EXACT_MATCH(DMI_BOARD_NAME, "KUN"),
},
.driver_data = (void *)&quirk_charge_limit,
},
{
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "AYANEO"),
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AYANEO 3"),
},
.driver_data = (void *)&quirk_ayaneo3,
},
{},
};
static umode_t ayaneo_ec_hwmon_is_visible(const void *drvdata,
enum hwmon_sensor_types type, u32 attr,
int channel)
{
switch (type) {
case hwmon_fan:
return 0444;
case hwmon_pwm:
return 0644;
default:
return 0;
}
}
static int ayaneo_ec_read(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long *val)
{
u8 tmp;
int ret;
switch (type) {
case hwmon_fan:
switch (attr) {
case hwmon_fan_input:
ret = ec_read(AYANEO_FAN_REG, &tmp);
if (ret)
return ret;
*val = tmp << 8;
ret = ec_read(AYANEO_FAN_REG + 1, &tmp);
if (ret)
return ret;
*val |= tmp;
return 0;
default:
break;
}
break;
case hwmon_pwm:
switch (attr) {
case hwmon_pwm_input:
ret = ec_read(AYANEO_PWM_REG, &tmp);
if (ret)
return ret;
if (tmp > 100)
return -EIO;
*val = (255 * tmp) / 100;
return 0;
case hwmon_pwm_enable:
ret = ec_read(AYANEO_PWM_ENABLE_REG, &tmp);
if (ret)
return ret;
if (tmp == AYANEO_PWM_MODE_MANUAL)
*val = 1;
else if (tmp == AYANEO_PWM_MODE_AUTO)
*val = 2;
else
return -EIO;
return 0;
default:
break;
}
break;
default:
break;
}
return -EOPNOTSUPP;
}
static int ayaneo_ec_write(struct device *dev, enum hwmon_sensor_types type,
u32 attr, int channel, long val)
{
struct ayaneo_ec_platform_data *data = dev_get_drvdata(dev);
int ret;
guard(mutex)(&data->hwmon_lock);
switch (type) {
case hwmon_pwm:
switch (attr) {
case hwmon_pwm_enable:
data->restore_pwm = false;
switch (val) {
case 1:
return ec_write(AYANEO_PWM_ENABLE_REG,
AYANEO_PWM_MODE_MANUAL);
case 2:
return ec_write(AYANEO_PWM_ENABLE_REG,
AYANEO_PWM_MODE_AUTO);
default:
return -EINVAL;
}
case hwmon_pwm_input:
if (val < 0 || val > 255)
return -EINVAL;
if (data->restore_pwm) {
ret = ec_write(AYANEO_PWM_ENABLE_REG,
AYANEO_PWM_MODE_MANUAL);
if (ret)
return ret;
data->restore_pwm = false;
}
return ec_write(AYANEO_PWM_REG, (val * 100) / 255);
default:
break;
}
break;
default:
break;
}
return -EOPNOTSUPP;
}
static const struct hwmon_ops ayaneo_ec_hwmon_ops = {
.is_visible = ayaneo_ec_hwmon_is_visible,
.read = ayaneo_ec_read,
.write = ayaneo_ec_write,
};
static const struct hwmon_channel_info *const ayaneo_ec_sensors[] = {
HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT),
HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
NULL,
};
static const struct hwmon_chip_info ayaneo_ec_chip_info = {
.ops = &ayaneo_ec_hwmon_ops,
.info = ayaneo_ec_sensors,
};
static int ayaneo_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)
{
int ret;
u8 tmp;
switch (psp) {
case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
ret = ec_read(AYANEO_CHARGE_REG, &tmp);
if (ret)
return ret;
if (tmp == AYANEO_CHARGE_VAL_INHIBIT)
val->intval = POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE;
else
val->intval = POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO;
return 0;
default:
return -EINVAL;
}
}
static int ayaneo_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)
{
u8 raw_val;
switch (psp) {
case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
switch (val->intval) {
case POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO:
raw_val = AYANEO_CHARGE_VAL_AUTO;
break;
case POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE:
raw_val = AYANEO_CHARGE_VAL_INHIBIT;
break;
default:
return -EINVAL;
}
return ec_write(AYANEO_CHARGE_REG, raw_val);
default:
return -EINVAL;
}
}
static int ayaneo_psy_prop_is_writeable(struct power_supply *psy,
const struct power_supply_ext *ext,
void *data,
enum power_supply_property psp)
{
return true;
}
static const enum power_supply_property ayaneo_psy_ext_props[] = {
POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR,
};
static const struct power_supply_ext ayaneo_psy_ext = {
.name = "ayaneo-charge-control",
.properties = ayaneo_psy_ext_props,
.num_properties = ARRAY_SIZE(ayaneo_psy_ext_props),
.charge_behaviours = EC_CHARGE_CONTROL_BEHAVIOURS,
.get_property = ayaneo_psy_ext_get_prop,
.set_property = ayaneo_psy_ext_set_prop,
.property_is_writeable = ayaneo_psy_prop_is_writeable,
};
static int ayaneo_add_battery(struct power_supply *battery,
struct acpi_battery_hook *hook)
{
struct ayaneo_ec_platform_data *data =
container_of(hook, struct ayaneo_ec_platform_data, battery_hook);
return power_supply_register_extension(battery, &ayaneo_psy_ext,
&data->pdev->dev, NULL);
}
static int ayaneo_remove_battery(struct power_supply *battery,
struct acpi_battery_hook *hook)
{
power_supply_unregister_extension(battery, &ayaneo_psy_ext);
return 0;
}
static ssize_t controller_power_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
bool value;
int ret;
ret = kstrtobool(buf, &value);
if (ret)
return ret;
ret = ec_write(AYANEO_POWER_REG, value ? AYANEO_POWER_ON : AYANEO_POWER_OFF);
if (ret)
return ret;
return count;
}
static ssize_t controller_power_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
int ret;
u8 val;
ret = ec_read(AYANEO_POWER_REG, &val);
if (ret)
return ret;
return sysfs_emit(buf, "%d\n", val == AYANEO_POWER_ON);
}
static DEVICE_ATTR_RW(controller_power);
static ssize_t controller_modules_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
u8 unconnected_modules;
char *out;
int ret;
ret = ec_read(AYANEO_MODULE_REG, &unconnected_modules);
if (ret)
return ret;
switch (~unconnected_modules & AYANEO_MODULE_MASK) {
case AYANEO_MODULE_LEFT | AYANEO_MODULE_RIGHT:
out = "both";
break;
case AYANEO_MODULE_LEFT:
out = "left";
break;
case AYANEO_MODULE_RIGHT:
out = "right";
break;
default:
out = "none";
break;
}
return sysfs_emit(buf, "%s\n", out);
}
static DEVICE_ATTR_RO(controller_modules);
static struct attribute *aya_mm_attrs[] = {
&dev_attr_controller_power.attr,
&dev_attr_controller_modules.attr,
NULL
};
static umode_t aya_mm_is_visible(struct kobject *kobj,
struct attribute *attr, int n)
{
struct device *dev = kobj_to_dev(kobj);
struct platform_device *pdev = to_platform_device(dev);
struct ayaneo_ec_platform_data *data = platform_get_drvdata(pdev);
if (data->quirks->has_magic_modules)
return attr->mode;
return 0;
}
static const struct attribute_group aya_mm_attribute_group = {
.is_visible = aya_mm_is_visible,
.attrs = aya_mm_attrs,
};
static const struct attribute_group *ayaneo_ec_groups[] = {
&aya_mm_attribute_group,
NULL
};
static int ayaneo_ec_probe(struct platform_device *pdev)
{
const struct dmi_system_id *dmi_entry;
struct ayaneo_ec_platform_data *data;
struct device *hwdev;
int ret;
dmi_entry = dmi_first_match(dmi_table);
if (!dmi_entry)
return -ENODEV;
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
if (!data)
return -ENOMEM;
data->pdev = pdev;
data->quirks = dmi_entry->driver_data;
ret = devm_mutex_init(&pdev->dev, &data->hwmon_lock);
if (ret)
return ret;
platform_set_drvdata(pdev, data);
if (data->quirks->has_fan_control) {
hwdev = devm_hwmon_device_register_with_info(&pdev->dev,
"ayaneo_ec", data, &ayaneo_ec_chip_info, NULL);
if (IS_ERR(hwdev))
return PTR_ERR(hwdev);
}
if (data->quirks->has_charge_control) {
data->battery_hook.add_battery = ayaneo_add_battery;
data->battery_hook.remove_battery = ayaneo_remove_battery;
data->battery_hook.name = "Ayaneo Battery";
ret = devm_battery_hook_register(&pdev->dev, &data->battery_hook);
if (ret)
return ret;
}
return 0;
}
static int ayaneo_freeze(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct ayaneo_ec_platform_data *data = platform_get_drvdata(pdev);
int ret;
u8 tmp;
if (data->quirks->has_charge_control) {
ret = ec_read(AYANEO_CHARGE_REG, &tmp);
if (ret)
return ret;
data->restore_charge_limit = tmp == AYANEO_CHARGE_VAL_INHIBIT;
}
if (data->quirks->has_fan_control) {
ret = ec_read(AYANEO_PWM_ENABLE_REG, &tmp);
if (ret)
return ret;
data->restore_pwm = tmp == AYANEO_PWM_MODE_MANUAL;
if (data->restore_pwm) {
ret = ec_write(AYANEO_PWM_ENABLE_REG, AYANEO_PWM_MODE_AUTO);
if (ret)
return ret;
}
}
return 0;
}
static int ayaneo_restore(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct ayaneo_ec_platform_data *data = platform_get_drvdata(pdev);
int ret;
if (data->quirks->has_charge_control && data->restore_charge_limit) {
ret = ec_write(AYANEO_CHARGE_REG, AYANEO_CHARGE_VAL_INHIBIT);
if (ret)
return ret;
}
return 0;
}
static const struct dev_pm_ops ayaneo_pm_ops = {
.freeze = ayaneo_freeze,
.restore = ayaneo_restore,
};
static struct platform_driver ayaneo_platform_driver = {
.driver = {
.name = "ayaneo-ec",
.dev_groups = ayaneo_ec_groups,
.pm = pm_sleep_ptr(&ayaneo_pm_ops),
},
.probe = ayaneo_ec_probe,
};
static struct platform_device *ayaneo_platform_device;
static int __init ayaneo_ec_init(void)
{
ayaneo_platform_device =
platform_create_bundle(&ayaneo_platform_driver,
ayaneo_ec_probe, NULL, 0, NULL, 0);
return PTR_ERR_OR_ZERO(ayaneo_platform_device);
}
static void __exit ayaneo_ec_exit(void)
{
platform_device_unregister(ayaneo_platform_device);
platform_driver_unregister(&ayaneo_platform_driver);
}
MODULE_DEVICE_TABLE(dmi, dmi_table);
module_init(ayaneo_ec_init);
module_exit(ayaneo_ec_exit);
MODULE_AUTHOR("Antheas Kapenekakis <lkml@antheas.dev>");
MODULE_DESCRIPTION("Ayaneo Embedded Controller (EC) platform features");
MODULE_LICENSE("GPL");
