linux驱动开发 - 12_platform 平台驱动模型

已于 2023-05-07 18:53:30 修改
阅读量1k 收藏 6
点赞数 1
分类专栏： linux驱动开发 文章标签： 驱动开发 linux 运维
于 2023-05-03 21:35:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kakaka666/article/details/130477600
版权

文章目录


链接: C/C++Linux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂

platform 平台驱动模型

根据总线-驱动-设备驱动模型，IIC、SPI、USB这样实实在在的总线是完全匹配的，但是要有一些外设是没法归结为具体的总线：比如定时器、RTC、LCD等。为此linux内核创造了一个虚拟的总线：platform总线。

  • 方便开发，linux提出了驱动分离与分层。

  • 进一步引出了驱动-总线-设备驱动模型，或者框架。

  • 对于SOC内部的RTC，timer等等不好归结为具体的总线，为此linux内核提出了一个虚拟总线：platform总线，platform设备和platform驱动。

1 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;	/* use dev_groups instead */
	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;
};
  • 第 10 行， match 函数，此函数就是完成设备和驱动之间匹配的，总使用 match 函数来根据注册的设备来查找对应的驱动，或者根据注册的驱动来查找相应的设备，因此每一条总线都必须实现此函数。 match 函数有两个参数： dev 和 drv，这两个参数分别为 device 和 device_driver 类型，也就是设备和驱动。

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 就是匹配函数。

驱动和设备是如何匹配的， platform_match 函数定义在文件 drivers/base/platform.c 中，函数内容如下所示

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

驱动和设备的匹配有四种方法 :

  • 第一种匹配方式， OF 类型的匹配，也就是设备树采用的匹配方式，of_driver_match_device 函数 。
  • 第四种匹配方式，如果第三种匹配方式的 id_table 不存在的话就直接比较驱动和设备的 name 字段，看看是不是相等，如果相等的话就匹配成功。

platform匹配过程

根据前面的分析，驱动和设备匹配是通过bus->match函数，platform总线下的match函数就是：platform_match。

platform_match	
	-> of_driver_match_device，设备树
	-> acpi_driver_match_device ACPI类型的
	-> platform_match_id 根据platform_driver-> id_table 
	-> strcmp(pdev->name, drv->name)  //最终的就是比较字符串，就是platform_device->name，和platform_driver->driver->name。无设备树情况下使用。

	1、有设备树的时候：
	of_driver_match_device
		-> of_match_device(drv->of_match_table, dev)  //of_match_table非常重要，
类型为of_device_id。
//compatible属性

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

  • 第 2 行， probe 函数，当驱动与设备匹配成功以后 probe 函数就会执行

  • 第 7 行， driver 成员，为 device_driver 结构体变量， Linux 内核里面大量使用到了面向对象的思维， device_driver 相当于基类，提供了最基础的驱动框架。 plaform_driver 继承了这个基类，然后在此基础上又添加了一些特有的成员变量。

使用platform_driver_register向内核注册platform驱动。
	platform_driver_register
		-> __platform_driver_register   (platform_driver)
			-> 设置driver的probe为platform_drv_probe， //如果platform_driver的
														// probe函数有效的话。
			-> driver_register
				->执行device_drive->probe，对于platform总线，也就是platform_drv_probe函数。而platform_drv_probe函数会执行platform_driver下的probe函数。
	结论：向内核注册platform驱动的时候，如果驱动和设备匹配成功，最终会执行platform_driver的probe函数。

在编写 platform 驱动的时候，首先定义一个 platform_driver 结构体变量，然后实现结构体中的各个成员变量，重点是实现匹配方法以及 probe 函数。当驱动和设备匹配成功以后 probe函数就会执行，具体的驱动程序在 probe 函数里面编写，比如字符设备驱动等等。

**定义并初始化好 platform_driver 结构体变量以后，需要在驱动入口函数里面调用platform_driver_register 函数向 Linux 内核注册一个 platform 驱动 **

platform_driver_register 函数原型如下所示：

int platform_driver_register (struct platform_driver *driver)
函数参数和返回值含义如下：
    driver：要注册的 platform 驱动。
    返回值： 负数，失败； 0，成功。

通过 platform_driver_unregister 函数卸载 platform 驱动，platform_driver_unregister 函数原型如下：

void platform_driver_unregister(struct platform_driver *drv)
函数参数和返回值含义如下：
    drv：要卸载的 platform 驱动。
    返回值： 无。

platform 驱动框架如下所示：

/* 设备结构体 */
struct xxx_dev{
	struct cdev cdev;
	/* 设备结构体其他具体内容 */
};

struct xxx_dev xxxdev; /* 定义个设备结构体变量 */

