基於platform的ok6410按鍵中斷實驗

plat_btn_device.c

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/io.h>


#define DEVICE_NAME "ok6410_plat_btn"


/*平臺資源的定義,按鍵中斷*/
static struct resource s3c_buttons_resource[] = {
    [0]={
        .start = IRQ_EINT(0),
        .end   = IRQ_EINT(0),
        .flags = IORESOURCE_IRQ,
    },
    [1]={
        .start = IRQ_EINT(1),
        .end   = IRQ_EINT(1),
        .flags = IORESOURCE_IRQ,
    },
    [2]={
        .start = IRQ_EINT(2),
        .end   = IRQ_EINT(2),
        .flags = IORESOURCE_IRQ,
    },
    [3]={
        .start = IRQ_EINT(3),
        .end   = IRQ_EINT(3),
        .flags = IORESOURCE_IRQ,
    },
    [4]={
        .start = IRQ_EINT(4),
        .end   = IRQ_EINT(4),
        .flags = IORESOURCE_IRQ,
    },
    [5]={
        .start = IRQ_EINT(5),
        .end   = IRQ_EINT(5),
        .flags = IORESOURCE_IRQ,
    }
};

static struct platform_device *s3c_buttons;


static int __init platform_init(void)
{

    s3c_buttons = platform_device_alloc(DEVICE_NAME,-1);

    //爲平臺設備s3c_buttons添加平臺資源
    platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,6);

    /*平臺設備的註冊*/
    platform_device_add(s3c_buttons);


}

static void __exit platform_exit(void)
{
    platform_device_unregister(s3c_buttons);
}

module_init(platform_init);
module_exit(platform_exit);

MODULE_AUTHOR("Sola");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:ok6410_buttons");

plat_btn_driver.c

#include <linux/module.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/clk.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <mach/map.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/unistd.h>
#include <linux/device.h>


#define DRIVER_NAME "ok6410_plat_btn"


//定義並初始化等待隊列頭
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;


static int key_value;
static struct device     *buttons_dev;  /* platform device attached to */
static struct resource   *buttons_irq;


static int button_irqs[6];//中斷號




/*按鍵中斷處理函數*/
static irqreturn_t buttons_interrupt(int irq, void *dev_id)
{
    int i;
    for(i=0; i<6; i++){
        if(irq == button_irqs[i]){
            //printk("==>interrput number:%d\n",irq);
            key_value = i;
            ev_press =1;
            wake_up_interruptible(&button_waitq);
        }
    }

    return IRQ_RETVAL(IRQ_HANDLED);

}



static int s3c6410_buttons_open(struct inode *inode, struct file *file)
{
    int i;
    int err = 0;
    /*註冊中斷*/
    for(i=0; i<6; i++){
        if (button_irqs[i] < 0)
            continue;

        /*中斷觸發方式：下降沿觸發，中斷接口函數*/
        err = request_irq(button_irqs[i],buttons_interrupt,IRQF_TRIGGER_FALLING,NULL,NULL);
        if(err)
          break;
    }

    if (err) {
        i--;
        for (; i >= 0; i--) {
            if (button_irqs[i] < 0) {
                continue;
            }
            disable_irq(button_irqs[i]);
            free_irq(button_irqs[i], NULL);
        }
        return -EBUSY;
    }

    ev_press = 0;
    return 0;
}

static int s3c6410_buttons_close(struct inode *inode, struct file *file)
{
    int i;
    for (i=0; i<6; i++) {
            if (button_irqs[i] < 0) {
                continue;
            }
            free_irq(button_irqs[i],NULL);
    }
    return 0;
}

static int s3c6410_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)//如果是非阻塞模式，就直接返回
            return -EAGAIN;
        else
            //阻塞，直到按鍵按下
            wait_event_interruptible(button_waitq, ev_press);
    }
    ev_press = 0;

    //將鍵值送回到用戶空間
    err = copy_to_user(buff, &key_value, sizeof(key_value));
    return sizeof(key_value);
}

static unsigned int s3c6410_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;
    }

    //返回掩碼
    return mask;
}



