嵌入式驱动day05

最新推荐文章于 2025-08-25 20:52:53 发布
最新推荐文章于 2025-08-25 20:52:53 发布
阅读量263 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Device
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011411117/article/details/79069501
1.字符设备驱动框架
struct cdev {//代表硬件上的一个字符设备
    dev_t dev;//设备号
    struct file_operations f_ops;//操作函数集合
    ....
}

关于设备号的分配方式
    静态分配
        register_chrdev_region
    动态分配
        alloc_chrdev_region
 关于cdev的操作
        cdev_init
        cdev_add
        cdev_del
 struct file_operations{
        open
        read
        write
        release
   }   

    struct    inode{
        dev_t    i_rdev;//记录设备号
        struct cdev *i_cdev;//关于cdev结构
   }

    struct    file{
        void    *private_data;
     }

    fd0=open("/dev/cdd0")    struct file
    fd1=open("/dev/cdd1")    struct file
    read(fd0,..)    ->    cdd_read(struct file*    filp,..)
    read(fd1,..)    ->    cdd_read(struct file*    filp,..)
------------------------------------------------------------------
用户空间和内核空间数据交换的问题
    copy_to_user
    copy_from_user
    day04代码多次读返回同样的内容
    添加    llseek    函数
  1. #include<linux/init.h>
  2. #include<linux/module.h>
  3. #include<linux/fs.h>
  4. #include<linux/cdev.h>
  5. #inlcude<linux/device.h>
  6. #include<asm/uaccess.h>//用户空间拷贝头文件
  7. //动态申请的头文件
  8. #include<linux/slab.h>
      #include<liunx/string.h>

  1. MODULE_LICENSE("GPL");
  2. #define CDD_MAJOR 200
  3. #define CDD_MINOR 0
  4. #define CDD_COUNT 10
  5. dev_t dev=0;
  6. u32 cdd_major=0;
  7. u32 cdd_minor=0;
  8. /*定义cdev类型的变量*/
  9. struct cdev cdd_cdev;
  10. struct class *dev_class=NULL;
  11. //struct device *dev_device=NULL;
  12. #define  BUF_SIZE 100
  13. struct cdd_cdev{
  14.  struct cdev cdev;
  15.  struct device *dev_device;
  16.  u8 led;
  17.  char kbuf[BUF_SIZE];
  19.  u32 data_len;//记录缓冲区已写入数据的长度
  21. }
  23. struct cdd_cdev *cdd_cdevp=NULL;
  25. int cdd_open(struct inode *inode,struct file *filp){
  26. /*2*/
  27.   printk("enter cdd_open\n");
  28.   struct cdd_cdev* pcdevp=NULL;
  29.   printk("enter cdd_open\n");
  30.   pcdevp = container_of(inode->i_cdev,struct cdd_cdev,cdev);
  31.   printk("led=%d\n",pcdevp->led);
  32.  filp->private_data = pcdevp;
  33.   return 0;
  34. }
  35. int cdd_read(struct file* filp,char __user *buf,size_t count,
  36.             loff_t *offset){
  37.    int ret=0;
  39.    u32 pos=*offset;
  40.    u32 cnt=count;
  41.    struct cdd_cdev* pcdevp = filp->private_data;
  42.    
  43.    printk("LED%d\n",pcdevp->led);
  44.    //copy_to_user(to,from,n);
  45.    //先判断下有没有数据可以进行读取
  46.    if(cnt>(pcdevp->data_len/*先有数据*/ - pos/**/)){
  47.       cnt=pcdevp->data_len-pos;
  48.    }
  49.    ret=copy_to_user(buf,pcdevp->kbuf+pos,cnt);
  50.    
  51.    *offset += cnt;
  52.    
  53.    return ret;
  54. }
  55. int cdd_write(struct file *filp,const char __user *buf,
  56.              size_t count,loff_t *offset){
  57.    printk("enter cdd_write!\n");
  58.    int  ret=0;
  59.    u32 pos=*offset;
  60.    u32 cnt =count;
  61.   
  62.    if(cnt > (BUF_SIZE - pos)){
  63.       cnt =　BUF_SIZE - pos;
  64.    }
  66.    copy_from_user(pcdevp->kbuf+pos,buf,cnt);
  67.    *offset += cnt;
  68.    if(*offset > pcdevp->data_len){
  69.       pcdevp->data_len = *offset
  70.     }
  71.    return ret;
  72. }
  73. int cdd_ioctl(struct inode *inode,struct file *filp,
  74.               unsigned int cmd ,unsigned data){
  75.     printk("enter cdd_ioctl!\n");
  76.     return 0;
  77. }
  78. int cdd_release(struct inode *inode,struct file *filp){
  79.     printk("enter cdd_release!\n");
  80.     return 0;
  81. }
  83. loff_t cdd_llseek(struct file *filp,loff_t offset,int whence){
  84.   struct cdd_cdev *pcdevp=filp->private_data;
  85.   loff_t newpos=0l
  86.   switch(whence){
  87.     case SEEK_SET:
  88.       newpos=offset;
  89.       break;
  90.     case  SEEK_CUR:
  91.       newpos=filp->fops+offset;
  92.       break;
  93.     case SEEK_END:
  94.       newpos=pcdevp->data_len+offset;
  95.       break;
  96.     default:
  97.       return -EINVAL;
  98.   }
  99.   if(newpos<0 || newpos>=BUF_SIZE){
  100.      return -EINVAL;  
  101.   }
  102.   filp->f_ops=newpos;
  103.   return newpos;
  104. }
  107. struct file_operations cdd_fops={
  108.   .owner = THIS_MODULE,
  109.   .open=cdd_open,
  110.   .read=cdd_read,
  111.   .write=cdd_write,
  112.   .ioctl=cdd_ioctl,
  113.   .release=cdd_release,
  114.   .llseek=cdd_llseek,
  115. };
  116. int __init cdd_init(void){
  117.   int ret =0;
  118.   int i;
  119.   if(cdd_major){
  120.      //静态方式分配设备号
  121.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  122.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  123.   }else{
  124.     /*动态分配设备号*/
  125.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  126.   }
  127.   
  128.   if(ret<0){
  129.      prink("register_chrdev_region failed!\n");
  130.      goto failure_register_chrdev;
  131.   }
  132.   /*获取主设备号*/
  133.   cdd_major=MAJOR(dev);
  134. /*1*/
  135.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  136.   if(IS_ERR(cdd_cdevp)){
  137.      printk("kzalloc fail");
  138.      goto failure_kzalloc;
  139.   }
  140.   /*创建设备类*/
  141.   dev_class = class_create(THIS_MODULE,"cdd_class");
  142.   if(IS_ERR(dev_class)){
  143.     printk("class_create failed!\n");
  144.     ret=PTR_ERR(dev_class);
  145.     goto failure_dev_class;
  146.   }
  147.   
  148.   for(i=0;i<CDD_COUNT;i++){
  149.      /*初始化cdev*/
  150.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  151.      /*添加cdev到内核*/
  152.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  153.      /*"/dev/xxx"*/
  154.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  155.      cdd_cdevp[i].led=i;
  156.   }
  157.   return 0;
  158. failure_dev_class:
  159.   kfree(cdd_cdevp);
  160. failure_kzalloc:
  161.   unregister_chrdev_region(dev,CDD_COUNT);
  162. failure_register_chrdev:
  163.   return ret;
  164. }
  165. void __exit cdd_exit(void){
  166.   int i=0;
  167.   for(i=0;i<CDD_COUNT;i++){
  168.     device_destroy(dev_class,dev+i);
  169.     cdev_del（*(cdd_cdevp[i].cdev)）;
  170.     
  171.   }
  172.   /*从内核中删除设备类*/
  173.   class_destroy(dev_class);
  174.   kfree(cdd_cdevp);
  175.   /*注销设备号*/
  176.   unregister_chrdev_region(dev,CDD_COUNT);
  177. }
  178. module_init(cdd_init);
  179. moudle_exit(cdd_exit);

