aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorDmitry Torokhov <dmitry.torokhov@gmail.com>2008-02-06 00:54:05 -0500
committerDmitry Torokhov <dmitry.torokhov@gmail.com>2008-02-06 00:54:05 -0500
commit03366e7b9bf1544cb0b98f1a5cd6d340654f486a (patch)
treeb9ca15f0acd86f90fdd62c1ab4b3e8e9b4592fd6 /drivers
parentc18bab80d16f04db3e263cc97522d21693cad2ce (diff)
parente0f2677f0d21cfff9d45160343e6246417e55d02 (diff)
Merge branch 'pxa-keypad'
Diffstat (limited to 'drivers')
-rw-r--r--drivers/input/keyboard/Kconfig8
-rw-r--r--drivers/input/keyboard/Makefile2
-rw-r--r--drivers/input/keyboard/pxa27x_keyboard.c274
-rw-r--r--drivers/input/keyboard/pxa27x_keypad.c572
4 files changed, 577 insertions, 279 deletions
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 0c327621bd86..8ea709be3306 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -260,13 +260,13 @@ config KEYBOARD_OMAP
260 module will be called omap-keypad. 260 module will be called omap-keypad.
261 261
262config KEYBOARD_PXA27x 262config KEYBOARD_PXA27x
263 tristate "PXA27x keyboard support" 263 tristate "PXA27x/PXA3xx keypad support"
264 depends on PXA27x 264 depends on PXA27x || PXA3xx
265 help 265 help
266 Enable support for PXA27x matrix keyboard controller 266 Enable support for PXA27x/PXA3xx keypad controller
267 267
268 To compile this driver as a module, choose M here: the 268 To compile this driver as a module, choose M here: the
269 module will be called pxa27x_keyboard. 269 module will be called pxa27x_keypad.
270 270
271config KEYBOARD_AAED2000 271config KEYBOARD_AAED2000
272 tristate "AAED-2000 keyboard" 272 tristate "AAED-2000 keyboard"
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 6caa065e27ae..e741f4031012 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -19,7 +19,7 @@ obj-$(CONFIG_KEYBOARD_TOSA) += tosakbd.o
19obj-$(CONFIG_KEYBOARD_HIL) += hil_kbd.o 19obj-$(CONFIG_KEYBOARD_HIL) += hil_kbd.o
20obj-$(CONFIG_KEYBOARD_HIL_OLD) += hilkbd.o 20obj-$(CONFIG_KEYBOARD_HIL_OLD) += hilkbd.o
21obj-$(CONFIG_KEYBOARD_OMAP) += omap-keypad.o 21obj-$(CONFIG_KEYBOARD_OMAP) += omap-keypad.o
22obj-$(CONFIG_KEYBOARD_PXA27x) += pxa27x_keyboard.o 22obj-$(CONFIG_KEYBOARD_PXA27x) += pxa27x_keypad.o
23obj-$(CONFIG_KEYBOARD_AAED2000) += aaed2000_kbd.o 23obj-$(CONFIG_KEYBOARD_AAED2000) += aaed2000_kbd.o
24obj-$(CONFIG_KEYBOARD_GPIO) += gpio_keys.o 24obj-$(CONFIG_KEYBOARD_GPIO) += gpio_keys.o
25obj-$(CONFIG_KEYBOARD_HP6XX) += jornada680_kbd.o 25obj-$(CONFIG_KEYBOARD_HP6XX) += jornada680_kbd.o
diff --git a/drivers/input/keyboard/pxa27x_keyboard.c b/drivers/input/keyboard/pxa27x_keyboard.c
deleted file mode 100644
index bdd64ee4c5c8..000000000000
--- a/drivers/input/keyboard/pxa27x_keyboard.c
+++ /dev/null
@@ -1,274 +0,0 @@
1/*
2 * linux/drivers/input/keyboard/pxa27x_keyboard.c
3 *
4 * Driver for the pxa27x matrix keyboard controller.
5 *
6 * Created: Feb 22, 2007
7 * Author: Rodolfo Giometti <giometti@linux.it>
8 *
9 * Based on a previous implementations by Kevin O'Connor
10 * <kevin_at_koconnor.net> and Alex Osborne <bobofdoom@gmail.com> and
11 * on some suggestions by Nicolas Pitre <nico@cam.org>.
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
16 */
17
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/interrupt.h>
23#include <linux/input.h>
24#include <linux/device.h>
25#include <linux/platform_device.h>
26#include <linux/clk.h>
27#include <linux/err.h>
28
29#include <asm/mach-types.h>
30#include <asm/mach/arch.h>
31#include <asm/mach/map.h>
32
33#include <asm/arch/hardware.h>
34#include <asm/arch/pxa-regs.h>
35#include <asm/arch/irqs.h>
36#include <asm/arch/pxa27x_keyboard.h>
37
38#define DRIVER_NAME "pxa27x-keyboard"
39
40#define KPASMKP(col) (col/2 == 0 ? KPASMKP0 : \
41 col/2 == 1 ? KPASMKP1 : \
42 col/2 == 2 ? KPASMKP2 : KPASMKP3)
43#define KPASMKPx_MKC(row, col) (1 << (row + 16 * (col % 2)))
44
45static struct clk *pxakbd_clk;
46
47static irqreturn_t pxakbd_irq_handler(int irq, void *dev_id)
48{
49 struct platform_device *pdev = dev_id;
50 struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
51 struct input_dev *input_dev = platform_get_drvdata(pdev);
52 unsigned long kpc = KPC;
53 int p, row, col, rel;
54
55 if (kpc & KPC_DI) {
56 unsigned long kpdk = KPDK;
57
58 if (!(kpdk & KPDK_DKP)) {
59 /* better luck next time */
60 } else if (kpc & KPC_REE0) {
61 unsigned long kprec = KPREC;
62 KPREC = 0x7f;
63
64 if (kprec & KPREC_OF0)
65 rel = (kprec & 0xff) + 0x7f;
66 else if (kprec & KPREC_UF0)
67 rel = (kprec & 0xff) - 0x7f - 0xff;
68 else
69 rel = (kprec & 0xff) - 0x7f;
70
71 if (rel) {
72 input_report_rel(input_dev, REL_WHEEL, rel);
73 input_sync(input_dev);
74 }
75 }
76 }
77
78 if (kpc & KPC_MI) {
79 /* report the status of every button */
80 for (row = 0; row < pdata->nr_rows; row++) {
81 for (col = 0; col < pdata->nr_cols; col++) {
82 p = KPASMKP(col) & KPASMKPx_MKC(row, col) ?
83 1 : 0;
84 pr_debug("keycode %x - pressed %x\n",
85 pdata->keycodes[row][col], p);
86 input_report_key(input_dev,
87 pdata->keycodes[row][col], p);
88 }
89 }
90 input_sync(input_dev);
91 }
92
93 return IRQ_HANDLED;
94}
95
96static int pxakbd_open(struct input_dev *dev)
97{
98 /* Set keypad control register */
99 KPC |= (KPC_ASACT |
100 KPC_MS_ALL |
101 (2 << 6) | KPC_REE0 | KPC_DK_DEB_SEL |
102 KPC_ME | KPC_MIE | KPC_DE | KPC_DIE);
103
104 KPC &= ~KPC_AS; /* disable automatic scan */
105 KPC &= ~KPC_IMKP; /* do not ignore multiple keypresses */
106
107 /* Set rotary count to mid-point value */
108 KPREC = 0x7F;
109
110 /* Enable unit clock */
111 clk_enable(pxakbd_clk);
112
113 return 0;
114}
115
116static void pxakbd_close(struct input_dev *dev)
117{
118 /* Disable clock unit */
119 clk_disable(pxakbd_clk);
120}
121
122#ifdef CONFIG_PM
123static int pxakbd_suspend(struct platform_device *pdev, pm_message_t state)
124{
125 struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
126
127 /* Save controller status */
128 pdata->reg_kpc = KPC;
129 pdata->reg_kprec = KPREC;
130
131 return 0;
132}
133
134static int pxakbd_resume(struct platform_device *pdev)
135{
136 struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
137 struct input_dev *input_dev = platform_get_drvdata(pdev);
138
139 mutex_lock(&input_dev->mutex);
140
141 if (input_dev->users) {
142 /* Restore controller status */
143 KPC = pdata->reg_kpc;
144 KPREC = pdata->reg_kprec;
145
146 /* Enable unit clock */
147 clk_disable(pxakbd_clk);
148 clk_enable(pxakbd_clk);
149 }
150
151 mutex_unlock(&input_dev->mutex);
152
153 return 0;
154}
155#else
156#define pxakbd_suspend NULL
157#define pxakbd_resume NULL
158#endif
159
160static int __devinit pxakbd_probe(struct platform_device *pdev)
161{
162 struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
163 struct input_dev *input_dev;
164 int i, row, col, error;
165
166 pxakbd_clk = clk_get(&pdev->dev, "KBDCLK");
167 if (IS_ERR(pxakbd_clk)) {
168 error = PTR_ERR(pxakbd_clk);
169 goto err_clk;
170 }
171
172 /* Create and register the input driver. */
173 input_dev = input_allocate_device();
174 if (!input_dev) {
175 printk(KERN_ERR "Cannot request keypad device\n");
176 error = -ENOMEM;
177 goto err_alloc;
178 }
179
180 input_dev->name = DRIVER_NAME;
181 input_dev->id.bustype = BUS_HOST;
182 input_dev->open = pxakbd_open;
183 input_dev->close = pxakbd_close;
184 input_dev->dev.parent = &pdev->dev;
185
186 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
187 BIT_MASK(EV_REL);
188 input_dev->relbit[BIT_WORD(REL_WHEEL)] = BIT_MASK(REL_WHEEL);
189 for (row = 0; row < pdata->nr_rows; row++) {
190 for (col = 0; col < pdata->nr_cols; col++) {
191 int code = pdata->keycodes[row][col];
192 if (code > 0)
193 set_bit(code, input_dev->keybit);
194 }
195 }
196
197 error = request_irq(IRQ_KEYPAD, pxakbd_irq_handler, IRQF_DISABLED,
198 DRIVER_NAME, pdev);
199 if (error) {
200 printk(KERN_ERR "Cannot request keypad IRQ\n");
201 goto err_free_dev;
202 }
203
204 platform_set_drvdata(pdev, input_dev);
205
206 /* Register the input device */
207 error = input_register_device(input_dev);
208 if (error)
209 goto err_free_irq;
210
211 /* Setup GPIOs. */
212 for (i = 0; i < pdata->nr_rows + pdata->nr_cols; i++)
213 pxa_gpio_mode(pdata->gpio_modes[i]);
214
215 /*
216 * Store rows/cols info into keyboard registers.
217 */
218
219 KPC |= (pdata->nr_rows - 1) << 26;
220 KPC |= (pdata->nr_cols - 1) << 23;
221
222 for (col = 0; col < pdata->nr_cols; col++)
223 KPC |= KPC_MS0 << col;
224
225 return 0;
226
227 err_free_irq:
228 platform_set_drvdata(pdev, NULL);
229 free_irq(IRQ_KEYPAD, pdev);
230 err_free_dev:
231 input_free_device(input_dev);
232 err_alloc:
233 clk_put(pxakbd_clk);
234 err_clk:
235 return error;
236}
237
238static int __devexit pxakbd_remove(struct platform_device *pdev)
239{
240 struct input_dev *input_dev = platform_get_drvdata(pdev);
241
242 input_unregister_device(input_dev);
243 free_irq(IRQ_KEYPAD, pdev);
244 clk_put(pxakbd_clk);
245 platform_set_drvdata(pdev, NULL);
246
247 return 0;
248}
249
250static struct platform_driver pxakbd_driver = {
251 .probe = pxakbd_probe,
252 .remove = __devexit_p(pxakbd_remove),
253 .suspend = pxakbd_suspend,
254 .resume = pxakbd_resume,
255 .driver = {
256 .name = DRIVER_NAME,
257 },
258};
259
260static int __init pxakbd_init(void)
261{
262 return platform_driver_register(&pxakbd_driver);
263}
264
265static void __exit pxakbd_exit(void)
266{
267 platform_driver_unregister(&pxakbd_driver);
268}
269
270module_init(pxakbd_init);
271module_exit(pxakbd_exit);
272
273MODULE_DESCRIPTION("PXA27x Matrix Keyboard Driver");
274MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
new file mode 100644
index 000000000000..6224c2fb3b65
--- /dev/null
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -0,0 +1,572 @@
1/*
2 * linux/drivers/input/keyboard/pxa27x_keypad.c
3 *
4 * Driver for the pxa27x matrix keyboard controller.
5 *
6 * Created: Feb 22, 2007
7 * Author: Rodolfo Giometti <giometti@linux.it>
8 *
9 * Based on a previous implementations by Kevin O'Connor
10 * <kevin_at_koconnor.net> and Alex Osborne <bobofdoom@gmail.com> and
11 * on some suggestions by Nicolas Pitre <nico@cam.org>.
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
16 */
17
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/interrupt.h>
23#include <linux/input.h>
24#include <linux/device.h>
25#include <linux/platform_device.h>
26#include <linux/clk.h>
27#include <linux/err.h>
28
29#include <asm/mach-types.h>
30#include <asm/mach/arch.h>
31#include <asm/mach/map.h>
32
33#include <asm/arch/hardware.h>
34#include <asm/arch/pxa27x_keypad.h>
35
36/*
37 * Keypad Controller registers
38 */
39#define KPC 0x0000 /* Keypad Control register */
40#define KPDK 0x0008 /* Keypad Direct Key register */
41#define KPREC 0x0010 /* Keypad Rotary Encoder register */
42#define KPMK 0x0018 /* Keypad Matrix Key register */
43#define KPAS 0x0020 /* Keypad Automatic Scan register */
44
45/* Keypad Automatic Scan Multiple Key Presser register 0-3 */
46#define KPASMKP0 0x0028
47#define KPASMKP1 0x0030
48#define KPASMKP2 0x0038
49#define KPASMKP3 0x0040
50#define KPKDI 0x0048
51
52/* bit definitions */
53#define KPC_MKRN(n) ((((n) & 0x7) - 1) << 26) /* matrix key row number */
54#define KPC_MKCN(n) ((((n) & 0x7) - 1) << 23) /* matrix key column number */
55#define KPC_DKN(n) ((((n) & 0x7) - 1) << 6) /* direct key number */
56
57#define KPC_AS (0x1 << 30) /* Automatic Scan bit */
58#define KPC_ASACT (0x1 << 29) /* Automatic Scan on Activity */
59#define KPC_MI (0x1 << 22) /* Matrix interrupt bit */
60#define KPC_IMKP (0x1 << 21) /* Ignore Multiple Key Press */
61
62#define KPC_MS(n) (0x1 << (13 + (n))) /* Matrix scan line 'n' */
63#define KPC_MS_ALL (0xff << 13)
64
65#define KPC_ME (0x1 << 12) /* Matrix Keypad Enable */
66#define KPC_MIE (0x1 << 11) /* Matrix Interrupt Enable */
67#define KPC_DK_DEB_SEL (0x1 << 9) /* Direct Keypad Debounce Select */
68#define KPC_DI (0x1 << 5) /* Direct key interrupt bit */
69#define KPC_RE_ZERO_DEB (0x1 << 4) /* Rotary Encoder Zero Debounce */
70#define KPC_REE1 (0x1 << 3) /* Rotary Encoder1 Enable */
71#define KPC_REE0 (0x1 << 2) /* Rotary Encoder0 Enable */
72#define KPC_DE (0x1 << 1) /* Direct Keypad Enable */
73#define KPC_DIE (0x1 << 0) /* Direct Keypad interrupt Enable */
74
75#define KPDK_DKP (0x1 << 31)
76#define KPDK_DK(n) ((n) & 0xff)
77
78#define KPREC_OF1 (0x1 << 31)
79#define kPREC_UF1 (0x1 << 30)
80#define KPREC_OF0 (0x1 << 15)
81#define KPREC_UF0 (0x1 << 14)
82
83#define KPREC_RECOUNT0(n) ((n) & 0xff)
84#define KPREC_RECOUNT1(n) (((n) >> 16) & 0xff)
85
86#define KPMK_MKP (0x1 << 31)
87#define KPAS_SO (0x1 << 31)
88#define KPASMKPx_SO (0x1 << 31)
89
90#define KPAS_MUKP(n) (((n) >> 26) & 0x1f)
91#define KPAS_RP(n) (((n) >> 4) & 0xf)
92#define KPAS_CP(n) ((n) & 0xf)
93
94#define KPASMKP_MKC_MASK (0xff)
95
96#define keypad_readl(off) __raw_readl(keypad->mmio_base + (off))
97#define keypad_writel(off, v) __raw_writel((v), keypad->mmio_base + (off))
98
99#define MAX_MATRIX_KEY_NUM (8 * 8)
100
101struct pxa27x_keypad {
102 struct pxa27x_keypad_platform_data *pdata;
103
104 struct clk *clk;
105 struct input_dev *input_dev;
106 void __iomem *mmio_base;
107
108 /* matrix key code map */
109 unsigned int matrix_keycodes[MAX_MATRIX_KEY_NUM];
110
111 /* state row bits of each column scan */
112 uint32_t matrix_key_state[MAX_MATRIX_KEY_COLS];
113 uint32_t direct_key_state;
114
115 unsigned int direct_key_mask;
116
117 int rotary_rel_code[2];
118 int rotary_up_key[2];
119 int rotary_down_key[2];
120};
121
122static void pxa27x_keypad_build_keycode(struct pxa27x_keypad *keypad)
123{
124 struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
125 struct input_dev *input_dev = keypad->input_dev;
126 unsigned int *key;
127 int i;
128
129 key = &pdata->matrix_key_map[0];
130 for (i = 0; i < pdata->matrix_key_map_size; i++, key++) {
131 int row = ((*key) >> 28) & 0xf;
132 int col = ((*key) >> 24) & 0xf;
133 int code = (*key) & 0xffffff;
134
135 keypad->matrix_keycodes[(row << 3) + col] = code;
136 set_bit(code, input_dev->keybit);
137 }
138
139 keypad->rotary_up_key[0] = pdata->rotary0_up_key;
140 keypad->rotary_up_key[1] = pdata->rotary1_up_key;
141 keypad->rotary_down_key[0] = pdata->rotary0_down_key;
142 keypad->rotary_down_key[1] = pdata->rotary1_down_key;
143 keypad->rotary_rel_code[0] = pdata->rotary0_rel_code;
144 keypad->rotary_rel_code[1] = pdata->rotary1_rel_code;
145
146 if (pdata->rotary0_up_key && pdata->rotary0_down_key) {
147 set_bit(pdata->rotary0_up_key, input_dev->keybit);
148 set_bit(pdata->rotary0_down_key, input_dev->keybit);
149 } else
150 set_bit(pdata->rotary0_rel_code, input_dev->relbit);
151
152 if (pdata->rotary1_up_key && pdata->rotary1_down_key) {
153 set_bit(pdata->rotary1_up_key, input_dev->keybit);
154 set_bit(pdata->rotary1_down_key, input_dev->keybit);
155 } else
156 set_bit(pdata->rotary1_rel_code, input_dev->relbit);
157}
158
159static inline unsigned int lookup_matrix_keycode(
160 struct pxa27x_keypad *keypad, int row, int col)
161{
162 return keypad->matrix_keycodes[(row << 3) + col];
163}
164
165static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad)
166{
167 struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
168 int row, col, num_keys_pressed = 0;
169 uint32_t new_state[MAX_MATRIX_KEY_COLS];
170 uint32_t kpas = keypad_readl(KPAS);
171
172 num_keys_pressed = KPAS_MUKP(kpas);
173
174 memset(new_state, 0, sizeof(new_state));
175
176 if (num_keys_pressed == 0)
177 goto scan;
178
179 if (num_keys_pressed == 1) {
180 col = KPAS_CP(kpas);
181 row = KPAS_RP(kpas);
182
183 /* if invalid row/col, treat as no key pressed */
184 if (col >= pdata->matrix_key_cols ||
185 row >= pdata->matrix_key_rows)
186 goto scan;
187
188 new_state[col] = (1 << row);
189 goto scan;
190 }
191
192 if (num_keys_pressed > 1) {
193 uint32_t kpasmkp0 = keypad_readl(KPASMKP0);
194 uint32_t kpasmkp1 = keypad_readl(KPASMKP1);
195 uint32_t kpasmkp2 = keypad_readl(KPASMKP2);
196 uint32_t kpasmkp3 = keypad_readl(KPASMKP3);
197
198 new_state[0] = kpasmkp0 & KPASMKP_MKC_MASK;
199 new_state[1] = (kpasmkp0 >> 16) & KPASMKP_MKC_MASK;
200 new_state[2] = kpasmkp1 & KPASMKP_MKC_MASK;
201 new_state[3] = (kpasmkp1 >> 16) & KPASMKP_MKC_MASK;
202 new_state[4] = kpasmkp2 & KPASMKP_MKC_MASK;
203 new_state[5] = (kpasmkp2 >> 16) & KPASMKP_MKC_MASK;
204 new_state[6] = kpasmkp3 & KPASMKP_MKC_MASK;
205 new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK;
206 }
207scan:
208 for (col = 0; col < pdata->matrix_key_cols; col++) {
209 uint32_t bits_changed;
210
211 bits_changed = keypad->matrix_key_state[col] ^ new_state[col];
212 if (bits_changed == 0)
213 continue;
214
215 for (row = 0; row < pdata->matrix_key_rows; row++) {
216 if ((bits_changed & (1 << row)) == 0)
217 continue;
218
219 input_report_key(keypad->input_dev,
220 lookup_matrix_keycode(keypad, row, col),
221 new_state[col] & (1 << row));
222 }
223 }
224 input_sync(keypad->input_dev);
225 memcpy(keypad->matrix_key_state, new_state, sizeof(new_state));
226}
227
228#define DEFAULT_KPREC (0x007f007f)
229
230static inline int rotary_delta(uint32_t kprec)
231{
232 if (kprec & KPREC_OF0)
233 return (kprec & 0xff) + 0x7f;
234 else if (kprec & KPREC_UF0)
235 return (kprec & 0xff) - 0x7f - 0xff;
236 else
237 return (kprec & 0xff) - 0x7f;
238}
239
240static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta)
241{
242 struct input_dev *dev = keypad->input_dev;
243
244 if (delta == 0)
245 return;
246
247 if (keypad->rotary_up_key[r] && keypad->rotary_down_key[r]) {
248 int keycode = (delta > 0) ? keypad->rotary_up_key[r] :
249 keypad->rotary_down_key[r];
250
251 /* simulate a press-n-release */
252 input_report_key(dev, keycode, 1);
253 input_sync(dev);
254 input_report_key(dev, keycode, 0);
255 input_sync(dev);
256 } else {
257 input_report_rel(dev, keypad->rotary_rel_code[r], delta);
258 input_sync(dev);
259 }
260}
261
262static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad)
263{
264 struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
265 uint32_t kprec;
266
267 /* read and reset to default count value */
268 kprec = keypad_readl(KPREC);
269 keypad_writel(KPREC, DEFAULT_KPREC);
270
271 if (pdata->enable_rotary0)
272 report_rotary_event(keypad, 0, rotary_delta(kprec));
273
274 if (pdata->enable_rotary1)
275 report_rotary_event(keypad, 1, rotary_delta(kprec >> 16));
276}
277
278static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
279{
280 struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
281 unsigned int new_state;
282 uint32_t kpdk, bits_changed;
283 int i;
284
285 kpdk = keypad_readl(KPDK);
286
287 if (pdata->enable_rotary0 || pdata->enable_rotary1)
288 pxa27x_keypad_scan_rotary(keypad);
289
290 if (pdata->direct_key_map == NULL)
291 return;
292
293 new_state = KPDK_DK(kpdk) & keypad->direct_key_mask;
294 bits_changed = keypad->direct_key_state ^ new_state;
295
296 if (bits_changed == 0)
297 return;
298
299 for (i = 0; i < pdata->direct_key_num; i++) {
300 if (bits_changed & (1 << i))
301 input_report_key(keypad->input_dev,
302 pdata->direct_key_map[i],
303 (new_state & (1 << i)));
304 }
305 input_sync(keypad->input_dev);
306 keypad->direct_key_state = new_state;
307}
308
309static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
310{
311 struct pxa27x_keypad *keypad = dev_id;
312 unsigned long kpc = keypad_readl(KPC);
313
314 if (kpc & KPC_DI)
315 pxa27x_keypad_scan_direct(keypad);
316
317 if (kpc & KPC_MI)
318 pxa27x_keypad_scan_matrix(keypad);
319
320 return IRQ_HANDLED;
321}
322
323static void pxa27x_keypad_config(struct pxa27x_keypad *keypad)
324{
325 struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
326 unsigned int mask = 0, direct_key_num = 0;
327 unsigned long kpc = 0;
328
329 /* enable matrix keys with automatic scan */
330 if (pdata->matrix_key_rows && pdata->matrix_key_cols) {
331 kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL;
332 kpc |= KPC_MKRN(pdata->matrix_key_rows) |
333 KPC_MKCN(pdata->matrix_key_cols);
334 }
335
336 /* enable rotary key, debounce interval same as direct keys */
337 if (pdata->enable_rotary0) {
338 mask |= 0x03;
339 direct_key_num = 2;
340 kpc |= KPC_REE0;
341 }
342
343 if (pdata->enable_rotary1) {
344 mask |= 0x0c;
345 direct_key_num = 4;
346 kpc |= KPC_REE1;
347 }
348
349 if (pdata->direct_key_num > direct_key_num)
350 direct_key_num = pdata->direct_key_num;
351
352 keypad->direct_key_mask = ((2 << direct_key_num) - 1) & ~mask;
353
354 /* enable direct key */
355 if (direct_key_num)
356 kpc |= KPC_DE | KPC_DIE | KPC_DKN(direct_key_num);
357
358 keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB);
359 keypad_writel(KPREC, DEFAULT_KPREC);
360 keypad_writel(KPKDI, pdata->debounce_interval);
361}
362
363static int pxa27x_keypad_open(struct input_dev *dev)
364{
365 struct pxa27x_keypad *keypad = input_get_drvdata(dev);
366
367 /* Enable unit clock */
368 clk_enable(keypad->clk);
369 pxa27x_keypad_config(keypad);
370
371 return 0;
372}
373
374static void pxa27x_keypad_close(struct input_dev *dev)
375{
376 struct pxa27x_keypad *keypad = input_get_drvdata(dev);
377
378 /* Disable clock unit */
379 clk_disable(keypad->clk);
380}
381
382#ifdef CONFIG_PM
383static int pxa27x_keypad_suspend(struct platform_device *pdev, pm_message_t state)
384{
385 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
386
387 clk_disable(keypad->clk);
388 return 0;
389}
390
391static int pxa27x_keypad_resume(struct platform_device *pdev)
392{
393 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
394 struct input_dev *input_dev = keypad->input_dev;
395
396 mutex_lock(&input_dev->mutex);
397
398 if (input_dev->users) {
399 /* Enable unit clock */
400 clk_enable(keypad->clk);
401 pxa27x_keypad_config(keypad);
402 }
403
404 mutex_unlock(&input_dev->mutex);
405
406 return 0;
407}
408#else
409#define pxa27x_keypad_suspend NULL
410#define pxa27x_keypad_resume NULL
411#endif
412
413#define res_size(res) ((res)->end - (res)->start + 1)
414
415static int __devinit pxa27x_keypad_probe(struct platform_device *pdev)
416{
417 struct pxa27x_keypad *keypad;
418 struct input_dev *input_dev;
419 struct resource *res;
420 int irq, error;
421
422 keypad = kzalloc(sizeof(struct pxa27x_keypad), GFP_KERNEL);
423 if (keypad == NULL) {
424 dev_err(&pdev->dev, "failed to allocate driver data\n");
425 return -ENOMEM;
426 }
427
428 keypad->pdata = pdev->dev.platform_data;
429 if (keypad->pdata == NULL) {
430 dev_err(&pdev->dev, "no platform data defined\n");
431 error = -EINVAL;
432 goto failed_free;
433 }
434
435 irq = platform_get_irq(pdev, 0);
436 if (irq < 0) {
437 dev_err(&pdev->dev, "failed to get keypad irq\n");
438 error = -ENXIO;
439 goto failed_free;
440 }
441
442 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
443 if (res == NULL) {
444 dev_err(&pdev->dev, "failed to get I/O memory\n");
445 error = -ENXIO;
446 goto failed_free;
447 }
448
449 res = request_mem_region(res->start, res_size(res), pdev->name);
450 if (res == NULL) {
451 dev_err(&pdev->dev, "failed to request I/O memory\n");
452 error = -EBUSY;
453 goto failed_free;
454 }
455
456 keypad->mmio_base = ioremap(res->start, res_size(res));
457 if (keypad->mmio_base == NULL) {
458 dev_err(&pdev->dev, "failed to remap I/O memory\n");
459 error = -ENXIO;
460 goto failed_free_mem;
461 }
462
463 keypad->clk = clk_get(&pdev->dev, "KBDCLK");
464 if (IS_ERR(keypad->clk)) {
465 dev_err(&pdev->dev, "failed to get keypad clock\n");
466 error = PTR_ERR(keypad->clk);
467 goto failed_free_io;
468 }
469
470 /* Create and register the input driver. */
471 input_dev = input_allocate_device();
472 if (!input_dev) {
473 dev_err(&pdev->dev, "failed to allocate input device\n");
474 error = -ENOMEM;
475 goto failed_put_clk;
476 }
477
478 input_dev->name = pdev->name;
479 input_dev->id.bustype = BUS_HOST;
480 input_dev->open = pxa27x_keypad_open;
481 input_dev->close = pxa27x_keypad_close;
482 input_dev->dev.parent = &pdev->dev;
483
484 keypad->input_dev = input_dev;
485 input_set_drvdata(input_dev, keypad);
486
487 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
488 BIT_MASK(EV_REL);
489
490 pxa27x_keypad_build_keycode(keypad);
491 platform_set_drvdata(pdev, keypad);
492
493 error = request_irq(irq, pxa27x_keypad_irq_handler, IRQF_DISABLED,
494 pdev->name, keypad);
495 if (error) {
496 dev_err(&pdev->dev, "failed to request IRQ\n");
497 goto failed_free_dev;
498 }
499
500 /* Register the input device */
501 error = input_register_device(input_dev);
502 if (error) {
503 dev_err(&pdev->dev, "failed to register input device\n");
504 goto failed_free_irq;
505 }
506
507 return 0;
508
509failed_free_irq:
510 free_irq(irq, pdev);
511 platform_set_drvdata(pdev, NULL);
512failed_free_dev:
513 input_free_device(input_dev);
514failed_put_clk:
515 clk_put(keypad->clk);
516failed_free_io:
517 iounmap(keypad->mmio_base);
518failed_free_mem:
519 release_mem_region(res->start, res_size(res));
520failed_free:
521 kfree(keypad);
522 return error;
523}
524
525static int __devexit pxa27x_keypad_remove(struct platform_device *pdev)
526{
527 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
528 struct resource *res;
529
530 free_irq(platform_get_irq(pdev, 0), pdev);
531
532 clk_disable(keypad->clk);
533 clk_put(keypad->clk);
534
535 input_unregister_device(keypad->input_dev);
536 input_free_device(keypad->input_dev);
537
538 iounmap(keypad->mmio_base);
539
540 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
541 release_mem_region(res->start, res_size(res));
542
543 platform_set_drvdata(pdev, NULL);
544 kfree(keypad);
545 return 0;
546}
547
548static struct platform_driver pxa27x_keypad_driver = {
549 .probe = pxa27x_keypad_probe,
550 .remove = __devexit_p(pxa27x_keypad_remove),
551 .suspend = pxa27x_keypad_suspend,
552 .resume = pxa27x_keypad_resume,
553 .driver = {
554 .name = "pxa27x-keypad",
555 },
556};
557
558static int __init pxa27x_keypad_init(void)
559{
560 return platform_driver_register(&pxa27x_keypad_driver);
561}
562
563static void __exit pxa27x_keypad_exit(void)
564{
565 platform_driver_unregister(&pxa27x_keypad_driver);
566}
567
568module_init(pxa27x_keypad_init);
569module_exit(pxa27x_keypad_exit);
570
571MODULE_DESCRIPTION("PXA27x Keypad Controller Driver");
572MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-25 14:54:18 -0500