1 /* 2 * LIRC base driver 3 * 4 * by Artur Lipowski <alipowski@interia.pl> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 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 35 static dev_t lirc_base_dev; 36 37 struct 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 51 static DEFINE_MUTEX(lirc_dev_lock); 52 53 static struct irctl *irctls[MAX_IRCTL_DEVICES]; 54 55 /* Only used for sysfs but defined to void otherwise */ 56 static struct class *lirc_class; 57 58 static 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 73 static 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 108 out: 109 return err; 110 } 111 112 int 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 /* find first free slot for driver */ 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 /* some safety check 8-) */ 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 226 out_cdev: 227 cdev_del(&ir->cdev); 228 out_free_dev: 229 put_device(&ir->dev); 230 out_lock: 231 mutex_unlock(&lirc_dev_lock); 232 233 return err; 234 } 235 EXPORT_SYMBOL(lirc_register_driver); 236 237 int 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 } 280 EXPORT_SYMBOL(lirc_unregister_driver); 281 282 int 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 326 error: 327 nonseekable_open(inode, file); 328 329 return retval; 330 } 331 EXPORT_SYMBOL(lirc_dev_fop_open); 332 333 int 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 } 354 EXPORT_SYMBOL(lirc_dev_fop_close); 355 356 unsigned 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 } 384 EXPORT_SYMBOL(lirc_dev_fop_poll); 385 386 long 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 * FIXME: We should actually set the mode somehow but 433 * for now, lirc_serial doesn't support mode changing either 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 } 465 EXPORT_SYMBOL(lirc_dev_fop_ioctl); 466 467 ssize_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 * we add ourselves to the task queue before buffer check 507 * to avoid losing scan code (in case when queue is awaken somewhere 508 * between while condition checking and scheduling) 509 */ 510 add_wait_queue(&ir->buf->wait_poll, &wait); 511 512 /* 513 * while we didn't provide 'length' bytes, device is opened in blocking 514 * mode and 'copy_to_user' is happy, wait for data. 515 */ 516 while (written < length && ret == 0) { 517 if (lirc_buffer_empty(ir->buf)) { 518 /* According to the read(2) man page, 'written' can be 519 * returned as less than 'length', instead of blocking 520 * again, returning -EWOULDBLOCK, or returning 521 * -ERESTARTSYS 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 562 out_locked: 563 mutex_unlock(&ir->irctl_lock); 564 565 out_unlocked: 566 kfree(buf); 567 568 return ret ? ret : written; 569 } 570 EXPORT_SYMBOL(lirc_dev_fop_read); 571 572 void *lirc_get_pdata(struct file *file) 573 { 574 return irctls[iminor(file_inode(file))]->d.data; 575 } 576 EXPORT_SYMBOL(lirc_get_pdata); 577 578 579 static 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 603 static 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 610 module_init(lirc_dev_init); 611 module_exit(lirc_dev_exit); 612 613 MODULE_DESCRIPTION("LIRC base driver module"); 614 MODULE_AUTHOR("Artur Lipowski"); 615 MODULE_LICENSE("GPL"); 616