Linux驱动开发(按键驱动)

举报
yd_274589494 发表于 2023/06/16 08:09:18 2023/06/16
【摘要】 @TOC 前言本篇文章我们来讲解按键的驱动程序,按键驱动程序的主要思路就是使用中断的方式,当按键按下时会发生中断这个时候就可以通过中断来获取按键的状态。 一、设备树编写我的开发板上有两个按键,那么我们就在gpios里面添加两个gpio的信息。 mykey:mykey{ compatible = "my,gpio_key"; gpios = <&gpio5 1...

@TOC


前言

本篇文章我们来讲解按键的驱动程序,按键驱动程序的主要思路就是使用中断的方式,当按键按下时会发生中断这个时候就可以通过中断来获取按键的状态。

一、设备树编写

我的开发板上有两个按键,那么我们就在gpios里面添加两个gpio的信息。

    mykey:mykey{
        compatible = "my,gpio_key";
        gpios = <&gpio5 1 GPIO_ACTIVE_LOW>,
                <&gpio4 14 GPIO_ACTIVE_LOW>;
    };

二、驱动程序编写

按键的驱动程序总的来说是非常常规的,这里我主要讲解一下难点。

这里首先需要提供一个环形缓冲区,这里环形缓冲区的作用如下:

防止按键过期:当按键处理时间较长时,正常的 IRQ(中断服务例程)处理可能无法及时响应新的按键事件,环形缓冲区可以将该事件保存起来,以便IRQ处理完之后再进行处理,防止按键丢失或失效。

前面我们都是使用gpiod_get来获取相关的硬件信息,但是在这个驱动程序中有两个gpio所以我们这里换一个函数来获取gpio信息。

函数原型如下:

struct gpio_desc *gpiod_get_index(struct device *dev, const char *propname, unsigned int index, unsigned long flags);

参数:

dev:表示GPIO设备所在的设备节点。

propname:表示设备树中属性名为 propname 的GPIO引脚。

index:表示GPIO设备中具有相同 propname 的GPIO引脚的索引号,如果所有引脚名均不相同,则将 index 值设置为 0。

flags:表示GPIO描述符的标志。

返回值:
struct gpio_desc *:成功则返回GPIO描述符,失败则返回错误指针。

全部代码:

#include <linux/module.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>

static struct gpio_desc *key0;
static struct gpio_desc *key1;
static int key0_irq;
static int key1_irq;


/* 主设备号                                                                 */
static int major = 0;
static struct class *gpio_key_class;


/* 环形缓冲区 */
#define BUF_LEN 128
static int g_keys[BUF_LEN];
static int r, w;

#define NEXT_POS(x) ((x+1) % BUF_LEN)

static int is_key_buf_empty(void)
{
	return (r == w);
}

static int is_key_buf_full(void)
{
	return (r == NEXT_POS(w));
}

static void put_key(int key)
{
	if (!is_key_buf_full())
	{
		g_keys[w] = key;
		w = NEXT_POS(w);
	}
}

static int get_key(void)
{
	int key = 0;
	if (!is_key_buf_empty())
	{
		key = g_keys[r];
		r = NEXT_POS(r);
	}
	return key;
}


static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);

/* 实现对应的open/read/write等函数,填入file_operations结构体                   */
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	int err;
	int key;
	
	wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
	key = get_key();
	err = copy_to_user(buf, &key, 4);
	
	return 4;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations gpio_key_drv = {
	.owner	 = THIS_MODULE,
	.read    = gpio_key_drv_read,
};


static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
	int val = 0;
	int key = 0;

	if(irq == key0_irq)
	{
		val = gpiod_get_value(key0);
		key = val | (0 << 8);
		printk("this key0 status is %d\n",val);
	}
	else if(irq == key1_irq)
	{
		val = gpiod_get_value(key1);
		key = val | (1 << 8);
		printk("this key1 status is %d\n",val);
	}
	
		
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);
	
	return IRQ_HANDLED;
}

/* 1. 从platform_device获得GPIO
 * 2. gpio=>irq
 * 3. request_irq
 */
