576 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * ACPI event handling for Wilco Embedded Controller4 *5 * Copyright 2019 Google LLC6 *7 * The Wilco Embedded Controller can create custom events that8 * are not handled as standard ACPI objects. These events can9 * contain information about changes in EC controlled features,10 * such as errors and events in the dock or display. For example,11 * an event is triggered if the dock is plugged into a display12 * incorrectly. These events are needed for telemetry and13 * diagnostics reasons, and for possibly alerting the user.14 15 * These events are triggered by the EC with an ACPI Notify(0x90),16 * and then the BIOS reads the event buffer from EC RAM via an17 * ACPI method. When the OS receives these events via ACPI,18 * it passes them along to this driver. The events are put into19 * a queue which can be read by a userspace daemon via a char device20 * that implements read() and poll(). The event queue acts as a21 * circular buffer of size 64, so if there are no userspace consumers22 * the kernel will not run out of memory. The char device will appear at23 * /dev/wilco_event{n}, where n is some small non-negative integer,24 * starting from 0. Standard ACPI events such as the battery getting25 * plugged/unplugged can also come through this path, but they are26 * dealt with via other paths, and are ignored here.27 28 * To test, you can tail the binary data with29 * $ cat /dev/wilco_event0 | hexdump -ve '1/1 "%x\n"'30 * and then create an event by plugging/unplugging the battery.31 */32 33#include <linux/acpi.h>34#include <linux/cdev.h>35#include <linux/device.h>36#include <linux/fs.h>37#include <linux/idr.h>38#include <linux/io.h>39#include <linux/list.h>40#include <linux/module.h>41#include <linux/poll.h>42#include <linux/spinlock.h>43#include <linux/uaccess.h>44#include <linux/wait.h>45 46/* ACPI Notify event code indicating event data is available. */47#define EC_ACPI_NOTIFY_EVENT 0x9048/* ACPI Method to execute to retrieve event data buffer from the EC. */49#define EC_ACPI_GET_EVENT "QSET"50/* Maximum number of words in event data returned by the EC. */51#define EC_ACPI_MAX_EVENT_WORDS 652#define EC_ACPI_MAX_EVENT_SIZE \53 (sizeof(struct ec_event) + (EC_ACPI_MAX_EVENT_WORDS) * sizeof(u16))54 55/* Node will appear in /dev/EVENT_DEV_NAME */56#define EVENT_DEV_NAME "wilco_event"57#define EVENT_CLASS_NAME EVENT_DEV_NAME58#define DRV_NAME EVENT_DEV_NAME59#define EVENT_DEV_NAME_FMT (EVENT_DEV_NAME "%d")60static struct class event_class = {61 .name = EVENT_CLASS_NAME,62};63 64/* Keep track of all the device numbers used. */65#define EVENT_MAX_DEV 12866static int event_major;67static DEFINE_IDA(event_ida);68 69/* Size of circular queue of events. */70#define MAX_NUM_EVENTS 6471 72/**73 * struct ec_event - Extended event returned by the EC.74 * @size: Number of 16bit words in structure after the size word.75 * @type: Extended event type, meaningless for us.76 * @event: Event data words. Max count is %EC_ACPI_MAX_EVENT_WORDS.77 */78struct ec_event {79 u16 size;80 u16 type;81 u16 event[];82} __packed;83 84#define ec_event_num_words(ev) (ev->size - 1)85#define ec_event_size(ev) (sizeof(*ev) + (ec_event_num_words(ev) * sizeof(u16)))86 87/**88 * struct ec_event_queue - Circular queue for events.89 * @capacity: Number of elements the queue can hold.90 * @head: Next index to write to.91 * @tail: Next index to read from.92 * @entries: Array of events.93 */94struct ec_event_queue {95 int capacity;96 int head;97 int tail;98 struct ec_event *entries[] __counted_by(capacity);99};100 101/* Maximum number of events to store in ec_event_queue */102static int queue_size = 64;103module_param(queue_size, int, 0644);104 105static struct ec_event_queue *event_queue_new(int capacity)106{107 struct ec_event_queue *q;108 109 q = kzalloc(struct_size(q, entries, capacity), GFP_KERNEL);110 if (!q)111 return NULL;112 113 q->capacity = capacity;114 115 return q;116}117 118static inline bool event_queue_empty(struct ec_event_queue *q)119{120 /* head==tail when both full and empty, but head==NULL when empty */121 return q->head == q->tail && !q->entries[q->head];122}123 124static inline bool event_queue_full(struct ec_event_queue *q)125{126 /* head==tail when both full and empty, but head!=NULL when full */127 return q->head == q->tail && q->entries[q->head];128}129 130static struct ec_event *event_queue_pop(struct ec_event_queue *q)131{132 struct ec_event *ev;133 134 if (event_queue_empty(q))135 return NULL;136 137 ev = q->entries[q->tail];138 q->entries[q->tail] = NULL;139 q->tail = (q->tail + 1) % q->capacity;140 141 return ev;142}143 144/*145 * If full, overwrite the oldest event and return it so the caller146 * can kfree it. If not full, return NULL.147 */148static struct ec_event *event_queue_push(struct ec_event_queue *q,149 struct ec_event *ev)150{151 struct ec_event *popped = NULL;152 153 if (event_queue_full(q))154 popped = event_queue_pop(q);155 q->entries[q->head] = ev;156 q->head = (q->head + 1) % q->capacity;157 158 return popped;159}160 161static void event_queue_free(struct ec_event_queue *q)162{163 struct ec_event *event;164 165 while ((event = event_queue_pop(q)) != NULL)166 kfree(event);167 168 kfree(q);169}170 171/**172 * struct event_device_data - Data for a Wilco EC device that responds to ACPI.173 * @events: Circular queue of EC events to be provided to userspace.174 * @queue_lock: Protect the queue from simultaneous read/writes.175 * @wq: Wait queue to notify processes when events are available or the176 * device has been removed.177 * @cdev: Char dev that userspace reads() and polls() from.178 * @dev: Device associated with the %cdev.179 * @exist: Has the device been not been removed? Once a device has been removed,180 * writes, reads, and new opens will fail.181 * @available: Guarantee only one client can open() file and read from queue.182 *183 * There will be one of these structs for each ACPI device registered. This data184 * is the queue of events received from ACPI that still need to be read from185 * userspace, the device and char device that userspace is using, a wait queue186 * used to notify different threads when something has changed, plus a flag187 * on whether the ACPI device has been removed.188 */189struct event_device_data {190 struct ec_event_queue *events;191 spinlock_t queue_lock;192 wait_queue_head_t wq;193 struct device dev;194 struct cdev cdev;195 bool exist;196 atomic_t available;197};198 199/**200 * enqueue_events() - Place EC events in queue to be read by userspace.201 * @adev: Device the events came from.202 * @buf: Buffer of event data.203 * @length: Length of event data buffer.204 *205 * %buf contains a number of ec_event's, packed one after the other.206 * Each ec_event is of variable length. Start with the first event, copy it207 * into a persistent ec_event, store that entry in the queue, move on208 * to the next ec_event in buf, and repeat.209 *210 * Return: 0 on success or negative error code on failure.211 */212static int enqueue_events(struct acpi_device *adev, const u8 *buf, u32 length)213{214 struct event_device_data *dev_data = adev->driver_data;215 struct ec_event *event, *queue_event, *old_event;216 size_t num_words, event_size;217 u32 offset = 0;218 219 while (offset < length) {220 event = (struct ec_event *)(buf + offset);221 222 num_words = ec_event_num_words(event);223 event_size = ec_event_size(event);224 if (num_words > EC_ACPI_MAX_EVENT_WORDS) {225 dev_err(&adev->dev, "Too many event words: %zu > %d\n",226 num_words, EC_ACPI_MAX_EVENT_WORDS);227 return -EOVERFLOW;228 }229 230 /* Ensure event does not overflow the available buffer */231 if ((offset + event_size) > length) {232 dev_err(&adev->dev, "Event exceeds buffer: %zu > %d\n",233 offset + event_size, length);234 return -EOVERFLOW;235 }236 237 /* Point to the next event in the buffer */238 offset += event_size;239 240 /* Copy event into the queue */241 queue_event = kmemdup(event, event_size, GFP_KERNEL);242 if (!queue_event)243 return -ENOMEM;244 spin_lock(&dev_data->queue_lock);245 old_event = event_queue_push(dev_data->events, queue_event);246 spin_unlock(&dev_data->queue_lock);247 kfree(old_event);248 wake_up_interruptible(&dev_data->wq);249 }250 251 return 0;252}253 254/**255 * event_device_notify() - Callback when EC generates an event over ACPI.256 * @adev: The device that the event is coming from.257 * @value: Value passed to Notify() in ACPI.258 *259 * This function will read the events from the device and enqueue them.260 */261static void event_device_notify(struct acpi_device *adev, u32 value)262{263 struct acpi_buffer event_buffer = { ACPI_ALLOCATE_BUFFER, NULL };264 union acpi_object *obj;265 acpi_status status;266 267 if (value != EC_ACPI_NOTIFY_EVENT) {268 dev_err(&adev->dev, "Invalid event: 0x%08x\n", value);269 return;270 }271 272 /* Execute ACPI method to get event data buffer. */273 status = acpi_evaluate_object(adev->handle, EC_ACPI_GET_EVENT,274 NULL, &event_buffer);275 if (ACPI_FAILURE(status)) {276 dev_err(&adev->dev, "Error executing ACPI method %s()\n",277 EC_ACPI_GET_EVENT);278 return;279 }280 281 obj = (union acpi_object *)event_buffer.pointer;282 if (!obj) {283 dev_err(&adev->dev, "Nothing returned from %s()\n",284 EC_ACPI_GET_EVENT);285 return;286 }287 if (obj->type != ACPI_TYPE_BUFFER) {288 dev_err(&adev->dev, "Invalid object returned from %s()\n",289 EC_ACPI_GET_EVENT);290 kfree(obj);291 return;292 }293 if (obj->buffer.length < sizeof(struct ec_event)) {294 dev_err(&adev->dev, "Invalid buffer length %d from %s()\n",295 obj->buffer.length, EC_ACPI_GET_EVENT);296 kfree(obj);297 return;298 }299 300 enqueue_events(adev, obj->buffer.pointer, obj->buffer.length);301 kfree(obj);302}303 304static int event_open(struct inode *inode, struct file *filp)305{306 struct event_device_data *dev_data;307 308 dev_data = container_of(inode->i_cdev, struct event_device_data, cdev);309 if (!dev_data->exist)310 return -ENODEV;311 312 if (atomic_cmpxchg(&dev_data->available, 1, 0) == 0)313 return -EBUSY;314 315 /* Increase refcount on device so dev_data is not freed */316 get_device(&dev_data->dev);317 stream_open(inode, filp);318 filp->private_data = dev_data;319 320 return 0;321}322 323static __poll_t event_poll(struct file *filp, poll_table *wait)324{325 struct event_device_data *dev_data = filp->private_data;326 __poll_t mask = 0;327 328 poll_wait(filp, &dev_data->wq, wait);329 if (!dev_data->exist)330 return EPOLLHUP;331 if (!event_queue_empty(dev_data->events))332 mask |= EPOLLIN | EPOLLRDNORM | EPOLLPRI;333 return mask;334}335 336/**337 * event_read() - Callback for passing event data to userspace via read().338 * @filp: The file we are reading from.339 * @buf: Pointer to userspace buffer to fill with one event.340 * @count: Number of bytes requested. Must be at least EC_ACPI_MAX_EVENT_SIZE.341 * @pos: File position pointer, irrelevant since we don't support seeking.342 *343 * Removes the first event from the queue, places it in the passed buffer.344 *345 * If there are no events in the queue, then one of two things happens,346 * depending on if the file was opened in nonblocking mode: If in nonblocking347 * mode, then return -EAGAIN to say there's no data. If in blocking mode, then348 * block until an event is available.349 *350 * Return: Number of bytes placed in buffer, negative error code on failure.351 */352static ssize_t event_read(struct file *filp, char __user *buf, size_t count,353 loff_t *pos)354{355 struct event_device_data *dev_data = filp->private_data;356 struct ec_event *event;357 ssize_t n_bytes_written = 0;358 int err;359 360 /* We only will give them the entire event at once */361 if (count != 0 && count < EC_ACPI_MAX_EVENT_SIZE)362 return -EINVAL;363 364 spin_lock(&dev_data->queue_lock);365 while (event_queue_empty(dev_data->events)) {366 spin_unlock(&dev_data->queue_lock);367 if (filp->f_flags & O_NONBLOCK)368 return -EAGAIN;369 370 err = wait_event_interruptible(dev_data->wq,371 !event_queue_empty(dev_data->events) ||372 !dev_data->exist);373 if (err)374 return err;375 376 /* Device was removed as we waited? */377 if (!dev_data->exist)378 return -ENODEV;379 spin_lock(&dev_data->queue_lock);380 }381 event = event_queue_pop(dev_data->events);382 spin_unlock(&dev_data->queue_lock);383 n_bytes_written = ec_event_size(event);384 if (copy_to_user(buf, event, n_bytes_written))385 n_bytes_written = -EFAULT;386 kfree(event);387 388 return n_bytes_written;389}390 391static int event_release(struct inode *inode, struct file *filp)392{393 struct event_device_data *dev_data = filp->private_data;394 395 atomic_set(&dev_data->available, 1);396 put_device(&dev_data->dev);397 398 return 0;399}400 401static const struct file_operations event_fops = {402 .open = event_open,403 .poll = event_poll,404 .read = event_read,405 .release = event_release,406 .owner = THIS_MODULE,407};408 409/**410 * free_device_data() - Callback to free the event_device_data structure.411 * @d: The device embedded in our device data, which we have been ref counting.412 *413 * This is called only after event_device_remove() has been called and all414 * userspace programs have called event_release() on all the open file415 * descriptors.416 */417static void free_device_data(struct device *d)418{419 struct event_device_data *dev_data;420 421 dev_data = container_of(d, struct event_device_data, dev);422 event_queue_free(dev_data->events);423 kfree(dev_data);424}425 426static void hangup_device(struct event_device_data *dev_data)427{428 dev_data->exist = false;429 /* Wake up the waiting processes so they can close. */430 wake_up_interruptible(&dev_data->wq);431 put_device(&dev_data->dev);432}433 434/**435 * event_device_add() - Callback when creating a new device.436 * @adev: ACPI device that we will be receiving events from.437 *438 * This finds a free minor number for the device, allocates and initializes439 * some device data, and creates a new device and char dev node.440 *441 * The device data is freed in free_device_data(), which is called when442 * %dev_data->dev is release()ed. This happens after all references to443 * %dev_data->dev are dropped, which happens once both event_device_remove()444 * has been called and every open()ed file descriptor has been release()ed.445 *446 * Return: 0 on success, negative error code on failure.447 */448static int event_device_add(struct acpi_device *adev)449{450 struct event_device_data *dev_data;451 int error, minor;452 453 minor = ida_alloc_max(&event_ida, EVENT_MAX_DEV-1, GFP_KERNEL);454 if (minor < 0) {455 error = minor;456 dev_err(&adev->dev, "Failed to find minor number: %d\n", error);457 return error;458 }459 460 dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL);461 if (!dev_data) {462 error = -ENOMEM;463 goto free_minor;464 }465 466 /* Initialize the device data. */467 adev->driver_data = dev_data;468 dev_data->events = event_queue_new(queue_size);469 if (!dev_data->events) {470 kfree(dev_data);471 error = -ENOMEM;472 goto free_minor;473 }474 spin_lock_init(&dev_data->queue_lock);475 init_waitqueue_head(&dev_data->wq);476 dev_data->exist = true;477 atomic_set(&dev_data->available, 1);478 479 /* Initialize the device. */480 dev_data->dev.devt = MKDEV(event_major, minor);481 dev_data->dev.class = &event_class;482 dev_data->dev.release = free_device_data;483 dev_set_name(&dev_data->dev, EVENT_DEV_NAME_FMT, minor);484 device_initialize(&dev_data->dev);485 486 /* Initialize the character device, and add it to userspace. */487 cdev_init(&dev_data->cdev, &event_fops);488 error = cdev_device_add(&dev_data->cdev, &dev_data->dev);489 if (error)490 goto free_dev_data;491 492 return 0;493 494free_dev_data:495 hangup_device(dev_data);496free_minor:497 ida_free(&event_ida, minor);498 return error;499}500 501static void event_device_remove(struct acpi_device *adev)502{503 struct event_device_data *dev_data = adev->driver_data;504 505 cdev_device_del(&dev_data->cdev, &dev_data->dev);506 ida_free(&event_ida, MINOR(dev_data->dev.devt));507 hangup_device(dev_data);508}509 510static const struct acpi_device_id event_acpi_ids[] = {511 { "GOOG000D", 0 },512 { }513};514MODULE_DEVICE_TABLE(acpi, event_acpi_ids);515 516static struct acpi_driver event_driver = {517 .name = DRV_NAME,518 .class = DRV_NAME,519 .ids = event_acpi_ids,520 .ops = {521 .add = event_device_add,522 .notify = event_device_notify,523 .remove = event_device_remove,524 },525};526 527static int __init event_module_init(void)528{529 dev_t dev_num = 0;530 int ret;531 532 ret = class_register(&event_class);533 if (ret) {534 pr_err(DRV_NAME ": Failed registering class: %d\n", ret);535 return ret;536 }537 538 /* Request device numbers, starting with minor=0. Save the major num. */539 ret = alloc_chrdev_region(&dev_num, 0, EVENT_MAX_DEV, EVENT_DEV_NAME);540 if (ret) {541 pr_err(DRV_NAME ": Failed allocating dev numbers: %d\n", ret);542 goto destroy_class;543 }544 event_major = MAJOR(dev_num);545 546 ret = acpi_bus_register_driver(&event_driver);547 if (ret < 0) {548 pr_err(DRV_NAME ": Failed registering driver: %d\n", ret);549 goto unregister_region;550 }551 552 return 0;553 554unregister_region:555 unregister_chrdev_region(MKDEV(event_major, 0), EVENT_MAX_DEV);556destroy_class:557 class_unregister(&event_class);558 ida_destroy(&event_ida);559 return ret;560}561 562static void __exit event_module_exit(void)563{564 acpi_bus_unregister_driver(&event_driver);565 unregister_chrdev_region(MKDEV(event_major, 0), EVENT_MAX_DEV);566 class_unregister(&event_class);567 ida_destroy(&event_ida);568}569 570module_init(event_module_init);571module_exit(event_module_exit);572 573MODULE_AUTHOR("Nick Crews <ncrews@chromium.org>");574MODULE_DESCRIPTION("Wilco EC ACPI event driver");575MODULE_LICENSE("GPL");576