static int xxx_open(struct inode *inode, struct file *filp)
{
	/* 函数具体内容 */
	return 0;
}

static ssize_t xxx_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	/* 函数具体内容 */
	return 0;
}

/* 字符设备驱动操作集 */
static struct file_operations xxx_fops = {
	.owner = THIS_MODULE,
	.open = xxx_open,
	.write = xxx_write,
};

/*
* platform 驱动的 probe 函数
* 驱动与设备匹配成功以后此函数就会执行
*/
static int xxx_probe(struct platform_device *dev)
{
	......
	cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 */
	/* 函数具体内容 */
	return 0;
}

static int xxx_remove(struct platform_device *dev)
{
	......
	cdev_del(&xxxdev.cdev);/* 删除 cdev */
	/* 函数具体内容 */
	return 0;
}

/* 匹配列表 */
static const struct of_device_id xxx_of_match[] = {
	{ .compatible = "xxx-gpio" },
	{ /* Sentinel */ }
};

/*platform 平台驱动结构体*/
static struct platform_driver xxx_driver = {
	.driver = {
		.name = "xxx",
		.of_match_table = xxx_of_match,
	},
	.probe = xxx_probe,
	.remove = xxx_remove,
};

/* 驱动模块加载 */
static int __init xxxdriver_init(void)
{
	return platform_driver_register(&xxx_driver);
}

/* 驱动模块卸载 */
static void __exit xxxdriver_exit(void)
{
	platform_driver_unregister(&xxx_driver);
}

module_init(xxxdriver_init);
module_exit(xxxdriver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("kaka");

3 platform 设备

platform_device 这个结构体表示 platform 设备，如果内核支持设备树的话就不要再使用 platform_device 来描述设备了，改用设备树去描述 。

platform_device 结构体定义在文件include/linux/platform_device.h 中，结构体内容如下：

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

  • name 表示设备名字，要和所使用的 platform 驱动的 name 字段相同，否则的话设=备就无法匹配到对应的驱动。比如对应的 platform 驱动的 name 字段为“xxx-gpio”，那么此 name字段也要设置为“xxx-gpio”。

  • num_resources 表示资源数量，一般为resource 资源的大小。

  • resource 表示资源，也就是设备信息，比如外设寄存器等。 Linux 内核使用 resource结构体表示资源， resource 结构体内容如下：

struct resource {
    resource_size_t start;
    resource_size_t end;
    const char *name;
    unsigned long flags;
    struct resource *parent, *sibling, *child;
};

1、无设备树的时候，此时需要驱动开发人员编写设备注册文件，使用platform_device_register函数注册设备。
2，有设备树，修改设备树的设备节点即可。

当设备与platform的驱动匹配以后，就会执行platform_driver->probe函数。

使用 platform_device_register 函数将设备信息注册到 Linux 内核中，此函数原型如下所示：

int platform_device_register(struct platform_device *pdev)
函数参数和返回值含义如下：
    pdev：要注册的 platform 设备。
    返回值： 负数，失败； 0，成功。

通过 platform_device_unregister 函数注销掉相应的 platform设备， platform_device_unregister 函数原型如下：

void platform_device_unregister(struct platform_device *pdev)
函数参数和返回值含义如下：
    pdev：要注销的 platform 设备。
    返回值： 无。

platform 设备信息框架如下所示：

/* 寄存器地址定义*/
#define PERIPH1_REGISTER_BASE (0X20000000) /* 外设 1 寄存器首地址 */
#define PERIPH2_REGISTER_BASE (0X020E0068) /* 外设 2 寄存器首地址 */
#define REGISTER_LENGTH 

/* 资源 
数组 xxx_resources 表示设备资源，一共有两个资源，分别为设备外设 1 和外设 2 的寄存器信息。
*/
static struct resource xxx_resources[] = {
	[0] = {
		.start = PERIPH1_REGISTER_BASE,
		.end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = PERIPH2_REGISTER_BASE,
		.end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),
		.flags = IORESOURCE_MEM,
	},
};

/* platform 设备结构体 */
static struct platform_device xxxdevice = {
	.name = "xxx-gpio",	// name 字段要和所使用的驱动中的 name 字段一致
	.id = -1,
	.num_resources = ARRAY_SIZE(xxx_resources),	//num_resources 表示资源大小，其实就是数组 xxx_resources的元素数量，
	.resource = xxx_resources,
};

/* 设备模块加载 */
static int __init xxxdevice_init(void)
{
	return platform_device_register(&xxxdevice);
}

/* 设备模块注销 */
static void __exit xxx_resourcesdevice_exit(void)
{
	platform_device_unregister(&xxxdevice);
}

