• 22071.11.24

    1. #ifndef __LED_H__
    2. #define __LED_H__
    3. #define LED_ON _IOW('a',1,int)
    4. #define LED_OFF _IOW('a',0,int)
    5. typedef enum 
    6. {
    7.     LED1,
    8.     LED2,
    9.     LED3,
    10.     LED4,
    11.     LED5,
    12.     LED6
    13. }led_t;
    14.  
    15. #endif
    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/stat.h>
    4. #include <fcntl.h>
    5. #include <errno.h>
    6. #include <unistd.h>
    7. #include <stdlib.h>
    8. #include <string.h>
    9. #include <sys/ioctl.h>
    10. #include "led.h"
    11.  
    12. int main(int argc, char const *argv[])
    13. {
    14.     int fd1 = -1;
    15.     int fd2 = -1;
    16.     int fd3 = -1;
    17.     int fd4 = -1;
    18.     int fd5 = -1;
    19.     int fd6 = -1;
    20.     int whitch;
    21.     //打开6个led设备文件
    22.     fd1 = open("/dev/myled0",O_RDWR);
    23.     if(-1==fd1)
    24.     {
    25.         perror("open fd1 is error");
    26.         exit(1);
    27.     }
    28.     fd2 = open("/dev/myled1",O_RDWR);
    29.     if(-1==fd2)
    30.     {
    31.         perror("open fd2 is error");
    32.         exit(1);
    33.     }
    34.     fd3 = open("/dev/myled2",O_RDWR);
    35.     if(-1==fd3)
    36.     {
    37.         perror("open fd3 is error");
    38.         exit(1);
    39.     }
    40.     fd4 = open("/dev/myled3",O_RDWR);
    41.     if(-1==fd4)
    42.     {
    43.         perror("open fd4 is error");
    44.         exit(1);
    45.     }
    46.     fd5 = open("/dev/myled4",O_RDWR);
    47.     if(-1==fd5)
    48.     {
    49.         perror("open fd5 is error");
    50.         exit(1);
    51.     }
    52.     fd6 = open("/dev/myled5",O_RDWR);
    53.     if(-1==fd6)
    54.     {
    55.         perror("open fd6 is error");
    56.         exit(1);
    57.     }
    58.     while(1)
    59.     {
    60.         whitch=LED1;
    61.         ioctl(fd1,LED_ON,&whitch);
    62.         sleep(1);
    63.         ioctl(fd1,LED_OFF,&whitch);
    64.         sleep(1);
    65.  
    66.         whitch=LED2;
    67.         ioctl(fd2,LED_ON,&whitch);
    68.         sleep(1);
    69.         ioctl(fd2,LED_OFF,&whitch);
    70.         sleep(1);
    71.  
    72.         whitch=LED3;
    73.         ioctl(fd3,LED_ON,&whitch);
    74.         sleep(1);
    75.         ioctl(fd3,LED_OFF,&whitch);
    76.         sleep(1);
    77.  
    78.         whitch=LED4;
    79.         ioctl(fd4,LED_ON,&whitch);
    80.         sleep(1);
    81.         ioctl(fd4,LED_OFF,&whitch);
    82.         sleep(1);
    83.  
    84.         whitch=LED5;
    85.         ioctl(fd5,LED_ON,&whitch);
    86.         sleep(1);
    87.         ioctl(fd5,LED_OFF,&whitch);
    88.         sleep(1);
    89.  
    90.         whitch=LED6;
    91.         ioctl(fd6,LED_ON,&whitch);
    92.         sleep(1);
    93.         ioctl(fd6,LED_OFF,&whitch);
    94.         sleep(1);
    95.     }
    96.     close(fd1);
    97.     close(fd2);
    98.     close(fd3);
    99.     close(fd4);
    100.     close(fd5);
    101.     close(fd6);
    102.     return 0;
    103. }

    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/of.h>
    4. #include <linux/of_gpio.h>
    5. #include <linux/gpio.h>
    6. #include <linux/cdev.h>
    7. #include <linux/fs.h>
    8. #include <linux/device.h> 
    9. #include <linux/slab.h>
    10. #include "led.h"
    11. #define CNAME "myled"
    12.  
    13. struct device_node *node;
    14. struct gpio_desc *gpio1;
    15. struct gpio_desc *gpio2;
    16. struct gpio_desc *gpio3;
    17. struct gpio_desc *gpio4;
    18. struct gpio_desc *gpio5;
    19. struct gpio_desc *gpio6;
    20. int ret;
    21. struct cdev* cdev; //字符设备结构体指针
    22. dev_t devno;
    23. struct class* cls;
    24. struct device* devt;
    25. #if 1
    26. unsigned int major = 0; //动态申请设备号
    27. #else
    28. unsigned int major = 500;
    29. #endif
    30. int minor = 0;
    31. const int count = 6;
    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. long mycdev_ioctl(struct file *file,unsigned int cmd,unsigned long arg)
    38. {
    39.     int ret;
    40.     int whitch;
    41.     switch(cmd)
    42.     {
    43.     case LED_ON:
    44.         ret = copy_from_user(&whitch,(void*)arg,sizeof(int));
    45.         if(ret)
    46.         {
    47.             printk("copy from user led on...");
    48.             return -EIO;
    49.         }
    50.         switch(whitch)
    51.         {
    52.             case LED1:
    53.             gpiod_set_value(gpio1,1);
    54.             break;
    55.             case LED2:
    56.             gpiod_set_value(gpio2,1);
    57.             break;
    58.             case LED3:
    59.             gpiod_set_value(gpio3,1);
    60.             break;
    61.             case LED4:
    62.             gpiod_set_value(gpio4,1);
    63.             break;
    64.             case LED5:
    65.             gpiod_set_value(gpio5,1);
    66.             break;
    67.             case LED6:
    68.             gpiod_set_value(gpio6,1);
    69.             break;
    70.         }
    71.     break;
    72.     case LED_OFF:
    73.         ret = copy_from_user(&whitch,(void*)arg,sizeof(int));
    74.         if(ret)
    75.         {
    76.             printk("copy from user led off...");
    77.             return -EIO;
    78.         }
    79.         switch(whitch)
    80.         {
    81.             case LED1:
    82.             gpiod_set_value(gpio1,0);
    83.             break;
    84.             case LED2:
    85.             gpiod_set_value(gpio2,0);
    86.             break;
    87.             case LED3:
    88.             gpiod_set_value(gpio3,0);
    89.             break;
    90.             case LED4:
    91.             gpiod_set_value(gpio4,0);
    92.             break;
    93.             case LED5:
    94.             gpiod_set_value(gpio5,0);
    95.             break;
    96.             case LED6:
    97.             gpiod_set_value(gpio6,0);
    98.             break;
    99.         }
    100.     break;
    101.     }
    102.     return 0;
    103. }
    104. int mycdev_close(struct inode *inode,struct file *file)
    105. {
    106.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    107.     return 0;
    108. }
    109. const struct file_operations fops = {
    110.         .open = mycdev_open,
    111.         .unlocked_ioctl = mycdev_ioctl,
    112.         .release = mycdev_close,
    113. };
    114. //进出口
    115. static int __init mycdev_init(void)
    116. { 
    117.     int i;
    118.     int error;  
    119.     cdev = cdev_alloc();
    120.     if(NULL==cdev)
    121.     {
    122.         printk("cdev alloc is error...\n");
    123.         error = -EIO;
    124.         goto ERR1;
    125.     }
    126.     cdev_init(cdev,&fops);
    127.     if(major>0)
    128.     {
    129.         //静态指定设备号
    130.         error = register_chrdev_region(MKDEV(major,minor),count,CNAME);
    131.         if(error)
    132.         {
    133.             printk("register chrdev region is error ...\n");
    134.             error = -ENOMEM;
    135.             goto ERR2;
    136.         }
    137.     }
    138.     else
    139.     {
    140.         //动态申请设备号
    141.         error = alloc_chrdev_region(&devno,0,count,CNAME);
    142.         if(error)
    143.         {
    144.             printk("alloc chadev region is error ...\n");
    145.             error = -ENOMEM;
    146.             goto ERR2;
    147.         }
    148.         major = MAJOR(devno);
    149.         minor = MINOR(devno); 
    150.     }
    151.     error = cdev_add(cdev,MKDEV(major,minor),count);
    152.     if(error)
    153.     {
    154.         printk("cdev add is error...\n");
    155.         error = -EIO;
    156.         goto ERR3;
    157.     }
    158.     //自动创建设备节点
    159.     cls = class_create(THIS_MODULE,CNAME);
    160.     if(IS_ERR(cls))
    161.     {
    162.         printk("class create is error ...\n");
    163.         error = PTR_ERR(cls);
    164.         goto ERR4;
    165.     }
    166.     for(i=0;i<count;i++)
    167.     {
    168.         devt = device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    169.         if(IS_ERR(devt))
    170.         {
    171.             printk("device create is error ...\n");
    172.             error = PTR_ERR(devt);
    173.             goto ERR5;
    174.         }
    175.     }
    176.     node=of_find_node_by_name(NULL,"myleds");
    177.     if(node==NULL)
    178.     {
    179.         printk("find node error\n");
    180.         return -EFAULT;
    181.     }
    182.     printk("find node success\n");
    183.     //获取并申请gpio编号
    184.     gpio1 = gpiod_get_from_of_node(node,"myled1",0,GPIOD_OUT_LOW,NULL);
    185.     if(IS_ERR(gpio1))
    186.     {
    187.         printk("get gpio1 error\n");
    188.         return PTR_ERR(gpio1);
    189.     }
    190.     gpiod_direction_output(gpio1,0);
    191.  
    192.     gpio2 = gpiod_get_from_of_node(node,"myled2",0,GPIOD_OUT_LOW,NULL);
    193.     if(IS_ERR(gpio2))
    194.     {
    195.         printk("get gpio2 error\n");
    196.         return PTR_ERR(gpio2);
    197.     }
    198.     gpiod_direction_output(gpio2,0);
    199.  
    200.     gpio3 = gpiod_get_from_of_node(node,"myled3",0,GPIOD_OUT_LOW,NULL);
    201.     if(IS_ERR(gpio3))
    202.     {
    203.         printk("get gpio3 error\n");
    204.         return PTR_ERR(gpio3);
    205.     }
    206.     gpiod_direction_output(gpio3,0);
    207.     
    208.     gpio4 = gpiod_get_from_of_node(node,"myled4",0,GPIOD_OUT_LOW,NULL);
    209.     if(IS_ERR(gpio4))
    210.     {
    211.         printk("get gpio4 error\n");
    212.         return PTR_ERR(gpio4);
    213.     }
    214.     gpiod_direction_output(gpio4,0);
    215.  
    216.     gpio5 = gpiod_get_from_of_node(node,"myled5",0,GPIOD_OUT_LOW,NULL);
    217.     if(IS_ERR(gpio5))
    218.     {
    219.         printk("get gpio5 error\n");
    220.         return PTR_ERR(gpio5);
    221.     }
    222.     gpiod_direction_output(gpio5,0);
    223.  
    224.     gpio6 = gpiod_get_from_of_node(node,"myled6",0,GPIOD_OUT_LOW,NULL);
    225.     if(IS_ERR(gpio6))
    226.     {
    227.         printk("get gpio6 error\n");
    228.         return PTR_ERR(gpio6);
    229.     }
    230.     gpiod_direction_output(gpio6,0);
    231.     return 0;
    232. //跳转接口
    233. ERR5:
    234.     for(--i;i>=0;i--)
    235.     {
    236.         device_destroy(cls,MKDEV(major,i));
    237.     }
    238.     class_destroy(cls);
    239. ERR4:
    240.     cdev_del(cdev);
    241. ERR3:
    242.     unregister_chrdev_region(MKDEV(major,minor),count);
    243. ERR2:
    244.     kfree(cdev);
    245. ERR1:
    246.     return -EIO;
    247. }
    248. static void __exit mycdev_exit(void)
    249. {
    250.     int i;
    251.     //注销
    252.     gpiod_set_value(gpio1,0);
    253.     gpiod_set_value(gpio2,0);
    254.     gpiod_set_value(gpio3,0);
    255.     gpiod_set_value(gpio4,0);
    256.     gpiod_set_value(gpio5,0);
    257.     gpiod_set_value(gpio6,0);
    258.     gpiod_put(gpio1);
    259.     gpiod_put(gpio2);
    260.     gpiod_put(gpio3);
    261.     gpiod_put(gpio4);
    262.     gpiod_put(gpio5);
    263.     gpiod_put(gpio6);
    264.  
    265.     //1。销毁设备节点信息
    266.     for(i=0;i<count;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),count);
    276.     //5.释放cdev结构体
    277.     kfree(cdev);
    278. }
    279. module_init(mycdev_init);
    280. module_exit(mycdev_exit);
    281. MODULE_LICENSE("GPL");

     

     

  • 相关阅读:
    达梦、Oracle、PostgreSQL查询全部表备注，表字段，全部字段备注，全部索引，全部字段类型
    iSpring SDK 全球领先 iSpring SDK PPT TO H5
    徐州存储服务器会应用在哪些场景？
    Django笔记十四之统计总数、最新纪录和空值判断等功能
    vue el-dialog弹出框自定义指令实现拖拽改变位置-宽度-高度
    Bioinformatics202207 | CD-MVGNN+：基于交叉依赖图神经网络的分子性质预测
    9、【办公自动化】Python实现Word文件的批量操作
    酒店数字化转型，就从这4步开始
    minio搭建文件存储服务
    Linux 操作另一台服务器
  • 原文地址：https://blog.csdn.net/brightmante/article/details/128025409