xref: /openbmc/u-boot/test/dm/adc.c (revision 430c166b)
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 
9 #include <common.h>
10 #include <adc.h>
11 #include <dm.h>
12 #include <dm/root.h>
13 #include <dm/util.h>
14 #include <dm/test.h>
15 #include <errno.h>
16 #include <fdtdec.h>
17 #include <power/regulator.h>
18 #include <power/sandbox_pmic.h>
19 #include <sandbox-adc.h>
20 #include <test/ut.h>
21 
dm_test_adc_bind(struct unit_test_state * uts)22 static int dm_test_adc_bind(struct unit_test_state *uts)
23 {
24 	struct udevice *dev;
25 	unsigned int channel_mask;
26 
27 	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
28 	ut_asserteq_str(SANDBOX_ADC_DEVNAME, dev->name);
29 
30 	ut_assertok(adc_channel_mask(dev, &channel_mask));
31 	ut_asserteq((1 << SANDBOX_ADC_CHANNELS) - 1, channel_mask);
32 
33 	return 0;
34 }
35 DM_TEST(dm_test_adc_bind, DM_TESTF_SCAN_FDT);
36 
dm_test_adc_wrong_channel_selection(struct unit_test_state * uts)37 static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
38 {
39 	struct udevice *dev;
40 
41 	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
42 	ut_asserteq(-EINVAL, adc_start_channel(dev, SANDBOX_ADC_CHANNELS));
43 
44 	return 0;
45 }
46 DM_TEST(dm_test_adc_wrong_channel_selection, DM_TESTF_SCAN_FDT);
47 
dm_test_adc_supply(struct unit_test_state * uts)48 static int dm_test_adc_supply(struct unit_test_state *uts)
49 {
50 	struct udevice *supply;
51 	struct udevice *dev;
52 	int uV;
53 
54 	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
55 
56 	/* Test Vss value - predefined 0 uV */
57 	ut_assertok(adc_vss_value(dev, &uV));
58 	ut_asserteq(SANDBOX_ADC_VSS_VALUE, uV);
59 
60 	/* Test Vdd initial value - buck2 */
61 	ut_assertok(adc_vdd_value(dev, &uV));
62 	ut_asserteq(SANDBOX_BUCK2_INITIAL_EXPECTED_UV, uV);
63 
64 	/* Change Vdd value - buck2 manual preset */
65 	ut_assertok(regulator_get_by_devname(SANDBOX_BUCK2_DEVNAME, &supply));
66 	ut_assertok(regulator_set_value(supply, SANDBOX_BUCK2_SET_UV));
67 	ut_asserteq(SANDBOX_BUCK2_SET_UV, regulator_get_value(supply));
68 
69 	/* Update ADC platdata and get new Vdd value */
70 	ut_assertok(adc_vdd_value(dev, &uV));
71 	ut_asserteq(SANDBOX_BUCK2_SET_UV, uV);
72 
73 	/* Disable buck2 and test ADC supply enable function */
74 	ut_assertok(regulator_set_enable(supply, false));
75 	ut_asserteq(false, regulator_get_enable(supply));
76 	/* adc_start_channel() should enable the supply regulator */
77 	ut_assertok(adc_start_channel(dev, 0));
78 	ut_asserteq(true, regulator_get_enable(supply));
79 
80 	return 0;
81 }
82 DM_TEST(dm_test_adc_supply, DM_TESTF_SCAN_FDT);
83 
84 struct adc_channel adc_channel_test_data[] = {
85 	{ 0, SANDBOX_ADC_CHANNEL0_DATA },
86 	{ 1, SANDBOX_ADC_CHANNEL1_DATA },
87 	{ 2, SANDBOX_ADC_CHANNEL2_DATA },
88 	{ 3, SANDBOX_ADC_CHANNEL3_DATA },
89 };
90 
dm_test_adc_single_channel_conversion(struct unit_test_state * uts)91 static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts)
92 {
93 	struct adc_channel *tdata = adc_channel_test_data;
94 	unsigned int i, data;
95 	struct udevice *dev;
96 
97 	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
98 	/* Test each ADC channel's value */
99 	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
100 		ut_assertok(adc_start_channel(dev, tdata->id));
101 		ut_assertok(adc_channel_data(dev, tdata->id, &data));
102 		ut_asserteq(tdata->data, data);
103 	}
104 
105 	return 0;
106 }
107 DM_TEST(dm_test_adc_single_channel_conversion, DM_TESTF_SCAN_FDT);
108 
dm_test_adc_multi_channel_conversion(struct unit_test_state * uts)109 static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
110 {
111 	struct adc_channel channels[SANDBOX_ADC_CHANNELS];
112 	struct udevice *dev;
113 	struct adc_channel *tdata = adc_channel_test_data;
114 	unsigned int i, channel_mask;
115 
116 	channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) |
117 		       ADC_CHANNEL(2) | ADC_CHANNEL(3);
118 
119 	/* Start multi channel conversion */
120 	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
121 	ut_assertok(adc_start_channels(dev, channel_mask));
122 	ut_assertok(adc_channels_data(dev, channel_mask, channels));
123 
124 	/* Compare the expected and returned conversion data. */
125 	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++)
126 		ut_asserteq(tdata->data, channels[i].data);
127 
128 	return 0;
129 }
130 DM_TEST(dm_test_adc_multi_channel_conversion, DM_TESTF_SCAN_FDT);
131 
dm_test_adc_single_channel_shot(struct unit_test_state * uts)132 static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
133 {
134 	struct adc_channel *tdata = adc_channel_test_data;
135 	unsigned int i, data;
136 
137 	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
138 		/* Start single channel conversion */
139 		ut_assertok(adc_channel_single_shot("adc", tdata->id, &data));
140 		/* Compare the expected and returned conversion data. */
141 		ut_asserteq(tdata->data, data);
142 	}
143 
144 	return 0;
145 }
146 DM_TEST(dm_test_adc_single_channel_shot, DM_TESTF_SCAN_FDT);
147 
dm_test_adc_multi_channel_shot(struct unit_test_state * uts)148 static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
149 {
150 	struct adc_channel channels[SANDBOX_ADC_CHANNELS];
151 	struct adc_channel *tdata = adc_channel_test_data;
152 	unsigned int i, channel_mask;
153 
154 	channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) |
155 		       ADC_CHANNEL(2) | ADC_CHANNEL(3);
156 
157 	/* Start single call and multi channel conversion */
158 	ut_assertok(adc_channels_single_shot("adc", channel_mask, channels));
159 
160 	/* Compare the expected and returned conversion data. */
161 	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++)
162 		ut_asserteq(tdata->data, channels[i].data);
163 
164 	return 0;
165 }
166 DM_TEST(dm_test_adc_multi_channel_shot, DM_TESTF_SCAN_FDT);
167 
168 static const int dm_test_adc_uV_data[SANDBOX_ADC_CHANNELS] = {
169 	((u64)SANDBOX_ADC_CHANNEL0_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
170 		SANDBOX_ADC_DATA_MASK,
171 	((u64)SANDBOX_ADC_CHANNEL1_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
172 		SANDBOX_ADC_DATA_MASK,
173 	((u64)SANDBOX_ADC_CHANNEL2_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
174 		SANDBOX_ADC_DATA_MASK,
175 	((u64)SANDBOX_ADC_CHANNEL3_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
176 		SANDBOX_ADC_DATA_MASK,
177 };
178 
dm_test_adc_raw_to_uV(struct unit_test_state * uts)179 static int dm_test_adc_raw_to_uV(struct unit_test_state *uts)
180 {
181 	struct adc_channel *tdata = adc_channel_test_data;
182 	unsigned int i, data;
183 	struct udevice *dev;
184 	int uV;
185 
186 	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
187 	/* Test each ADC channel's value in microvolts */
188 	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
189 		ut_assertok(adc_start_channel(dev, tdata->id));
190 		ut_assertok(adc_channel_data(dev, tdata->id, &data));
191 		ut_assertok(adc_raw_to_uV(dev, data, &uV));
192 		ut_asserteq(dm_test_adc_uV_data[i], uV);
193 	}
194 
195 	return 0;
196 }
197 DM_TEST(dm_test_adc_raw_to_uV, DM_TESTF_SCAN_FDT);
198