WatchDog Timer驱动

混杂设备

Misc(或miscellaneous)驱动是一些拥有着共同特性的简单字符设备驱动。内核抽象出这些特性而形成一些API(在文件drivers/char/misc.c中实现),以简化这些设备驱动程序的初始化。所有的misc设备被分配同一个主设备号MISC_MAJOR(10),但是每一个可以选择一个单独的次设备号。如果一个字符设备驱动要驱动多个设备,那么它就不应该用misc设备来实现。

通常情况下,一个字符设备都不得不在初始化的过程中进行下面的步骤:

通过alloc_chrdev_region()分配主/次设备号。

使用cdev_init()和cdev_add()来以一个字符设备注册自己。

而一个misc驱动,则可以只用一个调用misc_register()来完成这所有的步骤。

所有的miscdevice设备形成一个链表,对设备访问时,内核根据次设备号查找对应的miscdevice设备,然后调用其file_operations中注册的文件操作方法进行操作。

在Linux内核中,使用struct miscdevice来表示miscdevice。这个结构体的定义为:

struct miscdevice  {

int minor;

const char *name;

const struct file_operations *fops;

struct list_head list;

struct device *parent;

struct device *this_device;

const char *nodename;

mode_t mode;

};

minor是这个混杂设备的次设备号,若由系统自动配置,则可以设置为MISC_DYNANIC_MINOR,name是设备名。

每一个misc驱动会自动出现在/sys/class/misc下,而不需要驱动程序作者明确的去做。Linux watchdog timer驱动被实现为misc 驱动,他们被放在drivers/char/watchdog/目录下。Watchdog 驱动也导出了一个标准设备接口到用户空间。这样就可以使符合这个接口的应用程序的实现独立于Watchdog硬件。这个API在内核树中的Documentation/watchdog/watchdog-api.txt文件中有详细的说明。

在Linux驱动中把无法归类的五花八门的设备定义为混杂设备(用miscdevice结构体表述)。miscdevice共享一个主设备号MISC_MAJOR(即10),但次设备号不同。 所有的miscdevice设备形成了一个链表,对设备访问时内核根据次设备号查找对应的miscdevice设备,然后调用其file_operations结构中注册的文件操作接口进行操作。 在内核中用struct miscdevice表示miscdevice设备,然后调用其file_operations结构中注册的文件操作接口进行操作。miscdevice的API实现在drivers/char/misc.c中。


下边是描述这个设备的结构体:

  1. struct miscdevice  {
  2. int minor;                               //次设备号
  3. const char *name;                        //设备的名称
  4. const struct file_operations *fops;     //文件操作
  5. struct list_head list;                  //misc_list的链表头
  6. struct device *parent;                  //父设备(Linux设备模型中的东东了,哈哈)
  7. struct device *this_device;             //当前设备,是device_create的返回值,下边会看到
  8. };

然后来看看misc子系统的初始化函数:

  1. static int __init misc_init(void)
  2. {
  3. int err;
  4. #ifdef CONFIG_PROC_FS
  5. /*创建一个proc入口项*/
  6. proc_create("misc", 0, NULL, &misc_proc_fops);
  7. #endif
  8. /*在/sys/class/目录下创建一个名为misc的类*/
  9. misc_class = class_create(THIS_MODULE, "misc");
  10. err = PTR_ERR(misc_class);
  11. if (IS_ERR(misc_class))
  12. goto fail_remove;
  13. err = -EIO;
  14. /*注册设备,其中设备的主设备号为MISC_MAJOR,为10。设备名为misc,misc_fops是操作函数的集合*/
  15. if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))
  16. goto fail_printk;
  17. return 0;
  18. fail_printk:
  19. printk("unable to get major %d for misc devices/n", MISC_MAJOR);
  20. class_destroy(misc_class);
  21. fail_remove:
  22. remove_proc_entry("misc", NULL);
  23. return err;
  24. }
  25. /*misc作为一个子系统被注册到linux内核中*/
  26. subsys_initcall(misc_init);

