1 // SPDX-License-Identifier: GPL-2.0+
2 // ir-rcmm-decoder.c - A decoder for the RCMM IR protocol
3 //
4 // Copyright (C) 2018 by Patrick Lerda <patrick9876@free.fr>
5 
6 #include "rc-core-priv.h"
7 #include <linux/module.h>
8 
9 #define RCMM_UNIT		166  /* microseconds */
10 #define RCMM_PREFIX_PULSE	417  /* 166.666666666666*2.5 */
11 #define RCMM_PULSE_0            278  /* 166.666666666666*(1+2/3) */
12 #define RCMM_PULSE_1            444  /* 166.666666666666*(2+2/3) */
13 #define RCMM_PULSE_2            611  /* 166.666666666666*(3+2/3) */
14 #define RCMM_PULSE_3            778  /* 166.666666666666*(4+2/3) */
15 
16 enum rcmm_state {
17 	STATE_INACTIVE,
18 	STATE_LOW,
19 	STATE_BUMP,
20 	STATE_VALUE,
21 	STATE_FINISHED,
22 };
23 
24 static bool rcmm_mode(const struct rcmm_dec *data)
25 {
26 	return !((0x000c0000 & data->bits) == 0x000c0000);
27 }
28 
29 static int rcmm_miscmode(struct rc_dev *dev, struct rcmm_dec *data)
30 {
31 	switch (data->count) {
32 	case 24:
33 		if (dev->enabled_protocols & RC_PROTO_BIT_RCMM24) {
34 			rc_keydown(dev, RC_PROTO_RCMM24, data->bits, 0);
35 			data->state = STATE_INACTIVE;
36 			return 0;
37 		}
38 		return -1;
39 
40 	case 12:
41 		if (dev->enabled_protocols & RC_PROTO_BIT_RCMM12) {
42 			rc_keydown(dev, RC_PROTO_RCMM12, data->bits, 0);
43 			data->state = STATE_INACTIVE;
44 			return 0;
45 		}
46 		return -1;
47 	}
48 
49 	return -1;
50 }
51 
52 /**
53  * ir_rcmm_decode() - Decode one RCMM pulse or space
54  * @dev:	the struct rc_dev descriptor of the device
55  * @ev:		the struct ir_raw_event descriptor of the pulse/space
56  *
57  * This function returns -EINVAL if the pulse violates the state machine
58  */
59 static int ir_rcmm_decode(struct rc_dev *dev, struct ir_raw_event ev)
60 {
61 	struct rcmm_dec *data = &dev->raw->rcmm;
62 	u32 scancode;
63 	u8 toggle;
64 	int value;
65 
66 	if (!(dev->enabled_protocols & (RC_PROTO_BIT_RCMM32 |
67 					RC_PROTO_BIT_RCMM24 |
68 					RC_PROTO_BIT_RCMM12)))
69 		return 0;
70 
71 	if (!is_timing_event(ev)) {
72 		if (ev.overflow)
73 			data->state = STATE_INACTIVE;
74 		return 0;
75 	}
76 
77 	switch (data->state) {
78 	case STATE_INACTIVE:
79 		if (!ev.pulse)
80 			break;
81 
82 		if (!eq_margin(ev.duration, RCMM_PREFIX_PULSE, RCMM_UNIT))
83 			break;
84 
85 		data->state = STATE_LOW;
86 		data->count = 0;
87 		data->bits  = 0;
88 		return 0;
89 
90 	case STATE_LOW:
91 		if (ev.pulse)
92 			break;
93 
94 		if (!eq_margin(ev.duration, RCMM_PULSE_0, RCMM_UNIT))
95 			break;
96 
97 		data->state = STATE_BUMP;
98 		return 0;
99 
100 	case STATE_BUMP:
101 		if (!ev.pulse)
102 			break;
103 
104 		if (!eq_margin(ev.duration, RCMM_UNIT, RCMM_UNIT / 2))
105 			break;
106 
107 		data->state = STATE_VALUE;
108 		return 0;
109 
110 	case STATE_VALUE:
111 		if (ev.pulse)
112 			break;
113 
114 		if (eq_margin(ev.duration, RCMM_PULSE_0, RCMM_UNIT / 2))
115 			value = 0;
116 		else if (eq_margin(ev.duration, RCMM_PULSE_1, RCMM_UNIT / 2))
117 			value = 1;
118 		else if (eq_margin(ev.duration, RCMM_PULSE_2, RCMM_UNIT / 2))
119 			value = 2;
120 		else if (eq_margin(ev.duration, RCMM_PULSE_3, RCMM_UNIT / 2))
121 			value = 3;
122 		else
123 			value = -1;
124 
125 		if (value == -1) {
126 			if (!rcmm_miscmode(dev, data))
127 				return 0;
128 			break;
129 		}
130 
131 		data->bits <<= 2;
132 		data->bits |= value;
133 
134 		data->count += 2;
135 
136 		if (data->count < 32)
137 			data->state = STATE_BUMP;
138 		else
139 			data->state = STATE_FINISHED;
140 
141 		return 0;
142 
143 	case STATE_FINISHED:
144 		if (!ev.pulse)
145 			break;
146 
147 		if (!eq_margin(ev.duration, RCMM_UNIT, RCMM_UNIT / 2))
148 			break;
149 
150 		if (rcmm_mode(data)) {
151 			toggle = !!(0x8000 & data->bits);
152 			scancode = data->bits & ~0x8000;
153 		} else {
154 			toggle = 0;
155 			scancode = data->bits;
156 		}
157 
158 		if (dev->enabled_protocols & RC_PROTO_BIT_RCMM32) {
159 			rc_keydown(dev, RC_PROTO_RCMM32, scancode, toggle);
160 			data->state = STATE_INACTIVE;
161 			return 0;
162 		}
163 
164 		break;
165 	}
166 
167 	dev_dbg(&dev->dev, "RC-MM decode failed at count %d state %d (%uus %s)\n",
168 		data->count, data->state, ev.duration, TO_STR(ev.pulse));
169 	data->state = STATE_INACTIVE;
170 	return -EINVAL;
171 }
172 
173 static const int rcmmspace[] = {
174 	RCMM_PULSE_0,
175 	RCMM_PULSE_1,
176 	RCMM_PULSE_2,
177 	RCMM_PULSE_3,
178 };
179 
180 static int ir_rcmm_rawencoder(struct ir_raw_event **ev, unsigned int max,
181 			      unsigned int n, u32 data)
182 {
183 	int i;
184 	int ret;
185 
186 	ret = ir_raw_gen_pulse_space(ev, &max, RCMM_PREFIX_PULSE, RCMM_PULSE_0);
187 	if (ret)
188 		return ret;
189 
190 	for (i = n - 2; i >= 0; i -= 2) {
191 		const unsigned int space = rcmmspace[(data >> i) & 3];
192 
193 		ret = ir_raw_gen_pulse_space(ev, &max, RCMM_UNIT, space);
194 		if (ret)
195 			return ret;
196 	}
197 
198 	return ir_raw_gen_pulse_space(ev, &max, RCMM_UNIT, RCMM_PULSE_3 * 2);
199 }
200 
201 static int ir_rcmm_encode(enum rc_proto protocol, u32 scancode,
202 			  struct ir_raw_event *events, unsigned int max)
203 {
204 	struct ir_raw_event *e = events;
205 	int ret;
206 
207 	switch (protocol) {
208 	case RC_PROTO_RCMM32:
209 		ret = ir_rcmm_rawencoder(&e, max, 32, scancode);
210 		break;
211 	case RC_PROTO_RCMM24:
212 		ret = ir_rcmm_rawencoder(&e, max, 24, scancode);
213 		break;
214 	case RC_PROTO_RCMM12:
215 		ret = ir_rcmm_rawencoder(&e, max, 12, scancode);
216 		break;
217 	default:
218 		ret = -EINVAL;
219 	}
220 
221 	if (ret < 0)
222 		return ret;
223 
224 	return e - events;
225 }
226 
227 static struct ir_raw_handler rcmm_handler = {
228 	.protocols	= RC_PROTO_BIT_RCMM32 |
229 			  RC_PROTO_BIT_RCMM24 |
230 			  RC_PROTO_BIT_RCMM12,
231 	.decode		= ir_rcmm_decode,
232 	.encode         = ir_rcmm_encode,
233 	.carrier        = 36000,
234 	.min_timeout	= RCMM_PULSE_3 + RCMM_UNIT,
235 };
236 
237 static int __init ir_rcmm_decode_init(void)
238 {
239 	ir_raw_handler_register(&rcmm_handler);
240 
241 	pr_info("IR RCMM protocol handler initialized\n");
242 	return 0;
243 }
244 
245 static void __exit ir_rcmm_decode_exit(void)
246 {
247 	ir_raw_handler_unregister(&rcmm_handler);
248 }
249 
250 module_init(ir_rcmm_decode_init);
251 module_exit(ir_rcmm_decode_exit);
252 
253 MODULE_LICENSE("GPL");
254 MODULE_AUTHOR("Patrick Lerda");
255 MODULE_DESCRIPTION("RCMM IR protocol decoder");
256