tango-ir.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2015 Mans Rullgard <mans@mansr.com>
  4. */
  5. #include <linux/input.h>
  6. #include <linux/module.h>
  7. #include <linux/platform_device.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/io.h>
  10. #include <linux/clk.h>
  11. #include <linux/of.h>
  12. #include <media/rc-core.h>
  13. #define DRIVER_NAME "tango-ir"
  14. #define IR_NEC_CTRL 0x00
  15. #define IR_NEC_DATA 0x04
  16. #define IR_CTRL 0x08
  17. #define IR_RC5_CLK_DIV 0x0c
  18. #define IR_RC5_DATA 0x10
  19. #define IR_INT 0x14
  20. #define NEC_TIME_BASE 560
  21. #define RC5_TIME_BASE 1778
  22. #define RC6_CTRL 0x00
  23. #define RC6_CLKDIV 0x04
  24. #define RC6_DATA0 0x08
  25. #define RC6_DATA1 0x0c
  26. #define RC6_DATA2 0x10
  27. #define RC6_DATA3 0x14
  28. #define RC6_DATA4 0x18
  29. #define RC6_CARRIER 36000
  30. #define RC6_TIME_BASE 16
  31. #define NEC_CAP(n) ((n) << 24)
  32. #define GPIO_SEL(n) ((n) << 16)
  33. #define DISABLE_NEC (BIT(4) | BIT(8))
  34. #define ENABLE_RC5 (BIT(0) | BIT(9))
  35. #define ENABLE_RC6 (BIT(0) | BIT(7))
  36. #define ACK_IR_INT (BIT(0) | BIT(1))
  37. #define ACK_RC6_INT (BIT(31))
  38. #define NEC_ANY (RC_PROTO_BIT_NEC | RC_PROTO_BIT_NECX | RC_PROTO_BIT_NEC32)
  39. struct tango_ir {
  40. void __iomem *rc5_base;
  41. void __iomem *rc6_base;
  42. struct rc_dev *rc;
  43. struct clk *clk;
  44. };
  45. static void tango_ir_handle_nec(struct tango_ir *ir)
  46. {
  47. u32 v, code;
  48. enum rc_proto proto;
  49. v = readl_relaxed(ir->rc5_base + IR_NEC_DATA);
  50. if (!v) {
  51. rc_repeat(ir->rc);
  52. return;
  53. }
  54. code = ir_nec_bytes_to_scancode(v, v >> 8, v >> 16, v >> 24, &proto);
  55. rc_keydown(ir->rc, proto, code, 0);
  56. }
  57. static void tango_ir_handle_rc5(struct tango_ir *ir)
  58. {
  59. u32 data, field, toggle, addr, cmd, code;
  60. data = readl_relaxed(ir->rc5_base + IR_RC5_DATA);
  61. if (data & BIT(31))
  62. return;
  63. field = data >> 12 & 1;
  64. toggle = data >> 11 & 1;
  65. addr = data >> 6 & 0x1f;
  66. cmd = (data & 0x3f) | (field ^ 1) << 6;
  67. code = RC_SCANCODE_RC5(addr, cmd);
  68. rc_keydown(ir->rc, RC_PROTO_RC5, code, toggle);
  69. }
  70. static void tango_ir_handle_rc6(struct tango_ir *ir)
  71. {
  72. u32 data0, data1, toggle, mode, addr, cmd, code;
  73. data0 = readl_relaxed(ir->rc6_base + RC6_DATA0);
  74. data1 = readl_relaxed(ir->rc6_base + RC6_DATA1);
  75. mode = data0 >> 1 & 7;
  76. if (mode != 0)
  77. return;
  78. toggle = data0 & 1;
  79. addr = data0 >> 16;
  80. cmd = data1;
  81. code = RC_SCANCODE_RC6_0(addr, cmd);
  82. rc_keydown(ir->rc, RC_PROTO_RC6_0, code, toggle);
  83. }
  84. static irqreturn_t tango_ir_irq(int irq, void *dev_id)
  85. {
  86. struct tango_ir *ir = dev_id;
  87. unsigned int rc5_stat;
  88. unsigned int rc6_stat;
  89. rc5_stat = readl_relaxed(ir->rc5_base + IR_INT);
  90. writel_relaxed(rc5_stat, ir->rc5_base + IR_INT);
  91. rc6_stat = readl_relaxed(ir->rc6_base + RC6_CTRL);
  92. writel_relaxed(rc6_stat, ir->rc6_base + RC6_CTRL);
  93. if (!(rc5_stat & 3) && !(rc6_stat & BIT(31)))
  94. return IRQ_NONE;
  95. if (rc5_stat & BIT(0))
  96. tango_ir_handle_rc5(ir);
  97. if (rc5_stat & BIT(1))
  98. tango_ir_handle_nec(ir);
  99. if (rc6_stat & BIT(31))
  100. tango_ir_handle_rc6(ir);
  101. return IRQ_HANDLED;
  102. }
  103. static int tango_change_protocol(struct rc_dev *dev, u64 *rc_type)
  104. {
  105. struct tango_ir *ir = dev->priv;
  106. u32 rc5_ctrl = DISABLE_NEC;
  107. u32 rc6_ctrl = 0;
  108. if (*rc_type & NEC_ANY)
  109. rc5_ctrl = 0;
  110. if (*rc_type & RC_PROTO_BIT_RC5)
  111. rc5_ctrl |= ENABLE_RC5;
  112. if (*rc_type & RC_PROTO_BIT_RC6_0)
  113. rc6_ctrl = ENABLE_RC6;
  114. writel_relaxed(rc5_ctrl, ir->rc5_base + IR_CTRL);
  115. writel_relaxed(rc6_ctrl, ir->rc6_base + RC6_CTRL);
  116. return 0;
  117. }
  118. static int tango_ir_probe(struct platform_device *pdev)
  119. {
  120. const char *map_name = RC_MAP_TANGO;
  121. struct device *dev = &pdev->dev;
  122. struct rc_dev *rc;
  123. struct tango_ir *ir;
  124. u64 clkrate, clkdiv;
  125. int irq, err;
  126. u32 val;
  127. irq = platform_get_irq(pdev, 0);
  128. if (irq <= 0)
  129. return -EINVAL;
  130. ir = devm_kzalloc(dev, sizeof(*ir), GFP_KERNEL);
  131. if (!ir)
  132. return -ENOMEM;
  133. ir->rc5_base = devm_platform_ioremap_resource(pdev, 0);
  134. if (IS_ERR(ir->rc5_base))
  135. return PTR_ERR(ir->rc5_base);
  136. ir->rc6_base = devm_platform_ioremap_resource(pdev, 1);
  137. if (IS_ERR(ir->rc6_base))
  138. return PTR_ERR(ir->rc6_base);
  139. ir->clk = devm_clk_get(dev, NULL);
  140. if (IS_ERR(ir->clk))
  141. return PTR_ERR(ir->clk);
  142. rc = devm_rc_allocate_device(dev, RC_DRIVER_SCANCODE);
  143. if (!rc)
  144. return -ENOMEM;
  145. of_property_read_string(dev->of_node, "linux,rc-map-name", &map_name);
  146. rc->device_name = DRIVER_NAME;
  147. rc->driver_name = DRIVER_NAME;
  148. rc->input_phys = DRIVER_NAME "/input0";
  149. rc->map_name = map_name;
  150. rc->allowed_protocols = NEC_ANY | RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_0;
  151. rc->change_protocol = tango_change_protocol;
  152. rc->priv = ir;
  153. ir->rc = rc;
  154. err = clk_prepare_enable(ir->clk);
  155. if (err)
  156. return err;
  157. clkrate = clk_get_rate(ir->clk);
  158. clkdiv = clkrate * NEC_TIME_BASE;
  159. do_div(clkdiv, 1000000);
  160. val = NEC_CAP(31) | GPIO_SEL(12) | clkdiv;
  161. writel_relaxed(val, ir->rc5_base + IR_NEC_CTRL);
  162. clkdiv = clkrate * RC5_TIME_BASE;
  163. do_div(clkdiv, 1000000);
  164. writel_relaxed(DISABLE_NEC, ir->rc5_base + IR_CTRL);
  165. writel_relaxed(clkdiv, ir->rc5_base + IR_RC5_CLK_DIV);
  166. writel_relaxed(ACK_IR_INT, ir->rc5_base + IR_INT);
  167. clkdiv = clkrate * RC6_TIME_BASE;
  168. do_div(clkdiv, RC6_CARRIER);
  169. writel_relaxed(ACK_RC6_INT, ir->rc6_base + RC6_CTRL);
  170. writel_relaxed((clkdiv >> 2) << 18 | clkdiv, ir->rc6_base + RC6_CLKDIV);
  171. err = devm_request_irq(dev, irq, tango_ir_irq, IRQF_SHARED,
  172. dev_name(dev), ir);
  173. if (err)
  174. goto err_clk;
  175. err = devm_rc_register_device(dev, rc);
  176. if (err)
  177. goto err_clk;
  178. platform_set_drvdata(pdev, ir);
  179. return 0;
  180. err_clk:
  181. clk_disable_unprepare(ir->clk);
  182. return err;
  183. }
  184. static int tango_ir_remove(struct platform_device *pdev)
  185. {
  186. struct tango_ir *ir = platform_get_drvdata(pdev);
  187. clk_disable_unprepare(ir->clk);
  188. return 0;
  189. }
  190. static const struct of_device_id tango_ir_dt_ids[] = {
  191. { .compatible = "sigma,smp8642-ir" },
  192. { }
  193. };
  194. MODULE_DEVICE_TABLE(of, tango_ir_dt_ids);
  195. static struct platform_driver tango_ir_driver = {
  196. .probe = tango_ir_probe,
  197. .remove = tango_ir_remove,
  198. .driver = {
  199. .name = DRIVER_NAME,
  200. .of_match_table = tango_ir_dt_ids,
  201. },
  202. };
  203. module_platform_driver(tango_ir_driver);
  204. MODULE_DESCRIPTION("SMP86xx IR decoder driver");
  205. MODULE_AUTHOR("Mans Rullgard <mans@mansr.com>");
  206. MODULE_LICENSE("GPL");