RS485 内核提供的驱动的使用

Linux-4412

你们好！！！
       （1）RS485 模块使用内核提供的驱动，并在内核中配置好RS485模块选项，编译移植内核后，RS485模块能够正常通信吗？
       （2）内核中提供的 RS485 驱动程序 drivers/char/max485_ctl.c 没有 数据的发送和接收功能，若是要使用 RS485 模块通信，是要重新编写 RS485 的驱动程序吗，还是可以将串口的驱动程序修改为 RS485 的驱动程序呢？？

内核提供的 RS485 驱动程序 drivers/char/max485_ctl.c 如下：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. 
   
4. #include <linux/kernel.h>
   
5. #include <linux/fs.h>
   
6. #include <mach/gpio.h>
   
7. #include <plat/gpio-cfg.h>
   
8. #include <linux/miscdevice.h>
   
9. #include <linux/platform_device.h>
   
10. //#include <mach/gpio-bank.h>
    
11. #include <mach/regs-gpio.h>
    
12. #include <asm/io.h>
    
13. #include <linux/regulator/consumer.h>        //cwp, PMIC interafce
    
14. //#include "gps.h"
    
15. #include <linux/delay.h>
    
16. 
    
17. #define GPS_DEBUG
    
18. #ifdef GPS_DEBUG
    
19. #define DPRINTK(x...) printk("MAX485_CTL DEBUG:" x)
    
20. #else
    
21. #define DPRINTK(x...)
    
22. #endif
    
23. 
    
24. #define DRIVER_NAME "max485_ctl"
    
25. 
    
26. int max485_ctl_open(struct inode *inode,struct file *filp)
    
27. {
    
28.         DPRINTK("Device Opened Success!\n");
    
29.         return nonseekable_open(inode,filp);
    
30. }
    
31. 
    
32. int max485_ctl_release(struct inode *inode,struct file *filp)
    
33. {
    
34.         DPRINTK("Device Closed Success!\n");
    
35.         return 0;
    
36. }
    
37. 
    
38. int max485_ctl_pm(bool enable)
    
39. {
    
40.         int ret = 0;
    
41.         printk("firecxx debug: GPS PM return %d\r\n" , ret);
    
42.         return ret;
    
43. };
    
44. 
    
45. long max485_ctl_ioctl(struct file *filp,unsigned int cmd,unsigned long arg)
    
46. {
    
47.         printk("firecxx debug: max485_ctl_ioctl cmd is %d\n" , cmd);
    
48. 
    
49.         switch(cmd)
    
50.         {               
    
51.                 case 1:
    
52.                         if(gpio_request(EXYNOS4_GPA0(7) ,"GPA0_7"))
    
53.                         {
    
54.                                 DPRINTK("max485_ctl GPIO err!\r\n");
    
55.                         }
    
56.                         else
    
57.                         {
    
58.                                 gpio_direction_output(EXYNOS4_GPA0(7), 1);
    
59.                                 DPRINTK("max485_ctl Set High!\n");
    
60.                                 gpio_free(EXYNOS4_GPA0(7));
    
61. 
    
62.                                 mdelay(100);
    
63.                         }
    
64.                                
    
65.                         break;
    
66.                 case 0:
    
67.                         if(gpio_request(EXYNOS4_GPA0(7) ,"GPA0_7"))
    
68.                         {
    
69.                                 DPRINTK("max485_ctl GPIO err!\r\n");
    
70.                         }
    
71.                         else
    
72.                         {                       
    
73.                                 gpio_direction_output(EXYNOS4_GPA0(7),0);
    
74.                                 DPRINTK("max485_ctl Set Low!\n");
    
75.                                 gpio_free(EXYNOS4_GPA0(7));
    
76. 
    
77.                                 mdelay(100);
    
78.                         }
    
79.                        
    
80.                         break;
    
81.                        
    
82.                 default:
    
83.                         DPRINTK("max485_ctl COMMAND ERROR!\n");
    
84.                         return -ENOTTY;
    
85.         }
    
86.         return 0;
    
87. }
    
88. 
    
