test/dm/adc.c

   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 DECLARE_GLOBAL_DATA_PTR;
  24
  25 static 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 }
  34 DM_TEST(dm_test_adc_bind, DM_TESTF_SCAN_FDT);
  35
  36 static 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 }
  45 DM_TEST(dm_test_adc_wrong_channel_selection, DM_TESTF_SCAN_FDT);
  46
  47 static 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 }
  81 DM_TEST(dm_test_adc_supply, DM_TESTF_SCAN_FDT);
  82
  83 struct 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
  90 static 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 }
 106 DM_TEST(dm_test_adc_single_channel_conversion, DM_TESTF_SCAN_FDT);
 107
 108 static 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 }
 129 DM_TEST(dm_test_adc_multi_channel_conversion, DM_TESTF_SCAN_FDT);
 130
 131 static 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 }
 145 DM_TEST(dm_test_adc_single_channel_shot, DM_TESTF_SCAN_FDT);
 146
 147 static 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 }
 165 DM_TEST(dm_test_adc_multi_channel_shot, DM_TESTF_SCAN_FDT);