Merge branch 'btrfs-3.0' into for-linus
[pandora-kernel.git] / drivers / input / keyboard / adp5589-keys.c
1 /*
2  * Description:  keypad driver for ADP5589
3  *               I2C QWERTY Keypad and IO Expander
4  * Bugs: Enter bugs at http://blackfin.uclinux.org/
5  *
6  * Copyright (C) 2010-2011 Analog Devices Inc.
7  * Licensed under the GPL-2.
8  */
9
10 #include <linux/module.h>
11 #include <linux/init.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/input/adp5589.h>
24
25 /* GENERAL_CFG Register */
26 #define OSC_EN          (1 << 7)
27 #define CORE_CLK(x)     (((x) & 0x3) << 5)
28 #define LCK_TRK_LOGIC   (1 << 4)
29 #define LCK_TRK_GPI     (1 << 3)
30 #define INT_CFG         (1 << 1)
31 #define RST_CFG         (1 << 0)
32
33 /* INT_EN Register */
34 #define LOGIC2_IEN      (1 << 5)
35 #define LOGIC1_IEN      (1 << 4)
36 #define LOCK_IEN        (1 << 3)
37 #define OVRFLOW_IEN     (1 << 2)
38 #define GPI_IEN         (1 << 1)
39 #define EVENT_IEN       (1 << 0)
40
41 /* Interrupt Status Register */
42 #define LOGIC2_INT      (1 << 5)
43 #define LOGIC1_INT      (1 << 4)
44 #define LOCK_INT        (1 << 3)
45 #define OVRFLOW_INT     (1 << 2)
46 #define GPI_INT         (1 << 1)
47 #define EVENT_INT       (1 << 0)
48
49 /* STATUS Register */
50
51 #define LOGIC2_STAT     (1 << 7)
52 #define LOGIC1_STAT     (1 << 6)
53 #define LOCK_STAT       (1 << 5)
54 #define KEC             0xF
55
56 /* PIN_CONFIG_D Register */
57 #define C4_EXTEND_CFG   (1 << 6)        /* RESET2 */
58 #define R4_EXTEND_CFG   (1 << 5)        /* RESET1 */
59
60 /* LOCK_CFG */
61 #define LOCK_EN         (1 << 0)
62
63 #define PTIME_MASK      0x3
64 #define LTIME_MASK      0x3
65
66 /* Key Event Register xy */
67 #define KEY_EV_PRESSED          (1 << 7)
68 #define KEY_EV_MASK             (0x7F)
69
70 #define KEYP_MAX_EVENT          16
71
72 #define MAXGPIO                 19
73 #define ADP_BANK(offs)          ((offs) >> 3)
74 #define ADP_BIT(offs)           (1u << ((offs) & 0x7))
75
76 struct adp5589_kpad {
77         struct i2c_client *client;
78         struct input_dev *input;
79         unsigned short keycode[ADP5589_KEYMAPSIZE];
80         const struct adp5589_gpi_map *gpimap;
81         unsigned short gpimapsize;
82         unsigned extend_cfg;
83 #ifdef CONFIG_GPIOLIB
84         unsigned char gpiomap[MAXGPIO];
85         bool export_gpio;
86         struct gpio_chip gc;
87         struct mutex gpio_lock; /* Protect cached dir, dat_out */
88         u8 dat_out[3];
89         u8 dir[3];
90 #endif
91 };
92
93 static int adp5589_read(struct i2c_client *client, u8 reg)
94 {
95         int ret = i2c_smbus_read_byte_data(client, reg);
96
97         if (ret < 0)
98                 dev_err(&client->dev, "Read Error\n");
99
100         return ret;
101 }
102
103 static int adp5589_write(struct i2c_client *client, u8 reg, u8 val)
104 {
105         return i2c_smbus_write_byte_data(client, reg, val);
106 }
107
108 #ifdef CONFIG_GPIOLIB
109 static int adp5589_gpio_get_value(struct gpio_chip *chip, unsigned off)
110 {
111         struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
112         unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
113         unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
114
115         return !!(adp5589_read(kpad->client, ADP5589_GPI_STATUS_A + bank) &
116                   bit);
117 }
118
119 static void adp5589_gpio_set_value(struct gpio_chip *chip,
120                                    unsigned off, int val)
121 {
122         struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
123         unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
124         unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
125
126         mutex_lock(&kpad->gpio_lock);
127
128         if (val)
129                 kpad->dat_out[bank] |= bit;
130         else
131                 kpad->dat_out[bank] &= ~bit;
132
133         adp5589_write(kpad->client, ADP5589_GPO_DATA_OUT_A + bank,
134                       kpad->dat_out[bank]);
135
136         mutex_unlock(&kpad->gpio_lock);
137 }
138
139 static int adp5589_gpio_direction_input(struct gpio_chip *chip, unsigned off)
140 {
141         struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
142         unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
143         unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
144         int ret;
145
146         mutex_lock(&kpad->gpio_lock);
147
148         kpad->dir[bank] &= ~bit;
149         ret = adp5589_write(kpad->client, ADP5589_GPIO_DIRECTION_A + bank,
150                             kpad->dir[bank]);
151
152         mutex_unlock(&kpad->gpio_lock);
153
154         return ret;
155 }
156
157 static int adp5589_gpio_direction_output(struct gpio_chip *chip,
158                                          unsigned off, int val)
159 {
160         struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
161         unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
162         unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
163         int ret;
164
165         mutex_lock(&kpad->gpio_lock);
166
167         kpad->dir[bank] |= bit;
168
169         if (val)
170                 kpad->dat_out[bank] |= bit;
171         else
172                 kpad->dat_out[bank] &= ~bit;
173
174         ret = adp5589_write(kpad->client, ADP5589_GPO_DATA_OUT_A + bank,
175                             kpad->dat_out[bank]);
176         ret |= adp5589_write(kpad->client, ADP5589_GPIO_DIRECTION_A + bank,
177                              kpad->dir[bank]);
178
179         mutex_unlock(&kpad->gpio_lock);
180
181         return ret;
182 }
183
184 static int __devinit adp5589_build_gpiomap(struct adp5589_kpad *kpad,
185                                 const struct adp5589_kpad_platform_data *pdata)
186 {
187         bool pin_used[MAXGPIO];
188         int n_unused = 0;
189         int i;
190
191         memset(pin_used, false, sizeof(pin_used));
192
193         for (i = 0; i < MAXGPIO; i++)
194                 if (pdata->keypad_en_mask & (1 << i))
195                         pin_used[i] = true;
196
197         for (i = 0; i < kpad->gpimapsize; i++)
198                 pin_used[kpad->gpimap[i].pin - ADP5589_GPI_PIN_BASE] = true;
199
200         if (kpad->extend_cfg & R4_EXTEND_CFG)
201                 pin_used[4] = true;
202
203         if (kpad->extend_cfg & C4_EXTEND_CFG)
204                 pin_used[12] = true;
205
206         for (i = 0; i < MAXGPIO; i++)
207                 if (!pin_used[i])
208                         kpad->gpiomap[n_unused++] = i;
209
210         return n_unused;
211 }
212
213 static int __devinit adp5589_gpio_add(struct adp5589_kpad *kpad)
214 {
215         struct device *dev = &kpad->client->dev;
216         const struct adp5589_kpad_platform_data *pdata = dev->platform_data;
217         const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
218         int i, error;
219
220         if (!gpio_data)
221                 return 0;
222
223         kpad->gc.ngpio = adp5589_build_gpiomap(kpad, pdata);
224         if (kpad->gc.ngpio == 0) {
225                 dev_info(dev, "No unused gpios left to export\n");
226                 return 0;
227         }
228
229         kpad->export_gpio = true;
230
231         kpad->gc.direction_input = adp5589_gpio_direction_input;
232         kpad->gc.direction_output = adp5589_gpio_direction_output;
233         kpad->gc.get = adp5589_gpio_get_value;
234         kpad->gc.set = adp5589_gpio_set_value;
235         kpad->gc.can_sleep = 1;
236
237         kpad->gc.base = gpio_data->gpio_start;
238         kpad->gc.label = kpad->client->name;
239         kpad->gc.owner = THIS_MODULE;
240
241         mutex_init(&kpad->gpio_lock);
242
243         error = gpiochip_add(&kpad->gc);
244         if (error) {
245                 dev_err(dev, "gpiochip_add failed, err: %d\n", error);
246                 return error;
247         }
248
249         for (i = 0; i <= ADP_BANK(MAXGPIO); i++) {
250                 kpad->dat_out[i] = adp5589_read(kpad->client,
251                                                 ADP5589_GPO_DATA_OUT_A + i);
252                 kpad->dir[i] = adp5589_read(kpad->client,
253                                             ADP5589_GPIO_DIRECTION_A + i);
254         }
255
256         if (gpio_data->setup) {
257                 error = gpio_data->setup(kpad->client,
258                                          kpad->gc.base, kpad->gc.ngpio,
259                                          gpio_data->context);
260                 if (error)
261                         dev_warn(dev, "setup failed, %d\n", error);
262         }
263
264         return 0;
265 }
266
267 static void __devexit adp5589_gpio_remove(struct adp5589_kpad *kpad)
268 {
269         struct device *dev = &kpad->client->dev;
270         const struct adp5589_kpad_platform_data *pdata = dev->platform_data;
271         const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
272         int error;
273
274         if (!kpad->export_gpio)
275                 return;
276
277         if (gpio_data->teardown) {
278                 error = gpio_data->teardown(kpad->client,
279                                             kpad->gc.base, kpad->gc.ngpio,
280                                             gpio_data->context);
281                 if (error)
282                         dev_warn(dev, "teardown failed %d\n", error);
283         }
284
285         error = gpiochip_remove(&kpad->gc);
286         if (error)
287                 dev_warn(dev, "gpiochip_remove failed %d\n", error);
288 }
289 #else
290 static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
291 {
292         return 0;
293 }
294
295 static inline void adp5589_gpio_remove(struct adp5589_kpad *kpad)
296 {
297 }
298 #endif
299
300 static void adp5589_report_switches(struct adp5589_kpad *kpad,
301                                     int key, int key_val)
302 {
303         int i;
304
305         for (i = 0; i < kpad->gpimapsize; i++) {
306                 if (key_val == kpad->gpimap[i].pin) {
307                         input_report_switch(kpad->input,
308                                             kpad->gpimap[i].sw_evt,
309                                             key & KEY_EV_PRESSED);
310                         break;
311                 }
312         }
313 }
314
315 static void adp5589_report_events(struct adp5589_kpad *kpad, int ev_cnt)
316 {
317         int i;
318
319         for (i = 0; i < ev_cnt; i++) {
320                 int key = adp5589_read(kpad->client, ADP5589_FIFO_1 + i);
321                 int key_val = key & KEY_EV_MASK;
322
323                 if (key_val >= ADP5589_GPI_PIN_BASE &&
324                     key_val <= ADP5589_GPI_PIN_END) {
325                         adp5589_report_switches(kpad, key, key_val);
326                 } else {
327                         input_report_key(kpad->input,
328                                          kpad->keycode[key_val - 1],
329                                          key & KEY_EV_PRESSED);
330                 }
331         }
332 }
333
334 static irqreturn_t adp5589_irq(int irq, void *handle)
335 {
336         struct adp5589_kpad *kpad = handle;
337         struct i2c_client *client = kpad->client;
338         int status, ev_cnt;
339
340         status = adp5589_read(client, ADP5589_INT_STATUS);
341
342         if (status & OVRFLOW_INT)       /* Unlikely and should never happen */
343                 dev_err(&client->dev, "Event Overflow Error\n");
344
345         if (status & EVENT_INT) {
346                 ev_cnt = adp5589_read(client, ADP5589_STATUS) & KEC;
347                 if (ev_cnt) {
348                         adp5589_report_events(kpad, ev_cnt);
349                         input_sync(kpad->input);
350                 }
351         }
352
353         adp5589_write(client, ADP5589_INT_STATUS, status);      /* Status is W1C */
354
355         return IRQ_HANDLED;
356 }
357
358 static int __devinit adp5589_get_evcode(struct adp5589_kpad *kpad, unsigned short key)
359 {
360         int i;
361
362         for (i = 0; i < ADP5589_KEYMAPSIZE; i++)
363                 if (key == kpad->keycode[i])
364                         return (i + 1) | KEY_EV_PRESSED;
365
366         dev_err(&kpad->client->dev, "RESET/UNLOCK key not in keycode map\n");
367
368         return -EINVAL;
369 }
370
371 static int __devinit adp5589_setup(struct adp5589_kpad *kpad)
372 {
373         struct i2c_client *client = kpad->client;
374         const struct adp5589_kpad_platform_data *pdata =
375             client->dev.platform_data;
376         int i, ret;
377         unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
378         unsigned char pull_mask = 0;
379
380         ret = adp5589_write(client, ADP5589_PIN_CONFIG_A,
381                             pdata->keypad_en_mask & 0xFF);
382         ret |= adp5589_write(client, ADP5589_PIN_CONFIG_B,
383                              (pdata->keypad_en_mask >> 8) & 0xFF);
384         ret |= adp5589_write(client, ADP5589_PIN_CONFIG_C,
385                              (pdata->keypad_en_mask >> 16) & 0xFF);
386
387         if (pdata->en_keylock) {
388                 ret |= adp5589_write(client, ADP5589_UNLOCK1,
389                                      pdata->unlock_key1);
390                 ret |= adp5589_write(client, ADP5589_UNLOCK2,
391                                      pdata->unlock_key2);
392                 ret |= adp5589_write(client, ADP5589_UNLOCK_TIMERS,
393                                      pdata->unlock_timer & LTIME_MASK);
394                 ret |= adp5589_write(client, ADP5589_LOCK_CFG, LOCK_EN);
395         }
396
397         for (i = 0; i < KEYP_MAX_EVENT; i++)
398                 ret |= adp5589_read(client, ADP5589_FIFO_1 + i);
399
400         for (i = 0; i < pdata->gpimapsize; i++) {
401                 unsigned short pin = pdata->gpimap[i].pin;
402
403                 if (pin <= ADP5589_GPI_PIN_ROW_END) {
404                         evt_mode1 |= (1 << (pin - ADP5589_GPI_PIN_ROW_BASE));
405                 } else {
406                         evt_mode2 |=
407                             ((1 << (pin - ADP5589_GPI_PIN_COL_BASE)) & 0xFF);
408                         evt_mode3 |=
409                             ((1 << (pin - ADP5589_GPI_PIN_COL_BASE)) >> 8);
410                 }
411         }
412
413         if (pdata->gpimapsize) {
414                 ret |= adp5589_write(client, ADP5589_GPI_EVENT_EN_A, evt_mode1);
415                 ret |= adp5589_write(client, ADP5589_GPI_EVENT_EN_B, evt_mode2);
416                 ret |= adp5589_write(client, ADP5589_GPI_EVENT_EN_C, evt_mode3);
417         }
418
419         if (pdata->pull_dis_mask & pdata->pullup_en_100k &
420             pdata->pullup_en_300k & pdata->pulldown_en_300k)
421                 dev_warn(&client->dev, "Conflicting pull resistor config\n");
422
423         for (i = 0; i < MAXGPIO; i++) {
424                 unsigned val = 0;
425
426                 if (pdata->pullup_en_300k & (1 << i))
427                         val = 0;
428                 else if (pdata->pulldown_en_300k & (1 << i))
429                         val = 1;
430                 else if (pdata->pullup_en_100k & (1 << i))
431                         val = 2;
432                 else if (pdata->pull_dis_mask & (1 << i))
433                         val = 3;
434
435                 pull_mask |= val << (2 * (i & 0x3));
436
437                 if ((i & 0x3) == 0x3 || i == MAXGPIO - 1) {
438                         ret |= adp5589_write(client,
439                                              ADP5589_RPULL_CONFIG_A + (i >> 2),
440                                              pull_mask);
441                         pull_mask = 0;
442                 }
443         }
444
445         if (pdata->reset1_key_1 && pdata->reset1_key_2 && pdata->reset1_key_3) {
446                 ret |= adp5589_write(client, ADP5589_RESET1_EVENT_A,
447                                      adp5589_get_evcode(kpad,
448                                                         pdata->reset1_key_1));
449                 ret |= adp5589_write(client, ADP5589_RESET1_EVENT_B,
450                                      adp5589_get_evcode(kpad,
451                                                         pdata->reset1_key_2));
452                 ret |= adp5589_write(client, ADP5589_RESET1_EVENT_C,
453                                      adp5589_get_evcode(kpad,
454                                                         pdata->reset1_key_3));
455                 kpad->extend_cfg |= R4_EXTEND_CFG;
456         }
457
458         if (pdata->reset2_key_1 && pdata->reset2_key_2) {
459                 ret |= adp5589_write(client, ADP5589_RESET2_EVENT_A,
460                                      adp5589_get_evcode(kpad,
461                                                         pdata->reset2_key_1));
462                 ret |= adp5589_write(client, ADP5589_RESET2_EVENT_B,
463                                      adp5589_get_evcode(kpad,
464                                                         pdata->reset2_key_2));
465                 kpad->extend_cfg |= C4_EXTEND_CFG;
466         }
467
468         if (kpad->extend_cfg) {
469                 ret |= adp5589_write(client, ADP5589_RESET_CFG,
470                                      pdata->reset_cfg);
471                 ret |= adp5589_write(client, ADP5589_PIN_CONFIG_D,
472                                      kpad->extend_cfg);
473         }
474
475         for (i = 0; i <= ADP_BANK(MAXGPIO); i++)
476                 ret |= adp5589_write(client, ADP5589_DEBOUNCE_DIS_A + i,
477                                      pdata->debounce_dis_mask >> (i * 8));
478
479         ret |= adp5589_write(client, ADP5589_POLL_PTIME_CFG,
480                              pdata->scan_cycle_time & PTIME_MASK);
481         ret |= adp5589_write(client, ADP5589_INT_STATUS, LOGIC2_INT |
482                              LOGIC1_INT | OVRFLOW_INT | LOCK_INT |
483                              GPI_INT | EVENT_INT);      /* Status is W1C */
484
485         ret |= adp5589_write(client, ADP5589_GENERAL_CFG,
486                              INT_CFG | OSC_EN | CORE_CLK(3));
487         ret |= adp5589_write(client, ADP5589_INT_EN,
488                              OVRFLOW_IEN | GPI_IEN | EVENT_IEN);
489
490         if (ret < 0) {
491                 dev_err(&client->dev, "Write Error\n");
492                 return ret;
493         }
494
495         return 0;
496 }
497
498 static void __devinit adp5589_report_switch_state(struct adp5589_kpad *kpad)
499 {
500         int gpi_stat1 = adp5589_read(kpad->client, ADP5589_GPI_STATUS_A);
501         int gpi_stat2 = adp5589_read(kpad->client, ADP5589_GPI_STATUS_B);
502         int gpi_stat3 = adp5589_read(kpad->client, ADP5589_GPI_STATUS_C);
503         int gpi_stat_tmp, pin_loc;
504         int i;
505
506         for (i = 0; i < kpad->gpimapsize; i++) {
507                 unsigned short pin = kpad->gpimap[i].pin;
508
509                 if (pin <= ADP5589_GPI_PIN_ROW_END) {
510                         gpi_stat_tmp = gpi_stat1;
511                         pin_loc = pin - ADP5589_GPI_PIN_ROW_BASE;
512                 } else if ((pin - ADP5589_GPI_PIN_COL_BASE) < 8) {
513                         gpi_stat_tmp = gpi_stat2;
514                         pin_loc = pin - ADP5589_GPI_PIN_COL_BASE;
515                 } else {
516                         gpi_stat_tmp = gpi_stat3;
517                         pin_loc = pin - ADP5589_GPI_PIN_COL_BASE - 8;
518                 }
519
520                 if (gpi_stat_tmp < 0) {
521                         dev_err(&kpad->client->dev,
522                                 "Can't read GPIO_DAT_STAT switch"
523                                 " %d default to OFF\n", pin);
524                         gpi_stat_tmp = 0;
525                 }
526
527                 input_report_switch(kpad->input,
528                                     kpad->gpimap[i].sw_evt,
529                                     !(gpi_stat_tmp & (1 << pin_loc)));
530         }
531
532         input_sync(kpad->input);
533 }
534
535 static int __devinit adp5589_probe(struct i2c_client *client,
536                                    const struct i2c_device_id *id)
537 {
538         struct adp5589_kpad *kpad;
539         const struct adp5589_kpad_platform_data *pdata;
540         struct input_dev *input;
541         unsigned int revid;
542         int ret, i;
543         int error;
544
545         if (!i2c_check_functionality(client->adapter,
546                                      I2C_FUNC_SMBUS_BYTE_DATA)) {
547                 dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
548                 return -EIO;
549         }
550
551         pdata = client->dev.platform_data;
552         if (!pdata) {
553                 dev_err(&client->dev, "no platform data?\n");
554                 return -EINVAL;
555         }
556
557         if (!((pdata->keypad_en_mask & 0xFF) &&
558                         (pdata->keypad_en_mask >> 8)) || !pdata->keymap) {
559                 dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
560                 return -EINVAL;
561         }
562
563         if (pdata->keymapsize != ADP5589_KEYMAPSIZE) {
564                 dev_err(&client->dev, "invalid keymapsize\n");
565                 return -EINVAL;
566         }
567
568         if (!pdata->gpimap && pdata->gpimapsize) {
569                 dev_err(&client->dev, "invalid gpimap from pdata\n");
570                 return -EINVAL;
571         }
572
573         if (pdata->gpimapsize > ADP5589_GPIMAPSIZE_MAX) {
574                 dev_err(&client->dev, "invalid gpimapsize\n");
575                 return -EINVAL;
576         }
577
578         for (i = 0; i < pdata->gpimapsize; i++) {
579                 unsigned short pin = pdata->gpimap[i].pin;
580
581                 if (pin < ADP5589_GPI_PIN_BASE || pin > ADP5589_GPI_PIN_END) {
582                         dev_err(&client->dev, "invalid gpi pin data\n");
583                         return -EINVAL;
584                 }
585
586                 if ((1 << (pin - ADP5589_GPI_PIN_ROW_BASE)) &
587                                 pdata->keypad_en_mask) {
588                         dev_err(&client->dev, "invalid gpi row/col data\n");
589                         return -EINVAL;
590                 }
591         }
592
593         if (!client->irq) {
594                 dev_err(&client->dev, "no IRQ?\n");
595                 return -EINVAL;
596         }
597
598         kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
599         input = input_allocate_device();
600         if (!kpad || !input) {
601                 error = -ENOMEM;
602                 goto err_free_mem;
603         }
604
605         kpad->client = client;
606         kpad->input = input;
607
608         ret = adp5589_read(client, ADP5589_ID);
609         if (ret < 0) {
610                 error = ret;
611                 goto err_free_mem;
612         }
613
614         revid = (u8) ret & ADP5589_DEVICE_ID_MASK;
615
616         input->name = client->name;
617         input->phys = "adp5589-keys/input0";
618         input->dev.parent = &client->dev;
619
620         input_set_drvdata(input, kpad);
621
622         input->id.bustype = BUS_I2C;
623         input->id.vendor = 0x0001;
624         input->id.product = 0x0001;
625         input->id.version = revid;
626
627         input->keycodesize = sizeof(kpad->keycode[0]);
628         input->keycodemax = pdata->keymapsize;
629         input->keycode = kpad->keycode;
630
631         memcpy(kpad->keycode, pdata->keymap,
632                pdata->keymapsize * input->keycodesize);
633
634         kpad->gpimap = pdata->gpimap;
635         kpad->gpimapsize = pdata->gpimapsize;
636
637         /* setup input device */
638         __set_bit(EV_KEY, input->evbit);
639
640         if (pdata->repeat)
641                 __set_bit(EV_REP, input->evbit);
642
643         for (i = 0; i < input->keycodemax; i++)
644                 __set_bit(kpad->keycode[i] & KEY_MAX, input->keybit);
645         __clear_bit(KEY_RESERVED, input->keybit);
646
647         if (kpad->gpimapsize)
648                 __set_bit(EV_SW, input->evbit);
649         for (i = 0; i < kpad->gpimapsize; i++)
650                 __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
651
652         error = input_register_device(input);
653         if (error) {
654                 dev_err(&client->dev, "unable to register input device\n");
655                 goto err_free_mem;
656         }
657
658         error = request_threaded_irq(client->irq, NULL, adp5589_irq,
659                                      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
660                                      client->dev.driver->name, kpad);
661         if (error) {
662                 dev_err(&client->dev, "irq %d busy?\n", client->irq);
663                 goto err_unreg_dev;
664         }
665
666         error = adp5589_setup(kpad);
667         if (error)
668                 goto err_free_irq;
669
670         if (kpad->gpimapsize)
671                 adp5589_report_switch_state(kpad);
672
673         error = adp5589_gpio_add(kpad);
674         if (error)
675                 goto err_free_irq;
676
677         device_init_wakeup(&client->dev, 1);
678         i2c_set_clientdata(client, kpad);
679
680         dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
681         return 0;
682
683 err_free_irq:
684         free_irq(client->irq, kpad);
685 err_unreg_dev:
686         input_unregister_device(input);
687         input = NULL;
688 err_free_mem:
689         input_free_device(input);
690         kfree(kpad);
691
692         return error;
693 }
694
695 static int __devexit adp5589_remove(struct i2c_client *client)
696 {
697         struct adp5589_kpad *kpad = i2c_get_clientdata(client);
698
699         adp5589_write(client, ADP5589_GENERAL_CFG, 0);
700         free_irq(client->irq, kpad);
701         input_unregister_device(kpad->input);
702         adp5589_gpio_remove(kpad);
703         kfree(kpad);
704
705         return 0;
706 }
707
708 #ifdef CONFIG_PM_SLEEP
709 static int adp5589_suspend(struct device *dev)
710 {
711         struct adp5589_kpad *kpad = dev_get_drvdata(dev);
712         struct i2c_client *client = kpad->client;
713
714         disable_irq(client->irq);
715
716         if (device_may_wakeup(&client->dev))
717                 enable_irq_wake(client->irq);
718
719         return 0;
720 }
721
722 static int adp5589_resume(struct device *dev)
723 {
724         struct adp5589_kpad *kpad = dev_get_drvdata(dev);
725         struct i2c_client *client = kpad->client;
726
727         if (device_may_wakeup(&client->dev))
728                 disable_irq_wake(client->irq);
729
730         enable_irq(client->irq);
731
732         return 0;
733 }
734 #endif
735
736 static SIMPLE_DEV_PM_OPS(adp5589_dev_pm_ops, adp5589_suspend, adp5589_resume);
737
738 static const struct i2c_device_id adp5589_id[] = {
739         {"adp5589-keys", 0},
740         {}
741 };
742
743 MODULE_DEVICE_TABLE(i2c, adp5589_id);
744
745 static struct i2c_driver adp5589_driver = {
746         .driver = {
747                 .name = KBUILD_MODNAME,
748                 .owner = THIS_MODULE,
749                 .pm = &adp5589_dev_pm_ops,
750         },
751         .probe = adp5589_probe,
752         .remove = __devexit_p(adp5589_remove),
753         .id_table = adp5589_id,
754 };
755
756 static int __init adp5589_init(void)
757 {
758         return i2c_add_driver(&adp5589_driver);
759 }
760 module_init(adp5589_init);
761
762 static void __exit adp5589_exit(void)
763 {
764         i2c_del_driver(&adp5589_driver);
765 }
766 module_exit(adp5589_exit);
767
768 MODULE_LICENSE("GPL");
769 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
770 MODULE_DESCRIPTION("ADP5589 Keypad driver");