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