1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2017 Texas Instruments Incorporated - https://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/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_assert(generic_phy_valid(&phy1_method1));
ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2));
ut_assert(generic_phy_valid(&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, 5, &dev));
ut_asserteq(-ENODATA, generic_phy_get_by_name(parent,
"phy_not_existing", &phy1_method1));
ut_assert(!generic_phy_valid(&phy1_method1));
ut_asserteq(-ENOENT, generic_phy_get_by_index(parent, 3,
&phy1_method2));
ut_assert(!generic_phy_valid(&phy1_method2));
/* Try to get a phy where of_xlate fail */
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
"gen_phy_user2", &parent));
ut_asserteq(-EINVAL, generic_phy_get_by_name(parent, "phy1",
&phy1_method1));
ut_assert(!generic_phy_valid(&phy1_method1));
ut_asserteq(-EINVAL, generic_phy_get_by_index(parent, 0,
&phy1_method2));
ut_assert(!generic_phy_valid(&phy1_method2));
return 0;
}
DM_TEST(dm_test_phy_base, UT_TESTF_SCAN_PDATA | UT_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 power_on() failure after exit().
* The sandbox phy driver does not allow power-on/off after
* exit, but the uclass counts power-on/init calls and skips
* calling the driver's ops when e.g. powering off an already
* powered-off phy.
*/
ut_assertok(generic_phy_exit(&phy1));
ut_assert(generic_phy_power_on(&phy1) != 0);
ut_assertok(generic_phy_power_off(&phy1));
/*
* 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));
/*
* Test power_off() failure after exit().
* For this we need to call exit() while the phy is powered-on,
* so that the uclass actually calls the driver's power-off()
* and reports the resulting failure.
*/
ut_assertok(generic_phy_power_on(&phy1));
ut_assertok(generic_phy_exit(&phy1));
ut_assert(generic_phy_power_off(&phy1) != 0);
ut_assertok(generic_phy_power_on(&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_on(&phy3));
ut_assertok(generic_phy_power_off(&phy3));
return 0;
}
DM_TEST(dm_test_phy_ops, UT_TESTF_SCAN_PDATA | UT_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, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_phy_multi_exit(struct unit_test_state *uts)
{
struct phy phy1_method1;
struct phy phy1_method2;
struct phy phy1_method3;
struct udevice *parent;
/* Get the same phy instance in 3 different ways. */
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
"gen_phy_user", &parent));
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1));
ut_asserteq(0, phy1_method1.id);
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method2));
ut_asserteq(0, phy1_method2.id);
ut_asserteq_ptr(phy1_method1.dev, phy1_method1.dev);
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
"gen_phy_user1", &parent));
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method3));
ut_asserteq(0, phy1_method3.id);
ut_asserteq_ptr(phy1_method1.dev, phy1_method3.dev);
/*
* Test using the same PHY from different handles.
* In non-test code these could be in different drivers.
*/
/*
* These must only call the driver's ops at the first init()
* and power_on().
*/
ut_assertok(generic_phy_init(&phy1_method1));
ut_assertok(generic_phy_init(&phy1_method2));
ut_assertok(generic_phy_power_on(&phy1_method1));
ut_assertok(generic_phy_power_on(&phy1_method2));
ut_assertok(generic_phy_init(&phy1_method3));
ut_assertok(generic_phy_power_on(&phy1_method3));
/*
* These must not call the driver's ops as other handles still
* want the PHY powered-on and initialized.
*/
ut_assertok(generic_phy_power_off(&phy1_method3));
ut_assertok(generic_phy_exit(&phy1_method3));
/*
* We would get an error here if the generic_phy_exit() above
* actually called the driver's exit(), as the sandbox driver
* doesn't allow power-off() after exit().
*/
ut_assertok(generic_phy_power_off(&phy1_method1));
ut_assertok(generic_phy_power_off(&phy1_method2));
ut_assertok(generic_phy_exit(&phy1_method1));
ut_assertok(generic_phy_exit(&phy1_method2));
return 0;
}
DM_TEST(dm_test_phy_multi_exit, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_phy_setup(struct unit_test_state *uts)
{
struct phy phy;
struct udevice *parent;
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
"gen_phy_user", &parent));
/* normal */
ut_assertok(generic_setup_phy(parent, &phy, 0));
ut_assertok(generic_shutdown_phy(&phy));
/* power_off fail with -EIO */
ut_assertok(generic_setup_phy(parent, &phy, 1));
ut_asserteq(-EIO, generic_shutdown_phy(&phy));
/* power_on fail with -EIO */
ut_asserteq(-EIO, generic_setup_phy(parent, &phy, 2));
ut_assertok(generic_shutdown_phy(&phy));
/* generic_phy_get_by_index fail with -ENOENT */
ut_asserteq(-ENOENT, generic_phy_get_by_index(parent, 3, &phy));
ut_assertok(generic_setup_phy(parent, &phy, 3));
ut_assertok(generic_shutdown_phy(&phy));
return 0;
}
DM_TEST(dm_test_phy_setup, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
|
