Linux下bb-black的GPIO驱动程序

yisshll

Linux下bb-black的GPIO驱动程序

作者:Mlo_lv
QQ:102578546
(如需转载，请注明出处)

        最近几天拿到了一块bb-black，参照这《LINUX设备驱动程序》想着用来练习Linux下的驱动程序编写。我也是新手，本文仅贡交流之用，有写的不好的地方，还望各位高手指正，不吝赐教！

本文参照了：《Linux下AM335X的GPIO控制》：http://bbs.eeworld.com.cn/thread-327156-1-1.html
                        《Linux下TI omap芯片 MUX 配置分析（以AM335X芯片为例）》：http://blog.chinaunix.net/uid-20543672-id-3067021.html
                        《BeagleBone Black Linux驱动程序开发入门（1）： LED驱动程序》：https://www.cirmall.com/bbs/forum ... id=15284&highlight=
还有其他的一些博文，对我的帮助也很大，在这就不在这一一列举了！

/*-------------------------------------------------------------------------------------------------------------------------------------------------------*/

        我相信各位开发环境搭建已经不成问题了，如果开发环境没有搭建好的话，可以参照：http://bbs.eeworld.com.cn/thread-375502-1-1.html
        说实话，我并没有采用TI提供的SDK包中的交叉编译器，而是采用了embest的arm-none-linux-gnueabi-4.5，其实我尝试了很多编译器，最后还是这个好用，网上可以下到，如果各位功力够深的话，可以自己下载linaro提供的GCC源码制作的交叉编译器！我就偷懒了！还有关于链工具命名规则，可以参照：http://blog.sina.com.cn/s/blog_76550fd70101bd43.html  没事可以了解一下！


说的太多了，进入主题吧：


/*-------------------------------------------------------------------------------------------------------------------------------------------------------*/
内核空间
驱动程序gpioCtl.c：

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/printk.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/cdev.h>
   
6. #include <linux/init.h>
   
7. #include <linux/i2c.h>
   
8. #include <linux/delay.h>
   
9. #include <linux/gpio.h>
   
10. #include <linux/slab.h>
    
11. #include <asm/uaccess.h>
    
12. /*-----------------------------------------------------*/
    
13. #define DEVICE_NAME        "gpioCtl"
    
14. #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
    
15. /*------------------------------------------------------*/
    
16. 
    
17. struct gpio_qset;
    
18. 
    
19. /*设备编号存储结构体*/
    
20. struct dev_num
    
21. {
    
22.         dev_t devNum;
    
23.         unsigned int major;
    
24.         unsigned int minor;
    
25.         unsigned int minor_first;
    
26.         unsigned int count;
    
27. };
    
28. struct dev_num gpio_dev_num;
    
29. 
    
30. /*设备描述结构体*/
    
31. struct gpio_dev
    
32. {
    
33.         struct cdev cdev;
    
34.         struct gpio_qset* dptr;        //设备数据存储链表第一项
    
35.         unsigned long size;        //链表长度(随着申请的GPIO端口数增长)
    
36. };
    
37. struct gpio_dev *gpio_devp;
    
38. 
    
39. /*设备数据存储结构体(采用链式存储,不理解的可以看《数据结构》)*/
    
40. struct gpio_qset
    
41. {
    
42.         unsigned long port;        //端口号 #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
    
43.         unsigned int ddr;        //方向（输入(0)或输出(1)）
    
44.         char value;                //高(1)低(0)电平
    
45.         unsigned long num;        //当前编号(按照申请顺序编号)
    
46.         char label[10];                //申请的GPIO使用名称
    
47.         struct gpio_qset* next;        //指向链表下一项的指针
    
48. };
    
49. 
    
50. /**
    
51. * 功能:初始化gpio_dev
    
52. * *inode:
    
53. * *filp:
    
54. * 描述:用户空间调用open时运行
    
55. *         int (*open) (struct inode *, struct file *);
    
56. * 返回值:0
    
57. */
    
58. static int gpio_open(struct inode *inode, struct file *filp)
    
