1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2015 National Instruments
4 *
5 * (C) Copyright 2015
6 * Joe Hershberger <joe.hershberger@ni.com>
7 */
8
9 #include <common.h>
10 #include <dm.h>
11 #include <env.h>
12 #include <fdtdec.h>
13 #include <malloc.h>
14 #include <net.h>
15 #include <dm/test.h>
16 #include <dm/device-internal.h>
17 #include <dm/uclass-internal.h>
18 #include <asm/eth.h>
19 #include <test/ut.h>
20
21 #define DM_TEST_ETH_NUM 4
22
dm_test_eth(struct unit_test_state * uts)23 static int dm_test_eth(struct unit_test_state *uts)
24 {
25 net_ping_ip = string_to_ip("1.1.2.2");
26
27 env_set("ethact", "eth@10002000");
28 ut_assertok(net_loop(PING));
29 ut_asserteq_str("eth@10002000", env_get("ethact"));
30
31 env_set("ethact", "eth@10003000");
32 ut_assertok(net_loop(PING));
33 ut_asserteq_str("eth@10003000", env_get("ethact"));
34
35 env_set("ethact", "eth@10004000");
36 ut_assertok(net_loop(PING));
37 ut_asserteq_str("eth@10004000", env_get("ethact"));
38
39 return 0;
40 }
41 DM_TEST(dm_test_eth, DM_TESTF_SCAN_FDT);
42
dm_test_eth_alias(struct unit_test_state * uts)43 static int dm_test_eth_alias(struct unit_test_state *uts)
44 {
45 net_ping_ip = string_to_ip("1.1.2.2");
46 env_set("ethact", "eth0");
47 ut_assertok(net_loop(PING));
48 ut_asserteq_str("eth@10002000", env_get("ethact"));
49
50 env_set("ethact", "eth1");
51 ut_assertok(net_loop(PING));
52 ut_asserteq_str("eth@10004000", env_get("ethact"));
53
54 /* Expected to fail since eth2 is not defined in the device tree */
55 env_set("ethact", "eth2");
56 ut_assertok(net_loop(PING));
57 ut_asserteq_str("eth@10002000", env_get("ethact"));
58
59 env_set("ethact", "eth5");
60 ut_assertok(net_loop(PING));
61 ut_asserteq_str("eth@10003000", env_get("ethact"));
62
63 return 0;
64 }
65 DM_TEST(dm_test_eth_alias, DM_TESTF_SCAN_FDT);
66
dm_test_eth_prime(struct unit_test_state * uts)67 static int dm_test_eth_prime(struct unit_test_state *uts)
68 {
69 net_ping_ip = string_to_ip("1.1.2.2");
70
71 /* Expected to be "eth@10003000" because of ethprime variable */
72 env_set("ethact", NULL);
73 env_set("ethprime", "eth5");
74 ut_assertok(net_loop(PING));
75 ut_asserteq_str("eth@10003000", env_get("ethact"));
76
77 /* Expected to be "eth@10002000" because it is first */
78 env_set("ethact", NULL);
79 env_set("ethprime", NULL);
80 ut_assertok(net_loop(PING));
81 ut_asserteq_str("eth@10002000", env_get("ethact"));
82
83 return 0;
84 }
85 DM_TEST(dm_test_eth_prime, DM_TESTF_SCAN_FDT);
86
87 /**
88 * This test case is trying to test the following scenario:
89 * - All ethernet devices are not probed
90 * - "ethaddr" for all ethernet devices are not set
91 * - "ethact" is set to a valid ethernet device name
92 *
93 * With Sandbox default test configuration, all ethernet devices are
94 * probed after power-up, so we have to manually create such scenario:
95 * - Remove all ethernet devices
96 * - Remove all "ethaddr" environment variables
97 * - Set "ethact" to the first ethernet device
98 *
99 * Do a ping test to see if anything goes wrong.
100 */
dm_test_eth_act(struct unit_test_state * uts)101 static int dm_test_eth_act(struct unit_test_state *uts)
102 {
103 struct udevice *dev[DM_TEST_ETH_NUM];
104 const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000",
105 "sbe5", "eth@10004000"};
106 const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr",
107 "eth3addr", "eth1addr"};
108 char ethaddr[DM_TEST_ETH_NUM][18];
109 int i;
110
111 memset(ethaddr, '\0', sizeof(ethaddr));
112 net_ping_ip = string_to_ip("1.1.2.2");
113
114 /* Prepare the test scenario */
115 for (i = 0; i < DM_TEST_ETH_NUM; i++) {
116 ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
117 ethname[i], &dev[i]));
118 ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
119
120 /* Invalidate MAC address */
121 strncpy(ethaddr[i], env_get(addrname[i]), 17);
122 /* Must disable access protection for ethaddr before clearing */
123 env_set(".flags", addrname[i]);
124 env_set(addrname[i], NULL);
125 }
126
127 /* Set ethact to "eth@10002000" */
128 env_set("ethact", ethname[0]);
129
130 /* Segment fault might happen if something is wrong */
131 ut_asserteq(-ENODEV, net_loop(PING));
132
133 for (i = 0; i < DM_TEST_ETH_NUM; i++) {
134 /* Restore the env */
135 env_set(".flags", addrname[i]);
136 env_set(addrname[i], ethaddr[i]);
137
138 /* Probe the device again */
139 ut_assertok(device_probe(dev[i]));
140 }
141 env_set(".flags", NULL);
142 env_set("ethact", NULL);
143
144 return 0;
145 }
146 DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT);
147
148 /* The asserts include a return on fail; cleanup in the caller */
_dm_test_eth_rotate1(struct unit_test_state * uts)149 static int _dm_test_eth_rotate1(struct unit_test_state *uts)
150 {
151 /* Make sure that the default is to rotate to the next interface */
152 env_set("ethact", "eth@10004000");
153 ut_assertok(net_loop(PING));
154 ut_asserteq_str("eth@10002000", env_get("ethact"));
155
156 /* If ethrotate is no, then we should fail on a bad MAC */
157 env_set("ethact", "eth@10004000");
158 env_set("ethrotate", "no");
159 ut_asserteq(-EINVAL, net_loop(PING));
160 ut_asserteq_str("eth@10004000", env_get("ethact"));
161
162 return 0;
163 }
164
_dm_test_eth_rotate2(struct unit_test_state * uts)165 static int _dm_test_eth_rotate2(struct unit_test_state *uts)
166 {
167 /* Make sure we can skip invalid devices */
168 env_set("ethact", "eth@10004000");
169 ut_assertok(net_loop(PING));
170 ut_asserteq_str("eth@10004000", env_get("ethact"));
171
172 /* Make sure we can handle device name which is not eth# */
173 env_set("ethact", "sbe5");
174 ut_assertok(net_loop(PING));
175 ut_asserteq_str("sbe5", env_get("ethact"));
176
177 return 0;
178 }
179
dm_test_eth_rotate(struct unit_test_state * uts)180 static int dm_test_eth_rotate(struct unit_test_state *uts)
181 {
182 char ethaddr[18];
183 int retval;
184
185 /* Set target IP to mock ping */
186 net_ping_ip = string_to_ip("1.1.2.2");
187
188 /* Invalidate eth1's MAC address */
189 memset(ethaddr, '\0', sizeof(ethaddr));
190 strncpy(ethaddr, env_get("eth1addr"), 17);
191 /* Must disable access protection for eth1addr before clearing */
192 env_set(".flags", "eth1addr");
193 env_set("eth1addr", NULL);
194
195 retval = _dm_test_eth_rotate1(uts);
196
197 /* Restore the env */
198 env_set("eth1addr", ethaddr);
199 env_set("ethrotate", NULL);
200
201 if (!retval) {
202 /* Invalidate eth0's MAC address */
203 strncpy(ethaddr, env_get("ethaddr"), 17);
204 /* Must disable access protection for ethaddr before clearing */
205 env_set(".flags", "ethaddr");
206 env_set("ethaddr", NULL);
207
208 retval = _dm_test_eth_rotate2(uts);
209
210 /* Restore the env */
211 env_set("ethaddr", ethaddr);
212 }
213 /* Restore the env */
214 env_set(".flags", NULL);
215
216 return retval;
217 }
218 DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT);
219
220 /* The asserts include a return on fail; cleanup in the caller */
_dm_test_net_retry(struct unit_test_state * uts)221 static int _dm_test_net_retry(struct unit_test_state *uts)
222 {
223 /*
224 * eth1 is disabled and netretry is yes, so the ping should succeed and
225 * the active device should be eth0
226 */
227 sandbox_eth_disable_response(1, true);
228 env_set("ethact", "eth@10004000");
229 env_set("netretry", "yes");
230 sandbox_eth_skip_timeout();
231 ut_assertok(net_loop(PING));
232 ut_asserteq_str("eth@10002000", env_get("ethact"));
233
234 /*
235 * eth1 is disabled and netretry is no, so the ping should fail and the
236 * active device should be eth1
237 */
238 env_set("ethact", "eth@10004000");
239 env_set("netretry", "no");
240 sandbox_eth_skip_timeout();
241 ut_asserteq(-ENONET, net_loop(PING));
242 ut_asserteq_str("eth@10004000", env_get("ethact"));
243
244 return 0;
245 }
246
dm_test_net_retry(struct unit_test_state * uts)247 static int dm_test_net_retry(struct unit_test_state *uts)
248 {
249 int retval;
250
251 net_ping_ip = string_to_ip("1.1.2.2");
252
253 retval = _dm_test_net_retry(uts);
254
255 /* Restore the env */
256 env_set("netretry", NULL);
257 sandbox_eth_disable_response(1, false);
258
259 return retval;
260 }
261 DM_TEST(dm_test_net_retry, DM_TESTF_SCAN_FDT);
262
sb_check_arp_reply(struct udevice * dev,void * packet,unsigned int len)263 static int sb_check_arp_reply(struct udevice *dev, void *packet,
264 unsigned int len)
265 {
266 struct eth_sandbox_priv *priv = dev_get_priv(dev);
267 struct ethernet_hdr *eth = packet;
268 struct arp_hdr *arp;
269 /* Used by all of the ut_assert macros */
270 struct unit_test_state *uts = priv->priv;
271
272 if (ntohs(eth->et_protlen) != PROT_ARP)
273 return 0;
274
275 arp = packet + ETHER_HDR_SIZE;
276
277 if (ntohs(arp->ar_op) != ARPOP_REPLY)
278 return 0;
279
280 /* This test would be worthless if we are not waiting */
281 ut_assert(arp_is_waiting());
282
283 /* Validate response */
284 ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0);
285 ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0);
286 ut_assert(eth->et_protlen == htons(PROT_ARP));
287
288 ut_assert(arp->ar_hrd == htons(ARP_ETHER));
289 ut_assert(arp->ar_pro == htons(PROT_IP));
290 ut_assert(arp->ar_hln == ARP_HLEN);
291 ut_assert(arp->ar_pln == ARP_PLEN);
292 ut_assert(memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) == 0);
293 ut_assert(net_read_ip(&arp->ar_spa).s_addr == net_ip.s_addr);
294 ut_assert(memcmp(&arp->ar_tha, priv->fake_host_hwaddr, ARP_HLEN) == 0);
295 ut_assert(net_read_ip(&arp->ar_tpa).s_addr ==
296 string_to_ip("1.1.2.4").s_addr);
297
298 return 0;
299 }
300
sb_with_async_arp_handler(struct udevice * dev,void * packet,unsigned int len)301 static int sb_with_async_arp_handler(struct udevice *dev, void *packet,
302 unsigned int len)
303 {
304 struct eth_sandbox_priv *priv = dev_get_priv(dev);
305 struct ethernet_hdr *eth = packet;
306 struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
307 int ret;
308
309 /*
310 * If we are about to generate a reply to ARP, first inject a request
311 * from another host
312 */
313 if (ntohs(eth->et_protlen) == PROT_ARP &&
314 ntohs(arp->ar_op) == ARPOP_REQUEST) {
315 /* Make sure sandbox_eth_recv_arp_req() knows who is asking */
316 priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
317
318 ret = sandbox_eth_recv_arp_req(dev);
319 if (ret)
320 return ret;
321 }
322
323 sandbox_eth_arp_req_to_reply(dev, packet, len);
324 sandbox_eth_ping_req_to_reply(dev, packet, len);
325
326 return sb_check_arp_reply(dev, packet, len);
327 }
328
dm_test_eth_async_arp_reply(struct unit_test_state * uts)329 static int dm_test_eth_async_arp_reply(struct unit_test_state *uts)
330 {
331 net_ping_ip = string_to_ip("1.1.2.2");
332
333 sandbox_eth_set_tx_handler(0, sb_with_async_arp_handler);
334 /* Used by all of the ut_assert macros in the tx_handler */
335 sandbox_eth_set_priv(0, uts);
336
337 env_set("ethact", "eth@10002000");
338 ut_assertok(net_loop(PING));
339 ut_asserteq_str("eth@10002000", env_get("ethact"));
340
341 sandbox_eth_set_tx_handler(0, NULL);
342
343 return 0;
344 }
345
346 DM_TEST(dm_test_eth_async_arp_reply, DM_TESTF_SCAN_FDT);
347
sb_check_ping_reply(struct udevice * dev,void * packet,unsigned int len)348 static int sb_check_ping_reply(struct udevice *dev, void *packet,
349 unsigned int len)
350 {
351 struct eth_sandbox_priv *priv = dev_get_priv(dev);
352 struct ethernet_hdr *eth = packet;
353 struct ip_udp_hdr *ip;
354 struct icmp_hdr *icmp;
355 /* Used by all of the ut_assert macros */
356 struct unit_test_state *uts = priv->priv;
357
358 if (ntohs(eth->et_protlen) != PROT_IP)
359 return 0;
360
361 ip = packet + ETHER_HDR_SIZE;
362
363 if (ip->ip_p != IPPROTO_ICMP)
364 return 0;
365
366 icmp = (struct icmp_hdr *)&ip->udp_src;
367
368 if (icmp->type != ICMP_ECHO_REPLY)
369 return 0;
370
371 /* This test would be worthless if we are not waiting */
372 ut_assert(arp_is_waiting());
373
374 /* Validate response */
375 ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0);
376 ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0);
377 ut_assert(eth->et_protlen == htons(PROT_IP));
378
379 ut_assert(net_read_ip(&ip->ip_src).s_addr == net_ip.s_addr);
380 ut_assert(net_read_ip(&ip->ip_dst).s_addr ==
381 string_to_ip("1.1.2.4").s_addr);
382
383 return 0;
384 }
385
sb_with_async_ping_handler(struct udevice * dev,void * packet,unsigned int len)386 static int sb_with_async_ping_handler(struct udevice *dev, void *packet,
387 unsigned int len)
388 {
389 struct eth_sandbox_priv *priv = dev_get_priv(dev);
390 struct ethernet_hdr *eth = packet;
391 struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
392 int ret;
393
394 /*
395 * If we are about to generate a reply to ARP, first inject a request
396 * from another host
397 */
398 if (ntohs(eth->et_protlen) == PROT_ARP &&
399 ntohs(arp->ar_op) == ARPOP_REQUEST) {
400 /* Make sure sandbox_eth_recv_arp_req() knows who is asking */
401 priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
402
403 ret = sandbox_eth_recv_ping_req(dev);
404 if (ret)
405 return ret;
406 }
407
408 sandbox_eth_arp_req_to_reply(dev, packet, len);
409 sandbox_eth_ping_req_to_reply(dev, packet, len);
410
411 return sb_check_ping_reply(dev, packet, len);
412 }
413
dm_test_eth_async_ping_reply(struct unit_test_state * uts)414 static int dm_test_eth_async_ping_reply(struct unit_test_state *uts)
415 {
416 net_ping_ip = string_to_ip("1.1.2.2");
417
418 sandbox_eth_set_tx_handler(0, sb_with_async_ping_handler);
419 /* Used by all of the ut_assert macros in the tx_handler */
420 sandbox_eth_set_priv(0, uts);
421
422 env_set("ethact", "eth@10002000");
423 ut_assertok(net_loop(PING));
424 ut_asserteq_str("eth@10002000", env_get("ethact"));
425
426 sandbox_eth_set_tx_handler(0, NULL);
427
428 return 0;
429 }
430
431 DM_TEST(dm_test_eth_async_ping_reply, DM_TESTF_SCAN_FDT);
432