mirror of
https://github.com/sysprog21/lkmpg.git
synced 2024-11-29 12:16:41 +08:00
04465b1a44
The description of the attribute was added in sysfs section and referenced in vinput section. In vinput section, just described the class_attribute and some macros about sysfs class. Add file name at vinput-related examples begin.
403 lines
9.5 KiB
C
403 lines
9.5 KiB
C
/*
|
|
* vinput.c
|
|
*/
|
|
|
|
#include <linux/cdev.h>
|
|
#include <linux/input.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "vinput.h"
|
|
|
|
#define DRIVER_NAME "vinput"
|
|
|
|
#define dev_to_vinput(dev) container_of(dev, struct vinput, dev)
|
|
|
|
static DECLARE_BITMAP(vinput_ids, VINPUT_MINORS);
|
|
|
|
static LIST_HEAD(vinput_devices);
|
|
static LIST_HEAD(vinput_vdevices);
|
|
|
|
static int vinput_dev;
|
|
static struct spinlock vinput_lock;
|
|
static struct class vinput_class;
|
|
|
|
/* Search the name of vinput device in the vinput_devices linked list,
|
|
* which added at vinput_register().
|
|
*/
|
|
static struct vinput_device *vinput_get_device_by_type(const char *type)
|
|
{
|
|
int found = 0;
|
|
struct vinput_device *vinput;
|
|
struct list_head *curr;
|
|
|
|
spin_lock(&vinput_lock);
|
|
list_for_each (curr, &vinput_devices) {
|
|
vinput = list_entry(curr, struct vinput_device, list);
|
|
if (vinput && strncmp(type, vinput->name, strlen(vinput->name)) == 0) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock(&vinput_lock);
|
|
|
|
if (found)
|
|
return vinput;
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
|
|
/* Search the id of virtual device in the vinput_vdevices linked list,
|
|
* which added at vinput_alloc_vdevice().
|
|
*/
|
|
static struct vinput *vinput_get_vdevice_by_id(long id)
|
|
{
|
|
struct vinput *vinput = NULL;
|
|
struct list_head *curr;
|
|
|
|
spin_lock(&vinput_lock);
|
|
list_for_each (curr, &vinput_vdevices) {
|
|
vinput = list_entry(curr, struct vinput, list);
|
|
if (vinput && vinput->id == id)
|
|
break;
|
|
}
|
|
spin_unlock(&vinput_lock);
|
|
|
|
if (vinput && vinput->id == id)
|
|
return vinput;
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
|
|
static int vinput_open(struct inode *inode, struct file *file)
|
|
{
|
|
int err = 0;
|
|
struct vinput *vinput = NULL;
|
|
|
|
vinput = vinput_get_vdevice_by_id(iminor(inode));
|
|
|
|
if (IS_ERR(vinput))
|
|
err = PTR_ERR(vinput);
|
|
else
|
|
file->private_data = vinput;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int vinput_release(struct inode *inode, struct file *file)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t vinput_read(struct file *file, char __user *buffer, size_t count,
|
|
loff_t *offset)
|
|
{
|
|
int len;
|
|
char buff[VINPUT_MAX_LEN + 1];
|
|
struct vinput *vinput = file->private_data;
|
|
|
|
len = vinput->type->ops->read(vinput, buff, count);
|
|
|
|
if (*offset > len)
|
|
count = 0;
|
|
else if (count + *offset > VINPUT_MAX_LEN)
|
|
count = len - *offset;
|
|
|
|
if (raw_copy_to_user(buffer, buff + *offset, count))
|
|
count = -EFAULT;
|
|
|
|
*offset += count;
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t vinput_write(struct file *file, const char __user *buffer,
|
|
size_t count, loff_t *offset)
|
|
{
|
|
char buff[VINPUT_MAX_LEN + 1];
|
|
struct vinput *vinput = file->private_data;
|
|
|
|
memset(buff, 0, sizeof(char) * (VINPUT_MAX_LEN + 1));
|
|
|
|
if (count > VINPUT_MAX_LEN) {
|
|
dev_warn(&vinput->dev, "Too long. %d bytes allowed\n", VINPUT_MAX_LEN);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (raw_copy_from_user(buff, buffer, count))
|
|
return -EFAULT;
|
|
|
|
return vinput->type->ops->send(vinput, buff, count);
|
|
}
|
|
|
|
static const struct file_operations vinput_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = vinput_open,
|
|
.release = vinput_release,
|
|
.read = vinput_read,
|
|
.write = vinput_write,
|
|
};
|
|
|
|
static void vinput_unregister_vdevice(struct vinput *vinput)
|
|
{
|
|
input_unregister_device(vinput->input);
|
|
if (vinput->type->ops->kill)
|
|
vinput->type->ops->kill(vinput);
|
|
}
|
|
|
|
static void vinput_destroy_vdevice(struct vinput *vinput)
|
|
{
|
|
/* Remove from the list first */
|
|
spin_lock(&vinput_lock);
|
|
list_del(&vinput->list);
|
|
clear_bit(vinput->id, vinput_ids);
|
|
spin_unlock(&vinput_lock);
|
|
|
|
module_put(THIS_MODULE);
|
|
|
|
kfree(vinput);
|
|
}
|
|
|
|
static void vinput_release_dev(struct device *dev)
|
|
{
|
|
struct vinput *vinput = dev_to_vinput(dev);
|
|
int id = vinput->id;
|
|
|
|
vinput_destroy_vdevice(vinput);
|
|
|
|
pr_debug("released vinput%d.\n", id);
|
|
}
|
|
|
|
static struct vinput *vinput_alloc_vdevice(void)
|
|
{
|
|
int err;
|
|
struct vinput *vinput = kzalloc(sizeof(struct vinput), GFP_KERNEL);
|
|
|
|
try_module_get(THIS_MODULE);
|
|
|
|
memset(vinput, 0, sizeof(struct vinput));
|
|
|
|
spin_lock_init(&vinput->lock);
|
|
|
|
spin_lock(&vinput_lock);
|
|
vinput->id = find_first_zero_bit(vinput_ids, VINPUT_MINORS);
|
|
if (vinput->id >= VINPUT_MINORS) {
|
|
err = -ENOBUFS;
|
|
goto fail_id;
|
|
}
|
|
set_bit(vinput->id, vinput_ids);
|
|
list_add(&vinput->list, &vinput_vdevices);
|
|
spin_unlock(&vinput_lock);
|
|
|
|
/* allocate the input device */
|
|
vinput->input = input_allocate_device();
|
|
if (vinput->input == NULL) {
|
|
pr_err("vinput: Cannot allocate vinput input device\n");
|
|
err = -ENOMEM;
|
|
goto fail_input_dev;
|
|
}
|
|
|
|
/* initialize device */
|
|
vinput->dev.class = &vinput_class;
|
|
vinput->dev.release = vinput_release_dev;
|
|
vinput->dev.devt = MKDEV(vinput_dev, vinput->id);
|
|
dev_set_name(&vinput->dev, DRIVER_NAME "%lu", vinput->id);
|
|
|
|
return vinput;
|
|
|
|
fail_input_dev:
|
|
spin_lock(&vinput_lock);
|
|
list_del(&vinput->list);
|
|
fail_id:
|
|
spin_unlock(&vinput_lock);
|
|
module_put(THIS_MODULE);
|
|
kfree(vinput);
|
|
|
|
return ERR_PTR(err);
|
|
}
|
|
|
|
static int vinput_register_vdevice(struct vinput *vinput)
|
|
{
|
|
int err = 0;
|
|
|
|
/* register the input device */
|
|
vinput->input->name = vinput->type->name;
|
|
vinput->input->phys = "vinput";
|
|
vinput->input->dev.parent = &vinput->dev;
|
|
|
|
vinput->input->id.bustype = BUS_VIRTUAL;
|
|
vinput->input->id.product = 0x0000;
|
|
vinput->input->id.vendor = 0x0000;
|
|
vinput->input->id.version = 0x0000;
|
|
|
|
err = vinput->type->ops->init(vinput);
|
|
|
|
if (err == 0)
|
|
dev_info(&vinput->dev, "Registered virtual input %s %ld\n",
|
|
vinput->type->name, vinput->id);
|
|
|
|
return err;
|
|
}
|
|
|
|
static ssize_t export_store(struct class *class, struct class_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
int err;
|
|
struct vinput *vinput;
|
|
struct vinput_device *device;
|
|
|
|
device = vinput_get_device_by_type(buf);
|
|
if (IS_ERR(device)) {
|
|
pr_info("vinput: This virtual device isn't registered\n");
|
|
err = PTR_ERR(device);
|
|
goto fail;
|
|
}
|
|
|
|
vinput = vinput_alloc_vdevice();
|
|
if (IS_ERR(vinput)) {
|
|
err = PTR_ERR(vinput);
|
|
goto fail;
|
|
}
|
|
|
|
vinput->type = device;
|
|
err = device_register(&vinput->dev);
|
|
if (err < 0)
|
|
goto fail_register;
|
|
|
|
err = vinput_register_vdevice(vinput);
|
|
if (err < 0)
|
|
goto fail_register_vinput;
|
|
|
|
return len;
|
|
|
|
fail_register_vinput:
|
|
device_unregister(&vinput->dev);
|
|
fail_register:
|
|
vinput_destroy_vdevice(vinput);
|
|
fail:
|
|
return err;
|
|
}
|
|
/* This macro generates class_attr_export structure and export_store() */
|
|
static CLASS_ATTR_WO(export);
|
|
|
|
static ssize_t unexport_store(struct class *class, struct class_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
int err;
|
|
unsigned long id;
|
|
struct vinput *vinput;
|
|
|
|
err = kstrtol(buf, 10, &id);
|
|
if (err) {
|
|
err = -EINVAL;
|
|
goto failed;
|
|
}
|
|
|
|
vinput = vinput_get_vdevice_by_id(id);
|
|
if (IS_ERR(vinput)) {
|
|
pr_err("vinput: No such vinput device %ld\n", id);
|
|
err = PTR_ERR(vinput);
|
|
goto failed;
|
|
}
|
|
|
|
vinput_unregister_vdevice(vinput);
|
|
device_unregister(&vinput->dev);
|
|
|
|
return len;
|
|
failed:
|
|
return err;
|
|
}
|
|
/* This macro generates class_attr_unexport structure and unexport_store() */
|
|
static CLASS_ATTR_WO(unexport);
|
|
|
|
static struct attribute *vinput_class_attrs[] = {
|
|
&class_attr_export.attr,
|
|
&class_attr_unexport.attr,
|
|
NULL,
|
|
};
|
|
|
|
/* This macro generates vinput_class_groups structure */
|
|
ATTRIBUTE_GROUPS(vinput_class);
|
|
|
|
static struct class vinput_class = {
|
|
.name = "vinput",
|
|
.owner = THIS_MODULE,
|
|
.class_groups = vinput_class_groups,
|
|
};
|
|
|
|
int vinput_register(struct vinput_device *dev)
|
|
{
|
|
spin_lock(&vinput_lock);
|
|
list_add(&dev->list, &vinput_devices);
|
|
spin_unlock(&vinput_lock);
|
|
|
|
pr_info("vinput: registered new virtual input device '%s'\n", dev->name);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(vinput_register);
|
|
|
|
void vinput_unregister(struct vinput_device *dev)
|
|
{
|
|
struct list_head *curr, *next;
|
|
|
|
/* Remove from the list first */
|
|
spin_lock(&vinput_lock);
|
|
list_del(&dev->list);
|
|
spin_unlock(&vinput_lock);
|
|
|
|
/* unregister all devices of this type */
|
|
list_for_each_safe (curr, next, &vinput_vdevices) {
|
|
struct vinput *vinput = list_entry(curr, struct vinput, list);
|
|
if (vinput && vinput->type == dev) {
|
|
vinput_unregister_vdevice(vinput);
|
|
device_unregister(&vinput->dev);
|
|
}
|
|
}
|
|
|
|
pr_info("vinput: unregistered virtual input device '%s'\n", dev->name);
|
|
}
|
|
EXPORT_SYMBOL(vinput_unregister);
|
|
|
|
static int __init vinput_init(void)
|
|
{
|
|
int err = 0;
|
|
|
|
pr_info("vinput: Loading virtual input driver\n");
|
|
|
|
vinput_dev = register_chrdev(0, DRIVER_NAME, &vinput_fops);
|
|
if (vinput_dev < 0) {
|
|
pr_err("vinput: Unable to allocate char dev region\n");
|
|
goto failed_alloc;
|
|
}
|
|
|
|
spin_lock_init(&vinput_lock);
|
|
|
|
err = class_register(&vinput_class);
|
|
if (err < 0) {
|
|
pr_err("vinput: Unable to register vinput class\n");
|
|
goto failed_class;
|
|
}
|
|
|
|
return 0;
|
|
failed_class:
|
|
class_unregister(&vinput_class);
|
|
failed_alloc:
|
|
return err;
|
|
}
|
|
|
|
static void __exit vinput_end(void)
|
|
{
|
|
pr_info("vinput: Unloading virtual input driver\n");
|
|
|
|
unregister_chrdev(vinput_dev, DRIVER_NAME);
|
|
class_unregister(&vinput_class);
|
|
}
|
|
|
|
module_init(vinput_init);
|
|
module_exit(vinput_end);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("Emulate input events");
|