module_init(xxxdevice_init);
module_exit(xxxdevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");

当 Linux 内核支持了设备树以后就不需要用户手动去注册 platform 设备了。因为设备信息都放到了设备树中去描述，Linux 内核启动的时候会从设备树中读取设备信息，然后将其组织成 platform_device 形式

4 程序编写

1 LED灯的 platform 设备文件

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/ide.h>
#include <linux/platform_device.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



void leddevice_release(struct device *dev)
{
    printk("leddevice release\r\n");
}

static struct resource led_resources[] = {
    [0] = {
		.start	= CCM_CCGR1_BASE,
		.end	= CCM_CCGR1_BASE + REGISTER_LENGTH - 1,
		.flags	= IORESOURCE_MEM,   // 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,
    },
}; 


static struct platform_device leddevice = {
    .name = "imx6ull-led",  //设备和驱动匹配
    .id = -1,
    .dev = {
        .release  = leddevice_release,
    },
    .num_resources = ARRAY_SIZE(led_resources),
    .resource = led_resources,  // led_resources 数组，也就是设备资源，描述了 LED 所要使用到的寄存器信息，
};

/*
 设备加载
 */
static int __init leddevice_init(void)
{
    /* 注册platform设备 */
    return platform_device_register(&leddevice);
}

/* 
 设备卸载
 */
static void __exit leddevice_exit(void)
{
    platform_device_unregister(&leddevice);
}

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

2 LED 灯的 platform 的驱动文件

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/ide.h>
#include <linux/platform_device.h>

#define PLATFORM_NAME  "platled"
#define PLATFORM_COUNT 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;

#define LEDOFF  0       /* 关闭 */
#define LEDON   1       /* 打开 */


/* LED设备结构体 */
struct newchrled_dev{
    struct cdev cdev;       /* 字符设备 */
    dev_t   devid;          /* 设备号 */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */

};

struct newchrled_dev newchrled; /* led设备 */

/* LED灯打开/关闭 */
static void led_switch(u8 sta)
{
    u32 val = 0;

    if(sta == LEDON) {
        val = readl(GPIO1_DR);
        val &= ~(1 << 3);            /* bit3清零,打开LED灯 */
        writel(val, GPIO1_DR); 
    } else if(sta == LEDOFF) {
        val = readl(GPIO1_DR);
        val |= (1 << 3);            /* bit3清零,打开LED灯 */
        writel(val, GPIO1_DR);
    }
}

static int newchrled_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &newchrled;
    return 0;
}

static int newchrled_release(struct inode *inode, struct file *filp)
{
    struct newchrled_dev *dev = (struct newchrled_dev*)filp->private_data;
    
    return 0;
}

static ssize_t newchrled_write(struct file *filp, const char __user *buf,
			 size_t count, loff_t *ppos)
{
    int retvalue;
    unsigned char databuf[1];

    retvalue = copy_from_user(databuf, buf, count);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    /* 判断是开灯还是关灯 */
    led_switch(databuf[0]);

    return 0;
}

static const struct file_operations newchrled_fops = {
    .owner = THIS_MODULE,
    .write	= newchrled_write,
	.open	= newchrled_open,
	.release= newchrled_release,
};

