三种方式控制NanoPi2的GPIO

首先奉上PDF资料，万变不离其宗，掌握核心科技才是最重要的：

 SEC_Users_Manual_S5P4418_Users_Manual_Preliminary_Ver.0.10.pdf (12.59 MB, 下载次数: 37) 

我目前找到了三种方式控制NanoPi2的IO口：

• 通过sysfs(/sys/class/gpio)来操作；
• 通过内核的gpio_set_value函数来操作；
• 通过配置寄存器(0xC001X000)来操作。
  

1. 通过sysfs来操作

这种方法是官方教程给出的办法，这里只给出链接，不再详细解释。

http://bbs.elecfans.com/jishu_527063_1_1.html

2. 通过内核函数来操作
首先，用户层需要和驱动层交流，目前我知道的是两种方式，一种是通过ioctl操作，另一种是基于文件操作。注意，不管是基于ioctl还是文件操作，速度都是在200us这个数量级上，也就是0.2ms。
2.1 基于ioctl操作
下面是一段我自己写的内核代码，以及操作这个内核模块的demo。
2.1.1 内核模块
这个内核模块控制的是GPIOC11引脚，通过ioctl发送SET_VALUE命令可以设置引脚输出电平的高低，也就是LED的亮灭。使用的函数是：

1. gpio_request(GPIOC11, "test");
   
2. gpio_direction_output(GPIOC11, 1);
   
3. gpio_set_value(GPIOC11, HIGH);

复制代码

下面是全部代码：

1. #include <linux/kernel.h>
   
2. #include <linux/module.h>
   
3. #include <linux/gpio.h>
   
4. #include <linux/miscdevice.h>
   
5. #include <linux/fs.h>
   
6. #include <linux/moduleparam.h>
   
7. #include <linux/slab.h>
   
8. #include <linux/cdev.h>
   
9. #include <linux/delay.h>
   
10. #include <linux/compat.h>
    
11. 
    
12. #include <linux/spi/spi.h>
    
13. #include <linux/spi/spidev.h>
    
14. 
    
15. #include <mach/platform.h>
    
16. #include <mach/devices.h>
    
17. 
    
18. #define OUTPUT  1
    
19. #define INPUT   0
    
20. #define HIGH    1
    
21. #define LOW     0
    
22. 
    
23. #define SET_VALUE 123
    
24. unsigned int GPIOC11 = PAD_GPIO_C + 11;
    
25. #define DEVICE_NAME "gpio"
    
26. 
    
27. static int gpio_open(struct inode *inode, struct file *file)
    
28. {
    
29.     gpio_request(GPIOC11, "test");
    
30.     gpio_direction_output(GPIOC11, 1);
    
31.     printk("request GPIOC11\n");
    
32.     return 0;
    
33. }
    
34. 
    
35. static int gpio_close(struct inode *inode, struct file *file){
    
36.     printk("gpio_set_value LOW\n");
    
37.     gpio_set_value(GPIOC11, LOW);
    
38.     gpio_free(GPIOC11);
    
39.     return 0;
    
40. }
    
41. 
    
42. static long 
    
43. gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    
44.     if(cmd == SET_VALUE){
    
45.         if(arg == HIGH){
    
46.             gpio_set_value(GPIOC11, HIGH);
    
47.             printk("gpio_set_value HIGH\n");
    
48.         }else if(arg == LOW){
    
49.             gpio_set_value(GPIOC11, LOW);
    
50.             printk("gpio_set_value LOW\n");
    
51.         }
    
52.     }
    
53.     return -EMSGSIZE;
    
54. }
    
55. 
    
56. static struct file_operations gpio_fops = {
    
57.     .owner = THIS_MODULE,
    
58.     .open = gpio_open,
    
59.     .release = gpio_close,
    
60.     .unlocked_ioctl = gpio_ioctl,
    
61. };
    
62. 
    
63. static struct miscdevice gpio_dev = {
    
64.     .minor          = MISC_DYNAMIC_MINOR,
    
65.     .name          = DEVICE_NAME,
    
66.     .fops          = &gpio_fops,
    
67. };
    
68. 
    
69. volatile unsigned * GPIOCOUT;
    
70. 
    
71. static int gpio_init(void){
    
72.     int ret = 0;
    
73.     printk("init\n");
    
74.     ret = misc_register(&gpio_dev);
    
75.     return ret;
    
76. }
    
77. 
    