59. {
    
60.         struct gpio_dev *dev;
    
61.         
    
62.         //由container_of获得结构体指针inode中结构体cdev的指针，
    
63.         //让结构体指针dev指向上述的指针所指的地址，
    
64.         //再让file->private指向这一地址，
    
65.         dev = container_of(inode->i_cdev, struct gpio_dev, cdev);
    
66.         filp->private_data = dev;
    
67.         dev->dptr = NULL;
    
68.         dev->size = 0;
    
69.         //printk(KERN_ERR "gpio_open success!\n");
    
70.         return 0;
    
71. }
    
72. 
    
73. /**
    
74. * 功能:释放申请的GPIO端口以及释放链表(gpio_qset)
    
75. * *inode:
    
76. * *filp:
    
77. * 描述:用户空间调用close时运行
    
78. *         int (*release) (struct inode *, struct file *);
    
79. * 返回值:0
    
80. */
    
81. static int gpio_close(struct inode *inode, struct file *filp)
    
82. {
    
83.         struct gpio_dev *dev = filp->private_data;
    
84.         struct gpio_qset *qset, *qsetTmp;
    
85.         qsetTmp = (struct gpio_qset *)kzalloc(sizeof(struct gpio_qset), GFP_KERNEL);
    
86.         for(qset = dev->dptr; qset->next !=NULL; qset=qsetTmp)
    
87.         {
    
88.                 qsetTmp = qset->next;
    
89.                 gpio_free(qset->port);        //释放申请的端口
    
90.                 kfree(qset);                //释放gpio_qset内存
    
91.         }
    
92.         gpio_free(qsetTmp->port);
    
93.         kfree(qsetTmp);
    
94.          //printk(KERN_ERR "gpio release!\n");
    
95.         return 0;
    
96. }
    
97. 
    
98. /**
    
99. * 功能:申请新的gpio_qset的内存，确定相应的GPIO端口功能
    
100. * *inode:
     
101. * *filp:
     
102. * cmd:实现的功能，
     
103. *     0：读，
     
104. *     1：写，
     
105. *     2：释放GPIO端口
     
106. * arg:执行操作的GPIO端口
     
107. * 描述:用户空间调用ioctl时运行
     
108. *         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
     
109. * 返回值:成功返回操作的GPIO端口号
     
110. *           错误返回相应的错误码
     
111. */
     
112. static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
     
113. {
     
114.         int ret;
     
115.         struct gpio_dev *dev = filp->private_data;
     
116.         struct gpio_qset *qset;
     
117. 
     
118.         //cmd == 2 设计成为释放arg端口的功能，之后申请内存的任务便不必执行了，所以直接返回
     
119.         if(cmd == 2)
     
120.         {
     
121.                 gpio_free(arg);
     
122.                 return arg;
     
123.         }
     
124. 
     
125.         dev->size++;
     
126. 
     
127.         if(dev->dptr == NULL)
     
128.         {
     
129.                 dev->dptr = (struct gpio_qset *)kzalloc(sizeof(struct gpio_qset), GFP_KERNEL);
     
130.                 qset = dev->dptr;
     
131.         }
     
132.         else
     
133.         {
     
134.                 for(qset = dev->dptr; qset->next != NULL; qset = qset->next);                        //找到链表最后一项
     
135.                 qset->next = (struct gpio_qset *)kzalloc(sizeof(struct gpio_qset), GFP_KERNEL);
     
136.                 qset = qset->next;
     
137.         }
     
138.         /*链表数据*/
     
139.         qset->num = dev->size;        //确定自己的编号
     
140.         qset->ddr = cmd;        //确定方向
     
141.         qset->port = arg;        //确定端口号
     
142.         qset->next = NULL;        //最后一项地址清空
     
143. 
     
144.         //printk(KERN_ERR "qset->num=%d,qset->ddr=%d,qset->port=%d\n", qset->num, qset->ddr, qset->port);
     
145.         sprintf(qset->label, "gpio%ld", qset->port);                //确定申请的GPIO使用名称(和端口直接相关)
     
146.         ret = gpio_request(qset->port, qset->label);                //申请端口
     
147.         
     
148.         /*由于gpio_requset会自己判断成功与否并且退出函数，故注释掉对ret的判断
     
149.         if(ret < 0)
     
150.                 printk(KERN_ERR "%s_requset failled!%d \n", qset->label, ret);
     
151.         */
     
152. 
     
153.         /*判断GPIO工作方向(输出或输出)*/        
     
154.         switch(qset->ddr)
     
155.         {
     
156.                 case 0:        ret = gpio_direction_input(qset->port);
     
157.                         if(ret < 0)
     
158.                                 printk(KERN_ERR "gpio_direction_input failled!\n");
     
159.                         break;
     
160.                 case 1:        ret = gpio_direction_output(qset->port, 1);
     
161.                         if(ret < 0)
     
162.                                 printk(KERN_ERR "gpio_direction_output failled!\n");
     
163.                         break;
     
164.                 default:
     
165.                         return -EPERM;        /* Operation not permitted */
     
166.         }
     
167.         return qset->num;
     
168. }
     
