linux字符设备驱动程序设计概述

最新推荐文章于 2023-10-05 23:31:07 发布
最新推荐文章于 2023-10-05 23:31:07 发布
阅读量2.6k 收藏 2
点赞数
分类专栏： 驱动开发 文章标签： linux buffer struct module file cmd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaozhi_su/article/details/4258641
版权

字符设备是最基本、最常用的设备。概括的说，字符设备驱动主要要做三件事：1、定义一个结构体static struct file_operations变量，其内定义一些设备的打开、关闭、读、写、控制函数；2、在结构体外分别实现结构体中定义的这些函数；3、向内核中注册或删除驱动模块。具体如下：

字符设备提供给应用程序流控制接口有：open/close/read/write/ioctl，添加一个字符设备驱动程序，实际上是给上述操作添加对应的代码，Linux对这些操作统一做了抽象

struct file_operations

file_operations结构体的例子如下

       static struct file_operations myDriver_fops = {

       owner:           THIS_MODULE,

       write:             myDriver_write,

       read:                     myDriver_read,

       ioctl:              myDriver_ioctl,

       open:              myDriver_open,

       release:           myDriver_release,

};

该结构体规定了驱动程序向应用程序提供的操作接口：

实现write操作

从应用程序接收数据送到硬件。例：

static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)

{

       size_t fill_size = count;

       PRINTK("myDriver write called!/n");

       PRINTK("/tcount=%d, pos=%d/n", count, (int)*f_pos);

       if(*f_pos >= sizeof(myDriver_Buffer))

       {

              PRINTK("[myDriver write]Buffer Overlap/n");

              *f_pos = sizeof(myDriver_Buffer);

              return 0;

       }

       if((count + *f_pos) > sizeof(myDriver_Buffer))

       {

              PRINTK("count + f_pos > sizeof buffer/n");

              fill_size = sizeof(myDriver_Buffer) - *f_pos;

       }

       copy_from_user(&myDriver_Buffer[*f_pos], buf, fill_size);

       *f_pos += fill_size;

       return fill_size;

}

其中的关键函数

       u_long copy_from_user(void *to, const void *from, u_long len);

把用户态的数据拷到内核态，实现数据的传送。

实现read操作

从硬件读取数据并交给应用程序。例：

static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)

{

       size_t read_size = count;

       PRINTK("myDriver read called!/n");

       PRINTK("/tcount=%d, pos=%d/n", count, (int)*f_pos);

       if(*f_pos >= sizeof(myDriver_Buffer))

       {

              PRINTK("[myDriver read]Buffer Overlap/n");

              *f_pos = sizeof(myDriver_Buffer);

              return 0;

       }

       if((count + *f_pos) > sizeof(myDriver_Buffer))

       {

              PRINTK("count + f_pos > sizeof buffer/n");

              read_size = sizeof(myDriver_Buffer) - *f_pos;

       }

       copy_to_user(buf, &myDriver_Buffer[*f_pos], read_size);

       *f_pos += read_size;

       return read_size;

}

       其中的关键函数

                     u_long copy_to_user(void * to, const void *from, u_long len);

              该函数实现把内核态的数据拷到用户态下。

实现ioctl操作

为应用程序提供对硬件行为的控制。例：

static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)

{

       PRINTK("myDriver ioctl called(%d)!/n", cmd);

    if(_IOC_TYPE(cmd) != TSTDRV_MAGIC)

    {

        return -ENOTTY;

    }

 

    if(_IOC_NR(cmd) >= TSTDRV_MAXNR)

    {

        return -ENOTTY;

    }

       switch(cmd)

       {

              case MYDRV_IOCTL0:

                     PRINTK("IOCTRL 0 called(0x%lx)!/n", arg);

                     break;

              case MYDRV_IOCTL1:

                     PRINTK("IOCTRL 1 called(0x%lx)!/n", arg);

                     break;

              case MYDRV_IOCTL2:

                     PRINTK("IOCTRL 2 called(0x%lx)!/n", arg);

                     break;

              case MYDRV_IOCTL3:

                     PRINTK("IOCTRL 3 called(0x%lx)!/n", arg);

                     break;

       }

       return 0;

}

