• 华清远见嵌入式学习——驱动开发——作业1

    作业要求：

    通过字符设备驱动分步注册过程实现LED驱动的编写，编写应用程序测试，发布到CSDN

    作业答案：

    运行效果：

    驱动代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include "head.h"
    10.  
    11. struct cdev *cdev;
    12. char kbuf[128] = {0};
    13. unsigned int major = 0; // 主设备号
    14. unsigned int minor = 0; // 次设备号
    15. dev_t devno;
    16. struct class *cls;
    17. struct device *dev;
    18.  
    19. gpio_t *vir_led1;
    20. gpio_t *vir_led2;
    21. gpio_t *vir_led3;
    22. unsigned int *vir_rcc;
    23.  
    24. // 封装操作方法
    25. // 定义操作方法对象并初始化
    26. int mycdev_open(struct inode *inode, struct file *file)
    27. {
    28.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    29.     return 0;
    30. }
    31. ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
    32. {
    33.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    34.     unsigned long ret;
    35.     // 向用户空间读取拷贝
    36.     if (size > sizeof(kbuf)) // 用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
    37.         size = sizeof(kbuf);
    38.     ret = copy_to_user(ubuf, kbuf, size);
    39.     if (ret) // 拷贝失败
    40.     {
    41.         printk("copy_to_user filed\n");
    42.         return ret;
    43.     }
    44.     return 0;
    45. }
    46. ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
    47. {
    48.     unsigned long ret;
    49.     // 从用户空间读取数据
    50.     if (size > sizeof(kbuf)) // 用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
    51.         size = sizeof(kbuf);
    52.     ret = copy_from_user(kbuf, ubuf, size);
    53.     if (ret) // 拷贝失败
    54.     {
    55.         printk("copy_to_user filed\n");
    56.         return ret;
    57.     }
    58.  
    59.     return 0;
    60. }
    61.  
    62. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    63. {
    64.     int wh;
    65.     int ret=copy_from_user(&wh,(void *)arg,4);
    66.     if(ret)//拷贝失败
    67.     {
    68.         printk("copy_from_user filed\n");
    69.         return ret;
    70.     }
    71.     switch(cmd)
    72.     {
    73.         case LED_ON:
    74.         switch(wh)
    75.         {
    76.             case 1:
    77.              vir_led1->ODR |= (1<<10);
    78.              break;
    79.             case 2:
    80.              vir_led2->ODR |= (1<<10);
    81.              break;
    82.             case 3:
    83.              vir_led3->ODR |= (1<<8);
    84.              break;
    85.         } 
    86.             break;
    87.         case LED_OFF:
    88.             switch(wh)
    89.         {
    90.             case 1:
    91.               vir_led1->ODR &= (~(1<<10));
    92.              break;
    93.             case 2:
    94.               vir_led2->ODR &= (~(1<<10));
    95.              break;
    96.             case 3:
    97.               vir_led3->ODR &= (~(1<<8));
    98.              break;
    99.         } 
    100.            
    101.             break;
    102.     }
    103.     return 0;
    104. }
    105.  
    106. int mycdev_close(struct inode *inode, struct file *file)
    107. {
    108.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    109.     return 0;
    110. }
    111.  
    112. int all_led_init(void)
    113. {
    114.     //寄存器地址的映射
    115.     vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    116.     if(vir_led1==NULL)
    117.     {
    118.         printk("ioremap filed：%d\n",__LINE__);
    119.         return -ENOMEM;
    120.     }
    121.      vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    122.     if(vir_led2==NULL)
    123.     {
    124.         printk("ioremap filed：%d\n",__LINE__);
    125.         return -ENOMEM;
    126.     }
    127.      vir_led3=vir_led1;
    128.     vir_rcc=ioremap(PHY_RCC_ADDR,4);
    129.     if(vir_rcc==NULL)
    130.     {
    131.         printk("ioremap filed：%d\n",__LINE__);
    132.         return -ENOMEM;
    133.     }
    134.     printk("物理地址映射成功\n");
    135.     //寄存器的初始化
    136.     //rcc
    137.     (*vir_rcc) |= (3<<4);
    138.     //led1
    139.     vir_led1->MODER &= (~(3<<20));
    140.     vir_led1->MODER |= (1<<20);
    141.     vir_led1->ODR &= (~(1<<10));
    142.     //led2
    143.     vir_led2->MODER &= (~(3<<20));
    144.     vir_led2->MODER |= (1<<20);
    145.     vir_led2->ODR &= (~(1<<10));
    146.     //led3
    147.     vir_led3->MODER &= (~(3<<16));
    148.     vir_led3->MODER |= (1<<16);
    149.     vir_led3->ODR &= (~(1<<8));
    150.     printk("寄存器初始化成功\n");
    151.  
    152.     return 0;
    153. }
    154.  
    155. // 定义操作方法结构体变量并赋值
    156. struct file_operations fops={
    157.  
    158.     .open=mycdev_open,
    159.     .read=mycdev_read,
    160.     .write=mycdev_write,
    161.     .unlocked_ioctl=mycdev_ioctl,
    162.     .release=mycdev_close,
    163. };
    164. static int __init mycdev_init(void)
    165. {
    166.     int ret;
    167.     // 1.申请字符设备驱动对象空间
    168.     cdev = cdev_alloc();
    169.     if (cdev == NULL)
    170.     {
    171.         return -EFAULT;
    172.     }
    173.     printk("字符设备驱动对象申请成功\n");
    174.     // 2.初始化字符设备驱动对象
    175.     cdev_init(cdev, &fops);
    176.     // 3.申请设备号
    177.     if (major == 0) // 动态申请
    178.     {
    179.         ret = alloc_chrdev_region(&devno, minor, 3, "myled");
    180.         if (ret)
    181.         {
    182.             printk("动态申请设备号失败\n");
    183.             goto out1;
    184.         }
    185.         // 为了统一和静态申请设备号的操作
    186.         major = MAJOR(devno);
    187.         minor = MINOR(devno);
    188.     }
    189.     else // 静态指定
    190.     {
    191.         ret = register_chrdev_region(MKDEV(major, minor), 3, "myled");
    192.         if (ret)
    193.         {
    194.             printk("静态申请设备号失败\n");
    195.             goto out1;
    196.         }
    197.     }
    198.     printk("设备号申请成功\n");
    199.     // 4.注册驱动
    200.     ret = cdev_add(cdev, MKDEV(major, minor), 3);
    201.     if (ret)
    202.     {
    203.         printk("注册驱动失败\n");
    204.         goto out2;
    205.     }
    206.     printk("注册驱动成功\n");
    207.     // 5.向上提交目录
    208.     cls = class_create(THIS_MODULE, "led");
    209.     if (IS_ERR(cls))
    210.     {
    211.         printk("向上提交目录失败\n");
    212.         ret = -PTR_ERR(cls);
    213.         goto out3;
    214.     }
    215.     printk("向上提交目录成功\n");
    216.     // 6.向上提交设备节点
    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.             ret = -PTR_ERR(dev);
    225.             goto out4;
    226.         }
    227.     }
    228.     printk("向上提交设备信息成功\n");
    229.  
    230.     // 寄存器映射以及初始化
    231.     all_led_init();
    232.  
    233.     return 0;
    234. out4:
    235.     // 销毁提交成功的设备信息
    236.     for (--i; i >= 0; i--)
    237.     {
    238.         device_destroy(cls, MKDEV(major, i));
    239.     }
    240.     // 销毁目录
    241.     class_destroy(cls);
    242. out3:
    243.     cdev_del(cdev);
    244. out2:
    245.     unregister_chrdev_region(MKDEV(major, minor), 3);
    246. out1:
    247.     kfree(cdev);
    248.     return ret;
    249. }
    250. static void __exit mycdev_exit(void)
    251. {
    252.     // 1.释放设备信息
    253.     int i;
    254.     for (i = 0; i < 3; i++)
    255.     {
    256.         device_destroy(cls, MKDEV(major, i));
    257.     }
    258.     // 2.销毁目录
    259.     class_destroy(cls);
    260.     // 3.注销驱动对象
    261.     cdev_del(cdev);
    262.     // 4.释放设备号
    263.     unregister_chrdev_region(MKDEV(major, minor), 3);
    264.     // 5.释放对象空间
    265.     kfree(cdev);
    266. }
    267. module_init(mycdev_init);
    268. module_exit(mycdev_exit);
    269. 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.  
    12. int main(int argc, char const *argv[])
    13. {
    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("请输入要实现的功能\n");
    25.         printf("0(关灯) 1(开灯)\n");
    26.         printf("请输入>");
    27.         scanf("%d",&a);
    28.         printf("请输入要控制的灯\n");
    29.         printf("1(LED1) 2(LED2) 3(LED3)\n");
    30.         printf("请输入>");
    31.         scanf("%d",&b);
    32.         switch(a)
    33.         {
    34.             case 1:
    35.                 ioctl(fd,LED_ON,&b);
    36.                 break;
    37.             case 0:
    38.                 ioctl(fd,LED_OFF,&b);
    39.                 break;
    40.         }
    41.     }
    42.  
    43.     
    44.     close(fd);
    45.  
    46.     return 0;
    47. }

    头文件：

    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. //构建功能码
    17. #define LED_ON _IOW('l',1,int)  
    18. #define LED_OFF _IOW('l',0,int)
    19. #endif

  • 相关阅读:
    Maven下载、安装、配置教程
    Docker学习笔记
    开发Qt上位机获取阿里云IOT设备数据（开发上位机对接阿里云IOT平台）
    Redis主从复制的核心原理
    输入一个字符串，统计其中字符A的数量并且输出，输入共有一行，为一个不带空格的字符串（其中字符数不超过100），输出一行，包含一个整数，为输入字符串中的A的数量
    人人都会Kubernetes（二）：使用KRM实现快速部署服务，并且通过域名发布
    黑马点评--分布式锁
    tiup cluster import
    （十三）【Jmeter】线程（Threads(Users)）之tearDown 线程组
    vue3 globalData 的使用方法
  • 原文地址：https://blog.csdn.net/qq_54502935/article/details/136155088