一、补充知识

1.中断

装载至：https://blog.csdn.net/qq_20553613/article/details/80629255

1.1 概念

不同于裸机编程，操作系统是多个进程和多个线程执行，宏观上达到并行运行的状态，外设中断则会打断内核中任务调度和运行，及屏蔽其外设的中断响应，如果中断函数耗时过长则使得系统实时性和并发性降低。中断原则是尽可能处理少的事务，而一些设备中往往需要处理大量的耗时事务。为了提高系统的实时性和并发性，Linux内核将中断处理程序分为上半部（top half）和下半部（bottom half）。上半部分任务比较少，处理一些寄存器操作、时间敏感任务，以及“登记中断”通知内核及时处理下半部的任务。下半部分，则负责处理中断任务中的大部分工作，如一个总线通信系统中数据处理部分。

1.2 Linux中断上下部分区别：

1）上半部由外设中断触发，下半部由上半部触发。
2）上半部不会被其他中断打断，下半部是可以被打断的。
3）上半部分处理任务要快，主要任务、耗时任务放在下半部。

一般来说，在中断上半部执行完毕，下半部即在内核的调度下被执行，当然如果有其他更高优先级需处理的任务，会先处理该任务再调度处理下半部，或者在系统空闲时间进行处理。

1.3 处理原则

对于Linux系统设备而言，一个完整的中断程序由上半部和下半部分共同构成，在编写设备驱动程序前，就需考虑好上半部和下半部的分配。很多时候上半部与下半部并没有严格的区分界限，主要由程序员根据实际设计，如某些外设中断可以没有下半部。关于上下半部的划分原则，就是主要事务、耗时事务划分在下半部处理。

关于中断上下部分的设计，可以参考以下原则：
1）与硬件相关的操作，如操作寄存器，必须放在上半部。
2）对时间敏感、要求实时性的任务放在上半部。
3）该任务不能被其他中断或者进程打断的放在上半部。
4）实时性要求不高的任务、耗时任务放在下半部。

1.4 中断下半部

Linux下半部实现，通过内核版本更新中实现下衍化，最原始的实现手段是BH（bottom half）后在2.5版本移除，在2.3版本引入软中断（softirq）和tasklet机制，在2.5版本引入工作队列（work queue在）。因此，目前使用方式是三种，软中断、tasklet机制、工作队列。

1.5 中断使用

Linux驱动中断涉及到的主要函数有：

request_irq()　　　　申请中断

free_irq()　　　　　　释放中断

irq_interrupt()　　　 中断服务

2. 定时器

转载至：https://blog.csdn.net/dreamInTheWorld/article/details/107471967
内核定时器为了可以在某个时间点上调用函数，内核定时器的调度函数运行过一次后就不会再被运行了，
但是在del_timer销毁定时之前，可以使用add_timer(注册)或者mod_timer(修改)重新调用
一般重新调用的场景有
1 通过在被调度的函数中重新调度自己来周期运行。
2 通过某个中断服务函数中重新唤起调用

add_timer	把定时器注册连接到内核专门的链表中(最终也是通过调用mod_timer实现)
mod_timer	重新注册定时器到内核专门的链表中(不管定时器函数是否被运行过)
del_timer	注销一个定时器(它不会等待其他CPU上的调度结束，在单核处理器上，可以直接使用)
del_timer_sync	注销一个定时器(用于SMP多核系统，会进入休眠等待其他CPU上的调度结束)
timer_pending	判断一个定时器是否被添加到了内核链表中以等待被调度运行
setup_timer	建个定时器 主要负责给 function 和 data 进行赋值工作

jiffies

时间中断由系统定时硬件以周期性间隔产生，这个间隔由内核根据HZ的值设定，我们应保留默认的HZ值不要自行调整，每当时间中断发生的时，内核内部计数器的值就增加一，计数器的值在系统引导时被初始化为0，读取变量jiffies的值就可以获取计数器的值，这里值得注意的是jiffies应被看成只读变量。Linux系统的宏HZ的值一般在体系相关的目录，arch/arm/include/asm/param.h
所以本机配置， 1 jiffies = 10ms

