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

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

#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/test.h>
#include <test/ut.h>

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

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

	ut_assertok(adc_channel_mask(dev, &channel_mask));
	ut_asserteq((1 << SANDBOX_ADC_CHANNELS) - 1, channel_mask);

	return 0;
}
DM_TEST(dm_test_adc_bind, UT_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@0", &dev));
	ut_asserteq(-EINVAL, adc_start_channel(dev, SANDBOX_ADC_CHANNELS));

	return 0;
}
DM_TEST(dm_test_adc_wrong_channel_selection, UT_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@0", &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 plat 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, UT_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@0", &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, UT_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@0", &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, UT_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@0", 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, UT_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@0", 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, UT_TESTF_SCAN_FDT);

static const int dm_test_adc_uV_data[SANDBOX_ADC_CHANNELS] = {
	((u64)SANDBOX_ADC_CHANNEL0_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
		SANDBOX_ADC_DATA_MASK,
	((u64)SANDBOX_ADC_CHANNEL1_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
		SANDBOX_ADC_DATA_MASK,
	((u64)SANDBOX_ADC_CHANNEL2_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
		SANDBOX_ADC_DATA_MASK,
	((u64)SANDBOX_ADC_CHANNEL3_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
		SANDBOX_ADC_DATA_MASK,
};

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

	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
	/* Test each ADC channel's value in microvolts */
	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_assertok(adc_raw_to_uV(dev, data, &uV));
		ut_asserteq(dm_test_adc_uV_data[i], uV);
	}

	return 0;
}
DM_TEST(dm_test_adc_raw_to_uV, UT_TESTF_SCAN_FDT);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
c48cb7eb PM	2	/*
	3	* Tests for the driver model ADC API
	4	*
	5	* Copyright (c) 2015 Samsung Electronics
	6	* Przemyslaw Marczak <p.marczak@samsung.com>
c48cb7eb PM	7	*/
c48cb7eb PM	8
c48cb7eb PM	9	#include <adc.h>
	10	#include <dm.h>
	11	#include <dm/root.h>
	12	#include <dm/util.h>
	13	#include <dm/test.h>
	14	#include <errno.h>
	15	#include <fdtdec.h>
	16	#include <power/regulator.h>
	17	#include <power/sandbox_pmic.h>
	18	#include <sandbox-adc.h>
0e1fad43	19	#include <test/test.h>
c48cb7eb PM	20	#include <test/ut.h>
c48cb7eb PM	21
c48cb7eb PM	22	static int dm_test_adc_bind(struct unit_test_state *uts)
	23	{
	24	struct udevice *dev;
63f004e7	25	unsigned int channel_mask;
c48cb7eb	26
38ee9dfe	27	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
c48cb7eb PM	28	ut_asserteq_str(SANDBOX_ADC_DEVNAME, dev->name);
c48cb7eb PM	29
63f004e7 FG	30	ut_assertok(adc_channel_mask(dev, &channel_mask));
	31	ut_asserteq((1 << SANDBOX_ADC_CHANNELS) - 1, channel_mask);
	32
c48cb7eb PM	33	return 0;
c48cb7eb PM	34	}
e180c2b1	35	DM_TEST(dm_test_adc_bind, UT_TESTF_SCAN_FDT);
c48cb7eb PM	36
	37	static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
	38	{
	39	struct udevice *dev;
	40
38ee9dfe	41	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
c48cb7eb PM	42	ut_asserteq(-EINVAL, adc_start_channel(dev, SANDBOX_ADC_CHANNELS));
	43
	44	return 0;
	45	}
e180c2b1	46	DM_TEST(dm_test_adc_wrong_channel_selection, UT_TESTF_SCAN_FDT);
c48cb7eb PM	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
38ee9dfe	54	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
c48cb7eb PM	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
caa4daa2	69	/* Update ADC plat and get new Vdd value */
c48cb7eb PM	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	}
e180c2b1	82	DM_TEST(dm_test_adc_supply, UT_TESTF_SCAN_FDT);
c48cb7eb PM	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
38ee9dfe	97	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
c48cb7eb PM	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	}
e180c2b1	107	DM_TEST(dm_test_adc_single_channel_conversion, UT_TESTF_SCAN_FDT);
c48cb7eb PM	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 */
38ee9dfe	120	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
c48cb7eb PM	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	}
e180c2b1	130	DM_TEST(dm_test_adc_multi_channel_conversion, UT_TESTF_SCAN_FDT);
c48cb7eb PM	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 */
38ee9dfe	139	ut_assertok(adc_channel_single_shot("adc@0", tdata->id, &data));
c48cb7eb PM	140	/* Compare the expected and returned conversion data. */
	141	ut_asserteq(tdata->data, data);
	142	}
	143
	144	return 0;
	145	}
e180c2b1	146	DM_TEST(dm_test_adc_single_channel_shot, UT_TESTF_SCAN_FDT);
c48cb7eb PM	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 */
38ee9dfe	158	ut_assertok(adc_channels_single_shot("adc@0", channel_mask, channels));
c48cb7eb PM	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	}
e180c2b1	166	DM_TEST(dm_test_adc_multi_channel_shot, UT_TESTF_SCAN_FDT);
63f004e7 FG	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
38ee9dfe	186	ut_assertok(uclass_get_device_by_name(UCLASS_ADC, "adc@0", &dev));
63f004e7 FG	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	}
e180c2b1	197	DM_TEST(dm_test_adc_raw_to_uV, UT_TESTF_SCAN_FDT);