嵌入式驱动day04

最新推荐文章于 2023-09-13 21:11:34 发布
最新推荐文章于 2023-09-13 21:11:34 发布
阅读量180 收藏
点赞数
分类专栏： Device
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011411117/article/details/79069498
版权
复习day03
1.内核定时器
struct timer_list{
    expires
    function
    data
}
jiffies
init_timer
add_timer
del_timer
mod_timer
2.系统调用
如何实现？
    从用户态能够切换到内核的方法
         系统调用
         中断
3.字符设备驱动框架
    struct cdev{
         ...
         dev_t dev;//设备号
         file_operations fops*;
         ...
    }
    设备号=主设备好+次设备号
    主设备号：代表一类设备
    次设备号：用于区分同类设备中不同的个体

    静态分配      register_chrdev_region()
    动态分配     alloc_chrdev_region()

    cdev的操作
         cdev_init(*cdev,*file_operations)
         cdev_add(...)
         cdev_del(..)
    struct file_operations{
         .owner =THIS_MODULE,
    }
    insmod cdd.ko
    mknod /dev/cdd c 248 0
    ./test
--------------------------------------------------------------------------------------- 

   
   
  1. #include<linux/init.h>
  2. #include<linux/module.h>
  3. #include<linux/fs.h>
  4. #include<linux/cdev.h>
  5. MODULE_LICENSE("GPL");
  6. #define CDD_MAJOR 200
  7. #define CDD_MINOR 0
  8. #define CDD_COUNT 1
  9. dev_t dev=0;
  10. u32 cdd_major=0;
  11. u32 cdd_minor=0;
  12. /*定义cdev类型的变量*/
  13. struct cdev cdd_cdev;
  14. int cdd_open(struct inode *inode,struct file *filp){
  15.   printk("enter cdd_open\n");
  16.   return 0;
  17. }
  18. int cdd_read(struct file* filp,char __user *buf,size_t count,
  19.             loff_t *offset){
  20.   printk("enter cdd_read\n");
  21.   return 0;
  22. }
  23. int cdd_write(struct file *filp,const char __user *buf,
  24.              size_t count,loff_t *offset){
  25.    printk("enter cdd_write!\n");
  26.    return 0;
  27. }
  28. int cdd_ioctl(struct inode *inode,struct file *filp,
  29.               unsigned int cmd ,unsigned data){
  30.     printk("enter cdd_ioctl!\n");
  31.     return 0;
  32. }
  33. int cdd_release(struct inode *inode,struct file *filp){
  34.     printk("enter cdd_release!\n");
  35.     return 0;
  36. }
  38. struct file_operations cdd_fops={
  39.   .owner = THIS_MODULE,
  40.   .open=cdd_open,
  41.   .read=cdd_read,
  42.   .write=cdd_write,
  43.   .ioctl=cdd_ioctl,
  44.   .release=cdd_release,
  45. };
  46. int __init cdd_init(void){
  47.   int ret =0;
  48.   if(cdd_major){
  49.      //静态方式分配设备号
  50.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  51.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  52.   }else{
  53.     /*动态分配设备号*/
  54.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  55.   }
  56.   
  57.   if(ret<0){
  58.      prink("register_chrdev_region failed!\n");
  59.      goto failure_register_chrdev;
  60.   }
  61.   /*获取主设备号*/
  62.   cdd_major=MAJOR(dev);
  63.   /*初始化cdev
  64.   *cdev_int(struct cdev* dev,const struct file_operations* fops) 
  65.   */
  66.   cdev_int(&dev,&cdd_fops) ;
  67.   /*添加cdev到内核中
  68.   *cdev_add(struct cdev*p,dev_t dev ,unsigned count)
  69.   */
  70.   ret=cdev_add(&cdev,dev,CDD_COUNT);
  71.   if(ret<0){
  72.     printk("cdev_add failed!\n");
  73.     goto failure_cdev_add;
  74.   }
  75.   return 0;
  76. failure_cdv_add:
  77.   unregister_chrdev_region(dev,CDD_COUNT);
  78. failure_register_chrdev:
  79.   return ret;
  80. }
  81. void __exit cdd_exit(void){
  82.   /*从内核中删除cdev*/
  83.   cdev_del(&cdd_cdev);
  84.   /*注销设备号*/
  85.   unregister_chrdev_region(dev,CDD_COUNT);
  86. }
  87. module_init(cdd_init);
  88. moudle_exit(cdd_exit);