3. 等待队列

3.1 定义并初始化"等待队列头"

wait_queue_head_t w_queue;
init_waitqueue_head(&w_queue); //会将自旋锁初始化为未锁，等待队列初始化为空的双向循环链表。

3.2 等待事件

• wait_event(queue,condition);等待以queue为等待队列头等待队列被唤醒，condition必须满足，否则阻塞
• wait_event_interruptible(queue,condition);可被信号打断
• wait_event_timeout(queue,condition,timeout);阻塞等待的超时时间，时间到了，不论condition是否满足，都要返回
• wait_event_interruptible_timeout(queue,condition,timeout)

3.3唤醒队列

• wake_up()与wake_event()或者wait_event_timeout成对使用
• wake_up_intteruptible()与wait_event_intteruptible()或者wait_event_intteruptible_timeout()成对使用。

等待队列的流程：首先，定义并初始化等待队列，把进程的状态置成TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE，并将对待队列添加到等待队列头。最后，当进程被其他地方唤醒，将等待队列移除等待队列头。

二、驱动程序编写

1. 创建描述设备数据结构

• 判断按键是否按下， 我们不仅仅需要按键的数据信息，还需要一个状态位来判断当前的状态， 我们令这个为位status， 当status为1时按键按下， status为0时按键没有按下，status为2时按键为未确定位， 用于消抖。状态位确定之后， 我们再设置标志ev_press位来标志当前状态。
• 既然需要消抖，熟悉单片机的朋友肯定第一时间相到延时， 但是这里为了不占用内核的太多时间， 我们采用定时器来完成中断的下半部工作， 关于这个下半部， 后面会详细分析。
• 那么问题来了，有多个中断源需要判断， 我们应该如何处理， 这里需要用到一个多路复用的知识， 建立等待队列， 用户空间调用select或者poll， 会关联到内核内.poll函数来监视等待队列。
• 注册驱动， 我们需要注册cdev结构体。
• 自动创建结点， 需要创建class结构体。

2. 编写模块

驱动模块主体无非声明模块作者，协议以及模块描述， 也可以添加出传入模块参数， 再完成模块入口和出口函数编写：

static struct platform_driver s3c_button_driver = {.probe = s3c_button_probe,.remove = s3c_button_remove,.driver = {.name = "s3c_key",.owner = THIS_MODULE,},
};
static int __init s3c_button_init(void)
{int     rv=0;rv = platform_driver_register(&s3c_button_driver);if(rv){printk(KERN_ERR "%s:%d: Can't  regist button driver %d.\n", __FUNCTION__, __LINE__, rv);platform_driver_unregister(&s3c_button_driver);return rv;}printk("Regist button driver sucessfully!\n");return 0;
}static void s3c_button_exit(void)
{printk("%s:%d remove the BUTTON platform driver.\n", __FUNCTION__, __LINE__);platform_driver_unregister(&s3c_button_driver);
}module_init(s3c_button_init);
module_exit(s3c_button_exit);module_param(dev_major, int, S_IRUGO);
module_param(dev_minor, int, S_IRUGO);MODULE_AUTHOR("Moqiu <comeonqiuliang@163.com>");
MODULE_DESCRIPTION("FL2440 BUTTON DRIVER");
MODULE_LICENSE("GPL");

3.模块配置

模块配置也就分为四步：

• 硬件初始化， 本模块我们将硬件初始化放到open函数中进行
• 分配主次设备号
• 分配cdev结构体
• 绑定主次设备号、fops到cdev结构体中，并注册给Linux内核

