10. 中斷下半部---工作佇列
阿新 • • 發佈：2019-01-13
————————————————–
方法一
- 四部走
0. strunt work_queue{ //定義工作佇列物件
struct workqueue_struct *mywq;
struct work_struct mywork;
}
strunt worK_queue *key_dev;
1. 建立一個工作佇列（硬體初始化時）
key_dev->mywq = create_workqueue("my_workqueue");
2. 初始化work（硬體初始化時）
INIT_WORK(& #include <linux/init.h>
#include <linux/module.h> —————————————————
方法二
- 三部走
0. strunt work_queue{ //定義工作佇列物件
struct workqueue_struct *mywq;
struct work_struct mywork;
}
strunt worK_queue *key_dev;
1. 初始化work（硬體初始化時）
INIT_WORK(&key_dev->mywork,work_half_irq_handle);
2. 啟動下半部（中斷處理函式中執行）
schedule_work( &key_dev->mywork);
3. 執行下半部
void work_half_irq_handle(struct work_struct *work)
{
printk("-------^_^ %s-----------\n", __FUNCTION__);
} #include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// 設計一個表示按鍵資料的物件
struct key_event{
int code ; // 按鍵的鍵值， 比如KEY_DOWN, KEY_POWER
int value; // 按鍵的狀態，按下為1， 擡起為0
};
// 面向物件---將任何都看成物件， struct 就是物件
//設計一個物件型別，描述當前的裝置資訊，同時是一個全域性的裝置物件
struct s5pv210_key{
int dev_major; //用老的註冊裝置號的方式
struct class *cls;
struct device *dev;
int irqno; //表示裝置的中斷號碼
int testdata;
struct key_event event;//存放按鍵的資料
wait_queue_head_t wq_head;
int have_data; //表示標誌位，表示是否有資料
struct fasync_struct *key_fasync; //指向一個被分配之後的struct fasync_struct空間
struct work_struct mywork;
};
//設計一個物件，描述是按鍵的資訊
/*
1， 中斷號
2， gpio號碼
3， 名字
4， 按鍵的型別
*/
struct key_info{
char *name;
int irqno;
int gpionum;
int code;
int flags; //觸發方式
};
//設定所有按鍵的資訊
struct key_info allkeys[] = {
[0] = {
.name = "key1_eint0",
.irqno = IRQ_EINT(0),
.gpionum = S5PV210_GPH0(0),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_UP,
},
[1] = {
.name = "key2_eint1",
.irqno = IRQ_EINT(1),
.gpionum = S5PV210_GPH0(1),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_DOWN,
},
[2] = {
.name = "key3_eint2",
.irqno = IRQ_EINT(2),
.gpionum = S5PV210_GPH0(2),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_LEFT,
},
[3] = {
.name = "key4_eint3",
.irqno = IRQ_EINT(3),
.gpionum = S5PV210_GPH0(3),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_RIGHT,
},
[4] = {
.name = "key5_eint4",
.irqno = IRQ_EINT(4),
.gpionum = S5PV210_GPH0(4),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_ENTER,
},
[5] = {
.name = "key6_eint5",
.irqno = IRQ_EINT(5),
.gpionum = S5PV210_GPH0(5),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_ESC,
},
[6] = {
.name = "key7_eint22",
.irqno = IRQ_EINT16_31,
.gpionum = S5PV210_GPH2(6),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_HOME,
},
[7] = {
.name = "key8_eint23",
.irqno = IRQ_EINT16_31,
.gpionum = S5PV210_GPH2(7),
.flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
.code = KEY_POWER,
},
};
//設定物件
struct s5pv210_key *key_dev;
int key_drv_open(struct inode *inode, struct file *filp)
{
//一般也是做初始化動作
printk("-------^_^ %s-----------\n", __FUNCTION__);
memset(&key_dev->event,0, sizeof(struct key_event));
key_dev->have_data = 0;
return 0;
}
// write(fd, buf, size);
ssize_t key_drv_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
{
return 0;
}
int key_drv_close(struct inode *inode, struct file *filp)
{
printk("-------^_^ %s-----------\n", __FUNCTION__);
fasync_helper(-1, filp, 0, &key_dev->key_fasync);//釋放key_dev->key_fasync
return 0;
}
long key_drv_ioctl(struct file *filp, unsigned int cmd, unsigned long args)
{
return 0;
}
ssize_t key_drv_read (struct file *filp, char __user *buf, size_t count, loff_t *fpos)
{
printk("-------^_^ %s------have= %d-----\n", __FUNCTION__, key_dev->have_data);
int ret;
//區分阻塞還是非阻塞
if((filp->f_flags & O_NONBLOCK ) && !key_dev->have_data)
return -EAGAIN;
// 沒有資料就休眠--have_data如果0表示沒有資料,就需要等
wait_event_interruptible(key_dev->wq_head, key_dev->have_data);
ret = copy_to_user(buf, &key_dev->event, count);
if(ret > 0)
{
printk("copy_to_user error\n");
return -EFAULT;
}
// 清空後，接著去收其他的資料
memset(&key_dev->event,0, sizeof(struct key_event));
key_dev->have_data = 0; // 重新設定成沒有資料
return count;
}
unsigned int key_drv_poll(struct file *filp, struct poll_table_struct *pts)
{
printk("-------^_^ %s-----------\n", __FUNCTION__);
unsigned int mask = 0;
// 將當前的等待佇列註冊到vfs中
poll_wait(filp, &key_dev->wq_head, pts);
//如果有資料的時候，返回一個POLLIN
if(key_dev->have_data)
mask |= POLLIN;
return mask;
}
int key_drv_fasync (int fd, struct file *filp, int on)
{
//呼叫一個fasync_helper, 構建struct fasync_struct，描述訊號的資訊(訊號是給誰的)
return fasync_helper(fd, filp, on, &key_dev->key_fasync);
}
const struct file_operations key_fops = {
.open = key_drv_open,
.write = key_drv_write,
.read = key_drv_read,
.release = key_drv_close,
.unlocked_ioctl = key_drv_ioctl,
.poll = key_drv_poll,
.fasync = key_drv_fasync,
};
void work_half_irq_handle(struct work_struct *work)
{
printk("-------^_^ %s-----------\n", __FUNCTION__);
wake_up_interruptible(&key_dev->wq_head);//會喚醒
key_dev->have_data = 1; //表示有資料
//傳送訊號
kill_fasync(&key_dev->key_fasync, SIGIO, POLLIN);
}
irqreturn_t key_irq_handler(int irqno, void *dev_id)
{
printk("-------^_^ %s-----------\n", __FUNCTION__);
//區分不同的中斷
struct key_info *p = (struct key_info *)dev_id;
//區分是按下還是擡起
int value;
value = gpio_get_value(p->gpionum);
if(value){
//擡起
printk("%s up \n", p->name);
key_dev->event.code = p->code;
key_dev->event.value = 0;
}else{
//按下
printk("%s pressed \n", p->name);
key_dev->event.code = p->code;
key_dev->event.value = 1;
}
//啟動下半部
schedule_work( &key_dev->mywork);
return IRQ_HANDLED;
}
static int __init key_drv_init(void)
{
int ret;
//申請資源
// 例項化該物件
// GFP_KERNEL如果當前沒有記憶體可分配，該函式會一直等
key_dev = kzalloc(sizeof(struct s5pv210_key), GFP_KERNEL);
if(key_dev == NULL)
{
printk(KERN_ERR "kzalloc error\n");
return -ENOMEM;
}
// 1, 申請裝置號
key_dev->dev_major = register_chrdev(0, "s5pv210_key_drv", &key_fops);
if(key_dev->dev_major < 0)
{
printk(KERN_ERR "kzalloc error\n");
ret = -ENODEV;
goto err_0;
}
// 2, 自動建立檔案
// /sys/class/key_cls 資料夾
key_dev->cls = class_create(THIS_MODULE, "key_cls");
if(IS_ERR(key_dev->cls))
{
printk(KERN_ERR "class_create error\n");
ret = PTR_ERR(key_dev->cls);
goto err_1;
}
// /sys/class/key_cls/key/
// /dev/key1
key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->dev_major,1),NULL, "key1");
if(IS_ERR(key_dev->dev))
{
printk(KERN_ERR "device_create error\n");
ret = PTR_ERR(key_dev->dev);
goto err_2;
}
// 4, 硬體的初始化---中斷
//
//key_dev->irqno = IRQ_EINT(1);
int i;
int irqno;
int flags;
char *name;
for(i=0; i<ARRAY_SIZE(allkeys); i++)
{
irqno = allkeys[i].irqno;
if(irqno == IRQ_EINT16_31)
irqno = gpio_to_irq(allkeys[i].gpionum);
flags = allkeys[i].flags;
name = allkeys[i].name;
ret = request_irq(irqno, key_irq_handler, flags,name, &allkeys[i]);
if(ret != 0)
{
printk(KERN_ERR "request_irq error : i=%d\n", i);
ret = -EBUSY;
goto err_4;
}
}
//初始化等待佇列頭
init_waitqueue_head(&key_dev->wq_head);
// 初始化work
INIT_WORK(&key_dev->mywork,work_half_irq_handle);
return 0;
err_4:
i--;
for(; i>0; i--)
{
irqno = gpio_to_irq(allkeys[i].gpionum);
free_irq(irqno, &allkeys[i]);
}
err_3:
device_destroy(key_dev->cls, MKDEV(key_dev->dev_major,1));
err_2:
class_destroy(key_dev->cls);
err_1:
unregister_chrdev(key_dev->dev_major, "s5pv210_key_drv");
err_0:
kfree(key_dev);
return ret;
}
static void __exit key_drv_exit(void)
{
//釋放資源
//將工作佇列刪除
int i;
int irqno;
for(i=0; i<ARRAY_SIZE(allkeys); i++)
{
irqno = gpio_to_irq(allkeys[i].gpionum);
free_irq(irqno, &allkeys[i]);
}
device_destroy(key_dev->cls, MKDEV(key_dev->dev_major,1));
class_destroy(key_dev->cls);
unregister_chrdev(key_dev->dev_major, "s5pv210_key_drv");
kfree(key_dev);
}
module_init(key_drv_init);
module_exit(key_drv_exit);
MODULE_LICENSE("GPL");
相關推薦
10. 中斷下半部---工作佇列
————————————————– 方法一 四部走 0. strunt work_queue{ //定義工作佇列物件 struct workqueue_struct *mywq; s
中斷下半部_工作佇列(work queue)
1>work_queue:<linux/workqueue.h> __3.0.4 2>description: 中斷下半部，在核心執行緒的程序上下文中執行推後的工作. 它是唯一能在程序上下文執行的中斷下半部實現機制，也只有它才可以睡眠. 3>建
Linux2.6核心--中斷下半部實現方法 工作佇列
工作佇列子系統是一個用於建立核心執行緒的介面，通過它建立的程序負責執行由核心其他部分排到佇列裡的任務。它建立的這些核心執行緒稱作工作者執行緒。工作佇列可以讓你的驅動程式建立一個專門的工作者執
（六）3中斷下半部之工作佇列
1、工作佇列的使用 按慣例，在介紹工作佇列如何實現之前，先說說如何使用工作佇列實現下半部。 步驟一、定義並初始化工作佇列： 建立工作佇列函式： struct workqueue_struct *create_workqueue(const char *nam
linux 觸控式螢幕驅動中斷下半部實現-工作佇列
工作佇列(work queue)是Linux kernel中將工作推後執行的一種機制。這種機制和BH或Tasklets不同之處在於工作佇列是把推後的工作交由一個核心執行緒去執行，因此工作佇列的優勢就在於它允許重新排程甚至睡眠。工作佇列可以把工作推後，交由一個核心執行緒去執
《Linux內核設計與實現》讀書筆記（八）- 中斷下半部的處理
sym dmesg 重新編譯 warn dad style lsp 之前 res 在前一章也提到過，之所以中斷會分成上下兩部分，是由於中斷對時限的要求非常高，需要盡快的響應硬件。 主要內容： 中斷下半部處理 實現中斷下半部的機制 總結中斷下半部的實現 中斷實現
中斷下半部的妙用
中斷下半部 中斷處理程式是核心中很重要的一部分，但是由於本身存在著一些限制，所以他只能完成整個中斷處理程式中的上半部分。 具體侷限如下： 中斷處理程式是以非同步方式執行，並且他有可能會打斷其他重要的程式碼（甚至有可能是其他的中斷程式）的執行，因此為了避免被打斷的程式碼停止時間過
外部中斷和內部中斷 硬中斷 軟中斷 中斷下半部
重要宣告： 以下程式碼有貼上 擷取他人勞動成果的成分 如有雷同 不勝榮幸 如您不能容忍 請不要獨自忍受@weChat:iisssssssssii 聯絡小民 主動刪除 中斷含義： { 中斷是CPU處理外部突發事件的一個重要技術。它能使CPU在執行過程中對外部事件發
中斷下半部-軟中斷
1 軟中斷概述 軟中斷是實現中斷下半部的一種手段，與2.5以前版本的BH機制不同。軟中斷可以同時執行在不同的CPU上。 1.1 軟中斷的表示 核心中用結構體softirq_action表示一個軟中斷。軟中斷是一組靜態定義的介面，有32個。但是核心（2.
softirq(軟中斷)下半部中tasklet與workqueue的區別，整合
一、中斷處理的tasklet（小任務）機制 中斷服務程式一般都是在中斷請求關閉的條件下執行的,以避免巢狀而使中斷控制複雜化。但是，中斷是一個隨機事件，它隨時會到來，如果關中斷的時間太長，CPU就不能及
linux裝置驅動歸納總結（六）：3.中斷下半部之tasklet
linux裝置驅動歸納總結（六）：3.中斷的上半部和下半部——tasklet xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 一、什麼是下半部 中斷是一個很霸道的東西，處理
主要的中斷下半部及其區別
中斷下半部主要有：軟中斷，tasklet，工作佇列 區別 1. 軟中斷和tasket是不可以睡眠的，任務佇列在程序上下問執行是可以睡眠的。 2.相同的軟中斷可以在不同的cpu上同時執行，型別相同的tasklet不可以同時執行，不同型別的軟中斷可以在不同的cpu同時執行
中斷服務下半部之工作佇列【轉】
1 工作佇列概述 工作佇列 (work queue) 是另外一種將工作推後執行的形式，它和我們前面討論的所有其他形式都不相同。工作佇列可以把工作推後，交由一個核心執行緒去執行—這個下半部分總是會在程序上下文執行，但由於是核心執行緒，其不能訪問使用者空間。 最重要
中斷底半部機制之工作佇列詳解
工作佇列的使用方法和tasklet 非常相似，下面的程式碼用於定義一個工作佇列和一個底半部執行函式。 struct work_struct my_wq; /*定義一個工作佇列*/ void my_wq_func(unsigned long); /*定義一個處理函式*/ 通過INIT_W
下半部和推後運行的工作
eno 最重要的 rpo bit handler 平衡 2個 自己的 timer (一):下半部 下半部的任務就是運行與中斷處理密切相關但中斷處理程序本身不運行的工作.那麽有一些提示能夠借鑒哪些工作放在上半部中運行,哪些工作放在下半部運行. 1:假設
第8章 下半部和推後執行的工作
核心為處理中斷而提供的中斷處理程式機制。中斷處理程式是核心中很有用的部分。但是，由於本身存在一些侷限，所以它只能完成整個中斷處理流程的上半部分。這些侷限包括： 中斷處理程式以非同步方式執行，並且有可能會打斷其他重要程式碼的執行。因此，為了避免被打斷的程式碼停止時間過長，中斷
tasklet / 工作佇列 / 軟中斷
軟中斷、tasklet和工作佇列並不是Linux核心中一直存在的機制，而是由更早版本的核心中的“下半部”（bottom half）演變而來。下半部的機制實際上包括五種，但2.6版本的核心中，下半部和任務佇列的函式都消失了，只剩下了前三者。本文重點在於介紹這三者之間的關係。 （1
個人理解，中斷上半部，下半部，硬中斷，軟中斷
中斷上半部分與中斷下半部分對比 在中斷處理程式中，既想讓程式執行的快，又想讓程式完成的工作量多，這兩個目的有抵觸。 鑑於這兩個目的不可調和的矛盾，中斷處理可以分為兩部分： 中斷處理工作，例如對接收中斷進行中斷或復位硬體，這些工作都在所有中斷被禁止的情況下完成。可以稍後完成的
BS架構下使用訊息佇列的工作流程
非同步通訊 對於BS(Browser-Server 瀏覽器)架構，很多情景下server的處理時間較長。 如果瀏覽器傳送請求後，保持跟server的連線，等待server響應，那麼一方面會對使用者的
如何理解中斷的上半部和下半部
linux概念 上半部是不能中斷的 下半部是可以中斷的 對於適時要求高的,必須放在上半部 下半部的實現主要是通過軟中斷 ,tasklet,和工作佇列來實現的. 首先需要了解一下中斷的概念：一個“中斷”僅僅是一個訊號，當硬體需要獲得處理器對它的關注時，就