• 字符设备驱动笔记——异步通知(八)


    一、信号处理函数的要点:
    1.注册一个信号处理函数
    2.发信号,谁发
    3.发给谁
    4.怎么发

    #include <stdio.h>
    #include <signal.h>
    
    void my_signal_fun(int signum)
    {
        static int cnt = 0;
        printf("signal = %d, %d times
    ", signum, ++cnt);
    }
    
    int main(int argc, char **argv)
    {
    
        signal(SIGUSR1, my_signal_fun);
        
        while (1)
        {
            sleep(1000);
        }
        return 0;
    }

    二、执行:

    //执行 kill -USR1 833
    //或者
    //kill -10 833
    //kill -9 833

    三、驱动程序
    目标:
    按下按键时,驱动程序通知应用程序
    步骤:
    1.应用程序中注册信号处理函数
    2.驱动程序发送信号
    3.信号发给应用程序,应用程序告诉驱动程序PID
    4.驱动程序:kill_fasync

    实现:

    为了使设备支持异步通知机制,驱动程序中涉及以下3项工作:
    1. 支持F_SETOWN命令,能在这个控制命令处理中设置filp->f_owner为对应进程ID。
       不过此项工作已由内核完成,设备驱动无须处理。
    2. 支持F_SETFL命令的处理,每当FASYNC标志改变时,驱动程序中的fasync()函数将得以执行。
       驱动中应该实现fasync()函数。
       
    3. 在设备资源可获得时,调用kill_fasync()函数激发相应的信号


    应用程序:
    应用程序调用fcntl()函数告诉驱动程序,发给谁
    fcntl(fd, F_SETOWN, getpid());  // 告诉内核,发给谁

    //修改flag
    Oflags = fcntl(fd, F_GETFL);   
    fcntl(fd, F_SETFL, Oflags | FASYNC);  // 改变fasync标记,最终会调用到驱动的faync > fasync_helper:初始化/释

    放fasync_struct

    四、fifth_drv.c

    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/fs.h>
    #include <linux/init.h>
    #include <linux/delay.h>
    #include <linux/irq.h>
    #include <asm/uaccess.h>
    #include <asm/irq.h>
    #include <asm/io.h>
    #include <asm/arch/regs-gpio.h>
    #include <asm/hardware.h>
    #include <linux/poll.h>
    
    
    static struct class *fifthdrv_class;
    static struct class_device    *fifthdrv_class_dev;
    
    volatile unsigned long *gpfcon;
    volatile unsigned long *gpfdat;
    
    volatile unsigned long *gpgcon;
    volatile unsigned long *gpgdat;
    
    
    static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
    
    /* 中断事件标志, 中断服务程序将它置1,fifth_drv_read将它清0 */
    static volatile int ev_press = 0;
    
    static struct fasync_struct *button_async;
    
    
    struct pin_desc{
        unsigned int pin;
        unsigned int key_val;
    };
    
    
    /* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
    /* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
    static unsigned char key_val;
    
    struct pin_desc pins_desc[4] = {
        {S3C2410_GPF0, 0x01},
        {S3C2410_GPF2, 0x02},
        {S3C2410_GPG3, 0x03},
        {S3C2410_GPG11, 0x04},
    };
    
    
    /*
      * 确定按键值
      */
    static irqreturn_t buttons_irq(int irq, void *dev_id)
    {
        struct pin_desc * pindesc = (struct pin_desc *)dev_id;
        unsigned int pinval;
        
        pinval = s3c2410_gpio_getpin(pindesc->pin);
    
        if (pinval)
        {
            /* 松开 */
            key_val = 0x80 | pindesc->key_val;
        }
        else
        {
            /* 按下 */
            key_val = pindesc->key_val;
        }
    
        ev_press = 1;                  /* 表示中断发生了 */
        wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
        
        kill_fasync (&button_async, SIGIO, POLL_IN);
        
        return IRQ_RETVAL(IRQ_HANDLED);
    }
    
    static int fifth_drv_open(struct inode *inode, struct file *file)
    {
        /* 配置GPF0,2为输入引脚 */
        /* 配置GPG3,11为输入引脚 */
        request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
        request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
        request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
        request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
    
        return 0;
    }
    
    ssize_t fifth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
    {
        if (size != 1)
            return -EINVAL;
    
        /* 如果没有按键动作, 休眠 */
        wait_event_interruptible(button_waitq, ev_press);
    
        /* 如果有按键动作, 返回键值 */
        copy_to_user(buf, &key_val, 1);
        ev_press = 0;
        
        return 1;
    }
    
    
    int fifth_drv_close(struct inode *inode, struct file *file)
    {
        free_irq(IRQ_EINT0, &pins_desc[0]);
        free_irq(IRQ_EINT2, &pins_desc[1]);
        free_irq(IRQ_EINT11, &pins_desc[2]);
        free_irq(IRQ_EINT19, &pins_desc[3]);
        return 0;
    }
    
    static unsigned fifth_drv_poll(struct file *file, poll_table *wait)
    {
        unsigned int mask = 0;
        poll_wait(file, &button_waitq, wait); // 不会立即休眠
    
        if (ev_press)
            mask |= POLLIN | POLLRDNORM;
    
        return mask;
    }
    
    static int fifth_drv_fasync (int fd, struct file *filp, int on)
    {
        printk("driver: fifth_drv_fasync
    ");
        return fasync_helper (fd, filp, on, &button_async);
    }
    
    
    static struct file_operations sencod_drv_fops = {
        .owner   =  THIS_MODULE,    /* 这是一个宏,推向编译模块时自动创建的__this_module变量 */
        .open    =  fifth_drv_open,     
        .read     =    fifth_drv_read,       
        .release =  fifth_drv_close,
        .poll    =  fifth_drv_poll,
        .fasync     =  fifth_drv_fasync,
    };
    
    
    int major;
    static int fifth_drv_init(void)
    {
        major = register_chrdev(0, "fifth_drv", &sencod_drv_fops);
    
        fifthdrv_class = class_create(THIS_MODULE, "fifth_drv");
    
        fifthdrv_class_dev = class_device_create(fifthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */
    
        gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
        gpfdat = gpfcon + 1;
    
        gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
        gpgdat = gpgcon + 1;
    
        return 0;
    }
    
    static void fifth_drv_exit(void)
    {
        unregister_chrdev(major, "fifth_drv");
        class_device_unregister(fifthdrv_class_dev);
        class_destroy(fifthdrv_class);
        iounmap(gpfcon);
        iounmap(gpgcon);
        return 0;
    }
    
    
    module_init(fifth_drv_init);
    
    module_exit(fifth_drv_exit);
    
    MODULE_LICENSE("GPL");

    五、fifthdrvtest.c

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <poll.h>
    #include <signal.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <fcntl.h>
    
    
    /* fifthdrvtest 
      */
    int fd;
    
    void my_signal_fun(int signum)
    {
        unsigned char key_val;
        read(fd, &key_val, 1);
        printf("key_val: 0x%x
    ", key_val);
    }
    
    int main(int argc, char **argv)
    {
        unsigned char key_val;
        int ret;
        int Oflags;
    
        signal(SIGIO, my_signal_fun);
        
        fd = open("/dev/buttons", O_RDWR);
        if (fd < 0)
        {
            printf("can't open!
    ");
        }
    
        fcntl(fd, F_SETOWN, getpid());
        
        Oflags = fcntl(fd, F_GETFL); 
        
        fcntl(fd, F_SETFL, Oflags | FASYNC);
    
    
        while (1)
        {
            sleep(1000);
        }
        
        return 0;
    }

    六、Makefile

    KERN_DIR = /work/system/linux-2.6.22.6
    
    all:
        make -C $(KERN_DIR) M=`pwd` modules 
    
    clean:
        make -C $(KERN_DIR) M=`pwd` modules clean
        rm -rf modules.order
    
    obj-m    += fifth_drv.o
  • 相关阅读:
    《C++ Primer Plus》15.1 友元 学习笔记
    《C++ Primer Plus》14.4 类模板 学习笔记
    《C++ Primer Plus》14.3 多重继承 学习笔记
    《C++ Primer Plus》14.2 私有继承 学习笔记
    《C++ Primer Plus》第13章 类继承 笔记
    继承和动态内存分配——需要为继承类定义 显式析构函数、复制构造函数和赋值运算符
    C++中的抽象基类示例
    C++ 在继承中使用virtual
    《C++ Primer Plus》第12章 类和动态内存分配 学习笔记
    《C++ Primer Plus》12.7 队列模拟 学习笔记
  • 原文地址:https://www.cnblogs.com/liulipeng/p/3335195.html
Copyright © 2020-2023  润新知