linux驱动开发class_create

于 2024-10-15 13:16:55 发布
阅读量1.6k 收藏 12
点赞数 12
分类专栏： 驱动开发 文章标签： linux 驱动开发 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/142943242
版权

1.概要

2.内容

1.linux驱动开发class_create

在Linux驱动开发中，class_create 是一个用于创建一个新的设备类的函数。设备类（device class）是Linux内核中一种组织和管理设备的机制，它允许将设备按照功能或类型进行分组。这种分组有助于实现设备的统一管理和控制，比如权限管理、设备节点的创建等。

class_create 函数

class_create 函数的原型定义在 <linux/device.h> 头文件中，如下所示：

struct class *class_create(struct module *owner, const char *name);
  • owner：指向创建这个类的模块的指针。这通常是通过 THIS_MODULE 宏来获取的，表示当前正在编译的模块。
  • name：要创建的类的名称，这是一个字符串。类名应该唯一，以便区分不同的设备类。

函数返回值是一个指向 struct class 结构的指针，如果创建成功，则返回这个指针；如果失败（比如因为内存分配失败或者类名冲突），则返回 NULL。

使用示例

以下是一个简单的示例，展示了如何在Linux驱动中使用 class_create 创建一个设备类：

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
  
static struct class *my_class;  
  
static int __init my_driver_init(void)  
{  
    // 创建设备类  
    my_class = class_create(THIS_MODULE, "my_class");  
    if (IS_ERR(my_class)) {  
        printk(KERN_ERR "Failed to create device class\n");  
        return PTR_ERR(my_class);  
    }  
  
    printk(KERN_INFO "Device class created successfully\n");  
    return 0;  
}  
  
static void __exit my_driver_exit(void)  
{  
    // 销毁设备类  
    if (my_class) {  
        class_destroy(my_class);  
    }  
  
    printk(KERN_INFO "Device class destroyed\n");  
}  
  
