Commit eb5ab6ff authored by Koichiro Den's avatar Koichiro Den Committed by Bartosz Golaszewski
Browse files

gpio: introduce utilities for synchronous fake device creation 



Both gpio-sim and gpio-virtuser share a mechanism to instantiate a
platform device, wait for probe completion, and retrieve the probe
success or error status synchronously. With gpio-aggregator planned to
adopt this approach for its configfs interface, it's time to factor
out the common code.

Add dev-sync-probe.[ch] to house helper functions used by all such
implementations.

No functional change.

Signed-off-by: default avatarKoichiro Den <koichiro.den@canonical.com>
Link: https://lore.kernel.org/r/20250221133501.2203897-2-koichiro.den@canonical.com


Signed-off-by: default avatarBartosz Golaszewski <bartosz.golaszewski@linaro.org>
parent 11067f50

drivers/gpio/Kconfig

+3 −0
Original line number Diff line number Diff line
@@ -1948,3 +1948,6 @@ config GPIO_VIRTUSER 
endmenu



endif



config DEV_SYNC_PROBE

	tristate

drivers/gpio/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -19,6 +19,9 @@ obj-$(CONFIG_GPIO_GENERIC) += gpio-generic.o 
# directly supported by gpio-generic

gpio-generic-$(CONFIG_GPIO_GENERIC)	+= gpio-mmio.o



# Utilities for drivers that need synchronous fake device creation

obj-$(CONFIG_DEV_SYNC_PROBE)		+= dev-sync-probe.o



obj-$(CONFIG_GPIO_104_DIO_48E)		+= gpio-104-dio-48e.o

obj-$(CONFIG_GPIO_104_IDI_48)		+= gpio-104-idi-48.o

obj-$(CONFIG_GPIO_104_IDIO_16)		+= gpio-104-idio-16.o

drivers/gpio/dev-sync-probe.c

0 → 100644
+97 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Common code for drivers creating fake platform devices.

 *

 * Provides synchronous device creation: waits for probe completion and

 * returns the probe success or error status to the device creator.

 *

 * Copyright (C) 2021 Bartosz Golaszewski <brgl@bgdev.pl>

 * Copyright (C) 2025 Koichiro Den <koichiro.den@canonical.com>

 */



#include <linux/device.h>

#include <linux/slab.h>



#include "dev-sync-probe.h"



static int dev_sync_probe_notifier_call(struct notifier_block *nb,

					unsigned long action, void *data)

{

	struct dev_sync_probe_data *pdata;

	struct device *dev = data;



	pdata = container_of(nb, struct dev_sync_probe_data, bus_notifier);

	if (!device_match_name(dev, pdata->name))

		return NOTIFY_DONE;



	switch (action) {

	case BUS_NOTIFY_BOUND_DRIVER:

		pdata->driver_bound = true;

		break;

	case BUS_NOTIFY_DRIVER_NOT_BOUND:

		pdata->driver_bound = false;

		break;

	default:

		return NOTIFY_DONE;

	}



	complete(&pdata->probe_completion);

	return NOTIFY_OK;

}



void dev_sync_probe_init(struct dev_sync_probe_data *data)

{

	memset(data, 0, sizeof(*data));

	init_completion(&data->probe_completion);

	data->bus_notifier.notifier_call = dev_sync_probe_notifier_call;

}

EXPORT_SYMBOL_GPL(dev_sync_probe_init);



int dev_sync_probe_register(struct dev_sync_probe_data *data,

			    struct platform_device_info *pdevinfo)

{

	struct platform_device *pdev;

	char *name;



	name = kasprintf(GFP_KERNEL, "%s.%d", pdevinfo->name, pdevinfo->id);

	if (!name)

		return -ENOMEM;



	data->driver_bound = false;

	data->name = name;

	reinit_completion(&data->probe_completion);

	bus_register_notifier(&platform_bus_type, &data->bus_notifier);



	pdev = platform_device_register_full(pdevinfo);

	if (IS_ERR(pdev)) {

		bus_unregister_notifier(&platform_bus_type, &data->bus_notifier);

		kfree(data->name);

		return PTR_ERR(pdev);

	}



	wait_for_completion(&data->probe_completion);

	bus_unregister_notifier(&platform_bus_type, &data->bus_notifier);



	if (!data->driver_bound) {

		platform_device_unregister(pdev);

		kfree(data->name);

		return -ENXIO;

	}



	data->pdev = pdev;

	return 0;

}

EXPORT_SYMBOL_GPL(dev_sync_probe_register);



void dev_sync_probe_unregister(struct dev_sync_probe_data *data)

{

	platform_device_unregister(data->pdev);

	kfree(data->name);

	data->pdev = NULL;

}

EXPORT_SYMBOL_GPL(dev_sync_probe_unregister);



MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>");

MODULE_AUTHOR("Koichiro Den <koichiro.den@canonical.com>");

MODULE_DESCRIPTION("Utilities for synchronous fake device creation");

MODULE_LICENSE("GPL");

drivers/gpio/dev-sync-probe.h

0 → 100644
+25 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */



#ifndef DEV_SYNC_PROBE_H

#define DEV_SYNC_PROBE_H



#include <linux/completion.h>

#include <linux/notifier.h>

#include <linux/platform_device.h>



struct dev_sync_probe_data {

	struct platform_device *pdev;

	const char *name;



	/* Synchronize with probe */

	struct notifier_block bus_notifier;

	struct completion probe_completion;

	bool driver_bound;

};



void dev_sync_probe_init(struct dev_sync_probe_data *data);

int dev_sync_probe_register(struct dev_sync_probe_data *data,

			    struct platform_device_info *pdevinfo);

void dev_sync_probe_unregister(struct dev_sync_probe_data *data);



#endif /* DEV_SYNC_PROBE_H */