android下调试光感、温度、气压计(驱动篇)

前一段时间刚好要调试几个sensors，最开始手头上啥代码也没有，最后花了几天的时间熟悉了这一块，最

后感觉sensors相对其他的模块还是要简单的多！

 

第一步：
     完成相关驱动的编写，这里最开始我挺犹豫的，我驱动的数据如何上报？？通过ioctl？？我不想那么麻烦，最好在网上找到一个关于用input机制上报对应的值，这样就简单多了，先贴下代码

点击(此处)折叠或打开

1. #include <linux/platform_device.h>
   
2. #include <linux/input-polldev.h>
   
3. #include <linux/kernel.h>
   
4. #include <linux/module.h>
   
5. #include <mach/adc.h>
   
6. //#include <linux/saradc.h>
   
7. 
   
8. #define POLL_INTERVAL    2000     /* poll for input every 2s*/
   
9. #define LUX_LEVEL    4                    /* 0~4 report 5 levels*/
   
10. 
    
11. static struct platform_device *pdev;
    
12. static struct input_dev *idev;
    
13. static struct input_polled_dev *light_sensor_idev;
    
14. 
    
15. 
    
16. 
    
17. static const int sAdcValues[LUX_LEVEL] = {
    
18.     200,
    
19.       1000,
    
20.     1800,
    
21.     3400,
    
22. };
    
23. 
    
24. struct light_sensor_info {
    
25.     int lux_level;
    
26.     int suspend;
    
27. };
    
28. static struct light_sensor_info ls_info;
    
29. 
    
30. /* Sysfs Files */
    
31. static ssize_t light_sensor_lux_level_show(struct device *dev,
    
32.                  struct device_attribute *attr, char *buf)
    
33. {
    
34.     return sprintf(buf, "(%d)\n",get_s3c_adc_convert(3));
    
35. }
    
36. 
    
37. static DEVICE_ATTR(lux_level, 0444, light_sensor_lux_level_show, NULL);
    
38. 
    
39. static struct attribute *light_sensor_attributes[] = {
    
40.     &dev_attr_lux_level.attr,
    
41.     NULL,
    
42. };
    
43. 
    
44. static struct attribute_group light_sensor_attribute_group = {
    
45.     .attrs = light_sensor_attributes,
    
46. };
    
47. 
    
48. 
    
49. /* Device model stuff */
    
50. static int light_sensor_probe(struct platform_device *dev)
    
51. {
    
52.     printk(KERN_INFO "light_sensor: device successfully initialized.\n");
    
53.     return 0;
    
54. }
    
55. 
    
56. #ifdef CONFIG_PM
    
57. static int light_sensor_suspend(struct platform_device *dev, pm_message_t state)
    
58. {
    
59.         ls_info.suspend = 1;
    
60.     return 0;
    
61. }
    
62. 
    
63. static int light_sensor_resume(struct platform_device *dev)
    
64. {
    
65.         ls_info.suspend = 0;
    
66.     return 0;
    
67. }
    
68. #else
    
69.     #define light_sensor_suspend NULL
    
70.     #define light_sensor_resume NULL
    
71. #endif
    
72. 
    
73. static struct platform_driver light_sensor_driver = {
    
74.     .probe = light_sensor_probe,
    
75.     .resume = light_sensor_resume,
    
76.     .suspend = light_sensor_suspend,
    
77.     .driver    = {
    
78.         .name = "light_sensor",
    
79.         .owner = THIS_MODULE,
    
80.     },
    
81. };
    
82. 
    
83. static void light_sensor_dev_poll(struct input_polled_dev *dev)
    
84. {
    
85.         int adc_val, i;
    
86. 
    
87.     adc_val = get_s3c_adc_convert(3);
    
88.     for(i = 0; i < LUX_LEVEL; i++) {
    
89.         if(adc_val < sAdcValues[i])
    
90.             break;
    
91.     }
    
92. 
    
93.    
94.     
    
95.     if(ls_info.lux_level != i) {
    
96.         ls_info.lux_level = i;    
    
97.         input_report_abs(idev, ABS_X, ls_info.lux_level);
    
98.         input_sync(idev);
    
99.         
100.     }    
     
101. 
     
102. }
     
103. 
     
104. /* Module stuff */
     
105. static int __init light_sensor_init(void)
     
