platform设备驱动实验

最新推荐文章于 2024-06-11 23:48:55 发布
最新推荐文章于 2024-06-11 23:48:55 发布
阅读量614 收藏 20
点赞数 5
分类专栏： 嵌入式 文章标签： linux 运维 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzipeng/article/details/137658473
版权

platform驱动由来

是驱动的分隔，也就是将主机驱动和设备驱动分隔开来，比如 I2C 、 SPI 等等都会采
用驱动分隔的方式来简化驱动的开发。
当我们向系统注册一个驱动的时候，总线就会在右侧的设备中查找，看看有没有与之匹配
的设备，如果有的话就将两者联系起来。同样的，当向系统中注册一个设备的时候，总线就会
在左侧的驱动中查找看有没有与之匹配的设备，有的话也联系起来。 Linux 内核中大量的驱动
程序都采用总线、驱动和设备模式。

platform 平台驱动模型简介

platform 总线

Linux 系统内核使用 bus_type 结构体表示总线，此结构体定义在文件 include/linux/device.h ，
bus_type 结构体内容如下： 
 struct bus_type {
    const char *name; /* 总线名字 */
    const char *dev_name; 
    struct device *dev_root;
    struct device_attribute *dev_attrs;
    const struct attribute_group **bus_groups; /* 总线属性 */
    const struct attribute_group **dev_groups; /* 设备属性 */
    const struct attribute_group **drv_groups; /* 驱动属性 */

    int (*match)(struct device *dev, struct device_driver *drv);
    int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
    int (*probe)(struct device *dev);
    int (*remove)(struct device *dev);
    void (*shutdown)(struct device *dev);

    int (*online)(struct device *dev);
    int (*offline)(struct device *dev);
    int (*suspend)(struct device *dev, pm_message_t state);
    int (*resume)(struct device *dev);
    const struct dev_pm_ops *pm;
    const struct iommu_ops *iommu_ops;
    struct subsys_private *p;
    struct lock_class_key lock_key;
};
platform 总线是 bus_type 的一个具体实例，定义在文件 drivers/base/platform.c ， platform 总
线定义如下： 
struct bus_type platform_bus_type = {
    .name = "platform",
    .dev_groups = platform_dev_groups,
    .match = platform_match,
    .uevent = platform_uevent,
    .pm = &platform_dev_pm_ops,
};
platform_bus_type 就是 platform 平台总线，其中 platform_match 就是匹配函数。Linux下驱动和设备匹配是靠 latform_match 函数，其定义在文件 drivers/base/platform.c 中。

platform 驱动

platform_driver 结构体表示 platform 驱动，此结构体定义在文件
include/linux/platform_device.h 中，内容如下： 
struct platform_driver {
    int (*probe)(struct platform_device *);
    int (*remove)(struct platform_device *);
    void (*shutdown)(struct platform_device *);
    int (*suspend)(struct platform_device *, pm_message_t state);
    int (*resume)(struct platform_device *);
    struct device_driver driver;
    const struct platform_device_id *id_table;
    bool prevent_deferred_probe;
};
当驱动与设备匹配成功以后 probe 函数就会执行，非常重要的函数。
。。。

platform 设备与驱动程序编写

platform 设备文件leddevice.c 

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/fcntl.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

/* 
* 寄存器地址定义
*/
#define CCM_CCGR1_BASE (0X020C406C) 
#define SW_MUX_GPIO1_IO03_BASE (0X020E0068)
#define SW_PAD_GPIO1_IO03_BASE (0X020E02F4)
#define GPIO1_DR_BASE (0X0209C000)
#define GPIO1_GDIR_BASE (0X0209C004)
#define REGISTER_LENGTH 4

/* @description : 释放 flatform 设备模块的时候此函数会执行
* @param - dev : 要释放的设备
* @return : 无
*/
static void led_release(struct device *dev)
{
    printk("led device released!\r\n");
}

