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_type 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 IR_dprintk(2, "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_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_TYPE_SONY12; 131 break; 132 case 15: 133 if (!(dev->enabled_protocols & RC_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_TYPE_SONY15; 140 break; 141 case 20: 142 if (!(dev->enabled_protocols & RC_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_TYPE_SONY20; 149 break; 150 default: 151 IR_dprintk(1, "Sony invalid bitcount %u\n", data->count); 152 goto out; 153 } 154 155 scancode = device << 16 | subdevice << 8 | function; 156 IR_dprintk(1, "Sony(%u) scancode 0x%05x\n", data->count, scancode); 157 rc_keydown(dev, protocol, scancode, 0); 158 goto finish_state_machine; 159 } 160 161 out: 162 IR_dprintk(1, "Sony decode failed at state %d (%uus %s)\n", 163 data->state, TO_US(ev.duration), TO_STR(ev.pulse)); 164 data->state = STATE_INACTIVE; 165 return -EINVAL; 166 167 finish_state_machine: 168 data->state = STATE_INACTIVE; 169 return 0; 170 } 171 172 static struct ir_raw_handler sony_handler = { 173 .protocols = RC_BIT_SONY12 | RC_BIT_SONY15 | RC_BIT_SONY20, 174 .decode = ir_sony_decode, 175 }; 176 177 static int __init ir_sony_decode_init(void) 178 { 179 ir_raw_handler_register(&sony_handler); 180 181 printk(KERN_INFO "IR Sony protocol handler initialized\n"); 182 return 0; 183 } 184 185 static void __exit ir_sony_decode_exit(void) 186 { 187 ir_raw_handler_unregister(&sony_handler); 188 } 189 190 module_init(ir_sony_decode_init); 191 module_exit(ir_sony_decode_exit); 192 193 MODULE_LICENSE("GPL"); 194 MODULE_AUTHOR("David Härdeman <david@hardeman.nu>"); 195 MODULE_DESCRIPTION("Sony IR protocol decoder"); 196