Linux之分层分离思想

最新推荐文章于 2024-05-15 11:31:49 发布
最新推荐文章于 2024-05-15 11:31:49 发布
阅读量638 收藏 1
点赞数 1
分类专栏： Linux驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45775710/article/details/113739628
版权

目录

 

一、分层与分离

二、总线设备驱动模型

2.1 dev部分

2.2 drv部分

三、利用总线驱动模型点灯

3.1 device部分

3.2 driver部分

3.3 测试部分

3.4 改进代码

一、分层与分离

对于输入子系统分为上下两层，分离下层为两部分，input_handler部分和input_device部分，对于buttons.c硬件相关，evdev.c纯软件稳定，输入子系统参考：输入子系统分析与测试，input.c向上提供统一的接口,不管硬件怎么变化，只需要我们完善硬件相关的操作

 

二、总线设备驱动模型

是一种左右建立联系的机制，将驱动程序分为两部分，总线设备驱动模型分为三个概念：总线、设备和驱动，即Bus/Dev/Drv模型，是一种编程的机制，例如做一个led的驱动程序，在dev中提供好相关的资源，在drv中根据dev的资源来操作，而在内核中有很多的drv和dev，在include\linux\platform_device.h中，dev部分会注册一个platform_device(平台设备)，而drv会去注册一个platform_driver

struct platform_device {
	const char	*name;
	int		id;
	bool		id_auto;
	struct device	dev;
	u32		num_resources;
	struct resource	*resource;

	const struct platform_device_id	*id_entry;
	char *driver_override; /* Driver name to force a match */

	/* MFD cell pointer */
	struct mfd_cell *mfd_cell;

	/* arch specific additions */
	struct pdev_archdata	archdata;
};

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;
};

怎么去分辨哪个drv对应相应的dev，bus总线来管理，对于bus总线是一个虚拟、软件方面的概念，与硬件无关，以面向对象的思想，在drivers\base\platform.c中，根据bus中的match函数来匹配，其中"if (of_driver_match_device(dev, drv))"是根据设备树来匹配的，再到后面是根据drv部分的id_table与dev部分的name来匹配，若匹配不成功再尝试drv部分的name与dev部分的name是否相同，若相同则匹配成功

static int platform_match(struct device *dev, struct device_driver *drv)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct platform_driver *pdrv = to_platform_driver(drv);

	/* When driver_override is set, only bind to the matching driver */
	if (pdev->driver_override)
		return !strcmp(pdev->driver_override, drv->name);

	/* Attempt an OF style match first */
	if (of_driver_match_device(dev, drv))
		return 1;

	/* Then try ACPI style match */
	if (acpi_driver_match_device(dev, drv))
		return 1;

	/* Then try to match against the id table */
	if (pdrv->id_table)
		return platform_match_id(pdrv->id_table, pdev) != NULL;

	/* fall-back to driver name match */
	return (strcmp(pdev->name, drv->name) == 0);
}


struct bus_type platform_bus_type = {
	.name		= "platform",
	.dev_groups	= platform_dev_groups,
	.match		= platform_match,
	.uevent		= platform_uevent,
	.dma_configure	= platform_dma_configure,
	.pm		= &platform_dev_pm_ops,
};

 

2.1 dev部分

在device部分我们更加关注硬件相关的操作，主要的过程如下

把device放入bus的dev链表

从bus的drv链表取出每一个drv，用bus的match函数判断drv能否支持dev

若可以支持，调用drv的probe函数(核心)

2.2 drv部分

在driver部分我们更加关注软件相关，这部分的代码一般比较稳定，不需要做太大的变动，主要的过程如下

把driver放入bus的drv链表

从bus的dev链表取出每一个dev，用bus的match函数判断dev能否支持drv

若可以支持，调用drv的probe函数(核心)

 

三、利用总线驱动模型点灯

 

3.1 device部分

先分配/设置/注册一个platform_device，在platform_device结构体设置：resource资源(在其中加入led的寄存器和引脚)、name(建立连接时名字需要一致)、 release释放函数(remove需要) ，在应用程序若没有close设备文件，但是驱动程序中的release函数可能还会被调用， 是因为当应用程序退出后，linux系统会帮我们清除应用程序所打开的文件，调用文件对应的close函数

#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>



/* 分配/设置/注册一个platform_device */

