linux驱动开发：按键2

原創 changliang7731 2020-07-08 04:08

上篇文章中断按键的驱动跨度有点大，这里面揉合了太多的东西，所以特地再重新写以下，以加强理解：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>

#include <mach/map.h>
#include <mach/gpio.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>


#define DEVICE_NAME "buttons"

#define BUTTON_MAJOR        254


#define KEY_STATUS_DOWN     '0'
#define KEY_STATUS_UP       '1'
struct button_desc {
    int gpio;
    int number;
    char *name; 
};
static struct button_desc buttons[] = {
    { S5PV210_GPH2(0), 0, "KEY0" },
    { S5PV210_GPH2(1), 1, "KEY1" },
    { S5PV210_GPH2(2), 2, "KEY2" },
    { S5PV210_GPH2(3), 3, "KEY3" },
    { S5PV210_GPH3(0), 4, "KEY4" },
    { S5PV210_GPH3(1), 5, "KEY5" },
    { S5PV210_GPH3(2), 6, "KEY6" },
    { S5PV210_GPH3(3), 7, "KEY7" },
};

static volatile char key_states[] = {
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP
};

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
static volatile int ev_press = 0;


static irqreturn_t button_interrupt(int irq, void *dev_id)
{
    struct button_desc *bdata = (struct button_desc *)dev_id;

    if(gpio_get_value(bdata->gpio) == 0)//when press down
    {
        key_states[bdata->number]=KEY_STATUS_DOWN;
        ev_press = 1;
        wake_up_interruptible(&button_waitq);
    }
    else
    {
        key_states[bdata->number]=KEY_STATUS_UP;
    }

    return IRQ_HANDLED;
}

static ssize_t smart210_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp){
    unsigned long err;

    wait_event_interruptible(button_waitq, ev_press);

    ev_press = 0;

    err = copy_to_user((void *)buff, (const void *)(&key_states),
            min(sizeof(key_states), count));

    return err ? -EFAULT : min(sizeof(key_states), count);
};

static int smart210_buttons_open(struct inode *inode, struct file *file){
    int i;
    int err;
    int irq;
    for(i=0;i< ARRAY_SIZE(buttons);i++){
        //注册中断函数
        irq = gpio_to_irq(buttons[i].gpio);
        err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH, 
                buttons[i].name, (void *)&buttons[i]);
        if (err)
            break;
    }
    if(err)
    {
        i--;
        for (; i >= 0; i--) {
            if (!buttons[i].gpio)
                continue;

            irq = gpio_to_irq(buttons[i].gpio);
            disable_irq(irq);
            free_irq(irq, (void *)&buttons[i]);
        }

        return -EBUSY;
    }
    return 0;
};
static int smart210_buttons_close(struct inode *inode, struct file *file){
    int irq, i;

    for (i = 0; i < ARRAY_SIZE(buttons); i++) {
        if (!buttons[i].gpio)
            continue;

        irq = gpio_to_irq(buttons[i].gpio);
        free_irq(irq, (void *)&buttons[i]);
    }
    return 0;
};


static struct file_operations smart210_buttons_dev_fops = {
    .owner          = THIS_MODULE,
    .open           =smart210_buttons_open,
    .release        =smart210_buttons_close,
    .read           =smart210_buttons_read,

};

static int __init smart210_buttons_dev_init(void) {
    int ret;

    //字符设备
    ret=register_chrdev(BUTTON_MAJOR,DEVICE_NAME,&smart210_buttons_dev_fops);

    if (ret < 0) {
            printk("request char device failed\n");
            return ret;
        }
    printk(DEVICE_NAME"\tinitialized\n");

    return ret;
}

static void __exit smart210_buttons_dev_exit(void) {
    //注销字符设备
    unregister_chrdev(BUTTON_MAJOR,DEVICE_NAME);
}