实现open操作

当应用程序打开设备时对设备进行初始化，使用MOD_INC_USE_COUNT增加驱动程序的使用次数。例：

static int myDriver_open(struct inode *inode, struct file *filp)

{

       MOD_INC_USE_COUNT;

       PRINTK("myDriver open called!/n");

       return 0;

}

实现release操作

当应用程序关闭设备时处理设备的关闭操作。使用MOD_DEC_USE_COUNT增加驱动程序的使用次数。例：

static int myDriver_release(struct inode *inode, struct file *filp)

{

       MOD_DEC_USE_COUNT;

       PRINTK("myDriver release called!/n");

       return 0;

}

驱动程序初始化函数

Linux在加载内核模块时会调用初始化函数，初始化驱动程序本身使用register_chrdev向内核注册驱动程序，该函数的第三个指向包含有驱动程序接口函数信息的file_operations结构体。

例：

/* Module Init & Exit function */

#ifdef CONFIG_DEVFS_FS

devfs_handle_t devfs_myDriver_dir;

devfs_handle_t devfs_myDriver_raw;

#endif

static int __init myModule_init(void)

{

       /* Module init code */

       PRINTK("myModule_init/n");

       /* Driver register */

       myDriver_Major = register_chrdev(0, DRIVER_NAME, &myDriver_fops);

       if(myDriver_Major < 0)

       {

              PRINTK("register char device fail!/n");

              return myDriver_Major;

       }

       PRINTK("register myDriver OK! Major = %d/n", myDriver_Major);

#ifdef CONFIG_DEVFS_FS

       devfs_myDriver_dir = devfs_mk_dir(NULL, "myDriver", NULL);

       devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myDriver_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myDriver_fops, NULL);

       PRINTK("add dev file to devfs OK!/n");

#endif

       return 0;

}

其中，关键函数

module_init()

向内核声明当前模块的初始化函数

 

驱动程序退出函数

Linux在卸载内核模块时会调用退出函数释放驱动程序使用的资源，使用unregister_chrdev从内核中卸载驱动程序。将驱动程序模块注册到内核，内核需要知道模块的初始化函数和退出函数，才能将模块放入自己的管理队列中。

例：

static void __exit myModule_exit(void)

{

       /* Module exit code */

       PRINTK("myModule_exit/n");

       /* Driver unregister */

       if(myDriver_Major > 0)

       {

#ifdef CONFIG_DEVFS_FS

              devfs_unregister(devfs_myDriver_raw);

              devfs_unregister(devfs_myDriver_dir);

#endif

              unregister_chrdev(myDriver_Major, DRIVER_NAME);

       }

       return;

}

              其中，关键函数

module_exit()

向内核声明当前模块的退出函数。

关于devfs的操作

在devfs中建立一个目录（/dev下）

                     devfs_handle_t devfs_mk_dir (devfs_handle_t dir, const char *name, void *info);

在devfs中注册一个设备文件节点

                     devfs_handle_t devfs_register(devfs_handle_t dir, const char *name,

unsigned int flags,

unsigned int major, unsigned int minor,

umode_t mode, void *ops, void *info);

在devfs中删除一个设备文件节点

         void devfs_unregister(devfs_handle_t de);

 

 

加载驱动程序

在终端下，输入以下命令可以对模块进行相关的操作。

insmod 内核模块文件名

rmmod 内核模块文件名

lsmod  列举出当前全部的加载模块文件名

建立设备文件

mknod 文件路径 c [主设备号] [从设备号]

应用程序接口函数

可以使用标准C的文件操作函数来完成。

 

应用程序接口函数：

int open(const char *path, int oflag,…);

打开名为path的文件或设备

成功打开后返回文件句柄

常用oflag：O_RDONLY, O_WRONLY, O_RDWR

int close(int fd);

关闭之前被打开的文件或设备

