path: root/drivers/base/test/swnode-devlink-test.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) Qualcomm Technologies, Inc. and/or its subsidiaries
 */

#include <linux/array_size.h>
#include <linux/device.h>
#include <linux/fwnode.h>
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/time.h>
#include <linux/types.h>
#include <linux/wait.h>

#include <kunit/fwnode.h>
#include <kunit/platform_device.h>
#include <kunit/test.h>

static int swnode_count_suppliers(struct fwnode_handle *fwnode)
{
	struct fwnode_link *link;
	unsigned int count = 0;

	/*
	 * The suppliers and consumers lists should typically only be accessed
	 * with the fwnode_link_lock taken but it's private to the driver core.
	 *
	 * These are tests and at this point nobody should be modifying them so
	 * let's just access the list.
	 */
	list_for_each_entry(link, &fwnode->suppliers, c_hook)
		count++;

	return count;
}

/* True if a supplier link con->sup exists, checked from both list ends. */
static bool swnode_has_link(struct fwnode_handle *consumer,
			    struct fwnode_handle *supplier)
{
	bool from_con = false, from_sup = false;
	struct fwnode_link *link;

	list_for_each_entry(link, &consumer->suppliers, c_hook) {
		if (link->supplier == supplier && link->consumer == consumer)
			from_con = true;
	}

	list_for_each_entry(link, &supplier->consumers, s_hook) {
		if (link->supplier == supplier && link->consumer == consumer)
			from_sup = true;
	}

	return from_con && from_sup;
}

/* A single reference creates exactly one supplier link, on both list ends. */
static void swnode_devlink_test_single_ref(struct kunit *test)
{
	static const struct software_node supp_swnode = {
		.name = "swnode-devlink-test-supplier",
	};

	struct fwnode_handle *cons_fwnode, *supp_fwnode;
	int ret;

	const struct property_entry props[] = {
		PROPERTY_ENTRY_REF("supplier", &supp_swnode),
		{ }
	};

	supp_fwnode = kunit_software_node_register(test, &supp_swnode);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, supp_fwnode);

	cons_fwnode = kunit_fwnode_create_software_node(test, props, NULL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cons_fwnode);

	ret = fwnode_call_int_op(cons_fwnode, add_links);
	KUNIT_EXPECT_EQ(test, ret, 0);

	KUNIT_EXPECT_EQ(test, swnode_count_suppliers(cons_fwnode), 1);
	KUNIT_EXPECT_TRUE(test, swnode_has_link(cons_fwnode, supp_fwnode));
}

/* Multiple distinct references create multiple supplier links. */
static void swnode_devlink_test_multiple_refs(struct kunit *test)
{
	static const struct software_node supp1_swnode = {
		.name = "swnode-devlink-test-supplier-1",
	};
	static const struct software_node supp2_swnode = {
		.name = "swnode-devlink-test-supplier-2",
	};
	static const struct software_node *supp_nodes[] = {
		&supp1_swnode, &supp2_swnode, NULL
	};

	const struct property_entry props[] = {
		PROPERTY_ENTRY_REF("foo", &supp1_swnode),
		PROPERTY_ENTRY_REF("bar", &supp2_swnode),
		{ }
	};

	struct fwnode_handle *fwnode;
	int ret;

	ret = kunit_software_node_register_node_group(test, supp_nodes);
	KUNIT_ASSERT_EQ(test, ret, 0);

	fwnode = kunit_fwnode_create_software_node(test, props, NULL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fwnode);

	ret = fwnode_call_int_op(fwnode, add_links);
	KUNIT_EXPECT_EQ(test, ret, 0);

	KUNIT_EXPECT_EQ(test, swnode_count_suppliers(fwnode), 2);
	KUNIT_EXPECT_TRUE(test, swnode_has_link(fwnode, software_node_fwnode(&supp1_swnode)));
	KUNIT_EXPECT_TRUE(test, swnode_has_link(fwnode, software_node_fwnode(&supp2_swnode)));
}

