【轉】Linux驅動修煉之道-按鍵

按鍵程序使用了驅動的很多知識。有中斷，阻塞，等待隊列，linux設備驅動模型等。
使用中斷處理的步驟是：

1. 向內核註冊中斷
2. 實現中斷處理函數。

安裝中斷的函數是：

int request_irq(unsigned int irq, irqreturn_t (*handler) (int, void*, struct pt_regs *), unsigned long flags, const char *dev_name, void *dev_id);

釋放的函數：

void free_irq(unsigned int irq, void *dev_id);

這裏主要是申請中斷信號線，這是一個非常寶貴的資源。request_irq中的參數dev_id用於共享中斷信號線的時候，因爲需要中斷處理的設備肯定比中斷信號線多的，所以一旦某一個觸發了中斷，內核需要在這條中斷線上尋找發生中斷的設備，由於大家使用的中斷號是一樣的，所以通過dev_id來識別，dev_id是唯一的。使用完要注意釋放着寶貴的資源。從下邊的程序可以看到註冊中斷是在open的時候，爲什麼不在註冊模塊的函數中呢，因爲如果是在註冊函數中除非卸載模塊，這樣這個驅動會一直佔用中斷號，而自己可能不用，這樣就白白浪費了寶貴的資源。
中斷處理的函數原型是:

irqreturn_t (*handler) (int, void*, struct pt_regs *)；

第一個參數是irq，第二個是dev_id，第三個是struct pt_reg *regs，很少用，它保存了處理器進入中斷代碼之前的處理器上下文快照。注意返回值，如果處理程序發現其設備的確需要處理，則應返回IRQ_HANDLED；否則，返回值應該是IRQ_NONE。

在讀取的時候使用的是阻塞機制，也就是說如果用戶程序獲得不到數據，就阻塞。此時那個進程進入休眠狀態，被CPU的調度器從運行隊列搬到等待隊列。Linux內核中阻塞是通過等待隊列來實現的。在Linux中，一個等待隊列通過一個“等待隊列頭(wait queue head)”來管理。等待隊列頭是一個類型爲wait_queue_head_t的結構體，定義在<linux/wait.h>中。

可通過如下方法靜態定義並初始化一個等待隊列:

DECLARE_WAIT_QUEUE_HEAD(name);

或者用動態的方法：

 

wait_queue_head_t my_queue; init_waitqueue_head(&my_queue);

 

Linux內核中的休眠方式是使用wait_event宏,如下：

 

wait_event(queue,condition); wait_event_interruptible(queue,condition); wait_event_timeout(queue,condition,timeout); wait_event_interruptible_timeout(queue,condition,timeout);

 

queue是等待隊列頭，condition是等待條件。如果condition爲0，則進行阻塞；否則，不阻塞。wait_event_interruptible宏與wait_event宏的區別是wait_event_interruptible是可以被信號中斷的。當進程休眠時，它將期待某個條件在未來成爲真；當一個進程被喚醒時，它必須再次檢測它所等待的條件的確爲真。
用來喚醒等待隊列的函數：

 

void wake_up(wait_queue_head_t *queue); void wake_up_interruptible(wait_queue_head_t *queue);

 

wake_up會喚醒等待在給定queue上的所有進程。wake_up_interruptible只會喚醒那些執行可中斷休眠的進程。

 

