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/module.h>
24 #include <linux/platform_device.h>
25 #include <linux/interrupt.h>
26 #include <linux/clk.h>
27 #include <linux/io.h>
28 #include <linux/input/matrix_keypad.h>
29 #include <linux/slab.h>
30 
31 #include <mach/hardware.h>
32 #include <linux/platform_data/keypad-ep93xx.h>
33 
34 /*
35  * Keypad Interface Register offsets
36  */
37 #define KEY_INIT		0x00	/* Key Scan Initialization register */
38 #define KEY_DIAG		0x04	/* Key Scan Diagnostic register */
39 #define KEY_REG			0x08	/* Key Value Capture register */
40 
41 /* Key Scan Initialization Register bit defines */
42 #define KEY_INIT_DBNC_MASK	(0x00ff0000)
43 #define KEY_INIT_DBNC_SHIFT	(16)
44 #define KEY_INIT_DIS3KY		(1<<15)
45 #define KEY_INIT_DIAG		(1<<14)
46 #define KEY_INIT_BACK		(1<<13)
47 #define KEY_INIT_T2		(1<<12)
48 #define KEY_INIT_PRSCL_MASK	(0x000003ff)
49 #define KEY_INIT_PRSCL_SHIFT	(0)
50 
51 /* Key Scan Diagnostic Register bit defines */
52 #define KEY_DIAG_MASK		(0x0000003f)
53 #define KEY_DIAG_SHIFT		(0)
54 
55 /* Key Value Capture Register bit defines */
56 #define KEY_REG_K		(1<<15)
57 #define KEY_REG_INT		(1<<14)
58 #define KEY_REG_2KEYS		(1<<13)
59 #define KEY_REG_1KEY		(1<<12)
60 #define KEY_REG_KEY2_MASK	(0x00000fc0)
61 #define KEY_REG_KEY2_SHIFT	(6)
62 #define KEY_REG_KEY1_MASK	(0x0000003f)
63 #define KEY_REG_KEY1_SHIFT	(0)
64 
65 #define EP93XX_MATRIX_SIZE	(EP93XX_MATRIX_ROWS * EP93XX_MATRIX_COLS)
66 
67 struct ep93xx_keypad {
68 	struct ep93xx_keypad_platform_data *pdata;
69 	struct input_dev *input_dev;
70 	struct clk *clk;
71 
72 	void __iomem *mmio_base;
73 
74 	unsigned short keycodes[EP93XX_MATRIX_SIZE];
75 
76 	int key1;
77 	int key2;
78 
79 	int irq;
80 
81 	bool enabled;
82 };
83 
84 static irqreturn_t ep93xx_keypad_irq_handler(int irq, void *dev_id)
85 {
86 	struct ep93xx_keypad *keypad = dev_id;
87 	struct input_dev *input_dev = keypad->input_dev;
88 	unsigned int status;
89 	int keycode, key1, key2;
90 
91 	status = __raw_readl(keypad->mmio_base + KEY_REG);
92 
93 	keycode = (status & KEY_REG_KEY1_MASK) >> KEY_REG_KEY1_SHIFT;
94 	key1 = keypad->keycodes[keycode];
95 
96 	keycode = (status & KEY_REG_KEY2_MASK) >> KEY_REG_KEY2_SHIFT;
97 	key2 = keypad->keycodes[keycode];
98 
99 	if (status & KEY_REG_2KEYS) {
100 		if (keypad->key1 && key1 != keypad->key1 && key2 != keypad->key1)
101 			input_report_key(input_dev, keypad->key1, 0);
102 
103 		if (keypad->key2 && key1 != keypad->key2 && key2 != keypad->key2)
104 			input_report_key(input_dev, keypad->key2, 0);
105 
106 		input_report_key(input_dev, key1, 1);
107 		input_report_key(input_dev, key2, 1);
108 
109 		keypad->key1 = key1;
110 		keypad->key2 = key2;
111 
112 	} else if (status & KEY_REG_1KEY) {
113 		if (keypad->key1 && key1 != keypad->key1)
114 			input_report_key(input_dev, keypad->key1, 0);
115 
116 		if (keypad->key2 && key1 != keypad->key2)
117 			input_report_key(input_dev, keypad->key2, 0);
118 
119 		input_report_key(input_dev, key1, 1);
120 
121 		keypad->key1 = key1;
122 		keypad->key2 = 0;
123 
124 	} else {
125 		input_report_key(input_dev, keypad->key1, 0);
126 		input_report_key(input_dev, keypad->key2, 0);
127 
128 		keypad->key1 = keypad->key2 = 0;
129 	}
130 	input_sync(input_dev);
131 
132 	return IRQ_HANDLED;
133 }
134 
135 static void ep93xx_keypad_config(struct ep93xx_keypad *keypad)
136 {
137 	struct ep93xx_keypad_platform_data *pdata = keypad->pdata;
138 	unsigned int val = 0;
139 
140 	if (pdata->flags & EP93XX_KEYPAD_KDIV)
141 		clk_set_rate(keypad->clk, EP93XX_KEYTCHCLK_DIV4);
142 	else
143 		clk_set_rate(keypad->clk, EP93XX_KEYTCHCLK_DIV16);
144 
145 	if (pdata->flags & EP93XX_KEYPAD_DISABLE_3_KEY)
146 		val |= KEY_INIT_DIS3KY;
147 	if (pdata->flags & EP93XX_KEYPAD_DIAG_MODE)
148 		val |= KEY_INIT_DIAG;
149 	if (pdata->flags & EP93XX_KEYPAD_BACK_DRIVE)
150 		val |= KEY_INIT_BACK;
151 	if (pdata->flags & EP93XX_KEYPAD_TEST_MODE)
152 		val |= KEY_INIT_T2;
153 
154 	val |= ((pdata->debounce << KEY_INIT_DBNC_SHIFT) & KEY_INIT_DBNC_MASK);
155 
156 	val |= ((pdata->prescale << KEY_INIT_PRSCL_SHIFT) & KEY_INIT_PRSCL_MASK);
157 
158 	__raw_writel(val, keypad->mmio_base + KEY_INIT);
159 }
160 
161 static int ep93xx_keypad_open(struct input_dev *pdev)
162 {
163 	struct ep93xx_keypad *keypad = input_get_drvdata(pdev);
164 
165 	if (!keypad->enabled) {
166 		ep93xx_keypad_config(keypad);
167 		clk_enable(keypad->clk);
168 		keypad->enabled = true;
169 	}
170 
171 	return 0;
172 }
173 
174 static void ep93xx_keypad_close(struct input_dev *pdev)
175 {
176 	struct ep93xx_keypad *keypad = input_get_drvdata(pdev);
177 
178 	if (keypad->enabled) {
179 		clk_disable(keypad->clk);
180 		keypad->enabled = false;
181 	}
182 }
183 
184 
185 #ifdef CONFIG_PM_SLEEP
186 static int ep93xx_keypad_suspend(struct device *dev)
187 {
188 	struct platform_device *pdev = to_platform_device(dev);
189 	struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
190 	struct input_dev *input_dev = keypad->input_dev;
191 
192 	mutex_lock(&input_dev->mutex);
193 
194 	if (keypad->enabled) {
195 		clk_disable(keypad->clk);
196 		keypad->enabled = false;
197 	}
198 
199 	mutex_unlock(&input_dev->mutex);
200 
201 	if (device_may_wakeup(&pdev->dev))
202 		enable_irq_wake(keypad->irq);
203 
204 	return 0;
205 }
206 
207 static int ep93xx_keypad_resume(struct device *dev)
208 {
209 	struct platform_device *pdev = to_platform_device(dev);
210 	struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
211 	struct input_dev *input_dev = keypad->input_dev;
212 
213 	if (device_may_wakeup(&pdev->dev))
214 		disable_irq_wake(keypad->irq);
215 
216 	mutex_lock(&input_dev->mutex);
217 
218 	if (input_dev->users) {
219 		if (!keypad->enabled) {
220 			ep93xx_keypad_config(keypad);
221 			clk_enable(keypad->clk);
222 			keypad->enabled = true;
223 		}
224 	}
225 
226 	mutex_unlock(&input_dev->mutex);
227 
228 	return 0;
229 }
230 #endif
231 
232 static SIMPLE_DEV_PM_OPS(ep93xx_keypad_pm_ops,
233 			 ep93xx_keypad_suspend, ep93xx_keypad_resume);
234 
235 static int ep93xx_keypad_probe(struct platform_device *pdev)
236 {
237 	struct ep93xx_keypad *keypad;
238 	const struct matrix_keymap_data *keymap_data;
239 	struct input_dev *input_dev;
240 	struct resource *res;
241 	int err;
242 
243 	keypad = kzalloc(sizeof(struct ep93xx_keypad), GFP_KERNEL);
244 	if (!keypad)
245 		return -ENOMEM;
246 
247 	keypad->pdata = dev_get_platdata(&pdev->dev);
248 	if (!keypad->pdata) {
249 		err = -EINVAL;
250 		goto failed_free;
251 	}
252 
253 	keymap_data = keypad->pdata->keymap_data;
254 	if (!keymap_data) {
255 		err = -EINVAL;
256 		goto failed_free;
257 	}
258 
259 	keypad->irq = platform_get_irq(pdev, 0);
260 	if (!keypad->irq) {
261 		err = -ENXIO;
262 		goto failed_free;
263 	}
264 
265 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
266 	if (!res) {
267 		err = -ENXIO;
268 		goto failed_free;
269 	}
270 
271 	res = request_mem_region(res->start, resource_size(res), pdev->name);
272 	if (!res) {
273 		err = -EBUSY;
274 		goto failed_free;
275 	}
276 
277 	keypad->mmio_base = ioremap(res->start, resource_size(res));
278 	if (keypad->mmio_base == NULL) {
279 		err = -ENXIO;
280 		goto failed_free_mem;
281 	}
282 
283 	err = ep93xx_keypad_acquire_gpio(pdev);
284 	if (err)
285 		goto failed_free_io;
286 
287 	keypad->clk = clk_get(&pdev->dev, NULL);
288 	if (IS_ERR(keypad->clk)) {
289 		err = PTR_ERR(keypad->clk);
290 		goto failed_free_gpio;
291 	}
292 
293 	input_dev = input_allocate_device();
294 	if (!input_dev) {
295 		err = -ENOMEM;
296 		goto failed_put_clk;
297 	}
298 
299 	keypad->input_dev = input_dev;
300 
301 	input_dev->name = pdev->name;
302 	input_dev->id.bustype = BUS_HOST;
303 	input_dev->open = ep93xx_keypad_open;
304 	input_dev->close = ep93xx_keypad_close;
305 	input_dev->dev.parent = &pdev->dev;
306 
307 	err = matrix_keypad_build_keymap(keymap_data, NULL,
308 					 EP93XX_MATRIX_ROWS, EP93XX_MATRIX_COLS,
309 					 keypad->keycodes, input_dev);
310 	if (err)
311 		goto failed_free_dev;
312 
313 	if (keypad->pdata->flags & EP93XX_KEYPAD_AUTOREPEAT)
314 		__set_bit(EV_REP, input_dev->evbit);
315 	input_set_drvdata(input_dev, keypad);
316 
317 	err = request_irq(keypad->irq, ep93xx_keypad_irq_handler,
318 			  0, pdev->name, keypad);
319 	if (err)
320 		goto failed_free_dev;
321 
322 	err = input_register_device(input_dev);
323 	if (err)
324 		goto failed_free_irq;
325 
326 	platform_set_drvdata(pdev, keypad);
327 	device_init_wakeup(&pdev->dev, 1);
328 
329 	return 0;
330 
331 failed_free_irq:
332 	free_irq(keypad->irq, keypad);
333 failed_free_dev:
334 	input_free_device(input_dev);
335 failed_put_clk:
336 	clk_put(keypad->clk);
337 failed_free_gpio:
338 	ep93xx_keypad_release_gpio(pdev);
339 failed_free_io:
340 	iounmap(keypad->mmio_base);
341 failed_free_mem:
342 	release_mem_region(res->start, resource_size(res));
343 failed_free:
344 	kfree(keypad);
345 	return err;
346 }
347 
348 static int ep93xx_keypad_remove(struct platform_device *pdev)
349 {
350 	struct ep93xx_keypad *keypad = platform_get_drvdata(pdev);
351 	struct resource *res;
352 
353 	free_irq(keypad->irq, keypad);
354 
355 	if (keypad->enabled)
356 		clk_disable(keypad->clk);
357 	clk_put(keypad->clk);
358 
359 	input_unregister_device(keypad->input_dev);
360 
361 	ep93xx_keypad_release_gpio(pdev);
362 
363 	iounmap(keypad->mmio_base);
364 
365 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
366 	release_mem_region(res->start, resource_size(res));
367 
368 	kfree(keypad);
369 
370 	return 0;
371 }
372 
373 static struct platform_driver ep93xx_keypad_driver = {
374 	.driver		= {
375 		.name	= "ep93xx-keypad",
376 		.pm	= &ep93xx_keypad_pm_ops,
377 	},
378 	.probe		= ep93xx_keypad_probe,
379 	.remove		= ep93xx_keypad_remove,
380 };
381 module_platform_driver(ep93xx_keypad_driver);
382 
383 MODULE_LICENSE("GPL");
384 MODULE_AUTHOR("H Hartley Sweeten <hsweeten@visionengravers.com>");
385 MODULE_DESCRIPTION("EP93xx Matrix Keypad Controller");
386 MODULE_ALIAS("platform:ep93xx-keypad");
387