linux/drivers/input/misc/uinput.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  User level driver support for input subsystem
 *
 * Heavily based on evdev.c by Vojtech Pavlik
 *
 * Author: Aristeu Sergio Rozanski Filho <[email protected]>
 *
 * Changes/Revisions:
 *	0.4	01/09/2014 (Benjamin Tissoires <[email protected]>)
 *		- add UI_GET_SYSNAME ioctl
 *	0.3	09/04/2006 (Anssi Hannula <[email protected]>)
 *		- updated ff support for the changes in kernel interface
 *		- added MODULE_VERSION
 *	0.2	16/10/2004 (Micah Dowty <[email protected]>)
 *		- added force feedback support
 *              - added UI_SET_PHYS
 *	0.1	20/06/2002
 *		- first public version
 */
#include <uapi/linux/uinput.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/overflow.h>
#include <linux/input/mt.h>
#include "../input-compat.h"

#define UINPUT_NAME
#define UINPUT_BUFFER_SIZE
#define UINPUT_NUM_REQUESTS
#define UINPUT_TIMESTAMP_ALLOWED_OFFSET_SECS

enum uinput_state {};

struct uinput_request {};

struct uinput_device {};

static int uinput_dev_event(struct input_dev *dev,
			    unsigned int type, unsigned int code, int value)
{}

/* Atomically allocate an ID for the given request. Returns 0 on success. */
static bool uinput_request_alloc_id(struct uinput_device *udev,
				    struct uinput_request *request)
{}

static struct uinput_request *uinput_request_find(struct uinput_device *udev,
						  unsigned int id)
{}

static int uinput_request_reserve_slot(struct uinput_device *udev,
				       struct uinput_request *request)
{}

static void uinput_request_release_slot(struct uinput_device *udev,
					unsigned int id)
{}

static int uinput_request_send(struct uinput_device *udev,
			       struct uinput_request *request)
{}

static int uinput_request_submit(struct uinput_device *udev,
				 struct uinput_request *request)
{}

/*
 * Fail all outstanding requests so handlers don't wait for the userspace
 * to finish processing them.
 */
static void uinput_flush_requests(struct uinput_device *udev)
{}

static void uinput_dev_set_gain(struct input_dev *dev, u16 gain)
{}

static void uinput_dev_set_autocenter(struct input_dev *dev, u16 magnitude)
{}

static int uinput_dev_playback(struct input_dev *dev, int effect_id, int value)
{}

static int uinput_dev_upload_effect(struct input_dev *dev,
				    struct ff_effect *effect,
				    struct ff_effect *old)
{}

static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
{}

static int uinput_dev_flush(struct input_dev *dev, struct file *file)
{}

static void uinput_destroy_device(struct uinput_device *udev)
{}

static int uinput_create_device(struct uinput_device *udev)
{}

static int uinput_open(struct inode *inode, struct file *file)
{}

static int uinput_validate_absinfo(struct input_dev *dev, unsigned int code,
				   const struct input_absinfo *abs)
{}

static int uinput_validate_absbits(struct input_dev *dev)
{}

static int uinput_dev_setup(struct uinput_device *udev,
			    struct uinput_setup __user *arg)
{}

static int uinput_abs_setup(struct uinput_device *udev,
			    struct uinput_setup __user *arg, size_t size)
{}

/* legacy setup via write() */
static int uinput_setup_device_legacy(struct uinput_device *udev,
				      const char __user *buffer, size_t count)
{}

/*
 * Returns true if the given timestamp is valid (i.e., if all the following
 * conditions are satisfied), false otherwise.
 * 1) given timestamp is positive
 * 2) it's within the allowed offset before the current time
 * 3) it's not in the future
 */
static bool is_valid_timestamp(const ktime_t timestamp)
{}

static ssize_t uinput_inject_events(struct uinput_device *udev,
				    const char __user *buffer, size_t count)
{}

static ssize_t uinput_write(struct file *file, const char __user *buffer,
			    size_t count, loff_t *ppos)
{}

static bool uinput_fetch_next_event(struct uinput_device *udev,
				    struct input_event *event)
{}

static ssize_t uinput_events_to_user(struct uinput_device *udev,
				     char __user *buffer, size_t count)
{}

static ssize_t uinput_read(struct file *file, char __user *buffer,
			   size_t count, loff_t *ppos)
{}

static __poll_t uinput_poll(struct file *file, poll_table *wait)
{}

static int uinput_release(struct inode *inode, struct file *file)
{}

#ifdef CONFIG_COMPAT
struct uinput_ff_upload_compat {};

static int uinput_ff_upload_to_user(char __user *buffer,
				    const struct uinput_ff_upload *ff_up)
{}

static int uinput_ff_upload_from_user(const char __user *buffer,
				      struct uinput_ff_upload *ff_up)
{}

#else

static int uinput_ff_upload_to_user(char __user *buffer,
				    const struct uinput_ff_upload *ff_up)
{
	if (copy_to_user(buffer, ff_up, sizeof(struct uinput_ff_upload)))
		return -EFAULT;

	return 0;
}

static int uinput_ff_upload_from_user(const char __user *buffer,
				      struct uinput_ff_upload *ff_up)
{
	if (copy_from_user(ff_up, buffer, sizeof(struct uinput_ff_upload)))
		return -EFAULT;

	return 0;
}

#endif

#define uinput_set_bit(_arg, _bit, _max)

static int uinput_str_to_user(void __user *dest, const char *str,
			      unsigned int maxlen)
{}

static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
				 unsigned long arg, void __user *p)
{}

static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{}

#ifdef CONFIG_COMPAT

/*
 * These IOCTLs change their size and thus their numbers between
 * 32 and 64 bits.
 */
#define UI_SET_PHYS_COMPAT
#define UI_BEGIN_FF_UPLOAD_COMPAT
#define UI_END_FF_UPLOAD_COMPAT

static long uinput_compat_ioctl(struct file *file,
				unsigned int cmd, unsigned long arg)
{}
#endif

static const struct file_operations uinput_fops =;

static struct miscdevice uinput_misc =;
module_misc_device();

MODULE_ALIAS_MISCDEV();
MODULE_ALIAS();

MODULE_AUTHOR();
MODULE_DESCRIPTION();
MODULE_LICENSE();