• 驱动开发2 CoetexA7核 字符设备驱动（LED亮灯）（单独映射寄存器实现+封装结构体映射实现）

    一、单独映射寄存器实现

    可参考arm点灯C语言 cortex-A7核 点LED灯 （附 汇编实现、使用C语言 循环实现、使用C语言 封装函数实现【重要、常用】）-CSDN博客

    1 应用程序 test.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. int main(int argc, char const *argv[])
    8. {
    9.     char buf[128]={0};
    10.     int fd = open("/dev/mychrdev",O_RDWR);
    11.     if(fd < 0)
    12.     {
    13.         printf("打开设备文件失败\n");
    14.         return -1;
    15.     }
    16.     printf("打开设备文件成功\n");   
    17.     while(1)
    18.     {
    19.         printf("请输入要进行的操作：0(关灯) 1(开灯) >>> ");
    20.         fgets(buf,sizeof(buf),stdin);//在终端读一个字符串
    21.         buf[strlen(buf) - 1] = '\0';
    22.         write(fd, buf, sizeof(buf));//将数据传递给内核
    23.     }
    24.     close(fd);
    25.     return 0;
    26. }

    2 头文件head.h

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3. //GPIOE
    4. #define PHY_LED1_MODER 0X50006000
    5. #define PHY_LED1_ODR 0x50006014
    6. //GPIOF
    7. #define PHY_LED2_MODER 0X50007000
    8. #define PHY_LED2_ODR 0x50007014
    9. //RCC
    10. #define PHY_RCC 0x50000A28
    11.  
    12. #endif

    3 驱动程序 demo.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include "head.h"
    7. unsigned int major;
    8. char kbuf[128] = {};
    9. //定义三个指针指向映射后的虚拟内存
    10. unsigned int *vir_moder_E;
    11. unsigned int *vir_odr_E;
    12. unsigned int *vir_moder_F;
    13. unsigned int *vir_odr_F;
    14. unsigned int *vir_rcc;
    15. //封装操作方法
    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.     int ret;
    25.     ret = copy_to_user(ubuf,kbuf,size);
    26.     if (ret)
    27.     {
    28.         printk("copy_to_user filed\n");
    29.         return -EIO;
    30.     }
    31.     return 0;
    32. }
    33. ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size,loff_t *lof)
    34. {
    35.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    36.     int ret;
    37.     ret = copy_from_user(kbuf,ubuf,size);
    38.     if (ret)
    39.     {
    40.         printk("copy_from_user filed\n");
    41.         return -EIO;
    42.     }
    43.     if(kbuf[0] == '0') //关灯
    44.     {
    45.         //关灯逻辑
    46.         (*vir_odr_E) &= (~(0x1 << 10)); //LED1默认关灯
    47.         (*vir_odr_F) &= (~(0x1 << 10)); //LED2默认关灯
    48.         (*vir_odr_E) &= (~(0x1 << 8)); //LED3默认关灯
    49.     }
    50.     else if(kbuf[0] == '1') //开灯
    51.     {
    52.         //开灯逻辑
    53.         (*vir_odr_E) |= (0x1 << 10); //LED1
    54.         (*vir_odr_F) |= (0x1 << 10); //LED2
    55.         (*vir_odr_E) |= (0x1 << 8); //LED3
    56.     }
    57.     return 0;
    58. }
    59. int mycdev_close(struct inode *inode, struct file *file)
    60. {
    61.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    62.     return 0;
    63. }
    64. //定义操作方法结构体对象
    65. struct file_operations fops = {
    66.     .open = mycdev_open,
    67.     .read = mycdev_read,
    68.     .write = mycdev_write,
    69.     .release = mycdev_close,
    70. };
    71. static int __init mycdev_init(void)
    72. {
    73.     //注册字符设备驱动
    74.     major = register_chrdev(0,"mychrdev",&fops);
    75.     if(major < 0)
    76.     {
    77.         printk("字符设备驱动注册失败\n");
    78.         return major;
    79.     }
    80.     printk("字符设备驱动注册成功major=%d\n",major);
    81.     //进行寄存器的地址映射
    82.     //GPIOE
    83.     vir_moder_E = ioremap(PHY_LED1_MODER,4);
    84.     if(vir_moder_E == NULL)
    85.     {
    86.         printk("物理内存地址映射失败%d\n",__LINE__);
    87.         return -EFAULT;
    88.     }
    89.     vir_odr_E = ioremap(PHY_LED1_ODR,4);
    90.     if(vir_odr_E == NULL)
    91.     {
    92.         printk("物理内存地址映射失败%d\n",__LINE__);
    93.         return -EFAULT;
    94.     }
    95.     //GPIOF
    96.     vir_moder_F = ioremap(PHY_LED2_MODER,4);
    97.     if(vir_moder_F == NULL)
    98.     {
    99.         printk("物理内存地址映射失败%d\n",__LINE__);
    100.         return -EFAULT;
    101.     }
    102.     vir_odr_F = ioremap(PHY_LED2_ODR,4);
    103.     if(vir_odr_F == NULL)
    104.     {
    105.         printk("物理内存地址映射失败%d\n",__LINE__);
    106.         return -EFAULT;
    107.     }
    108.     //RCC
    109.     vir_rcc = ioremap(PHY_RCC,4);
    110.     if(vir_rcc == NULL)
    111.     {
    112.         printk("物理内存地址映射失败%d\n",__LINE__);
    113.         return -EFAULT;
    114.     }
    115.     printk("寄存器内存映射成功\n");
    116.     //LED1寄存器初始化
    117.     (*vir_rcc) |= (0x1 << 4); //GPIOE控制器时钟使能
    118.     (*vir_moder_E) &= (~(0x3 << 20)); //MODER[21:20]->00
    119.     (*vir_moder_E) |= (0x1 << 20); //MODER[21:20]->01
    120.     (*vir_odr_E) &= (~(0x1 << 10)); //默认关灯
    121.     //LED2寄存器初始化
    122.     (*vir_rcc) |= (0x1 << 5); //GPIOF控制器时钟使能
    123.     (*vir_moder_F) &= (~(0x3 << 20)); //MODER[21:20]->00
    124.     (*vir_moder_F) |= (0x1 << 20); //MODER[21:20]->01
    125.     (*vir_odr_F) &= (~(0x1 << 10)); //默认关灯
    126.     //LED3寄存器初始化
    127.     (*vir_rcc) |= (0x1 << 4); //GPIOE控制器时钟使能
    128.     (*vir_moder_E) &= (~(0x3 << 16)); //MODER[17:16]->00
    129.     (*vir_moder_E) |= (0x1 << 16); //MODER[17:16]->01
    130.     (*vir_odr_E) &= (~(0x1 << 8)); //默认关灯
    131.     return 0;
    132. }
    133. static void __exit mycdev_exit(void)
    134. {
    135.     //取消内存映射
    136.     iounmap(vir_moder_E);
    137.     iounmap(vir_odr_E);
    138.     iounmap(vir_moder_F);
    139.     iounmap(vir_odr_F);
    140.     iounmap(vir_rcc);
    141.     //注册字符设备驱动
    142.     unregister_chrdev(major,"mychrdev");
    143. }
    144. module_init(mycdev_init);
    145. module_exit(mycdev_exit);
    146. MODULE_LICENSE("GPL");

    编写好代码后，make成arm架构

    make arch=arm modname=demo

    使用交叉编译工具链

    arm-linux-gnueabihf-gcc test.c 

    将文件通过tftp传输到开发板中

    cp demo.ko ~/nfs/rootfs/
    cp a.out ~/nfs/rootfs/

    4 效果呈现

    二、封装结构体映射实现

    kbuf[0] 控制灯

    kbuf[1] 控制状态

    1 头文件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

    2 驱动程序 demo.c

    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");
    155.

    3 应用程序 test.c

    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/mychrdev",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. }

  • 相关阅读:
    方案设计｜汽车轮胎数显胎压计方案
    MATLAB 边界点排序（最近邻域搜索算法）
    man 1 2 3的区别
    10张流程图+部署图，讲透单点登录原理与简单实现
    Java题目汇总(二)
    Maven生命周期
    MySQL学习笔记（七）——数据处理之增删改
    合合信息财务自动化解决方案亮相腾讯全球数字生态大会，助力企业财务合规建设
    centos安装kingbase(人大进仓)数据库
    协程: Flow 异步流 /
  • 原文地址：https://blog.csdn.net/Smallxu_/article/details/133953396