Chinaunix首页 | 论坛 | 博客

lchjczwlchjczw.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

lchjczw

  • 博客访问： 630992
  • 博文数量： 1008
  • 博客积分： 10
  • 博客等级： 民兵
  • 技术积分： 5175
  • 用 户 组： 普通用户
  • 注册时间： 2012-07-31 09:44
文章分类

全部博文（1008）

文章存档

2012年（1008）

我的朋友
最近访客
推荐博文
字符设备驱动poll函数

分类：

2012-08-01 11:28:54

原文地址：字符设备驱动poll函数 作者：luozhiyong131

  1. #ifndef _MEMDEV_H_
  2. #define _MEMDEV_H_

  4. #ifndef MEMDEV_MAJOR
  5. #define MEMDEV_MAJOR 0 /*预设的mem的主设备号*/
  6. #endif

  8. #ifndef MEMDEV_NR_DEVS
  9. #define MEMDEV_NR_DEVS 2 /*设备数*/
  10. #endif

  12. #ifndef MEMDEV_SIZE
  13. #define MEMDEV_SIZE 4096
  14. #endif

  16. /*mem设备描述结构体*/
  17. struct mem_dev
  18. {
  19.   char *data;
  20.   unsigned long size;
  21.   wait_queue_head_t inq;
  22. };

  24. #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>

  13. #include <linux/poll.h>
  14. #include "memdev.h"

  16. static mem_major = MEMDEV_MAJOR;
  17. bool have_data = false; /*表明设备有足够数据可供读*/

  19. module_param(mem_major, int, S_IRUGO);

  21. struct mem_dev *mem_devp; /*设备结构体指针*/

  23. struct cdev cdev;

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

  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. }

  43. /*文件释放函数*/
  44. int mem_release(struct inode *inode, struct file *filp)
  45. {
  46.   return 0;
  47. }

  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; /*获得设备结构体指针*/

  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.   }

  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. }

  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;

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

  119.   return ret;
  120. }

  122. /* seek文件定位函数 */
  123. static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
  124. {
  125.     loff_t newpos;

  127.     switch(whence) {
  128.       case 0: /* SEEK_SET */
  129.         newpos = offset;
  130.         break;

  132.       case 1: /* SEEK_CUR */
  133.         newpos = filp->f_pos + offset;
  134.         break;

  136.       case 2: /* SEEK_END */
  137.         newpos = MEMDEV_SIZE -1 + offset;
  138.         break;

  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;

  149. }

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

  159.     
  160.     if (have_data) mask |= POLLIN | POLLRDNORM; /* readable */

  162.     return mask;
  163. }


  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. };

  178. /*设备驱动模块加载函数*/
  179. static int memdev_init(void)
  180. {
  181.   int result;
  182.   int i;

  184.   dev_t devno = MKDEV(mem_major, 0);

  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;

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

  226.   }
  227.    
  228.   return 0;

  230.   fail_malloc:
  231.   unregister_chrdev_region(devno, 1);
  232.   
  233.   return result;
  234. }

  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. }

  244. MODULE_AUTHOR("David Xie");
  245. MODULE_LICENSE("GPL");

  247. module_init(memdev_init);
  248. module_exit(memdev_exit);
  1. #include <stdio.h>

  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;    

  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>

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

  29.     /*清除Buf*/
  30.     strcpy(Buf,"Buf is NULL!");
  31.     printf("Read BUF1: %s\n",Buf);

  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. }
阅读(164) | 评论(0) | 转发(0) |
0

上一篇：自动创建设备文件

下一篇：阻塞型字符设备驱动

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6