225 lines · c
1// SPDX-License-Identifier: GPL-2.02/*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 the22 * 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 name41 * 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 platform66 * 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 extra91 * put_device() call on the platform device. The best we can do here is92 * make sure the device no longer exists on the bus, but if something93 * is wrong we'll see a refcount underflow here. We can't test for a94 * refcount underflow because the kref matches the lifetime of the95 * device which should already be freed and could be used by something96 * 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 APIs106 */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 completion173 * 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 APIs212 */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");225