创建字符设备

转载 2016年05月30日 18:37:47
将创建字符设备的三种方法记录一下,以便以后参考.

1.使用早期的register_chardev()方法
#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<asm/uaccess.h>
int init_module(void);
void cleanup_module(void);
static int device_open(struct inode*, struct file*);
static int device_release(struct inode*, struct file*);
static ssize_t device_read(struct file*, char *, size_t, loff_t*);
static ssize_t device_write(struct file*, const char*, size_t, loff_t*);
#define SUCCESS 0
#define DEVICE_NAME "chardev"
#define BUF_LEN 80
static int major;
static int Device_open = 0;
static char msg[BUF_LEN];
static char *msg_ptr;
static struct file_operations fops =
{
        .read = device_read,
        .write = device_write,
        .open = device_open,
        .release = device_release,
};
int init_module(void)
{
        major = register_chrdev(0, DEVICE_NAME, &fops);
        if (major < 0)
        {
                printk(KERN_ALERT "Registering char device failed with %d\n", major);
                return major;
        }
        printk(KERN_INFO "I was assigned major number %d.\n", major);
        return SUCCESS;
}
void cleanup_module(void)
{
        int ret = unregister_chrdev(major, DEVICE_NAME);
        if (ret < 0)
        {
                printk(KERN_ALERT "Error in unregister chrdev %d\n", major);
        }
}
static int device_open(struct inode* inode, struct file* file)
{
        static int counter = 0;
        if (Device_open)
        {
                return -EBUSY;
        }
        Device_open++;
        sprintf(msg, "I already told you %d times hello world\nDevice_open=%d\n" , counter++, Device_open);
        msg_ptr = msg;
        try_module_get(THIS_MODULE);
        return SUCCESS;
}
static int device_release(struct inode* inode, struct file* file)
{
        Device_open--;
        module_put(THIS_MODULE);
        return 0;
}
static ssize_t device_read(struct file* filp, char *buffer, size_t length, loff_t *offset)
{
        int bytes_read = 0;
        if (*msg_ptr == '\0')
                return 0;
        printk(KERN_ALERT "length=%d\n", length);
        while (length && *msg_ptr)
        {
                put_user(*(msg_ptr++), buffer++);
                length--;
                bytes_read++;
        }
        return bytes_read;
}
static ssize_t device_write(struct file* filp, const char *buff, size_t len, loff_t *off)
{
        printk(KERN_ALERT "Sorry, this operation isn't supported\n");
        return -EINVAL;
}

2.使用cdev的方法
#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/types.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<asm/uaccess.h>
int init_module(void);
void cleanup_module(void);
static int device_open(struct inode*, struct file*);
static int device_release(struct inode*, struct file*);
static ssize_t device_read(struct file*, char *, size_t, loff_t*);
static ssize_t device_write(struct file*, const char*, size_t, loff_t*);
#define SUCCESS 0
#define DEVICE_NAME "chardev"
#define BUF_LEN 80

static int major;
static int Device_open = 0;
static char msg[BUF_LEN];
static char *msg_ptr;
static struct cdev *my_cdev;
static struct file_operations fops =
{
        .read = device_read,
        .write = device_write,
        .open = device_open,
        .release = device_release,
};
int init_module(void)
{
        int err;
        dev_t devid ;
        alloc_chrdev_region(&devid, 0, 1, "chardev");
        major = MAJOR(devid);
        my_cdev = cdev_alloc();
        cdev_init(my_cdev, &fops);
        err = cdev_add(my_cdev, devid, 1);
        if (err)
        {
                printk(KERN_INFO "I was assigned major number %d.\n", major);
                return -1;
        }
        printk("major number is %d\n", MAJOR(devid));
        return SUCCESS;
}
void cleanup_module(void)
{
        cdev_del(my_cdev);
        printk("cleanup done\n");
}
static int device_open(struct inode* inode, struct file* file)
{
        static int counter = 0;
        if (Device_open)
        {
                return -EBUSY;
        }
        Device_open++;
        sprintf(msg, "I already told you %d times hello world\nDevice_open=%d\n", counter++, Device_open);
        msg_ptr = msg;
        try_module_get(THIS_MODULE);
        return SUCCESS;
}
static int device_release(struct inode* inode, struct file* file)
{
        Device_open--;
        module_put(THIS_MODULE);
        return 0;
}
static ssize_t device_read(struct file* filp, char *buffer, size_t length, loff_t *offset)
{
        int bytes_read = 0;
        if (*msg_ptr == '\0')
                return 0;
        printk(KERN_ALERT "length=%d\n", length);
        while (length && *msg_ptr)
        {
                put_user(*(msg_ptr++), buffer++);
                length--;
                bytes_read++;
        }
        return bytes_read;
}
static ssize_t device_write(struct file* filp, const char *buff, size_t len, loff_t *off)
{
        printk(KERN_ALERT "Sorry, this operation isn't supported\n");
        return -EINVAL;
}

3.使用udev在/dev/下动态生成设备文件的方式
#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/types.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/pci.h>
#include<linux/moduleparam.h>
#include<linux/init.h>
#include<linux/string.h>
#include<asm/uaccess.h>
#include<asm/unistd.h>
#include<asm/uaccess.h>
MODULE_LICENSE("GPL");                     
int init_module(void);
void cleanup_module(void);
static int device_open(struct inode*, struct file*);
static int device_release(struct inode*, struct file*);
static ssize_t device_read(struct file*, char *, size_t, loff_t*);
static ssize_t device_write(struct file*, const char*, size_t, loff_t*);
#define SUCCESS 0
#define DEVICE_NAME "chardev"
#define BUF_LEN 80

