• 驱动 11/24

    要求：设备树点亮板子上的所有灯

    测试代码：

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/stat.h>
    4. #include <fcntl.h>
    5. #include <unistd.h> 
    6. #include <stdlib.h>   
    7. #include <string.h> 
    8. char buf[128] = "";
    9. char ubuf[128] = {0};
    10. int main(int argc, char const *argv[])
    11. {
    12.     int fd = -1;
    13.     fd = open("/dev/myled0",O_RDWR);
    14.     if(-1 == fd)
    15.     {
    16.         perror("open is error");
    17.         exit(1);
    18.     }
    19.     
    20.     while(1)
    21.     {
    22.         printf("请输入你想操控的位置>>0：内核板  1：拓展板\n");
    23.         fgets(buf,sizeof(buf),stdin);
    24.         buf[strlen(buf)-1]='\0';    //去除换行
    25.         printf("请输入你想开灯还是关灯>>0：关灯  1：开灯\n");
    26.         fgets(buf+1,sizeof(buf),stdin);
    27.         buf[strlen(buf)-1]='\0';    //去除换行
    28.         printf("请输入你想操控的灯>>1：LED1  2：LED2  3：LED3\n");
    29.         fgets(buf+2,sizeof(buf),stdin);
    30.         buf[strlen(buf)-1]='\0';    //去除换行
    31.         printf("最后的操作码为：%s\n",buf);
    32.         write(fd,buf,sizeof(buf));
    33.     }
    34.     close(fd);
    35.     return 0;
    36. }

    驱动代码

    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/cdev.h>
    4. #include <linux/fs.h>
    5. #include <linux/device.h>
    6. #include <linux/slab.h>
    7. #include <linux/io.h>
    8. #include <linux/uaccess.h>
    9. #include <linux/of.h>
    10. #include<linux/of_gpio.h>
    11. #include<linux/gpio.h>
    12.  
    13. #define CNAME "myled"
    14. struct cdev *cdev;
    15. struct class * cls;
    16. struct device * dev;
    17. #if 1
    18. unsigned int major = 0;//动态申请设备号
    19. #else
    20. unsigned int major = 500; //静态指定设备号
    21. #endif
    22. int minor = 0;
    23. const int count = 1;
    24. char kbuf[128] = "";
    25. //定义指针指向获取到的设备节点信息
    26. struct device_node *nhb_node;
    27. struct device_node *tzb_node;
    28. //用于接收到的gpio编号
    29. struct gpio_desc * tzb_gpiono1,* tzb_gpiono2,* tzb_gpiono3;
    30. struct gpio_desc * nhb_gpiono1,* nhb_gpiono2,* nhb_gpiono3;
    31.  
    32. int mycdev_open(struct inode *inode, struct file *file)
    33. {
    34.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    35.      return 0;
    36. }
    37. ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
    38. {
    39.     int ret;
    40.     printk("read:%s:%s:%d\n",__FILE__,__func__,__LINE__);
    41.     if(size > sizeof(kbuf)) size = sizeof(kbuf);
    42.     ret = copy_to_user(ubuf,kbuf,size);
    43.     if(ret)
    44.     {
    45.         printk("copy to user is error\n");
    46.         return -EIO;
    47.     }
    48.     return size;
    49.     return 0;
    50. }
    51. ssize_t mycdev_write (struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
    52. {
    53.     int ret;
    54.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    55.     //校验传输数据大小，如果用户空间传输数据的大小大于内核空间，需要更正传输数据大小
    56.     if(size > sizeof(kbuf)) size = sizeof(kbuf);
    57.     ret = copy_from_user(kbuf,ubuf,size);
    58.     if(ret)
    59.     {
    60.         printk("copy from user is error\n");
    61.         return -EIO;
    62.     }
    63.     printk("传递过来的命令为：kbuf=%s\n",kbuf);
    64.     /*kbuf[0]:控制内核板还是拓展板
    65.       kbuf[1]:开灯还是关灯
    66.       kbuf[2]:具体的哪一盏灯
    67.       */
    68.     switch(kbuf[0])
    69.     {
    70.         case '0'://内核
    71.             switch (kbuf[1])
    72.             {
    73.             case '0'://关灯
    74.                 switch (kbuf[2])
    75.                 {
    76.                 case '1': //led1
    77.                     gpiod_set_value(nhb_gpiono1,0);
    78.                     break;
    79.                 case '2': //led2
    80.                     gpiod_set_value(nhb_gpiono2,0);
    81.                     break;
    82.                 case '3': //led3
    83.                     gpiod_set_value(nhb_gpiono3,0);
    84.                     break;
    85.                 default:
    86.                     break;
    87.                 }
    88.                 break;
    89.             case '1'://开灯
    90.                 switch (kbuf[2])
    91.                 {
    92.                 case '1': //led1
    93.                     gpiod_set_value(nhb_gpiono1,1);
    94.                     break;
    95.                 case '2': //led2
    96.                     gpiod_set_value(nhb_gpiono2,1);
    97.                     break;
    98.                 case '3': //led3
    99.                     gpiod_set_value(nhb_gpiono3,1);
    100.                     break;
    101.                 default:
    102.                     break;
    103.                 }
    104.                 break;
    105.             default:
    106.                 break;
    107.             }
    108.         case '1'://拓展板
    109.             switch (kbuf[1])
    110.             {
    111.             case '0'://关灯
    112.                 switch (kbuf[2])
    113.                 {
    114.                 case '1': //led1
    115.                     gpiod_set_value(tzb_gpiono1,0);
    116.                     break;
    117.                 case '2': //led2
    118.                     gpiod_set_value(tzb_gpiono2,0);
    119.                     break;
    120.                 case '3': //led3
    121.                     gpiod_set_value(tzb_gpiono3,0);
    122.                     break;
    123.                 default:
    124.                     break;
    125.                 }
    126.                 break;
    127.             case '1'://开灯
    128.                 switch (kbuf[2])
    129.                 {
    130.                 case '1': //led1
    131.                     gpiod_set_value(tzb_gpiono1,1);
    132.                     break;
    133.                 case '2': //led2
    134.                     gpiod_set_value(tzb_gpiono2,1);
    135.                     break;
    136.                 case '3': //led3
    137.                     gpiod_set_value(tzb_gpiono3,1);
    138.                     break;
    139.                 default:
    140.                     break;
    141.                 }
    142.                 break;
    143.             default:
    144.                 break;
    145.             }
    146.         break;
    147.  
    148.     }
    149.     return size;
    150. }
    151. int  mycdev_close (struct inode *inode, struct file *file)
    152. {
    153.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    154.  
    155.     return 0;
    156. }
    157. const struct file_operations fops = {
    158.     .open = mycdev_open,
    159.     .read = mycdev_read,
    160.     .write = mycdev_write,
    161.     .release = mycdev_close,
    162. };
    163. //入口
    164. static int __init mycdev_init(void)
    165. {
    166.     int ret;
    167.     int i;
    168.     dev_t devno;
    169.     //1.分配cdev结构体
    170.     cdev=cdev_alloc();
    171.     if(NULL==cdev)
    172.     {
    173.         printk("分配结构体失败\n");
    174.         ret = -EIO;
    175.         goto ERR1;
    176.     }
    177.     //2.初始化结构体
    178.     cdev_init(cdev,&fops);
    179.     //3.申请设备号
    180.     if(major>0)
    181.     {
    182.         //静态指定设备号
    183.         ret=register_chrdev_region(MKDEV(major,minor),count,CNAME);
    184.         if(ret)
    185.         {
    186.             printk("静态指定设备号失败\n");
    187.             ret= -ENOMEM;
    188.             goto ERR2;   
    189.         }
    190.     }
    191.     else
    192.     {
    193.         //动态申请设备号
    194.         ret=alloc_chrdev_region(&devno,0,count,CNAME);
    195.         if(ret)
    196.         {
    197.             printk("动态指定设备号失败\n");
    198.             ret= -ENOMEM;
    199.             goto ERR2;   
    200.         }
    201.     
    202.         //获取主设备号
    203.         major=MAJOR(devno);
    204.         //获取次设备号
    205.         minor=MINOR(devno);
    206.          printk("动态指定设备号成功\n");
    207.     }    
    208.  
    209.     //4.驱动的注册
    210.     ret=cdev_add(cdev,MKDEV(major,minor),count);
    211.     if(ret)
    212.     {
    213.         printk("驱动注册失败\n");
    214.         ret=-EIO;
    215.         goto ERR3;
    216.     }
    217.    printk("驱动注册成功\n");
    218.     //5.自动创建设备节点
    219.         //1)向上层提交目录信息
    220.     cls=class_create(THIS_MODULE,CNAME);
    221.     if(IS_ERR(cls))
    222.     {
    223.         printk("向上层提交目录信息失败\n");
    224.         ret=PTR_ERR(cls);
    225.         goto ERR4;
    226.     }
    227.         //2）向上层提交设备节点信息
    228.     printk("向上层提交设备节点信息成功\n");
    229.     for(i=0;i<count;i++)
    230.     {
    231.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    232.         if(IS_ERR(dev))
    233.         {
    234.             printk("向上层提交设备节点信息失败\n");
    235.             ret=PTR_ERR(dev);
    236.             goto ERR5;  
    237.         }
    238.     }
    239.     printk("向上层提交设备节点信息成功\n");
    240.     //灯的初始化
    241.    /* 
    242.         nhb-leds{
    243.          led1=<&gpioz 5 0>;
    244.          led2=<&gpioz 6 0>;
    245.          led3=<&gpioz 7 0>;
    246.      };
    247.         tzb-leds{                     
    248.          led1=<&gpioe 10 0>;
    249.          led2=<&gpiof 10 0>;
    250.          led3=<&gpioe 8 0>;
    251.      };  */
    252.     //通过名字获取设备树结点信息
    253.     //拓展板
    254.     tzb_node=of_find_node_by_name(NULL,"tzb-leds");
    255.     if(tzb_node==NULL)
    256.     {
    257.         printk("通过名字解析设备树失败\n");
    258.         return -EFAULT;
    259.     }
    260.     printk("通过名字解析设备树成功\n");
    261.     
    262.     //获取并申请gpio编号
    263.     tzb_gpiono1=gpiod_get_from_of_node(tzb_node,"led1",0,GPIOD_OUT_LOW,NULL);
    264.     if(IS_ERR(tzb_gpiono1))
    265.     {
    266.         printk("获取并申请gpio编号失败\n");
    267.         return PTR_ERR(tzb_gpiono1);
    268.     }
    269.  
    270.     tzb_gpiono2=gpiod_get_from_of_node(tzb_node,"led2",0,GPIOD_OUT_LOW,NULL);
    271.     if(IS_ERR(tzb_gpiono2))
    272.     {
    273.         printk("获取并申请gpio编号失败\n");
    274.         return PTR_ERR(tzb_gpiono2);
    275.     }
    276.  
    277.     tzb_gpiono3=gpiod_get_from_of_node(tzb_node,"led3",0,GPIOD_OUT_LOW,NULL);
    278.     if(IS_ERR(tzb_gpiono3))
    279.     {
    280.         printk("获取并申请gpio编号失败\n");
    281.         return PTR_ERR(tzb_gpiono3);
    282.     }
    283.  
    284.     printk("获取gpio编号成功\n");
    285.  
    286. /* 
    287.    //点亮拓展板led1
    288.     gpiod_set_value(tzb_gpiono1,1);
    289.     gpiod_set_value(tzb_gpiono2,1);
    290.     gpiod_set_value(tzb_gpiono3,1);
    291. */
    292. /*****************************************************************************/
    293.   //内核板
    294.     nhb_node=of_find_node_by_name(NULL,"nhb-leds");
    295.     if(nhb_node==NULL)
    296.     {
    297.         printk("通过名字解析设备树失败\n");
    298.         return -EFAULT;
    299.     }
    300.     printk("通过名字解析设备树成功\n");
    301.     
    302.     //获取并申请gpio编号
    303.     nhb_gpiono1=gpiod_get_from_of_node(nhb_node,"led1",0,GPIOD_OUT_LOW,NULL);
    304.     if(IS_ERR(nhb_gpiono1))
    305.     {
    306.         printk("获取并申请gpio编号失败\n");
    307.         return PTR_ERR(nhb_gpiono1);
    308.     }
    309.  
    310.     nhb_gpiono2=gpiod_get_from_of_node(nhb_node,"led2",0,GPIOD_OUT_LOW,NULL);
    311.     if(IS_ERR(nhb_gpiono2))
    312.     {
    313.         printk("获取并申请gpio编号失败\n");
    314.         return PTR_ERR(nhb_gpiono2);
    315.     }
    316.  
    317.     nhb_gpiono3=gpiod_get_from_of_node(nhb_node,"led3",0,GPIOD_OUT_LOW,NULL);
    318.     if(IS_ERR(nhb_gpiono3))
    319.     {
    320.         printk("获取并申请gpio编号失败\n");
    321.         return PTR_ERR(nhb_gpiono3);
    322.     }
    323.     printk("获取gpio编号成功\n");
    324. /*     
    325.    //点亮内核板led1
    326.     gpiod_set_value(nhb_gpiono1,1);
    327.     gpiod_set_value(nhb_gpiono2,1);
    328.     gpiod_set_value(nhb_gpiono3,1);
    329. */
    330.     return 0;
    331. ERR5:
    332.      for(--i;i>0;i--)
    333.         {
    334.             device_destroy(cls,MKDEV(major,i));
    335.         }
    336. ERR4:
    337.     cdev_del(cdev);
    338. ERR3:
    339.     unregister_chrdev_region(MKDEV(major,minor),count);
    340. ERR2:
    341.     kfree(cdev);
    342. ERR1:
    343.     return -EIO;
    344. }
    345. //出口
    346. static void __exit mycdev_exit(void)
    347. {
    348.     int i;
    349.     //1。销毁设备节点信息
    350.     for(i=0;i<count;i++)
    351.     {
    352.         device_destroy(cls,MKDEV(major,i));
    353.     }
    354.     //2.销毁目录信息
    355.     class_destroy(cls);
    356.     //3.驱动的注销
    357.     cdev_del(cdev);
    358.     //4.销毁设备号
    359.     unregister_chrdev_region(MKDEV(major,minor),count);
    360.     //5.释放cdev结构体
    361.     kfree(cdev);
    362.     //卸载驱动前熄灭灯
    363.     gpiod_set_value(tzb_gpiono1,0);
    364.     gpiod_set_value(tzb_gpiono2,0);
    365.     gpiod_set_value(tzb_gpiono3,0);
    366.     gpiod_set_value(nhb_gpiono1,0);
    367.     gpiod_set_value(nhb_gpiono2,0);
    368.     gpiod_set_value(nhb_gpiono3,0);
    369.     //释放申请得到的gpio编号
    370.    
    371.     gpiod_put(tzb_gpiono1);
    372.     gpiod_put(tzb_gpiono2);
    373.     gpiod_put(tzb_gpiono3);
    374.     gpiod_put(nhb_gpiono1);
    375.     gpiod_put(nhb_gpiono2);
    376.     gpiod_put(nhb_gpiono3);
    377.  
    378. }
    379. //指定入口地址
    380. module_init(mycdev_init);
    381. module_exit(mycdev_exit);
    382. //指定出口地址
    383. //许可证
    384. MODULE_LICENSE("GPL");

    设备树

     现象：

     

  • 相关阅读:
    Gateway 接口参数加解密
    vector 用法 说明
    spring整合SpringCache
    盘点5个C#开发的、可用于个人博客的系统
    BM1684X搭建sophon sail环境
    [推荐]Linux安装与配置虚拟机之虚拟机服务器坏境配置
    Java面试题之synchronized平台级锁和Lock实现的锁区别
    小红书多账号管理平台哪个好用？可以快速监测多个小红书账号的数据吗？
    五、【React-Router6】路由表 useRoutes() + Outlet
    Golang 变量作用域陷阱 误用短声明导致变量覆盖
  • 原文地址：https://blog.csdn.net/weixin_47202678/article/details/128022374