static struct file_operations s3c_button_fops = {.owner = THIS_MODULE,.open = button_open,.read = button_read,.poll = button_poll,.release = button_release,
};static int s3c_button_probe(struct platform_device *dev)
{int    result = 0;dev_t  devno;if(0 != dev_major){devno = MKDEV(dev_major, dev_minor);result = register_chrdev_region(devno, 1, DEV_NAME);}else{result = alloc_chrdev_region(&devno, dev_major, 1, DEV_NAME);dev_major = MAJOR(devno);}if(result < 0){printk("%s driver can't get major %d\n", DEV_NAME, dev_major);return result;}memset(&button_device, 0,sizeof(button_device));button_device.data = dev->dev.platform_data;cdev_init(&(button_device.cdev), &s3c_button_fops);button_device.cdev.owner = THIS_MODULE;result = cdev_add(&(button_device.cdev), devno, 1);if(result){printk(KERN_NOTICE "error %d add %s device", result, DEV_NAME);goto ERROR;}button_device.dev_class = class_create(THIS_MODULE, DEV_NAME);if(IS_ERR(button_device.dev_class)){printk("%s driver create class failure\n", DEV_NAME);result = -ENOMEM;goto ERROR;}#if  LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)device_create(button_device.dev_class, NULL, devno, NULL, DEV_NAME);
#elsedevice_create(button_device.dev_class, NULL, devno, DEV_NAME);
#endifreturn 0;
ERROR:printk("s3c %s driver install faliure.\n", DEV_NAME);cdev_del(&(button_device.cdev));unregister_chrdev_region(devno, 1);return result;
}

4. 配置卸载

卸载需要将原有申请的cdev结构体删除释放， 删除已安装结点：

static int s3c_button_remove(struct platform_device *dev)
{dev_t devno = MKDEV(dev_major, dev_minor);cdev_del(&(button_device.cdev));device_destroy(button_device.dev_class, devno);class_destroy(button_device.dev_class);unregister_chrdev_region(devno, 1);printk("s3c %s driver removed \n", DEV_NAME);return 0;
}

5. 关联函数

通过file_operations 类型结构体来配置我们的相应的关联函数：

static struct file_operations s3c_button_fops = {.owner = THIS_MODULE,.open = button_open,.read = button_read,.poll = button_poll,.release = button_release,
};

5.1 open

用户程序空间进行系统调用open后， 会关联button_open函数，在VFS层完成驱动设备的绑定，并且完成硬件初始化工作，定时器初始化和poll等待队列初始化，主要工作包括配置GPIO口并且为每个IO口申请一个定时器和装置位的用户空间， 绑定定时器相应函数：

static int button_open(struct inode *inode, struct file *file)
{struct button_device *pdev;struct s3c_button_platform_data *pdata;int i, result;pdev = container_of(inode->i_cdev, struct button_device, cdev);pdata = pdev->data;file->private_data = pdev;pdev->timers = (struct timer_list *)kmalloc(pdata->nbuttons * sizeof(struct timer_list), GFP_KERNEL);if(NULL == pdev->timers){printk("Alloc %s driver for timers faliure.\n", DEV_NAME);return -ENOMEM;}memset(pdev->timers, 0, pdata->nbuttons*sizeof(struct timer_list));pdev->status = (unsigned char *)kmalloc(pdata->nbuttons*sizeof(unsigned char), GFP_KERNEL);if(NULL == pdev->status){printk("Alloc %s driver for status faliure.\n", DEV_NAME);result = -ENOMEM;goto ERROR;}memset(pdev->status, 0, pdata->nbuttons*sizeof(unsigned char));init_waitqueue_head(&(pdev->waitq));for(i=0; i<pdata->nbuttons; i++){pdev->status[i] = BUTTON_UP;setup_timer(&(pdev->timers[i]), s3c_button_timer_handler, i);s3c2410_gpio_cfgpin(pdata->buttons[i].gpio, pdata->buttons[i].setting);irq_set_irq_type(pdata->buttons[i].nIRQ, IRQ_TYPE_EDGE_FALLING);result =  request_irq(pdata->buttons[i].nIRQ, s3c_button_intterupt, IRQF_DISABLED, DEV_NAME, (void*)i);if(result){result = -EBUSY;goto ERROR1;}}return 0;ERROR1:kfree((unsigned char *)pdev->status);while(--i){disable_irq(pdata->buttons[i]. nIRQ);free_irq(pdata->buttons[i].nIRQ, (void*)i);}ERROR:kfree(pdev->timers);return result;}

5.2 poll

当用户空间调用select或者poll多路复用后，会自动绑定button_poll, button_poll会将需要监视的文件描述符加入监视队列中。

