LINUX 产生PPM 驱动例子

APP：

 

[cpp] view plain copy

 

1. //author:DriverMonkey  
2. //phone:[phone]  
3. //mail:[e-mail]  
4. //qq:196568501  
5.   
6.   
7. #include<stdio.h>  
8. #include<string.h>  
9. #include<sys/types.h>  
10. #include<sys/stat.h>  
11. #include<fcntl.h>  
12. #include<unistd.h>  
13.   
14. #define US (1000)  
15.   
16. #define PPM_CHANEL 8  
17. #define FIX_LOW_TIME 100*US  
18. #define FIX_SYNC_TIME 5000  
19.   
20. static long long ppm_values[(PPM_CHANEL + 1)*2] =   
21.        {FIX_LOW_TIME,1000*US,   // 1  
22.        FIX_LOW_TIME,1000*US,    // 2  
23.        FIX_LOW_TIME,1000*US,    // 3  
24.        FIX_LOW_TIME,1000*US,    // 4  
25.        FIX_LOW_TIME,1000*US,    // 5  
26.        FIX_LOW_TIME,1000*US,    // 6  
27.        FIX_LOW_TIME,1000*US,    // 7  
28.        FIX_LOW_TIME,1000*US,    // 8  
29.        FIX_LOW_TIME,FIX_SYNC_TIME*US, };    // 9  
30.   
31.   
32. int main(int argc,char *args[])  
33. {  
34.     int fd;  
35.     int channel = 0;  
36.     long long value = 0;  
37.       
38.     fd=open("/dev/ppm",O_WRONLY|O_CREAT,0640);  
39.     if(fd < 0)  
40.         return 0;  
41.   
42.     if(argc > 3)   
43.         return;  
44.     channel = atol(args[1]);  
45.     printf("input channle is: %d\n", channel);  
46.       
47.     value  = atol(args[2]);  
48.     printf("input value is: %d\n", (int)value );  
49.   
50.     printf("old value is:%d\n",(int)ppm_values[channel*2 + 1]);  
51.     ppm_values[channel*2 + 1] = value*US;  
52.     printf("new value is:%d\n",(int)ppm_values[channel*2 + 1]);  
53.       
54.     write(fd,ppm_values,sizeof(ppm_values));  
55.   
56.     sleep(20);  
57.     close(fd);  
58. }  

Driver:

 

 

[cpp] view plain copy

 

