ir-sony-decoder.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* ir-sony-decoder.c - handle Sony IR Pulse/Space protocol
  3. *
  4. * Copyright (C) 2010 by David Härdeman <david@hardeman.nu>
  5. */
  6. #include <linux/bitrev.h>
  7. #include <linux/module.h>
  8. #include "rc-core-priv.h"
  9. #define SONY_UNIT 600 /* us */
  10. #define SONY_HEADER_PULSE (4 * SONY_UNIT)
  11. #define SONY_HEADER_SPACE (1 * SONY_UNIT)
  12. #define SONY_BIT_0_PULSE (1 * SONY_UNIT)
  13. #define SONY_BIT_1_PULSE (2 * SONY_UNIT)
  14. #define SONY_BIT_SPACE (1 * SONY_UNIT)
  15. #define SONY_TRAILER_SPACE (10 * SONY_UNIT) /* minimum */
  16. enum sony_state {
  17. STATE_INACTIVE,
  18. STATE_HEADER_SPACE,
  19. STATE_BIT_PULSE,
  20. STATE_BIT_SPACE,
  21. STATE_FINISHED,
  22. };
  23. /**
  24. * ir_sony_decode() - Decode one Sony pulse or space
  25. * @dev: the struct rc_dev descriptor of the device
  26. * @ev: the struct ir_raw_event descriptor of the pulse/space
  27. *
  28. * This function returns -EINVAL if the pulse violates the state machine
  29. */
  30. static int ir_sony_decode(struct rc_dev *dev, struct ir_raw_event ev)
  31. {
  32. struct sony_dec *data = &dev->raw->sony;
  33. enum rc_proto protocol;
  34. u32 scancode;
  35. u8 device, subdevice, function;
  36. if (!is_timing_event(ev)) {
  37. if (ev.reset)
  38. data->state = STATE_INACTIVE;
  39. return 0;
  40. }
  41. if (!geq_margin(ev.duration, SONY_UNIT, SONY_UNIT / 2))
  42. goto out;
  43. dev_dbg(&dev->dev, "Sony decode started at state %d (%uus %s)\n",
  44. data->state, ev.duration, TO_STR(ev.pulse));
  45. switch (data->state) {
  46. case STATE_INACTIVE:
  47. if (!ev.pulse)
  48. break;
  49. if (!eq_margin(ev.duration, SONY_HEADER_PULSE, SONY_UNIT / 2))
  50. break;
  51. data->count = 0;
  52. data->state = STATE_HEADER_SPACE;
  53. return 0;
  54. case STATE_HEADER_SPACE:
  55. if (ev.pulse)
  56. break;
  57. if (!eq_margin(ev.duration, SONY_HEADER_SPACE, SONY_UNIT / 2))
  58. break;
  59. data->state = STATE_BIT_PULSE;
  60. return 0;
  61. case STATE_BIT_PULSE:
  62. if (!ev.pulse)
  63. break;
  64. data->bits <<= 1;
  65. if (eq_margin(ev.duration, SONY_BIT_1_PULSE, SONY_UNIT / 2))
  66. data->bits |= 1;
  67. else if (!eq_margin(ev.duration, SONY_BIT_0_PULSE, SONY_UNIT / 2))
  68. break;
  69. data->count++;
  70. data->state = STATE_BIT_SPACE;
  71. return 0;
  72. case STATE_BIT_SPACE:
  73. if (ev.pulse)
  74. break;
  75. if (!geq_margin(ev.duration, SONY_BIT_SPACE, SONY_UNIT / 2))
  76. break;
  77. decrease_duration(&ev, SONY_BIT_SPACE);
  78. if (!geq_margin(ev.duration, SONY_UNIT, SONY_UNIT / 2)) {
  79. data->state = STATE_BIT_PULSE;
  80. return 0;
  81. }
  82. data->state = STATE_FINISHED;
  83. fallthrough;
  84. case STATE_FINISHED:
  85. if (ev.pulse)
  86. break;
  87. if (!geq_margin(ev.duration, SONY_TRAILER_SPACE, SONY_UNIT / 2))
  88. break;
  89. switch (data->count) {
  90. case 12:
  91. if (!(dev->enabled_protocols & RC_PROTO_BIT_SONY12))
  92. goto finish_state_machine;
  93. device = bitrev8((data->bits << 3) & 0xF8);
  94. subdevice = 0;
  95. function = bitrev8((data->bits >> 4) & 0xFE);
  96. protocol = RC_PROTO_SONY12;
  97. break;
  98. case 15:
  99. if (!(dev->enabled_protocols & RC_PROTO_BIT_SONY15))
  100. goto finish_state_machine;
  101. device = bitrev8((data->bits >> 0) & 0xFF);
  102. subdevice = 0;
  103. function = bitrev8((data->bits >> 7) & 0xFE);
  104. protocol = RC_PROTO_SONY15;
  105. break;
  106. case 20:
  107. if (!(dev->enabled_protocols & RC_PROTO_BIT_SONY20))
  108. goto finish_state_machine;
  109. device = bitrev8((data->bits >> 5) & 0xF8);
  110. subdevice = bitrev8((data->bits >> 0) & 0xFF);
  111. function = bitrev8((data->bits >> 12) & 0xFE);
  112. protocol = RC_PROTO_SONY20;
  113. break;
  114. default:
  115. dev_dbg(&dev->dev, "Sony invalid bitcount %u\n",
  116. data->count);
  117. goto out;
  118. }
  119. scancode = device << 16 | subdevice << 8 | function;
  120. dev_dbg(&dev->dev, "Sony(%u) scancode 0x%05x\n", data->count,
  121. scancode);
  122. rc_keydown(dev, protocol, scancode, 0);
  123. goto finish_state_machine;
  124. }
  125. out:
  126. dev_dbg(&dev->dev, "Sony decode failed at state %d (%uus %s)\n",
  127. data->state, ev.duration, TO_STR(ev.pulse));
  128. data->state = STATE_INACTIVE;
  129. return -EINVAL;
  130. finish_state_machine:
  131. data->state = STATE_INACTIVE;
  132. return 0;
  133. }
  134. static const struct ir_raw_timings_pl ir_sony_timings = {
  135. .header_pulse = SONY_HEADER_PULSE,
  136. .bit_space = SONY_BIT_SPACE,
  137. .bit_pulse[0] = SONY_BIT_0_PULSE,
  138. .bit_pulse[1] = SONY_BIT_1_PULSE,
  139. .trailer_space = SONY_TRAILER_SPACE + SONY_BIT_SPACE,
  140. .msb_first = 0,
  141. };
  142. /**
  143. * ir_sony_encode() - Encode a scancode as a stream of raw events
  144. *
  145. * @protocol: protocol to encode
  146. * @scancode: scancode to encode
  147. * @events: array of raw ir events to write into
  148. * @max: maximum size of @events
  149. *
  150. * Returns: The number of events written.
  151. * -ENOBUFS if there isn't enough space in the array to fit the
  152. * encoding. In this case all @max events will have been written.
  153. */
  154. static int ir_sony_encode(enum rc_proto protocol, u32 scancode,
  155. struct ir_raw_event *events, unsigned int max)
  156. {
  157. struct ir_raw_event *e = events;
  158. u32 raw, len;
  159. int ret;
  160. if (protocol == RC_PROTO_SONY12) {
  161. raw = (scancode & 0x7f) | ((scancode & 0x1f0000) >> 9);
  162. len = 12;
  163. } else if (protocol == RC_PROTO_SONY15) {
  164. raw = (scancode & 0x7f) | ((scancode & 0xff0000) >> 9);
  165. len = 15;
  166. } else {
  167. raw = (scancode & 0x7f) | ((scancode & 0x1f0000) >> 9) |
  168. ((scancode & 0xff00) << 4);
  169. len = 20;
  170. }
  171. ret = ir_raw_gen_pl(&e, max, &ir_sony_timings, len, raw);
  172. if (ret < 0)
  173. return ret;
  174. return e - events;
  175. }
  176. static struct ir_raw_handler sony_handler = {
  177. .protocols = RC_PROTO_BIT_SONY12 | RC_PROTO_BIT_SONY15 |
  178. RC_PROTO_BIT_SONY20,
  179. .decode = ir_sony_decode,
  180. .encode = ir_sony_encode,
  181. .carrier = 40000,
  182. .min_timeout = SONY_TRAILER_SPACE,
  183. };
  184. static int __init ir_sony_decode_init(void)
  185. {
  186. ir_raw_handler_register(&sony_handler);
  187. printk(KERN_INFO "IR Sony protocol handler initialized\n");
  188. return 0;
  189. }
  190. static void __exit ir_sony_decode_exit(void)
  191. {
  192. ir_raw_handler_unregister(&sony_handler);
  193. }
  194. module_init(ir_sony_decode_init);
  195. module_exit(ir_sony_decode_exit);
  196. MODULE_LICENSE("GPL");
  197. MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
  198. MODULE_DESCRIPTION("Sony IR protocol decoder");