static struct resource led_resource[] = {
    [0] = {
        .start = 0x56000050,             //资源有寄存器起始地址，换寄存器地址就改这里
        .end   = 0x56000050 + 8 - 1,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = 5,     //哪个引脚，换灯的时候改这里就可以
        .end   = 5,
        .flags = IORESOURCE_IRQ,
    }

};
	
static void led_release(struct device * dev)
{
}

static struct platform_device led_dev = {//定义了一个平台设备
    .name         = "myled",
    .id       = -1,
    .num_resources    = ARRAY_SIZE(led_resource),  //资源
    .resource     = led_resource,
    .dev = { 
    	.release = led_release, 
	},
};

static int led_dev_init(void)
{
	platform_device_register(&led_dev); //注册一个平台设备 最终调用到device_add，放到平台总线的设备链表中去
	return 0;
}

static void led_dev_exit(void)
{
	platform_device_unregister(&led_dev);
}

module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

 

3.2 driver部分

分配/设置/注册一个platform_driver，在platform_driver结构体设置：probe函数来配置led的资源，并注册字符设备驱动程序，在remove函数中卸载字符设备驱动程序  

#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>

/* 分配/设置/注册一个platform_driver */
static int major;


static struct class *led_class;
static volatile unsigned long *gpio_con;
static volatile unsigned long *gpio_dat;
static int pin;

static int led_open(struct inode *inode, struct file *file)
{
	printk("first_drv_open\n");
	/* 配置为输出 */
	*gpio_con &= ~(0x3<<(pin*2));
	*gpio_con |= (0x1<<(pin*2));
	
	return 0;
}

static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
	int val;
	copy_from_user(&val, buf, count); //	copy_to_user();

	if (val == 1)
	{
		// 点灯
		*gpio_dat &= ~(1<<pin);
	}
	else
	{
		// 灭灯
		*gpio_dat |= (1<<pin);
	}

	return 0;
}

static struct file_operations led_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   led_open,       
	.write	=	led_write,	
};

static int led_probe(struct platform_device *pdev)
{
	struct resource		*res;

	/* 根据platform_device的资源进行ioremap */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	gpio_con = ioremap(res->start, res->end - res->start + 1);
	gpio_dat = gpio_con + 1;

	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);//参数三代表资源中的第零个
	pin = res->start;


	/* 注册字符设备驱动程序 */

	printk("led_probe, found led\n");
	
	major = register_chrdev(0, "myled", & led_fops);

	led_class = class_create(THIS_MODULE, "myled");
	
	class_device_create(led_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */

	
	return 0;
}

static int led_remove(struct platform_device *pdev)
{
	/* 卸载字符设备驱动程序           */
	/* iounmap */
	printk("led_remove, remove led\n");
	class_device_destroy(led_class, MKDEV(major, 0)); 
	class_destroy(led_class);
	unregister_chrdev(major, "myled");
	iounmap(gpio_con);
	return 0;
}

struct platform_driver led_driver = {
	.probe		= led_probe,
	.remove		= led_remove,
	.driver		= {
		.name	= "myled",
	}
};


static int led_drv_init(void)
{
	platform_driver_register(&led_driver);
	return 0;
}

static void led_drv_exit(void)
{
	platform_driver_unregister(&led_driver);	
}

module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

 

  •  Makefile：编译程序
KERN_DIR = /work/system/linux-2.6.22.6

all:
	make -C $(KERN_DIR) M=`pwd` modules 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order

obj-m	+= led_drv.o
obj-m	+= led_dev.o

 

3.3 测试部分


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

/* led_test on 
 * led_test off
 */
int main(int argc, char **argv)
{
	int fd;
	int val = 1;
	fd = open("dev/led",O_RDWR);
	if(fd < 0)
		printf("cant't open!\n");
	if(argc != 2){
		printf("Usage:\n");
		printf("%s <on|off>\n", argv[0]);
	}
	if(strcmp(argv[1], "on") == 0){
		val = 1;
	}else{
		val = 0;
	}
	
	write(fd, &val, 4);
	return 0;
}

 

编译驱动程序和测试程序，加载驱动并执行测试程序

# insmod led_drv.ko
# insmod led_dev.ko
led_probe, found led
# ./led_test on
first_drv_open
# ./led_test off
first_drv_open
# rmmod led_dev
led_remove, remove led