module_init(smart210_buttons_dev_init);
module_exit(smart210_buttons_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("FriendlyARM Inc.");

这里少了定时器中断的内容。原先我一直不理解为什么在按键中断里面又要加入定时器。等到我把定时器拿掉后，才发现。好像是为了按键消抖。如果不消抖，有时候会出现按下去一下，实际驱动中会get 到按下去多次。
将设备注册为字符设备，而非混杂设备，这里只是试试看两者会有什么差异。
实际上字符设备需要手动在dev目录下创建设备文件,如果没有特殊处理的话，这样的话会非常麻烦。
首先先cat /proc/devices

由于我们是静态分配，所以知道主设备号为254，如果是动态分配主设备号，则安上面操作查询主设备号！
然后在dev目录下 mknod buttons c 254 1 创建设备文件

可见手动创建设备节点还是比较繁琐的，misc混杂设备是可以自动生成的，很实用！

使字符设备可以自动创建设备节点：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>

#include <mach/map.h>
#include <mach/gpio.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>


#define DEVICE_NAME "buttons"

/*set to 0 自动分配主设备号，否则手动分配，但是如果已经被占用，便会分配失败*/
#define BUTTON_MAJOR         0


#define KEY_STATUS_DOWN     '0'
#define KEY_STATUS_UP       '1'
struct button_desc {
    int gpio;
    int number;
    char *name; 
};
static struct button_desc buttons[] = {
    { S5PV210_GPH2(0), 0, "KEY0" },
    { S5PV210_GPH2(1), 1, "KEY1" },
    { S5PV210_GPH2(2), 2, "KEY2" },
    { S5PV210_GPH2(3), 3, "KEY3" },
    { S5PV210_GPH3(0), 4, "KEY4" },
    { S5PV210_GPH3(1), 5, "KEY5" },
    { S5PV210_GPH3(2), 6, "KEY6" },
    { S5PV210_GPH3(3), 7, "KEY7" },
};

static volatile char key_states[] = {
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP
};

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
static volatile int ev_press = 0;

/*当用户空间已经移植了udev/mdev,使用下列方式可以在dev目录下自动创建字符设备*/
static struct class* buttons_class;
static dev_t dev;


static irqreturn_t button_interrupt(int irq, void *dev_id)
{
    struct button_desc *bdata = (struct button_desc *)dev_id;

    if(gpio_get_value(bdata->gpio) == 0)//when press down
    {
        key_states[bdata->number]=KEY_STATUS_DOWN;
        ev_press = 1;
        wake_up_interruptible(&button_waitq);
    }
    else
    {
        key_states[bdata->number]=KEY_STATUS_UP;
    }

    return IRQ_HANDLED;
}

static ssize_t smart210_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp){
    unsigned long err;
    //等待 wait队列被唤醒，获取值,阻塞模式访问，没有数据一直等待
    wait_event_interruptible(button_waitq, ev_press);

    ev_press = 0;

    err = copy_to_user((void *)buff, (const void *)(&key_states),
            min(sizeof(key_states), count));

    return err ? -EFAULT : min(sizeof(key_states), count);
};

static int smart210_buttons_open(struct inode *inode, struct file *file){
    int i;
    int err;
    int irq;
    for(i=0;i< ARRAY_SIZE(buttons);i++){
        //注册中断函数
        irq = gpio_to_irq(buttons[i].gpio);
        err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH, 
                buttons[i].name, (void *)&buttons[i]);
        if (err)
            break;
    }
    if(err)
    {
        i--;
        for (; i >= 0; i--) {
            if (!buttons[i].gpio)
                continue;

            irq = gpio_to_irq(buttons[i].gpio);
            disable_irq(irq);
            free_irq(irq, (void *)&buttons[i]);
        }

        return -EBUSY;
    }
    return 0;
};
static int smart210_buttons_close(struct inode *inode, struct file *file){
    int irq, i;

    for (i = 0; i < ARRAY_SIZE(buttons); i++) {
        if (!buttons[i].gpio)
            continue;

        irq = gpio_to_irq(buttons[i].gpio);
        free_irq(irq, (void *)&buttons[i]);
    }
    return 0;
};


static struct file_operations smart210_buttons_dev_fops = {
    .owner          = THIS_MODULE,
    .open           =smart210_buttons_open,
    .release        =smart210_buttons_close,
    .read           =smart210_buttons_read,

};