static struct file_operations ok6410_buttons_fops = {
    .owner   =   THIS_MODULE,
    .open    =   s3c6410_buttons_open,
    .release =   s3c6410_buttons_close,
    .read    =   s3c6410_buttons_read,
    .poll    =   s3c6410_buttons_poll,
};



//聲明一個混雜設備,設備名稱爲"buttons"
static struct miscdevice ok6410_miscdev = {

    .minor = MISC_DYNAMIC_MINOR,
    .name ="buttons",
    .fops = &ok6410_buttons_fops,//操作集
};

/* device interface ，當發現匹配設備時會調用此函數*/
static int ok6410_buttons_probe(struct platform_device *pdev)
{
    struct resource *res;
    struct device *dev;
    int ret;
    int size;
    int i;

    printk("probe:%s\n", __func__);
    dev = &pdev->dev;
    buttons_dev = &pdev->dev;

    /*平臺資源獲取*/
 /*get irq number*/
  for(i=0; i<6; i++){
    //獲取中斷號
     buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);
     if(buttons_irq == NULL){
        dev_err(dev,"no irq resource specified\n");
          ret = -ENOENT;
        return ret;
    }
    button_irqs[i] = buttons_irq->start;
    //printk("button_irqs[%d]=%d\n",i,button_irqs[i]);
    }

    //註冊混雜設備
    ret = misc_register(&ok6410_miscdev);



    return ret;
}

static int ok6410_buttons_remove(struct platform_device *dev)
{

    misc_deregister(&ok6410_miscdev);
    return 0;
}

/*平臺驅動定義*/
static struct platform_driver ok6410_buttons_driver = {
    .probe      = ok6410_buttons_probe,//探針函數
    .remove     = ok6410_buttons_remove,
    .driver     = {
        .owner  = THIS_MODULE,
        .name   = DRIVER_NAME,
    },
};

static char banner[] __initdata =
     "ok6410 Buttons Driver\n";

static int __init buttons_init(void)
{
    printk(banner);
    /*平臺驅動註冊*/
    platform_driver_register(&ok6410_buttons_driver);
    return 0;
}

static void __exit buttons_exit(void)
{
    //平臺驅動的註銷
    platform_driver_unregister(&ok6410_buttons_driver);
}

module_init(buttons_init);
module_exit(buttons_exit);

MODULE_AUTHOR("David Xie");
MODULE_DESCRIPTION("ok6410 Buttons Driver");
MODULE_LICENSE("GPL");

測試程序:

app-button.c

/*
 *      Buttons Example for Matrix V
 *
 *      Copyright (C) 2004 capbily - friendly-arm
 *  [email protected]
 */
#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>

int main(void)
{
    int buttons_fd;
    int key_value;

    buttons_fd = open("/dev/buttons", 0);
    if (buttons_fd < 0) {
        perror("open device buttons");
        exit(1);
    }

    for (;;) {
        fd_set rds;
        int ret;

        FD_ZERO(&rds);
        FD_SET(buttons_fd, &rds);

        ret = select(buttons_fd + 1, &rds, NULL, NULL, NULL);
        if (ret < 0) {
            perror("select");
            exit(1);
        }
        if (ret == 0) {
            printf("Timeout.\n");
        } else if (FD_ISSET(buttons_fd, &rds)) {
            int ret = read(buttons_fd, &key_value, sizeof key_value);
            if (ret != sizeof key_value) {
                if (errno != EAGAIN)
                    perror("read buttons\n");
                continue;
            } else {
                printf("buttons_value: %d\n", key_value+1);
            }

        }
    }

    close(buttons_fd);
    return 0;
}

Makefile:

ifneq ($(KERNELRELEASE),)

obj-m := plat_btn_device.o plat_btn_driver.o

else

KDIR := /home/ok6410/kernel/linux2.6.28
all:
    make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
    rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*

endif

實驗步驟，分別編譯生成內核模塊plat_btn_drvice.ko     plat_btn_driver.ko

然後先加載plat_btn_device.ko內核模塊，再加載plat_tbn_driver.ko

最後運行測試程序:app-button

實驗結果如下:

分享到：