Chinaunix首页 | 论坛 | 博客

Linux_rwl的ChinaUnix博客

首页　| 　博文目录　| 　关于我

rwlcc

  • 博客访问： 133906
  • 博文数量： 49
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 182
  • 用 户 组： 普通用户
  • 注册时间： 2013-03-14 13:22
个人简介

Linux的热爱者

文章分类

全部博文（49）

文章存档

2014年（7）

2013年（42）

我的朋友
最近访客
推荐博文
相关博文
字符设备驱动—2

分类： LINUX

2013-09-25 14:23:50

创建字符设备的三种方法：
1. 使用早期的register_chardev()方法

点击(此处)折叠或打开

  1. #include<linux/kernel.h>
  2. #include<linux/module.h>
  3. #include<linux/fs.h>
  4. #include<asm/uaccess.h>
  5. int init_module(void);
  6. void cleanup_module(void);
  7. static int device_open(struct inode*, struct file*);
  8. static int device_release(struct inode*, struct file*);
  9. static ssize_t device_read(struct file*, char *, size_t, loff_t*);
  10. static ssize_t device_write(struct file*, const char*, size_t, loff_t*);
  11. #define SUCCESS 0
  12. #define DEVICE_NAME "chardev"
  13. #define BUF_LEN 80
  14. static int major;
  15. static int Device_open = 0;
  16. static char msg[BUF_LEN];
  17. static char *msg_ptr;
  18. static struct file_operations fops =
  19. {
  20.         .read = device_read,
  21.         .write = device_write,
  22.         .open = device_open,
  23.         .release = device_release,
  24. };
  25. int init_module(void)
  26. {
  27.         major = register_chrdev(0, DEVICE_NAME, &fops);
  28.         if (major < 0)
  29.         {
  30.                 printk(KERN_ALERT "Registering char device failed with %d\n", major);
  31.                 return major;
  32.         }
  33.         printk(KERN_INFO "I was assigned major number %d.\n", major);
  34.         return SUCCESS;
  35. }
  36. void cleanup_module(void)
  37. {
  38.         int ret = unregister_chrdev(major, DEVICE_NAME);
  39.         if (ret < 0)
  40.         {
  41.                 printk(KERN_ALERT "Error in unregister chrdev %d\n", major);
  42.         }
  43. }
  44. static int device_open(struct inode* inode, struct file* file)
  45. {
  46.         static int counter = 0;
  47.         if (Device_open)
  48.         {
  49.                 return -EBUSY;
  50.         }
  51.         Device_open++;
  52.         sprintf(msg, "I already told you %d times hello world\nDevice_open=%d\n" , counter++, Device_open);
  53.         msg_ptr = msg;
  54.         try_module_get(THIS_MODULE);
  55.         return SUCCESS;
  56. }
  57. static int device_release(struct inode* inode, struct file* file)
  58. {
  59.         Device_open--;
  60.         module_put(THIS_MODULE);
  61.         return 0;
  62. }
  63. static ssize_t device_read(struct file* filp, char *buffer, size_t length, loff_t *offset)
  64. {
  65.         int bytes_read = 0;
  66.         if (*msg_ptr == '\0')
  67.                 return 0;
  68.         printk(KERN_ALERT "length=%d\n", length);
  69.         while (length && *msg_ptr)
  70.         {
  71.                 put_user(*(msg_ptr++), buffer++);
  72.                 length--;
  73.                 bytes_read++;
  74.         }
  75.         return bytes_read;
  76. }
  77. static ssize_t device_write(struct file* filp, const char *buff, size_t len, loff_t *off)
  78. {
  79.         printk(KERN_ALERT "Sorry, this operation isn't supported\n");
  80.         return -EINVAL;
  81. }

2. 使用cdev的方法

点击(此处)折叠或打开

  1. #include<linux/kernel.h>
  2. #include<linux/module.h>
  3. #include<linux/fs.h>
  4. #include<linux/types.h>
  5. #include<linux/fs.h>
  6. #include<linux/cdev.h>
  7. #include<asm/uaccess.h>
  8. int init_module(void);
  9. void cleanup_module(void);
  10. static int device_open(struct inode*, struct file*);
  11. static int device_release(struct inode*, struct file*);
  12. static ssize_t device_read(struct file*, char *, size_t, loff_t*);
  13. static ssize_t device_write(struct file*, const char*, size_t, loff_t*);
  14. #define SUCCESS 0
  15. #define DEVICE_NAME "chardev"
  16. #define BUF_LEN 80

  18. static int major;
  19. static int Device_open = 0;
  20. static char msg[BUF_LEN];
  21. static char *msg_ptr;
  22. static struct cdev *my_cdev;
  23. static struct file_operations fops =
  24. {
  25.         .read = device_read,
  26.         .write = device_write,
  27.         .open = device_open,
  28.         .release = device_release,
  29. };
  30. int init_module(void)
  31. {
  32.         int err;
  33.         dev_t devid ;
  34.         alloc_chrdev_region(&devid, 0, 1, "chardev");
  35.         major = MAJOR(devid);
  36.         my_cdev = cdev_alloc();
  37.         cdev_init(my_cdev, &fops);
  38.         err = cdev_add(my_cdev, devid, 1);
  39.         if (err)
  40.         {
  41.                 printk(KERN_INFO "I was assigned major number %d.\n", major);
  42.                 return -1;
  43.         }
  44.         printk("major number is %d\n", MAJOR(devid));
  45.         return SUCCESS;
  46. }
  47. void cleanup_module(void)
  48. {
  49.         cdev_del(my_cdev);
  50.         printk("cleanup done\n");
  51. }
  52. static int device_open(struct inode* inode, struct file* file)
  53. {
  54.         static int counter = 0;
  55.         if (Device_open)
  56.         {
  57.                 return -EBUSY;
  58.         }
  59.         Device_open++;
  60.         sprintf(msg, "I already told you %d times hello world\nDevice_open=%d\n", counter++, Device_open);
  61.         msg_ptr = msg;
  62.         try_module_get(THIS_MODULE);
  63.         return SUCCESS;
  64. }
  65. static int device_release(struct inode* inode, struct file* file)
  66. {
  67.         Device_open--;
  68.         module_put(THIS_MODULE);
  69.         return 0;
  70. }
  71. static ssize_t device_read(struct file* filp, char *buffer, size_t length, loff_t *offset)
  72. {
  73.         int bytes_read = 0;
  74.         if (*msg_ptr == '\0')
  75.                 return 0;
  76.         printk(KERN_ALERT "length=%d\n", length);
  77.         while (length && *msg_ptr)
  78.         {
  79.                 put_user(*(msg_ptr++), buffer++);
  80.                 length--;
  81.                 bytes_read++;
  82.         }
  83.         return bytes_read;
  84. }
  85. static ssize_t device_write(struct file* filp, const char *buff, size_t len, loff_t *off)
  86. {
  87.         printk(KERN_ALERT "Sorry, this operation isn't supported\n");
  88.         return -EINVAL;
  89. }

