LXR uboot/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
  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);
 166