下边是register_chrdev函数的实现:

  1. int register_chrdev(unsigned int major, const char *name,
  2. const struct file_operations *fops)
  3. {
  4. struct char_device_struct *cd;
  5. struct cdev *cdev;
  6. char *s;
  7. int err = -ENOMEM;
  8. /*主设备号是10,次设备号为从0开始,分配256个设备*/
  9. cd = __register_chrdev_region(major, 0, 256, name);
  10. if (IS_ERR(cd))
  11. return PTR_ERR(cd);
  12. /*分配字符设备*/
  13. cdev = cdev_alloc();
  14. if (!cdev)
  15. goto out2;
  16. cdev->owner = fops->owner;
  17. cdev->ops = fops;
  18. /*Linux设备模型中的,设置kobject的名字*/
  19. kobject_set_name(&cdev->kobj, "%s", name);
  20. for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))
  21. *s = '!';
  22. /*把这个字符设备注册到系统中*/
  23. err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
  24. if (err)
  25. goto out;
  26. cd->cdev = cdev;
  27. return major ? 0 : cd->major;
  28. out:
  29. kobject_put(&cdev->kobj);
  30. out2:
  31. kfree(__unregister_chrdev_region(cd->major, 0, 256));
  32. return err;
  33. }

来看看这个设备的操作函数的集合:

  1. static const struct file_operations misc_fops = {
  2. .owner      = THIS_MODULE,
  3. .open       = misc_open,
  4. };

可以看到这里只有一个打开函数,用户打开miscdevice设备是通过主设备号对应的打开函数,在这个函数中找到次设备号对应的相应的具体设备的open函数。它的实现如下:

  1. static int misc_open(struct inode * inode, struct file * file)
  2. {
  3. int minor = iminor(inode);
  4. struct miscdevice *c;
  5. int err = -ENODEV;
  6. const struct file_operations *old_fops, *new_fops = NULL;
  7. lock_kernel();
  8. mutex_lock(&misc_mtx);
  9. /*找到次设备号对应的操作函数集合,让new_fops指向这个具体设备的操作函数集合*/
  10. list_for_each_entry(c, &misc_list, list) {
  11. if (c->minor == minor) {
  12. new_fops = fops_get(c->fops);
  13. break;
  14. }
  15. }
  16. if (!new_fops) {
  17. mutex_unlock(&misc_mtx);
  18. /*如果没有找到,则请求加载这个次设备号对应的模块*/
  19. request_module("char-major-%d-%d", MISC_MAJOR, minor);
  20. mutex_lock(&misc_mtx);
  21. /*重新遍历misc_list链表,如果没有找到就退出,否则让new_fops指向这个具体设备的操作函数集合*/
  22. list_for_each_entry(c, &misc_list, list) {
  23. if (c->minor == minor) {
  24. new_fops = fops_get(c->fops);
  25. break;
  26. }
  27. }
  28. if (!new_fops)
  29. goto fail;
  30. }
  31. err = 0;
  32. /*保存旧打开函数的地址*/
  33. old_fops = file->f_op;
  34. /*让主设备号的操作函数集合指针指向具体设备的操作函数集合*/
  35. file->f_op = new_fops;
  36. if (file->f_op->open) {
  37. /*使用具体设备的打开函数打开设备*/
  38. err=file->f_op->open(inode,file);
  39. if (err) {
  40. fops_put(file->f_op);
  41. file->f_op = fops_get(old_fops);
  42. }
  43. }
  44. fops_put(old_fops);
  45. fail:
  46. mutex_unlock(&misc_mtx);
  47. unlock_kernel();
  48. return err;
  49. }

