字符設備異步通知

driver:
[cpp] 
#include <linux/kernel.h>   
#include <linux/module.h>   
#include <linux/cdev.h>   
#include <linux/fs.h>   
#include <linux/device.h>   
#include <linux/syscalls.h> 
  
#include <linux/uaccess.h>   
#include <linux/string.h>   
   
struct fpga_key_dev   
{   
    struct cdev cdev;   
    dev_t devno;   
    char test[20]; 
    struct class *fpga_key_class;  
    struct fasync_struct *async_queue; 
 
    int message_cdev_open; 
};   
   
static int fpga_key_open(struct inode *node, struct file *fd)   
{   
    struct fpga_key_dev *dev; 
     
    printk("fpga_key_open()++\n");   
 
    printk("node->i_cdev = %x\n", (unsigned int)node->i_cdev); 
    dev = container_of(node->i_cdev, struct fpga_key_dev, cdev); 
    printk("dev->cdev = %x\n", (unsigned int)&dev->cdev); 
    printk("dev = %x\n", (unsigned int)dev); 
     
    if (!dev->message_cdev_open) { 
        dev->message_cdev_open = 1; 
        fd->private_data = dev; 
    } 
    else{ 
        return -EFAULT; 
    } 
     
    printk("test[20] = %s\n",dev->test); 
     
    printk("fpga_key_open()--\n");   
   
    return 0;   
}    
   
static ssize_t fpga_key_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)   
{   
    char temp_buffer [20];   
    int print_size = 0;   
    struct fpga_key_dev *dev = fd->private_data; 
       
    printk("fpga_key_wirte()++\n");   
    if(len > 20)   
        print_size = 20;   
    else   
        print_size = len;   
    printk("print_size = %d; len = %d\n", print_size, len);   
    if(copy_from_user(temp_buffer, buf, print_size))   
        return -EFAULT;   
 
    if (dev->async_queue) 
        kill_fasync(&dev->async_queue, SIGIO, POLL_IN);  
       
    printk("writing data:%s", temp_buffer);   
       
    printk("fpga_key_wirte()--\n");   
   
    return print_size;   
}   
static ssize_t fpga_key_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)   
{   
      char *temp_buffer = "Hello fpga_key_read !\n";   
      int print_size = 0;   
         
    printk("fpga_key_read()++\n");   
       
    if(len > strnlen(temp_buffer,20))   
        print_size = strnlen(temp_buffer,20);   
    else   
        print_size = len;   
    printk("print_size = %d; len = %d\n", print_size, len);   
    if(copy_to_user(buf, temp_buffer, print_size))   
        return -EFAULT;   
    printk("%s", temp_buffer);   
    printk("fpga_key_read()--\n");   
   
    return print_size;   
}   
 
static int fpga_key_fasync(int fd, struct file *filp, int mode) 
{ 
    struct fpga_key_dev     *dev = filp->private_data; 
 
    printk("fpga_key_fasync()++\n"); 
     
    fasync_helper(fd, filp, mode, &dev->async_queue);  
 
    printk("fpga_key_fasync()--\n"); 
     
    return 0; 
} 
 
static int fpga_key_release(struct inode *node, struct file *fd)   
{   
    struct fpga_key_dev *dev = fd->private_data; 
     
    printk("fpga_key_release()++\n");  
 
    dev->message_cdev_open = 0; 
    fpga_key_fasync(-1, fd, 0); 
     
    printk("fpga_key_release()--\n");   
    return 0;   
}  
 
 
struct file_operations meassage_operatons =   
{   
    .owner = THIS_MODULE,   
    .open = fpga_key_open,   
    .write = fpga_key_write, 
    .read = fpga_key_read,  
    .fasync = fpga_key_fasync, 
    .release = fpga_key_release,   
};   
   
struct fpga_key_dev fpga_key_dev;   
static int __init fpga_key_init(void)   
{   
    struct fpga_key_dev * dev;   
    char * temp_char = "hello world\n"; 
   
    printk("fpga_key_to_app_init(void)++\n");   
   
    dev = &fpga_key_dev;   
    strcpy(dev->test, temp_char); 
    printk("%s",dev->test); 
   
    alloc_chrdev_region(&dev->devno, 0, 1, "fpga_key_to_app");   
    //dev->cdev = cdev_alloc();   
    cdev_init(&dev->cdev, &meassage_operatons);   
    cdev_add(&dev->cdev, dev->devno, 1);   
    printk("dev->cdev = %x\n", (unsigned int)&dev->cdev); 
    printk("dev = %x\n", (unsigned int)dev); 
     
    dev->fpga_key_class = class_create(THIS_MODULE, "fpga_key_class");   
    if(IS_ERR(dev->fpga_key_class)) {   
         printk("Err: failed in creating class./n");   
         return -1;    
     }   
    device_create(dev->fpga_key_class, NULL, dev->devno, NULL, "fpga_key");   
    printk("fpga_key_to_app_init(void)--\n");       
    return 0;   
}   
static void __exit fpga_key_exit(void)   
{   
    struct fpga_key_dev *dev = &fpga_key_dev;   
   
    printk("fpga_key_to_app_exit(void)++\n");   
    device_destroy(dev->fpga_key_class, dev->devno);   
    class_destroy(dev->fpga_key_class);    
    cdev_del(&dev->cdev);   
    unregister_chrdev_region(dev->devno, 1);   
        
    printk("fpga_key_to_app_exit(void)--\n");   
}   
module_init(fpga_key_init);   
module_exit(fpga_key_exit);   
   
MODULE_LICENSE("GPL");   
MODULE_AUTHOR("Driver Monkey");   
MODULE_DESCRIPTION("Test fpga_key to App");   

App code:
[cpp] 
#include<stdio.h>   
#include<sys/types.h>   
#include<sys/stat.h>   
#include<fcntl.h>   
#include<sys/select.h>   
#include<unistd.h>   
#include<signal.h>   
#include<string.h>   
   
unsigned int flag = 0;   
   
void sig_handler(int sig)   
{   
  printf("%s\n",__FUNCTION__);   
  flag++;   
}   
int main(void)   
{   
    char r_buf[20];   
    char *w_buf = "hello write!\n";   
    int r_count = 0;   
    int fd;   
    int f_flags;   
    flag++;   
    fd=open("/dev/fpga_key",O_RDWR);   
    if(fd<0)   
    {   
        perror("open");   
        return-1;   
    }   
 
    signal(SIGIO, sig_handler);  
    fcntl(fd, F_SETOWN, getpid()); 
    f_flags = fcntl(fd, F_GETFL); 
    fcntl(fd, F_SETFL, FASYNC | f_flags);  
     
    while(1) 
    { 
        printf("waiting \n");  
        sleep(2); 
        if(flag > 3) 
            break; 
        printf("flag = %d\n", flag); 
         
        write(fd, w_buf, strlen(w_buf));   
    }        
 
    close(fd);   
   
    return 0;   
}