projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Input: alps - v7: ignore new packets
[deliverable/linux.git] / drivers / input / keyboard / adp5588-keys.c
1 /*
2 * File: drivers/input/keyboard/adp5588_keys.c
3 * Description: keypad driver for ADP5588 and ADP5587
4 * I2C QWERTY Keypad and IO Expander
5 * Bugs: Enter bugs at http://blackfin.uclinux.org/
6 *
7 * Copyright (C) 2008-2010 Analog Devices Inc.
8 * Licensed under the GPL-2 or later.
9 */
10
11 #include <linux/module.h>
12 #include <linux/interrupt.h>
13 #include <linux/irq.h>
14 #include <linux/workqueue.h>
15 #include <linux/errno.h>
16 #include <linux/pm.h>
17 #include <linux/platform_device.h>
18 #include <linux/input.h>
19 #include <linux/i2c.h>
20 #include <linux/gpio.h>
21 #include <linux/slab.h>
22
23 #include <linux/i2c/adp5588.h>
24
25 /* Key Event Register xy */
26 #define KEY_EV_PRESSED (1 << 7)
27 #define KEY_EV_MASK (0x7F)
28
29 #define KP_SEL(x) (0xFFFF >> (16 - x)) /* 2^x-1 */
30
31 #define KEYP_MAX_EVENT 10
32
33 /*
34 * Early pre 4.0 Silicon required to delay readout by at least 25ms,
35 * since the Event Counter Register updated 25ms after the interrupt
36 * asserted.
37 */
38 #define WA_DELAYED_READOUT_REVID(rev) ((rev) < 4)
39
40 struct adp5588_kpad {
41 struct i2c_client *client;
42 struct input_dev *input;
43 struct delayed_work work;
44 unsigned long delay;
45 unsigned short keycode[ADP5588_KEYMAPSIZE];
46 const struct adp5588_gpi_map *gpimap;
47 unsigned short gpimapsize;
48 #ifdef CONFIG_GPIOLIB
49 unsigned char gpiomap[ADP5588_MAXGPIO];
50 bool export_gpio;
51 struct gpio_chip gc;
52 struct mutex gpio_lock; /* Protect cached dir, dat_out */
53 u8 dat_out[3];
54 u8 dir[3];
55 #endif
56 };
57
58 static int adp5588_read(struct i2c_client *client, u8 reg)
59 {
60 int ret = i2c_smbus_read_byte_data(client, reg);
61
62 if (ret < 0)
63 dev_err(&client->dev, "Read Error\n");
64
65 return ret;
66 }
67
68 static int adp5588_write(struct i2c_client *client, u8 reg, u8 val)
69 {
70 return i2c_smbus_write_byte_data(client, reg, val);
71 }
72
73 #ifdef CONFIG_GPIOLIB
74 static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
75 {
76 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
77 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
78 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
79 int val;
80
81 mutex_lock(&kpad->gpio_lock);
82
83 if (kpad->dir[bank] & bit)
84 val = kpad->dat_out[bank];
85 else
86 val = adp5588_read(kpad->client, GPIO_DAT_STAT1 + bank);
87
88 mutex_unlock(&kpad->gpio_lock);
89
90 return !!(val & bit);
91 }
92
93 static void adp5588_gpio_set_value(struct gpio_chip *chip,
94 unsigned off, int val)
95 {
96 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
97 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
98 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
99
100 mutex_lock(&kpad->gpio_lock);
101
102 if (val)
103 kpad->dat_out[bank] |= bit;
104 else
105 kpad->dat_out[bank] &= ~bit;
106
107 adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank,
108 kpad->dat_out[bank]);
109
110 mutex_unlock(&kpad->gpio_lock);
111 }
112
113 static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
114 {
115 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
116 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
117 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
118 int ret;
119
120 mutex_lock(&kpad->gpio_lock);
121
122 kpad->dir[bank] &= ~bit;
123 ret = adp5588_write(kpad->client, GPIO_DIR1 + bank, kpad->dir[bank]);
124
125 mutex_unlock(&kpad->gpio_lock);
126
127 return ret;
128 }
129
130 static int adp5588_gpio_direction_output(struct gpio_chip *chip,
131 unsigned off, int val)
132 {
133 struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
134 unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
135 unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
136 int ret;
137
138 mutex_lock(&kpad->gpio_lock);
139
140 kpad->dir[bank] |= bit;
141
142 if (val)
143 kpad->dat_out[bank] |= bit;
144 else
145 kpad->dat_out[bank] &= ~bit;
146
147 ret = adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank,
148 kpad->dat_out[bank]);
149 ret |= adp5588_write(kpad->client, GPIO_DIR1 + bank,
150 kpad->dir[bank]);
151
152 mutex_unlock(&kpad->gpio_lock);
153
154 return ret;
155 }
156
157 static int adp5588_build_gpiomap(struct adp5588_kpad *kpad,
158 const struct adp5588_kpad_platform_data *pdata)
159 {
160 bool pin_used[ADP5588_MAXGPIO];
161 int n_unused = 0;
162 int i;
163
164 memset(pin_used, 0, sizeof(pin_used));
165
166 for (i = 0; i < pdata->rows; i++)
167 pin_used[i] = true;
168
169 for (i = 0; i < pdata->cols; i++)
170 pin_used[i + GPI_PIN_COL_BASE - GPI_PIN_BASE] = true;
171
172 for (i = 0; i < kpad->gpimapsize; i++)
173 pin_used[kpad->gpimap[i].pin - GPI_PIN_BASE] = true;
174
175 for (i = 0; i < ADP5588_MAXGPIO; i++)
176 if (!pin_used[i])
177 kpad->gpiomap[n_unused++] = i;
178
179 return n_unused;
180 }
181
182 static int adp5588_gpio_add(struct adp5588_kpad *kpad)
183 {
184 struct device *dev = &kpad->client->dev;
185 const struct adp5588_kpad_platform_data *pdata = dev_get_platdata(dev);
186 const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data;
187 int i, error;
188
189 if (!gpio_data)
190 return 0;
191
192 kpad->gc.ngpio = adp5588_build_gpiomap(kpad, pdata);
193 if (kpad->gc.ngpio == 0) {
194 dev_info(dev, "No unused gpios left to export\n");
195 return 0;
196 }
197
198 kpad->export_gpio = true;
199
200 kpad->gc.direction_input = adp5588_gpio_direction_input;
201 kpad->gc.direction_output = adp5588_gpio_direction_output;
202 kpad->gc.get = adp5588_gpio_get_value;
203 kpad->gc.set = adp5588_gpio_set_value;
204 kpad->gc.can_sleep = 1;
205
206 kpad->gc.base = gpio_data->gpio_start;
207 kpad->gc.label = kpad->client->name;
208 kpad->gc.owner = THIS_MODULE;
209 kpad->gc.names = gpio_data->names;
210
211 mutex_init(&kpad->gpio_lock);
212
213 error = gpiochip_add(&kpad->gc);
214 if (error) {
215 dev_err(dev, "gpiochip_add failed, err: %d\n", error);
216 return error;
217 }
218
219 for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
220 kpad->dat_out[i] = adp5588_read(kpad->client,
221 GPIO_DAT_OUT1 + i);
222 kpad->dir[i] = adp5588_read(kpad->client, GPIO_DIR1 + i);
223 }
224
225 if (gpio_data->setup) {
226 error = gpio_data->setup(kpad->client,
227 kpad->gc.base, kpad->gc.ngpio,
228 gpio_data->context);
229 if (error)
230 dev_warn(dev, "setup failed, %d\n", error);
231 }
232
233 return 0;
234 }
235
236 static void adp5588_gpio_remove(struct adp5588_kpad *kpad)
237 {
238 struct device *dev = &kpad->client->dev;
239 const struct adp5588_kpad_platform_data *pdata = dev_get_platdata(dev);
240 const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data;
241 int error;
242
243 if (!kpad->export_gpio)
244 return;
245
246 if (gpio_data->teardown) {
247 error = gpio_data->teardown(kpad->client,
248 kpad->gc.base, kpad->gc.ngpio,
249 gpio_data->context);
250 if (error)
251 dev_warn(dev, "teardown failed %d\n", error);
252 }
253
254 error = gpiochip_remove(&kpad->gc);
255 if (error)
256 dev_warn(dev, "gpiochip_remove failed %d\n", error);
257 }
258 #else
259 static inline int adp5588_gpio_add(struct adp5588_kpad *kpad)
260 {
261 return 0;
262 }
263
264 static inline void adp5588_gpio_remove(struct adp5588_kpad *kpad)
265 {
266 }
267 #endif
268
269 static void adp5588_report_events(struct adp5588_kpad *kpad, int ev_cnt)
270 {
271 int i, j;
272
273 for (i = 0; i < ev_cnt; i++) {
274 int key = adp5588_read(kpad->client, Key_EVENTA + i);
275 int key_val = key & KEY_EV_MASK;
276
277 if (key_val >= GPI_PIN_BASE && key_val <= GPI_PIN_END) {
278 for (j = 0; j < kpad->gpimapsize; j++) {
279 if (key_val == kpad->gpimap[j].pin) {
280 input_report_switch(kpad->input,
281 kpad->gpimap[j].sw_evt,
282 key & KEY_EV_PRESSED);
283 break;
284 }
285 }
286 } else {
287 input_report_key(kpad->input,
288 kpad->keycode[key_val - 1],
289 key & KEY_EV_PRESSED);
290 }
291 }
292 }
293
294 static void adp5588_work(struct work_struct *work)
295 {
296 struct adp5588_kpad *kpad = container_of(work,
297 struct adp5588_kpad, work.work);
298 struct i2c_client *client = kpad->client;
299 int status, ev_cnt;
300
301 status = adp5588_read(client, INT_STAT);
302
303 if (status & ADP5588_OVR_FLOW_INT) /* Unlikely and should never happen */
304 dev_err(&client->dev, "Event Overflow Error\n");
305
306 if (status & ADP5588_KE_INT) {
307 ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & ADP5588_KEC;
308 if (ev_cnt) {
309 adp5588_report_events(kpad, ev_cnt);
310 input_sync(kpad->input);
311 }
312 }
313 adp5588_write(client, INT_STAT, status); /* Status is W1C */
314 }
315
316 static irqreturn_t adp5588_irq(int irq, void *handle)
317 {
318 struct adp5588_kpad *kpad = handle;
319
320 /*
321 * use keventd context to read the event fifo registers
322 * Schedule readout at least 25ms after notification for
323 * REVID < 4
324 */
325
326 schedule_delayed_work(&kpad->work, kpad->delay);
327
328 return IRQ_HANDLED;
329 }
330
331 static int adp5588_setup(struct i2c_client *client)
332 {
333 const struct adp5588_kpad_platform_data *pdata =
334 dev_get_platdata(&client->dev);
335 const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data;
336 int i, ret;
337 unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
338
339 ret = adp5588_write(client, KP_GPIO1, KP_SEL(pdata->rows));
340 ret |= adp5588_write(client, KP_GPIO2, KP_SEL(pdata->cols) & 0xFF);
341 ret |= adp5588_write(client, KP_GPIO3, KP_SEL(pdata->cols) >> 8);
342
343 if (pdata->en_keylock) {
344 ret |= adp5588_write(client, UNLOCK1, pdata->unlock_key1);
345 ret |= adp5588_write(client, UNLOCK2, pdata->unlock_key2);
346 ret |= adp5588_write(client, KEY_LCK_EC_STAT, ADP5588_K_LCK_EN);
347 }
348
349 for (i = 0; i < KEYP_MAX_EVENT; i++)
350 ret |= adp5588_read(client, Key_EVENTA);
351
352 for (i = 0; i < pdata->gpimapsize; i++) {
353 unsigned short pin = pdata->gpimap[i].pin;
354
355 if (pin <= GPI_PIN_ROW_END) {
356 evt_mode1 |= (1 << (pin - GPI_PIN_ROW_BASE));
357 } else {
358 evt_mode2 |= ((1 << (pin - GPI_PIN_COL_BASE)) & 0xFF);
359 evt_mode3 |= ((1 << (pin - GPI_PIN_COL_BASE)) >> 8);
360 }
361 }
362
363 if (pdata->gpimapsize) {
364 ret |= adp5588_write(client, GPI_EM1, evt_mode1);
365 ret |= adp5588_write(client, GPI_EM2, evt_mode2);
366 ret |= adp5588_write(client, GPI_EM3, evt_mode3);
367 }
368
369 if (gpio_data) {
370 for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
371 int pull_mask = gpio_data->pullup_dis_mask;
372
373 ret |= adp5588_write(client, GPIO_PULL1 + i,
374 (pull_mask >> (8 * i)) & 0xFF);
375 }
376 }
377
378 ret |= adp5588_write(client, INT_STAT,
379 ADP5588_CMP2_INT | ADP5588_CMP1_INT |
380 ADP5588_OVR_FLOW_INT | ADP5588_K_LCK_INT |
381 ADP5588_GPI_INT | ADP5588_KE_INT); /* Status is W1C */
382
383 ret |= adp5588_write(client, CFG, ADP5588_INT_CFG |
384 ADP5588_OVR_FLOW_IEN |
385 ADP5588_KE_IEN);
386
387 if (ret < 0) {
388 dev_err(&client->dev, "Write Error\n");
389 return ret;
390 }
391
392 return 0;
393 }
394
395 static void adp5588_report_switch_state(struct adp5588_kpad *kpad)
396 {
397 int gpi_stat1 = adp5588_read(kpad->client, GPIO_DAT_STAT1);
398 int gpi_stat2 = adp5588_read(kpad->client, GPIO_DAT_STAT2);
399 int gpi_stat3 = adp5588_read(kpad->client, GPIO_DAT_STAT3);
400 int gpi_stat_tmp, pin_loc;
401 int i;
402
403 for (i = 0; i < kpad->gpimapsize; i++) {
404 unsigned short pin = kpad->gpimap[i].pin;
405
406 if (pin <= GPI_PIN_ROW_END) {
407 gpi_stat_tmp = gpi_stat1;
408 pin_loc = pin - GPI_PIN_ROW_BASE;
409 } else if ((pin - GPI_PIN_COL_BASE) < 8) {
410 gpi_stat_tmp = gpi_stat2;
411 pin_loc = pin - GPI_PIN_COL_BASE;
412 } else {
413 gpi_stat_tmp = gpi_stat3;
414 pin_loc = pin - GPI_PIN_COL_BASE - 8;
415 }
416
417 if (gpi_stat_tmp < 0) {
418 dev_err(&kpad->client->dev,
419 "Can't read GPIO_DAT_STAT switch %d default to OFF\n",
420 pin);
421 gpi_stat_tmp = 0;
422 }
423
424 input_report_switch(kpad->input,
425 kpad->gpimap[i].sw_evt,
426 !(gpi_stat_tmp & (1 << pin_loc)));
427 }
428
429 input_sync(kpad->input);
430 }
431
432
433 static int adp5588_probe(struct i2c_client *client,
434 const struct i2c_device_id *id)
435 {
436 struct adp5588_kpad *kpad;
437 const struct adp5588_kpad_platform_data *pdata =
438 dev_get_platdata(&client->dev);
439 struct input_dev *input;
440 unsigned int revid;
441 int ret, i;
442 int error;
443
444 if (!i2c_check_functionality(client->adapter,
445 I2C_FUNC_SMBUS_BYTE_DATA)) {
446 dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
447 return -EIO;
448 }
449
450 if (!pdata) {
451 dev_err(&client->dev, "no platform data?\n");
452 return -EINVAL;
453 }
454
455 if (!pdata->rows || !pdata->cols || !pdata->keymap) {
456 dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
457 return -EINVAL;
458 }
459
460 if (pdata->keymapsize != ADP5588_KEYMAPSIZE) {
461 dev_err(&client->dev, "invalid keymapsize\n");
462 return -EINVAL;
463 }
464
465 if (!pdata->gpimap && pdata->gpimapsize) {
466 dev_err(&client->dev, "invalid gpimap from pdata\n");
467 return -EINVAL;
468 }
469
470 if (pdata->gpimapsize > ADP5588_GPIMAPSIZE_MAX) {
471 dev_err(&client->dev, "invalid gpimapsize\n");
472 return -EINVAL;
473 }
474
475 for (i = 0; i < pdata->gpimapsize; i++) {
476 unsigned short pin = pdata->gpimap[i].pin;
477
478 if (pin < GPI_PIN_BASE || pin > GPI_PIN_END) {
479 dev_err(&client->dev, "invalid gpi pin data\n");
480 return -EINVAL;
481 }
482
483 if (pin <= GPI_PIN_ROW_END) {
484 if (pin - GPI_PIN_ROW_BASE + 1 <= pdata->rows) {
485 dev_err(&client->dev, "invalid gpi row data\n");
486 return -EINVAL;
487 }
488 } else {
489 if (pin - GPI_PIN_COL_BASE + 1 <= pdata->cols) {
490 dev_err(&client->dev, "invalid gpi col data\n");
491 return -EINVAL;
492 }
493 }
494 }
495
496 if (!client->irq) {
497 dev_err(&client->dev, "no IRQ?\n");
498 return -EINVAL;
499 }
500
501 kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
502 input = input_allocate_device();
503 if (!kpad || !input) {
504 error = -ENOMEM;
505 goto err_free_mem;
506 }
507
508 kpad->client = client;
509 kpad->input = input;
510 INIT_DELAYED_WORK(&kpad->work, adp5588_work);
511
512 ret = adp5588_read(client, DEV_ID);
513 if (ret < 0) {
514 error = ret;
515 goto err_free_mem;
516 }
517
518 revid = (u8) ret & ADP5588_DEVICE_ID_MASK;
519 if (WA_DELAYED_READOUT_REVID(revid))
520 kpad->delay = msecs_to_jiffies(30);
521
522 input->name = client->name;
523 input->phys = "adp5588-keys/input0";
524 input->dev.parent = &client->dev;
525
526 input_set_drvdata(input, kpad);
527
528 input->id.bustype = BUS_I2C;
529 input->id.vendor = 0x0001;
530 input->id.product = 0x0001;
531 input->id.version = revid;
532
533 input->keycodesize = sizeof(kpad->keycode[0]);
534 input->keycodemax = pdata->keymapsize;
535 input->keycode = kpad->keycode;
536
537 memcpy(kpad->keycode, pdata->keymap,
538 pdata->keymapsize * input->keycodesize);
539
540 kpad->gpimap = pdata->gpimap;
541 kpad->gpimapsize = pdata->gpimapsize;
542
543 /* setup input device */
544 __set_bit(EV_KEY, input->evbit);
545
546 if (pdata->repeat)
547 __set_bit(EV_REP, input->evbit);
548
549 for (i = 0; i < input->keycodemax; i++)
550 if (kpad->keycode[i] <= KEY_MAX)
551 __set_bit(kpad->keycode[i], input->keybit);
552 __clear_bit(KEY_RESERVED, input->keybit);
553
554 if (kpad->gpimapsize)
555 __set_bit(EV_SW, input->evbit);
556 for (i = 0; i < kpad->gpimapsize; i++)
557 __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
558
559 error = input_register_device(input);
560 if (error) {
561 dev_err(&client->dev, "unable to register input device\n");
562 goto err_free_mem;
563 }
564
565 error = request_irq(client->irq, adp5588_irq,
566 IRQF_TRIGGER_FALLING,
567 client->dev.driver->name, kpad);
568 if (error) {
569 dev_err(&client->dev, "irq %d busy?\n", client->irq);
570 goto err_unreg_dev;
571 }
572
573 error = adp5588_setup(client);
574 if (error)
575 goto err_free_irq;
576
577 if (kpad->gpimapsize)
578 adp5588_report_switch_state(kpad);
579
580 error = adp5588_gpio_add(kpad);
581 if (error)
582 goto err_free_irq;
583
584 device_init_wakeup(&client->dev, 1);
585 i2c_set_clientdata(client, kpad);
586
587 dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
588 return 0;
589
590 err_free_irq:
591 free_irq(client->irq, kpad);
592 cancel_delayed_work_sync(&kpad->work);
593 err_unreg_dev:
594 input_unregister_device(input);
595 input = NULL;
596 err_free_mem:
597 input_free_device(input);
598 kfree(kpad);
599
600 return error;
601 }
602
603 static int adp5588_remove(struct i2c_client *client)
604 {
605 struct adp5588_kpad *kpad = i2c_get_clientdata(client);
606
607 adp5588_write(client, CFG, 0);
608 free_irq(client->irq, kpad);
609 cancel_delayed_work_sync(&kpad->work);
610 input_unregister_device(kpad->input);
611 adp5588_gpio_remove(kpad);
612 kfree(kpad);
613
614 return 0;
615 }
616
617 #ifdef CONFIG_PM
618 static int adp5588_suspend(struct device *dev)
619 {
620 struct adp5588_kpad *kpad = dev_get_drvdata(dev);
621 struct i2c_client *client = kpad->client;
622
623 disable_irq(client->irq);
624 cancel_delayed_work_sync(&kpad->work);
625
626 if (device_may_wakeup(&client->dev))
627 enable_irq_wake(client->irq);
628
629 return 0;
630 }
631
632 static int adp5588_resume(struct device *dev)
633 {
634 struct adp5588_kpad *kpad = dev_get_drvdata(dev);
635 struct i2c_client *client = kpad->client;
636
637 if (device_may_wakeup(&client->dev))
638 disable_irq_wake(client->irq);
639
640 enable_irq(client->irq);
641
642 return 0;
643 }
644
645 static const struct dev_pm_ops adp5588_dev_pm_ops = {
646 .suspend = adp5588_suspend,
647 .resume = adp5588_resume,
648 };
649 #endif
650
651 static const struct i2c_device_id adp5588_id[] = {
652 { "adp5588-keys", 0 },
653 { "adp5587-keys", 0 },
654 { }
655 };
656 MODULE_DEVICE_TABLE(i2c, adp5588_id);
657
658 static struct i2c_driver adp5588_driver = {
659 .driver = {
660 .name = KBUILD_MODNAME,
661 #ifdef CONFIG_PM
662 .pm = &adp5588_dev_pm_ops,
663 #endif
664 },
665 .probe = adp5588_probe,
666 .remove = adp5588_remove,
667 .id_table = adp5588_id,
668 };
669
670 module_i2c_driver(adp5588_driver);
671
672 MODULE_LICENSE("GPL");
673 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
674 MODULE_DESCRIPTION("ADP5588/87 Keypad driver");
Linux kernel - Deliverables
This page took 0.071668 seconds and 5 git commands to generate.