static unsigned int button_poll(struct file *file, poll_table *wait)
{struct button_device *pdev  = file->private_data;unsigned int mask = 0;poll_wait(file, &(pdev->waitq), wait);if(pdev->ev_press){mask |= POLLIN | POLLRDNORM;}return mask;
}

poll()函数最后应该返回设备资源的可获取状态

常量	说明
POLLIN	普通或优先级带数据可读
POLLRDNORM	普通数据可读
POLLRDBAND	优先级带数据可读
POLLPRI	高优先级数据可读
POLLOUT	普通数据可写
POLLWRNORM	普通数据可写
POLLWRBAND	优先级带数据可写
POLLERR	发生错误
POLLHUP	发生挂起
POLLNVAL	描述字不是一个打开的文件

5.3 read

当.poll检测到相应事件时，执行button_read函数， button_read函数阻塞在 wait_event_interruptible(pdev->waitq, pdev->ev_press); 等待pdev->ev_press为真及wake_up_interruptible函数唤醒，

static int button_read(struct file* file, char __user *buf, size_t count, loff_t *ppos)
{struct button_device *pdev = file->private_data;struct s3c_button_platform_data *pdata;int i, ret;unsigned int status = 0;pdata = pdev->data;printk("ev_press: %d\n",  pdev->ev_press);if(!pdev->ev_press){if(file->f_flags & O_NONBLOCK){printk("read() without block mode.\n");return -EAGAIN;}else{printk("read() blocked here now.\n");wait_event_interruptible(pdev->waitq, pdev->ev_press);}}pdev->ev_press = 0;for(i=0; i<pdata->nbuttons; i++){printk("button[%d] status=%d\n",i, pdev->status[i]);status |= (pdev->status[i]<<i);}ret = copy_to_user(buf, (void *)&status, min(sizeof(status), count));return ret ? -EFAULT : min(sizeof(status), count);
}

5.4 中断服务函数（上半部）

当检测到相应的中断信号时， 进入中断服务函数中，中断服务函数通过中断号确认中断源，因为存在各种干扰，在中断服务函数中我们将按键状态设为未定义态， 消抖后再判断按键状态，消抖我们通过下半部来进行。 因为下半部是通过上半部触发， 所以我们在中断服务函数中配置定时器超时时间， 启动定时器，由定时器绑定的函数进行下半部操作， 中断上半部执行完成。

static irqreturn_t s3c_button_intterupt (int irq, void *de_id)
{int     i;int     found =0 ;struct  s3c_button_platform_data *pdata = button_device.data;for(i=0; i<pdata->nbuttons; i++){if(irq == pdata->buttons[i].nIRQ){found = 1;break;}}if(!found)return IRQ_NONE;if(BUTTON_UP == button_device.status[i]){button_device.status[i] = BUTTON_UNCERTAIN;mod_timer(&(button_device.timers[i]), jiffies+TIMER_DOWN);}return IRQ_HANDLED;
}

5.5 定时器函数（下半部）

在定时器函数中， 再次判断按键是否按下， 由此完成消抖功能。

static void s3c_button_timer_handler(unsigned long data)
{struct s3c_button_platform_data *pdata = button_device.data;int  num = (int)data;int status = s3c2410_gpio_getpin(pdata->buttons[num].gpio);if(LOWLEVEL == status){if(BUTTON_UNCERTAIN == button_device.status[num]){button_device.status[num] = BUTTON_DOWN;printk("%s presssed.\n", pdata->buttons[num].name);button_device.ev_press = 1;wake_up_interruptible(&(button_device.waitq));}mod_timer(&(button_device.timers[num]), jiffies+TIMER_DELAY_UP);}else{button_device.status[num] =  BUTTON_UP;}return;
}

6 完整源码

1. platdrv_key.c

