如何使得触摸按键驱动正常运行？

tomxue0126

我的平台: Beagle Bone Black, Ubuntu, kernel: 3.14.29-ti-r46
触摸芯片: MPR121, connect to Beagle's i2c-2

我需要使触摸按键芯片MPR121 (Freescal) 工作在我的 Beagle Bone Black上. 内核驱动是现成的，但是它需要结合device tree才能工作。

我的做法：首先我创建一个设备树文件dts file 用于支持MPR121，如下:

1. tomxue@ubuntu:~/Tom/Source_Code/BBB/Ubuntu/ti-linux-kernel-dev/KERNEL/arch/arm/boot/dts$ cat am335x-bone-i2c2-mpr121.dts
   
2. /*
   
3. * Copyright (C) 2012 Texas Instruments Incorporated -
   
4. *
   
5. * This program is free software; you can redistribute it and/or modify
   
6. * it under the terms of the GNU General Public License version 2 as
   
7. * published by the Free Software Foundation.
   
8. */
   
9. /dts-v1/;
   
10. 
    
11. #include "am33xx.dtsi"
    
12. #include "am335x-bone-common.dtsi"
    
13. #include "am335x-bone-common-pinmux.dtsi"
    
14. 
    
15. / {
    
16.         model = "TI AM335x BeagleBone Black";
    
17.         compatible = "ti,am335x-bone-black", "ti,am335x-bone", "ti,am33xx";
    
18. };
    
19. 
    
20. &ocp {
    
21.         /* i2c2 */
    
22.         P9_19_pinmux {
    
23.                 mode = "i2c";
    
24.         };
    
25.         P9_20_pinmux {
    
26.                 mode = "i2c";
    
27.         };
    
28. };
    
29. 
    
30. &i2c2 {
    
31.         status = "okay";
    
32.         pinctrl-names = "default";
    
33.         pinctrl-0 = <>; /* pinctrl-0 = <&i2c2_pins>; */
    
34. 
    
35.         clock-frequency = <100000>;
    
36. 
    
37.         touchkey: mpr121@5a {
    
38.                 compatible = "fsl,mpr121";
    
39.                 reg = <0x5a>;
    
40.         };
    
41. };
    
42. 
    
43. #include "am335x-bone-i2c2-cape-eeprom.dtsi"

复制代码

对应的Makefile(在dts目录内):

1. dtb-$(CONFIG_ARCH_OMAP2PLUS) += omap2420-h4.dtb \
   
2.     ...
   
3.     am335x-base0033.dtb \
   
4.     am335x-bone-i2c2-mpr121.dtb \
   
5.     am3517-craneboard.dtb \

复制代码

然后我就重新编译内核+设备树，使用BeagleBone提供的脚本烧写内核镜像，模块和设备树。
重启之后，先看看内核版本：

1. root@arm:/dev/input# uname -a
   
2. Linux arm 3.14.29-ti-r46 #2 SMP PREEMPT Tue Apr 21 14:30:14 CST 2015 armv7l armv7l armv7l GNU/Linux

复制代码

加载相应的模块：

1. root@arm:~# insmod mpr121_touchkey.ko

复制代码

可是dmesg中没有任何关于mpr121的信息。我又检查了一下i2c-2总线，mpr121已经连在上面了，地址是0x5a，和设备树中设置的一样：

1. 
   
2. root@arm:~# i2cdetect -y -r 2
   
3.      0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
   
4. 00:          -- -- -- -- -- -- -- -- -- -- -- -- --
   
5. 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   
6. 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   
7. 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   
8. 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   
9. 50: -- -- -- -- UU UU UU UU -- -- 5a -- -- -- -- --
   
10. 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    
11. 70: -- -- -- -- -- -- -- --

复制代码

最后，我看了一下这个目录，按照内核模块源码显示，它应该在input目录下生成相应的设备文件，但是实际上找不到。

1. root@arm:/dev/input# ls
   
2. mice

复制代码

这到底是怎么回事？我需要怎么做才能把该驱动模块正常跑起来？
谢谢！


补充下，内核模块文件为mpr121_touchkey.c ，在这里：drivers/input/keyboard，其源码如下：