static int major;
static int Device_open = 0;
static char msg[BUF_LEN];
static char *msg_ptr;
static struct cdev *my_cdev;
static struct class *my_class;
dev_t devid ;
static struct file_operations fops =
{
        .read = device_read,
        .write = device_write,
        .open = device_open,
        .release = device_release,
};
int init_module(void)
{
        int err;
        alloc_chrdev_region(&devid, 0, 1, "chardev");
        major = MAJOR(devid);
        my_cdev = cdev_alloc();
        cdev_init(my_cdev, &fops);
        my_cdev->owner = THIS_MODULE;
        err = cdev_add(my_cdev, devid, 1);
        if (err)
        {
                printk(KERN_INFO "I was assigned major number %d.\n", major);
                return -1;
        }
        my_class = class_create(THIS_MODULE, "chardev_class1");
        if (IS_ERR(my_class))
        {
                printk(KERN_INFO "create class error\n");
                return -1;
        }
        class_device_create(my_class, NULL, devid, NULL, "chardev" "%d", MINOR(devid));
        printk("major number is %d\n", MAJOR(devid));
        return SUCCESS;
}
void cleanup_module(void)
{
        cdev_del(my_cdev);
        class_device_destroy(my_class,  devid);
        class_destroy(my_class);
        printk("cleanup done\n");
}
static int device_open(struct inode* inode, struct file* file)
{
        static int counter = 0;
        if (Device_open)
        {
                return -EBUSY;
        }
        Device_open++;
        sprintf(msg, "I already told you %d times hello world\nDevice_open=%d\n", counter++, Device_open);
        msg_ptr = msg;
        try_module_get(THIS_MODULE);
        return SUCCESS;
}
static int device_release(struct inode* inode, struct file* file)
{
        Device_open--;
        module_put(THIS_MODULE);
        return 0;
}
static ssize_t device_read(struct file* filp, char *buffer, size_t length, loff_t *offset)
{
        int bytes_read = 0;
        if (*msg_ptr == '\0')
                return 0;
        printk(KERN_ALERT "length=%d\n", length);
        while (length && *msg_ptr)
        {
                put_user(*(msg_ptr++), buffer++);
                length--;
                bytes_read++;
        }
        return bytes_read;
}
static ssize_t device_write(struct file* filp, const char *buff, size_t len, loff_t *off)
{
        printk(KERN_ALERT "Sorry, this operation isn't supported\n");
        return -EINVAL;
}

UCOSII创建的创建任务

INT8U OSTaskCreate (void (*task)(void *pd), void *pdata, OS_STK *ptos, INT8U prio)在UCOSII中负责创建任务 第一...
  • u012967763
  • u012967763
  • 2017年06月22日 20:26
  • 170

java 创建文件-创建目录-创建临时文件

[java] view plain copy  print? import java.io.File;   import java.io.IOException;   ...
  • defineshan
  • defineshan
  • 2016年09月25日 23:40
  • 150

创建主键 创建外键 创建约束

笔记本 创建表(包括创建主键,外键,非空列,唯一) **************** 创建主键(三种方法) **************** 创建学生表: 第一种: create table...
  • u012467492
  • u012467492
  • 2015年06月24日 11:46
  • 401

C#创建如何创建DataTable

创建DataTable实例     DataTable StockTable2 = new DataTable(); 增加DataTable 列          DataColumn dc1 ...
  • a136511479
  • a136511479
  • 2016年06月14日 17:46
  • 159

db2 创建实例,创建数据库,创建表

创建实例
  • fabbychips
  • fabbychips
  • 2014年10月30日 19:29
  • 11407

wordpress 自己创建插件怎么创建

我是个wordpress菜鸟,刚学习什么都不会,插件都不会自己写,老手就不要笑话了,对新手应该有点用吧 首先你要在htdocs\wp-content\plugins 写一个文件夹谢你插件的名...
  • Q1059081877Q
  • Q1059081877Q
  • 2015年06月02日 21:57
  • 630

如何创建索引、什么时候该创建、什么时候不应该创建

适当的使用索引可以提高数据检索速度,可以给经常需要进行查询的字段创建索引  Oracle的索引分为5种:唯一索引,组合索引,反向键索引,位图索引,基于函数的索引  创建索引的标准语法:  ...
  • nannancctv1
  • nannancctv1
  • 2017年01月20日 10:26
  • 107

创建线程的三种方式

一、继承Thread类+重写run()方法 启动:创建子类对象+对象.start() 二、实现Runnable接口+重写run方法 启动:使用静态代理 1)、创建真实角色 2)、创建代理角色...
  • scgaliguodong123_
  • scgaliguodong123_
  • 2015年05月27日 17:13
  • 5972

创建线程的三种方法

第一种方法:继承Thread类,重写run()方法,run()方法代表线程要执行的任务。 第二种方法:实现Runnable接口,重写run()方法,run()方法代表线程要执行的任务。 第三种方法:实...
  • baidu_21578557
  • baidu_21578557
  • 2016年04月16日 21:34
  • 5313

关于枚举的创建和使用

枚举简单的说也是一种数据类型,只不过是这种数据类型只包含自定义的特定数据,它是一组有共同特性的数据的集合。举个例子,颜色也可以定义成枚举类型,它可以包含你定义的任何颜色,当需要的时候,只需要通过枚举调...
  • aeiou20018
  • aeiou20018
  • 2016年07月10日 16:31
  • 3206
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:创建字符设备
举报原因:
原因补充:

(最多只允许输入30个字)