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