10. 中断下半部---工作队列

最新推荐文章于 2024-02-03 21:39:55 发布
最新推荐文章于 2024-02-03 21:39:55 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 12_linux初级驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hua_zai_arm/article/details/51755534
版权

————————————————–

方法一

  • 四部走
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(&key_dev->mywork,work_half_irq_handle);

3. 启动下半部（中断处理函数执行）
    queue_work(key_dev->mywq, &key_dev->mywork);

4. 执行下半部
    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 workqueue_struct  *mywq;
    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;
    }

    //启动下半部
    queue_work(key_dev->mywq, &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);


    // 创建一个工作队列
    key_dev->mywq = create_workqueue("my_workqueue");

    // 初始化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)
{
    //释放资源
    //将工作队列删除

    destroy_workqueue(key_dev->mywq);

    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");

—————————————————

方法二

  • 三部走
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");
世界从而改变
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内核中断下半部机制之工作队列
wojiaxiaohuang2014的博客
03-03 344
Linux内核中断下半部机制之工作队列
中断下半部-工作队列
xxu0123456789的专栏
04-22 667
中断下半部-工作队列<br /><br /><br />工作队列（work queue）是另外一种将中断的部分工作推后的一种方式，它可以实现一些tasklet不能实现的工作，比如工作队列机制可以睡眠。这种差异的本质原因是，在工作队列机制中，将推后的工作交给一个称之为工作者线程（worker thread）的内核线程去完成（单核下一般会交给默认的线程events/0）。因此，在该机制中，当内核在执行中断的剩余工作时就处在进程上下文（process context）中。也就是说由工作队列所执行的中断代码会表现出
Linux中断下半部——工作队列
骨头和狗的博客
01-25 524
1 参考书籍 《Linux设备驱动开发详解》 宋宝华 机械工业出版社 《嵌入式Linux驱动开发教程》 华清远见嵌入式学院 电子工业出版社 2 工作队列 下面的代码用于定义一个工作队列和一个底半部执行函数struct work_struct my_wq; /*定义一个工作队列*/ void my_wq_func(struct work_struct *work); /*定义一个
中断服务下半部之工作队列详解
05-01
总之，中断服务下半部之工作队列详解涉及Linux内核中断处理机制的优化策略，它通过将复杂任务从中断服务上半部转移到工作队列，在进程上下文中执行，提升了系统的响应速度和可调度性。理解并熟练运用工作队列对于...
linux 中断的上半部和下半部
07-20
工作队列是另一种用于实现下半部的机制，它提供了一种更加通用的方式来管理后台任务。 **特点：** - 动态创建和销毁。 - 可以处理各种异步任务。 - 支持优先级和延时。 - 可以通过work_struct结构体和一系列API进行...
中断的上半部和下半部——工作队列
01-09
中断的上半部和下半部——工作队列中断的上半部和下半部——工作队列
Linux 中断的上半部和下半部
01-09
上半部的功能是登记中断，当一个中断发生时，它进行相应地硬件读写后把中断例程的下半部挂到该设备的下半部执行队列中去。因此，上半部 执行的速度会很快，可以服务更多的中断请求。但是，仅有登记中断是远远不够的...
工作队列中断
03-05
工作队列就是实现中断下半部的一种方式，它将任务放入一个队列中，由系统调度器在合适的时机（如在用户态或内核线程上下文）执行。 在“工作队列中断”中，当设备产生中断时，上半部会快速响应，将需要处理的任务...
Linux中断下半部分：软中断，tasklet和工作队列
最新发布
qq_35693377的博客
02-03 1183
此外，内核定时器和tasklet都是建立在软中断上的。每个tasklet都存放在两个链表中的其一: tasklet_vec(普通tasklet),tasklet_hi_vec(高优先级tasklet).软中断有32位，因为do_softirq()是从下到大的遍历位图，所以小的索引会在大的索引之前执行，索引具有优先级。一个注册的软中断只有在标记后才会执行，中断处理程序会在返回前标记它的软中断，使其在稍后执行。软中断使用较少（相对于tasklet），但是tasklet是基于软中断实现的。
中断下半部之工作队列
倚楼听风雨的博客
09-24 2694
一、中断的顶半部和底半部     设备的中断会打断内核中进程的正常调度和运行，而系统对更高吞吐率的追求势必要求中断服务程序尽可能地短小精悍。但是，这个良好的愿望往往与现实并不吻合。在大多数真实的系统中，当中断到来时，要完成的工作往往并不会是短小的，它可能要进行较大量的耗时处理，由于中断的优先级最高，这时候就会影响到其他进程的实时性。     为了在中断执行时间尽可能短和中断处理需完成大量工作之
Linux内核中断下半部工作队列（work queue）
weixin_71478434的博客
08-27 1689
queue_delayed_work 跟schedule_delayed_work 类似，区别在于schedule_delayed_work 是在系统默认的工作队列上执行一个work，queue_delayed_work需要自行指定工作队列。flush_delayed_work 等待一个delayed_work执行完毕。queue_work 跟schedule_work类似，区别在于schedule_work是在系统默认的工作队列上执行一个work，而queue_work 需要自行指定工作队列。...
中断上半部,下半部/软中断/tasklet/工作队列
Jason Gel 的专栏
03-30 3698
在阅读本文之前，可以先行阅读：中断上下文、进程上下文本文回答了为什么引入中断上部分、下部分以及上半部和下半部各自的分工；同时重点分析了下半部的三种机制及tasklet和工作队列的使用模块，能对整个框架有一个清晰的认识。1. 为什么引入中断上半部、下半部(1)为了解决一个矛盾体：又想中断处理程序运行快，又想中断处理程序完成的工作量多。 (2)中断处理程序本身局限性，使得它只能完成整个中断处理流程的上
Linux 驱动之中断下半部之工作队列
ZP1015
06-03 3076
1、工作队列的使用 按惯例，在介绍工作队列如何实现之前，先说说如何使用工作队列实现下半部。 步骤一、定义并初始化工作队列： 创建工作队列函数： struct workqueue_struct *create_workqueue(const char *name) 函数传参是内核中工作队列的名称，返回值是workqueue_struct结构体的指针，该结构体用来维护一个等待队列。 我的代码如下： struct workqueue_struct * ZP1015_wq; //定义工作队列 ZP101
linux设备驱动之gpio_keys
流水
03-20 2152
#ifndef _GPIO_KEYS_H #define _GPIO_KEYS_H struct gpio_keys_button {         /* Configuration parameters */         int code;               /* 输入事件的键值可以是EV_*或KEY_* */         int gpio;
8. 文件io模型—异步通信 kill
花花世界
06-24 649
#客户端# 要点三（ 设置信号SIGIO的处理） 设置信号处理方法（当中断型号来之后自动跳到catch_signal( ) 函数执行 signal(SIGIO, catch_signal); 设置信号的属主进程 fcntl(fd, F_SETOWN, getpid()); 将读写模式设置成异步模式 unsigned int flag = fcntl(fd, F_GETFL, 0);
基于i.MX28x的工作函数：按键消抖与中断下半部处理
4. **中断处理的下半部**：对于长时间运行的任务，不适合在中断服务例程中完成，而是放到中断处理的下半部，如工作队列，以避免阻塞中断服务。 5. **工作队列**：在Linux内核中，工作队列是一种异步执行任务的机制，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值