// probe 函数，当设备和驱动匹配以后此函数就会执行
static int led_probe(struct platform_device *dev)
{
  int i = 0;
  struct resource *ledsource[5];
  int ret = 0;
  unsigned int val = 0;

  //printk("led driver proe\r\n");
  /* 初始化LED，字符设备驱动 */
  /* 1,从设备中获取资源 */
  for(i=0; i < 5; i++) {
    ledsource[i] = platform_get_resource(dev, IORESOURCE_MEM, i);
    if (ledsource[i] == NULL)
		  return -EINVAL;
  }

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

    /* 2,初始化 */
    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26);  /* 先清除以前的配置bit26,27 */
    val |= 3 << 26;     /* bit26,27置1 */
    writel(val, IMX6U_CCM_CCGR1);
 
    writel(0x5, SW_MUX_GPIO1_IO03);     /* 设置复用 */
    writel(0X10B0, SW_PAD_GPIO1_IO03);  /* 设置电气属性 */

    val = readl(GPIO1_GDIR);
    val |= 1 << 3;              /* bit3置1,设置为输出 */
    writel(val, GPIO1_GDIR);

    val = readl(GPIO1_DR);
    val |= (1 << 3);            /* bit3置1,关闭LED灯 */
    writel(val, GPIO1_DR);

    newchrled.major = 0;    /* 设置为0,表示由系统申请设备号 */

    /* 2，注册字符设备 */
    if(newchrled.major){    /* 给定主设备号 */
        newchrled.devid = MKDEV(newchrled.major, 0);
        ret = register_chrdev_region(newchrled.devid, PLATFORM_COUNT, PLATFORM_NAME);
    } else {                /* 没有给定主设备号 */
        ret = alloc_chrdev_region(&newchrled.devid, 0, PLATFORM_COUNT, PLATFORM_NAME);
        newchrled.major = MAJOR(newchrled.devid);
        newchrled.minor = MINOR(newchrled.devid);
    }
    if(ret < 0) {
        printk("newchrled chrdev_region err!\r\n");
        goto fail_devid;
    }
    printk("newchrled major=%d, minor=%d\r\n", newchrled.major, newchrled.minor);

    /* 3,注册字符设备 */
    newchrled.cdev.owner = THIS_MODULE;
    cdev_init(&newchrled.cdev, &newchrled_fops);
    ret = cdev_add(&newchrled.cdev, newchrled.devid, PLATFORM_COUNT);
    if(ret < 0) {
        goto fail_cdev;
    }

    /* 4,自动创建设备节点 */
    newchrled.class = class_create(THIS_MODULE, PLATFORM_NAME);
	if (IS_ERR(newchrled.class)) {
        ret = PTR_ERR(newchrled.class);
		goto fail_class;
    }

    newchrled.device = device_create(newchrled.class, NULL,
			     newchrled.devid, NULL, PLATFORM_NAME);
	if (IS_ERR(newchrled.device)) {
        ret = PTR_ERR(newchrled.device);
        goto fail_device;
    }
		
    return 0;

fail_device:
    class_destroy(newchrled.class);
fail_class:
    cdev_del(&newchrled.cdev);
fail_cdev:
    unregister_chrdev_region(newchrled.devid, PLATFORM_COUNT);
fail_devid:
	return ret; 
}

//remobe 函数，当卸载 platform 驱动的时候此函数就会执行
static int led_remove(struct platform_device *dev)
{

  unsigned int val = 0;

  printk("led driver remove\r\n");
  val = readl(GPIO1_DR);
  val |= (1 << 3);            /* bit3清零,打开LED灯 */
  writel(val, GPIO1_DR);

  /* 1,取消地址映射 */
  iounmap(IMX6U_CCM_CCGR1);
  iounmap(SW_MUX_GPIO1_IO03);
  iounmap(SW_PAD_GPIO1_IO03);
  iounmap(GPIO1_DR);
  iounmap(GPIO1_GDIR);

  /* 1,删除字符设备 */
  cdev_del(&newchrled.cdev);

  /* 2,注销设备号 */
  unregister_chrdev_region(newchrled.devid, PLATFORM_COUNT);

  /* 3,摧毁设备 */
  device_destroy(newchrled.class, newchrled.devid);
  
  /* 4,摧毁类 */
  class_destroy(newchrled.class);
  return 0;
}

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

/*
 驱动加载
 */
static int __init leddriver_init(void)
{
    /* 注册platform驱动 */
    return platform_driver_register(&led_driver);
}

/* 
 驱动卸载
 */
static void __exit leddriver_exit(void)
{
  platform_driver_unregister(&led_driver);
}

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

3 编写测试 APP

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


/*
 *argc:应用程序参数个数
 *argv[]:具体的参数内容，字符串形式 
 *./platledApp  <filename>  <0:1> 0表示关灯，1表示开灯
 * ./platledApp /dev/platled 0    关灯
 * ./platledApp /dev/platled 1    开灯
 */

#define LEDOFF 0
#define LEDON 1

int main(int argc, char *argv[])
{
    int fd, retvalue;
    char *filename;
    unsigned char databuf[1];


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

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if(fd < 0) {
        printf("file %s open failed!\r\n", filename);
        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;
    }

    close(fd);

    return 0;
}

4 编译驱动程序和测试 APP

①、编译驱动程序

KERNELDIR := /home/kaka/linux/IMX6ULL/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)

obj-m := leddevice.o leddriver.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

输入如下命令编译出驱动模块文件：

make -j32

编译成功以后就会生成一个名为“leddevice.ko leddriver.ko”的驱动模块文件。

②、编译测试 APP

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

4、运行测试

将编译出来的leddevice.ko 、 leddriver.ko 和 ledApp 拷贝到rootfs/lib/modules/4.1.15目录中 ，输入如下命令
加载 leddevice.ko 设备模块和 leddriver.ko 这个驱动模块。

depmod //第一次加载驱动的时候需要运行此命令
modprobe leddevice.ko //加载设备模块
modprobe leddriver.ko //加载驱动模块

