Chinaunix首页 | 论坛 | 博客

fzxlhy的ChinaUnix博客

首页　| 　博文目录　| 　关于我

fzxlhy

  • 博客访问： 20084
  • 博文数量： 8
  • 博客积分： 10
  • 博客等级： 民兵
  • 技术积分： 50
  • 用 户 组： 普通用户
  • 注册时间： 2012-10-23 14:34
文章分类

全部博文（8）

文章存档

2012年（8）

我的朋友
最近访客
推荐博文
scull0字符设备驱动示例(参考《Linux设备驱动程序第三版》)

分类：

2012-12-01 22:34:03

原文地址：scull0字符设备驱动示例(参考《Linux设备驱动程序第三版》) 作者：txgc_wm

        参考《Linux设备驱动程序》及其代码，写了一个简单的字符设备驱动，相比作者提供的要简单很多，我在ubuntu10.04的系统上已测试，能运行起来。因水平有限，只实现了open,release,write及read四个基本的接口，且使用测试程序运行时存在明显的bug，望志同道合的朋友一起完善。

头文件部分的定义：

  1. #ifndef __SCULL_H__
  2. #define __SCULL_H__

  4. #ifndef SCULL_MAJOR
  5. #define SCULL_MAJOR 0
  6. #endif

  8. #ifndef SCULL_MINOR
  9. #define SCULL_MINOR 0
  10. #endif

  12. typedef struct _scull_dev_ {
  13.     void **data;     
  14.        int quantum;
  15.        int qset;
  16.        unsigned long size;
  17.        struct semaphore sem;
  18.     struct cdev cdev;

  20. } SCULL_DEV,pSCULL_DEV;

  22. #endif
