[字符设备]key设备驱动(中断+异步IO)

--key.c

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/mm.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <asm/io.h>
#include <asm/module.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>

#include "keydev.h"
#define BUTTON_MAJOR 0
#define DEVICE_NAME "button"
#define BUTTON_NR_DEVS 1
static int button_major = BUTTON_MAJOR;

struct button_dev
{
    struct cdev dev;
    wait_queue_head_t button_queue;
    struct fasync_struct *async_queue;
};
struct button_dev *devp;
static struct class *button_class;
static volatile int press_no = -1;

struct button_irq_desc
{
    int irq;
    int pin;
    int flags;
    int no;
    char *name;
};

static struct button_irq_desc button_irq_table [] =
{
    {IRQ_EINT8 , S3C2410_GPG(0) , S3C2410_GPG0_EINT8  , 0, "KEY0"},
    {IRQ_EINT11, S3C2410_GPG(3) , S3C2410_GPG3_EINT11 , 1, "KEY1"},
    {IRQ_EINT13, S3C2410_GPG(5) , S3C2410_GPG5_EINT13 , 2, "KEY2"},
    {IRQ_EINT14, S3C2410_GPG(6) , S3C2410_GPG6_EINT14 , 3, "KEY3"},
    {IRQ_EINT15, S3C2410_GPG(7) , S3C2410_GPG7_EINT15 , 4, "KEY4"},
    {IRQ_EINT19, S3C2410_GPG(11), S3C2410_GPG11_EINT19, 5, "KEY5"},
};

static int s3c2440_key_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
        case KEYDEV_POLL:
            break;
        case KEYDEV_IRQ:
            break;
        default:
            return -EINVAL;
    }
    return 0;
}

static int s3c2440_key_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    int err;
    err = copy_to_user(buf, (void *)&press_no, sizeof(int));
    return err ? -EFAULT : 0;
}


static int s3c2440_key_open(struct inode *inode, struct file *filp)
{
    struct button_dev *dev;
    dev = container_of(inode->i_cdev, struct button_dev, dev);
    filp->private_data = dev;
    return 0;
}

static int s3c2440_key_fasync(int fd, struct file *filp, int mode)
{
    struct button_dev *dev = filp->private_data;
    return fasync_helper(fd, filp, mode, &dev->async_queue);
}

static int s3c2440_key_release(struct inode *inode, struct file *filp)
{
    s3c2440_key_fasync(-1, filp, 0);
    return 0;
}

static struct file_operations dev_fops =
{
    .owner = THIS_MODULE,
    .ioctl = s3c2440_key_ioctl,
    .open  = s3c2440_key_open,
    .read  = s3c2440_key_read,
    .release = s3c2440_key_release,
    .fasync = s3c2440_key_fasync,
};

static irqreturn_t button_irq_handler(int irq, void *dev_id)
{
    int i = *(int *)dev_id;
    if (!s3c2410_gpio_getpin(button_irq_table[i].pin))
    {
        press_no = i;
        if (devp->async_queue)
            kill_fasync(&devp->async_queue, SIGIO, POLL_OUT);
    }
    return IRQ_RETVAL(IRQ_HANDLED);
}

static void s3c2440_key_setup_irq(void)
{
    int i, err;
    for (i = 0; i < sizeof(button_irq_table)/sizeof(button_irq_table[0]); ++i)
    {
        err = request_irq(button_irq_table[i].irq, button_irq_handler, IRQ_TYPE_EDGE_BOTH, button_irq_table[i].name, (void *)&button_irq_table[i].no);

        if (err)
            printk("apply fail-->%d\n", i);
    }
}

static void s3c2440_key_free_irq(void)
{
    int i;
    for (i = 0; i < sizeof(button_irq_table)/sizeof(button_irq_table[0]); ++i)
    {
        free_irq(button_irq_table[i].irq, &button_irq_table[i].no);
    }
}

static int __init s3c2440_key_init(void)
{
    int result;
    struct device *devxx;
    dev_t devno = MKDEV(button_major, 0);

    if (button_major)
        result = register_chrdev_region(devno, BUTTON_NR_DEVS, DEVICE_NAME);
    else
    {
        result = alloc_chrdev_region(&devno, 0, BUTTON_NR_DEVS, DEVICE_NAME);
        button_major = MAJOR(devno);
        printk("Major-->%d\n", button_major);
    }

    if (result < 0)
        return result;

    devp = kmalloc(sizeof(struct button_dev), GFP_KERNEL);
    if (!devp)
    {
        result = -ENOMEM;
        goto fail_malloc;
    }
    memset(devp, 0, sizeof(struct button_dev));

    cdev_init(&devp->dev, &dev_fops);
    devp->dev.owner = THIS_MODULE;

    cdev_add(&devp->dev, devno, BUTTON_NR_DEVS);

    s3c2440_key_setup_irq();
    init_waitqueue_head(&devp->button_queue);

    button_class = class_create(THIS_MODULE, "button_class");
    if (IS_ERR(button_class))
    {
        printk("create class fail!\n");
        goto fail_class;
    }
    devxx = device_create(button_class, NULL, devno, NULL, DEVICE_NAME);
    if (IS_ERR(devxx))
    {
        printk("create device fail!\n");
        goto fail_device;
    }
    return 0;

fail_device:
    class_destroy(button_class);
fail_class:
    cdev_del(&devp->dev);
fail_malloc:
    unregister_chrdev_region(devno, BUTTON_NR_DEVS);
    return result;
}


static void __exit s3c2440_key_exit(void)
{
    s3c2440_key_free_irq();
    cdev_del(&devp->dev);
    device_destroy(button_class, MKDEV(button_major, 0));
    class_destroy(button_class);
    unregister_chrdev_region(MKDEV(button_major, 0), BUTTON_NR_DEVS);
}


MODULE_LICENSE("GPL");
MODULE_AUTHOR("Domod");
module_init(s3c2440_key_init);
module_exit(s3c2440_key_exit);

--keydev.h

#ifndef __KEYDEV_H__
#define __KEYDEV_H__

#include <linux/ioctl.h>
#define KEYDEV_IOC_MAGIC 'k'

#define KEYDEV_POLL _IO(KEYDEV_IOC_MAGIC, 1)
#define KEYDEV_IRQ  _IO(KEYDEV_IOC_MAGIC, 2)

#define KEYDEV_IOC_MAXNR 2

#endif

--app-key.c

#include "keydev.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/ioctl.h>

int fd;
void input_handler(int num)
{
    int i;
    fd = open("/dev/button", 0);
    read(fd, &i, 4);
    printf("key%d is pressing!\n", i);
}

int main(int argc, char **argv)
{
    int fd, oflags;

    fd = open("/dev/button", 0);
    signal(SIGIO, input_handler);
    fcntl(fd, F_SETOWN, getpid());//设置接收信号的进程为当前进程
    oflags = fcntl(fd, F_GETFL);//读取当前得文件属性
    fcntl(fd, F_SETFL, oflags | FASYNC);


    while(1);
}

--Makefile

ifneq ($(KERNELRELEASE),)

obj-m := key.o

else

KDIR := /home/domod/arm/kernel/src/linux-2.6.32.2
all:
make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
app:
arm-linux-gcc app-key.c -o key
clean:
rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*


endif