/* 
* 设备资源信息，也就是 LED0 所使用的所有寄存器
*/
static struct resource led_resources[] = {
    [0] = {
            .start = CCM_CCGR1_BASE,
            .end = (CCM_CCGR1_BASE + REGISTER_LENGTH - 1),
            .flags = IORESOURCE_MEM,
        }, 
    [1] = {
            .start = SW_MUX_GPIO1_IO03_BASE,
            .end = (SW_MUX_GPIO1_IO03_BASE + REGISTER_LENGTH - 1),
            .flags = IORESOURCE_MEM,
        },
    [2] = {
            .start = SW_PAD_GPIO1_IO03_BASE,
            .end = (SW_PAD_GPIO1_IO03_BASE + REGISTER_LENGTH - 1),
            .flags = IORESOURCE_MEM,
          },
    [3] = {
            .start = GPIO1_DR_BASE,
            .end = (GPIO1_DR_BASE + REGISTER_LENGTH - 1),
            .flags = IORESOURCE_MEM,
          },
    [4] = {
            .start = GPIO1_GDIR_BASE,
            .end = (GPIO1_GDIR_BASE + REGISTER_LENGTH - 1),
            .flags = IORESOURCE_MEM,
        },
    };


/*
* platform 设备结构体
*/
static struct platform_device leddevice = {
    .name = "imx6ul-led",
    .id = -1,
    .dev = {
            .release = &led_release,
        },
    .num_resources = ARRAY_SIZE(led_resources),
    .resource = led_resources,
};

/*
* @description : 设备模块加载
* @param : 无
* @return : 无
*/
static int __init leddevice_init(void)
{
    return platform_device_register(&leddevice);
}
/*
* @description : 设备模块注销
* @param : 无
* @return : 无
*/
static void __exit leddevice_exit(void)
{
    platform_device_unregister(&leddevice);
}

module_init(leddevice_init);
module_exit(leddevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zipeng");

platform 驱动文件leddriver.c 

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/fcntl.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define LEDDEV_CNT 1 /* 设备号长度 */
#define LEDDEV_NAME "platled" /* 设备名字 */
#define LEDOFF 0
#define LEDON 1

/* 寄存器名 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

/* leddev 设备结构体 */
struct leddev_dev{
    dev_t devid; /* 设备号 */
    struct cdev cdev; /* cdev */
    struct class *class; /* 类 */
    struct device *device; /* 设备 */
    int major; /* 主设备号 */ 
};

struct leddev_dev leddev; /* led 设备 */
 
/*
* @description : LED 打开/关闭
* @param - sta : LEDON(0) 打开 LED，LEDOFF(1) 关闭 LED
* @return : 无
*/
void led0_switch(u8 sta)
{
    u32 val = 0;
    if(sta == LEDON){
        val = readl(GPIO1_DR);
        val &= ~(1 << 3); 
        writel(val, GPIO1_DR);
    }
    else if(sta == LEDOFF){
        val = readl(GPIO1_DR);
        val|= (1 << 3);
        writel(val, GPIO1_DR);
    } 
}

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param - filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int led_open(struct inode *inode, struct file *filp)
{
filp->private_data = &leddev; /* 设置私有数据 */
return 0;
}

/*
* @description : 向设备写数据
* @param – filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t led_write(struct file *filp, const char __user *buf,
size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;
    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        return -EFAULT;
    }

    ledstat = databuf[0]; /* 获取状态值 */
    if(ledstat == LEDON) {
        led0_switch(LEDON); /* 打开 LED 灯 */
    }else if(ledstat == LEDOFF) {
        led0_switch(LEDOFF); /* 关闭 LED 灯 */
    }
    return 0;
}

/* 设备操作函数 */
static struct file_operations led_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .write = led_write,
};