module_init(my_driver_init);  
module_exit(my_driver_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("A simple example of device class creation");

注意事项

  1. 销毁类：在模块卸载或者不再需要这个类时，应该调用 class_destroy 函数来销毁这个类，以释放相关的资源。
  2. 权限和节点：创建类之后，通常还会需要为类中的设备创建设备节点（通过 device_create 函数），并设置适当的权限，以便用户空间程序可以访问这些设备。
  3. 错误处理：在调用 class_create 之后，应该检查返回值是否为 NULL 或者是否是一个错误指针（使用 IS_ERR 宏），以确保类创建成功。

通过正确地使用设备类，驱动开发者可以更加有效地管理设备，并提供一个更加清晰和一致的设备模型给操作系统和用户空间程序。

2.class_create 函数的“创建的类的名称”应用举例 

在Linux内核驱动开发中，class_create 函数用于创建一个新的设备类，该类将设备按照功能或类型进行分组。创建类时，需要为该类指定一个唯一的名称，这个名称在系统中应该是独一无二的，以避免与其他类发生冲突。

以下是一些class_create函数中“创建的类的名称”的应用举例：

举例1: 创建USB设备类

在USB子系统中，可以创建一个名为usb的设备类，用于管理所有的USB设备。

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
  
static struct class *usb_class;  
  
static int __init usb_init(void)  
{  
    usb_class = class_create(THIS_MODULE, "usb");  
    if (IS_ERR(usb_class)) {  
        printk(KERN_ERR "Failed to create USB device class\n");  
        return PTR_ERR(usb_class);  
    }  
  
    // 后续可以添加USB设备的初始化代码  
  
    return 0;  
}  
  
static void __exit usb_exit(void)  
{  
    if (usb_class) {  
        class_destroy(usb_class);  
    }  
  
    // 后续可以添加USB设备的清理代码  
}  
  
module_init(usb_init);  
module_exit(usb_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("USB device class creation example");

在这个例子中，class_create函数被用来创建一个名为usb的设备类。如果创建成功，usb_class将指向这个新创建的类。

举例2: 创建自定义设备类

假设你正在开发一个自定义的驱动程序，并且想要为这个驱动程序创建一个专属的设备类，比如名为my_custom_class。

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
  
static struct class *usb_class;  
  
static int __init usb_init(void)  
{  
    usb_class = class_create(THIS_MODULE, "usb");  
    if (IS_ERR(usb_class)) {  
        printk(KERN_ERR "Failed to create USB device class\n");  
        return PTR_ERR(usb_class);  
    }  
  
    // 后续可以添加USB设备的初始化代码  
  
    return 0;  
}  
  
static void __exit usb_exit(void)  
{  
    if (usb_class) {  
        class_destroy(usb_class);  
    }  
  
    // 后续可以添加USB设备的清理代码  
}  
  
module_init(usb_init);  
module_exit(usb_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("USB device class creation example");

在这个例子中，class_create函数被用来创建一个名为my_custom_class的设备类。这个类可以用于管理你的自定义驱动程序中的设备。

注意事项

  • 类名应该是有意义的，并且能够清晰地描述这个类的用途。
  • 类名在系统中应该是唯一的，以避免与其他类发生冲突。
  • 在模块卸载时，应该调用class_destroy函数来销毁创建的类，以释放相关资源。

通过创建设备类，你可以更好地组织和管理你的设备，并为它们提供一致的接口和行为。

3.class_create 函数的“创建的类的名称”应用举例，创建一个在应用端访问设备的例子 

在Linux内核驱动开发中，class_create 函数用于创建一个新的设备类，该类将设备按照功能或类型进行分组。创建类时，需要为该类指定一个唯一的名称，这个名称在系统中应该是独一无二的，以避免与其他类发生冲突。

以下是一些class_create函数中“创建的类的名称”的应用举例：

举例1: 创建USB设备类

在USB子系统中，可以创建一个名为usb的设备类，用于管理所有的USB设备。

 

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
  
static struct class *usb_class;  
  
static int __init usb_init(void)  
{  
    usb_class = class_create(THIS_MODULE, "usb");  
    if (IS_ERR(usb_class)) {  
        printk(KERN_ERR "Failed to create USB device class\n");  
        return PTR_ERR(usb_class);  
    }  
  
    // 后续可以添加USB设备的初始化代码  
  
    return 0;  
}  
  
static void __exit usb_exit(void)  
{  
    if (usb_class) {  
        class_destroy(usb_class);  
    }  
  
    // 后续可以添加USB设备的清理代码  
}  
  
module_init(usb_init);  
module_exit(usb_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("USB device class creation example");
 

在这个例子中，class_create函数被用来创建一个名为usb的设备类。如果创建成功，usb_class将指向这个新创建的类。
 

举例2: 创建自定义设备类
 

假设你正在开发一个自定义的驱动程序，并且想要为这个驱动程序创建一个专属的设备类，比如名为my_custom_class。
 

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
  
static struct class *my_custom_class;  
  
static int __init my_driver_init(void)  
{  
    my_custom_class = class_create(THIS_MODULE, "my_custom_class");  
    if (IS_ERR(my_custom_class)) {  
        printk(KERN_ERR "Failed to create custom device class\n");  
        return PTR_ERR(my_custom_class);  
    }  
  
    // 后续可以添加自定义设备的初始化代码  
  
    return 0;  
}  
  
static void __exit my_driver_exit(void)  
{  
    if (my_custom_class) {  
        class_destroy(my_custom_class);  
    }  
  
    // 后续可以添加自定义设备的清理代码  
}  
  
module_init(my_driver_init);  
module_exit(my_driver_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("Custom device class creation example");
 

在这个例子中，class_create函数被用来创建一个名为my_custom_class的设备类。这个类可以用于管理你的自定义驱动程序中的设备。
 

注意事项
 

  • 类名应该是有意义的，并且能够清晰地描述这个类的用途。
  • 类名在系统中应该是唯一的，以避免与其他类发生冲突。
  • 在模块卸载时，应该调用class_destroy函数来销毁创建的类，以释放相关资源。
 

通过创建设备类，你可以更好地组织和管理你的设备，并为它们提供一致的接口和行为。
 

4.class_create 函数的“创建的类的名称”应用举例，创建一个在应用端访问设备的例子 
 

为了创建一个能够在应用端访问的设备类，我们需要结合class_create和device_create函数来创建设备类和设备节点。下面是一个简化的例子，展示了如何使用这些函数来创建一个设备类，并在/dev目录下创建一个设备节点，以便应用端程序可以访问这个设备。
 

 

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
#include <linux/fs.h> // 为了使用file_operations结构体  
  
static struct class *my_device_class;  
static struct device *my_device;  
  
// 假设这是你的设备驱动的文件操作函数集  
static struct file_operations my_device_fops = {  
    .owner = THIS_MODULE,  
    // .open, .release, .read, .write 等函数指针可以在这里定义  
    // 这个例子中我们省略了这些函数的实现  
};  
  
static int __init my_device_init(void)  
{  
    int ret = 0;  
  
    // 创建设备类  
    my_device_class = class_create(THIS_MODULE, "my_device_class");  
    if (IS_ERR(my_device_class)) {  
        ret = PTR_ERR(my_device_class);  
        printk(KERN_ERR "Failed to create device class\n");  
        goto out;  
    }  
  
    // 在/dev目录下创建设备节点  
    my_device = device_create(my_device_class, NULL, MKDEV(240, 0), NULL, "my_device");  
    if (IS_ERR(my_device)) {  
        ret = PTR_ERR(my_device);  
        printk(KERN_ERR "Failed to create device node\n");  
        class_destroy(my_device_class); // 销毁之前创建的类  
        goto out;  
    }  
  
    // 设置设备节点的文件操作函数集  
    my_device->dev.of_private = &my_device_fops; // 注意：这里的赋值方式可能因内核版本而异  
  
    printk(KERN_INFO "Device class and node created successfully\n");  
  
out:  
    return ret;  
}  
  
static void __exit my_device_exit(void)  
{  
    // 销毁设备节点  
    if (my_device) {  
        device_destroy(my_device_class, MKDEV(240, 0));  
    }  
  
    // 销毁设备类  
    if (my_device_class) {  
        class_destroy(my_device_class);  
    }  
  
    printk(KERN_INFO "Device class and node destroyed\n");  
}  
  
module_init(my_device_init);  
module_exit(my_device_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("Example of creating a device class and node");  
  
// 注意：这个例子中省略了设备驱动的具体实现（如open, read, write等函数），  
// 你需要根据你的设备特性来实现这些函数。
 

在这个例子中，我们首先使用class_create函数创建了一个名为my_device_class的设备类。然后，我们使用device_create函数在/dev目录下创建了一个名为my_device的设备节点，并指定了主设备号为240（这个主设备号是你可以自由选择的，只要它不与系统中的其他设备冲突即可）。我们还为设备节点指定了一个文件操作函数集my_device_fops，尽管在这个例子中我们没有实现任何文件操作函数。
 

请注意，of_private字段的赋值方式可能因内核版本而异。在一些内核版本中，你可能需要使用device_set_drvdata或类似函数来设置私有数据，而不是直接赋值给of_private。此外，MKDEV宏用于生成一个设备号，它是由主设备号和次设备号组成的。在这个例子中，我们假设次设备号为0。
 

最后，在模块卸载时，我们使用device_destroy函数销毁设备节点，并使用class_destroy函数销毁设备类。这样，我们就完成了一个简单的设备类和设备节点的创建过程，使得应用端程序可以通过/dev/my_device来访问这个设备。
 

5.class_create 函数的“创建的类的名称”应用举例，创建一个在应用端访问设备的例子 
 

为了创建一个能够在应用端访问的设备类，我们需要结合class_create和device_create函数来创建设备类和设备节点。下面是一个简化的例子，展示了如何使用这些函数来创建一个设备类，并在/dev目录下创建一个设备节点，以便应用端程序可以访问这个设备。
 

 

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
#include <linux/fs.h> // 为了使用file_operations结构体  
  
static struct class *my_device_class;  
static struct device *my_device;  
  
// 假设这是你的设备驱动的文件操作函数集  
static struct file_operations my_device_fops = {  
    .owner = THIS_MODULE,  
    // .open, .release, .read, .write 等函数指针可以在这里定义  
    // 这个例子中我们省略了这些函数的实现  
};  
  
static int __init my_device_init(void)  
{  
    int ret = 0;  
  
    // 创建设备类  
    my_device_class = class_create(THIS_MODULE, "my_device_class");  
    if (IS_ERR(my_device_class)) {  
        ret = PTR_ERR(my_device_class);  
        printk(KERN_ERR "Failed to create device class\n");  
        goto out;  
    }  
  
    // 在/dev目录下创建设备节点  
    my_device = device_create(my_device_class, NULL, MKDEV(240, 0), NULL, "my_device");  
    if (IS_ERR(my_device)) {  
        ret = PTR_ERR(my_device);  
        printk(KERN_ERR "Failed to create device node\n");  
        class_destroy(my_device_class); // 销毁之前创建的类  
        goto out;  
    }  
  
    // 设置设备节点的文件操作函数集  
    my_device->dev.of_private = &my_device_fops; // 注意：这里的赋值方式可能因内核版本而异  
  
    printk(KERN_INFO "Device class and node created successfully\n");  
  
out:  
    return ret;  
}  
  
static void __exit my_device_exit(void)  
{  
    // 销毁设备节点  
    if (my_device) {  
        device_destroy(my_device_class, MKDEV(240, 0));  
    }  
  
    // 销毁设备类  
    if (my_device_class) {  
        class_destroy(my_device_class);  
    }  
  
    printk(KERN_INFO "Device class and node destroyed\n");  
}  
  
module_init(my_device_init);  
module_exit(my_device_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("Example of creating a device class and node");  
  
// 注意：这个例子中省略了设备驱动的具体实现（如open, read, write等函数），  
// 你需要根据你的设备特性来实现这些函数。
 

在这个例子中，我们首先使用class_create函数创建了一个名为my_device_class的设备类。然后，我们使用device_create函数在/dev目录下创建了一个名为my_device的设备节点，并指定了主设备号为240（这个主设备号是你可以自由选择的，只要它不与系统中的其他设备冲突即可）。我们还为设备节点指定了一个文件操作函数集my_device_fops，尽管在这个例子中我们没有实现任何文件操作函数。
 

请注意，of_private字段的赋值方式可能因内核版本而异。在一些内核版本中，你可能需要使用device_set_drvdata或类似函数来设置私有数据，而不是直接赋值给of_private。此外，MKDEV宏用于生成一个设备号，它是由主设备号和次设备号组成的。在这个例子中，我们假设次设备号为0。
 

最后，在模块卸载时，我们使用device_destroy函数销毁设备节点，并使用class_destroy函数销毁设备类。这样，我们就完成了一个简单的设备类和设备节点的创建过程，使得应用端程序可以通过/dev/my_device来访问这个设备。
 

6.举一个例子：使用“创建的类的名称”访问设备 
 

在Linux内核中，通过设备类和设备节点，我们可以实现应用层程序对内核设备的访问。以下是一个简化的例子，展示了如何使用class_create和device_create创建的设备类和设备节点，并在应用层通过设备节点的名称来访问设备。
 

首先，我们创建一个内核模块，该模块创建一个名为example_class的设备类，并在该类下创建一个名为example_device的设备节点。
 

内核模块代码（简化版）
 

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/device.h>  
#include <linux/fs.h>  
#include <linux/uaccess.h> // 为了使用copy_from_user等函数  
  
#define EXAMPLE_DEVICE_NAME "example_device"  
#define EXAMPLE_CLASS_NAME "example_class"  
#define EXAMPLE_DEVICE_MAJOR 240 // 假设的主设备号  
  
static struct class *example_class;  
static struct device *example_device;  
  
// 假设的设备驱动文件操作函数集  
static ssize_t example_read(struct file *filp, char __user *buffer, size_t len, loff_t *offset)  
{  
    // 这里只是简单地返回一个固定的字符串，实际应用中应该根据设备状态来读取数据  
    static const char *msg = "Hello from example device!\n";  
    copy_to_user(buffer, msg, strlen(msg) + 1); // +1 是为了包含字符串结尾的'\0'  
    return strlen(msg) + 1; // 返回读取的字节数  
}  
  
static struct file_operations example_fops = {  
    .owner = THIS_MODULE,  
    .read = example_read,  
    // .open, .release, .write 等函数指针可以在这里定义，这个例子中只实现了read  
};  
  
static int __init example_init(void)  
{  
    int ret = 0;  
  
    // 创建设备类  
    example_class = class_create(THIS_MODULE, EXAMPLE_CLASS_NAME);  
    if (IS_ERR(example_class)) {  
        ret = PTR_ERR(example_class);  
        printk(KERN_ERR "Failed to create device class\n");  
        goto out;  
    }  
  
    // 创建设备节点  
    example_device = device_create(example_class, NULL, MKDEV(EXAMPLE_DEVICE_MAJOR, 0), NULL, EXAMPLE_DEVICE_NAME);  
    if (IS_ERR(example_device)) {  
        ret = PTR_ERR(example_device);  
        printk(KERN_ERR "Failed to create device node\n");  
        class_destroy(example_class);  
        goto out;  
    }  
  
    // 设置设备节点的文件操作函数集  
    device_set_drvdata(example_device, &example_fops); // 在新的内核版本中应该使用这个函数  
  
    printk(KERN_INFO "Device class and node created successfully\n");  
  
out:  
    return ret;  
}  
  
static void __exit example_exit(void)  
{  
    // 销毁设备节点  
    if (example_device) {  
        device_destroy(example_class, MKDEV(EXAMPLE_DEVICE_MAJOR, 0));  
    }  
  
    // 销毁设备类  
    if (example_class) {  
        class_destroy(example_class);  
    }  
  
    printk(KERN_INFO "Device class and node destroyed\n");  
}  
  
module_init(example_init);  
module_exit(example_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("Example of creating a device class and node, and accessing the device from userspace");
 

应用层代码
 

在应用层，我们可以通过标准的Linux文件操作API（如open, read, write, close等）来访问设备节点。以下是一个简单的C程序，用于读取上面内核模块中创建的example_device设备节点的数据。
 

#include <stdio.h>  
#include <stdlib.h>  
#include <fcntl.h>  
#include <unistd.h>  
  
#define DEVICE_PATH "/dev/example_device"  
#define BUFFER_SIZE 256  
  
int main()  
{  
    int fd;  
    char buffer[BUFFER_SIZE];  
    ssize_t bytes_read;  
  
    // 打开设备节点  
    fd = open(DEVICE_PATH, O_RDONLY);  
    if (fd == -1) {  
        perror("Failed to open device");  
        return EXIT_FAILURE;  
    }  
  
    // 读取设备数据  
    bytes_read = read(fd, buffer, BUFFER_SIZE - 1);  
    if (bytes_read == -1) {  
        perror("Failed to read from device");  
        close(fd);  
        return EXIT_FAILURE;  
    }  
  
    // 输出读取的数据  
    buffer[bytes_read] = '\0'; // 确保字符串以'\0'结尾  
    printf("Read from device: %s\n", buffer);  
  
    // 关闭设备节点  
    close(fd);  
  
    return EXIT_SUCCESS;  
}
 

在这个例子中，内核模块创建了一个名为example_class的设备类，并在该类下创建了一个名为example_device的设备节点。应用层程序通过打开/dev/example_device设备节点，并调用read函数来读取设备的数据。内核模块中的example_read函数被调用，将固定的字符串返回给应用层程序。
 

7.EXAMPLE_DEVICE_NAME 
 

EXAMPLE_DEVICE_NAME 是一个在内核模块代码中定义的宏，用于表示设备节点的名称。在这个例子中，它被设置为 "example_device"。这个名称会用于在 /dev 目录下创建相应的设备文件（节点），以便用户空间程序可以通过标准的文件操作API来访问内核设备。
 

在内核模块中，device_create 函数用于创建这个设备节点，并且会将 EXAMPLE_DEVICE_NAME 作为设备节点的名称。当用户空间程序想要与这个设备进行交互时，它会打开 /dev/example_device 文件，这个文件实际上是一个指向内核中设备的接口。
 

总结一下，EXAMPLE_DEVICE_NAME 的作用是为设备节点提供一个唯一的、用户友好的名称，这个名称会出现在 /dev 目录下，并且可以被用户空间程序用来访问设备。在这个具体的例子中，通过访问 /dev/example_device，用户空间程序可以调用内核模块中实现的 example_read 函数（以及其他可能的文件操作函数）来与设备进行交互。
 

8.EXAMPLE_CLASS_NAME 
 

EXAMPLE_CLASS_NAME 是一个在内核模块代码中定义的宏，用于表示设备类的名称。在这个上下文中，设备类是一种组织设备节点的方式，它允许将具有相似功能的设备归为一类。
 

在Linux内核中，设备类是通过 class_create 函数创建的。这个函数返回一个指向新创建的 struct class 结构的指针，该结构代表了设备类。设备类在 /sys/class 目录下表示，并且可以在该目录下找到与类名对应的子目录。
 

在这个例子中，EXAMPLE_CLASS_NAME 被设置为 "example_class"。当内核模块调用 class_create 函数时，它会使用这个宏的值作为设备类的名称。然后，模块可以使用 device_create 函数在这个类下创建一个或多个设备节点。
 

与用户空间交互时，设备类的名称并不直接出现在文件路径中。相反，设备节点的名称（在这个例子中是 EXAMPLE_DEVICE_NAME，即 "example_device"）会出现在 /dev 目录下，并且用户空间程序会通过这个路径来访问设备。然而，设备类的存在对于内核来说是有意义的，因为它提供了一种组织和管理设备节点的方式。
 

总结一下，EXAMPLE_CLASS_NAME 用于在内核中定义一个设备类的名称，这个类可以包含多个具有相似功能的设备节点。在这个具体的例子中，通过 example_class 类，内核模块可以组织和管理名为 example_device 的设备节点。
 

9.设备节点的名称和设备类的名称有什么差别 
 

设备节点的名称和设备类的名称在Linux内核和设备管理中扮演着不同的角色，它们之间存在显著的差别。以下是对这两者的详细比较：
 

设备节点名称
 

  • 定义与功能：设备节点名称是用来表示设备的文件名称，它提供了一种用户空间和内核空间进行通信的方式。在Linux系统中，一切皆文件，设备也被看作文件的形式来管理，而设备节点名称就是这些设备文件的名称。
  • 位置：设备节点通常位于/dev目录下，例如键盘的设备节点可能位于/dev/input/eventX。
  • 作用：设备节点名称使得用户可以通过标准的文件操作来访问设备，如打开、读取、写入等。它是应用程序与设备驱动程序交互的桥梁。
  • 命名规则：设备节点名称通常由设备类型和实例编号组成，例如/dev/sda表示第一个SCSI磁盘。
 

设备类名称
 

  • 定义与功能：设备类名称是对具有相似功能或属性的设备节点进行分组的标识符。它用于在内核中组织和管理设备节点，使得设备的管理和访问更加有序和高效。
  • 位置：设备类名称在内核中表示，并在/sys/class目录下反映出来。每个设备类在该目录下都有一个对应的子目录。
  • 作用：设备类名称有助于内核对设备进行分类和管理。通过设备类，内核可以更容易地识别和管理具有相似功能的设备节点，例如热插拔事件处理、电源管理等。
  • 命名规则：设备类名称通常是有意义的字符串，能够反映设备类的功能或属性。例如，键盘和鼠标等输入设备可能被归类到input设备类中。
 

差别总结
 

  • 位置与表示：设备节点名称出现在/dev目录下，是用户空间访问设备的接口；而设备类名称在内核中表示，并在/sys/class目录下反映出来，用于组织和管理设备节点。
  • 功能与作用：设备节点名称直接用于用户空间的设备访问；而设备类名称则用于内核中的设备管理和组织。
  • 命名规则：设备节点名称通常由设备类型和实例编号组成，具有唯一性；而设备类名称则更注重于反映设备的功能或属性，可能具有更高的抽象层次。
 

总的来说，设备节点名称和设备类名称在Linux内核和设备管理中扮演着不同的角色，它们共同构成了Linux设备管理体系的基础。
 

10.inux驱动的open函数 
 

在Linux内核中，设备驱动程序的 open 函数是驱动程序中关键的一部分，用于处理用户空间对设备的打开请求。当用户空间程序尝试打开设备文件（例如 /dev/sda 或 /dev/mydevice）时，内核会调用相应设备驱动程序的 open 函数。
 

这个 open 函数通常执行以下任务：
 

  1.  
    检查设备状态：验证设备是否处于可以被打开的状态，例如设备是否已经被其他进程打开，或者设备是否存在硬件故障。
     
  2.  
    初始化设备：为设备的后续操作进行必要的初始化，这可能包括分配内存、配置硬件寄存器、设置设备状态等。
     
  3.  
    更新设备状态：记录设备当前被打开的事实，可能还需要更新设备的其他状态信息。
     
  4.  
    返回文件描述符：虽然 open 函数本身不直接返回文件描述符给用户空间，但它会确保内核能够为用户空间程序提供一个有效的文件描述符，该描述符随后可用于对设备进行读写操作。
     
  5.  
    错误处理：如果无法打开设备，open 函数需要返回适当的错误代码（例如 -ENODEV 表示设备不存在，-EBUSY 表示设备正忙等）。
     
 

在Linux内核中，设备驱动程序的 open 函数通常是通过文件操作结构体 file_operations 暴露给内核的。这个结构体包含了驱动程序提供的所有文件操作函数，包括 open、read、write、release（对应于用户空间的 close）等。
 

下面是一个简化的例子，展示了如何在Linux设备驱动程序中实现 open 函数：
 

 

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/fs.h>  
#include <linux/uaccess.h>  
#include <linux/cdev.h>  
  
// 假设这是你的设备结构体  
struct my_device {  
    struct cdev cdev; // 字符设备结构体  
    // ... 其他设备相关的成员  
};  
  
// 设备驱动的 open 函数  
static int my_device_open(struct inode *inode, struct file *file)  
{  
    struct my_device *device;  
  
    // 获取设备私有数据（通常在设备初始化时设置）  
    device = container_of(inode->i_cdev, struct my_device, cdev);  
  
    // 检查设备状态，进行初始化等操作  
    // ...  
  
    // 如果一切正常，返回0表示成功  
    return 0;  
  
    // 如果出错，返回相应的负值错误代码  
    // return -ENXIO; // 例如，设备不存在  
}  
  
// 文件操作结构体  
static struct file_operations my_device_fops = {  
    .owner = THIS_MODULE,  
    .open = my_device_open,  
    // ... 其他文件操作函数  
};  
  
// 驱动程序的其他部分，如初始化、清理等  
// ...
 

在这个例子中，my_device_open 函数是设备驱动程序的 open 函数。当用户空间程序尝试打开设备时，内核会调用这个函数。函数通过 container_of 宏获取设备的私有数据（即 my_device 结构体实例），然后进行必要的检查和初始化。如果一切正常，函数返回0表示成功；如果出错，则返回相应的错误代码。
 

11.inux驱动的open函数详细说明 
 

Linux内核中的设备驱动程序的open函数是文件操作接口的一部分，它负责处理用户空间对设备文件的打开请求。下面是对open函数的详细说明：
 

一、函数原型
 

在Linux内核中，open函数通常是file_operations结构体中的一个成员，其原型如下：
 

 

c复制代码
 

int (*open)(struct inode *inode, struct file *file);
 

  • inode：指向设备文件在文件系统中的索引节点的指针，它包含了文件的元数据信息。
  • file：指向一个file结构的指针，该结构表示打开的文件。它包含了文件的当前状态信息，如文件偏移量、访问模式等。
 

二、函数功能
 

open函数的主要功能包括：
 

  1.  
    检查设备状态：在设备被打开之前，open函数可以检查设备的状态，确保设备是可用的，并且没有被其他进程占用。
     
  2.  
    初始化设备：根据需要进行设备的初始化工作，如分配内存、设置设备的工作模式、启动设备等。
     
  3.  
    更新文件结构：open函数可以更新file结构中的成员，以记录设备的当前状态和用户空间对设备的访问模式。
     
  4.  
    错误处理：如果设备无法被打开（例如设备不存在、设备忙等），open函数应该返回相应的错误代码。
     
 

三、返回值
 

  • 成功时，open函数应返回0。
  • 失败时，open函数应返回一个负值错误代码。常见的错误代码包括： 
  
    • -ENODEV：设备不存在。
    • -EBUSY：设备正忙，无法被打开。
    • -EACCES：没有足够的权限打开设备。
    • 其他错误代码，具体取决于设备驱动程序的实现和遇到的错误情况。
 

四、示例代码
 

下面是一个简化的示例，展示了如何在设备驱动程序的open函数中进行一些基本的操作：
 

 

#include <linux/fs.h>  
#include <linux/module.h>  
#include <linux/uaccess.h>  
#include <linux/cdev.h>  
  
// 假设这是你的设备结构体  
struct my_device {  
    struct cdev cdev; // 字符设备结构体  
    // ... 其他设备相关的成员  
};  
  
// 设备驱动的 open 函数  
static int my_device_open(struct inode *inode, struct file *file)  
{  
    struct my_device *device;  
  
    // 获取设备私有数据  
    device = container_of(inode->i_cdev, struct my_device, cdev);  
  
    // 检查设备状态（此处仅为示例，实际应根据设备特性进行检查）  
    if (!device->is_ready) {  
        printk(KERN_ERR "Device is not ready\n");  
        return -EBUSY; // 设备忙，无法打开  
    }  
  
    // 初始化设备（此处仅为示例，实际应根据设备特性进行初始化）  
    device->is_open = true; // 标记设备已被打开  
    // ... 其他初始化操作  
  
    // 更新文件结构（此处仅为示例，实际应根据需要更新）  
    file->private_data = device; // 将设备结构体指针保存在file结构中  
  
    // 打开成功，返回0  
    return 0;  
}  
  
// 文件操作结构体  
static struct file_operations my_device_fops = {  
    .owner = THIS_MODULE,  
    .open = my_device_open,  
    // ... 其他文件操作函数  
};  
  
// 驱动程序的其他部分，如初始化、清理等  
// ...
 

在这个示例中，my_device_open函数是设备驱动程序的open函数。它首先通过container_of宏获取设备私有数据，然后检查设备状态，并进行必要的初始化工作。最后，它更新file结构中的成员，以记录设备的当前状态，并返回0表示打开成功。
 

五、注意事项
 

  1.  
    并发访问：在设备被多个进程同时访问时，open函数需要考虑并发访问的问题。通常，可以通过锁机制来保护设备的状态信息和初始化过程。
     
  2.  
    错误处理：open函数应该对可能发生的错误进行妥善处理，并返回相应的错误代码。这有助于用户空间程序了解打开设备失败的原因，并采取相应的措施。
     
  3.  
    资源管理：在open函数中分配的资源（如内存、文件描述符等）需要在设备关闭时进行释放，以避免资源泄漏。这通常是在release函数中完成的。
     
 

12.inode 
 

inode（索引节点）是Linux和其他类UNIX操作系统文件系统中用于存储文件和目录元数据信息的数据结构。每个文件和目录都有一个唯一的inode，用于标识和管理文件系统中的文件和目录。以下是对inode的详细解释：
 

inode的作用和内容
 

  • 唯一标识：inode是文件系统中每个文件和目录的唯一标识符。通过inode，系统可以唯一地定位和管理文件或目录。
  • 存储元数据：inode包含了文件和目录的各种属性信息，如文件类型、文件大小、访问权限、所属用户和组、创建时间、修改时间、访问时间等。此外，inode还包含了指向文件数据块的指针，用于定位文件数据的实际存储位置。
  • 性能优化：由于inode中记录了文件的元数据信息，系统可以通过读取inode来获取文件的属性，而无需读取整个文件，从而提高了文件系统的性能。
 

inode的特点
 

  • 分离性：在Linux文件系统中，文件名和inode是分离的。文件名只是inode的一个别名，用于用户友好的文件访问。当用户访问一个文件时，系统通过文件名查找对应的inode，然后根据inode中的信息获取文件的元数据和数据。
  • 灵活性：inode中包含了丰富的文件属性信息，可以支持灵活的文件系统管理和权限控制。
  • 硬链接支持：inode允许多个文件名指向同一个inode，从而支持硬链接。硬链接是多个文件名指向同一个文件数据块的方式，可以在文件系统中创建多个文件名访问同一个文件，而不占用额外的存储空间。
 

inode的管理
 

  • inode表：文件系统中有一个inode表，用于存储所有inode的信息。当一个文件或目录被创建时，系统会在inode表中为其分配一个inode。
  • inode数量限制：文件系统在格式化时会预先分配一定数量的inode。一旦inode被用完，即使磁盘上还有空闲空间，也无法再创建新的文件或目录。因此，inode数量是文件系统容量管理中的一个重要指标。
  • inode使用监控：可以使用df -i命令检查文件系统内的inode总数和已使用情况，以便及时发现和处理inode耗尽的问题。
 

inode的实际应用
 

  • 磁盘空间管理：在磁盘空间耗尽的情况下，可能是inode不足导致的。通过监控inode的使用情况，可以更好地管理磁盘空间。
  • 文件恢复：当文件被意外删除时，如果数据块尚未被覆盖，使用inode信息可以帮助恢复文件。
  • 硬链接管理：通过inode可以实现硬链接，从而允许多个文件名访问同一个文件数据块，提高文件系统的灵活性。
 

总之，inode是Linux文件系统中非常重要的概念，它对于文件系统的管理和优化起着至关重要的作用。了解inode的工作原理和特性，有助于更好地管理和维护Linux文件系统。
 

13.linux驱动开发 O_RDWR 
 

在Linux驱动开发中，O_RDWR 是一个重要的标志，用于指定文件的打开模式。当用户空间程序通过系统调用（如 open()）尝试打开一个设备文件时，它可以传递这个标志来表明希望对设备进行读写操作。
 

O_RDWR 标志的意义
 

O_RDWR 标志表示“读写模式”（Read/Write Mode）。当一个文件（在这里特指设备文件）以这种模式打开时，用户程序既可以读取设备的数据，也可以向设备写入数据。
 

在驱动中的使用
 

在设备驱动的 open 函数中，通常会检查传递给它的标志，并根据这些标志来设置设备的状态或执行相应的初始化操作。如果 O_RDWR 标志被设置，驱动就知道用户希望进行读写操作，因此可能会执行一些额外的初始化来确保设备能够同时支持这两种操作。
 

示例代码
 

下面是一个简化的设备驱动 open 函数的示例，它检查了 O_RDWR 标志：
 

 

#include <linux/fs.h>  
#include <linux/uaccess.h>  
#include <linux/cdev.h>  
  
// 假设这是设备结构体  
struct my_device {  
    struct cdev cdev; // 字符设备结构体  
    // ... 其他成员  
};  
  
// 设备驱动的 open 函数  
static int my_device_open(struct inode *inode, struct file *file)  
{  
    struct my_device *device;  
    int flags = file->f_flags; // 获取打开标志  
  
    // 获取设备私有数据  
    device = container_of(inode->i_cdev, struct my_device, cdev);  
  
    // 检查是否以读写模式打开  
    if (flags & O_RDWR) {  
        // 执行读写模式的初始化  
        // ...  
        printk(KERN_INFO "Device opened in read/write mode\n");  
    }  
  
    // ... 其他初始化操作  
  
    // 更新文件私有数据（可选）  
    file->private_data = device;  
  
    // 打开成功，返回0  
    return 0;  
}  
  
// 文件操作结构体  
static struct file_operations my_device_fops = {  
    .owner = THIS_MODULE,  
    .open = my_device_open,  
    // ... 其他文件操作  
};  
  
// 驱动的入口函数（初始化等）  
// ...
 

在这个示例中，my_device_open 函数检查了传递给它的文件标志（file->f_flags），并判断了 O_RDWR 标志是否被设置。如果是，它会执行一些特定的初始化操作，并打印一条消息到内核日志。
 

注意事项
 

  1. 并发访问：如果设备支持多个进程同时打开进行读写操作，驱动需要确保适当的同步机制来防止数据竞争和条件竞争。
  2. 错误处理：如果设备不支持读写模式，或者由于其他原因无法以读写模式打开，驱动应该返回相应的错误代码（如 -EACCES 表示权限不足，-EINVAL 表示无效参数等）。
  3. 资源管理：在打开设备时分配的资源（如内存、锁等）需要在设备关闭时正确释放，以避免资源泄漏。这通常是在驱动的 release 函数中完成的。
 

 

                

        

    

  



    



                



	

		

			

				
					
Linux设备驱动的class(类)的理解(以timed_output为基础)

				
			

			

				

					dkleikesa的专栏
				

				

					07-18
					
					1985
					
				

			

		

		

			
				
一、  前言
前天写了关于安卓震动系统的驱动开发全过程，其中用到了timed_output这个驱动模型，那天只是简单的用了一下，今天拿出来彻底的研究一下，分享一下我的理解。
在使用这个驱动模型的时候，我一直都很奇怪，它的名字看上去和时间有很大的关系，在我的心里我也以为它会提供一些与时间操作相关的函数，帮助开发人员简单的完成与时间相关的操作，但是翻遍了它的实现代码都没有发现它与时间的半毛钱关系。

			
		

	



                

            
              



	

		

			

				
					
Linux驱动之 自动创建设备节点class_create、device_create

				
			

			

				

					编程一时爽爽一时
				

				

					04-24
					
					5217
					
				

			

		

		

			
				
Linux驱动之自动创建设备文件节点学习记录：
上节课利用了mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点。内核中定义了struct class结构体，一个struct class结构体类型变量对应一个类，内核同时提供了class_create()函数，可以用它来创建一个类，这个类存放于sysfs下面，创建了这个类，再调用device_create()函数来在/dev目录下创建相应的设备节点。这

			
		

	



              


  
              

                


	

		

			

				
					
在驱动模块初始化函数中实现设备节点的自动创建

				
			

			

				

					华清远见 | 程序员的学习天堂
				

				

					08-26
					
					1191
					
				

			

		

		

			
				
作者：杨硕，华清远见嵌入式学院讲师。我们在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了udev。内核中定义了struct class结构体，顾名思义，一个struct class结构体类型

			
		

	





	

		

			

				
					
Linux 设备驱动模型中的class（类）

				
			

			

				

					yinwei520的专栏
				

				

					07-08
					
					1万+
					
				

			

		

		

			
				
首先，想说明一下，促使我研究class（类）的是因为它能够自动创建/dev下的设备节点。当然class还有其另外的作用，且自动创建设备节点的还有udev系统，udev是处于用户空间的，其自动创建设备节点也是依赖于sysfs文件系统中提供的class类，我有个问题，如果我的内核没有

			
		

	



		

			
		



	

		

			

				
					
字符设驱动

				
			

			

				

					uyiwfn的专栏
				

				

					07-01
					
					630
					
				

			

		

		

			
				
从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的替代。提醒一点，udev是应用层的，不要试图在内核的配置选项里找到它;加入对udev的支持很简单，以作者所写的一个字符设备驱动为例，在驱动初始化的代码里调用class_create为该设备创建一个class，再为每个设备调用device_create创建对应的设备。大致用法如下：

struct class *m

			
		

	





	

		

			

				
					
class_create()

				
			

			

				

					JINKAI
				

				

					09-14
					
					780
					
				

			

		

		

			
				
从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的替代。相比devfs，udev有很多优势，在此就不罗嗦了，提醒一点，udev是应用层的东东，不要试图在内核的配置选项里找到它;加入对udev的支持很简单，以作者所写的一个字符设备驱动为例，在驱动初始

			
		

	





	

		

			

				
					
Linux Kernel编程 --- class_create/device_create/udev特性

				
			

			

				

					huofengfeihu的博客
				

				

					08-11
					
					3867
					
				

			

		

		

			
				
1 class

    内核中定义了struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。



（1）通过class_cr...

			
		

	





	

		

			

				
					
linux class结构体,linux中class_create和device_creat

				
			

			

				

					weixin_42502075的博客
				

				

					05-15
					
					772
					
				

			

		

		

			
				
from:http://blog.youkuaiyun.com/angle_birds/article/details/16802099from:http://blog.chinaunix.net/uid-1827018-id-4098044.htmlfrom:http://www.linuxidc.com/Linux/2011-09/43391p4.htm对于字符设备驱动，当file_operations注...

			
		

	





	

		

			

				
					
结合实验代码device_create ()详解

				
			

			

				

					10-20
				

			

		

		

			
				
通过以上分析可以看出，`device_create()`和`class_create()`是Linux内核驱动程序中非常重要的函数。它们不仅负责设备的注册和管理，还确保了设备节点的正确创建。这对于实现用户空间应用程序与内核驱动之间的通信至...

			
		

	





	

		

			

				
					
Linux 设备创建 device_create() 和  device_create_file()

				
			

			

				

					xiaoyu_wu的博客
				

				

					04-22
					
					6165
					
				

			

		

		

			
				
1、device_create

如果成功，它将会在 /dev 目录下产生 /dev/mdev 设备



struce device *device_create(struct class *class, struct device *parent, 
                        dev_t devt, void *drvdata, const char *fmt, ...)


/******************* 代码例子 **************************.

			
		

	





	

		

			

				
					
四、 class_create(),device_create(),device_create_file()

				
			

			

				

					当我荒废时间的时候，会有多少人在拼命
				

				

					08-18
					
					1409
					
				

			

		

		

			
				
转载来自:http://blog.youkuaiyun.com/hustyangju/article/details/21019967?utm_source=tuicool&utm_medium=referral

开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点(包括ldd3中不少例子也是这样)，实际上现在Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动

			
		

	





	

		

			

				
					
class_create()  class_device_create

				
			

			

				

					kerson的专栏
				

				

					07-30
					
					1414
					
				

			

		

		

			
				
class_create()








从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的替代。相比devfs，udev有很多优势，在此就不罗嗦了，提醒一点，udev是应用层的东东，不要试图在内核的配置选项里找到它;加入对u

			
		

	





	

		

			

				
					
class_create()函数

				
			

			

				

					o0o0o0D的博客
				

				

					10-26
					
					3241
					
				

			

		

		

			
				
内核中定义了struct class结构体，一个struct
 class 结构体类型变量对应一个类，内核同时提供了class_create()函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建了这个类，再调用device_create()函数在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应device_create()函数，去/sysfs下

			
		

	





	

		

			

				
					
linux驱动-设备驱动模型(class类)

				
			

			

				

					sty01z的博客
				

				

					05-03
					
					739
					
				

			

		

		

			
				
class 用于管理同类的设备，常常被我们用来给上层开辟一个属性节点，多用于查看，修改对应的设备信息。

			
		

	





	

		

			

				
					
Linux内核API之class_create与class_destroy

				
			

			

				

					phmatthaus的专栏
				

				

					04-28
					
					7730
					
				

			

		

		

			
				
一、class_create

函数功能

宏class_create()用于动态创建设备的逻辑类，并完成部分字段的初始化，然后将其添加进Linux内核系统中。此函数的执行效果就是在/sys/class目录下创建一个新的文件夹，此文件夹的名字为此函数的第二个输入参数，但此文件夹是空的。宏class_create()在实现时，调用了函数__class_create()。



函数实现

<内核源码路径>/include/linux/device.h中：


#define class_creat

			
		

	





	

		

			

				
					
class_create(),class_device_create()或device_create()自动创建设备文件结点

					
热门推荐

				
			

			

				

					junglyfine's Blog
				

				

					03-14
					
					1万+
					
				

			

		

		

			
				
<br />从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的替代。相比devfs，udev有很多优势，在此就不罗嗦了，提醒一点，udev是应用层的东东，不要试图在内核的配置选项里找到它;加入对udev的支持很简单，以作者所写的一个字符设备驱动为例，在驱动初始化的代码里调用class_create为该设备创建一个class，再为每个设备调用 class_device_create创建对应的设备。(不太明白什么是devfs,udev,对linux中的文件系统没有什么概念呢。)<

			
		

	





	

		

			

				
					
Linux中class_create和class_register

				
			

			

				

					Embedded engineer 
				

				

					03-08
					
					1141
					
				

			

		

		

			
				
Linux中class_create和class_register

			
		

	





	

		

			

				
					
class_create

				
			

			

				

					qinrenzhi的博客
				

				

					07-15
					
					833
					
				

			

		

		

			
				
class_create函数跟踪：
/* 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 __ke

			
		

	





	

		

			

				
					
linux中class_create和class_register分析

				
			

			

				

					mu0206mu的专栏
				

				

					11-17
					
					2663
					
				

			

		

		

			
				
原文地址：http://www.cnblogs.com/skywang12345/archive/2013/05/15/driver_class.html

			
		

	





	

		

			

				
					
class_create和device_create函数的关系

					
最新发布

				
			

			

				

					02-25
				

			

		

		

			
				
 - 在旧内核中，`class_create` 可能命名为 `class_create_module`。  - 新内核（如 5.x+）中参数可能略有变化（例如返回类型为 `struct class *`）。   2. **错误处理**：   - 必须检查 `class_create` 和 `device_...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值