Commit | Line | Data |
---|---|---|
fc4f3146 DT |
1 | /* |
2 | * Copyright (C) 2013 Daniel Tang <tangrs@tangrs.id.au> | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2, as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | ||
9 | #include <linux/input/matrix_keypad.h> | |
10 | #include <linux/platform_device.h> | |
11 | #include <linux/interrupt.h> | |
12 | #include <linux/io.h> | |
13 | #include <linux/delay.h> | |
14 | #include <linux/input.h> | |
15 | #include <linux/slab.h> | |
16 | #include <linux/clk.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/of.h> | |
19 | ||
20 | #define KEYPAD_SCAN_MODE 0x00 | |
21 | #define KEYPAD_CNTL 0x04 | |
22 | #define KEYPAD_INT 0x08 | |
23 | #define KEYPAD_INTMSK 0x0C | |
24 | ||
25 | #define KEYPAD_DATA 0x10 | |
26 | #define KEYPAD_GPIO 0x30 | |
27 | ||
28 | #define KEYPAD_UNKNOWN_INT 0x40 | |
29 | #define KEYPAD_UNKNOWN_INT_STS 0x44 | |
30 | ||
31 | #define KEYPAD_BITMASK_COLS 11 | |
32 | #define KEYPAD_BITMASK_ROWS 8 | |
33 | ||
34 | struct nspire_keypad { | |
35 | void __iomem *reg_base; | |
36 | u32 int_mask; | |
37 | ||
38 | struct input_dev *input; | |
39 | struct clk *clk; | |
40 | ||
41 | struct matrix_keymap_data *keymap; | |
42 | int row_shift; | |
43 | ||
44 | /* Maximum delay estimated assuming 33MHz APB */ | |
45 | u32 scan_interval; /* In microseconds (~2000us max) */ | |
46 | u32 row_delay; /* In microseconds (~500us max) */ | |
47 | ||
48 | u16 state[KEYPAD_BITMASK_ROWS]; | |
49 | ||
50 | bool active_low; | |
51 | }; | |
52 | ||
53 | static irqreturn_t nspire_keypad_irq(int irq, void *dev_id) | |
54 | { | |
55 | struct nspire_keypad *keypad = dev_id; | |
56 | struct input_dev *input = keypad->input; | |
57 | unsigned short *keymap = input->keycode; | |
58 | unsigned int code; | |
59 | int row, col; | |
60 | u32 int_sts; | |
61 | u16 state[8]; | |
62 | u16 bits, changed; | |
63 | ||
64 | int_sts = readl(keypad->reg_base + KEYPAD_INT) & keypad->int_mask; | |
65 | if (!int_sts) | |
66 | return IRQ_NONE; | |
67 | ||
68 | memcpy_fromio(state, keypad->reg_base + KEYPAD_DATA, sizeof(state)); | |
69 | ||
70 | for (row = 0; row < KEYPAD_BITMASK_ROWS; row++) { | |
71 | bits = state[row]; | |
72 | if (keypad->active_low) | |
73 | bits = ~bits; | |
74 | ||
75 | changed = bits ^ keypad->state[row]; | |
76 | if (!changed) | |
77 | continue; | |
78 | ||
79 | keypad->state[row] = bits; | |
80 | ||
81 | for (col = 0; col < KEYPAD_BITMASK_COLS; col++) { | |
82 | if (!(changed & (1U << col))) | |
83 | continue; | |
84 | ||
85 | code = MATRIX_SCAN_CODE(row, col, keypad->row_shift); | |
86 | input_event(input, EV_MSC, MSC_SCAN, code); | |
87 | input_report_key(input, keymap[code], | |
88 | bits & (1U << col)); | |
89 | } | |
90 | } | |
91 | ||
92 | input_sync(input); | |
93 | ||
94 | writel(0x3, keypad->reg_base + KEYPAD_INT); | |
95 | ||
96 | return IRQ_HANDLED; | |
97 | } | |
98 | ||
99 | static int nspire_keypad_chip_init(struct nspire_keypad *keypad) | |
100 | { | |
101 | unsigned long val = 0, cycles_per_us, delay_cycles, row_delay_cycles; | |
102 | ||
103 | cycles_per_us = (clk_get_rate(keypad->clk) / 1000000); | |
104 | if (cycles_per_us == 0) | |
105 | cycles_per_us = 1; | |
106 | ||
107 | delay_cycles = cycles_per_us * keypad->scan_interval; | |
108 | WARN_ON(delay_cycles >= (1 << 16)); /* Overflow */ | |
109 | delay_cycles &= 0xffff; | |
110 | ||
111 | row_delay_cycles = cycles_per_us * keypad->row_delay; | |
112 | WARN_ON(row_delay_cycles >= (1 << 14)); /* Overflow */ | |
113 | row_delay_cycles &= 0x3fff; | |
114 | ||
115 | val |= 3 << 0; /* Set scan mode to 3 (continuous scan) */ | |
116 | val |= row_delay_cycles << 2; /* Delay between scanning each row */ | |
117 | val |= delay_cycles << 16; /* Delay between scans */ | |
118 | writel(val, keypad->reg_base + KEYPAD_SCAN_MODE); | |
119 | ||
120 | val = (KEYPAD_BITMASK_ROWS & 0xff) | (KEYPAD_BITMASK_COLS & 0xff)<<8; | |
121 | writel(val, keypad->reg_base + KEYPAD_CNTL); | |
122 | ||
123 | /* Enable interrupts */ | |
124 | keypad->int_mask = 1 << 1; | |
46146e7d | 125 | writel(keypad->int_mask, keypad->reg_base + KEYPAD_INTMSK); |
fc4f3146 DT |
126 | |
127 | /* Disable GPIO interrupts to prevent hanging on touchpad */ | |
128 | /* Possibly used to detect touchpad events */ | |
129 | writel(0, keypad->reg_base + KEYPAD_UNKNOWN_INT); | |
130 | /* Acknowledge existing interrupts */ | |
131 | writel(~0, keypad->reg_base + KEYPAD_UNKNOWN_INT_STS); | |
132 | ||
133 | return 0; | |
134 | } | |
135 | ||
136 | static int nspire_keypad_open(struct input_dev *input) | |
137 | { | |
138 | struct nspire_keypad *keypad = input_get_drvdata(input); | |
139 | int error; | |
140 | ||
141 | error = clk_prepare_enable(keypad->clk); | |
142 | if (error) | |
143 | return error; | |
144 | ||
145 | error = nspire_keypad_chip_init(keypad); | |
146 | if (error) | |
147 | return error; | |
148 | ||
149 | return 0; | |
150 | } | |
151 | ||
152 | static void nspire_keypad_close(struct input_dev *input) | |
153 | { | |
154 | struct nspire_keypad *keypad = input_get_drvdata(input); | |
155 | ||
156 | clk_disable_unprepare(keypad->clk); | |
157 | } | |
158 | ||
159 | static int nspire_keypad_probe(struct platform_device *pdev) | |
160 | { | |
161 | const struct device_node *of_node = pdev->dev.of_node; | |
162 | struct nspire_keypad *keypad; | |
163 | struct input_dev *input; | |
164 | struct resource *res; | |
165 | int irq; | |
166 | int error; | |
167 | ||
168 | irq = platform_get_irq(pdev, 0); | |
169 | if (irq < 0) { | |
170 | dev_err(&pdev->dev, "failed to get keypad irq\n"); | |
171 | return -EINVAL; | |
172 | } | |
173 | ||
fc4f3146 DT |
174 | keypad = devm_kzalloc(&pdev->dev, sizeof(struct nspire_keypad), |
175 | GFP_KERNEL); | |
176 | if (!keypad) { | |
177 | dev_err(&pdev->dev, "failed to allocate keypad memory\n"); | |
178 | return -ENOMEM; | |
179 | } | |
180 | ||
181 | keypad->row_shift = get_count_order(KEYPAD_BITMASK_COLS); | |
182 | ||
183 | error = of_property_read_u32(of_node, "scan-interval", | |
184 | &keypad->scan_interval); | |
185 | if (error) { | |
186 | dev_err(&pdev->dev, "failed to get scan-interval\n"); | |
187 | return error; | |
188 | } | |
189 | ||
190 | error = of_property_read_u32(of_node, "row-delay", | |
191 | &keypad->row_delay); | |
192 | if (error) { | |
193 | dev_err(&pdev->dev, "failed to get row-delay\n"); | |
194 | return error; | |
195 | } | |
196 | ||
197 | keypad->active_low = of_property_read_bool(of_node, "active-low"); | |
198 | ||
199 | keypad->clk = devm_clk_get(&pdev->dev, NULL); | |
200 | if (IS_ERR(keypad->clk)) { | |
201 | dev_err(&pdev->dev, "unable to get clock\n"); | |
202 | return PTR_ERR(keypad->clk); | |
203 | } | |
204 | ||
ef0aca7f | 205 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
fc4f3146 | 206 | keypad->reg_base = devm_ioremap_resource(&pdev->dev, res); |
20c3da9f | 207 | if (IS_ERR(keypad->reg_base)) |
fc4f3146 | 208 | return PTR_ERR(keypad->reg_base); |
fc4f3146 DT |
209 | |
210 | keypad->input = input = devm_input_allocate_device(&pdev->dev); | |
211 | if (!input) { | |
212 | dev_err(&pdev->dev, "failed to allocate input device\n"); | |
213 | return -ENOMEM; | |
214 | } | |
215 | ||
216 | input_set_drvdata(input, keypad); | |
217 | ||
218 | input->id.bustype = BUS_HOST; | |
219 | input->name = "nspire-keypad"; | |
220 | input->open = nspire_keypad_open; | |
221 | input->close = nspire_keypad_close; | |
222 | ||
223 | __set_bit(EV_KEY, input->evbit); | |
224 | __set_bit(EV_REP, input->evbit); | |
225 | input_set_capability(input, EV_MSC, MSC_SCAN); | |
226 | ||
227 | error = matrix_keypad_build_keymap(NULL, NULL, | |
228 | KEYPAD_BITMASK_ROWS, | |
229 | KEYPAD_BITMASK_COLS, | |
230 | NULL, input); | |
231 | if (error) { | |
232 | dev_err(&pdev->dev, "building keymap failed\n"); | |
233 | return error; | |
234 | } | |
235 | ||
236 | error = devm_request_irq(&pdev->dev, irq, nspire_keypad_irq, 0, | |
237 | "nspire_keypad", keypad); | |
238 | if (error) { | |
239 | dev_err(&pdev->dev, "allocate irq %d failed\n", irq); | |
240 | return error; | |
241 | } | |
242 | ||
243 | error = input_register_device(input); | |
244 | if (error) { | |
245 | dev_err(&pdev->dev, | |
246 | "unable to register input device: %d\n", error); | |
247 | return error; | |
248 | } | |
249 | ||
250 | platform_set_drvdata(pdev, keypad); | |
251 | ||
252 | dev_dbg(&pdev->dev, | |
253 | "TI-NSPIRE keypad at %pR (scan_interval=%uus, row_delay=%uus%s)\n", | |
254 | res, keypad->row_delay, keypad->scan_interval, | |
255 | keypad->active_low ? ", active_low" : ""); | |
256 | ||
257 | return 0; | |
258 | } | |
259 | ||
260 | static const struct of_device_id nspire_keypad_dt_match[] = { | |
261 | { .compatible = "ti,nspire-keypad" }, | |
262 | { }, | |
263 | }; | |
264 | MODULE_DEVICE_TABLE(of, nspire_keypad_dt_match); | |
265 | ||
266 | static struct platform_driver nspire_keypad_driver = { | |
267 | .driver = { | |
268 | .name = "nspire-keypad", | |
269 | .owner = THIS_MODULE, | |
270 | .of_match_table = of_match_ptr(nspire_keypad_dt_match), | |
271 | }, | |
272 | .probe = nspire_keypad_probe, | |
273 | }; | |
274 | ||
275 | module_platform_driver(nspire_keypad_driver); | |
276 | ||
277 | MODULE_LICENSE("GPL"); | |
278 | MODULE_DESCRIPTION("TI-NSPIRE Keypad Driver"); |