drivers/platform/chrome/wilco_ec/charge_schedule_sysfs.c - third_party/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Sysfs interface for Peak Shift and Advanced Battery Charging schedules.
  *
  * Copyright 2019 Google LLC
  *
  * See Documentation/ABI/testing/sysfs-platform-wilco-ec for more info.
  */

 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/platform_data/wilco-ec.h>
 #include <linux/platform_device.h>
 #include <linux/string.h>
 #include <linux/sysfs.h>

 #include "charge_schedule.h"

 #define DRV_NAME "wilco-charge-schedule"

 static ssize_t peak_shift_enable_show(struct device *dev,
 				      struct device_attribute *attr, char *buf)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	bool enabled;
 	int ret;

 	ret = wilco_ec_get_peak_shift_enable(ec, &enabled);
 	if (ret < 0)
 		return ret;

 	return snprintf(buf, PAGE_SIZE, "%d\n", enabled);
 }

 static ssize_t peak_shift_enable_store(struct device *dev,
 				       struct device_attribute *attr,
 				       const char *buf, size_t count)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	bool enable;
 	int ret;

 	if (strtobool(buf, &enable) < 0)
 		return -EINVAL;

 	ret = wilco_ec_set_peak_shift_enable(ec, enable);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 static struct device_attribute dev_attr_peak_shift_enable =
 		__ATTR(enable, 0644,
 		       peak_shift_enable_show, peak_shift_enable_store);

 static ssize_t advanced_charging_enable_show(struct device *dev,
 					     struct device_attribute *attr,
 					     char *buf)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	bool enabled;
 	int ret;

 	ret = wilco_ec_get_adv_charging_enable(ec, &enabled);
 	if (ret < 0)
 		return ret;

 	return snprintf(buf, PAGE_SIZE, "%d\n", enabled);
 }
 static ssize_t advanced_charging_enable_store(struct device *dev,
 					      struct device_attribute *attr,
 					      const char *buf, size_t count)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	bool enable;
 	int ret;

 	if (strtobool(buf, &enable) < 0)
 		return -EINVAL;

 	ret = wilco_ec_set_adv_charging_enable(ec, enable);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 static struct device_attribute dev_attr_advanced_charging_enable =
 		__ATTR(enable, 0644,
 		       advanced_charging_enable_show,
 		       advanced_charging_enable_store);

 static ssize_t
 peak_shift_battery_threshold_show(struct device *dev,
 				  struct device_attribute *attr, char *buf)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	int ret, val;

 	ret = wilco_ec_get_peak_shift_battery_threshold(ec, &val);
 	if (ret < 0)
 		return ret;

 	return snprintf(buf, PAGE_SIZE, "%d\n", val);
 }

 static ssize_t
 peak_shift_battery_threshold_store(struct device *dev,
 				   struct device_attribute *attr,
 				   const char *buf, size_t count)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	int ret, val;

 	if (kstrtoint(buf, 10, &val) < 0)
 		return -EINVAL;

 	ret = wilco_ec_set_peak_shift_battery_threshold(ec, val);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 struct device_attribute dev_attr_peak_shift_battery_threshold =
 		__ATTR(battery_threshold, 0644,
 		       peak_shift_battery_threshold_show,
 		       peak_shift_battery_threshold_store);

 struct wilco_schedule_attribute {
 	struct device_attribute dev_attr;
 	int day_of_week;	/* 0==Sunday, 1==Monday, ... */
 };

 #define to_wilco_schedule_attr(_dev_attr) \
 	container_of(_dev_attr, struct wilco_schedule_attribute, dev_attr)

 static ssize_t advanced_charging_schedule_show(struct device *dev,
 					       struct device_attribute *attr,
 					       char *buf)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	struct wilco_schedule_attribute *wsa;
 	struct adv_charge_schedule sched;
 	int ret;

 	wsa = to_wilco_schedule_attr(attr);
 	sched.day_of_week = wsa->day_of_week;
 	ret = wilco_ec_get_adv_charge_schedule(ec, &sched);
 	if (ret < 0)
 		return ret;

 	return snprintf(buf, PAGE_SIZE, "%02d:%02d %02d:%02d\n",
 			sched.start_hour, sched.start_minute,
 			sched.duration_hour, sched.duration_minute);
 }

 static ssize_t advanced_charging_schedule_store(struct device *dev,
 						struct device_attribute *attr,
 						const char *buf, size_t count)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	struct wilco_schedule_attribute *wsa;
 	struct adv_charge_schedule sched;
 	int ret;

 	ret = sscanf(buf, "%d:%d %d:%d",
 		     &sched.start_hour, &sched.start_minute,
 		     &sched.duration_hour, &sched.duration_minute);
 	if (ret != 4)
 		return -EINVAL;

 	wsa = to_wilco_schedule_attr(attr);
 	sched.day_of_week = wsa->day_of_week;
 	ret = wilco_ec_set_adv_charge_schedule(ec, &sched);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 #define ADVANCED_CHARGING_SCHED_ATTR(_name, _day_of_week)		\
 	struct wilco_schedule_attribute adv_charging_sched_attr_##_name = { \
 		.dev_attr = __ATTR(_name, 0644,				\
 				   advanced_charging_schedule_show,	\
 				   advanced_charging_schedule_store),	\
 		.day_of_week = _day_of_week				\
 	}

 static ADVANCED_CHARGING_SCHED_ATTR(sunday, 0);
 static ADVANCED_CHARGING_SCHED_ATTR(monday, 1);
 static ADVANCED_CHARGING_SCHED_ATTR(tuesday, 2);
 static ADVANCED_CHARGING_SCHED_ATTR(wednesday, 3);
 static ADVANCED_CHARGING_SCHED_ATTR(thursday, 4);
 static ADVANCED_CHARGING_SCHED_ATTR(friday, 5);
 static ADVANCED_CHARGING_SCHED_ATTR(saturday, 6);

 static struct attribute *wilco_advanced_charging_attrs[] = {
 	&dev_attr_advanced_charging_enable.attr,
 	&adv_charging_sched_attr_sunday.dev_attr.attr,
 	&adv_charging_sched_attr_monday.dev_attr.attr,
 	&adv_charging_sched_attr_tuesday.dev_attr.attr,
 	&adv_charging_sched_attr_wednesday.dev_attr.attr,
 	&adv_charging_sched_attr_thursday.dev_attr.attr,
 	&adv_charging_sched_attr_friday.dev_attr.attr,
 	&adv_charging_sched_attr_saturday.dev_attr.attr,
 	NULL,
 };

 static struct attribute_group wilco_advanced_charging_attr_group = {
 	.name = "advanced_charging",
 	.attrs = wilco_advanced_charging_attrs,
 };

 static ssize_t peak_shift_schedule_show(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	struct wilco_schedule_attribute *wsa;
 	struct peak_shift_schedule sched;
 	int ret;

 	wsa = to_wilco_schedule_attr(attr);
 	sched.day_of_week = wsa->day_of_week;
 	ret = wilco_ec_get_peak_shift_schedule(ec, &sched);
 	if (ret < 0)
 		return ret;

 	return snprintf(buf, PAGE_SIZE, "%02d:%02d %02d:%02d %02d:%02d\n",
 			sched.start_hour, sched.start_minute,
 			sched.end_hour, sched.end_minute,
 			sched.charge_start_hour, sched.charge_start_minute);
 }

 static ssize_t peak_shift_schedule_store(struct device *dev,
 					 struct device_attribute *attr,
 					 const char *buf, size_t count)
 {
 	struct wilco_ec_device *ec = dev_get_platdata(dev);
 	struct wilco_schedule_attribute *wsa;
 	struct peak_shift_schedule sched;
 	int ret;

 	ret = sscanf(buf, "%d:%d %d:%d %d:%d",
 		     &sched.start_hour, &sched.start_minute,
 		     &sched.end_hour, &sched.end_minute,
 		     &sched.charge_start_hour, &sched.charge_start_minute);
 	if (ret != 6)
 		return -EINVAL;

 	wsa = to_wilco_schedule_attr(attr);
 	sched.day_of_week = wsa->day_of_week;
 	ret = wilco_ec_set_peak_shift_schedule(ec, &sched);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 #define PEAK_SHIFT_SCHED_ATTR(_name, _day_of_week)			\
 	struct wilco_schedule_attribute peak_shift_sched_attr_##_name = { \
 		.dev_attr = __ATTR(_name, 0644,				\
 				   peak_shift_schedule_show,		\
 				   peak_shift_schedule_store),		\
 		.day_of_week = _day_of_week				\
 	}

 static PEAK_SHIFT_SCHED_ATTR(sunday, 0);
 static PEAK_SHIFT_SCHED_ATTR(monday, 1);
 static PEAK_SHIFT_SCHED_ATTR(tuesday, 2);
 static PEAK_SHIFT_SCHED_ATTR(wednesday, 3);
 static PEAK_SHIFT_SCHED_ATTR(thursday, 4);
 static PEAK_SHIFT_SCHED_ATTR(friday, 5);
 static PEAK_SHIFT_SCHED_ATTR(saturday, 6);

 static struct attribute *wilco_peak_shift_attrs[] = {
 	&dev_attr_peak_shift_enable.attr,
 	&dev_attr_peak_shift_battery_threshold.attr,
 	&peak_shift_sched_attr_sunday.dev_attr.attr,
 	&peak_shift_sched_attr_monday.dev_attr.attr,
 	&peak_shift_sched_attr_tuesday.dev_attr.attr,
 	&peak_shift_sched_attr_wednesday.dev_attr.attr,
 	&peak_shift_sched_attr_thursday.dev_attr.attr,
 	&peak_shift_sched_attr_friday.dev_attr.attr,
 	&peak_shift_sched_attr_saturday.dev_attr.attr,
 	NULL,
 };

 static struct attribute_group wilco_peak_shift_attr_group = {
 	.name = "peak_shift",
 	.attrs = wilco_peak_shift_attrs,
 };

 static const struct attribute_group *wilco_charge_schedule_attr_groups[] = {
 	&wilco_advanced_charging_attr_group,
 	&wilco_peak_shift_attr_group,
 	NULL
 };

 static int wilco_charge_schedule_probe(struct platform_device *pdev)
 {
 	return devm_device_add_groups(&pdev->dev,
 				      wilco_charge_schedule_attr_groups);
 }

 static struct platform_driver wilco_charge_schedule_driver = {
 	.probe	= wilco_charge_schedule_probe,
 	.driver = {
 		.name = DRV_NAME,
 	}
 };
 module_platform_driver(wilco_charge_schedule_driver);

 MODULE_ALIAS("platform:" DRV_NAME);
 MODULE_AUTHOR("Nick Crews <ncrews@chromium.org>");
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("Wilco EC charge scheduling driver");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Sysfs interface for Peak Shift and Advanced Battery Charging schedules.
	*
	* Copyright 2019 Google LLC
	*
	* See Documentation/ABI/testing/sysfs-platform-wilco-ec for more info.
	*/

	#include <linux/device.h>
	#include <linux/module.h>
	#include <linux/platform_data/wilco-ec.h>
	#include <linux/platform_device.h>
	#include <linux/string.h>
	#include <linux/sysfs.h>

	#include "charge_schedule.h"

	#define DRV_NAME "wilco-charge-schedule"

	static ssize_t peak_shift_enable_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	bool enabled;
	int ret;

	ret = wilco_ec_get_peak_shift_enable(ec, &enabled);
	if (ret < 0)
	return ret;

	return snprintf(buf, PAGE_SIZE, "%d\n", enabled);
	}

	static ssize_t peak_shift_enable_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	bool enable;
	int ret;

	if (strtobool(buf, &enable) < 0)
	return -EINVAL;

	ret = wilco_ec_set_peak_shift_enable(ec, enable);
	if (ret < 0)
	return ret;

	return count;
	}

	static struct device_attribute dev_attr_peak_shift_enable =
	__ATTR(enable, 0644,
	peak_shift_enable_show, peak_shift_enable_store);

	static ssize_t advanced_charging_enable_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	bool enabled;
	int ret;

	ret = wilco_ec_get_adv_charging_enable(ec, &enabled);
	if (ret < 0)
	return ret;

	return snprintf(buf, PAGE_SIZE, "%d\n", enabled);
	}
	static ssize_t advanced_charging_enable_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	bool enable;
	int ret;

	if (strtobool(buf, &enable) < 0)
	return -EINVAL;

	ret = wilco_ec_set_adv_charging_enable(ec, enable);
	if (ret < 0)
	return ret;

	return count;
	}

	static struct device_attribute dev_attr_advanced_charging_enable =
	__ATTR(enable, 0644,
	advanced_charging_enable_show,
	advanced_charging_enable_store);

	static ssize_t
	peak_shift_battery_threshold_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	int ret, val;

	ret = wilco_ec_get_peak_shift_battery_threshold(ec, &val);
	if (ret < 0)
	return ret;

	return snprintf(buf, PAGE_SIZE, "%d\n", val);
	}

	static ssize_t
	peak_shift_battery_threshold_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	int ret, val;

	if (kstrtoint(buf, 10, &val) < 0)
	return -EINVAL;

	ret = wilco_ec_set_peak_shift_battery_threshold(ec, val);
	if (ret < 0)
	return ret;

	return count;
	}

	struct device_attribute dev_attr_peak_shift_battery_threshold =
	__ATTR(battery_threshold, 0644,
	peak_shift_battery_threshold_show,
	peak_shift_battery_threshold_store);

	struct wilco_schedule_attribute {
	struct device_attribute dev_attr;
	int day_of_week; /* 0==Sunday, 1==Monday, ... */
	};

	#define to_wilco_schedule_attr(_dev_attr) \
	container_of(_dev_attr, struct wilco_schedule_attribute, dev_attr)

	static ssize_t advanced_charging_schedule_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	struct wilco_schedule_attribute *wsa;
	struct adv_charge_schedule sched;
	int ret;

	wsa = to_wilco_schedule_attr(attr);
	sched.day_of_week = wsa->day_of_week;
	ret = wilco_ec_get_adv_charge_schedule(ec, &sched);
	if (ret < 0)
	return ret;

	return snprintf(buf, PAGE_SIZE, "%02d:%02d %02d:%02d\n",
	sched.start_hour, sched.start_minute,
	sched.duration_hour, sched.duration_minute);
	}

	static ssize_t advanced_charging_schedule_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	struct wilco_schedule_attribute *wsa;
	struct adv_charge_schedule sched;
	int ret;

	ret = sscanf(buf, "%d:%d %d:%d",
	&sched.start_hour, &sched.start_minute,
	&sched.duration_hour, &sched.duration_minute);
	if (ret != 4)
	return -EINVAL;

	wsa = to_wilco_schedule_attr(attr);
	sched.day_of_week = wsa->day_of_week;
	ret = wilco_ec_set_adv_charge_schedule(ec, &sched);
	if (ret < 0)
	return ret;

	return count;
	}

	#define ADVANCED_CHARGING_SCHED_ATTR(_name, _day_of_week) \
	struct wilco_schedule_attribute adv_charging_sched_attr_##_name = { \
	.dev_attr = __ATTR(_name, 0644, \
	advanced_charging_schedule_show, \
	advanced_charging_schedule_store), \
	.day_of_week = _day_of_week \
	}

	static ADVANCED_CHARGING_SCHED_ATTR(sunday, 0);
	static ADVANCED_CHARGING_SCHED_ATTR(monday, 1);
	static ADVANCED_CHARGING_SCHED_ATTR(tuesday, 2);
	static ADVANCED_CHARGING_SCHED_ATTR(wednesday, 3);
	static ADVANCED_CHARGING_SCHED_ATTR(thursday, 4);
	static ADVANCED_CHARGING_SCHED_ATTR(friday, 5);
	static ADVANCED_CHARGING_SCHED_ATTR(saturday, 6);

	static struct attribute *wilco_advanced_charging_attrs[] = {
	&dev_attr_advanced_charging_enable.attr,
	&adv_charging_sched_attr_sunday.dev_attr.attr,
	&adv_charging_sched_attr_monday.dev_attr.attr,
	&adv_charging_sched_attr_tuesday.dev_attr.attr,
	&adv_charging_sched_attr_wednesday.dev_attr.attr,
	&adv_charging_sched_attr_thursday.dev_attr.attr,
	&adv_charging_sched_attr_friday.dev_attr.attr,
	&adv_charging_sched_attr_saturday.dev_attr.attr,
	NULL,
	};

	static struct attribute_group wilco_advanced_charging_attr_group = {
	.name = "advanced_charging",
	.attrs = wilco_advanced_charging_attrs,
	};

	static ssize_t peak_shift_schedule_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	struct wilco_schedule_attribute *wsa;
	struct peak_shift_schedule sched;
	int ret;

	wsa = to_wilco_schedule_attr(attr);
	sched.day_of_week = wsa->day_of_week;
	ret = wilco_ec_get_peak_shift_schedule(ec, &sched);
	if (ret < 0)
	return ret;

	return snprintf(buf, PAGE_SIZE, "%02d:%02d %02d:%02d %02d:%02d\n",
	sched.start_hour, sched.start_minute,
	sched.end_hour, sched.end_minute,
	sched.charge_start_hour, sched.charge_start_minute);
	}

	static ssize_t peak_shift_schedule_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct wilco_ec_device *ec = dev_get_platdata(dev);
	struct wilco_schedule_attribute *wsa;
	struct peak_shift_schedule sched;
	int ret;

	ret = sscanf(buf, "%d:%d %d:%d %d:%d",
	&sched.start_hour, &sched.start_minute,
	&sched.end_hour, &sched.end_minute,
	&sched.charge_start_hour, &sched.charge_start_minute);
	if (ret != 6)
	return -EINVAL;

	wsa = to_wilco_schedule_attr(attr);
	sched.day_of_week = wsa->day_of_week;
	ret = wilco_ec_set_peak_shift_schedule(ec, &sched);
	if (ret < 0)
	return ret;

	return count;
	}

	#define PEAK_SHIFT_SCHED_ATTR(_name, _day_of_week) \
	struct wilco_schedule_attribute peak_shift_sched_attr_##_name = { \
	.dev_attr = __ATTR(_name, 0644, \
	peak_shift_schedule_show, \
	peak_shift_schedule_store), \
	.day_of_week = _day_of_week \
	}

	static PEAK_SHIFT_SCHED_ATTR(sunday, 0);
	static PEAK_SHIFT_SCHED_ATTR(monday, 1);
	static PEAK_SHIFT_SCHED_ATTR(tuesday, 2);
	static PEAK_SHIFT_SCHED_ATTR(wednesday, 3);
	static PEAK_SHIFT_SCHED_ATTR(thursday, 4);
	static PEAK_SHIFT_SCHED_ATTR(friday, 5);
	static PEAK_SHIFT_SCHED_ATTR(saturday, 6);

	static struct attribute *wilco_peak_shift_attrs[] = {
	&dev_attr_peak_shift_enable.attr,
	&dev_attr_peak_shift_battery_threshold.attr,
	&peak_shift_sched_attr_sunday.dev_attr.attr,
	&peak_shift_sched_attr_monday.dev_attr.attr,
	&peak_shift_sched_attr_tuesday.dev_attr.attr,
	&peak_shift_sched_attr_wednesday.dev_attr.attr,
	&peak_shift_sched_attr_thursday.dev_attr.attr,
	&peak_shift_sched_attr_friday.dev_attr.attr,
	&peak_shift_sched_attr_saturday.dev_attr.attr,
	NULL,
	};

	static struct attribute_group wilco_peak_shift_attr_group = {
	.name = "peak_shift",
	.attrs = wilco_peak_shift_attrs,
	};

	static const struct attribute_group *wilco_charge_schedule_attr_groups[] = {
	&wilco_advanced_charging_attr_group,
	&wilco_peak_shift_attr_group,
	NULL
	};

	static int wilco_charge_schedule_probe(struct platform_device *pdev)
	{
	return devm_device_add_groups(&pdev->dev,
	wilco_charge_schedule_attr_groups);
	}

	static struct platform_driver wilco_charge_schedule_driver = {
	.probe = wilco_charge_schedule_probe,
	.driver = {
	.name = DRV_NAME,
	}
	};
	module_platform_driver(wilco_charge_schedule_driver);

	MODULE_ALIAS("platform:" DRV_NAME);
	MODULE_AUTHOR("Nick Crews <ncrews@chromium.org>");
	MODULE_LICENSE("GPL v2");
	MODULE_DESCRIPTION("Wilco EC charge scheduling driver");