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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
 * Written by Jean-Jacques Hiblot  <jjhiblot@ti.com>
 */

#include <common.h>
#include <dm.h>
#include <generic-phy.h>
#include <log.h>
#include <dm/test.h>
#include <test/ut.h>

/* Base test of the phy uclass */
static int dm_test_phy_base(struct unit_test_state *uts)
{
	struct udevice *dev;
	struct phy phy1_method1;
	struct phy phy1_method2;
	struct phy phy2;
	struct phy phy3;
	struct udevice *parent;

	/* Get the device using the phy device*/
	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
					      "gen_phy_user", &parent));
	/*
	 * Get the same phy port in 2 different ways and compare.
	 */
	ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1))
	ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2))
	ut_asserteq(phy1_method1.id, phy1_method2.id);

	/*
	 * Get the second phy port. Check that the same phy provider (device)
	 * provides this 2nd phy port, but that the IDs are different
	 */
	ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2))
	ut_asserteq_ptr(phy1_method2.dev, phy2.dev);
	ut_assert(phy1_method1.id != phy2.id);

	/*
	 * Get the third phy port. Check that the phy provider is different
	 */
	ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3))
	ut_assert(phy2.dev != phy3.dev);

	/* Try to get a non-existing phy */
	ut_asserteq(-ENODEV, uclass_get_device(UCLASS_PHY, 3, &dev));
	ut_asserteq(-ENODATA, generic_phy_get_by_name(parent,
					"phy_not_existing", &phy1_method1));

	return 0;
}
DM_TEST(dm_test_phy_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test of the phy uclass using the sandbox phy driver operations */
static int dm_test_phy_ops(struct unit_test_state *uts)
{
	struct phy phy1;
	struct phy phy2;
	struct phy phy3;
	struct udevice *parent;

	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
					      "gen_phy_user", &parent));

	ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1));
	ut_asserteq(0, phy1.id);
	ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
	ut_asserteq(1, phy2.id);
	ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
	ut_asserteq(0, phy3.id);

	/* test normal operations */
	ut_assertok(generic_phy_init(&phy1));
	ut_assertok(generic_phy_power_on(&phy1));
	ut_assertok(generic_phy_power_off(&phy1));

	/*
	 * test operations after exit().
	 * The sandbox phy driver does not allow it.
	 */
	ut_assertok(generic_phy_exit(&phy1));
	ut_assert(generic_phy_power_on(&phy1) != 0);
	ut_assert(generic_phy_power_off(&phy1) != 0);

	/*
	 * test normal operations again (after re-init)
	 */
	ut_assertok(generic_phy_init(&phy1));
	ut_assertok(generic_phy_power_on(&phy1));
	ut_assertok(generic_phy_power_off(&phy1));

	/*
	 * test calling unimplemented feature.
	 * The call is expected to succeed
	 */
	ut_assertok(generic_phy_reset(&phy1));

	/* PHY2 has a known problem with power off */
	ut_assertok(generic_phy_init(&phy2));
	ut_assertok(generic_phy_power_on(&phy2));
	ut_asserteq(-EIO, generic_phy_power_off(&phy2));

	/* PHY3 has a known problem with power off and power on */
	ut_assertok(generic_phy_init(&phy3));
	ut_asserteq(-EIO, generic_phy_power_off(&phy3));
	ut_asserteq(-EIO, generic_phy_power_off(&phy3));

	return 0;
}
DM_TEST(dm_test_phy_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

static int dm_test_phy_bulk(struct unit_test_state *uts)
{
	struct phy_bulk phys;
	struct udevice *parent;

	/* test normal operations */
	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
					      "gen_phy_user1", &parent));

	ut_assertok(generic_phy_get_bulk(parent, &phys));
	ut_asserteq(2, phys.count);

	ut_asserteq(0, generic_phy_init_bulk(&phys));
	ut_asserteq(0, generic_phy_power_on_bulk(&phys));
	ut_asserteq(0, generic_phy_power_off_bulk(&phys));
	ut_asserteq(0, generic_phy_exit_bulk(&phys));

	/* has a known problem phy */
	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
					      "gen_phy_user", &parent));

	ut_assertok(generic_phy_get_bulk(parent, &phys));
	ut_asserteq(3, phys.count);

	ut_asserteq(0, generic_phy_init_bulk(&phys));
	ut_asserteq(-EIO, generic_phy_power_on_bulk(&phys));
	ut_asserteq(-EIO, generic_phy_power_off_bulk(&phys));
	ut_asserteq(0, generic_phy_exit_bulk(&phys));

	return 0;
}
DM_TEST(dm_test_phy_bulk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
86322f59 JJH	2	/*
	3	* Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
	4	* Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
86322f59 JJH	5	*/
	6
	7	#include <common.h>
	8	#include <dm.h>
	9	#include <generic-phy.h>
f7ae49fc	10	#include <log.h>
86322f59 JJH	11	#include <dm/test.h>
	12	#include <test/ut.h>
	13
86322f59 JJH	14	/* Base test of the phy uclass */
	15	static int dm_test_phy_base(struct unit_test_state *uts)
	16	{
	17	struct udevice *dev;
	18	struct phy phy1_method1;
	19	struct phy phy1_method2;
	20	struct phy phy2;
	21	struct phy phy3;
	22	struct udevice *parent;
	23
	24	/* Get the device using the phy device*/
	25	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
	26	"gen_phy_user", &parent));
	27	/*
	28	* Get the same phy port in 2 different ways and compare.
	29	*/
	30	ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1))
	31	ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2))
	32	ut_asserteq(phy1_method1.id, phy1_method2.id);
	33
	34	/*
	35	* Get the second phy port. Check that the same phy provider (device)
	36	* provides this 2nd phy port, but that the IDs are different
	37	*/
	38	ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2))
	39	ut_asserteq_ptr(phy1_method2.dev, phy2.dev);
	40	ut_assert(phy1_method1.id != phy2.id);
	41
	42	/*
	43	* Get the third phy port. Check that the phy provider is different
	44	*/
	45	ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3))
	46	ut_assert(phy2.dev != phy3.dev);
	47
	48	/* Try to get a non-existing phy */
	49	ut_asserteq(-ENODEV, uclass_get_device(UCLASS_PHY, 3, &dev));
