2 * Roccat driver for Linux
4 * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
15 * Module roccat is a char device used to report special events of roccat
16 * hardware to userland. These events include requests for on-screen-display of
17 * profile or dpi settings or requests for execution of macro sequences that are
18 * not stored in device. The information in these events depends on hid device
19 * implementation and contains data that is not available in a single hid event
20 * or else hidraw could have been used.
21 * It is inspired by hidraw, but uses only one circular buffer for all readers.
24 #include <linux/cdev.h>
25 #include <linux/poll.h>
26 #include <linux/sched.h>
28 #include "hid-roccat.h"
30 #define ROCCAT_FIRST_MINOR 0
31 #define ROCCAT_MAX_DEVICES 8
33 /* should be a power of 2 for performance reason */
34 #define ROCCAT_CBUF_SIZE 16
36 struct roccat_report
{
41 struct roccat_device
{
45 wait_queue_head_t wait
;
47 struct hid_device
*hid
;
48 struct list_head readers
;
49 /* protects modifications of readers list */
50 struct mutex readers_lock
;
53 * circular_buffer has one writer and multiple readers with their own
56 struct roccat_report cbuf
[ROCCAT_CBUF_SIZE
];
58 struct mutex cbuf_lock
;
61 struct roccat_reader
{
62 struct list_head node
;
63 struct roccat_device
*device
;
67 static int roccat_major
;
68 static struct class *roccat_class
;
69 static struct cdev roccat_cdev
;
71 static struct roccat_device
*devices
[ROCCAT_MAX_DEVICES
];
72 /* protects modifications of devices array */
73 static DEFINE_MUTEX(devices_lock
);
75 static ssize_t
roccat_read(struct file
*file
, char __user
*buffer
,
76 size_t count
, loff_t
*ppos
)
78 struct roccat_reader
*reader
= file
->private_data
;
79 struct roccat_device
*device
= reader
->device
;
80 struct roccat_report
*report
;
81 ssize_t retval
= 0, len
;
82 DECLARE_WAITQUEUE(wait
, current
);
84 mutex_lock(&device
->cbuf_lock
);
87 if (reader
->cbuf_start
== device
->cbuf_end
) {
88 add_wait_queue(&device
->wait
, &wait
);
89 set_current_state(TASK_INTERRUPTIBLE
);
92 while (reader
->cbuf_start
== device
->cbuf_end
) {
93 if (file
->f_flags
& O_NONBLOCK
) {
97 if (signal_pending(current
)) {
98 retval
= -ERESTARTSYS
;
101 if (!device
->exist
) {
106 mutex_unlock(&device
->cbuf_lock
);
108 mutex_lock(&device
->cbuf_lock
);
109 set_current_state(TASK_INTERRUPTIBLE
);
112 set_current_state(TASK_RUNNING
);
113 remove_wait_queue(&device
->wait
, &wait
);
116 /* here we either have data or a reason to return if retval is set */
120 report
= &device
->cbuf
[reader
->cbuf_start
];
122 * If report is larger than requested amount of data, rest of report
125 len
= report
->len
> count
? count
: report
->len
;
127 if (copy_to_user(buffer
, report
->value
, len
)) {
132 reader
->cbuf_start
= (reader
->cbuf_start
+ 1) % ROCCAT_CBUF_SIZE
;
135 mutex_unlock(&device
->cbuf_lock
);
139 static unsigned int roccat_poll(struct file
*file
, poll_table
*wait
)
141 struct roccat_reader
*reader
= file
->private_data
;
142 poll_wait(file
, &reader
->device
->wait
, wait
);
143 if (reader
->cbuf_start
!= reader
->device
->cbuf_end
)
144 return POLLIN
| POLLRDNORM
;
145 if (!reader
->device
->exist
)
146 return POLLERR
| POLLHUP
;
150 static int roccat_open(struct inode
*inode
, struct file
*file
)
152 unsigned int minor
= iminor(inode
);
153 struct roccat_reader
*reader
;
154 struct roccat_device
*device
;
157 reader
= kzalloc(sizeof(struct roccat_reader
), GFP_KERNEL
);
161 mutex_lock(&devices_lock
);
163 device
= devices
[minor
];
165 mutex_lock(&device
->readers_lock
);
168 printk(KERN_EMERG
"roccat device with minor %d doesn't exist\n",
174 if (!device
->open
++) {
175 /* power on device on adding first reader */
176 error
= hid_hw_power(device
->hid
, PM_HINT_FULLON
);
182 error
= hid_hw_open(device
->hid
);
184 hid_hw_power(device
->hid
, PM_HINT_NORMAL
);
190 reader
->device
= device
;
191 /* new reader doesn't get old events */
192 reader
->cbuf_start
= device
->cbuf_end
;
194 list_add_tail(&reader
->node
, &device
->readers
);
195 file
->private_data
= reader
;
198 mutex_unlock(&device
->readers_lock
);
199 mutex_unlock(&devices_lock
);
206 static int roccat_release(struct inode
*inode
, struct file
*file
)
208 unsigned int minor
= iminor(inode
);
209 struct roccat_reader
*reader
= file
->private_data
;
210 struct roccat_device
*device
;
212 mutex_lock(&devices_lock
);
214 device
= devices
[minor
];
216 mutex_unlock(&devices_lock
);
217 printk(KERN_EMERG
"roccat device with minor %d doesn't exist\n",
222 mutex_lock(&device
->readers_lock
);
223 list_del(&reader
->node
);
224 mutex_unlock(&device
->readers_lock
);
227 if (!--device
->open
) {
228 /* removing last reader */
230 hid_hw_power(device
->hid
, PM_HINT_NORMAL
);
231 hid_hw_close(device
->hid
);
237 mutex_unlock(&devices_lock
);
243 * roccat_report_event() - output data to readers
244 * @minor: minor device number returned by roccat_connect()
245 * @data: pointer to data
248 * Return value is zero on success, a negative error code on failure.
250 * This is called from interrupt handler.
252 int roccat_report_event(int minor
, u8
const *data
, int len
)
254 struct roccat_device
*device
;
255 struct roccat_reader
*reader
;
256 struct roccat_report
*report
;
259 new_value
= kmemdup(data
, len
, GFP_ATOMIC
);
263 device
= devices
[minor
];
265 report
= &device
->cbuf
[device
->cbuf_end
];
267 /* passing NULL is safe */
268 kfree(report
->value
);
270 report
->value
= new_value
;
272 device
->cbuf_end
= (device
->cbuf_end
+ 1) % ROCCAT_CBUF_SIZE
;
274 list_for_each_entry(reader
, &device
->readers
, node
) {
276 * As we already inserted one element, the buffer can't be
277 * empty. If start and end are equal, buffer is full and we
278 * increase start, so that slow reader misses one event, but
279 * gets the newer ones in the right order.
281 if (reader
->cbuf_start
== device
->cbuf_end
)
282 reader
->cbuf_start
= (reader
->cbuf_start
+ 1) % ROCCAT_CBUF_SIZE
;
285 wake_up_interruptible(&device
->wait
);
288 EXPORT_SYMBOL_GPL(roccat_report_event
);
291 * roccat_connect() - create a char device for special event output
292 * @hid: the hid device the char device should be connected to.
294 * Return value is minor device number in Range [0, ROCCAT_MAX_DEVICES] on
295 * success, a negative error code on failure.
297 int roccat_connect(struct hid_device
*hid
)
300 struct roccat_device
*device
;
303 device
= kzalloc(sizeof(struct roccat_device
), GFP_KERNEL
);
307 mutex_lock(&devices_lock
);
309 for (minor
= 0; minor
< ROCCAT_MAX_DEVICES
; ++minor
) {
315 if (minor
< ROCCAT_MAX_DEVICES
) {
316 devices
[minor
] = device
;
318 mutex_unlock(&devices_lock
);
323 device
->dev
= device_create(roccat_class
, &hid
->dev
,
324 MKDEV(roccat_major
, minor
), NULL
,
325 "%s%s%d", "roccat", hid
->driver
->name
, minor
);
327 if (IS_ERR(device
->dev
)) {
328 devices
[minor
] = NULL
;
329 mutex_unlock(&devices_lock
);
330 temp
= PTR_ERR(device
->dev
);
335 mutex_unlock(&devices_lock
);
337 init_waitqueue_head(&device
->wait
);
338 INIT_LIST_HEAD(&device
->readers
);
339 mutex_init(&device
->readers_lock
);
340 mutex_init(&device
->cbuf_lock
);
341 device
->minor
= minor
;
344 device
->cbuf_end
= 0;
348 EXPORT_SYMBOL_GPL(roccat_connect
);
350 /* roccat_disconnect() - remove char device from hid device
351 * @minor: the minor device number returned by roccat_connect()
353 void roccat_disconnect(int minor
)
355 struct roccat_device
*device
;
357 mutex_lock(&devices_lock
);
358 device
= devices
[minor
];
359 devices
[minor
] = NULL
;
360 mutex_unlock(&devices_lock
);
362 device
->exist
= 0; /* TODO exist maybe not needed */
364 device_destroy(roccat_class
, MKDEV(roccat_major
, minor
));
367 hid_hw_close(device
->hid
);
368 wake_up_interruptible(&device
->wait
);
373 EXPORT_SYMBOL_GPL(roccat_disconnect
);
375 static const struct file_operations roccat_ops
= {
376 .owner
= THIS_MODULE
,
380 .release
= roccat_release
,
381 .llseek
= noop_llseek
,
384 static int __init
roccat_init(void)
389 retval
= alloc_chrdev_region(&dev_id
, ROCCAT_FIRST_MINOR
,
390 ROCCAT_MAX_DEVICES
, "roccat");
392 roccat_major
= MAJOR(dev_id
);
395 printk(KERN_WARNING
"roccat: can't get major number\n");
399 roccat_class
= class_create(THIS_MODULE
, "roccat");
400 if (IS_ERR(roccat_class
)) {
401 retval
= PTR_ERR(roccat_class
);
402 unregister_chrdev_region(dev_id
, ROCCAT_MAX_DEVICES
);
406 cdev_init(&roccat_cdev
, &roccat_ops
);
407 cdev_add(&roccat_cdev
, dev_id
, ROCCAT_MAX_DEVICES
);
412 static void __exit
roccat_exit(void)
414 dev_t dev_id
= MKDEV(roccat_major
, 0);
416 cdev_del(&roccat_cdev
);
417 class_destroy(roccat_class
);
418 unregister_chrdev_region(dev_id
, ROCCAT_MAX_DEVICES
);
421 module_init(roccat_init
);
422 module_exit(roccat_exit
);
424 MODULE_AUTHOR("Stefan Achatz");
425 MODULE_DESCRIPTION("USB Roccat char device");
426 MODULE_LICENSE("GPL v2");