Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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");