成功关闭返回0，否则返回错误代号

ssize_t read(int fd, void *buffer, size_t count);

从已经打开的文件或设备中读取数据

buffer表示应用程序缓冲区

count表示应用程序希望读取的数据长度

成功读取后返回读取的字节数，否则返回-1

ssize_t write(int fd, void *buffer, size_t count);

向已经打开的文件或设备中写入数据

buffer表示应用程序缓冲区

count表示应用程序希望写入的数据长度

成功写入后返回写入的字节数，否则返回-1

int ioctl(int fd, unsigned long int cmd,…);

向驱动程序发送控制命令

cmd需是唯一值

type：又称幻数，8bit，一般表示cmd所属模块

number：cmd序号，8bit，一般表示实际的命令

direction：数据传输方向，2bit

size：数据大小，位数与体系结构有关（ARM:12bit）

sizeof(int)-(sizeof(type)+sizeof(number)+sizeof(direction))

使用_IO宏可快速合成cmd：_IO(MAGIC, num)

 

       附：完整的示例驱动程序

              // tst-driver.h

              #ifndef __TST_DRIVER_H__

#define __TST_DRIVER_H__

 

#define TSTDRV_MAGIC                          0xd0

 

#define MYDRV_IOCTL0                          _IO(TSTDRV_MAGIC, 0)

#define MYDRV_IOCTL1                          _IO(TSTDRV_MAGIC, 1)

#define MYDRV_IOCTL2                          _IO(TSTDRV_MAGIC, 2)

#define MYDRV_IOCTL3                          _IO(TSTDRV_MAGIC, 3)

 

#define TSTDRV_MAXNR                        4

 

#endif     //#ifndef __TST_DRIVER_H__

 

// tst-driver.c

       #ifndef __KERNEL__

       #define __KERNEL__

#endif

#ifndef MODULE

       #define MODULE

#endif

 

#include <linux/config.h>

#include <linux/module.h>

#include <linux/kernel.h>      /* printk() */

#include <linux/init.h>    /* __init __exit */

 

#include <linux/types.h>       /* size_t */

#include <linux/fs.h>     /* file_operation */

//#include <linux/errno.h>     /* Error number */

//#include <linux/delay.h>      /* udelay */

#include <asm/uaccess.h>     /* copy_to_user, copy_from_user */

#include <asm/hardware.h>

 

#include "tst-driver.h"

 

#define DRIVER_NAME       "myDriver"

//#undef CONFIG_DEVFS_FS

#ifdef DEBUG

#define PRINTK(fmt, arg...)        printk(KERN_NOTICE fmt, ##arg)

#else

#define PRINTK(fmt, arg...)

#endif

/*

       KERN_EMERG             用于紧急事件,一般是系统崩溃前的提示信息

       KERN_ALERT              用于需要立即采取动作的场合

       KERN_CRIT         临界状态,通常设计验证的硬件或软件操作失败

       KERN_ERR    用于报告错误状态.设备驱动程序通常会用它报告来自硬件的问题

       KERN_WARNING 就可能出现的问题提出警告.这些问题通常不会对系统造成严重破坏

       KERN_NOTICE     有必要提示的正常情况.许多安全相关的情况用这个级别汇报

       KERN_INFO         提示性信息.有很多驱动程序在启动时用这个级别打印相关信息

       KERN_DEBUG             用于调试的信息

*/

 

static int myDriver_Major = 0;             /* Driver Major Number */

 

/* Vitual Driver Buffer */

static unsigned char myDriver_Buffer[1024*1024];

 

/* Driver Operation Functions */

static int myDriver_open(struct inode *inode, struct file *filp)

{

//     int Minor = MINOR(inode->i_rdev);

//     filp->private_data = 0;

       MOD_INC_USE_COUNT;

       PRINTK("myDriver open called!/n");

       return 0;

}

 

static int myDriver_release(struct inode *inode, struct file *filp)

