mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 05:48:40 +00:00
![David Herrmann](/assets/img/avatar_default.png)
The raw hid output function that is supported by bluetooth low-level hid driver does not provide an output queue and also may sleep. The wiimote driver, though, may need to send data in atomic context so this patch adds a buffered output queue for the wiimote driver. We use the shared workqueue to send our buffer to the hid device. There is always only one active worker which flushes the whole output queue to the device. If our queue is full, every further output is discarded. Special care is needed in the deinitialization routine. When wiimote_hid_remove is called, HID input is already disabled, but HID output may still be used from our worker and is then discarded by the lower HID layers. Therefore, we can safely disable the input layer since it is the only layer that still sends input events. Future sysfs attributes must be freed before unregistering input to avoid the sysfs handlers to send input events to a non-existing input layer. Signed-off-by: David Herrmann <dh.herrmann@googlemail.com> Signed-off-by: Jiri Kosina <jkosina@suse.cz>
279 lines
6.3 KiB
C
279 lines
6.3 KiB
C
/*
|
|
* HID driver for Nintendo Wiimote devices
|
|
* Copyright (c) 2011 David Herrmann
|
|
*/
|
|
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*/
|
|
|
|
#include <linux/atomic.h>
|
|
#include <linux/device.h>
|
|
#include <linux/hid.h>
|
|
#include <linux/input.h>
|
|
#include <linux/module.h>
|
|
#include <linux/spinlock.h>
|
|
#include "hid-ids.h"
|
|
|
|
#define WIIMOTE_VERSION "0.1"
|
|
#define WIIMOTE_NAME "Nintendo Wii Remote"
|
|
#define WIIMOTE_BUFSIZE 32
|
|
|
|
struct wiimote_buf {
|
|
__u8 data[HID_MAX_BUFFER_SIZE];
|
|
size_t size;
|
|
};
|
|
|
|
struct wiimote_data {
|
|
atomic_t ready;
|
|
struct hid_device *hdev;
|
|
struct input_dev *input;
|
|
|
|
spinlock_t qlock;
|
|
__u8 head;
|
|
__u8 tail;
|
|
struct wiimote_buf outq[WIIMOTE_BUFSIZE];
|
|
struct work_struct worker;
|
|
};
|
|
|
|
static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
|
|
size_t count)
|
|
{
|
|
__u8 *buf;
|
|
ssize_t ret;
|
|
|
|
if (!hdev->hid_output_raw_report)
|
|
return -ENODEV;
|
|
|
|
buf = kmemdup(buffer, count, GFP_KERNEL);
|
|
if (!buf)
|
|
return -ENOMEM;
|
|
|
|
ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
|
|
|
|
kfree(buf);
|
|
return ret;
|
|
}
|
|
|
|
static void wiimote_worker(struct work_struct *work)
|
|
{
|
|
struct wiimote_data *wdata = container_of(work, struct wiimote_data,
|
|
worker);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&wdata->qlock, flags);
|
|
|
|
while (wdata->head != wdata->tail) {
|
|
spin_unlock_irqrestore(&wdata->qlock, flags);
|
|
wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
|
|
wdata->outq[wdata->tail].size);
|
|
spin_lock_irqsave(&wdata->qlock, flags);
|
|
|
|
wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&wdata->qlock, flags);
|
|
}
|
|
|
|
static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
|
|
size_t count)
|
|
{
|
|
unsigned long flags;
|
|
__u8 newhead;
|
|
|
|
if (count > HID_MAX_BUFFER_SIZE) {
|
|
hid_warn(wdata->hdev, "Sending too large output report\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Copy new request into our output queue and check whether the
|
|
* queue is full. If it is full, discard this request.
|
|
* If it is empty we need to start a new worker that will
|
|
* send out the buffer to the hid device.
|
|
* If the queue is not empty, then there must be a worker
|
|
* that is currently sending out our buffer and this worker
|
|
* will reschedule itself until the queue is empty.
|
|
*/
|
|
|
|
spin_lock_irqsave(&wdata->qlock, flags);
|
|
|
|
memcpy(wdata->outq[wdata->head].data, buffer, count);
|
|
wdata->outq[wdata->head].size = count;
|
|
newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
|
|
|
|
if (wdata->head == wdata->tail) {
|
|
wdata->head = newhead;
|
|
schedule_work(&wdata->worker);
|
|
} else if (newhead != wdata->tail) {
|
|
wdata->head = newhead;
|
|
} else {
|
|
hid_warn(wdata->hdev, "Output queue is full");
|
|
}
|
|
|
|
spin_unlock_irqrestore(&wdata->qlock, flags);
|
|
}
|
|
|
|
static int wiimote_input_event(struct input_dev *dev, unsigned int type,
|
|
unsigned int code, int value)
|
|
{
|
|
struct wiimote_data *wdata = input_get_drvdata(dev);
|
|
|
|
if (!atomic_read(&wdata->ready))
|
|
return -EBUSY;
|
|
/* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
|
|
smp_rmb();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
|
|
u8 *raw_data, int size)
|
|
{
|
|
struct wiimote_data *wdata = hid_get_drvdata(hdev);
|
|
|
|
if (!atomic_read(&wdata->ready))
|
|
return -EBUSY;
|
|
/* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
|
|
smp_rmb();
|
|
|
|
if (size < 1)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct wiimote_data *wiimote_create(struct hid_device *hdev)
|
|
{
|
|
struct wiimote_data *wdata;
|
|
|
|
wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
|
|
if (!wdata)
|
|
return NULL;
|
|
|
|
wdata->input = input_allocate_device();
|
|
if (!wdata->input) {
|
|
kfree(wdata);
|
|
return NULL;
|
|
}
|
|
|
|
wdata->hdev = hdev;
|
|
hid_set_drvdata(hdev, wdata);
|
|
|
|
input_set_drvdata(wdata->input, wdata);
|
|
wdata->input->event = wiimote_input_event;
|
|
wdata->input->dev.parent = &wdata->hdev->dev;
|
|
wdata->input->id.bustype = wdata->hdev->bus;
|
|
wdata->input->id.vendor = wdata->hdev->vendor;
|
|
wdata->input->id.product = wdata->hdev->product;
|
|
wdata->input->id.version = wdata->hdev->version;
|
|
wdata->input->name = WIIMOTE_NAME;
|
|
|
|
spin_lock_init(&wdata->qlock);
|
|
INIT_WORK(&wdata->worker, wiimote_worker);
|
|
|
|
return wdata;
|
|
}
|
|
|
|
static void wiimote_destroy(struct wiimote_data *wdata)
|
|
{
|
|
kfree(wdata);
|
|
}
|
|
|
|
static int wiimote_hid_probe(struct hid_device *hdev,
|
|
const struct hid_device_id *id)
|
|
{
|
|
struct wiimote_data *wdata;
|
|
int ret;
|
|
|
|
wdata = wiimote_create(hdev);
|
|
if (!wdata) {
|
|
hid_err(hdev, "Can't alloc device\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = hid_parse(hdev);
|
|
if (ret) {
|
|
hid_err(hdev, "HID parse failed\n");
|
|
goto err;
|
|
}
|
|
|
|
ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
|
|
if (ret) {
|
|
hid_err(hdev, "HW start failed\n");
|
|
goto err;
|
|
}
|
|
|
|
ret = input_register_device(wdata->input);
|
|
if (ret) {
|
|
hid_err(hdev, "Cannot register input device\n");
|
|
goto err_stop;
|
|
}
|
|
|
|
/* smp_wmb: Write wdata->xy first before wdata->ready is set to 1 */
|
|
smp_wmb();
|
|
atomic_set(&wdata->ready, 1);
|
|
hid_info(hdev, "New device registered\n");
|
|
return 0;
|
|
|
|
err_stop:
|
|
hid_hw_stop(hdev);
|
|
err:
|
|
input_free_device(wdata->input);
|
|
wiimote_destroy(wdata);
|
|
return ret;
|
|
}
|
|
|
|
static void wiimote_hid_remove(struct hid_device *hdev)
|
|
{
|
|
struct wiimote_data *wdata = hid_get_drvdata(hdev);
|
|
|
|
hid_info(hdev, "Device removed\n");
|
|
|
|
hid_hw_stop(hdev);
|
|
input_unregister_device(wdata->input);
|
|
|
|
cancel_work_sync(&wdata->worker);
|
|
wiimote_destroy(wdata);
|
|
}
|
|
|
|
static const struct hid_device_id wiimote_hid_devices[] = {
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
|
|
USB_DEVICE_ID_NINTENDO_WIIMOTE) },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
|
|
|
|
static struct hid_driver wiimote_hid_driver = {
|
|
.name = "wiimote",
|
|
.id_table = wiimote_hid_devices,
|
|
.probe = wiimote_hid_probe,
|
|
.remove = wiimote_hid_remove,
|
|
.raw_event = wiimote_hid_event,
|
|
};
|
|
|
|
static int __init wiimote_init(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = hid_register_driver(&wiimote_hid_driver);
|
|
if (ret)
|
|
pr_err("Can't register wiimote hid driver\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __exit wiimote_exit(void)
|
|
{
|
|
hid_unregister_driver(&wiimote_hid_driver);
|
|
}
|
|
|
|
module_init(wiimote_init);
|
|
module_exit(wiimote_exit);
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
|
|
MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
|
|
MODULE_VERSION(WIIMOTE_VERSION);
|