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