test.c 
   
   
  1. #include<stdio.h>
  2. #include<fcntl.h>
  3. #include<stdlib.h>
  4. int fd =0;
  5. int main(void){
  6.   char ch;
  7.   char buf[10];
  8.   fd=open("/dev/cdd",O_RDWR);
  9.   if(fd<0){
  10.     printf("open failed!\n");
  11.     return -1;
  12.   }
  13.   printf("open successed fd =%d",fd);
  14.   while(1){
  15.     printf("string to test /dev/cdd...\n");
  16.     ch=getchar();
  17.     getchar();
  18.     if(ch=='q'){
  19.        break;
  20.     }
  21.     switch(ch){
  22.        case 'r': read(fd,buf,0);break;
  23.        case 'w': write(fd,buf,0);break;
  24.        case 'o': ioctl(fd,0,0);break;
  25.        default:
  26.          break;
  27.     }
  28.     sleep(1);
  29.   }
  30.   close(fd);
  31.   return 0;
  32. }
insmod cdd.ko
mknod /dev/cdd c 248 0

用户空间open调用到内核中的cdd_open
open
----------------
    sys_open
         ->do_sys_open
              ->do_filp_open
                   ->do_last
                        ->nameidat_to_filp
                             ->__dentry_open
                                  ->chrdev_open
                                       ->filp->f_op->open(cdd_open)
思考:/dev/cdd 起到的作用? 通道？

手工创建节点
    mknod 
自动创建设备结点 
   
   
  1. #include<linux/init.h>
  2. #include<linux/module.h>
  3. #include<linux/fs.h>
  4. #include<linux/cdev.h>
  5. #include<linux/device.h>
  6. //动态申请的头文件
  7. #include<linux/slab.h>
  8. MODULE_LICENSE("GPL");
  9. #define CDD_MAJOR 200
  10. #define CDD_MINOR 0
  11. #define CDD_COUNT 10
  12. dev_t dev=0;
  13. u32 cdd_major=0;
  14. u32 cdd_minor=0;
  15. /*定义cdev类型的变量*/
  16. struct cdev cdd_cdev;
  17. struct class *dev_class=NULL;
  18. //struct device *dev_device=NULL;
  19. struct cdd_cdev{
  20.  struct cdev cdev;
  21.  struct device *dev_device;
  22.  u8 led;
  23. };
  24. struct cdd_cdev *cdd_cdevp=NULL;
  25. int cdd_open(struct inode *inode,struct file *filp){
  26.   printk("enter cdd_open\n");
  27.   return 0;
  28. }
  29. int cdd_read(struct file* filp,char __user *buf,size_t count,
  30.             loff_t *offset){
  31.   printk("enter cdd_read\n");
  32.   return 0;
  33. }
  34. int cdd_write(struct file *filp,const char __user *buf,
  35.              size_t count,loff_t *offset){
  36.    printk("enter cdd_write!\n");
  37.    return 0;
  38. }
  39. int cdd_ioctl(struct inode *inode,struct file *filp,
  40.               unsigned int cmd ,unsigned data){
  41.     printk("enter cdd_ioctl!\n");
  42.     return 0;
  43. }
  44. int cdd_release(struct inode *inode,struct file *filp){
  45.     printk("enter cdd_release!\n");
  46.     return 0;
  47. }
  48. struct file_operations cdd_fops={
  49.   .owner = THIS_MODULE,
  50.   .open=cdd_open,
  51.   .read=cdd_read,
  52.   .write=cdd_write,
  53.   .ioctl=cdd_ioctl,
  54.   .release=cdd_release,
  55. };
  56. int __init cdd_init(void){
  57.   int ret =0;
  58.   int i;
  59.   if(cdd_major){
  60.      //静态方式分配设备号
  61.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  62.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  63.   }else{
  64.     /*动态分配设备号*/
  65.     ret =alloc_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  66.   }
  67.   
  68.   if(ret<0){
  69.      prink("register_chrdev_region failed!\n");
  70.      goto failure_register_chrdev;
  71.   }
  72.   /*获取主设备号*/
  73.   cdd_major=MAJOR(dev);
  74.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  75.   if(IS_ERR(cdd_cdevp)){
  76.      printk("kzalloc fail");
  77.      goto failure_kzalloc;
  78.   }
  79.   /*创建设备类*/
  80.   dev_class = class_create(THIS_MODULE,"cdd_class");
  81.   if(IS_ERR(dev_class)){
  82.     printk("class_create failed!\n");
  83.     ret=PTR_ERR(dev_class);
  84.     goto failure_dev_class;
  85.   }
  86.   
  87.   for(i=0;i<CDD_COUNT;i++){
  88.      /*初始化cdev*/
  89.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  90.      /*添加cdev到内核*/
  91.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  92.      /*"/dev/xxx"*/
  93.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  94.   }
  95.   return 0;
  96. failure_dev_class:
  97.   kfree(cdd_cdevp);
  98. failure_kzalloc:
  99.   unregister_chrdev_region(dev,CDD_COUNT);
  100. failure_register_chrdev:
  101.   return ret;
  102. }
  103. void __exit cdd_exit(void){
  104.   int i=0;
  105.   for(i=0;i<CDD_COUNT;i++){
  106.     device_destroy(dev_class,dev+i);
  107.     cdev_del(*(cdd_cdevp[i].cdev));
  108.     
  109.   }
  110.   /*从内核中删除设备类*/
  111.   class_destroy(dev_class);
  112.   kfree(cdd_cdevp);
  113.   /*注销设备号*/
  114.   unregister_chrdev_region(dev,CDD_COUNT);
  115. }
  116. module_init(cdd_init);
  117. moudle_exit(cdd_exit);自动创建设备节点文件的方式
    用户态的程序创建的设备节点文件
    udev(mdev嵌入式使用),根据/sys/的变化，动态在目录下
    创建设备节点文件。
    (pc环境下)
    udev ,后台守护进程接收uevent事件，
            device_create会发出该事件
            udev会根据事件信息创建/dev/cdd0
    (嵌入式环境下)
    mdev,device_create函数会直接调用/sbin/mdev程序下
            来创建设备节点文件。
            
    /proc ->procfs 导出内核运行状态信息
    /sys  ->sysfs 重点在于导出内核中所有硬件设备的结构层次图
    这两个目录都是虚拟目录