1. //author:DriverMonkey  
2. //phone:[phone]  
3. //mail:[e-mail]  
4. //qq:196568501  
5.   
6.   
7. #include <linux/kernel.h>    
8. #include <linux/module.h>    
9. #include <linux/cdev.h>    
10. #include <linux/fs.h>    
11. #include <linux/device.h>    
12. #include <linux/syscalls.h>  
13. #include <linux/interrupt.h>   
14. #include <linux/gpio.h>  
15. #include <linux/of_gpio.h>  
16. #include <linux/of_platform.h>  
17. #include <linux/uaccess.h>    
18. #include <linux/string.h>   
19.   
20. #include <mach/gpio.h>  
21. #include <mach/irqs.h>  
22.   
23. #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))  
24.   
25. #define US (1000)  
26.   
27. #define PPM_CHANEL 8  
28. #define FIX_LOW_TIME 100*US  
29.   
30.   
31. struct ppm_dev    
32. {    
33.     struct cdev cdev;    
34.     dev_t devno;    
35.     struct class *ppm_class;   
36.     int message_cdev_open;    
37. };   
38.   
39. struct ppm_dev ppm_dev;    
40.   
41.   
42. static long long ppm_values[(PPM_CHANEL + 1)*2] =   
43.        {FIX_LOW_TIME,1000*US,   // 1  
44.        FIX_LOW_TIME,1000*US,    // 2  
45.        FIX_LOW_TIME,1000*US,    // 3  
46.        FIX_LOW_TIME,1000*US,    // 4  
47.        FIX_LOW_TIME,1000*US,    // 5  
48.        FIX_LOW_TIME,1000*US,    // 6  
49.        FIX_LOW_TIME,1000*US,    // 7  
50.        FIX_LOW_TIME,1000*US,    // 8  
51.        FIX_LOW_TIME,5000*US, }; // 9  
52.   
53. ktime_t ktime;  
54. static struct hrtimer hr_timer;  
55.   
56. static enum hrtimer_restart hrtimer_callback(struct hrtimer *timer)  
57. {  
58.     static int index = 0;  
59.     static ktime_t ktime;  
60.     if(index == ((PPM_CHANEL + 1)*2))  
61.         index = 0;  
62.     ktime.tv64 = ppm_values[index];  
63.     hrtimer_forward(timer, timer->base->get_time(), ktime);  
64.     index++;  
65.     if(ktime.tv64 == FIX_LOW_TIME)  
66.         gpio_direction_output(GPIO_TO_PIN(0,27), 0);  
67.     else  
68.         gpio_direction_output(GPIO_TO_PIN(0,27), 1);  
69.   
70.     //printk("%d\n",(int)ktime.tv64);  
71.       
72.     return HRTIMER_RESTART;  
73. }  
74.   
75.   
76. static int ppm_open(struct inode *node, struct file *fd)    
77. {    
78.     int ret = 0;  
79.       
80.     printk("ppm_open()++\n");   
81.       
82.     ktime = ktime_set( 0, 200*1000);                   // 200us  
83.     hrtimer_init( &hr_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL );  
84.     hr_timer.function = &hrtimer_callback;  
85.     hrtimer_start( &hr_timer, ktime, HRTIMER_MODE_REL );  
86.   
87.   
88.     printk("ppm_open()--\n");    
89.     
90.     return ret;    
91. }     
92.   
93.  ssize_t ppm_write(struct file *pfile,   
94.                     const char __user *buffer,   
95.                     size_t size,   
96.                     loff_t *pnull)  
97.    
98. {     
99.   
100.     printk("ppm_write()++\n");  
101.       
102.     if(size != sizeof(ppm_values))  
103.         return 0;  
104.   
105.     copy_from_user(ppm_values, buffer, size);  
106.   
107.     printk("ppm_write()--\n");  
108.       
109.     return size;  
110. }  
111. static int ppm_fasync(int fd, struct file *filp, int mode)  
112. {  
113.   
114.     printk("ppm_fasync()++\n");  
115.       
116.   
117.     printk("ppm_fasync()--\n");  
118.       
119.     return 0;  
120. }  
121.   
122. static int ppm_release(struct inode *node, struct file *fd)    
123. {    
124.     printk("ppm_release()++\n");   
125.   
126.     hrtimer_cancel(&hr_timer);    
127.     printk("ppm_release()--\n");    
128.     return 0;    
129. }   
130.   
131.   
132. struct file_operations meassage_operatons =    
133. {    
134.     .owner = THIS_MODULE,    
135.     .open = ppm_open,    
136.       
137.     .write = ppm_write,  
138.     .fasync = ppm_fasync,  
139.     .release = ppm_release,    
140. };    
141.     
142. static int __init ppm_init(void)    
143. {    
144.     struct ppm_dev * dev;    
145.     int ret = 0;  
146.     
147.   
148.     dev = &ppm_dev;    
149.   
150.     alloc_chrdev_region(&dev->devno, 0, 1, "out_ppm");    
151.   
152.     dev->ppm_class = class_create(THIS_MODULE, "ppm_class");    
153.     if(IS_ERR(dev->ppm_class)) {    
154.          printk(KERN_ERR"Err: failed in creating class./n");    
155.          goto fail1;     
156.      }    
157.     device_create(dev->ppm_class, NULL, dev->devno, NULL, "ppm");    
158.   
159.       
160.     //init irq  
161.     ret = gpio_request(GPIO_TO_PIN(0,27), "ppm_inter");  
162.     if(ret){  
163.         printk(KERN_ERR"gpio_request() failed !\n");  
164.         goto fail1;  
165.     }  
166.     ret = gpio_direction_output(GPIO_TO_PIN(0,27), 1);  
167.     if(ret){  
168.         printk(KERN_ERR"gpio_direction_input() failed !\n");  
169.         goto fail2;   
170.     }  
171.       
172.     cdev_init(&dev->cdev, &meassage_operatons);    
173.     cdev_add(&dev->cdev, dev->devno, 1);    
174.   
175.       
176.     if(ret){  
177.         printk(KERN_ERR"request_irq() failed ! %d\n", ret);  
178.         goto fail2;  
179.     }  
180.       
181.    printk("ppm_to_app_init(void)--\n");        
182.     return 0;    
183.   
184. fail2:    
185.     gpio_free(GPIO_TO_PIN(0,27));     
186. fail1:      
187.     device_destroy(dev->ppm_class, dev->devno);    
188.     class_destroy(dev->ppm_class);     
189.     cdev_del(&dev->cdev);    
190.     unregister_chrdev_region(dev->devno, 1);    
191.   
192.     return ret;  
193. }    
194. static void __exit ppm_exit(void)    
195. {    
196.     struct ppm_dev *dev = &ppm_dev;    
197.     
198.    // printk("ppm_to_app_exit(void)++\n");   
199.     gpio_free(GPIO_TO_PIN(0,27));  
200.   
201.     device_destroy(dev->ppm_class, dev->devno);    
202.     class_destroy(dev->ppm_class);     
203.     cdev_del(&dev->cdev);    
204.     unregister_chrdev_region(dev->devno, 1);    
205.          
206.    // printk("ppm_to_app_exit(void)--\n");    
207. }    
208. module_init(ppm_init);    
209. module_exit(ppm_exit);    
210.     
211. MODULE_LICENSE("GPL");    
212. MODULE_AUTHOR("Driver Monkey");    
213. MODULE_DESCRIPTION("Test ppm");  

作者：柒月