控制LED
    看原理图，如果想让LED1亮就是在GPC1_3上输出高电平反之输出低电平
    编程使CPU的GPC1_3管脚为输出管脚
                控制该管教输出高电平或者低电平
    cpu芯片手册:寄存器
                GPC1CON
                GPC1DAT
                GPC1PUD
在linux下控制相应的GPIO管脚,有两种方式
    1)直接操作相应的寄存器
    2)通过内核提供的GPIO操作库函数
在用户空间采用两种方式控制LED的亮/灭
    1)    /dev/led0    /dev/led1
            cdev0        cdev1
            fd0=open("dev/led0",O_RDWR);
            ioctl(fd,cmd,data)
                例:ioctl(fd1,1,0)//亮    ioctl(fd1,0,0)//灭
    2)/dev/led
        cdev
        fd0=open("dev/led0",O_RDWR);
            ioctl(fd,cmd,data)
                例:ioctl(fd1,1,1)//第一个亮    ioctl(fd1,0,2)//第二个灯亮
    
  1. #include<linux/init.h>
  2. #include<linux/module.h>
  3. #include<linux/fs.h>
  4. #include<linux/cdev.h>
  5. #inlcude<linux/device.h>
  6. #include<asm/uaccess.h>//用户空间拷贝头文件
  7. //动态申请的头文件
  8. #include<linux/slab.h>
  9. #include<liunx/string.h>
  10. //GPIO
  11. #include<asm/gpio.h>
  12. #include<plat/gpio-cfg,h>
  14. MODULE_LICENSE("GPL");
  15. #define CDD_MAJOR 200
  16. #define CDD_MINOR 0
  17. #define CDD_COUNT 1
  18. dev_t dev=0;
  19. u32 cdd_major=0;
  20. u32 cdd_minor=0;
  21. /*定义cdev类型的变量*/
  22. struct cdev cdd_cdev;
  23. struct class *dev_class=NULL;
  24. //struct device *dev_device=NULL;
  25. #define  BUF_SIZE 100
  26. struct cdd_cdev{
  27.  struct cdev cdev;
  28.  struct device *dev_device;
  29.  u8 led;
  30.  char kbuf[BUF_SIZE];
  31.  u32 data_len;//记录缓冲区已写入数据的长度
  32. }
  33. struct cdd_cdev *cdd_cdevp=NULL;
  35. unsigned long led_gpio_table[2]={
  36.    S5PV210_GPC1(3),//宏->数字
  37.    S5PV210_GPC1(4)
  38. };
  41. int cdd_open(struct inode *inode,struct file *filp){
  42. /*2*/
  43.   printk("enter cdd_open\n");
  44.   struct cdd_cdev* pcdevp=NULL;
  45.   printk("enter cdd_open\n");
  46.   pcdevp = container_of(inode->i_cdev,struct cdd_cdev,cdev);
  47.   printk("led=%d\n",pcdevp->led);
  48.  filp->private_data = pcdevp;
  49.   return 0;
  50. }
  51. int cdd_read(struct file* filp,char __user *buf,size_t count,
  52.             loff_t *offset){
  53.    int ret=0;
  54.    u32 pos=*offset;
  55.    u32 cnt=count;
  56.    struct cdd_cdev* pcdevp = filp->private_data;
  57.    
  58.    printk("LED%d\n",pcdevp->led);
  59.    //copy_to_user(to,from,n);
  60.    //先判断下有没有数据可以进行读取
  61.    if(cnt>(pcdevp->data_len/*先有数据*/ - pos/**/)){
  62.       cnt=pcdevp->data_len-pos;
  63.    }
  64.    ret=copy_to_user(buf,pcdevp->kbuf+pos,cnt);
  65.    
  66.    *offset += cnt;
  67.    
  68.    return ret;
  69. }
  70. int cdd_write(struct file *filp,const char __user *buf,
  71.              size_t count,loff_t *offset){
  72.    printk("enter cdd_write!\n");
  73.    int  ret=0;
  74.    u32 pos=*offset;
  75.    u32 cnt =count;
  76.   
  77.    if(cnt > (BUF_SIZE - pos)){
  78.       cnt =　BUF_SIZE - pos;
  79.    }
  80.    copy_from_user(pcdevp->kbuf+pos,buf,cnt);
  81.    *offset += cnt;
  82.    if(*offset > pcdevp->data_len){
  83.       pcdevp->data_len = *offset
  84.     }
  85.    return ret;
  86. }
  87. int cdd_ioctl(struct inode *inode,struct file *filp,
  88.               unsigned int cmd ,unsigned data){
  89.     printk("enter cdd_ioctl!\n");
  90.     switch(cmd){
  91.        case 1:/*点亮灯*/
  92.             /*
  93.             *gpio_direction_output(int gpio,int v);
  94.             *设置管脚为输出功能
  95.             *gpio要设置的管教编号
  96.             *v 默认的高低电平 1高 0低
  97.             */
  98.             gpio_direction_output(led_gpio_table[data],0);
  99.              /*禁止内部上拉*/
  100.             s3c_gpio_setpull(led_gpio_table[data],S3C_GPIO_PULL_UP);
  101.             /*设置输出值*/
  102.             gpio_set_value(led_gpio_table[data],1);
  103.             break; 
  104.        case 0:/*熄灭灯*/
  105.             
  106.             /*设置管脚为输出功能*/
  107.             gpio_direction_output(led_gpio_table[data],0);
  108.              /*禁止内部上拉*/
  109.             s3c_gpio_setpull(led_gpio_table[data],S3C_GPIO_PULL_UP);
  110.             /*设置输出值*/
  111.             gpio_set_value(led_gpio_table[data],0);       
  112.             break;
  113.        default:
  114.           return -EINVAL;
  115.     }
  116.     return 0;
  117. }
  118. int cdd_release(struct inode *inode,struct file *filp){
  119.     printk("enter cdd_release!\n");
  120.     return 0;
  121. }
  122. loff_t cdd_llseek(struct file *filp,loff_t offset,int whence){
  123.   struct cdd_cdev *pcdevp=filp->private_data;
  124.   loff_t newpos=0l
  125.   switch(whence){
  126.     case SEEK_SET:
  127.       newpos=offset;
  128.       break;
  129.     case  SEEK_CUR:
  130.       newpos=filp->fops+offset;
  131.       break;
  132.     case SEEK_END:
  133.       newpos=pcdevp->data_len+offset;
  134.       break;
  135.     default:
  136.       return -EINVAL;
  137.   }
  138.   if(newpos<0 || newpos>=BUF_SIZE){
  139.      return -EINVAL;  
  140.   }
  141.   filp->f_ops=newpos;
  142.   return newpos;
  143. }
  144. struct file_operations cdd_fops={
  145.   .owner = THIS_MODULE,
  146.   .open=cdd_open,
  147.   .read=cdd_read,
  148.   .write=cdd_write,
  149.   .ioctl=cdd_ioctl,
  150.   .release=cdd_release,
  151.   .llseek=cdd_llseek,
  152. };
  153. int __init cdd_init(void){
  154.   int ret =0;
  155.   int i;
  156.   if(cdd_major){
  157.      //静态方式分配设备号
  158.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  159.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  160.   }else{
  161.     /*动态分配设备号*/
  162.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  163.   }
  164.   
  165.   if(ret<0){
  166.      prink("register_chrdev_region failed!\n");
  167.      goto failure_register_chrdev;
  168.   }
  169.   /*获取主设备号*/
  170.   cdd_major=MAJOR(dev);
  171. /*1*/
  172.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  173.   if(IS_ERR(cdd_cdevp)){
  174.      printk("kzalloc fail");
  175.      goto failure_kzalloc;
  176.   }
  177.   /*创建设备类*/
  178.   dev_class = class_create(THIS_MODULE,"cdd_class");
  179.   if(IS_ERR(dev_class)){
  180.     printk("class_create failed!\n");
  181.     ret=PTR_ERR(dev_class);
  182.     goto failure_dev_class;
  183.   }
  184.   
  185.   for(i=0;i<CDD_COUNT;i++){
  186.      /*初始化cdev*/
  187.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  188.      /*添加cdev到内核*/
  189.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  190.      /*"/dev/xxx"*/
  191.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  192.      cdd_cdevp[i].led=i;
  193.   }
  194.   return 0;
  195. failure_dev_class:
  196.   kfree(cdd_cdevp);
  197. failure_kzalloc:
  198.   unregister_chrdev_region(dev,CDD_COUNT);
  199. failure_register_chrdev:
  200.   return ret;
  201. }
  202. void __exit cdd_exit(void){
  203.   int i=0;
  204.   for(i=0;i<CDD_COUNT;i++){
  205.     device_destroy(dev_class,dev+i);
  206.     cdev_del（*(cdd_cdevp[i].cdev)）;
  207.     
  208.   }
  209.   /*从内核中删除设备类*/
  210.   class_destroy(dev_class);
  211.   kfree(cdd_cdevp);
  212.   /*注销设备号*/
  213.   unregister_chrdev_region(dev,CDD_COUNT);
  214. }
  215. module_init(cdd_init);
  216. moudle_exit(cdd_exit);
