582 строки
16 KiB
C
582 строки
16 KiB
C
// 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 <ncrews@chromium.org>");
|
|
MODULE_DESCRIPTION("Wilco EC ACPI event driver");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:" DRV_NAME);
|