1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
4 * Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
5 */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <generic-phy.h>
10 #include <log.h>
11 #include <dm/test.h>
12 #include <test/test.h>
13 #include <test/ut.h>
14
15 /* Base test of the phy uclass */
dm_test_phy_base(struct unit_test_state * uts)16 static int dm_test_phy_base(struct unit_test_state *uts)
17 {
18 struct udevice *dev;
19 struct phy phy1_method1;
20 struct phy phy1_method2;
21 struct phy phy2;
22 struct phy phy3;
23 struct udevice *parent;
24
25 /* Get the device using the phy device*/
26 ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
27 "gen_phy_user", &parent));
28 /*
29 * Get the same phy port in 2 different ways and compare.
30 */
31 ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1));
32 ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2));
33 ut_asserteq(phy1_method1.id, phy1_method2.id);
34
35 /*
36 * Get the second phy port. Check that the same phy provider (device)
37 * provides this 2nd phy port, but that the IDs are different
38 */
39 ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
40 ut_asserteq_ptr(phy1_method2.dev, phy2.dev);
41 ut_assert(phy1_method1.id != phy2.id);
42
43 /*
44 * Get the third phy port. Check that the phy provider is different
45 */
46 ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
47 ut_assert(phy2.dev != phy3.dev);
48
49 /* Try to get a non-existing phy */
50 ut_asserteq(-ENODEV, uclass_get_device(UCLASS_PHY, 4, &dev));
51 ut_asserteq(-ENODATA, generic_phy_get_by_name(parent,
52 "phy_not_existing", &phy1_method1));
53
54 return 0;
55 }
56 DM_TEST(dm_test_phy_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
57
58 /* Test of the phy uclass using the sandbox phy driver operations */
dm_test_phy_ops(struct unit_test_state * uts)59 static int dm_test_phy_ops(struct unit_test_state *uts)
60 {
61 struct phy phy1;
62 struct phy phy2;
63 struct phy phy3;
64 struct udevice *parent;
65
66 ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
67 "gen_phy_user", &parent));
68
69 ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1));
70 ut_asserteq(0, phy1.id);
71 ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
72 ut_asserteq(1, phy2.id);
73 ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
74 ut_asserteq(0, phy3.id);
75
76 /* test normal operations */
77 ut_assertok(generic_phy_init(&phy1));
78 ut_assertok(generic_phy_power_on(&phy1));
79 ut_assertok(generic_phy_power_off(&phy1));
80
81 /*
82 * Test power_on() failure after exit().
83 * The sandbox phy driver does not allow power-on/off after
84 * exit, but the uclass counts power-on/init calls and skips
85 * calling the driver's ops when e.g. powering off an already
86 * powered-off phy.
87 */
88 ut_assertok(generic_phy_exit(&phy1));
89 ut_assert(generic_phy_power_on(&phy1) != 0);
90 ut_assertok(generic_phy_power_off(&phy1));
91
92 /*
93 * test normal operations again (after re-init)
94 */
95 ut_assertok(generic_phy_init(&phy1));
96 ut_assertok(generic_phy_power_on(&phy1));
97 ut_assertok(generic_phy_power_off(&phy1));
98
99 /*
100 * test calling unimplemented feature.
101 * The call is expected to succeed
102 */
103 ut_assertok(generic_phy_reset(&phy1));
104
105 /*
106 * Test power_off() failure after exit().
107 * For this we need to call exit() while the phy is powered-on,
108 * so that the uclass actually calls the driver's power-off()
109 * and reports the resulting failure.
110 */
111 ut_assertok(generic_phy_power_on(&phy1));
112 ut_assertok(generic_phy_exit(&phy1));
113 ut_assert(generic_phy_power_off(&phy1) != 0);
114 ut_assertok(generic_phy_power_on(&phy1));
115
116 /* PHY2 has a known problem with power off */
117 ut_assertok(generic_phy_init(&phy2));
118 ut_assertok(generic_phy_power_on(&phy2));
119 ut_asserteq(-EIO, generic_phy_power_off(&phy2));
120
121 /* PHY3 has a known problem with power off and power on */
122 ut_assertok(generic_phy_init(&phy3));
123 ut_asserteq(-EIO, generic_phy_power_on(&phy3));
124 ut_assertok(generic_phy_power_off(&phy3));
125
126 return 0;
127 }
128 DM_TEST(dm_test_phy_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
129
dm_test_phy_bulk(struct unit_test_state * uts)130 static int dm_test_phy_bulk(struct unit_test_state *uts)
131 {
132 struct phy_bulk phys;
133 struct udevice *parent;
134
135 /* test normal operations */
136 ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
137 "gen_phy_user1", &parent));
138
139 ut_assertok(generic_phy_get_bulk(parent, &phys));
140 ut_asserteq(2, phys.count);
141
142 ut_asserteq(0, generic_phy_init_bulk(&phys));
143 ut_asserteq(0, generic_phy_power_on_bulk(&phys));
144 ut_asserteq(0, generic_phy_power_off_bulk(&phys));
145 ut_asserteq(0, generic_phy_exit_bulk(&phys));
146
147 /* has a known problem phy */
148 ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
149 "gen_phy_user", &parent));
150
151 ut_assertok(generic_phy_get_bulk(parent, &phys));
152 ut_asserteq(3, phys.count);
153
154 ut_asserteq(0, generic_phy_init_bulk(&phys));
155 ut_asserteq(-EIO, generic_phy_power_on_bulk(&phys));
156 ut_asserteq(-EIO, generic_phy_power_off_bulk(&phys));
157 ut_asserteq(0, generic_phy_exit_bulk(&phys));
158
159 return 0;
160 }
161 DM_TEST(dm_test_phy_bulk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
162
dm_test_phy_multi_exit(struct unit_test_state * uts)163 static int dm_test_phy_multi_exit(struct unit_test_state *uts)
164 {
165 struct phy phy1_method1;
166 struct phy phy1_method2;
167 struct phy phy1_method3;
168 struct udevice *parent;
169
170 /* Get the same phy instance in 3 different ways. */
171 ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
172 "gen_phy_user", &parent));
173 ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1));
174 ut_asserteq(0, phy1_method1.id);
175 ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method2));
176 ut_asserteq(0, phy1_method2.id);
177 ut_asserteq_ptr(phy1_method1.dev, phy1_method1.dev);
178
179 ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
180 "gen_phy_user1", &parent));
181 ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method3));
182 ut_asserteq(0, phy1_method3.id);
183 ut_asserteq_ptr(phy1_method1.dev, phy1_method3.dev);
184
185 /*
186 * Test using the same PHY from different handles.
187 * In non-test code these could be in different drivers.
188 */
189
190 /*
191 * These must only call the driver's ops at the first init()
192 * and power_on().
193 */
194 ut_assertok(generic_phy_init(&phy1_method1));
195 ut_assertok(generic_phy_init(&phy1_method2));
196 ut_assertok(generic_phy_power_on(&phy1_method1));
197 ut_assertok(generic_phy_power_on(&phy1_method2));
198 ut_assertok(generic_phy_init(&phy1_method3));
199 ut_assertok(generic_phy_power_on(&phy1_method3));
200
201 /*
202 * These must not call the driver's ops as other handles still
203 * want the PHY powered-on and initialized.
204 */
205 ut_assertok(generic_phy_power_off(&phy1_method3));
206 ut_assertok(generic_phy_exit(&phy1_method3));
207
208 /*
209 * We would get an error here if the generic_phy_exit() above
210 * actually called the driver's exit(), as the sandbox driver
211 * doesn't allow power-off() after exit().
212 */
213 ut_assertok(generic_phy_power_off(&phy1_method1));
214 ut_assertok(generic_phy_power_off(&phy1_method2));
215 ut_assertok(generic_phy_exit(&phy1_method1));
216 ut_assertok(generic_phy_exit(&phy1_method2));
217
218 return 0;
219 }
220 DM_TEST(dm_test_phy_multi_exit, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
221