根文件系统中/sys/bus/platform/目录下保存着当前板子 platform 总线下的设备和驱动，其中devices 子目录为 platform 设备， drivers 子目录为 plartofm 驱动。

查看/sys/bus/platform/devices/目录，看一下驱动是否存在
/lib/modules/4.1.15 # ls /sys/bus/platform/devices/imx6ul
imx6ul-pinctrl/  imx6ul-tsc/      imx6ull-led/

查看/sys/bus/platform/drivers/目录，看一下驱动是否存在
/lib/modules/4.1.15 # ls /sys/bus/platform/drivers/imx6ul
imx6ul-pinctrl/  imx6ul-tsc/      imx6ull-led/

驱动和设备匹配成功以后测试 LED 灯驱动了，输入如下命令打开 LED 灯：

./ledApp /dev/platled 1 / /打开 LED 灯

在输入如下命令关闭 LED 灯：

./ledApp /dev/platled 0 //关闭 LED 灯

观察一下 LED 灯能否打开和关闭，如果可以的话就说明驱动工作正常，如果要卸载驱动的话输入如下命令即可：

rmmod leddevice.ko
rmmod leddriver.ko

设备树下的 platform 驱动

Linux 下的驱动分离与分层，以及总线、设备和驱动这样的驱动框架。基于总线、设备和驱动这样的驱动框架， Linux 内核提出来 platform 这个虚拟总线，相应的也有 platform 设备和 platform 驱动。

最新的 Linux 内核已经支持了设备树，如何在设备树下编写 platform 驱动？

1 设备树下的 platform 驱动简介

  • platform 驱动框架分为总线、设备和驱动，其中总线不需要去管理，这个是 Linux 内核提供的，编写驱动的时候只要关注于设备和驱动的具体实现即可。

  • 在没有设备树的 Linux 内核下，需要分别编写并注册 platform_device 和 platform_driver，分别代表设备和驱动。

  • 在使用设备树的时候，设备的描述被放到了设备树中，因此 platform_device 就不需要去编写了，只需要实现 platform_driver 即可。

1.1 在设备树中创建设备节点

要先在设备树中创建设备节点来描述设备信息，重点是要设置好 compatible属性的值，因为 platform 总线需要通过设备节点的 compatible 属性值来匹配驱动

编写如下设备节点来描述 LED 这个设备：

gpioled {
    #address-cells = <1>;
    #size-cells = <1>;
    compatible = "atkalpha-gpioled";
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_led>;
    led-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
    status = "okay";
};

compatible 属性值为“atkalpha-gpioled”，写 platform驱动的时of_match_table 属性表中要有“atkalpha-gpioled”

1.2 编写 platform 驱动的时候要注意兼容属性

用设备树的时候 platform 驱动会通过 of_match_table 来保存兼容性值，platform 驱动中 platform_driver 就可以按照如下所示设置：

struct of_device_id led_of_match[] = {
    {.compatible = "alientek,gpioled"}, /* 兼容属性 */
    { /* sentinel */ },
};

MODULE_DEVICE_TABLE(of, led_of_match);

struct platform_driver led_driver = {
    .driver = {
        .name = "imx6ull-led",  /* 无设备树和设备进行匹配，驱动名字 */
        .of_match_table = led_of_match, /* 设备树匹配表 */ 

    },
    .probe = led_probe,
    .remove = led_remove,
};

  • compatible 值为“atkalpha-gpioled”，驱动中的 compatible 属性和设备中的 compatible 属性相匹配，因此驱动中对应的 probe 函数就会执行。在编写 of_device_id 的时候最后一个元素一定要为空！

  • 通过 MODULE_DEVICE_TABLE 声明一下 leds_of_match 这个设备匹配表。

  • 设置 platform_driver 中的 of_match_table 匹配表为上面创建的 leds_of_match

1.3 编写 platform 驱动

当驱动和设备匹配成功以后就会执行 probe 函数。需要在 probe 函数里面执行字符设备驱动初始化，当注销驱动模块的时候 remove 函数就会执行。

2 程序编写

2.1 platform 驱动程序编写

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/ide.h>
#include <linux/platform_device.h>

#define GPIOLED_CNT     1
#define GPIOLED_NAME    "dtsplatled"
#define LEDOFF          0
#define LEDON           1

/* gpioled设备结构体 */
struct gpioled_dev{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int led_gpio;
};

struct gpioled_dev gpioled; /* LED */

static int led_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &gpioled;
    return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
    
    return 0;
}

