drivers/media/rc/ir-rc5-decoder.c

   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         dev_dbg(&dev->dev, "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 (data->count == CHECK_RC5X_NBITS)
  92                         data->state = STATE_CHECK_RC5X;
  93                 else
  94                         data->state = STATE_BIT_START;
  95
  96                 decrease_duration(&ev, RC5_BIT_END);
  97                 goto again;
  98
  99         case STATE_CHECK_RC5X:
 100                 if (!ev.pulse && geq_margin(ev.duration, RC5X_SPACE, RC5_UNIT / 2)) {
 101                         data->is_rc5x = true;
 102                         decrease_duration(&ev, RC5X_SPACE);
 103                 } else
 104                         data->is_rc5x = false;
 105                 data->state = STATE_BIT_START;
 106                 goto again;
 107
 108         case STATE_FINISHED:
 109                 if (ev.pulse)
 110                         break;
 111
 112                 if (data->is_rc5x && data->count == RC5X_NBITS) {
 113                         /* RC5X */
 114                         u8 xdata, command, system;
 115                         if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5X_20)) {
 116                                 data->state = STATE_INACTIVE;
 117                                 return 0;
 118                         }
 119                         xdata    = (data->bits & 0x0003F) >> 0;
 120                         command  = (data->bits & 0x00FC0) >> 6;
 121                         system   = (data->bits & 0x1F000) >> 12;
 122                         toggle   = (data->bits & 0x20000) ? 1 : 0;
 123                         command += (data->bits & 0x40000) ? 0 : 0x40;
 124                         scancode = system << 16 | command << 8 | xdata;
 125                         protocol = RC_PROTO_RC5X_20;
 126
 127                 } else if (!data->is_rc5x && data->count == RC5_NBITS) {
 128                         /* RC5 */
 129                         u8 command, system;
 130                         if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5)) {
 131                                 data->state = STATE_INACTIVE;
 132                                 return 0;
 133                         }
 134                         command  = (data->bits & 0x0003F) >> 0;
 135                         system   = (data->bits & 0x007C0) >> 6;
 136                         toggle   = (data->bits & 0x00800) ? 1 : 0;
 137                         command += (data->bits & 0x01000) ? 0 : 0x40;
 138                         scancode = system << 8 | command;
 139                         protocol = RC_PROTO_RC5;
 140
 141                 } else if (!data->is_rc5x && data->count == RC5_SZ_NBITS) {
 142                         /* RC5 StreamZap */
 143                         u8 command, system;
 144                         if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5_SZ)) {
 145                                 data->state = STATE_INACTIVE;
 146                                 return 0;
 147                         }
 148                         command  = (data->bits & 0x0003F) >> 0;
 149                         system   = (data->bits & 0x02FC0) >> 6;
 150                         toggle   = (data->bits & 0x01000) ? 1 : 0;
 151                         scancode = system << 6 | command;
 152                         protocol = RC_PROTO_RC5_SZ;
 153
 154                 } else
 155                         break;
 156
 157                 dev_dbg(&dev->dev, "RC5(x/sz) scancode 0x%06x (p: %u, t: %u)\n",
 158                         scancode, protocol, toggle);
 159
 160                 rc_keydown(dev, protocol, scancode, toggle);
 161                 data->state = STATE_INACTIVE;
 162                 return 0;
 163         }
 164
 165 out:
 166         dev_dbg(&dev->dev, "RC5(x/sz) decode failed at state %i count %d (%uus %s)\n",
 167                 data->state, data->count, TO_US(ev.duration), TO_STR(ev.pulse));
 168         data->state = STATE_INACTIVE;
 169         return -EINVAL;
 170 }
 171
 172 static const struct ir_raw_timings_manchester ir_rc5_timings = {
 173         .leader_pulse           = RC5_UNIT,
 174         .clock                  = RC5_UNIT,
 175         .trailer_space          = RC5_UNIT * 10,
 176 };
 177
 178 static const struct ir_raw_timings_manchester ir_rc5x_timings[2] = {
 179         {
 180                 .leader_pulse           = RC5_UNIT,
 181                 .clock                  = RC5_UNIT,
 182                 .trailer_space          = RC5X_SPACE,
 183         },
 184         {
 185                 .clock                  = RC5_UNIT,
 186                 .trailer_space          = RC5_UNIT * 10,
 187         },
 188 };
 189
 190 static const struct ir_raw_timings_manchester ir_rc5_sz_timings = {
 191         .leader_pulse                   = RC5_UNIT,
 192         .clock                          = RC5_UNIT,
 193         .trailer_space                  = RC5_UNIT * 10,
 194 };
 195
 196 /**
 197  * ir_rc5_encode() - Encode a scancode as a stream of raw events
 198  *
 199  * @protocol:   protocol variant to encode
 200  * @scancode:   scancode to encode
 201  * @events:     array of raw ir events to write into
 202  * @max:        maximum size of @events
 203  *
 204  * Returns:     The number of events written.
 205  *              -ENOBUFS if there isn't enough space in the array to fit the
 206  *              encoding. In this case all @max events will have been written.
 207  *              -EINVAL if the scancode is ambiguous or invalid.
 208  */
 209 static int ir_rc5_encode(enum rc_proto protocol, u32 scancode,
 210                          struct ir_raw_event *events, unsigned int max)
 211 {
 212         int ret;
 213         struct ir_raw_event *e = events;
 214         unsigned int data, xdata, command, commandx, system, pre_space_data;
 215
 216         /* Detect protocol and convert scancode to raw data */
 217         if (protocol == RC_PROTO_RC5) {
 218                 /* decode scancode */
 219                 command  = (scancode & 0x003f) >> 0;
 220                 commandx = (scancode & 0x0040) >> 6;
 221                 system   = (scancode & 0x1f00) >> 8;
 222                 /* encode data */
 223                 data = !commandx << 12 | system << 6 | command;
 224
 225                 /* First bit is encoded by leader_pulse */
 226                 ret = ir_raw_gen_manchester(&e, max, &ir_rc5_timings,
 227                                             RC5_NBITS - 1, data);
 228                 if (ret < 0)
 229                         return ret;
 230         } else if (protocol == RC_PROTO_RC5X_20) {
 231                 /* decode scancode */
 232                 xdata    = (scancode & 0x00003f) >> 0;
 233                 command  = (scancode & 0x003f00) >> 8;
 234                 commandx = !(scancode & 0x004000);
 235                 system   = (scancode & 0x1f0000) >> 16;
 236
 237                 /* encode data */
 238                 data = commandx << 18 | system << 12 | command << 6 | xdata;
 239
 240                 /* First bit is encoded by leader_pulse */
 241                 pre_space_data = data >> (RC5X_NBITS - CHECK_RC5X_NBITS);
 242                 ret = ir_raw_gen_manchester(&e, max, &ir_rc5x_timings[0],
 243                                             CHECK_RC5X_NBITS - 1,
 244                                             pre_space_data);
 245                 if (ret < 0)
 246                         return ret;
 247                 ret = ir_raw_gen_manchester(&e, max - (e - events),
 248                                             &ir_rc5x_timings[1],
 249                                             RC5X_NBITS - CHECK_RC5X_NBITS,
 250                                             data);
 251                 if (ret < 0)
 252                         return ret;
 253         } else if (protocol == RC_PROTO_RC5_SZ) {
 254                 /* RC5-SZ scancode is raw enough for Manchester as it is */
 255                 /* First bit is encoded by leader_pulse */
 256                 ret = ir_raw_gen_manchester(&e, max, &ir_rc5_sz_timings,
 257                                             RC5_SZ_NBITS - 1,
 258                                             scancode & 0x2fff);
 259                 if (ret < 0)
 260                         return ret;
 261         } else {
 262                 return -EINVAL;
 263         }
 264
 265         return e - events;
 266 }
 267
 268 static struct ir_raw_handler rc5_handler = {
 269         .protocols      = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC5X_20 |
 270                                                         RC_PROTO_BIT_RC5_SZ,
 271         .decode         = ir_rc5_decode,
 272         .encode         = ir_rc5_encode,
 273         .carrier        = 36000,
 274         .min_timeout    = RC5_TRAILER,
 275 };
 276
 277 static int __init ir_rc5_decode_init(void)
 278 {
 279         ir_raw_handler_register(&rc5_handler);
 280
 281         printk(KERN_INFO "IR RC5(x/sz) protocol handler initialized\n");
 282         return 0;
 283 }
 284
 285 static void __exit ir_rc5_decode_exit(void)
 286 {
 287         ir_raw_handler_unregister(&rc5_handler);
 288 }
 289
 290 module_init(ir_rc5_decode_init);
 291 module_exit(ir_rc5_decode_exit);
 292
 293 MODULE_LICENSE("GPL v2");
 294 MODULE_AUTHOR("Mauro Carvalho Chehab and Jarod Wilson");
 295 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
 296 MODULE_DESCRIPTION("RC5(x/sz) IR protocol decoder");