--------------------------------------------------------------------------------
支持多设备去驱动 
   
   
  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. //动态申请的头文件
  7. #include<linux/slab.h>
  9. MODULE_LICENSE("GPL");
  10. #define CDD_MAJOR 200
  11. #define CDD_MINOR 0
  13. #define CDD_COUNT 10
  15. dev_t dev=0;
  16. u32 cdd_major=0;
  17. u32 cdd_minor=0;
  18. /*定义cdev类型的变量*/
  19. struct cdev cdd_cdev;
  20. struct class *dev_class=NULL;
  21. //struct device *dev_device=NULL;
  23. struct cdd_cdev{
  24.  struct cdev cdev;
  25.  struct device *dev_device;
  26.  u8 led;
  27. }
  29. struct cdd_cdev *cdd_cdevp=NULL;
  31. int cdd_open(struct inode *inode,struct file *filp){
  32.   printk("enter cdd_open\n");
  33.   return 0;
  34. }
  35. int cdd_read(struct file* filp,char __user *buf,size_t count,
  36.             loff_t *offset){
  37.   printk("enter cdd_read\n");
  38.   return 0;
  39. }
  40. int cdd_write(struct file *filp,const char __user *buf,
  41.              size_t count,loff_t *offset){
  42.    printk("enter cdd_write!\n");
  43.    return 0;
  44. }
  45. int cdd_ioctl(struct inode *inode,struct file *filp,
  46.               unsigned int cmd ,unsigned data){
  47.     printk("enter cdd_ioctl!\n");
  48.     return 0;
  49. }
  50. int cdd_release(struct inode *inode,struct file *filp){
  51.     printk("enter cdd_release!\n");
  52.     return 0;
  53. }
  54. struct file_operations cdd_fops={
  55.   .owner = THIS_MODULE,
  56.   .open=cdd_open,
  57.   .read=cdd_read,
  58.   .write=cdd_write,
  59.   .ioctl=cdd_ioctl,
  60.   .release=cdd_release,
  61. };
  62. int __init cdd_init(void){
  63.   int ret =0;
  64.   int i;
  65.   if(cdd_major){
  66.      //静态方式分配设备号
  67.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  68.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  69.   }else{
  70.     /*动态分配设备号*/
  71.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  72.   }
  73.   
  74.   if(ret<0){
  75.      prink("register_chrdev_region failed!\n");
  76.      goto failure_register_chrdev;
  77.   }
  78.   /*获取主设备号*/
  79.   cdd_major=MAJOR(dev);
  81.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  82.   if(IS_ERR(cdd_cdevp)){
  83.      printk("kzalloc fail");
  84.      goto failure_kzalloc;
  85.   }
  86.   /*创建设备类*/
  87.   dev_class = class_create(THIS_MODULE,"cdd_class");
  88.   if(IS_ERR(dev_class)){
  89.     printk("class_create failed!\n");
  90.     ret=PTR_ERR(dev_class);
  91.     goto failure_dev_class;
  92.   }
  93.   
  94.   for(i=0;i<CDD_COUNT;i++){
  95.      /*初始化cdev*/
  96.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  97.      /*添加cdev到内核*/
  98.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  99.      /*"/dev/xxx"*/
  100.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  101.   }
  104.   return 0;
  105. failure_dev_class:
  106.   kfree(cdd_cdevp);
  107. failure_kzalloc:
  108.   unregister_chrdev_region(dev,CDD_COUNT);
  109. failure_register_chrdev:
  110.   return ret;
  111. }
  112. void __exit cdd_exit(void){
  113.   int i=0;
  114.   for(i=0;i<CDD_COUNT;i++){
  115.     device_destroy(dev_class,dev+i);
  116.     cdev_del（*(cdd_cdevp[i].cdev)）;
  117.     
  118.   }
  120.   /*从内核中删除设备类*/
  121.   class_destroy(dev_class);
  122.   kfree(cdd_cdevp);
  123.   /*注销设备号*/
  124.   unregister_chrdev_region(dev,CDD_COUNT);
  125. }
  126. module_init(cdd_init);
  127. moudle_exit(cdd_exit);

