[people/ms/u-boot.git] / test / dm / adc.c

/*
 * Tests for the driver model ADC API
 *
 * Copyright (c) 2015 Samsung Electronics
 * Przemyslaw Marczak <p.marczak@samsung.com>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <adc.h>
#include <dm.h>
#include <dm/root.h>
#include <dm/util.h>
#include <dm/test.h>
#include <errno.h>
#include <fdtdec.h>
#include <power/regulator.h>
#include <power/sandbox_pmic.h>
#include <sandbox-adc.h>
#include <test/ut.h>

DECLARE_GLOBAL_DATA_PTR;

static int dm_test_adc_bind(struct unit_test_state *uts)
{
	struct udevice *dev;

	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
	ut_asserteq_str(SANDBOX_ADC_DEVNAME, dev->name);

	return 0;
}
DM_TEST(dm_test_adc_bind, DM_TESTF_SCAN_FDT);

static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
{
	struct udevice *dev;

	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
	ut_asserteq(-EINVAL, adc_start_channel(dev, SANDBOX_ADC_CHANNELS));

	return 0;
}
DM_TEST(dm_test_adc_wrong_channel_selection, DM_TESTF_SCAN_FDT);

static int dm_test_adc_supply(struct unit_test_state *uts)
{
	struct udevice *supply;
	struct udevice *dev;
	int uV;

	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));

	/* Test Vss value - predefined 0 uV */
	ut_assertok(adc_vss_value(dev, &uV));
	ut_asserteq(SANDBOX_ADC_VSS_VALUE, uV);

	/* Test Vdd initial value - buck2 */
	ut_assertok(adc_vdd_value(dev, &uV));
	ut_asserteq(SANDBOX_BUCK2_INITIAL_EXPECTED_UV, uV);

	/* Change Vdd value - buck2 manual preset */
	ut_assertok(regulator_get_by_devname(SANDBOX_BUCK2_DEVNAME, &supply));
	ut_assertok(regulator_set_value(supply, SANDBOX_BUCK2_SET_UV));
	ut_asserteq(SANDBOX_BUCK2_SET_UV, regulator_get_value(supply));

	/* Update ADC platdata and get new Vdd value */
	ut_assertok(adc_vdd_value(dev, &uV));
	ut_asserteq(SANDBOX_BUCK2_SET_UV, uV);

	/* Disable buck2 and test ADC supply enable function */
	ut_assertok(regulator_set_enable(supply, false));
	ut_asserteq(false, regulator_get_enable(supply));
	/* adc_start_channel() should enable the supply regulator */
	ut_assertok(adc_start_channel(dev, 0));
	ut_asserteq(true, regulator_get_enable(supply));

	return 0;
}
DM_TEST(dm_test_adc_supply, DM_TESTF_SCAN_FDT);

struct adc_channel adc_channel_test_data[] = {
	{ 0, SANDBOX_ADC_CHANNEL0_DATA },
	{ 1, SANDBOX_ADC_CHANNEL1_DATA },
	{ 2, SANDBOX_ADC_CHANNEL2_DATA },
	{ 3, SANDBOX_ADC_CHANNEL3_DATA },
};

static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts)
{
	struct adc_channel *tdata = adc_channel_test_data;
	unsigned int i, data;
	struct udevice *dev;

	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
	/* Test each ADC channel's value */
	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
		ut_assertok(adc_start_channel(dev, tdata->id));
		ut_assertok(adc_channel_data(dev, tdata->id, &data));
		ut_asserteq(tdata->data, data);
	}

	return 0;
}
DM_TEST(dm_test_adc_single_channel_conversion, DM_TESTF_SCAN_FDT);

static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
{
	struct adc_channel channels[SANDBOX_ADC_CHANNELS];
	struct udevice *dev;
	struct adc_channel *tdata = adc_channel_test_data;
	unsigned int i, channel_mask;

	channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) |
		       ADC_CHANNEL(2) | ADC_CHANNEL(3);

	/* Start multi channel conversion */
	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc", &dev));
	ut_assertok(adc_start_channels(dev, channel_mask));
	ut_assertok(adc_channels_data(dev, channel_mask, channels));

	/* Compare the expected and returned conversion data. */
	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++)
		ut_asserteq(tdata->data, channels[i].data);

	return 0;
}
DM_TEST(dm_test_adc_multi_channel_conversion, DM_TESTF_SCAN_FDT);

static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
{
	struct adc_channel *tdata = adc_channel_test_data;
	unsigned int i, data;

	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++) {
		/* Start single channel conversion */
		ut_assertok(adc_channel_single_shot("adc", tdata->id, &data));
		/* Compare the expected and returned conversion data. */
		ut_asserteq(tdata->data, data);
	}

	return 0;
}
DM_TEST(dm_test_adc_single_channel_shot, DM_TESTF_SCAN_FDT);

static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
{
	struct adc_channel channels[SANDBOX_ADC_CHANNELS];
	struct adc_channel *tdata = adc_channel_test_data;
	unsigned int i, channel_mask;

	channel_mask = ADC_CHANNEL(0) | ADC_CHANNEL(1) |
		       ADC_CHANNEL(2) | ADC_CHANNEL(3);

	/* Start single call and multi channel conversion */
	ut_assertok(adc_channels_single_shot("adc", channel_mask, channels));

	/* Compare the expected and returned conversion data. */
	for (i = 0; i < SANDBOX_ADC_CHANNELS; i++, tdata++)
		ut_asserteq(tdata->data, channels[i].data);

	return 0;
}
DM_TEST(dm_test_adc_multi_channel_shot, DM_TESTF_SCAN_FDT);
Commit	Line	Data
c48cb7eb PM	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);