]>
Commit | Line | Data |
---|---|---|
312e8e8a | 1 | /* |
adf779c1 | 2 | * Touchkey driver for MELFAS MCS5000/5080 controller |
312e8e8a JS |
3 | * |
4 | * Copyright (C) 2010 Samsung Electronics Co.Ltd | |
5 | * Author: HeungJun Kim <riverful.kim@samsung.com> | |
6 | * Author: Joonyoung Shim <jy0922.shim@samsung.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the | |
10 | * Free Software Foundation; either version 2 of the License, or (at your | |
11 | * option) any later version. | |
12 | */ | |
13 | ||
14 | #include <linux/module.h> | |
312e8e8a JS |
15 | #include <linux/i2c.h> |
16 | #include <linux/i2c/mcs.h> | |
17 | #include <linux/interrupt.h> | |
18 | #include <linux/input.h> | |
19 | #include <linux/irq.h> | |
20 | #include <linux/slab.h> | |
adf779c1 | 21 | #include <linux/pm.h> |
312e8e8a JS |
22 | |
23 | /* MCS5000 Touchkey */ | |
24 | #define MCS5000_TOUCHKEY_STATUS 0x04 | |
25 | #define MCS5000_TOUCHKEY_STATUS_PRESS 7 | |
26 | #define MCS5000_TOUCHKEY_FW 0x0a | |
27 | #define MCS5000_TOUCHKEY_BASE_VAL 0x61 | |
28 | ||
29 | /* MCS5080 Touchkey */ | |
30 | #define MCS5080_TOUCHKEY_STATUS 0x00 | |
31 | #define MCS5080_TOUCHKEY_STATUS_PRESS 3 | |
32 | #define MCS5080_TOUCHKEY_FW 0x01 | |
33 | #define MCS5080_TOUCHKEY_BASE_VAL 0x1 | |
34 | ||
35 | enum mcs_touchkey_type { | |
36 | MCS5000_TOUCHKEY, | |
37 | MCS5080_TOUCHKEY, | |
38 | }; | |
39 | ||
40 | struct mcs_touchkey_chip { | |
41 | unsigned int status_reg; | |
42 | unsigned int pressbit; | |
43 | unsigned int press_invert; | |
44 | unsigned int baseval; | |
45 | }; | |
46 | ||
47 | struct mcs_touchkey_data { | |
adf779c1 HK |
48 | void (*poweron)(bool); |
49 | ||
312e8e8a JS |
50 | struct i2c_client *client; |
51 | struct input_dev *input_dev; | |
52 | struct mcs_touchkey_chip chip; | |
53 | unsigned int key_code; | |
54 | unsigned int key_val; | |
55 | unsigned short keycodes[]; | |
56 | }; | |
57 | ||
58 | static irqreturn_t mcs_touchkey_interrupt(int irq, void *dev_id) | |
59 | { | |
60 | struct mcs_touchkey_data *data = dev_id; | |
61 | struct mcs_touchkey_chip *chip = &data->chip; | |
62 | struct i2c_client *client = data->client; | |
63 | struct input_dev *input = data->input_dev; | |
64 | unsigned int key_val; | |
65 | unsigned int pressed; | |
66 | int val; | |
67 | ||
68 | val = i2c_smbus_read_byte_data(client, chip->status_reg); | |
69 | if (val < 0) { | |
70 | dev_err(&client->dev, "i2c read error [%d]\n", val); | |
71 | goto out; | |
72 | } | |
73 | ||
74 | pressed = (val & (1 << chip->pressbit)) >> chip->pressbit; | |
75 | if (chip->press_invert) | |
76 | pressed ^= chip->press_invert; | |
77 | ||
78 | /* key_val is 0 when released, so we should use key_val of press. */ | |
79 | if (pressed) { | |
80 | key_val = val & (0xff >> (8 - chip->pressbit)); | |
81 | if (!key_val) | |
82 | goto out; | |
83 | key_val -= chip->baseval; | |
84 | data->key_code = data->keycodes[key_val]; | |
85 | data->key_val = key_val; | |
86 | } | |
87 | ||
88 | input_event(input, EV_MSC, MSC_SCAN, data->key_val); | |
89 | input_report_key(input, data->key_code, pressed); | |
90 | input_sync(input); | |
91 | ||
92 | dev_dbg(&client->dev, "key %d %d %s\n", data->key_val, data->key_code, | |
93 | pressed ? "pressed" : "released"); | |
94 | ||
95 | out: | |
96 | return IRQ_HANDLED; | |
97 | } | |
98 | ||
5298cc4c | 99 | static int mcs_touchkey_probe(struct i2c_client *client, |
312e8e8a JS |
100 | const struct i2c_device_id *id) |
101 | { | |
102 | const struct mcs_platform_data *pdata; | |
103 | struct mcs_touchkey_data *data; | |
104 | struct input_dev *input_dev; | |
105 | unsigned int fw_reg; | |
106 | int fw_ver; | |
107 | int error; | |
108 | int i; | |
109 | ||
c838cb3d | 110 | pdata = dev_get_platdata(&client->dev); |
312e8e8a JS |
111 | if (!pdata) { |
112 | dev_err(&client->dev, "no platform data defined\n"); | |
113 | return -EINVAL; | |
114 | } | |
115 | ||
116 | data = kzalloc(sizeof(struct mcs_touchkey_data) + | |
117 | sizeof(data->keycodes[0]) * (pdata->key_maxval + 1), | |
118 | GFP_KERNEL); | |
119 | input_dev = input_allocate_device(); | |
120 | if (!data || !input_dev) { | |
121 | dev_err(&client->dev, "Failed to allocate memory\n"); | |
122 | error = -ENOMEM; | |
123 | goto err_free_mem; | |
124 | } | |
125 | ||
126 | data->client = client; | |
127 | data->input_dev = input_dev; | |
128 | ||
129 | if (id->driver_data == MCS5000_TOUCHKEY) { | |
130 | data->chip.status_reg = MCS5000_TOUCHKEY_STATUS; | |
131 | data->chip.pressbit = MCS5000_TOUCHKEY_STATUS_PRESS; | |
132 | data->chip.baseval = MCS5000_TOUCHKEY_BASE_VAL; | |
133 | fw_reg = MCS5000_TOUCHKEY_FW; | |
134 | } else { | |
135 | data->chip.status_reg = MCS5080_TOUCHKEY_STATUS; | |
136 | data->chip.pressbit = MCS5080_TOUCHKEY_STATUS_PRESS; | |
137 | data->chip.press_invert = 1; | |
138 | data->chip.baseval = MCS5080_TOUCHKEY_BASE_VAL; | |
139 | fw_reg = MCS5080_TOUCHKEY_FW; | |
140 | } | |
141 | ||
142 | fw_ver = i2c_smbus_read_byte_data(client, fw_reg); | |
143 | if (fw_ver < 0) { | |
144 | error = fw_ver; | |
145 | dev_err(&client->dev, "i2c read error[%d]\n", error); | |
146 | goto err_free_mem; | |
147 | } | |
148 | dev_info(&client->dev, "Firmware version: %d\n", fw_ver); | |
149 | ||
9ab65da3 | 150 | input_dev->name = "MELFAS MCS Touchkey"; |
312e8e8a JS |
151 | input_dev->id.bustype = BUS_I2C; |
152 | input_dev->dev.parent = &client->dev; | |
153 | input_dev->evbit[0] = BIT_MASK(EV_KEY); | |
154 | if (!pdata->no_autorepeat) | |
155 | input_dev->evbit[0] |= BIT_MASK(EV_REP); | |
156 | input_dev->keycode = data->keycodes; | |
157 | input_dev->keycodesize = sizeof(data->keycodes[0]); | |
158 | input_dev->keycodemax = pdata->key_maxval + 1; | |
159 | ||
160 | for (i = 0; i < pdata->keymap_size; i++) { | |
161 | unsigned int val = MCS_KEY_VAL(pdata->keymap[i]); | |
162 | unsigned int code = MCS_KEY_CODE(pdata->keymap[i]); | |
163 | ||
164 | data->keycodes[val] = code; | |
165 | __set_bit(code, input_dev->keybit); | |
166 | } | |
167 | ||
168 | input_set_capability(input_dev, EV_MSC, MSC_SCAN); | |
169 | input_set_drvdata(input_dev, data); | |
170 | ||
171 | if (pdata->cfg_pin) | |
172 | pdata->cfg_pin(); | |
173 | ||
adf779c1 HK |
174 | if (pdata->poweron) { |
175 | data->poweron = pdata->poweron; | |
176 | data->poweron(true); | |
177 | } | |
178 | ||
312e8e8a | 179 | error = request_threaded_irq(client->irq, NULL, mcs_touchkey_interrupt, |
9b7e31bb LPC |
180 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
181 | client->dev.driver->name, data); | |
312e8e8a JS |
182 | if (error) { |
183 | dev_err(&client->dev, "Failed to register interrupt\n"); | |
184 | goto err_free_mem; | |
185 | } | |
186 | ||
187 | error = input_register_device(input_dev); | |
188 | if (error) | |
189 | goto err_free_irq; | |
190 | ||
191 | i2c_set_clientdata(client, data); | |
192 | return 0; | |
193 | ||
194 | err_free_irq: | |
195 | free_irq(client->irq, data); | |
196 | err_free_mem: | |
197 | input_free_device(input_dev); | |
198 | kfree(data); | |
199 | return error; | |
200 | } | |
201 | ||
e2619cf7 | 202 | static int mcs_touchkey_remove(struct i2c_client *client) |
312e8e8a JS |
203 | { |
204 | struct mcs_touchkey_data *data = i2c_get_clientdata(client); | |
205 | ||
206 | free_irq(client->irq, data); | |
adf779c1 HK |
207 | if (data->poweron) |
208 | data->poweron(false); | |
312e8e8a JS |
209 | input_unregister_device(data->input_dev); |
210 | kfree(data); | |
211 | ||
212 | return 0; | |
213 | } | |
214 | ||
5f62615e HK |
215 | static void mcs_touchkey_shutdown(struct i2c_client *client) |
216 | { | |
217 | struct mcs_touchkey_data *data = i2c_get_clientdata(client); | |
218 | ||
219 | if (data->poweron) | |
220 | data->poweron(false); | |
221 | } | |
222 | ||
adf779c1 HK |
223 | #ifdef CONFIG_PM_SLEEP |
224 | static int mcs_touchkey_suspend(struct device *dev) | |
225 | { | |
226 | struct mcs_touchkey_data *data = dev_get_drvdata(dev); | |
227 | struct i2c_client *client = data->client; | |
228 | ||
229 | /* Disable the work */ | |
230 | disable_irq(client->irq); | |
231 | ||
232 | /* Finally turn off the power */ | |
233 | if (data->poweron) | |
234 | data->poweron(false); | |
235 | ||
236 | return 0; | |
237 | } | |
238 | ||
239 | static int mcs_touchkey_resume(struct device *dev) | |
240 | { | |
241 | struct mcs_touchkey_data *data = dev_get_drvdata(dev); | |
242 | struct i2c_client *client = data->client; | |
243 | ||
244 | /* Enable the device first */ | |
245 | if (data->poweron) | |
246 | data->poweron(true); | |
247 | ||
248 | /* Enable irq again */ | |
249 | enable_irq(client->irq); | |
250 | ||
251 | return 0; | |
252 | } | |
253 | #endif | |
254 | ||
255 | static SIMPLE_DEV_PM_OPS(mcs_touchkey_pm_ops, | |
256 | mcs_touchkey_suspend, mcs_touchkey_resume); | |
257 | ||
312e8e8a JS |
258 | static const struct i2c_device_id mcs_touchkey_id[] = { |
259 | { "mcs5000_touchkey", MCS5000_TOUCHKEY }, | |
260 | { "mcs5080_touchkey", MCS5080_TOUCHKEY }, | |
261 | { } | |
262 | }; | |
263 | MODULE_DEVICE_TABLE(i2c, mcs_touchkey_id); | |
264 | ||
265 | static struct i2c_driver mcs_touchkey_driver = { | |
266 | .driver = { | |
267 | .name = "mcs_touchkey", | |
adf779c1 | 268 | .pm = &mcs_touchkey_pm_ops, |
312e8e8a JS |
269 | }, |
270 | .probe = mcs_touchkey_probe, | |
1cb0aa88 | 271 | .remove = mcs_touchkey_remove, |
5f62615e | 272 | .shutdown = mcs_touchkey_shutdown, |
312e8e8a JS |
273 | .id_table = mcs_touchkey_id, |
274 | }; | |
275 | ||
1b92c1cf | 276 | module_i2c_driver(mcs_touchkey_driver); |
312e8e8a JS |
277 | |
278 | /* Module information */ | |
279 | MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); | |
280 | MODULE_AUTHOR("HeungJun Kim <riverful.kim@samsung.com>"); | |
281 | MODULE_DESCRIPTION("Touchkey driver for MELFAS MCS5000/5080 controller"); | |
282 | MODULE_LICENSE("GPL"); |