Linux设备驱动程序

已于 2024-05-23 20:17:22 修改
阅读量97 收藏
点赞数 3
文章标签： linux 运维 服务器
于 2024-05-23 15:27:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74126856/article/details/139149214
版权 
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/ioctl.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/wait.h>

#define DEVICE_NAME "custom_dev"
#define BUFFER_SIZE 4096

static int major_num;
static char *buffer;
static int head = 0;
static int tail = 0;
static struct mutex lock;
static wait_queue_head_t read_wait, write_wait;

static int __init char_dev_init(void) {
    dev_t dev_num;
    int ret;

    // 注册字符设备
    major_num = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_num < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_num;
    }
    printk(KERN_INFO "Registered correctly with major number %d\n", major_num);

    // 分配缓冲区
    buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!buffer) {
        unregister_chrdev(major_num, DEVICE_NAME);
        return -ENOMEM;
    }
    memset(buffer, 0, BUFFER_SIZE);

    // 初始化互斥锁和等待队列
    mutex_init(&lock);
    init_waitqueue_head(&read_wait);
    init_waitqueue_head(&write_wait);

    return 0;
}

static void __exit char_dev_exit(void) {
    // 释放缓冲区和注销字符设备
    kfree(buffer);
    unregister_chrdev(major_num, DEVICE_NAME);
    printk(KERN_INFO "Unregistered correctly\n");
}

static ssize_t char_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) {
    int ret;
    int bytes_to_read;

    printk(KERN_INFO "Read operation\n");

    wait_event_interruptible(read_wait, (head != tail));

    mutex_lock(&lock);
    bytes_to_read = min((size_t)(tail - head), count);
    ret = copy_to_user(buf, &buffer[head], bytes_to_read);
    if (ret == 0) {
        head += bytes_to_read;
        if (head == BUFFER_SIZE) {
            head = 0;
        }
    } else {
        ret = -EFAULT;
    }
    mutex_unlock(&lock);

    return ret ? ret : bytes_to_read;
}

static ssize_t char_dev_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) {
    int ret;
    int bytes_to_write;

    printk(KERN_INFO "Write operation\n");

    wait_event_interruptible(write_wait, (head != tail));

    mutex_lock(&lock);
    bytes_to_write = min((size_t)(BUFFER_SIZE - (tail - head)), count);
    ret = copy_from_user(&buffer[tail], buf, bytes_to_write);
    if (ret == 0) {
        tail += bytes_to_write;
        if (tail == BUFFER_SIZE) {
            tail = 0;
        }
    } else {
        ret = -EFAULT;
    }
    mutex_unlock(&lock);

    if (!ret) {
        wake_up_interruptible(&read_wait); // 唤醒读进程
    }

    return ret ? ret : bytes_to_write;
}

static int char_dev_open(struct inode *inode, struct file *filp) {
    printk(KERN_INFO "Device opened\n");
    return 0;
}

static int char_dev_release(struct inode *inode, struct file *filp) {
    printk(KERN_INFO "Device released\n");
    return 0;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .read = char_dev_read,
    .write = char_dev_write,
    .open = char_dev_open,
    .release = char_dev_release,
};