106. {
     
107.     
     
108.     int ret;
     
109. 
     
110.     ret = platform_driver_register(&light_sensor_driver);
     
111.     if (ret)
     
112.         goto out;
     
113. 
     
114.     pdev = platform_device_register_simple("light_sensor", -1, NULL, 0);
     
115.     if (IS_ERR(pdev)) {
     
116.         ret = PTR_ERR(pdev);
     
117.         goto out_driver;
     
118.     }
     
119. 
     
120.     ret = sysfs_create_group(&pdev->dev.kobj, &light_sensor_attribute_group);
     
121.     if (ret)
     
122.         goto out_device;
     
123. 
     
124.     light_sensor_idev = input_allocate_polled_device();
     
125.     if (!light_sensor_idev) {
     
126.         ret = -ENOMEM;
     
127.         goto out_group;
     
128.     }
     
129. 
     
130.     light_sensor_idev->poll = light_sensor_dev_poll;//在hal层成功打开的时候会开始轮询
     
131.     light_sensor_idev->poll_interval = POLL_INTERVAL;
     
132. 
     
133.     /* initialize the input class */
     
134.     idev = light_sensor_idev->input;
     
135.     idev->name = "light_sensor";//这个名字到时和你hal写的name必须一致
     
136.     idev->phys = "light_sensor/input0";
     
137.     idev->id.bustype = BUS_ISA;
     
138.     idev->dev.parent = &pdev->dev;
     
139.     idev->evbit[0] = BIT_MASK(EV_ABS);
     
140.     input_set_abs_params(idev, ABS_X,
     
141.             0, LUX_LEVEL, 0, 1);
     
142. 
     
143.     ret = input_register_polled_device(light_sensor_idev);
     
144.     if (ret)
     
145.         goto out_idev;
     
146. 
     
147.     
     
148.     printk(KERN_INFO "huabinbin test light_sensor: driver successfully loaded.\n");
     
149.     return 0;
     
150. 
     
151. out_idev:
     
152.     input_free_polled_device(light_sensor_idev);
     
153. out_group:
     
154.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
     
155. out_device:
     
156.     platform_device_unregister(pdev);
     
157. out_driver:
     
158.     platform_driver_unregister(&light_sensor_driver);
     
159. out:
     
160.     printk(KERN_WARNING "light_sensor: driver init failed (ret=%d)!\n", ret);
     
161.     return ret;
     
162. }
     
163. 
     
164. static void __exit light_sensor_exit(void)
     
165. {
     
166.     input_unregister_polled_device(light_sensor_idev);
     
167.     input_free_polled_device(light_sensor_idev);
     
168.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
     
169.     platform_device_unregister(pdev);
     
170.     platform_driver_unregister(&light_sensor_driver);    
     
171. 
     
172.     printk(KERN_INFO "light_sensor: driver unloaded.\n");
     
173. }
     
174. 
     
175. module_init(light_sensor_init);
     
176. module_exit(light_sensor_exit);

 

经过实际测试，上面的代码有严重的问题，具体代码更新如下：

点击(此处)折叠或打开

1. #include <linux/platform_device.h>
   
2. #include <linux/input-polldev.h>
   
3. #include <linux/kernel.h>
   
4. #include <linux/module.h>
   
5. #include <mach/adc.h>
   
6. #include <linux/kthread.h>
   
7. #include <linux/delay.h>
   
8. //#include <linux/saradc.h>
   
9. 
   
10. #define POLL_INTERVAL    993     /* poll for input every 2s*/
    
11. #define LUX_LEVEL    3            /* 0~4 report 5 levels*/
    
12. #define LUX_MAX 3300
    
13. 
    
14. static struct platform_device *pdev;
    
15. static struct input_dev *idev;
    
16. static struct input_polled_dev *light_sensor_idev;
    
17. static int32_t enable_als(uint32_t enable);
    
18. static struct completion thread_completion;
    
19. static bool bThreadRunning;
    
20. /*define for polling thread*/
    
21. static int polling_function(void* arg);
    
22. static struct task_struct *polling_tsk;
    
23. 
    
24. static const int sAdcValues[LUX_LEVEL] = {
    
25.     200,
    
26.       1000,
    
27.     2300,
    
28.     3400,
    
29. };
    
30. 
    
31. #define SAMPLE_NUM 10
    
32. 
    
33. static int Sample_value[SAMPLE_NUM];
    
34. 
    
35. struct light_sensor_info {
    
36.     int lux_level;
    
37.     int suspend;
    
38. };
    
39. static struct light_sensor_info ls_info;
    
40. 
    
41. /* Sysfs Files */
    
42. static ssize_t light_sensor_enable_show(struct device *dev,
    
43.                  struct device_attribute *attr, char *buf)
    
44. {
    
45.     //return sprintf(buf, "(%d)\n",get_s3c_adc_convert(3));
    
46.     return sprintf(buf, "%d\n", bThreadRunning);
    
47. }
    
48. 
    
49. static ssize_t light_sensor_enable_store(struct device *dev,
    
50.                  struct device_attribute *attr, char *buf,size_t len)
    
