• 驱动开发DAY4

    驱动代码

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

    头文件

    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. //构建LED开关的功能码，添加ioctl第三个参数int
    17. #define LED_ON _IOW('l',1,int)
    18. #define LED_OFF _IOW('l',0,int)
    19. #endif

    应用代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include "head.h"
    10.  
    11. int main(int argc, char const *argv[])
    12. {
    13.     int a,b;
    14.     int c;
    15.     char buf[128] = {0};
    16.     int fd,fd1,fd2;
    17.     while (1)
    18.     {
    19.         // 从终端读取        
    20.         printf("请输入要控制的灯：0(LED1) 1(LED2) 2(LED3)>");
    21.         scanf("%d",&a);
    22.         switch (a)
    23.         {
    24.         case 0:
    25.             fd = open("/dev/myled0", O_RDWR);
    26.             printf("请输入开灯(1) 关灯(0)>");
    27.             scanf("%d",&b);
    28.             switch (b)
    29.             {
    30.             case 1:
    31.                 ioctl(fd, LED_ON,c); // 开灯
    32.                 close(fd);
    33.                 break;
    34.             case 0:
    35.                 ioctl(fd, LED_OFF,c); // 关灯
    36.                 break;
    37.                 close(fd);
    38.             }
    39.             break;
    40.         case 1:
    41.             fd1 = open("/dev/myled1", O_RDWR);
    42.             printf("请输入开灯(1) 关灯(0)>");
    43.             scanf("%d",&b);
    44.             switch(b)
    45.             {
    46.             case 1:
    47.                 ioctl(fd1, LED_ON,c); // 开灯
    48.                 close(fd1);
    49.                 break;
    50.             case 0:
    51.                 ioctl(fd1, LED_OFF,c); // 关灯
    52.                 close(fd1);
    53.                 break;
    54.             }
    55.             break;           
    56.         case 2:
    57.             fd2 = open("/dev/myled2", O_RDWR);
    58.             printf("请输入开灯(1) 关灯(0)>");
    59.             scanf("%d",&b);
    60.             switch(b)
    61.             {
    62.             case 1:
    63.                 ioctl(fd2, LED_ON,c); // 开灯
    64.                 close(fd2);
    65.                 break;
    66.             case 0:
    67.                 ioctl(fd2, LED_OFF,c); // 关灯
    68.                 close(fd2);
    69.                 break;
    70.             }
    71.             break;
    72.         }
    73.     }
    74.  
    75.     
    76.  
    77.  
    78.  
    79.     return 0;
    80. }

  • 相关阅读:
    【idea】 java: 找不到符号
    postman打开后，以前的接口记录不在，问题解决
    竞赛 基于情感分析的网络舆情热点分析系统
    C Primer Plus(6) 中文版 第7章 C控制语句：分支和跳转 7.1 if语句
    Git 使用教程
    武汉新时标文化传媒有限公司：如何做好短视频直播间的流量？
    基于Java的个性化旅游攻略系统设计与实现(源码+lw+ppt+部署文档+视频讲解等)
    2.6 PE结构：导出表详细解析
    爆款小游戏用的都是什么游戏开发引擎？
    面试素材-结构化
  • 原文地址：https://blog.csdn.net/qq_62504624/article/details/132863880