字符设备驱动poll函数

1. #ifndef _MEMDEV_H_
   

• #define _MEMDEV_H_
  
• 
  
• #ifndef MEMDEV_MAJOR
  
• #define MEMDEV_MAJOR 0 /*预设的mem的主设备号*/
  
• #endif
  
• 
  
• #ifndef MEMDEV_NR_DEVS
  
• #define MEMDEV_NR_DEVS 2 /*设备数*/
  
• #endif
  
• 
  
• #ifndef MEMDEV_SIZE
  
• #define MEMDEV_SIZE 4096
  
• #endif
  
• 
  
• /*mem设备描述结构体*/
  
• struct mem_dev
  
• {
  
•   char *data;
  
•   unsigned long size;
  
•   wait_queue_head_t inq;
  
• };
  
• 
  
• #endif /* _MEMDEV_H_ */
  1. #include <linux/module.h>
     
  2. #include <linux/types.h>
     
  3. #include <linux/fs.h>
     
  4. #include <linux/errno.h>
     
  5. #include <linux/mm.h>
     
  6. #include <linux/sched.h>
     
  7. #include <linux/init.h>
     
  8. #include <linux/cdev.h>
     
  9. #include <asm/io.h>
     
  10. #include <asm/system.h>
      
  11. #include <asm/uaccess.h>
      
  12. 
      
  13. #include <linux/poll.h>
      
  14. #include "memdev.h"
      
  15. 
      
  16. static mem_major = MEMDEV_MAJOR;
      
  17. bool have_data = false; /*表明设备有足够数据可供读*/
      
  18. 
      
  19. module_param(mem_major, int, S_IRUGO);
      
  20. 
      
  21. struct mem_dev *mem_devp; /*设备结构体指针*/
      
  22. 
      
  23. struct cdev cdev;
      
  24. 
      
  25. /*文件打开函数*/
      
  26. int mem_open(struct inode *inode, struct file *filp)
      
  27. {
      
  28.     struct mem_dev *dev;
      
  29.    
      
  30.     /*获取次设备号*/
      
  31.     int num = MINOR(inode->i_rdev);
      
  32. 
      
  33.     if (num >= MEMDEV_NR_DEVS)
      
  34.             return -ENODEV;
      
  35.     dev = &mem_devp[num];
      
  36.    
      
  37.     /*将设备描述结构指针赋值给文件私有数据指针*/
      
  38.     filp->private_data = dev;
      
  39.    
      
  40.     return 0;
      
  41. }
      
  42. 
      
  43. /*文件释放函数*/
      
  44. int mem_release(struct inode *inode, struct file *filp)
      
  45. {
      
  46.   return 0;
      
  47. }
      
  48. 
      
  49. /*读函数*/
      
  50. static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
      
  51. {
      
  52.   unsigned long p = *ppos;
      
  53.   unsigned int count = size;
      
  54.   int ret = 0;
      
  55.   struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
      
  56. 
      
  57.   /*判断读位置是否有效*/
      
  58.   if (p >= MEMDEV_SIZE)
      
  59.     return 0;
      
  60.   if (count > MEMDEV_SIZE - p)
      
  61.     count = MEMDEV_SIZE - p;
      
  62.    
      
  63.   while (!have_data) /* 没有数据可读，考虑为什么不用if，而用while */
      
  64.   {
      
  65.         if (filp->f_flags & O_NONBLOCK)
      
  66.             return -EAGAIN;
      
  67.    
      
  68.     wait_event_interruptible(dev->inq,have_data);
      
  69.   }
      
  70. 
      
  71.   /*读数据到用户空间*/
      
  72.   if (copy_to_user(buf, (void*)(dev->data + p), count))
      
  73.   {
      
  74.     ret = - EFAULT;
      
  75.   }
      
  76.   else
      
  77.   {
      
  78.     *ppos += count;
      
  79.     ret = count;
      
  80.   
      
  81.     printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
      
  82.   }
      
  83.  
      
  84.   have_data = false; /* 表明不再有数据可读 */
      
  85.   /* 唤醒写进程 */
      
  86.   return ret;
      
  87. }
      
  88. 
      
  89. /*写函数*/
      
  90. static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
      
  91. {
      
  92.   unsigned long p = *ppos;
      
  93.   unsigned int count = size;
      
  94.   int ret = 0;
      
  95.   struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
      
  96.  
      
  97.   /*分析和获取有效的写长度*/
      
  98.   if (p >= MEMDEV_SIZE)
      
  99.     return 0;
      
  100.   if (count > MEMDEV_SIZE - p)
       
  101.     count = MEMDEV_SIZE - p;
       
  102. 
       
  103.   /*从用户空间写入数据*/
       
  104.   if (copy_from_user(dev->data + p, buf, count))
       
  105.     ret = - EFAULT;
       
  106.   else
       
  107.   {
       
  108.     *ppos += count;
       
  109.     ret = count;
       
  110.    
       
  111.     printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
       
  112.   }
       
  113.  
       
  114.   have_data = true; /* 有新的数据可读 */
       
  115.    
       
  116.     /* 唤醒读进程 */
       
  117.     wake_up(&(dev->inq));
       
  118. 
       
  119.   return ret;
       
  120. }
       
  121. 
       
  122. /* seek文件定位函数 */
       
  123. static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
       
  124. {
       
  125.     loff_t newpos;
       
  126. 
       
  127.     switch(whence) {
       
  128.       case 0: /* SEEK_SET */
       
  129.         newpos = offset;
       
  130.         break;
       
  131. 
       
  132.       case 1: /* SEEK_CUR */
       
  133.         newpos = filp->f_pos + offset;
       
  134.         break;
       
  135. 
       
  136.       case 2: /* SEEK_END */
       
  137.         newpos = MEMDEV_SIZE -1 + offset;
       
  138.         break;
       
  139. 
       
  140.       default: /* can't happen */
       
  141.         return -EINVAL;
       
  142.     }
       
  143.     if ((newpos<0) || (newpos>MEMDEV_SIZE))
       
  144.         return -EINVAL;
       
  145.        
       
  146.     filp->f_pos = newpos;
       
  147.     return newpos;
       
  148. 
       
  149. }
       
  150. 
       
  151. unsigned int mem_poll(struct file *filp, poll_table *wait)
       
  152. {
       
  153.     struct mem_dev *dev = filp->private_data;
       
  154.     unsigned int mask = 0;
       
  155.    
       
  156.    /*将等待队列添加到poll_table */
       
  157.     poll_wait(filp, &dev->inq, wait);
       
  158. 
       
  159.    
       
  160.     if (have_data) mask |= POLLIN | POLLRDNORM; /* readable */
       
  161. 
       
  162.     return mask;
       
  163. }
       
  164. 
       
  165. 
       
  166. /*文件操作结构体*/
       
  167. static const struct file_operations mem_fops =
       
  168. {
       
  169.   .owner = THIS_MODULE,
       
  170.   .llseek = mem_llseek,
       
  171.   .read = mem_read,
       
  172.   .write = mem_write,
       
  173.   .open = mem_open,
       
  174.   .release = mem_release,
       
  175.   .poll = mem_poll,
       
  176. };
       
  177. 
       
  178. /*设备驱动模块加载函数*/
       
  179. static int memdev_init(void)
       
  180. {
       
  181.   int result;
       
  182.   int i;
       
  183. 
       
  184.   dev_t devno = MKDEV(mem_major, 0);
       
  185. 
       
  186.   /* 静态申请设备号*/
       
  187.   if (mem_major)
       
  188.     result = register_chrdev_region(devno, 2, "memdev");
       
  189.   else /* 动态分配设备号 */
       
  190.   {
       
  191.     result = alloc_chrdev_region(&devno, 0, 2, "memdev");
       
  192.     mem_major = MAJOR(devno);
       
  193.   }
       
  194.  
       
  195.   if (result < 0)
       
  196.     return result;
       
  197. 
       
  198.   /*初始化cdev结构*/
       
  199.   cdev_init(&cdev, &mem_fops);
       
  200.   cdev.owner = THIS_MODULE;
       
  201.   cdev.ops = &mem_fops;
       
  202.  
       
  203.   /* 注册字符设备 */
       
  204.   cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
       
  205.   
       
  206.   /* 为设备描述结构分配内存*/
       
  207.   mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
       
  208.   if (!mem_devp) /*申请失败*/
       
  209.   {
       
  210.     result = - ENOMEM;
       
  211.     goto fail_malloc;
       
  212.   }
       
  213.   memset(mem_devp, 0, sizeof(struct mem_dev));
       
  214.  
       
  215.   /*为设备分配内存*/
       
  216.   for (i=0; i < MEMDEV_NR_DEVS; i++)
       
  217.   {
       
  218.         mem_devp[i].size = MEMDEV_SIZE;
       
  219.         mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
       
  220.         memset(mem_devp[i].data, 0, MEMDEV_SIZE);
       
  221.  
       
  222.       /*初始化等待队列*/
       
  223.      init_waitqueue_head(&(mem_devp[i].inq));
       
  224.      //init_waitqueue_head(&(mem_devp[i].outq));
       
  225. 
       
  226.   }
       
  227.   
       
  228.   return 0;
       
  229. 
       
  230.   fail_malloc:
       
  231.   unregister_chrdev_region(devno, 1);
       
  232.  
       
  233.   return result;
       
  234. }
       
  235. 
       
  236. /*模块卸载函数*/
       
  237. static void memdev_exit(void)
       
  238. {
       
  239.   cdev_del(&cdev); /*注销设备*/
       
  240.   kfree(mem_devp); /*释放设备结构体内存*/
       
  241.   unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
       
  242. }
       
  243. 
       
  244. MODULE_AUTHOR("David Xie");
       
  245. MODULE_LICENSE("GPL");
       
  246. 
       
  247. module_init(memdev_init);
       
  248. module_exit(memdev_exit);
  1. #include <stdio.h>
     
  2. 
     
  3. int main()
     
  4. {
     
  5.     FILE *fp = NULL;
     
  6.     char Buf[128];
     
  7.        
     
  8.     /*打开设备文件*/
     
  9.     fp = fopen("/dev/memdev0","r+");
     
  10.     if (fp == NULL)
      
  11.     {
      
  12.         printf("Open Dev memdev Error!\n");
      
  13.         return -1;
      
  14.     }
      
  15.    
      
  16.     /*写入设备*/
      
  17.     strcpy(Buf,"memdev is char dev!");
      
  18.     printf("Write BUF: %s\n",Buf);
      
  19.     fwrite(Buf, sizeof(Buf), 1, fp);
      
  20.    
      
  21.     sleep(5);
      
  22.     fclose(fp);
      
  23.    
      
  24.     return 0;   
      
  25. 
      
  26. }
  1. #include <stdio.h>
     
  2. #include <stdlib.h>
     
  3. #include <unistd.h>
     
  4. #include <sys/ioctl.h>
     
  5. #include <sys/types.h>
     
  6. #include <sys/stat.h>
     
  7. #include <fcntl.h>
     
  8. #include <sys/select.h>
     
  9. #include <sys/time.h>
     
  10. #include <errno.h>
      
  11. 
      
  12. int main()
      
  13. {
      
  14.     int fd;
      
  15.     fd_set rds;
      
  16.     int ret;
      
  17.     char Buf[128];
      
  18.    
      
  19.     /*初始化Buf*/
      
  20.     strcpy(Buf,"memdev is char dev!");
      
  21.     printf("BUF: %s\n",Buf);
      
  22.    
      
  23.     /*打开设备文件*/
      
  24.     fd = open("/dev/memdev0",O_RDWR);
      
  25.    
      
  26.     FD_ZERO(&rds);
      
  27.     FD_SET(fd, &rds);
      
  28. 
      
  29.     /*清除Buf*/
      
  30.     strcpy(Buf,"Buf is NULL!");
      
  31.     printf("Read BUF1: %s\n",Buf);
      
  32. 
      
  33.     ret = select(fd + 1, &rds, NULL, NULL, NULL);
      
  34.     if (ret < 0)
      
  35.     {
      
  36.      printf("select error!\n");
      
  37.      exit(1);
      
  38.     }
      
  39.     if (FD_ISSET(fd, &rds))
      
  40.      read(fd, Buf, sizeof(Buf));           
      
  41.    
      
  42.     /*检测结果*/
      
  43.     printf("Read BUF2: %s\n",Buf);
      
  44.    
      
  45.     close(fd);
      
  46.    
      
  47.     return 0;   
      
  48. }