• 驱动开发--自动创建设备节点udev机制的实现过程

    一、udev的认识

    udev:自动创建设备节点的机制，创建设备节点的逻辑在用户空间

    二、udev机制创建设备节点的过程分析

    三、目录信息创建和删除类函数

    1. #include
    2. 1.向上提交目录信息
    3. struct class * class_create(struct module *owner,const char *name );
    4. 功能：申请一个设备类并初始化，向上提交目录信息
    5. 参数：
    6. 参数1：owner:指向当前内核模块自身的一个模块指针，填写THIS_MODULE
    7. 参数2：name:向上提交的目录名
    8. 返回值：成功返回申请的struct class对象空间首地址，失败返回错误码指针
    9.     /*
    10.     在内核空间最顶层会预留4K空间，当struct class函数调用失败后函数会返回一个指向这4K空间的指针
    11.     bool __must_check IS_ERR(__force const void *ptr)
    12.     功能：判断指针是否指向4K预留空间
    13.     参数：要判断的指针
    14.     返回值：如果指着指向4K预留空间返回逻辑真，否则返回逻辑假
    15.      long __must_check PTR_ERR(__force const void *ptr)
    16.      功能：通过错误码指针得到错误码
    17.      ex:struct class_create *cls=struct class_create(THIS_MODULE,"mycdev");
    18.      if(IS_ERR(cls))
    19.      {
    20.          printk("向上提交目录失败\n");
    21.          return -PRT_ERR(cls);     
    22.      }
    23.     */
    24. 2.销毁目录
    25. void class_destroy(struct class *cls)
    26. 功能:销毁目录信息
    27. 参数：cls:指向class对象的指针
    28. 返回值：无

    四、节点信息创建和删除类函数

    1. 1.向上提交节点信息
    2. struct device *device_create(struct class *class, struct device *parent,
    3.                  dev_t devt, void *drvdata, const char *fmt, ...)
    4. 功能：创建一个设备对象，向上提交设备节点信息
    5. 参数：
    6. 参数1：cls:向上提交目录时的到的类对象指针
    7. 参数2：parent:当前申请的对象前一个节点的地址，不知道就填 NULL
    8. 参数3：devt:设备号    主设备号<<20|次设备号
    9.         /*
    10.             MKDEV(主设备号,次设备号)：根据主设备号和次设备号得到设备号
    11.             MAJOR(dev)：根据设备号获取主设备号
    12.             MINOR(dev)：根据设备号获取次设备号
    13.         */
    14. 参数4：dridata:申请的device对象的私有数据，填写NULL
    15. 参数5：fmt:向上提交的设备节点名
    16. ...:不定长参数   
    17. 返回值：成功返回申请到的device对象首地址，失败返回错误码指针，指向4K预留空间
    18.  
    19. 2.销毁设备节点信息
    20. void device_destroy(struct class *class, dev_t devt)
    21. 功能：销毁设备节点信息
    22. 参数：
    23. class:向上提交目录时得到的类对象指针
    24. devt:向上提交设备节点信息时提交的设备号
    25. 返回值：无

    五、自动创建设备节点实例

    1.驱动程序

    1. #include 
    2. #include 
    3. #include
    4. #include
    5. #include
    6. #include"head.h"
    7.  
    8. int major;
    9. char kbuf[128]={0};
    10. gpio_t *vir_led1;
    11. gpio_t *vir_led2;
    12. gpio_t *vir_led3;
    13. unsigned int *vir_rcc;
    14. struct class *cls;
    15. struct device *dev;
    16. int mycdev_open(struct inode *inode, struct file *file)
    17. {
    18.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    19.     return 0;
    20. }
    21. ssize_t mycdev_read(struct file *file, char  *ubuf, size_t size, loff_t *lof)
    22. {
    23.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    24.      unsigned long ret;
    25.     //向用户空间读取拷贝
    26.     if(size>sizeof(kbuf))//用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
    27.         size=sizeof(kbuf);
    28.     ret=copy_to_user(ubuf,kbuf,size);
    29.     if(ret)//拷贝失败
    30.     {
    31.         printk("copy_to_user filed\n");
    32.         return ret;
    33.     }
    34.     return 0;
    35. }
    36. ssize_t mycdev_write(struct file *file, const char  *ubuf, size_t size, loff_t *lof)
    37. {
    38.     unsigned long ret;
    39.     //从用户空间读取数据
    40.     if(size>sizeof(kbuf))//用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
    41.         size=sizeof(kbuf);
    42.     ret=copy_from_user(kbuf,ubuf,size);
    43.     if(ret)//拷贝失败
    44.     {
    45.         printk("copy_to_user filed\n");
    46.         return ret;
    47.     }
    48.     switch(kbuf[0]){
    49.         case '1'://LED1
    50.             if(kbuf[1]=='0')//关灯
    51.                 vir_led1->ODR &= (~(1<<10));
    52.             else//开灯
    53.                 vir_led1->ODR |= 1<<10;
    54.             break;
    55.         case '2'://LED2
    56.             if(kbuf[1]=='0')//关灯
    57.                 vir_led2->ODR &= (~(1<<10));
    58.             else//开灯
    59.                 vir_led2->ODR |= 1<<10;
    60.             break;
    61.         case '3'://LED3
    62.             if(kbuf[1]=='0')//关灯
    63.                 vir_led3->ODR &= (~(1<<8));
    64.             else//开灯
    65.                 vir_led3->ODR |= 1<<8;
    66.             break;
    67.     }
    68.     return 0;
    69. }
    70. int mycdev_close(struct inode *inode, struct file *file)
    71. {
    72.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    73.     return 0;
    74. }
    75.  
    76. //定义操作方法结构体变量并赋值
    77. struct file_operations fops={
    78.  
    79.     .open=mycdev_open,
    80.     .read=mycdev_read,
    81.     .write=mycdev_write,
    82.     .release=mycdev_close,
    83. };
    84.  
    85. int all_led_init(void)
    86. {
    87.     //寄存器地址的映射
    88.     vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    89.     if(vir_led1==NULL)
    90.     {
    91.         printk("ioremap filed：%d\n",__LINE__);
    92.         return -ENOMEM;
    93.     }
    94.      vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    95.     if(vir_led2==NULL)
    96.     {
    97.         printk("ioremap filed：%d\n",__LINE__);
    98.         return -ENOMEM;
    99.     }
    100.      vir_led3=vir_led1;
    101.     vir_rcc=ioremap(PHY_RCC_ADDR,4);
    102.     if(vir_rcc==NULL)
    103.     {
    104.         printk("ioremap filed：%d\n",__LINE__);
    105.         return -ENOMEM;
    106.     }
    107.     printk("物理地址映射成功\n");
    108.     //寄存器的初始化
    109.     //rcc
    110.     (*vir_rcc) |= (0X3<<4);
    111.     //led1
    112.     vir_led1->MODER &= (~(3<<20));
    113.     vir_led1->MODER |= (1<<20);
    114.     vir_led1->ODR &= (~(1<<10));
    115.     //led2
    116.     vir_led2->MODER &= (~(3<<20));
    117.     vir_led2->MODER |= (1<<20);
    118.     vir_led2->ODR &= (~(1<<10));
    119.     //led3
    120.     vir_led3->MODER &= (~(3<<16));
    121.     vir_led1->MODER |= (1<<16);
    122.     vir_led1->ODR &= (~(1<<8));
    123.     printk("寄存器初始化成功\n");
    124.  
    125.     return 0;
    126. }
    127.  
    128. static int __init mycdev_init(void)
    129. {
    130.     //字符设备驱动注册
    131.     major=register_chrdev(0,"mychrdev",&fops);
    132.     if(major<0)
    133.     {
    134.         printk("字符设备驱动注册失败\n");
    135.         return major;
    136.     }
    137.     printk("字符设备驱动注册成功:major=%d\n",major);
    138.     
    139.     //寄存器映射以及初始化
    140.     all_led_init();
    141.     //向上提交目录
    142.     cls=class_create(THIS_MODULE,"mychrdev");
    143.     if(IS_ERR(cls))
    144.     {
    145.         printk("向上提交目录失败\n");
    146.         return -PTR_ERR(cls);
    147.     }
    148.     printk("向上提交目录成功\n");
    149.     //向上提交设备节点信息
    150.     int i;
    151.     for(i=0;i<3;i++)
    152.     {
    153.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"mychrdev%d",i);
    154.         if(IS_ERR(dev))
    155.         {
    156.             printk("向上提交设备节点信息失败\n");
    157.             return -PTR_ERR(dev);
    158.         }
    159.     }
    160.     printk("向上提交设备节点信息成功\n");
    161.  
    162.  
    163.     return 0;
    164. }
    165. static void __exit mycdev_exit(void)
    166. {
    167.     /*销毁设备节点信息*/
    168.     int i;
    169.     for(i=0;i<3;i++)
    170.     {
    171.         device_destroy(cls,MKDEV(major,i));
    172.     }
    173.     //销毁目录信息
    174.     class_destroy(cls);
    175.     //取消地址映射
    176.     iounmap(vir_led1);
    177.     iounmap(vir_led2);
    178.     iounmap(vir_rcc);
    179.     
    180.    
    181.     //注销字符设备驱动
    182.     unregister_chrdev(major,"mychrdev");
    183.  
    184.  
    185. }
    186. module_init(mycdev_init);
    187. module_exit(mycdev_exit);
    188. MODULE_LICENSE("GPL");

    2.应用程序

    1. #include
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6. #include
    7. #include
    8.  
    9.  
    10. int main(int argc, char const *argv[])
    11. {
    12.     char buf[128]={0};
    13.     int fd=open("/dev/mychrdev0",O_RDWR);
    14.     if(fd<0)
    15.     {
    16.         printf("打开设备文件失败\n");
    17.         exit(-1);
    18.     }
    19.     while(1)
    20.     {
    21.         //从终端读取
    22.         printf("请输入两个字符\n");
    23.         printf("第一个字符:1(LED1) 2(LED2) 3(LED3)\n");
    24.         printf("第二个字符:0(关灯) 1(开灯)\n");
    25.         printf("请输入>");
    26.         fgets(buf,sizeof(buf),stdin);
    27.         buf[strlen(buf)-1]='\0';
    28.         //向设备文件中写
    29.         write(fd,buf,sizeof(buf));
    30.     }
    31.  
    32.     
    33.     close(fd);
    34.  
    35.     return 0;
    36. }

    3.头文件

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__ 
    3. typedef struct{
    4.     unsigned int MODER;
    5.     unsigned int OTYPER;
    6.     unsigned int OSPEEDR;
    7.     unsigned int PUPDR;
    8.     unsigned int IDR;
    9.     unsigned int ODR;
    10. }gpio_t;
    11. #define PHY_LED1_ADDR 0X50006000
    12. #define PHY_LED2_ADDR    0X50007000
    13. #define PHY_LED3_ADDR 0X50006000
    14. #define PHY_RCC_ADDR    0X50000A28
    15. #endif

  • 相关阅读:
    Intel 7工艺的极限！酷睿i9-14900K/i7-14700K首发评测：6GHz单核性能无敌
    int指令
    Android之App跳转其他软件
    北京化工大学数据结构2022/12/1作业 题解
    自定义数据训练的rknn模型部署 踩坑记录
    同花顺_代码解析_五彩K线
    bgp链路聚合配置与详解
    金仓数据库KingbaseES客户端应用参考手册--7. sys_basebackup
    C++ Primer 类与构造函数 三五法则
    C++多态 万字详解
  • 原文地址：https://blog.csdn.net/m0_62774039/article/details/132838576