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

   1 /* ir-sharp-decoder.c - handle Sharp IR Pulse/Space protocol
   2  *
   3  * Copyright (C) 2013-2014 Imagination Technologies Ltd.
   4  *
   5  * Based on NEC decoder:
   6  * Copyright (C) 2010 by Mauro Carvalho Chehab
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation version 2 of the License.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  */
  17
  18 #include <linux/bitrev.h>
  19 #include <linux/module.h>
  20 #include "rc-core-priv.h"
  21
  22 #define SHARP_NBITS             15
  23 #define SHARP_UNIT              40000  /* ns */
  24 #define SHARP_BIT_PULSE         (8    * SHARP_UNIT) /* 320us */
  25 #define SHARP_BIT_0_PERIOD      (25   * SHARP_UNIT) /* 1ms (680us space) */
  26 #define SHARP_BIT_1_PERIOD      (50   * SHARP_UNIT) /* 2ms (1680ms space) */
  27 #define SHARP_ECHO_SPACE        (1000 * SHARP_UNIT) /* 40 ms */
  28 #define SHARP_TRAILER_SPACE     (125  * SHARP_UNIT) /* 5 ms (even longer) */
  29
  30 enum sharp_state {
  31         STATE_INACTIVE,
  32         STATE_BIT_PULSE,
  33         STATE_BIT_SPACE,
  34         STATE_TRAILER_PULSE,
  35         STATE_ECHO_SPACE,
  36         STATE_TRAILER_SPACE,
  37 };
  38
  39 /**
  40  * ir_sharp_decode() - Decode one Sharp pulse or space
  41  * @dev:        the struct rc_dev descriptor of the device
  42  * @ev:         the struct ir_raw_event descriptor of the pulse/space
  43  *
  44  * This function returns -EINVAL if the pulse violates the state machine
  45  */
  46 static int ir_sharp_decode(struct rc_dev *dev, struct ir_raw_event ev)
  47 {
  48         struct sharp_dec *data = &dev->raw->sharp;
  49         u32 msg, echo, address, command, scancode;
  50
  51         if (!is_timing_event(ev)) {
  52                 if (ev.reset)
  53                         data->state = STATE_INACTIVE;
  54                 return 0;
  55         }
  56
  57         IR_dprintk(2, "Sharp decode started at state %d (%uus %s)\n",
  58                    data->state, TO_US(ev.duration), TO_STR(ev.pulse));
  59
  60         switch (data->state) {
  61
  62         case STATE_INACTIVE:
  63                 if (!ev.pulse)
  64                         break;
  65
  66                 if (!eq_margin(ev.duration, SHARP_BIT_PULSE,
  67                                SHARP_BIT_PULSE / 2))
  68                         break;
  69
  70                 data->count = 0;
  71                 data->pulse_len = ev.duration;
  72                 data->state = STATE_BIT_SPACE;
  73                 return 0;
  74
  75         case STATE_BIT_PULSE:
  76                 if (!ev.pulse)
  77                         break;
  78
  79                 if (!eq_margin(ev.duration, SHARP_BIT_PULSE,
  80                                SHARP_BIT_PULSE / 2))
  81                         break;
  82
  83                 data->pulse_len = ev.duration;
  84                 data->state = STATE_BIT_SPACE;
  85                 return 0;
  86
  87         case STATE_BIT_SPACE:
  88                 if (ev.pulse)
  89                         break;
  90
  91                 data->bits <<= 1;
  92                 if (eq_margin(data->pulse_len + ev.duration, SHARP_BIT_1_PERIOD,
  93                               SHARP_BIT_PULSE * 2))
  94                         data->bits |= 1;
  95                 else if (!eq_margin(data->pulse_len + ev.duration,
  96                                     SHARP_BIT_0_PERIOD, SHARP_BIT_PULSE * 2))
  97                         break;
  98                 data->count++;
  99
 100                 if (data->count == SHARP_NBITS ||
 101                     data->count == SHARP_NBITS * 2)
 102                         data->state = STATE_TRAILER_PULSE;
 103                 else
 104                         data->state = STATE_BIT_PULSE;
 105
 106                 return 0;
 107
 108         case STATE_TRAILER_PULSE:
 109                 if (!ev.pulse)
 110                         break;
 111
 112                 if (!eq_margin(ev.duration, SHARP_BIT_PULSE,
 113                                SHARP_BIT_PULSE / 2))
 114                         break;
 115
 116                 if (data->count == SHARP_NBITS) {
 117                         /* exp,chk bits should be 1,0 */
 118                         if ((data->bits & 0x3) != 0x2 &&
 119                         /* DENON variant, both chk bits 0 */
 120                             (data->bits & 0x3) != 0x0)
 121                                 break;
 122                         data->state = STATE_ECHO_SPACE;
 123                 } else {
 124                         data->state = STATE_TRAILER_SPACE;
 125                 }
 126                 return 0;
 127
 128         case STATE_ECHO_SPACE:
 129                 if (ev.pulse)
 130                         break;
 131
 132                 if (!eq_margin(ev.duration, SHARP_ECHO_SPACE,
 133                                SHARP_ECHO_SPACE / 4))
 134                         break;
 135
 136                 data->state = STATE_BIT_PULSE;
 137
 138                 return 0;
 139
 140         case STATE_TRAILER_SPACE:
 141                 if (ev.pulse)
 142                         break;
 143
 144                 if (!geq_margin(ev.duration, SHARP_TRAILER_SPACE,
 145                                 SHARP_BIT_PULSE / 2))
 146                         break;
 147
 148                 /* Validate - command, ext, chk should be inverted in 2nd */
 149                 msg = (data->bits >> 15) & 0x7fff;
 150                 echo = data->bits & 0x7fff;
 151                 if ((msg ^ echo) != 0x3ff) {
 152                         IR_dprintk(1,
 153                                    "Sharp checksum error: received 0x%04x, 0x%04x\n",
 154                                    msg, echo);
 155                         break;
 156                 }
 157
 158                 address = bitrev8((msg >> 7) & 0xf8);
 159                 command = bitrev8((msg >> 2) & 0xff);
 160
 161                 scancode = address << 8 | command;
 162                 IR_dprintk(1, "Sharp scancode 0x%04x\n", scancode);
 163
 164                 rc_keydown(dev, RC_PROTO_SHARP, scancode, 0);
 165                 data->state = STATE_INACTIVE;
 166                 return 0;
 167         }
 168
 169         IR_dprintk(1, "Sharp decode failed at count %d state %d (%uus %s)\n",
 170                    data->count, data->state, TO_US(ev.duration),
 171                    TO_STR(ev.pulse));
 172         data->state = STATE_INACTIVE;
 173         return -EINVAL;
 174 }
 175
 176 static const struct ir_raw_timings_pd ir_sharp_timings = {
 177         .header_pulse  = 0,
 178         .header_space  = 0,
 179         .bit_pulse     = SHARP_BIT_PULSE,
 180         .bit_space[0]  = SHARP_BIT_0_PERIOD,
 181         .bit_space[1]  = SHARP_BIT_1_PERIOD,
 182         .trailer_pulse = SHARP_BIT_PULSE,
 183         .trailer_space = SHARP_ECHO_SPACE,
 184         .msb_first     = 1,
 185 };
 186
 187 /**
 188  * ir_sharp_encode() - Encode a scancode as a stream of raw events
 189  *
 190  * @protocol:   protocol to encode
 191  * @scancode:   scancode to encode
 192  * @events:     array of raw ir events to write into
 193  * @max:        maximum size of @events
 194  *
 195  * Returns:     The number of events written.
 196  *              -ENOBUFS if there isn't enough space in the array to fit the
 197  *              encoding. In this case all @max events will have been written.
 198  */
 199 static int ir_sharp_encode(enum rc_proto protocol, u32 scancode,
 200                            struct ir_raw_event *events, unsigned int max)
 201 {
 202         struct ir_raw_event *e = events;
 203         int ret;
 204         u32 raw;
 205
 206         raw = (((bitrev8(scancode >> 8) >> 3) << 8) & 0x1f00) |
 207                 bitrev8(scancode);
 208         ret = ir_raw_gen_pd(&e, max, &ir_sharp_timings, SHARP_NBITS,
 209                             (raw << 2) | 2);
 210         if (ret < 0)
 211                 return ret;
 212
 213         max -= ret;
 214
 215         raw = (((bitrev8(scancode >> 8) >> 3) << 8) & 0x1f00) |
 216                 bitrev8(~scancode);
 217         ret = ir_raw_gen_pd(&e, max, &ir_sharp_timings, SHARP_NBITS,
 218                             (raw << 2) | 1);
 219         if (ret < 0)
 220                 return ret;
 221
 222         return e - events;
 223 }
 224
 225 static struct ir_raw_handler sharp_handler = {
 226         .protocols      = RC_PROTO_BIT_SHARP,
 227         .decode         = ir_sharp_decode,
 228         .encode         = ir_sharp_encode,
 229         .carrier        = 38000,
 230 };
 231
 232 static int __init ir_sharp_decode_init(void)
 233 {
 234         ir_raw_handler_register(&sharp_handler);
 235
 236         pr_info("IR Sharp protocol handler initialized\n");
 237         return 0;
 238 }
 239
 240 static void __exit ir_sharp_decode_exit(void)
 241 {
 242         ir_raw_handler_unregister(&sharp_handler);
 243 }
 244
 245 module_init(ir_sharp_decode_init);
 246 module_exit(ir_sharp_decode_exit);
 247
 248 MODULE_LICENSE("GPL");
 249 MODULE_AUTHOR("James Hogan <jhogan@kernel.org>");
 250 MODULE_DESCRIPTION("Sharp IR protocol decoder");