1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * KUnit test for KUnit platform driver infrastructure.
  4 */
  5
  6#include <linux/platform_device.h>
  7
  8#include <kunit/platform_device.h>
  9#include <kunit/test.h>
 10
 11/*
 12 * Test that kunit_platform_device_alloc() creates a platform device.
 13 */
 14static void kunit_platform_device_alloc_test(struct kunit *test)
 15{
 16	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
 17			kunit_platform_device_alloc(test, "kunit-platform", 1));
 18}
 19
 20/*
 21 * Test that kunit_platform_device_add() registers a platform device on the
 22 * platform bus with the proper name and id.
 23 */
 24static void kunit_platform_device_add_test(struct kunit *test)
 25{
 26	struct platform_device *pdev;
 27	const char *name = "kunit-platform-add";
 28	const int id = -1;
 29
 30	pdev = kunit_platform_device_alloc(test, name, id);
 31	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
 32
 33	KUNIT_EXPECT_EQ(test, 0, kunit_platform_device_add(test, pdev));
 34	KUNIT_EXPECT_TRUE(test, dev_is_platform(&pdev->dev));
 35	KUNIT_EXPECT_STREQ(test, pdev->name, name);
 36	KUNIT_EXPECT_EQ(test, pdev->id, id);
 37}
 38
 39/*
 40 * Test that kunit_platform_device_add() called twice with the same device name
 41 * and id fails the second time and properly cleans up.
 42 */
 43static void kunit_platform_device_add_twice_fails_test(struct kunit *test)
 44{
 45	struct platform_device *pdev;
 46	const char *name = "kunit-platform-add-2";
 47	const int id = -1;
 48
 49	pdev = kunit_platform_device_alloc(test, name, id);
 50	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
 51	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));
 52
 53	pdev = kunit_platform_device_alloc(test, name, id);
 54	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
 55
 56	KUNIT_EXPECT_NE(test, 0, kunit_platform_device_add(test, pdev));
 57}
 58
 59static int kunit_platform_device_find_by_name(struct device *dev, const void *data)
 60{
 61	return strcmp(dev_name(dev), data) == 0;
 62}
 63
 64/*
 65 * Test that kunit_platform_device_add() cleans up by removing the platform
 66 * device when the test finishes. */
 67static void kunit_platform_device_add_cleans_up(struct kunit *test)
 68{
 69	struct platform_device *pdev;
 70	const char *name = "kunit-platform-clean";
 71	const int id = -1;
 72	struct kunit fake;
 73	struct device *dev;
 74
 75	kunit_init_test(&fake, "kunit_platform_device_add_fake_test", NULL);
 76	KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS);
 77
 78	pdev = kunit_platform_device_alloc(&fake, name, id);
 79	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
 80	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(&fake, pdev));
 81	dev = bus_find_device(&platform_bus_type, NULL, name,
 82			      kunit_platform_device_find_by_name);
 83	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 84	put_device(dev);
 85
 86	/* Remove pdev */
 87	kunit_cleanup(&fake);
 88
 89	/*
 90	 * Failing to migrate the kunit_resource would lead to an extra
 91	 * put_device() call on the platform device. The best we can do here is
 92	 * make sure the device no longer exists on the bus, but if something
 93	 * is wrong we'll see a refcount underflow here. We can't test for a
 94	 * refcount underflow because the kref matches the lifetime of the
 95	 * device which should already be freed and could be used by something
 96	 * else.
 97	 */
 98	dev = bus_find_device(&platform_bus_type, NULL, name,
 99			      kunit_platform_device_find_by_name);
100	KUNIT_EXPECT_PTR_EQ(test, NULL, dev);
101	put_device(dev);
102}
103
104/*
105 * Test suite for struct platform_device kunit APIs
106 */
107static struct kunit_case kunit_platform_device_test_cases[] = {
108	KUNIT_CASE(kunit_platform_device_alloc_test),
109	KUNIT_CASE(kunit_platform_device_add_test),
110	KUNIT_CASE(kunit_platform_device_add_twice_fails_test),
111	KUNIT_CASE(kunit_platform_device_add_cleans_up),
112	{}
113};
114
115static struct kunit_suite kunit_platform_device_suite = {
116	.name = "kunit_platform_device",
117	.test_cases = kunit_platform_device_test_cases,
118};
119
120struct kunit_platform_driver_test_context {
121	struct platform_driver pdrv;
122	const char *data;
123};
124
125static const char * const test_data = "test data";
126
127static inline struct kunit_platform_driver_test_context *
128to_test_context(struct platform_device *pdev)
129{
130	return container_of(to_platform_driver(pdev->dev.driver),
131			    struct kunit_platform_driver_test_context,
132			    pdrv);
133}
134
135static int kunit_platform_driver_probe(struct platform_device *pdev)
136{
137	struct kunit_platform_driver_test_context *ctx;
138
139	ctx = to_test_context(pdev);
140	ctx->data = test_data;
141
142	return 0;
143}
144
145/* Test that kunit_platform_driver_register() registers a driver that probes. */
146static void kunit_platform_driver_register_test(struct kunit *test)
147{
148	struct platform_device *pdev;
149	struct kunit_platform_driver_test_context *ctx;
150	DECLARE_COMPLETION_ONSTACK(comp);
151	const char *name = "kunit-platform-register";
152
153	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
154	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
155
156	pdev = kunit_platform_device_alloc(test, name, -1);
157	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
158	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));
159
160	ctx->pdrv.probe = kunit_platform_driver_probe;
161	ctx->pdrv.driver.name = name;
162	ctx->pdrv.driver.owner = THIS_MODULE;
163
164	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));
165
166	KUNIT_EXPECT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));
167	KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));
168	KUNIT_EXPECT_STREQ(test, ctx->data, test_data);
169}
170
171/*
172 * Test that kunit_platform_device_prepare_wait_for_probe() completes the completion
173 * when the device is already probed.
174 */
175static void kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed(struct kunit *test)
176{
177	struct platform_device *pdev;
178	struct kunit_platform_driver_test_context *ctx;
179	DECLARE_COMPLETION_ONSTACK(comp);
180	const char *name = "kunit-platform-wait";
181
182	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
183	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
184
185	pdev = kunit_platform_device_alloc(test, name, -1);
186	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
187	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));
188
189	ctx->pdrv.probe = kunit_platform_driver_probe;
190	ctx->pdrv.driver.name = name;
191	ctx->pdrv.driver.owner = THIS_MODULE;
192
193	/* Make sure driver has actually probed */
194	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));
195	KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));
196	KUNIT_ASSERT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));
197
198	reinit_completion(&comp);
199	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));
200
201	KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, HZ));
202}
203
204static struct kunit_case kunit_platform_driver_test_cases[] = {
205	KUNIT_CASE(kunit_platform_driver_register_test),
206	KUNIT_CASE(kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed),
207	{}
208};
209
210/*
211 * Test suite for struct platform_driver kunit APIs
212 */
213static struct kunit_suite kunit_platform_driver_suite = {
214	.name = "kunit_platform_driver",
215	.test_cases = kunit_platform_driver_test_cases,
216};
217
218kunit_test_suites(
219	&kunit_platform_device_suite,
220	&kunit_platform_driver_suite,
221);
222
223MODULE_LICENSE("GPL");
224MODULE_DESCRIPTION("KUnit test for KUnit platform driver infrastructure");