• 【驱动开发】创建设备节点、ioctl函数的使用

    一、控制三盏灯的亮灭

    头文件：
    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
    驱动程序：
    1. #include 
    2. #include 
    3. #include
    4. #include
    5. #include"head.h"
    6.  
    7. int major;
    8. char kbuf[128]={0};
    9. gpio_t *vir_led1;
    10. gpio_t *vir_led2;
    11. gpio_t *vir_led3;
    12. unsigned int *vir_rcc;
    13. int mycdev_open(struct inode *inode, struct file *file)
    14. {
    15.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    16.     return 0;
    17. }
    18. ssize_t mycdev_read(struct file *file, char  *ubuf, size_t size, loff_t *lof)
    19. {
    20.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    21.      unsigned long ret;
    22.     //向用户空间读取拷贝
    23.     if(size>sizeof(kbuf))//用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
    24.         size=sizeof(kbuf);
    25.     ret=copy_to_user(ubuf,kbuf,size);
    26.     if(ret)//拷贝失败
    27.     {
    28.         printk("copy_to_user filed\n");
    29.         return ret;
    30.     }
    31.     return 0;
    32. }
    33. ssize_t mycdev_write(struct file *file, const char  *ubuf, size_t size, loff_t *lof)
    34. {
    35.     unsigned long ret;
    36.     //从用户空间读取数据
    37.     if(size>sizeof(kbuf))//用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
    38.         size=sizeof(kbuf);
    39.     ret=copy_from_user(kbuf,ubuf,size);
    40.     if(ret)//拷贝失败
    41.     {
    42.         printk("copy_to_user filed\n");
    43.         return ret;
    44.     }
    45.     switch(kbuf[0]){
    46.         case '1'://LED1
    47.             if(kbuf[1]=='0')//关灯
    48.                 vir_led1->ODR &= (~(1<<10));
    49.             else//开灯
    50.                 vir_led1->ODR |= 1<<10;
    51.             break;
    52.         case '2'://LED2
    53.             if(kbuf[1]=='0')//关灯
    54.                 vir_led2->ODR &= (~(1<<10));
    55.             else//开灯
    56.                 vir_led2->ODR |= 1<<10;
    57.             break;
    58.         case '3'://LED3
    59.             if(kbuf[1]=='0')//关灯
    60.                 vir_led3->ODR &= (~(1<<8));
    61.             else//开灯
    62.                 vir_led3->ODR |= 1<<8;
    63.             break;
    64.     }
    65.     return 0;
    66. }
    67. int mycdev_close(struct inode *inode, struct file *file)
    68. {
    69.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    70.     return 0;
    71. }
    72.  
    73. //定义操作方法结构体变量并赋值
    74. struct file_operations fops={
    75.  
    76.     .open=mycdev_open,
    77.     .read=mycdev_read,
    78.     .write=mycdev_write,
    79.     .release=mycdev_close,
    80. };
    81.  
    82. int all_led_init(void)
    83. {
    84.     //寄存器地址的映射
    85.     vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    86.     if(vir_led1==NULL)
    87.     {
    88.         printk("ioremap filed：%d\n",__LINE__);
    89.         return -ENOMEM;
    90.     }
    91.      vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    92.     if(vir_led2==NULL)
    93.     {
    94.         printk("ioremap filed：%d\n",__LINE__);
    95.         return -ENOMEM;
    96.     }
    97.      vir_led3=vir_led1;
    98.     vir_rcc=ioremap(PHY_RCC_ADDR,4);
    99.     if(vir_rcc==NULL)
    100.     {
    101.         printk("ioremap filed：%d\n",__LINE__);
    102.         return -ENOMEM;
    103.     }
    104.     printk("物理地址映射成功\n");
    105.     //寄存器的初始化
    106.     //rcc
    107.     (*vir_rcc) |= (3<<4);
    108.     //led1
    109.     vir_led1->MODER &= (~(3<<20));
    110.     vir_led1->MODER |= (1<<20);
    111.     vir_led1->ODR &= (~(1<<10));
    112.     //led2
    113.     vir_led2->MODER &= (~(3<<20));
    114.     vir_led2->MODER |= (1<<20);
    115.     vir_led2->ODR &= (~(1<<10));
    116.     //led3
    117.     vir_led3->MODER &= (~(3<<16));
    118.     vir_led1->MODER |= (1<<16);
    119.     vir_led1->ODR &= (~(1<<8));
    120.     printk("寄存器初始化成功\n");
    121.  
    122.     return 0;
    123. }
    124.  
    125. static int __init mycdev_init(void)
    126. {
    127.     //字符设备驱动注册
    128.     major=register_chrdev(0,"mychrdev",&fops);
    129.     if(major<0)
    130.     {
    131.         printk("字符设备驱动注册失败\n");
    132.         return major;
    133.     }
    134.     printk("字符设备驱动注册成功:major=%d\n",major);
    135.  
    136.     //寄存器映射以及初始化
    137.     all_led_init();
    138.  
    139.     return 0;
    140. }
    141. static void __exit mycdev_exit(void)
    142. {
    143.     //取消地址映射
    144.     iounmap(vir_led1);
    145.     iounmap(vir_led2);
    146.     iounmap(vir_rcc);
    147.     //注销字符设备驱动
    148.     unregister_chrdev(major,"mychrdev");
    149.  
    150.  
    151. }
    152. module_init(mycdev_init);
    153. module_exit(mycdev_exit);
    154. MODULE_LICENSE("GPL");
    应用程序：
    1. #include
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6. #include
    7. #include
    8.  
    9. int main(int argc, char const *argv[])
    10. {
    11.     char buf[128]={0};
    12.     int fd=open("/dev/mychrdev",O_RDWR);
    13.     if(fd<0)
    14.     {
    15.         printf("打开设备文件失败\n");
    16.         exit(-1);
    17.     }
    18.     while(1)
    19.     {
    20.         //从终端读取
    21.         printf("请输入两个字符\n");
    22.         printf("第一个字符:1(LED1) 2(LED2) 3(LED3)\n");
    23.         printf("第二个字符:0(关灯) 1(开灯)\n");
    24.         printf("请输入>");
    25.         fgets(buf,sizeof(buf),stdin);
    26.         buf[strlen(buf)-1]='\0';
    27.         //向设备文件中写
    28.         write(fd,buf,sizeof(buf));
    29.     }
    30.  
    31.     close(fd);
    32.     return 0;
    33. }

    二、自动创建设备节点

    1.创建设备节点的机制

    • mknod:手动创建设备节点的命令
    • devfs:linux早期创建设备节点的机制，如今由于各自原因不再使用，它创建设备节点的逻辑存在于内核空间（2.4版本之前）
    • udev机制：目前使用的自动创建设备节点的机制，创建设备节点的逻辑是在用户空间（2.6版本）
    • mdev机制：可以将mdev理解为轻量级的udev,mdev主要应用于一些嵌入式系统中

    2.udev创建设备节点的原理

    3.创建设备节点的相关API

    1. **************创建设备文件相关**********
    2. #include
    3. 1.向上提交目录
    4. struct class *class_create(struct module *owner, const char *name)
    5. 功能：向上提交目录信息，申请了一个struct class对象并初始化
    6. 参数：
    7.     owner:指向当前模块自身的一个指针，填写THIS_MODULE
    8.     name:向上提交的目录名
    9. 返回值：成功返回申请到的class对象的首地址，失败返回一个指向内核顶层4K空间的指针
    10.     /* 
    11.         关关于返回值判断问题：
    12.         只要判断指针的数值>4K预留空间起始值就说明函数调用失败
    13.         bool __must_check IS_ERR(__force const void *ptr)
    14.                 //#define IS_ERR_VALUE(x) (unsigned long)(void *)(x) >= 0XFFFFFFF-4095
    15.     功能：判断指针是否指向内核4K预留空间，如果指针指向4K预留空间返回真，否则返回假
    16.         long __must_check PTR_ERR(__force const void *ptr)
    17.            功能：将一个指针转换成long类型错误码返回
    18.     */
    19.     
    20. ex:
    21.         struct class *cls=class_create(THIS_MODULE,"mychrdev");
    22.         if(IS_ERR(cls))
    23.         {
    24.             printk("向上提交目录失败\n");
    25.             return -PTR_ERR(cls);        
    26.         }
    27.  
    28. 2.向上提交设备节点信息
    29. struct device *device_create(struct class *class, struct device *parent,
    30.                  dev_t devt, void *drvdata, const char *fmt, ...)
    31. 功能：向上提交设备节点信息，申请一个struct  device对象并初始化
    32. 参数：
    33.     class:class_create()得到的对象指针
    34.     parent:父节点指针，不知道就填NULL
    35.     devt:设备号    主设备号<<20|次设备号
    36.         /*
    37.             MKDEV(主设备号，次设备号)：根据主设备号和次设备号得到设备号
    38.             MAJOR(dev)：根据设备号得到主设备号
    39.             MINOR(dev)：根据设备号得到次设备号
    40.         */
    41.         drvdata:当前对象的一个私有数据，填NULL
    42.         fmt:填要创建的设备节点名  video%d
    43.         ...:不定长参数       i
    44. 返回值：成功返回创建成功的struct device对象指针，失败返回指针指向4K预留空间
    45. ************删除设备文件相关**********
    46. 销毁节点信息：
    47. void device_destroy(struct class *class, dev_t devt)
    48. 功能：销毁节点信息
    49. 参数：
    50.     class:class_create()得到的对象指针
    51.     devt:向上提交设备节点是填写的设备号
    52. 销毁目录
    53. void class_destroy(struct class *cls)
    54. 参数：class_create()得到的对象指针
    55. 返回值：无

    4.实例

    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) |= (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.     cls=class_create(THIS_MODULE,"mychrdev");
    140.     if(IS_ERR(cls))
    141.     {
    142.         printk("向上提交目录失败\n");
    143.         return -PTR_ERR(cls);
    144.     }
    145.     printk("向上提交目录成功\n");
    146.     //向上提交设备节点信息
    147.     int i;//向上提交三次设备节点信息
    148.     for(i=0;i<3;i++)
    149.     {
    150.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    151.         if(IS_ERR(dev))
    152.         {
    153.             printk("向上提交设备节点失败\n");
    154.             return -PTR_ERR(dev);
    155.         }
    156.     }
    157.     printk("向上提交设备节点成功\n");
    158.  
    159.     //寄存器映射以及初始化
    160.     all_led_init();
    161.  
    162.     return 0;
    163. }
    164. static void __exit mycdev_exit(void)
    165. {
    166.     //取消地址映射
    167.     iounmap(vir_led1);
    168.     iounmap(vir_led2);
    169.     iounmap(vir_rcc);
    170.     //销毁设备节点信息
    171.     int i;
    172.     for(i=0;i<3;i++)
    173.     {
    174.         device_destroy(cls,MKDEV(major,i));
    175.     }
    176.  
    177.     //销毁目录
    178.     class_destroy(cls);
    179.     //注销字符设备驱动
    180.     unregister_chrdev(major,"mychrdev");
    181. }
    182. module_init(mycdev_init);
    183. module_exit(mycdev_exit);
    184. MODULE_LICENSE("GPL");

    三、ioctl函数的使用

    1.引入ioctl函数的意义

    linux操作系统中有意将数据的读写和读写功能的选择分别交给不同的函数去完成。就让read/write函数只进行数据的读写即可，让一些其他功能的设置和选择交给ioctl函数来实现。比如，串口通信时，需要设置波特率，需要设置数据格式，也需要最终选择数据收发，让这些都由ioctl函数来完成。让read()write()只进行串口数据收发即可。

    2.ioctl函数的分析

    1. *********系统调用函数的分析**********
    2. #include 
    3. int ioctl(int fd, unsigned long request, ...);
    4. 功能：进行io功能的设置   
    5. 参数：
    6. fd:文件描述符
    7. request:io控制的功能码
    8. ...:可以加，也可以不加。如果第三个参数传递数值，只能传递整型数据和指针
    9. 返回值：成功返回0，失败返回错误码
    10.  
    11. *********驱动中操作方法的分析********
    12. long (*unlocked_ioctl) (struct file *file, unsigned int cmd, unsigned long arg)
    13. {
    14.     参数分析：
    15.         file:文件指针
    16.         cmd:应用程序中的ioctl第二个参数传递过来
    17.         arg:应用程序中的ioctl第三个参数传递过来
    18. }

    3.ioctl功能码的构建

    为了让实现不同功能的功能码尽量不一样，我们对功能码进行了编码

    查询内核的说明手册：~/linux-5.10.61/Documentation/userspace-api/ioctl

    vi ioctl-decoding.rst//功能码的编码说明文档

    1. ====== ==================================
    2.  bits   meaning
    3.  ====== ==================================
    4.  31-30    00 - no parameters: uses _IO macro
    5.     10 - read: _IOR
    6.     01 - write: _IOW
    7.     11 - read/write: _IOWR
    8.  
    9.  29-16    size of arguments
    10.  
    11.  15-8    ascii character supposedly
    12.     unique to each driver
    13.  
    14.  7-0    function #
    15.  ====== ==================================

    1. #define _IO(type,nr)        _IOC(_IOC_NONE,(type),(nr),0)
    2. #define _IOR(type,nr,size)    _IOC(_IOC_READ,(type),(nr),sizeof(size))
    3. #define _IOW(type,nr,size)    _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
    4. #define _IOWR(type,nr,size)    _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size)
    5.  
    6. #define _IOC(dir,type,nr,size)          \
    7.     ((unsigned int)             \
    8.      (((dir)  << _IOC_DIRSHIFT) |       \
    9.       ((type) << _IOC_TYPESHIFT) |      \
    10.       ((nr)   << _IOC_NRSHIFT) |        \
    11.       ((size) << _IOC_SIZESHIFT)))
    12.       
    13.     ex：构建LED开关的功能码：ioctl函数无第三个参数
    14.     开灯  #define  LED_ON  _IO('l',1)
    15.     关灯  #define  LED_OFF  _IO('l',0)
    16.     
    17.         ex：构建LED开关的功能码：ioctl函数有第三个参数
    18.     开灯  #define  LED_ON  _IOW('l',1,int)
    19.     关灯  #define  LED_OFF  _IOW('l',0,int)

    4.ioctl实例----不传递第三个参数

    头文件:
    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3. typedef struct
    4. {
    5.     unsigned int MODER;
    6.     unsigned int OTYPER;
    7.     unsigned int OSPEEDR;
    8.     unsigned int PUPDR;
    9.     unsigned int IDR;
    10.     unsigned int ODR;
    11. } gpio_t;
    12. #define PHY_LED1_ADDR 0X50006000
    13. #define PHY_LED2_ADDR 0X50007000
    14. #define PHY_LED3_ADDR 0X50006000
    15. #define PHY_RCC_ADDR 0X50000A28
    16. // 构建开灯关灯的功能码
    17. #define LED_ON _IO('l', 1)
    18. #define LED_OFF _IO('l', 0)
    19. #endif
    驱动程序：
    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. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    22. {
    23.     switch (cmd)
    24.     {
    25.     case LED_ON: // 开灯
    26.         vir_led1->ODR |= (0X1 << 10);
    27.         vir_led2->ODR |= (0X1 << 10);
    28.         vir_led3->ODR |= (0X1 << 8);
    29.         break;
    30.     case LED_OFF: // 关灯
    31.         vir_led1->ODR &= (~(0X1 << 10));
    32.         vir_led2->ODR &= (~(0X1 << 10));
    33.         vir_led3->ODR &= (~(0X1 << 8));
    34.         break;
    35.     }
    36.     return 0;
    37. }
    38. int mycdev_close(struct inode *inode, struct file *file)
    39. {
    40.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    41.     return 0;
    42. }
    43.  
    44. // 定义操作方法结构体变量并赋值
    45. struct file_operations fops = {
    46.  
    47.     .open = mycdev_open,
    48.     .unlocked_ioctl = mycdev_ioctl,
    49.     .release = mycdev_close,
    50. };
    51.  
    52. int all_led_init(void)
    53. {
    54.     // 寄存器地址的映射
    55.     vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    56.     if (vir_led1 == NULL)
    57.     {
    58.         printk("ioremap filed：%d\n", __LINE__);
    59.         return -ENOMEM;
    60.     }
    61.     vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    62.     if (vir_led2 == NULL)
    63.     {
    64.         printk("ioremap filed：%d\n", __LINE__);
    65.         return -ENOMEM;
    66.     }
    67.     vir_led3 = vir_led1;
    68.     vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    69.     if (vir_rcc == NULL)
    70.     {
    71.         printk("ioremap filed：%d\n", __LINE__);
    72.         return -ENOMEM;
    73.     }
    74.     printk("物理地址映射成功\n");
    75.     // 寄存器的初始化
    76.     // rcc
    77.     (*vir_rcc) |= (3 << 4);
    78.     // led1
    79.     vir_led1->MODER &= (~(3 << 20));
    80.     vir_led1->MODER |= (1 << 20);
    81.     vir_led1->ODR &= (~(1 << 10));
    82.     // led2
    83.     vir_led2->MODER &= (~(3 << 20));
    84.     vir_led2->MODER |= (1 << 20);
    85.     vir_led2->ODR &= (~(1 << 10));
    86.     // led3
    87.     vir_led3->MODER &= (~(3 << 16));
    88.     vir_led1->MODER |= (1 << 16);
    89.     vir_led1->ODR &= (~(1 << 8));
    90.     printk("寄存器初始化成功\n");
    91.  
    92.     return 0;
    93. }
    94.  
    95. static int __init mycdev_init(void)
    96. {
    97.     // 字符设备驱动注册
    98.     major = register_chrdev(0, "mychrdev", &fops);
    99.     if (major < 0)
    100.     {
    101.         printk("字符设备驱动注册失败\n");
    102.         return major;
    103.     }
    104.     printk("字符设备驱动注册成功:major=%d\n", major);
    105.     // 向上提交目录
    106.     cls = class_create(THIS_MODULE, "mychrdev");
    107.     if (IS_ERR(cls))
    108.     {
    109.         printk("向上提交目录失败\n");
    110.         return -PTR_ERR(cls);
    111.     }
    112.     printk("向上提交目录成功\n");
    113.     // 向上提交设备节点信息
    114.     int i; // 向上提交三次设备节点信息
    115.     for (i = 0; i < 3; i++)
    116.     {
    117.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
    118.         if (IS_ERR(dev))
    119.         {
    120.             printk("向上提交设备节点失败\n");
    121.             return -PTR_ERR(dev);
    122.         }
    123.     }
    124.     printk("向上提交设备节点成功\n");
    125.  
    126.     // 寄存器映射以及初始化
    127.     all_led_init();
    128.  
    129.     return 0;
    130. }
    131. static void __exit mycdev_exit(void)
    132. {
    133.     // 取消地址映射
    134.     iounmap(vir_led1);
    135.     iounmap(vir_led2);
    136.     iounmap(vir_rcc);
    137.     // 销毁设备节点信息
    138.     int i;
    139.     for (i = 0; i < 3; i++)
    140.     {
    141.         device_destroy(cls, MKDEV(major, i));
    142.     }
    143.  
    144.     // 销毁目录
    145.     class_destroy(cls);
    146.     // 注销字符设备驱动
    147.     unregister_chrdev(major, "mychrdev");
    148. }
    149. module_init(mycdev_init);
    150. module_exit(mycdev_exit);
    151. MODULE_LICENSE("GPL");
    应用程序：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include "head.h"
    10.  
    11. int main(int argc, char const *argv[])
    12. {
    13.     char buf[128] = {0};
    14.     int a;
    15.     int fd = open("/dev/myled0", O_RDWR);
    16.     if (fd < 0)
    17.     {
    18.         printf("打开设备文件失败\n");
    19.         exit(-1);
    20.     }
    21.     while (1)
    22.     {
    23.         // 从终端读取
    24.         printf("请输入要实现的功能 ");
    25.         printf("0(关灯) 1(开灯)\n");
    26.         printf("请输入>>>");
    27.         scanf("%d", &a);
    28.         switch (a)
    29.         {
    30.         case 1:
    31.             ioctl(fd, LED_ON);
    32.             break;
    33.         case 0:
    34.             ioctl(fd, LED_OFF);
    35.             break;
    36.         }
    37.     }
    38.     close(fd);
    39.     return 0;
    40. }

    5.ioctl实例----传递第三个参数（传递整型）

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

    6.ioctl实例----传递第三个参数（传递地址）

    头文件：
    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3. typedef struct
    4. {
    5.     unsigned int MODER;
    6.     unsigned int OTYPER;
    7.     unsigned int OSPEEDR;
    8.     unsigned int PUPDR;
    9.     unsigned int IDR;
    10.     unsigned int ODR;
    11. } gpio_t;
    12. #define PHY_LED1_ADDR 0X50006000
    13. #define PHY_LED2_ADDR 0X50007000
    14. #define PHY_LED3_ADDR 0X50006000
    15. #define PHY_RCC_ADDR 0X50000A28
    16. // 构建开灯关灯的功能码
    17. #define LED_ON _IOW('l', 1,int)
    18. #define LED_OFF _IOW('l', 0,int)
    19.  
    20. #endif
    驱动程序：
    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. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    22. {
    23.     int which;
    24.     //获取应用程序中b的值
    25.     int ret= copy_from_user(&which,(void *)arg,4);
    26.     if(ret)
    27.     {
    28.         printk("copy_from_user filed\n");
    29.         return-EIO;
    30.     }
    31.     switch (cmd)
    32.     {
    33.     case LED_ON: // 开灯
    34.         switch (which)
    35.         {
    36.         case 1: // LED1
    37.             vir_led1->ODR |= (0X1 << 10);
    38.             break;
    39.         case 2:
    40.             vir_led2->ODR |= (0X1 << 10);
    41.             break;
    42.         case 3:
    43.             vir_led3->ODR |= (0X1 << 8);
    44.             break;
    45.         }
    46.         break;
    47.     case LED_OFF: // 关灯
    48.           switch (which)
    49.         {
    50.         case 1: // LED1
    51.             vir_led1->ODR &= (~(0X1 << 10));
    52.             break;
    53.         case 2:
    54.             vir_led2->ODR &= (~(0X1 << 10));
    55.             break;
    56.         case 3:
    57.             vir_led3->ODR &= (~(0X1 << 8));
    58.             break;
    59.         } 
    60.         break;
    61.     }
    62.     return 0;
    63. }
    64. int mycdev_close(struct inode *inode, struct file *file)
    65. {
    66.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    67.     return 0;
    68. }
    69.  
    70. // 定义操作方法结构体变量并赋值
    71. struct file_operations fops = {
    72.  
    73.     .open = mycdev_open,
    74.     .unlocked_ioctl = mycdev_ioctl,
    75.     .release = mycdev_close,
    76. };
    77.  
    78. int all_led_init(void)
    79. {
    80.     // 寄存器地址的映射
    81.     vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    82.     if (vir_led1 == NULL)
    83.     {
    84.         printk("ioremap filed：%d\n", __LINE__);
    85.         return -ENOMEM;
    86.     }
    87.     vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    88.     if (vir_led2 == NULL)
    89.     {
    90.         printk("ioremap filed：%d\n", __LINE__);
    91.         return -ENOMEM;
    92.     }
    93.     vir_led3 = vir_led1;
    94.     vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    95.     if (vir_rcc == NULL)
    96.     {
    97.         printk("ioremap filed：%d\n", __LINE__);
    98.         return -ENOMEM;
    99.     }
    100.     printk("物理地址映射成功\n");
    101.     // 寄存器的初始化
    102.     // rcc
    103.     (*vir_rcc) |= (3 << 4);
    104.     // led1
    105.     vir_led1->MODER &= (~(3 << 20));
    106.     vir_led1->MODER |= (1 << 20);
    107.     vir_led1->ODR &= (~(1 << 10));
    108.     // led2
    109.     vir_led2->MODER &= (~(3 << 20));
    110.     vir_led2->MODER |= (1 << 20);
    111.     vir_led2->ODR &= (~(1 << 10));
    112.     // led3
    113.     vir_led3->MODER &= (~(3 << 16));
    114.     vir_led1->MODER |= (1 << 16);
    115.     vir_led1->ODR &= (~(1 << 8));
    116.     printk("寄存器初始化成功\n");
    117.  
    118.     return 0;
    119. }
    120.  
    121. static int __init mycdev_init(void)
    122. {
    123.     // 字符设备驱动注册
    124.     major = register_chrdev(0, "mychrdev", &fops);
    125.     if (major < 0)
    126.     {
    127.         printk("字符设备驱动注册失败\n");
    128.         return major;
    129.     }
    130.     printk("字符设备驱动注册成功:major=%d\n", major);
    131.     // 向上提交目录
    132.     cls = class_create(THIS_MODULE, "mychrdev");
    133.     if (IS_ERR(cls))
    134.     {
    135.         printk("向上提交目录失败\n");
    136.         return -PTR_ERR(cls);
    137.     }
    138.     printk("向上提交目录成功\n");
    139.     // 向上提交设备节点信息
    140.     int i; // 向上提交三次设备节点信息
    141.     for (i = 0; i < 3; i++)
    142.     {
    143.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
    144.         if (IS_ERR(dev))
    145.         {
    146.             printk("向上提交设备节点失败\n");
    147.             return -PTR_ERR(dev);
    148.         }
    149.     }
    150.     printk("向上提交设备节点成功\n");
    151.  
    152.     // 寄存器映射以及初始化
    153.     all_led_init();
    154.  
    155.     return 0;
    156. }
    157. static void __exit mycdev_exit(void)
    158. {
    159.     // 取消地址映射
    160.     iounmap(vir_led1);
    161.     iounmap(vir_led2);
    162.     iounmap(vir_rcc);
    163.     // 销毁设备节点信息
    164.     int i;
    165.     for (i = 0; i < 3; i++)
    166.     {
    167.         device_destroy(cls, MKDEV(major, i));
    168.     }
    169.  
    170.     // 销毁目录
    171.     class_destroy(cls);
    172.     // 注销字符设备驱动
    173.     unregister_chrdev(major, "mychrdev");
    174. }
    175. module_init(mycdev_init);
    176. module_exit(mycdev_exit);
    177. MODULE_LICENSE("GPL");
    应用程序：
    1. #include
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include
    8. #include
    9. #include "head.h"
    10.  
    11. int main(int argc, char const *argv[])
    12. {
    13.     char buf[128]={0};
    14.     int a,b;
    15.     int fd=open("/dev/myled0",O_RDWR);
    16.     if(fd<0)
    17.     {
    18.         printf("打开设备文件失败\n");
    19.         exit(-1);
    20.     }
    21.     while(1)
    22.     {
    23.         //从终端读取
    24.         printf("请输入要实现的功能 ");
    25.         printf("0(关灯) 1(开灯)\n");
    26.         printf("请输入>");
    27.         scanf("%d",&a);
    28.         printf("请选择要控制的灯：1（LED1）2(LED2) 3(LED3)\n");
    29.         printf("请输入>");
    30.         scanf("%d",&b);
    31.         switch(a)
    32.         {
    33.             case 1:
    34.                 ioctl(fd,LED_ON,&b);
    35.                 break;
    36.             case 0:
    37.                 ioctl(fd,LED_OFF,&b);
    38.                 break;
    39.         }
    40.     }
    41.  
    42.     close(fd);
    43.     return 0;
    44. }
  • 相关阅读:
    Git学习笔记（四）远程仓库
    DocCMS keyword SQL注入
    2334. 元素值大于变化阈值的子数组-单调栈法和暴力求解法
    【Spring】Spring MVC
    DataX二次开发——（9）新增s3reader和s3writer模块
    【注解和反射】获取类运行时结构
    06-集合
    机器人中的数值优化|【三】无约束优化，拟牛顿法，共轭梯度法理论与推导
    openGauss/MogDB脚本源码浅析（2）—— gs_install_plugin/gs_install_plugin_local
    目标检测（4）—— 经典算法和常用指标
  • 原文地址：https://blog.csdn.net/m0_68542867/article/details/133977628