scmi.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2020, Linaro Limited
  4. *
  5. * Tests scmi_agent uclass and the SCMI drivers implemented in other
  6. * uclass devices probe when a SCMI server exposes resources.
  7. *
  8. * Note in test.dts the protocol@10 node in agent 1. Protocol 0x10 is not
  9. * implemented in U-Boot SCMI components but the implementation is exepected
  10. * to not complain on unknown protocol IDs, as long as it is not used. Note
  11. * in test.dts tests that SCMI drivers probing does not fail for such an
  12. * unknown SCMI protocol ID.
  13. */
  14. #include <common.h>
  15. #include <clk.h>
  16. #include <dm.h>
  17. #include <reset.h>
  18. #include <asm/scmi_test.h>
  19. #include <dm/device-internal.h>
  20. #include <dm/test.h>
  21. #include <linux/kconfig.h>
  22. #include <test/ut.h>
  23. static int ut_assert_scmi_state_preprobe(struct unit_test_state *uts)
  24. {
  25. struct sandbox_scmi_service *scmi_ctx = sandbox_scmi_service_ctx();
  26. ut_assertnonnull(scmi_ctx);
  27. if (scmi_ctx->agent_count)
  28. ut_asserteq(2, scmi_ctx->agent_count);
  29. return 0;
  30. }
  31. static int ut_assert_scmi_state_postprobe(struct unit_test_state *uts,
  32. struct udevice *dev)
  33. {
  34. struct sandbox_scmi_devices *scmi_devices;
  35. struct sandbox_scmi_service *scmi_ctx;
  36. /* Device references to check context against test sequence */
  37. scmi_devices = sandbox_scmi_devices_ctx(dev);
  38. ut_assertnonnull(scmi_devices);
  39. if (IS_ENABLED(CONFIG_CLK_SCMI))
  40. ut_asserteq(3, scmi_devices->clk_count);
  41. if (IS_ENABLED(CONFIG_RESET_SCMI))
  42. ut_asserteq(1, scmi_devices->reset_count);
  43. /* State of the simulated SCMI server exposed */
  44. scmi_ctx = sandbox_scmi_service_ctx();
  45. ut_asserteq(2, scmi_ctx->agent_count);
  46. ut_assertnonnull(scmi_ctx->agent[0]);
  47. ut_asserteq(2, scmi_ctx->agent[0]->clk_count);
  48. ut_assertnonnull(scmi_ctx->agent[0]->clk);
  49. ut_asserteq(1, scmi_ctx->agent[0]->reset_count);
  50. ut_assertnonnull(scmi_ctx->agent[0]->reset);
  51. ut_assertnonnull(scmi_ctx->agent[1]);
  52. ut_assertnonnull(scmi_ctx->agent[1]->clk);
  53. ut_asserteq(1, scmi_ctx->agent[1]->clk_count);
  54. return 0;
  55. }
  56. static int load_sandbox_scmi_test_devices(struct unit_test_state *uts,
  57. struct udevice **dev)
  58. {
  59. int ret;
  60. ret = ut_assert_scmi_state_preprobe(uts);
  61. if (ret)
  62. return ret;
  63. ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_scmi",
  64. dev));
  65. ut_assertnonnull(*dev);
  66. return ut_assert_scmi_state_postprobe(uts, *dev);
  67. }
  68. static int release_sandbox_scmi_test_devices(struct unit_test_state *uts,
  69. struct udevice *dev)
  70. {
  71. ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
  72. /* Not sure test devices are fully removed, agent may not be visible */
  73. return 0;
  74. }
  75. /*
  76. * Test SCMI states when loading and releasing resources
  77. * related to SCMI drivers.
  78. */
  79. static int dm_test_scmi_sandbox_agent(struct unit_test_state *uts)
  80. {
  81. struct udevice *dev = NULL;
  82. int ret;
  83. ret = load_sandbox_scmi_test_devices(uts, &dev);
  84. if (!ret)
  85. ret = release_sandbox_scmi_test_devices(uts, dev);
  86. return ret;
  87. }
  88. DM_TEST(dm_test_scmi_sandbox_agent, UT_TESTF_SCAN_FDT);
  89. static int dm_test_scmi_clocks(struct unit_test_state *uts)
  90. {
  91. struct sandbox_scmi_devices *scmi_devices;
  92. struct sandbox_scmi_service *scmi_ctx;
  93. struct udevice *dev = NULL;
  94. int ret_dev;
  95. int ret;
  96. if (!IS_ENABLED(CONFIG_CLK_SCMI))
  97. return 0;
  98. ret = load_sandbox_scmi_test_devices(uts, &dev);
  99. if (ret)
  100. return ret;
  101. scmi_devices = sandbox_scmi_devices_ctx(dev);
  102. scmi_ctx = sandbox_scmi_service_ctx();
  103. /* Test SCMI clocks rate manipulation */
  104. ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
  105. ut_asserteq(333, clk_get_rate(&scmi_devices->clk[1]));
  106. ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
  107. ret_dev = clk_set_rate(&scmi_devices->clk[1], 1088);
  108. ut_assert(!ret_dev || ret_dev == 1088);
  109. ut_asserteq(1000, scmi_ctx->agent[0]->clk[0].rate);
  110. ut_asserteq(1088, scmi_ctx->agent[0]->clk[1].rate);
  111. ut_asserteq(44, scmi_ctx->agent[1]->clk[0].rate);
  112. ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
  113. ut_asserteq(1088, clk_get_rate(&scmi_devices->clk[1]));
  114. ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
  115. /* restore original rate for further tests */
  116. ret_dev = clk_set_rate(&scmi_devices->clk[1], 333);
  117. ut_assert(!ret_dev || ret_dev == 333);
  118. /* Test SCMI clocks gating manipulation */
  119. ut_assert(!scmi_ctx->agent[0]->clk[0].enabled);
  120. ut_assert(!scmi_ctx->agent[0]->clk[1].enabled);
  121. ut_assert(!scmi_ctx->agent[1]->clk[0].enabled);
  122. ut_asserteq(0, clk_enable(&scmi_devices->clk[1]));
  123. ut_asserteq(0, clk_enable(&scmi_devices->clk[2]));
  124. ut_assert(!scmi_ctx->agent[0]->clk[0].enabled);
  125. ut_assert(scmi_ctx->agent[0]->clk[1].enabled);
  126. ut_assert(scmi_ctx->agent[1]->clk[0].enabled);
  127. ut_assertok(clk_disable(&scmi_devices->clk[1]));
  128. ut_assertok(clk_disable(&scmi_devices->clk[2]));
  129. ut_assert(!scmi_ctx->agent[0]->clk[0].enabled);
  130. ut_assert(!scmi_ctx->agent[0]->clk[1].enabled);
  131. ut_assert(!scmi_ctx->agent[1]->clk[0].enabled);
  132. return release_sandbox_scmi_test_devices(uts, dev);
  133. }
  134. DM_TEST(dm_test_scmi_clocks, UT_TESTF_SCAN_FDT);
  135. static int dm_test_scmi_resets(struct unit_test_state *uts)
  136. {
  137. struct sandbox_scmi_devices *scmi_devices;
  138. struct sandbox_scmi_service *scmi_ctx;
  139. struct udevice *dev = NULL;
  140. int ret;
  141. if (!IS_ENABLED(CONFIG_RESET_SCMI))
  142. return 0;
  143. ret = load_sandbox_scmi_test_devices(uts, &dev);
  144. if (ret)
  145. return ret;
  146. scmi_devices = sandbox_scmi_devices_ctx(dev);
  147. scmi_ctx = sandbox_scmi_service_ctx();
  148. /* Test SCMI resect controller manipulation */
  149. ut_assert(!scmi_ctx->agent[0]->reset[0].asserted)
  150. ut_assertok(reset_assert(&scmi_devices->reset[0]));
  151. ut_assert(scmi_ctx->agent[0]->reset[0].asserted)
  152. ut_assertok(reset_deassert(&scmi_devices->reset[0]));
  153. ut_assert(!scmi_ctx->agent[0]->reset[0].asserted);
  154. return release_sandbox_scmi_test_devices(uts, dev);
  155. }
  156. DM_TEST(dm_test_scmi_resets, UT_TESTF_SCAN_FDT);