• 内核驱动模块分布编译

    内核驱动模块代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include "fsmp157a_led_head.h"
    11.  
    12. unsigned int *vir_gpioe_moder;
    13. unsigned int *vir_gpioe_odr;
    14. unsigned int *vir_gpiof_moder;
    15. unsigned int *vir_gpiof_odr;
    16. unsigned int *vir_rcc;
    17.  
    18. char kbuf[128] = "";
    19. //封装操作方法
    20. //int (*open) (struct inode *, struct file *);
    21. //ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    22. //ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    23. //int (*release) (struct inode *, struct file *);
    24. //long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    25.  
    26. int mycdev_open(struct inode *inode, struct file *file)
    27. {
    28.     int min = MINOR(inode->i_rdev);
    29.     file->private_data = (void *)min;
    30.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    31.     return 0;
    32. }
    33.  
    34. ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
    35. {
    36.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    37.     return 0;
    38. }
    39.  
    40. ssize_t mycdev_write(struct file *fiile,const char *ubuf, size_t size, loff_t *lof)
    41. {
    42.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    43.    
    44.     int ret;
    45.     //将用户空间的数据传递到内核
    46.     ret = copy_from_user(kbuf, ubuf, size);
    47.     if(ret)
    48.     {
    49.         printk("copy_from_user is filed\n");
    50.         return -EIO;
    51.     }
    52.     /*
    53.     switch(kbuf[0])
    54.     {
    56.         //LED1
    57.         case '1':
    58.             switch(kbuf[1])
    59.             {
    60.                 case '0':
    61.                     //关灯逻辑
    62.                     (*vir_gpioe_odr) &= (~(0x1 << 10));
    63.                     break;
    64.                 case '1':
    65.                     //开灯逻辑
    66.                     (*vir_gpioe_odr) |= (0x1 << 10);
    67.                     break;
    68.             }
    69.             break;
    70.         //LED2
    71.         case '2':
    72.             switch(kbuf[1])
    73.             {
    74.                 case '0':
    75.                     //关灯逻辑
    76.                     (*vir_gpiof_odr) &= (~(0x1 << 10));
    77.                     break;
    78.                 case '1':
    79.                     //开灯逻辑
    80.                     (*vir_gpiof_odr) |= (0x1 << 10);
    81.                     break;
    82.             }
    83.             break;
    84.         //LED3
    85.          case '3':
    86.             switch(kbuf[1])
    87.             {
    88.                 case '0':
    89.                     //关灯逻辑
    90.                     (*vir_gpioe_odr) &= (~(0x1 << 8));
    91.                     break;
    92.                 case '1':
    93.                     //开灯逻辑
    94.                     (*vir_gpioe_odr) |= (0x1 << 8);
    95.                     break;
    96.             }
    97.             break;
    98.     }
    99.     */
    100.     return 0;
    101. }
    102.  
    103. int mycdev_close(struct inode *inode, struct file *file)
    104. {
    105.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    106.     return 0;
    107. }
    108. //long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    109. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    110. {
    111.     // int which;
    112.     // int ret;
    113.     // ret = copy_from_user(&which , (void *) arg, 4);
    114.     // if(ret)
    115.     // {
    116.     //     printk("copy_from_user is filed\n");
    117.     //     return -EIO;
    118.     // }
    119.     int min = (int)file->private_data;
    120.     switch(min)
    121.     {
    122.         case 0:
    123.             switch(cmd)
    124.             {
    125.                 case LED_OFF:
    126.                 (*vir_gpioe_odr) &= (~(0x1 << 10));
    127.                 break;
    128.                 case LED_ON:
    129.                 (*vir_gpioe_odr) |= (0x1 << 10);
    130.                 break;
    131.             }
    132.             break;
    133.         case 1:
    134.             switch(cmd)
    135.             {
    136.                 case LED_OFF:
    137.                     (*vir_gpiof_odr) &= (~(0x1 << 10));
    138.                     break;
    139.                 case LED_ON:
    140.                     (*vir_gpiof_odr) |= (0x1 << 10);
    141.                     break;
    142.             }
    143.             break;
    144.         case 2:
    145.             switch(cmd)
    146.             {
    147.                 case LED_OFF:
    148.                 (*vir_gpioe_odr) &= (~(0x1 << 8));
    149.                 break;
    150.                 case LED_ON:
    151.                 (*vir_gpioe_odr) |= (0x1 << 8);
    152.                 break;
    153.             }
    154.             break;
    155.     }
    156.    
    157.     return 0;
    158. }
    159. //定义一个操作方法结构体对象
    160. struct file_operations fos = {
    161.     .open = mycdev_open,
    162.     .read = mycdev_read,
    163.     .write = mycdev_write,
    164.     .release = mycdev_close,
    165.     .unlocked_ioctl = mycdev_ioctl,
    166.  
    167. };
    168.  
    169. //定义变量，存放major
    170. unsigned int major;
    171. //定义变量，接收class_create()函数得到的对象指针
    172. struct class *cls;
    173. //定义变量，接收device_create()函数得到的对象指针
    174. struct device *dev;
    175.  
    176. //定义变量，主设备号，次设备号
    177. unsigned int major=0;
    178. unsigned int minor=0;
    179. //定义变量，设备号
    180. dev_t devnum;
    181. //定义变量，存放申请类对象空间的首地址
    182. struct cdev *cdev;
    183. //定义变量，接收返回值
    184. int ret;
    185. //int __register_file(struct cdev *cdev, dev_t devnum, unsigned int major, unsigned int minor, struct class *cls, struct device *dev, struct file_operations *fos);
    186. int __register_file(void);
    187. //入口函数
    188. static int __init mycdev_init(void)
    189. {
    190.     // __register_file(cdev, devnum, major,  minor, cls, dev, &fos);
    191.     __register_file();
    192.     /*
    193.     //注册设备驱动，申请0-255共256个资源（次设备号）
    194.     major = register_chrdev(0, "mychardev", &fos);
    195.     if(major < 0)
    196.     {
    197.         printk("注册设备驱动失败\n");
    198.         return major;
    199.     }
    200.     printk("注册设备驱动成功:major = %d\n", major);
    201.     
    202.     //向上提供目录
    203.     //函数原型struct class *class_create(owner, name);
    204.     //功能：向上提供目录信息，申请一个struct class类对象空间并初始化
    205.     //参数1：owner：指向当前模块自身的一个指针，填写THIS_MODULE
    206.     //参数2：name:向上提交的目录名
    207.     //返回值：成功返回申请到的class对象的首地址，失败返回一个指向内核顶层4k空间的指针
    208.     cls = class_create(THIS_MODULE, "mychrdev");
    209.     if(IS_ERR(cls))
    210.     {
    211.         printk("向上提供目录失败\n");
    212.         return -PTR_ERR(cls);
    213.     }
    214.     printk("向上提供目录成功\n");
    215.     //向上提供设备节点信息
    216.     //函数原型struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);
    217.     int i;
    218.     for(i=0; i<3; i++)
    219.     {
    220.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
    221.         if(IS_ERR(dev))
    222.         {
    223.             printk("向上提供设备节点信息失败\n");
    224.             return -PTR_ERR(dev);
    225.         }
    226.     }
    227.     printk("向上提供设备节点信息成功\n");
    228.     */
    229.    
    230.     //物理内存映射到虚拟地址
    231.     //GOIOE_MODER寄存器地址映射
    232.     vir_gpioe_moder = ioremap(PHY_GPIOE_MODER, 4);
    233.     if(NULL == vir_gpioe_moder)
    234.     {
    235.         printk("物理内存地址映射失败%d\n", __LINE__);
    236.         return -EFAULT;
    237.     }
    238.     //GOIOE_ODR寄存器地址映射
    239.     vir_gpioe_odr = ioremap(PHY_GPIOE_ODR, 4);
    240.     if(NULL == vir_gpioe_odr)
    241.     {
    242.         printk("物理内存地址映射失败%d\n", __LINE__);
    243.         return -EFAULT;
    244.     }
    245.     //GOIOF_MODER寄存器地址映射
    246.     vir_gpiof_moder = ioremap(PHY_GPIOF_MODER, 4);
    247.     if(NULL == vir_gpiof_moder)
    248.     {
    249.         printk("物理内存地址映射失败%d\n", __LINE__);
    250.         return -EFAULT;
    251.     }
    252.     //GOIOF_ODR寄存器地址映射
    253.     vir_gpiof_odr = ioremap(PHY_GPIOF_ODR, 4);
    254.     if(NULL == vir_gpiof_odr)
    255.     {
    256.         printk("物理内存地址映射失败%d\n", __LINE__);
    257.         return -EFAULT;
    258.     }
    259.     //RCC_AHB4ENSETR寄存器地址映射
    260.     vir_rcc = ioremap(PHY_RCC, 4);
    261.     if(NULL == vir_rcc)
    262.     {
    263.         printk("物理内存地址映射失败%d\n", __LINE__);
    264.         return -EFAULT;
    265.     }
    266.     printk("物理内存地址映射成功\n");
    267.     //寄存器初始化工作
    268.     //RCC使能GPIOE/GPIOF组控制器
    269.     (*vir_rcc) |= (0x3 << 4);
    270.  
    271.       
    272.     
    273.     return 0;
    274. }
    275.  
    276. //出口函数
    277. static void __exit mycdev_exit(void)
    278. {
    279.     
    280.     //取消内存映射
    281.     iounmap(vir_gpioe_moder);
    282.     iounmap(vir_gpioe_odr);
    283.  
    284.     iounmap(vir_gpiof_moder);
    285.     iounmap(vir_gpiof_odr);
    286.  
    287.     iounmap(vir_rcc);
    288.     
    289.    //销毁设备节点信息
    290.    int i;
    291.    for(i=0; i<3; i++)
    292.    {
    293.         device_destroy(cls, MKDEV(major, i));
    294.    }
    295.    
    296.    //删除目录信息
    297.    class_destroy(cls);
    298.  
    299.     //注销字符设备驱动对象
    300.     cdev_del(cdev);
    301.     //释放设备号
    302.     unregister_chrdev_region(MKDEV(major, major), 3);
    303.     //释放申请到的字符设备驱动对象空间
    304.     kfree(cdev);
    305.    //删除信息
    306.  
    307.     // //销毁设备节点信息
    308.     // int i;
    309.     // for(i=0; i<3; i++)
    310.     // {
    311.     //     device_destroy(cls, MKDEV(major, i));
    312.     // }
    313.  
    314.     // //销毁目录信息
    315.     // class_destroy(cls);
    316.     // //注销字符设备驱动
    317.     // unregister_chrdev(major, "mychrdev");
    318.  
    319. }
    320. //声明入口函数
    321. module_init(mycdev_init);
    322. //声明出口函数
    323. module_exit(mycdev_exit);
    324. //声明内核模块遵循GPL协议
    325. MODULE_LICENSE("GPL");
    326.  
    327. //注册设备驱动，创建设备文件
    328. //int __register_file(struct cdev *cdev, dev_t devnum, unsigned int major, unsigned int minor, struct class *cls, struct device *dev, struct file_operations *fos)
    329. int __register_file(void)
    330. {
    331.     //1.申请字符设备驱动对象空间
    332.     cdev = cdev_alloc();
    333.     if(NULL == cdev)
    334.     {
    335.         printk("申请字符设备驱动对象空间失败\n");
    336.         goto out1;
    337.     }
    338.     printk("申请字符设备驱动成功\n");
    339.     //2.初始化对象 
    340.     //函数原型： cdev_init(struct cdev *, const struct file_operations *);
    341.     cdev_init(cdev, &fos);
    342.     //3.申请设备号
    343.     if(0 == major)
    344.     {
    345.         ret = alloc_chrdev_region(&devnum, minor, 3, "mychrdev");
    346.         if(ret)
    347.         {
    348.             printk("申请设备号失败\n");
    349.             goto out2;
    350.         }
    351.         major = MAJOR(devnum);
    352.         minor = MINOR(devnum);
    353.         printk("动态申请设备号成功\n");
    354.     }
    355.     else
    356.     {
    357.         ret = register_chrdev_region(MKDEV(major, minor), 3, "mychrdev");
    358.         if(ret)
    359.         {
    360.             printk("申请设备号失败\n");
    361.             goto out2;
    362.         }
    363.         printk("静态申请设备号成功\n");
    364.     }
    365.     
    366.     //4.注册设备驱动到内核
    367.     ret = cdev_add(cdev, MKDEV(major, minor), 3);
    368.     if(ret)
    369.     {
    370.         printk("注册设备驱动到内核失败\n");
    371.         goto out3;
    372.     }
    373.      printk("注册设备驱动到内核成功\n");
    374.     //5.向上提交目录信息
    375.     cls = class_create(THIS_MODULE, "mychrdev");
    376.     if(IS_ERR(cls))
    377.     {
    378.         printk("向上提交目录失败\n");
    379.         goto out4;
    380.     }
    381.     printk("向上提交目录成功\n");
    382.     //6.向上提交设备节点信息
    383.     int i;
    384.     for(i=0; i<3; i++)
    385.     {
    386.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "mychrdev%d", i);
    387.         if(IS_ERR(dev))
    388.         {
    389.             printk("向上提交设备节点信息失败\n");
    390.             goto out5;
    391.         }
    392.     }
    393.     printk("向上提交设备节点信息成功\n");
    394.     return 0;
    395.     out5:
    396.         //删除设备节点信息
    397.         for(--i; i>=0;  i--)
    398.         {
    399.             device_destroy(cls, MKDEV(major, i));
    400.             return -PTR_ERR(dev);
    401.         }
    402.         //删除设备目录
    403.         class_destroy(cls);
    404.         return -PTR_ERR(cls);
    405.     out4:
    406.         //注销设备驱动
    407.         cdev_del(cdev);
    408.     out3:
    409.         //释放设备号
    410.         unregister_chrdev_region(MKDEV(major, major), 3);
    411.     out2:
    412.         //释放字符设备驱动对象空间
    413.         kfree(cdev);
    414.     out1:
    415.         return ret;
    416. }

    应用层测试代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include "fsmp157a_led_head.h"
    8.  
    9. int main(int argc, char const *argv[])
    10. {
    11.     char buf[128] = "";
    12.     char filename[128] = "";
    13.     printf("请输入操作的设备文件\n");
    14.     fgets(filename, sizeof(filename), stdin);
    15.     filename[strlen(filename) - 1] = '\0';
    16.     int fd = open(filename, O_RDWR);
    17.     if(fd < 0)
    18.     {
    19.         printf("打开设备文件失败\n");
    20.         return -1;
    21.     }
    22.     printf("打开设备文件成功\n");
    23.     while(1)
    24.     {
    25.        while(1)
    26.        {
    27.             ioctl(fd, LED_ON);
    28.             sleep(1);
    29.             ioctl(fd, LED_OFF);
    30.             sleep(1);
    31.        }
    32.     }
    33.  
    34.     return 0;
    35. }

    头文件

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3.  
    4. //GPIOE_MODER寄存器地址
    5. #define PHY_GPIOE_MODER 0x50006000
    6. //GPIOE_ODR寄存器地址
    7. #define PHY_GPIOE_ODR 0X50006014
    8.  
    9. //GPIOF_MODER寄存器地址
    10. #define PHY_GPIOF_MODER 0X50007000
    11. //GPIOF_ODR寄存器地址
    12. #define PHY_GPIOF_ODR 0X50007014
    13.  
    14. //RCC_AHB4ENSETR寄存器地址
    15. #define PHY_RCC 0x50000A28
    16.  
    17. //构建开关等的功能码
    18. #define LED_ON _IO('l', 1)
    19. #define LED_OFF _IO('l', 0)
    20. #endif

  • 相关阅读:
    计算机毕设 SpringBoot+Vue校园博客系统 博客管理系统 开源博客系统 个人博客系统Java Vue MySQL数据库 远程调试 代码讲解
    gzip 压缩优化大 XML 响应的处理方法
    责任链模式
    通过Shell脚本自动安装Hive&JDBC测试&提供CDH5网盘地址
    爬虫入门教程：爬虫概述
    C语言学习笔记 —— 内存管理
    大模型高级 RAG 检索策略：自动合并检索
    流媒体技术优化
    传奇战盟GOM引擎登录器配置教程
    工具篇--分布式定时任务springBoot--elasticjob简单使用（1）
  • 原文地址：https://blog.csdn.net/qq_46766479/article/details/134000950