添加修改
   设备节点文件                     内核中
    /dev/cdd0                           cdev0        led=0
   /dev/cdd1                            cdev1        led=1
  ...                                             ...                     ...    
   /dev/cdd9                            cdev9        led=9

open("/dev/cdd0")
cdd_open(struct inode *inode,struct file *filp )
uc中打开一个文件
推荐一本书<unix高级环境编程> 

   
   
  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. //动态申请的头文件
  7. #include<linux/slab.h>
  8. MODULE_LICENSE("GPL");
  9. #define CDD_MAJOR 200
  10. #define CDD_MINOR 0
  11. #define CDD_COUNT 10
  12. dev_t dev=0;
  13. u32 cdd_major=0;
  14. u32 cdd_minor=0;
  15. /*定义cdev类型的变量*/
  16. struct cdev cdd_cdev;
  17. struct class *dev_class=NULL;
  18. //struct device *dev_device=NULL;
  19. struct cdd_cdev{
  20.  struct cdev cdev;
  21.  struct device *dev_device;
  22.  u8 led;
  23. }
  24. struct cdd_cdev *cdd_cdevp=NULL;
  25. int cdd_open(struct inode *inode,struct file *filp){
  26.   printk("enter cdd_open\n");
  27.   return 0;
  28. }
  29. int cdd_read(struct file* filp,char __user *buf,size_t count,
  30.             loff_t *offset){
  31.   printk("enter cdd_read\n");
  32.   return 0;
  33. }
  34. int cdd_write(struct file *filp,const char __user *buf,
  35.              size_t count,loff_t *offset){
  36.    printk("enter cdd_write!\n");
  37.    return 0;
  38. }
  39. int cdd_ioctl(struct inode *inode,struct file *filp,
  40.               unsigned int cmd ,unsigned data){
  41.     printk("enter cdd_ioctl!\n");
  42.     return 0;
  43. }
  44. int cdd_release(struct inode *inode,struct file *filp){
  45.     printk("enter cdd_release!\n");
  46.     return 0;
  47. }
  48. struct file_operations cdd_fops={
  49.   .owner = THIS_MODULE,
  50.   .open=cdd_open,
  51.   .read=cdd_read,
  52.   .write=cdd_write,
  53.   .ioctl=cdd_ioctl,
  54.   .release=cdd_release,
  55. };
  56. int __init cdd_init(void){
  57.   int ret =0;
  58.   int i;
  59.   if(cdd_major){
  60.      //静态方式分配设备号
  61.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  62.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  63.   }else{
  64.     /*动态分配设备号*/
  65.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  66.   }
  67.   
  68.   if(ret<0){
  69.      prink("register_chrdev_region failed!\n");
  70.      goto failure_register_chrdev;
  71.   }
  72.   /*获取主设备号*/
  73.   cdd_major=MAJOR(dev);
  74.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  75.   if(IS_ERR(cdd_cdevp)){
  76.      printk("kzalloc fail");
  77.      goto failure_kzalloc;
  78.   }
  79.   /*创建设备类*/
  80.   dev_class = class_create(THIS_MODULE,"cdd_class");
  81.   if(IS_ERR(dev_class)){
  82.     printk("class_create failed!\n");
  83.     ret=PTR_ERR(dev_class);
  84.     goto failure_dev_class;
  85.   }
  86.   
  87.   for(i=0;i<CDD_COUNT;i++){
  88.      /*初始化cdev*/
  89.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  90.      /*添加cdev到内核*/
  91.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  92.      /*"/dev/xxx"*/
  93.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  94.      cdd_cdevp[i].led=i;
  95.   }
  96.   return 0;
  97. failure_dev_class:
  98.   kfree(cdd_cdevp);
  99. failure_kzalloc:
  100.   unregister_chrdev_region(dev,CDD_COUNT);
  101. failure_register_chrdev:
  102.   return ret;
  103. }
  104. void __exit cdd_exit(void){
  105.   int i=0;
  106.   for(i=0;i<CDD_COUNT;i++){
  107.     device_destroy(dev_class,dev+i);
  108.     cdev_del（*(cdd_cdevp[i].cdev)）;
  109.     
  110.   }
  111.   /*从内核中删除设备类*/
  112.   class_destroy(dev_class);
  113.   kfree(cdd_cdevp);
  114.   /*注销设备号*/
  115.   unregister_chrdev_region(dev,CDD_COUNT);
  116. }
  117. module_init(cdd_init);
  118. moudle_exit(cdd_exit);
