Linux内核模块编写之？: Platform Device

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

/**
 * __platform_driver_register - register a driver for platform-level devices
 * @drv: platform driver structure
 * @owner: owning module/driver
 */
int __platform_driver_register(struct platform_driver *drv,
							struct module *owner)
{
	drv->driver.owner = owner;
	drv->driver.bus = &platform_bus_type;
	drv->driver.probe = platform_drv_probe;        // 手动“重载”了device_driver里的函数们，
	drv->driver.remove = platform_drv_remove;      // 于是在device_driver里调用这些函数，
	drv->driver.shutdown = platform_drv_shutdown;  // 也不会有错误出现。

	return driver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(__platform_driver_register);

struct platform_device {
	const char		*name; // 驱动名称，必须和platform_driver的对应
	int				id;    // id号
	bool			id_auto;
	struct device	dev;   // device结构体
	u64				platform_dma_mask;
	struct device_dma_parameters dma_parms;
	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;
};

#define red_led_gpio   10
#define green_led_gpio 13
#define blue_led_gpio  2

static struct platform_driver gpio_led_driver = {
	.probe		= gpio_led_probe,
	.shutdown	= gpio_led_shutdown,
	.driver		= {
		.name	= "leds-gpio",
		.of_match_table = of_gpio_leds_match,
	},
};

static int gpio_led_probe(struct platform_device *pdev)
{
	struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
	struct gpio_leds_priv *priv;
	int i, ret = 0;
	// ...
	// 中略，内容为根据pdata构造priv
	// (仅在pdata有效时，否则走设备树流程)
	// ...
	platform_set_drvdata(pdev, priv);
	return 0;
}

#include <linux/module.h>           // 所有模块都需要
#include <linux/moduleparam.h>      // 模块参数
#include <linux/kernel.h>           // printk和KERN_INFO等等
#include <linux/init.h>             // __init、__exit的定义
#include <linux/platform_device.h>  // platform_device的定义
#include <linux/device.h>           // device的定义
#include <linux/leds.h>             // gpio_led_platform_data等等结构体的定义

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Fw[a]rd");
MODULE_DESCRIPTION("A rgb leds module");

#define red_led_gpio   10
#define green_led_gpio 13
#define blue_led_gpio  2

static struct gpio_led rgb_leds_info[3] = {
	{.name = "red", .gpio = red_led_gpio, .active_low = 0u},
	{.name = "green", .gpio = green_led_gpio, .active_low = 0u},
	{.name = "blue", .gpio = blue_led_gpio, .active_low = 0u},
};


static struct gpio_led_platform_data rgb_leds_data = {
	.num_leds = 3,
	.leds = rgb_leds_info,
};

// 防止报错用
void rgb_leds_device_release(struct device *dev) {
	// do nothing
	return;
}

// platform设备结构体
static struct platform_device rgb_leds_device =
{
	.name = "leds-gpio", // 必须是这个名字，否则无法加载
	.id = 0x2233,
	.dev = {
		.platform_data = &rgb_leds_data,
		.release = &rgb_leds_device_release,
	}
};


// 加载模块调用的函数
static int __init rgb_init(void)
{
    int res = platform_device_register(&rgb_leds_device);
	printk(KERN_INFO "rgb_leds: registered, return %d\n", res);
    return 0;
}

// 卸载模块调用的函数，需要用__exit宏
static void __exit rgb_exit(void)
{   
    platform_device_unregister(&rgb_leds_device);
    printk(KERN_INFO "rgb_leds: Goodbye!\n");
}

// 定义模块的加载卸载函数
module_init(rgb_init);
module_exit(rgb_exit);

static int gpio_led_probe(struct platform_device *pdev)
{
	struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
	struct gpio_leds_priv *priv;
	int i, ret = 0;

	if (pdata && pdata->num_leds) {
		// 中略，在pdata（gpio_led_platform_data*）有效时走常规路线
		// ...
	} else { // 这里是设备树路线
		priv = gpio_leds_create(pdev); // 通过设备树内容构造priv
		if (IS_ERR(priv))
			return PTR_ERR(priv);
	}

	platform_set_drvdata(pdev, priv);

	return 0;
}

static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct fwnode_handle *child;
	struct gpio_leds_priv *priv;
	int count, ret;

	count = device_get_child_node_count(dev); // 获取子节点个数
	if (!count)
		return ERR_PTR(-ENODEV);

	priv = devm_kzalloc(dev, struct_size(priv, leds, count), GFP_KERNEL);  // 给priv分配内存空间
	if (!priv)
		return ERR_PTR(-ENOMEM);

	device_for_each_child_node(dev, child) { // 每个子节点进行foreach循环
		struct gpio_led_data *led_dat = &priv->leds[priv->num_leds];
		struct gpio_led led = {};
		const char *state = NULL;

		/*
		 * Acquire gpiod from DT with uninitialized label, which
		 * will be updated after LED class device is registered,
		 * Only then the final LED name is known.
		 */
		led.gpiod = devm_fwnode_get_gpiod_from_child(dev, NULL, child,
							     GPIOD_ASIS,
							     NULL);
		if (IS_ERR(led.gpiod)) {
			fwnode_handle_put(child);
			return ERR_CAST(led.gpiod);
		}

		led_dat->gpiod = led.gpiod;

		fwnode_property_read_string(child, "linux,default-trigger",
					    &led.default_trigger);

		if (!fwnode_property_read_string(child, "default-state",
						 &state)) {
			if (!strcmp(state, "keep"))
				led.default_state = LEDS_GPIO_DEFSTATE_KEEP;
			else if (!strcmp(state, "on"))
				led.default_state = LEDS_GPIO_DEFSTATE_ON;
			else
				led.default_state = LEDS_GPIO_DEFSTATE_OFF;
		}

		if (fwnode_property_present(child, "retain-state-suspended"))
			led.retain_state_suspended = 1;
		if (fwnode_property_present(child, "retain-state-shutdown"))
			led.retain_state_shutdown = 1;
		if (fwnode_property_present(child, "panic-indicator"))
			led.panic_indicator = 1;

		ret = create_gpio_led(&led, led_dat, dev, child, NULL);
		if (ret < 0) {
			fwnode_handle_put(child);
			return ERR_PTR(ret);
		}
		/* Set gpiod label to match the corresponding LED name. */
		gpiod_set_consumer_name(led_dat->gpiod,
					led_dat->cdev.dev->kobj.name);
		priv->num_leds++;
	}

	return priv;
}