module_init(char_dev_init);
module_exit(char_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple character device driver with circular buffer and mutex");
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_NAME "/dev/custom_dev"

int main() {
    int fd;
    char buffer[1024];
    ssize_t bytes;

    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }

    while (1) {
        bytes = read(fd, buffer, sizeof(buffer));
        if (bytes < 0) {
            perror("Error reading from device");
            break;
        } else if (bytes == 0) {
            printf("Reached end of file, no more data to read\n");
            break;
        }
        // 打印读取的数据
        printf("Read %zd bytes: %.*s\n", bytes, (int)bytes, buffer);
    }

    close(fd);
    return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_NAME "/dev/custom_dev" 

int main() {
    int fd;
    const char *message = "Hello, this is a test message!\n";
    ssize_t bytes;

    fd = open(DEVICE_NAME, O_WRONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }

    while (1) {
        bytes = write(fd, message, strlen(message));
        if (bytes < 0) {
            perror("Error writing to device");
            break;
        }
        printf("Written %zd bytes to device\n", bytes);
        // 休眠一段时间后再写入，模拟生产者节奏
        usleep(100000); // 休眠100ms
    }

    close(fd);
    return 0;
}
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/wait.h>
#include <linux/mutex.h>

#define DEVICE_NAME "custom_char_dev"
#define BUFFER_SIZE 32

static char *buffer;
static int pRead = 0;
static int pWrite = 0;
static int bytes_in_buffer = 0;
static DECLARE_WAIT_QUEUE_HEAD(read_queue);
static DECLARE_WAIT_QUEUE_HEAD(write_queue);
static DEFINE_MUTEX(mutex);

static ssize_t dev_read(struct file *file, char __user *user_buffer, size_t count, loff_t *offset) {
    ssize_t bytes_read = 0;
    if (wait_event_interruptible(read_queue, bytes_in_buffer > 0)) {
        return -ERESTARTSYS;
    }
    mutex_lock(&mutex);
    bytes_read = min_t(size_t, count, bytes_in_buffer);
    if (copy_to_user(user_buffer, buffer + pRead, bytes_read)) {
        mutex_unlock(&mutex);
        return -EFAULT;
    }
    pRead = (pRead + bytes_read) % BUFFER_SIZE;
    bytes_in_buffer -= bytes_read;
    mutex_unlock(&mutex);
    wake_up(&write_queue);
    return bytes_read;
}

static ssize_t dev_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *offset) {
    ssize_t bytes_written = 0;
    if (wait_event_interruptible(write_queue, bytes_in_buffer < BUFFER_SIZE)) {
        return -ERESTARTSYS;
    }
    mutex_lock(&mutex);
    bytes_written = min_t(size_t, count, BUFFER_SIZE - bytes_in_buffer);
    if (copy_from_user(buffer + pWrite, user_buffer, bytes_written)) {
        mutex_unlock(&mutex);
        return -EFAULT;
    }
    pWrite = (pWrite + bytes_written) % BUFFER_SIZE;
    bytes_in_buffer += bytes_written;
    mutex_unlock(&mutex);
    wake_up(&read_queue);
    return bytes_written;
}

static int dev_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device %s opened\n", DEVICE_NAME);
    return 0;
}

static int dev_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device %s closed\n", DEVICE_NAME);
    return 0;
}

static struct file_operations fops = {
    .open = dev_open,
    .release = dev_release,
    .read = dev_read,
    .write = dev_write,
};

static struct miscdevice custom_char_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = DEVICE_NAME,
    .fops = &fops,
};

static int __init custom_char_dev_init(void) {
    int ret;
    buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!buffer) {
        printk(KERN_ERR "Failed to allocate buffer\n");
        return -ENOMEM;
    }
    ret = misc_register(&custom_char_dev);
    if (ret) {
        printk(KERN_ERR "Failed to register misc device\n");
        kfree(buffer);
        return ret;
    }
    printk(KERN_INFO "Custom char device registered\n");
    return 0;
}

static void __exit custom_char_dev_exit(void) {
    misc_deregister(&custom_char_dev);
    kfree(buffer);
    printk(KERN_INFO "Custom char device unregistered\n");
}

module_init(custom_char_dev_init);
module_exit(custom_char_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Custom Character Device Driver");

read

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
 
#define DEVICE_NAME "/dev/custom_dev" 
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes;

    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }
 
    while (1) {
        bytes = read(fd, buffer, sizeof(buffer) - 1);
        if (bytes < 0) {
            perror("Error reading from device");
            break;
        }
        buffer[bytes] = '\0'; // Null terminate the string
        printf("Read: %s\n", buffer);
        sleep(1); // 每秒读取一次
    }
 
    close(fd);
    return 0;
}

write:

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
 
#define DEVICE_NAME "/dev/custom_dev" 
#define MESSAGE "Hello, this is a test message!\n"

