嵌入式LINUX四按键驱动

对一个具有四个按键的按键驱动的分析

源代码：

/*Headers-------------------------------------------------*/

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#ifdef CONFIG_DEVFS_FS

#include

#endif

/*V ars----------------------------------------------------*/

#define DEVICE_NAME "buttons"

#define EXTINT_OFF (IRQ_EINT4 - 4)

unsigned int buttons_major=0;

unsigned int buttons_minor=0;

unsigned int type = IRQT_FALLING;

struct button_info {

unsigned int irq_no;

unsigned int gpio_port;

unsigned int IN;

int button_no;

};

struct button_info realarm_button_info[4] = {

{ IRQ_EINT19, S3C2410_GPG11, S3C2410_GPG11_INP, 1 }, { IRQ_EINT8, S3C2410_GPG0, S3C2410_GPG0_INP, 2 },

{ IRQ_EINT11, S3C2410_GPG3, S3C2410_GPG3_INP, 3 }, { IRQ_EINT2, S3C2410_GPF2, S3C2410_GPF2_INP, 4 }, };

struct realarm_button_dev

{

struct button_info buttoninfo_tab[4];

int extint_num[4];

struct semaphore sem;

wait_queue_head_t wq;

struct cdev buttons_dev;

};

struct realarm_button_dev *realarm_button_device;

void s3c_irq_ack(unsigned int irqno)

{

unsigned long bitval = 1UL << (irqno - IRQ_EINT0);

__raw_writel(bitval, S3C2410_SRCPND);

__raw_writel(bitval, S3C2410_INTPND);

return;

}

void s3c_irqext_ack(unsigned int irqno)

