/*****************************************************************************
*
* evemu - Kernel device emulation
*
* Copyright (C) 2010-2012 Canonical Ltd.
*
* This library is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License version 3
* as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranties of
* MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library. If not, see .
*
* Copyright (C) 2010 Henrik Rydberg
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
****************************************************************************/
#ifndef EVEMU_H
#define EVEMU_H
#include
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
#define EVEMU_VERSION 0x00010000
/**
* evemu_new() - allocate a new evemu device
* @name: wanted input device name (or NULL to leave empty)
*
* This function allocates a new evemu device structure and
* initializes all fields to zero. If name is non-null and the length
* is sane, it is copied to the device name.
*
* Returns NULL in case of memory failure.
*/
struct evemu_device *evemu_new(const char *name);
/**
* evemu_delete() - free and allocated evemu device
* @dev: the device to free
*
* The device pointer is invalidated by this call.
*/
void evemu_delete(struct evemu_device *dev);
/**
* evemu_get_version() - get library version
* @dev: the device in use
*
* Returns the library version used to create this evemu instance. The
* version may differ from the value of EVEMU_VERSION in this header
* file.
*/
unsigned int evemu_get_version(const struct evemu_device *dev);
/**
* evemu_get_name() - get device name
* @dev: the device in use
*
* Returns the name of the device. The pointer is owned by the evemu
* instance and has evemu scope.
*/
const char *evemu_get_name(const struct evemu_device *dev);
/**
* evemu_set_name() - set device name
* @dev: the device in use
*
* Sets the name of the device. If name is non-null and the length is
* sane, it is copied to the device name.
*/
void evemu_set_name(struct evemu_device *dev, const char *name);
/**
* evemu_get_id_bustype() - get kernel device bustype
* @dev: the device in use
*
* Returns the kernel bus type used by the device.
*/
unsigned int evemu_get_id_bustype(const struct evemu_device *dev);
/**
* evemu_set_id_bustype() - set kernel bustype
*
* @dev: the device in use
* @bustype: the bustype value to set.
*/
void evemu_set_id_bustype(struct evemu_device *dev, unsigned int bustype);
/**
* evemu_get_id_vendor() - get kernel device vendor id
* @dev: the device in use
*
* Returns the kernel vendor id used by the device.
*/
unsigned int evemu_get_id_vendor(const struct evemu_device *dev);
/**
* evemu_set_id_vendor() - set kernel device vendor id
*
* @dev: the device in use
* @vendor: the vendor id value to set.
*/
void evemu_set_id_vendor(struct evemu_device *dev, unsigned int vendor);
/**
* evemu_get_id_product() - get kernel device product id
* @dev: the device in use
*
* Returns the kernel product id used by the device.
*/
unsigned int evemu_get_id_product(const struct evemu_device *dev);
/**
* evemu_set_id_product() - set kernel device product id
*
* @dev: the device in use
* @product: the product id value to set.
*/
void evemu_set_id_product(struct evemu_device *dev, unsigned int product);
/**
* evemu_get_id_version() - get kernel device id version
* @dev: the device in use
*
* Returns the kernel device id used by the device.
*/
unsigned int evemu_get_id_version(const struct evemu_device *dev);
/**
* evemu_set_id_version() - set kernel device id version
*
* @dev: the device in use
* @version: the version value to set.
*/
void evemu_set_id_version(struct evemu_device *dev, unsigned int version);
/**
* evemu_get_abs_minimum() - get kernel minimum value of event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns the range minimum of the specified event type.
*/
int evemu_get_abs_minimum(const struct evemu_device *dev, int code);
/**
* evemu_set_abs_minimum() - set kernel minimum value of event type
*
* @dev: the device in use
* @code: the event type code to set
* @min: the minimum value to set
*/
void evemu_set_abs_minimum(struct evemu_device *dev, int code, int min);
/**
* evemu_get_abs_maximum() - get kernel maximum value of event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns the range maximum of the specified event type.
*/
int evemu_get_abs_maximum(const struct evemu_device *dev, int code);
/**
* evemu_get_abs_current_value() - get kernel current value of event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns the current value of the specified event type.
*/
int evemu_get_abs_current_value(const struct evemu_device *dev, int code);
/**
* evemu_set_abs_maximum() - set kernel maximum value of event type
*
* @dev: the device in use
* @code: the event type code to set
* @max: the maximum value to set
*/
void evemu_set_abs_maximum(struct evemu_device *dev, int code, int max);
/**
* evemu_get_abs_maximum() - get kernel filter fuzz of event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns the filter fuzz of the specified event type.
*/
int evemu_get_abs_fuzz(const struct evemu_device *dev, int code);
/**
* evemu_set_abs_fuzz() - set kernel filter fuzz of event type
*
* @dev: the device in use
* @code: the event type code to set
* @fuzz: the fuzz value to set
*/
void evemu_set_abs_fuzz(struct evemu_device *dev, int code, int fuzz);
/**
* evemu_get_abs_maximum() - get kernel flat value of event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns the flat value of the specified event type. Only used for
* joysticks.
*/
int evemu_get_abs_flat(const struct evemu_device *dev, int code);
/**
* evemu_set_abs_flat() - set kernel filter flat of event type
*
* @dev: the device in use
* @code: the event type code to set
* @flat: the flat value to set
*/
void evemu_set_abs_flat(struct evemu_device *dev, int code, int flat);
/**
* evemu_get_abs_resolution() - get kernel resolution of event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns the resolution of the specified event type. Resolution is
* specified in units per millimeter (units/mm), or units per radian
* where appropriate.
*/
int evemu_get_abs_resolution(const struct evemu_device *dev, int code);
/**
* evemu_set_abs_resolution() - set kernel resolution of event type
* @dev: the device in use
* @code: the event type code to set
* @res: the resolution value to set.
*
* Resolution is specified in units per millimeter (units/mm), or units per
* radian where appropriate.
*/
void evemu_set_abs_resolution(struct evemu_device *dev, int code, int res);
/**
* evemu_has_prop() - check if device has a certain property
* @dev: the device in use
* @code: the property type code to query
*
* Returns true if the device has the given property.
*/
int evemu_has_prop(const struct evemu_device *dev, int code);
/**
* evemu_has_event() - check if device has a certain event type
* @dev: the device in use
* @code: the event type code to query
*
* Returns true if the event type is supported by the device.
*/
int evemu_has_event(const struct evemu_device *dev, int type, int code);
/**
* evemu_has_bit() - check if a device has a certain EV_* bit set
* @dev: the device in use
* @type: the EV_* bit to query
*
* Returns true if the event bit is supported by the device.
*/
int evemu_has_bit(const struct evemu_device *dev, int type);
/**
* evemu_extract() - configure evemu instance directly from the kernel device
* @dev: the device in use
* @fd: file descriptor of the kernel device to query
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_extract(struct evemu_device *dev, int fd);
/**
* evemu_write() - write evemu configuration to a file
* @dev: the device in use
* @fp: file pointer to write the evemu configuration to
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_write(const struct evemu_device *dev, FILE *fp);
/**
* evemu_read() - read evemu configuration from a file
* @dev: the device in use
* @fp: file pointer to read the evemu configuration from
*
* Returns a positive number if successful, zero or negative error
* otherwise.
*/
int evemu_read(struct evemu_device *dev, FILE *fp);
/**
* evemu_write_event() - write kernel event to file
* @fp: file pointer to write the event to
* @ev: pointer to the kernel event to write
*
* Writes the kernel event to the file.
*
* Returns a positive number if successful, zero or negative error
* otherwise.
*/
int evemu_write_event(FILE *fp, const struct input_event *ev);
/**
* evemu_create_event() - Create a single event
* @ev: pointer to the kernel event to be filled
* @type: the event type to set
* @code: the event code to set
* @value: the event value to set
*/
int evemu_create_event(struct input_event *ev, int type, int code, int value);
/**
* evemu_read_event() - read kernel event from file
* @fp: file pointer to read the event from
* @ev: pointer to the kernel event to be filled
*
* Reads a kernel event from the file.
*
* Returns a positive number if successful, zero or negative error
* otherwise.
*/
int evemu_read_event(FILE *fp, struct input_event *ev);
/**
* evemu_read_event_realtime() - read kernel events in realtime
* @fp: file pointer to read the event from
* @ev: pointer to the kernel event to be filled
* @evtime: pointer to a timeval struct
*
* The evtime struct should be cleared (zeroed) before the first call
* to this function. This function reads a kernel event from the file,
* and performs the microsleep necessary to deliver the event with the
* same timings as originally received.
*
* Returns a positive number if successful, zero or negative error
* otherwise.
*/
int evemu_read_event_realtime(FILE *fp, struct input_event *ev,
struct timeval *evtime);
/**
* evemu_record() - read events directly from a kernel device
* @fp: file pointer to write the events to
* @fd: file descriptor of kernel device to read from
* @ms: maximum time to wait for an event to appear before reading (ms)
*
* Continuously reads events from the kernel device and writes them to
* the file. The function terminates after ms milliseconds of
* inactivity.
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_record(FILE *fp, int fd, int ms);
/**
* evemu_play_one() - play one event to kernel device
* @fd: file descriptor of kernel device to write to
* @ev: pointer to the kernel event to be played
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_play_one(int fd, const struct input_event *ev);
/**
* evemu_play() - replay events from file to kernel device in realtime
* @fp: file pointer to read the events from
* @fd: file descriptor of kernel device to write to
*
* Contiuously reads events from the file and writes them to the
* kernel device, in realtime. The function terminates when end of
* file has been reached.
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_play(FILE *fp, int fd);
/**
* evemu_create() - create a kernel device from the evemu configuration
* @dev: the device in use
* @fd: file descriptor of the special kernel uinput device
*
* Creates a new device with all the properties of the evemu device.
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_create(struct evemu_device *dev, int fd);
/**
* evemu_create_managed() - create a kernel device from the evemu configuration
* @dev: the device in use
*
* Creates a new device with all the properties of the evemu device.
* Compared to evemu_create, evemu will take care of the handling of the uinput
* file descriptor.
*
* Returns zero if successful, negative error otherwise.
*/
int evemu_create_managed(struct evemu_device *dev);
/**
* evemu_get_devnode() - get device node
* @dev: the device in use
*
* Returns the input device node of the virtual device. The pointer is owned by
* the evemu instance and has evemu scope.
*/
const char *evemu_get_devnode(struct evemu_device *dev);
/**
* evemu_destroy() - destroy all created kernel devices
* @dev: the device to destroy
*
* Destroys all devices created using this file descriptor.
*/
void evemu_destroy(struct evemu_device *dev);
#ifdef __cplusplus
}
#endif
#endif