之ds18b20驱动

前几天系统已经一直完成，这俩天做了一下温度传感器的实验，在这里与大家分享。
版本说明：
               平台：OK210；
                os ：Linux2.6.35.7
                驱动类型：ds18b20


驱动程序如下

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/init.h>
   
5. #include <linux/delay.h>
   
6. #include <linux/device.h>
   
7. #include <linux/platform_device.h>
   
8. #include <asm/uaccess.h>
   
9. #include <asm/irq.h>
   
10. #include <asm/io.h>
    
11. #include <linux/miscdevice.h>
    
12. 
    
13. 
    
14. #define DS18B20_RESET   (0x10009)
    
15. #define DS18B20_REL     (0x10011)
    
16. 
    
17. #define SKIP_ROM        0xcc
    
18. #define COVERTT         0x44
    
19. #define READ_MEM        0xbe
    
20. #define WRITE_MEM       0x4e
    
21. 
    
22. #define NINE_BIT           0x1f
    
23. #define TEN_BIT          0x3f
    
24. #define ELE_BIT          0x5f
    
25. #define TWL_BIT          0x7f
    
26. 
    
27. #define TH              100
    
28. #define TL              0
    
29. 
    
30. #define TEMP_H          10000
    
31. #define TEMP_L          -10000
    
32. 
    
33. static unsigned long *gpio_con;
    
34. static unsigned long *gpio_dat;
    
35. 
    
36. static void gpio_cfg_out(unsigned char val)
    
37. {
    
38.         *gpio_con &= ~0xf;
    
39.         *gpio_con |= 0x1;
    
40.         if (val == 0)
    
41.                 *gpio_dat &= ~0x1;
    
42.         else
    
43.                 *gpio_dat |= 0x1;
    
44. }
    
45. 
    
46. static unsigned char gpio_cfg_in(void)
    
47. {
    
48.         *gpio_con &= ~0xf;
    
49.         return *gpio_dat&0x1;
    
50. }
    
51. 
    
52. /* 鍙傜湅鏂囨。P16,娉ㄦ剰鍐?鍜?鐨勬椂闅欒�佹�?/
    
53. static void ds18b20_write8(unsigned char data)
    
54. {
    
55.         int i;
    
56. 
    
57.        for (i = 0; i < 8; i++) {
    
58.                 if ((data & 0x1) == 1) {
    
59.                         gpio_cfg_out(0);
    
60.                         udelay(3);
    
61.                         gpio_cfg_out(1);
    
62.                         udelay(80);
    
63.                 } else {
    
64.                         gpio_cfg_out(0);
    
65.                         udelay(80);
    
66.                         gpio_cfg_out(1);
    
67.                         udelay(3);
    
68.                 }
    
69.                 data >>= 1;
    
70.        }
    
71. }
    
72. 
    
73. /* 鍙傜湅鏂囨。P16,娉ㄦ剰璇?鍜?鐨勬椂闅欒�佹�?/
    
74. static unsigned char ds18b20_read8(void)
    
75. {
    
76.         int i;
    
77.         unsigned char bit;
    
78.         unsigned char data = 0;
    
79. 
    
80.         for (i = 0; i < 8; i++) {
    
81.                 gpio_cfg_out(0);
    
82.                 udelay(2);
    
83.                 gpio_cfg_out(1);
    
84.                 udelay(5);
    
85.                 bit = gpio_cfg_in();
    
86.                 data |= (bit << i);
    
87.                 udelay(5);
    
88.                 gpio_cfg_out(1);
    
89.                 udelay(60);
    
90.         }
    
91.         return data;
    
92. }
    
93. 
    
94. /* 鍙傜湅鏂囨。P15*/
    
95. static void ds18b20_reset(void)
    
96. {
    
97.         unsigned char ret;
    
98. 
    
99.         gpio_cfg_out(0);
    
100.         udelay(500);
     
101.         gpio_cfg_out(1);
     
102.         udelay(30);
     
103.         ret = gpio_cfg_in();
     
104.         udelay(500);
     
105. #if 0
     
106.         if (ret == 0) {
     
107.                 printk("reset ok.\n");
     
108.         } else {
     
109.                 printk("reset failed.\n");
     
110.         }
     
111. #endif
     
112. }
     
113. 
     
114. static void ds18b20_config_rel(unsigned char rel)
     
115. {
     
116.         ds18b20_reset();
     
117.         ds18b20_write8(SKIP_ROM);
     
118.         ds18b20_write8(WRITE_MEM);
     
119.         ds18b20_write8(TH);
     
120.         ds18b20_write8(TL);
     
121.         switch(rel) {
     
122.                 case 9:
     
123.                         ds18b20_write8(NINE_BIT);
     
124.                         break;
     
125.                 case 10:
     
126.                         ds18b20_write8(TEN_BIT);
     
127.                         break;
     
128.                 case 11:
     
129.                         ds18b20_write8(ELE_BIT);
     
130.                         break;
     
131.                 case 12:
     
132.                         ds18b20_write8(TWL_BIT);
     
133.                         break;
     
134.         }
     
135. }
     
136. 
     
137. static int ds18b20_open(struct inode *inode, struct file *file)
     
138. {
     
139.         return 0;
     
140. }
     
141. 
     
142. static int ds18b20_close(struct inode *inode, struct file *file)
     
143. {
     
144.         return 0;
     
145. }
     
146. 
     
147. void bubbleSort(int arr[], int count)
     