文件表
 struct inode
{
     dev_t    i_rdev;//记录设备号
     union{
        struct pipe_inode_info *i_pipe;
        struct cdev  *i_cdev;//指向了cdev_add时添加的cdev
     }
} 

   
   
  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. //动态申请的头文件
  7. #include<linux/slab.h>
  8. MODULE_LICENSE("GPL");
  9. #define CDD_MAJOR 200
  10. #define CDD_MINOR 0
  11. #define CDD_COUNT 10
  12. dev_t dev=0;
  13. u32 cdd_major=0;
  14. u32 cdd_minor=0;
  15. /*定义cdev类型的变量*/
  16. struct cdev cdd_cdev;
  17. struct class *dev_class=NULL;
  18. //struct device *dev_device=NULL;
  19. struct cdd_cdev{
  20.  struct cdev cdev;
  21.  struct device *dev_device;
  22.  u8 led;
  23. }
  24. struct cdd_cdev *cdd_cdevp=NULL;
  25. int cdd_open(struct inode *inode,struct file *filp){
  26.   printk("enter cdd_open\n");
  29.   struct cdd_cdev* pcdevp=NULL;
  30.   printk("enter cdd_open\n");
  31.   pcdevp = container_of(inode->i_cdev,struct cdd_cdev,cdev);
  32.   printk("led=%d\n",pcdevp->led);
  34.   return 0;
  35. }
  36. int cdd_read(struct file* filp,char __user *buf,size_t count,
  37.             loff_t *offset){
  38.   printk("enter cdd_read\n");
  39.   return 0;
  40. }
  41. int cdd_write(struct file *filp,const char __user *buf,
  42.              size_t count,loff_t *offset){
  43.    printk("enter cdd_write!\n");
  44.    return 0;
  45. }
  46. int cdd_ioctl(struct inode *inode,struct file *filp,
  47.               unsigned int cmd ,unsigned data){
  48.     printk("enter cdd_ioctl!\n");
  49.     return 0;
  50. }
  51. int cdd_release(struct inode *inode,struct file *filp){
  52.     printk("enter cdd_release!\n");
  53.     return 0;
  54. }
  55. struct file_operations cdd_fops={
  56.   .owner = THIS_MODULE,
  57.   .open=cdd_open,
  58.   .read=cdd_read,
  59.   .write=cdd_write,
  60.   .ioctl=cdd_ioctl,
  61.   .release=cdd_release,
  62. };
  63. int __init cdd_init(void){
  64.   int ret =0;
  65.   int i;
  66.   if(cdd_major){
  67.      //静态方式分配设备号
  68.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  69.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  70.   }else{
  71.     /*动态分配设备号*/
  72.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  73.   }
  74.   
  75.   if(ret<0){
  76.      prink("register_chrdev_region failed!\n");
  77.      goto failure_register_chrdev;
  78.   }
  79.   /*获取主设备号*/
  80.   cdd_major=MAJOR(dev);
  81.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  82.   if(IS_ERR(cdd_cdevp)){
  83.      printk("kzalloc fail");
  84.      goto failure_kzalloc;
  85.   }
  86.   /*创建设备类*/
  87.   dev_class = class_create(THIS_MODULE,"cdd_class");
  88.   if(IS_ERR(dev_class)){
  89.     printk("class_create failed!\n");
  90.     ret=PTR_ERR(dev_class);
  91.     goto failure_dev_class;
  92.   }
  93.   
  94.   for(i=0;i<CDD_COUNT;i++){
  95.      /*初始化cdev*/
  96.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  97.      /*添加cdev到内核*/
  98.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  99.      /*"/dev/xxx"*/
  100.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  101.      cdd_cdevp[i].led=i;
  102.   }
  103.   return 0;
  104. failure_dev_class:
  105.   kfree(cdd_cdevp);
  106. failure_kzalloc:
  107.   unregister_chrdev_region(dev,CDD_COUNT);
  108. failure_register_chrdev:
  109.   return ret;
  110. }
  111. void __exit cdd_exit(void){
  112.   int i=0;
  113.   for(i=0;i<CDD_COUNT;i++){
  114.     device_destroy(dev_class,dev+i);
  115.     cdev_del（*(cdd_cdevp[i].cdev)）;
  116.     
  117.   }
  118.   /*从内核中删除设备类*/
  119.   class_destroy(dev_class);
  120.   kfree(cdd_cdevp);
  121.   /*注销设备号*/
  122.   unregister_chrdev_region(dev,CDD_COUNT);
  123. }
  124. module_init(cdd_init);
  125. moudle_exit(cdd_exit);
