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