LINUX 产生PPM 驱动例子

APP：

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

Driver:

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