1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | // Expose the ChromeOS EC through sysfs |
3 | // |
4 | // Copyright (C) 2014 Google, Inc. |
5 | |
6 | #include <linux/ctype.h> |
7 | #include <linux/delay.h> |
8 | #include <linux/device.h> |
9 | #include <linux/fs.h> |
10 | #include <linux/kobject.h> |
11 | #include <linux/module.h> |
12 | #include <linux/platform_data/cros_ec_commands.h> |
13 | #include <linux/platform_data/cros_ec_proto.h> |
14 | #include <linux/platform_device.h> |
15 | #include <linux/printk.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/stat.h> |
18 | #include <linux/types.h> |
19 | #include <linux/uaccess.h> |
20 | |
21 | #define DRV_NAME "cros-ec-sysfs" |
22 | |
23 | /* Accessor functions */ |
24 | |
25 | static ssize_t reboot_show(struct device *dev, |
26 | struct device_attribute *attr, char *buf) |
27 | { |
28 | int count = 0; |
29 | |
30 | count += sysfs_emit_at(buf, at: count, |
31 | fmt: "ro|rw|cancel|cold|disable-jump|hibernate|cold-ap-off" ); |
32 | count += sysfs_emit_at(buf, at: count, fmt: " [at-shutdown]\n" ); |
33 | return count; |
34 | } |
35 | |
36 | static ssize_t reboot_store(struct device *dev, |
37 | struct device_attribute *attr, |
38 | const char *buf, size_t count) |
39 | { |
40 | static const struct { |
41 | const char * const str; |
42 | uint8_t cmd; |
43 | uint8_t flags; |
44 | } words[] = { |
45 | {"cancel" , EC_REBOOT_CANCEL, 0}, |
46 | {"ro" , EC_REBOOT_JUMP_RO, 0}, |
47 | {"rw" , EC_REBOOT_JUMP_RW, 0}, |
48 | {"cold-ap-off" , EC_REBOOT_COLD_AP_OFF, 0}, |
49 | {"cold" , EC_REBOOT_COLD, 0}, |
50 | {"disable-jump" , EC_REBOOT_DISABLE_JUMP, 0}, |
51 | {"hibernate" , EC_REBOOT_HIBERNATE, 0}, |
52 | {"at-shutdown" , -1, EC_REBOOT_FLAG_ON_AP_SHUTDOWN}, |
53 | }; |
54 | struct cros_ec_command *msg; |
55 | struct ec_params_reboot_ec *param; |
56 | int got_cmd = 0, offset = 0; |
57 | int i; |
58 | int ret; |
59 | struct cros_ec_dev *ec = to_cros_ec_dev(dev); |
60 | |
61 | msg = kmalloc(size: sizeof(*msg) + sizeof(*param), GFP_KERNEL); |
62 | if (!msg) |
63 | return -ENOMEM; |
64 | |
65 | param = (struct ec_params_reboot_ec *)msg->data; |
66 | |
67 | param->flags = 0; |
68 | while (1) { |
69 | /* Find word to start scanning */ |
70 | while (buf[offset] && isspace(buf[offset])) |
71 | offset++; |
72 | if (!buf[offset]) |
73 | break; |
74 | |
75 | for (i = 0; i < ARRAY_SIZE(words); i++) { |
76 | if (!strncasecmp(s1: words[i].str, s2: buf+offset, |
77 | strlen(words[i].str))) { |
78 | if (words[i].flags) { |
79 | param->flags |= words[i].flags; |
80 | } else { |
81 | param->cmd = words[i].cmd; |
82 | got_cmd = 1; |
83 | } |
84 | break; |
85 | } |
86 | } |
87 | |
88 | /* On to the next word, if any */ |
89 | while (buf[offset] && !isspace(buf[offset])) |
90 | offset++; |
91 | } |
92 | |
93 | if (!got_cmd) { |
94 | count = -EINVAL; |
95 | goto exit; |
96 | } |
97 | |
98 | msg->version = 0; |
99 | msg->command = EC_CMD_REBOOT_EC + ec->cmd_offset; |
100 | msg->outsize = sizeof(*param); |
101 | msg->insize = 0; |
102 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
103 | if (ret < 0) |
104 | count = ret; |
105 | exit: |
106 | kfree(objp: msg); |
107 | return count; |
108 | } |
109 | |
110 | static ssize_t version_show(struct device *dev, |
111 | struct device_attribute *attr, char *buf) |
112 | { |
113 | static const char * const image_names[] = {"unknown" , "RO" , "RW" }; |
114 | struct ec_response_get_version *r_ver; |
115 | struct ec_response_get_chip_info *r_chip; |
116 | struct ec_response_board_version *r_board; |
117 | struct cros_ec_command *msg; |
118 | int ret; |
119 | int count = 0; |
120 | struct cros_ec_dev *ec = to_cros_ec_dev(dev); |
121 | |
122 | msg = kmalloc(size: sizeof(*msg) + EC_HOST_PARAM_SIZE, GFP_KERNEL); |
123 | if (!msg) |
124 | return -ENOMEM; |
125 | |
126 | /* Get versions. RW may change. */ |
127 | msg->version = 0; |
128 | msg->command = EC_CMD_GET_VERSION + ec->cmd_offset; |
129 | msg->insize = sizeof(*r_ver); |
130 | msg->outsize = 0; |
131 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
132 | if (ret < 0) { |
133 | count = ret; |
134 | goto exit; |
135 | } |
136 | r_ver = (struct ec_response_get_version *)msg->data; |
137 | /* Strings should be null-terminated, but let's be sure. */ |
138 | r_ver->version_string_ro[sizeof(r_ver->version_string_ro) - 1] = '\0'; |
139 | r_ver->version_string_rw[sizeof(r_ver->version_string_rw) - 1] = '\0'; |
140 | count += sysfs_emit_at(buf, at: count, fmt: "RO version: %s\n" , r_ver->version_string_ro); |
141 | count += sysfs_emit_at(buf, at: count, fmt: "RW version: %s\n" , r_ver->version_string_rw); |
142 | count += sysfs_emit_at(buf, at: count, fmt: "Firmware copy: %s\n" , |
143 | (r_ver->current_image < ARRAY_SIZE(image_names) ? |
144 | image_names[r_ver->current_image] : "?" )); |
145 | |
146 | /* Get build info. */ |
147 | msg->command = EC_CMD_GET_BUILD_INFO + ec->cmd_offset; |
148 | msg->insize = EC_HOST_PARAM_SIZE; |
149 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
150 | if (ret < 0) { |
151 | count += sysfs_emit_at(buf, at: count, |
152 | fmt: "Build info: XFER / EC ERROR %d / %d\n" , |
153 | ret, msg->result); |
154 | } else { |
155 | msg->data[EC_HOST_PARAM_SIZE - 1] = '\0'; |
156 | count += sysfs_emit_at(buf, at: count, fmt: "Build info: %s\n" , msg->data); |
157 | } |
158 | |
159 | /* Get chip info. */ |
160 | msg->command = EC_CMD_GET_CHIP_INFO + ec->cmd_offset; |
161 | msg->insize = sizeof(*r_chip); |
162 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
163 | if (ret < 0) { |
164 | count += sysfs_emit_at(buf, at: count, |
165 | fmt: "Chip info: XFER / EC ERROR %d / %d\n" , |
166 | ret, msg->result); |
167 | } else { |
168 | r_chip = (struct ec_response_get_chip_info *)msg->data; |
169 | |
170 | r_chip->vendor[sizeof(r_chip->vendor) - 1] = '\0'; |
171 | r_chip->name[sizeof(r_chip->name) - 1] = '\0'; |
172 | r_chip->revision[sizeof(r_chip->revision) - 1] = '\0'; |
173 | count += sysfs_emit_at(buf, at: count, fmt: "Chip vendor: %s\n" , r_chip->vendor); |
174 | count += sysfs_emit_at(buf, at: count, fmt: "Chip name: %s\n" , r_chip->name); |
175 | count += sysfs_emit_at(buf, at: count, fmt: "Chip revision: %s\n" , r_chip->revision); |
176 | } |
177 | |
178 | /* Get board version */ |
179 | msg->command = EC_CMD_GET_BOARD_VERSION + ec->cmd_offset; |
180 | msg->insize = sizeof(*r_board); |
181 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
182 | if (ret < 0) { |
183 | count += sysfs_emit_at(buf, at: count, |
184 | fmt: "Board version: XFER / EC ERROR %d / %d\n" , |
185 | ret, msg->result); |
186 | } else { |
187 | r_board = (struct ec_response_board_version *)msg->data; |
188 | |
189 | count += sysfs_emit_at(buf, at: count, |
190 | fmt: "Board version: %d\n" , |
191 | r_board->board_version); |
192 | } |
193 | |
194 | exit: |
195 | kfree(objp: msg); |
196 | return count; |
197 | } |
198 | |
199 | static ssize_t flashinfo_show(struct device *dev, |
200 | struct device_attribute *attr, char *buf) |
201 | { |
202 | struct ec_response_flash_info *resp; |
203 | struct cros_ec_command *msg; |
204 | int ret; |
205 | struct cros_ec_dev *ec = to_cros_ec_dev(dev); |
206 | |
207 | msg = kmalloc(size: sizeof(*msg) + sizeof(*resp), GFP_KERNEL); |
208 | if (!msg) |
209 | return -ENOMEM; |
210 | |
211 | /* The flash info shouldn't ever change, but ask each time anyway. */ |
212 | msg->version = 0; |
213 | msg->command = EC_CMD_FLASH_INFO + ec->cmd_offset; |
214 | msg->insize = sizeof(*resp); |
215 | msg->outsize = 0; |
216 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
217 | if (ret < 0) |
218 | goto exit; |
219 | |
220 | resp = (struct ec_response_flash_info *)msg->data; |
221 | |
222 | ret = sysfs_emit(buf, |
223 | fmt: "FlashSize %d\nWriteSize %d\n" |
224 | "EraseSize %d\nProtectSize %d\n" , |
225 | resp->flash_size, resp->write_block_size, |
226 | resp->erase_block_size, resp->protect_block_size); |
227 | exit: |
228 | kfree(objp: msg); |
229 | return ret; |
230 | } |
231 | |
232 | /* Keyboard wake angle control */ |
233 | static ssize_t kb_wake_angle_show(struct device *dev, |
234 | struct device_attribute *attr, char *buf) |
235 | { |
236 | struct cros_ec_dev *ec = to_cros_ec_dev(dev); |
237 | struct ec_response_motion_sense *resp; |
238 | struct ec_params_motion_sense *param; |
239 | struct cros_ec_command *msg; |
240 | int ret; |
241 | |
242 | msg = kmalloc(size: sizeof(*msg) + EC_HOST_PARAM_SIZE, GFP_KERNEL); |
243 | if (!msg) |
244 | return -ENOMEM; |
245 | |
246 | param = (struct ec_params_motion_sense *)msg->data; |
247 | msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset; |
248 | msg->version = 2; |
249 | param->cmd = MOTIONSENSE_CMD_KB_WAKE_ANGLE; |
250 | param->kb_wake_angle.data = EC_MOTION_SENSE_NO_VALUE; |
251 | msg->outsize = sizeof(*param); |
252 | msg->insize = sizeof(*resp); |
253 | |
254 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
255 | if (ret < 0) |
256 | goto exit; |
257 | |
258 | resp = (struct ec_response_motion_sense *)msg->data; |
259 | ret = sysfs_emit(buf, fmt: "%d\n" , resp->kb_wake_angle.ret); |
260 | exit: |
261 | kfree(objp: msg); |
262 | return ret; |
263 | } |
264 | |
265 | static ssize_t kb_wake_angle_store(struct device *dev, |
266 | struct device_attribute *attr, |
267 | const char *buf, size_t count) |
268 | { |
269 | struct cros_ec_dev *ec = to_cros_ec_dev(dev); |
270 | struct ec_params_motion_sense *param; |
271 | struct cros_ec_command *msg; |
272 | u16 angle; |
273 | int ret; |
274 | |
275 | ret = kstrtou16(s: buf, base: 0, res: &angle); |
276 | if (ret) |
277 | return ret; |
278 | |
279 | msg = kmalloc(size: sizeof(*msg) + EC_HOST_PARAM_SIZE, GFP_KERNEL); |
280 | if (!msg) |
281 | return -ENOMEM; |
282 | |
283 | param = (struct ec_params_motion_sense *)msg->data; |
284 | msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset; |
285 | msg->version = 2; |
286 | param->cmd = MOTIONSENSE_CMD_KB_WAKE_ANGLE; |
287 | param->kb_wake_angle.data = angle; |
288 | msg->outsize = sizeof(*param); |
289 | msg->insize = sizeof(struct ec_response_motion_sense); |
290 | |
291 | ret = cros_ec_cmd_xfer_status(ec_dev: ec->ec_dev, msg); |
292 | kfree(objp: msg); |
293 | if (ret < 0) |
294 | return ret; |
295 | return count; |
296 | } |
297 | |
298 | /* Module initialization */ |
299 | |
300 | static DEVICE_ATTR_RW(reboot); |
301 | static DEVICE_ATTR_RO(version); |
302 | static DEVICE_ATTR_RO(flashinfo); |
303 | static DEVICE_ATTR_RW(kb_wake_angle); |
304 | |
305 | static struct attribute *__ec_attrs[] = { |
306 | &dev_attr_kb_wake_angle.attr, |
307 | &dev_attr_reboot.attr, |
308 | &dev_attr_version.attr, |
309 | &dev_attr_flashinfo.attr, |
310 | NULL, |
311 | }; |
312 | |
313 | static umode_t cros_ec_ctrl_visible(struct kobject *kobj, |
314 | struct attribute *a, int n) |
315 | { |
316 | struct device *dev = kobj_to_dev(kobj); |
317 | struct cros_ec_dev *ec = to_cros_ec_dev(dev); |
318 | |
319 | if (a == &dev_attr_kb_wake_angle.attr && !ec->has_kb_wake_angle) |
320 | return 0; |
321 | |
322 | return a->mode; |
323 | } |
324 | |
325 | static const struct attribute_group cros_ec_attr_group = { |
326 | .attrs = __ec_attrs, |
327 | .is_visible = cros_ec_ctrl_visible, |
328 | }; |
329 | |
330 | static int cros_ec_sysfs_probe(struct platform_device *pd) |
331 | { |
332 | struct cros_ec_dev *ec_dev = dev_get_drvdata(dev: pd->dev.parent); |
333 | struct device *dev = &pd->dev; |
334 | int ret; |
335 | |
336 | ret = sysfs_create_group(kobj: &ec_dev->class_dev.kobj, grp: &cros_ec_attr_group); |
337 | if (ret < 0) |
338 | dev_err(dev, "failed to create attributes. err=%d\n" , ret); |
339 | |
340 | return ret; |
341 | } |
342 | |
343 | static void cros_ec_sysfs_remove(struct platform_device *pd) |
344 | { |
345 | struct cros_ec_dev *ec_dev = dev_get_drvdata(dev: pd->dev.parent); |
346 | |
347 | sysfs_remove_group(kobj: &ec_dev->class_dev.kobj, grp: &cros_ec_attr_group); |
348 | } |
349 | |
350 | static struct platform_driver cros_ec_sysfs_driver = { |
351 | .driver = { |
352 | .name = DRV_NAME, |
353 | }, |
354 | .probe = cros_ec_sysfs_probe, |
355 | .remove_new = cros_ec_sysfs_remove, |
356 | }; |
357 | |
358 | module_platform_driver(cros_ec_sysfs_driver); |
359 | |
360 | MODULE_LICENSE("GPL" ); |
361 | MODULE_DESCRIPTION("Expose the ChromeOS EC through sysfs" ); |
362 | MODULE_ALIAS("platform:" DRV_NAME); |
363 | |