static int gpio_key_probe(struct platform_device *pdev)
{
	int err;
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
	/* 获取硬件信息 */
	key0 = gpiod_get_index(&pdev->dev, NULL, 0, 0);
	if (IS_ERR(key0)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}
	key1 = gpiod_get_index(&pdev->dev, NULL, 1, 0);
	if (IS_ERR(key0)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}

	/*将gpio设置为输入引脚*/
	gpiod_direction_input(key0);
	gpiod_direction_input(key1);

	/*获得gpio中断号*/
	key0_irq = gpiod_to_irq(key0);
	if(key0_irq < 0)
	{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		return key0_irq;
	}
	key1_irq = gpiod_to_irq(key1);
	if(key1_irq < 0)
	{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		return key1_irq;
	}

	/*根据irq申请中断*/
	err = request_irq(key0_irq, gpio_key_isr, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, "key", NULL);
	err = request_irq(key1_irq, gpio_key_isr, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, "key", NULL);
	

	/* 注册file_operations 	*/
	major = register_chrdev(0, "100ask_gpio_key", &gpio_key_drv);  /* /dev/gpio_key */

	gpio_key_class = class_create(THIS_MODULE, "100ask_gpio_key_class");
	if (IS_ERR(gpio_key_class)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		unregister_chrdev(major, "100ask_gpio_key");
		return PTR_ERR(gpio_key_class);
	}

	device_create(gpio_key_class, NULL, MKDEV(major, 0), NULL, "100ask_gpio_key"); /* /dev/100ask_gpio_key */
        
    return 0;
    
}

static int gpio_key_remove(struct platform_device *pdev)
{

	device_destroy(gpio_key_class, MKDEV(major, 0));
	class_destroy(gpio_key_class);
	unregister_chrdev(major, "100ask_gpio_key");

	/*释放中断*/
	free_irq(key1_irq,&key1_irq);
	free_irq(key0_irq,&key0_irq);

	/*释放引脚*/
	gpiod_put(key1);
	gpiod_put(key0);
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
    return 0;
}


static const struct of_device_id ask100_keys[] = {
    { .compatible = "my,gpio_key" },
    { },
};

/* 1. 定义platform_driver */
static struct platform_driver gpio_keys_driver = {
    .probe      = gpio_key_probe,
    .remove     = gpio_key_remove,
    .driver     = {
        .name   = "100ask_gpio_key",
        .of_match_table = ask100_keys,
    },
};

/* 2. 在入口函数注册platform_driver */
static int __init gpio_key_init(void)
{
    int err;
    
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
    err = platform_driver_register(&gpio_keys_driver); 
	
	return err;
}

/* 3. 有入口函数就应该有出口函数:卸载驱动程序时,就会去调用这个出口函数
 *     卸载platform_driver
 */
static void __exit gpio_key_exit(void)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

    platform_driver_unregister(&gpio_keys_driver);
}


/* 7. 其他完善:提供设备信息,自动创建设备节点                                     */

module_init(gpio_key_init);
module_exit(gpio_key_exit);

MODULE_LICENSE("GPL");



三、应用程序编写

在应用程序中使用read函数可以读取到按键的状态。


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

/*
 * ./button_test /dev/100ask_button0
 *
 */
int main(int argc, char **argv)
{
	int fd;
	int val;
	int status;
	int num;
	
	/* 1. 判断参数 */
	if (argc != 2) 
	{
		printf("Usage: %s <dev>\n", argv[0]);
		return -1;
	}

	/* 2. 打开文件 */
	fd = open(argv[1], O_RDWR);
	if (fd == -1)
	{
		printf("can not open file %s\n", argv[1]);
		return -1;
	}

	while (1)
	{
		/* 3. 读文件 */
		read(fd, &val, 4);
		status = val&0xff;
		num    = val>>8;
		printf("get button : 0x%x\n", val);
		printf("key%d status is %d\n",num,status);
	}
	
	close(fd);
	
	return 0;
}

总结

按键驱动的编写是比较简单的,主要就是需要注意设备树的编写和gpio硬件信息的获取函数。

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。