#include <linux/fs.h> #include <linux/module.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/cdev.h> #include <linux/slab.h> #include <linux/platform_device.h> #include <linux/types.h> #include <asm/uaccess.h> #include <asm/irq.h> #include <linux/irq.h> #include <mach/hardware.h> #include <linux/slab.h> #define key_major 234 #define key_minor 0 dev_t dev_num; struct cdev * keyp; struct class *key_class; #define DEVICE_NAME "key_driver" volatile int press_cnt[] = {0,0,0,0}; volatile bool ev_press = 0; DECLARE_WAIT_QUEUE_HEAD(key_wait); struct irq_key_descriptor{ unsigned int irq; unsigned int flags; const char *dev_name; }; struct irq_key_descriptor key_irq[] = { {IRQ_EINT0,IRQF_DISABLED,"key0"}, {IRQ_EINT2,IRQF_DISABLED,"key1"}, }; irqreturn_t key_interrupt(int irq, void *dev_id){ volatile int *press_cnt = (volatile int *)dev_id; *press_cnt = *press_cnt + 1; ev_press = 1; wake_up_interruptible(&key_wait); return IRQ_HANDLED; } int key_open(struct inode *inode, struct file *filp){ int i; unsigned long err; for(i = 0; i < sizeof(key_irq)/sizeof(key_irq[0]); i++){ err = request_irq(key_irq[i].irq, key_interrupt,key_irq[i].flags,key_irq[i].dev_name,(void*)&press_cnt[i]); if(err) break; } if(err){ i--; for(;i>=0;i--) free_irq(key_irq[i].irq,(void*)&press_cnt[i]); return -EBUSY; } return 0; } int key_close(struct inode *inode, struct file *filp){ int i; for(i = 0; i < sizeof(key_irq)/sizeof(key_irq[0]); i++){ free_irq(key_irq[i].irq,(void*)&press_cnt[i]); } return 0; } ssize_t key_read(struct file *filp, char __user *buf, size_t count , loff_t * offp){ unsigned long err; wait_event_interruptible(key_wait, ev_press); ev_press = 0; err = copy_to_user(buf,(const void *) press_cnt,count); memset((void*)press_cnt, 0, sizeof(press_cnt)); return err?-EFAULT:0; } struct file_operations key_ops = { .owner = THIS_MODULE, .open = key_open, .release = key_close, .read = key_read, }; void key_cdev_setup(void){ int err; cdev_init(keyp,&key_ops); keyp->owner = THIS_MODULE; keyp->ops = &key_ops; err = cdev_add(keyp,dev_num,1); if(IS_ERR(&err)) printk(KERN_NOTICE "Error %d adding key_driver",err); } static int __init keyp_init(void){ int ret; if(key_major){ dev_num = MKDEV(key_major, key_minor); ret = register_chrdev_region(dev_num, 1, DEVICE_NAME); }else{ ret = alloc_chrdev_region(&dev_num, key_minor, 1, DEVICE_NAME); } if(ret < 0){ printk(KERN_WARNING "key: can't get major %d/n",key_major); return ret; } keyp = kmalloc(sizeof(struct cdev), GFP_KERNEL); if(!keyp){ ret = -ENOMEM; } memset(keyp,0,sizeof(struct cdev)); key_cdev_setup(); key_class = class_create(THIS_MODULE,DEVICE_NAME); if(IS_ERR(key_class)){ printk("Error:Failed to create key_class/n"); return -1; } device_create(key_class,NULL,dev_num,NULL,DEVICE_NAME); printk(DEVICE_NAME "initialized/n"); return 0; } static void __exit keyp_exit(void){ cdev_del(keyp); kfree(keyp); unregister_chrdev_region(dev_num,1); } module_init(keyp_init); module_exit(keyp_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("liwanpeng");

 

用戶測試程序：

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/ioctl.h> int main(int argc,char **argv) { int i; int ret; int fd; int press_cnt[4]; fd=open("/dev/key_driver",0); if(fd<0) { printf("Can't open /dev/key_driver /n"); return -1; } //這是個無限循環，進程有可能在read函數中休眠，當有按鍵按下時， //它才返回 while(1) { ret = read(fd,press_cnt,sizeof(press_cnt)); if(ret<0) { printf("read err !/n"); continue; } //如果被按下的次數不爲0，打印出來 for(i=0;i<sizeof(press_cnt)/sizeof(press_cnt[0]);i++) { if(press_cnt[i]) printf("Key%d has been pressed %d times /n",i+1,press_cnt[i]); } } }

Makefile:

ifneq ($(KERNELRELEASE), ) obj-m:=key_driver.o else KERNELSRC :=/home/hacker/linux-2.6.30.4 modules: make -C $(KERNELSRC) SUBDIRS=$(PWD) $@ clean: rm -f *.o *.ko *.mod.c *~ endif

效果：

觀察效果圖，有的時候是按1次，有的是2，3，7等，看看用戶程序，那裏一直在讀，如果按鍵不按下，則沒有任何輸出，因爲讀取進程被阻塞了，如果按下在讀後按的次數會被清零。那應該都顯示1啊，因爲驅動程序中每按一次，在中斷程序中喚醒等待進程，然後讀取函數中進行了清零，應該每次都爲1。可是，進程被喚醒後從等待隊列搬到運行隊列，在運行隊列需要排隊的，也就是說，可能不會立即獲得時間片，這樣下次中斷又進行了加1，所以。。。哈哈