【米尔MYD-C8MMX开发板】+ 7、key按键linux驱动程序

TLLED

   
    这节来学习下按键输入的linux驱动程序。


    一、硬件电路


    按键使用IO口是GPIO3_IO19。
   
     




    二、驱动程序


    2.1、dts文件定义
    设备树文件/MYIR-i.MX8MM-Linux/arch/arm64/boot/dts/freescale/myb-fsl-imx8mm-evk.dts有关按键接口定义
      
        
     
    2.2、驱动程序


    userkey.c

1. <font size="3">#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. #define KEY0VAL                                0xF0                 
    
18. #define INVAKEY                           0x00
    
19. 
    
20. #define KEY_CNT                                1
    
21. #define KEY_NAME                        "userkey"                  
    
22. 
    
23. struct userkey_dev
    
24. {
    
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 key_gpio;               
    
33.         atomic_t keyval;         
    
34. };
    
35. 
    
36. struct userkey_dev userkey;         
    
37. //key open
    
38. static int key_open(struct inode *inode, struct file *filp)
    
39. {
    
40.         filp->private_data = &userkey;
    
41.         return 0;
    
42. }
    
43. //key read
    
44. static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
    
45. {
    
46.         int sta=0;
    
47.         unsigned char val;
    
48.         struct userkey_dev *dev = filp->private_data;
    
49.         {
    
50.                 if(gpio_get_value(dev->key_gpio)==0)
    
51.                 {
    
52.                         while (!gpio_get_value(dev->key_gpio));
    
53.                         atomic_set(&dev->keyval, KEY0VAL);
    
54.                 }
    
55.                 else
    
56.                 {
    
57.                         atomic_set(&dev->keyval,INVAKEY);
    
58.                 }
    
59.                 val=atomic_read(&dev->keyval);
    
60.                 sta= copy_to_user(buf, &val, sizeof(val));
    
61.                 return sta;
    
62.         };
    
63.         return 0;
    
64. }
    
65. 
    
66. //fops
    
67. static struct file_operations userkey_fops = {
    
68.         .owner = THIS_MODULE,
    
69.         .open = key_open,
    
70.         .read = key_read,
    
71. };
    
72. //led init
    
73. static int __init ourkey_init(void)
    
74. {
    
75.         int ret = 0;
    
76. 
    
77.         atomic_set(&userkey.keyval,INVAKEY);
    
78. 
    
79.         userkey.nd = of_find_node_by_path("/gpio-keys/user");
    
80.         if(userkey.nd == NULL)
    
81.         {
    
82.                 printk("userkey node not find!\r\n");
    
83.                 return -EINVAL;
    
84.         }
    
85.         else
    
86.         {
    
87.                 printk("userkey node find!\r\n");
    
88.         }
    
89.         
    
90.         userkey.key_gpio = of_get_named_gpio(userkey.nd, "gpios", 0);
    
91.         if(userkey.key_gpio < 0)
    
92.         {
    
93.                 printk("can't get usergpio\r\n");
    
94.                 return -EINVAL;
    
95.         }
    
96.         printk("key_gpio=%d\r\n",userkey.key_gpio);
    
97. 
    
98.         gpio_request(userkey.key_gpio, "key0");
    
99.         ret = gpio_direction_input(userkey.key_gpio);
    
100.         if(ret < 0)
     
101.         {
     
102.                 printk("can't set userkey!\r\n");
     
103.         }
     
104. 
     
105.         if (userkey.major)
     
106.         {               
     
107.                 userkey.devid = MKDEV(userkey.major, 0);
     
108.                 register_chrdev_region(userkey.devid, KEY_CNT, KEY_NAME);
     
109.         }
     
110.         else
     
111.         {                                                
     
112.                 alloc_chrdev_region(&userkey.devid, 0, KEY_CNT, KEY_NAME);        
     
113.                 userkey.major = MAJOR(userkey.devid);        
     
114.                 userkey.minor = MINOR(userkey.devid);        
     
115.         }
     
116.         printk("userkey major=%d,minor=%d\r\n",userkey.major, userkey.minor);        
     
117.         
     
118.         //cdev
     
119.         userkey.cdev.owner = THIS_MODULE;
     
120.         cdev_init(&userkey.cdev, &userkey_fops);
     
121.         cdev_add(&userkey.cdev, userkey.devid, KEY_CNT);
     
122.         userkey.class = class_create(THIS_MODULE, KEY_NAME);
     
123.         if (IS_ERR(userkey.class))
     
124.         {
     
125.                 return PTR_ERR(userkey.class);
     
126.         }
     
127. 
     
128.         userkey.device = device_create(userkey.class, NULL, userkey.devid, NULL, KEY_NAME);
     
129.         if (IS_ERR(userkey.device))
     
130.         {
     
131.                 return PTR_ERR(userkey.device);
     
132.         }
     
133.         return 0;
     
134. }
     