/* A reference to an unregistered node creates no link (graceful skip). */
static void swnode_devlink_test_unregistered_ref(struct kunit *test)
{
	static const struct software_node supp_swnode = {
		.name = "swnode-devlink-test-supplier",
	};

	const struct property_entry props[] = {
		PROPERTY_ENTRY_REF("supplier", &supp_swnode),
		{ }
	};

	struct fwnode_handle *fwnode;
	int ret;

	fwnode = kunit_fwnode_create_software_node(test, props, NULL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fwnode);

	ret = fwnode_call_int_op(fwnode, add_links);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_EQ(test, swnode_count_suppliers(fwnode), 0);
}

/* Graph "remote-endpoint" references are excluded. */
static void swnode_devlink_test_remote_endpoint_excluded(struct kunit *test)
{
	static const struct software_node ep_swnode = {
		.name = "swnode-devlink-test-end-point"
	};

	const struct property_entry props[] = {
		PROPERTY_ENTRY_REF("remote-endpoint", &ep_swnode),
		{ }
	};

	struct fwnode_handle *cons_fwnode, *supp_fwnode;
	int ret;

	supp_fwnode = kunit_software_node_register(test, &ep_swnode);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, supp_fwnode);

	cons_fwnode = kunit_fwnode_create_software_node(test, props, NULL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cons_fwnode);

	ret = fwnode_call_int_op(cons_fwnode, add_links);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_EQ(test, swnode_count_suppliers(cons_fwnode), 0);
}

/* A reference array creates one link per registered element. */
static void swnode_devlink_test_ref_array(struct kunit *test)
{
	static const struct software_node supp1_swnode = {
		.name = "swnode-devlink-test-supplier-1",
	};
	static const struct software_node supp2_swnode = {
		.name = "swnode-devlink-test-supplier-2",
	};
	static const struct software_node *supp_nodes[] = {
		&supp1_swnode, &supp2_swnode, NULL
	};
	static const struct software_node_ref_args refs[] = {
		SOFTWARE_NODE_REFERENCE(&supp1_swnode),
		SOFTWARE_NODE_REFERENCE(&supp2_swnode, 4, 2),
	};

	const struct property_entry props[] = {
		PROPERTY_ENTRY_REF_ARRAY("suppliers", refs),
		{ }
	};

	struct fwnode_handle *fwnode;
	int ret;

	ret = kunit_software_node_register_node_group(test, supp_nodes);
	KUNIT_ASSERT_EQ(test, ret, 0);

	fwnode = kunit_fwnode_create_software_node(test, props, NULL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fwnode);

	ret = fwnode_call_int_op(fwnode, add_links);
	KUNIT_EXPECT_EQ(test, ret, 0);

	KUNIT_EXPECT_EQ(test, swnode_count_suppliers(fwnode), 2);
	KUNIT_EXPECT_TRUE(test, swnode_has_link(fwnode, software_node_fwnode(&supp1_swnode)));
	KUNIT_EXPECT_TRUE(test, swnode_has_link(fwnode, software_node_fwnode(&supp2_swnode)));
}

/*
 * End-to-end test: fw_devlink must defer a consumer's probe until its
 * supplier has probed.
 *
 * The reference created by software_node_add_links() is only useful if the
 * driver core promotes it to a real device_link and uses it to order probing.
 * This test drives actual probing through the platform bus and asserts the
 * supplier binds before the consumer.
 */

#define SWNODE_DEVLINK_TEST_SUPPLIER	"swnode-link-supplier"
#define SWNODE_DEVLINK_TEST_CONSUMER	"swnode-link-consumer"
#define SWNODE_DEVLINK_TEST_TIMEOUT_MS	(2 * MSEC_PER_SEC)

struct swnode_test_probe_order {
	/* Names in the order their drivers' .probe ran. */
	const char *probed[2];
	unsigned int count;
	wait_queue_head_t wq;
};

