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         memset(ethaddr, '\0', sizeof(ethaddr));
 114         net_ping_ip = string_to_ip("1.1.2.2");
 115
 116         /* Prepare the test scenario */
 117         for (i = 0; i < DM_TEST_ETH_NUM; i++) {
 118                 ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
 119                                                        ethname[i], &dev[i]));
 120                 ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
 121
 122                 /* Invalidate MAC address */
 123                 strncpy(ethaddr[i], env_get(addrname[i]), 17);
 124                 /* Must disable access protection for ethaddr before clearing */
 125                 env_set(".flags", addrname[i]);
 126                 env_set(addrname[i], NULL);
 127         }
 128
 129         /* Set ethact to "eth@10002000" */
 130         env_set("ethact", ethname[0]);
 131
 132         /* Segment fault might happen if something is wrong */
 133         ut_asserteq(-ENODEV, net_loop(PING));
 134
 135         for (i = 0; i < DM_TEST_ETH_NUM; i++) {
 136                 /* Restore the env */
 137                 env_set(".flags", addrname[i]);
 138                 env_set(addrname[i], ethaddr[i]);
 139
 140                 /* Probe the device again */
 141                 ut_assertok(device_probe(dev[i]));
 142         }
 143         env_set(".flags", NULL);
 144         env_set("ethact", NULL);
 145
 146         return 0;
 147 }
 148 DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT);
 149
 150 /* The asserts include a return on fail; cleanup in the caller */
 151 static int _dm_test_eth_rotate1(struct unit_test_state *uts)
 152 {
 153         /* Make sure that the default is to rotate to the next interface */
 154         env_set("ethact", "eth@10004000");
 155         ut_assertok(net_loop(PING));
 156         ut_asserteq_str("eth@10002000", env_get("ethact"));
 157
 158         /* If ethrotate is no, then we should fail on a bad MAC */
 159         env_set("ethact", "eth@10004000");
 160         env_set("ethrotate", "no");
 161         ut_asserteq(-EINVAL, net_loop(PING));
 162         ut_asserteq_str("eth@10004000", env_get("ethact"));
 163
 164         return 0;
 165 }
 166
 167 static int _dm_test_eth_rotate2(struct unit_test_state *uts)
 168 {
 169         /* Make sure we can skip invalid devices */
 170         env_set("ethact", "eth@10004000");
 171         ut_assertok(net_loop(PING));
 172         ut_asserteq_str("eth@10004000", env_get("ethact"));
 173
 174         /* Make sure we can handle device name which is not eth# */
 175         env_set("ethact", "sbe5");
 176         ut_assertok(net_loop(PING));
 177         ut_asserteq_str("sbe5", env_get("ethact"));
 178
 179         return 0;
 180 }
 181
 182 static int dm_test_eth_rotate(struct unit_test_state *uts)
 183 {
 184         char ethaddr[18];
 185         int retval;
 186
 187         /* Set target IP to mock ping */
 188         net_ping_ip = string_to_ip("1.1.2.2");
 189
 190         /* Invalidate eth1's MAC address */
 191         memset(ethaddr, '\0', sizeof(ethaddr));
 192         strncpy(ethaddr, env_get("eth1addr"), 17);
 193         /* Must disable access protection for eth1addr before clearing */
 194         env_set(".flags", "eth1addr");
 195         env_set("eth1addr", NULL);
 196
 197         retval = _dm_test_eth_rotate1(uts);
 198
 199         /* Restore the env */
 200         env_set("eth1addr", ethaddr);
 201         env_set("ethrotate", NULL);
 202
 203         if (!retval) {
 204                 /* Invalidate eth0's MAC address */
 205                 strncpy(ethaddr, env_get("ethaddr"), 17);
 206                 /* Must disable access protection for ethaddr before clearing */
 207                 env_set(".flags", "ethaddr");
 208                 env_set("ethaddr", NULL);
 209
 210                 retval = _dm_test_eth_rotate2(uts);
 211
 212                 /* Restore the env */
 213                 env_set("ethaddr", ethaddr);
 214         }
 215         /* Restore the env */
 216         env_set(".flags", NULL);
 217
 218         return retval;
 219 }
 220 DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT);
 221
 222 /* The asserts include a return on fail; cleanup in the caller */
 223 static int _dm_test_net_retry(struct unit_test_state *uts)
 224 {
 225         /*
 226          * eth1 is disabled and netretry is yes, so the ping should succeed and
 227          * the active device should be eth0
 228          */
 229         sandbox_eth_disable_response(1, true);
 230         env_set("ethact", "eth@10004000");
 231         env_set("netretry", "yes");
 232         sandbox_eth_skip_timeout();
 233         ut_assertok(net_loop(PING));
 234         ut_asserteq_str("eth@10002000", env_get("ethact"));
 235
 236         /*
 237          * eth1 is disabled and netretry is no, so the ping should fail and the
 238          * active device should be eth1
 239          */
 240         env_set("ethact", "eth@10004000");
 241         env_set("netretry", "no");
 242         sandbox_eth_skip_timeout();
 243         ut_asserteq(-ETIMEDOUT, net_loop(PING));
 244         ut_asserteq_str("eth@10004000", env_get("ethact"));
 245
 246         return 0;
 247 }
 248
 249 static int dm_test_net_retry(struct unit_test_state *uts)
 250 {
 251         int retval;
 252
 253         net_ping_ip = string_to_ip("1.1.2.2");
 254
 255         retval = _dm_test_net_retry(uts);
 256
 257         /* Restore the env */
 258         env_set("netretry", NULL);
 259         sandbox_eth_disable_response(1, false);
 260
 261         return retval;
 262 }
 263 DM_TEST(dm_test_net_retry, DM_TESTF_SCAN_FDT);