1 /*
2  * Copyright (C) ST-Ericsson SA 2010
3  *
4  * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson
5  * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
6  *
7  * License terms:GNU General Public License (GPL) version 2
8  *
9  * Keypad controller driver for the SKE (Scroll Key Encoder) module used in
10  * the Nomadik 8815 and Ux500 platforms.
11  */
12 
13 #include <linux/platform_device.h>
14 #include <linux/interrupt.h>
15 #include <linux/spinlock.h>
16 #include <linux/io.h>
17 #include <linux/delay.h>
18 #include <linux/input.h>
19 #include <linux/slab.h>
20 #include <linux/clk.h>
21 #include <linux/module.h>
22 
23 #include <plat/ske.h>
24 
25 /* SKE_CR bits */
26 #define SKE_KPMLT	(0x1 << 6)
27 #define SKE_KPCN	(0x7 << 3)
28 #define SKE_KPASEN	(0x1 << 2)
29 #define SKE_KPASON	(0x1 << 7)
30 
31 /* SKE_IMSC bits */
32 #define SKE_KPIMA	(0x1 << 2)
33 
34 /* SKE_ICR bits */
35 #define SKE_KPICS	(0x1 << 3)
36 #define SKE_KPICA	(0x1 << 2)
37 
38 /* SKE_RIS bits */
39 #define SKE_KPRISA	(0x1 << 2)
40 
41 #define SKE_KEYPAD_ROW_SHIFT	3
42 #define SKE_KPD_KEYMAP_SIZE	(8 * 8)
43 
44 /* keypad auto scan registers */
45 #define SKE_ASR0	0x20
46 #define SKE_ASR1	0x24
47 #define SKE_ASR2	0x28
48 #define SKE_ASR3	0x2C
49 
50 #define SKE_NUM_ASRX_REGISTERS	(4)
51 
52 /**
53  * struct ske_keypad  - data structure used by keypad driver
54  * @irq:	irq no
55  * @reg_base:	ske regsiters base address
56  * @input:	pointer to input device object
57  * @board:	keypad platform device
58  * @keymap:	matrix scan code table for keycodes
59  * @clk:	clock structure pointer
60  */
61 struct ske_keypad {
62 	int irq;
63 	void __iomem *reg_base;
64 	struct input_dev *input;
65 	const struct ske_keypad_platform_data *board;
66 	unsigned short keymap[SKE_KPD_KEYMAP_SIZE];
67 	struct clk *clk;
68 	spinlock_t ske_keypad_lock;
69 };
70 
71 static void ske_keypad_set_bits(struct ske_keypad *keypad, u16 addr,
72 		u8 mask, u8 data)
73 {
74 	u32 ret;
75 
76 	spin_lock(&keypad->ske_keypad_lock);
77 
78 	ret = readl(keypad->reg_base + addr);
79 	ret &= ~mask;
80 	ret |= data;
81 	writel(ret, keypad->reg_base + addr);
82 
83 	spin_unlock(&keypad->ske_keypad_lock);
84 }
85 
86 /*
87  * ske_keypad_chip_init: init keypad controller configuration
88  *
89  * Enable Multi key press detection, auto scan mode
90  */
91 static int __init ske_keypad_chip_init(struct ske_keypad *keypad)
92 {
93 	u32 value;
94 	int timeout = 50;
95 
96 	/* check SKE_RIS to be 0 */
97 	while ((readl(keypad->reg_base + SKE_RIS) != 0x00000000) && timeout--)
98 		cpu_relax();
99 
100 	if (!timeout)
101 		return -EINVAL;
102 
103 	/*
104 	 * set debounce value
105 	 * keypad dbounce is configured in DBCR[15:8]
106 	 * dbounce value in steps of 32/32.768 ms
107 	 */
108 	spin_lock(&keypad->ske_keypad_lock);
109 	value = readl(keypad->reg_base + SKE_DBCR);
110 	value = value & 0xff;
111 	value |= ((keypad->board->debounce_ms * 32000)/32768) << 8;
112 	writel(value, keypad->reg_base + SKE_DBCR);
113 	spin_unlock(&keypad->ske_keypad_lock);
114 
115 	/* enable multi key detection */
116 	ske_keypad_set_bits(keypad, SKE_CR, 0x0, SKE_KPMLT);
117 
118 	/*
119 	 * set up the number of columns
120 	 * KPCN[5:3] defines no. of keypad columns to be auto scanned
121 	 */
122 	value = (keypad->board->kcol - 1) << 3;
123 	ske_keypad_set_bits(keypad, SKE_CR, SKE_KPCN, value);
124 
125 	/* clear keypad interrupt for auto(and pending SW) scans */
126 	ske_keypad_set_bits(keypad, SKE_ICR, 0x0, SKE_KPICA | SKE_KPICS);
127 
128 	/* un-mask keypad interrupts */
129 	ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
130 
131 	/* enable automatic scan */
132 	ske_keypad_set_bits(keypad, SKE_CR, 0x0, SKE_KPASEN);
133 
134 	return 0;
135 }
136 
137 static void ske_keypad_read_data(struct ske_keypad *keypad)
138 {
139 	struct input_dev *input = keypad->input;
140 	u16 status;
141 	int col = 0, row = 0, code;
142 	int ske_asr, ske_ris, key_pressed, i;
143 
144 	/*
145 	 * Read the auto scan registers
146 	 *
147 	 * Each SKE_ASRx (x=0 to x=3) contains two row values.
148 	 * lower byte contains row value for column 2*x,
149 	 * upper byte contains row value for column 2*x + 1
150 	 */
151 	for (i = 0; i < SKE_NUM_ASRX_REGISTERS; i++) {
152 		ske_asr = readl(keypad->reg_base + SKE_ASR0 + (4 * i));
153 		if (!ske_asr)
154 			continue;
155 
156 		/* now that ASRx is zero, find out the column x and row y*/
157 		if (ske_asr & 0xff) {
158 			col = i * 2;
159 			status = ske_asr & 0xff;
160 		} else {
161 			col = (i * 2) + 1;
162 			status = (ske_asr & 0xff00) >> 8;
163 		}
164 
165 		/* find out the row */
166 		row = __ffs(status);
167 
168 		code = MATRIX_SCAN_CODE(row, col, SKE_KEYPAD_ROW_SHIFT);
169 		ske_ris = readl(keypad->reg_base + SKE_RIS);
170 		key_pressed = ske_ris & SKE_KPRISA;
171 
172 		input_event(input, EV_MSC, MSC_SCAN, code);
173 		input_report_key(input, keypad->keymap[code], key_pressed);
174 		input_sync(input);
175 	}
176 }
177 
178 static irqreturn_t ske_keypad_irq(int irq, void *dev_id)
179 {
180 	struct ske_keypad *keypad = dev_id;
181 	int retries = 20;
182 
183 	/* disable auto scan interrupt; mask the interrupt generated */
184 	ske_keypad_set_bits(keypad, SKE_IMSC, ~SKE_KPIMA, 0x0);
185 	ske_keypad_set_bits(keypad, SKE_ICR, 0x0, SKE_KPICA);
186 
187 	while ((readl(keypad->reg_base + SKE_CR) & SKE_KPASON) && --retries)
188 		msleep(5);
189 
190 	if (retries) {
191 		/* SKEx registers are stable and can be read */
192 		ske_keypad_read_data(keypad);
193 	}
194 
195 	/* enable auto scan interrupts */
196 	ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
197 
198 	return IRQ_HANDLED;
199 }
200 
201 static int __init ske_keypad_probe(struct platform_device *pdev)
202 {
203 	const struct ske_keypad_platform_data *plat = pdev->dev.platform_data;
204 	struct ske_keypad *keypad;
205 	struct input_dev *input;
206 	struct resource *res;
207 	int irq;
208 	int error;
209 
210 	if (!plat) {
211 		dev_err(&pdev->dev, "invalid keypad platform data\n");
212 		return -EINVAL;
213 	}
214 
215 	irq = platform_get_irq(pdev, 0);
216 	if (irq < 0) {
217 		dev_err(&pdev->dev, "failed to get keypad irq\n");
218 		return -EINVAL;
219 	}
220 
221 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
222 	if (!res) {
223 		dev_err(&pdev->dev, "missing platform resources\n");
224 		return -EINVAL;
225 	}
226 
227 	keypad = kzalloc(sizeof(struct ske_keypad), GFP_KERNEL);
228 	input = input_allocate_device();
229 	if (!keypad || !input) {
230 		dev_err(&pdev->dev, "failed to allocate keypad memory\n");
231 		error = -ENOMEM;
232 		goto err_free_mem;
233 	}
234 
235 	keypad->irq = irq;
236 	keypad->board = plat;
237 	keypad->input = input;
238 	spin_lock_init(&keypad->ske_keypad_lock);
239 
240 	if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
241 		dev_err(&pdev->dev, "failed to request I/O memory\n");
242 		error = -EBUSY;
243 		goto err_free_mem;
244 	}
245 
246 	keypad->reg_base = ioremap(res->start, resource_size(res));
247 	if (!keypad->reg_base) {
248 		dev_err(&pdev->dev, "failed to remap I/O memory\n");
249 		error = -ENXIO;
250 		goto err_free_mem_region;
251 	}
252 
253 	keypad->clk = clk_get(&pdev->dev, NULL);
254 	if (IS_ERR(keypad->clk)) {
255 		dev_err(&pdev->dev, "failed to get clk\n");
256 		error = PTR_ERR(keypad->clk);
257 		goto err_iounmap;
258 	}
259 
260 	input->id.bustype = BUS_HOST;
261 	input->name = "ux500-ske-keypad";
262 	input->dev.parent = &pdev->dev;
263 
264 	input->keycode = keypad->keymap;
265 	input->keycodesize = sizeof(keypad->keymap[0]);
266 	input->keycodemax = ARRAY_SIZE(keypad->keymap);
267 
268 	input_set_capability(input, EV_MSC, MSC_SCAN);
269 
270 	__set_bit(EV_KEY, input->evbit);
271 	if (!plat->no_autorepeat)
272 		__set_bit(EV_REP, input->evbit);
273 
274 	matrix_keypad_build_keymap(plat->keymap_data, SKE_KEYPAD_ROW_SHIFT,
275 			input->keycode, input->keybit);
276 
277 	clk_enable(keypad->clk);
278 
279 	/* go through board initialization helpers */
280 	if (keypad->board->init)
281 		keypad->board->init();
282 
283 	error = ske_keypad_chip_init(keypad);
284 	if (error) {
285 		dev_err(&pdev->dev, "unable to init keypad hardware\n");
286 		goto err_clk_disable;
287 	}
288 
289 	error = request_threaded_irq(keypad->irq, NULL, ske_keypad_irq,
290 				     IRQF_ONESHOT, "ske-keypad", keypad);
291 	if (error) {
292 		dev_err(&pdev->dev, "allocate irq %d failed\n", keypad->irq);
293 		goto err_clk_disable;
294 	}
295 
296 	error = input_register_device(input);
297 	if (error) {
298 		dev_err(&pdev->dev,
299 				"unable to register input device: %d\n", error);
300 		goto err_free_irq;
301 	}
302 
303 	if (plat->wakeup_enable)
304 		device_init_wakeup(&pdev->dev, true);
305 
306 	platform_set_drvdata(pdev, keypad);
307 
308 	return 0;
309 
310 err_free_irq:
311 	free_irq(keypad->irq, keypad);
312 err_clk_disable:
313 	clk_disable(keypad->clk);
314 	clk_put(keypad->clk);
315 err_iounmap:
316 	iounmap(keypad->reg_base);
317 err_free_mem_region:
318 	release_mem_region(res->start, resource_size(res));
319 err_free_mem:
320 	input_free_device(input);
321 	kfree(keypad);
322 	return error;
323 }
324 
325 static int __devexit ske_keypad_remove(struct platform_device *pdev)
326 {
327 	struct ske_keypad *keypad = platform_get_drvdata(pdev);
328 	struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
329 
330 	free_irq(keypad->irq, keypad);
331 
332 	input_unregister_device(keypad->input);
333 
334 	clk_disable(keypad->clk);
335 	clk_put(keypad->clk);
336 
337 	if (keypad->board->exit)
338 		keypad->board->exit();
339 
340 	iounmap(keypad->reg_base);
341 	release_mem_region(res->start, resource_size(res));
342 	kfree(keypad);
343 
344 	return 0;
345 }
346 
347 #ifdef CONFIG_PM_SLEEP
348 static int ske_keypad_suspend(struct device *dev)
349 {
350 	struct platform_device *pdev = to_platform_device(dev);
351 	struct ske_keypad *keypad = platform_get_drvdata(pdev);
352 	int irq = platform_get_irq(pdev, 0);
353 
354 	if (device_may_wakeup(dev))
355 		enable_irq_wake(irq);
356 	else
357 		ske_keypad_set_bits(keypad, SKE_IMSC, ~SKE_KPIMA, 0x0);
358 
359 	return 0;
360 }
361 
362 static int ske_keypad_resume(struct device *dev)
363 {
364 	struct platform_device *pdev = to_platform_device(dev);
365 	struct ske_keypad *keypad = platform_get_drvdata(pdev);
366 	int irq = platform_get_irq(pdev, 0);
367 
368 	if (device_may_wakeup(dev))
369 		disable_irq_wake(irq);
370 	else
371 		ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
372 
373 	return 0;
374 }
375 #endif
376 
377 static SIMPLE_DEV_PM_OPS(ske_keypad_dev_pm_ops,
378 			 ske_keypad_suspend, ske_keypad_resume);
379 
380 static struct platform_driver ske_keypad_driver = {
381 	.driver = {
382 		.name = "nmk-ske-keypad",
383 		.owner  = THIS_MODULE,
384 		.pm = &ske_keypad_dev_pm_ops,
385 	},
386 	.remove = __devexit_p(ske_keypad_remove),
387 };
388 
389 static int __init ske_keypad_init(void)
390 {
391 	return platform_driver_probe(&ske_keypad_driver, ske_keypad_probe);
392 }
393 module_init(ske_keypad_init);
394 
395 static void __exit ske_keypad_exit(void)
396 {
397 	platform_driver_unregister(&ske_keypad_driver);
398 }
399 module_exit(ske_keypad_exit);
400 
401 MODULE_LICENSE("GPL v2");
402 MODULE_AUTHOR("Naveen Kumar <naveen.gaddipati@stericsson.com> / Sundar Iyer <sundar.iyer@stericsson.com>");
403 MODULE_DESCRIPTION("Nomadik Scroll-Key-Encoder Keypad Driver");
404 MODULE_ALIAS("platform:nomadik-ske-keypad");
405