上面代码在open中确定用户中打开哪个设备
--------------------------------------------------------------------
用户空间操作的设备在read函数中实现知道那个设备
struct filp{
    loff_t    f_ops;
}
fd5=open("/dev/cdd5")    struct file    filp5
read(fd5,....)
    cdd_read()

cdd_open中添加
   filp->private_data = pcdevp ;
cdd_read
    -----------------------------------------------------------------------
4.内核空间和用户空间数据交互问题
   内核态数据向用户态拷贝 copy_to_user(.....)
    用户态数据向内核态拷贝    copy_from_user(....)
    定义在arch/arm/include/asm/uaccess.h 

  
  
  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>
  7. #include<asm/uaccess.h>//用户空间拷贝头文件
  10. //动态申请的头文件
  11. #include<linux/slab.h>
  12. MODULE_LICENSE("GPL");
  13. #define CDD_MAJOR 200
  14. #define CDD_MINOR 0
  15. #define CDD_COUNT 10
  16. dev_t dev=0;
  17. u32 cdd_major=0;
  18. u32 cdd_minor=0;
  19. /*定义cdev类型的变量*/
  20. struct cdev cdd_cdev;
  21. struct class *dev_class=NULL;
  22. //struct device *dev_device=NULL;
  24. #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. }
  32. struct cdd_cdev *cdd_cdevp=NULL;
  33. int cdd_open(struct inode *inode,struct file *filp){
  34.   printk("enter cdd_open\n");
  35.   struct cdd_cdev* pcdevp=NULL;
  36.   printk("enter cdd_open\n");
  37.   pcdevp = container_of(inode->i_cdev,struct cdd_cdev,cdev);
  38.   printk("led=%d\n",pcdevp->led);
  40.  filp->private_data = pcdevp;
  42.   return 0;
  43. }
  44. int cdd_read(struct file* filp,char __user *buf,size_t count,
  45.             loff_t *offset){
  47.    int ret=0
  48.    struct cdd_cdev* pcdevp = filp->private_data;
  49.    printk("LED%d\n",pcdevp->led);
  51.    //copy_to_user(to,from,n);
  52.    ret=copy_to_user(buf,pcdevp->kbuf,count);
  54.    return ret;
  55. }
  56. int cdd_write(struct file *filp,const char __user *buf,
  57.              size_t count,loff_t *offset){
  58.    printk("enter cdd_write!\n");
  59.    int  ret=0;
  60.    copy_from_user(pcdevp->kbuf,buf,count);
  61.    return ret;
  62. }
  63. int cdd_ioctl(struct inode *inode,struct file *filp,
  64.               unsigned int cmd ,unsigned data){
  65.     printk("enter cdd_ioctl!\n");
  66.     return 0;
  67. }
  68. int cdd_release(struct inode *inode,struct file *filp){
  69.     printk("enter cdd_release!\n");
  70.     return 0;
  71. }
  72. struct file_operations cdd_fops={
  73.   .owner = THIS_MODULE,
  74.   .open=cdd_open,
  75.   .read=cdd_read,
  76.   .write=cdd_write,
  77.   .ioctl=cdd_ioctl,
  78.   .release=cdd_release,
  79. };
  80. int __init cdd_init(void){
  81.   int ret =0;
  82.   int i;
  83.   if(cdd_major){
  84.      //静态方式分配设备号
  85.      dev=MKDEV(CDD_MAJOR,CDD_MINOR)；
  86.      ret =register_chrdev_region(dev,CDD_COUNT,cdd_demo);
  87.   }else{
  88.     /*动态分配设备号*/
  89.     ret =all_chrdev_region(&dev,cdd_minor,CDD_COUNT,cdd_demo);
  90.   }
  91.   
  92.   if(ret<0){
  93.      prink("register_chrdev_region failed!\n");
  94.      goto failure_register_chrdev;
  95.   }
  96.   /*获取主设备号*/
  97.   cdd_major=MAJOR(dev);
  98.   cdd_cdevp=kzalloc(sizeof(struct cdd_cdev)*CDD_COUNT,GFP_KERNEL);
  99.   if(IS_ERR(cdd_cdevp)){
  100.      printk("kzalloc fail");
  101.      goto failure_kzalloc;
  102.   }
  103.   /*创建设备类*/
  104.   dev_class = class_create(THIS_MODULE,"cdd_class");
  105.   if(IS_ERR(dev_class)){
  106.     printk("class_create failed!\n");
  107.     ret=PTR_ERR(dev_class);
  108.     goto failure_dev_class;
  109.   }
  110.   
  111.   for(i=0;i<CDD_COUNT;i++){
  112.      /*初始化cdev*/
  113.      cdev_init(&(cdd_cdevp[i].cdev),&cdd_fops);
  114.      /*添加cdev到内核*/
  115.      cdev_add(&(cdd_cdevp[i].cdev),dev+i,1);
  116.      /*"/dev/xxx"*/
  117.      device_create(dev_class,NULL,dev+i,NULL,"cdd%d",i);
  118.      cdd_cdevp[i].led=i;
  119.   }
  120.   return 0;
  121. failure_dev_class:
  122.   kfree(cdd_cdevp);
  123. failure_kzalloc:
  124.   unregister_chrdev_region(dev,CDD_COUNT);
  125. failure_register_chrdev:
  126.   return ret;
  127. }
  128. void __exit cdd_exit(void){
  129.   int i=0;
  130.   for(i=0;i<CDD_COUNT;i++){
  131.     device_destroy(dev_class,dev+i);
  132.     cdev_del（*(cdd_cdevp[i].cdev)）;
  133.     
  134.   }
  135.   /*从内核中删除设备类*/
  136.   class_destroy(dev_class);
  137.   kfree(cdd_cdevp);
  138.   /*注销设备号*/
  139.   unregister_chrdev_region(dev,CDD_COUNT);
  140. }
  141. module_init(cdd_init);
  142. moudle_exit(cdd_exit);