78. static void gpio_exit(void){
    
79.     misc_deregister(&gpio_dev);
    
80.     printk("exit\n");
    
81. }
    
82. 
    
83. module_init(gpio_init);
    
84. module_exit(gpio_exit);
    
85. 
    
86. MODULE_LICENSE("GPL");
    
87. MODULE_AUTHOR("YPW");
    

复制代码

下面就是这个模块的Makefile：

1. obj-m:=gpio.o
   
2. mymodule-objs:=gpio
   
3. KDIR:=/home/ypw/Desktop/linux-3.4.y/
   
4. MAKE:=make
   
5. # EXTRA_CFLAGS += -I$(KDIR)arch/arm/mach-s5p4418/prototype/module
   
6. default:
   
7.         $(MAKE) -C $(KDIR) M=$(PWD) modules
   
8. clean:
   
9.         $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean
   

复制代码

如果你需要编译这个内核模块，你首先需要下载linux内核的源代码：https://github.com/friendlyarm/linux-3.4.y，然后将KDIR修改为你的内核地址，make即可编译出gpio.ko。如果不想自己编译，只想使用GPIOC11，可以下载我编译好的内核模块：gpio_ioctl.ko
2.1.2 操作demo
安装和删除内核模块的办法：

1. insmod gpio_ioctl.ko
   
2. rmmod gpio_ioctl.ko

复制代码

安装好以后，如何使用呢？

1. #include <stdio.h>
   
2. #include <fcntl.h>
   
3. #include <sys/ioctl.h>
   
4. #define HIGH    1
   
5. #define LOW     0
   
6. 
   
7. #define SET_VALUE 123
   
8. 
   
9. int main()
   
10. {
    
11.         int fd = open("/dev/gpio", O_RDWR);
    
12.         int i;
    
13.         for(i=0;i<3;i++){
    
14.                 ioctl(fd, SET_VALUE, HIGH);
    
15.                 usleep(100000);
    
16.                 ioctl(fd, SET_VALUE, LOW);
    
17.                 usleep(100000);
    
18.         }
    
19.         close(fd);
    
20.         return 0;
    
21. }
    

复制代码

1. gcc gpio_ioctl.c -o gpio_ioctl
   
2. ./gpio_ioctl

复制代码

编译运行，即可看到灯闪三下。
http://yangpeiwen.com/wp-content/uploads/2016/01/gpio.mp4

2.2 基于文件操作
2.2.1 内核代码：

1. #include <linux/kernel.h>
   
2. #include <linux/module.h>
   
3. #include <linux/gpio.h>
   
4. #include <linux/miscdevice.h>
   
5. #include <linux/fs.h>
   
6. #include <linux/moduleparam.h>
   
7. #include <linux/slab.h>
   
8. #include <linux/cdev.h>
   
9. #include <linux/delay.h>
   
10. #include <linux/compat.h>
    
11. 
    
12. #include <linux/spi/spi.h>
    
13. #include <linux/spi/spidev.h>
    
14. 
    
15. #include <mach/platform.h>
    
16. #include <mach/devices.h>
    
17. 
    
18. #define OUTPUT  1
    
19. #define INPUT   0
    
20. #define HIGH    1
    
21. #define LOW     0
    
22. 
    
23. #define SET_VALUE 123
    
24. unsigned int GPIOC11 = PAD_GPIO_C + 11;
    
25. #define DEVICE_NAME "gpio"
    
26. 
    
27. static int gpio_open(struct inode *inode, struct file *file)
    
28. {
    
29.     gpio_request(GPIOC11, "test");
    
30.     gpio_direction_output(GPIOC11, 1);
    
31.     printk("request GPIOC11\n");
    
32.     return 0;
    
33. }
    
34. 
    
35. static int gpio_close(struct inode *inode, struct file *file){
    
36.     printk("gpio_set_value LOW\n");
    
37.     gpio_set_value(GPIOC11, LOW);
    
38.     gpio_free(GPIOC11);
    
39.     return 0;
    
40. }
    
41. 
    
42. static ssize_t 
    
43. gpio_write(struct file *filp, const char __user *buf,
    
44.     size_t count, loff_t *f_pos) {
    
45.     if (count > 1)
    
46.         return -EMSGSIZE;
    
47.     if(buf[0] == '1'){
    
48.         gpio_set_value(GPIOC11, HIGH);
    
49.         printk("gpio_set_value HIGH\n");
    
50.     }else if(buf[0] == '0'){
    
51.         gpio_set_value(GPIOC11, LOW);
    
52.         printk("gpio_set_value LOW\n");
    
53.     }else{
    
54.         return -EMSGSIZE;
    
55.     }
    
56.     return -EMSGSIZE;
    
57. }
    