int main() {
    int fd;
    ssize_t bytes;

    fd = open(DEVICE_NAME, O_WRONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }
 
    while (1) {
        bytes = write(fd, MESSAGE, strlen(MESSAGE));
        if (bytes < 0) {
            perror("Error writing to device");
            break;
        }
        printf("Written %zd bytes to device\n", bytes);
        sleep(1); // 每秒写入一次
    }
 
    close(fd);
    return 0;
}

xie

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
 
#define DEVICE_NAME "/dev/custom_char_dev" 
#define MESSAGE "hello device\n"

int main() {
    int fd;
    ssize_t bytes;
    int write_count = 0;

    fd = open(DEVICE_NAME, O_WRONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }
 
    while (1) {
        bytes = write(fd, MESSAGE, strlen(MESSAGE));
        if (bytes < 0) {
            perror("Error writing to device");
            break;
        }
        printf("Wrote: %s %d\n", MESSAGE, write_count++);
        sleep(1); // 每秒写入一次
    }
 
    close(fd);
    return 0;
}

读

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
 
#define DEVICE_NAME "/dev/custom_dev" 
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes;

    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }
 
    while (1) {
        bytes = read(fd, buffer, sizeof(buffer) - 1);
        if (bytes < 0) {
            perror("Error reading from device");
            break;
        } else if (bytes == 0) {
            printf("No more data to read\n");
            break;
        }
        buffer[bytes] = '\0'; // Null terminate the string
        printf("Read: %s\n", buffer);
        sleep(1); // 每秒读取一次
    }
 
    close(fd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h> // 添加错误处理头文件
 
#define DEVICE_NAME "/dev/custom_dev" 
#define BUFFER_SIZE 1024
 
int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes;
    size_t total_bytes_read = 0; // 用于跟踪读取的总字节数
 
    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }
 
    while (1) {
        bytes = read(fd, buffer + total_bytes_read, sizeof(buffer) - total_bytes_read - 1);
        if (bytes < 0) {
            perror("Error reading from device");
            break;
        } else if (bytes == 0) {
            printf("No more data to read\n");
            break;
        }
        total_bytes_read += bytes;
 
        // 检查是否包含完整的一行
        char *newline_pos = strchr(buffer, '\n');
        if (newline_pos != NULL) {
            *newline_pos = '\0'; // 将换行符替换为空字符
            printf("Read: %s\n", buffer);
            memmove(buffer, newline_pos + 1, total_bytes_read - (newline_pos - buffer) - 1);
            total_bytes_read -= (newline_pos - buffer) + 1;
        }
 
        sleep(1); // 每秒读取一次
    }
 
    close(fd);
    return 0;
}