169. 
     
170. /**
     
171. * 功能:获取相应端口电平，写入相应的qset_dev->value，写到用户空间的readBuf
     
172. * *inode:
     
173. * *filp:
     
174. * *readBuf:读数据缓存指针，用户空间的指针
     
175. * port:被读取的GPIO端口号
     
176. * *offp:
     
177. * 描述:用户空间调用read时运行
     
178. *         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
     
179. * 返回值:成功返回qset->value
     
180. *           错误返回相应的错误码
     
181. */
     
182. static ssize_t gpio_read (struct file *filp, char __user *readBuf, size_t port, loff_t *offp)
     
183. {
     
184.         long ret;
     
185.         struct gpio_dev *dev = filp->private_data;
     
186.         struct gpio_qset *qset;
     
187.         
     
188.         if(dev->dptr == NULL)        
     
189.                 return -ENODEV;                /* No such device */
     
190.                         
     
191.         for(qset = dev->dptr; qset != NULL; qset = qset->next)
     
192.         {
     
193.                 if(qset->port == port)
     
194.                         break;
     
195.                 if(qset->next == NULL)        
     
196.                         return -ENODEV;        /* No such device */
     
197.         }
     
198. 
     
199.         if(qset->ddr != 0)                //判断是否ioctl设置为读操作
     
200.                 return -EPERM;                /* Operation not permitted */
     
201.         qset->value = gpio_get_value(qset->port);
     
202.         //printk(KERN_ERR "qset->port:%d, qset->value:%d\n", qset->port, qset->value);
     
203.         switch(qset->value)
     
204.         {
     
205.                 case 0:        ret = copy_to_user(readBuf, "0", 1);
     
206.                         break;
     
207.                 case 1:        ret = copy_to_user(readBuf, "1", 1);
     
208.                         break;
     
209.         }
     
210.         return qset->value;
     
211. }
     
212. /**
     
213. * 功能:写入相应端口电平，写入相应的qset_dev->value，数据来自用户空间的writeBuf
     
214. * *inode:
     
215. * *filp:
     
216. * *writeBuf:写数据缓存指针，用户空间的指针
     
217. * port:被写入的GPIO端口号
     
218. * *offp:
     
219. * 描述:用户空间调用write时运行
     
220. *         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
     
221. * 返回值:成功返回qset->value
     
222. *           错误返回相应的错误码
     
223. */
     
224. static ssize_t gpio_write (struct file *filp, const char __user *writeBuf, size_t port, loff_t *offp)
     
225. {
     
226.         long ret;
     
227.         struct gpio_dev *dev = filp->private_data;
     
228.         struct gpio_qset *qset;
     
229. 
     
230.         if(dev->dptr == NULL)        
     
231.                 return -ENODEV;                /* No such device */
     
232.                         
     
233.         for(qset = dev->dptr; qset != NULL; qset = qset->next)
     
234.         {
     
235.         //        printk(KERN_ERR "qset->port=%d,port=%d\n", qset->port, port);
     
236.                 if(qset->port == port)
     
237.                         break;
     
238.                 if(qset->next == NULL)        
     
239.                         return -ENODEV;        /* No such device */
     
240.         }
     
241. 
     
242.         if(qset->ddr != 1)                //判断是否ioctl设置为写操作
     
243.                 return -EPERM;                /* Operation not permitted */
     
244. 
     
245.         ret = copy_from_user(&qset->value, writeBuf, 1);
     
246.         //printk(KERN_ERR "write:%d\n", qset->value);
     
247.         switch(qset->value)
     
248.         {
     
249.                 case '0': qset->value = 0;
     
250.                           gpio_set_value(qset->port, 0);
     
251.                           break;
     
252.                 default : qset->value = 1;
     
253.                           gpio_set_value(qset->port, 1);
     
254.                           break;
     
255.         }
     
256.         return qset->value;
     
257. }
     
