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