1. /*
   
2. * Touchkey driver for Freescale MPR121 Controllor
   
3. *
   
4. * Copyright (C) 2011 Freescale Semiconductor, Inc.
   
5. * Author: Zhang Jiejing <jiejing.zhang@freescale.com>
   
6. *
   
7. * Based on mcs_touchkey.c
   
8. *
   
9. * This program is free software; you can redistribute it and/or modify
   
10. * it under the terms of the GNU General Public License version 2 as
    
11. * published by the Free Software Foundation.
    
12. *
    
13. */
    
14. 
    
15. #include <linux/module.h>
    
16. #include <linux/input.h>
    
17. #include <linux/i2c.h>
    
18. #include <linux/slab.h>
    
19. #include <linux/delay.h>
    
20. #include <linux/bitops.h>
    
21. #include <linux/interrupt.h>
    
22. #include <linux/i2c/mpr121_touchkey.h>
    
23. 
    
24. /* Register definitions */
    
25. #define ELE_TOUCH_STATUS_0_ADDR        0x0
    
26. #define ELE_TOUCH_STATUS_1_ADDR        0X1
    
27. #define MHD_RISING_ADDR                0x2b
    
28. #define NHD_RISING_ADDR                0x2c
    
29. #define NCL_RISING_ADDR                0x2d
    
30. #define FDL_RISING_ADDR                0x2e
    
31. #define MHD_FALLING_ADDR        0x2f
    
32. #define NHD_FALLING_ADDR        0x30
    
33. #define NCL_FALLING_ADDR        0x31
    
34. #define FDL_FALLING_ADDR        0x32
    
35. #define ELE0_TOUCH_THRESHOLD_ADDR        0x41
    
36. #define ELE0_RELEASE_THRESHOLD_ADDR        0x42
    
37. #define AFE_CONF_ADDR                        0x5c
    
38. #define FILTER_CONF_ADDR                0x5d
    
39. 
    
40. /*
    
41. * ELECTRODE_CONF_ADDR: This register configures the number of
    
42. * enabled capacitance sensing inputs and its run/suspend mode.
    
43. */
    
44. #define ELECTRODE_CONF_ADDR                0x5e
    
45. #define ELECTRODE_CONF_QUICK_CHARGE        0x80
    
46. #define AUTO_CONFIG_CTRL_ADDR                0x7b
    
47. #define AUTO_CONFIG_USL_ADDR                0x7d
    
48. #define AUTO_CONFIG_LSL_ADDR                0x7e
    
49. #define AUTO_CONFIG_TL_ADDR                0x7f
    
50. 
    
51. /* Threshold of touch/release trigger */
    
52. #define TOUCH_THRESHOLD                        0x08
    
53. #define RELEASE_THRESHOLD                0x05
    
54. /* Masks for touch and release triggers */
    
55. #define TOUCH_STATUS_MASK                0xfff
    
56. /* MPR121 has 12 keys */
    
57. #define MPR121_MAX_KEY_COUNT                12
    
58. 
    
59. struct mpr121_touchkey {
    
60.         struct i2c_client        *client;
    
61.         struct input_dev        *input_dev;
    
62.         unsigned int                key_val;
    
63.         unsigned int                statusbits;
    
64.         unsigned int                keycount;
    
65.         u16                        keycodes[MPR121_MAX_KEY_COUNT];
    
66. };
    
67. 
    
68. struct mpr121_init_register {
    
69.         int addr;
    
70.         u8 val;
    
71. };
    
72. 
    
73. static const struct mpr121_init_register init_reg_table[] = {
    
74.         { MHD_RISING_ADDR,        0x1 },
    
75.         { NHD_RISING_ADDR,        0x1 },
    
76.         { MHD_FALLING_ADDR,        0x1 },
    
77.         { NHD_FALLING_ADDR,        0x1 },
    
78.         { NCL_FALLING_ADDR,        0xff },
    
79.         { FDL_FALLING_ADDR,        0x02 },
    
80.         { FILTER_CONF_ADDR,        0x04 },
    
81.         { AFE_CONF_ADDR,        0x0b },
    
82.         { AUTO_CONFIG_CTRL_ADDR, 0x0b },
    
83. };
    
