Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6 into for-linus
[linux-2.6] / drivers / input / keyboard / sh_keysc.c
1 /*
2  * SuperH KEYSC Keypad Driver
3  *
4  * Copyright (C) 2008 Magnus Damm
5  *
6  * Based on gpio_keys.c, Copyright 2005 Phil Blundell
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
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/irq.h>
18 #include <linux/delay.h>
19 #include <linux/platform_device.h>
20 #include <linux/input.h>
21 #include <linux/io.h>
22 #include <asm/sh_keysc.h>
23
24 #define KYCR1_OFFS   0x00
25 #define KYCR2_OFFS   0x04
26 #define KYINDR_OFFS  0x08
27 #define KYOUTDR_OFFS 0x0c
28
29 #define KYCR2_IRQ_LEVEL    0x10
30 #define KYCR2_IRQ_DISABLED 0x00
31
32 static const struct {
33         unsigned char kymd, keyout, keyin;
34 } sh_keysc_mode[] = {
35         [SH_KEYSC_MODE_1] = { 0, 6, 5 },
36         [SH_KEYSC_MODE_2] = { 1, 5, 6 },
37         [SH_KEYSC_MODE_3] = { 2, 4, 7 },
38 };
39
40 struct sh_keysc_priv {
41         void __iomem *iomem_base;
42         unsigned long last_keys;
43         struct input_dev *input;
44         struct sh_keysc_info pdata;
45 };
46
47 static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
48 {
49         struct platform_device *pdev = dev_id;
50         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
51         struct sh_keysc_info *pdata = &priv->pdata;
52         unsigned long keys, keys1, keys0, mask;
53         unsigned char keyin_set, tmp;
54         int i, k;
55
56         dev_dbg(&pdev->dev, "isr!\n");
57
58         keys1 = ~0;
59         keys0 = 0;
60
61         do {
62                 keys = 0;
63                 keyin_set = 0;
64
65                 iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
66
67                 for (i = 0; i < sh_keysc_mode[pdata->mode].keyout; i++) {
68                         iowrite16(0xfff ^ (3 << (i * 2)),
69                                   priv->iomem_base + KYOUTDR_OFFS);
70                         udelay(pdata->delay);
71                         tmp = ioread16(priv->iomem_base + KYINDR_OFFS);
72                         keys |= tmp << (sh_keysc_mode[pdata->mode].keyin * i);
73                         tmp ^= (1 << sh_keysc_mode[pdata->mode].keyin) - 1;
74                         keyin_set |= tmp;
75                 }
76
77                 iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
78                 iowrite16(KYCR2_IRQ_LEVEL | (keyin_set << 8),
79                           priv->iomem_base + KYCR2_OFFS);
80
81                 keys ^= ~0;
82                 keys &= (1 << (sh_keysc_mode[pdata->mode].keyin *
83                                sh_keysc_mode[pdata->mode].keyout)) - 1;
84                 keys1 &= keys;
85                 keys0 |= keys;
86
87                 dev_dbg(&pdev->dev, "keys 0x%08lx\n", keys);
88
89         } while (ioread16(priv->iomem_base + KYCR2_OFFS) & 0x01);
90
91         dev_dbg(&pdev->dev, "last_keys 0x%08lx keys0 0x%08lx keys1 0x%08lx\n",
92                 priv->last_keys, keys0, keys1);
93
94         for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
95                 k = pdata->keycodes[i];
96                 if (!k)
97                         continue;
98
99                 mask = 1 << i;
100
101                 if (!((priv->last_keys ^ keys0) & mask))
102                         continue;
103
104                 if ((keys1 | keys0) & mask) {
105                         input_event(priv->input, EV_KEY, k, 1);
106                         priv->last_keys |= mask;
107                 }
108
109                 if (!(keys1 & mask)) {
110                         input_event(priv->input, EV_KEY, k, 0);
111                         priv->last_keys &= ~mask;
112                 }
113
114         }
115         input_sync(priv->input);
116
117         return IRQ_HANDLED;
118 }
119
120 #define res_size(res) ((res)->end - (res)->start + 1)
121
122 static int __devinit sh_keysc_probe(struct platform_device *pdev)
123 {
124         struct sh_keysc_priv *priv;
125         struct sh_keysc_info *pdata;
126         struct resource *res;
127         struct input_dev *input;
128         int i, k;
129         int irq, error;
130
131         if (!pdev->dev.platform_data) {
132                 dev_err(&pdev->dev, "no platform data defined\n");
133                 error = -EINVAL;
134                 goto err0;
135         }
136
137         error = -ENXIO;
138         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
139         if (res == NULL) {
140                 dev_err(&pdev->dev, "failed to get I/O memory\n");
141                 goto err0;
142         }
143
144         irq = platform_get_irq(pdev, 0);
145         if (irq < 0) {
146                 dev_err(&pdev->dev, "failed to get irq\n");
147                 goto err0;
148         }
149
150         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
151         if (priv == NULL) {
152                 dev_err(&pdev->dev, "failed to allocate driver data\n");
153                 error = -ENOMEM;
154                 goto err0;
155         }
156
157         platform_set_drvdata(pdev, priv);
158         memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata));
159         pdata = &priv->pdata;
160
161         res = request_mem_region(res->start, res_size(res), pdev->name);
162         if (res == NULL) {
163                 dev_err(&pdev->dev, "failed to request I/O memory\n");
164                 error = -EBUSY;
165                 goto err1;
166         }
167
168         priv->iomem_base = ioremap_nocache(res->start, res_size(res));
169         if (priv->iomem_base == NULL) {
170                 dev_err(&pdev->dev, "failed to remap I/O memory\n");
171                 error = -ENXIO;
172                 goto err2;
173         }
174
175         priv->input = input_allocate_device();
176         if (!priv->input) {
177                 dev_err(&pdev->dev, "failed to allocate input device\n");
178                 error = -ENOMEM;
179                 goto err3;
180         }
181
182         input = priv->input;
183         input->evbit[0] = BIT_MASK(EV_KEY);
184
185         input->name = pdev->name;
186         input->phys = "sh-keysc-keys/input0";
187         input->dev.parent = &pdev->dev;
188
189         input->id.bustype = BUS_HOST;
190         input->id.vendor = 0x0001;
191         input->id.product = 0x0001;
192         input->id.version = 0x0100;
193
194         error = request_irq(irq, sh_keysc_isr, 0, pdev->name, pdev);
195         if (error) {
196                 dev_err(&pdev->dev, "failed to request IRQ\n");
197                 goto err4;
198         }
199
200         for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
201                 k = pdata->keycodes[i];
202                 if (k)
203                         input_set_capability(input, EV_KEY, k);
204         }
205
206         error = input_register_device(input);
207         if (error) {
208                 dev_err(&pdev->dev, "failed to register input device\n");
209                 goto err5;
210         }
211
212         iowrite16((sh_keysc_mode[pdata->mode].kymd << 8) |
213                   pdata->scan_timing, priv->iomem_base + KYCR1_OFFS);
214         iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
215         iowrite16(KYCR2_IRQ_LEVEL, priv->iomem_base + KYCR2_OFFS);
216         return 0;
217  err5:
218         free_irq(irq, pdev);
219  err4:
220         input_free_device(input);
221  err3:
222         iounmap(priv->iomem_base);
223  err2:
224         release_mem_region(res->start, res_size(res));
225  err1:
226         platform_set_drvdata(pdev, NULL);
227         kfree(priv);
228  err0:
229         return error;
230 }
231
232 static int __devexit sh_keysc_remove(struct platform_device *pdev)
233 {
234         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
235         struct resource *res;
236
237         iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
238
239         input_unregister_device(priv->input);
240         free_irq(platform_get_irq(pdev, 0), pdev);
241         iounmap(priv->iomem_base);
242
243         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
244         release_mem_region(res->start, res_size(res));
245
246         platform_set_drvdata(pdev, NULL);
247         kfree(priv);
248         return 0;
249 }
250
251
252 #define sh_keysc_suspend NULL
253 #define sh_keysc_resume NULL
254
255 struct platform_driver sh_keysc_device_driver = {
256         .probe          = sh_keysc_probe,
257         .remove         = __devexit_p(sh_keysc_remove),
258         .suspend        = sh_keysc_suspend,
259         .resume         = sh_keysc_resume,
260         .driver         = {
261                 .name   = "sh_keysc",
262         }
263 };
264
265 static int __init sh_keysc_init(void)
266 {
267         return platform_driver_register(&sh_keysc_device_driver);
268 }
269
270 static void __exit sh_keysc_exit(void)
271 {
272         platform_driver_unregister(&sh_keysc_device_driver);
273 }
274
275 module_init(sh_keysc_init);
276 module_exit(sh_keysc_exit);
277
278 MODULE_AUTHOR("Magnus Damm");
279 MODULE_DESCRIPTION("SuperH KEYSC Keypad Driver");
280 MODULE_LICENSE("GPL");