2 * twl4030_keypad.c - driver for 8x8 keypad controller in twl4030 chips
4 * Copyright (C) 2007 Texas Instruments, Inc.
5 * Copyright (C) 2008 Nokia Corporation
7 * Code re-written for 2430SDP by:
8 * Syed Mohammed Khasim <x0khasim@ti.com>
11 * Manjunatha G K <manjugk@ti.com>
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/interrupt.h>
31 #include <linux/input.h>
32 #include <linux/platform_device.h>
33 #include <linux/i2c/twl.h>
34 #include <linux/slab.h>
38 * The TWL4030 family chips include a keypad controller that supports
39 * up to an 8x8 switch matrix. The controller can issue system wakeup
40 * events, since it uses only the always-on 32KiHz oscillator, and has
41 * an internal state machine that decodes pressed keys, including
42 * multi-key combinations.
44 * This driver lets boards define what keycodes they wish to report for
45 * which scancodes, as part of the "struct twl4030_keypad_data" used in
46 * the probe() routine.
48 * See the TPS65950 documentation; that's the general availability
49 * version of the TWL5030 second generation part.
51 #define TWL4030_MAX_ROWS 8 /* TWL4030 hard limit */
52 #define TWL4030_MAX_COLS 8
54 * Note that we add space for an extra column so that we can handle
55 * row lines connected to the gnd (see twl4030_col_xlate()).
57 #define TWL4030_ROW_SHIFT 4
58 #define TWL4030_KEYMAP_SIZE (TWL4030_MAX_ROWS << TWL4030_ROW_SHIFT)
60 struct twl4030_keypad
{
61 unsigned short keymap
[TWL4030_KEYMAP_SIZE
];
62 u16 kp_state
[TWL4030_MAX_ROWS
];
68 struct device
*dbg_dev
;
69 struct input_dev
*input
;
72 /*----------------------------------------------------------------------*/
74 /* arbitrary prescaler value 0..7 */
75 #define PTV_PRESCALER 4
77 /* Register Offsets */
78 #define KEYP_CTRL 0x00
80 #define KEYP_LONG_KEY 0x02
81 #define KEYP_LK_PTV 0x03
82 #define KEYP_TIMEOUT_L 0x04
83 #define KEYP_TIMEOUT_H 0x05
87 #define KEYP_FULL_CODE_7_0 0x09 /* row 0 column status */
88 #define KEYP_FULL_CODE_15_8 0x0a /* ... row 1 ... */
89 #define KEYP_FULL_CODE_23_16 0x0b
90 #define KEYP_FULL_CODE_31_24 0x0c
91 #define KEYP_FULL_CODE_39_32 0x0d
92 #define KEYP_FULL_CODE_47_40 0x0e
93 #define KEYP_FULL_CODE_55_48 0x0f
94 #define KEYP_FULL_CODE_63_56 0x10
95 #define KEYP_ISR1 0x11
96 #define KEYP_IMR1 0x12
97 #define KEYP_ISR2 0x13
98 #define KEYP_IMR2 0x14
100 #define KEYP_EDR 0x16 /* edge triggers */
101 #define KEYP_SIH_CTRL 0x17
103 /* KEYP_CTRL_REG Fields */
104 #define KEYP_CTRL_SOFT_NRST BIT(0)
105 #define KEYP_CTRL_SOFTMODEN BIT(1)
106 #define KEYP_CTRL_LK_EN BIT(2)
107 #define KEYP_CTRL_TOE_EN BIT(3)
108 #define KEYP_CTRL_TOLE_EN BIT(4)
109 #define KEYP_CTRL_RP_EN BIT(5)
110 #define KEYP_CTRL_KBD_ON BIT(6)
112 /* KEYP_DEB, KEYP_LONG_KEY, KEYP_TIMEOUT_x*/
113 #define KEYP_PERIOD_US(t, prescale) ((t) / (31 << ((prescale) + 1)) - 1)
115 /* KEYP_LK_PTV_REG Fields */
116 #define KEYP_LK_PTV_PTV_SHIFT 5
118 /* KEYP_{IMR,ISR,SIR} Fields */
119 #define KEYP_IMR1_MIS BIT(3)
120 #define KEYP_IMR1_TO BIT(2)
121 #define KEYP_IMR1_LK BIT(1)
122 #define KEYP_IMR1_KP BIT(0)
124 /* KEYP_EDR Fields */
125 #define KEYP_EDR_KP_FALLING 0x01
126 #define KEYP_EDR_KP_RISING 0x02
127 #define KEYP_EDR_KP_BOTH 0x03
128 #define KEYP_EDR_LK_FALLING 0x04
129 #define KEYP_EDR_LK_RISING 0x08
130 #define KEYP_EDR_TO_FALLING 0x10
131 #define KEYP_EDR_TO_RISING 0x20
132 #define KEYP_EDR_MIS_FALLING 0x40
133 #define KEYP_EDR_MIS_RISING 0x80
136 /*----------------------------------------------------------------------*/
138 static int twl4030_kpread(struct twl4030_keypad
*kp
,
139 u8
*data
, u32 reg
, u8 num_bytes
)
141 int ret
= twl_i2c_read(TWL4030_MODULE_KEYPAD
, data
, reg
, num_bytes
);
144 dev_warn(kp
->dbg_dev
,
145 "Couldn't read TWL4030: %X - ret %d[%x]\n",
151 static int twl4030_kpwrite_u8(struct twl4030_keypad
*kp
, u8 data
, u32 reg
)
153 int ret
= twl_i2c_write_u8(TWL4030_MODULE_KEYPAD
, data
, reg
);
156 dev_warn(kp
->dbg_dev
,
157 "Could not write TWL4030: %X - ret %d[%x]\n",
163 static inline u16
twl4030_col_xlate(struct twl4030_keypad
*kp
, u8 col
)
166 * If all bits in a row are active for all columns then
167 * we have that row line connected to gnd. Mark this
168 * key on as if it was on matrix position n_cols (i.e.
169 * one higher than the size of the matrix).
172 return 1 << kp
->n_cols
;
174 return col
& ((1 << kp
->n_cols
) - 1);
177 static int twl4030_read_kp_matrix_state(struct twl4030_keypad
*kp
, u16
*state
)
179 u8 new_state
[TWL4030_MAX_ROWS
];
181 int ret
= twl4030_kpread(kp
, new_state
,
182 KEYP_FULL_CODE_7_0
, kp
->n_rows
);
184 for (row
= 0; row
< kp
->n_rows
; row
++)
185 state
[row
] = twl4030_col_xlate(kp
, new_state
[row
]);
190 static bool twl4030_is_in_ghost_state(struct twl4030_keypad
*kp
, u16
*key_state
)
195 for (i
= 0; i
< kp
->n_rows
; i
++) {
196 u16 col
= key_state
[i
];
198 if ((col
& check
) && hweight16(col
) > 1)
207 static void twl4030_kp_scan(struct twl4030_keypad
*kp
, bool release_all
)
209 struct input_dev
*input
= kp
->input
;
210 u16 new_state
[TWL4030_MAX_ROWS
];
214 memset(new_state
, 0, sizeof(new_state
));
216 /* check for any changes */
217 int ret
= twl4030_read_kp_matrix_state(kp
, new_state
);
219 if (ret
< 0) /* panic ... */
222 if (twl4030_is_in_ghost_state(kp
, new_state
))
226 /* check for changes and print those */
227 for (row
= 0; row
< kp
->n_rows
; row
++) {
228 int changed
= new_state
[row
] ^ kp
->kp_state
[row
];
233 /* Extra column handles "all gnd" rows */
234 for (col
= 0; col
< kp
->n_cols
+ 1; col
++) {
237 if (!(changed
& (1 << col
)))
240 dev_dbg(kp
->dbg_dev
, "key [%d:%d] %s\n", row
, col
,
241 (new_state
[row
] & (1 << col
)) ?
242 "press" : "release");
244 code
= MATRIX_SCAN_CODE(row
, col
, TWL4030_ROW_SHIFT
);
245 input_event(input
, EV_MSC
, MSC_SCAN
, code
);
246 input_report_key(input
, kp
->keymap
[code
],
247 new_state
[row
] & (1 << col
));
249 kp
->kp_state
[row
] = new_state
[row
];
255 * Keypad interrupt handler
257 static irqreturn_t
do_kp_irq(int irq
, void *_kp
)
259 struct twl4030_keypad
*kp
= _kp
;
263 /* Read & Clear TWL4030 pending interrupt */
264 ret
= twl4030_kpread(kp
, ®
, KEYP_ISR1
, 1);
267 * Release all keys if I2C has gone bad or
268 * the KEYP has gone to idle state.
270 if (ret
>= 0 && (reg
& KEYP_IMR1_KP
))
271 twl4030_kp_scan(kp
, false);
273 twl4030_kp_scan(kp
, true);
278 static int twl4030_kp_program(struct twl4030_keypad
*kp
)
283 /* Enable controller, with hardware decoding but not autorepeat */
284 reg
= KEYP_CTRL_SOFT_NRST
| KEYP_CTRL_SOFTMODEN
285 | KEYP_CTRL_TOE_EN
| KEYP_CTRL_KBD_ON
;
286 if (twl4030_kpwrite_u8(kp
, reg
, KEYP_CTRL
) < 0)
290 * NOTE: we could use sih_setup() here to package keypad
291 * event sources as four different IRQs ... but we don't.
294 /* Enable TO rising and KP rising and falling edge detection */
295 reg
= KEYP_EDR_KP_BOTH
| KEYP_EDR_TO_RISING
;
296 if (twl4030_kpwrite_u8(kp
, reg
, KEYP_EDR
) < 0)
299 /* Set PTV prescaler Field */
300 reg
= (PTV_PRESCALER
<< KEYP_LK_PTV_PTV_SHIFT
);
301 if (twl4030_kpwrite_u8(kp
, reg
, KEYP_LK_PTV
) < 0)
304 /* Set key debounce time to 20 ms */
305 i
= KEYP_PERIOD_US(20000, PTV_PRESCALER
);
306 if (twl4030_kpwrite_u8(kp
, i
, KEYP_DEB
) < 0)
309 /* Set timeout period to 200 ms */
310 i
= KEYP_PERIOD_US(200000, PTV_PRESCALER
);
311 if (twl4030_kpwrite_u8(kp
, (i
& 0xFF), KEYP_TIMEOUT_L
) < 0)
314 if (twl4030_kpwrite_u8(kp
, (i
>> 8), KEYP_TIMEOUT_H
) < 0)
318 * Enable Clear-on-Read; disable remembering events that fire
319 * after the IRQ but before our handler acks (reads) them.
321 reg
= TWL4030_SIH_CTRL_COR_MASK
| TWL4030_SIH_CTRL_PENDDIS_MASK
;
322 if (twl4030_kpwrite_u8(kp
, reg
, KEYP_SIH_CTRL
) < 0)
325 /* initialize key state; irqs update it from here on */
326 if (twl4030_read_kp_matrix_state(kp
, kp
->kp_state
) < 0)
333 * Registers keypad device with input subsystem
334 * and configures TWL4030 keypad registers
336 static int twl4030_kp_probe(struct platform_device
*pdev
)
338 struct twl4030_keypad_data
*pdata
= dev_get_platdata(&pdev
->dev
);
339 const struct matrix_keymap_data
*keymap_data
= NULL
;
340 struct twl4030_keypad
*kp
;
341 struct input_dev
*input
;
345 kp
= devm_kzalloc(&pdev
->dev
, sizeof(*kp
), GFP_KERNEL
);
349 input
= devm_input_allocate_device(&pdev
->dev
);
353 /* get the debug device */
354 kp
->dbg_dev
= &pdev
->dev
;
357 /* setup input device */
358 input
->name
= "TWL4030 Keypad";
359 input
->phys
= "twl4030_keypad/input0";
361 input
->id
.bustype
= BUS_HOST
;
362 input
->id
.vendor
= 0x0001;
363 input
->id
.product
= 0x0001;
364 input
->id
.version
= 0x0003;
367 if (!pdata
->rows
|| !pdata
->cols
|| !pdata
->keymap_data
) {
368 dev_err(&pdev
->dev
, "Missing platform_data\n");
372 kp
->n_rows
= pdata
->rows
;
373 kp
->n_cols
= pdata
->cols
;
374 kp
->autorepeat
= pdata
->rep
;
375 keymap_data
= pdata
->keymap_data
;
377 error
= matrix_keypad_parse_properties(&pdev
->dev
, &kp
->n_rows
,
382 kp
->autorepeat
= true;
385 if (kp
->n_rows
> TWL4030_MAX_ROWS
|| kp
->n_cols
> TWL4030_MAX_COLS
) {
387 "Invalid rows/cols amount specified in platform/devicetree data\n");
391 kp
->irq
= platform_get_irq(pdev
, 0);
393 dev_err(&pdev
->dev
, "no keyboard irq assigned\n");
397 error
= matrix_keypad_build_keymap(keymap_data
, NULL
,
399 1 << TWL4030_ROW_SHIFT
,
402 dev_err(kp
->dbg_dev
, "Failed to build keymap\n");
406 input_set_capability(input
, EV_MSC
, MSC_SCAN
);
407 /* Enable auto repeat feature of Linux input subsystem */
409 __set_bit(EV_REP
, input
->evbit
);
411 error
= input_register_device(input
);
414 "Unable to register twl4030 keypad device\n");
418 error
= twl4030_kp_program(kp
);
423 * This ISR will always execute in kernel thread context because of
424 * the need to access the TWL4030 over the I2C bus.
426 * NOTE: we assume this host is wired to TWL4040 INT1, not INT2 ...
428 error
= devm_request_threaded_irq(&pdev
->dev
, kp
->irq
, NULL
, do_kp_irq
,
431 dev_info(kp
->dbg_dev
, "request_irq failed for irq no=%d: %d\n",
436 /* Enable KP and TO interrupts now. */
437 reg
= (u8
) ~(KEYP_IMR1_KP
| KEYP_IMR1_TO
);
438 if (twl4030_kpwrite_u8(kp
, reg
, KEYP_IMR1
)) {
439 /* mask all events - we don't care about the result */
440 (void) twl4030_kpwrite_u8(kp
, 0xff, KEYP_IMR1
);
448 static const struct of_device_id twl4030_keypad_dt_match_table
[] = {
449 { .compatible
= "ti,twl4030-keypad" },
452 MODULE_DEVICE_TABLE(of
, twl4030_keypad_dt_match_table
);
456 * NOTE: twl4030 are multi-function devices connected via I2C.
457 * So this device is a child of an I2C parent, thus it needs to
458 * support unplug/replug (which most platform devices don't).
461 static struct platform_driver twl4030_kp_driver
= {
462 .probe
= twl4030_kp_probe
,
464 .name
= "twl4030_keypad",
465 .of_match_table
= of_match_ptr(twl4030_keypad_dt_match_table
),
468 module_platform_driver(twl4030_kp_driver
);
470 MODULE_AUTHOR("Texas Instruments");
471 MODULE_DESCRIPTION("TWL4030 Keypad Driver");
472 MODULE_LICENSE("GPL");
473 MODULE_ALIAS("platform:twl4030_keypad");