84. 
    
85. static irqreturn_t mpr_touchkey_interrupt(int irq, void *dev_id)
    
86. {
    
87.         struct mpr121_touchkey *mpr121 = dev_id;
    
88.         struct i2c_client *client = mpr121->client;
    
89.         struct input_dev *input = mpr121->input_dev;
    
90.         unsigned int key_num, key_val, pressed;
    
91.         int reg;
    
92. 
    
93.         reg = i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_1_ADDR);
    
94.         if (reg < 0) {
    
95.                 dev_err(&client->dev, "i2c read error [%d]\n", reg);
    
96.                 goto out;
    
97.         }
    
98. 
    
99.         reg <<= 8;
    
100.         reg |= i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_0_ADDR);
     
101.         if (reg < 0) {
     
102.                 dev_err(&client->dev, "i2c read error [%d]\n", reg);
     
103.                 goto out;
     
104.         }
     
105. 
     
106.         reg &= TOUCH_STATUS_MASK;
     
107.         /* use old press bit to figure out which bit changed */
     
108.         key_num = ffs(reg ^ mpr121->statusbits) - 1;
     
109.         pressed = reg & (1 << key_num);
     
110.         mpr121->statusbits = reg;
     
111. 
     
112.         key_val = mpr121->keycodes[key_num];
     
113. 
     
114.         input_event(input, EV_MSC, MSC_SCAN, key_num);
     
115.         input_report_key(input, key_val, pressed);
     
116.         input_sync(input);
     
117. 
     
118.         dev_dbg(&client->dev, "key %d %d %s\n", key_num, key_val,
     
119.                 pressed ? "pressed" : "released");
     
120. 
     
121. out:
     
122.         return IRQ_HANDLED;
     
123. }
     
124. 
     
125. static int mpr121_phys_init(const struct mpr121_platform_data *pdata,
     
126.                                       struct mpr121_touchkey *mpr121,
     
127.                                       struct i2c_client *client)
     
128. {
     
129.         const struct mpr121_init_register *reg;
     
130.         unsigned char usl, lsl, tl, eleconf;
     
131.         int i, t, vdd, ret;
     
132. 
     
133.         /* Set up touch/release threshold for ele0-ele11 */
     
134.         for (i = 0; i <= MPR121_MAX_KEY_COUNT; i++) {
     
135.                 t = ELE0_TOUCH_THRESHOLD_ADDR + (i * 2);
     
136.                 ret = i2c_smbus_write_byte_data(client, t, TOUCH_THRESHOLD);
     
137.                 if (ret < 0)
     
138.                         goto err_i2c_write;
     
139.                 ret = i2c_smbus_write_byte_data(client, t + 1,
     
140.                                                 RELEASE_THRESHOLD);
     
141.                 if (ret < 0)
     
142.                         goto err_i2c_write;
     
143.         }
     
144. 
     
145.         /* Set up init register */
     
146.         for (i = 0; i < ARRAY_SIZE(init_reg_table); i++) {
     
147.                 reg = &init_reg_table[i];
     
148.                 ret = i2c_smbus_write_byte_data(client, reg->addr, reg->val);
     
149.                 if (ret < 0)
     
150.                         goto err_i2c_write;
     
151.         }
     
152. 
     
153. 
     
154.         /*
     
155.          * Capacitance on sensing input varies and needs to be compensated.
     
156.          * The internal MPR121-auto-configuration can do this if it's
     
157.          * registers are set properly (based on pdata->vdd_uv).
     
158.          */
     
159.         vdd = pdata->vdd_uv / 1000;
     
160.         usl = ((vdd - 700) * 256) / vdd;
     
161.         lsl = (usl * 65) / 100;
     
162.         tl = (usl * 90) / 100;
     
163.         ret = i2c_smbus_write_byte_data(client, AUTO_CONFIG_USL_ADDR, usl);
     
164.         ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_LSL_ADDR, lsl);
     
165.         ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_TL_ADDR, tl);
     
166. 
     
167.         /*
     
168.          * Quick charge bit will let the capacitive charge to ready
     
169.          * state quickly, or the buttons may not function after system
     
170.          * boot.
     
171.          */
     