/*
* @description : flatform 驱动的 probe 函数，当驱动与设备
* 匹配以后此函数就会执行
* @param - dev : platform 设备
* @return : 0，成功;其他负值,失败
*/
static int led_probe(struct platform_device *dev)
{ 
    int i = 0;
    int ressize[5];
    u32 val = 0;
    struct resource *ledsource[5];

    printk("led driver and device has matched!\r\n");
    /* 1、获取资源 */
    for (i = 0; i < 5; i++) {
        ledsource[i] = platform_get_resource(dev, IORESOURCE_MEM, i);
        if (!ledsource[i]) {
            dev_err(&dev->dev, "No MEM resource for always on\n");
            return -ENXIO;
        }
        ressize[i] = resource_size(ledsource[i]); 
    } 

    /* 2、初始化 LED */
    /* 寄存器地址映射 */
    IMX6U_CCM_CCGR1 = ioremap(ledsource[0]->start, ressize[0]);
    SW_MUX_GPIO1_IO03 = ioremap(ledsource[1]->start, ressize[1]);
    SW_PAD_GPIO1_IO03 = ioremap(ledsource[2]->start, ressize[2]);
    GPIO1_DR = ioremap(ledsource[3]->start, ressize[3]);
    GPIO1_GDIR = ioremap(ledsource[4]->start, ressize[4]);

    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26); /* 清除以前的设置 */
    val |= (3 << 26); /* 设置新值 */
    writel(val, IMX6U_CCM_CCGR1);

    /* 设置 GPIO1_IO03 复用功能，将其复用为 GPIO1_IO03 */
    writel(5, SW_MUX_GPIO1_IO03);
    writel(0x10B0, SW_PAD_GPIO1_IO03);

    /* 设置 GPIO1_IO03 为输出功能 */
    val = readl(GPIO1_GDIR);
    val &= ~(1 << 3); /* 清除以前的设置 */
    val |= (1 << 3); /* 设置为输出 */
    writel(val, GPIO1_GDIR);

    /* 默认关闭 LED1 */
    val = readl(GPIO1_DR);
    val |= (1 << 3) ; 
    writel(val, GPIO1_DR);

    /* 注册字符设备驱动 */
    /*1、创建设备号 */
    if (leddev.major) { /* 定义了设备号 */
        leddev.devid = MKDEV(leddev.major, 0);
        register_chrdev_region(leddev.devid, LEDDEV_CNT,
        LEDDEV_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT,LEDDEV_NAME);
        leddev.major = MAJOR(leddev.devid);
    }

    /* 2、初始化 cdev */
    leddev.cdev.owner = THIS_MODULE;
    cdev_init(&leddev.cdev, &led_fops);

    /* 3、添加一个 cdev */
    cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);

    /* 4、创建类 */
    leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
    if (IS_ERR(leddev.class)) {
        return PTR_ERR(leddev.class);
    }

    /* 5、创建设备 */
    leddev.device = device_create(leddev.class, NULL, leddev.devid,NULL, LEDDEV_NAME);
    if (IS_ERR(leddev.device)) {
        return PTR_ERR(leddev.device);
    }

    return 0;
}

/*
* @description :移除 platform 驱动的时候此函数会执行
* @param - dev : platform 设备
* @return : 0，成功;其他负值,失败
*/
static int led_remove(struct platform_device *dev)
{
    iounmap(IMX6U_CCM_CCGR1);
    iounmap(SW_MUX_GPIO1_IO03);
    iounmap(SW_PAD_GPIO1_IO03);
    iounmap(GPIO1_DR);
    iounmap(GPIO1_GDIR);

    cdev_del(&leddev.cdev); /* 删除 cdev */
    unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
    device_destroy(leddev.class, leddev.devid);
    class_destroy(leddev.class);
    return 0;
}

/* platform 驱动结构体 */
static struct platform_driver led_driver = {
    .driver = {
        .name = "imx6ul-led", /* 驱动名字，用于和设备匹配 */
    },
    .probe = led_probe,
    .remove = led_remove,
};

/*
* @description : 驱动模块加载函数
* @param : 无
* @return : 无
*/
static int __init leddriver_init(void)
{
    return platform_driver_register(&led_driver);
}

/*
* @description : 驱动模块卸载函数
* @param : 无
* @return : 无
*/
static void __exit leddriver_exit(void)
{
    platform_driver_unregister(&led_driver);
}

module_init(leddriver_init);
module_exit(leddriver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zipeng");

测试 APP 编写ledApp.c

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#define LEDOFF 0
#define LEDON 1

/*
* @description : main 主程序
* @param - argc : argv 数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
    int fd, retvalue;
    char *filename;
    unsigned char databuf[2];

    if(argc != 3){
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];
    /* 打开 led 驱动 */
    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("file %s open failed!\r\n", argv[1]);
        return -1;
    }

    databuf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */
    retvalue = write(fd, databuf, sizeof(databuf));
    if(retvalue < 0){
        printf("LED Control Failed!\r\n");
        close(fd);
        return -1;
    }

    retvalue = close(fd); /* 关闭文件 */
    if(retvalue < 0){
        printf("file %s close failed!\r\n", argv[1]);
        return -1;
    }
    return 0;
}

运行测试

编译驱动程序