应用程序中调用ioctl就可以实现LED的亮灭
/*
!arm :历史命令就是 在shell中调用最近一次的arm开头指令
*/
上述程序会出现一大堆信息,但是还是能够实现亮和灭

多个设备使用LED的时候会发生穿线的现象
led_open中添加
gpio_request(led_gpiotable[0],"GPC1_3");
led_release中添加
gpio_free(led_gpiotable[0])

驱动程序的调试
    printk
    Oops: 
    kgdb
内核奔溃前会打印关键信息
pc:[<bf0000b8>]    ->    地址
##cat /proc/kallsyms >test.txt
代码崩溃在cdd.c文件的哪个函数中
3G-4G内核地址：模块编译是没有在3-4G中，编译进zImage才是3-4G
 arm-linux-objdump -D cdd.ko >test2.txt
 arm-linux-objdump -D vmlinux >test3.txt

    编译地址    
 
















嵌入式学习——硬件（Linux内核驱动编程LED、蜂鸣器、按键）——day59
qq_47798402的博客
07-05 312
3. LED标准字符设备驱动（省去在linux终端mknod的过程，直接insmod的即可运行程序）1. 编写LED驱动（初始化所有子设备号）2. 编写LED驱动（初始化一个子设备号）5. 按键（轮询查看按键）——混杂设备驱动。4. 蜂鸣器——混杂设备驱动。
嵌入式学习——硬件（Linux内核驱动编程中断、队列、ADC）——day60
qq_47798402的博客
07-05 396
1.按键（中断处理）——混杂设备驱动。3. ADC中断队列——混杂设备驱动。2. 按键队列——混杂设备驱动。
STM32嵌入式基础开发01-点亮LED灯（1_LED）
Morven
01-13 1150
      博客内容基于STM32F103 RET6芯片，点亮PC3引脚LED灯，程序主要参考B站：STM32F103开发课程视频。       主程序（Main.c）： //================================================ // 该程序用于STM32F103芯片，点亮PC3引脚LED灯 // 作者： Morven_X //