3. 使用udev在/dev/下动态生成设备文件的方式

点击(此处)折叠或打开

  1. #include<linux/kernel.h>
  2. #include<linux/module.h>
  3. #include<linux/types.h>
  4. #include<linux/fs.h>
  5. #include<linux/cdev.h>
  6. #include<linux/pci.h>
  7. #include<linux/moduleparam.h>
  8. #include<linux/init.h>
  9. #include<linux/string.h>
  10. #include<asm/uaccess.h>
  11. #include<asm/unistd.h>
  12. #include<asm/uaccess.h>
  13. MODULE_LICENSE("GPL"); /*此处如果不加的话加载的时候会出错*/
  14. int init_module(void);
  15. void cleanup_module(void);
  16. static int device_open(struct inode*, struct file*);
  17. static int device_release(struct inode*, struct file*);
  18. static ssize_t device_read(struct file*, char *, size_t, loff_t*);
  19. static ssize_t device_write(struct file*, const char*, size_t, loff_t*);
  20. #define SUCCESS 0
  21. #define DEVICE_NAME "chardev"
  22. #define BUF_LEN 80

  24. static int major;
  25. static int Device_open = 0;
  26. static char msg[BUF_LEN];
  27. static char *msg_ptr;
  28. static struct cdev *my_cdev;
  29. static struct class *my_class;
  30. dev_t devid ;
  31. static struct file_operations fops =
  32. {
  33.         .read = device_read,
  34.         .write = device_write,
  35.         .open = device_open,
  36.         .release = device_release,
  37. };
  38. int init_module(void)
  39. {
  40.         int err;
  41.         alloc_chrdev_region(&devid, 0, 1, "chardev");
  42.         major = MAJOR(devid);
  43.         my_cdev = cdev_alloc();
  44.         cdev_init(my_cdev, &fops);
  45.         my_cdev->owner = THIS_MODULE;
  46.         err = cdev_add(my_cdev, devid, 1);
  47.         if (err)
  48.         {
  49.                 printk(KERN_INFO "I was assigned major number %d.\n", major);
  50.                 return -1;
  51.         }
  52.         my_class = class_create(THIS_MODULE, "chardev_class1");
  53.         if (IS_ERR(my_class))
  54.         {
  55.                 printk(KERN_INFO "create class error\n");
  56.                 return -1;
  57.         }
  58.         class_device_create(my_class, NULL, devid, NULL, "chardev" "%d", MINOR(devid));
  59.         printk("major number is %d\n", MAJOR(devid));
  60.         return SUCCESS;
  61. }
  62. void cleanup_module(void)
  63. {
  64.         cdev_del(my_cdev);
  65.         class_device_destroy(my_class, devid);
  66.         class_destroy(my_class);
  67.         printk("cleanup done\n");
  68. }
  69. static int device_open(struct inode* inode, struct file* file)
  70. {
  71.         static int counter = 0;
  72.         if (Device_open)
  73.         {
  74.                 return -EBUSY;
  75.         }
  76.         Device_open++;
  77.         sprintf(msg, "I already told you %d times hello world\nDevice_open=%d\n", counter++, Device_open);
  78.         msg_ptr = msg;
  79.         try_module_get(THIS_MODULE);
  80.         return SUCCESS;
  81. }
  82. static int device_release(struct inode* inode, struct file* file)
  83. {
  84.         Device_open--;
  85.         module_put(THIS_MODULE);
  86.         return 0;
  87. }
  88. static ssize_t device_read(struct file* filp, char *buffer, size_t length, loff_t *offset)
  89. {
  90.         int bytes_read = 0;
  91.         if (*msg_ptr == '\0')
  92.                 return 0;
  93.         printk(KERN_ALERT "length=%d\n", length);
  94.         while (length && *msg_ptr)
  95.         {
  96.                 put_user(*(msg_ptr++), buffer++);
  97.                 length--;
  98.                 bytes_read++;
  99.         }
  100.         return bytes_read;
  101. }
  102. static ssize_t device_write(struct file* filp, const char *buff, size_t len, loff_t *off)
  103. {
  104.         printk(KERN_ALERT "Sorry, this operation isn't supported\n");
  105.         return -EINVAL;
  106. }




阅读(1290) | 评论(0) | 转发(0) |
0

上一篇：字符设备驱动-1

下一篇：字符设备驱动—3

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6