xref: /openbmc/linux/drivers/mfd/cros_ec_dev.c (revision 556c2420)
1 /*
2  * cros_ec_dev - expose the Chrome OS Embedded Controller to user-space
3  *
4  * Copyright (C) 2014 Google, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include <linux/fs.h>
21 #include <linux/mfd/core.h>
22 #include <linux/module.h>
23 #include <linux/platform_device.h>
24 #include <linux/pm.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 
28 #include "cros_ec_dev.h"
29 
30 #define DRV_NAME "cros-ec-dev"
31 
32 /* Device variables */
33 #define CROS_MAX_DEV 128
34 static int ec_major;
35 
36 static const struct attribute_group *cros_ec_groups[] = {
37 	&cros_ec_attr_group,
38 	&cros_ec_lightbar_attr_group,
39 	&cros_ec_vbc_attr_group,
40 	NULL,
41 };
42 
43 static struct class cros_class = {
44 	.owner          = THIS_MODULE,
45 	.name           = "chromeos",
46 	.dev_groups     = cros_ec_groups,
47 };
48 
49 /* Basic communication */
50 static int ec_get_version(struct cros_ec_dev *ec, char *str, int maxlen)
51 {
52 	struct ec_response_get_version *resp;
53 	static const char * const current_image_name[] = {
54 		"unknown", "read-only", "read-write", "invalid",
55 	};
56 	struct cros_ec_command *msg;
57 	int ret;
58 
59 	msg = kmalloc(sizeof(*msg) + sizeof(*resp), GFP_KERNEL);
60 	if (!msg)
61 		return -ENOMEM;
62 
63 	msg->version = 0;
64 	msg->command = EC_CMD_GET_VERSION + ec->cmd_offset;
65 	msg->insize = sizeof(*resp);
66 	msg->outsize = 0;
67 
68 	ret = cros_ec_cmd_xfer(ec->ec_dev, msg);
69 	if (ret < 0)
70 		goto exit;
71 
72 	if (msg->result != EC_RES_SUCCESS) {
73 		snprintf(str, maxlen,
74 			 "%s\nUnknown EC version: EC returned %d\n",
75 			 CROS_EC_DEV_VERSION, msg->result);
76 		ret = -EINVAL;
77 		goto exit;
78 	}
79 
80 	resp = (struct ec_response_get_version *)msg->data;
81 	if (resp->current_image >= ARRAY_SIZE(current_image_name))
82 		resp->current_image = 3; /* invalid */
83 
84 	snprintf(str, maxlen, "%s\n%s\n%s\n%s\n", CROS_EC_DEV_VERSION,
85 		 resp->version_string_ro, resp->version_string_rw,
86 		 current_image_name[resp->current_image]);
87 
88 	ret = 0;
89 exit:
90 	kfree(msg);
91 	return ret;
92 }
93 
94 static int cros_ec_check_features(struct cros_ec_dev *ec, int feature)
95 {
96 	struct cros_ec_command *msg;
97 	int ret;
98 
99 	if (ec->features[0] == -1U && ec->features[1] == -1U) {
100 		/* features bitmap not read yet */
101 
102 		msg = kmalloc(sizeof(*msg) + sizeof(ec->features), GFP_KERNEL);
103 		if (!msg)
104 			return -ENOMEM;
105 
106 		msg->version = 0;
107 		msg->command = EC_CMD_GET_FEATURES + ec->cmd_offset;
108 		msg->insize = sizeof(ec->features);
109 		msg->outsize = 0;
110 
111 		ret = cros_ec_cmd_xfer(ec->ec_dev, msg);
112 		if (ret < 0 || msg->result != EC_RES_SUCCESS) {
113 			dev_warn(ec->dev, "cannot get EC features: %d/%d\n",
114 				 ret, msg->result);
115 			memset(ec->features, 0, sizeof(ec->features));
116 		} else {
117 			memcpy(ec->features, msg->data, sizeof(ec->features));
118 		}
119 
120 		dev_dbg(ec->dev, "EC features %08x %08x\n",
121 			ec->features[0], ec->features[1]);
122 
123 		kfree(msg);
124 	}
125 
126 	return ec->features[feature / 32] & EC_FEATURE_MASK_0(feature);
127 }
128 
129 /* Device file ops */
130 static int ec_device_open(struct inode *inode, struct file *filp)
131 {
132 	struct cros_ec_dev *ec = container_of(inode->i_cdev,
133 					      struct cros_ec_dev, cdev);
134 	filp->private_data = ec;
135 	nonseekable_open(inode, filp);
136 	return 0;
137 }
138 
139 static int ec_device_release(struct inode *inode, struct file *filp)
140 {
141 	return 0;
142 }
143 
144 static ssize_t ec_device_read(struct file *filp, char __user *buffer,
145 			      size_t length, loff_t *offset)
146 {
147 	struct cros_ec_dev *ec = filp->private_data;
148 	char msg[sizeof(struct ec_response_get_version) +
149 		 sizeof(CROS_EC_DEV_VERSION)];
150 	size_t count;
151 	int ret;
152 
153 	if (*offset != 0)
154 		return 0;
155 
156 	ret = ec_get_version(ec, msg, sizeof(msg));
157 	if (ret)
158 		return ret;
159 
160 	count = min(length, strlen(msg));
161 
162 	if (copy_to_user(buffer, msg, count))
163 		return -EFAULT;
164 
165 	*offset = count;
166 	return count;
167 }
168 
169 /* Ioctls */
170 static long ec_device_ioctl_xcmd(struct cros_ec_dev *ec, void __user *arg)
171 {
172 	long ret;
173 	struct cros_ec_command u_cmd;
174 	struct cros_ec_command *s_cmd;
175 
176 	if (copy_from_user(&u_cmd, arg, sizeof(u_cmd)))
177 		return -EFAULT;
178 
179 	if ((u_cmd.outsize > EC_MAX_MSG_BYTES) ||
180 	    (u_cmd.insize > EC_MAX_MSG_BYTES))
181 		return -EINVAL;
182 
183 	s_cmd = kmalloc(sizeof(*s_cmd) + max(u_cmd.outsize, u_cmd.insize),
184 			GFP_KERNEL);
185 	if (!s_cmd)
186 		return -ENOMEM;
187 
188 	if (copy_from_user(s_cmd, arg, sizeof(*s_cmd) + u_cmd.outsize)) {
189 		ret = -EFAULT;
190 		goto exit;
191 	}
192 
193 	if (u_cmd.outsize != s_cmd->outsize ||
194 	    u_cmd.insize != s_cmd->insize) {
195 		ret = -EINVAL;
196 		goto exit;
197 	}
198 
199 	s_cmd->command += ec->cmd_offset;
200 	ret = cros_ec_cmd_xfer(ec->ec_dev, s_cmd);
201 	/* Only copy data to userland if data was received. */
202 	if (ret < 0)
203 		goto exit;
204 
205 	if (copy_to_user(arg, s_cmd, sizeof(*s_cmd) + s_cmd->insize))
206 		ret = -EFAULT;
207 exit:
208 	kfree(s_cmd);
209 	return ret;
210 }
211 
212 static long ec_device_ioctl_readmem(struct cros_ec_dev *ec, void __user *arg)
213 {
214 	struct cros_ec_device *ec_dev = ec->ec_dev;
215 	struct cros_ec_readmem s_mem = { };
216 	long num;
217 
218 	/* Not every platform supports direct reads */
219 	if (!ec_dev->cmd_readmem)
220 		return -ENOTTY;
221 
222 	if (copy_from_user(&s_mem, arg, sizeof(s_mem)))
223 		return -EFAULT;
224 
225 	num = ec_dev->cmd_readmem(ec_dev, s_mem.offset, s_mem.bytes,
226 				  s_mem.buffer);
227 	if (num <= 0)
228 		return num;
229 
230 	if (copy_to_user((void __user *)arg, &s_mem, sizeof(s_mem)))
231 		return -EFAULT;
232 
233 	return 0;
234 }
235 
236 static long ec_device_ioctl(struct file *filp, unsigned int cmd,
237 			    unsigned long arg)
238 {
239 	struct cros_ec_dev *ec = filp->private_data;
240 
241 	if (_IOC_TYPE(cmd) != CROS_EC_DEV_IOC)
242 		return -ENOTTY;
243 
244 	switch (cmd) {
245 	case CROS_EC_DEV_IOCXCMD:
246 		return ec_device_ioctl_xcmd(ec, (void __user *)arg);
247 	case CROS_EC_DEV_IOCRDMEM:
248 		return ec_device_ioctl_readmem(ec, (void __user *)arg);
249 	}
250 
251 	return -ENOTTY;
252 }
253 
254 /* Module initialization */
255 static const struct file_operations fops = {
256 	.open = ec_device_open,
257 	.release = ec_device_release,
258 	.read = ec_device_read,
259 	.unlocked_ioctl = ec_device_ioctl,
260 #ifdef CONFIG_COMPAT
261 	.compat_ioctl = ec_device_ioctl,
262 #endif
263 };
264 
265 static void cros_ec_sensors_register(struct cros_ec_dev *ec)
266 {
267 	/*
268 	 * Issue a command to get the number of sensor reported.
269 	 * Build an array of sensors driver and register them all.
270 	 */
271 	int ret, i, id, sensor_num;
272 	struct mfd_cell *sensor_cells;
273 	struct cros_ec_sensor_platform *sensor_platforms;
274 	int sensor_type[MOTIONSENSE_TYPE_MAX];
275 	struct ec_params_motion_sense *params;
276 	struct ec_response_motion_sense *resp;
277 	struct cros_ec_command *msg;
278 
279 	msg = kzalloc(sizeof(struct cros_ec_command) +
280 		      max(sizeof(*params), sizeof(*resp)), GFP_KERNEL);
281 	if (msg == NULL)
282 		return;
283 
284 	msg->version = 2;
285 	msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset;
286 	msg->outsize = sizeof(*params);
287 	msg->insize = sizeof(*resp);
288 
289 	params = (struct ec_params_motion_sense *)msg->data;
290 	params->cmd = MOTIONSENSE_CMD_DUMP;
291 
292 	ret = cros_ec_cmd_xfer(ec->ec_dev, msg);
293 	if (ret < 0 || msg->result != EC_RES_SUCCESS) {
294 		dev_warn(ec->dev, "cannot get EC sensor information: %d/%d\n",
295 			 ret, msg->result);
296 		goto error;
297 	}
298 
299 	resp = (struct ec_response_motion_sense *)msg->data;
300 	sensor_num = resp->dump.sensor_count;
301 	/* Allocate 1 extra sensors in FIFO are needed */
302 	sensor_cells = kzalloc(sizeof(struct mfd_cell) * (sensor_num + 1),
303 			       GFP_KERNEL);
304 	if (sensor_cells == NULL)
305 		goto error;
306 
307 	sensor_platforms = kzalloc(sizeof(struct cros_ec_sensor_platform) *
308 		  (sensor_num + 1), GFP_KERNEL);
309 	if (sensor_platforms == NULL)
310 		goto error_platforms;
311 
312 	memset(sensor_type, 0, sizeof(sensor_type));
313 	id = 0;
314 	for (i = 0; i < sensor_num; i++) {
315 		params->cmd = MOTIONSENSE_CMD_INFO;
316 		params->info.sensor_num = i;
317 		ret = cros_ec_cmd_xfer(ec->ec_dev, msg);
318 		if (ret < 0 || msg->result != EC_RES_SUCCESS) {
319 			dev_warn(ec->dev, "no info for EC sensor %d : %d/%d\n",
320 				 i, ret, msg->result);
321 			continue;
322 		}
323 		switch (resp->info.type) {
324 		case MOTIONSENSE_TYPE_ACCEL:
325 			sensor_cells[id].name = "cros-ec-accel";
326 			break;
327 		case MOTIONSENSE_TYPE_BARO:
328 			sensor_cells[id].name = "cros-ec-baro";
329 			break;
330 		case MOTIONSENSE_TYPE_GYRO:
331 			sensor_cells[id].name = "cros-ec-gyro";
332 			break;
333 		case MOTIONSENSE_TYPE_MAG:
334 			sensor_cells[id].name = "cros-ec-mag";
335 			break;
336 		case MOTIONSENSE_TYPE_PROX:
337 			sensor_cells[id].name = "cros-ec-prox";
338 			break;
339 		case MOTIONSENSE_TYPE_LIGHT:
340 			sensor_cells[id].name = "cros-ec-light";
341 			break;
342 		case MOTIONSENSE_TYPE_ACTIVITY:
343 			sensor_cells[id].name = "cros-ec-activity";
344 			break;
345 		default:
346 			dev_warn(ec->dev, "unknown type %d\n", resp->info.type);
347 			continue;
348 		}
349 		sensor_platforms[id].sensor_num = i;
350 		sensor_cells[id].id = sensor_type[resp->info.type];
351 		sensor_cells[id].platform_data = &sensor_platforms[id];
352 		sensor_cells[id].pdata_size =
353 			sizeof(struct cros_ec_sensor_platform);
354 
355 		sensor_type[resp->info.type]++;
356 		id++;
357 	}
358 
359 	if (sensor_type[MOTIONSENSE_TYPE_ACCEL] >= 2)
360 		ec->has_kb_wake_angle = true;
361 
362 	if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE_FIFO)) {
363 		sensor_cells[id].name = "cros-ec-ring";
364 		id++;
365 	}
366 
367 	ret = mfd_add_devices(ec->dev, 0, sensor_cells, id,
368 			      NULL, 0, NULL);
369 	if (ret)
370 		dev_err(ec->dev, "failed to add EC sensors\n");
371 
372 	kfree(sensor_platforms);
373 error_platforms:
374 	kfree(sensor_cells);
375 error:
376 	kfree(msg);
377 }
378 
379 static const struct mfd_cell cros_ec_rtc_cells[] = {
380 	{ .name = "cros-ec-rtc" }
381 };
382 
383 static int ec_device_probe(struct platform_device *pdev)
384 {
385 	int retval = -ENOMEM;
386 	struct device *dev = &pdev->dev;
387 	struct cros_ec_platform *ec_platform = dev_get_platdata(dev);
388 	struct cros_ec_dev *ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL);
389 
390 	if (!ec)
391 		return retval;
392 
393 	dev_set_drvdata(dev, ec);
394 	ec->ec_dev = dev_get_drvdata(dev->parent);
395 	ec->dev = dev;
396 	ec->cmd_offset = ec_platform->cmd_offset;
397 	ec->features[0] = -1U; /* Not cached yet */
398 	ec->features[1] = -1U; /* Not cached yet */
399 	device_initialize(&ec->class_dev);
400 	cdev_init(&ec->cdev, &fops);
401 
402 	/*
403 	 * Add the class device
404 	 * Link to the character device for creating the /dev entry
405 	 * in devtmpfs.
406 	 */
407 	ec->class_dev.devt = MKDEV(ec_major, pdev->id);
408 	ec->class_dev.class = &cros_class;
409 	ec->class_dev.parent = dev;
410 
411 	retval = dev_set_name(&ec->class_dev, "%s", ec_platform->ec_name);
412 	if (retval) {
413 		dev_err(dev, "dev_set_name failed => %d\n", retval);
414 		goto failed;
415 	}
416 
417 	/* check whether this EC is a sensor hub. */
418 	if (cros_ec_check_features(ec, EC_FEATURE_MOTION_SENSE))
419 		cros_ec_sensors_register(ec);
420 
421 	/* Check whether this EC instance has RTC host command support */
422 	if (cros_ec_check_features(ec, EC_FEATURE_RTC)) {
423 		retval = mfd_add_devices(ec->dev, PLATFORM_DEVID_AUTO,
424 					 cros_ec_rtc_cells,
425 					 ARRAY_SIZE(cros_ec_rtc_cells),
426 					 NULL, 0, NULL);
427 		if (retval)
428 			dev_err(ec->dev,
429 				"failed to add cros-ec-rtc device: %d\n",
430 				retval);
431 	}
432 
433 	/* Take control of the lightbar from the EC. */
434 	lb_manual_suspend_ctrl(ec, 1);
435 
436 	/* We can now add the sysfs class, we know which parameter to show */
437 	retval = cdev_device_add(&ec->cdev, &ec->class_dev);
438 	if (retval) {
439 		dev_err(dev, "cdev_device_add failed => %d\n", retval);
440 		goto failed;
441 	}
442 
443 	if (cros_ec_debugfs_init(ec))
444 		dev_warn(dev, "failed to create debugfs directory\n");
445 
446 	return 0;
447 
448 failed:
449 	put_device(&ec->class_dev);
450 	return retval;
451 }
452 
453 static int ec_device_remove(struct platform_device *pdev)
454 {
455 	struct cros_ec_dev *ec = dev_get_drvdata(&pdev->dev);
456 
457 	/* Let the EC take over the lightbar again. */
458 	lb_manual_suspend_ctrl(ec, 0);
459 
460 	cros_ec_debugfs_remove(ec);
461 
462 	cdev_del(&ec->cdev);
463 	device_unregister(&ec->class_dev);
464 	return 0;
465 }
466 
467 static void ec_device_shutdown(struct platform_device *pdev)
468 {
469 	struct cros_ec_dev *ec = dev_get_drvdata(&pdev->dev);
470 
471 	/* Be sure to clear up debugfs delayed works */
472 	cros_ec_debugfs_remove(ec);
473 }
474 
475 static const struct platform_device_id cros_ec_id[] = {
476 	{ DRV_NAME, 0 },
477 	{ /* sentinel */ }
478 };
479 MODULE_DEVICE_TABLE(platform, cros_ec_id);
480 
481 static __maybe_unused int ec_device_suspend(struct device *dev)
482 {
483 	struct cros_ec_dev *ec = dev_get_drvdata(dev);
484 
485 	cros_ec_debugfs_suspend(ec);
486 
487 	lb_suspend(ec);
488 
489 	return 0;
490 }
491 
492 static __maybe_unused int ec_device_resume(struct device *dev)
493 {
494 	struct cros_ec_dev *ec = dev_get_drvdata(dev);
495 
496 	cros_ec_debugfs_resume(ec);
497 
498 	lb_resume(ec);
499 
500 	return 0;
501 }
502 
503 static const struct dev_pm_ops cros_ec_dev_pm_ops = {
504 #ifdef CONFIG_PM_SLEEP
505 	.suspend = ec_device_suspend,
506 	.resume = ec_device_resume,
507 #endif
508 };
509 
510 static struct platform_driver cros_ec_dev_driver = {
511 	.driver = {
512 		.name = DRV_NAME,
513 		.pm = &cros_ec_dev_pm_ops,
514 	},
515 	.probe = ec_device_probe,
516 	.remove = ec_device_remove,
517 	.shutdown = ec_device_shutdown,
518 };
519 
520 static int __init cros_ec_dev_init(void)
521 {
522 	int ret;
523 	dev_t dev = 0;
524 
525 	ret  = class_register(&cros_class);
526 	if (ret) {
527 		pr_err(CROS_EC_DEV_NAME ": failed to register device class\n");
528 		return ret;
529 	}
530 
531 	/* Get a range of minor numbers (starting with 0) to work with */
532 	ret = alloc_chrdev_region(&dev, 0, CROS_MAX_DEV, CROS_EC_DEV_NAME);
533 	if (ret < 0) {
534 		pr_err(CROS_EC_DEV_NAME ": alloc_chrdev_region() failed\n");
535 		goto failed_chrdevreg;
536 	}
537 	ec_major = MAJOR(dev);
538 
539 	/* Register the driver */
540 	ret = platform_driver_register(&cros_ec_dev_driver);
541 	if (ret < 0) {
542 		pr_warn(CROS_EC_DEV_NAME ": can't register driver: %d\n", ret);
543 		goto failed_devreg;
544 	}
545 	return 0;
546 
547 failed_devreg:
548 	unregister_chrdev_region(MKDEV(ec_major, 0), CROS_MAX_DEV);
549 failed_chrdevreg:
550 	class_unregister(&cros_class);
551 	return ret;
552 }
553 
554 static void __exit cros_ec_dev_exit(void)
555 {
556 	platform_driver_unregister(&cros_ec_dev_driver);
557 	unregister_chrdev(ec_major, CROS_EC_DEV_NAME);
558 	class_unregister(&cros_class);
559 }
560 
561 module_init(cros_ec_dev_init);
562 module_exit(cros_ec_dev_exit);
563 
564 MODULE_ALIAS("platform:" DRV_NAME);
565 MODULE_AUTHOR("Bill Richardson <wfrichar@chromium.org>");
566 MODULE_DESCRIPTION("Userspace interface to the Chrome OS Embedded Controller");
567 MODULE_VERSION("1.0");
568 MODULE_LICENSE("GPL");
569