test-driver.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2013 Google, Inc
  4. *
  5. * (C) Copyright 2012
  6. * Pavel Herrmann <morpheus.ibis@gmail.com>
  7. */
  8. #include <common.h>
  9. #include <dm.h>
  10. #include <errno.h>
  11. #include <log.h>
  12. #include <malloc.h>
  13. #include <asm/io.h>
  14. #include <dm/device-internal.h>
  15. #include <dm/test.h>
  16. #include <test/test.h>
  17. #include <test/ut.h>
  18. int dm_testdrv_op_count[DM_TEST_OP_COUNT];
  19. static int testdrv_ping(struct udevice *dev, int pingval, int *pingret)
  20. {
  21. const struct dm_test_pdata *pdata = dev_get_plat(dev);
  22. struct dm_test_priv *priv = dev_get_priv(dev);
  23. *pingret = pingval + pdata->ping_add;
  24. priv->ping_total += *pingret;
  25. return 0;
  26. }
  27. static const struct test_ops test_ops = {
  28. .ping = testdrv_ping,
  29. };
  30. static int test_bind(struct udevice *dev)
  31. {
  32. struct unit_test_state *uts = test_get_state();
  33. /* Private data should not be allocated */
  34. ut_assert(!dev_get_priv(dev));
  35. dm_testdrv_op_count[DM_TEST_OP_BIND]++;
  36. return 0;
  37. }
  38. static int test_probe(struct udevice *dev)
  39. {
  40. struct unit_test_state *uts = test_get_state();
  41. struct dm_test_priv *priv = dev_get_priv(dev);
  42. /* Private data should be allocated */
  43. ut_assert(priv);
  44. dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
  45. priv->ping_total += DM_TEST_START_TOTAL;
  46. return 0;
  47. }
  48. static int test_remove(struct udevice *dev)
  49. {
  50. struct unit_test_state *uts = test_get_state();
  51. /* Private data should still be allocated */
  52. ut_assert(dev_get_priv(dev));
  53. dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
  54. return 0;
  55. }
  56. static int test_unbind(struct udevice *dev)
  57. {
  58. struct unit_test_state *uts = test_get_state();
  59. /* Private data should not be allocated */
  60. ut_assert(!dev_get_priv(dev));
  61. dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
  62. return 0;
  63. }
  64. U_BOOT_DRIVER(test_drv) = {
  65. .name = "test_drv",
  66. .id = UCLASS_TEST,
  67. .ops = &test_ops,
  68. .bind = test_bind,
  69. .probe = test_probe,
  70. .remove = test_remove,
  71. .unbind = test_unbind,
  72. .priv_auto = sizeof(struct dm_test_priv),
  73. };
  74. U_BOOT_DRIVER(test2_drv) = {
  75. .name = "test2_drv",
  76. .id = UCLASS_TEST,
  77. .ops = &test_ops,
  78. .bind = test_bind,
  79. .probe = test_probe,
  80. .remove = test_remove,
  81. .unbind = test_unbind,
  82. .priv_auto = sizeof(struct dm_test_priv),
  83. };
  84. static int test_manual_drv_ping(struct udevice *dev, int pingval, int *pingret)
  85. {
  86. *pingret = pingval + 2;
  87. return 0;
  88. }
  89. static const struct test_ops test_manual_ops = {
  90. .ping = test_manual_drv_ping,
  91. };
  92. static int test_manual_bind(struct udevice *dev)
  93. {
  94. dm_testdrv_op_count[DM_TEST_OP_BIND]++;
  95. return 0;
  96. }
  97. static int test_manual_probe(struct udevice *dev)
  98. {
  99. struct unit_test_state *uts = test_get_state();
  100. dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
  101. if (!uts->force_fail_alloc)
  102. dev_set_priv(dev, calloc(1, sizeof(struct dm_test_priv)));
  103. if (!dev_get_priv(dev))
  104. return -ENOMEM;
  105. return 0;
  106. }
  107. static int test_manual_remove(struct udevice *dev)
  108. {
  109. dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
  110. return 0;
  111. }
  112. static int test_manual_unbind(struct udevice *dev)
  113. {
  114. dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
  115. return 0;
  116. }
  117. U_BOOT_DRIVER(test_manual_drv) = {
  118. .name = "test_manual_drv",
  119. .id = UCLASS_TEST,
  120. .ops = &test_manual_ops,
  121. .bind = test_manual_bind,
  122. .probe = test_manual_probe,
  123. .remove = test_manual_remove,
  124. .unbind = test_manual_unbind,
  125. };
  126. U_BOOT_DRIVER(test_pre_reloc_drv) = {
  127. .name = "test_pre_reloc_drv",
  128. .id = UCLASS_TEST,
  129. .ops = &test_manual_ops,
  130. .bind = test_manual_bind,
  131. .probe = test_manual_probe,
  132. .remove = test_manual_remove,
  133. .unbind = test_manual_unbind,
  134. .flags = DM_FLAG_PRE_RELOC,
  135. };
  136. U_BOOT_DRIVER(test_act_dma_drv) = {
  137. .name = "test_act_dma_drv",
  138. .id = UCLASS_TEST,
  139. .ops = &test_manual_ops,
  140. .bind = test_manual_bind,
  141. .probe = test_manual_probe,
  142. .remove = test_manual_remove,
  143. .unbind = test_manual_unbind,
  144. .flags = DM_FLAG_ACTIVE_DMA,
  145. };
  146. U_BOOT_DRIVER(test_vital_clk_drv) = {
  147. .name = "test_vital_clk_drv",
  148. .id = UCLASS_TEST,
  149. .ops = &test_manual_ops,
  150. .bind = test_manual_bind,
  151. .probe = test_manual_probe,
  152. .remove = test_manual_remove,
  153. .unbind = test_manual_unbind,
  154. .flags = DM_FLAG_VITAL,
  155. };
  156. U_BOOT_DRIVER(test_act_dma_vital_clk_drv) = {
  157. .name = "test_act_dma_vital_clk_drv",
  158. .id = UCLASS_TEST,
  159. .ops = &test_manual_ops,
  160. .bind = test_manual_bind,
  161. .probe = test_manual_probe,
  162. .remove = test_manual_remove,
  163. .unbind = test_manual_unbind,
  164. .flags = DM_FLAG_VITAL | DM_FLAG_ACTIVE_DMA,
  165. };