{

unsigned long req;

unsigned long bit;

bit = 1UL << (irqno - EXTINT_OFF);

__raw_writel(bit, S3C2410_EINTPEND);

req = __raw_readl(S3C2410_EINTPEND);

if (irqno <= IRQ_EINT7 )

{

if ((req & 0xf0) == 0)

s3c_irq_ack(IRQ_EINT4t7);

}

else

{

if ((req >> 8) == 0)

s3c_irq_ack(IRQ_EINT8t23);

return;

}

int realarm_interrupt_init(unsigned int irq, unsigned int type) {

unsigned long gpcon_reg;

unsigned long gpcon_offset;

unsigned long extint_reg;

unsigned long extint_offset;

unsigned long newvalue = 0;

unsigned long value;

if ((irq >= IRQ_EINT0) && (irq <= IRQ_EINT3))

{

gpcon_reg = S3C2410_GPFCON;

extint_reg = S3C2410_EXTINT0;

gpcon_offset = (irq - IRQ_EINT0) * 2;

extint_offset = (irq - IRQ_EINT0) * 4;

}

else if ((irq >= IRQ_EINT4) && (irq <= IRQ_EINT7))

{

gpcon_reg = S3C2410_GPFCON;

extint_reg = S3C2410_EXTINT0;

gpcon_offset = (irq - EXTINT_OFF) * 2;

extint_offset = (irq - EXTINT_OFF) * 4;

}

else if ((irq >= IRQ_EINT8) && (irq <= IRQ_EINT15)) {

gpcon_reg = S3C2410_GPGCON;

extint_reg = S3C2410_EXTINT1;

gpcon_offset = (irq - IRQ_EINT8) * 2;

extint_offset = (irq - IRQ_EINT8) * 4;

}

else if ((irq >= IRQ_EINT16) && (irq <= IRQ_EINT23)) {

gpcon_reg = S3C2410_GPGCON;

extint_reg = S3C2410_EXTINT2;

gpcon_offset = (irq - IRQ_EINT8) * 2;

extint_offset = (irq - IRQ_EINT16) * 4;

} else

{

return -1;

/* Set the GPIO to external interrupt mode */

value = __raw_readl(gpcon_reg);

value = (value & ~(3 << gpcon_offset)) | (0x02 << gpcon_offset);

__raw_writel(value, gpcon_reg);

/* Set the external interrupt to pointed trigger type */

switch (type)

{

case IRQT_NOEDGE:

printk(KERN_WARNING "No edge setting!\n");

break;

case IRQT_RISING:

newvalue = S3C2410_EXTINT_RISEEDGE;

break;

case IRQT_FALLING:

newvalue = S3C2410_EXTINT_FALLEDGE;

break;

case IRQT_BOTHEDGE:

newvalue = S3C2410_EXTINT_BOTHEDGE;

break;

case IRQT_LOW:

newvalue = S3C2410_EXTINT_LOWLEV;

break;

case IRQT_HIGH:

newvalue = S3C2410_EXTINT_HILEV;

break;

default:

printk(KERN_ERR "No such irq type %d", type);

return -1;

}

value = __raw_readl(extint_reg);

value = (value & ~(7 << extint_offset)) | (newvalue << extint_offset); __raw_writel(value, extint_reg);

return 0;

static irqreturn_t buttons_irq(int irq, void *dev_id, struct pt_regs *req)

{

struct button_info *k;

int i;

int found = 0;

struct realarm_button_dev* dev = (struct realarm_button_dev *) dev_id;

int up;

for (i = 0; i < sizeof dev->buttoninfo_tab / sizeof dev->buttoninfo_tab[0]; i++) { k = dev->buttoninfo_tab + i;

if (k->irq_no == irq) {

found = 1;

if(irq <= IRQ_EINT3)

s3c_irq_ack(irq);

else

s3c_irqext_ack(irq);

disable_irq(irq);

mdelay(200);

s3c2410_gpio_cfgpin(k->gpio_port, k->IN);

up = s3c2410_gpio_getpin(k->gpio_port);

if (!up) {

dev->extint_num[i]++;

wake_up_interruptible(&dev->wq);

}

realarm_interrupt_init(irq, type);

enable_irq(irq);

break;

}

}

if (!found) {

printk("bad irq %d in button\n", irq);

return IRQ_NONE;

}

return IRQ_HANDLED;

}

int realarm_request_irq(struct realarm_button_dev* dev)

{

struct button_info *k;

int i;

int ret;

unsigned int irq;

for (i = 0; i < sizeof dev->buttoninfo_tab / sizeof dev->buttoninfo_tab[0]; i++) { k = dev->buttoninfo_tab + i;

irq = k->irq_no;

realarm_interrupt_init(irq, type);

ret = request_irq(irq, &buttons_irq, SA_INTERRUPT, DEVICE_NAME, dev);

if (ret) {

printk(KERN_WARNING "buttons:can't get irq no.\n");

return ret;

}

}

return 0;

}

int buttons_open(struct inode *inode, struct file *filp)

{

struct realarm_button_dev *dev;

dev = container_of(inode->i_cdev, struct realarm_button_dev, buttons_dev);

filp->private_data = dev;

realarm_request_irq(dev);

return 0;

}

int buttons_release(struct inode *inode, struct file *filp)

{

struct realarm_button_dev *dev = (struct realarm_button_dev *)filp->private_data;

struct button_info *k;

int i;

for (i = 0; i < sizeof dev->buttoninfo_tab / sizeof dev->buttoninfo_tab[1]; i++) { k = dev->buttoninfo_tab + i;

free_irq(k->irq_no, dev);

}

return 0;

}

ssize_t buttons_read(struct file *filp,char __user *buffer,size_t count,loff_t *ppos)

{

struct realarm_button_dev *dev = (struct realarm_button_dev *)filp->private_data;

if (down_interruptible(&dev->sem))

return -ERESTARTSYS;

interruptible_sleep_on(&dev->wq);

if(copy_to_user(buffer, (char *)dev->extint_num, sizeof(dev->extint_num)))

{

printk(KERN_ALERT "Copy to user error.\n");

return -EFAULT;

}

up(&dev->sem);

return sizeof(dev->extint_num);

}

struct file_operations buttons_fops = {

.owner = THIS_MODULE,

.open = buttons_open,

.release = buttons_release,

.read =buttons_read,

};

static int __init buttons_init(void)

{

int i;

int ret;

dev_t dev;

printk(KERN_INFO "Initial RealARM Buttons driver!\n");

if (buttons_major) {

dev = MKDEV(buttons_major, buttons_minor);

ret = register_chrdev_region(dev, 1, DEVICE_NAME);

} else {

ret = alloc_chrdev_region(&dev, buttons_minor, 1, DEVICE_NAME);

buttons_major = MAJOR(dev);

}

if (ret < 0) {

printk(KERN_WARNING "Buttons: can't get major %d\n", buttons_major);

return ret;

}

realarm_button_device = kmalloc(sizeof(struct realarm_button_dev), GFP_KERNEL);

if (!realarm_button_device) {

unregister_chrdev_region(dev, 1);

ret = -ENOMEM;

return ret;

}

memset(realarm_button_device, 0, sizeof(struct realarm_button_dev));

memcpy(realarm_button_device->buttoninfo_tab, realarm_button_info, sizeof(realarm_button_info));

for(i = 0; i < 4; i++)

{

realarm_button_device->extint_num[i] = 0;

}

init_MUTEX(&realarm_button_device->sem);

init_waitqueue_head(&realarm_button_device->wq);

cdev_init(&realarm_button_device->buttons_dev, &buttons_fops);

realarm_button_device->buttons_dev.owner = THIS_MODULE;

realarm_button_device->buttons_dev.ops = &buttons_fops;

ret = cdev_add(&realarm_button_device->buttons_dev, dev, 1);

if (ret) {

unregister_chrdev_region(dev, 1);

printk(KERN_NOTICE "Error %d adding buttons device\n",ret);

return ret;

}

#ifdef CONFIG_DEVFS_FS

devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR, DEVICE_NAME);

printk(KERN_INFO"/dev/%s has been added to your system.\n",DEVICE_NAME);

#else

printk(DEVICE_NAME "Initialized\n");

printk(KERN_INFO "You must create the dev file manually.\n");

printk(KERN_INFO "Todo: mknod c /dev/%s %d 0\n",DEVICE_NAME,buttons_major);

#endif

return 0;

}

static void __exit buttons_cleanup(void)

{

dev_t dev = MKDEV(buttons_major, buttons_minor);

cdev_del(&realarm_button_device->buttons_dev);

kfree(realarm_button_device);

unregister_chrdev_region(dev, 1);

#ifdef CONFIG_DEVFS_FS

devfs_remove(DEVICE_NAME);

#endif

printk(KERN_INFO "unregistered the %s\n",DEVICE_NAME); }

module_init(buttons_init);

module_exit(buttons_cleanup);

MODULE_AUTHOR("LiuRui");

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Key driver for RealARM");

分析：

四个按键信息说明

struct button_info realarm_button_info[4] = {

{ IRQ_EINT19, S3C2410_GPG11, S3C2410_GPG11_INP, 1 }, { IRQ_EINT8, S3C2410_GPG0, S3C2410_GPG0_INP, 2 }, { IRQ_EINT11, S3C2410_GPG3, S3C2410_GPG3_INP, 3 }, { IRQ_EINT2, S3C2410_GPF2, S3C2410_GPF2_INP, 4 }, };

自定义按键结构把字符设备嵌入其中

struct realarm_button_dev

{

struct button_info buttoninfo_tab[4];//记录每个按键信息

int extint_num[4]; //用于记录按键的次数

struct semaphore sem;//消息变量

wait_queue_head_t wq;//等待队列

struct cdev buttons_dev;//嵌入字符设备

};

程序流程分析：

module_init(buttons_init);

module_exit(buttons_cleanup);

对file_operations 中各个函数的实现分析：

struct file_operations buttons_fops = {

.owner = THIS_MODULE,

.open = buttons_open,

.release = buttons_release,

.read = buttons_read,

};

buttons_open

先来说一下container_of函数

318#define container_of(ptr, type, member) ({ \

319const typeof( ((type *)0)->member ) *__mptr = (ptr); \

320(type *)( (char *)__mptr - offsetof(type,member) );})

指针ptr指向结构体type中的成员member；通过指针ptr，返回结构体type的起始地址。

type

|---------- ----- |

| |

| |

|---------- ----- |

ptr-->| member |

|---------- ----- |

| |

| |

|---------- ----- |

buttons_release

buttons_read

来分析中断处理子程序流程

ret = request_irq(irq, &buttons_irq, SA_INTERRUPT, DEVICE_NAME, dev); 通过这句话把中断号和中断处理子程序绑定起来

对中断处理程序的分析

buttons_irq

字符设备驱动自此分析完毕，发现驱动并不向大家想象的那样难。通常各种常见驱动比如字符设备驱动，块设备驱动都有一定框架，各个模块的功能也很清晰，只要我们按照这个框架，一步一步就可以完成我们自己的驱动。