static int __init smart210_buttons_dev_init(void) {
    int major;

    //字符设备
    major=register_chrdev(BUTTON_MAJOR,DEVICE_NAME,&smart210_buttons_dev_fops);

    if (major < 0) {
            printk("request char device failed\n");
            return major;
            }

    buttons_class=class_create(THIS_MODULE,DEVICE_NAME);
    dev = MKDEV(major, 1);
    device_create(buttons_class,NULL,dev,NULL,"%s",buttons_class->name);
    printk(DEVICE_NAME"\tinitialized\n");
    return major;
}

static void __exit smart210_buttons_dev_exit(void) {
    //注销字符设备
    unregister_chrdev(BUTTON_MAJOR,DEVICE_NAME);
    device_destroy(buttons_class, dev);
    class_destroy(buttons_class);
}

module_init(smart210_buttons_dev_init);
module_exit(smart210_buttons_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("FriendlyARM Inc.");

另外还有一种方式，因为以上驱动读设备时阻塞访问，一直停留在那里等待，有点浪费资源！

我们可以用poll的方式：poll里面有一个timeout参数，比如poll一个设备50ms，如果在50ms内设备可以进行某些操作，比如
可以被读，或者IO允许被写，此时我们再直接调用read函数或者write函数，便可以直接获得/操作数据.
如果50ms内设备返回 0，即超时。我们此时可以选择继续poll或者做其他事情。
这里主要研究下poll函数的作用！

最后的驱动这样写：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>

#include <mach/map.h>
#include <mach/gpio.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>


#define DEVICE_NAME "buttons"

/*set to 0 自动分配主设备号，否则手动分配，但是如果已经被占用，便会分配失败*/
#define BUTTON_MAJOR         0


#define KEY_STATUS_DOWN     '0'
#define KEY_STATUS_UP       '1'
struct button_desc {
    int gpio;
    int number;
    char *name; 
};
static struct button_desc buttons[] = {
    { S5PV210_GPH2(0), 0, "KEY0" },
    { S5PV210_GPH2(1), 1, "KEY1" },
    { S5PV210_GPH2(2), 2, "KEY2" },
    { S5PV210_GPH2(3), 3, "KEY3" },
    { S5PV210_GPH3(0), 4, "KEY4" },
    { S5PV210_GPH3(1), 5, "KEY5" },
    { S5PV210_GPH3(2), 6, "KEY6" },
    { S5PV210_GPH3(3), 7, "KEY7" },
};

static volatile char key_states[] = {
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP
};

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
static volatile int ev_press = 0;

/*当用户空间已经移植了udev/mdev,使用下列方式可以在dev目录下自动创建字符设备*/
static struct class* buttons_class;
static dev_t dev;


static irqreturn_t button_interrupt(int irq, void *dev_id)
{
    struct button_desc *bdata = (struct button_desc *)dev_id;

    if(gpio_get_value(bdata->gpio) == 0)//when press down
    {
        key_states[bdata->number]=KEY_STATUS_DOWN;
        ev_press = 1;
        wake_up_interruptible(&button_waitq);
    }
    else
    {
        key_states[bdata->number]=KEY_STATUS_UP;
    }

    return IRQ_HANDLED;
}

static ssize_t smart210_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp){
    unsigned long err;
    if (!ev_press) {
        if (filp->f_flags & O_NONBLOCK){
            printk("noneblock return\n");
            return -EAGAIN;
        }
    }
    ev_press = 0;

    err = copy_to_user((void *)buff, (const void *)(&key_states),
            min(sizeof(key_states), count));

    return err ? -EFAULT : min(sizeof(key_states), count);
};