再来看看misc子系统对外提供的两个重要的API,misc_register,misc_deregister:

  1. int misc_register(struct miscdevice * misc)
  2. {
  3. struct miscdevice *c;
  4. dev_t dev;
  5. int err = 0;
  6. /*初始化misc_list链表*/
  7. INIT_LIST_HEAD(&misc->list);
  8. mutex_lock(&misc_mtx);
  9. /*遍历misc_list链表,看这个次设备号以前有没有被用过,如果次设备号已被占有则退出*/
  10. list_for_each_entry(c, &misc_list, list) {
  11. if (c->minor == misc->minor) {
  12. mutex_unlock(&misc_mtx);
  13. return -EBUSY;
  14. }
  15. }
  16. /*看是否是需要动态分配次设备号*/
  17. if (misc->minor == MISC_DYNAMIC_MINOR) {
  18. /*
  19. *#define DYNAMIC_MINORS 64 /* like dynamic majors */
  20. *static unsigned char misc_minors[DYNAMIC_MINORS / 8];
  21. *这里存在一个次设备号的位图,一共64位。下边是遍历每一位,
  22. *如果这位为0,表示没有被占有,可以使用,为1表示被占用。
  23. */
  24. int i = DYNAMIC_MINORS;
  25. while (--i >= 0)
  26. if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)
  27. break;
  28. if (i<0) {
  29. mutex_unlock(&misc_mtx);
  30. return -EBUSY;
  31. }
  32. /*得到这个次设备号*/
  33. misc->minor = i;
  34. }
  35. /*设置位图中相应位为1*/
  36. if (misc->minor < DYNAMIC_MINORS)
  37. misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
  38. /*计算出设备号*/
  39. dev = MKDEV(MISC_MAJOR, misc->minor);
  40. /*在/dev下创建设备节点,这就是有些驱动程序没有显式调用device_create,却出现了设备节点的原因*/
  41. misc->this_device = device_create(misc_class, misc->parent, dev, NULL,
  42. "%s", misc->name);
  43. if (IS_ERR(misc->this_device)) {
  44. err = PTR_ERR(misc->this_device);
  45. goto out;
  46. }
  47. /*
  48. * Add it to the front, so that later devices can "override"
  49. * earlier defaults
  50. */
  51. /*将这个miscdevice添加到misc_list链表中*/
  52. list_add(&misc->list, &misc_list);
  53. out:
  54. mutex_unlock(&misc_mtx);
  55. return err;
  56. }

这个是miscdevice的卸载函数:

  1. int misc_deregister(struct miscdevice *misc)
  2. {
  3. int i = misc->minor;
  4. if (list_empty(&misc->list))
  5. return -EINVAL;
  6. mutex_lock(&misc_mtx);
  7. /*在misc_list链表中删除miscdevice设备*/
  8. list_del(&misc->list);
  9. /*删除设备节点*/
  10. device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
  11. if (i < DYNAMIC_MINORS && i>0) {
  12. /*释放位图相应位*/
  13. misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
  14. }
  15. mutex_unlock(&misc_mtx);
  16. return 0;
  17. }
 
总结一下miscdevice驱动的注册和卸载流程:
 
misc_register:
匹配次设备号->找到一个没有占用的次设备号(如果需要动态分配的话)->计算设号->创建设备文-
miscdevice结构体添加到misc_list链表中。
misc_deregister:
从mist_list中删除miscdevice->删除设备文件->位图位清零。