static ssize_t led_write(struct file *filp, const char __user *buf,
			 size_t count, loff_t *ppos)
{
    int ret;
    unsigned char databuf[1];
    struct gpioled_dev *dev = filp->private_data;

    ret = copy_from_user(databuf, buf, count);
    if(ret < 0) {
        return -EINVAL;
    }

    if(databuf[0] == LEDON) {
        gpio_set_value(dev->led_gpio, 0); 
    } else if(databuf[0] == LEDOFF) {
        gpio_set_value(dev->led_gpio, 1); 
    }

    return 0;
}

/* 操作集 */
static const struct file_operations led_fops = {
    .owner		=	THIS_MODULE,
	.write		=	led_write,
	.open		=	led_open,
	.release	=	led_release,
};

static int led_probe(struct platform_device *dev)
{
    printk("led probe\r\n");

     int ret = 0;

    /* 注册字符设备驱动 */
    gpioled.major = 0;
    if(gpioled.major) { /* 给定主设备号 */
        gpioled.devid = MKDEV(gpioled.major, 0);
        register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
    } else {            /* 没给定设备号 */
        alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    printk("gpioled major = %d, minor = %d\r\n", gpioled.major, gpioled.minor);

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

    /* 3,添加cdev */
    cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);

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

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

    /* 1，获取设备节点 */
#if 0
    gpioled.nd = of_find_node_by_path("/gpioled");
    if(gpioled.nd == NULL) {
        ret = -EINVAL;
        goto fail_findnode;
    }
#endif
    gpioled.nd = dev->dev.of_node; 
  
    /* 2, 获取LED所对应的GPIO */
    gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpios", 0);
    if(gpioled.led_gpio < 0) {
        printk("can't find led gpio\r\n");
        ret = -EINVAL;
        goto fail_findnode;
    }
    printk("led gpio num = %d\r\n", gpioled.led_gpio);

    /* 3,申请IO */
    ret = gpio_request(gpioled.led_gpio, "led-gpio");
	if (ret) {
		printk("Failed to request the led gpio\r\n");
		ret = -EINVAL;
        goto fail_findnode;
	}

    /* 4,使用IO，设置为输出 */
    ret = gpio_direction_output(gpioled.led_gpio, 1);
	if (ret) {
		goto fail_setoutput;
	}

    /* 5,输出底电平，点亮LED灯*/
    gpio_set_value(gpioled.led_gpio, 0);

    return 0;

fail_setoutput:
    gpio_free(gpioled.led_gpio);
fail_findnode:
    return ret;
}

static int led_remove(struct platform_device *dev)
{
    printk("led remove\r\n");

        /* 关灯 */
    gpio_set_value(gpioled.led_gpio, 1);

    /* 注销字符设备驱动 */
    cdev_del(&gpioled.cdev);
    unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);

    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);

    /* 释放IO */
    gpio_free(gpioled.led_gpio);

    return 0;
}

struct of_device_id led_of_match[] = {
    {.compatible = "alientek,gpioled"},
    { /* sentinel */ },
};

struct platform_driver led_driver = {
    .driver = {
        .name = "imx6ull-led",  /* 无设备树和设备进行匹配，驱动名字 */
        .of_match_table = led_of_match, /* 设备树匹配表 */ 

    },
    .probe = led_probe,
    .remove = led_remove,
};

/*
 驱动加载
 */
static int __init leddriver_init(void)
{
    return  platform_driver_register(&led_driver);
}

/* 
 驱动卸载
 */
static void __exit leddriver_exit(void)
{
  platform_driver_unregister(&led_driver);  
}

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

2.2 编写测试 APP

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


/*
 *argc:应用程序参数个数
 *argv[]:具体的参数内容，字符串形式 
 *./platledApp  <filename>  <0:1> 0表示关灯，1表示开灯
 * ./platledApp /dev/platled 0    关灯
 * ./platledApp /dev/platled 1    开灯
 */

#define LEDOFF 0
#define LEDON 1

int main(int argc, char *argv[])
{
    int fd, retvalue;
    char *filename;
    unsigned char databuf[1];


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

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if(fd < 0) {
        printf("file %s open failed!\r\n", filename);
        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;
    }

    close(fd);

    return 0;
}

2.3 编译驱动程序和测试 APP

①、编译驱动程序

KERNELDIR := /home/kaka/linux/IMX6ULL/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)

obj-m := leddriver.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

输入如下命令编译出驱动模块文件：

make -j32

编译成功以后就会生成一个名为“leddriver.ko”的驱动模块文件。

②、编译测试 APP

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

2.4 运行测试

将编译出来的 leddriver.ko 和 ledApp 拷贝到rootfs/lib/modules/4.1.15目录中 ，输入如下命令
加载 leddriver.ko 这个驱动模块。

depmod //第一次加载驱动的时候需要运行此命令
modprobe leddriver.ko //加载驱动模块