58. 
    
59. static struct file_operations gpio_fops = {
    
60.     .owner = THIS_MODULE,
    
61.     .open = gpio_open,
    
62.     .release = gpio_close,
    
63.     .write = gpio_write,
    
64. };
    
65. 
    
66. static struct miscdevice gpio_dev = {
    
67.     .minor          = MISC_DYNAMIC_MINOR,
    
68.     .name          = DEVICE_NAME,
    
69.     .fops          = &gpio_fops,
    
70. };
    
71. 
    
72. volatile unsigned * GPIOCOUT;
    
73. 
    
74. static int gpio_init(void){
    
75.     int ret = 0;
    
76.     printk("init\n");
    
77.     ret = misc_register(&gpio_dev);
    
78.     return ret;
    
79. }
    
80. 
    
81. static void gpio_exit(void){
    
82.     iounmap(GPIOCOUT);
    
83.     misc_deregister(&gpio_dev);
    
84.     printk("exit\n");
    
85. }
    
86. 
    
87. module_init(gpio_init);
    
88. module_exit(gpio_exit);
    
89. 
    
90. MODULE_LICENSE("GPL");
    
91. MODULE_AUTHOR("YPW");
    

复制代码

2.2.2 DEMO代码

1. #include <stdio.h>
   
2. int main()
   
3. {
   
4.         FILE *p = fopen("/dev/gpio", "w");
   
5.         int i;
   
6.         for(i=0;i<3;i++){
   
7.                 fprintf(p, "1");fflush(p);
   
8.                 usleep(100000);
   
9.                 fprintf(p, "0");fflush(p);
   
10.                 usleep(100000);
    
11.         }
    
12.         fclose(p);
    
13.         return 0;
    
14. }

复制代码

这个比较简单，跟上面的一样，我就不过多讲了。如果不想自己编译，可以下载我编译好的内核模块：gpio_file.ko

不过有一点我想说的就是，可以通过寄存器加速控制IO口的速度，这里仅贴一个代码片段，只能在内核中操作，这种操作方式最快可以达到20ns：

1. #include <asm/io.h>
   
2. volatile unsigned * GPIOCOUT;
   
3. GPIOCOUT = ioremap(0xC001C000, 4);
   
4. *GPIOCOUT = 0xFFFF;
   
5. *GPIOCOUT = 0;
   
6. iounmap(GPIOCOUT);

复制代码

3. 通过配置寄存器来操作
下面这个程序在用户层即可操作寄存器，原理是通过mmap将寄存器的地址通过映射到用户层，然后控制方法参考三星PDF即可。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <time.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <unistd.h>
   
7. #include <sys/mman.h>
   
8. 
   
9. #define GPIOC_BASE_ADDRESS   (0xC001C000)
   
10. #define MAP_SIZE 40
    
11. static int dev_fd;
    
12. 
    
13. int main(int argc, char **argv)
    
14. {
    
15.     dev_fd = open("/dev/mem", O_RDWR | O_NDELAY);
    
16.     if (dev_fd < 0)
    
17.     {
    
18.         printf("open(/dev/mem) failed.");
    
19.         return 0;
    
20.     }
    
21.     unsigned int base = (unsigned int)mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, dev_fd, GPIOC_BASE_ADDRESS );
    
22.     #define GPIOCOUT *(unsigned int *)base
    
23.     #define GPIOCOUTENB *(unsigned int *)(base+0x04)
    
24.     #define GPIOCALTFN0 *(unsigned int *)(base+0x20)
    
25.     GPIOCALTFN0 &= ~(3<<22);
    
26.     GPIOCALTFN0 |= (1<<22);
    
27.     GPIOCOUTENB |= (1<<11);
    
28.     GPIOCOUT |= (1<<11);
    
29.     sleep(1);
    
30.     GPIOCOUT &= ~(1<<11);
    
31.     if(dev_fd)
    
32.         close(dev_fd);
    
33.     munmap((unsigned int *)base,MAP_SIZE);
    
34.     return 0;
    
35. }

复制代码

效果是灯亮一秒，然后熄灭。这种方法操作速度很快，可以在80ns级别控制，而且很方便，不需要内核级的代码。