258. 
     
259. /*文件操作结构体*/
     
260. static const struct file_operations gpio_fops = {
     
261.         .owner = THIS_MODULE,
     
262.         .open = gpio_open,
     
263.         .unlocked_ioctl = gpio_ioctl,
     
264.         .write = gpio_write,
     
265.         .read = gpio_read,
     
266.         .release = gpio_close,
     
267. };
     
268. 
     
269. /*cdev注册函数*/
     
270. static void gpio_setup_cdev(struct gpio_dev *dev, int index)
     
271. {
     
272.         int ret,devno = gpio_dev_num.devNum + index;
     
273.         cdev_init(&dev->cdev, &gpio_fops);
     
274.         dev->cdev.owner = THIS_MODULE;
     
275.         dev->cdev.ops = &gpio_fops;
     
276. 
     
277.         ret = cdev_add(&dev->cdev, devno, 1);
     
278. 
     
279.         if(ret)
     
280.                 printk(KERN_ERR "error %d : adding gpioCtl%d",ret,index);
     
281. }
     
282. 
     
283. /*设备初始化函数*/
     
284. static int __init omap3gpio_init(void)
     
285. {
     
286.         int ret;
     
287. 
     
288.         gpio_dev_num.count = 1;
     
289.         gpio_dev_num.minor_first = 0;
     
290.         ret = alloc_chrdev_region(&gpio_dev_num.devNum, gpio_dev_num.minor_first, gpio_dev_num.count, DEVICE_NAME);
     
291.         
     
292.         if(ret < 0)        
     
293.                 return ret;
     
294.         
     
295.         gpio_dev_num.major = MAJOR(gpio_dev_num.devNum);
     
296.         gpio_dev_num.minor = MINOR(gpio_dev_num.devNum);
     
297. 
     
298.         gpio_devp = kzalloc(sizeof(struct gpio_dev),GFP_KERNEL);
     
299. 
     
300.         gpio_setup_cdev(gpio_devp, 0);
     
301. 
     
302.         printk(KERN_ERR "gpio alloc_chrdev_region success, major = %d\n", gpio_dev_num.major);
     
303.         return 0;
     
304. }
     
305. 
     
306. /*设备释放函数*/
     
307. static void __exit omap3gpio_exit(void)
     
308. {
     
309.         /*test*/
     
310.         //struct file *filp;
     
311.         //struct inode *inode;
     
312.         //inode = container_of(&gpio_devp->cdev, struct inode, i_cdev);
     
313.         //filp = container_of(gpio_devp, struct file, private_data);
     
314.         //gpio_close(inode, filp);
     
315.         /*test*/
     
316. 
     
317.         cdev_del(&gpio_devp->cdev);
     
318.         kfree(gpio_devp);
     
319.         unregister_chrdev_region(gpio_dev_num.devNum, 1);
     
320.         printk(KERN_ERR "gpio unregister_chrdev_region success, major = %d\n", gpio_dev_num.major);
     
321. }
     
322. 
     
323. MODULE_LICENSE("Dual BSD/GPL");
     
324. MODULE_AUTHOR("Mlo_Lv,Tute-421E-studio");
     
325. MODULE_DESCRIPTION("This module is used to conrtol omap3 gpio");
     
326. 
     
327. module_init(omap3gpio_init);
     
328. module_exit(omap3gpio_exit);

复制代码

        我的驱动程序文件名是gpioCtl.c，如果各位想直接使用这一驱动的话，请使用这个文件名，不要修改。还有就是其中对于GPIO操作的一些函数，例如"gpio_requset()","gpio_free()","gpio_set_value()"，如果有不理解的可以参照：http://blog.csdn.net/beyondioi/article/details/6984406，这篇博文详细讲解了omap系列产品用于操作GPIO的函数，其实看看源码应该能够明白这写函数的意思。


