之前实现的一个adc驱动，贴一下

z3j6w9

1. #include <linux/kernel.h>
   
2. #include <linux/init.h>
   
3. #include <linux/module.h>
   
4. #include <linux/delay.h>
   
5. #include <linux/gpio.h>
   
6. #include <linux/fs.h>
   
7. #include <linux/cdev.h>
   
8. #include <linux/slab.h>
   
9. #include <linux/uaccess.h>
   
10. #include <linux/interrupt.h>
    
11. #include <asm/irq.h>
    
12. #include <linux/iio/consumer.h>
    
13. 
    
14. #ifdef CONFIG_OF
    
15. #include <linux/of.h>
    
16. #include <linux/of_gpio.h>
    
17. #include <linux/of_platform.h>
    
18. #endif
    
19. 
    
20. 
    
21. #define DESC(x) 1
    
22. 
    
23. #if DESC("global area")
    
24. 
    
25. static int global_major;
    
26. static struct class *adc0_class;
    
27. static struct device *adc0_device;
    
28. static struct device *adc0_dev = NULL;
    
29. 
    
30. #endif
    
31. static int adc0_probe(struct platform_device *pdev)
    
32. {
    
33.         /*Get io channel*/
    
34.         adc0_dev = &pdev->dev;
    
35.         printk("%s \n", __FUNCTION__);
    
36.        
    
37.         return 0;
    
38.        
    
39. }
    
40. 
    
41. static int adc0_remove(struct platform_device *pdev)
    
42. {
    
43.         return 0;
    
44. }
    
45. 
    
46. static const struct of_device_id of_adc0_match[] = {
    
47.         { .compatible = "sunrex,adc_test" },
    
48.         { /* Sentinel */ }
    
49. };
    
50. 
    
51. static struct platform_driver adc0_driver = {
    
52.         .probe = adc0_probe,
    
53.         .remove = adc0_remove,
    
54.         .driver = {
    
55.                 .owner = THIS_MODULE,
    
56.                 .name  = "adc0",
    
57. #ifdef CONFIG_OF
    
58.                 .of_match_table  = of_adc0_match,
    
59. #endif
    
60.         },
    
61. };
    
62. 
    
63. static ssize_t adc0_read(struct file *filep, char __user *usrbuf, size_t size, loff_t *offset)
    
64. {
    
65.        
    
66.         int val,ret;
    
67.         struct iio_channel *chan; //定义 IIO 通道结构体
    
68. 
    
69.         printk("%s \n", __FUNCTION__);
    
70.         chan = iio_channel_get(adc0_dev, NULL); //获取 IIO 通道结构体
    
71.         ret = iio_read_channel_raw(chan, &val);
    
72. 
    
73.         printk("adc0 value = %u \n", val);
    
74.         if (ret < 0)
    
75.         {
    
76.                 printk("Read channel failed. \n");
    
77.                 return EIO;
    
78.         }
    
79.         copy_to_user(usrbuf, (void *)&val, size);
    
80. 
    
81.          return 0;
    
82. }
    
83. static ssize_t adc0_write(struct file *filep, const char __user *usrbuf, size_t size, loff_t *offset)
    
84. {
    
85.         return 0;
    
86. }
    
87. 
    
88. static int adc0_open(struct inode *inode, struct file *filep)
    
89. {
    
90.         return 0;
    
91. }
    
92. static int adc0_release(struct inode *inode, struct file *filep)
    
93. {
    
94. 
    
95.         return 0;
    
96. }
    
97. 
    
98. 
    
99. static struct file_operations motor_fops = {
    
100.         .owner =   THIS_MODULE,
     
101.         .read  =   adc0_read,
     
102.         .write =   adc0_write,
     
103.         .open  =   adc0_open,
     
104.         .release = adc0_release,
     
105. };
     
106. 
     
107. static int __init adc0_init(void)
     
108. {
     
109.         /*system will auto allocate major*/
     
110.         global_major = register_chrdev(0, "adc0", &motor_fops);
     
111. 
     
112.         /*create class*/
     
113.         adc0_class = class_create(THIS_MODULE, "adc0_drv");
     
114. 
     
115.         /*create device for app*/
     
116.         adc0_device = device_create(adc0_class, NULL, MKDEV(global_major, 0), NULL, "adc0");
     
117.        
     
118. 
     
119.         //if (ret < 0)
     
120.         //        return ret;
     
121.         platform_driver_register(&adc0_driver);
     
122.         return 0;
     
123. }
     
124. 
     
125. static void __exit adc0_exit(void)
     
126. {
     
127.         platform_driver_unregister(&adc0_driver);
     
128.         device_destroy(adc0_class,MKDEV(global_major, 0));
     
129.         class_destroy(adc0_class);
     
130.         //unregister_chrdev_region(MKDEV(global_major, 0), 1);
     
131.         unregister_chrdev(global_major, "adc0");
     
132. }
     
133. 
     
134. module_init(adc0_init);
     
135. module_exit(adc0_exit);
     
136. MODULE_LICENSE("GPL");
     
137. MODULE_AUTHOR("zhang jiawei");
     

复制代码

raindy_s

正在看这方面的内容，先收藏！谢谢！

cheng_86

ADC   MARK