驱动程序：
  1. /*
  2.  * name:scull.c
  3.  * function:scull character device driver
  4.  * time:2012-2-19
  5.  *
  6.  * author:txgcwm
  7.  * mail:txgcwm@163.com
  8.  * reference:Linux设备驱动程序(第三版)
  9.  */

  11. #ifndef __KERNEL__
  12. # define __KERNEL__
  13. #endif
  14. #ifndef MODULE
  15. # define MODULE
  16. #endif

  18. #include <linux/init.h>
  19. #include <linux/module.h>
  20. #include <linux/cdev.h>
  21. #include <linux/slab.h>
  22. #include <linux/kernel.h> /* printk() */
  23. #include <linux/fs.h> /* everything... */
  24. #include <linux/errno.h> /* error codes */
  25. #include <linux/types.h> /* size_t */
  26. #include <linux/proc_fs.h>
  27. #include <linux/fcntl.h> /* O_ACCMODE */
  28. #include <asm/system.h> /* cli(), *_flags */
  29. #include <asm/uaccess.h>

  31. #include "scull.h" /* local definitions */


  34. int scull_major = SCULL_MAJOR;
  35. int scull_minor    = SCULL_MINOR;
  36. int scull_mn_dev = 1;
  37. int scull_quantum = 4000;    /*每个指针所指向存储单元的大小*/
  38. int scull_qset = 1000;    /*指针数组的大小*/
  39. static pSCULL_DEV *pscull_dev = NULL;


  42. int scull_trim(SCULL_DEV *dev)
  43. {
  44.     int i = 0;
  45.     int qset = dev->qset;

  47.     if (dev->data)
  48.     {
  49.         for(i = 0; i < qset; i++)
  50.         {
  51.             if (dev->data[i])
  52.                 kfree(dev->data[i]);
  53.         }

  55.         kfree(dev->data);
  56.         dev->data=NULL;
  57.     }

  59.     dev->size = 0;
  60.     dev->quantum = scull_quantum;
  61.     dev->qset = scull_qset;
  62.  
  63.     return 0;
  64. }

  66. int scull_open(struct inode *inode, struct file *filp)
  67. {
  68.     SCULL_DEV *dev = NULL;

  70.     dev = container_of(inode->i_cdev,pSCULL_DEV,cdev);
  71.     filp->private_data = dev;
  72.     if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
  73.     {
  74.         scull_trim(dev);
  75.     }

  77.     return 0;
  78. }

  80. int scull_release(struct inode *inode, struct file *filp)
  81. {
  82.     return 0;
  83. }

  85. ssize_t scull_read(struct file *filp, char *buf, size_t count,loff_t *f_pos)
  86. {
  87.     SCULL_DEV *dev = filp->private_data;
  88.     int quantum = dev->quantum;
  89.     int qset = dev->qset;
  90.     int s_pos, q_pos;
  91.     ssize_t ret = 0;

  93.     if(down_interruptible(&dev->sem))
  94.         return -ERESTARTSYS;
  95.     if(*f_pos >= dev->size)
  96.         goto out;
  97.     if(*f_pos + count > dev->size)
  98.         count = dev->size - *f_pos;
  99.     
  100.     s_pos = (long)*f_pos / quantum;
  101.     q_pos = (long)*f_pos % quantum;

  103.     if(s_pos > qset)
  104.         goto out;
  105.     if(!dev->data)
  106.         goto out;
  107.     if(!dev->data[s_pos])
  108.         goto out;
  109.     
  110.     if(count > quantum - q_pos)
  111.         count = quantum - q_pos;

  113.     if(copy_to_user(buf, dev->data[s_pos]+q_pos, count)) /*将内核空间的数据拷贝到用户空间*/
  114.     {
  115.         ret = -EFAULT;
  116.         goto out;
  117.     }
  118.     *f_pos += count;
  119.     ret = count;

  121.  out:
  122.     up(&dev->sem);
  123.     return ret;    
  124. }

  126. ssize_t scull_write(struct file *filp, const char *buf, size_t count,loff_t *f_pos)
  127. {
  128.     SCULL_DEV *dev = filp->private_data;
  129.     int quantum = dev->quantum;
  130.     int qset = dev->qset;
  131.     int s_pos,q_pos;
  132.     ssize_t ret = -ENOMEM;

  134.     if(down_interruptible(&dev->sem))
  135.         return -ERESTARTSYS;

  137.     s_pos = (long)*f_pos / quantum;
  138.     q_pos = (long)*f_pos % quantum;

  140.     if(!dev->data)
  141.     {
  142.         dev->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);
  143.         if (!dev->data)
  144.             goto out;
  145.         memset(dev->data, 0, qset * sizeof(char *));
  146.     }

  148.     if(!dev->data[s_pos])
  149.     {
  150.         dev->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
  151.         if (!dev->data[s_pos])
  152.             goto out;
  153.     }

  155.     if(count > quantum - q_pos)
  156.         count = quantum - q_pos;

  158.     if(copy_from_user(dev->data[s_pos]+q_pos, buf, count))    /*将用户空间的数据拷贝到内核空间*/
  159.     {
  160.         ret = -EFAULT;
  161.         goto out;
  162.     }
  163.     *f_pos += count;
  164.     ret = count;

  166.     if(dev->size < *f_pos)
  167.         dev->size = *f_pos;

  169.   out:
  170.     up(&dev->sem);
  171.     return ret;
  172. }

  174. int scull_ioctl(struct inode *inode, struct file *filp,unsigned int cmd, unsigned long arg)
  175. {
  176.     return 0;
  177. }

  179. loff_t scull_llseek(struct file *filp, loff_t off, int whence)
  180. {
  181.     return 0;
  182. }

  184. struct file_operations scull_fops = {
  185.     .owner     =    THIS_MODULE,
  186.     .llseek    =    scull_llseek,
  187.     .read    =    scull_read,
  188.     .write    =    scull_write,
  189.     .ioctl    =    scull_ioctl,
  190.     .open    =    scull_open,
  191.     .release =    scull_release,
  192. };

  194. static void scull_cleanup_module(void)
  195. {
  196.     dev_t dev;

  198.     dev = MKDEV(scull_major,scull_minor);
  199.     cdev_del(&pscull_dev->cdev);
  200.     unregister_chrdev_region(dev,scull_mn_dev);
  201.     scull_trim(pscull_dev);
  202.     kfree(pscull_dev);
  203.     pscull_dev = NULL;    
  204.     printk(KERN_EMERG"Leave World!\n");

  206.     return;
  207. }

  209. static int scull_init_module(void)
  210. {
  211.     dev_t dev;
  212.     int result = -1;

  214.     pscull_dev = kmalloc(sizeof(SCULL_DEV),GFP_KERNEL);
  215.     if(pscull_dev == NULL)
  216.     {
  217.         printk(KERN_WARNING"scull: can't kmalloc memory\n");
  218.         result = -ENOMEM;
  219.         return result;
  220.     }
  221.     memset(pscull_dev,0,sizeof(SCULL_DEV));
  222.     pscull_dev->data = NULL;
  223.     pscull_dev->quantum = scull_quantum;
  224.     pscull_dev->qset = scull_qset;
  225.     sema_init(&pscull_dev->sem, 1);

  227.     if(scull_major)
  228.     {
  229.         dev = MKDEV(scull_major,scull_minor);    
  230.         result = register_chrdev_region(dev,scull_mn_dev,"scull");
  231.     }
  232.     else
  233.     {
  234.         result = alloc_chrdev_region(&dev,scull_minor,scull_mn_dev,"scull");
  235.         scull_major = MAJOR(dev);
  236.     }

  238.     if(result < 0)
  239.     {
  240.         printk(KERN_WARNING"scull: can't get major %d\n",scull_major);
  241.         return result;
  242.     }

  244.     cdev_init(&pscull_dev->cdev,&scull_fops);
  245.     pscull_dev->cdev.owner = THIS_MODULE;
  246.     pscull_dev->cdev.ops = &scull_fops;
  247.     result = cdev_add(&pscull_dev->cdev,dev,1);
  248.     if(result)
  249.     {
  250.         printk(KERN_NOTICE"Error %d add scull device\n",result);
  251.         goto fail;
  252.     }
  253.     printk(KERN_EMERG"Hello World!\n");
  254.     return 0;

  256.   fail:
  257.     scull_cleanup_module();

  259.     return result;
  260. }



  264. module_init(scull_init_module);
  265. module_exit(scull_cleanup_module);

  267. MODULE_AUTHOR("txgcwm");
  268. MODULE_VERSION("scull_v1.0");
  269. MODULE_LICENSE("GPL");

附件包含了驱动程序，测试程序，启动及卸载脚本。

参考书籍：
       《Linux设备驱动程序第三版》
                                                                            scull.rar  
阅读(1052) | 评论(0) | 转发(0) |
0

上一篇：Linux中的工作队列

下一篇：没有了

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

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

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

16024965号-6