adc.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Tests for the driver model ADC API
  4. *
  5. * Copyright (c) 2015 Samsung Electronics
  6. * Przemyslaw Marczak <p.marczak@samsung.com>
  7. */
  8. #include <common.h>
  9. #include <adc.h>
  10. #include <dm.h>
  11. #include <dm/root.h>
  12. #include <dm/util.h>
  13. #include <dm/test.h>
  14. #include <errno.h>
  15. #include <fdtdec.h>
  16. #include <power/regulator.h>
  17. #include <power/sandbox_pmic.h>
  18. #include <sandbox-adc.h>
  19. #include <test/test.h>
  20. #include <test/ut.h>
  21. static int dm_test_adc_bind(struct unit_test_state *uts)
  22. {
  23. struct udevice *dev;
  24. unsigned int channel_mask;
  25. ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
  26. ut_asserteq_str(SANDBOX_ADC_DEVNAME, dev->name);
  27. ut_assertok(adc_channel_mask(dev, &channel_mask));
  28. ut_asserteq((1 << SANDBOX_ADC_CHANNELS) - 1, channel_mask);
  29. return 0;
  30. }
  31. DM_TEST(dm_test_adc_bind, UT_TESTF_SCAN_FDT);
  32. static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
  33. {
  34. struct udevice *dev;
  35. ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
  36. ut_asserteq(-EINVAL, adc_start_channel(dev, SANDBOX_ADC_CHANNELS));
  37. return 0;
  38. }
  39. DM_TEST(dm_test_adc_wrong_channel_selection, UT_TESTF_SCAN_FDT);
  40. static int dm_test_adc_supply(struct unit_test_state *uts)
  41. {
  42. struct udevice *supply;
  43. struct udevice *dev;
  44. int uV;
  45. ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
  46. /* Test Vss value - predefined 0 uV */
  47. ut_assertok(adc_vss_value(dev, &uV));
  48. ut_asserteq(SANDBOX_ADC_VSS_VALUE, uV);
  49. /* Test Vdd initial value - buck2 */
  50. ut_assertok(adc_vdd_value(dev, &uV));
  51. ut_asserteq(SANDBOX_BUCK2_INITIAL_EXPECTED_UV, uV);
  52. /* Change Vdd value - buck2 manual preset */
  53. ut_assertok(regulator_get_by_devname(SANDBOX_BUCK2_DEVNAME, &supply));
  54. ut_assertok(regulator_set_value(supply, SANDBOX_BUCK2_SET_UV));
  55. ut_asserteq(SANDBOX_BUCK2_SET_UV, regulator_get_value(supply));
  56. /* Update ADC plat and get new Vdd value */
  57. ut_assertok(adc_vdd_value(dev, &uV));
  58. ut_asserteq(SANDBOX_BUCK2_SET_UV, uV);
  59. /* Disable buck2 and test ADC supply enable function */
  60. ut_assertok(regulator_set_enable(supply, false));
  61. ut_asserteq(false, regulator_get_enable(supply));
  62. /* adc_start_channel() should enable the supply regulator */
  63. ut_assertok(adc_start_channel(dev, 0));
  64. ut_asserteq(true, regulator_get_enable(supply));
  65. return 0;
  66. }
  67. DM_TEST(dm_test_adc_supply, UT_TESTF_SCAN_FDT);
  68. struct adc_channel adc_channel_test_data[] = {
  69. { 0, SANDBOX_ADC_CHANNEL0_DATA },
  70. { 1, SANDBOX_ADC_CHANNEL1_DATA },
  71. { 2, SANDBOX_ADC_CHANNEL2_DATA },
  72. { 3, SANDBOX_ADC_CHANNEL3_DATA },
  73. };
  74. static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts)
  75. {
  76. struct adc_channel *tdata = adc_channel_test_data;
  77. unsigned int i, data;
  78. struct udevice *dev;
  79. ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
  80. /* Test each ADC channel's value */
  81. for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
  82. ut_assertok(adc_start_channel(dev, tdata->id));
  83. ut_assertok(adc_channel_data(dev, tdata->id, &data));
  84. ut_asserteq(tdata->data, data);
  85. }
  86. return 0;
  87. }
  88. DM_TEST(dm_test_adc_single_channel_conversion, UT_TESTF_SCAN_FDT);
  89. static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
  90. {
  91. struct adc_channel channels[SANDBOX_ADC_CHANNELS];
  92. struct udevice *dev;
  93. struct adc_channel *tdata = adc_channel_test_data;
  94. unsigned int i, channel_mask;
  95. channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) |
  96. ADC_CHANNEL(2) | ADC_CHANNEL(3);
  97. /* Start multi channel conversion */
  98. ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
  99. ut_assertok(adc_start_channels(dev, channel_mask));
  100. ut_assertok(adc_channels_data(dev, channel_mask, channels));
  101. /* Compare the expected and returned conversion data. */
  102. for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++)
  103. ut_asserteq(tdata->data, channels[i].data);
  104. return 0;
  105. }
  106. DM_TEST(dm_test_adc_multi_channel_conversion, UT_TESTF_SCAN_FDT);
  107. static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
  108. {
  109. struct adc_channel *tdata = adc_channel_test_data;
  110. unsigned int i, data;
  111. for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
  112. /* Start single channel conversion */
  113. ut_assertok(adc_channel_single_shot("adc@0", tdata->id, &data));
  114. /* Compare the expected and returned conversion data. */
  115. ut_asserteq(tdata->data, data);
  116. }
  117. return 0;
  118. }
  119. DM_TEST(dm_test_adc_single_channel_shot, UT_TESTF_SCAN_FDT);
  120. static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
  121. {
  122. struct adc_channel channels[SANDBOX_ADC_CHANNELS];
  123. struct adc_channel *tdata = adc_channel_test_data;
  124. unsigned int i, channel_mask;
  125. channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) |
  126. ADC_CHANNEL(2) | ADC_CHANNEL(3);
  127. /* Start single call and multi channel conversion */
  128. ut_assertok(adc_channels_single_shot("adc@0", channel_mask, channels));
  129. /* Compare the expected and returned conversion data. */
  130. for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++)
  131. ut_asserteq(tdata->data, channels[i].data);
  132. return 0;
  133. }
  134. DM_TEST(dm_test_adc_multi_channel_shot, UT_TESTF_SCAN_FDT);
  135. static const int dm_test_adc_uV_data[SANDBOX_ADC_CHANNELS] = {
  136. ((u64)SANDBOX_ADC_CHANNEL0_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
  137. SANDBOX_ADC_DATA_MASK,
  138. ((u64)SANDBOX_ADC_CHANNEL1_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
  139. SANDBOX_ADC_DATA_MASK,
  140. ((u64)SANDBOX_ADC_CHANNEL2_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
  141. SANDBOX_ADC_DATA_MASK,
  142. ((u64)SANDBOX_ADC_CHANNEL3_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
  143. SANDBOX_ADC_DATA_MASK,
  144. };
  145. static int dm_test_adc_raw_to_uV(struct unit_test_state *uts)
  146. {
  147. struct adc_channel *tdata = adc_channel_test_data;
  148. unsigned int i, data;
  149. struct udevice *dev;
  150. int uV;
  151. ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
  152. /* Test each ADC channel's value in microvolts */
  153. for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
  154. ut_assertok(adc_start_channel(dev, tdata->id));
  155. ut_assertok(adc_channel_data(dev, tdata->id, &data));
  156. ut_assertok(adc_raw_to_uV(dev, data, &uV));
  157. ut_asserteq(dm_test_adc_uV_data[i], uV);
  158. }
  159. return 0;
  160. }
  161. DM_TEST(dm_test_adc_raw_to_uV, UT_TESTF_SCAN_FDT);