Commit | Line | Data |
---|---|---|
88751dd6 MH |
1 | /* |
2 | * File: drivers/input/keyboard/adp5588_keys.c | |
5a9003db MH |
3 | * Description: keypad driver for ADP5588 and ADP5587 |
4 | * I2C QWERTY Keypad and IO Expander | |
88751dd6 MH |
5 | * Bugs: Enter bugs at http://blackfin.uclinux.org/ |
6 | * | |
95716c0d | 7 | * Copyright (C) 2008-2010 Analog Devices Inc. |
88751dd6 MH |
8 | * Licensed under the GPL-2 or later. |
9 | */ | |
10 | ||
11 | #include <linux/module.h> | |
88751dd6 MH |
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> | |
ba9f507a | 20 | #include <linux/gpio.h> |
5a0e3ad6 | 21 | #include <linux/slab.h> |
88751dd6 MH |
22 | |
23 | #include <linux/i2c/adp5588.h> | |
24 | ||
88751dd6 MH |
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]; | |
69a4af60 XC |
46 | const struct adp5588_gpi_map *gpimap; |
47 | unsigned short gpimapsize; | |
ba9f507a | 48 | #ifdef CONFIG_GPIOLIB |
95716c0d | 49 | unsigned char gpiomap[ADP5588_MAXGPIO]; |
ba9f507a XC |
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 | |
88751dd6 MH |
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 | ||
ba9f507a XC |
73 | #ifdef CONFIG_GPIOLIB |
74 | static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off) | |
75 | { | |
d3baee37 | 76 | struct adp5588_kpad *kpad = gpiochip_get_data(chip); |
95716c0d MH |
77 | unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); |
78 | unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); | |
910a9f56 | 79 | int val; |
ba9f507a | 80 | |
910a9f56 JFD |
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); | |
ba9f507a XC |
91 | } |
92 | ||
93 | static void adp5588_gpio_set_value(struct gpio_chip *chip, | |
94 | unsigned off, int val) | |
95 | { | |
d3baee37 | 96 | struct adp5588_kpad *kpad = gpiochip_get_data(chip); |
95716c0d MH |
97 | unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); |
98 | unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); | |
ba9f507a XC |
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 | { | |
d3baee37 | 115 | struct adp5588_kpad *kpad = gpiochip_get_data(chip); |
95716c0d MH |
116 | unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); |
117 | unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); | |
ba9f507a XC |
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 | { | |
d3baee37 | 133 | struct adp5588_kpad *kpad = gpiochip_get_data(chip); |
95716c0d MH |
134 | unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]); |
135 | unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]); | |
ba9f507a XC |
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 | ||
5298cc4c | 157 | static int adp5588_build_gpiomap(struct adp5588_kpad *kpad, |
0d87c722 | 158 | const struct adp5588_kpad_platform_data *pdata) |
ba9f507a | 159 | { |
95716c0d | 160 | bool pin_used[ADP5588_MAXGPIO]; |
0d87c722 DT |
161 | int n_unused = 0; |
162 | int i; | |
ba9f507a | 163 | |
0d87c722 | 164 | memset(pin_used, 0, sizeof(pin_used)); |
ba9f507a | 165 | |
0d87c722 DT |
166 | for (i = 0; i < pdata->rows; i++) |
167 | pin_used[i] = true; | |
ba9f507a | 168 | |
0d87c722 DT |
169 | for (i = 0; i < pdata->cols; i++) |
170 | pin_used[i + GPI_PIN_COL_BASE - GPI_PIN_BASE] = true; | |
ba9f507a | 171 | |
0d87c722 DT |
172 | for (i = 0; i < kpad->gpimapsize; i++) |
173 | pin_used[kpad->gpimap[i].pin - GPI_PIN_BASE] = true; | |
ba9f507a | 174 | |
95716c0d | 175 | for (i = 0; i < ADP5588_MAXGPIO; i++) |
0d87c722 DT |
176 | if (!pin_used[i]) |
177 | kpad->gpiomap[n_unused++] = i; | |
ba9f507a | 178 | |
0d87c722 DT |
179 | return n_unused; |
180 | } | |
ba9f507a | 181 | |
5298cc4c | 182 | static int adp5588_gpio_add(struct adp5588_kpad *kpad) |
0d87c722 DT |
183 | { |
184 | struct device *dev = &kpad->client->dev; | |
c838cb3d | 185 | const struct adp5588_kpad_platform_data *pdata = dev_get_platdata(dev); |
0d87c722 DT |
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) { | |
ba9f507a XC |
194 | dev_info(dev, "No unused gpios left to export\n"); |
195 | return 0; | |
196 | } | |
197 | ||
0d87c722 DT |
198 | kpad->export_gpio = true; |
199 | ||
ba9f507a XC |
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; | |
d0a3457d | 209 | kpad->gc.names = gpio_data->names; |
ba9f507a XC |
210 | |
211 | mutex_init(&kpad->gpio_lock); | |
212 | ||
d3baee37 | 213 | error = gpiochip_add_data(&kpad->gc, kpad); |
ba9f507a XC |
214 | if (error) { |
215 | dev_err(dev, "gpiochip_add failed, err: %d\n", error); | |
216 | return error; | |
217 | } | |
218 | ||
95716c0d | 219 | for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) { |
ba9f507a XC |
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 | ||
e2619cf7 | 236 | static void adp5588_gpio_remove(struct adp5588_kpad *kpad) |
ba9f507a | 237 | { |
0d87c722 | 238 | struct device *dev = &kpad->client->dev; |
c838cb3d | 239 | const struct adp5588_kpad_platform_data *pdata = dev_get_platdata(dev); |
ba9f507a XC |
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 | ||
88d5e520 | 254 | gpiochip_remove(&kpad->gc); |
ba9f507a XC |
255 | } |
256 | #else | |
0d87c722 | 257 | static inline int adp5588_gpio_add(struct adp5588_kpad *kpad) |
ba9f507a XC |
258 | { |
259 | return 0; | |
260 | } | |
261 | ||
0d87c722 | 262 | static inline void adp5588_gpio_remove(struct adp5588_kpad *kpad) |
ba9f507a XC |
263 | { |
264 | } | |
265 | #endif | |
266 | ||
69a4af60 XC |
267 | static void adp5588_report_events(struct adp5588_kpad *kpad, int ev_cnt) |
268 | { | |
269 | int i, j; | |
270 | ||
271 | for (i = 0; i < ev_cnt; i++) { | |
272 | int key = adp5588_read(kpad->client, Key_EVENTA + i); | |
273 | int key_val = key & KEY_EV_MASK; | |
274 | ||
275 | if (key_val >= GPI_PIN_BASE && key_val <= GPI_PIN_END) { | |
276 | for (j = 0; j < kpad->gpimapsize; j++) { | |
277 | if (key_val == kpad->gpimap[j].pin) { | |
278 | input_report_switch(kpad->input, | |
279 | kpad->gpimap[j].sw_evt, | |
280 | key & KEY_EV_PRESSED); | |
281 | break; | |
282 | } | |
283 | } | |
284 | } else { | |
285 | input_report_key(kpad->input, | |
286 | kpad->keycode[key_val - 1], | |
287 | key & KEY_EV_PRESSED); | |
288 | } | |
289 | } | |
290 | } | |
291 | ||
88751dd6 MH |
292 | static void adp5588_work(struct work_struct *work) |
293 | { | |
294 | struct adp5588_kpad *kpad = container_of(work, | |
295 | struct adp5588_kpad, work.work); | |
296 | struct i2c_client *client = kpad->client; | |
69a4af60 | 297 | int status, ev_cnt; |
88751dd6 MH |
298 | |
299 | status = adp5588_read(client, INT_STAT); | |
300 | ||
95716c0d | 301 | if (status & ADP5588_OVR_FLOW_INT) /* Unlikely and should never happen */ |
88751dd6 MH |
302 | dev_err(&client->dev, "Event Overflow Error\n"); |
303 | ||
95716c0d MH |
304 | if (status & ADP5588_KE_INT) { |
305 | ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & ADP5588_KEC; | |
88751dd6 | 306 | if (ev_cnt) { |
69a4af60 | 307 | adp5588_report_events(kpad, ev_cnt); |
88751dd6 MH |
308 | input_sync(kpad->input); |
309 | } | |
310 | } | |
311 | adp5588_write(client, INT_STAT, status); /* Status is W1C */ | |
312 | } | |
313 | ||
314 | static irqreturn_t adp5588_irq(int irq, void *handle) | |
315 | { | |
316 | struct adp5588_kpad *kpad = handle; | |
317 | ||
318 | /* | |
319 | * use keventd context to read the event fifo registers | |
320 | * Schedule readout at least 25ms after notification for | |
321 | * REVID < 4 | |
322 | */ | |
323 | ||
324 | schedule_delayed_work(&kpad->work, kpad->delay); | |
325 | ||
326 | return IRQ_HANDLED; | |
327 | } | |
328 | ||
5298cc4c | 329 | static int adp5588_setup(struct i2c_client *client) |
88751dd6 | 330 | { |
c838cb3d JH |
331 | const struct adp5588_kpad_platform_data *pdata = |
332 | dev_get_platdata(&client->dev); | |
ba9f507a | 333 | const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data; |
88751dd6 | 334 | int i, ret; |
69a4af60 | 335 | unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0; |
88751dd6 MH |
336 | |
337 | ret = adp5588_write(client, KP_GPIO1, KP_SEL(pdata->rows)); | |
338 | ret |= adp5588_write(client, KP_GPIO2, KP_SEL(pdata->cols) & 0xFF); | |
339 | ret |= adp5588_write(client, KP_GPIO3, KP_SEL(pdata->cols) >> 8); | |
340 | ||
341 | if (pdata->en_keylock) { | |
342 | ret |= adp5588_write(client, UNLOCK1, pdata->unlock_key1); | |
343 | ret |= adp5588_write(client, UNLOCK2, pdata->unlock_key2); | |
95716c0d | 344 | ret |= adp5588_write(client, KEY_LCK_EC_STAT, ADP5588_K_LCK_EN); |
88751dd6 MH |
345 | } |
346 | ||
347 | for (i = 0; i < KEYP_MAX_EVENT; i++) | |
348 | ret |= adp5588_read(client, Key_EVENTA); | |
349 | ||
69a4af60 XC |
350 | for (i = 0; i < pdata->gpimapsize; i++) { |
351 | unsigned short pin = pdata->gpimap[i].pin; | |
352 | ||
353 | if (pin <= GPI_PIN_ROW_END) { | |
354 | evt_mode1 |= (1 << (pin - GPI_PIN_ROW_BASE)); | |
355 | } else { | |
356 | evt_mode2 |= ((1 << (pin - GPI_PIN_COL_BASE)) & 0xFF); | |
357 | evt_mode3 |= ((1 << (pin - GPI_PIN_COL_BASE)) >> 8); | |
358 | } | |
359 | } | |
360 | ||
361 | if (pdata->gpimapsize) { | |
362 | ret |= adp5588_write(client, GPI_EM1, evt_mode1); | |
363 | ret |= adp5588_write(client, GPI_EM2, evt_mode2); | |
364 | ret |= adp5588_write(client, GPI_EM3, evt_mode3); | |
365 | } | |
366 | ||
ba9f507a | 367 | if (gpio_data) { |
95716c0d | 368 | for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) { |
ba9f507a XC |
369 | int pull_mask = gpio_data->pullup_dis_mask; |
370 | ||
371 | ret |= adp5588_write(client, GPIO_PULL1 + i, | |
372 | (pull_mask >> (8 * i)) & 0xFF); | |
373 | } | |
374 | } | |
375 | ||
95716c0d MH |
376 | ret |= adp5588_write(client, INT_STAT, |
377 | ADP5588_CMP2_INT | ADP5588_CMP1_INT | | |
378 | ADP5588_OVR_FLOW_INT | ADP5588_K_LCK_INT | | |
379 | ADP5588_GPI_INT | ADP5588_KE_INT); /* Status is W1C */ | |
88751dd6 | 380 | |
95716c0d MH |
381 | ret |= adp5588_write(client, CFG, ADP5588_INT_CFG | |
382 | ADP5588_OVR_FLOW_IEN | | |
383 | ADP5588_KE_IEN); | |
88751dd6 MH |
384 | |
385 | if (ret < 0) { | |
386 | dev_err(&client->dev, "Write Error\n"); | |
387 | return ret; | |
388 | } | |
389 | ||
390 | return 0; | |
391 | } | |
392 | ||
5298cc4c | 393 | static void adp5588_report_switch_state(struct adp5588_kpad *kpad) |
69a4af60 XC |
394 | { |
395 | int gpi_stat1 = adp5588_read(kpad->client, GPIO_DAT_STAT1); | |
396 | int gpi_stat2 = adp5588_read(kpad->client, GPIO_DAT_STAT2); | |
397 | int gpi_stat3 = adp5588_read(kpad->client, GPIO_DAT_STAT3); | |
398 | int gpi_stat_tmp, pin_loc; | |
399 | int i; | |
400 | ||
401 | for (i = 0; i < kpad->gpimapsize; i++) { | |
402 | unsigned short pin = kpad->gpimap[i].pin; | |
403 | ||
404 | if (pin <= GPI_PIN_ROW_END) { | |
405 | gpi_stat_tmp = gpi_stat1; | |
406 | pin_loc = pin - GPI_PIN_ROW_BASE; | |
407 | } else if ((pin - GPI_PIN_COL_BASE) < 8) { | |
408 | gpi_stat_tmp = gpi_stat2; | |
409 | pin_loc = pin - GPI_PIN_COL_BASE; | |
410 | } else { | |
411 | gpi_stat_tmp = gpi_stat3; | |
412 | pin_loc = pin - GPI_PIN_COL_BASE - 8; | |
413 | } | |
414 | ||
415 | if (gpi_stat_tmp < 0) { | |
416 | dev_err(&kpad->client->dev, | |
417 | "Can't read GPIO_DAT_STAT switch %d default to OFF\n", | |
418 | pin); | |
419 | gpi_stat_tmp = 0; | |
420 | } | |
421 | ||
422 | input_report_switch(kpad->input, | |
423 | kpad->gpimap[i].sw_evt, | |
424 | !(gpi_stat_tmp & (1 << pin_loc))); | |
425 | } | |
426 | ||
427 | input_sync(kpad->input); | |
428 | } | |
429 | ||
430 | ||
5298cc4c BP |
431 | static int adp5588_probe(struct i2c_client *client, |
432 | const struct i2c_device_id *id) | |
88751dd6 MH |
433 | { |
434 | struct adp5588_kpad *kpad; | |
c838cb3d JH |
435 | const struct adp5588_kpad_platform_data *pdata = |
436 | dev_get_platdata(&client->dev); | |
88751dd6 MH |
437 | struct input_dev *input; |
438 | unsigned int revid; | |
439 | int ret, i; | |
440 | int error; | |
441 | ||
442 | if (!i2c_check_functionality(client->adapter, | |
443 | I2C_FUNC_SMBUS_BYTE_DATA)) { | |
444 | dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); | |
445 | return -EIO; | |
446 | } | |
447 | ||
448 | if (!pdata) { | |
449 | dev_err(&client->dev, "no platform data?\n"); | |
450 | return -EINVAL; | |
451 | } | |
452 | ||
453 | if (!pdata->rows || !pdata->cols || !pdata->keymap) { | |
454 | dev_err(&client->dev, "no rows, cols or keymap from pdata\n"); | |
455 | return -EINVAL; | |
456 | } | |
457 | ||
458 | if (pdata->keymapsize != ADP5588_KEYMAPSIZE) { | |
459 | dev_err(&client->dev, "invalid keymapsize\n"); | |
460 | return -EINVAL; | |
461 | } | |
462 | ||
69a4af60 XC |
463 | if (!pdata->gpimap && pdata->gpimapsize) { |
464 | dev_err(&client->dev, "invalid gpimap from pdata\n"); | |
465 | return -EINVAL; | |
466 | } | |
467 | ||
468 | if (pdata->gpimapsize > ADP5588_GPIMAPSIZE_MAX) { | |
469 | dev_err(&client->dev, "invalid gpimapsize\n"); | |
470 | return -EINVAL; | |
471 | } | |
472 | ||
473 | for (i = 0; i < pdata->gpimapsize; i++) { | |
474 | unsigned short pin = pdata->gpimap[i].pin; | |
475 | ||
476 | if (pin < GPI_PIN_BASE || pin > GPI_PIN_END) { | |
477 | dev_err(&client->dev, "invalid gpi pin data\n"); | |
478 | return -EINVAL; | |
479 | } | |
480 | ||
481 | if (pin <= GPI_PIN_ROW_END) { | |
482 | if (pin - GPI_PIN_ROW_BASE + 1 <= pdata->rows) { | |
483 | dev_err(&client->dev, "invalid gpi row data\n"); | |
484 | return -EINVAL; | |
485 | } | |
486 | } else { | |
487 | if (pin - GPI_PIN_COL_BASE + 1 <= pdata->cols) { | |
488 | dev_err(&client->dev, "invalid gpi col data\n"); | |
489 | return -EINVAL; | |
490 | } | |
491 | } | |
492 | } | |
493 | ||
88751dd6 MH |
494 | if (!client->irq) { |
495 | dev_err(&client->dev, "no IRQ?\n"); | |
496 | return -EINVAL; | |
497 | } | |
498 | ||
499 | kpad = kzalloc(sizeof(*kpad), GFP_KERNEL); | |
500 | input = input_allocate_device(); | |
501 | if (!kpad || !input) { | |
502 | error = -ENOMEM; | |
503 | goto err_free_mem; | |
504 | } | |
505 | ||
506 | kpad->client = client; | |
507 | kpad->input = input; | |
508 | INIT_DELAYED_WORK(&kpad->work, adp5588_work); | |
509 | ||
510 | ret = adp5588_read(client, DEV_ID); | |
511 | if (ret < 0) { | |
512 | error = ret; | |
513 | goto err_free_mem; | |
514 | } | |
515 | ||
516 | revid = (u8) ret & ADP5588_DEVICE_ID_MASK; | |
517 | if (WA_DELAYED_READOUT_REVID(revid)) | |
518 | kpad->delay = msecs_to_jiffies(30); | |
519 | ||
520 | input->name = client->name; | |
521 | input->phys = "adp5588-keys/input0"; | |
522 | input->dev.parent = &client->dev; | |
523 | ||
524 | input_set_drvdata(input, kpad); | |
525 | ||
526 | input->id.bustype = BUS_I2C; | |
527 | input->id.vendor = 0x0001; | |
528 | input->id.product = 0x0001; | |
529 | input->id.version = revid; | |
530 | ||
531 | input->keycodesize = sizeof(kpad->keycode[0]); | |
532 | input->keycodemax = pdata->keymapsize; | |
533 | input->keycode = kpad->keycode; | |
534 | ||
535 | memcpy(kpad->keycode, pdata->keymap, | |
536 | pdata->keymapsize * input->keycodesize); | |
537 | ||
69a4af60 XC |
538 | kpad->gpimap = pdata->gpimap; |
539 | kpad->gpimapsize = pdata->gpimapsize; | |
540 | ||
88751dd6 MH |
541 | /* setup input device */ |
542 | __set_bit(EV_KEY, input->evbit); | |
543 | ||
544 | if (pdata->repeat) | |
545 | __set_bit(EV_REP, input->evbit); | |
546 | ||
547 | for (i = 0; i < input->keycodemax; i++) | |
e4cfb034 AL |
548 | if (kpad->keycode[i] <= KEY_MAX) |
549 | __set_bit(kpad->keycode[i], input->keybit); | |
88751dd6 MH |
550 | __clear_bit(KEY_RESERVED, input->keybit); |
551 | ||
69a4af60 XC |
552 | if (kpad->gpimapsize) |
553 | __set_bit(EV_SW, input->evbit); | |
554 | for (i = 0; i < kpad->gpimapsize; i++) | |
555 | __set_bit(kpad->gpimap[i].sw_evt, input->swbit); | |
556 | ||
88751dd6 MH |
557 | error = input_register_device(input); |
558 | if (error) { | |
559 | dev_err(&client->dev, "unable to register input device\n"); | |
560 | goto err_free_mem; | |
561 | } | |
562 | ||
563 | error = request_irq(client->irq, adp5588_irq, | |
ec4665c4 | 564 | IRQF_TRIGGER_FALLING, |
88751dd6 MH |
565 | client->dev.driver->name, kpad); |
566 | if (error) { | |
567 | dev_err(&client->dev, "irq %d busy?\n", client->irq); | |
568 | goto err_unreg_dev; | |
569 | } | |
570 | ||
571 | error = adp5588_setup(client); | |
572 | if (error) | |
573 | goto err_free_irq; | |
574 | ||
69a4af60 XC |
575 | if (kpad->gpimapsize) |
576 | adp5588_report_switch_state(kpad); | |
577 | ||
0d87c722 | 578 | error = adp5588_gpio_add(kpad); |
ba9f507a XC |
579 | if (error) |
580 | goto err_free_irq; | |
581 | ||
88751dd6 MH |
582 | device_init_wakeup(&client->dev, 1); |
583 | i2c_set_clientdata(client, kpad); | |
584 | ||
585 | dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq); | |
586 | return 0; | |
587 | ||
588 | err_free_irq: | |
589 | free_irq(client->irq, kpad); | |
b3f9db49 | 590 | cancel_delayed_work_sync(&kpad->work); |
88751dd6 MH |
591 | err_unreg_dev: |
592 | input_unregister_device(input); | |
593 | input = NULL; | |
594 | err_free_mem: | |
595 | input_free_device(input); | |
596 | kfree(kpad); | |
597 | ||
598 | return error; | |
599 | } | |
600 | ||
e2619cf7 | 601 | static int adp5588_remove(struct i2c_client *client) |
88751dd6 MH |
602 | { |
603 | struct adp5588_kpad *kpad = i2c_get_clientdata(client); | |
604 | ||
605 | adp5588_write(client, CFG, 0); | |
606 | free_irq(client->irq, kpad); | |
607 | cancel_delayed_work_sync(&kpad->work); | |
608 | input_unregister_device(kpad->input); | |
0d87c722 | 609 | adp5588_gpio_remove(kpad); |
88751dd6 MH |
610 | kfree(kpad); |
611 | ||
612 | return 0; | |
613 | } | |
614 | ||
615 | #ifdef CONFIG_PM | |
616 | static int adp5588_suspend(struct device *dev) | |
617 | { | |
618 | struct adp5588_kpad *kpad = dev_get_drvdata(dev); | |
619 | struct i2c_client *client = kpad->client; | |
620 | ||
621 | disable_irq(client->irq); | |
622 | cancel_delayed_work_sync(&kpad->work); | |
623 | ||
624 | if (device_may_wakeup(&client->dev)) | |
625 | enable_irq_wake(client->irq); | |
626 | ||
627 | return 0; | |
628 | } | |
629 | ||
630 | static int adp5588_resume(struct device *dev) | |
631 | { | |
632 | struct adp5588_kpad *kpad = dev_get_drvdata(dev); | |
633 | struct i2c_client *client = kpad->client; | |
634 | ||
635 | if (device_may_wakeup(&client->dev)) | |
636 | disable_irq_wake(client->irq); | |
637 | ||
638 | enable_irq(client->irq); | |
639 | ||
640 | return 0; | |
641 | } | |
642 | ||
47145210 | 643 | static const struct dev_pm_ops adp5588_dev_pm_ops = { |
88751dd6 MH |
644 | .suspend = adp5588_suspend, |
645 | .resume = adp5588_resume, | |
646 | }; | |
647 | #endif | |
648 | ||
649 | static const struct i2c_device_id adp5588_id[] = { | |
d537155a | 650 | { "adp5588-keys", 0 }, |
5a9003db | 651 | { "adp5587-keys", 0 }, |
88751dd6 MH |
652 | { } |
653 | }; | |
654 | MODULE_DEVICE_TABLE(i2c, adp5588_id); | |
655 | ||
656 | static struct i2c_driver adp5588_driver = { | |
657 | .driver = { | |
658 | .name = KBUILD_MODNAME, | |
659 | #ifdef CONFIG_PM | |
660 | .pm = &adp5588_dev_pm_ops, | |
661 | #endif | |
662 | }, | |
663 | .probe = adp5588_probe, | |
1cb0aa88 | 664 | .remove = adp5588_remove, |
88751dd6 MH |
665 | .id_table = adp5588_id, |
666 | }; | |
667 | ||
1b92c1cf | 668 | module_i2c_driver(adp5588_driver); |
88751dd6 MH |
669 | |
670 | MODULE_LICENSE("GPL"); | |
671 | MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); | |
5a9003db | 672 | MODULE_DESCRIPTION("ADP5588/87 Keypad driver"); |