148. {
     
149.         int i = count, j;
     
150.         int temp;
     
151. 
     
152.         while(i > 0)
     
153.         {
     
154.                 for(j = 0; j < i - 1; j++)
     
155.                 {
     
156.                         if(arr[j] > arr[j + 1])
     
157.                         {
     
158.                                 temp = arr[j];
     
159.                                 arr[j] = arr[j + 1];
     
160.                                 arr[j + 1] = temp;
     
161.                         }
     
162.                 }
     
163.                 i--;
     
164.         }
     
165. 
     
166. }
     
167. 
     
168. static ssize_t ds18b20_read(struct file *file, char *buf, size_t count, loff_t *pos)
     
169. {
     
170.         unsigned char h8, l8;
     
171.         int i, temp = 0, tvalsum;
     
172.         int value[12];
     
173. 
     
174.         ds18b20_reset();
     
175.         ds18b20_write8(SKIP_ROM);
     
176.         ds18b20_write8(COVERTT);
     
177.         udelay(700);
     
178.       
     
179.         //mdelay(750);
     
180.         
     
181.         for (i = 0; i < 12; ++i) {
     
182.                 ds18b20_reset();
     
183.                 ds18b20_write8(SKIP_ROM);
     
184.                 ds18b20_write8(READ_MEM);
     
185. 
     
186.                 l8 = ds18b20_read8();
     
187.                 h8 = ds18b20_read8();
     
188. 
     
189.                 temp = (h8 << 8) | l8;
     
190.                 if (temp & 0x8000) {
     
191.                         temp = ~temp + 1;
     
192.                 }
     
193.                 temp *= 50;
     
194.                 temp >>= 3;
     
195.                 if ((temp > TEMP_H) || (temp < TEMP_L)) {
     
196.                         --i;
     
197.                         temp = 0;
     
198.                         continue;
     
199.                 }
     
200.                 value[i] = temp;
     
201.         }
     
202.         
     
203.         bubbleSort(value, 12);
     
204.        
     
205.         for(i = 4, tvalsum = 0;i < 8; ++i)
     
206.                 tvalsum+=value[i];
     
207.        
     
208.         temp = (tvalsum) / 4;
     
209.         copy_to_user(buf, &temp, 4);
     
210.         return count;
     
211. }
     
212. 
     
213. static int ds18b20_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
     
214. {
     
215.         unsigned char rel;
     
216. 
     
217.         copy_from_user(&rel, (unsigned char *)arg, 1);
     
218. 
     
219.         switch(cmd) {
     
220.                 case DS18B20_RESET:
     
221.                         ds18b20_reset();
     
222.                         break;
     
223.                 case DS18B20_REL:
     
224.                         ds18b20_config_rel(rel);
     
225.                         break;
     
226.                 default:
     
227.                         return -1;
     
228.         }
     
229.         return 0;
     
230. }
     
231. 
     
232. static struct file_operations ds18b20_fops = {
     
233.         .owner  = THIS_MODULE,
     
234.         .open   = ds18b20_open,
     
235.         .release  = ds18b20_close,
     
236.         .read    = ds18b20_read,
     
237.         .unlocked_ioctl  = ds18b20_ioctl,
     
238. };
     
239. 
     
240. static struct miscdevice ds18b20_miscdev = {
     
241.         .minor  = MISC_DYNAMIC_MINOR,      
     
242.         .name   = "ds18b20",
     
243.         .fops   = &ds18b20_fops,
     
244. };
     
245. 
     
246. static int ds18b20_init(void)
     
247. {
     
248.         misc_register(&ds18b20_miscdev);
     
249. 
     
250.         gpio_con = ioremap(0xE0200C40, 8);
     
251.         gpio_dat = gpio_con + 1;
     
252. 
     
253.         return 0;
     
254. }
     
255. 
     
256. static void ds18b20_exit(void)
     
257. {
     
258.         iounmap(gpio_con);
     
259.         misc_deregister(&ds18b20_miscdev);
     
260. }
     
261. 
     
262. module_init(ds18b20_init);
     
263. module_exit(ds18b20_exit);
     
264. MODULE_LICENSE("GPL");
     

复制代码

下面是makefile文件

1. obj-m := ds18b20_drv.o
   
2. KDIR := /my_dir/linux-smart210/
   
3. all:
   
4.         make -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux- ARCH=arm
   
5. clean:
   
6.         rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.bak *.order
   

复制代码

下面是测试程序

1. #include <stdio.h>
   
2. #include <sys/types.h>
   
3. #include <sys/stat.h>
   
4. #include <fcntl.h>
   
5. #include <sys/ioctl.h>
   
6. #include <unistd.h>
   
7. #include <stdlib.h>
   
8. 
   
9. #define DS18B20_RESET 0x10001
   
10. #define DS18B20_REL   0x10002
    
11. 
    
12. int main(int argc, char *argv[])
    
13. {
    
14.         int fd;
    
15.         int data;
    
16.         unsigned char relbit;
    
17. 
    
18.         fd = open("/dev/ds18b20", O_RDWR);
    
19.         if (fd < 0) {
    
20.                 printf("open ds18b20 failed.\n");
    
21.                 exit(-1);
    
22.         }
    
23. 
    
24.         if (argc < 2)  {
    
25.                 printf("usage:\n %s <9|10|11|12>\n", argv[0]);
    
26.                 exit(-1);
    
27.         }
    
28.       
    
29.         relbit = strtoul(argv[1], NULL, 10);
    
30.         while (1) {
    
31.                 ioctl(fd, DS18B20_REL, &relbit);
    
32.                 read(fd, &data, sizeof(data));
    
33.                 usleep(200000);
    
34.                 printf("%f\n", (float)data / 100);        
    
35.         }
    
36.         close(fd);
    
37.         return 0;
    
38. }
    

复制代码

水平有限，难免有错误，忘各位大神多多指教。

走过 路过 抢沙发