【米尔MYD-C8MMX开发板】+ 6、gpio驱动led灯linux驱动程序

TLLED

        开始学习在米尔MYD-C8MMX开发板linux开发环境下编写驱动程序。开发板使用的linxu版本是linux4.14板，给予linux4版本下的驱动都是基于设备树结构进行驱动程序开发的。下面使用板卡上的LED灯，使用GPIO 来驱动LED。


    一、硬件电路
   
    开发板上的LED灯对应的端口，这次使用的端口是GPIO5_4，LED1指示灯，LED2用指示系统运行就不在改动LED2。
   
     
   

    一、驱动程序


    1.1、驱动测试的设备树文件在/MYIR-i.MX8MM-Linux/arch/arm64/boot/dts/freescale/下面，找到对应开发板的dts文件   myb-fsl-imx8mm-evk.dts   查找有关开发板上有关LED1的设备，厂家已经把LED灯端口都配置好了。
   
   

    1.2、驱动程序源码
    1.2.1、userled.c

1. #include <linux/types.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/delay.h>
   
4. #include <linux/ide.h>
   
5. #include <linux/init.h>
   
6. #include <linux/module.h>
   
7. #include <linux/errno.h>
   
8. #include <linux/gpio.h>
   
9. #include <linux/cdev.h>
   
10. #include <linux/device.h>
    
11. #include <linux/of.h>
    
12. #include <linux/of_address.h>
    
13. #include <linux/of_gpio.h>
    
14. #include <asm/uaccess.h>
    
15. #include <asm/io.h>
    
16. 
    
17. 
    
18. #define GPIOLED_CNT                        1                           
    
19. #define GPIOLED_NAME                "userled"         
    
20. #define LEDOFF                                 0                        
    
21. #define LEDON                                 1                        
    
22. 
    
23. 
    
24. struct userled_dev{
    
25.         dev_t devid;                        
    
26.         struct cdev cdev;                 
    
27.         struct class *class;         
    
28.         struct device *device;
    
29.         int major;                                 
    
30.         int minor;                                 
    
31.         struct device_node        *nd;  
    
32.         int led_gpio;                        
    
33. };
    
34. 
    
35. struct userled_dev userled;         
    
36. 
    
37. //led open
    
38. static int led_open(struct inode *inode, struct file *filp)
    
39. {
    
40.         filp->private_data = &userled;
    
41.         return 0;
    
42. }
    
43. //led read
    
44. static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
    
45. {
    
46.         return 0;
    
47. }
    
48. //led write
    
49. static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
    
50. {
    
51.         int retvalue;
    
52.         unsigned char databuf[1];
    
53.         unsigned char ledstat;
    
54.         struct userled_dev *dev = filp->private_data;
    
55. 
    
56.         retvalue = copy_from_user(databuf, buf, cnt);
    
57.         if(retvalue < 0)
    
58.         {
    
59.                 printk("kernel write failed!\r\n");
    
60.                 return -EFAULT;
    
61.         }
    
62. 
    
63.         ledstat = databuf[0];        
    
64. 
    
65.         if(ledstat == LEDON)
    
66.         {        
    
67.                 gpio_set_value(dev->led_gpio, 0);        
    
68.         }
    
69.         else if(ledstat == LEDOFF)
    
70.         {
    
71.                 gpio_set_value(dev->led_gpio, 1);        
    
72.         }
    
73.         return 0;
    
74. }
    
75. //led release
    
76. static int led_release(struct inode *inode, struct file *filp)
    
77. {
    
78.         return 0;
    
79. }
    
80. //fops
    
81. static struct file_operations userled_fops = {
    
82.         .owner = THIS_MODULE,
    
83.         .open = led_open,
    
84.         .read = led_read,
    
85.         .write = led_write,
    
86.         .release =         led_release,
    
87. };
    
88. //led init
    
89. static int __init led_init(void)
    
90. {
    
91.         int ret = 0;
    
92. 
    
93.         userled.nd = of_find_node_by_path("/leds/user");
    
94.         if(userled.nd == NULL)
    
95.         {
    
96.                 printk("userled node not find!\r\n");
    
97.                 return -EINVAL;
    
98.         } else
    
99.         {
    
100.                 printk("userled node find!\r\n");
     
101.         }
     
102. 
     
103.         userled.led_gpio = of_get_named_gpio(userled.nd, "gpios", 0);
     
104.         if(userled.led_gpio < 0)
     
105.         {
     
106.                 printk("can't get usergpio");
     
107.                 return -EINVAL;
     
108.         }
     
109. 
     
110.         ret = gpio_direction_output(userled.led_gpio, 1);
     
111.         if(ret < 0)
     
112.         {
     
113.                 printk("can't set usergpio!\r\n");
     
114.         }
     
115.         if (userled.major)
     
116.         {               
     
117.                 userled.devid = MKDEV(userled.major, 0);
     
118.                 register_chrdev_region(userled.devid, GPIOLED_CNT, GPIOLED_NAME);
     
119.         } else
     
120.         {                                                
     
121.                 alloc_chrdev_region(&userled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);        
     
122.                 userled.major = MAJOR(userled.devid);        
     
123.                 userled.minor = MINOR(userled.devid);        
     
124.         }
     
125.         printk("userled major=%d,minor=%d\r\n",userled.major, userled.minor);        
     
126.         
     
127.         userled.cdev.owner = THIS_MODULE;
     
128.         cdev_init(&userled.cdev, &userled_fops);
     
129.         cdev_add(&userled.cdev, userled.devid, GPIOLED_CNT);
     
130.         userled.class = class_create(THIS_MODULE, GPIOLED_NAME);
     
131.         if (IS_ERR(userled.class))
     
132.         {
     
133.                 return PTR_ERR(userled.class);
     
134.         }
     
135. 
     
136.         userled.device = device_create(userled.class, NULL, userled.devid, NULL, GPIOLED_NAME);
     
137.         if (IS_ERR(userled.device))
     
138.         {
     
139.                 return PTR_ERR(userled.device);
     
140.         }
     
141.         return 0;
     
142. }
     
