使用class 自动创建设备节点

#include <linux/init.h>// __init   __exit
#include <linux/module.h>      // module_init  module_exit
#include <linux/fs.h>          //file_operations
#include <asm/uaccess.h>          //copy_from_user  copy_to_user
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <asm/string.h>
#include <linux/ioport.h>          //request_mem_region
#include <asm/io.h> //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#define MYNAME "led_dev"
#define DEVNUM 1
#define S5PV210_PA_GPIOJ0CON 0xe0200240
volatile unsigned int *rGPJ0CON  = NULL;
volatile unsigned int *rGPJ0DAT = NULL;
static dev_t led_dev_no = ;
/************ 静态使用cdev**********/
//static struct cdev led_cdev;
/************ 动态使用cdev**********/
static struct cdev *pled_cdev = NULL;
static struct class *pled_dev_class = NULL;
static int led_open(struct inode *inode, struct file *file);
ssize_t led_read(struct file *file, char __user *user, size_t count, loff_t *loff);
ssize_t led_write(struct file *file, const char __user *user, size_t count, loff_t *loff);
static int led_release(struct inode *inode, struct file *file);
static char kbuf[] = {};
static const struct file_operations led_fops = {
.owner= THIS_MODULE,
.open= led_open,
.read       = led_read,
.write      = led_write,
.release= led_release,
};
int led_open(struct inode *inode, struct file *file)
{
printk(KERN_INFO "led_open successful\n");
return ;
}
ssize_t led_read(struct file *file, char __user *user, size_t ucount, loff_t *loff)
{
printk(KERN_INFO "led_read successful\n");
if (copy_to_user(user,kbuf , ucount))
{
printk(KERN_INFO "copy_to_user fail\n");
return -EINVAL;
}
printk(KERN_INFO "copy_to_user successful\n");
return strlen(kbuf);
}
ssize_t led_write(struct file *file, const char __user *user, size_t ucount, loff_t *loff)
{
printk(KERN_INFO "led_write successful\n");
memset(kbuf,,sizeof(kbuf));
if (copy_from_user(kbuf, user, ucount))
{
printk(KERN_INFO "copy_from_user fail\n");
return -EINVAL;
}
if(!strcmp(kbuf,"on"))
{
    *rGPJ0CON &=0xff000fff;
    *rGPJ0CON |=0x00111000;
        *rGPJ0DAT &=~((0x01<<)|(0x01<<)|(0x01<<));
}
else if(!strcmp(kbuf,"off"))
{
    *rGPJ0CON &=0xff000fff;
    *rGPJ0CON |=0x00111000;
        *rGPJ0DAT |=((0x01<<)|(0x01<<)|(0x01<<));
}
return ucount;
printk(KERN_INFO "copy_from_user successful\n");
}
int led_release(struct inode *inode, struct file *file)
{
printk(KERN_INFO "led_release successful\n");
return ;
}
// 模块安装函数
static int __init chrdev_init(void)
{
int ret = -;
int retval = -;
printk(KERN_INFO "chrdev_init successful\n");
/******指定主设备号注册*****/
//led_dev_no = MKDEV(250,0);
//retval = register_chrdev_region(led_dev_no, DEVNUM,MYNAME);
/******内核自动分配主设备号注册*****/
retval = alloc_chrdev_region(&led_dev_no,,DEVNUM,MYNAME);
if (retval)
{
printk(KERN_WARNING "alloc_chrdev_region fail\n.");
ret = -EINVAL;
goto err_reg;
}
printk(KERN_INFO "alloc_chrdev_region successful major = %d,minor = %d \n",MAJOR(led_dev_no),MINOR(led_dev_no));
/****动态申请cdev实体******/
pled_cdev = cdev_alloc();
printk(KERN_INFO "cdev_alloc successful\n");
cdev_init(pled_cdev, &led_fops);
retval = cdev_add(pled_cdev, led_dev_no, DEVNUM);
if (retval)
{
printk(KERN_WARNING "cdev_add fail\n.");
ret = -EINVAL;
goto err_add;
}
printk(KERN_INFO "cdev_add successful\n");
// 注册字符设备驱动完成后，添加设备类的操作，以让内核帮我们发信息
// 给udev，让udev自动创建和删除设备文件
pled_dev_class = class_create(THIS_MODULE, "led_musk");
if (IS_ERR(pled_dev_class))
{
printk(KERN_WARNING "class_create fail\n.");
ret = -EINVAL;
goto err_class_create;
}
device_create(pled_dev_class, NULL, led_dev_no, NULL, "led_dev");       //“led_dev”对应/dev/下的名字
if (request_mem_region(S5PV210_PA_GPIOJ0CON, , "GPIOJ0CON") == NULL)
{
printk(KERN_WARNING "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
rGPJ0CON = ioremap(S5PV210_PA_GPIOJ0CON,);
if (rGPJ0CON ==  NULL)
{
printk(KERN_WARNING "fail to ioremap() region\n");
ret = -ENOENT;
goto err_map;
}
rGPJ0DAT = rGPJ0CON+;
return ;
err_map:
release_mem_region(S5PV210_PA_GPIOJ0CON,);
err_req:
class_destroy(pled_dev_class);
err_class_create:
/***for static cdev******/
//cdev_del(&led_cdev);
/***for dynamic cdev******/
cdev_del(pled_cdev);
err_add:
printk(KERN_INFO "err_add err\n");
unregister_chrdev_region(led_dev_no, DEVNUM);
err_reg:
return ret;
}
// 模块卸载函数
static void __exit chrdev_exit(void)
{
iounmap(rGPJ0CON);
release_mem_region(S5PV210_PA_GPIOJ0CON,);
device_destroy(pled_dev_class,led_dev_no);
class_destroy(pled_dev_class);
/***for static cdev******/
//cdev_del(&led_cdev);
/***for dynamic cdev******/
cdev_del(pled_cdev);
unregister_chrdev_region(led_dev_no, DEVNUM);
printk(KERN_INFO "chrdev_exit successful\n");
}
module_init(chrdev_init);
module_exit(chrdev_exit);
// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");// 描述模块的许可证
MODULE_AUTHOR("musk");// 描述模块的作者
MODULE_DESCRIPTION("module test");// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");// 描述模块的别名信息

一. 什么是class

1.1. class 指的是 设备类(device classes),是对于设备的高级抽象。但实际上 class 也是一个结构体,只不过 class 结构体在声明时是按照类的思想来组织其成员的。运用 class,可以让用户空间的程序根据自己要处理的事情来调用设备,而不是根据设备被接入到系统的方式或设备的工作原理来调用

1.2.  一个 struct class 结构体类型变量对应一个类,内核提供了class_create() 函数,可以用它来创建一个类,这个类存放于 sysfs 下面。 一旦创建了类,再调用 device_create() 函数在 /dev 目录下创建相应的设备节点

1.2.1. sysfs虚拟文件系统

a. sysfs是 Linux 内核中设计较新的一种虚拟的基于内存的文件系统，它的作用与 proc 有些类似，但除了与 proc相同的具有查看和设定内核参数功能之外，还有为 Linux 统一设备模型作为管理之用。相比于 proc 文件系统，使用 sysfs导出内核数据的方式更为统一，并且组织的方式更好，它的设计从 proc 中吸取了很多教训

b. 当使用class_create创建时，在/sys/class/中会创建相应文件

二. linux中的mdev机制

2.1.什么是mdev

2.1.1. mdev是busybox自带的一个简化版的udev。适合于嵌入式的应用埸合。其具有使用简单的特点。它的作用，就是在系统启动和热插拔或动态加载驱动程序时，自动产生驱动程序所

需的节点文件。在以busybox 为基础构建嵌入式linux 的根文件系统时，使用它是最优的选择

2.1.2. mdev 的使用在busybox 中的mdev.txt 文档已经将得很详细了

2.2. mdev 用法

2.2.1.执行mdev前要挂载 /sys

a. mount -t tmpfs mdev /dev

b.mount -t sysfs sysfs /sys

2.2.2. 命令内核在增删设备时执行/sbin/mdev，使设备节点会被创建和删除

a. echo /sbin/mdev > /proc/sys/kernel/hotplug

2.2.3. 设置mdev，让它在系统启动时创建所有的设备节点

a. mdev -s

2.2.4. 相关操作bsp 下/etc/init.d/rcS启动开发板时会设置。

PATH=/sbin:/bin:/usr/sbin:/usr/bin

runlevel=S
prevlevel=N

umask 

export PATH runlevel prevlevel

mount -a

echo /sbin/mdev > /proc/sys/kernel/hotplug
mdev -s

/bin/hostname -F /etc/sysconfig/HOSTNAME

ifconfig eth0 192.168.1.20
~
- /etc/init.d/rcS / %

三. 相关函数分析

3.1. class_create函数分析。

3.1.1. 函数调用层级

class_create

__class_create

__class_register

kset_register

kobject_uevent

/* This is a #define to keep the compiler from merging different
 * instances of the __key variable */
#define class_create(owner, name)        \
({                        \
    static struct lock_class_key __key;    \
    __class_create(owner, name, &__key);    \
})

/**
 * class_create - create a struct class structure
 * @owner: pointer to the module that is to "own" this struct class
 * @name: pointer to a string for the name of this class.
 * @key: the lock_class_key for this class; used by mutex lock debugging
 *
 * This is used to create a struct class pointer that can then be used
 * in calls to device_create().
 *
 * Returns &struct class pointer on success, or ERR_PTR() on error.
 *
 * Note, the pointer created here is to be destroyed when finished by
 * making a call to class_destroy().
 */
struct class *__class_create(struct module *owner, const char *name,
                 struct lock_class_key *key)
{
    struct class *cls;
    int retval;

    cls = kzalloc(sizeof(*cls), GFP_KERNEL);
    if (!cls) {
        retval = -ENOMEM;
        goto error;
    }

    cls->name = name;
    cls->owner = owner;
    cls->class_release = class_create_release;

    retval = __class_register(cls, key);
    if (retval)
        goto error;

    return cls;

error:
    kfree(cls);
    return ERR_PTR(retval);
}

int __class_register(struct class *cls, struct lock_class_key *key)
{
    struct class_private *cp;
    int error;

    pr_debug("device class '%s': registering\n", cls->name);

    cp = kzalloc(sizeof(*cp), GFP_KERNEL);
    if (!cp)
        return -ENOMEM;
    klist_init(&cp->class_devices, klist_class_dev_get, klist_class_dev_put);
    INIT_LIST_HEAD(&cp->class_interfaces);
    kset_init(&cp->class_dirs);
    __mutex_init(&cp->class_mutex, "struct class mutex", key);
    error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);
    if (error) {
        kfree(cp);
        return error;
    }

    /* set the default /sys/dev directory for devices of this class */
    if (!cls->dev_kobj)
        cls->dev_kobj = sysfs_dev_char_kobj;

#if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
    /* let the block class directory show up in the root of sysfs */
    if (cls != &block_class)
        cp->class_subsys.kobj.kset = class_kset;
#else
    cp->class_subsys.kobj.kset = class_kset;
#endif
    cp->class_subsys.kobj.ktype = &class_ktype;
    cp->class = cls;
    cls->p = cp;

    error = kset_register(&cp->class_subsys);
    if (error) {
        kfree(cp);
        return error;
    }
    error = add_class_attrs(class_get(cls));
    class_put(cls);
    return error;
}
/**
 * kset_register - initialize and add a kset.
 * @k: kset.
 */
int kset_register(struct kset *k)
{
    int err;

    if (!k)
        return -EINVAL;

    kset_init(k);
    err = kobject_add_internal(&k->kobj);
    if (err)
        return err;
    kobject_uevent(&k->kobj, KOBJ_ADD);
    return ;
}
/**
 * kobject_uevent - notify userspace by ending an uevent
 *
 * @action: action that is happening
 * @kobj: struct kobject that the action is happening to
 *
 * Returns 0 if kobject_uevent() is completed with success or the
 * corresponding error when it fails.
 */
int kobject_uevent(struct kobject *kobj, enum kobject_action action)
{
    return kobject_uevent_env(kobj, action, NULL);
}

3.2. device_create函数分析。

3.2.1. 函数调用层级

device_create

device_create_vargs

kobject_set_name_vargs

device_register

device_add

kobject_add

device_create_file

device_create_sys_dev_entry

devtmpfs_create_node

device_add_class_symlinks

device_add_attrs

device_pm_add

kobject_uevent

/**
 * device_create - creates a device and registers it with sysfs
 * @class: pointer to the struct class that this device should be registered to
 * @parent: pointer to the parent struct device of this new device, if any
 * @devt: the dev_t for the char device to be added
 * @drvdata: the data to be added to the device for callbacks
 * @fmt: string for the device's name
 *
 * This function can be used by char device classes.  A struct device
 * will be created in sysfs, registered to the specified class.
 *
 * A "dev" file will be created, showing the dev_t for the device, if
 * the dev_t is not 0,0.
 * If a pointer to a parent struct device is passed in, the newly created
 * struct device will be a child of that device in sysfs.
 * The pointer to the struct device will be returned from the call.
 * Any further sysfs files that might be required can be created using this
 * pointer.
 *
 * Returns &struct device pointer on success, or ERR_PTR() on error.
 *
 * Note: the struct class passed to this function must have previously
 * been created with a call to class_create().
 */
struct device *device_create(struct class *class, struct device *parent,
                 dev_t devt, void *drvdata, const char *fmt, ...)
{
    va_list vargs;
    struct device *dev;

    va_start(vargs, fmt);
    dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
    va_end(vargs);
    return dev;
}

3.2.2. 调用此函数最早会创建/sys/class/xxx 下dev        power      subsystem   uevent等文件

3.3. device_destroy函数

3.3.1. 函数定义：

/**
 * device_destroy - removes a device that was created with device_create()
 * @class: pointer to the struct class that this device was registered with
 * @devt: the dev_t of the device that was previously registered
 *
 * This call unregisters and cleans up a device that was created with a
 * call to device_create().
 */
void device_destroy(struct class *class, dev_t devt)
{
    struct device *dev;

    dev = class_find_device(class, NULL, &devt, __match_devt);
    if (dev) {
        put_device(dev);
        device_unregister(dev);
    }
}

3.4. class_destroy函数

3.4.1.函数定义

/**
 * class_destroy - destroys a struct class structure
 * @cls: pointer to the struct class that is to be destroyed
 *
 * Note, the pointer to be destroyed must have been created with a call
 * to class_create().
 */
void class_destroy(struct class *cls)
{
    if ((cls == NULL) || (IS_ERR(cls)))
        return;

    class_unregister(cls);
}

四. 应用层调用内核

4.1. 应用层代码如下：

#include <stdio.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <string.h>

#define DEVFILE "/dev/led_dev"

int main(void)
{
    char buf[] = {};
    int fd = -;
    if((fd =open(DEVFILE, O_RDWR))<)
    {
        perror("open");
        return -;
    }
    printf("open successful fd = %d\n",fd);
    if(write(fd, "on", strlen("on"))<)
    {
        perror("write");
        return -;
    }
    sleep();
    memset(buf,,sizeof(buf));
    if(read(fd, buf, )<)
    {
        perror("read");
        return -;
    }
    printf("read data = %s\n",buf);

    if(write(fd, "off", strlen("off"))<)
    {
        perror("write");
        return -;
    }
    sleep();
    memset(buf,,sizeof(buf));
    if(read(fd, buf, )<)
    {
        perror("read");
        return -;
    }
    printf("read data = %s\n",buf);

    close(fd);
    return ;
}