2
0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-24 21:24:00 +08:00
linux-next/drivers/media/rc/lirc_dev.c
David Härdeman b15e39379f [media] media: lirc_dev: merge struct irctl into struct lirc_dev
The use of two separate structs (lirc_dev aka lirc_driver and irctl) makes
it much harder to follow the proper lifetime of the various structs and
necessitates hacks such as keeping a copy of struct lirc_dev inside
struct irctl.

Merging the two structs means that lirc_dev can properly manage the
lifetime of the resulting struct and simplifies the code at the same time.

[mchehab@s-opensource.com: fix merge conflict]
Signed-off-by: David Härdeman <david@hardeman.nu>
Signed-off-by: Sean Young <sean@mess.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2017-10-04 14:53:07 -03:00

535 lines
11 KiB
C

/*
* LIRC base driver
*
* by Artur Lipowski <alipowski@interia.pl>
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h>
#include <linux/sched/signal.h>
#include <linux/ioctl.h>
#include <linux/poll.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/idr.h>
#include <media/rc-core.h>
#include <media/lirc.h>
#include <media/lirc_dev.h>
#define LOGHEAD "lirc_dev (%s[%d]): "
static dev_t lirc_base_dev;
/* Used to keep track of allocated lirc devices */
#define LIRC_MAX_DEVICES 256
static DEFINE_IDA(lirc_ida);
/* Only used for sysfs but defined to void otherwise */
static struct class *lirc_class;
static void lirc_release_device(struct device *ld)
{
struct lirc_dev *d = container_of(ld, struct lirc_dev, dev);
put_device(d->dev.parent);
if (d->buf_internal) {
lirc_buffer_free(d->buf);
kfree(d->buf);
d->buf = NULL;
}
kfree(d);
module_put(THIS_MODULE);
}
static int lirc_allocate_buffer(struct lirc_dev *d)
{
int err;
if (d->buf) {
d->buf_internal = false;
return 0;
}
d->buf = kmalloc(sizeof(*d->buf), GFP_KERNEL);
if (!d->buf)
return -ENOMEM;
err = lirc_buffer_init(d->buf, d->chunk_size, d->buffer_size);
if (err) {
kfree(d->buf);
d->buf = NULL;
return err;
}
d->buf_internal = true;
return 0;
}
struct lirc_dev *
lirc_allocate_device(void)
{
struct lirc_dev *d;
d = kzalloc(sizeof(*d), GFP_KERNEL);
if (d) {
mutex_init(&d->mutex);
device_initialize(&d->dev);
d->dev.class = lirc_class;
d->dev.release = lirc_release_device;
__module_get(THIS_MODULE);
}
return d;
}
EXPORT_SYMBOL(lirc_allocate_device);
void lirc_free_device(struct lirc_dev *d)
{
if (!d)
return;
put_device(&d->dev);
}
EXPORT_SYMBOL(lirc_free_device);
int lirc_register_device(struct lirc_dev *d)
{
int minor;
int err;
if (!d) {
pr_err("driver pointer must be not NULL!\n");
return -EBADRQC;
}
if (!d->dev.parent) {
pr_err("dev parent pointer not filled in!\n");
return -EINVAL;
}
if (!d->fops) {
pr_err("fops pointer not filled in!\n");
return -EINVAL;
}
if (!d->buf && d->chunk_size < 1) {
pr_err("chunk_size must be set!\n");
return -EINVAL;
}
if (!d->buf && d->buffer_size < 1) {
pr_err("buffer_size must be set!\n");
return -EINVAL;
}
if (d->code_length < 1 || d->code_length > (BUFLEN * 8)) {
dev_err(&d->dev, "code length must be less than %d bits\n",
BUFLEN * 8);
return -EBADRQC;
}
if (!d->buf && !(d->fops && d->fops->read &&
d->fops->poll && d->fops->unlocked_ioctl)) {
dev_err(&d->dev, "undefined read, poll, ioctl\n");
return -EBADRQC;
}
/* some safety check 8-) */
d->name[sizeof(d->name) - 1] = '\0';
if (d->features == 0)
d->features = LIRC_CAN_REC_LIRCCODE;
if (LIRC_CAN_REC(d->features)) {
err = lirc_allocate_buffer(d);
if (err)
return err;
}
minor = ida_simple_get(&lirc_ida, 0, LIRC_MAX_DEVICES, GFP_KERNEL);
if (minor < 0)
return minor;
d->minor = minor;
d->dev.devt = MKDEV(MAJOR(lirc_base_dev), d->minor);
dev_set_name(&d->dev, "lirc%d", d->minor);
cdev_init(&d->cdev, d->fops);
d->cdev.owner = d->owner;
d->attached = true;
err = cdev_device_add(&d->cdev, &d->dev);
if (err) {
ida_simple_remove(&lirc_ida, minor);
return err;
}
get_device(d->dev.parent);
dev_info(&d->dev, "lirc_dev: driver %s registered at minor = %d\n",
d->name, d->minor);
return 0;
}
EXPORT_SYMBOL(lirc_register_device);
void lirc_unregister_device(struct lirc_dev *d)
{
if (!d)
return;
dev_dbg(&d->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
d->name, d->minor);
mutex_lock(&d->mutex);
d->attached = false;
if (d->open) {
dev_dbg(&d->dev, LOGHEAD "releasing opened driver\n",
d->name, d->minor);
wake_up_interruptible(&d->buf->wait_poll);
}
mutex_unlock(&d->mutex);
cdev_device_del(&d->cdev, &d->dev);
ida_simple_remove(&lirc_ida, d->minor);
put_device(&d->dev);
}
EXPORT_SYMBOL(lirc_unregister_device);
int lirc_dev_fop_open(struct inode *inode, struct file *file)
{
struct lirc_dev *d = container_of(inode->i_cdev, struct lirc_dev, cdev);
int retval;
dev_dbg(&d->dev, LOGHEAD "open called\n", d->name, d->minor);
retval = mutex_lock_interruptible(&d->mutex);
if (retval)
return retval;
if (!d->attached) {
retval = -ENODEV;
goto out;
}
if (d->open) {
retval = -EBUSY;
goto out;
}
if (d->rdev) {
retval = rc_open(d->rdev);
if (retval)
goto out;
}
if (d->buf)
lirc_buffer_clear(d->buf);
d->open++;
lirc_init_pdata(inode, file);
nonseekable_open(inode, file);
mutex_unlock(&d->mutex);
return 0;
out:
mutex_unlock(&d->mutex);
return retval;
}
EXPORT_SYMBOL(lirc_dev_fop_open);
int lirc_dev_fop_close(struct inode *inode, struct file *file)
{
struct lirc_dev *d = file->private_data;
mutex_lock(&d->mutex);
rc_close(d->rdev);
d->open--;
mutex_unlock(&d->mutex);
return 0;
}
EXPORT_SYMBOL(lirc_dev_fop_close);
unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait)
{
struct lirc_dev *d = file->private_data;
unsigned int ret;
if (!d->attached)
return POLLHUP | POLLERR;
if (d->buf) {
poll_wait(file, &d->buf->wait_poll, wait);
if (lirc_buffer_empty(d->buf))
ret = 0;
else
ret = POLLIN | POLLRDNORM;
} else {
ret = POLLERR;
}
dev_dbg(&d->dev, LOGHEAD "poll result = %d\n", d->name, d->minor, ret);
return ret;
}
EXPORT_SYMBOL(lirc_dev_fop_poll);
long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct lirc_dev *d = file->private_data;
__u32 mode;
int result;
dev_dbg(&d->dev, LOGHEAD "ioctl called (0x%x)\n",
d->name, d->minor, cmd);
result = mutex_lock_interruptible(&d->mutex);
if (result)
return result;
if (!d->attached) {
result = -ENODEV;
goto out;
}
switch (cmd) {
case LIRC_GET_FEATURES:
result = put_user(d->features, (__u32 __user *)arg);
break;
case LIRC_GET_REC_MODE:
if (!LIRC_CAN_REC(d->features)) {
result = -ENOTTY;
break;
}
result = put_user(LIRC_REC2MODE
(d->features & LIRC_CAN_REC_MASK),
(__u32 __user *)arg);
break;
case LIRC_SET_REC_MODE:
if (!LIRC_CAN_REC(d->features)) {
result = -ENOTTY;
break;
}
result = get_user(mode, (__u32 __user *)arg);
if (!result && !(LIRC_MODE2REC(mode) & d->features))
result = -EINVAL;
/*
* FIXME: We should actually set the mode somehow but
* for now, lirc_serial doesn't support mode changing either
*/
break;
case LIRC_GET_LENGTH:
result = put_user(d->code_length, (__u32 __user *)arg);
break;
case LIRC_GET_MIN_TIMEOUT:
if (!(d->features & LIRC_CAN_SET_REC_TIMEOUT) ||
d->min_timeout == 0) {
result = -ENOTTY;
break;
}
result = put_user(d->min_timeout, (__u32 __user *)arg);
break;
case LIRC_GET_MAX_TIMEOUT:
if (!(d->features & LIRC_CAN_SET_REC_TIMEOUT) ||
d->max_timeout == 0) {
result = -ENOTTY;
break;
}
result = put_user(d->max_timeout, (__u32 __user *)arg);
break;
default:
result = -ENOTTY;
}
out:
mutex_unlock(&d->mutex);
return result;
}
EXPORT_SYMBOL(lirc_dev_fop_ioctl);
ssize_t lirc_dev_fop_read(struct file *file,
char __user *buffer,
size_t length,
loff_t *ppos)
{
struct lirc_dev *d = file->private_data;
unsigned char *buf;
int ret, written = 0;
DECLARE_WAITQUEUE(wait, current);
buf = kzalloc(d->buf->chunk_size, GFP_KERNEL);
if (!buf)
return -ENOMEM;
dev_dbg(&d->dev, LOGHEAD "read called\n", d->name, d->minor);
ret = mutex_lock_interruptible(&d->mutex);
if (ret) {
kfree(buf);
return ret;
}
if (!d->attached) {
ret = -ENODEV;
goto out_locked;
}
if (!LIRC_CAN_REC(d->features)) {
ret = -EINVAL;
goto out_locked;
}
if (length % d->buf->chunk_size) {
ret = -EINVAL;
goto out_locked;
}
/*
* we add ourselves to the task queue before buffer check
* to avoid losing scan code (in case when queue is awaken somewhere
* between while condition checking and scheduling)
*/
add_wait_queue(&d->buf->wait_poll, &wait);
/*
* while we didn't provide 'length' bytes, device is opened in blocking
* mode and 'copy_to_user' is happy, wait for data.
*/
while (written < length && ret == 0) {
if (lirc_buffer_empty(d->buf)) {
/* According to the read(2) man page, 'written' can be
* returned as less than 'length', instead of blocking
* again, returning -EWOULDBLOCK, or returning
* -ERESTARTSYS
*/
if (written)
break;
if (file->f_flags & O_NONBLOCK) {
ret = -EWOULDBLOCK;
break;
}
if (signal_pending(current)) {
ret = -ERESTARTSYS;
break;
}
mutex_unlock(&d->mutex);
set_current_state(TASK_INTERRUPTIBLE);
schedule();
set_current_state(TASK_RUNNING);
ret = mutex_lock_interruptible(&d->mutex);
if (ret) {
remove_wait_queue(&d->buf->wait_poll, &wait);
goto out_unlocked;
}
if (!d->attached) {
ret = -ENODEV;
goto out_locked;
}
} else {
lirc_buffer_read(d->buf, buf);
ret = copy_to_user((void __user *)buffer+written, buf,
d->buf->chunk_size);
if (!ret)
written += d->buf->chunk_size;
else
ret = -EFAULT;
}
}
remove_wait_queue(&d->buf->wait_poll, &wait);
out_locked:
mutex_unlock(&d->mutex);
out_unlocked:
kfree(buf);
return ret ? ret : written;
}
EXPORT_SYMBOL(lirc_dev_fop_read);
void lirc_init_pdata(struct inode *inode, struct file *file)
{
struct lirc_dev *d = container_of(inode->i_cdev, struct lirc_dev, cdev);
file->private_data = d;
}
EXPORT_SYMBOL(lirc_init_pdata);
void *lirc_get_pdata(struct file *file)
{
struct lirc_dev *d = file->private_data;
return d->data;
}
EXPORT_SYMBOL(lirc_get_pdata);
static int __init lirc_dev_init(void)
{
int retval;
lirc_class = class_create(THIS_MODULE, "lirc");
if (IS_ERR(lirc_class)) {
pr_err("class_create failed\n");
return PTR_ERR(lirc_class);
}
retval = alloc_chrdev_region(&lirc_base_dev, 0, LIRC_MAX_DEVICES,
"BaseRemoteCtl");
if (retval) {
class_destroy(lirc_class);
pr_err("alloc_chrdev_region failed\n");
return retval;
}
pr_info("IR Remote Control driver registered, major %d\n",
MAJOR(lirc_base_dev));
return 0;
}
static void __exit lirc_dev_exit(void)
{
class_destroy(lirc_class);
unregister_chrdev_region(lirc_base_dev, LIRC_MAX_DEVICES);
pr_info("module unloaded\n");
}
module_init(lirc_dev_init);
module_exit(lirc_dev_exit);
MODULE_DESCRIPTION("LIRC base driver module");
MODULE_AUTHOR("Artur Lipowski");
MODULE_LICENSE("GPL");