• 驱动开发day4

    通过字符设备驱动的分步实现编写LED驱动，另外实现设备文件和驱动的绑定

    head.h

    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

    test.c

    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.     char buf[128]={0};
    15.     int a,b;
    16.     int fd=open("/dev/mycdev1",O_RDWR);
    17.     if(fd<0)
    18.     {
    19.         printf("打开设备文件失败\n");
    20.         exit(-1);
    21.     }
    22.     while(1)
    23.     {
    24.         //从终端读取
    25.         printf("请输入要实现的功能 ");
    26.         printf("0(关灯) 1(开灯)\n");
    27.         printf("请输入>");
    28.         scanf("%d",&a);
    29.        
    30.         switch(a)
    31.         {
    32.             case 1:
    33.                 ioctl(fd,LED_ON);
    34.                 break;
    35.             case 0:
    36.                 ioctl(fd,LED_OFF);
    37.                 break;
    38.         }
    39.     }
    40.  
    41.     close(fd);
    42.  
    43.     return 0;
    44. }

    mycdev.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 <linux/cdev.h>
    7. #include <linux/slab.h>
    8. #include <linux/uaccess.h>
    9. #include "head.h"
    10.  
    11. char kbuf[128] = {0};
    12. gpio_t *vir_led1;
    13. gpio_t *vir_led2;
    14. gpio_t *vir_led3;
    15. unsigned int *vir_rcc;
    16. struct class *cls;
    17. struct device *dev;
    18. struct cdev *cdev;
    19. unsigned int major = 0;
    20. unsigned int minor = 0;
    21. dev_t devno;
    22.  
    23. int mycdev_open(struct inode *inode, struct file *file)
    24. {
    25.     //获取打开文件的次设备号
    26.     int min = MINOR(inode->i_rdev);
    27.     file->private_data = (void *)min;
    28.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    29.     return 0;
    30. }
    31. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    32. {
    33.     //获取文件的次设备号
    34.     int min = (int)file->private_data;
    35.     switch (min)
    36.     {
    37.         case 0://操作LED1
    38.         switch(cmd)
    39.         {
    40.             case LED_ON:
    41.             (vir_led1->ODR) |= (0x1 << 10);//led1开灯
    42.             break;
    43.             case LED_OFF:
    44.             (vir_led1->ODR) &= (~(0x1 << 10));//LED1关灯
    45.             break;
    46.         }
    47.         break;
    48.         case 1://操作LED2
    49.         switch(cmd)
    50.         {
    51.             case LED_ON:
    52.             (vir_led2->ODR) |= (0x1 << 10);//led2开灯
    53.             break;
    54.             case LED_OFF:
    55.             (vir_led2->ODR) &= (~(0x1 << 10));//LED2关灯
    56.             break;
    57.         }
    58.         break;
    59.         case 2://操作LED3
    60.         switch(cmd)
    61.         {
    62.             case LED_ON:
    63.             (vir_led3->ODR) |= (0x1 << 10);//led3开灯
    64.             break;
    65.             case LED_OFF:
    66.             (vir_led3->ODR) &= (~(0x1 << 10));//LED3关灯
    67.             break;
    68.         }
    69.         break;
    70.     }
    71.     return 0;
    72. }
    73. int mycdev_close(struct inode *inode, struct file *file)
    74. {
    75.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    76.     return 0;
    77. }
    78.  
    79. // 定义操作方法结构体变量并赋值
    80. struct file_operations fops = {
    81.  
    82.     .open = mycdev_open,
    83.     .unlocked_ioctl = mycdev_ioctl,
    84.     .release = mycdev_close,
    85. };
    86.  
    87. int all_led_init(void)
    88. {
    89.     // 寄存器地址的映射
    90.     vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    91.     if (vir_led1 == NULL)
    92.     {
    93.         printk("ioremap filed：%d\n", __LINE__);
    94.         return -ENOMEM;
    95.     }
    96.     vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    97.     if (vir_led2 == NULL)
    98.     {
    99.         printk("ioremap filed：%d\n", __LINE__);
    100.         return -ENOMEM;
    101.     }
    102.     vir_led3 = vir_led1;
    103.     vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    104.     if (vir_rcc == NULL)
    105.     {
    106.         printk("ioremap filed：%d\n", __LINE__);
    107.         return -ENOMEM;
    108.     }
    109.     printk("物理地址映射成功\n");
    110.     // 寄存器的初始化
    111.     // rcc
    112.     (*vir_rcc) |= (3 << 4);
    113.     // led1
    114.     vir_led1->MODER &= (~(3 << 20));
    115.     vir_led1->MODER |= (1 << 20);
    116.     vir_led1->ODR &= (~(1 << 10));
    117.     // led2
    118.     vir_led2->MODER &= (~(3 << 20));
    119.     vir_led2->MODER |= (1 << 20);
    120.     vir_led2->ODR &= (~(1 << 10));
    121.     // led3
    122.     vir_led3->MODER &= (~(3 << 16));
    123.     vir_led1->MODER |= (1 << 16);
    124.     vir_led1->ODR &= (~(1 << 8));
    125.     printk("寄存器初始化成功\n");
    126.     // 寄存器地址的映射
    127.     vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    128.     if (vir_led1 == NULL)
    129.     {
    130.         printk("ioremap filed：%d\n", __LINE__);
    131.         return -ENOMEM;
    132.     }
    133.     vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    134.     if (vir_led2 == NULL)
    135.     {
    136.         printk("ioremap filed：%d\n", __LINE__);
    137.         return -ENOMEM;
    138.     }
    139.     vir_led3 = vir_led1;
    140.     vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    141.     if (vir_rcc == NULL)
    142.     {
    143.         printk("ioremap filed：%d\n", __LINE__);
    144.         return -ENOMEM;
    145.     }
    146.     printk("物理地址映射成功\n");
    147.     // 寄存器的初始化
    148.     // rcc
    149.     (*vir_rcc) |= (3 << 4);
    150.     // led1
    151.     vir_led1->MODER &= (~(3 << 20));
    152.     vir_led1->MODER |= (1 << 20);
    153.     vir_led1->ODR &= (~(1 << 10));
    154.     // led2
    155.     vir_led2->MODER &= (~(3 << 20));
    156.     vir_led2->MODER |= (1 << 20);
    157.     vir_led2->ODR &= (~(1 << 10));
    158.     // led3
    159.     vir_led3->MODER &= (~(3 << 16));
    160.     vir_led1->MODER |= (1 << 16);
    161.     vir_led1->ODR &= (~(1 << 8));
    162.     printk("寄存器初始化成功\n");
    163.     return 0;
    164.  
    165. }
    166.  
    167. static int __init mycdev_init(void)
    168. {
    169.     
    170.     int ret;
    171.     // 1.申请一个对象空间 cdev_alloc
    172.     cdev = cdev_alloc();
    173.     if (cdev == NULL)
    174.     {
    175.         printk("申请字符设备驱动对象失败");
    176.         ret = -EFAULT;
    177.         goto cont1;
    178.     }
    179.     printk("字符设备驱动对象申请成功\n");
    180.  
    181.     // 2.初始化对象 cdev_init
    182.     cdev_init(cdev, &fops);
    183.  
    184.     // 3.申请设备号 register_chrdev_region()/alloc_chrdev_region()
    185.     if (major == 0) // 动态申请模拟
    186.     {
    187.         ret = alloc_chrdev_region(&devno, minor, 3, "mychrdev");
    188.         if (ret)
    189.         {
    190.             printk("动态申请设备号失败\n");
    191.             goto cont2;
    192.         }
    193.         major = MAJOR(devno); // 根据设备号获取主设备号
    194.         minor = MINOR(devno); // 根据设备号获取次设备号
    195.     }
    196.     else // 静态申请模拟
    197.     {
    198.         ret = register_chrdev_region(MKDEV(major, minor), 3, "mychrdev");
    199.         if (ret)
    200.         {
    201.             printk("静态指定设备号失败\n");
    202.             goto cont2;
    203.         }
    204.     }
    205.     printk("设备号申请成功\n");
    206.     // 4.注册驱动对象 cdev_add
    207.     ret = cdev_add(cdev, MKDEV(major, minor), 3);
    208.     if (ret)
    209.     {
    210.         printk("注册驱动对象失败\n");
    211.         goto cont3;
    212.     }
    213.     printk("注册字符设备驱动对象成功\n");
    214.     // 5.向上提交目录 class_create
    215.     cls = class_create(THIS_MODULE, "mychrdev");
    216.     if (IS_ERR(cls))
    217.     {
    218.         printk("向上提交目录失败\n");
    219.         goto cont4;
    220.     }
    221.     printk("向上提交目录成功\n");
    222.     // 6.向上提交设备节点信息 device_create
    223.     int i;
    224.     for (i = 0; i < 3; i++)
    225.     {
    226.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "mycdev%d", i);
    227.         if (IS_ERR(dev))
    228.         {
    229.             printk("向上提交设备节点失败\n");
    230.             goto cont5;
    231.         }
    232.     }
    233.     printk("向上提交设备节点信息成功\n");
    234.  
    235.  
    236.     // 寄存器映射以及初始化
    237.     all_led_init();
    238.  
    239.     return 0;
    240. cont5:
    241.     // 将提交成功的节点信息释放
    242.     for (--i; i > 0; i--)
    243.     {
    244.         device_destroy(cls, MKDEV(major, i));
    245.     }
    246.     // 销毁目录
    247.     class_destroy(cls);
    248. cont4:
    249.     cdev_del(cdev);
    250. cont3:
    251.     unregister_chrdev_region(MKDEV(major, minor), 3);
    252. cont2:
    253.     kfree(cdev);
    254. cont1:
    255.     return ret;
    256.  
    257. }
    258. static void __exit mycdev_exit(void)
    259. {
    260.     // 取消地址映射
    261.     iounmap(vir_led1);
    262.     iounmap(vir_led2);
    263.     iounmap(vir_rcc);
    264.     // 1.销毁设备节点信息
    265.     int i;
    266.     for (i = 0; i < 3; i++)
    267.     {
    268.         device_destroy(cls, MKDEV(major, i));
    269.     }
    270.     // 2.销毁目录
    271.     class_destroy(cls);
    272.     // 3.注销字符设备驱动对象
    273.     cdev_del(cdev);
    274.     // 4.释放设备号
    275.     unregister_chrdev_region(MKDEV(major, minor), 3);
    276.     // 5.释放申请到的字符设备驱动对象空间
    277.     kfree(cdev);
    278. }
    279. module_init(mycdev_init);
    280. module_exit(mycdev_exit);
    281. MODULE_LICENSE("GPL");

  • 相关阅读:
    Linux安装redis数据库
    温敏性N-异丙基丙烯酰胺(NIPA)和pH敏感性丙烯酸(AA)接枝纳米聚苯乙烯微球相关研究
    机械工程师和电气工程师方向哪个前景比较好？
    LeetCode 230.二叉搜索树中第K小的元素
    C#基础笔记
    深度学习推荐系统--协同过滤推荐算法＋实现代码
    Java经典问题解答（9题）
    git everything up-to-date解决方法
    【无标题】
    【保姆级】lookup-method标签实践与分析
  • 原文地址：https://blog.csdn.net/Meng_fighting/article/details/133999305