2019-09-15 18:00:46 +07:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2017-12-19 03:15:53 +07:00
|
|
|
/*
|
|
|
|
* Remote Controller core raw events header
|
|
|
|
*
|
|
|
|
* Copyright (C) 2010 by Mauro Carvalho Chehab
|
|
|
|
*/
|
2010-04-09 01:10:27 +07:00
|
|
|
|
2010-11-20 06:43:27 +07:00
|
|
|
#ifndef _RC_CORE_PRIV
|
|
|
|
#define _RC_CORE_PRIV
|
2010-04-09 01:10:27 +07:00
|
|
|
|
2017-09-26 20:34:47 +07:00
|
|
|
#define RC_DEV_MAX 256
|
2015-11-28 05:02:38 +07:00
|
|
|
/* Define the max number of pulse/space transitions to buffer */
|
|
|
|
#define MAX_IR_EVENT_SIZE 512
|
|
|
|
|
2010-04-09 01:10:27 +07:00
|
|
|
#include <linux/slab.h>
|
2018-05-27 18:24:09 +07:00
|
|
|
#include <uapi/linux/bpf.h>
|
2010-11-17 23:28:38 +07:00
|
|
|
#include <media/rc-core.h>
|
2010-04-09 01:10:27 +07:00
|
|
|
|
2017-09-23 21:41:13 +07:00
|
|
|
/**
|
|
|
|
* rc_open - Opens a RC device
|
|
|
|
*
|
|
|
|
* @rdev: pointer to struct rc_dev.
|
|
|
|
*/
|
|
|
|
int rc_open(struct rc_dev *rdev);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rc_close - Closes a RC device
|
|
|
|
*
|
|
|
|
* @rdev: pointer to struct rc_dev.
|
|
|
|
*/
|
|
|
|
void rc_close(struct rc_dev *rdev);
|
|
|
|
|
2010-04-09 01:10:27 +07:00
|
|
|
struct ir_raw_handler {
|
|
|
|
struct list_head list;
|
|
|
|
|
2010-06-14 03:29:31 +07:00
|
|
|
u64 protocols; /* which are handled by this handler */
|
2010-10-30 02:08:23 +07:00
|
|
|
int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
|
2017-08-08 03:20:58 +07:00
|
|
|
int (*encode)(enum rc_proto protocol, u32 scancode,
|
2015-04-01 00:48:06 +07:00
|
|
|
struct ir_raw_event *events, unsigned int max);
|
2017-02-25 18:51:30 +07:00
|
|
|
u32 carrier;
|
2018-03-24 03:47:37 +07:00
|
|
|
u32 min_timeout;
|
2010-06-14 03:29:36 +07:00
|
|
|
|
2017-09-23 21:41:13 +07:00
|
|
|
/* These two should only be used by the mce kbd decoder */
|
2010-10-30 02:08:23 +07:00
|
|
|
int (*raw_register)(struct rc_dev *dev);
|
|
|
|
int (*raw_unregister)(struct rc_dev *dev);
|
2010-04-09 01:10:27 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ir_raw_event_ctrl {
|
2010-06-14 03:29:36 +07:00
|
|
|
struct list_head list; /* to keep track of raw clients */
|
2010-07-31 21:59:17 +07:00
|
|
|
struct task_struct *thread;
|
2015-11-28 05:02:38 +07:00
|
|
|
/* fifo for the pulse/space durations */
|
|
|
|
DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE);
|
2010-04-09 01:10:27 +07:00
|
|
|
ktime_t last_event; /* when last event occurred */
|
2010-10-30 02:08:23 +07:00
|
|
|
struct rc_dev *dev; /* pointer to the parent rc_dev */
|
2018-02-14 22:26:17 +07:00
|
|
|
/* handle delayed ir_raw_event_store_edge processing */
|
|
|
|
spinlock_t edge_spinlock;
|
|
|
|
struct timer_list edge_handle;
|
2010-06-14 03:29:36 +07:00
|
|
|
|
|
|
|
/* raw decoder state follows */
|
|
|
|
struct ir_raw_event prev_ev;
|
2010-07-31 21:59:22 +07:00
|
|
|
struct ir_raw_event this_ev;
|
2018-05-27 18:24:09 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_BPF_LIRC_MODE2
|
|
|
|
u32 bpf_sample;
|
|
|
|
struct bpf_prog_array __rcu *progs;
|
|
|
|
#endif
|
2020-04-21 17:19:27 +07:00
|
|
|
#if IS_ENABLED(CONFIG_IR_NEC_DECODER)
|
2010-06-14 03:29:36 +07:00
|
|
|
struct nec_dec {
|
|
|
|
int state;
|
|
|
|
unsigned count;
|
|
|
|
u32 bits;
|
2010-07-31 21:59:20 +07:00
|
|
|
bool is_nec_x;
|
|
|
|
bool necx_repeat;
|
2010-06-14 03:29:36 +07:00
|
|
|
} nec;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_RC5_DECODER)
|
2010-06-14 03:29:36 +07:00
|
|
|
struct rc5_dec {
|
|
|
|
int state;
|
|
|
|
u32 bits;
|
|
|
|
unsigned count;
|
2014-04-04 06:32:31 +07:00
|
|
|
bool is_rc5x;
|
2010-06-14 03:29:36 +07:00
|
|
|
} rc5;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_RC6_DECODER)
|
2010-06-14 03:29:36 +07:00
|
|
|
struct rc6_dec {
|
|
|
|
int state;
|
|
|
|
u8 header;
|
|
|
|
u32 body;
|
|
|
|
bool toggle;
|
|
|
|
unsigned count;
|
|
|
|
unsigned wanted_bits;
|
|
|
|
} rc6;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_SONY_DECODER)
|
2010-06-14 03:29:36 +07:00
|
|
|
struct sony_dec {
|
|
|
|
int state;
|
|
|
|
u32 bits;
|
|
|
|
unsigned count;
|
|
|
|
} sony;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_JVC_DECODER)
|
2010-06-14 03:29:36 +07:00
|
|
|
struct jvc_dec {
|
|
|
|
int state;
|
|
|
|
u16 bits;
|
|
|
|
u16 old_bits;
|
|
|
|
unsigned count;
|
|
|
|
bool first;
|
|
|
|
bool toggle;
|
|
|
|
} jvc;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_SANYO_DECODER)
|
2011-11-23 22:04:08 +07:00
|
|
|
struct sanyo_dec {
|
|
|
|
int state;
|
|
|
|
unsigned count;
|
|
|
|
u64 bits;
|
|
|
|
} sanyo;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_SHARP_DECODER)
|
2014-01-17 20:58:48 +07:00
|
|
|
struct sharp_dec {
|
|
|
|
int state;
|
|
|
|
unsigned count;
|
|
|
|
u32 bits;
|
|
|
|
unsigned int pulse_len;
|
|
|
|
} sharp;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_MCE_KBD_DECODER)
|
[media] rc-core support for Microsoft IR keyboard/mouse
This is a custom IR protocol decoder, for the RC-6-ish protocol used by
the Microsoft Remote Keyboard, apparently developed internally at
Microsoft, and officially dubbed MCIR-2, per their March 2011 remote and
transceiver requirements and specifications document, which also touches
on this IR keyboard/mouse device.
Its a standard keyboard with embedded thumb stick mouse pointer and
mouse buttons, along with a number of media keys. The media keys are
standard RC-6, identical to the signals from the stock MCE remotes, and
will be handled as such. The keyboard and mouse signals will be decoded
and delivered to the system by an input device registered specifically
by this driver.
Successfully tested with multiple mceusb-driven transceivers, as well as
with fintek-cir and redrat3 hardware. Essentially, any raw IR hardware
with enough sampling resolution should be able to use this decoder,
nothing about it is at all receiver-hardware-specific.
This work is inspired by lirc_mod_mce:
The documentation there and code aided in understanding and decoding the
protocol, but the bulk of the code is actually borrowed more from the
existing in-kernel decoders than anything. I did recycle the keyboard
keycode table, a few defines, and some of the keyboard and mouse data
parsing bits from lirc_mod_mce though.
Special thanks to James Meyer for providing the hardware, and being
patient with me as I took forever to get around to writing this.
callback routine to ensure we don't get any stuck keys, and used
symbolic names for the keytable. Also cc'ing Florian this time, who I
believe is the original mod-mce author...
CC: Florian Demski <fdemski@users.sourceforge.net>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
2011-07-14 04:09:48 +07:00
|
|
|
struct mce_kbd_dec {
|
2018-04-13 03:28:39 +07:00
|
|
|
/* locks key up timer */
|
|
|
|
spinlock_t keylock;
|
[media] rc-core support for Microsoft IR keyboard/mouse
This is a custom IR protocol decoder, for the RC-6-ish protocol used by
the Microsoft Remote Keyboard, apparently developed internally at
Microsoft, and officially dubbed MCIR-2, per their March 2011 remote and
transceiver requirements and specifications document, which also touches
on this IR keyboard/mouse device.
Its a standard keyboard with embedded thumb stick mouse pointer and
mouse buttons, along with a number of media keys. The media keys are
standard RC-6, identical to the signals from the stock MCE remotes, and
will be handled as such. The keyboard and mouse signals will be decoded
and delivered to the system by an input device registered specifically
by this driver.
Successfully tested with multiple mceusb-driven transceivers, as well as
with fintek-cir and redrat3 hardware. Essentially, any raw IR hardware
with enough sampling resolution should be able to use this decoder,
nothing about it is at all receiver-hardware-specific.
This work is inspired by lirc_mod_mce:
The documentation there and code aided in understanding and decoding the
protocol, but the bulk of the code is actually borrowed more from the
existing in-kernel decoders than anything. I did recycle the keyboard
keycode table, a few defines, and some of the keyboard and mouse data
parsing bits from lirc_mod_mce though.
Special thanks to James Meyer for providing the hardware, and being
patient with me as I took forever to get around to writing this.
callback routine to ensure we don't get any stuck keys, and used
symbolic names for the keytable. Also cc'ing Florian this time, who I
believe is the original mod-mce author...
CC: Florian Demski <fdemski@users.sourceforge.net>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
2011-07-14 04:09:48 +07:00
|
|
|
struct timer_list rx_timeout;
|
|
|
|
int state;
|
|
|
|
u8 header;
|
|
|
|
u32 body;
|
|
|
|
unsigned count;
|
|
|
|
unsigned wanted_bits;
|
|
|
|
} mce_kbd;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_XMP_DECODER)
|
2014-07-27 03:28:26 +07:00
|
|
|
struct xmp_dec {
|
|
|
|
int state;
|
|
|
|
unsigned count;
|
|
|
|
u32 durations[16];
|
|
|
|
} xmp;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_IMON_DECODER)
|
2017-12-03 23:06:54 +07:00
|
|
|
struct imon_dec {
|
|
|
|
int state;
|
|
|
|
int count;
|
|
|
|
int last_chk;
|
|
|
|
unsigned int bits;
|
2018-04-19 03:44:58 +07:00
|
|
|
bool stick_keyboard;
|
2017-12-03 23:06:54 +07:00
|
|
|
} imon;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_IR_RCMM_DECODER)
|
2019-01-17 15:50:13 +07:00
|
|
|
struct rcmm_dec {
|
|
|
|
int state;
|
|
|
|
unsigned int count;
|
|
|
|
u32 bits;
|
|
|
|
} rcmm;
|
2020-04-21 17:19:27 +07:00
|
|
|
#endif
|
2010-04-09 01:10:27 +07:00
|
|
|
};
|
|
|
|
|
2018-05-27 18:24:09 +07:00
|
|
|
/* Mutex for locking raw IR processing and handler change */
|
|
|
|
extern struct mutex ir_raw_handler_lock;
|
|
|
|
|
2010-04-09 01:10:27 +07:00
|
|
|
/* macros for IR decoders */
|
2010-04-21 04:50:54 +07:00
|
|
|
static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
|
|
|
|
{
|
2010-04-16 04:46:00 +07:00
|
|
|
return d1 > (d2 - margin);
|
|
|
|
}
|
|
|
|
|
2010-04-21 04:50:54 +07:00
|
|
|
static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
|
|
|
|
{
|
2010-04-16 04:46:00 +07:00
|
|
|
return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
|
|
|
|
}
|
|
|
|
|
2010-04-21 04:50:54 +07:00
|
|
|
static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
|
|
|
|
{
|
2010-04-16 04:46:00 +07:00
|
|
|
return x->pulse != y->pulse;
|
|
|
|
}
|
|
|
|
|
2010-04-21 04:50:54 +07:00
|
|
|
static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
|
|
|
|
{
|
2010-04-16 04:46:00 +07:00
|
|
|
if (duration > ev->duration)
|
|
|
|
ev->duration = 0;
|
|
|
|
else
|
|
|
|
ev->duration -= duration;
|
|
|
|
}
|
|
|
|
|
2010-10-17 05:56:28 +07:00
|
|
|
/* Returns true if event is normal pulse/space event */
|
|
|
|
static inline bool is_timing_event(struct ir_raw_event ev)
|
|
|
|
{
|
|
|
|
return !ev.carrier_report && !ev.reset;
|
|
|
|
}
|
|
|
|
|
2010-07-31 21:59:15 +07:00
|
|
|
#define TO_US(duration) DIV_ROUND_CLOSEST((duration), 1000)
|
2010-04-16 04:46:00 +07:00
|
|
|
#define TO_STR(is_pulse) ((is_pulse) ? "pulse" : "space")
|
2010-04-09 01:10:27 +07:00
|
|
|
|
2015-04-01 00:48:07 +07:00
|
|
|
/* functions for IR encoders */
|
2017-09-28 03:00:49 +07:00
|
|
|
bool rc_validate_scancode(enum rc_proto proto, u32 scancode);
|
2015-04-01 00:48:07 +07:00
|
|
|
|
|
|
|
static inline void init_ir_raw_event_duration(struct ir_raw_event *ev,
|
|
|
|
unsigned int pulse,
|
|
|
|
u32 duration)
|
|
|
|
{
|
2018-08-22 02:57:52 +07:00
|
|
|
*ev = (struct ir_raw_event) {
|
|
|
|
.duration = duration,
|
|
|
|
.pulse = pulse
|
|
|
|
};
|
2015-04-01 00:48:07 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct ir_raw_timings_manchester - Manchester coding timings
|
2018-01-05 20:26:51 +07:00
|
|
|
* @leader_pulse: duration of leader pulse (if any) 0 if continuing
|
|
|
|
* existing signal
|
|
|
|
* @leader_space: duration of leader space (if any)
|
2015-04-01 00:48:07 +07:00
|
|
|
* @clock: duration of each pulse/space in ns
|
|
|
|
* @invert: if set clock logic is inverted
|
|
|
|
* (0 = space + pulse, 1 = pulse + space)
|
|
|
|
* @trailer_space: duration of trailer space in ns
|
|
|
|
*/
|
|
|
|
struct ir_raw_timings_manchester {
|
2018-01-05 20:26:51 +07:00
|
|
|
unsigned int leader_pulse;
|
|
|
|
unsigned int leader_space;
|
2015-04-01 00:48:07 +07:00
|
|
|
unsigned int clock;
|
|
|
|
unsigned int invert:1;
|
|
|
|
unsigned int trailer_space;
|
|
|
|
};
|
|
|
|
|
|
|
|
int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
|
|
|
|
const struct ir_raw_timings_manchester *timings,
|
2017-02-12 05:33:38 +07:00
|
|
|
unsigned int n, u64 data);
|
2015-04-01 00:48:07 +07:00
|
|
|
|
2014-03-15 06:04:12 +07:00
|
|
|
/**
|
|
|
|
* ir_raw_gen_pulse_space() - generate pulse and space raw events.
|
|
|
|
* @ev: Pointer to pointer to next free raw event.
|
|
|
|
* Will be incremented for each raw event written.
|
|
|
|
* @max: Pointer to number of raw events available in buffer.
|
|
|
|
* Will be decremented for each raw event written.
|
|
|
|
* @pulse_width: Width of pulse in ns.
|
|
|
|
* @space_width: Width of space in ns.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success.
|
|
|
|
* -ENOBUFS if there isn't enough buffer space to write both raw
|
|
|
|
* events. In this case @max events will have been written.
|
|
|
|
*/
|
|
|
|
static inline int ir_raw_gen_pulse_space(struct ir_raw_event **ev,
|
|
|
|
unsigned int *max,
|
|
|
|
unsigned int pulse_width,
|
|
|
|
unsigned int space_width)
|
|
|
|
{
|
|
|
|
if (!*max)
|
|
|
|
return -ENOBUFS;
|
|
|
|
init_ir_raw_event_duration((*ev)++, 1, pulse_width);
|
|
|
|
if (!--*max)
|
|
|
|
return -ENOBUFS;
|
|
|
|
init_ir_raw_event_duration((*ev)++, 0, space_width);
|
|
|
|
--*max;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct ir_raw_timings_pd - pulse-distance modulation timings
|
|
|
|
* @header_pulse: duration of header pulse in ns (0 for none)
|
|
|
|
* @header_space: duration of header space in ns
|
|
|
|
* @bit_pulse: duration of bit pulse in ns
|
|
|
|
* @bit_space: duration of bit space (for logic 0 and 1) in ns
|
|
|
|
* @trailer_pulse: duration of trailer pulse in ns
|
|
|
|
* @trailer_space: duration of trailer space in ns
|
|
|
|
* @msb_first: 1 if most significant bit is sent first
|
|
|
|
*/
|
|
|
|
struct ir_raw_timings_pd {
|
|
|
|
unsigned int header_pulse;
|
|
|
|
unsigned int header_space;
|
|
|
|
unsigned int bit_pulse;
|
|
|
|
unsigned int bit_space[2];
|
|
|
|
unsigned int trailer_pulse;
|
|
|
|
unsigned int trailer_space;
|
|
|
|
unsigned int msb_first:1;
|
|
|
|
};
|
|
|
|
|
|
|
|
int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max,
|
|
|
|
const struct ir_raw_timings_pd *timings,
|
|
|
|
unsigned int n, u64 data);
|
|
|
|
|
2016-12-07 03:33:57 +07:00
|
|
|
/**
|
|
|
|
* struct ir_raw_timings_pl - pulse-length modulation timings
|
|
|
|
* @header_pulse: duration of header pulse in ns (0 for none)
|
|
|
|
* @bit_space: duration of bit space in ns
|
|
|
|
* @bit_pulse: duration of bit pulse (for logic 0 and 1) in ns
|
|
|
|
* @trailer_space: duration of trailer space in ns
|
|
|
|
* @msb_first: 1 if most significant bit is sent first
|
|
|
|
*/
|
|
|
|
struct ir_raw_timings_pl {
|
|
|
|
unsigned int header_pulse;
|
|
|
|
unsigned int bit_space;
|
|
|
|
unsigned int bit_pulse[2];
|
|
|
|
unsigned int trailer_space;
|
|
|
|
unsigned int msb_first:1;
|
|
|
|
};
|
|
|
|
|
|
|
|
int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max,
|
|
|
|
const struct ir_raw_timings_pl *timings,
|
|
|
|
unsigned int n, u64 data);
|
|
|
|
|
2010-04-09 01:10:27 +07:00
|
|
|
/*
|
2010-10-30 02:08:23 +07:00
|
|
|
* Routines from rc-raw.c to be used internally and by decoders
|
2010-04-09 01:10:27 +07:00
|
|
|
*/
|
2010-06-14 03:29:31 +07:00
|
|
|
u64 ir_raw_get_allowed_protocols(void);
|
2017-05-03 17:04:00 +07:00
|
|
|
int ir_raw_event_prepare(struct rc_dev *dev);
|
2010-10-30 02:08:23 +07:00
|
|
|
int ir_raw_event_register(struct rc_dev *dev);
|
2017-05-03 17:04:00 +07:00
|
|
|
void ir_raw_event_free(struct rc_dev *dev);
|
2010-10-30 02:08:23 +07:00
|
|
|
void ir_raw_event_unregister(struct rc_dev *dev);
|
2010-04-09 01:10:27 +07:00
|
|
|
int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
|
|
|
|
void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
|
2017-02-25 18:51:31 +07:00
|
|
|
void ir_raw_load_modules(u64 *protocols);
|
2010-04-09 01:10:27 +07:00
|
|
|
void ir_raw_init(void);
|
|
|
|
|
2017-09-23 21:41:13 +07:00
|
|
|
/*
|
|
|
|
* lirc interface
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_LIRC
|
|
|
|
int lirc_dev_init(void);
|
|
|
|
void lirc_dev_exit(void);
|
|
|
|
void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev);
|
media: lirc: implement reading scancode
This implements LIRC_MODE_SCANCODE reading from the lirc device. The
scancode can be read from the input device too, but with this interface
you get the rc protocol, keycode, toggle and repeat status in addition
to just the scancode.
int main()
{
int fd, mode, rc;
fd = open("/dev/lirc0", O_RDWR);
mode = LIRC_MODE_SCANCODE;
if (ioctl(fd, LIRC_SET_REC_MODE, &mode)) {
// kernel too old or lirc does not support transmit
}
struct lirc_scancode scancode;
while (read(fd, &scancode, sizeof(scancode)) == sizeof(scancode)) {
printf("protocol:%d scancode:0x%x toggle:%d repeat:%d\n",
scancode.rc_proto, scancode.scancode,
!!(scancode.flags & LIRC_SCANCODE_FLAG_TOGGLE),
!!(scancode.flags & LIRC_SCANCODE_FLAG_REPEAT));
}
close(fd);
}
Signed-off-by: Sean Young <sean@mess.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2017-02-25 18:51:32 +07:00
|
|
|
void ir_lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc);
|
2017-09-23 21:41:13 +07:00
|
|
|
int ir_lirc_register(struct rc_dev *dev);
|
|
|
|
void ir_lirc_unregister(struct rc_dev *dev);
|
2018-05-27 18:24:09 +07:00
|
|
|
struct rc_dev *rc_dev_get_from_fd(int fd);
|
2017-09-23 21:41:13 +07:00
|
|
|
#else
|
|
|
|
static inline int lirc_dev_init(void) { return 0; }
|
|
|
|
static inline void lirc_dev_exit(void) {}
|
|
|
|
static inline void ir_lirc_raw_event(struct rc_dev *dev,
|
|
|
|
struct ir_raw_event ev) { }
|
media: lirc: implement reading scancode
This implements LIRC_MODE_SCANCODE reading from the lirc device. The
scancode can be read from the input device too, but with this interface
you get the rc protocol, keycode, toggle and repeat status in addition
to just the scancode.
int main()
{
int fd, mode, rc;
fd = open("/dev/lirc0", O_RDWR);
mode = LIRC_MODE_SCANCODE;
if (ioctl(fd, LIRC_SET_REC_MODE, &mode)) {
// kernel too old or lirc does not support transmit
}
struct lirc_scancode scancode;
while (read(fd, &scancode, sizeof(scancode)) == sizeof(scancode)) {
printf("protocol:%d scancode:0x%x toggle:%d repeat:%d\n",
scancode.rc_proto, scancode.scancode,
!!(scancode.flags & LIRC_SCANCODE_FLAG_TOGGLE),
!!(scancode.flags & LIRC_SCANCODE_FLAG_REPEAT));
}
close(fd);
}
Signed-off-by: Sean Young <sean@mess.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
2017-02-25 18:51:32 +07:00
|
|
|
static inline void ir_lirc_scancode_event(struct rc_dev *dev,
|
|
|
|
struct lirc_scancode *lsc) { }
|
2017-09-23 21:41:13 +07:00
|
|
|
static inline int ir_lirc_register(struct rc_dev *dev) { return 0; }
|
|
|
|
static inline void ir_lirc_unregister(struct rc_dev *dev) { }
|
|
|
|
#endif
|
|
|
|
|
2018-05-27 18:24:09 +07:00
|
|
|
/*
|
|
|
|
* bpf interface
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_BPF_LIRC_MODE2
|
|
|
|
void lirc_bpf_free(struct rc_dev *dev);
|
|
|
|
void lirc_bpf_run(struct rc_dev *dev, u32 sample);
|
|
|
|
#else
|
|
|
|
static inline void lirc_bpf_free(struct rc_dev *dev) { }
|
|
|
|
static inline void lirc_bpf_run(struct rc_dev *dev, u32 sample) { }
|
|
|
|
#endif
|
|
|
|
|
2010-11-20 06:43:27 +07:00
|
|
|
#endif /* _RC_CORE_PRIV */
|