#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/spinlock.h>
#include <asm/uaccess.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/string.h>
#include <linux/bcd.h>
#include <linux/miscdevice.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/sysfs.h>
#include <linux/proc_fs.h>
#include <linux/rtc.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#include <asm/uaccess.h>
#include <asm/delay.h>
#include <linux/syscalls.h>  /*    For sys_access*/
#include <linux/platform_device.h>
#include <linux/unistd.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/serial_core.h>
#include <linux/irq.h>
#include <mach/regs-gpio.h>
#include "platdev_key.h"#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
#include <mach/hardware.h>
#include <mach/gpio.h>
#include <asm/irq.h>
#else
#include <asm-arm/irq.h>
#include <asm/arch/gpio.h>
#include <asm/arch/hardware.h>
#endif#define  DEV_NAME   "key"#ifndef  DEV_MAJOR  
#define  DEV_MAJOR 0
#endif#define BUTTON_UP    0
#define BUTTON_DOWN  1
#define BUTTON_UNCERTAIN    2#define TIMER_DOWN (HZ/50)
#define TIMER_DELAY_UP (HZ/10)#define HIGHLEVEL                   1
#define LOWLEVEL                    0static int dev_major = DEV_MAJOR;
static int dev_minor = 0;struct button_device
{unsigned char                  *status;struct s3c_button_platform_data *data;struct timer_list               *timers;wait_queue_head_t               waitq;volatile    int                 ev_press;struct cdev                     cdev;struct class                    *dev_class;}button_device;static irqreturn_t s3c_button_intterupt (int irq, void *de_id)
{int     i;int     found =0 ;struct  s3c_button_platform_data *pdata = button_device.data;for(i=0; i<pdata->nbuttons; i++){if(irq == pdata->buttons[i].nIRQ){found = 1;break;}}if(!found)return IRQ_NONE;if(BUTTON_UP == button_device.status[i]){button_device.status[i] = BUTTON_UNCERTAIN;mod_timer(&(button_device.timers[i]), jiffies+TIMER_DOWN);}return IRQ_HANDLED;
}static void s3c_button_timer_handler(unsigned long data)
{struct s3c_button_platform_data *pdata = button_device.data;int  num = (int)data;int status = s3c2410_gpio_getpin(pdata->buttons[num].gpio);if(LOWLEVEL == status){if(BUTTON_UNCERTAIN == button_device.status[num]){button_device.status[num] = BUTTON_DOWN;printk("%s presssed.\n", pdata->buttons[num].name);button_device.ev_press = 1;wake_up_interruptible(&(button_device.waitq));}mod_timer(&(button_device.timers[num]), jiffies+TIMER_DELAY_UP);}else{button_device.status[num] =  BUTTON_UP;}return;}static int button_open(struct inode *inode, struct file *file)
{struct button_device *pdev;struct s3c_button_platform_data *pdata;int i, result;pdev = container_of(inode->i_cdev, struct button_device, cdev);pdata = pdev->data;file->private_data = pdev;pdev->timers = (struct timer_list *)kmalloc(pdata->nbuttons * sizeof(struct timer_list), GFP_KERNEL);if(NULL == pdev->timers){printk("Alloc %s driver for timers faliure.\n", DEV_NAME);return -ENOMEM;}memset(pdev->timers, 0, pdata->nbuttons*sizeof(struct timer_list));pdev->status = (unsigned char *)kmalloc(pdata->nbuttons*sizeof(unsigned char), GFP_KERNEL);if(NULL == pdev->status){printk("Alloc %s driver for status faliure.\n", DEV_NAME);result = -ENOMEM;goto ERROR;}memset(pdev->status, 0, pdata->nbuttons*sizeof(unsigned char));init_waitqueue_head(&(pdev->waitq));for(i=0; i<pdata->nbuttons; i++){pdev->status[i] = BUTTON_UP;setup_timer(&(pdev->timers[i]), s3c_button_timer_handler, i);s3c2410_gpio_cfgpin(pdata->buttons[i].gpio, pdata->buttons[i].setting);irq_set_irq_type(pdata->buttons[i].nIRQ, IRQ_TYPE_EDGE_FALLING);result =  request_irq(pdata->buttons[i].nIRQ, s3c_button_intterupt, IRQF_DISABLED, DEV_NAME, (void*)i);if(result){result = -EBUSY;goto ERROR1;}}return 0;ERROR1:kfree((unsigned char *)pdev->status);while(--i){disable_irq(pdata->buttons[i]. nIRQ);free_irq(pdata->buttons[i].nIRQ, (void*)i);}ERROR:kfree(pdev->timers);return result;}static int button_read(struct file* file, char __user *buf, size_t count, loff_t *ppos)
{struct button_device *pdev = file->private_data;struct s3c_button_platform_data *pdata;int i, ret;unsigned int status = 0;pdata = pdev->data;printk("ev_press: %d\n",  pdev->ev_press);if(!pdev->ev_press){if(file->f_flags & O_NONBLOCK){printk("read() without block mode.\n");return -EAGAIN;}else{printk("read() blocked here now.\n");wait_event_interruptible(pdev->waitq, pdev->ev_press);}}pdev->ev_press = 0;for(i=0; i<pdata->nbuttons; i++){printk("button[%d] status=%d\n",i, pdev->status[i]);status |= (pdev->status[i]<<i);}ret = copy_to_user(buf, (void *)&status, min(sizeof(status), count));return ret ? -EFAULT : min(sizeof(status), count);
}static unsigned int button_poll(struct file *file, poll_table *wait)
{struct button_device *pdev  = file->private_data;unsigned int mask = 0;poll_wait(file, &(pdev->waitq), wait);if(pdev->ev_press){mask |= POLLIN | POLLRDNORM;}return mask;
}static int button_release(struct inode *inode, struct file *file)
{int     i;struct  button_device *pdev =  file->private_data;struct  s3c_button_platform_data *pdata;pdata = pdev->data;for(i=0; i<pdata->nbuttons; i++){disable_irq(pdata->buttons[i].nIRQ);free_irq(pdata->buttons[i].nIRQ, (void*)i);del_timer(&(pdev->timers[i]));}kfree(pdev->timers);kfree((unsigned char *)pdev->status);return 0;
}static struct file_operations s3c_button_fops = {.owner = THIS_MODULE,.open = button_open,.read = button_read,.poll = button_poll,.release = button_release,
};static int s3c_button_probe(struct platform_device *dev)
{int    result = 0;dev_t  devno;if(0 != dev_major){devno = MKDEV(dev_major, dev_minor);result = register_chrdev_region(devno, 1, DEV_NAME);}else{result = alloc_chrdev_region(&devno, dev_major, 1, DEV_NAME);dev_major = MAJOR(devno);}if(result < 0){printk("%s driver can't get major %d\n", DEV_NAME, dev_major);return result;}memset(&button_device, 0,sizeof(button_device));button_device.data = dev->dev.platform_data;cdev_init(&(button_device.cdev), &s3c_button_fops);button_device.cdev.owner = THIS_MODULE;result = cdev_add(&(button_device.cdev), devno, 1);if(result){printk(KERN_NOTICE "error %d add %s device", result, DEV_NAME);goto ERROR;}button_device.dev_class = class_create(THIS_MODULE, DEV_NAME);if(IS_ERR(button_device.dev_class)){printk("%s driver create class failure\n", DEV_NAME);result = -ENOMEM;goto ERROR;}#if  LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)device_create(button_device.dev_class, NULL, devno, NULL, DEV_NAME);
#elsedevice_create(button_device.dev_class, NULL, devno, DEV_NAME);#endifreturn 0;ERROR:printk("s3c %s driver install faliure.\n", DEV_NAME);cdev_del(&(button_device.cdev));unregister_chrdev_region(devno, 1);return result;
}static int s3c_button_remove(struct platform_device *dev)
{dev_t devno = MKDEV(dev_major, dev_minor);cdev_del(&(button_device.cdev));device_destroy(button_device.dev_class, devno);class_destroy(button_device.dev_class);unregister_chrdev_region(devno, 1);printk("s3c %s driver removed \n", DEV_NAME);return 0;
}static struct platform_driver s3c_button_driver = {.probe = s3c_button_probe,.remove = s3c_button_remove,.driver = {.name = "s3c_key",.owner = THIS_MODULE,},
};static int __init s3c_button_init(void)
{int     rv=0;rv = platform_driver_register(&s3c_button_driver);if(rv){printk(KERN_ERR "%s:%d: Can't  regist button driver %d.\n", __FUNCTION__, __LINE__, rv);platform_driver_unregister(&s3c_button_driver);return rv;}printk("Regist button driver sucessfully!\n");return 0;}static void s3c_button_exit(void)
{printk("%s:%d remove the BUTTON platform driver.\n", __FUNCTION__, __LINE__);platform_driver_unregister(&s3c_button_driver);
}module_init(s3c_button_init);
module_exit(s3c_button_exit);module_param(dev_major, int, S_IRUGO);
module_param(dev_minor, int, S_IRUGO);MODULE_AUTHOR("Moqiu <comeonqiuliang@163.com>");
MODULE_DESCRIPTION("FL2440 BUTTON DRIVER");
MODULE_LICENSE("GPL");