135. //led exit
     
136. static void __exit ourkey_exit(void)
     
137. {
     
138.         cdev_del(&userkey.cdev);
     
139.         unregister_chrdev_region(userkey.devid, KEY_CNT);  
     
140. 
     
141.         device_destroy(userkey.class, userkey.devid);
     
142.         class_destroy(userkey.class);
     
143. }
     
144. module_init(ourkey_init);
     
145. module_exit(ourkey_exit);
     
146. MODULE_LICENSE("GPL");
     
147. MODULE_AUTHOR("author");
     
148. </font>

复制代码

        2.3、Makefile文件   

1. <font size="3">KERNELDIR :=  /opt/04-Sources/MYIR-i.MX8MM-Linux
   
2. CURRENT_PATH := $(shell pwd)
   
3. 
   
4. obj-m := userkey.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</font>

复制代码

     2.4、编译程序后


    生成userkey.ko文件
   
   
    三、应用程序
   
    3.1、userkeyApp.c
   

1. <font size="3">#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 KEY0VAL         0xf0
   
10. #define INVAKEY                0x00
    
11. 
    
12. int main(int argc, char *argv[])
    
13. {
    
14.         int fd, retvalue;
    
15.         char *filename;
    
16.         unsigned char keyval;
    
17.         
    
18.         if(argc != 2)
    
19.         {
    
20.                 printf("Error Usage!\r\n");
    
21.                 return -1;
    
22.         }
    
23. 
    
24.         filename = argv[1];
    
25. 
    
26.         fd = open(filename, O_RDWR);
    
27.         if(fd < 0)
    
28.         {
    
29.                 printf("file %s open failed!\r\n", argv[1]);
    
30.                 return -1;
    
31.         }
    
32. 
    
33.         printf("please input key \r\n");
    
34.         for(;;)
    
35.         {
    
36.                 read(fd, &keyval, sizeof(keyval));
    
37.                 if(keyval == KEY0VAL)
    
38.                 {
    
39.                         printf("KEY press, value= %#x\r\n",keyval);
    
40.                 }
    
41.         }
    
42.         
    
43.         retvalue = close(fd);
    
44.         if(retvalue < 0)
    
45.         {
    
46.                 printf("file %s close failed!\r\n", argv[1]);
    
47.                 return -1;
    
48.         }
    
49.         return 0;
    
50. }
    
51. </font>

复制代码

    3.2、Makefile
   

1. <font size="3">include ../env.mk
   
2. TARGET = userkeyledApp
   
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_151        ]lt; -o $@
    
11. clean:
    
12.         $(RM) *.o $(TARGET)</font>

复制代码

    3.3、编译程序


    编译后生成userkeyApp
   
   
    四、测试程序


    4.1、将上面编译生成的两个文件拷贝到开发板 /opt目录下，
    执行命令：
    > insmod userkay.ko
    > ./userkeyApp /dev/userkey


    4.2、运行结果


    按下按键一次，打印一帧数据。