嵌入式linux控制led单个灯亮,嵌入式学习之ARM开发板上利用按键产生的终端控制led灯的亮和灭...
weixin_36463451的博客
05-09 914
实践：按动K1按键，LED1亮，按动K1按键，LED1亮，按动K1按键，LED1亮，按动K1按键，LED1亮，按动K1按键，LED1亮，#include #include #include "def.h"#include "2440addr.h"#include "2440lib.h"#include "2440slib.h"#include "mmu.h"#include "def.h"#inc...
嵌入式：驱动开发 Day3
jx4252的博客
09-12 226
嵌入式：驱动开发 Day3
嵌入式：驱动开发 Day4
jx4252的博客
09-13 534
嵌入式：驱动开发 Day4
嵌入式学习 day57 驱动-驱动框架
2301_81142331的博客
08-22 588
驱动开发
嵌入式驱动day01
晴天
01-15 233
1.编写一个简单的驱动代码，在内核态运行的helloworld #include #include int __init helloworld_init(void)｛ printk("hello world\n"); return 0;｝void __exit helloworld_exit(void){ printk("bye bye\n");}moudle_init(hell
嵌入式学习 day58 驱动字符设备驱动
2301_81142331的博客
08-25 644
字符设备驱动编写
嵌入式硬件day3
lc66_的博客
03-16 238
就是 异步全双工串行通信。
嵌入式学习day01
weixin_70912462的博客
07-16 415
专业定义: 以应用为中心，以计算机技术为基础，软硬件可裁剪，对功能，可靠性，成本，体积， 功耗等严格要求的专用计算机系统。简单理解：除PC外，一切针对控制类的硬件设备开发都可以称为嵌入式开发，嵌入式系统往往是要 包含一个可用于编程控制的开发板及外围器件组成。
linux嵌入式，DAY5
m0_67411840的博客
04-02 702
将自定义脚本或第三方工具的目录加入。
嵌入式系统驱动视频初级+高级.zip
02-08
day05 字符设备驱动基础中_IO模型 day06 字符设备驱动基础下_并发控制 day07 内核定时器 day08 内核内存管理 day09 设备树 day10 中断处理上_基础框架 day11 中断处理下_下半部机制 课件资料 高级： day01 设备模型 ...
day33:零基础学嵌入式之网络-HTTP服务端
07-25
同时，在不影响服务稳定性的前提下，合理使用异步IO和事件驱动编程技术，可以有效提升并发处理能力。 最后，随着物联网技术的发展，嵌入式设备越来越多地被连接到互联网，作为HTTP服务端的嵌入式系统也愈加重要。...
indispensable-tvosx64-3.14.0-javadoc.jar
09-13
indispensable-tvosx64-3.14.0-javadoc.jar
appsync-0.13.0-beta.jar
09-13
appsync-0.13.0-beta.jar
如官网下载不了的，直接下载安装包
最新发布
09-13
如官网下载不了的，直接下载安装包
pic-smaller.zip
09-13
这款图片压缩工具支持 JPG、PNG、WEBP、GIF、SVG 等多种格式，能够进行批量处理，并提供可调节的压缩选项。它完全在浏览器中运行，免费使用，无需注册。
【scratch2.0少儿编程-游戏原型-动画-项目源码】键盘控制的画笔.zip
09-13
资源说明： 1：本资料仅用作交流学习参考，请切勿用于商业用途。更多精品资源请访问 https://blog.youkuaiyun.com/ashyyyy/article/details/146464041 2：一套精品实用scratch2.0少儿编程游戏、动画源码资源，无论是入门练手还是项目复用都超实用，省去重复开发时间，让开发少走弯路！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值