forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
581 lines
16 KiB
581 lines
16 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* ACPI event handling for Wilco Embedded Controller |
|
* |
|
* Copyright 2019 Google LLC |
|
* |
|
* The Wilco Embedded Controller can create custom events that |
|
* are not handled as standard ACPI objects. These events can |
|
* contain information about changes in EC controlled features, |
|
* such as errors and events in the dock or display. For example, |
|
* an event is triggered if the dock is plugged into a display |
|
* incorrectly. These events are needed for telemetry and |
|
* diagnostics reasons, and for possibly alerting the user. |
|
|
|
* These events are triggered by the EC with an ACPI Notify(0x90), |
|
* and then the BIOS reads the event buffer from EC RAM via an |
|
* ACPI method. When the OS receives these events via ACPI, |
|
* it passes them along to this driver. The events are put into |
|
* a queue which can be read by a userspace daemon via a char device |
|
* that implements read() and poll(). The event queue acts as a |
|
* circular buffer of size 64, so if there are no userspace consumers |
|
* the kernel will not run out of memory. The char device will appear at |
|
* /dev/wilco_event{n}, where n is some small non-negative integer, |
|
* starting from 0. Standard ACPI events such as the battery getting |
|
* plugged/unplugged can also come through this path, but they are |
|
* dealt with via other paths, and are ignored here. |
|
|
|
* To test, you can tail the binary data with |
|
* $ cat /dev/wilco_event0 | hexdump -ve '1/1 "%x\n"' |
|
* and then create an event by plugging/unplugging the battery. |
|
*/ |
|
|
|
#include <linux/acpi.h> |
|
#include <linux/cdev.h> |
|
#include <linux/device.h> |
|
#include <linux/fs.h> |
|
#include <linux/idr.h> |
|
#include <linux/io.h> |
|
#include <linux/list.h> |
|
#include <linux/module.h> |
|
#include <linux/poll.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/uaccess.h> |
|
#include <linux/wait.h> |
|
|
|
/* ACPI Notify event code indicating event data is available. */ |
|
#define EC_ACPI_NOTIFY_EVENT 0x90 |
|
/* ACPI Method to execute to retrieve event data buffer from the EC. */ |
|
#define EC_ACPI_GET_EVENT "QSET" |
|
/* Maximum number of words in event data returned by the EC. */ |
|
#define EC_ACPI_MAX_EVENT_WORDS 6 |
|
#define EC_ACPI_MAX_EVENT_SIZE \ |
|
(sizeof(struct ec_event) + (EC_ACPI_MAX_EVENT_WORDS) * sizeof(u16)) |
|
|
|
/* Node will appear in /dev/EVENT_DEV_NAME */ |
|
#define EVENT_DEV_NAME "wilco_event" |
|
#define EVENT_CLASS_NAME EVENT_DEV_NAME |
|
#define DRV_NAME EVENT_DEV_NAME |
|
#define EVENT_DEV_NAME_FMT (EVENT_DEV_NAME "%d") |
|
static struct class event_class = { |
|
.owner = THIS_MODULE, |
|
.name = EVENT_CLASS_NAME, |
|
}; |
|
|
|
/* Keep track of all the device numbers used. */ |
|
#define EVENT_MAX_DEV 128 |
|
static int event_major; |
|
static DEFINE_IDA(event_ida); |
|
|
|
/* Size of circular queue of events. */ |
|
#define MAX_NUM_EVENTS 64 |
|
|
|
/** |
|
* struct ec_event - Extended event returned by the EC. |
|
* @size: Number of 16bit words in structure after the size word. |
|
* @type: Extended event type, meaningless for us. |
|
* @event: Event data words. Max count is %EC_ACPI_MAX_EVENT_WORDS. |
|
*/ |
|
struct ec_event { |
|
u16 size; |
|
u16 type; |
|
u16 event[]; |
|
} __packed; |
|
|
|
#define ec_event_num_words(ev) (ev->size - 1) |
|
#define ec_event_size(ev) (sizeof(*ev) + (ec_event_num_words(ev) * sizeof(u16))) |
|
|
|
/** |
|
* struct ec_event_queue - Circular queue for events. |
|
* @capacity: Number of elements the queue can hold. |
|
* @head: Next index to write to. |
|
* @tail: Next index to read from. |
|
* @entries: Array of events. |
|
*/ |
|
struct ec_event_queue { |
|
int capacity; |
|
int head; |
|
int tail; |
|
struct ec_event *entries[]; |
|
}; |
|
|
|
/* Maximum number of events to store in ec_event_queue */ |
|
static int queue_size = 64; |
|
module_param(queue_size, int, 0644); |
|
|
|
static struct ec_event_queue *event_queue_new(int capacity) |
|
{ |
|
struct ec_event_queue *q; |
|
|
|
q = kzalloc(struct_size(q, entries, capacity), GFP_KERNEL); |
|
if (!q) |
|
return NULL; |
|
|
|
q->capacity = capacity; |
|
|
|
return q; |
|
} |
|
|
|
static inline bool event_queue_empty(struct ec_event_queue *q) |
|
{ |
|
/* head==tail when both full and empty, but head==NULL when empty */ |
|
return q->head == q->tail && !q->entries[q->head]; |
|
} |
|
|
|
static inline bool event_queue_full(struct ec_event_queue *q) |
|
{ |
|
/* head==tail when both full and empty, but head!=NULL when full */ |
|
return q->head == q->tail && q->entries[q->head]; |
|
} |
|
|
|
static struct ec_event *event_queue_pop(struct ec_event_queue *q) |
|
{ |
|
struct ec_event *ev; |
|
|
|
if (event_queue_empty(q)) |
|
return NULL; |
|
|
|
ev = q->entries[q->tail]; |
|
q->entries[q->tail] = NULL; |
|
q->tail = (q->tail + 1) % q->capacity; |
|
|
|
return ev; |
|
} |
|
|
|
/* |
|
* If full, overwrite the oldest event and return it so the caller |
|
* can kfree it. If not full, return NULL. |
|
*/ |
|
static struct ec_event *event_queue_push(struct ec_event_queue *q, |
|
struct ec_event *ev) |
|
{ |
|
struct ec_event *popped = NULL; |
|
|
|
if (event_queue_full(q)) |
|
popped = event_queue_pop(q); |
|
q->entries[q->head] = ev; |
|
q->head = (q->head + 1) % q->capacity; |
|
|
|
return popped; |
|
} |
|
|
|
static void event_queue_free(struct ec_event_queue *q) |
|
{ |
|
struct ec_event *event; |
|
|
|
while ((event = event_queue_pop(q)) != NULL) |
|
kfree(event); |
|
|
|
kfree(q); |
|
} |
|
|
|
/** |
|
* struct event_device_data - Data for a Wilco EC device that responds to ACPI. |
|
* @events: Circular queue of EC events to be provided to userspace. |
|
* @queue_lock: Protect the queue from simultaneous read/writes. |
|
* @wq: Wait queue to notify processes when events are available or the |
|
* device has been removed. |
|
* @cdev: Char dev that userspace reads() and polls() from. |
|
* @dev: Device associated with the %cdev. |
|
* @exist: Has the device been not been removed? Once a device has been removed, |
|
* writes, reads, and new opens will fail. |
|
* @available: Guarantee only one client can open() file and read from queue. |
|
* |
|
* There will be one of these structs for each ACPI device registered. This data |
|
* is the queue of events received from ACPI that still need to be read from |
|
* userspace, the device and char device that userspace is using, a wait queue |
|
* used to notify different threads when something has changed, plus a flag |
|
* on whether the ACPI device has been removed. |
|
*/ |
|
struct event_device_data { |
|
struct ec_event_queue *events; |
|
spinlock_t queue_lock; |
|
wait_queue_head_t wq; |
|
struct device dev; |
|
struct cdev cdev; |
|
bool exist; |
|
atomic_t available; |
|
}; |
|
|
|
/** |
|
* enqueue_events() - Place EC events in queue to be read by userspace. |
|
* @adev: Device the events came from. |
|
* @buf: Buffer of event data. |
|
* @length: Length of event data buffer. |
|
* |
|
* %buf contains a number of ec_event's, packed one after the other. |
|
* Each ec_event is of variable length. Start with the first event, copy it |
|
* into a persistent ec_event, store that entry in the queue, move on |
|
* to the next ec_event in buf, and repeat. |
|
* |
|
* Return: 0 on success or negative error code on failure. |
|
*/ |
|
static int enqueue_events(struct acpi_device *adev, const u8 *buf, u32 length) |
|
{ |
|
struct event_device_data *dev_data = adev->driver_data; |
|
struct ec_event *event, *queue_event, *old_event; |
|
size_t num_words, event_size; |
|
u32 offset = 0; |
|
|
|
while (offset < length) { |
|
event = (struct ec_event *)(buf + offset); |
|
|
|
num_words = ec_event_num_words(event); |
|
event_size = ec_event_size(event); |
|
if (num_words > EC_ACPI_MAX_EVENT_WORDS) { |
|
dev_err(&adev->dev, "Too many event words: %zu > %d\n", |
|
num_words, EC_ACPI_MAX_EVENT_WORDS); |
|
return -EOVERFLOW; |
|
} |
|
|
|
/* Ensure event does not overflow the available buffer */ |
|
if ((offset + event_size) > length) { |
|
dev_err(&adev->dev, "Event exceeds buffer: %zu > %d\n", |
|
offset + event_size, length); |
|
return -EOVERFLOW; |
|
} |
|
|
|
/* Point to the next event in the buffer */ |
|
offset += event_size; |
|
|
|
/* Copy event into the queue */ |
|
queue_event = kmemdup(event, event_size, GFP_KERNEL); |
|
if (!queue_event) |
|
return -ENOMEM; |
|
spin_lock(&dev_data->queue_lock); |
|
old_event = event_queue_push(dev_data->events, queue_event); |
|
spin_unlock(&dev_data->queue_lock); |
|
kfree(old_event); |
|
wake_up_interruptible(&dev_data->wq); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* event_device_notify() - Callback when EC generates an event over ACPI. |
|
* @adev: The device that the event is coming from. |
|
* @value: Value passed to Notify() in ACPI. |
|
* |
|
* This function will read the events from the device and enqueue them. |
|
*/ |
|
static void event_device_notify(struct acpi_device *adev, u32 value) |
|
{ |
|
struct acpi_buffer event_buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
|
union acpi_object *obj; |
|
acpi_status status; |
|
|
|
if (value != EC_ACPI_NOTIFY_EVENT) { |
|
dev_err(&adev->dev, "Invalid event: 0x%08x\n", value); |
|
return; |
|
} |
|
|
|
/* Execute ACPI method to get event data buffer. */ |
|
status = acpi_evaluate_object(adev->handle, EC_ACPI_GET_EVENT, |
|
NULL, &event_buffer); |
|
if (ACPI_FAILURE(status)) { |
|
dev_err(&adev->dev, "Error executing ACPI method %s()\n", |
|
EC_ACPI_GET_EVENT); |
|
return; |
|
} |
|
|
|
obj = (union acpi_object *)event_buffer.pointer; |
|
if (!obj) { |
|
dev_err(&adev->dev, "Nothing returned from %s()\n", |
|
EC_ACPI_GET_EVENT); |
|
return; |
|
} |
|
if (obj->type != ACPI_TYPE_BUFFER) { |
|
dev_err(&adev->dev, "Invalid object returned from %s()\n", |
|
EC_ACPI_GET_EVENT); |
|
kfree(obj); |
|
return; |
|
} |
|
if (obj->buffer.length < sizeof(struct ec_event)) { |
|
dev_err(&adev->dev, "Invalid buffer length %d from %s()\n", |
|
obj->buffer.length, EC_ACPI_GET_EVENT); |
|
kfree(obj); |
|
return; |
|
} |
|
|
|
enqueue_events(adev, obj->buffer.pointer, obj->buffer.length); |
|
kfree(obj); |
|
} |
|
|
|
static int event_open(struct inode *inode, struct file *filp) |
|
{ |
|
struct event_device_data *dev_data; |
|
|
|
dev_data = container_of(inode->i_cdev, struct event_device_data, cdev); |
|
if (!dev_data->exist) |
|
return -ENODEV; |
|
|
|
if (atomic_cmpxchg(&dev_data->available, 1, 0) == 0) |
|
return -EBUSY; |
|
|
|
/* Increase refcount on device so dev_data is not freed */ |
|
get_device(&dev_data->dev); |
|
stream_open(inode, filp); |
|
filp->private_data = dev_data; |
|
|
|
return 0; |
|
} |
|
|
|
static __poll_t event_poll(struct file *filp, poll_table *wait) |
|
{ |
|
struct event_device_data *dev_data = filp->private_data; |
|
__poll_t mask = 0; |
|
|
|
poll_wait(filp, &dev_data->wq, wait); |
|
if (!dev_data->exist) |
|
return EPOLLHUP; |
|
if (!event_queue_empty(dev_data->events)) |
|
mask |= EPOLLIN | EPOLLRDNORM | EPOLLPRI; |
|
return mask; |
|
} |
|
|
|
/** |
|
* event_read() - Callback for passing event data to userspace via read(). |
|
* @filp: The file we are reading from. |
|
* @buf: Pointer to userspace buffer to fill with one event. |
|
* @count: Number of bytes requested. Must be at least EC_ACPI_MAX_EVENT_SIZE. |
|
* @pos: File position pointer, irrelevant since we don't support seeking. |
|
* |
|
* Removes the first event from the queue, places it in the passed buffer. |
|
* |
|
* If there are no events in the the queue, then one of two things happens, |
|
* depending on if the file was opened in nonblocking mode: If in nonblocking |
|
* mode, then return -EAGAIN to say there's no data. If in blocking mode, then |
|
* block until an event is available. |
|
* |
|
* Return: Number of bytes placed in buffer, negative error code on failure. |
|
*/ |
|
static ssize_t event_read(struct file *filp, char __user *buf, size_t count, |
|
loff_t *pos) |
|
{ |
|
struct event_device_data *dev_data = filp->private_data; |
|
struct ec_event *event; |
|
ssize_t n_bytes_written = 0; |
|
int err; |
|
|
|
/* We only will give them the entire event at once */ |
|
if (count != 0 && count < EC_ACPI_MAX_EVENT_SIZE) |
|
return -EINVAL; |
|
|
|
spin_lock(&dev_data->queue_lock); |
|
while (event_queue_empty(dev_data->events)) { |
|
spin_unlock(&dev_data->queue_lock); |
|
if (filp->f_flags & O_NONBLOCK) |
|
return -EAGAIN; |
|
|
|
err = wait_event_interruptible(dev_data->wq, |
|
!event_queue_empty(dev_data->events) || |
|
!dev_data->exist); |
|
if (err) |
|
return err; |
|
|
|
/* Device was removed as we waited? */ |
|
if (!dev_data->exist) |
|
return -ENODEV; |
|
spin_lock(&dev_data->queue_lock); |
|
} |
|
event = event_queue_pop(dev_data->events); |
|
spin_unlock(&dev_data->queue_lock); |
|
n_bytes_written = ec_event_size(event); |
|
if (copy_to_user(buf, event, n_bytes_written)) |
|
n_bytes_written = -EFAULT; |
|
kfree(event); |
|
|
|
return n_bytes_written; |
|
} |
|
|
|
static int event_release(struct inode *inode, struct file *filp) |
|
{ |
|
struct event_device_data *dev_data = filp->private_data; |
|
|
|
atomic_set(&dev_data->available, 1); |
|
put_device(&dev_data->dev); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct file_operations event_fops = { |
|
.open = event_open, |
|
.poll = event_poll, |
|
.read = event_read, |
|
.release = event_release, |
|
.llseek = no_llseek, |
|
.owner = THIS_MODULE, |
|
}; |
|
|
|
/** |
|
* free_device_data() - Callback to free the event_device_data structure. |
|
* @d: The device embedded in our device data, which we have been ref counting. |
|
* |
|
* This is called only after event_device_remove() has been called and all |
|
* userspace programs have called event_release() on all the open file |
|
* descriptors. |
|
*/ |
|
static void free_device_data(struct device *d) |
|
{ |
|
struct event_device_data *dev_data; |
|
|
|
dev_data = container_of(d, struct event_device_data, dev); |
|
event_queue_free(dev_data->events); |
|
kfree(dev_data); |
|
} |
|
|
|
static void hangup_device(struct event_device_data *dev_data) |
|
{ |
|
dev_data->exist = false; |
|
/* Wake up the waiting processes so they can close. */ |
|
wake_up_interruptible(&dev_data->wq); |
|
put_device(&dev_data->dev); |
|
} |
|
|
|
/** |
|
* event_device_add() - Callback when creating a new device. |
|
* @adev: ACPI device that we will be receiving events from. |
|
* |
|
* This finds a free minor number for the device, allocates and initializes |
|
* some device data, and creates a new device and char dev node. |
|
* |
|
* The device data is freed in free_device_data(), which is called when |
|
* %dev_data->dev is release()ed. This happens after all references to |
|
* %dev_data->dev are dropped, which happens once both event_device_remove() |
|
* has been called and every open()ed file descriptor has been release()ed. |
|
* |
|
* Return: 0 on success, negative error code on failure. |
|
*/ |
|
static int event_device_add(struct acpi_device *adev) |
|
{ |
|
struct event_device_data *dev_data; |
|
int error, minor; |
|
|
|
minor = ida_alloc_max(&event_ida, EVENT_MAX_DEV-1, GFP_KERNEL); |
|
if (minor < 0) { |
|
error = minor; |
|
dev_err(&adev->dev, "Failed to find minor number: %d\n", error); |
|
return error; |
|
} |
|
|
|
dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL); |
|
if (!dev_data) { |
|
error = -ENOMEM; |
|
goto free_minor; |
|
} |
|
|
|
/* Initialize the device data. */ |
|
adev->driver_data = dev_data; |
|
dev_data->events = event_queue_new(queue_size); |
|
if (!dev_data->events) { |
|
kfree(dev_data); |
|
error = -ENOMEM; |
|
goto free_minor; |
|
} |
|
spin_lock_init(&dev_data->queue_lock); |
|
init_waitqueue_head(&dev_data->wq); |
|
dev_data->exist = true; |
|
atomic_set(&dev_data->available, 1); |
|
|
|
/* Initialize the device. */ |
|
dev_data->dev.devt = MKDEV(event_major, minor); |
|
dev_data->dev.class = &event_class; |
|
dev_data->dev.release = free_device_data; |
|
dev_set_name(&dev_data->dev, EVENT_DEV_NAME_FMT, minor); |
|
device_initialize(&dev_data->dev); |
|
|
|
/* Initialize the character device, and add it to userspace. */ |
|
cdev_init(&dev_data->cdev, &event_fops); |
|
error = cdev_device_add(&dev_data->cdev, &dev_data->dev); |
|
if (error) |
|
goto free_dev_data; |
|
|
|
return 0; |
|
|
|
free_dev_data: |
|
hangup_device(dev_data); |
|
free_minor: |
|
ida_simple_remove(&event_ida, minor); |
|
return error; |
|
} |
|
|
|
static int event_device_remove(struct acpi_device *adev) |
|
{ |
|
struct event_device_data *dev_data = adev->driver_data; |
|
|
|
cdev_device_del(&dev_data->cdev, &dev_data->dev); |
|
ida_simple_remove(&event_ida, MINOR(dev_data->dev.devt)); |
|
hangup_device(dev_data); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct acpi_device_id event_acpi_ids[] = { |
|
{ "GOOG000D", 0 }, |
|
{ } |
|
}; |
|
MODULE_DEVICE_TABLE(acpi, event_acpi_ids); |
|
|
|
static struct acpi_driver event_driver = { |
|
.name = DRV_NAME, |
|
.class = DRV_NAME, |
|
.ids = event_acpi_ids, |
|
.ops = { |
|
.add = event_device_add, |
|
.notify = event_device_notify, |
|
.remove = event_device_remove, |
|
}, |
|
.owner = THIS_MODULE, |
|
}; |
|
|
|
static int __init event_module_init(void) |
|
{ |
|
dev_t dev_num = 0; |
|
int ret; |
|
|
|
ret = class_register(&event_class); |
|
if (ret) { |
|
pr_err(DRV_NAME ": Failed registering class: %d\n", ret); |
|
return ret; |
|
} |
|
|
|
/* Request device numbers, starting with minor=0. Save the major num. */ |
|
ret = alloc_chrdev_region(&dev_num, 0, EVENT_MAX_DEV, EVENT_DEV_NAME); |
|
if (ret) { |
|
pr_err(DRV_NAME ": Failed allocating dev numbers: %d\n", ret); |
|
goto destroy_class; |
|
} |
|
event_major = MAJOR(dev_num); |
|
|
|
ret = acpi_bus_register_driver(&event_driver); |
|
if (ret < 0) { |
|
pr_err(DRV_NAME ": Failed registering driver: %d\n", ret); |
|
goto unregister_region; |
|
} |
|
|
|
return 0; |
|
|
|
unregister_region: |
|
unregister_chrdev_region(MKDEV(event_major, 0), EVENT_MAX_DEV); |
|
destroy_class: |
|
class_unregister(&event_class); |
|
ida_destroy(&event_ida); |
|
return ret; |
|
} |
|
|
|
static void __exit event_module_exit(void) |
|
{ |
|
acpi_bus_unregister_driver(&event_driver); |
|
unregister_chrdev_region(MKDEV(event_major, 0), EVENT_MAX_DEV); |
|
class_unregister(&event_class); |
|
ida_destroy(&event_ida); |
|
} |
|
|
|
module_init(event_module_init); |
|
module_exit(event_module_exit); |
|
|
|
MODULE_AUTHOR("Nick Crews <[email protected]>"); |
|
MODULE_DESCRIPTION("Wilco EC ACPI event driver"); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_ALIAS("platform:" DRV_NAME);
|
|
|