Commit | Line | Data |
---|---|---|
88751dd6 MH |
1 | /* |
2 | * File: drivers/input/keyboard/adp5588_keys.c | |
3 | * Description: keypad driver for ADP5588 I2C QWERTY Keypad and IO Expander | |
4 | * Bugs: Enter bugs at http://blackfin.uclinux.org/ | |
5 | * | |
6 | * Copyright (C) 2008-2009 Analog Devices Inc. | |
7 | * Licensed under the GPL-2 or later. | |
8 | */ | |
9 | ||
10 | #include <linux/module.h> | |
11 | #include <linux/version.h> | |
12 | #include <linux/init.h> | |
13 | #include <linux/interrupt.h> | |
14 | #include <linux/irq.h> | |
15 | #include <linux/workqueue.h> | |
16 | #include <linux/errno.h> | |
17 | #include <linux/pm.h> | |
18 | #include <linux/platform_device.h> | |
19 | #include <linux/input.h> | |
20 | #include <linux/i2c.h> | |
21 | ||
22 | #include <linux/i2c/adp5588.h> | |
23 | ||
24 | /* Configuration Register1 */ | |
25 | #define AUTO_INC (1 << 7) | |
26 | #define GPIEM_CFG (1 << 6) | |
27 | #define OVR_FLOW_M (1 << 5) | |
28 | #define INT_CFG (1 << 4) | |
29 | #define OVR_FLOW_IEN (1 << 3) | |
30 | #define K_LCK_IM (1 << 2) | |
31 | #define GPI_IEN (1 << 1) | |
32 | #define KE_IEN (1 << 0) | |
33 | ||
34 | /* Interrupt Status Register */ | |
35 | #define CMP2_INT (1 << 5) | |
36 | #define CMP1_INT (1 << 4) | |
37 | #define OVR_FLOW_INT (1 << 3) | |
38 | #define K_LCK_INT (1 << 2) | |
39 | #define GPI_INT (1 << 1) | |
40 | #define KE_INT (1 << 0) | |
41 | ||
42 | /* Key Lock and Event Counter Register */ | |
43 | #define K_LCK_EN (1 << 6) | |
44 | #define LCK21 0x30 | |
45 | #define KEC 0xF | |
46 | ||
47 | /* Key Event Register xy */ | |
48 | #define KEY_EV_PRESSED (1 << 7) | |
49 | #define KEY_EV_MASK (0x7F) | |
50 | ||
51 | #define KP_SEL(x) (0xFFFF >> (16 - x)) /* 2^x-1 */ | |
52 | ||
53 | #define KEYP_MAX_EVENT 10 | |
54 | ||
55 | /* | |
56 | * Early pre 4.0 Silicon required to delay readout by at least 25ms, | |
57 | * since the Event Counter Register updated 25ms after the interrupt | |
58 | * asserted. | |
59 | */ | |
60 | #define WA_DELAYED_READOUT_REVID(rev) ((rev) < 4) | |
61 | ||
62 | struct adp5588_kpad { | |
63 | struct i2c_client *client; | |
64 | struct input_dev *input; | |
65 | struct delayed_work work; | |
66 | unsigned long delay; | |
67 | unsigned short keycode[ADP5588_KEYMAPSIZE]; | |
68 | }; | |
69 | ||
70 | static int adp5588_read(struct i2c_client *client, u8 reg) | |
71 | { | |
72 | int ret = i2c_smbus_read_byte_data(client, reg); | |
73 | ||
74 | if (ret < 0) | |
75 | dev_err(&client->dev, "Read Error\n"); | |
76 | ||
77 | return ret; | |
78 | } | |
79 | ||
80 | static int adp5588_write(struct i2c_client *client, u8 reg, u8 val) | |
81 | { | |
82 | return i2c_smbus_write_byte_data(client, reg, val); | |
83 | } | |
84 | ||
85 | static void adp5588_work(struct work_struct *work) | |
86 | { | |
87 | struct adp5588_kpad *kpad = container_of(work, | |
88 | struct adp5588_kpad, work.work); | |
89 | struct i2c_client *client = kpad->client; | |
90 | int i, key, status, ev_cnt; | |
91 | ||
92 | status = adp5588_read(client, INT_STAT); | |
93 | ||
94 | if (status & OVR_FLOW_INT) /* Unlikely and should never happen */ | |
95 | dev_err(&client->dev, "Event Overflow Error\n"); | |
96 | ||
97 | if (status & KE_INT) { | |
98 | ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & KEC; | |
99 | if (ev_cnt) { | |
100 | for (i = 0; i < ev_cnt; i++) { | |
101 | key = adp5588_read(client, Key_EVENTA + i); | |
102 | input_report_key(kpad->input, | |
103 | kpad->keycode[(key & KEY_EV_MASK) - 1], | |
104 | key & KEY_EV_PRESSED); | |
105 | } | |
106 | input_sync(kpad->input); | |
107 | } | |
108 | } | |
109 | adp5588_write(client, INT_STAT, status); /* Status is W1C */ | |
110 | } | |
111 | ||
112 | static irqreturn_t adp5588_irq(int irq, void *handle) | |
113 | { | |
114 | struct adp5588_kpad *kpad = handle; | |
115 | ||
116 | /* | |
117 | * use keventd context to read the event fifo registers | |
118 | * Schedule readout at least 25ms after notification for | |
119 | * REVID < 4 | |
120 | */ | |
121 | ||
122 | schedule_delayed_work(&kpad->work, kpad->delay); | |
123 | ||
124 | return IRQ_HANDLED; | |
125 | } | |
126 | ||
127 | static int __devinit adp5588_setup(struct i2c_client *client) | |
128 | { | |
129 | struct adp5588_kpad_platform_data *pdata = client->dev.platform_data; | |
130 | int i, ret; | |
131 | ||
132 | ret = adp5588_write(client, KP_GPIO1, KP_SEL(pdata->rows)); | |
133 | ret |= adp5588_write(client, KP_GPIO2, KP_SEL(pdata->cols) & 0xFF); | |
134 | ret |= adp5588_write(client, KP_GPIO3, KP_SEL(pdata->cols) >> 8); | |
135 | ||
136 | if (pdata->en_keylock) { | |
137 | ret |= adp5588_write(client, UNLOCK1, pdata->unlock_key1); | |
138 | ret |= adp5588_write(client, UNLOCK2, pdata->unlock_key2); | |
139 | ret |= adp5588_write(client, KEY_LCK_EC_STAT, K_LCK_EN); | |
140 | } | |
141 | ||
142 | for (i = 0; i < KEYP_MAX_EVENT; i++) | |
143 | ret |= adp5588_read(client, Key_EVENTA); | |
144 | ||
145 | ret |= adp5588_write(client, INT_STAT, CMP2_INT | CMP1_INT | | |
146 | OVR_FLOW_INT | K_LCK_INT | | |
147 | GPI_INT | KE_INT); /* Status is W1C */ | |
148 | ||
149 | ret |= adp5588_write(client, CFG, INT_CFG | OVR_FLOW_IEN | KE_IEN); | |
150 | ||
151 | if (ret < 0) { | |
152 | dev_err(&client->dev, "Write Error\n"); | |
153 | return ret; | |
154 | } | |
155 | ||
156 | return 0; | |
157 | } | |
158 | ||
159 | static int __devinit adp5588_probe(struct i2c_client *client, | |
160 | const struct i2c_device_id *id) | |
161 | { | |
162 | struct adp5588_kpad *kpad; | |
163 | struct adp5588_kpad_platform_data *pdata = client->dev.platform_data; | |
164 | struct input_dev *input; | |
165 | unsigned int revid; | |
166 | int ret, i; | |
167 | int error; | |
168 | ||
169 | if (!i2c_check_functionality(client->adapter, | |
170 | I2C_FUNC_SMBUS_BYTE_DATA)) { | |
171 | dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); | |
172 | return -EIO; | |
173 | } | |
174 | ||
175 | if (!pdata) { | |
176 | dev_err(&client->dev, "no platform data?\n"); | |
177 | return -EINVAL; | |
178 | } | |
179 | ||
180 | if (!pdata->rows || !pdata->cols || !pdata->keymap) { | |
181 | dev_err(&client->dev, "no rows, cols or keymap from pdata\n"); | |
182 | return -EINVAL; | |
183 | } | |
184 | ||
185 | if (pdata->keymapsize != ADP5588_KEYMAPSIZE) { | |
186 | dev_err(&client->dev, "invalid keymapsize\n"); | |
187 | return -EINVAL; | |
188 | } | |
189 | ||
190 | if (!client->irq) { | |
191 | dev_err(&client->dev, "no IRQ?\n"); | |
192 | return -EINVAL; | |
193 | } | |
194 | ||
195 | kpad = kzalloc(sizeof(*kpad), GFP_KERNEL); | |
196 | input = input_allocate_device(); | |
197 | if (!kpad || !input) { | |
198 | error = -ENOMEM; | |
199 | goto err_free_mem; | |
200 | } | |
201 | ||
202 | kpad->client = client; | |
203 | kpad->input = input; | |
204 | INIT_DELAYED_WORK(&kpad->work, adp5588_work); | |
205 | ||
206 | ret = adp5588_read(client, DEV_ID); | |
207 | if (ret < 0) { | |
208 | error = ret; | |
209 | goto err_free_mem; | |
210 | } | |
211 | ||
212 | revid = (u8) ret & ADP5588_DEVICE_ID_MASK; | |
213 | if (WA_DELAYED_READOUT_REVID(revid)) | |
214 | kpad->delay = msecs_to_jiffies(30); | |
215 | ||
216 | input->name = client->name; | |
217 | input->phys = "adp5588-keys/input0"; | |
218 | input->dev.parent = &client->dev; | |
219 | ||
220 | input_set_drvdata(input, kpad); | |
221 | ||
222 | input->id.bustype = BUS_I2C; | |
223 | input->id.vendor = 0x0001; | |
224 | input->id.product = 0x0001; | |
225 | input->id.version = revid; | |
226 | ||
227 | input->keycodesize = sizeof(kpad->keycode[0]); | |
228 | input->keycodemax = pdata->keymapsize; | |
229 | input->keycode = kpad->keycode; | |
230 | ||
231 | memcpy(kpad->keycode, pdata->keymap, | |
232 | pdata->keymapsize * input->keycodesize); | |
233 | ||
234 | /* setup input device */ | |
235 | __set_bit(EV_KEY, input->evbit); | |
236 | ||
237 | if (pdata->repeat) | |
238 | __set_bit(EV_REP, input->evbit); | |
239 | ||
240 | for (i = 0; i < input->keycodemax; i++) | |
241 | __set_bit(kpad->keycode[i] & KEY_MAX, input->keybit); | |
242 | __clear_bit(KEY_RESERVED, input->keybit); | |
243 | ||
244 | error = input_register_device(input); | |
245 | if (error) { | |
246 | dev_err(&client->dev, "unable to register input device\n"); | |
247 | goto err_free_mem; | |
248 | } | |
249 | ||
250 | error = request_irq(client->irq, adp5588_irq, | |
251 | IRQF_TRIGGER_FALLING | IRQF_DISABLED, | |
252 | client->dev.driver->name, kpad); | |
253 | if (error) { | |
254 | dev_err(&client->dev, "irq %d busy?\n", client->irq); | |
255 | goto err_unreg_dev; | |
256 | } | |
257 | ||
258 | error = adp5588_setup(client); | |
259 | if (error) | |
260 | goto err_free_irq; | |
261 | ||
262 | device_init_wakeup(&client->dev, 1); | |
263 | i2c_set_clientdata(client, kpad); | |
264 | ||
265 | dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq); | |
266 | return 0; | |
267 | ||
268 | err_free_irq: | |
269 | free_irq(client->irq, kpad); | |
270 | err_unreg_dev: | |
271 | input_unregister_device(input); | |
272 | input = NULL; | |
273 | err_free_mem: | |
274 | input_free_device(input); | |
275 | kfree(kpad); | |
276 | ||
277 | return error; | |
278 | } | |
279 | ||
280 | static int __devexit adp5588_remove(struct i2c_client *client) | |
281 | { | |
282 | struct adp5588_kpad *kpad = i2c_get_clientdata(client); | |
283 | ||
284 | adp5588_write(client, CFG, 0); | |
285 | free_irq(client->irq, kpad); | |
286 | cancel_delayed_work_sync(&kpad->work); | |
287 | input_unregister_device(kpad->input); | |
288 | i2c_set_clientdata(client, NULL); | |
289 | kfree(kpad); | |
290 | ||
291 | return 0; | |
292 | } | |
293 | ||
294 | #ifdef CONFIG_PM | |
295 | static int adp5588_suspend(struct device *dev) | |
296 | { | |
297 | struct adp5588_kpad *kpad = dev_get_drvdata(dev); | |
298 | struct i2c_client *client = kpad->client; | |
299 | ||
300 | disable_irq(client->irq); | |
301 | cancel_delayed_work_sync(&kpad->work); | |
302 | ||
303 | if (device_may_wakeup(&client->dev)) | |
304 | enable_irq_wake(client->irq); | |
305 | ||
306 | return 0; | |
307 | } | |
308 | ||
309 | static int adp5588_resume(struct device *dev) | |
310 | { | |
311 | struct adp5588_kpad *kpad = dev_get_drvdata(dev); | |
312 | struct i2c_client *client = kpad->client; | |
313 | ||
314 | if (device_may_wakeup(&client->dev)) | |
315 | disable_irq_wake(client->irq); | |
316 | ||
317 | enable_irq(client->irq); | |
318 | ||
319 | return 0; | |
320 | } | |
321 | ||
47145210 | 322 | static const struct dev_pm_ops adp5588_dev_pm_ops = { |
88751dd6 MH |
323 | .suspend = adp5588_suspend, |
324 | .resume = adp5588_resume, | |
325 | }; | |
326 | #endif | |
327 | ||
328 | static const struct i2c_device_id adp5588_id[] = { | |
329 | { KBUILD_MODNAME, 0 }, | |
330 | { } | |
331 | }; | |
332 | MODULE_DEVICE_TABLE(i2c, adp5588_id); | |
333 | ||
334 | static struct i2c_driver adp5588_driver = { | |
335 | .driver = { | |
336 | .name = KBUILD_MODNAME, | |
337 | #ifdef CONFIG_PM | |
338 | .pm = &adp5588_dev_pm_ops, | |
339 | #endif | |
340 | }, | |
341 | .probe = adp5588_probe, | |
342 | .remove = __devexit_p(adp5588_remove), | |
343 | .id_table = adp5588_id, | |
344 | }; | |
345 | ||
346 | static int __init adp5588_init(void) | |
347 | { | |
348 | return i2c_add_driver(&adp5588_driver); | |
349 | } | |
350 | module_init(adp5588_init); | |
351 | ||
352 | static void __exit adp5588_exit(void) | |
353 | { | |
354 | i2c_del_driver(&adp5588_driver); | |
355 | } | |
356 | module_exit(adp5588_exit); | |
357 | ||
358 | MODULE_LICENSE("GPL"); | |
359 | MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); | |
360 | MODULE_DESCRIPTION("ADP5588 Keypad driver"); | |
361 | MODULE_ALIAS("platform:adp5588-keys"); |