编写测试程序 
   
   
  1. #include<stdio.h>
  2. #inlcude<fcntl.h>
  3. #inlcude<stdlib.h>
  5. int fd =0;
  6. char rbuf[100];
  7. char wbuf[100]="nihao!\n"
  9. int main(void){
  10.   char ch;
  11.   fd=open("/dev/cdd5",O_RDWR);
  12.   if(fd<0){
  13.     printf("open failed");
  14.     return -1;
  15.   }
  16.   printf("open successed fd=%d\n",fd);
  17.   while(1){
  18.    ch=getchar()
  19.    getchar();
  20.    switch(ch){
  21.      case 'r':
  22.         read(fd,rbuf,100);
  23.         printf("%s",rbuf);
  24.         break;
  25.      case 'w':
  26.         write(fd,wbuf,100);
  27.         break;
  28.      case 'o':
  29.         ioctl(fd,0,0);
  30.         break;
  31.      default:
  32.         break;
  33.    }
  34.   }
  36. }


















技术小青年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式驱动笔记
qq_40866127的博客
06-22 300
Linux驱动开发面试总结 1.Linux设备驱动 （1）字符设备 Linux字符设备是一种按字节访问的设备，字符驱动通常实现open、close、read、write系统调用 例：串口 LED 按键等 应用程序通过设备文件（/dev/xxx）可以使用相应的字符驱动来控制字符设备 创建字符设备文件： (1）使用命令 mknod /dev/文件名 c 主设备号 次设备号 （1 安装驱动模块：insm...
1.嵌入式驱动知识梳理（一）
qq_27221271的博客
05-05 768
        忙活了几天上网查找各种资料，试图搞清，Linux驱动程序究竟是什么样的存在，在整个嵌入式系统中处于什么位置，搞清这个首先就要宏观上把握整个嵌入式系统是什么。        网上资料一大堆，废话连篇，越看越晕，这张图讲的还算比较清晰。        整个嵌入式系统从上到下可以分为应用程序、库、内核、驱动程序以及硬件设备5个部分，为了搞明白各部分之间的关系，在这里要和电脑端的Linux...
linux驱动开发--字符设备：通过cdd_cdev结构中的led变量区分是哪个节点，private_data使用
吴英强的技术博客
12-28 2797
private_data改进 为设备驱动支持多个设备个体做准备，针对private_data进行改进 在设备打开操作中通过inode中保存的i_cdev获取代表当前设备的cdev对象 通过代表当前设备的cdev对象得到包含该对象的设备私有数据结构体 将设备私有数据结构体指针保存到struct file的private_data成员中 在其它设备操作中直接使用保存在struct file的
嵌入式：驱动开发 Day3
jx4252的博客
09-12 127
嵌入式：驱动开发 Day3
嵌入式：驱动开发 Day4
jx4252的博客
09-13 428
嵌入式：驱动开发 Day4
HARDWARE_DS1302驱动_
09-29
在本文中，我们将深入探讨如何使用DS1302时钟芯片，并且了解其驱动程序的实现细节...通过深入理解DS1302的工作原理和驱动程序的实现，开发者可以灵活地将这款RTC芯片集成到各种嵌入式系统中，实现精确的时间管理功能。
达内嵌入式TTS文档
08-22
嵌入式系统是一种在各种设备和机器中运行的...通过这些文档的学习，开发者不仅可以了解TTS技术的基础，还能掌握在嵌入式系统中实现和优化TTS的技能，对于想要在嵌入式驱动开发领域深入的人来说，是非常宝贵的学习资源。
DAY18. 中断处理作业
08-16
中断处理作业"涉及了Linux内核中断处理机制、驱动程序开发以及硬件交互的基本原理，这对于理解操作系统底层运作和嵌入式系统开发具有重要意义。通过这样的实践，我们可以更好地掌握如何利用中断技术实现硬件设备的...
DS1302LCD.rar_嵌入式/单片机/硬件编程_C/C++_
08-12
综上所述，"DS1302LCD.rar"项目涵盖了DS1302实时时钟芯片的使用、串行通信、LCD显示驱动以及时间管理等多个嵌入式开发的关键知识点。通过分析DS1302LCD.c源码，我们可以深入了解这些概念及其在实际应用中的实现。
DAY15. WDT实验作业
08-08
在“DAY15. WDT 实验作业”中，任务是将 WDT 的递减频率设置为 10000Hz，这意味着 WDT 的计时周期为 100μs。然后，你需要编写程序，使得开发板在运行 5 秒（即 5000 次 WDT 计时周期）后自动复位。这个过程涉及两个...
java资源异步HTTP客户端开发包HttpAsyncClient
最新发布
08-21
java资源异步HTTP客户端开发包 HttpAsyncClient提取方式是百度网盘分享地址
[毕业设计]Java构建的安全电子商务身份认证与授权系统(论文).doc
08-21
[毕业设计]Java构建的安全电子商务身份认证与授权系统(论文)
系统架构师学习全套资料，整理不易
08-21
系统架构师学习全套资料，整理不易，包括教程、考试心得，考试要点、真题等 适用人群：架构师考试人群
基于python及opencv的围棋棋盘棋子识别
08-21
python 前提准备 需要安装opencv库 1、test1：单张图片检测 直接运行21_0629_opencv_python_weiqi_test1.py即可。 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
254个人健康信息管理.zip
08-21
随着科学技术的飞速发展，通过科技手段提高自身的优势；对于个人健康信息管理当然也不能排除在外，随着网络技术的不断成熟，带动了个人健康信息管理，它彻底改变了过去传统的管理方式，不仅使服务管理难度变低了，还提升了管理的灵活性。这种个性化的平台特别注重交互协调与管理的相互配合，激发了管理人员的创造性与主动性，对个人健康信息管理而言非常有利。 本系统采用的数据库是Mysql，使用SSM技术开发，在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。
AUTOSAR 配置BSW与MCAL的接口模块的文档
08-21
这篇文档是关于如何使用ETAS的RTA-CAR工具进行微控制器抽象层（MCAL）配置的入门指南。MCAL是软件层，为更高层次的软件提供微控制器硬件的抽象，帮助实现嵌入式软件开发的可移植性和可扩展性。 文档首先介绍了MCAL的各个模块，包括CAN通信、编译器、数字输入/输出（DIO）、闪存（FLS）、通用定时器（GPT）、中断处理（IRQ）、MCAL库（McalLib）、微控制器单元（MCU）、端口接口（PORT）、资源管理（ResourceM）和看门狗定时器（WDG）。每个模块都有其特定的职责，如配置GPIO引脚、管理中断、执行应用程序代码、管理系统资源等。 接下来，文档说明了进行MCAL配置的先决条件，包括安装Tresos和拥有适当的模块和插件，以及导入所需的微控制器项目到RTA-CAR。 文档重点介绍了RTA-CAR的ConfGen功能，该功能可以为现有系统描述中相关的MCAL模块生成通用配置。这些配置是通用的，不特定于任何硬件，也不通过RTA-CAR生成任何MCAL代码。它们仅作为相关BSW模块中配置的参考。用户还可以在RTA-CAR项目中创建一些虚拟的MCAL......
YonBIP V3.0 (R1_2207_1) 高级版产品安装指南.pdf
08-21
YonBIP V3.0 (R1_2207_1) 高级版产品安装指南.pdf
【浏览器插件】飞书剪存.zip
08-21
体验飞书剪存，轻松保存网页精华，告别繁琐的复制粘贴。只需一键操作，即可将您喜爱的网页内容直接保存至飞书云文档。智能过滤技术，自动剔除网页中的广告和无关信息，为您呈现一个纯净、专注的阅读环境。
【泛微OA一级通知】泛微产品相关功能因为高德地图接口限流造成无法进行地图定位问题处理方案.pdf
08-21
【泛微OA一级通知】泛微产品相关功能因为高德地图接口限流造成无法进行地图定位问题处理方案.pdf
ds1302驱动程序
05-28
DS1302是一款实时时钟芯片，常用于嵌入式系统中。下面是一个简单的DS1302驱动程序的示例代码，仅供参考： ```c #include #include #include #include #define DS1302_SCLK_PIN 2 #define DS1302_IO_PIN 3 #...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值