Makefile：

1. #Makefile for gpioCtl.c
   
2. ARCH=arm
   
3. CROSS_COMPILE=arm-none-linux-gnueabi-
   
4. ifneq ($(KERNELRELEASE),)
   
5.         obj-m := gpioCtl.o
   
6. else
   
7.         KERNELDIR ?= /usr/embeded/bb-black/sources/kernel/kernel
   
8.         PWD := $(shell pwd)
   
9. default:
   
10.         make -C $(KERNELDIR) M=$(PWD) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules
    
11. 
    
12. app: app.c
    
13.         $(CROSS_COMPILE)gcc -o app app.c
    
14. clean:
    
15.         $(MAKE) -C $(KERNELDIR) M=$(PWD) clean
    
16.         rm -rf modules.order
    
17. cleanr:        
    
18.         rm *~
    
19. endif

复制代码

        如果各位使用的交叉编译器和我的不一样的话，请修改CROSS_COMPILE（一样的话就免了），然后修改KERNELDIR成为自己内核的存储路径，至此所有有关驱动的程序就写完了，将上面的两短代码放在同一文件目录下，make（编译驱动之前，请先编译好内核），就会生成相应的驱动gpioCtl.ko




/*-------------------------------------------------------------------------------------------------------------------------------------------------------*/
用户空间
应用程序app.c：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <sys/types.h>
   
4. #include <sys/stat.h>
   
5. #include <fcntl.h>
   
6. #include <linux/input.h>
   
7. #include <unistd.h>
   
8. #include <sys/ioctl.h>
   
9. 
   
10. #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
    
11. 
    
12. int main(int argc, char * argv)
    
13. {
    
14.         int i, n, fd;
    
15.         char num;
    
16.         int ret;
    
17.         fd = open("/dev/gpioCtl", O_RDWR);                //打开设备
    
18.         if (fd < 0)
    
19.         {
    
20.             printf("can't open /dev/gpioCtl!\n");
    
21.             exit(1);
    
22.         }
    
23.         sleep(1);
    
24.         ioctl(fd, 1, GPIO_TO_PIN(1,22));                //设置gpio1-22为输出（user:led3）
    
25.         ioctl(fd, 0, GPIO_TO_PIN(2, 1));                //设置gpio2-1 为输入（p8-18）
    
26.         while (1)
    
27.         {
    
28.                 num = 1;
    
29.                 ret = write(fd,"1",GPIO_TO_PIN(1,22));
    
30.                 if(ret < 0)
    
31.                 {
    
32.                         perror("write");
    
33.                         return -1;
    
34.                 }
    
35.                 sleep(1);
    
36.                 ret = write(fd,"0",GPIO_TO_PIN(1,22));
    
37.                 if(ret < 0)
    
38.                 {
    
39.                     perror("write");
    
40.                     return -1;
    

复制代码

        执行make app 交叉编译应用程序。此程序能实现user:led3闪烁效果以及读取gpio2-1的电平！




/*-------------------------------------------------------------------------------------------------------------------------------------------------------*/
shell gpioCtl.sh:

1. #!/bin/sh
   
2. insmod gpioCtl.ko
   
3. mknod /dev/gpioCtl c 245 0
   

复制代码

        我在上面的驱动程序编号申请采用动态分配方式，但是每次分配的主设备号都是254，所以shell中的设备号采用了245，如果各位动态分配的结果不是245，可能需要修改shell，cat /proc/devices 可以察看到分配到的设备号。


        现在将所有文件拷贝到板子上
chmod +x gpioCtl.sh  为脚本增加执行权
./gpioCtl.sh                  运行脚本
./app                             运行程序

如果没有问题的话，现在就能看到 led 闪烁以及读取到的 p2-1的电平了！



        今天就写到这里吧！感谢各位捧场！

GY@艳

大力支持，要多多原创哟！

懒兔子

好复杂的驱动啊

小小希希

楼主应用程序不全啊

武阳

谢谢分享。

我是胡工

你是用什么软件编的程序？