1 /* 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 23 static int dm_test_adc_bind(struct unit_test_state *uts) 24 { 25 struct udevice *dev; 26 27 ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev)); 28 ut_asserteq_str(SANDBOX_ADC_DEVNAME, dev->name); 29 30 return 0; 31 } 32 DM_TEST(dm_test_adc_bind, DM_TESTF_SCAN_FDT); 33 34 static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts) 35 { 36 struct udevice *dev; 37 38 ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev)); 39 ut_asserteq(-EINVAL, adc_start_channel(dev, SANDBOX_ADC_CHANNELS)); 40 41 return 0; 42 } 43 DM_TEST(dm_test_adc_wrong_channel_selection, DM_TESTF_SCAN_FDT); 44 45 static int dm_test_adc_supply(struct unit_test_state *uts) 46 { 47 struct udevice *supply; 48 struct udevice *dev; 49 int uV; 50 51 ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev)); 52 53 /* Test Vss value - predefined 0 uV */ 54 ut_assertok(adc_vss_value(dev, &uV)); 55 ut_asserteq(SANDBOX_ADC_VSS_VALUE, uV); 56 57 /* Test Vdd initial value - buck2 */ 58 ut_assertok(adc_vdd_value(dev, &uV)); 59 ut_asserteq(SANDBOX_BUCK2_INITIAL_EXPECTED_UV, uV); 60 61 /* Change Vdd value - buck2 manual preset */ 62 ut_assertok(regulator_get_by_devname(SANDBOX_BUCK2_DEVNAME, &supply)); 63 ut_assertok(regulator_set_value(supply, SANDBOX_BUCK2_SET_UV)); 64 ut_asserteq(SANDBOX_BUCK2_SET_UV, regulator_get_value(supply)); 65 66 /* Update ADC platdata and get new Vdd value */ 67 ut_assertok(adc_vdd_value(dev, &uV)); 68 ut_asserteq(SANDBOX_BUCK2_SET_UV, uV); 69 70 /* Disable buck2 and test ADC supply enable function */ 71 ut_assertok(regulator_set_enable(supply, false)); 72 ut_asserteq(false, regulator_get_enable(supply)); 73 /* adc_start_channel() should enable the supply regulator */ 74 ut_assertok(adc_start_channel(dev, 0)); 75 ut_asserteq(true, regulator_get_enable(supply)); 76 77 return 0; 78 } 79 DM_TEST(dm_test_adc_supply, DM_TESTF_SCAN_FDT); 80 81 struct adc_channel adc_channel_test_data[] = { 82 { 0, SANDBOX_ADC_CHANNEL0_DATA }, 83 { 1, SANDBOX_ADC_CHANNEL1_DATA }, 84 { 2, SANDBOX_ADC_CHANNEL2_DATA }, 85 { 3, SANDBOX_ADC_CHANNEL3_DATA }, 86 }; 87 88 static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts) 89 { 90 struct adc_channel *tdata = adc_channel_test_data; 91 unsigned int i, data; 92 struct udevice *dev; 93 94 ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev)); 95 /* Test each ADC channel's value */ 96 for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) { 97 ut_assertok(adc_start_channel(dev, tdata->id)); 98 ut_assertok(adc_channel_data(dev, tdata->id, &data)); 99 ut_asserteq(tdata->data, data); 100 } 101 102 return 0; 103 } 104 DM_TEST(dm_test_adc_single_channel_conversion, DM_TESTF_SCAN_FDT); 105 106 static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts) 107 { 108 struct adc_channel channels[SANDBOX_ADC_CHANNELS]; 109 struct udevice *dev; 110 struct adc_channel *tdata = adc_channel_test_data; 111 unsigned int i, channel_mask; 112 113 channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) | 114 ADC_CHANNEL(2) | ADC_CHANNEL(3); 115 116 /* Start multi channel conversion */ 117 ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev)); 118 ut_assertok(adc_start_channels(dev, channel_mask)); 119 ut_assertok(adc_channels_data(dev, channel_mask, channels)); 120 121 /* Compare the expected and returned conversion data. */ 122 for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) 123 ut_asserteq(tdata->data, channels[i].data); 124 125 return 0; 126 } 127 DM_TEST(dm_test_adc_multi_channel_conversion, DM_TESTF_SCAN_FDT); 128 129 static int dm_test_adc_single_channel_shot(struct unit_test_state *uts) 130 { 131 struct adc_channel *tdata = adc_channel_test_data; 132 unsigned int i, data; 133 134 for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) { 135 /* Start single channel conversion */ 136 ut_assertok(adc_channel_single_shot("adc", tdata->id, &data)); 137 /* Compare the expected and returned conversion data. */ 138 ut_asserteq(tdata->data, data); 139 } 140 141 return 0; 142 } 143 DM_TEST(dm_test_adc_single_channel_shot, DM_TESTF_SCAN_FDT); 144 145 static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts) 146 { 147 struct adc_channel channels[SANDBOX_ADC_CHANNELS]; 148 struct adc_channel *tdata = adc_channel_test_data; 149 unsigned int i, channel_mask; 150 151 channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) | 152 ADC_CHANNEL(2) | ADC_CHANNEL(3); 153 154 /* Start single call and multi channel conversion */ 155 ut_assertok(adc_channels_single_shot("adc", channel_mask, channels)); 156 157 /* Compare the expected and returned conversion data. */ 158 for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) 159 ut_asserteq(tdata->data, channels[i].data); 160 161 return 0; 162 } 163 DM_TEST(dm_test_adc_multi_channel_shot, DM_TESTF_SCAN_FDT); 164