1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/bitops.h>
16#include <linux/delay.h>
17#include <linux/i2c.h>
18#include <linux/input.h>
19#include <linux/interrupt.h>
20#include <linux/module.h>
21#include <linux/of.h>
22#include <linux/property.h>
23#include <linux/regulator/consumer.h>
24#include <linux/slab.h>
25
26
27#define ELE_TOUCH_STATUS_0_ADDR 0x0
28#define ELE_TOUCH_STATUS_1_ADDR 0X1
29#define MHD_RISING_ADDR 0x2b
30#define NHD_RISING_ADDR 0x2c
31#define NCL_RISING_ADDR 0x2d
32#define FDL_RISING_ADDR 0x2e
33#define MHD_FALLING_ADDR 0x2f
34#define NHD_FALLING_ADDR 0x30
35#define NCL_FALLING_ADDR 0x31
36#define FDL_FALLING_ADDR 0x32
37#define ELE0_TOUCH_THRESHOLD_ADDR 0x41
38#define ELE0_RELEASE_THRESHOLD_ADDR 0x42
39#define AFE_CONF_ADDR 0x5c
40#define FILTER_CONF_ADDR 0x5d
41
42
43
44
45
46#define ELECTRODE_CONF_ADDR 0x5e
47#define ELECTRODE_CONF_QUICK_CHARGE 0x80
48#define AUTO_CONFIG_CTRL_ADDR 0x7b
49#define AUTO_CONFIG_USL_ADDR 0x7d
50#define AUTO_CONFIG_LSL_ADDR 0x7e
51#define AUTO_CONFIG_TL_ADDR 0x7f
52
53
54#define TOUCH_THRESHOLD 0x08
55#define RELEASE_THRESHOLD 0x05
56
57#define TOUCH_STATUS_MASK 0xfff
58
59#define MPR121_MAX_KEY_COUNT 12
60
61struct mpr121_touchkey {
62 struct i2c_client *client;
63 struct input_dev *input_dev;
64 unsigned int statusbits;
65 unsigned int keycount;
66 u32 keycodes[MPR121_MAX_KEY_COUNT];
67};
68
69struct mpr121_init_register {
70 int addr;
71 u8 val;
72};
73
74static const struct mpr121_init_register init_reg_table[] = {
75 { MHD_RISING_ADDR, 0x1 },
76 { NHD_RISING_ADDR, 0x1 },
77 { MHD_FALLING_ADDR, 0x1 },
78 { NHD_FALLING_ADDR, 0x1 },
79 { NCL_FALLING_ADDR, 0xff },
80 { FDL_FALLING_ADDR, 0x02 },
81 { FILTER_CONF_ADDR, 0x04 },
82 { AFE_CONF_ADDR, 0x0b },
83 { AUTO_CONFIG_CTRL_ADDR, 0x0b },
84};
85
86static void mpr121_vdd_supply_disable(void *data)
87{
88 struct regulator *vdd_supply = data;
89
90 regulator_disable(vdd_supply);
91}
92
93static struct regulator *mpr121_vdd_supply_init(struct device *dev)
94{
95 struct regulator *vdd_supply;
96 int err;
97
98 vdd_supply = devm_regulator_get(dev, "vdd");
99 if (IS_ERR(vdd_supply)) {
100 dev_err(dev, "failed to get vdd regulator: %ld\n",
101 PTR_ERR(vdd_supply));
102 return vdd_supply;
103 }
104
105 err = regulator_enable(vdd_supply);
106 if (err) {
107 dev_err(dev, "failed to enable vdd regulator: %d\n", err);
108 return ERR_PTR(err);
109 }
110
111 err = devm_add_action(dev, mpr121_vdd_supply_disable, vdd_supply);
112 if (err) {
113 regulator_disable(vdd_supply);
114 dev_err(dev, "failed to add disable regulator action: %d\n",
115 err);
116 return ERR_PTR(err);
117 }
118
119 return vdd_supply;
120}
121
122static irqreturn_t mpr_touchkey_interrupt(int irq, void *dev_id)
123{
124 struct mpr121_touchkey *mpr121 = dev_id;
125 struct i2c_client *client = mpr121->client;
126 struct input_dev *input = mpr121->input_dev;
127 unsigned long bit_changed;
128 unsigned int key_num;
129 int reg;
130
131 reg = i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_1_ADDR);
132 if (reg < 0) {
133 dev_err(&client->dev, "i2c read error [%d]\n", reg);
134 goto out;
135 }
136
137 reg <<= 8;
138 reg |= i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_0_ADDR);
139 if (reg < 0) {
140 dev_err(&client->dev, "i2c read error [%d]\n", reg);
141 goto out;
142 }
143
144 reg &= TOUCH_STATUS_MASK;
145
146 bit_changed = reg ^ mpr121->statusbits;
147 mpr121->statusbits = reg;
148 for_each_set_bit(key_num, &bit_changed, mpr121->keycount) {
149 unsigned int key_val, pressed;
150
151 pressed = reg & BIT(key_num);
152 key_val = mpr121->keycodes[key_num];
153
154 input_event(input, EV_MSC, MSC_SCAN, key_num);
155 input_report_key(input, key_val, pressed);
156
157 dev_dbg(&client->dev, "key %d %d %s\n", key_num, key_val,
158 pressed ? "pressed" : "released");
159
160 }
161 input_sync(input);
162
163out:
164 return IRQ_HANDLED;
165}
166
167static int mpr121_phys_init(struct mpr121_touchkey *mpr121,
168 struct i2c_client *client, int vdd_uv)
169{
170 const struct mpr121_init_register *reg;
171 unsigned char usl, lsl, tl, eleconf;
172 int i, t, vdd, ret;
173
174
175 for (i = 0; i <= MPR121_MAX_KEY_COUNT; i++) {
176 t = ELE0_TOUCH_THRESHOLD_ADDR + (i * 2);
177 ret = i2c_smbus_write_byte_data(client, t, TOUCH_THRESHOLD);
178 if (ret < 0)
179 goto err_i2c_write;
180 ret = i2c_smbus_write_byte_data(client, t + 1,
181 RELEASE_THRESHOLD);
182 if (ret < 0)
183 goto err_i2c_write;
184 }
185
186
187 for (i = 0; i < ARRAY_SIZE(init_reg_table); i++) {
188 reg = &init_reg_table[i];
189 ret = i2c_smbus_write_byte_data(client, reg->addr, reg->val);
190 if (ret < 0)
191 goto err_i2c_write;
192 }
193
194
195
196
197
198
199
200 vdd = vdd_uv / 1000;
201 usl = ((vdd - 700) * 256) / vdd;
202 lsl = (usl * 65) / 100;
203 tl = (usl * 90) / 100;
204 ret = i2c_smbus_write_byte_data(client, AUTO_CONFIG_USL_ADDR, usl);
205 ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_LSL_ADDR, lsl);
206 ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_TL_ADDR, tl);
207
208
209
210
211
212
213 eleconf = mpr121->keycount | ELECTRODE_CONF_QUICK_CHARGE;
214 ret |= i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR,
215 eleconf);
216 if (ret != 0)
217 goto err_i2c_write;
218
219 dev_dbg(&client->dev, "set up with %x keys.\n", mpr121->keycount);
220
221 return 0;
222
223err_i2c_write:
224 dev_err(&client->dev, "i2c write error: %d\n", ret);
225 return ret;
226}
227
228static int mpr_touchkey_probe(struct i2c_client *client,
229 const struct i2c_device_id *id)
230{
231 struct device *dev = &client->dev;
232 struct regulator *vdd_supply;
233 int vdd_uv;
234 struct mpr121_touchkey *mpr121;
235 struct input_dev *input_dev;
236 int error;
237 int i;
238
239 if (!client->irq) {
240 dev_err(dev, "irq number should not be zero\n");
241 return -EINVAL;
242 }
243
244 vdd_supply = mpr121_vdd_supply_init(dev);
245 if (IS_ERR(vdd_supply))
246 return PTR_ERR(vdd_supply);
247
248 vdd_uv = regulator_get_voltage(vdd_supply);
249
250 mpr121 = devm_kzalloc(dev, sizeof(*mpr121), GFP_KERNEL);
251 if (!mpr121)
252 return -ENOMEM;
253
254 input_dev = devm_input_allocate_device(dev);
255 if (!input_dev)
256 return -ENOMEM;
257
258 mpr121->client = client;
259 mpr121->input_dev = input_dev;
260 mpr121->keycount = device_property_read_u32_array(dev, "linux,keycodes",
261 NULL, 0);
262 if (mpr121->keycount > MPR121_MAX_KEY_COUNT) {
263 dev_err(dev, "too many keys defined (%d)\n", mpr121->keycount);
264 return -EINVAL;
265 }
266
267 error = device_property_read_u32_array(dev, "linux,keycodes",
268 mpr121->keycodes,
269 mpr121->keycount);
270 if (error) {
271 dev_err(dev,
272 "failed to read linux,keycode property: %d\n", error);
273 return error;
274 }
275
276 input_dev->name = "Freescale MPR121 Touchkey";
277 input_dev->id.bustype = BUS_I2C;
278 input_dev->dev.parent = dev;
279 if (device_property_read_bool(dev, "autorepeat"))
280 __set_bit(EV_REP, input_dev->evbit);
281 input_set_capability(input_dev, EV_MSC, MSC_SCAN);
282
283 input_dev->keycode = mpr121->keycodes;
284 input_dev->keycodesize = sizeof(mpr121->keycodes[0]);
285 input_dev->keycodemax = mpr121->keycount;
286
287 for (i = 0; i < mpr121->keycount; i++)
288 input_set_capability(input_dev, EV_KEY, mpr121->keycodes[i]);
289
290 error = mpr121_phys_init(mpr121, client, vdd_uv);
291 if (error) {
292 dev_err(dev, "Failed to init register\n");
293 return error;
294 }
295
296 error = devm_request_threaded_irq(dev, client->irq, NULL,
297 mpr_touchkey_interrupt,
298 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
299 dev->driver->name, mpr121);
300 if (error) {
301 dev_err(dev, "Failed to register interrupt\n");
302 return error;
303 }
304
305 error = input_register_device(input_dev);
306 if (error)
307 return error;
308
309 i2c_set_clientdata(client, mpr121);
310 device_init_wakeup(dev,
311 device_property_read_bool(dev, "wakeup-source"));
312
313 return 0;
314}
315
316static int __maybe_unused mpr_suspend(struct device *dev)
317{
318 struct i2c_client *client = to_i2c_client(dev);
319
320 if (device_may_wakeup(&client->dev))
321 enable_irq_wake(client->irq);
322
323 i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR, 0x00);
324
325 return 0;
326}
327
328static int __maybe_unused mpr_resume(struct device *dev)
329{
330 struct i2c_client *client = to_i2c_client(dev);
331 struct mpr121_touchkey *mpr121 = i2c_get_clientdata(client);
332
333 if (device_may_wakeup(&client->dev))
334 disable_irq_wake(client->irq);
335
336 i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR,
337 mpr121->keycount);
338
339 return 0;
340}
341
342static SIMPLE_DEV_PM_OPS(mpr121_touchkey_pm_ops, mpr_suspend, mpr_resume);
343
344static const struct i2c_device_id mpr121_id[] = {
345 { "mpr121_touchkey", 0 },
346 { }
347};
348MODULE_DEVICE_TABLE(i2c, mpr121_id);
349
350#ifdef CONFIG_OF
351static const struct of_device_id mpr121_touchkey_dt_match_table[] = {
352 { .compatible = "fsl,mpr121-touchkey" },
353 { },
354};
355MODULE_DEVICE_TABLE(of, mpr121_touchkey_dt_match_table);
356#endif
357
358static struct i2c_driver mpr_touchkey_driver = {
359 .driver = {
360 .name = "mpr121",
361 .pm = &mpr121_touchkey_pm_ops,
362 .of_match_table = of_match_ptr(mpr121_touchkey_dt_match_table),
363 },
364 .id_table = mpr121_id,
365 .probe = mpr_touchkey_probe,
366};
367
368module_i2c_driver(mpr_touchkey_driver);
369
370MODULE_LICENSE("GPL");
371MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>");
372MODULE_DESCRIPTION("Touch Key driver for Freescale MPR121 Chip");
373