{

//     int Minor = MINOR(inode->i_rdev);

       MOD_DEC_USE_COUNT;

       PRINTK("myDriver release called!/n");

       return 0;

}

 

static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)

{

       size_t read_size = count;

       PRINTK("myDriver read called!/n");

       PRINTK("/tcount=%d, pos=%d/n", count, (int)*f_pos);

       if(*f_pos >= sizeof(myDriver_Buffer))

       {

              PRINTK("[myDriver read]Buffer Overlap/n");

              *f_pos = sizeof(myDriver_Buffer);

              return 0;

       }

       if((count + *f_pos) > sizeof(myDriver_Buffer))

       {

              PRINTK("count + f_pos > sizeof buffer/n");

              read_size = sizeof(myDriver_Buffer) - *f_pos;

       }

       copy_to_user(buf, &myDriver_Buffer[*f_pos], read_size);

       *f_pos += read_size;

       return read_size;

}

 

static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)

{

       size_t fill_size = count;

       PRINTK("myDriver write called!/n");

       PRINTK("/tcount=%d, pos=%d/n", count, (int)*f_pos);

       if(*f_pos >= sizeof(myDriver_Buffer))

       {

              PRINTK("[myDriver write]Buffer Overlap/n");

              *f_pos = sizeof(myDriver_Buffer);

              return 0;

       }

       if((count + *f_pos) > sizeof(myDriver_Buffer))

       {

              PRINTK("count + f_pos > sizeof buffer/n");

              fill_size = sizeof(myDriver_Buffer) - *f_pos;

       }

       copy_from_user(&myDriver_Buffer[*f_pos], buf, fill_size);

       *f_pos += fill_size;

       return fill_size;

}

 

static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)

{

       PRINTK("myDriver ioctl called(%d)!/n", cmd);

    if(_IOC_TYPE(cmd) != TSTDRV_MAGIC)

    {

        return -ENOTTY;

    }

 

    if(_IOC_NR(cmd) >= TSTDRV_MAXNR)

    {

        return -ENOTTY;

    }

       switch(cmd)

       {

              case MYDRV_IOCTL0:

                     PRINTK("IOCTRL 0 called(0x%lx)!/n", arg);

                     break;

              case MYDRV_IOCTL1:

                     PRINTK("IOCTRL 1 called(0x%lx)!/n", arg);

                     break;

              case MYDRV_IOCTL2:

                     PRINTK("IOCTRL 2 called(0x%lx)!/n", arg);

                     break;

              case MYDRV_IOCTL3:

                     PRINTK("IOCTRL 3 called(0x%lx)!/n", arg);

                     break;

       }

       return 0;

}

 

/* Driver Operation structure */

static struct file_operations myDriver_fops = {

       owner:           THIS_MODULE,

       write:             myDriver_write,

       read:              myDriver_read,

       ioctl:              myDriver_ioctl,

       open:              myDriver_open,

       release:    myDriver_release,

};

 

/* Module Init & Exit function */

#ifdef CONFIG_DEVFS_FS

devfs_handle_t devfs_myDriver_dir;

devfs_handle_t devfs_myDriver_raw;

#endif

static int __init myModule_init(void)

{

       /* Module init code */

       PRINTK("myModule_init/n");

       /* Driver register */

       myDriver_Major = register_chrdev(0, DRIVER_NAME, &myDriver_fops);

       if(myDriver_Major < 0)

       {

              PRINTK("register char device fail!/n");

              return myDriver_Major;

       }

       PRINTK("register myDriver OK! Major = %d/n", myDriver_Major);

#ifdef CONFIG_DEVFS_FS

       devfs_myDriver_dir = devfs_mk_dir(NULL, "myDriver", NULL);

       devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myDriver_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myDriver_fops, NULL);

       PRINTK("add dev file to devfs OK!/n");

#endif

       return 0;

}

 

static void __exit myModule_exit(void)

