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