1/*
2 * File:         drivers/input/keyboard/bf54x-keys.c
3 * Based on:
4 * Author:       Michael Hennerich <hennerich@blackfin.uclinux.org>
5 *
6 * Created:
7 * Description:  keypad driver for Analog Devices Blackfin BF54x Processors
8 *
9 *
10 * Modified:
11 *               Copyright 2007-2008 Analog Devices Inc.
12 *
13 * Bugs:         Enter bugs at http://blackfin.uclinux.org/
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see the file COPYING, or write
27 * to the Free Software Foundation, Inc.,
28 * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
29 */
30
31#include <linux/module.h>
32
33#include <linux/fs.h>
34#include <linux/interrupt.h>
35#include <linux/irq.h>
36#include <linux/slab.h>
37#include <linux/sched.h>
38#include <linux/pm.h>
39#include <linux/sysctl.h>
40#include <linux/proc_fs.h>
41#include <linux/delay.h>
42#include <linux/platform_device.h>
43#include <linux/input.h>
44
45#include <asm/portmux.h>
46#include <mach/bf54x_keys.h>
47
48#define DRV_NAME	"bf54x-keys"
49#define TIME_SCALE	100	/* 100 ns */
50#define	MAX_MULT	(0xFF * TIME_SCALE)
51#define MAX_RC		8	/* Max Row/Col */
52
53static const u16 per_rows[] = {
54	P_KEY_ROW7,
55	P_KEY_ROW6,
56	P_KEY_ROW5,
57	P_KEY_ROW4,
58	P_KEY_ROW3,
59	P_KEY_ROW2,
60	P_KEY_ROW1,
61	P_KEY_ROW0,
62	0
63};
64
65static const u16 per_cols[] = {
66	P_KEY_COL7,
67	P_KEY_COL6,
68	P_KEY_COL5,
69	P_KEY_COL4,
70	P_KEY_COL3,
71	P_KEY_COL2,
72	P_KEY_COL1,
73	P_KEY_COL0,
74	0
75};
76
77struct bf54x_kpad {
78	struct input_dev *input;
79	int irq;
80	unsigned short lastkey;
81	unsigned short *keycode;
82	struct timer_list timer;
83	unsigned int keyup_test_jiffies;
84	unsigned short kpad_msel;
85	unsigned short kpad_prescale;
86	unsigned short kpad_ctl;
87};
88
89static inline int bfin_kpad_find_key(struct bf54x_kpad *bf54x_kpad,
90			struct input_dev *input, u16 keyident)
91{
92	u16 i;
93
94	for (i = 0; i < input->keycodemax; i++)
95		if (bf54x_kpad->keycode[i + input->keycodemax] == keyident)
96			return bf54x_kpad->keycode[i];
97	return -1;
98}
99
100static inline void bfin_keycodecpy(unsigned short *keycode,
101			const unsigned int *pdata_kc,
102			unsigned short keymapsize)
103{
104	unsigned int i;
105
106	for (i = 0; i < keymapsize; i++) {
107		keycode[i] = pdata_kc[i] & 0xffff;
108		keycode[i + keymapsize] = pdata_kc[i] >> 16;
109	}
110}
111
112static inline u16 bfin_kpad_get_prescale(u32 timescale)
113{
114	u32 sclk = get_sclk();
115
116	return ((((sclk / 1000) * timescale) / 1024) - 1);
117}
118
119static inline u16 bfin_kpad_get_keypressed(struct bf54x_kpad *bf54x_kpad)
120{
121	return (bfin_read_KPAD_STAT() & KPAD_PRESSED);
122}
123
124static inline void bfin_kpad_clear_irq(void)
125{
126	bfin_write_KPAD_STAT(0xFFFF);
127	bfin_write_KPAD_ROWCOL(0xFFFF);
128}
129
130static void bfin_kpad_timer(unsigned long data)
131{
132	struct platform_device *pdev =  (struct platform_device *) data;
133	struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
134
135	if (bfin_kpad_get_keypressed(bf54x_kpad)) {
136		/* Try again later */
137		mod_timer(&bf54x_kpad->timer,
138			  jiffies + bf54x_kpad->keyup_test_jiffies);
139		return;
140	}
141
142	input_report_key(bf54x_kpad->input, bf54x_kpad->lastkey, 0);
143	input_sync(bf54x_kpad->input);
144
145	/* Clear IRQ Status */
146
147	bfin_kpad_clear_irq();
148	enable_irq(bf54x_kpad->irq);
149}
150
151static irqreturn_t bfin_kpad_isr(int irq, void *dev_id)
152{
153	struct platform_device *pdev = dev_id;
154	struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
155	struct input_dev *input = bf54x_kpad->input;
156	int key;
157	u16 rowcol = bfin_read_KPAD_ROWCOL();
158
159	key = bfin_kpad_find_key(bf54x_kpad, input, rowcol);
160
161	input_report_key(input, key, 1);
162	input_sync(input);
163
164	if (bfin_kpad_get_keypressed(bf54x_kpad)) {
165		disable_irq_nosync(bf54x_kpad->irq);
166		bf54x_kpad->lastkey = key;
167		mod_timer(&bf54x_kpad->timer,
168			  jiffies + bf54x_kpad->keyup_test_jiffies);
169	} else {
170		input_report_key(input, key, 0);
171		input_sync(input);
172
173		bfin_kpad_clear_irq();
174	}
175
176	return IRQ_HANDLED;
177}
178
179static int bfin_kpad_probe(struct platform_device *pdev)
180{
181	struct bf54x_kpad *bf54x_kpad;
182	struct bfin_kpad_platform_data *pdata = dev_get_platdata(&pdev->dev);
183	struct input_dev *input;
184	int i, error;
185
186	if (!pdata->rows || !pdata->cols || !pdata->keymap) {
187		dev_err(&pdev->dev, "no rows, cols or keymap from pdata\n");
188		return -EINVAL;
189	}
190
191	if (!pdata->keymapsize ||
192	    pdata->keymapsize > (pdata->rows * pdata->cols)) {
193		dev_err(&pdev->dev, "invalid keymapsize\n");
194		return -EINVAL;
195	}
196
197	bf54x_kpad = kzalloc(sizeof(struct bf54x_kpad), GFP_KERNEL);
198	if (!bf54x_kpad)
199		return -ENOMEM;
200
201	platform_set_drvdata(pdev, bf54x_kpad);
202
203	/* Allocate memory for keymap followed by private LUT */
204	bf54x_kpad->keycode = kmalloc(pdata->keymapsize *
205					sizeof(unsigned short) * 2, GFP_KERNEL);
206	if (!bf54x_kpad->keycode) {
207		error = -ENOMEM;
208		goto out;
209	}
210
211	if (!pdata->debounce_time || pdata->debounce_time > MAX_MULT ||
212	    !pdata->coldrive_time || pdata->coldrive_time > MAX_MULT) {
213		dev_warn(&pdev->dev,
214			"invalid platform debounce/columndrive time\n");
215		bfin_write_KPAD_MSEL(0xFF0);	/* Default MSEL	*/
216	} else {
217		bfin_write_KPAD_MSEL(
218			((pdata->debounce_time / TIME_SCALE)
219						& DBON_SCALE) |
220			(((pdata->coldrive_time / TIME_SCALE) << 8)
221						& COLDRV_SCALE));
222
223	}
224
225	if (!pdata->keyup_test_interval)
226		bf54x_kpad->keyup_test_jiffies = msecs_to_jiffies(50);
227	else
228		bf54x_kpad->keyup_test_jiffies =
229			msecs_to_jiffies(pdata->keyup_test_interval);
230
231	if (peripheral_request_list((u16 *)&per_rows[MAX_RC - pdata->rows],
232				    DRV_NAME)) {
233		dev_err(&pdev->dev, "requesting peripherals failed\n");
234		error = -EFAULT;
235		goto out0;
236	}
237
238	if (peripheral_request_list((u16 *)&per_cols[MAX_RC - pdata->cols],
239				    DRV_NAME)) {
240		dev_err(&pdev->dev, "requesting peripherals failed\n");
241		error = -EFAULT;
242		goto out1;
243	}
244
245	bf54x_kpad->irq = platform_get_irq(pdev, 0);
246	if (bf54x_kpad->irq < 0) {
247		error = -ENODEV;
248		goto out2;
249	}
250
251	error = request_irq(bf54x_kpad->irq, bfin_kpad_isr,
252				0, DRV_NAME, pdev);
253	if (error) {
254		dev_err(&pdev->dev, "unable to claim irq %d\n",
255			bf54x_kpad->irq);
256		goto out2;
257	}
258
259	input = input_allocate_device();
260	if (!input) {
261		error = -ENOMEM;
262		goto out3;
263	}
264
265	bf54x_kpad->input = input;
266
267	input->name = pdev->name;
268	input->phys = "bf54x-keys/input0";
269	input->dev.parent = &pdev->dev;
270
271	input_set_drvdata(input, bf54x_kpad);
272
273	input->id.bustype = BUS_HOST;
274	input->id.vendor = 0x0001;
275	input->id.product = 0x0001;
276	input->id.version = 0x0100;
277
278	input->keycodesize = sizeof(unsigned short);
279	input->keycodemax = pdata->keymapsize;
280	input->keycode = bf54x_kpad->keycode;
281
282	bfin_keycodecpy(bf54x_kpad->keycode, pdata->keymap, pdata->keymapsize);
283
284	/* setup input device */
285	__set_bit(EV_KEY, input->evbit);
286
287	if (pdata->repeat)
288		__set_bit(EV_REP, input->evbit);
289
290	for (i = 0; i < input->keycodemax; i++)
291		if (bf54x_kpad->keycode[i] <= KEY_MAX)
292			__set_bit(bf54x_kpad->keycode[i], input->keybit);
293	__clear_bit(KEY_RESERVED, input->keybit);
294
295	error = input_register_device(input);
296	if (error) {
297		dev_err(&pdev->dev, "unable to register input device\n");
298		goto out4;
299	}
300
301	/* Init Keypad Key Up/Release test timer */
302
303	setup_timer(&bf54x_kpad->timer, bfin_kpad_timer, (unsigned long) pdev);
304
305	bfin_write_KPAD_PRESCALE(bfin_kpad_get_prescale(TIME_SCALE));
306
307	bfin_write_KPAD_CTL((((pdata->cols - 1) << 13) & KPAD_COLEN) |
308				(((pdata->rows - 1) << 10) & KPAD_ROWEN) |
309				(2 & KPAD_IRQMODE));
310
311	bfin_write_KPAD_CTL(bfin_read_KPAD_CTL() | KPAD_EN);
312
313	device_init_wakeup(&pdev->dev, 1);
314
315	return 0;
316
317out4:
318	input_free_device(input);
319out3:
320	free_irq(bf54x_kpad->irq, pdev);
321out2:
322	peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
323out1:
324	peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
325out0:
326	kfree(bf54x_kpad->keycode);
327out:
328	kfree(bf54x_kpad);
329
330	return error;
331}
332
333static int bfin_kpad_remove(struct platform_device *pdev)
334{
335	struct bfin_kpad_platform_data *pdata = dev_get_platdata(&pdev->dev);
336	struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
337
338	del_timer_sync(&bf54x_kpad->timer);
339	free_irq(bf54x_kpad->irq, pdev);
340
341	input_unregister_device(bf54x_kpad->input);
342
343	peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
344	peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
345
346	kfree(bf54x_kpad->keycode);
347	kfree(bf54x_kpad);
348
349	return 0;
350}
351
352#ifdef CONFIG_PM
353static int bfin_kpad_suspend(struct platform_device *pdev, pm_message_t state)
354{
355	struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
356
357	bf54x_kpad->kpad_msel = bfin_read_KPAD_MSEL();
358	bf54x_kpad->kpad_prescale = bfin_read_KPAD_PRESCALE();
359	bf54x_kpad->kpad_ctl = bfin_read_KPAD_CTL();
360
361	if (device_may_wakeup(&pdev->dev))
362		enable_irq_wake(bf54x_kpad->irq);
363
364	return 0;
365}
366
367static int bfin_kpad_resume(struct platform_device *pdev)
368{
369	struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
370
371	bfin_write_KPAD_MSEL(bf54x_kpad->kpad_msel);
372	bfin_write_KPAD_PRESCALE(bf54x_kpad->kpad_prescale);
373	bfin_write_KPAD_CTL(bf54x_kpad->kpad_ctl);
374
375	if (device_may_wakeup(&pdev->dev))
376		disable_irq_wake(bf54x_kpad->irq);
377
378	return 0;
379}
380#else
381# define bfin_kpad_suspend NULL
382# define bfin_kpad_resume  NULL
383#endif
384
385static struct platform_driver bfin_kpad_device_driver = {
386	.driver		= {
387		.name	= DRV_NAME,
388	},
389	.probe		= bfin_kpad_probe,
390	.remove		= bfin_kpad_remove,
391	.suspend	= bfin_kpad_suspend,
392	.resume		= bfin_kpad_resume,
393};
394module_platform_driver(bfin_kpad_device_driver);
395
396MODULE_LICENSE("GPL");
397MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
398MODULE_DESCRIPTION("Keypad driver for BF54x Processors");
399MODULE_ALIAS("platform:bf54x-keys");
400