0
点赞
收藏
分享

微信扫一扫

Linux驱动开发之按键输入实验【完整教程】

有点d伤 2022-03-20 阅读 39
驱动开发linuxc#运维centos

做驱动都是有流程的嘛，要写驱动，第一件事便是去修改设备树。
                  

                ## 完整的代码见最后

一：修改设备树
在&iomux中添加pinctrl：

pinctrl_key: keygrp{
			fsl,pin = <
				MX6ULL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080
			>;
		};

然后创建子节点key

key{
		compatible = "alientek,key";
		pinctrl-names = "default";
		pinctrl-0 = <&pinctrl_key>;
		beep-gpio = <&gpio1 18 GPIO_ACTIVE_HIGH>;
		status = "okay";
	};

至此，设备树相关的就已经添加完成了

二：准备好一个最基本的字符设备驱动框架的模板
这里我就直接放出我构建的最基本字符设备了，有需要的可以直接使用

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>

#define KEY_CNT 1
#define KEY_NAME "key1"

/*key设备结构体*/
struct key_dev{
    dev_t devid;
    int major; //主设备号
    int minor; //次设备号
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int key_gpio;
};
struct key_dev key;/*KEY*/

static int key_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &key;
    return 0;
}
static int key_release(struct inode *inode, struct file *filp)
{
    return 0;
}
static ssize_t key_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    int ret;
        
    return 0;
}
/*cdev操作集合*/
static const struct file_operations key_fops = {
    .owner   = THIS_MODULE,
    .write   = key_write,
    .open    = key_open,
    .release = key_release,
};

/*驱动入口函数*/
static int __init key_init(void)
{
    int ret = 0;

    /*1注册字符设备驱动*/
    key.major = 0;
    if(key.major){ //给定主设备号
        key.devid = MKDEV(key.major, 0);
        register_chrdev_region(key.devid, KEY_CNT, KEY_NAME);
    }else{  //没有给定设备号
        alloc_chrdev_region(&key.devid, 0, KEY_CNT, KEY_NAME);
        key.major = MAJOR(key.devid);
        key.minor = MINOR(key.devid);
    }
    if(ret <0){
        goto fail_devid;
    }
    printk("key major = %d, key = %d \r\n",key.major,key.minor);

    /*2初始化cdev*/
    key.cdev.owner = THIS_MODULE;
    cdev_init(&key.cdev, &key_fops);//初始化cdev

    /*3添加cdev*/
    cdev_add(&key.cdev, key.devid, KEY_CNT);
    if(ret){
        goto fail_cdevadd;
    }

    /*4创建类*/
    key.class = class_create(THIS_MODULE, KEY_NAME);
    if(IS_ERR(key.class)){
        ret = PTR_ERR(key.class);
        goto fail_class;
    }
    /*5创建设备*/
    key.device = device_create(key.class, NULL, key.devid, NULL, KEY_NAME);
    if(IS_ERR(key.device)){
        ret = PTR_ERR(key.device);
        goto fail_device;
    }

   return 0;
fail_device:
    class_destroy(key.class);
fail_class:
    cdev_del(&key.cdev);
fail_cdevadd:
    unregister_chrdev_region(key.devid, KEY_CNT);
fail_devid:
    return ret;

}
/*驱动出口函数*/
static void __exit key_exit(void)
{
    /*注销字符设备驱动*/
    cdev_del(&key.cdev);
    unregister_chrdev_region(key.devid, KEY_CNT);
    /*摧毁设备*/
    device_destroy(key.class, key.devid);
    /*摧毁类*/
    class_destroy(key.class);

}

module_init(key_init);
module_exit(key_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kong");

三：因为我们是读取按键，所以需要添加key_read函数

ssize_t key_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int ret = 0;

    return 0;
}

注意字符设备结构体也要相应的添加 .read = key_read;
这里我就直接把整个操作集复制了过来

static const struct file_operations key_fops = {
    .owner   = THIS_MODULE,
    .write   = key_write,
    .read    = key_read，
    .open    = key_open,
    .release = key_release,
};

四：单独写一个函数是key io初始化

