/* SPDX-License-Identifier: GPL-2.0-only */ /* * Remote Controller core header * * Copyright (C) 2009-2010 by Mauro Carvalho Chehab */ #ifndef _RC_CORE #define _RC_CORE #include <linux/spinlock.h> #include <linux/cdev.h> #include <linux/kfifo.h> #include <linux/time.h> #include <linux/timer.h> #include <media/rc-map.h> /** * enum rc_driver_type - type of the RC driver. * * @RC_DRIVER_SCANCODE: Driver or hardware generates a scancode. * @RC_DRIVER_IR_RAW: Driver or hardware generates pulse/space sequences. * It needs a Infra-Red pulse/space decoder * @RC_DRIVER_IR_RAW_TX: Device transmitter only, * driver requires pulse/space data sequence. */ enum rc_driver_type { … }; /** * struct rc_scancode_filter - Filter scan codes. * @data: Scancode data to match. * @mask: Mask of bits of scancode to compare. */ struct rc_scancode_filter { … }; /** * enum rc_filter_type - Filter type constants. * @RC_FILTER_NORMAL: Filter for normal operation. * @RC_FILTER_WAKEUP: Filter for waking from suspend. * @RC_FILTER_MAX: Number of filter types. */ enum rc_filter_type { … }; /** * struct lirc_fh - represents an open lirc file * @list: list of open file handles * @rc: rcdev for this lirc chardev * @carrier_low: when setting the carrier range, first the low end must be * set with an ioctl and then the high end with another ioctl * @rawir: queue for incoming raw IR * @scancodes: queue for incoming decoded scancodes * @wait_poll: poll struct for lirc device * @send_mode: lirc mode for sending, either LIRC_MODE_SCANCODE or * LIRC_MODE_PULSE * @rec_mode: lirc mode for receiving, either LIRC_MODE_SCANCODE or * LIRC_MODE_MODE2 */ struct lirc_fh { … }; /** * struct rc_dev - represents a remote control device * @dev: driver model's view of this device * @managed_alloc: devm_rc_allocate_device was used to create rc_dev * @sysfs_groups: sysfs attribute groups * @device_name: name of the rc child device * @input_phys: physical path to the input child device * @input_id: id of the input child device (struct input_id) * @driver_name: name of the hardware driver which registered this device * @map_name: name of the default keymap * @rc_map: current scan/key table * @lock: used to ensure we've filled in all protocol details before * anyone can call show_protocols or store_protocols * @minor: unique minor remote control device number * @raw: additional data for raw pulse/space devices * @input_dev: the input child device used to communicate events to userspace * @driver_type: specifies if protocol decoding is done in hardware or software * @idle: used to keep track of RX state * @encode_wakeup: wakeup filtering uses IR encode API, therefore the allowed * wakeup protocols is the set of all raw encoders * @allowed_protocols: bitmask with the supported RC_PROTO_BIT_* protocols * @enabled_protocols: bitmask with the enabled RC_PROTO_BIT_* protocols * @allowed_wakeup_protocols: bitmask with the supported RC_PROTO_BIT_* wakeup * protocols * @wakeup_protocol: the enabled RC_PROTO_* wakeup protocol or * RC_PROTO_UNKNOWN if disabled. * @scancode_filter: scancode filter * @scancode_wakeup_filter: scancode wakeup filters * @scancode_mask: some hardware decoders are not capable of providing the full * scancode to the application. As this is a hardware limit, we can't do * anything with it. Yet, as the same keycode table can be used with other * devices, a mask is provided to allow its usage. Drivers should generally * leave this field in blank * @users: number of current users of the device * @priv: driver-specific data * @keylock: protects the remaining members of the struct * @keypressed: whether a key is currently pressed * @keyup_jiffies: time (in jiffies) when the current keypress should be released * @timer_keyup: timer for releasing a keypress * @timer_repeat: timer for autorepeat events. This is needed for CEC, which * has non-standard repeats. * @last_keycode: keycode of last keypress * @last_protocol: protocol of last keypress * @last_scancode: scancode of last keypress * @last_toggle: toggle value of last command * @timeout: optional time after which device stops sending data * @min_timeout: minimum timeout supported by device * @max_timeout: maximum timeout supported by device * @rx_resolution : resolution (in us) of input sampler * @tx_resolution: resolution (in us) of output sampler * @lirc_dev: lirc device * @lirc_cdev: lirc char cdev * @gap_start: start time for gap after timeout if non-zero * @lirc_fh_lock: protects lirc_fh list * @lirc_fh: list of open files * @registered: set to true by rc_register_device(), false by * rc_unregister_device * @change_protocol: allow changing the protocol used on hardware decoders * @open: callback to allow drivers to enable polling/irq when IR input device * is opened. * @close: callback to allow drivers to disable polling/irq when IR input device * is opened. * @s_tx_mask: set transmitter mask (for devices with multiple tx outputs) * @s_tx_carrier: set transmit carrier frequency * @s_tx_duty_cycle: set transmit duty cycle (0% - 100%) * @s_rx_carrier_range: inform driver about carrier it is expected to handle * @tx_ir: transmit IR * @s_idle: enable/disable hardware idle mode, upon which, * device doesn't interrupt host until it sees IR pulses * @s_wideband_receiver: enable wide band receiver used for learning * @s_carrier_report: enable carrier reports * @s_filter: set the scancode filter * @s_wakeup_filter: set the wakeup scancode filter. If the mask is zero * then wakeup should be disabled. wakeup_protocol will be set to * a valid protocol if mask is nonzero. * @s_timeout: set hardware timeout in us */ struct rc_dev { … }; #define to_rc_dev(d) … /* * From rc-main.c * Those functions can be used on any type of Remote Controller. They * basically creates an input_dev and properly reports the device as a * Remote Controller, at sys/class/rc. */ /** * rc_allocate_device - Allocates a RC device * * @rc_driver_type: specifies the type of the RC output to be allocated * returns a pointer to struct rc_dev. */ struct rc_dev *rc_allocate_device(enum rc_driver_type); /** * devm_rc_allocate_device - Managed RC device allocation * * @dev: pointer to struct device * @rc_driver_type: specifies the type of the RC output to be allocated * returns a pointer to struct rc_dev. */ struct rc_dev *devm_rc_allocate_device(struct device *dev, enum rc_driver_type); /** * rc_free_device - Frees a RC device * * @dev: pointer to struct rc_dev. */ void rc_free_device(struct rc_dev *dev); /** * rc_register_device - Registers a RC device * * @dev: pointer to struct rc_dev. */ int rc_register_device(struct rc_dev *dev); /** * devm_rc_register_device - Manageded registering of a RC device * * @parent: pointer to struct device. * @dev: pointer to struct rc_dev. */ int devm_rc_register_device(struct device *parent, struct rc_dev *dev); /** * rc_unregister_device - Unregisters a RC device * * @dev: pointer to struct rc_dev. */ void rc_unregister_device(struct rc_dev *dev); void rc_repeat(struct rc_dev *dev); void rc_keydown(struct rc_dev *dev, enum rc_proto protocol, u64 scancode, u8 toggle); void rc_keydown_notimeout(struct rc_dev *dev, enum rc_proto protocol, u64 scancode, u8 toggle); void rc_keyup(struct rc_dev *dev); u32 rc_g_keycode_from_table(struct rc_dev *dev, u64 scancode); /* * From rc-raw.c * The Raw interface is specific to InfraRed. It may be a good idea to * split it later into a separate header. */ struct ir_raw_event { … }; #define US_TO_NS(usec) … #define MS_TO_US(msec) … #define IR_MAX_DURATION … #define IR_DEFAULT_TIMEOUT … #define IR_MAX_TIMEOUT … void ir_raw_event_handle(struct rc_dev *dev); int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev); int ir_raw_event_store_edge(struct rc_dev *dev, bool pulse); int ir_raw_event_store_with_filter(struct rc_dev *dev, struct ir_raw_event *ev); int ir_raw_event_store_with_timeout(struct rc_dev *dev, struct ir_raw_event *ev); void ir_raw_event_set_idle(struct rc_dev *dev, bool idle); int ir_raw_encode_scancode(enum rc_proto protocol, u32 scancode, struct ir_raw_event *events, unsigned int max); int ir_raw_encode_carrier(enum rc_proto protocol); static inline void ir_raw_event_overflow(struct rc_dev *dev) { … } /* extract mask bits out of data and pack them into the result */ static inline u32 ir_extract_bits(u32 data, u32 mask) { … } /* Get NEC scancode and protocol type from address and command bytes */ static inline u32 ir_nec_bytes_to_scancode(u8 address, u8 not_address, u8 command, u8 not_command, enum rc_proto *protocol) { … } #endif /* _RC_CORE */
Codebase Browser
linux