172.         eleconf = mpr121->keycount | ELECTRODE_CONF_QUICK_CHARGE;
     
173.         ret |= i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR,
     
174.                                          eleconf);
     
175.         if (ret != 0)
     
176.                 goto err_i2c_write;
     
177. 
     
178.         dev_dbg(&client->dev, "set up with %x keys.\n", mpr121->keycount);
     
179. 
     
180.         return 0;
     
181. 
     
182. err_i2c_write:
     
183.         dev_err(&client->dev, "i2c write error: %d\n", ret);
     
184.         return ret;
     
185. }
     
186. 
     
187. static int mpr_touchkey_probe(struct i2c_client *client,
     
188.                               const struct i2c_device_id *id)
     
189. {
     
190.         const struct mpr121_platform_data *pdata =
     
191.                         dev_get_platdata(&client->dev);
     
192.         struct mpr121_touchkey *mpr121;
     
193.         struct input_dev *input_dev;
     
194.         int error;
     
195.         int i;
     
196. 
     
197.         if (!pdata) {
     
198.                 dev_err(&client->dev, "no platform data defined\n");
     
199.                 return -EINVAL;
     
200.         }
     
201. 
     
202.         if (!pdata->keymap || !pdata->keymap_size) {
     
203.                 dev_err(&client->dev, "missing keymap data\n");
     
204.                 return -EINVAL;
     
205.         }
     
206. 
     
207.         if (pdata->keymap_size > MPR121_MAX_KEY_COUNT) {
     
208.                 dev_err(&client->dev, "too many keys defined\n");
     
209.                 return -EINVAL;
     
210.         }
     
211. 
     
212.         if (!client->irq) {
     
213.                 dev_err(&client->dev, "irq number should not be zero\n");
     
214.                 return -EINVAL;
     
215.         }
     
216. 
     
217.         mpr121 = kzalloc(sizeof(struct mpr121_touchkey), GFP_KERNEL);
     
218.         input_dev = input_allocate_device();
     
219.         if (!mpr121 || !input_dev) {
     
220.                 dev_err(&client->dev, "Failed to allocate memory\n");
     
221.                 error = -ENOMEM;
     
222.                 goto err_free_mem;
     
223.         }
     
224. 
     
225.         mpr121->client = client;
     
226.         mpr121->input_dev = input_dev;
     
227.         mpr121->keycount = pdata->keymap_size;
     
228. 
     
229.         input_dev->name = "Freescale MPR121 Touchkey";
     
230.         input_dev->id.bustype = BUS_I2C;
     
231.         input_dev->dev.parent = &client->dev;
     
232.         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
     
233. 
     
234.         input_dev->keycode = mpr121->keycodes;
     
235.         input_dev->keycodesize = sizeof(mpr121->keycodes[0]);
     
236.         input_dev->keycodemax = mpr121->keycount;
     
237. 
     
238.         for (i = 0; i < pdata->keymap_size; i++) {
     
239.                 input_set_capability(input_dev, EV_KEY, pdata->keymap[i]);
     
240.                 mpr121->keycodes[i] = pdata->keymap[i];
     
241.         }
     
242. 
     
243.         error = mpr121_phys_init(pdata, mpr121, client);
     
244.         if (error) {
     
245.                 dev_err(&client->dev, "Failed to init register\n");
     
246.                 goto err_free_mem;
     
247.         }
     
248. 
     
249.         error = request_threaded_irq(client->irq, NULL,
     
250.                                      mpr_touchkey_interrupt,
     
251.                                      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
     
252.                                      client->dev.driver->name, mpr121);
     
253.         if (error) {
     
254.                 dev_err(&client->dev, "Failed to register interrupt\n");
     
255.                 goto err_free_mem;
     
256.         }
     
257. 
     
258.         error = input_register_device(input_dev);
     
259.         if (error)
     
260.                 goto err_free_irq;
     
261. 
     
262.         i2c_set_clientdata(client, mpr121);
     
263.         device_init_wakeup(&client->dev, pdata->wakeup);
     
264. 
     
265.         return 0;
     
266. 
     
267. err_free_irq:
     
268.         free_irq(client->irq, mpr121);
     
269. err_free_mem:
     
270.         input_free_device(input_dev);
     
271.         kfree(mpr121);
     
272.         return error;
     
273. }
     
