1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Roccat driver for Linux |
4 | * |
5 | * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net> |
6 | */ |
7 | |
8 | /* |
9 | */ |
10 | |
11 | /* |
12 | * Module roccat is a char device used to report special events of roccat |
13 | * hardware to userland. These events include requests for on-screen-display of |
14 | * profile or dpi settings or requests for execution of macro sequences that are |
15 | * not stored in device. The information in these events depends on hid device |
16 | * implementation and contains data that is not available in a single hid event |
17 | * or else hidraw could have been used. |
18 | * It is inspired by hidraw, but uses only one circular buffer for all readers. |
19 | */ |
20 | |
21 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
22 | |
23 | #include <linux/cdev.h> |
24 | #include <linux/poll.h> |
25 | #include <linux/sched/signal.h> |
26 | #include <linux/hid-roccat.h> |
27 | #include <linux/module.h> |
28 | |
29 | #define ROCCAT_FIRST_MINOR 0 |
30 | #define ROCCAT_MAX_DEVICES 8 |
31 | |
32 | /* should be a power of 2 for performance reason */ |
33 | #define ROCCAT_CBUF_SIZE 16 |
34 | |
35 | struct roccat_report { |
36 | uint8_t *value; |
37 | }; |
38 | |
39 | struct roccat_device { |
40 | unsigned int minor; |
41 | int report_size; |
42 | int open; |
43 | int exist; |
44 | wait_queue_head_t wait; |
45 | struct device *dev; |
46 | struct hid_device *hid; |
47 | struct list_head readers; |
48 | /* protects modifications of readers list */ |
49 | struct mutex readers_lock; |
50 | |
51 | /* |
52 | * circular_buffer has one writer and multiple readers with their own |
53 | * read pointers |
54 | */ |
55 | struct roccat_report cbuf[ROCCAT_CBUF_SIZE]; |
56 | int cbuf_end; |
57 | struct mutex cbuf_lock; |
58 | }; |
59 | |
60 | struct roccat_reader { |
61 | struct list_head node; |
62 | struct roccat_device *device; |
63 | int cbuf_start; |
64 | }; |
65 | |
66 | static int roccat_major; |
67 | static struct cdev roccat_cdev; |
68 | |
69 | static struct roccat_device *devices[ROCCAT_MAX_DEVICES]; |
70 | /* protects modifications of devices array */ |
71 | static DEFINE_MUTEX(devices_lock); |
72 | |
73 | static ssize_t roccat_read(struct file *file, char __user *buffer, |
74 | size_t count, loff_t *ppos) |
75 | { |
76 | struct roccat_reader *reader = file->private_data; |
77 | struct roccat_device *device = reader->device; |
78 | struct roccat_report *report; |
79 | ssize_t retval = 0, len; |
80 | DECLARE_WAITQUEUE(wait, current); |
81 | |
82 | mutex_lock(&device->cbuf_lock); |
83 | |
84 | /* no data? */ |
85 | if (reader->cbuf_start == device->cbuf_end) { |
86 | add_wait_queue(wq_head: &device->wait, wq_entry: &wait); |
87 | set_current_state(TASK_INTERRUPTIBLE); |
88 | |
89 | /* wait for data */ |
90 | while (reader->cbuf_start == device->cbuf_end) { |
91 | if (file->f_flags & O_NONBLOCK) { |
92 | retval = -EAGAIN; |
93 | break; |
94 | } |
95 | if (signal_pending(current)) { |
96 | retval = -ERESTARTSYS; |
97 | break; |
98 | } |
99 | if (!device->exist) { |
100 | retval = -EIO; |
101 | break; |
102 | } |
103 | |
104 | mutex_unlock(lock: &device->cbuf_lock); |
105 | schedule(); |
106 | mutex_lock(&device->cbuf_lock); |
107 | set_current_state(TASK_INTERRUPTIBLE); |
108 | } |
109 | |
110 | set_current_state(TASK_RUNNING); |
111 | remove_wait_queue(wq_head: &device->wait, wq_entry: &wait); |
112 | } |
113 | |
114 | /* here we either have data or a reason to return if retval is set */ |
115 | if (retval) |
116 | goto exit_unlock; |
117 | |
118 | report = &device->cbuf[reader->cbuf_start]; |
119 | /* |
120 | * If report is larger than requested amount of data, rest of report |
121 | * is lost! |
122 | */ |
123 | len = device->report_size > count ? count : device->report_size; |
124 | |
125 | if (copy_to_user(to: buffer, from: report->value, n: len)) { |
126 | retval = -EFAULT; |
127 | goto exit_unlock; |
128 | } |
129 | retval += len; |
130 | reader->cbuf_start = (reader->cbuf_start + 1) % ROCCAT_CBUF_SIZE; |
131 | |
132 | exit_unlock: |
133 | mutex_unlock(lock: &device->cbuf_lock); |
134 | return retval; |
135 | } |
136 | |
137 | static __poll_t roccat_poll(struct file *file, poll_table *wait) |
138 | { |
139 | struct roccat_reader *reader = file->private_data; |
140 | poll_wait(filp: file, wait_address: &reader->device->wait, p: wait); |
141 | if (reader->cbuf_start != reader->device->cbuf_end) |
142 | return EPOLLIN | EPOLLRDNORM; |
143 | if (!reader->device->exist) |
144 | return EPOLLERR | EPOLLHUP; |
145 | return 0; |
146 | } |
147 | |
148 | static int roccat_open(struct inode *inode, struct file *file) |
149 | { |
150 | unsigned int minor = iminor(inode); |
151 | struct roccat_reader *reader; |
152 | struct roccat_device *device; |
153 | int error = 0; |
154 | |
155 | reader = kzalloc(size: sizeof(struct roccat_reader), GFP_KERNEL); |
156 | if (!reader) |
157 | return -ENOMEM; |
158 | |
159 | mutex_lock(&devices_lock); |
160 | |
161 | device = devices[minor]; |
162 | |
163 | if (!device) { |
164 | pr_emerg("roccat device with minor %d doesn't exist\n" , minor); |
165 | error = -ENODEV; |
166 | goto exit_err_devices; |
167 | } |
168 | |
169 | mutex_lock(&device->readers_lock); |
170 | |
171 | if (!device->open++) { |
172 | /* power on device on adding first reader */ |
173 | error = hid_hw_power(hdev: device->hid, PM_HINT_FULLON); |
174 | if (error < 0) { |
175 | --device->open; |
176 | goto exit_err_readers; |
177 | } |
178 | |
179 | error = hid_hw_open(hdev: device->hid); |
180 | if (error < 0) { |
181 | hid_hw_power(hdev: device->hid, PM_HINT_NORMAL); |
182 | --device->open; |
183 | goto exit_err_readers; |
184 | } |
185 | } |
186 | |
187 | reader->device = device; |
188 | /* new reader doesn't get old events */ |
189 | reader->cbuf_start = device->cbuf_end; |
190 | |
191 | list_add_tail(new: &reader->node, head: &device->readers); |
192 | file->private_data = reader; |
193 | |
194 | exit_err_readers: |
195 | mutex_unlock(lock: &device->readers_lock); |
196 | exit_err_devices: |
197 | mutex_unlock(lock: &devices_lock); |
198 | if (error) |
199 | kfree(objp: reader); |
200 | return error; |
201 | } |
202 | |
203 | static int roccat_release(struct inode *inode, struct file *file) |
204 | { |
205 | unsigned int minor = iminor(inode); |
206 | struct roccat_reader *reader = file->private_data; |
207 | struct roccat_device *device; |
208 | |
209 | mutex_lock(&devices_lock); |
210 | |
211 | device = devices[minor]; |
212 | if (!device) { |
213 | mutex_unlock(lock: &devices_lock); |
214 | pr_emerg("roccat device with minor %d doesn't exist\n" , minor); |
215 | return -ENODEV; |
216 | } |
217 | |
218 | mutex_lock(&device->readers_lock); |
219 | list_del(entry: &reader->node); |
220 | mutex_unlock(lock: &device->readers_lock); |
221 | kfree(objp: reader); |
222 | |
223 | if (!--device->open) { |
224 | /* removing last reader */ |
225 | if (device->exist) { |
226 | hid_hw_power(hdev: device->hid, PM_HINT_NORMAL); |
227 | hid_hw_close(hdev: device->hid); |
228 | } else { |
229 | kfree(objp: device); |
230 | } |
231 | } |
232 | |
233 | mutex_unlock(lock: &devices_lock); |
234 | |
235 | return 0; |
236 | } |
237 | |
238 | /* |
239 | * roccat_report_event() - output data to readers |
240 | * @minor: minor device number returned by roccat_connect() |
241 | * @data: pointer to data |
242 | * |
243 | * Return value is zero on success, a negative error code on failure. |
244 | * |
245 | * This is called from interrupt handler. |
246 | */ |
247 | int roccat_report_event(int minor, u8 const *data) |
248 | { |
249 | struct roccat_device *device; |
250 | struct roccat_reader *reader; |
251 | struct roccat_report *report; |
252 | uint8_t *new_value; |
253 | |
254 | device = devices[minor]; |
255 | |
256 | new_value = kmemdup(p: data, size: device->report_size, GFP_ATOMIC); |
257 | if (!new_value) |
258 | return -ENOMEM; |
259 | |
260 | mutex_lock(&device->cbuf_lock); |
261 | |
262 | report = &device->cbuf[device->cbuf_end]; |
263 | |
264 | /* passing NULL is safe */ |
265 | kfree(objp: report->value); |
266 | |
267 | report->value = new_value; |
268 | device->cbuf_end = (device->cbuf_end + 1) % ROCCAT_CBUF_SIZE; |
269 | |
270 | list_for_each_entry(reader, &device->readers, node) { |
271 | /* |
272 | * As we already inserted one element, the buffer can't be |
273 | * empty. If start and end are equal, buffer is full and we |
274 | * increase start, so that slow reader misses one event, but |
275 | * gets the newer ones in the right order. |
276 | */ |
277 | if (reader->cbuf_start == device->cbuf_end) |
278 | reader->cbuf_start = (reader->cbuf_start + 1) % ROCCAT_CBUF_SIZE; |
279 | } |
280 | |
281 | mutex_unlock(lock: &device->cbuf_lock); |
282 | |
283 | wake_up_interruptible(&device->wait); |
284 | return 0; |
285 | } |
286 | EXPORT_SYMBOL_GPL(roccat_report_event); |
287 | |
288 | /* |
289 | * roccat_connect() - create a char device for special event output |
290 | * @class: the class thats used to create the device. Meant to hold device |
291 | * specific sysfs attributes. |
292 | * @hid: the hid device the char device should be connected to. |
293 | * @report_size: size of reports |
294 | * |
295 | * Return value is minor device number in Range [0, ROCCAT_MAX_DEVICES] on |
296 | * success, a negative error code on failure. |
297 | */ |
298 | int roccat_connect(const struct class *klass, struct hid_device *hid, int report_size) |
299 | { |
300 | unsigned int minor; |
301 | struct roccat_device *device; |
302 | int temp; |
303 | |
304 | device = kzalloc(size: sizeof(struct roccat_device), GFP_KERNEL); |
305 | if (!device) |
306 | return -ENOMEM; |
307 | |
308 | mutex_lock(&devices_lock); |
309 | |
310 | for (minor = 0; minor < ROCCAT_MAX_DEVICES; ++minor) { |
311 | if (devices[minor]) |
312 | continue; |
313 | break; |
314 | } |
315 | |
316 | if (minor < ROCCAT_MAX_DEVICES) { |
317 | devices[minor] = device; |
318 | } else { |
319 | mutex_unlock(lock: &devices_lock); |
320 | kfree(objp: device); |
321 | return -EINVAL; |
322 | } |
323 | |
324 | device->dev = device_create(cls: klass, parent: &hid->dev, |
325 | MKDEV(roccat_major, minor), NULL, |
326 | fmt: "%s%s%d" , "roccat" , hid->driver->name, minor); |
327 | |
328 | if (IS_ERR(ptr: device->dev)) { |
329 | devices[minor] = NULL; |
330 | mutex_unlock(lock: &devices_lock); |
331 | temp = PTR_ERR(ptr: device->dev); |
332 | kfree(objp: device); |
333 | return temp; |
334 | } |
335 | |
336 | mutex_unlock(lock: &devices_lock); |
337 | |
338 | init_waitqueue_head(&device->wait); |
339 | INIT_LIST_HEAD(list: &device->readers); |
340 | mutex_init(&device->readers_lock); |
341 | mutex_init(&device->cbuf_lock); |
342 | device->minor = minor; |
343 | device->hid = hid; |
344 | device->exist = 1; |
345 | device->cbuf_end = 0; |
346 | device->report_size = report_size; |
347 | |
348 | return minor; |
349 | } |
350 | EXPORT_SYMBOL_GPL(roccat_connect); |
351 | |
352 | /* roccat_disconnect() - remove char device from hid device |
353 | * @minor: the minor device number returned by roccat_connect() |
354 | */ |
355 | void roccat_disconnect(int minor) |
356 | { |
357 | struct roccat_device *device; |
358 | |
359 | mutex_lock(&devices_lock); |
360 | device = devices[minor]; |
361 | mutex_unlock(lock: &devices_lock); |
362 | |
363 | device->exist = 0; /* TODO exist maybe not needed */ |
364 | |
365 | device_destroy(cls: device->dev->class, MKDEV(roccat_major, minor)); |
366 | |
367 | mutex_lock(&devices_lock); |
368 | devices[minor] = NULL; |
369 | mutex_unlock(lock: &devices_lock); |
370 | |
371 | if (device->open) { |
372 | hid_hw_close(hdev: device->hid); |
373 | wake_up_interruptible(&device->wait); |
374 | } else { |
375 | kfree(objp: device); |
376 | } |
377 | } |
378 | EXPORT_SYMBOL_GPL(roccat_disconnect); |
379 | |
380 | static long roccat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
381 | { |
382 | struct inode *inode = file_inode(f: file); |
383 | struct roccat_device *device; |
384 | unsigned int minor = iminor(inode); |
385 | long retval = 0; |
386 | |
387 | mutex_lock(&devices_lock); |
388 | |
389 | device = devices[minor]; |
390 | if (!device) { |
391 | retval = -ENODEV; |
392 | goto out; |
393 | } |
394 | |
395 | switch (cmd) { |
396 | case ROCCATIOCGREPSIZE: |
397 | if (put_user(device->report_size, (int __user *)arg)) |
398 | retval = -EFAULT; |
399 | break; |
400 | default: |
401 | retval = -ENOTTY; |
402 | } |
403 | out: |
404 | mutex_unlock(lock: &devices_lock); |
405 | return retval; |
406 | } |
407 | |
408 | static const struct file_operations roccat_ops = { |
409 | .owner = THIS_MODULE, |
410 | .read = roccat_read, |
411 | .poll = roccat_poll, |
412 | .open = roccat_open, |
413 | .release = roccat_release, |
414 | .llseek = noop_llseek, |
415 | .unlocked_ioctl = roccat_ioctl, |
416 | }; |
417 | |
418 | static int __init roccat_init(void) |
419 | { |
420 | int retval; |
421 | dev_t dev_id; |
422 | |
423 | retval = alloc_chrdev_region(&dev_id, ROCCAT_FIRST_MINOR, |
424 | ROCCAT_MAX_DEVICES, "roccat" ); |
425 | if (retval < 0) { |
426 | pr_warn("can't get major number\n" ); |
427 | goto error; |
428 | } |
429 | |
430 | roccat_major = MAJOR(dev_id); |
431 | |
432 | cdev_init(&roccat_cdev, &roccat_ops); |
433 | retval = cdev_add(&roccat_cdev, dev_id, ROCCAT_MAX_DEVICES); |
434 | |
435 | if (retval < 0) { |
436 | pr_warn("cannot add cdev\n" ); |
437 | goto cleanup_alloc_chrdev_region; |
438 | } |
439 | return 0; |
440 | |
441 | |
442 | cleanup_alloc_chrdev_region: |
443 | unregister_chrdev_region(dev_id, ROCCAT_MAX_DEVICES); |
444 | error: |
445 | return retval; |
446 | } |
447 | |
448 | static void __exit roccat_exit(void) |
449 | { |
450 | dev_t dev_id = MKDEV(roccat_major, 0); |
451 | |
452 | cdev_del(&roccat_cdev); |
453 | unregister_chrdev_region(dev_id, ROCCAT_MAX_DEVICES); |
454 | } |
455 | |
456 | module_init(roccat_init); |
457 | module_exit(roccat_exit); |
458 | |
459 | MODULE_AUTHOR("Stefan Achatz" ); |
460 | MODULE_DESCRIPTION("USB Roccat char device" ); |
461 | MODULE_LICENSE("GPL v2" ); |
462 | |