2. Makefile

LINUX_SRC = ${shell pwd}/../../linux/linux-3.0/
CROSS_COMPILE=/opt/xtools/arm920t/bin/arm-linux-
INST_PATH=/tftpPWD := $(shell pwd)EXTRA_CFLAGS+=-DMODULEobj-m += platdev_key.o
obj-m += platdrv_key.omodules:@echo ${LINUX_SRC}@make -C $(LINUX_SRC) M=$(PWD) modules@make clearuninstall:rm -f ${INST_PATH}/*.koinstall: uninstallcp -af *.ko ${INST_PATH}clear:@rm -f *.o *.cmd *.mod.c@rm -rf  *~ core .depend  .tmp_versions Module.symvers modules.order -f@rm -f .*ko.cmd .*.o.cmd .*.o.dclean: clear@rm -f  *.ko

三、设备程序编写

1. 抽象数据结构

从图中我们可以得知， 按键s2、s3、s4、s5分别连在GPF0、GPF2、GPF3、GPF4上，其对应的中断线为EINT0、EINT2、EINT3和EINT4， 所以我们可以抽象一个数据结构来描述按键信息：

struct s3c_button_info 
{unsigned char           num;char *                  name;int                     nIRQ;unsigned int            setting;unsigned int            gpio;
};

为了加强可移植性， 可以再添加一个数据结构来描述多个按键：

struct s3c_button_platform_data{struct s3c_button_info *buttons;int    nbuttons;
};

2. 编写模块

1. 完善设备信息

通过上文抽象的数据结构，把我们的设备信息完善：

static struct s3c_button_info s3c_buttons[] = {[0] = {.num = 1,.name = "KEY1",.nIRQ = IRQ_EINT0,.gpio = S3C2410_GPF(0),.setting = S3C2410_GPF0_EINT0,},[1] = {.num = 2,.name = "KEY2",.nIRQ = IRQ_EINT2,.gpio = S3C2410_GPF(2),.setting = S3C2410_GPF2_EINT2,},[2] = {.num = 3,.name = "KEY3",.nIRQ = IRQ_EINT3,.gpio = S3C2410_GPF(3),.setting = S3C2410_GPF3_EINT3,},[3] = {.num = 4,.name = "KEY4",.nIRQ = IRQ_EINT4,.gpio = S3C2410_GPF(4),.setting = S3C2410_GPF4_EINT4,},
};static struct s3c_button_platform_data s3c_button_data =
{.buttons = s3c_buttons,.nbuttons = ARRAY_SIZE(s3c_buttons),
};

2.完善模块信息

• 首先编写模块的基本信息， 包括作者、模块描述和模块协议：

MODULE_AUTHOR("Moqiu <comeonqiuliang@163.com>");
MODULE_DESCRIPTION("FL2440 BUTTON DEVICE");
MODULE_LICENSE("GPL");

• 然后编写模块入口和出口

module_init(s3c_button_dev_init);
module_exit(s3c_button_dev_exit);

• 完善入口函数， 注册设备，注册设备需要建立设备相应的数据结构

static struct s3c_button_platform_data s3c_button_data =
{.buttons = s3c_buttons,.nbuttons = ARRAY_SIZE(s3c_buttons),
};
static void platform_button_release(struct device *dev)
{return ;
}
static struct platform_device s3c_button_device = {.name = "s3c_key",.id = 1,.dev ={.platform_data = &s3c_button_data,.release = platform_button_release,},
};static int __init s3c_button_dev_init(void)
{int     rv=0;rv = platform_device_register(&s3c_button_device);if(rv){printk(KERN_ERR "%s:%d: Can't  regist button device %d.\n", __FUNCTION__, __LINE__, rv);return rv;}printk("Regist button device sucessfully!\n");return 0;
}

• 完善出口函数，此函数为卸载模块时调用

static void s3c_button_dev_exit(void)
{printk("%s:%d remove the s3c button device.\n", __FUNCTION__, __LINE__);platform_device_unregister(&s3c_button_device);
}

3. 完整源码

1. platdev_key.h

#ifndef  _PLATDEV_KEY_H_
#define  _PLATDEV_KEY_H_#include <linux/platform_device.h>
#include <linux/version.h>
#include <mach/regs-gpio.h>#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
#include <mach/hardware.h>
#include <mach/gpio.h>
#include <asm/irq.h>
#else
#include <asm-arm/irq.h>
#include <asm/arch/gpio.h>
#include <asm/arch/hardware.h>
#endifstruct s3c_button_info 
{unsigned char           num;char *                  name;int                     nIRQ;unsigned int            setting;unsigned int            gpio;
};struct s3c_button_platform_data{struct s3c_button_info *buttons;int    nbuttons;
};#endif

2. platdev_key.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>#include "platdev_key.h"static struct s3c_button_info s3c_buttons[] = {[0] = {.num = 1,.name = "KEY1",.nIRQ = IRQ_EINT0,.gpio = S3C2410_GPF(0),.setting = S3C2410_GPF0_EINT0,},[1] = {.num = 2,.name = "KEY2",.nIRQ = IRQ_EINT2,.gpio = S3C2410_GPF(2),.setting = S3C2410_GPF2_EINT2,},[2] = {.num = 3,.name = "KEY3",.nIRQ = IRQ_EINT3,.gpio = S3C2410_GPF(3),.setting = S3C2410_GPF3_EINT3,},[3] = {.num = 4,.name = "KEY4",.nIRQ = IRQ_EINT4,.gpio = S3C2410_GPF(4),.setting = S3C2410_GPF4_EINT4,},
};static struct s3c_button_platform_data s3c_button_data =
{.buttons = s3c_buttons,.nbuttons = ARRAY_SIZE(s3c_buttons),
};static void platform_button_release(struct device *dev)
{return ;
}static struct platform_device s3c_button_device = {.name = "s3c_key",.id = 1,.dev ={.platform_data = &s3c_button_data,.release = platform_button_release,},
};static int __init s3c_button_dev_init(void)
{int     rv=0;rv = platform_device_register(&s3c_button_device);if(rv){printk(KERN_ERR "%s:%d: Can't  regist button device %d.\n", __FUNCTION__, __LINE__, rv);return rv;}printk("Regist button device sucessfully!\n");return 0;
}static void s3c_button_dev_exit(void)
{printk("%s:%d remove the s3c button device.\n", __FUNCTION__, __LINE__);platform_device_unregister(&s3c_button_device);
}module_init(s3c_button_dev_init);
module_exit(s3c_button_dev_exit);MODULE_AUTHOR("Moqiu <comeonqiuliang@163.com>");
MODULE_DESCRIPTION("FL2440 BUTTON DEVICE");
MODULE_LICENSE("GPL");

3. Makefile

PWD=$(shell pwd)
CROSS_COMPILE=/opt/xtools/arm920t/bin/arm-linux-export CC=${CROSS_COMPILE}gcc
CFLAGS+=-I`dirname ${PWD}`SRCFILES = $(wildcard *.c)
BINARIES=$(SRCFILES:%.c=%)all: binaries binaries: ${BINARIES}@echo " Compile over"
%: %.c$(CC) -o $@ $< $(CFLAGS)clean:@rm -f version.h@rm -f *.o $(BINARIES)@rm -rf *.gdb *.a *.so *.elf*distclean: clean@rm -f tags cscope*.PHONY: clean