• linux驱动开发---day3（自启动创建设备节点进行点灯实验、ioctl函数实现点灯实验）

    自动创建设备节点udev机制的实现过程

    1. udev是自动创建设备节点，逻辑在用户空间
    2. 过程：1）首先注册字符设备驱动，得到标识设备的设备号
                 2）获得设备信息后，先创建一个设备类，向上提交目录信息，使用class_create
                 3）然后创建设备对象，向上提交设备节点信息，使用device_create
                 4）在向上提交设备节点信息后，会自动发起热插拔事件通知udev进程去查询设备节点的信息，以及在/dev下创建设备节点

    自动创建设备节点：（led点灯）

    my_led.c:
    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include<linux/fs.h>
    4. #include<linux/io.h>
    5. #include<linux/device.h>
    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) |= (3<<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.     //向上提交目录
    143.     cls=class_create(THIS_MODULE,"mychrdev");
    144.     if(IS_ERR(cls))
    145.     {
    146.         printk("向上提交目录失败\n");
    147.         return -PTR_ERR(cls);
    148.     }
    149.     printk("向上提交目录成功\n");
    150.  
    151.     //向上提交设备节点信息
    152.     int i;
    153.     for(i=0;i<3;i++)
    154.     {
    155.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"mychrdev%d",i);
    156.         if(IS_ERR(dev))
    157.         {
    158.             printk("向上提交设备节点信息失败\n");
    159.             return -PTR_ERR(dev);
    160.         }
    161.     }
    162.     printk("向上提交设备节点信息成功\n");
    163.  
    164.     return 0;
    165. }
    166. static void __exit mycdev_exit(void)
    167. {
    168.     //销毁设备节点信息
    169.     int i;
    170.     for(i=0;i<3;i++)
    171.     {
    172.         device_destroy(cls,MKDEV(major,i));
    173.     }
    174.     //销毁目录信息
    175.     class_destroy(cls);
    176.     //取消地址映射
    177.     iounmap(vir_led1);
    178.     iounmap(vir_led2);
    179.     iounmap(vir_rcc);
    180.     //注销字符设备驱动
    181.     unregister_chrdev(major,"mychrdev");
    182.  
    183.  
    184. }
    185. module_init(mycdev_init);
    186. module_exit(mycdev_exit);
    187. MODULE_LICENSE("GPL");
    188.
    test.c
    1. #include<stdlib.h>
    2. #include<stdio.h>
    3. #include <sys/types.h>
    4. #include <sys/stat.h>
    5. #include <fcntl.h>
    6. #include<unistd.h>
    7. #include<string.h>
    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. }
    head.h
    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
    测试过程：

    make arch=arm modname=my_led

    cp my_led.ko ~/nfs/rootfs/

    arm-linux-gnueabihf-gcc test.c 

     cp a.out ~/nfs/rootfs/

    ---------------------------------------------------------------------------------------------------------------------------------

    insmod my_led.ko---------->./a.out

    通过ls -l /dev/mychrdev*指令查看创建的设备文件

    rmmod my_led

    测试现象：

    ioctl函数实现点灯实验---添加第三个参数（第三个参数为指针）

    myled.c:
    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include<linux/fs.h>
    4. #include<linux/io.h>
    5. #include<linux/device.h> 
    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.  
    22. long mydev_ioctl(struct file* file,unsigned int cmd,unsigned long arg)
    23. {
    24.     int which;
    25.     //获取arg对应用户空间中的值
    26.     int ret=copy_from_user(&which,(void *)arg,4);
    27.     if(ret)
    28.     {
    29.         printk("从用户空间获取数据失败\n");
    30.         return -EIO;
    31.     }
    32.     switch(cmd)
    33.     {
    34.         case LED_ON://开灯
    35.         switch(which)
    36.         {
    37.             case 1:
    38.                  vir_led1->ODR |= 1<<10;
    39.                 break;
    40.             case 2:
    41.                 vir_led2->ODR |= 1<<10;
    42.                 break;
    43.             case 3:
    44.                 vir_led3->ODR |= 1<<8;
    45.                 break;
    46.         }
    47.         break;
    48.         case LED_OFF: //关灯
    49.         switch(which)
    50.         {
    51.             case 1:
    52.                  vir_led1->ODR &= (~(1<<10));
    53.                 break;
    54.             case 2:
    55.                 vir_led2->ODR &= (~(1<<10));
    56.                 break;
    57.             case 3:
    58.                 vir_led3->ODR &= (~(1<<8));
    59.                 break;
    60.         }
    61.         break;
    62.     }
    63.     return 0;
    64. }
    65.  
    66. int mycdev_close(struct inode *inode, struct file *file)
    67. {
    68.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    69.     return 0;
    70. }
    71.  
    72. //定义操作方法结构体变量并赋值
    73. struct file_operations fops={
    74.  
    75.     .open=mycdev_open,
    76.     .unlocked_ioctl=mydev_ioctl,
    77.     .release=mycdev_close,
    78. };
    79.  
    80. int all_led_init(void)
    81. {
    82.     //寄存器地址的映射
    83.     vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    84.     if(vir_led1==NULL)
    85.     {
    86.         printk("ioremap filed：%d\n",__LINE__);
    87.         return -ENOMEM;
    88.     }
    89.      vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    90.     if(vir_led2==NULL)
    91.     {
    92.         printk("ioremap filed：%d\n",__LINE__);
    93.         return -ENOMEM;
    94.     }
    95.      vir_led3=vir_led1;
    96.     vir_rcc=ioremap(PHY_RCC_ADDR,4);
    97.     if(vir_rcc==NULL)
    98.     {
    99.         printk("ioremap filed：%d\n",__LINE__);
    100.         return -ENOMEM;
    101.     }
    102.     printk("物理地址映射成功\n");
    103.     //寄存器的初始化
    104.     //rcc
    105.     (*vir_rcc) |= (3<<4);
    106.     //led1
    107.     vir_led1->MODER &= (~(3<<20));
    108.     vir_led1->MODER |= (1<<20);
    109.     vir_led1->ODR &= (~(1<<10));
    110.     //led2
    111.     vir_led2->MODER &= (~(3<<20));
    112.     vir_led2->MODER |= (1<<20);
    113.     vir_led2->ODR &= (~(1<<10));
    114.     //led3
    115.     vir_led3->MODER &= (~(3<<16));
    116.     vir_led1->MODER |= (1<<16);
    117.     vir_led1->ODR &= (~(1<<8));
    118.     printk("寄存器初始化成功\n");
    119.  
    120.     return 0;
    121. }
    122.  
    123. static int __init mycdev_init(void)
    124. {
    125.     //字符设备驱动注册
    126.     major=register_chrdev(0,"mychrdev",&fops);
    127.     if(major<0)
    128.     {
    129.         printk("字符设备驱动注册失败\n");
    130.         return major;
    131.     }
    132.     printk("字符设备驱动注册成功:major=%d\n",major);
    133.  
    134.     //寄存器映射以及初始化
    135.     all_led_init();
    136.  
    137.     //向上提交目录
    138.     cls=class_create(THIS_MODULE,"mychrdev");
    139.     if(IS_ERR(cls))
    140.     {
    141.         printk("向上提交目录失败\n");
    142.         return -PTR_ERR(cls);
    143.     }
    144.     printk("向上提交目录成功\n");
    145.  
    146.     //向上提交设备节点信息
    147.     int i;
    148.     for(i=0;i<3;i++)
    149.     {
    150.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"mychrdev%d",i);
    151.         if(IS_ERR(dev))
    152.         {
    153.             printk("向上提交设备节点信息失败\n");
    154.             return -PTR_ERR(dev);
    155.         }
    156.     }
    157.     printk("向上提交设备节点信息成功\n");
    158.  
    159.     return 0;
    160. }
    161. static void __exit mycdev_exit(void)
    162. {
    163.     //销毁设备节点信息
    164.     int i;
    165.     for(i=0;i<3;i++)
    166.     {
    167.         device_destroy(cls,MKDEV(major,i));
    168.     }
    169.     //销毁目录信息
    170.     class_destroy(cls);
    171.     //取消地址映射
    172.     iounmap(vir_led1);
    173.     iounmap(vir_led2);
    174.     iounmap(vir_rcc);
    175.     //注销字符设备驱动
    176.     unregister_chrdev(major,"mychrdev");
    177.  
    178.  
    179. }
    180. module_init(mycdev_init);
    181. module_exit(mycdev_exit);
    182. MODULE_LICENSE("GPL");
    183.
    test.c:
    1. #include<stdlib.h>
    2. #include<stdio.h>
    3. #include <sys/types.h>
    4. #include <sys/stat.h>
    5. #include <fcntl.h>
    6. #include<unistd.h>
    7. #include<string.h>
    8. #include<sys/ioctl.h>
    9. #include"head.h"
    10.  
    11.  
    12. int main(int argc, char const *argv[])
    13. {
    14.     int a,b;
    15.     char buf[128]={0};
    16.     int fd=open("/dev/mychrdev0",O_RDWR);
    17.     if(fd<0)
    18.     {
    19.         printf("打开设备文件失败\n");
    20.         exit(-1);
    21.     }
    22.     while(1)
    23.     {
    24.         //从终端读取
    25.         printf("请输入对LED灯的控制:0(关灯) 1(开灯)\n");
    26.         scanf("%d",&a);
    27.         printf("请输入要控制的灯:1(LED1) 2(LED2) 3(LED3)\n");
    28.         scanf("%d",&b);
    29.         switch(a)
    30.         {
    31.             case 1:
    32.                 ioctl(fd,LED_ON,&b);//开灯
    33.                 break;
    34.             case 0:
    35.                 ioctl(fd,LED_ON,&b);//关灯
    36.                 break;
    37.         }
    38.     }
    39.  
    40.     close(fd);
    41.  
    42.     return 0;
    43. }
    head.h:
    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.  
    16. //构建LED开关功能码，添加ioctl第三个参数
    17. #define LED_ON _IOW('l',1,int)
    18. #define LED_OFF _IOW('l',0,int)
    19. #endif
    测试步骤同上，以下为现象：

  • 相关阅读:
    SpingBoot快速入门下
    前端监控 SDK 开发分享
    【面向对象】理解面向对象编程中的封装性
    自动驾驶——仿真的几大挑战
    wireshark使用
    12.5 Hierarchical names （层次化名称）
    元代理模型可迁移对抗攻击
    【C语言刷LeetCode】面试题 10.09. 排序矩阵查找(M)
    webpack配置之source-map的使用
    阿里架构师：让Spring不再复杂
  • 原文地址：https://blog.csdn.net/m0_72852022/article/details/132830880