{

       /* Module exit code */

       PRINTK("myModule_exit/n");

       /* Driver unregister */

       if(myDriver_Major > 0)

       {

#ifdef CONFIG_DEVFS_FS

              devfs_unregister(devfs_myDriver_raw);

              devfs_unregister(devfs_myDriver_dir);

#endif

              unregister_chrdev(myDriver_Major, DRIVER_NAME);

       }

       return;

}

 

MODULE_AUTHOR("SXZ");

MODULE_LICENSE("Dual BSD/GPL");

module_init(myModule_init);

module_exit(myModule_exit);

xiaozhi_su
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
字符设备驱动程序的设计
LDan508的博客
01-22 1457
【字符设备驱动程序的组成】      字符设备驱动程序包含5个部分：头文件、file_operation结构体变量、接口函数、加载函数以及卸载函数。  头文件的部分包含进数据结构以及内核函数要用到的头文件。file_operation结构体变量部分定义file_operation结构体的变量，该结构体声明了驱动程序所有的接口函数。接口函数部分包含字符驱动设备驱动程序与内核应用程序交互
Linux字符设备驱动程序
07-17
Linux字符设备驱动程序是操作系统与硬件之间的重要接口，它允许操作系统和应用程序访问并控制硬件设备，如串口、键盘、鼠标等。在Linux系统中，设备驱动分为字符设备驱动和块设备驱动，前者主要处理单个数据的传输，...
嵌入式安防监控项目——实现真实数据的上传
qq_52479948的博客
03-16 2518
嵌入式安防监控项目——实现真实数据的上传
linux模块驱动模板,linux字符驱动模板
weixin_29235923的博客
05-13 68
#include #define MAJOR_NUM 125#define DEVICE_NAME "emptychr"static ssize_t test_read(struct file *file,char *buf,size_t count,loff_t *f_pos){return count;}static ssize_t test_write(struct file *file, ...
linux下ad键盘驱动,led、键盘、ADC驱动程序
weixin_30158793的博客
05-15 379
LED，键盘，AD驱动程序开发一：硬件平台及系统平台CPU: S3C2410ASDRAM: 64MFLASH: K9F1208(64MB)NET: CS8900友善之臂2410，优龙2410.参考原理图,编写相应的程序.原理是一样的.只要改下GPIO端口及相应的地址就可以了.后面涉及到的程序是针对优龙2410版子的程序.二：使用的内核版本：LINUX2.6.24交叉编译工具版本：arm-linux...
Linux驱动学习：Linux文件系统与设备文件
最新发布
GS8FG的博客
10-05 251
作用一直，都是用于分割命令的，第一个命令是指：匹配。后面的序列，并删除；第二个命令是指：匹配。文件描述了Linux设备号的分配情况。udev的轻量级版本：mdev；：查看系统中包含的设备文件。：获知系统中注册的设备。netlink套接字。android中的是。
linux驱动 不创建dev,linux内核驱动知识三，自动创建设备文件devfs与udev
weixin_27427619的博客
05-16 263
Linux2.4内核中devfs创建设备目录：devfs_handle_t devfs_mk_dir(devfs_handle_tdir, const char *name, void info);创建设备文件：devfs_handle_tdevfs_register(devfs_handle_t dir, const char * name.unsigned int flags, unsigne...
基于Linux字符设备驱动程序的设计与实现.pdf
09-06
【Linux字符设备驱动程序概述】 Linux字符设备驱动程序是操作系统内核与硬件设备之间的桥梁，它的主要任务是处理用户空间应用程序对硬件设备的访问请求，将这些请求转换为硬件能够理解的操作指令。在Linux系统中，...
Linux增加字符设备驱动实验
05-11
字符设备驱动程序处理来自用户空间的应用程序对特定设备的I/O请求，并通过内核接口与硬件进行通信。本实验旨在帮助你理解如何为Linux添加一个新的字符设备驱动，以实现简单的"Hello World"输出。以下是关于这个实验...
Linux设备驱动程序
04-21
《Linux设备驱动程序》是关于Linux操作系统下设备驱动程序开发的重要参考书籍，尤其适用于嵌入式ARM平台的开发者。在Linux系统中，设备驱动程序是操作系统与硬件设备之间的桥梁，它使得操作系统能够控制和管理硬件...
虚拟字符设备驱动程序在Linux的实现
04-09
在 Linux 系统中, 设备驱动程序隐藏了设备的细节, 用户程序可以方便地操作设备,但随着硬件产品不断更新, 需要不断编写新的驱动程序以支持硬件, 通过虚拟字符设备驱动程序的编写,来说明 Linux 系统中字符设备驱动程序的工作 原理。首先介绍了 Linux 系统中设备驱动程序的基本结构, 以及字符设备驱动程序应提供的入口点, 最后用进程虚拟字符设 备,编写了相应的驱动程序, 实现进程间的信息读写。
简单linux字符设备驱动程序与编程小技巧
02-16
简单linux字符设备驱动程序与编程小技巧 代码分析请看http://blog.csdn.net/jiebaoabcabc/article/details/19242621 http://blog.csdn.net/jiebaoabcabc/article/details/19283859
devfs
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
05-16 180
devfs（设备文件系统）是由Linux 2.4内核引入的，引入时被许多工程师给予了高度评价，它的出现使得设备驱动程序能自主地管理自己的设备文件。，使用的register_chrdev（）和unregister_chrdev（）在Linux 2.6以后的内核中仍被采用。是被普遍采用并值得大力推荐的好方法。代码清单5.5给出了一个使用devfs的范例。驱动程序应调用下面这些函数来进行设备文件的创建和撤销工作。在Linux 2.4的设备驱动编程中，分别在。代码中第7行和第23行分别用于。
字符设备驱动概述
YellowMax
03-04 831
linux字符设备驱动的开发概述
linux不自动创建sda1,linux内核驱动知识三，自动创建设备文件devfs与udev
weixin_32219363的博客
05-11 157
Linux2.4内核中devfs创建设备目录：devfs_handle_t devfs_mk_dir(devfs_handle_tdir, const char *name, void info);创建设备文件：devfs_handle_tdevfs_register(devfs_handle_t dir, const char * name.unsigned int flags, unsigne...
Linux·设备文件devfs
m0_64560763的博客
08-31 528
设备文件devfs
linux驱动编写（虚拟字符设备编写）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
01-24 2万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】    昨天我们说了一些简单模块编写方法，但是终归没有涉及到设备的编写内容，今天我们就可以了解一下相关方面的内容，并且用一个实例来说明在linux上面设备是如何编写的。虽然我不是专门做linux驱动的，却也经常收到一些朋友们的来信。在信件中，很多做驱动的朋友对自己的工作不是很满意，认为自己的工作
字符设备驱动透彻分析（一）
张飞online博客
06-07 3295
 前言：    首先要说的是对于linux这样优秀的操作系统，我们在分析的时候一定是站在全局去对对待，而非一开始就去扣那些毛细血管的东西。我看到诸多博客对linux下的字符设备驱动进行这样那样的描述，但是大多居于形式，告诉你这样或者那样操作。1.首先我们要谈的是linux下的贯穿始终的一句话“一切皆文件”，很多时候当你想不通的时候，想下这句话也许就豁然开朗，当然linux下的字符设备驱动也是以文件...
linux驱动被哪些进程使用,Linux驱动程序开发的经验总结
weixin_30514003的博客
04-29 715
在尝试编写一些驱动模块时，其中就是遇到一些编译错误之类的，一种错误有很多种原因，总结下我遇到的一些问题，供你们参考：1.编写一个内核程序spinlock.c：#include #include #include #include #include MODULE_LICENSE(“GPL”);#define MAJOR_NUM 224static ssize_t simplespin_read(st...
"Linux字符设备驱动程序概述及开发步骤
1.1.2 Linux 驱动程序的分类 Linux 驱动程序通常可以分为字符设备驱动程序、块设备驱动程序和网络设备驱动程序。字符设备驱动程序是对设备...因此，深入学习和掌握Linux字符设备驱动程序的开发是非常有意义而且值得的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值