总结

  • 先加载led_drv.ko，根据name在bus总线中找不到drv支持的dev，加载led_dev.ko后，建立了联系，调用drv的probe函数，在probe函数打印led_probe, found led，卸载dev驱动后会调用drv的remove函数，在remove函数中打印led_remove, remove led
  • 一个简单的字符驱动程序被拆分成两部分dev硬件相关部分和drv(稳定，不需要大改动)部分，这就是分离
  • 因此只需修改dev中的pin引脚就可以改变其他led的控制，不需要改动drv

 

3.4 改进代码

对于上述代码是用内核2.6的，现在用内核4.19

drv部分，跟dev提供的资源来操作相关的不同寄存器实现点灯

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>

#define S3C2440_GPA(n)  (0<<16 | n)
#define S3C2440_GPB(n)  (1<<16 | n)
#define S3C2440_GPC(n)  (2<<16 | n)
#define S3C2440_GPD(n)  (3<<16 | n)
#define S3C2440_GPE(n)  (4<<16 | n)
#define S3C2440_GPF(n)  (5<<16 | n)
#define S3C2440_GPG(n)  (6<<16 | n)
#define S3C2440_GPH(n)  (7<<16 | n)
#define S3C2440_GPI(n)  (8<<16 | n)
#define S3C2440_GPJ(n)  (9<<16 | n)

static int led_pin;
static volatile unsigned int *gpio_con;
static volatile unsigned int *gpio_dat;

/* 123. 分配/设置/注册file_operations 
 * 4. 入口
 * 5. 出口
 */

static int major;
static struct class *led_class;

static unsigned int gpio_base[] = {
	0x56000000, /* GPACON */
	0x56000010, /* GPBCON */
	0x56000020, /* GPCCON */
	0x56000030, /* GPDCON */
	0x56000040, /* GPECON */
	0x56000050, /* GPFCON */
	0x56000060, /* GPGCON */
	0x56000070, /* GPHCON */
	0,           /* GPICON */
	0x560000D0, /* GPJCON */
};

static int led_open (struct inode *node, struct file *filp)
{
	/* 把LED引脚配置为输出引脚 */
	/* GPF5 - 0x56000050 */
	int bank = led_pin >> 16;
	int base = gpio_base[bank];

	int pin = led_pin & 0xffff;
	gpio_con = ioremap(base, 8);
	if (gpio_con) {
		printk("ioremap(0x%x) = 0x%x\n", base, gpio_con);
	}
	else {
		return -EINVAL;
	}
	
	gpio_dat = gpio_con + 1;

	*gpio_con &= ~(3<<(pin * 2));
	*gpio_con |= (1<<(pin * 2));  

	return 0;
}

static ssize_t led_write (struct file *filp, const char __user *buf, size_t size, loff_t *off)
{
	/* 根据APP传入的值来设置LED引脚 */
	unsigned char val;
	int pin = led_pin & 0xffff;
	
	copy_from_user(&val, buf, 1);

	if (val)
	{
		/* 点灯 */
		*gpio_dat &= ~(1<<pin);
	}
	else
	{
		/* 灭灯 */
		*gpio_dat |= (1<<pin);
	}

	return 1; /* 已写入1个数据 */
}

static int led_release (struct inode *node, struct file *filp)
{
	printk("iounmap(0x%x)\n", gpio_con);
	iounmap(gpio_con);
	return 0;
}


static struct file_operations myled_oprs = {
	.owner = THIS_MODULE,
	.open  = led_open,
	.write = led_write,
	.release = led_release,
};


