1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * linux/drivers/input/keyboard/omap-keypad.c |
4 | * |
5 | * OMAP Keypad Driver |
6 | * |
7 | * Copyright (C) 2003 Nokia Corporation |
8 | * Written by Timo Teräs <ext-timo.teras@nokia.com> |
9 | * |
10 | * Added support for H2 & H3 Keypad |
11 | * Copyright (C) 2004 Texas Instruments |
12 | */ |
13 | |
14 | #include <linux/module.h> |
15 | #include <linux/interrupt.h> |
16 | #include <linux/types.h> |
17 | #include <linux/input.h> |
18 | #include <linux/kernel.h> |
19 | #include <linux/delay.h> |
20 | #include <linux/platform_device.h> |
21 | #include <linux/mutex.h> |
22 | #include <linux/errno.h> |
23 | #include <linux/slab.h> |
24 | #include <linux/platform_data/gpio-omap.h> |
25 | #include <linux/platform_data/keypad-omap.h> |
26 | #include <linux/soc/ti/omap1-io.h> |
27 | |
28 | #undef NEW_BOARD_LEARNING_MODE |
29 | |
30 | static void omap_kp_tasklet(unsigned long); |
31 | static void omap_kp_timer(struct timer_list *); |
32 | |
33 | static unsigned char keypad_state[8]; |
34 | static DEFINE_MUTEX(kp_enable_mutex); |
35 | static int kp_enable = 1; |
36 | static int kp_cur_group = -1; |
37 | |
38 | struct omap_kp { |
39 | struct input_dev *input; |
40 | struct timer_list timer; |
41 | int irq; |
42 | unsigned int rows; |
43 | unsigned int cols; |
44 | unsigned long delay; |
45 | unsigned int debounce; |
46 | unsigned short keymap[]; |
47 | }; |
48 | |
49 | static DECLARE_TASKLET_DISABLED_OLD(kp_tasklet, omap_kp_tasklet); |
50 | |
51 | static irqreturn_t omap_kp_interrupt(int irq, void *dev_id) |
52 | { |
53 | /* disable keyboard interrupt and schedule for handling */ |
54 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
55 | |
56 | tasklet_schedule(t: &kp_tasklet); |
57 | |
58 | return IRQ_HANDLED; |
59 | } |
60 | |
61 | static void omap_kp_timer(struct timer_list *unused) |
62 | { |
63 | tasklet_schedule(t: &kp_tasklet); |
64 | } |
65 | |
66 | static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state) |
67 | { |
68 | int col = 0; |
69 | |
70 | /* disable keyboard interrupt and schedule for handling */ |
71 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
72 | |
73 | /* read the keypad status */ |
74 | omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC); |
75 | for (col = 0; col < omap_kp->cols; col++) { |
76 | omap_writew(~(1 << col) & 0xff, |
77 | OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC); |
78 | |
79 | udelay(omap_kp->delay); |
80 | |
81 | state[col] = ~omap_readw(OMAP1_MPUIO_BASE + |
82 | OMAP_MPUIO_KBR_LATCH) & 0xff; |
83 | } |
84 | omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC); |
85 | udelay(2); |
86 | } |
87 | |
88 | static void omap_kp_tasklet(unsigned long data) |
89 | { |
90 | struct omap_kp *omap_kp_data = (struct omap_kp *) data; |
91 | unsigned short *keycodes = omap_kp_data->input->keycode; |
92 | unsigned int row_shift = get_count_order(count: omap_kp_data->cols); |
93 | unsigned char new_state[8], changed, key_down = 0; |
94 | int col, row; |
95 | |
96 | /* check for any changes */ |
97 | omap_kp_scan_keypad(omap_kp: omap_kp_data, state: new_state); |
98 | |
99 | /* check for changes and print those */ |
100 | for (col = 0; col < omap_kp_data->cols; col++) { |
101 | changed = new_state[col] ^ keypad_state[col]; |
102 | key_down |= new_state[col]; |
103 | if (changed == 0) |
104 | continue; |
105 | |
106 | for (row = 0; row < omap_kp_data->rows; row++) { |
107 | int key; |
108 | if (!(changed & (1 << row))) |
109 | continue; |
110 | #ifdef NEW_BOARD_LEARNING_MODE |
111 | printk(KERN_INFO "omap-keypad: key %d-%d %s\n" , col, |
112 | row, (new_state[col] & (1 << row)) ? |
113 | "pressed" : "released" ); |
114 | #else |
115 | key = keycodes[MATRIX_SCAN_CODE(row, col, row_shift)]; |
116 | |
117 | if (!(kp_cur_group == (key & GROUP_MASK) || |
118 | kp_cur_group == -1)) |
119 | continue; |
120 | |
121 | kp_cur_group = key & GROUP_MASK; |
122 | input_report_key(dev: omap_kp_data->input, code: key & ~GROUP_MASK, |
123 | value: new_state[col] & (1 << row)); |
124 | #endif |
125 | } |
126 | } |
127 | input_sync(dev: omap_kp_data->input); |
128 | memcpy(keypad_state, new_state, sizeof(keypad_state)); |
129 | |
130 | if (key_down) { |
131 | /* some key is pressed - keep irq disabled and use timer |
132 | * to poll the keypad */ |
133 | mod_timer(timer: &omap_kp_data->timer, expires: jiffies + HZ / 20); |
134 | } else { |
135 | /* enable interrupts */ |
136 | omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
137 | kp_cur_group = -1; |
138 | } |
139 | } |
140 | |
141 | static ssize_t omap_kp_enable_show(struct device *dev, |
142 | struct device_attribute *attr, char *buf) |
143 | { |
144 | return sprintf(buf, fmt: "%u\n" , kp_enable); |
145 | } |
146 | |
147 | static ssize_t omap_kp_enable_store(struct device *dev, struct device_attribute *attr, |
148 | const char *buf, size_t count) |
149 | { |
150 | struct omap_kp *omap_kp = dev_get_drvdata(dev); |
151 | int state; |
152 | |
153 | if (sscanf(buf, "%u" , &state) != 1) |
154 | return -EINVAL; |
155 | |
156 | if ((state != 1) && (state != 0)) |
157 | return -EINVAL; |
158 | |
159 | mutex_lock(&kp_enable_mutex); |
160 | if (state != kp_enable) { |
161 | if (state) |
162 | enable_irq(irq: omap_kp->irq); |
163 | else |
164 | disable_irq(irq: omap_kp->irq); |
165 | kp_enable = state; |
166 | } |
167 | mutex_unlock(lock: &kp_enable_mutex); |
168 | |
169 | return strnlen(p: buf, maxlen: count); |
170 | } |
171 | |
172 | static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, omap_kp_enable_show, omap_kp_enable_store); |
173 | |
174 | static int omap_kp_probe(struct platform_device *pdev) |
175 | { |
176 | struct omap_kp *omap_kp; |
177 | struct input_dev *input_dev; |
178 | struct omap_kp_platform_data *pdata = dev_get_platdata(dev: &pdev->dev); |
179 | int ret; |
180 | unsigned int row_shift, keycodemax; |
181 | |
182 | if (!pdata->rows || !pdata->cols || !pdata->keymap_data) { |
183 | printk(KERN_ERR "No rows, cols or keymap_data from pdata\n" ); |
184 | return -EINVAL; |
185 | } |
186 | |
187 | row_shift = get_count_order(count: pdata->cols); |
188 | keycodemax = pdata->rows << row_shift; |
189 | |
190 | omap_kp = kzalloc(struct_size(omap_kp, keymap, keycodemax), GFP_KERNEL); |
191 | input_dev = input_allocate_device(); |
192 | if (!omap_kp || !input_dev) { |
193 | kfree(objp: omap_kp); |
194 | input_free_device(dev: input_dev); |
195 | return -ENOMEM; |
196 | } |
197 | |
198 | platform_set_drvdata(pdev, data: omap_kp); |
199 | |
200 | omap_kp->input = input_dev; |
201 | |
202 | /* Disable the interrupt for the MPUIO keyboard */ |
203 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
204 | |
205 | if (pdata->delay) |
206 | omap_kp->delay = pdata->delay; |
207 | |
208 | omap_kp->rows = pdata->rows; |
209 | omap_kp->cols = pdata->cols; |
210 | |
211 | timer_setup(&omap_kp->timer, omap_kp_timer, 0); |
212 | |
213 | /* get the irq and init timer*/ |
214 | kp_tasklet.data = (unsigned long) omap_kp; |
215 | tasklet_enable(t: &kp_tasklet); |
216 | |
217 | ret = device_create_file(device: &pdev->dev, entry: &dev_attr_enable); |
218 | if (ret < 0) |
219 | goto err2; |
220 | |
221 | /* setup input device */ |
222 | input_dev->name = "omap-keypad" ; |
223 | input_dev->phys = "omap-keypad/input0" ; |
224 | input_dev->dev.parent = &pdev->dev; |
225 | |
226 | input_dev->id.bustype = BUS_HOST; |
227 | input_dev->id.vendor = 0x0001; |
228 | input_dev->id.product = 0x0001; |
229 | input_dev->id.version = 0x0100; |
230 | |
231 | if (pdata->rep) |
232 | __set_bit(EV_REP, input_dev->evbit); |
233 | |
234 | ret = matrix_keypad_build_keymap(keymap_data: pdata->keymap_data, NULL, |
235 | rows: pdata->rows, cols: pdata->cols, |
236 | keymap: omap_kp->keymap, input_dev); |
237 | if (ret < 0) |
238 | goto err3; |
239 | |
240 | ret = input_register_device(omap_kp->input); |
241 | if (ret < 0) { |
242 | printk(KERN_ERR "Unable to register omap-keypad input device\n" ); |
243 | goto err3; |
244 | } |
245 | |
246 | if (pdata->dbounce) |
247 | omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING); |
248 | |
249 | /* scan current status and enable interrupt */ |
250 | omap_kp_scan_keypad(omap_kp, state: keypad_state); |
251 | omap_kp->irq = platform_get_irq(pdev, 0); |
252 | if (omap_kp->irq >= 0) { |
253 | if (request_irq(irq: omap_kp->irq, handler: omap_kp_interrupt, flags: 0, |
254 | name: "omap-keypad" , dev: omap_kp) < 0) |
255 | goto err4; |
256 | } |
257 | omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
258 | |
259 | return 0; |
260 | |
261 | err4: |
262 | input_unregister_device(omap_kp->input); |
263 | input_dev = NULL; |
264 | err3: |
265 | device_remove_file(dev: &pdev->dev, attr: &dev_attr_enable); |
266 | err2: |
267 | kfree(objp: omap_kp); |
268 | input_free_device(dev: input_dev); |
269 | |
270 | return -EINVAL; |
271 | } |
272 | |
273 | static void omap_kp_remove(struct platform_device *pdev) |
274 | { |
275 | struct omap_kp *omap_kp = platform_get_drvdata(pdev); |
276 | |
277 | /* disable keypad interrupt handling */ |
278 | tasklet_disable(t: &kp_tasklet); |
279 | omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); |
280 | free_irq(omap_kp->irq, omap_kp); |
281 | |
282 | timer_shutdown_sync(timer: &omap_kp->timer); |
283 | tasklet_kill(t: &kp_tasklet); |
284 | |
285 | /* unregister everything */ |
286 | input_unregister_device(omap_kp->input); |
287 | |
288 | kfree(objp: omap_kp); |
289 | } |
290 | |
291 | static struct platform_driver omap_kp_driver = { |
292 | .probe = omap_kp_probe, |
293 | .remove_new = omap_kp_remove, |
294 | .driver = { |
295 | .name = "omap-keypad" , |
296 | }, |
297 | }; |
298 | module_platform_driver(omap_kp_driver); |
299 | |
300 | MODULE_AUTHOR("Timo Teräs" ); |
301 | MODULE_DESCRIPTION("OMAP Keypad Driver" ); |
302 | MODULE_LICENSE("GPL" ); |
303 | MODULE_ALIAS("platform:omap-keypad" ); |
304 | |