/*KEY IO初始化函数*/
static int keyio_init(struct key_dev *dev)
{
    int ret = 0;

    /*1.获取设备结点*/
    dev->nd = of_find_node_by_path("/key");
    if(dev->nd == NULL){
        ret = -EINVAL;
        goto fail_nd;
    }

    /*2.获取GPIO*/
    dev->key_gpio =of_get_named_gpio(dev->nd, "key-gpios", 0);
    if(dev->key_gpio < 0){
        ret = -EINVAL;
        goto fali_gpio;
    }

    /*3.请求GPIO*/
    ret = gpio_request(dev->key_gpio, "key0");
    if(ret){
        ret = -EBUSY;
        printk("KERN_WARNING:IO %d can't request", dev->key_gpio);
        goto fail_request;
    }

    /*4.设置GPIO输入输出*/
    ret = gpio_direction_input(dev->key_gpio);
    if(ret < 0){
        ret = -EINVAL;
        goto fail_input;
    }

    return 0;

fail_input:
    gpio_free(dev->key_gpio);
fail_request:
fali_gpio:
fail_nd:
    return ret;
}

五:将刚才写的GPIO初始化函数放入key_init函数里面去
在这里插入图片描述

六：因为在init函数里面成功申请了IO，所以要在驱动出口函数key_exit释放IO
在这里插入图片描述
七：完善read函数

ssize_t key_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int value;
    struct key_dev *dev =filp->private_data;
    int ret = 0;

    if(gpio_get_value(dev->key_gpio) == 0){ //表示按下
        while(!gpio_get_value(dev->key_gpio)) //等待释放按键
        atomic_set(&dev->keyvalue, KEY0VALUE); //有效
    }else{
        atomic_set(&dev->keyvalue, INVAKEY); //无效
    }

    value = atomic_read(&dev->keyvalue);

    ret = copy_to_user(buf, &value, sizeof(value));//buf保存着驱动的数据;value：数据源；
    return ret;
}

八：驱动已经写完了，现在可以写应用了，应用APP完整代码

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define KEY0VALUE 0XF0  //有效
#define INVAKEY   0X00  //无效
int main(int argc, char *argv[])
{
    int value = 0;
    int fd,retvalue;
    char *filename;
    unsigned char databuf[1];

    if(argc != 2){
        printf("Eroor Usage!\r\n");
        return -1;
    }
    filename = argv[1];

    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("file %s open failed!\r\n",filename);
        return -1;
    }

    /*循环读取*/
    while(1){
        read(fd, &value, sizeof(value));
        if(value == KEY0VALUE){
            printf("KEY0 Press, value =%d \r\n", value);
        }
    }
   close(fd);

   return 0;

}

九，至此，按键驱动便完成了，现象如下所示，每按一次KEY，便会输出一个串字符串
在这里插入图片描述

  
  
  
  
  

驱动完整代码

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>

#define KEY_CNT 1
#define KEY_NAME "key"

#define KEY0VALUE 0XF0  //有效
#define INVAKEY   0X00  //无效
/*key设备结构体*/
struct key_dev{
    dev_t devid;
    int major; //主设备号
    int minor; //次设备号
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int key_gpio;

    atomic_t keyvalue; //全局变量，考虑到并发与竞争
};
struct key_dev key;/*KEY*/

static int key_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &key;
    return 0;
}
static int key_release(struct inode *inode, struct file *filp)
{
    return 0;
}
static ssize_t key_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    int ret;
        
    return 0;
}
ssize_t key_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int value;
    struct key_dev *dev =filp->private_data;
    int ret = 0;

    if(gpio_get_value(dev->key_gpio) == 0){ //表示按下
        while(!gpio_get_value(dev->key_gpio)) //等待释放按键
        atomic_set(&dev->keyvalue, KEY0VALUE); //有效
    }else{
        atomic_set(&dev->keyvalue, INVAKEY); //无效
    }

    value = atomic_read(&dev->keyvalue);

    ret = copy_to_user(buf, &value, sizeof(value));//buf保存着驱动的数据;value：数据源；
    return ret;
}
/*cdev操作集合*/
static const struct file_operations key_fops = {
    .owner   = THIS_MODULE,
    .write   = key_write,
    .read    = key_read,
    .open    = key_open,
    .release = key_release,
};
/*KEY IO初始化函数*/
static int keyio_init(struct key_dev *dev)
{
    int ret = 0;

    /*1.获取设备结点*/
    dev->nd = of_find_node_by_path("/key");
    if(dev->nd == NULL){
        ret = -EINVAL;
        goto fail_nd;
    }

    /*2.获取GPIO*/
    dev->key_gpio =of_get_named_gpio(dev->nd, "key-gpios", 0);
    if(dev->key_gpio < 0){
        ret = -EINVAL;
        goto fali_gpio;
    }

    /*3.请求GPIO*/
    ret = gpio_request(dev->key_gpio, "key0");
    if(ret){
        ret = -EBUSY;
        printk("KERN_WARNING:IO %d can't request", dev->key_gpio);
        goto fail_request;
    }

    /*4.设置GPIO输入输出*/
    ret = gpio_direction_input(dev->key_gpio);
    if(ret < 0){
        ret = -EINVAL;
        goto fail_input;
    }

    return 0;

fail_input:
    gpio_free(dev->key_gpio);
fail_request:
fali_gpio:
fail_nd:
    return ret;
}

