test/dm/adc.c

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