51. {
    
52.     uint32_t value = simple_strtoul(buf, NULL, 10);
    
53.    printk("huabinbin test : Enable LS : %d\n",value);
    
54.     enable_als(value);
    
55.     return len;
    
56. }
    
57. 
    
58. static DEVICE_ATTR(ls_enable, 0666, light_sensor_enable_show, light_sensor_enable_store);
    
59. 
    
60. static struct attribute *light_sensor_attributes[] = {
    
61.     &dev_attr_ls_enable.attr,
    
62.     NULL,
    
63. };
    
64. 
    
65. static struct attribute_group light_sensor_attribute_group = {
    
66.     .attrs = light_sensor_attributes,
    
67. };
    
68. 
    
69. static void sample_vol(unsigned int vol)
    
70. {
    
71.     int i = 0;
    
72. 
    
73.     for(i = 0; i < SAMPLE_NUM -1; i++)
    
74.     Sample_value[i] = Sample_value[i+1];
    
75.     Sample_value[SAMPLE_NUM - 1]=vol;
    
76.     return;
    
77. }
    
78. 
    
79. static int get_lux_average()
    
80. {
    
81.     int i,sum = 0;
    
82. 
    
83.     for(i = 0; i < SAMPLE_NUM-1; i++)
    
84.         sum += Sample_value[i];
    
85. 
    
86.     //printk("hbb test %s adc_val = %d\n",__func__,sum / SAMPLE_NUM);
    
87.     return (sum / SAMPLE_NUM);
    
88. }
    
89. 
    
90. static int polling_function(void* arg)
    
91. {
    
92.     int adc_val, i;
    
93.     init_completion(&thread_completion);
    
94. 
    
95.     while (1)
    
96.     {
    
97.         adc_val = get_s3c_adc_convert(3);
    
98.         //printk("hbb test %s adc_val = %d\n",__func__,adc_val);
    
99.         sample_vol(adc_val);
    
100.         #if 0
     
101.         
     
102.         for(i = 0; i <= LUX_LEVEL; i++) {
     
103.             if(adc_val < sAdcValues[i])
     
104.                 break;
     
105.         }
     
106. 
     
107.         if(ls_info.lux_level != i) {
     
108.             ls_info.lux_level = i;    
     
109.             //input_report_abs(idev, ABS_X, ls_info.lux_level);
     
110.             input_report_abs(idev, ABS_MISC, ls_info.lux_level);
     
111.             input_sync(idev);
     
112.             
     
113.             printk(KERN_INFO "light_sensor: light_sensor_dev_poll lux_level = %d\n",sAdcValues[ls_info.lux_level]);
     
114.         }    
     
115.         #else
     
116.         input_report_abs(idev, ABS_MISC,get_lux_average());
     
117.         input_sync(idev);
     
118.         #endif
     
119.         if (bThreadRunning == false)
     
120.             break;
     
121.         msleep(POLL_INTERVAL);
     
122. 
     
123.     };
     
124.     complete(&thread_completion);
     
125.     return 0;
     
126. }
     
127. 
     
128. static int32_t enable_als(uint32_t enable)
     
129. {
     
130.     int32_t ret;
     
131.     if (enable)
     
132.     {
     
133. 
     
134.         if (bThreadRunning == 0)
     
135.         {
     
136.             bThreadRunning = 1;
     
137.             polling_tsk = kthread_run(polling_function,NULL,"ls_polling");
     
138.         }
     
139.         else
     
140.         {
     
141.          printk("huabinbin test : thread has running\n");
     
142.         }
     
143.     }
     
144.     else
     
145.     {
     
146.         if (bThreadRunning)
     
147.         {
     
148.             bThreadRunning = false;
     
149.             wait_for_completion(&thread_completion);
     
150.             polling_tsk = NULL;
     
151.         }
     
152.     }
     
153.     return ret;
     
154. }
     
155. 
     
156. /* Device model stuff */
     
157. static int light_sensor_probe(struct platform_device *dev)
     
158. {
     
159.     printk(KERN_INFO "light_sensor: device successfully initialized.\n");
     
160.     return 0;
     
161. }
     
162. 
     
163. #ifdef CONFIG_PM
     
164. static int light_sensor_suspend(struct platform_device *dev, pm_message_t state)
     
165. {
     
166.         ls_info.suspend = 1;
     
167.     return 0;
     
168. }
     
169. 
     
170. static int light_sensor_resume(struct platform_device *dev)
     
171. {
     
172.         ls_info.suspend = 0;
     
173.     return 0;
     
174. }
     
175. #else
     
176.     #define light_sensor_suspend NULL
     
177.     #define light_sensor_resume NULL
     
178. #endif
     
179. 
     
