scmi.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260
  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 <power/regulator.h>
  23. #include <test/ut.h>
  24. static int ut_assert_scmi_state_preprobe(struct unit_test_state *uts)
  25. {
  26. struct sandbox_scmi_service *scmi_ctx = sandbox_scmi_service_ctx();
  27. ut_assertnonnull(scmi_ctx);
  28. if (scmi_ctx->agent_count)
  29. ut_asserteq(2, scmi_ctx->agent_count);
  30. return 0;
  31. }
  32. static int ut_assert_scmi_state_postprobe(struct unit_test_state *uts,
  33. struct udevice *dev)
  34. {
  35. struct sandbox_scmi_devices *scmi_devices;
  36. struct sandbox_scmi_service *scmi_ctx;
  37. struct sandbox_scmi_agent *agent0;
  38. struct sandbox_scmi_agent *agent1;
  39. /* Device references to check context against test sequence */
  40. scmi_devices = sandbox_scmi_devices_ctx(dev);
  41. ut_assertnonnull(scmi_devices);
  42. ut_asserteq(3, scmi_devices->clk_count);
  43. ut_asserteq(1, scmi_devices->reset_count);
  44. ut_asserteq(2, scmi_devices->regul_count);
  45. /* State of the simulated SCMI server exposed */
  46. scmi_ctx = sandbox_scmi_service_ctx();
  47. agent0 = scmi_ctx->agent[0];
  48. agent1 = scmi_ctx->agent[1];
  49. ut_asserteq(2, scmi_ctx->agent_count);
  50. ut_assertnonnull(agent0);
  51. ut_asserteq(2, agent0->clk_count);
  52. ut_assertnonnull(agent0->clk);
  53. ut_asserteq(1, agent0->reset_count);
  54. ut_assertnonnull(agent0->reset);
  55. ut_asserteq(2, agent0->voltd_count);
  56. ut_assertnonnull(agent0->voltd);
  57. ut_assertnonnull(agent1);
  58. ut_assertnonnull(agent1->clk);
  59. ut_asserteq(1, agent1->clk_count);
  60. return 0;
  61. }
  62. static int load_sandbox_scmi_test_devices(struct unit_test_state *uts,
  63. struct udevice **dev)
  64. {
  65. int ret;
  66. ret = ut_assert_scmi_state_preprobe(uts);
  67. if (ret)
  68. return ret;
  69. ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_scmi",
  70. dev));
  71. ut_assertnonnull(*dev);
  72. return ut_assert_scmi_state_postprobe(uts, *dev);
  73. }
  74. static int release_sandbox_scmi_test_devices(struct unit_test_state *uts,
  75. struct udevice *dev)
  76. {
  77. ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
  78. /* Not sure test devices are fully removed, agent may not be visible */
  79. return 0;
  80. }
  81. /*
  82. * Test SCMI states when loading and releasing resources
  83. * related to SCMI drivers.
  84. */
  85. static int dm_test_scmi_sandbox_agent(struct unit_test_state *uts)
  86. {
  87. struct udevice *dev = NULL;
  88. int ret;
  89. ret = load_sandbox_scmi_test_devices(uts, &dev);
  90. if (!ret)
  91. ret = release_sandbox_scmi_test_devices(uts, dev);
  92. return ret;
  93. }
  94. DM_TEST(dm_test_scmi_sandbox_agent, UT_TESTF_SCAN_FDT);
  95. static int dm_test_scmi_clocks(struct unit_test_state *uts)
  96. {
  97. struct sandbox_scmi_devices *scmi_devices;
  98. struct sandbox_scmi_service *scmi_ctx;
  99. struct sandbox_scmi_agent *agent0;
  100. struct sandbox_scmi_agent *agent1;
  101. struct udevice *dev = NULL;
  102. int ret_dev;
  103. int ret;
  104. ret = load_sandbox_scmi_test_devices(uts, &dev);
  105. if (ret)
  106. return ret;
  107. scmi_devices = sandbox_scmi_devices_ctx(dev);
  108. scmi_ctx = sandbox_scmi_service_ctx();
  109. agent0 = scmi_ctx->agent[0];
  110. agent1 = scmi_ctx->agent[1];
  111. /* Test SCMI clocks rate manipulation */
  112. ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
  113. ut_asserteq(333, clk_get_rate(&scmi_devices->clk[1]));
  114. ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
  115. ret_dev = clk_set_rate(&scmi_devices->clk[1], 1088);
  116. ut_assert(!ret_dev || ret_dev == 1088);
  117. ut_asserteq(1000, agent0->clk[0].rate);
  118. ut_asserteq(1088, agent0->clk[1].rate);
  119. ut_asserteq(44, agent1->clk[0].rate);
  120. ut_asserteq(1000, clk_get_rate(&scmi_devices->clk[0]));
  121. ut_asserteq(1088, clk_get_rate(&scmi_devices->clk[1]));
  122. ut_asserteq(44, clk_get_rate(&scmi_devices->clk[2]));
  123. /* restore original rate for further tests */
  124. ret_dev = clk_set_rate(&scmi_devices->clk[1], 333);
  125. ut_assert(!ret_dev || ret_dev == 333);
  126. /* Test SCMI clocks gating manipulation */
  127. ut_assert(!agent0->clk[0].enabled);
  128. ut_assert(!agent0->clk[1].enabled);
  129. ut_assert(!agent1->clk[0].enabled);
  130. ut_asserteq(0, clk_enable(&scmi_devices->clk[1]));
  131. ut_asserteq(0, clk_enable(&scmi_devices->clk[2]));
  132. ut_assert(!agent0->clk[0].enabled);
  133. ut_assert(agent0->clk[1].enabled);
  134. ut_assert(agent1->clk[0].enabled);
  135. ut_assertok(clk_disable(&scmi_devices->clk[1]));
  136. ut_assertok(clk_disable(&scmi_devices->clk[2]));
  137. ut_assert(!agent0->clk[0].enabled);
  138. ut_assert(!agent0->clk[1].enabled);
  139. ut_assert(!agent1->clk[0].enabled);
  140. return release_sandbox_scmi_test_devices(uts, dev);
  141. }
  142. DM_TEST(dm_test_scmi_clocks, UT_TESTF_SCAN_FDT);
  143. static int dm_test_scmi_resets(struct unit_test_state *uts)
  144. {
  145. struct sandbox_scmi_devices *scmi_devices;
  146. struct sandbox_scmi_service *scmi_ctx;
  147. struct sandbox_scmi_agent *agent0;
  148. struct udevice *dev = NULL;
  149. int ret;
  150. ret = load_sandbox_scmi_test_devices(uts, &dev);
  151. if (ret)
  152. return ret;
  153. scmi_devices = sandbox_scmi_devices_ctx(dev);
  154. scmi_ctx = sandbox_scmi_service_ctx();
  155. agent0 = scmi_ctx->agent[0];
  156. /* Test SCMI resect controller manipulation */
  157. ut_assert(!agent0->reset[0].asserted)
  158. ut_assertok(reset_assert(&scmi_devices->reset[0]));
  159. ut_assert(agent0->reset[0].asserted)
  160. ut_assertok(reset_deassert(&scmi_devices->reset[0]));
  161. ut_assert(!agent0->reset[0].asserted);
  162. return release_sandbox_scmi_test_devices(uts, dev);
  163. }
  164. DM_TEST(dm_test_scmi_resets, UT_TESTF_SCAN_FDT);
  165. static int dm_test_scmi_voltage_domains(struct unit_test_state *uts)
  166. {
  167. struct sandbox_scmi_devices *scmi_devices;
  168. struct sandbox_scmi_service *scmi_ctx;
  169. struct sandbox_scmi_agent *agent0;
  170. struct dm_regulator_uclass_plat *uc_pdata;
  171. struct udevice *dev;
  172. struct udevice *regul0_dev;
  173. ut_assertok(load_sandbox_scmi_test_devices(uts, &dev));
  174. scmi_devices = sandbox_scmi_devices_ctx(dev);
  175. scmi_ctx = sandbox_scmi_service_ctx();
  176. agent0 = scmi_ctx->agent[0];
  177. /* Set/Get an SCMI voltage domain level */
  178. regul0_dev = scmi_devices->regul[0];
  179. ut_assert(regul0_dev);
  180. uc_pdata = dev_get_uclass_plat(regul0_dev);
  181. ut_assert(uc_pdata);
  182. ut_assertok(regulator_set_value(regul0_dev, uc_pdata->min_uV));
  183. ut_asserteq(agent0->voltd[0].voltage_uv, uc_pdata->min_uV);
  184. ut_assert(regulator_get_value(regul0_dev) == uc_pdata->min_uV);
  185. ut_assertok(regulator_set_value(regul0_dev, uc_pdata->max_uV));
  186. ut_asserteq(agent0->voltd[0].voltage_uv, uc_pdata->max_uV);
  187. ut_assert(regulator_get_value(regul0_dev) == uc_pdata->max_uV);
  188. /* Enable/disable SCMI voltage domains */
  189. ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
  190. ut_assertok(regulator_set_enable(scmi_devices->regul[1], false));
  191. ut_assert(!agent0->voltd[0].enabled);
  192. ut_assert(!agent0->voltd[1].enabled);
  193. ut_assertok(regulator_set_enable(scmi_devices->regul[0], true));
  194. ut_assert(agent0->voltd[0].enabled);
  195. ut_assert(!agent0->voltd[1].enabled);
  196. ut_assertok(regulator_set_enable(scmi_devices->regul[1], true));
  197. ut_assert(agent0->voltd[0].enabled);
  198. ut_assert(agent0->voltd[1].enabled);
  199. ut_assertok(regulator_set_enable(scmi_devices->regul[0], false));
  200. ut_assert(!agent0->voltd[0].enabled);
  201. ut_assert(agent0->voltd[1].enabled);
  202. return release_sandbox_scmi_test_devices(uts, dev);
  203. }
  204. DM_TEST(dm_test_scmi_voltage_domains, UT_TESTF_SCAN_FDT);