static int led_probe(struct platform_device *pdev)
{
	struct resource		*res;

	/* 根据platform_device的资源进行ioremap */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	led_pin = res->start;

	major = register_chrdev(0, "myled", &myled_oprs);

	led_class = class_create(THIS_MODULE, "myled");
	device_create(led_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */
	
	return 0;
}

static int led_remove(struct platform_device *pdev)
{
	unregister_chrdev(major, "myled");
	device_destroy(led_class,  MKDEV(major, 0));
	class_destroy(led_class);
	
	return 0;
}


struct platform_driver led_drv = {
	.probe		= led_probe,
	.remove		= led_remove,
	.driver		= {
		.name	= "myled",
	}
};


static int myled_init(void)
{
	platform_driver_register(&led_drv);
	return 0;
}

static void myled_exit(void)
{
	platform_driver_unregister(&led_drv);
}


module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");

dev部分，当我们想改变led的引脚时，更改led_resource资源就可以了

#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>

#define S3C2440_GPA(n)  (0<<16 | n)
#define S3C2440_GPB(n)  (1<<16 | n)
#define S3C2440_GPC(n)  (2<<16 | n)
#define S3C2440_GPD(n)  (3<<16 | n)
#define S3C2440_GPE(n)  (4<<16 | n)
#define S3C2440_GPF(n)  (5<<16 | n)
#define S3C2440_GPG(n)  (6<<16 | n)
#define S3C2440_GPH(n)  (7<<16 | n)
#define S3C2440_GPI(n)  (8<<16 | n)
#define S3C2440_GPJ(n)  (9<<16 | n)


/* 分配/设置/注册一个platform_device */

static struct resource led_resource[] = {
    [0] = {
        .start = S3C2440_GPF(5),
        .end   = S3C2440_GPF(5),
        .flags = IORESOURCE_MEM,
    },
};

static void led_release(struct device * dev)
{
}


static struct platform_device led_dev = {
    .name         = "myled",
    .id       = -1,
    .num_resources    = ARRAY_SIZE(led_resource),
    .resource     = led_resource,
    .dev = { 
    	.release = led_release, 
	},
};

static int led_dev_init(void)
{
	platform_device_register(&led_dev);
	return 0;
}

static void led_dev_exit(void)
{
	platform_device_unregister(&led_dev);
}

module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

 

小宝是狗子啊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
今天了解Linux体系结构
ylescxy的博客
10-30 914
让我们一起努力进步吧
驱动分离与分层思想与实现
qq_33471732的博客
03-08 344
驱动分离与分层 驱动的分层与分离思想是指将软件系统中的不同功能模块分层和分离，以实现更好的可维护性、可扩展性和可重用性。 在这种思想下，系统的不同功能模块被分为不同的层次，每个层次都有其特定的职责和功能，且层与层之间的接口是相互独立的。这种分层和分离的思想可以使得系统更容易维护和修改，也可以使得系统更容易扩展和重用。 具体怎么实施 驱动的分层与分离思想可以通过以下几个步骤来实施： 划分层次：根据驱动程序的功能和职责，将其划分为不同的层次。例如，可以将驱动程序分为硬件抽象层、设备驱动层和应用程序接口层等。
驱动设计思想（机制、策略、分离、分层）
weixin_42031299的博客
04-18 1422
1、机制和策略 (1)机制就是提供什么功能，策略就是怎么使用这些功能。在编写驱动时需要在编程时间和驱动的灵活性之间取一个可接受的折中，驱动提供机制，尽量不提供策略，策略让上层应用去做。 (2)机制和策略的分离使得驱动有更好的移植性。同一个硬件可能在不同的环境和不同功能的设备里使用，当机制和策略分离时，同一个硬件就只需要修改策略不需要修改机制。比如硬盘的驱动， 会将硬盘初始化并提供读写接口，但是谁有权访问、什么时候读写、每次读写多少数据都是上层去控制。这优点类似RISC架构，只提供基础操作，功能要上层开发人
Linux操作系统主要层次
最新发布
java_newstu的博客
05-15 317
驱动层通常位于内核层中，负责管理硬件设备。驱动程序是内核与硬件设备之间的接口，它们允许内核发送指令给硬件，以及接收来自硬件的状态信息和数据。应用层通过系统调用接口层与内核层交互，内核层中的驱动层再与硬件层进行交互。
Linux驱动编程（分层分离编程思想）
afddasfa的博客
05-05 1120
程序仍分为上下结构：上层 leddrv.c 向内核注册 file_operations 结构体；下层 chip_demo_gpio.c 提供 led_operations 结构体来操作硬件。下层的代码分为 2 个：chip_demo_gpio.c 实现通用的 GPIO 操作，board_A_led.c 指定使用哪个 GPIO，即“资源”。使用时，我们只需要在 board_A_led.c 中指定使用哪一个引脚即可。下层实现硬件相关的操作，比如 board_A.c 实现单板 A 的 LED 操作。
Linux驱动之platform设备驱动
Wang_XB_3434的博客
08-27 401
每日一个简单的驱动，日久方长，对Linux驱动就越来越熟悉，也越来容易学会写驱动程序。今日进行第四个简单的platform设备驱动。
【Linux学习笔记】platform 设备
第六个葫芦娃的博客
07-18 207
同系列笔记已放置链接在上面。
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
尽管这个驱动支持多个LED灯，但并没有体现Linux驱动的分层设计思想。分层设计通常意味着将驱动分解为更小、更独立的模块，如总线驱动、设备驱动、功能驱动等，以提高代码的可维护性和复用性。 LED字符设备驱动通常...
【嵌入式Linux驱动开发】五、LED驱动完善 – 面向对象·上下分层·左右分离
01-06
一、面向对象·上下分层·左右分离思想 面向对象 字符设备驱动程序抽象出一个 file_operations 结构体； 我们写的程序针对硬件部分抽象出 led_operations 结构体。 上下分层， 比如我们前面写的 LED 驱动程序就分为 ...
MVC分层 PPT
02-02
MVC（Model-View-Controller）是一种广泛应用于Web开发的分层设计模式，它的核心思想是将应用的业务逻辑、数据处理和用户界面分离，以实现更好的组织和解耦。以下是对MVC各层的详细说明： 1. **模型层（Model）** ...
基于Linux的嵌入式GUI设计研究.pdf
09-06
总结来说，基于Linux的嵌入式GUI设计是将复杂的硬件驱动与用户界面设计分离，通过分层架构提高系统的可扩展性和可移植性。这使得开发者能够专注于应用程序的逻辑，而无需关心底层硬件的具体细节，从而加速了产品开发...
代码之美(中文完整版).pdf
11-14
17.6.分层是永恒之道? 第18章 Python的字典类：如何打造全能战士 18.1. 字典类的内部实现 18.2. 特殊调校 18.3. 冲突处理 18.4. 调整大小 18.5. 迭代和动态变化 18.6. 结论 18.7. 致谢 第19章 NumPy中的多维迭代器 ...
韦东山分层分离思想
w492665264的博客
09-21 226
分层分离思想的关键就是抽象出各种类，以类为出发点，考虑程序的构建
Linux驱动之分离分层的概念
饕餮的阿周
08-18 768
linux驱动之分离分层的概念
Linux驱动的软件架构（二）：设备驱动的分层思想
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
10-31 1755
在Linux 2.6以后的设备驱动模型中，需关心总线、设备和驱动这3个实体，总线将设备和驱动绑定。在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，会寻找与之匹配的设备，而。一个现实的Linux设备和驱动通常都需要挂接在一种总线上，对于本身依附于PCI、USB、I2C、SPI等的设备而言，这自然不是问题，但是在嵌入式系统里面，
Linux驱动的分离与分层(很重要)
weixin_45905650的博客
05-03 1653
Linux驱动的分离与分层前言驱动的分隔与分离驱动的分层 前言 本文主要来自正点原子、野火Linux教程及本人理解，若有侵权请及时联系本人删除。 驱动的分隔与分离 对于 Linux 这样一个成熟、庞大、复杂的操作系统，代码的重用性非常重要，否则的话就会在 Linux 内核中存在大量无意义的重复代码。尤其是驱动程序，因为驱动程序占用了 Linux内核代码量的大头，如果不对驱动程序加以管理，任由重复的代码肆意增加，那么用不了多久Linux 内核的文件数量就庞大到无法接受的地步。 假如现在有三个平台 A、B 和
Linux设备驱动模型-Driver
半月旋空
10-19 1137
前言 linux将所有的驱动抽象为struct device_driver结构。这样设计可以方便驱动程序更好编写，在编写驱动的时候只需要将此结构嵌入到具体的驱动中即可。 比如常见的结构:  struct platform_driver结构 struct platform_driver { int (*probe)(struct platform_device *); int (*remo
Linux Platform驱动模型(二) _驱动方法
weixin_33978016的博客
02-06 138
在Linux设备树语法详解和Linux Platform驱动模型(一) _设备信息中我们讨论了设备信息的写法，本文主要讨论平台总线中另外一部分-驱动方法，将试图回答下面几个问题： 如何填充platform_driver对象？ 如何将驱动方法对象注册到平台总线中？ 正文前的一点罗嗦 写驱动也有一段时间了，可以发现，其实驱动本质上只做了两件事：向上提供接口，向下控制硬件，当然，这里的向上并不是直接...
驱动程序分层分离实践与LED示例详解
在实验中，通过平台分层分离的思想，作者指导如何编写一个简单的LED驱动程序。首先是定义平台资源结构体，它包含了设备的基本属性和所需的硬件资源。接下来，用户需编写“平台设备”和“平台驱动”，分别用于描述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值