89. static struct file_operations max485_ctl_ops = {
    
90.         .owner         = THIS_MODULE,
    
91.         .open         = max485_ctl_open,
    
92.         .release= max485_ctl_release,
    
93.         .unlocked_ioctl         = max485_ctl_ioctl,
    
94. };
    
95. 
    
96. static struct miscdevice max485_ctl_dev = {
    
97.         .minor        = MISC_DYNAMIC_MINOR,
    
98.         .fops        = &max485_ctl_ops,
    
99.         .name        = "max485_ctl_pin",
    
100. };
     
101. 
     
102. 
     
103. static int max485_ctl_probe(struct platform_device *pdev)
     
104. {
     
105.         int err = 0;
     
106.        
     
107.         int ret;
     
108.         char *banner = "max485_ctl Initialize\n";
     
109. 
     
110.         printk(banner);
     
111. 
     
112.         err = gpio_request(EXYNOS4_GPA0(7), "GPA0_7");
     
113.         if (err) {
     
114.                 printk(KERN_ERR "failed to request GPA0_7 for "
     
115.                         "max485_ctl control\n");
     
116.                 return err;
     
117.         }
     
118.         gpio_direction_output(EXYNOS4_GPA0(7), 1);
     
119. 
     
120.         s3c_gpio_cfgpin(EXYNOS4_GPA0(7), S3C_GPIO_OUTPUT);
     
121.         gpio_free(EXYNOS4_GPA0(7));
     
122. 
     
123.         ret = misc_register(&max485_ctl_dev);
     
124.         if(ret<0)
     
125.         {
     
126.                 printk("max485_ctl:register device failed!\n");
     
127.                 goto exit;
     
128.         }
     
129. 
     
130.         return 0;
     
131. 
     
132. exit:
     
133.         misc_deregister(&max485_ctl_dev);
     
134.         return ret;
     
135. }
     
136. 
     
137. static int max485_ctl_remove (struct platform_device *pdev)
     
138. {
     
139.         misc_deregister(&max485_ctl_dev);       
     
140. 
     
141.         return 0;
     
142. }
     
143. 
     
144. static int max485_ctl_suspend (struct platform_device *pdev, pm_message_t state)
     
145. {
     
146.         DPRINTK("max485_ctl suspend:power off!\n");
     
147.         return 0;
     
148. }
     
149. 
     
150. static int max485_ctl_resume (struct platform_device *pdev)
     
151. {
     
152.         DPRINTK("max485_ctl resume:power on!\n");
     
153.         return 0;
     
154. }
     
155. 
     
156. static struct platform_driver max485_ctl_driver = {
     
157.         .probe = max485_ctl_probe,
     
158.         .remove = max485_ctl_remove,
     
159.         .suspend = max485_ctl_suspend,
     
160.         .resume = max485_ctl_resume,
     
161.         .driver = {
     
162.                 .name = DRIVER_NAME,
     
163.                 .owner = THIS_MODULE,
     
164.         },
     
165. };
     
166. 
     
167. static void __exit max485_ctl_exit(void)
     
168. {
     
169.         platform_driver_unregister(&max485_ctl_driver);
     
170. }
     
171. 
     
172. static int __init max485_ctl_init(void)
     
173. {
     
174.         return platform_driver_register(&max485_ctl_driver);
     
175. }
     
176. 
     
177. module_init(max485_ctl_init);
     
178. module_exit(max485_ctl_exit);
     
179. 
     
180. MODULE_LICENSE("Dual BSD/GPL");
     

复制代码

TOPEET_moon

485的原理和驱动很简单的。
你可以看下网盘资料
\iTOP4412开发板资料汇总（不含光盘内容）\iTOP-4412开发板视频教程及其相关\08-Linux驱动实验视频教程
\视频27
这几个视频介绍的是485~

Linux-4412

TOPEET_moon 发表于 2017-6-12 15:22
485的原理和驱动很简单的。
你可以看下网盘资料
\iTOP4412开发板资料汇总（不含光盘内容）\iTOP-4412开发 ...

好的，谢你啦！！！