test/dm/eth.c

   1 /*
   2  * Copyright (c) 2015 National Instruments
   3  *
   4  * (C) Copyright 2015
   5  * Joe Hershberger <joe.hershberger@ni.com>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0
   8  */
   9
  10 #include <common.h>
  11 #include <dm.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 DECLARE_GLOBAL_DATA_PTR;
  22
  23 #define DM_TEST_ETH_NUM         4
  24
  25 static int dm_test_eth(struct unit_test_state *uts)
  26 {
  27         net_ping_ip = string_to_ip("1.1.2.2");
  28
  29         env_set("ethact", "eth@10002000");
  30         ut_assertok(net_loop(PING));
  31         ut_asserteq_str("eth@10002000", env_get("ethact"));
  32
  33         env_set("ethact", "eth@10003000");
  34         ut_assertok(net_loop(PING));
  35         ut_asserteq_str("eth@10003000", env_get("ethact"));
  36
  37         env_set("ethact", "eth@10004000");
  38         ut_assertok(net_loop(PING));
  39         ut_asserteq_str("eth@10004000", env_get("ethact"));
  40
  41         return 0;
  42 }
  43 DM_TEST(dm_test_eth, DM_TESTF_SCAN_FDT);
  44
  45 static int dm_test_eth_alias(struct unit_test_state *uts)
  46 {
  47         net_ping_ip = string_to_ip("1.1.2.2");
  48         env_set("ethact", "eth0");
  49         ut_assertok(net_loop(PING));
  50         ut_asserteq_str("eth@10002000", env_get("ethact"));
  51
  52         env_set("ethact", "eth1");
  53         ut_assertok(net_loop(PING));
  54         ut_asserteq_str("eth@10004000", env_get("ethact"));
  55
  56         /* Expected to fail since eth2 is not defined in the device tree */
  57         env_set("ethact", "eth2");
  58         ut_assertok(net_loop(PING));
  59         ut_asserteq_str("eth@10002000", env_get("ethact"));
  60
  61         env_set("ethact", "eth5");
  62         ut_assertok(net_loop(PING));
  63         ut_asserteq_str("eth@10003000", env_get("ethact"));
  64
  65         return 0;
  66 }
  67 DM_TEST(dm_test_eth_alias, DM_TESTF_SCAN_FDT);
  68
  69 static int dm_test_eth_prime(struct unit_test_state *uts)
  70 {
  71         net_ping_ip = string_to_ip("1.1.2.2");
  72
  73         /* Expected to be "eth@10003000" because of ethprime variable */
  74         env_set("ethact", NULL);
  75         env_set("ethprime", "eth5");
  76         ut_assertok(net_loop(PING));
  77         ut_asserteq_str("eth@10003000", env_get("ethact"));
  78
  79         /* Expected to be "eth@10002000" because it is first */
  80         env_set("ethact", NULL);
  81         env_set("ethprime", NULL);
  82         ut_assertok(net_loop(PING));
  83         ut_asserteq_str("eth@10002000", env_get("ethact"));
  84
  85         return 0;
  86 }
  87 DM_TEST(dm_test_eth_prime, DM_TESTF_SCAN_FDT);
  88
  89 /**
  90  * This test case is trying to test the following scenario:
  91  *      - All ethernet devices are not probed
  92  *      - "ethaddr" for all ethernet devices are not set
  93  *      - "ethact" is set to a valid ethernet device name
  94  *
  95  * With Sandbox default test configuration, all ethernet devices are
  96  * probed after power-up, so we have to manually create such scenario:
  97  *      - Remove all ethernet devices
  98  *      - Remove all "ethaddr" environment variables
  99  *      - Set "ethact" to the first ethernet device
 100  *
 101  * Do a ping test to see if anything goes wrong.
 102  */
 103 static int dm_test_eth_act(struct unit_test_state *uts)
 104 {
 105         struct udevice *dev[DM_TEST_ETH_NUM];
 106         const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000",
 107                                                 "sbe5", "eth@10004000"};
 108         const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr",
 109                                                  "eth3addr", "eth1addr"};
 110         char ethaddr[DM_TEST_ETH_NUM][18];
 111         int i;
 112
 113         net_ping_ip = string_to_ip("1.1.2.2");
 114
 115         /* Prepare the test scenario */
 116         for (i = 0; i < DM_TEST_ETH_NUM; i++) {
 117                 ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
 118                                                        ethname[i], &dev[i]));
 119                 ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
 120
 121                 /* Invalidate MAC address */
 122                 strcpy(ethaddr[i], env_get(addrname[i]));
 123                 /* Must disable access protection for ethaddr before clearing */
 124                 env_set(".flags", addrname[i]);
 125                 env_set(addrname[i], NULL);
 126         }
 127
 128         /* Set ethact to "eth@10002000" */
 129         env_set("ethact", ethname[0]);
 130
 131         /* Segment fault might happen if something is wrong */
 132         ut_asserteq(-ENODEV, net_loop(PING));
 133
 134         for (i = 0; i < DM_TEST_ETH_NUM; i++) {
 135                 /* Restore the env */
 136                 env_set(".flags", addrname[i]);
 137                 env_set(addrname[i], ethaddr[i]);
 138
 139                 /* Probe the device again */
 140                 ut_assertok(device_probe(dev[i]));
 141         }
 142         env_set(".flags", NULL);
 143         env_set("ethact", NULL);
 144
 145         return 0;
 146 }
 147 DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT);
 148
 149 /* The asserts include a return on fail; cleanup in the caller */
 150 static int _dm_test_eth_rotate1(struct unit_test_state *uts)
 151 {
 152         /* Make sure that the default is to rotate to the next interface */
 153         env_set("ethact", "eth@10004000");
 154         ut_assertok(net_loop(PING));
 155         ut_asserteq_str("eth@10002000", env_get("ethact"));
 156
 157         /* If ethrotate is no, then we should fail on a bad MAC */
 158         env_set("ethact", "eth@10004000");
 159         env_set("ethrotate", "no");
 160         ut_asserteq(-EINVAL, net_loop(PING));
 161         ut_asserteq_str("eth@10004000", env_get("ethact"));
 162
 163         return 0;
 164 }
 165
 166 static int _dm_test_eth_rotate2(struct unit_test_state *uts)
 167 {
 168         /* Make sure we can skip invalid devices */
 169         env_set("ethact", "eth@10004000");
 170         ut_assertok(net_loop(PING));
 171         ut_asserteq_str("eth@10004000", env_get("ethact"));
 172
 173         /* Make sure we can handle device name which is not eth# */
 174         env_set("ethact", "sbe5");
 175         ut_assertok(net_loop(PING));
 176         ut_asserteq_str("sbe5", env_get("ethact"));
 177
 178         return 0;
 179 }
 180
 181 static int dm_test_eth_rotate(struct unit_test_state *uts)
 182 {
 183         char ethaddr[18];
 184         int retval;
 185
 186         /* Set target IP to mock ping */
 187         net_ping_ip = string_to_ip("1.1.2.2");
 188
 189         /* Invalidate eth1's MAC address */
 190         strcpy(ethaddr, env_get("eth1addr"));
 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                 strcpy(ethaddr, env_get("ethaddr"));
 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 */
 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(-ETIMEDOUT, net_loop(PING));
 242         ut_asserteq_str("eth@10004000", env_get("ethact"));
 243
 244         return 0;
 245 }
 246
 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);