1 // SPDX-License-Identifier: GPL-2.0 2 // ir-rc5-decoder.c - decoder for RC5(x) and StreamZap protocols 3 // 4 // Copyright (C) 2010 by Mauro Carvalho Chehab 5 // Copyright (C) 2010 by Jarod Wilson <jarod@redhat.com> 6 7 /* 8 * This decoder handles the 14 bit RC5 protocol, 15 bit "StreamZap" protocol 9 * and 20 bit RC5x protocol. 10 */ 11 12 #include "rc-core-priv.h" 13 #include <linux/module.h> 14 15 #define RC5_NBITS 14 16 #define RC5_SZ_NBITS 15 17 #define RC5X_NBITS 20 18 #define CHECK_RC5X_NBITS 8 19 #define RC5_UNIT 888888 /* ns */ 20 #define RC5_BIT_START (1 * RC5_UNIT) 21 #define RC5_BIT_END (1 * RC5_UNIT) 22 #define RC5X_SPACE (4 * RC5_UNIT) 23 #define RC5_TRAILER (6 * RC5_UNIT) /* In reality, approx 100 */ 24 25 enum rc5_state { 26 STATE_INACTIVE, 27 STATE_BIT_START, 28 STATE_BIT_END, 29 STATE_CHECK_RC5X, 30 STATE_FINISHED, 31 }; 32 33 /** 34 * ir_rc5_decode() - Decode one RC-5 pulse or space 35 * @dev: the struct rc_dev descriptor of the device 36 * @ev: the struct ir_raw_event descriptor of the pulse/space 37 * 38 * This function returns -EINVAL if the pulse violates the state machine 39 */ 40 static int ir_rc5_decode(struct rc_dev *dev, struct ir_raw_event ev) 41 { 42 struct rc5_dec *data = &dev->raw->rc5; 43 u8 toggle; 44 u32 scancode; 45 enum rc_proto protocol; 46 47 if (!is_timing_event(ev)) { 48 if (ev.reset) 49 data->state = STATE_INACTIVE; 50 return 0; 51 } 52 53 if (!geq_margin(ev.duration, RC5_UNIT, RC5_UNIT / 2)) 54 goto out; 55 56 again: 57 IR_dprintk(2, "RC5(x/sz) decode started at state %i (%uus %s)\n", 58 data->state, TO_US(ev.duration), TO_STR(ev.pulse)); 59 60 if (!geq_margin(ev.duration, RC5_UNIT, RC5_UNIT / 2)) 61 return 0; 62 63 switch (data->state) { 64 65 case STATE_INACTIVE: 66 if (!ev.pulse) 67 break; 68 69 data->state = STATE_BIT_START; 70 data->count = 1; 71 decrease_duration(&ev, RC5_BIT_START); 72 goto again; 73 74 case STATE_BIT_START: 75 if (!ev.pulse && geq_margin(ev.duration, RC5_TRAILER, RC5_UNIT / 2)) { 76 data->state = STATE_FINISHED; 77 goto again; 78 } 79 80 if (!eq_margin(ev.duration, RC5_BIT_START, RC5_UNIT / 2)) 81 break; 82 83 data->bits <<= 1; 84 if (!ev.pulse) 85 data->bits |= 1; 86 data->count++; 87 data->state = STATE_BIT_END; 88 return 0; 89 90 case STATE_BIT_END: 91 if (!is_transition(&ev, &dev->raw->prev_ev)) 92 break; 93 94 if (data->count == CHECK_RC5X_NBITS) 95 data->state = STATE_CHECK_RC5X; 96 else 97 data->state = STATE_BIT_START; 98 99 decrease_duration(&ev, RC5_BIT_END); 100 goto again; 101 102 case STATE_CHECK_RC5X: 103 if (!ev.pulse && geq_margin(ev.duration, RC5X_SPACE, RC5_UNIT / 2)) { 104 data->is_rc5x = true; 105 decrease_duration(&ev, RC5X_SPACE); 106 } else 107 data->is_rc5x = false; 108 data->state = STATE_BIT_START; 109 goto again; 110 111 case STATE_FINISHED: 112 if (ev.pulse) 113 break; 114 115 if (data->is_rc5x && data->count == RC5X_NBITS) { 116 /* RC5X */ 117 u8 xdata, command, system; 118 if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5X_20)) { 119 data->state = STATE_INACTIVE; 120 return 0; 121 } 122 xdata = (data->bits & 0x0003F) >> 0; 123 command = (data->bits & 0x00FC0) >> 6; 124 system = (data->bits & 0x1F000) >> 12; 125 toggle = (data->bits & 0x20000) ? 1 : 0; 126 command += (data->bits & 0x40000) ? 0 : 0x40; 127 scancode = system << 16 | command << 8 | xdata; 128 protocol = RC_PROTO_RC5X_20; 129 130 } else if (!data->is_rc5x && data->count == RC5_NBITS) { 131 /* RC5 */ 132 u8 command, system; 133 if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5)) { 134 data->state = STATE_INACTIVE; 135 return 0; 136 } 137 command = (data->bits & 0x0003F) >> 0; 138 system = (data->bits & 0x007C0) >> 6; 139 toggle = (data->bits & 0x00800) ? 1 : 0; 140 command += (data->bits & 0x01000) ? 0 : 0x40; 141 scancode = system << 8 | command; 142 protocol = RC_PROTO_RC5; 143 144 } else if (!data->is_rc5x && data->count == RC5_SZ_NBITS) { 145 /* RC5 StreamZap */ 146 u8 command, system; 147 if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5_SZ)) { 148 data->state = STATE_INACTIVE; 149 return 0; 150 } 151 command = (data->bits & 0x0003F) >> 0; 152 system = (data->bits & 0x02FC0) >> 6; 153 toggle = (data->bits & 0x01000) ? 1 : 0; 154 scancode = system << 6 | command; 155 protocol = RC_PROTO_RC5_SZ; 156 157 } else 158 break; 159 160 IR_dprintk(1, "RC5(x/sz) scancode 0x%06x (p: %u, t: %u)\n", 161 scancode, protocol, toggle); 162 163 rc_keydown(dev, protocol, scancode, toggle); 164 data->state = STATE_INACTIVE; 165 return 0; 166 } 167 168 out: 169 IR_dprintk(1, "RC5(x/sz) decode failed at state %i count %d (%uus %s)\n", 170 data->state, data->count, TO_US(ev.duration), TO_STR(ev.pulse)); 171 data->state = STATE_INACTIVE; 172 return -EINVAL; 173 } 174 175 static const struct ir_raw_timings_manchester ir_rc5_timings = { 176 .leader_pulse = RC5_UNIT, 177 .clock = RC5_UNIT, 178 .trailer_space = RC5_UNIT * 10, 179 }; 180 181 static const struct ir_raw_timings_manchester ir_rc5x_timings[2] = { 182 { 183 .leader_pulse = RC5_UNIT, 184 .clock = RC5_UNIT, 185 .trailer_space = RC5X_SPACE, 186 }, 187 { 188 .clock = RC5_UNIT, 189 .trailer_space = RC5_UNIT * 10, 190 }, 191 }; 192 193 static const struct ir_raw_timings_manchester ir_rc5_sz_timings = { 194 .leader_pulse = RC5_UNIT, 195 .clock = RC5_UNIT, 196 .trailer_space = RC5_UNIT * 10, 197 }; 198 199 /** 200 * ir_rc5_encode() - Encode a scancode as a stream of raw events 201 * 202 * @protocol: protocol variant to encode 203 * @scancode: scancode to encode 204 * @events: array of raw ir events to write into 205 * @max: maximum size of @events 206 * 207 * Returns: The number of events written. 208 * -ENOBUFS if there isn't enough space in the array to fit the 209 * encoding. In this case all @max events will have been written. 210 * -EINVAL if the scancode is ambiguous or invalid. 211 */ 212 static int ir_rc5_encode(enum rc_proto protocol, u32 scancode, 213 struct ir_raw_event *events, unsigned int max) 214 { 215 int ret; 216 struct ir_raw_event *e = events; 217 unsigned int data, xdata, command, commandx, system, pre_space_data; 218 219 /* Detect protocol and convert scancode to raw data */ 220 if (protocol == RC_PROTO_RC5) { 221 /* decode scancode */ 222 command = (scancode & 0x003f) >> 0; 223 commandx = (scancode & 0x0040) >> 6; 224 system = (scancode & 0x1f00) >> 8; 225 /* encode data */ 226 data = !commandx << 12 | system << 6 | command; 227 228 /* First bit is encoded by leader_pulse */ 229 ret = ir_raw_gen_manchester(&e, max, &ir_rc5_timings, 230 RC5_NBITS - 1, data); 231 if (ret < 0) 232 return ret; 233 } else if (protocol == RC_PROTO_RC5X_20) { 234 /* decode scancode */ 235 xdata = (scancode & 0x00003f) >> 0; 236 command = (scancode & 0x003f00) >> 8; 237 commandx = !(scancode & 0x004000); 238 system = (scancode & 0x1f0000) >> 16; 239 240 /* encode data */ 241 data = commandx << 18 | system << 12 | command << 6 | xdata; 242 243 /* First bit is encoded by leader_pulse */ 244 pre_space_data = data >> (RC5X_NBITS - CHECK_RC5X_NBITS); 245 ret = ir_raw_gen_manchester(&e, max, &ir_rc5x_timings[0], 246 CHECK_RC5X_NBITS - 1, 247 pre_space_data); 248 if (ret < 0) 249 return ret; 250 ret = ir_raw_gen_manchester(&e, max - (e - events), 251 &ir_rc5x_timings[1], 252 RC5X_NBITS - CHECK_RC5X_NBITS, 253 data); 254 if (ret < 0) 255 return ret; 256 } else if (protocol == RC_PROTO_RC5_SZ) { 257 /* RC5-SZ scancode is raw enough for Manchester as it is */ 258 /* First bit is encoded by leader_pulse */ 259 ret = ir_raw_gen_manchester(&e, max, &ir_rc5_sz_timings, 260 RC5_SZ_NBITS - 1, 261 scancode & 0x2fff); 262 if (ret < 0) 263 return ret; 264 } else { 265 return -EINVAL; 266 } 267 268 return e - events; 269 } 270 271 static struct ir_raw_handler rc5_handler = { 272 .protocols = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC5X_20 | 273 RC_PROTO_BIT_RC5_SZ, 274 .decode = ir_rc5_decode, 275 .encode = ir_rc5_encode, 276 .carrier = 36000, 277 }; 278 279 static int __init ir_rc5_decode_init(void) 280 { 281 ir_raw_handler_register(&rc5_handler); 282 283 printk(KERN_INFO "IR RC5(x/sz) protocol handler initialized\n"); 284 return 0; 285 } 286 287 static void __exit ir_rc5_decode_exit(void) 288 { 289 ir_raw_handler_unregister(&rc5_handler); 290 } 291 292 module_init(ir_rc5_decode_init); 293 module_exit(ir_rc5_decode_exit); 294 295 MODULE_LICENSE("GPL v2"); 296 MODULE_AUTHOR("Mauro Carvalho Chehab and Jarod Wilson"); 297 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)"); 298 MODULE_DESCRIPTION("RC5(x/sz) IR protocol decoder"); 299