lib/kunit/platform-test.c

   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  */
  14 static 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  */
  24 static 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  */
  43 static 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
  59 static 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. */
  67 static 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  */
 107 static 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
 115 static struct kunit_suite kunit_platform_device_suite = {
 116         .name = "kunit_platform_device",
 117         .test_cases = kunit_platform_device_test_cases,
 118 };
 119
 120 struct kunit_platform_driver_test_context {
 121         struct platform_driver pdrv;
 122         const char *data;
 123 };
 124
 125 static const char * const test_data = "test data";
 126
 127 static inline struct kunit_platform_driver_test_context *
 128 to_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
 135 static 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. */
 146 static 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  */
 175 static 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
 204 static 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  */
 213 static struct kunit_suite kunit_platform_driver_suite = {
 214         .name = "kunit_platform_driver",
 215         .test_cases = kunit_platform_driver_test_cases,
 216 };
 217
 218 kunit_test_suites(
 219         &kunit_platform_device_suite,
 220         &kunit_platform_driver_suite,
 221 );
 222
 223 MODULE_LICENSE("GPL");
 224 MODULE_DESCRIPTION("KUnit test for KUnit platform driver infrastructure");