static int smart210_buttons_open(struct inode *inode, struct file *file){
    int i;
    int err;
    int irq;

    for(i=0;i< ARRAY_SIZE(buttons);i++){
        //注册中断函数
        irq = gpio_to_irq(buttons[i].gpio);
        err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH, 
                buttons[i].name, (void *)&buttons[i]);
        if (err)
            break;
    }
    if(err)
    {
        i--;
        for (; i >= 0; i--) {
            if (!buttons[i].gpio)
                continue;

            irq = gpio_to_irq(buttons[i].gpio);
            disable_irq(irq);
            free_irq(irq, (void *)&buttons[i]);
        }

        return -EBUSY;
    }
    return 0;
};
static int smart210_buttons_close(struct inode *inode, struct file *file){
    int irq, i;

    for (i = 0; i < ARRAY_SIZE(buttons); i++) {
        if (!buttons[i].gpio)
            continue;

        irq = gpio_to_irq(buttons[i].gpio);
        free_irq(irq, (void *)&buttons[i]);
    }
    return 0;
};
static unsigned int smart210_buttons_poll( struct file *file,
        struct poll_table_struct *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait);
    if (ev_press)
        mask |= POLLIN | POLLRDNORM;/*key is press down,IO is readable*/

    return mask;
}

static struct file_operations smart210_buttons_dev_fops = {
    .owner          = THIS_MODULE,
    .open           =smart210_buttons_open,
    .release        =smart210_buttons_close,
    .read           =smart210_buttons_read,
    .poll           =smart210_buttons_poll,

};

static int __init smart210_buttons_dev_init(void) {
    int major;

    //字符设备
    major=register_chrdev(BUTTON_MAJOR,DEVICE_NAME,&smart210_buttons_dev_fops);

    if (major < 0) {
            printk("request char device failed\n");
            return major;
            }

    buttons_class=class_create(THIS_MODULE,DEVICE_NAME);
    dev = MKDEV(major, 1);
    device_create(buttons_class,NULL,dev,NULL,"%s",buttons_class->name);
    printk(DEVICE_NAME"\tinitialized\n");
    return major;
}

static void __exit smart210_buttons_dev_exit(void) {
    //注销字符设备
    unregister_chrdev(BUTTON_MAJOR,DEVICE_NAME);
    device_destroy(buttons_class, dev);
    class_destroy(buttons_class);
}

