1 /*
2  * Driver for the Cirrus EP93xx matrix keypad controller.
3  *
4  * Copyright (c) 2008 H Hartley Sweeten <hsweeten@visionengravers.com>
5  *
6  * Based on the pxa27x matrix keypad controller by Rodolfo Giometti.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * NOTE:
13  *
14  * The 3-key reset is triggered by pressing the 3 keys in
15  * Row 0, Columns 2, 4, and 7 at the same time.  This action can
16  * be disabled by setting the EP93XX_KEYPAD_DISABLE_3_KEY flag.
17  *
18  * Normal operation for the matrix does not autorepeat the key press.
19  * This action can be enabled by setting the EP93XX_KEYPAD_AUTOREPEAT
20  * flag.
21  */
22 
23 #include <linux/platform_device.h>
24 #include <linux/interrupt.h>
25 #include <linux/clk.h>
26 #include <linux/io.h>
27 #include <linux/input/matrix_keypad.h>
28 
29 #include <mach/hardware.h>
30 #include <mach/ep93xx_keypad.h>
31 
32 /*
33  * Keypad Interface Register offsets
34  */
35 #define KEY_INIT		0x00	/* Key Scan Initialization register */
36 #define KEY_DIAG		0x04	/* Key Scan Diagnostic register */
37 #define KEY_REG			0x08	/* Key Value Capture register */
38 
39 /* Key Scan Initialization Register bit defines */
40 #define KEY_INIT_DBNC_MASK	(0x00ff0000)
41 #define KEY_INIT_DBNC_SHIFT	(16)
42 #define KEY_INIT_DIS3KY		(1<<15)
43 #define KEY_INIT_DIAG		(1<<14)
44 #define KEY_INIT_BACK		(1<<13)
45 #define KEY_INIT_T2		(1<<12)
46 #define KEY_INIT_PRSCL_MASK	(0x000003ff)
47 #define KEY_INIT_PRSCL_SHIFT	(0)
48 
49 /* Key Scan Diagnostic Register bit defines */
50 #define KEY_DIAG_MASK		(0x0000003f)
51 #define KEY_DIAG_SHIFT		(0)
52 
53 /* Key Value Capture Register bit defines */
54 #define KEY_REG_K		(1<<15)
55 #define KEY_REG_INT		(1<<14)
56 #define KEY_REG_2KEYS		(1<<13)
57 #define KEY_REG_1KEY		(1<<12)
58 #define KEY_REG_KEY2_MASK	(0x00000fc0)
59 #define KEY_REG_KEY2_SHIFT	(6)
60 #define KEY_REG_KEY1_MASK	(0x0000003f)
61 #define KEY_REG_KEY1_SHIFT	(0)
62 
63 #define EP93XX_MATRIX_SIZE	(EP93XX_MATRIX_ROWS * EP93XX_MATRIX_COLS)
64 
65 struct ep93xx_keypad {
66 	struct ep93xx_keypad_platform_data *pdata;
67 	struct input_dev *input_dev;
68 	struct clk *clk;
69 
70 	void __iomem *mmio_base;
71 
72 	unsigned int matrix_keycodes[EP93XX_MATRIX_SIZE];
73 
74 	int key1;
75 	int key2;
76 
77 	int irq;
78 
79 	bool enabled;
80 };
81 
82 static void ep93xx_keypad_build_keycode(struct ep93xx_keypad *keypad)
83 {
84 	struct ep93xx_keypad_platform_data *pdata = keypad->pdata;
85 	struct input_dev *input_dev = keypad->input_dev;
86 	unsigned int *key;
87 	int i;
88 
89 	key = &pdata->matrix_key_map[0];
90 	for (i = 0; i < pdata->matrix_key_map_size; i++, key++) {
91 		int row = KEY_ROW(*key);
92 		int col = KEY_COL(*key);
93 		int code = KEY_VAL(*key);
94 
95 		keypad->matrix_keycodes[(row << 3) + col] = code;
96 		__set_bit(code, input_dev->keybit);
97 	}
98 }
99 
100 static irqreturn_t ep93xx_keypad_irq_handler(int irq, void *dev_id)
101 {
102 	struct ep93xx_keypad *keypad = dev_id;
103 	struct input_dev *input_dev = keypad->input_dev;
104 	unsigned int status;
105 	int keycode, key1, key2;
106 
107 	status = __raw_readl(keypad->mmio_base + KEY_REG);
108 
109 	keycode = (status & KEY_REG_KEY1_MASK) >> KEY_REG_KEY1_SHIFT;
110 	key1 = keypad->matrix_keycodes[keycode];
111 
112 	keycode = (status & KEY_REG_KEY2_MASK) >> KEY_REG_KEY2_SHIFT;
113 	key2 = keypad->matrix_keycodes[keycode];
114 
115 	if (status & KEY_REG_2KEYS) {
116 		if (keypad->key1 && key1 != keypad->key1 && key2 != keypad->key1)
117 			input_report_key(input_dev, keypad->key1, 0);
118 
119 		if (keypad->key2 && key1 != keypad->key2 && key2 != keypad->key2)
120 			input_report_key(input_dev, keypad->key2, 0);
121 
122 		input_report_key(input_dev, key1, 1);
123 		input_report_key(input_dev, key2, 1);
124 
125 		keypad->key1 = key1;
126 		keypad->key2 = key2;
127 
128 	} else if (status & KEY_REG_1KEY) {
129 		if (keypad->key1 && key1 != keypad->key1)
130 			input_report_key(input_dev, keypad->key1, 0);
131 
132 		if (keypad->key2 && key1 != keypad->key2)
133 			input_report_key(input_dev, keypad->key2, 0);
134 
135 		input_report_key(input_dev, key1, 1);
136 
137 		keypad->key1 = key1;
138 		keypad->key2 = 0;
139 
140 	} else {
141 		input_report_key(input_dev, keypad->key1, 0);
142 		input_report_key(input_dev, keypad->key2, 0);
143 
144 		keypad->key1 = keypad->key2 = 0;
145 	}
146 	input_sync(input_dev);
147 
148 	return IRQ_HANDLED;
149 }
150 
151 static void ep93xx_keypad_config(struct ep93xx_keypad *keypad)
152 {
153 	struct ep93xx_keypad_platform_data *pdata = keypad->pdata;
154 	unsigned int val = 0;
155 
156 	if (pdata->flags & EP93XX_KEYPAD_KDIV)
157 		clk_set_rate(keypad->clk, EP93XX_KEYTCHCLK_DIV4);
158 	else
159 		clk_set_rate(keypad->clk, EP93XX_KEYTCHCLK_DIV16);
160 
161 	if (pdata->flags & EP93XX_KEYPAD_DISABLE_3_KEY)
162 		val |= KEY_INIT_DIS3KY;
163 	if (pdata->flags & EP93XX_KEYPAD_DIAG_MODE)
164 		val |= KEY_INIT_DIAG;
165 	if (pdata->flags & EP93XX_KEYPAD_BACK_DRIVE)
166 		val |= KEY_INIT_BACK;
167 	if (pdata->flags & EP93XX_KEYPAD_TEST_MODE)
168 		val |= KEY_INIT_T2;
169 
170 	val |= ((pdata->debounce << KEY_INIT_DBNC_SHIFT) & KEY_INIT_DBNC_MASK);
171 
172 	val |= ((pdata->prescale << KEY_INIT_PRSCL_SHIFT) & KEY_INIT_PRSCL_MASK);
173 
174 	__raw_writel(val, keypad->mmio_base + KEY_INIT);
175 }
176 
177 static int ep93xx_keypad_open(struct input_dev *pdev)
178 {
179 	struct ep93xx_keypad *keypad = input_get_drvdata(pdev);
180 
181 	if (!keypad->enabled) {
182 		ep93xx_keypad_config(keypad);
183 		clk_enable(keypad->clk);
184 		keypad->enabled = true;
185 	}
186 
187 	return 0;
188 }
189 
190 static void ep93xx_keypad_close(struct input_dev *pdev)
191 {
192 	struct ep93xx_keypad *keypad = input_get_drvdata(pdev);
193 
194 	if (keypad->enabled) {
195 		clk_disable(keypad->clk);
196 		keypad->enabled = false;
197 	}
198 }
199 
200 
201 #ifdef CONFIG_PM
202 /*
203  * NOTE: I don't know if this is correct, or will work on the ep93xx.
204  *
205  * None of the existing ep93xx drivers have power management support.
206  * But, this is basically what the pxa27x_keypad driver does.
207  */
208 static int ep93xx_keypad_suspend(struct platform_device *pdev,
209 				 pm_message_t state)
210 {
211 	struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
212 	struct input_dev *input_dev = keypad->input_dev;
213 
214 	mutex_lock(&input_dev->mutex);
215 
216 	if (keypad->enabled) {
217 		clk_disable(keypad->clk);
218 		keypad->enabled = false;
219 	}
220 
221 	mutex_unlock(&input_dev->mutex);
222 
223 	if (device_may_wakeup(&pdev->dev))
224 		enable_irq_wake(keypad->irq);
225 
226 	return 0;
227 }
228 
229 static int ep93xx_keypad_resume(struct platform_device *pdev)
230 {
231 	struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
232 	struct input_dev *input_dev = keypad->input_dev;
233 
234 	if (device_may_wakeup(&pdev->dev))
235 		disable_irq_wake(keypad->irq);
236 
237 	mutex_lock(&input_dev->mutex);
238 
239 	if (input_dev->users) {
240 		if (!keypad->enabled) {
241 			ep93xx_keypad_config(keypad);
242 			clk_enable(keypad->clk);
243 			keypad->enabled = true;
244 		}
245 	}
246 
247 	mutex_unlock(&input_dev->mutex);
248 
249 	return 0;
250 }
251 #else	/* !CONFIG_PM */
252 #define ep93xx_keypad_suspend	NULL
253 #define ep93xx_keypad_resume	NULL
254 #endif	/* !CONFIG_PM */
255 
256 static int __devinit ep93xx_keypad_probe(struct platform_device *pdev)
257 {
258 	struct ep93xx_keypad *keypad;
259 	struct input_dev *input_dev;
260 	struct resource *res;
261 	int err;
262 
263 	keypad = kzalloc(sizeof(struct ep93xx_keypad), GFP_KERNEL);
264 	if (!keypad)
265 		return -ENOMEM;
266 
267 	keypad->pdata = pdev->dev.platform_data;
268 	if (!keypad->pdata) {
269 		err = -EINVAL;
270 		goto failed_free;
271 	}
272 
273 	keypad->irq = platform_get_irq(pdev, 0);
274 	if (!keypad->irq) {
275 		err = -ENXIO;
276 		goto failed_free;
277 	}
278 
279 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
280 	if (!res) {
281 		err = -ENXIO;
282 		goto failed_free;
283 	}
284 
285 	res = request_mem_region(res->start, resource_size(res), pdev->name);
286 	if (!res) {
287 		err = -EBUSY;
288 		goto failed_free;
289 	}
290 
291 	keypad->mmio_base = ioremap(res->start, resource_size(res));
292 	if (keypad->mmio_base == NULL) {
293 		err = -ENXIO;
294 		goto failed_free_mem;
295 	}
296 
297 	err = ep93xx_keypad_acquire_gpio(pdev);
298 	if (err)
299 		goto failed_free_io;
300 
301 	keypad->clk = clk_get(&pdev->dev, NULL);
302 	if (IS_ERR(keypad->clk)) {
303 		err = PTR_ERR(keypad->clk);
304 		goto failed_free_gpio;
305 	}
306 
307 	input_dev = input_allocate_device();
308 	if (!input_dev) {
309 		err = -ENOMEM;
310 		goto failed_put_clk;
311 	}
312 
313 	keypad->input_dev = input_dev;
314 
315 	input_dev->name = pdev->name;
316 	input_dev->id.bustype = BUS_HOST;
317 	input_dev->open = ep93xx_keypad_open;
318 	input_dev->close = ep93xx_keypad_close;
319 	input_dev->dev.parent = &pdev->dev;
320 	input_dev->keycode = keypad->matrix_keycodes;
321 	input_dev->keycodesize = sizeof(keypad->matrix_keycodes[0]);
322 	input_dev->keycodemax = ARRAY_SIZE(keypad->matrix_keycodes);
323 
324 	input_set_drvdata(input_dev, keypad);
325 
326 	input_dev->evbit[0] = BIT_MASK(EV_KEY);
327 	if (keypad->pdata->flags & EP93XX_KEYPAD_AUTOREPEAT)
328 		input_dev->evbit[0] |= BIT_MASK(EV_REP);
329 
330 	ep93xx_keypad_build_keycode(keypad);
331 	platform_set_drvdata(pdev, keypad);
332 
333 	err = request_irq(keypad->irq, ep93xx_keypad_irq_handler,
334 			  IRQF_DISABLED, pdev->name, keypad);
335 	if (err)
336 		goto failed_free_dev;
337 
338 	err = input_register_device(input_dev);
339 	if (err)
340 		goto failed_free_irq;
341 
342 	device_init_wakeup(&pdev->dev, 1);
343 
344 	return 0;
345 
346 failed_free_irq:
347 	free_irq(keypad->irq, pdev);
348 	platform_set_drvdata(pdev, NULL);
349 failed_free_dev:
350 	input_free_device(input_dev);
351 failed_put_clk:
352 	clk_put(keypad->clk);
353 failed_free_gpio:
354 	ep93xx_keypad_release_gpio(pdev);
355 failed_free_io:
356 	iounmap(keypad->mmio_base);
357 failed_free_mem:
358 	release_mem_region(res->start, resource_size(res));
359 failed_free:
360 	kfree(keypad);
361 	return err;
362 }
363 
364 static int __devexit ep93xx_keypad_remove(struct platform_device *pdev)
365 {
366 	struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
367 	struct resource *res;
368 
369 	free_irq(keypad->irq, pdev);
370 
371 	platform_set_drvdata(pdev, NULL);
372 
373 	if (keypad->enabled)
374 		clk_disable(keypad->clk);
375 	clk_put(keypad->clk);
376 
377 	input_unregister_device(keypad->input_dev);
378 
379 	ep93xx_keypad_release_gpio(pdev);
380 
381 	iounmap(keypad->mmio_base);
382 
383 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
384 	release_mem_region(res->start, resource_size(res));
385 
386 	kfree(keypad);
387 
388 	return 0;
389 }
390 
391 static struct platform_driver ep93xx_keypad_driver = {
392 	.driver		= {
393 		.name	= "ep93xx-keypad",
394 		.owner	= THIS_MODULE,
395 	},
396 	.probe		= ep93xx_keypad_probe,
397 	.remove		= __devexit_p(ep93xx_keypad_remove),
398 	.suspend	= ep93xx_keypad_suspend,
399 	.resume		= ep93xx_keypad_resume,
400 };
401 
402 static int __init ep93xx_keypad_init(void)
403 {
404 	return platform_driver_register(&ep93xx_keypad_driver);
405 }
406 
407 static void __exit ep93xx_keypad_exit(void)
408 {
409 	platform_driver_unregister(&ep93xx_keypad_driver);
410 }
411 
412 module_init(ep93xx_keypad_init);
413 module_exit(ep93xx_keypad_exit);
414 
415 MODULE_LICENSE("GPL");
416 MODULE_AUTHOR("H Hartley Sweeten <hsweeten@visionengravers.com>");
417 MODULE_DESCRIPTION("EP93xx Matrix Keypad Controller");
418 MODULE_ALIAS("platform:ep93xx-keypad");
419