//read
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_NAME "/dev/custom_char_dev"
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes;
    size_t total_bytes_read = 0;
    int read_count = 1; // 从1开始编号

    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }

    while (1) {
        bytes = read(fd, buffer + total_bytes_read, sizeof(buffer) - total_bytes_read - 1);
        if (bytes < 0) {
            perror("Error reading from device");
            break;
        } else if (bytes == 0) {
            printf("No more data to read\n");
            break;
        }
        total_bytes_read += bytes;

        char *newline_pos = strchr(buffer, '\n');
        if (newline_pos != NULL) {
            *newline_pos = '\0';
            printf("Read: %s [Count: %d]\n", buffer, read_count++); // 输出编号
            memmove(buffer, newline_pos + 1, total_bytes_read - (newline_pos - buffer) - 1);
            total_bytes_read -= (newline_pos - buffer) + 1;
        }

        sleep(1); // 每秒读取一次
    }

    close(fd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define DEVICE_NAME "/dev/custom_char_dev"
#define MESSAGE "hello device\n"

int main() {
    int fd;
    ssize_t bytes;
    int write_count = 1; // 从1开始编号

    fd = open(DEVICE_NAME, O_WRONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }

    while (1) {
        bytes = write(fd, MESSAGE, strlen(MESSAGE));
        if (bytes < 0) {
            perror("Error writing to device");
            break;
        }
        printf("Wrote: %s [Count: %d]\n", MESSAGE, write_count++); // 输出编号
        sleep(1); // 每秒写入一次
    }

    close(fd);
    return 0;
}

羊村你喜哥哥
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
linux 驱动程序安装,如何在Linux上安装设备驱动程序
weixin_42376118的博客
05-01 1558
了解Linux设备驱动程序如何工作以及如何使用它们.对于想要切换到Linux的熟悉Windows或MacOS的人，他们将面临如何安装和配置设备驱动程序的难题. 这是可以理解的，因为Windows和MacOS都有使该过程非常友好的机制. 例如，当您插入新的硬件设备时，Windows会自动检测并弹出一个窗口，询问您是否要继续安装驱动程序. 您也可以从Internet下载驱动程序，只需双击以通过设备管理...
深入linux设备驱动程序内核机制
04-26
《深入Linux设备驱动程序内核机制》一书探讨了Linux内核与设备驱动程序的紧密关系，旨在帮助读者深入理解如何有效地编写和优化Linux设备驱动。书中不仅关注内核模块的构建，还涉及驱动程序与内核交互的关键技术，如...
Linux设备驱动程序（一）——设备驱动简介
明天你好的博客
05-19 1678
这一部分主要是用来介绍 Linux 设备驱动程序的一些基本概念，包括：Linux 设备驱动程序的作用、内核功能的划分、设备和模块的分类以及版本编号。
Linux设备驱动程序设计(一）
zhangjianangyou的博客
11-20 1917
Linux驱动程序概述 Linux设备驱动程序是为特定的硬件提供给应用程序的一组标准化接口，它隐藏了设备工作的细节。用户程序通过标准化系统调用，这些调用和特定的硬件是无关的，再由Linux内核调用特定的设备驱动程序操作和控制特定的实际的硬件设备。其中，Linux系统设备分为三种类型： 字符设备（character device) 块设备（block device） 网络接口（network interface） 本篇文章中，主要谈论字符设备驱动程序的设计。 字符设备是能够像字节流一样被访问的设备，一般不
学习笔记——《LINUX设备驱动程序（第三版）》Linux设备模型：内核添加、删除设备、驱动程序
holly的专栏
09-20 1436
该章先讲解了设备驱动的几个基础概念：kobject、kset、subsystem、sysfs、hotplug、bus、device、device_drive、class。本文主要总结内核添加设备和删除设备的过程。
linux设备驱动程序开发--并口控制LED的驱动源码
华为奋斗者精神
08-23 4580
linux设备驱动程序开发--并口控制LED的驱动源码，有驱动开发的可以参考一下，欢迎点赞！
Linux设备驱动程序源码
a3121772305的博客
01-17 1485
「Linux设备驱动程序第三版源码」https://www.aliyundrive.com/s/6aRKP1cZQ7z 点击链接保存，或者复制本段内容，打开「阿里云盘」APP ，无需下载极速在线查看，视频原画倍速播放。
Linux设备驱动程序第三版源码
lallbj23的博客
11-15 2011
这本书的源码可以直接在http://www.oreilly.com/catalog/linuxdrive3下载，国内可以直接访问。 另附阿里云盘链接 https://www.aliyundrive.com/s/84pq7iacHi5
linux设备驱动程序注册过程详解
蜗牛Running
01-11 7491
Linux的驱动程序注册过程，大致分为两个步骤： 模块初始化驱动程序注册 下面以内核提供的示例代码pci-skeleton.c，详细说明一个pci设备驱动程序的注册过程。其他设备的驱动代码注册过程基本相同，大家可自行查看。使用的内核代码版本是2.6.38。 1. 模块初始化 1.1 驱动程序入口 所有的设备驱动程序都会有如下两行代码： 1922 module_init(netd
Linux设备驱动开发---字符设备驱动程序
qq_41683305的博客
04-26 3495
字符设备驱动程序1 主设备和次设备的概念设备号的注册和释放静态方法动态方法区别2 设备文件操作struct file_operations与struct file、struct inode关系3 分配和注册字符设备class_createcdev_adddevice_create4 字符设备驱动程序 字符设备通过字符（一个接一个的字符）以流方式向用户程序传递数据，就像串行端口那样。字符设备驱动通过/dev目录下的特殊文件公开设备的属性和功能，通过这个文件可以在设备和用户应用程序之间交换数据，也可以通过它来控
Linux设备驱动开发详解
热门推荐
tan1666的博客
01-20 2万+
Linux设备驱动开发详解Linux设备驱动开发详解Linux设备驱动开发Linux设备驱动开发详解1. linux设备驱动概述及开发环境搭建2. 驱动设计的硬件基础3. linux内核及内核编程4. linux内核模块5. linux文件系统与设备文件6. 字符设备驱动7. linux设备驱动中的并发控制8. linux设备驱动中的阻塞与非阻塞I/O9. linux设备驱动中的异步通知与异步I/O10. 中断与时钟11. 内存与I/O访问12. linux设备驱动的软件架构思想13. linux块设备驱.
深入Linux设备驱动程序内核机制.pdf
08-22
Linux设备驱动程序是操作系统与硬件之间的重要桥梁，它们负责处理硬件操作，使应用程序能够与硬件进行通信。在Linux内核中，设备驱动程序是作为内核模块编写的，可以动态加载或卸载，以增强系统的灵活性。本文深入...
嵌入式Linux设备驱动程序开发.pdf
09-06
嵌入式Linux设备驱动程序开发 本文主要讲述了嵌入式Linux设备驱动程序的概念、通用模块和具体开发流程，进一步通过实例论述了如何设计和编写模块化的嵌入式Linux设备驱动程序，以及解释驱动程序的关键代码。 一、...
嵌入式Linux设备驱动程序开发指南.pdf
03-16
《嵌入式Linux设备驱动程序开发指南》是针对嵌入式Linux系统中设备驱动程序开发的一本专业书籍，由西班牙作者Alberto Liberal de los Ríos撰写，专注于讲解如何为使用设备树的嵌入式Linux系统开发驱动。本书特别...
Linux 下 Anaconda/Miniconda 环境安装教程
蜡笔小新星的博客
08-04 654
通过以上步骤，你应该能够详尽地完成 Anaconda 或 Miniconda 的安装，创建和管理环境。
Linux初学基本命令
yuan20010401的博客
07-25 1315
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
【Kubernetes】Deployment 的状态
最新发布
书山有路，学海无涯。记录成长，追逐梦想
08-04 545
通过使用 Deployment 控制器，开发人员可以部署 Pod、设置 Pod 的副本、实现 Pod 的升级与回滚。在 YAML 文件中描述清楚了 Deployment 控制器的目标是什么，Deployment 控制器会自动完成对 Pod 和 ReplicaSet 的管理。Kubernetes 可以直接运行一个新的 Deployment 控制器，也可以用一个新的 Deployment 控制器替换旧的 Deployment 控制器。
Linux 内核更换与代码阅读环境设置(Vscode+Clangd)
Scolin丶
08-04 124
测试环境：Ubuntu 22.04安装编译依赖获取内核源代码内核配置处理证书问题，在编译时遇到证书问题输入两次 enter 即可继续编译内核和模块安装模块安装内核更新引导加载程序重启默认情况下已经更换为最新的内核。如果没有更换，则在 GRUB 引导界面（在开机过程中按下 Esc 键）选择 Advanced options for Ubuntu，手动选择对应的内核版本启动即可。
Linux设备驱动程序深度探索
"Linux设备驱动程序" 《Linux设备驱动程序》是由Jonathan Corbet, Alessandro Rubini和Greg Kroah-Hartman合著的专业书籍，该书的简体中文版本由quickwhale翻译，目前处于V0.0.1阶段。书中详细介绍了Linux系统中的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值