leds-cros_ec.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  ChromeOS EC LED Driver
  4 *
  5 *  Copyright (C) 2024 Thomas Weißschuh <linux@weissschuh.net>
  6 */
  7
  8#include <linux/device.h>
  9#include <linux/leds.h>
 10#include <linux/led-class-multicolor.h>
 11#include <linux/mod_devicetable.h>
 12#include <linux/module.h>
 13#include <linux/platform_device.h>
 14#include <linux/platform_data/cros_ec_commands.h>
 15#include <linux/platform_data/cros_ec_proto.h>
 16
 17static const char * const cros_ec_led_functions[] = {
 18	[EC_LED_ID_BATTERY_LED]            = LED_FUNCTION_CHARGING,
 19	[EC_LED_ID_POWER_LED]              = LED_FUNCTION_POWER,
 20	[EC_LED_ID_ADAPTER_LED]            = "adapter",
 21	[EC_LED_ID_LEFT_LED]               = "left",
 22	[EC_LED_ID_RIGHT_LED]              = "right",
 23	[EC_LED_ID_RECOVERY_HW_REINIT_LED] = "recovery-hw-reinit",
 24	[EC_LED_ID_SYSRQ_DEBUG_LED]        = "sysrq-debug",
 25};
 26
 27static_assert(ARRAY_SIZE(cros_ec_led_functions) == EC_LED_ID_COUNT);
 28
 29static const int cros_ec_led_to_linux_id[] = {
 30	[EC_LED_COLOR_RED]    = LED_COLOR_ID_RED,
 31	[EC_LED_COLOR_GREEN]  = LED_COLOR_ID_GREEN,
 32	[EC_LED_COLOR_BLUE]   = LED_COLOR_ID_BLUE,
 33	[EC_LED_COLOR_YELLOW] = LED_COLOR_ID_YELLOW,
 34	[EC_LED_COLOR_WHITE]  = LED_COLOR_ID_WHITE,
 35	[EC_LED_COLOR_AMBER]  = LED_COLOR_ID_AMBER,
 36};
 37
 38static_assert(ARRAY_SIZE(cros_ec_led_to_linux_id) == EC_LED_COLOR_COUNT);
 39
 40static const int cros_ec_linux_to_ec_id[] = {
 41	[LED_COLOR_ID_RED]    = EC_LED_COLOR_RED,
 42	[LED_COLOR_ID_GREEN]  = EC_LED_COLOR_GREEN,
 43	[LED_COLOR_ID_BLUE]   = EC_LED_COLOR_BLUE,
 44	[LED_COLOR_ID_YELLOW] = EC_LED_COLOR_YELLOW,
 45	[LED_COLOR_ID_WHITE]  = EC_LED_COLOR_WHITE,
 46	[LED_COLOR_ID_AMBER]  = EC_LED_COLOR_AMBER,
 47};
 48
 49struct cros_ec_led_priv {
 50	struct led_classdev_mc led_mc_cdev;
 51	struct cros_ec_device *cros_ec;
 52	enum ec_led_id led_id;
 53};
 54
 55static inline struct cros_ec_led_priv *cros_ec_led_cdev_to_priv(struct led_classdev *led_cdev)
 56{
 57	return container_of(lcdev_to_mccdev(led_cdev), struct cros_ec_led_priv, led_mc_cdev);
 58}
 59
 60union cros_ec_led_cmd_data {
 61	struct ec_params_led_control req;
 62	struct ec_response_led_control resp;
 63};
 64
 65static int cros_ec_led_send_cmd(struct cros_ec_device *cros_ec,
 66				union cros_ec_led_cmd_data *arg)
 67{
 68	int ret;
 69
 70	ret = cros_ec_cmd(cros_ec, 1, EC_CMD_LED_CONTROL, &arg->req,
 71			  sizeof(arg->req), &arg->resp, sizeof(arg->resp));
 72	if (ret < 0)
 73		return ret;
 74
 75	return 0;
 76}
 77
 78static int cros_ec_led_trigger_activate(struct led_classdev *led_cdev)
 79{
 80	struct cros_ec_led_priv *priv = cros_ec_led_cdev_to_priv(led_cdev);
 81	union cros_ec_led_cmd_data arg = {};
 82
 83	arg.req.led_id = priv->led_id;
 84	arg.req.flags = EC_LED_FLAGS_AUTO;
 85
 86	return cros_ec_led_send_cmd(priv->cros_ec, &arg);
 87}
 88
 89static struct led_hw_trigger_type cros_ec_led_trigger_type;
 90
 91static struct led_trigger cros_ec_led_trigger = {
 92	.name = "chromeos-auto",
 93	.trigger_type = &cros_ec_led_trigger_type,
 94	.activate = cros_ec_led_trigger_activate,
 95};
 96
 97static int cros_ec_led_brightness_set_blocking(struct led_classdev *led_cdev,
 98					       enum led_brightness brightness)
 99{
100	struct cros_ec_led_priv *priv = cros_ec_led_cdev_to_priv(led_cdev);
101	union cros_ec_led_cmd_data arg = {};
102	enum ec_led_colors led_color;
103	struct mc_subled *subled;
104	size_t i;
105
106	led_mc_calc_color_components(&priv->led_mc_cdev, brightness);
107
108	arg.req.led_id = priv->led_id;
109
110	for (i = 0; i < priv->led_mc_cdev.num_colors; i++) {
111		subled = &priv->led_mc_cdev.subled_info[i];
112		led_color = cros_ec_linux_to_ec_id[subled->color_index];
113		arg.req.brightness[led_color] = subled->brightness;
114	}
115
116	return cros_ec_led_send_cmd(priv->cros_ec, &arg);
117}
118
119static int cros_ec_led_count_subleds(struct device *dev,
120				     struct ec_response_led_control *resp,
121				     unsigned int *max_brightness)
122{
123	unsigned int range, common_range = 0;
124	int num_subleds = 0;
125	size_t i;
126
127	for (i = 0; i < EC_LED_COLOR_COUNT; i++) {
128		range = resp->brightness_range[i];
129
130		if (!range)
131			continue;
132
133		num_subleds++;
134
135		if (!common_range)
136			common_range = range;
137
138		if (common_range != range) {
139			/* The multicolor LED API expects a uniform max_brightness */
140			dev_err(dev, "Inconsistent LED brightness values\n");
141			return -EINVAL;
142		}
143	}
144
145	*max_brightness = common_range;
146	return num_subleds;
147}
148
149static const char *cros_ec_led_get_color_name(struct led_classdev_mc *led_mc_cdev)
150{
151	int color;
152
153	if (led_mc_cdev->num_colors == 1)
154		color = led_mc_cdev->subled_info[0].color_index;
155	else
156		color = LED_COLOR_ID_MULTI;
157
158	return led_get_color_name(color);
159}
160
161static int cros_ec_led_probe_one(struct device *dev, struct cros_ec_device *cros_ec,
162				 enum ec_led_id id)
163{
164	union cros_ec_led_cmd_data arg = {};
165	struct cros_ec_led_priv *priv;
166	struct led_classdev *led_cdev;
167	struct mc_subled *subleds;
168	int i, ret, num_subleds;
169	size_t subled;
170
171	arg.req.led_id = id;
172	arg.req.flags = EC_LED_FLAGS_QUERY;
173	ret = cros_ec_led_send_cmd(cros_ec, &arg);
174	if (ret == -EINVAL)
175		return 0; /* Unknown LED, skip */
176	if (ret == -EOPNOTSUPP)
177		return -ENODEV;
178	if (ret < 0)
179		return ret;
180
181	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
182	if (!priv)
183		return -ENOMEM;
184
185	num_subleds = cros_ec_led_count_subleds(dev, &arg.resp,
186						&priv->led_mc_cdev.led_cdev.max_brightness);
187	if (num_subleds < 0)
188		return num_subleds;
189	if (num_subleds == 0)
190		return 0; /* LED without any colors, skip */
191
192	priv->cros_ec = cros_ec;
193	priv->led_id = id;
194
195	subleds = devm_kcalloc(dev, num_subleds, sizeof(*subleds), GFP_KERNEL);
196	if (!subleds)
197		return -ENOMEM;
198
199	subled = 0;
200	for (i = 0; i < EC_LED_COLOR_COUNT; i++) {
201		if (!arg.resp.brightness_range[i])
202			continue;
203
204		subleds[subled].color_index = cros_ec_led_to_linux_id[i];
205		if (subled == 0)
206			subleds[subled].intensity = 100;
207		subled++;
208	}
209
210	priv->led_mc_cdev.subled_info = subleds;
211	priv->led_mc_cdev.num_colors = num_subleds;
212
213	led_cdev = &priv->led_mc_cdev.led_cdev;
214	led_cdev->brightness_set_blocking = cros_ec_led_brightness_set_blocking;
215	led_cdev->trigger_type = &cros_ec_led_trigger_type;
216	led_cdev->default_trigger = cros_ec_led_trigger.name;
217	led_cdev->hw_control_trigger = cros_ec_led_trigger.name;
218
219	led_cdev->name = devm_kasprintf(dev, GFP_KERNEL, "chromeos:%s:%s",
220					cros_ec_led_get_color_name(&priv->led_mc_cdev),
221					cros_ec_led_functions[id]);
222	if (!led_cdev->name)
223		return -ENOMEM;
224
225	return devm_led_classdev_multicolor_register(dev, &priv->led_mc_cdev);
226}
227
228static int cros_ec_led_probe(struct platform_device *pdev)
229{
230	struct device *dev = &pdev->dev;
231	struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent);
232	struct cros_ec_device *cros_ec = ec_dev->ec_dev;
233	int i, ret = 0;
234
235	ret = devm_led_trigger_register(dev, &cros_ec_led_trigger);
236	if (ret)
237		return ret;
238
239	for (i = 0; i < EC_LED_ID_COUNT; i++) {
240		ret = cros_ec_led_probe_one(dev, cros_ec, i);
241		if (ret)
242			break;
243	}
244
245	return ret;
246}
247
248static const struct platform_device_id cros_ec_led_id[] = {
249	{ "cros-ec-led", 0 },
250	{}
251};
252
253static struct platform_driver cros_ec_led_driver = {
254	.driver.name	= "cros-ec-led",
255	.probe		= cros_ec_led_probe,
256	.id_table	= cros_ec_led_id,
257};
258module_platform_driver(cros_ec_led_driver);
259
260MODULE_DEVICE_TABLE(platform, cros_ec_led_id);
261MODULE_DESCRIPTION("ChromeOS EC LED Driver");
262MODULE_AUTHOR("Thomas Weißschuh <linux@weissschuh.net");
263MODULE_LICENSE("GPL");