180. static struct platform_driver light_sensor_driver = {
     
181.     .probe = light_sensor_probe,
     
182.     .resume = light_sensor_resume,
     
183.     .suspend = light_sensor_suspend,
     
184.     .driver    = {
     
185.         .name = "light_sensor",
     
186.         .owner = THIS_MODULE,
     
187.     },
     
188. };
     
189. 
     
190. static void light_sensor_dev_poll(struct input_polled_dev *dev)
     
191. {
     
192.     //printk("huabinbin test light_sensor_dev_poll get adc %d\n",get_s3c_adc_convert(3));
     
193.     int adc_val, i;
     
194. 
     
195.     adc_val = get_s3c_adc_convert(3);
     
196.     for(i = 0; i < LUX_LEVEL; i++) {
     
197.         if(adc_val < sAdcValues[i])
     
198.             break;
     
199.     }
     
200. 
     
201.     //printk("huabinbin test get adc %d\n",get_s3c_adc_convert(3));
     
202.     
     
203.     if(ls_info.lux_level != i) {
     
204.         ls_info.lux_level = i;    
     
205.         input_report_abs(idev, ABS_X, ls_info.lux_level);
     
206.         input_sync(idev);
     
207.         
     
208.         //printk(KERN_INFO "light_sensor: light_sensor_dev_poll lux_level = %d\n",sAdcValues[ls_info.lux_level]);
     
209.     }    
     
210. 
     
211. }
     
212. 
     
213. /* Module stuff */
     
214. static int __init light_sensor_init(void)
     
215. {
     
216.     
     
217.     int ret;
     
218. 
     
219.     ret = platform_driver_register(&light_sensor_driver);
     
220.     if (ret)
     
221.         goto out;
     
222. 
     
223.     pdev = platform_device_register_simple("light_sensor", -1, NULL, 0);
     
224.     if (IS_ERR(pdev)) {
     
225.         ret = PTR_ERR(pdev);
     
226.         goto out_driver;
     
227.     }
     
228. 
     
229.     ret = sysfs_create_group(&pdev->dev.kobj, &light_sensor_attribute_group);
     
230.     if (ret)
     
231.         goto out_device;
     
232. 
     
233. //    light_sensor_idev = input_allocate_polled_device();
     
234. //    if (!light_sensor_idev) {
     
235.     //    ret = -ENOMEM;
     
236.     //    goto out_group;
     
237.     //}
     
238. 
     
239.     bThreadRunning = false;
     
240.     
     
241.     //light_sensor_idev->poll = light_sensor_dev_poll;
     
242.     //light_sensor_idev->poll_interval = POLL_INTERVAL;
     
243. 
     
244.     /* initialize the input class */
     
245.     //idev = light_sensor_idev->input;
     
246.     idev = input_allocate_device();
     
247.     idev->name = "light_sensor";
     
248.     idev->phys = "light_sensor/input0";
     
249.     idev->id.bustype = BUS_ISA;
     
250.     idev->dev.parent = &pdev->dev;
     
251.     idev->evbit[0] = BIT_MASK(EV_ABS);
     
252.     //input_set_abs_params(idev, ABS_MISC,0, LUX_LEVEL, 0, 1);
     
253.     input_set_abs_params(idev, ABS_MISC,0, LUX_MAX, 0, 1);
     
254. 
     
255.     ret = input_register_device(idev);
     
256.     if (ret)
     
257.         goto out_idev;
     
258. 
     
259.     
     
260.     printk(KERN_INFO "huabinbin test light_sensor: driver successfully loaded.\n");
     
261.     return 0;
     
262. 
     
263. out_idev:
     
264.      input_free_device(idev);
     
265. out_group:
     
266.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
     
267. out_device:
     
268.     platform_device_unregister(pdev);
     
269. out_driver:
     
270.     platform_driver_unregister(&light_sensor_driver);
     
271. out:
     
272.     printk(KERN_WARNING "light_sensor: driver init failed (ret=%d)!\n", ret);
     
273.     return ret;
     
274. }
     
275. 
     
276. static void __exit light_sensor_exit(void)
     
277. {
     
278.     input_unregister_polled_device(light_sensor_idev);
     
279.     input_free_polled_device(light_sensor_idev);
     
280.     sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group);
     
281.     platform_device_unregister(pdev);
     
282.     platform_driver_unregister(&light_sensor_driver);    
     
283. 
     
284.     printk(KERN_INFO "light_sensor: driver unloaded.\n");
     
285. }
     
286. 
     
287. module_init(light_sensor_init);
     
288. module_exit(light_sensor_exit);
     
289. 
     
290. MODULE_AUTHOR("bb.hua@unistrong.com");
     
291. MODULE_DESCRIPTION("Light Sensor Driver - po188");
     
292. MODULE_LICENSE("GPL");