misc设备的更多相关文章

  1. 手把手教你从零实现Linux misc设备驱动一(基于友善之臂4412开发板)

    关于怎样来写一个misc设备,在前面有篇文章已经介绍了大致的流程,如今就让我们来实现一个最简单的misc设备驱动. http://blog.csdn.net/morixinguan/article/d ...

  2. 【linux驱动分析】misc设备驱动

    misc设备驱动.又称混杂设备驱动. misc设备驱动共享一个设备驱动号MISC_MAJOR.它在include\linux\major.h中定义:         #define MISC_MAJO ...

  3. 跟着内核学框架-从misc子系统到3+2+1设备识别驱动框架

    misc子系统在Linux中是一个非常简单的子系统,但是其清晰的框架结构非常适合用来研究设备识别模型.本文从misc子系统的使用出发,通过了解其机制来总结一套的设备识别的驱动框架,即使用使用同一个驱动 ...

  4. Linux驱动框架之misc类设备驱动框架

    1.何为misc设备 (1)misc中文名就是杂项设备\杂散设备,因为现在的硬件设备多种多样,有好些设备不好对他们进行一个单独的分类,所以就将这些设备全部归属于 杂散设备,也就是misc设备,例如像a ...

  5. misc类设备

    何为misc (1)中文名:杂项设备\杂散设备,它是一种典型的字符设,在一般情况下在内核中,所有的misc设备的主设备号是固定的,为10,它们的次设备号不一样:(2)可以在根文件系统中看到:/sys/ ...

  6. linux之misc及使用misc创建字符设备

    1:linux字符设备及udev 1.1字符设备 字符设备就是:一个一个字节来进行访问的,不能对字符设备进行随机读写.简单字符设备创建实例如下: #include <linux/module.h ...

  7. 设备驱动基础学习--misc device简单实现

    在Linux驱动中把无法归类的五花八门的设备定义为混杂设备(用miscdevice结构体表述).miscdevice共享一个主设备号MISC_MAJOR(即10),但次设备号不同. 所有的miscde ...

  8. linux 字符设备驱动写法

    字符设备,块设备书 一.register_chrdev_region, register_chrdev, misc_register misc device(杂项设备) 在 Linux 内核的incl ...

  9. i2c总线,设备,驱动之间的关系

    ------ 总线上先添加好所有具体驱动,i2c.c遍历i2c_boardinfo链表,依次建立i2c_client, 并对每一个i2c_client与所有这个线上的驱动匹配,匹配上,就调用这个驱动的 ...

随机推荐

  1. hdwiki中model模块的应用

    control中调用model原则是这样的,如果你的这个model在本control中大部分方法中都要用到,那么,就写在构造函数里面.例如,名字为doc的control的构造函数如下: functio ...

  2. ACM题目————二叉树的遍历

    一.二叉树的后序遍历: 题目描述 给定一颗二叉树,要求输出二叉树的深度以及后序遍历二叉树得到的序列.本题假设二叉树的结点数不超过1000 输入 输 入数据分为多组,第一行是测试数据的组数n,下面的n行 ...

  3. ACM题目————马拦过河卒

    题目描述 棋盘上A点有一个过河卒,需要走到目标B点.卒行走的规则:可以向下.或者向右.同时在棋盘上C点有一个对方的马,该马所在的点和所有跳跃一步可达的点称为对方马的控制点.因此称之为“马拦过河卒”. ...

  4. Android本机号码及Sim卡状态的获取

    SIM卡存储的数据可分为四类:第一类是固定存放的数据.这类数据在移动电话机被出售之前由SIM卡中心写入,包括国际移动用户识别号(IMSI).鉴权密钥(KI).鉴权和加密算法等等.第二类是暂时存放的有关 ...

  5. The Blacksmith学习的相关资源

    1.Unity官网的Blacksmith主页 https://unity3d.com/pages/the-blacksmith 2.WRINKLE MAPS IN THE BLACKSMITH 褶皱贴 ...

  6. AIM Tech Round 3 (Div. 2) B

    Description Vasya takes part in the orienteering competition. There are n checkpoints located along ...

  7. 【Java】hashcode()和equals()

    大家知道,在集合中判断集合中的两个元素是否相同,依赖的是hashcode()和equals()两个方法. > 一个简单的实验 public class Teacher { private Int ...

  8. ActiveMQ点对点的消息发送案例

    公司最近会用MQ对某些业务进行处理,所以,这次我下载了apache-activemq-5.12.0-bin把玩下. 基于练习方便需要,使用Windows的版本. 参考的优秀文章: activemq的几 ...

  9. JAVA的名词释义

    JDK : Java Development Toolkit (java 开发工具包). JDK是整个JAVA的核心,包括了java运行环境(Java Runtime Envirnmet),一堆jav ...

  10. centos7 安装 mariadb 的正确命令

    使用的是linode的centos7系统,安装mysql发现已经默认的是mariadb. 但是不管是使用linode官网说明还是百度搜索到的的根本安装方法无法安装成功. 总是提示这一句: ERROR  ...