ac206a0f SG	50	ut_asserteq(-ENODATA, generic_phy_get_by_name(parent,
ac206a0f SG	51	"phy_not_existing", &phy1_method1));
86322f59 JJH	52
	53	return 0;
	54	}
	55	DM_TEST(dm_test_phy_base, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	56
	57	/* Test of the phy uclass using the sandbox phy driver operations */
	58	static int dm_test_phy_ops(struct unit_test_state *uts)
	59	{
	60	struct phy phy1;
	61	struct phy phy2;
	62	struct phy phy3;
	63	struct udevice *parent;
	64
	65	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
	66	"gen_phy_user", &parent));
	67
	68	ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1));
ac206a0f	69	ut_asserteq(0, phy1.id);
86322f59	70	ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
ac206a0f	71	ut_asserteq(1, phy2.id);
86322f59	72	ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
ac206a0f	73	ut_asserteq(0, phy3.id);
86322f59 JJH	74
	75	/* test normal operations */
	76	ut_assertok(generic_phy_init(&phy1));
	77	ut_assertok(generic_phy_power_on(&phy1));
	78	ut_assertok(generic_phy_power_off(&phy1));
	79
	80	/*
	81	* test operations after exit().
	82	* The sandbox phy driver does not allow it.
	83	*/
	84	ut_assertok(generic_phy_exit(&phy1));
	85	ut_assert(generic_phy_power_on(&phy1) != 0);
	86	ut_assert(generic_phy_power_off(&phy1) != 0);
	87
	88	/*
	89	* test normal operations again (after re-init)
	90	*/
	91	ut_assertok(generic_phy_init(&phy1));
	92	ut_assertok(generic_phy_power_on(&phy1));
	93	ut_assertok(generic_phy_power_off(&phy1));
	94
	95	/*
	96	* test calling unimplemented feature.
	97	* The call is expected to succeed
	98	*/
	99	ut_assertok(generic_phy_reset(&phy1));
	100
	101	/* PHY2 has a known problem with power off */
	102	ut_assertok(generic_phy_init(&phy2));
	103	ut_assertok(generic_phy_power_on(&phy2));
ac206a0f	104	ut_asserteq(-EIO, generic_phy_power_off(&phy2));
86322f59	105
ac206a0f	106	/* PHY3 has a known problem with power off and power on */
86322f59	107	ut_assertok(generic_phy_init(&phy3));
ac206a0f SG	108	ut_asserteq(-EIO, generic_phy_power_off(&phy3));
ac206a0f SG	109	ut_asserteq(-EIO, generic_phy_power_off(&phy3));
86322f59 JJH	110
	111	return 0;
	112	}
	113	DM_TEST(dm_test_phy_ops, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
00c82acf CY	114
	115	static int dm_test_phy_bulk(struct unit_test_state *uts)
	116	{
	117	struct phy_bulk phys;
	118	struct udevice *parent;
	119
	120	/* test normal operations */
	121	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
	122	"gen_phy_user1", &parent));
	123
	124	ut_assertok(generic_phy_get_bulk(parent, &phys));
	125	ut_asserteq(2, phys.count);
	126
	127	ut_asserteq(0, generic_phy_init_bulk(&phys));
	128	ut_asserteq(0, generic_phy_power_on_bulk(&phys));
	129	ut_asserteq(0, generic_phy_power_off_bulk(&phys));
	130	ut_asserteq(0, generic_phy_exit_bulk(&phys));
	131
	132	/* has a known problem phy */
	133	ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
	134	"gen_phy_user", &parent));
	135
	136	ut_assertok(generic_phy_get_bulk(parent, &phys));
	137	ut_asserteq(3, phys.count);
	138
	139	ut_asserteq(0, generic_phy_init_bulk(&phys));
	140	ut_asserteq(-EIO, generic_phy_power_on_bulk(&phys));
	141	ut_asserteq(-EIO, generic_phy_power_off_bulk(&phys));
	142	ut_asserteq(0, generic_phy_exit_bulk(&phys));
	143
	144	return 0;
	145	}
	146	DM_TEST(dm_test_phy_bulk, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);