drivers/net/ethernet/mellanox/mlx5/core/en_selftest.c

   1 /*
   2  * Copyright (c) 2016, Mellanox Technologies, Ltd.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/prefetch.h>
  34 #include <linux/ip.h>
  35 #include <linux/udp.h>
  36 #include <net/udp.h>
  37 #include "en.h"
  38
  39 enum {
  40         MLX5E_ST_LINK_STATE,
  41         MLX5E_ST_LINK_SPEED,
  42         MLX5E_ST_HEALTH_INFO,
  43 #ifdef CONFIG_INET
  44         MLX5E_ST_LOOPBACK,
  45 #endif
  46         MLX5E_ST_NUM,
  47 };
  48
  49 const char mlx5e_self_tests[MLX5E_ST_NUM][ETH_GSTRING_LEN] = {
  50         "Link Test",
  51         "Speed Test",
  52         "Health Test",
  53 #ifdef CONFIG_INET
  54         "Loopback Test",
  55 #endif
  56 };
  57
  58 int mlx5e_self_test_num(struct mlx5e_priv *priv)
  59 {
  60         return ARRAY_SIZE(mlx5e_self_tests);
  61 }
  62
  63 static int mlx5e_test_health_info(struct mlx5e_priv *priv)
  64 {
  65         struct mlx5_core_health *health = &priv->mdev->priv.health;
  66
  67         return health->sick ? 1 : 0;
  68 }
  69
  70 static int mlx5e_test_link_state(struct mlx5e_priv *priv)
  71 {
  72         u8 port_state;
  73
  74         if (!netif_carrier_ok(priv->netdev))
  75                 return 1;
  76
  77         port_state = mlx5_query_vport_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_VNIC_VPORT, 0);
  78         return port_state == VPORT_STATE_UP ? 0 : 1;
  79 }
  80
  81 static int mlx5e_test_link_speed(struct mlx5e_priv *priv)
  82 {
  83         u32 out[MLX5_ST_SZ_DW(ptys_reg)];
  84         u32 eth_proto_oper;
  85         int i;
  86
  87         if (!netif_carrier_ok(priv->netdev))
  88                 return 1;
  89
  90         if (mlx5_query_port_ptys(priv->mdev, out, sizeof(out), MLX5_PTYS_EN, 1))
  91                 return 1;
  92
  93         eth_proto_oper = MLX5_GET(ptys_reg, out, eth_proto_oper);
  94         for (i = 0; i < MLX5E_LINK_MODES_NUMBER; i++) {
  95                 if (eth_proto_oper & MLX5E_PROT_MASK(i))
  96                         return 0;
  97         }
  98         return 1;
  99 }
 100
 101 struct mlx5ehdr {
 102         __be32 version;
 103         __be64 magic;
 104 };
 105
 106 #ifdef CONFIG_INET
 107 /* loopback test */
 108 #define MLX5E_TEST_PKT_SIZE (sizeof(struct ethhdr) + sizeof(struct iphdr) +\
 109                              sizeof(struct udphdr) + sizeof(struct mlx5ehdr))
 110 #define MLX5E_TEST_MAGIC 0x5AEED15C001ULL
 111
 112 static struct sk_buff *mlx5e_test_get_udp_skb(struct mlx5e_priv *priv)
 113 {
 114         struct sk_buff *skb = NULL;
 115         struct mlx5ehdr *mlxh;
 116         struct ethhdr *ethh;
 117         struct udphdr *udph;
 118         struct iphdr *iph;
 119         int    iplen;
 120
 121         skb = netdev_alloc_skb(priv->netdev, MLX5E_TEST_PKT_SIZE);
 122         if (!skb) {
 123                 netdev_err(priv->netdev, "\tFailed to alloc loopback skb\n");
 124                 return NULL;
 125         }
 126
 127         prefetchw(skb->data);
 128         skb_reserve(skb, NET_IP_ALIGN);
 129
 130         /*  Reserve for ethernet and IP header  */
 131         ethh = skb_push(skb, ETH_HLEN);
 132         skb_reset_mac_header(skb);
 133
 134         skb_set_network_header(skb, skb->len);
 135         iph = skb_put(skb, sizeof(struct iphdr));
 136
 137         skb_set_transport_header(skb, skb->len);
 138         udph = skb_put(skb, sizeof(struct udphdr));
 139
 140         /* Fill ETH header */
 141         ether_addr_copy(ethh->h_dest, priv->netdev->dev_addr);
 142         eth_zero_addr(ethh->h_source);
 143         ethh->h_proto = htons(ETH_P_IP);
 144
 145         /* Fill UDP header */
 146         udph->source = htons(9);
 147         udph->dest = htons(9); /* Discard Protocol */
 148         udph->len = htons(sizeof(struct mlx5ehdr) + sizeof(struct udphdr));
 149         udph->check = 0;
 150
 151         /* Fill IP header */
 152         iph->ihl = 5;
 153         iph->ttl = 32;
 154         iph->version = 4;
 155         iph->protocol = IPPROTO_UDP;
 156         iplen = sizeof(struct iphdr) + sizeof(struct udphdr) +
 157                 sizeof(struct mlx5ehdr);
 158         iph->tot_len = htons(iplen);
 159         iph->frag_off = 0;
 160         iph->saddr = 0;
 161         iph->daddr = 0;
 162         iph->tos = 0;
 163         iph->id = 0;
 164         ip_send_check(iph);
 165
 166         /* Fill test header and data */
 167         mlxh = skb_put(skb, sizeof(*mlxh));
 168         mlxh->version = 0;
 169         mlxh->magic = cpu_to_be64(MLX5E_TEST_MAGIC);
 170
 171         skb->csum = 0;
 172         skb->ip_summed = CHECKSUM_PARTIAL;
 173         udp4_hwcsum(skb, iph->saddr, iph->daddr);
 174
 175         skb->protocol = htons(ETH_P_IP);
 176         skb->pkt_type = PACKET_HOST;
 177         skb->dev = priv->netdev;
 178
 179         return skb;
 180 }
 181
 182 struct mlx5e_lbt_priv {
 183         struct packet_type pt;
 184         struct completion comp;
 185         bool loopback_ok;
 186         bool local_lb;
 187 };
 188
 189 static int
 190 mlx5e_test_loopback_validate(struct sk_buff *skb,
 191                              struct net_device *ndev,
 192                              struct packet_type *pt,
 193                              struct net_device *orig_ndev)
 194 {
 195         struct mlx5e_lbt_priv *lbtp = pt->af_packet_priv;
 196         struct mlx5ehdr *mlxh;
 197         struct ethhdr *ethh;
 198         struct udphdr *udph;
 199         struct iphdr *iph;
 200
 201         /* We are only going to peek, no need to clone the SKB */
 202         if (MLX5E_TEST_PKT_SIZE - ETH_HLEN > skb_headlen(skb))
 203                 goto out;
 204
 205         ethh = (struct ethhdr *)skb_mac_header(skb);
 206         if (!ether_addr_equal(ethh->h_dest, orig_ndev->dev_addr))
 207                 goto out;
 208
 209         iph = ip_hdr(skb);
 210         if (iph->protocol != IPPROTO_UDP)
 211                 goto out;
 212
 213         /* Don't assume skb_transport_header() was set */
 214         udph = (struct udphdr *)((u8 *)iph + 4 * iph->ihl);
 215         if (udph->dest != htons(9))
 216                 goto out;
 217
 218         mlxh = (struct mlx5ehdr *)((char *)udph + sizeof(*udph));
 219         if (mlxh->magic != cpu_to_be64(MLX5E_TEST_MAGIC))
 220                 goto out; /* so close ! */
 221
 222         /* bingo */
 223         lbtp->loopback_ok = true;
 224         complete(&lbtp->comp);
 225 out:
 226         kfree_skb(skb);
 227         return 0;
 228 }
 229
 230 static int mlx5e_test_loopback_setup(struct mlx5e_priv *priv,
 231                                      struct mlx5e_lbt_priv *lbtp)
 232 {
 233         int err = 0;
 234
 235         /* Temporarily enable local_lb */
 236         err = mlx5_nic_vport_query_local_lb(priv->mdev, &lbtp->local_lb);
 237         if (err)
 238                 return err;
 239
 240         if (!lbtp->local_lb) {
 241                 err = mlx5_nic_vport_update_local_lb(priv->mdev, true);
 242                 if (err)
 243                         return err;
 244         }
 245
 246         err = mlx5e_refresh_tirs(priv, true);
 247         if (err)
 248                 goto out;
 249
 250         lbtp->loopback_ok = false;
 251         init_completion(&lbtp->comp);
 252
 253         lbtp->pt.type = htons(ETH_P_IP);
 254         lbtp->pt.func = mlx5e_test_loopback_validate;
 255         lbtp->pt.dev = priv->netdev;
 256         lbtp->pt.af_packet_priv = lbtp;
 257         dev_add_pack(&lbtp->pt);
 258
 259         return 0;
 260
 261 out:
 262         if (!lbtp->local_lb)
 263                 mlx5_nic_vport_update_local_lb(priv->mdev, false);
 264
 265         return err;
 266 }
 267
 268 static void mlx5e_test_loopback_cleanup(struct mlx5e_priv *priv,
 269                                         struct mlx5e_lbt_priv *lbtp)
 270 {
 271         if (!lbtp->local_lb)
 272                 mlx5_nic_vport_update_local_lb(priv->mdev, false);
 273
 274         dev_remove_pack(&lbtp->pt);
 275         mlx5e_refresh_tirs(priv, false);
 276 }
 277
 278 #define MLX5E_LB_VERIFY_TIMEOUT (msecs_to_jiffies(200))
 279 static int mlx5e_test_loopback(struct mlx5e_priv *priv)
 280 {
 281         struct mlx5e_lbt_priv *lbtp;
 282         struct sk_buff *skb = NULL;
 283         int err;
 284
 285         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
 286                 netdev_err(priv->netdev,
 287                            "\tCan't perform loopback test while device is down\n");
 288                 return -ENODEV;
 289         }
 290
 291         lbtp = kzalloc(sizeof(*lbtp), GFP_KERNEL);
 292         if (!lbtp)
 293                 return -ENOMEM;
 294         lbtp->loopback_ok = false;
 295
 296         err = mlx5e_test_loopback_setup(priv, lbtp);
 297         if (err)
 298                 goto out;
 299
 300         skb = mlx5e_test_get_udp_skb(priv);
 301         if (!skb) {
 302                 err = -ENOMEM;
 303                 goto cleanup;
 304         }
 305
 306         skb_set_queue_mapping(skb, 0);
 307         err = dev_queue_xmit(skb);
 308         if (err) {
 309                 netdev_err(priv->netdev,
 310                            "\tFailed to xmit loopback packet err(%d)\n",
 311                            err);
 312                 goto cleanup;
 313         }
 314
 315         wait_for_completion_timeout(&lbtp->comp, MLX5E_LB_VERIFY_TIMEOUT);
 316         err = !lbtp->loopback_ok;
 317
 318 cleanup:
 319         mlx5e_test_loopback_cleanup(priv, lbtp);
 320 out:
 321         kfree(lbtp);
 322         return err;
 323 }
 324 #endif
 325
 326 static int (*mlx5e_st_func[MLX5E_ST_NUM])(struct mlx5e_priv *) = {
 327         mlx5e_test_link_state,
 328         mlx5e_test_link_speed,
 329         mlx5e_test_health_info,
 330 #ifdef CONFIG_INET
 331         mlx5e_test_loopback,
 332 #endif
 333 };
 334
 335 void mlx5e_self_test(struct net_device *ndev, struct ethtool_test *etest,
 336                      u64 *buf)
 337 {
 338         struct mlx5e_priv *priv = netdev_priv(ndev);
 339         int i;
 340
 341         memset(buf, 0, sizeof(u64) * MLX5E_ST_NUM);
 342
 343         mutex_lock(&priv->state_lock);
 344         netdev_info(ndev, "Self test begin..\n");
 345
 346         for (i = 0; i < MLX5E_ST_NUM; i++) {
 347                 netdev_info(ndev, "\t[%d] %s start..\n",
 348                             i, mlx5e_self_tests[i]);
 349                 buf[i] = mlx5e_st_func[i](priv);
 350                 netdev_info(ndev, "\t[%d] %s end: result(%lld)\n",
 351                             i, mlx5e_self_tests[i], buf[i]);
 352         }
 353
 354         mutex_unlock(&priv->state_lock);
 355
 356         for (i = 0; i < MLX5E_ST_NUM; i++) {
 357                 if (buf[i]) {
 358                         etest->flags |= ETH_TEST_FL_FAILED;
 359                         break;
 360                 }
 361         }
 362         netdev_info(ndev, "Self test out: status flags(0x%x)\n",
 363                     etest->flags);
 364 }