1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
20#include <linux/module.h>
21#include <linux/sched/signal.h>
22#include <linux/ioctl.h>
23#include <linux/poll.h>
24#include <linux/mutex.h>
25#include <linux/device.h>
26#include <linux/cdev.h>
27
28#include <media/rc-core.h>
29#include <media/lirc.h>
30#include <media/lirc_dev.h>
31
32#define NOPLUG -1
33#define LOGHEAD "lirc_dev (%s[%d]): "
34
35static dev_t lirc_base_dev;
36
37struct irctl {
38 struct lirc_driver d;
39 int attached;
40 int open;
41
42 struct mutex irctl_lock;
43 struct lirc_buffer *buf;
44 bool buf_internal;
45 unsigned int chunk_size;
46
47 struct device dev;
48 struct cdev cdev;
49};
50
51static DEFINE_MUTEX(lirc_dev_lock);
52
53static struct irctl *irctls[MAX_IRCTL_DEVICES];
54
55
56static struct class *lirc_class;
57
58static void lirc_release(struct device *ld)
59{
60 struct irctl *ir = container_of(ld, struct irctl, dev);
61
62 if (ir->buf_internal) {
63 lirc_buffer_free(ir->buf);
64 kfree(ir->buf);
65 }
66
67 mutex_lock(&lirc_dev_lock);
68 irctls[ir->d.minor] = NULL;
69 mutex_unlock(&lirc_dev_lock);
70 kfree(ir);
71}
72
73static int lirc_allocate_buffer(struct irctl *ir)
74{
75 int err = 0;
76 int bytes_in_key;
77 unsigned int chunk_size;
78 unsigned int buffer_size;
79 struct lirc_driver *d = &ir->d;
80
81 bytes_in_key = BITS_TO_LONGS(d->code_length) +
82 (d->code_length % 8 ? 1 : 0);
83 buffer_size = d->buffer_size ? d->buffer_size : BUFLEN / bytes_in_key;
84 chunk_size = d->chunk_size ? d->chunk_size : bytes_in_key;
85
86 if (d->rbuf) {
87 ir->buf = d->rbuf;
88 ir->buf_internal = false;
89 } else {
90 ir->buf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
91 if (!ir->buf) {
92 err = -ENOMEM;
93 goto out;
94 }
95
96 err = lirc_buffer_init(ir->buf, chunk_size, buffer_size);
97 if (err) {
98 kfree(ir->buf);
99 ir->buf = NULL;
100 goto out;
101 }
102
103 ir->buf_internal = true;
104 d->rbuf = ir->buf;
105 }
106 ir->chunk_size = ir->buf->chunk_size;
107
108out:
109 return err;
110}
111
112int lirc_register_driver(struct lirc_driver *d)
113{
114 struct irctl *ir;
115 int minor;
116 int err;
117
118 if (!d) {
119 pr_err("driver pointer must be not NULL!\n");
120 return -EBADRQC;
121 }
122
123 if (!d->dev) {
124 pr_err("dev pointer not filled in!\n");
125 return -EINVAL;
126 }
127
128 if (!d->fops) {
129 pr_err("fops pointer not filled in!\n");
130 return -EINVAL;
131 }
132
133 if (d->minor >= MAX_IRCTL_DEVICES) {
134 dev_err(d->dev, "minor must be between 0 and %d!\n",
135 MAX_IRCTL_DEVICES - 1);
136 return -EBADRQC;
137 }
138
139 if (d->code_length < 1 || d->code_length > (BUFLEN * 8)) {
140 dev_err(d->dev, "code length must be less than %d bits\n",
141 BUFLEN * 8);
142 return -EBADRQC;
143 }
144
145 if (!d->rbuf && !(d->fops && d->fops->read &&
146 d->fops->poll && d->fops->unlocked_ioctl)) {
147 dev_err(d->dev, "undefined read, poll, ioctl\n");
148 return -EBADRQC;
149 }
150
151 mutex_lock(&lirc_dev_lock);
152
153 minor = d->minor;
154
155 if (minor < 0) {
156
157 for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++)
158 if (!irctls[minor])
159 break;
160 if (minor == MAX_IRCTL_DEVICES) {
161 dev_err(d->dev, "no free slots for drivers!\n");
162 err = -ENOMEM;
163 goto out_lock;
164 }
165 } else if (irctls[minor]) {
166 dev_err(d->dev, "minor (%d) just registered!\n", minor);
167 err = -EBUSY;
168 goto out_lock;
169 }
170
171 ir = kzalloc(sizeof(struct irctl), GFP_KERNEL);
172 if (!ir) {
173 err = -ENOMEM;
174 goto out_lock;
175 }
176
177 mutex_init(&ir->irctl_lock);
178 irctls[minor] = ir;
179 d->minor = minor;
180
181
182 d->name[sizeof(d->name)-1] = '\0';
183
184 if (d->features == 0)
185 d->features = LIRC_CAN_REC_LIRCCODE;
186
187 ir->d = *d;
188
189 if (LIRC_CAN_REC(d->features)) {
190 err = lirc_allocate_buffer(irctls[minor]);
191 if (err) {
192 kfree(ir);
193 goto out_lock;
194 }
195 d->rbuf = ir->buf;
196 }
197
198 device_initialize(&ir->dev);
199 ir->dev.devt = MKDEV(MAJOR(lirc_base_dev), ir->d.minor);
200 ir->dev.class = lirc_class;
201 ir->dev.parent = d->dev;
202 ir->dev.release = lirc_release;
203 dev_set_name(&ir->dev, "lirc%d", ir->d.minor);
204
205 cdev_init(&ir->cdev, d->fops);
206 ir->cdev.owner = ir->d.owner;
207 ir->cdev.kobj.parent = &ir->dev.kobj;
208
209 err = cdev_add(&ir->cdev, ir->dev.devt, 1);
210 if (err)
211 goto out_free_dev;
212
213 ir->attached = 1;
214
215 err = device_add(&ir->dev);
216 if (err)
217 goto out_cdev;
218
219 mutex_unlock(&lirc_dev_lock);
220
221 dev_info(ir->d.dev, "lirc_dev: driver %s registered at minor = %d\n",
222 ir->d.name, ir->d.minor);
223
224 return minor;
225
226out_cdev:
227 cdev_del(&ir->cdev);
228out_free_dev:
229 put_device(&ir->dev);
230out_lock:
231 mutex_unlock(&lirc_dev_lock);
232
233 return err;
234}
235EXPORT_SYMBOL(lirc_register_driver);
236
237int lirc_unregister_driver(int minor)
238{
239 struct irctl *ir;
240
241 if (minor < 0 || minor >= MAX_IRCTL_DEVICES) {
242 pr_err("minor (%d) must be between 0 and %d!\n",
243 minor, MAX_IRCTL_DEVICES - 1);
244 return -EBADRQC;
245 }
246
247 ir = irctls[minor];
248 if (!ir) {
249 pr_err("failed to get irctl\n");
250 return -ENOENT;
251 }
252
253 mutex_lock(&lirc_dev_lock);
254
255 if (ir->d.minor != minor) {
256 dev_err(ir->d.dev, "lirc_dev: minor %d device not registered\n",
257 minor);
258 mutex_unlock(&lirc_dev_lock);
259 return -ENOENT;
260 }
261
262 dev_dbg(ir->d.dev, "lirc_dev: driver %s unregistered from minor = %d\n",
263 ir->d.name, ir->d.minor);
264
265 ir->attached = 0;
266 if (ir->open) {
267 dev_dbg(ir->d.dev, LOGHEAD "releasing opened driver\n",
268 ir->d.name, ir->d.minor);
269 wake_up_interruptible(&ir->buf->wait_poll);
270 }
271
272 mutex_unlock(&lirc_dev_lock);
273
274 device_del(&ir->dev);
275 cdev_del(&ir->cdev);
276 put_device(&ir->dev);
277
278 return 0;
279}
280EXPORT_SYMBOL(lirc_unregister_driver);
281
282int lirc_dev_fop_open(struct inode *inode, struct file *file)
283{
284 struct irctl *ir;
285 int retval = 0;
286
287 if (iminor(inode) >= MAX_IRCTL_DEVICES) {
288 pr_err("open result for %d is -ENODEV\n", iminor(inode));
289 return -ENODEV;
290 }
291
292 if (mutex_lock_interruptible(&lirc_dev_lock))
293 return -ERESTARTSYS;
294
295 ir = irctls[iminor(inode)];
296 mutex_unlock(&lirc_dev_lock);
297
298 if (!ir) {
299 retval = -ENODEV;
300 goto error;
301 }
302
303 dev_dbg(ir->d.dev, LOGHEAD "open called\n", ir->d.name, ir->d.minor);
304
305 if (ir->d.minor == NOPLUG) {
306 retval = -ENODEV;
307 goto error;
308 }
309
310 if (ir->open) {
311 retval = -EBUSY;
312 goto error;
313 }
314
315 if (ir->d.rdev) {
316 retval = rc_open(ir->d.rdev);
317 if (retval)
318 goto error;
319 }
320
321 if (ir->buf)
322 lirc_buffer_clear(ir->buf);
323
324 ir->open++;
325
326error:
327 nonseekable_open(inode, file);
328
329 return retval;
330}
331EXPORT_SYMBOL(lirc_dev_fop_open);
332
333int lirc_dev_fop_close(struct inode *inode, struct file *file)
334{
335 struct irctl *ir = irctls[iminor(inode)];
336 int ret;
337
338 if (!ir) {
339 pr_err("called with invalid irctl\n");
340 return -EINVAL;
341 }
342
343 ret = mutex_lock_killable(&lirc_dev_lock);
344 WARN_ON(ret);
345
346 rc_close(ir->d.rdev);
347
348 ir->open--;
349 if (!ret)
350 mutex_unlock(&lirc_dev_lock);
351
352 return 0;
353}
354EXPORT_SYMBOL(lirc_dev_fop_close);
355
356unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait)
357{
358 struct irctl *ir = irctls[iminor(file_inode(file))];
359 unsigned int ret;
360
361 if (!ir) {
362 pr_err("called with invalid irctl\n");
363 return POLLERR;
364 }
365
366 if (!ir->attached)
367 return POLLHUP | POLLERR;
368
369 if (ir->buf) {
370 poll_wait(file, &ir->buf->wait_poll, wait);
371
372 if (lirc_buffer_empty(ir->buf))
373 ret = 0;
374 else
375 ret = POLLIN | POLLRDNORM;
376 } else
377 ret = POLLERR;
378
379 dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n",
380 ir->d.name, ir->d.minor, ret);
381
382 return ret;
383}
384EXPORT_SYMBOL(lirc_dev_fop_poll);
385
386long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
387{
388 __u32 mode;
389 int result = 0;
390 struct irctl *ir = irctls[iminor(file_inode(file))];
391
392 if (!ir) {
393 pr_err("no irctl found!\n");
394 return -ENODEV;
395 }
396
397 dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n",
398 ir->d.name, ir->d.minor, cmd);
399
400 if (ir->d.minor == NOPLUG || !ir->attached) {
401 dev_err(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n",
402 ir->d.name, ir->d.minor);
403 return -ENODEV;
404 }
405
406 mutex_lock(&ir->irctl_lock);
407
408 switch (cmd) {
409 case LIRC_GET_FEATURES:
410 result = put_user(ir->d.features, (__u32 __user *)arg);
411 break;
412 case LIRC_GET_REC_MODE:
413 if (!LIRC_CAN_REC(ir->d.features)) {
414 result = -ENOTTY;
415 break;
416 }
417
418 result = put_user(LIRC_REC2MODE
419 (ir->d.features & LIRC_CAN_REC_MASK),
420 (__u32 __user *)arg);
421 break;
422 case LIRC_SET_REC_MODE:
423 if (!LIRC_CAN_REC(ir->d.features)) {
424 result = -ENOTTY;
425 break;
426 }
427
428 result = get_user(mode, (__u32 __user *)arg);
429 if (!result && !(LIRC_MODE2REC(mode) & ir->d.features))
430 result = -EINVAL;
431
432
433
434
435 break;
436 case LIRC_GET_LENGTH:
437 result = put_user(ir->d.code_length, (__u32 __user *)arg);
438 break;
439 case LIRC_GET_MIN_TIMEOUT:
440 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
441 ir->d.min_timeout == 0) {
442 result = -ENOTTY;
443 break;
444 }
445
446 result = put_user(ir->d.min_timeout, (__u32 __user *)arg);
447 break;
448 case LIRC_GET_MAX_TIMEOUT:
449 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
450 ir->d.max_timeout == 0) {
451 result = -ENOTTY;
452 break;
453 }
454
455 result = put_user(ir->d.max_timeout, (__u32 __user *)arg);
456 break;
457 default:
458 result = -ENOTTY;
459 }
460
461 mutex_unlock(&ir->irctl_lock);
462
463 return result;
464}
465EXPORT_SYMBOL(lirc_dev_fop_ioctl);
466
467ssize_t lirc_dev_fop_read(struct file *file,
468 char __user *buffer,
469 size_t length,
470 loff_t *ppos)
471{
472 struct irctl *ir = irctls[iminor(file_inode(file))];
473 unsigned char *buf;
474 int ret = 0, written = 0;
475 DECLARE_WAITQUEUE(wait, current);
476
477 if (!ir) {
478 pr_err("called with invalid irctl\n");
479 return -ENODEV;
480 }
481
482 if (!LIRC_CAN_REC(ir->d.features))
483 return -EINVAL;
484
485 dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor);
486
487 buf = kzalloc(ir->chunk_size, GFP_KERNEL);
488 if (!buf)
489 return -ENOMEM;
490
491 if (mutex_lock_interruptible(&ir->irctl_lock)) {
492 ret = -ERESTARTSYS;
493 goto out_unlocked;
494 }
495 if (!ir->attached) {
496 ret = -ENODEV;
497 goto out_locked;
498 }
499
500 if (length % ir->chunk_size) {
501 ret = -EINVAL;
502 goto out_locked;
503 }
504
505
506
507
508
509
510 add_wait_queue(&ir->buf->wait_poll, &wait);
511
512
513
514
515
516 while (written < length && ret == 0) {
517 if (lirc_buffer_empty(ir->buf)) {
518
519
520
521
522
523 if (written)
524 break;
525 if (file->f_flags & O_NONBLOCK) {
526 ret = -EWOULDBLOCK;
527 break;
528 }
529 if (signal_pending(current)) {
530 ret = -ERESTARTSYS;
531 break;
532 }
533
534 mutex_unlock(&ir->irctl_lock);
535 set_current_state(TASK_INTERRUPTIBLE);
536 schedule();
537 set_current_state(TASK_RUNNING);
538
539 if (mutex_lock_interruptible(&ir->irctl_lock)) {
540 ret = -ERESTARTSYS;
541 remove_wait_queue(&ir->buf->wait_poll, &wait);
542 goto out_unlocked;
543 }
544
545 if (!ir->attached) {
546 ret = -ENODEV;
547 goto out_locked;
548 }
549 } else {
550 lirc_buffer_read(ir->buf, buf);
551 ret = copy_to_user((void __user *)buffer+written, buf,
552 ir->buf->chunk_size);
553 if (!ret)
554 written += ir->buf->chunk_size;
555 else
556 ret = -EFAULT;
557 }
558 }
559
560 remove_wait_queue(&ir->buf->wait_poll, &wait);
561
562out_locked:
563 mutex_unlock(&ir->irctl_lock);
564
565out_unlocked:
566 kfree(buf);
567
568 return ret ? ret : written;
569}
570EXPORT_SYMBOL(lirc_dev_fop_read);
571
572void *lirc_get_pdata(struct file *file)
573{
574 return irctls[iminor(file_inode(file))]->d.data;
575}
576EXPORT_SYMBOL(lirc_get_pdata);
577
578
579static int __init lirc_dev_init(void)
580{
581 int retval;
582
583 lirc_class = class_create(THIS_MODULE, "lirc");
584 if (IS_ERR(lirc_class)) {
585 pr_err("class_create failed\n");
586 return PTR_ERR(lirc_class);
587 }
588
589 retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES,
590 "BaseRemoteCtl");
591 if (retval) {
592 class_destroy(lirc_class);
593 pr_err("alloc_chrdev_region failed\n");
594 return retval;
595 }
596
597 pr_info("IR Remote Control driver registered, major %d\n",
598 MAJOR(lirc_base_dev));
599
600 return 0;
601}
602
603static void __exit lirc_dev_exit(void)
604{
605 class_destroy(lirc_class);
606 unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES);
607 pr_info("module unloaded\n");
608}
609
610module_init(lirc_dev_init);
611module_exit(lirc_dev_exit);
612
613MODULE_DESCRIPTION("LIRC base driver module");
614MODULE_AUTHOR("Artur Lipowski");
615MODULE_LICENSE("GPL");
616