274. 
     
275. static int mpr_touchkey_remove(struct i2c_client *client)
     
276. {
     
277.         struct mpr121_touchkey *mpr121 = i2c_get_clientdata(client);
     
278. 
     
279.         free_irq(client->irq, mpr121);
     
280.         input_unregister_device(mpr121->input_dev);
     
281.         kfree(mpr121);
     
282. 
     
283.         return 0;
     
284. }
     
285. 
     
286. #ifdef CONFIG_PM_SLEEP
     
287. static int mpr_suspend(struct device *dev)
     
288. {
     
289.         struct i2c_client *client = to_i2c_client(dev);
     
290. 
     
291.         if (device_may_wakeup(&client->dev))
     
292.                 enable_irq_wake(client->irq);
     
293. 
     
294.         i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR, 0x00);
     
295. 
     
296.         return 0;
     
297. }
     
298. 
     
299. static int mpr_resume(struct device *dev)
     
300. {
     
301.         struct i2c_client *client = to_i2c_client(dev);
     
302.         struct mpr121_touchkey *mpr121 = i2c_get_clientdata(client);
     
303. 
     
304.         if (device_may_wakeup(&client->dev))
     
305.                 disable_irq_wake(client->irq);
     
306. 
     
307.         i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR,
     
308.                                   mpr121->keycount);
     
309. 
     
310.         return 0;
     
311. }
     
312. #endif
     
313. 
     
314. static SIMPLE_DEV_PM_OPS(mpr121_touchkey_pm_ops, mpr_suspend, mpr_resume);
     
315. 
     
316. static const struct i2c_device_id mpr121_id[] = {
     
317.         { "mpr121_touchkey", 0 },
     
318.         { }
     
319. };
     
320. MODULE_DEVICE_TABLE(i2c, mpr121_id);
     
321. 
     
322. static struct i2c_driver mpr_touchkey_driver = {
     
323.         .driver = {
     
324.                 .name        = "mpr121",
     
325.                 .owner        = THIS_MODULE,
     
326.                 .pm        = &mpr121_touchkey_pm_ops,
     
327.         },
     
328.         .id_table        = mpr121_id,
     
329.         .probe                = mpr_touchkey_probe,
     
330.         .remove                = mpr_touchkey_remove,
     
331. };
     
332. 
     
333. module_i2c_driver(mpr_touchkey_driver);
     
334. 
     
335. MODULE_LICENSE("GPL");
     
336. MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>");
     
337. MODULE_DESCRIPTION("Touch Key driver for Freescale MPR121 Chip");
     

复制代码

linuxfellow

运行这个命令看看：
echo mpr121 0x5a > /sys/bus/i2c/devices/i2c-2/new_device

tomxue0126

回复 2# linuxfellow

多谢！
执行上述命令，然后就会多出一个目录，如下：

1. i2c-2# echo mpr121 0x5a > /sys/bus/i2c/devices/i2c
   
2. root@arm:/sys/bus/i2c/devices/i2c-2# ls
   
3. 2-0054  2-0056  2-005a         device   name        power      uevent
   
4. 2-0055  2-0057  delete_device  i2c-dev  new_device  subsystem
   
5. root@arm:/sys/bus/i2c/devices/i2c-2# cd 2-005a/
   
6. root@arm:/sys/bus/i2c/devices/i2c-2/2-005a# ls
   
7. modalias  name  power  subsystem  uevent
   

复制代码

然后呢？里面貌似找不到有用的信息，我的硬件端触摸按键触发的话，也找不到对应的驱动输出
而/dev/input/目录下，还是只有一个mice文件

接下来应该做什么？



   

linuxfellow

/sys/bus/i2c/devices/i2c-2/2-005a 应该就是你的device
从i2c角度，你的设备和驱动都有
你的系统内核没有配置input event, 添加后应该出现/dev/input/event*
然后你可以运行一个evtest程序，你触摸屏幕时，相应的event就会打印在console里