2 * TSC2301 keypad driver
4 * Copyright (C) 2005-2006 Nokia Corporation
6 * Written by Jarkko Oikarinen
7 * Rewritten by Juha Yrjola <juha.yrjola@nokia.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/input.h>
28 #include <linux/interrupt.h>
29 #include <linux/irq.h>
30 #include <linux/delay.h>
31 #include <linux/spi/spi.h>
33 #ifdef CONFIG_ARCH_OMAP
34 #include <asm/arch/gpio.h>
37 #include <linux/spi/tsc2301.h>
39 #define TSC2301_KEYBOARD_PRODUCT_ID 0x0051
40 #define TSC2301_KEYBOARD_PRODUCT_VERSION 0x0001
41 #define TSC2301_DEBOUNCE_TIME_2MS 0x0000
42 #define TSC2301_DEBOUNCE_TIME_10MS 0x0800
43 #define TSC2301_DEBOUNCE_TIME_20MS 0x1000
44 #define TSC2301_DEBOUNCE_TIME_50MS 0x1800
45 #define TSC2301_DEBOUNCE_TIME_60MS 0x2000
46 #define TSC2301_DEBOUNCE_TIME_80MS 0x2800
47 #define TSC2301_DEBOUNCE_TIME_100MS 0x3000
48 #define TSC2301_DEBOUNCE_TIME_120MS 0x3800
50 #define TSC2301_DEBOUNCE_TIME TSC2301_DEBOUNCE_TIME_20MS
52 #define TSC2301_POLL_TIME 30
55 struct input_dev *idev;
59 struct timer_list timer;
62 unsigned user_disabled:1;
63 unsigned disable_depth;
65 struct spi_transfer read_xfer[4];
66 struct spi_message read_msg;
74 int (*get_keyb_irq_state)(struct device *dev);
77 static inline int tsc2301_kp_disabled(struct tsc2301 *tsc)
79 return tsc->kp->disable_depth != 0;
82 static inline void tsc2301_kp_set_keypressed_state(struct tsc2301 *tsc)
84 struct tsc2301_kp *kp = tsc->kp;
86 /* kp->state is updated only if we don't have the callback */
87 if (kp->get_keyb_irq_state != NULL) {
88 if (kp->get_keyb_irq_state(&tsc->spi->dev))
95 static inline int tsc2301_kp_key_is_pressed(struct tsc2301 *tsc)
97 return tsc->kp->state & (1 << 15);
100 static void tsc2301_kp_send_key_events(struct tsc2301 *tsc,
104 struct tsc2301_kp *kp = tsc->kp;
105 u16 common, released, pressed;
108 common = prev_state & new_state;
109 released = common ^ prev_state;
110 pressed = common ^ new_state;
111 if (!released && !pressed)
113 for (i = 0; i < 16 && (released || pressed); i++) {
115 dev_dbg(&tsc->spi->dev, "key %d released\n", i);
116 input_report_key(kp->idev, kp->keymap[i], 0);
120 dev_dbg(&tsc->spi->dev, "key %d pressed\n", i);
121 input_report_key(kp->idev, kp->keymap[i], 1);
125 input_sync(kp->idev);
128 static inline void tsc2301_kp_release_all_keys(struct tsc2301 *tsc)
130 struct tsc2301_kp *kp = tsc->kp;
134 spin_lock_irqsave(&kp->lock, flags);
135 keys_pressed = kp->keys_pressed;
136 kp->keys_pressed = 0;
137 spin_unlock_irqrestore(&kp->lock, flags);
139 tsc2301_kp_send_key_events(tsc, keys_pressed, 0);
142 static inline void _filter_out(struct tsc2301 *tsc, u16 prev_state,
143 u16 *new_state, int row1, int row2, u8 rect_pat)
147 mask = (rect_pat << (row1 * 4)) | (rect_pat << (row2 * 4));
150 dev_dbg(&tsc->spi->dev, "filtering ghost keys %02x\n", mask);
153 static void tsc2301_filter_ghost_keys(struct tsc2301 *tsc, u16 prev_state,
159 static const u8 rect_pat[] = {
160 0x3, 0x5, 0x9, 0x6, 0xa, 0xc, 0,
163 key_map = *new_state;
164 for (row1 = 0; row1 < 4; row1++) {
165 row1_map = (key_map >> (row1 * 4)) & 0xf;
168 for (row2 = row1 + 1; row2 < 4; row2++) {
169 u16 rect_map = (key_map >> (row2 * 4)) & 0xf;
172 rect_map &= row1_map;
175 for (rp = rect_pat; *rp; rp++)
176 if ((rect_map & *rp) == *rp)
177 _filter_out(tsc, prev_state, new_state,
183 static void tsc2301_kp_timer(unsigned long arg)
185 struct tsc2301 *tsc = (void *) arg;
188 /* This needs to be done early enough, since reading the key data
189 * register clears the IRQ line, which may be used to determine
190 * the key pressed state.
192 tsc2301_kp_set_keypressed_state(tsc);
193 r = spi_async(tsc->spi, &tsc->kp->read_msg);
194 if (unlikely(r < 0 && printk_ratelimit()))
195 dev_err(&tsc->spi->dev, "kp: spi_async() failed");
198 static void tsc2301_kp_rx(void *arg)
200 struct tsc2301 *tsc = arg;
201 struct tsc2301_kp *kp = tsc->kp;
207 key_pressed = tsc2301_kp_key_is_pressed(tsc);
208 dev_dbg(&tsc->spi->dev, "KP data %04x (%s)\n",
209 kp_data, key_pressed ? "pressed" : "not pressed");
213 tsc2301_filter_ghost_keys(tsc, kp->keys_pressed, &kp_data);
214 tsc2301_kp_send_key_events(tsc, kp->keys_pressed, kp_data);
215 kp->keys_pressed = kp_data;
216 spin_lock_irqsave(&kp->lock, flags);
217 if (likely(!tsc2301_kp_disabled(tsc))) {
218 if (likely(key_pressed))
219 mod_timer(&kp->timer,
220 jiffies + msecs_to_jiffies(TSC2301_POLL_TIME));
227 spin_unlock_irqrestore(&kp->lock, flags);
230 static irqreturn_t tsc2301_kp_irq_handler(int irq, void *dev_id)
232 struct tsc2301 *tsc = dev_id;
233 struct tsc2301_kp *kp = tsc->kp;
236 spin_lock_irqsave(&kp->lock, flags);
238 if (tsc2301_kp_disabled(tsc)) {
239 spin_unlock_irqrestore(&kp->lock, flags);
243 disable_irq_nosync(irq);
244 spin_unlock_irqrestore(&kp->lock, flags);
245 tsc2301_kp_timer((unsigned long) tsc);
249 static void tsc2301_kp_start_scan(struct tsc2301 *tsc)
251 tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, tsc->kp->mask);
252 tsc2301_write_reg(tsc, TSC2301_REG_KEY, TSC2301_DEBOUNCE_TIME);
255 static void tsc2301_kp_stop_scan(struct tsc2301 *tsc)
257 tsc2301_write_reg(tsc, TSC2301_REG_KEY, 1 << 14);
258 tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, 0xffff);
261 /* Must be called with the mutex held */
262 static void tsc2301_kp_enable(struct tsc2301 *tsc)
264 struct tsc2301_kp *kp = tsc->kp;
267 spin_lock_irqsave(&kp->lock, flags);
268 BUG_ON(!tsc2301_kp_disabled(tsc));
269 if (--kp->disable_depth != 0) {
270 spin_unlock_irqrestore(&kp->lock, flags);
273 if (kp->keys_pressed)
275 spin_unlock_irqrestore(&kp->lock, flags);
277 set_irq_type(kp->irq, IRQT_FALLING);
278 tsc2301_kp_start_scan(tsc);
280 /* continue an interrupted polling */
281 mod_timer(&kp->timer,
282 jiffies + msecs_to_jiffies(TSC2301_POLL_TIME));
287 /* Must be called with the mutex held */
288 static int tsc2301_kp_disable(struct tsc2301 *tsc, int release_keys)
290 struct tsc2301_kp *kp = tsc->kp;
293 spin_lock_irqsave(&kp->lock, flags);
294 if (kp->disable_depth++ != 0) {
295 spin_unlock_irqrestore(&kp->lock, flags);
299 disable_irq_nosync(kp->irq);
301 while (kp->pending) {
302 spin_unlock_irqrestore(&kp->lock, flags);
304 spin_lock_irqsave(&kp->lock, flags);
306 spin_unlock_irqrestore(&kp->lock, flags);
308 tsc2301_kp_stop_scan(tsc);
309 set_irq_type(kp->irq, IRQT_NOEDGE);
312 tsc2301_kp_release_all_keys(tsc);
317 /* The following workaround is needed for a HW bug triggered by the
319 * 1. keep any key pressed
321 * 3. release all keys
323 * 5. disable touch screen controller
325 * After this the keypad scanner will get stuck in busy state and won't
326 * report any interrupts for further keypresses. One way to recover is to
327 * restart the keypad scanner whenever we enable / disable the
328 * touchscreen controller.
330 void tsc2301_kp_restart(struct tsc2301 *tsc)
332 struct tsc2301_kp *kp = tsc->kp;
334 mutex_lock(&kp->mutex);
335 if (!kp->user_disabled) {
336 tsc2301_kp_disable(tsc, 0);
337 tsc2301_kp_enable(tsc);
339 mutex_unlock(&kp->mutex);
342 static ssize_t tsc2301_kp_disable_show(struct device *dev,
343 struct device_attribute *attr, char *buf)
345 struct tsc2301 *tsc = dev_get_drvdata(dev);
347 return sprintf(buf, "%u\n", tsc2301_kp_disabled(tsc) ? 1 : 0);
350 static ssize_t tsc2301_kp_disable_store(struct device *dev,
351 struct device_attribute *attr,
352 const char *buf, size_t count)
354 struct tsc2301 *tsc = dev_get_drvdata(dev);
355 struct tsc2301_kp *kp = tsc->kp;
359 i = simple_strtoul(buf, &endp, 10);
362 mutex_lock(&kp->mutex);
363 if (i == kp->user_disabled) {
364 mutex_unlock(&kp->mutex);
367 kp->user_disabled = i;
370 tsc2301_kp_disable(tsc, 1);
372 tsc2301_kp_enable(tsc);
373 mutex_unlock(&kp->mutex);
378 static DEVICE_ATTR(disable_kp, 0664, tsc2301_kp_disable_show,
379 tsc2301_kp_disable_store);
381 static const u16 tsc2301_kp_read_data = 0x8000 | TSC2301_REG_KPDATA;
382 static const u16 tsc2301_kp_read_state = 0x8000 | TSC2301_REG_KEY;
384 static void tsc2301_kp_setup_spi_xfer(struct tsc2301 *tsc)
386 struct tsc2301_kp *kp = tsc->kp;
387 struct spi_message *m = &kp->read_msg;
388 struct spi_transfer *x = &kp->read_xfer[0];
390 spi_message_init(&kp->read_msg);
392 if (kp->get_keyb_irq_state == NULL) {
393 /* No platform specific way for determining the keypress
394 * state, so we'll need an extra status register read.
396 x->tx_buf = &tsc2301_kp_read_state;
398 spi_message_add_tail(x, m);
401 x->rx_buf = &kp->state;
404 spi_message_add_tail(x, m);
408 x->tx_buf = &tsc2301_kp_read_data;
410 spi_message_add_tail(x, m);
413 x->rx_buf = &kp->data;
415 spi_message_add_tail(x, m);
417 m->complete = tsc2301_kp_rx;
422 int tsc2301_kp_suspend(struct tsc2301 *tsc)
424 struct tsc2301_kp *kp = tsc->kp;
426 mutex_lock(&kp->mutex);
427 tsc2301_kp_disable(tsc, 1);
428 mutex_unlock(&kp->mutex);
432 void tsc2301_kp_resume(struct tsc2301 *tsc)
434 struct tsc2301_kp *kp = tsc->kp;
436 mutex_lock(&kp->mutex);
437 tsc2301_kp_enable(tsc);
438 mutex_unlock(&kp->mutex);
442 int __devinit tsc2301_kp_init(struct tsc2301 *tsc,
443 struct tsc2301_platform_data *pdata)
445 struct input_dev *idev;
446 struct tsc2301_kp *kp;
450 if (pdata->keyb_int < 0) {
451 dev_err(&tsc->spi->dev, "need kbirq");
455 kp = kzalloc(sizeof(*kp), GFP_KERNEL);
460 kp->irq = pdata->keyb_int;
461 spin_lock_init(&kp->lock);
462 mutex_init(&kp->mutex);
464 init_timer(&kp->timer);
465 kp->timer.data = (unsigned long) tsc;
466 kp->timer.function = tsc2301_kp_timer;
468 kp->get_keyb_irq_state = pdata->get_keyb_irq_state;
470 idev = input_allocate_device();
475 idev->name = "TSC2301 keypad";
476 snprintf(kp->phys, sizeof(kp->phys), "%s/input-kp", tsc->spi->dev.bus_id);
477 idev->phys = kp->phys;
480 idev->evbit[0] = BIT(EV_KEY);
481 for (i = 0; i < 16; i++) {
482 if (pdata->keymap[i] > 0) {
483 set_bit(pdata->keymap[i], idev->keybit);
484 kp->keymap[i] = pdata->keymap[i];
492 set_bit(EV_REP, idev->evbit);
496 tsc2301_kp_setup_spi_xfer(tsc);
498 r = device_create_file(&tsc->spi->dev, &dev_attr_disable_kp);
502 tsc2301_kp_start_scan(tsc);
504 /* IRQ mode 0 is faulty, it can cause the KBIRQ to get stuck.
505 * Mode 2 deasserts the IRQ at:
507 * - Setting SCS flag in REG_KEY register
508 * - Releasing all keys
509 * - Reading the REG_KPDATA
511 tsc2301_write_kbc(tsc, 2);
513 tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, mask);
516 set_irq_type(kp->irq, IRQT_FALLING);
518 r = request_irq(kp->irq, tsc2301_kp_irq_handler, IRQF_SAMPLE_RANDOM,
521 dev_err(&tsc->spi->dev, "unable to get kbirq IRQ");
524 set_irq_wake(kp->irq, 1);
526 /* We need to read the register once..? */
527 tsc2301_read_reg(tsc, TSC2301_REG_KPDATA);
529 r = input_register_device(idev);
531 dev_err(&tsc->spi->dev, "can't register keypad device\n");
538 free_irq(kp->irq, tsc);
540 tsc2301_kp_stop_scan(tsc);
541 device_remove_file(&tsc->spi->dev, &dev_attr_disable_kp);
543 input_free_device(kp->idev);
549 void __devexit tsc2301_kp_exit(struct tsc2301 *tsc)
551 struct tsc2301_kp *kp = tsc->kp;
553 tsc2301_kp_disable(tsc, 1);
554 input_unregister_device(kp->idev);
555 free_irq(kp->irq, tsc);
556 device_remove_file(&tsc->spi->dev, &dev_attr_disable_kp);