module_init(smart210_buttons_dev_init);
module_exit(smart210_buttons_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("FriendlyARM Inc.");

这边的差别是：如果打开文件，接下来直接read ，因为没有按键按下时，就直接返回一个负数,而不会等待。
所以测试程序的编写需要改变下：
先打开文件，然后poll ，传给内核驱动中的poll，有一个timeout时间，如果在timeout时间内返回可读，此时调用read函数直接读取，否则，重新poll。
测试程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <termios.h>
#include <sys/poll.h>
#include <string.h>
#define KEY_STATUS_DOWN     '0'
#define KEY_STATUS_UP       '1'


/*main timeouttime*/
int main(int argc, char **argv)
{
    int buttons_fd;
    int ret;
    int timeoutcount;
    char current_buttons[8] = {
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP,
    KEY_STATUS_UP
    };
    struct pollfd event; //创建一个struct pollfd结构体变量，存放文件描述符、要等待发生的事件

    if(argc !=2 || sscanf(argv[1], "%d", &timeoutcount) !=1 || timeoutcount <40){
        printf("USE like : ./buttons timeout(40-)\n");
        exit(1);
    }

    buttons_fd = open("/dev/buttons", O_NONBLOCK);//非阻塞方式
    if (buttons_fd < 0) {
        perror("open device buttons");
        exit(1);
    }


    while(timeoutcount--){
        int i;
        //poll结束后struct pollfd结构体变量的内容被全部清零，需要再次设置
        memset(&event,0,sizeof(event)); //memst函数对对象的内容设置为同一值
        event.fd=buttons_fd; //存放打开的文件描述符
        event.events=POLLIN; //存放要等待发生的事件
        ret=poll((struct pollfd *)&event,1,100); //监测event，一个对象，等待100毫秒后超时,-1为无限等待

        //判断poll的返回值，负数是出错，0是设定的时间超时，整数表示等待的时间发生
        if(ret<0){
            printf("poll error!\n");
            exit(1);
            }
        if(ret==0){
            //printf("Time out!\n");
            continue;
        }
        if(event.revents&POLLERR){ //revents是由内核记录的实际发生的事件，events是进程等待的事件
            printf("Device error!\n");
            exit(1);
         }
        //poll in
        if(event.revents&POLLIN){
            read(buttons_fd, current_buttons, sizeof(current_buttons));
            for (i = 0; i < sizeof(current_buttons) / sizeof(current_buttons[0]); i++) {
                if (current_buttons[i] ==KEY_STATUS_DOWN) {
                printf("The key %d is pressed down!\n",i);

                }
            }
        }

    }
    printf("Time out close file\n");
    close(buttons_fd);
    return 0;
}

大概说明一个；测试程序传入一个参数n，当n*timeout（poll的timeout时间为100ms）后，自动关掉设备文件。
在这段时间之间，如果有某些按键按下，当前被按下的按键都会被打印出来。

这里的驱动程序其实已经和开发板上的按键驱动程序非常相近了。如果我在这里再把定时器消抖的函数拿进来，那么其实就和例程是一样的。
到此，按键驱动开发结束！

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

linux驱动开发：input子系统二

輸入子系統：linux內核中將所有輸入設備歸爲一個類：input子系統。裏面實現了幾乎所有輸入設備的公共操作接口，相當於內核給我們搭建了一個輸入子系統的框架，我們用它的框架開發驅動，會變得非常簡單。因爲一些公共的函數內核已經幫我們

changliang7731 2020-07-08 04:08:45

linux驱动开发：背光设备

上一篇的pwm 驅動，加上第一篇的led燈控制，合起來就是背光設備的驅動！ 背光設備定位於僅僅對於lcd的背光進行控制，其中主要控制背光開關腳(GPIO)，背光調節腳(PWM)! 由於很類似，在這裏就不做贅述 顯而易見，pwm

changliang7731 2020-07-08 04:08:45

平台，设备，驱动

繼上次研究ADC驅動，開始接觸platform這個東西。不過坦白講，還是理解的不是很透徹。所以準備今天爬一次code。以加深這方面的理解。 我們來看一個led燈的驅動是如何用平臺總線來實現的： struct gpio_led {

changliang7731 2020-07-08 04:08:44

嵌入式内核开发：led灯驱动

接觸單片機或者其他嵌入式芯片的編程中，最簡單的就是GPIO的High/Low控制。 比如學校裏面最基本的單片機實驗：led控制，流水燈，數碼管。其實都是最基本的GPIO操作。 那麼同樣，對應到linux嵌入式開發，GPIO的H

changliang7731 2020-07-08 04:08:44

linux驱动开发：input子系统一

input子系統開發：按鍵是一種標準的輸入設備，實驗以按鍵來分析，實現簡單的input子系統. 未完成. 實驗代碼：實現一個按鍵的功能 #include <linux/init.h> #include <linux/module.

changliang7731 2020-07-08 04:08:43

linux驱动开发：input子系统三

linux輸入設備的總結： 上一篇文章中，用戶空間可以open 我們的event1設備文件，也可以read我們的設備文件。可是我們的代碼裏面並沒有實現read 和 open函數。但是依舊可以抓到數據。這也就是說內核幫我們做好了很

changliang7731 2020-07-08 04:08:42

linux驱动：按键

按鍵：按下去我們get到low電平以此來判斷用戶輸入，可以把它看作是一個輸入設備。 通常在51單片機上，我們可以寫一個while，然後不停的輪詢，判斷某個gpio口被拉低了，我們便認爲按鍵被按下了。另外一種是中斷。當有中斷觸發時

changliang7731 2020-07-08 04:08:42

Source Insight解析Linux内核的c.tom文件内容

在C:\Documents and Settings\XXXX\My Documents\Source Insight目錄下的C.tom文件中增加如下內容（需要不斷完善，碰到不能解析的宏時添加進來）。 添加後，關閉SourceInsigh

nust20 2020-07-03 05:09:10

kmalloc and vmalloc

kernel_learner 2020-02-24 20:37:11

Linux内核线程编程方法

kernel_learner 2020-02-24 20:37:01

Linux PCI设备驱动

kernel_learner 2020-02-24 20:37:01

NAPI In Linux Network Device Driver

kernel_learner 2020-02-24 20:37:01

Netlink实例----用户态内核态全包含

kernel_learner 2020-02-24 20:37:01

Linux Notification chain学习

kernel_learner 2020-02-24 20:37:01

打印super_block结构中的一些域的值

wrx1721267632 2020-02-21 19:05:11