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 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 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 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 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 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 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 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 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