1 /* ir-sony-decoder.c - handle Sony IR Pulse/Space protocol 2 * 3 * Copyright (C) 2010 by David Härdeman <david@hardeman.nu> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation version 2 of the License. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 15 #include <linux/bitrev.h> 16 #include <linux/module.h> 17 #include "rc-core-priv.h" 18 19 #define SONY_UNIT 600000 /* ns */ 20 #define SONY_HEADER_PULSE (4 * SONY_UNIT) 21 #define SONY_HEADER_SPACE (1 * SONY_UNIT) 22 #define SONY_BIT_0_PULSE (1 * SONY_UNIT) 23 #define SONY_BIT_1_PULSE (2 * SONY_UNIT) 24 #define SONY_BIT_SPACE (1 * SONY_UNIT) 25 #define SONY_TRAILER_SPACE (10 * SONY_UNIT) /* minimum */ 26 27 enum sony_state { 28 STATE_INACTIVE, 29 STATE_HEADER_SPACE, 30 STATE_BIT_PULSE, 31 STATE_BIT_SPACE, 32 STATE_FINISHED, 33 }; 34 35 /** 36 * ir_sony_decode() - Decode one Sony pulse or space 37 * @dev: the struct rc_dev descriptor of the device 38 * @ev: the struct ir_raw_event descriptor of the pulse/space 39 * 40 * This function returns -EINVAL if the pulse violates the state machine 41 */ 42 static int ir_sony_decode(struct rc_dev *dev, struct ir_raw_event ev) 43 { 44 struct sony_dec *data = &dev->raw->sony; 45 enum rc_proto protocol; 46 u32 scancode; 47 u8 device, subdevice, function; 48 49 if (!is_timing_event(ev)) { 50 if (ev.reset) 51 data->state = STATE_INACTIVE; 52 return 0; 53 } 54 55 if (!geq_margin(ev.duration, SONY_UNIT, SONY_UNIT / 2)) 56 goto out; 57 58 dev_dbg(&dev->dev, "Sony decode started at state %d (%uus %s)\n", 59 data->state, TO_US(ev.duration), TO_STR(ev.pulse)); 60 61 switch (data->state) { 62 63 case STATE_INACTIVE: 64 if (!ev.pulse) 65 break; 66 67 if (!eq_margin(ev.duration, SONY_HEADER_PULSE, SONY_UNIT / 2)) 68 break; 69 70 data->count = 0; 71 data->state = STATE_HEADER_SPACE; 72 return 0; 73 74 case STATE_HEADER_SPACE: 75 if (ev.pulse) 76 break; 77 78 if (!eq_margin(ev.duration, SONY_HEADER_SPACE, SONY_UNIT / 2)) 79 break; 80 81 data->state = STATE_BIT_PULSE; 82 return 0; 83 84 case STATE_BIT_PULSE: 85 if (!ev.pulse) 86 break; 87 88 data->bits <<= 1; 89 if (eq_margin(ev.duration, SONY_BIT_1_PULSE, SONY_UNIT / 2)) 90 data->bits |= 1; 91 else if (!eq_margin(ev.duration, SONY_BIT_0_PULSE, SONY_UNIT / 2)) 92 break; 93 94 data->count++; 95 data->state = STATE_BIT_SPACE; 96 return 0; 97 98 case STATE_BIT_SPACE: 99 if (ev.pulse) 100 break; 101 102 if (!geq_margin(ev.duration, SONY_BIT_SPACE, SONY_UNIT / 2)) 103 break; 104 105 decrease_duration(&ev, SONY_BIT_SPACE); 106 107 if (!geq_margin(ev.duration, SONY_UNIT, SONY_UNIT / 2)) { 108 data->state = STATE_BIT_PULSE; 109 return 0; 110 } 111 112 data->state = STATE_FINISHED; 113 /* Fall through */ 114 115 case STATE_FINISHED: 116 if (ev.pulse) 117 break; 118 119 if (!geq_margin(ev.duration, SONY_TRAILER_SPACE, SONY_UNIT / 2)) 120 break; 121 122 switch (data->count) { 123 case 12: 124 if (!(dev->enabled_protocols & RC_PROTO_BIT_SONY12)) 125 goto finish_state_machine; 126 127 device = bitrev8((data->bits << 3) & 0xF8); 128 subdevice = 0; 129 function = bitrev8((data->bits >> 4) & 0xFE); 130 protocol = RC_PROTO_SONY12; 131 break; 132 case 15: 133 if (!(dev->enabled_protocols & RC_PROTO_BIT_SONY15)) 134 goto finish_state_machine; 135 136 device = bitrev8((data->bits >> 0) & 0xFF); 137 subdevice = 0; 138 function = bitrev8((data->bits >> 7) & 0xFE); 139 protocol = RC_PROTO_SONY15; 140 break; 141 case 20: 142 if (!(dev->enabled_protocols & RC_PROTO_BIT_SONY20)) 143 goto finish_state_machine; 144 145 device = bitrev8((data->bits >> 5) & 0xF8); 146 subdevice = bitrev8((data->bits >> 0) & 0xFF); 147 function = bitrev8((data->bits >> 12) & 0xFE); 148 protocol = RC_PROTO_SONY20; 149 break; 150 default: 151 dev_dbg(&dev->dev, "Sony invalid bitcount %u\n", 152 data->count); 153 goto out; 154 } 155 156 scancode = device << 16 | subdevice << 8 | function; 157 dev_dbg(&dev->dev, "Sony(%u) scancode 0x%05x\n", data->count, 158 scancode); 159 rc_keydown(dev, protocol, scancode, 0); 160 goto finish_state_machine; 161 } 162 163 out: 164 dev_dbg(&dev->dev, "Sony decode failed at state %d (%uus %s)\n", 165 data->state, TO_US(ev.duration), TO_STR(ev.pulse)); 166 data->state = STATE_INACTIVE; 167 return -EINVAL; 168 169 finish_state_machine: 170 data->state = STATE_INACTIVE; 171 return 0; 172 } 173 174 static const struct ir_raw_timings_pl ir_sony_timings = { 175 .header_pulse = SONY_HEADER_PULSE, 176 .bit_space = SONY_BIT_SPACE, 177 .bit_pulse[0] = SONY_BIT_0_PULSE, 178 .bit_pulse[1] = SONY_BIT_1_PULSE, 179 .trailer_space = SONY_TRAILER_SPACE + SONY_BIT_SPACE, 180 .msb_first = 0, 181 }; 182 183 /** 184 * ir_sony_encode() - Encode a scancode as a stream of raw events 185 * 186 * @protocol: protocol to encode 187 * @scancode: scancode to encode 188 * @events: array of raw ir events to write into 189 * @max: maximum size of @events 190 * 191 * Returns: The number of events written. 192 * -ENOBUFS if there isn't enough space in the array to fit the 193 * encoding. In this case all @max events will have been written. 194 */ 195 static int ir_sony_encode(enum rc_proto protocol, u32 scancode, 196 struct ir_raw_event *events, unsigned int max) 197 { 198 struct ir_raw_event *e = events; 199 u32 raw, len; 200 int ret; 201 202 if (protocol == RC_PROTO_SONY12) { 203 raw = (scancode & 0x7f) | ((scancode & 0x1f0000) >> 9); 204 len = 12; 205 } else if (protocol == RC_PROTO_SONY15) { 206 raw = (scancode & 0x7f) | ((scancode & 0xff0000) >> 9); 207 len = 15; 208 } else { 209 raw = (scancode & 0x7f) | ((scancode & 0x1f0000) >> 9) | 210 ((scancode & 0xff00) << 4); 211 len = 20; 212 } 213 214 ret = ir_raw_gen_pl(&e, max, &ir_sony_timings, len, raw); 215 if (ret < 0) 216 return ret; 217 218 return e - events; 219 } 220 221 static struct ir_raw_handler sony_handler = { 222 .protocols = RC_PROTO_BIT_SONY12 | RC_PROTO_BIT_SONY15 | 223 RC_PROTO_BIT_SONY20, 224 .decode = ir_sony_decode, 225 .encode = ir_sony_encode, 226 .carrier = 40000, 227 .min_timeout = SONY_TRAILER_SPACE, 228 }; 229 230 static int __init ir_sony_decode_init(void) 231 { 232 ir_raw_handler_register(&sony_handler); 233 234 printk(KERN_INFO "IR Sony protocol handler initialized\n"); 235 return 0; 236 } 237 238 static void __exit ir_sony_decode_exit(void) 239 { 240 ir_raw_handler_unregister(&sony_handler); 241 } 242 243 module_init(ir_sony_decode_init); 244 module_exit(ir_sony_decode_exit); 245 246 MODULE_LICENSE("GPL"); 247 MODULE_AUTHOR("David Härdeman <david@hardeman.nu>"); 248 MODULE_DESCRIPTION("Sony IR protocol decoder"); 249