/*驱动入口函数*/
static int __init key_init(void)
{
    int ret = 0;

    /*初始化atomic*/
    atomic_set(&key.keyvalue, INVAKEY);
    /*1注册字符设备驱动*/
    key.major = 0;
    if(key.major){ //给定主设备号
        key.devid = MKDEV(key.major, 0);
        register_chrdev_region(key.devid, KEY_CNT, KEY_NAME);
    }else{  //没有给定设备号
        alloc_chrdev_region(&key.devid, 0, KEY_CNT, KEY_NAME);
        key.major = MAJOR(key.devid);
        key.minor = MINOR(key.devid);
    }
    if(ret <0){
        goto fail_devid;
    }
    printk("key major = %d, key = %d \r\n",key.major,key.minor);

    /*2初始化cdev*/
    key.cdev.owner = THIS_MODULE;
    cdev_init(&key.cdev, &key_fops);//初始化cdev

    /*3添加cdev*/
    cdev_add(&key.cdev, key.devid, KEY_CNT);
    if(ret){
        goto fail_cdevadd;
    }

    /*4创建类*/
    key.class = class_create(THIS_MODULE, KEY_NAME);
    if(IS_ERR(key.class)){
        ret = PTR_ERR(key.class);
        goto fail_class;
    }
    /*5创建设备*/
    key.device = device_create(key.class, NULL, key.devid, NULL, KEY_NAME);
    if(IS_ERR(key.device)){
        ret = PTR_ERR(key.device);
        goto fail_device;
    }

    ret = keyio_init(&key);
    if(ret < 0){  //判断有没有被其他外设使用、或者被复用为其他的功能
        goto fail_device;
    }

   return 0;
fail_device:
    class_destroy(key.class);
fail_class:
    cdev_del(&key.cdev);
fail_cdevadd:
    unregister_chrdev_region(key.devid, KEY_CNT);
fail_devid:
    return ret;

}
/*驱动出口函数*/
static void __exit key_exit(void)
{
    /*注销字符设备驱动*/
    cdev_del(&key.cdev);
    unregister_chrdev_region(key.devid, KEY_CNT);
    /*摧毁设备*/
    device_destroy(key.class, key.devid);
    /*摧毁类*/
    class_destroy(key.class);

    /*释放IO*/
    gpio_free(key.key_gpio);
}

module_init(key_init);
module_exit(key_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kong");
举报

相关推荐

Linux驱动开发之无设备树下的platform设备驱动实验【完整教程】

驱动开发linuxc#c语言

Linux驱动开发-编写按键驱动

linux驱动开发

linux驱动之按键（中断）

#include3clinux系统/运维

Linux 驱动开发 四十九：Linux 自带按键驱动程序

linux

＜Linux开发＞驱动开发 -之- Linux RTC 驱动

kafka大数据分布式

Linux驱动之输入子系统​

输入子系统事件处理键值嵌入式Linux嵌入式yyds干货盘点

《I.MX6U嵌入式Linux驱动开发指南》第十五章 按键输入实验

初始化#include开发板嵌入式Linux嵌入式

Linux系统中驱动之设备树添加按键驱动方法

linux#include键值JavaScript前端开发

Linux——Linux驱动之使用输入子系统设计按键驱动实战（输入子系统基本概念、代码获取上报信息、相关函数解析）

物联网嵌入式IOTlinux输入子系统

Linux驱动开发学习笔记6《蜂鸣器实验》

计算机视觉人工智能算法
0 条评论