static int swnode_test_record_probe(struct platform_device *pdev)
{
	struct swnode_test_probe_order *order = platform_get_drvdata(pdev);

	if (order && order->count < ARRAY_SIZE(order->probed)) {
		order->probed[order->count++] = dev_name(&pdev->dev);
		wake_up_interruptible(&order->wq);
	}

	return 0;
}

static struct platform_driver swnode_test_supplier_driver = {
	.probe = swnode_test_record_probe,
	.driver = {
		.name = SWNODE_DEVLINK_TEST_SUPPLIER,
	},
};

static struct platform_driver swnode_test_consumer_driver = {
	.probe = swnode_test_record_probe,
	.driver = {
		.name = SWNODE_DEVLINK_TEST_CONSUMER,
	},
};

static void swnode_devlink_test_probe_order(struct kunit *test)
{
	static const struct software_node supplier_swnode = {
		.name = "swnode-devlink-test-supplier",
	};

	const struct property_entry consumer_props[] = {
		PROPERTY_ENTRY_REF("supplier-ref", &supplier_swnode),
		{ }
	};

	struct platform_device *supplier, *consumer;
	struct swnode_test_probe_order *order;
	struct fwnode_handle *fwnode;
	int ret;

	order = kunit_kzalloc(test, sizeof(*order), GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, order);
	init_waitqueue_head(&order->wq);

	fwnode = kunit_software_node_register(test, &supplier_swnode);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fwnode);

	ret = kunit_platform_driver_register(test, &swnode_test_supplier_driver);
	KUNIT_ASSERT_EQ(test, ret, 0);
	ret = kunit_platform_driver_register(test, &swnode_test_consumer_driver);
	KUNIT_ASSERT_EQ(test, ret, 0);

	supplier = kunit_platform_device_alloc(test, SWNODE_DEVLINK_TEST_SUPPLIER,
					       PLATFORM_DEVID_NONE);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, supplier);
	consumer = kunit_platform_device_alloc(test, SWNODE_DEVLINK_TEST_CONSUMER,
					       PLATFORM_DEVID_NONE);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, consumer);

	platform_set_drvdata(supplier, order);
	platform_set_drvdata(consumer, order);

	ret = kunit_device_add_software_node(test, &supplier->dev, &supplier_swnode);
	KUNIT_ASSERT_EQ(test, ret, 0);
	ret = device_create_managed_software_node(&consumer->dev,
						  consumer_props, NULL);
	KUNIT_ASSERT_EQ(test, ret, 0);

	ret = kunit_platform_device_add(test, consumer);
	KUNIT_ASSERT_EQ(test, ret, 0);
	ret = kunit_platform_device_add(test, supplier);
	KUNIT_ASSERT_EQ(test, ret, 0);

	ret = wait_event_interruptible_timeout(order->wq,
					       order->count == 2,
					       msecs_to_jiffies(SWNODE_DEVLINK_TEST_TIMEOUT_MS));
	KUNIT_ASSERT_GT(test, ret, 0);

	KUNIT_EXPECT_STREQ(test, order->probed[0], SWNODE_DEVLINK_TEST_SUPPLIER);
	KUNIT_EXPECT_STREQ(test, order->probed[1], SWNODE_DEVLINK_TEST_CONSUMER);

	/* Tear down the consumer (and its device link) before the supplier. */
	kunit_platform_device_unregister(test, consumer);
}

static struct kunit_case swnode_test_cases[] = {
	KUNIT_CASE(swnode_devlink_test_single_ref),
	KUNIT_CASE(swnode_devlink_test_multiple_refs),
	KUNIT_CASE(swnode_devlink_test_unregistered_ref),
	KUNIT_CASE(swnode_devlink_test_remote_endpoint_excluded),
	KUNIT_CASE(swnode_devlink_test_ref_array),
	KUNIT_CASE(swnode_devlink_test_probe_order),
	{ }
};

static struct kunit_suite swnode_test_suite = {
	.name = "software-node-links",
	.test_cases = swnode_test_cases,
};

kunit_test_suite(swnode_test_suite);

MODULE_DESCRIPTION("Test module for software node fw_devlink support");
MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>");
MODULE_LICENSE("GPL");