143. 
     
144. //led exit
     
145. static void __exit led_exit(void)
     
146. {
     
147.         cdev_del(&userled.cdev);
     
148.         unregister_chrdev_region(userled.devid, GPIOLED_CNT);  
     
149. 
     
150.         device_destroy(userled.class, userled.devid);
     
151.         class_destroy(userled.class);
     
152. }
     
153. 
     
154. module_init(led_init);
     
155. module_exit(led_exit);
     
156. MODULE_LICENSE("GPL");
     
157. MODULE_AUTHOR("author");

复制代码

   
     1.2.2、Makefile文件

1. KERNELDIR :=  /opt/04-Sources/MYIR-i.MX8MM-Linux
   
2. CURRENT_PATH := $(shell pwd)
   
3. 
   
4. obj-m := userled.o
   
5. 
   
6. build: kernel_modules
   
7. 
   
8. kernel_modules:
   
9.         $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
   
10. 
    
11. clean:
    
12.         $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

    1.2.3、编译程序


    设置编译环境
    >/opt/04-Sources/example/userled# source /opt/myir-imx-xwayland/4.14-sumo/environment-setup-aarch64-poky-linux
    >/opt/04-Sources/example/userled# LDFLAGS="" CC="$CC"   
    >make
    编译完成后，会生成userled.ko文件，
   


   二、应用程序

    通过应用测试来测试驱动程序的运行情况。

    2.1、userledApp.c

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. #include <sys/types.h>
   
4. #include <sys/stat.h>
   
5. #include <fcntl.h>
   
6. #include <stdlib.h>
   
7. #include <string.h>
   
8. 
   
9. #define LED_DELAY_US    (200*1000) /* 200 ms */
   
10. 
    
11. #define LEDOFF         0
    
12. #define LEDON         1
    
13. 
    
14. int main(int argc, char *argv[])
    
15. {
    
16.         int fd, retvalue;
    
17.         char *filename;
    
18.         unsigned char databuf[1];
    
19.         unsigned char databuf1[1];
    
20.         
    
21.         if(argc != 3){
    
22.                 printf("Error Usage!\r\n");
    
23.                 return -1;
    
24.         }
    
25. 
    
26.         filename = argv[1];
    
27. 
    
28.         fd = open(filename, O_RDWR);
    
29.         if(fd < 0)
    
30.         {
    
31.                 printf("file %s open failed!\r\n", argv[1]);
    
32.                 return -1;
    
33.         }
    
34. 
    
35.         for(;;)
    
36.         {
    
37.                 databuf[0] = 0x01;
    
38.                 retvalue = write(fd, databuf, sizeof(databuf));
    
39.                  usleep(LED_DELAY_US );
    
40.                 databuf[0] = 0x00;
    
41.                 retvalue = write(fd, databuf, sizeof(databuf));
    
42.                 usleep(LED_DELAY_US );
    
43.                 printf("LED Control test!\r\n");
    
44. 
    
45.         }
    
46.         
    
47.         retvalue = close(fd);
    
48.         if(retvalue < 0)
    
49.         {
    
50.                 printf("file %s close failed!\r\n", argv[1]);
    
51.                 return -1;
    
52.         }
    
53.         return 0;
    
54. }

复制代码

         
    2.2、Makefile

1. include ../env.mk
   
2. TARGET = userledApp
   
3. SRC =  $(TARGET).c
   
4. OBJS = $(patsubst %.c ,%.o ,$(SRC))
   
5. .PHONY: all
   
6. all: $(TARGET)
   
7. $(TARGET) : $(OBJS)
   
8.         $(CC) -o $@ $^
   
9. %.o : %.c
   
10.         $(CC) -c [        DISCUZ_CODE_421        ]lt; -o $@
    
11. clean:
    
12.         $(RM) *.o $(TARGET)

复制代码

   
    2.3、编译程序
   
    执行make命令生成文件。
   
   
    三、测试程序

    3.1、将上面生成的两个文件复制到开发板上
   


    3.2、加载模块
   
   
    3.3、运行测试程序
   


    3.4、测试结果
    蓝色的LED闪烁运行。


   
   
     

zhangyacheng

修改了设备树后，怎么重新替换设备树呢？大佬