KERNELDIR := /home/zipeng/linux/myKernel/linux-imx
rel_imx_4.1.15_2.1.0_ga_alientek
......
obj-m := leddevice.o leddriver.o   #设备文件和驱动文件
......
clean :
  $(MAKE) -C $(KERNELDIR) M = $(CURRENT_PATH) clean
编译命令：make -j32
编译成功以后就会生成一个名为“ leddevice.ko leddriver.ko ”的驱动模块文件。

编译测试 APP

arm-linux-gnueabihf-gcc ledApp.c -o ledApp

运行测试

depmod   //第一次加载驱动的时候需要运行此命令
modprobe leddevice.ko // 加载设备模块
modprobe leddriver.ko // 加载驱动模块
根文件系统中 /sys/bus/platform/ 目录下保存着当前板子 platform 总线下的设备和驱动，其中
devices 子目录为 platform 设备， drivers 子目录为 plartofm 驱动。查看 /sys/bus/platform/devices/
目录，看看我们的设备是否存在，我们在 leddevice.c 中设置 leddevice(platform_device 类型 ) 的
name 字段为“ imx6ul-led ”，也就是设备名字为 imx6ul-led.
查看 /sys/bus/platform/drivers/ 目录，看一下驱动是否存在，我们在 leddriver.c 中设置
led_driver (platform_driver 类型 ) 的 name 字段为“ imx6ul-led ”，因此会在 /sys/bus/platform/drivers/
目录下存在名为“ imx6ul-led ”这个文件.
./ledApp /dev/platled 1 // 打开 LED 灯
./ledApp /dev/platled 0 // 关闭 LED 灯
rmmod leddevice.ko  //卸载设备
rmmod leddriver.ko  //卸载驱动
zzipeng
关注
  • 5
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
plat_device.rar_platform 驱动_platform设备
09-14
platform平台设备驱动,里面包含应用程序，驱动和Makefile
linux Platform设备驱动.docx
11-08
linux Platform设备驱动.docx
Linux 设备驱动之platform子系统
12-27
本文档主要讲解了platform总线的原理及总线设备的注册跟驱动的编写
Linux设备模型及Platform驱动
08-03
课程内容 Linux设备模型及Platform驱动 目标 理解Linux设备模型的内容和意义 掌握符合设备模型的驱动编写方法 掌握Platform设备驱动编写方法 第一章：Linux设备模型 ...第三章：Platform设备驱动
platform设备驱动全透析
04-26
platform设备驱动全透析 linux设备驱动全透析
linux 系统被异地登录，cpu占用拉满100%
BiuBiu_Ka
06-04 435
命令，查看占用最高的是否kswapd0。记下该进程ID 5081。执行查找命令 find / -name kswapd0。再按":“后，出现提示符”:" ,输入wq 然后回车保存。这些都和病毒相关，按 任意字母键，进入编辑模式，全部清空。将结果中的每个地址都删除掉 示例如下。最后修改服务器密码，并重启。
linux 系统监控脚本
wyx的博客
06-05 386
3.对磁盘IO的监控函数。4.对线程状态的监控函数。5.对网卡流量的监控函数。1.对CPU的监控函数。2.对内存的监控函数。
Linux 内存屏障简介
JiMoKuangXiangQu的专栏
06-04 721
Linux，内存屏障
Linux基础命令
威桑的博客
06-11 624
常见基础Linux命令
【Linux】生产者消费者模型——阻塞队列BlockQueue
AAlykk的博客
06-11 455
Linux有两个重要的模型，一个是生产者消费者模型——阻塞队列BlockQueue，另一个则是生产者消费者模型——环形队列RingQueue。今天我们学习其中一个模型：【Linux】生产者消费者模型——阻塞队列BlockQueue。⭐主体生产者消费模型高效在哪里？高效体现在一个线程拿出来任务可能正在做计算，它在做计算的同时，其他线程可以继续从队列中拿，继续做运算，高效并不是体现在从队列中拿数据高效！而是我们可以让一个、多个线程并发的同时计算多个任务！
玄机靶场 第一章 应急响应- Linux入侵排查
qq_46343633的博客
06-04 546
1.web目录存在木马，请找到木马的密码提交2.服务器疑似存在不死马，请找到不死马的密码提交3.不死马是通过哪个文件生成的，请提交文件名4.黑客留下了木马文件，请找出黑客的服务器ip提交5.黑客留下了木马文件，请找出黑客服务器开启的监端口提交。
在linux和windows平台启动子进程差异及终止子进程差异
liweiweili126的博客
06-07 318
因此，在 Windows 中，子进程的全局变量与父进程的全局变量是完全独立的。在linux操作系统下，执行process.terminate()会传递终止信号给到子进程，但是不会终止子进程，在windows系统下直接终止子进程，子进程中注册的signal.signal(signal.SIGTERM, handle_signal)handle_signal都来不及执行。因此，子进程会拥有与父进程相同的全局变量副本。综上所述，在 Windows 中，父进程对全局变量的修改不会直接影响到子进程中的全局变量。
NVIDIA Jetson Linux 35.3.1-开发指南-Accelerated GStreamer
FREEDOM_X的专栏
06-07 557
原文：Accelerated GStreamer — Jetson Linux Developer Guide documentation (nvidia.com) 加速GStreamer 本主题是NVIDIA®Jetson™Linux中包含的基于GStreamer 1.0和1.14版的加速解决方案指南。 注 对GStreamer 1.0版的引用也适用于GStreamer 1.16版。 GStreamer-1.0安装和设置 本节介绍如何安装和配置GStreamer。 安装GStre
【Linux取经路】网络套接字编程——初识篇
春人.的博客
06-06 1117
本篇文章介绍了套接字编程的基础，介绍了常用的套接字编程 API
Linux Mint 21.3简介
最新发布
地球空间
06-11 226
1. Cinnamon 6.0桌面环境：Linux Mint 21.3采用了最新的Cinnamon 6.0桌面环境，带来了新的功能和改进，例如支持Wayland会话（尽管仍处于实验性阶段）、改进的声音和电源小部件、对AVIF图像格式的新支持、屏幕缩放新手势、菜单详细信息选项、75%缩放以及窗口不透明度键绑定等。4. 应用程序更新：Linux Mint 21.3带来了应用程序的更新，包括Nemo文件管理器、Cinnamon桌面和小部件、扩展和主题等的改进。
Suse Linux ssh配置免密后仍需要输入密码
大好人ssr的博客
06-08 288
2.使用ssh-copy-id拷贝public key到目标机器(或者自身)找到并且注释#AuthenticationMethods password。Suse Linux已经配置了ssh免密，但无法ssh到目标服务器。1.使用ssh-keygen -t rsa生产key文件。重启服务 systemctl restart sshd。进入/etc/ssh/sshd_config。3.配置成功后ssh 目标时仍需要输入密码。对自身的ssh登陆也需要输入密码。系统–Suse 15 SP5。
【Linux】网络管理
2402_83162616的博客
06-03 634
1、查看网络管理程序的状态2、查看网络子管理程序的状态。
Linux CGroup资源限制（概念&限制进程CPU使用）
weixin_45565886的博客
06-04 1274
Linux CGroup资源限制（概念&限制进程CPU使用）
Linux Swap Cache
weixin_43230594的博客
06-08 280
Linux Swap Cache
platform设备驱动
07-27
平台设备驱动是一种用于操作系统和硬件设备之间进行通信的软件程序。它提供了操作系统访问硬件设备的接口，使操作系统能够控制和管理硬件设备的功能。 平台设备可以是各种类型的硬件，例如网络适配器、声卡、显卡、磁盘控制器等。平台设备驱动程序负责与硬件设备进行通信，并将硬件设备的功能映射到操作系统的抽象接口上，使操作系统能够通过统一的方式访问不同类型的硬件设备。 平台设备驱动通常由硬件设备的制造商开发，并提供给操作系统供其加载和使用。驱动程序通过操作系统的设备管理框架与操作系统进行交互，向操作系统提供硬件设备的功能和特性，并接收操作系统的指令来控制硬件设备的行为。 平台设备驱动的开发需要深入了解硬件设备的工作原理和规范，以及操作系统的设备管理框架和驱动开发接口。开发人员需要编写与硬件设备交互的代码，并实现与操作系统的通信和数据传输。同时，他们还需要进行测试和调试，确保驱动程序能够正确地与硬件设备进行通信并提供预期的功能。 总而言之，平台设备驱动是操作系统和硬件设备之间的桥梁，它使得操作系统能够有效地管理和控制硬件设备，并为应用程序提供访问硬件功能的接口。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值