根文件系统中/sys/bus/platform/目录下保存着当前板子 platform 总线下的设备和驱动，其中devices 子目录为 platform 设备， drivers 子目录为 plartofm 驱动。

查看/sys/bus/platform/devices/目录，看一下驱动是否存在
/lib/modules/4.1.15 # ls /sys/bus/platform/devices/imx6ul
imx6ul-pinctrl/  imx6ul-tsc/      imx6ull-led/

查看/sys/bus/platform/drivers/目录，看一下驱动是否存在
/lib/modules/4.1.15 # ls /sys/bus/platform/drivers/imx6ul
imx6ul-pinctrl/  imx6ul-tsc/      imx6ull-led/

驱动和设备匹配成功以后测试 LED 灯驱动了，输入如下命令打开 LED 灯：

./ledApp /dev/platled 1 / /打开 LED 灯

在输入如下命令关闭 LED 灯：

./ledApp /dev/platled 0 //关闭 LED 灯

观察一下 LED 灯能否打开和关闭，如果可以的话就说明驱动工作正常，如果要卸载驱动的话输入如下命令即可：

rmmod leddevice.ko
rmmod leddriver.ko
kaka的卡
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
platform设备驱动框架详解
eurphan_y的博客
02-11 1672
platform设备驱动详解     前面我们讲了设备驱动的分离,并且引出了总线(bus)、驱动(driver)和设备(device)模型,比如 I2C、SPI、USB 等总线。但是在 SOC 中有些外设是没有总线这个概念的,但是又要使用总线、驱动和设备模型该怎么办呢?为了解决此问题,Linux 提出了 platform 这个虚拟总线,相应的就有 platform_driver 和 platfo...
Linux驱动开发-14、串行设备驱动模型
hntea-hong
04-19 630
串行设备驱动模型 1、TTY概念解析 a) 串口终端（/dev/ttyS*） 串口终端是使用计算机串口连接的终端设备；Linux 以字符设备来处理这种串行端口；这些端口所对应的设备名称是/dev/ttySAC0-N   b) 控制台终端（/dev/console ） 计算机的输出设备通常被称为控制台终端，特指printk信息输出到的设备；/dev/console 是一个虚拟设备；它
【Linux驱动】设备树下的 platform驱动
最新发布
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
05-17 894
Linux3.x以后的版本才引入了设备树，设备树用于描述一个硬件平台的板级细节。在早些的linux内核，这些“硬件平台的板级细节”保存在linux内核目录“/arch”， 以ARM平台为例“硬件平台的板级细节”保存在“/arch/arm/plat-xxx”和“/arch/arm/mach-xxx”目录下。随着处理器数量的增多用于描述“硬件平台板级细节”的文件越来越多导致Linux内核非常臃肿， Linux之父发现这个问题之后决定使用设备树解决这个问题。
platform驱动框架梳理
Yisnow.的博客
11-30 1226
最后将device_node链表赋给of_root，即of_root代表所有的device_node的root，通过它，可以遍历所有的device_node。从start_kernel开始是找不到platform device这一部分转换的源头的，这个转换过程的函数是of_platform_default_populate_init(),它被调用的方式是一个声明：arch_initcall_sync(of_platform_default_populate_init);但这种方式应该很少见了。
一张图掌握 Linux platform 平台设备驱动框架！【建议收藏】
热门推荐
火山上的企鹅
07-08 1万+
嵌入式系统中有很多的物理总线：I2c、SPI、USB、uart、PCIE、APB、AHB。像这样的总线很多，而 Linux 系统要考虑到驱动的可重用性，因此提出了驱动的分离与分层这样的软件思路，于是 Linux从2.6起就加入了 platform 设备驱动，也叫做平台设备驱动。它是一条虚拟的总线, 并不是一个物理的总线。如下图所示：（本文不考虑设备树的情况）：
Linux之Platform设备驱动
风间琉璃的博客
09-25 2434
上述代码假定为了实现 funca()， 对于同类设备而言， 操作流程一致， 都要经过通用代码 A、 底层 ops1、通用代码 B、 底层 ops2、 通用代码 C、 底层 ops3这几步， 分层设计明显带来的好处是， 对于通用代码 A、B、 C， 具体的底层驱动不需要再实现， 而仅仅只关心其底层的操作ops1、 ops2、 ops3。当内核中有驱动注册时， 总线就会在右侧的设备中查找， 是否有匹配的设备， 同样的， 当有设备注册到内核中时， 也会在总线左侧查找是否有匹配的驱动。
Linux·platform驱动框架
m0_64560763的博客
08-20 1522
驱动框架-platform驱动框架
Platform平台设备驱动框架
Paper_Love的博客
07-29 669
platform驱动框架： //设备结构体 struct device {}; //驱动结构体 struct device_driver {}; //平台设备驱动框架 struct platform_driver { int (*probe)(struct platform_device *); int (*remove)(struct platform_device *); void (*shutdown)(struct platform_device *); int (*suspend)(s
platform平台设备_railroadzts_q_linux驱动_platform驱动_
10-03
在Linux操作系统中，平台驱动（Platform Driver）是用于与硬件接口进行交互的一种驱动模型，它主要处理特定SoC（System on Chip）系统中各种非标准I/O设备的控制。平台驱动设计灵活，能够适应不同厂商的硬件差异。...
Linux嵌入式驱动开发——平台总线实例modules_platform
02-08
3. **驱动模型**：平台总线支持模块化驱动，使得驱动程序可以动态加载和卸载，提高了系统的灵活性和可维护性。 在实际的嵌入式驱动开发中，我们通常会遇到以下关键步骤： 1. **设备节点创建**：在设备树中定义设备...
Linux嵌入式platform驱动模块modules_platform_dirver
02-08
平台驱动模型是Linux内核为了简化不同架构下的设备驱动开发而设计的一种统一接口。它允许驱动程序直接与硬件平台进行交互，而无需关心底层总线的细节。本主题将深入探讨`modules_platform_driver`及其相关概念。 ...
plat_device.rar_platform 驱动_platform设备
09-14
在Linux操作系统中，`platform`驱动是用于连接和管理基于平台特定硬件的接口。...总的来说，这个压缩包是一个宝贵的教育资源，对于那些想要深入学习Linux驱动开发的人来说，是非常有价值的参考资料。
S5PV210-Key_Platform.zip
04-02
Platform Bus驱动是Linux内核中用于设备驱动模型的一种机制，它简化了硬件设备与内核之间的交互。 在Linux内核中，设备驱动通常有多种类型，如PCI、SPI、I2C等，而Platform Bus驱动则是针对那些没有特定总线接口...
Linux platform 设备驱动实验
weixin_42482191的博客
05-29 1146
本篇文章主要介绍了总线--驱动----设备模型下的platform总线的初始化过程，如何进行设备和驱动的匹配和绑定的？以及从源码的角度解释了为什么会执行驱动中的probe函数。
Linux驱动之platform设备驱动
qq_53221728的博客
04-26 1669
inux内核提供了将驱动的硬件部分和软件部分分离开来的方法，移植的时候只需要修改其中的硬件部分。platform是一条虚拟的总线，也叫平台设备总线驱动。
Linux内核platform机制
爱锻炼的程序员
02-09 508
一.linux内核platform机制1.1.回顾ioremap实现开关灯驱动 需求： 硬件LED的GPIO由GPC0_3,GPC0_4更换为GPF1_4,GPF1_5 通过分析代码可知： 1.一个完整的驱动包括两部分：纯硬件和纯软件 2.之前的驱动如果硬件发生变化，代码几乎重头都要进行检查和修改，增大了驱动开发的工作量，可移植性非常差； 3.如果要优化此问题，内核提出分离思想，把纯软...
Linux驱动_Platform平台驱动
qq_42174306的博客
02-19 4430
在Linux操作系统中，驱动程序占用了Linux内核代码量的大头，如果不进行管理，将会造成数量庞大的结果。因此引入了驱动的分离。 上图所示就是驱动的分离，相当于驱动使用标准方法去获取到设备信息(比如从设备树中获取到设备信息)，然后根据获取到的设备信息来初始化设备。 这样就相当于驱动只负责驱动，设备只负责设备，想办法将两者进行匹配即可。这个就是 Linux 中的总线(bus)、驱动(driver)和设备(device)模型，也就是常说的驱动分离。总线就是驱动和设备信息的月老...
Linux驱动开发之【Platform总线驱动模型】
weixin_53351963的博客
03-19 673
自内核2.6版本开始，需要关注的是总线、设备和驱动这3个实体：总线将设备和驱动绑定。在Linux内核系统中注册一个设备的时候，会寻找与之对应驱动进行匹配;相反地，系统中注册一个驱动的时候，会去寻找一个对应的设备进行匹配。匹配的的工作由总线来完成。在Linux设备中有的是没有对应的物理总线的，但为了适配Linux的总线模型，内核针对这种没有物理总线的设备开发了一种虚拟总线--platform总线
Linux平台设备驱动模型详解
“linux驱动实战之平台设备总线_v1.2” 在Linux操作系统中，设备驱动是连接硬件和操作系统内核的关键部分。本文档深入探讨了“平台设备总线”驱动模型，这是针对嵌入式系统特别是System-on-Chip (SOC) 设备的一种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值