mlx4: /dev/ -> /dev_vfs/
[akaros.git] / kern / drivers / net / mlx4 / en_selftest.c
1 /*
2  * Copyright (c) 2007 Mellanox Technologies. 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
34 #include "mlx4_en.h"
35
36
37 static int mlx4_en_test_registers(struct mlx4_en_priv *priv)
38 {
39         return mlx4_cmd(priv->mdev->dev, 0, 0, 0, MLX4_CMD_HW_HEALTH_CHECK,
40                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
41 }
42
43 static int mlx4_en_test_loopback_xmit(struct mlx4_en_priv *priv)
44 {
45         panic("Disabled");
46 #if 0 // AKAROS_PORT
47         struct sk_buff *skb;
48         struct ethhdr *ethh;
49         unsigned char *packet;
50         unsigned int packet_size = MLX4_LOOPBACK_TEST_PAYLOAD;
51         unsigned int i;
52         int err;
53
54
55         /* build the pkt before xmit */
56         skb = netdev_alloc_skb(priv->dev,
57                                MLX4_LOOPBACK_TEST_PAYLOAD + ETHERHDRSIZE + NET_IP_ALIGN);
58         if (!skb)
59                 return -ENOMEM;
60
61         skb_reserve(skb, NET_IP_ALIGN);
62
63         ethh = (struct ethhdr *)skb_put(skb, sizeof(struct ethhdr));
64         packet  = (unsigned char *)skb_put(skb, packet_size);
65         memcpy(ethh->h_dest, priv->dev->ea, Eaddrlen);
66         eth_zero_addr(ethh->h_source);
67         ethh->h_proto = cpu_to_be16(ETH_P_ARP);
68         skb_set_mac_header(skb, 0);
69         for (i = 0; i < packet_size; ++i)       /* fill our packet */
70                 packet[i] = (unsigned char)(i & 0xff);
71
72         /* xmit the pkt */
73         err = mlx4_en_xmit(skb, priv->dev);
74         return err;
75 #endif
76 }
77
78 static int mlx4_en_test_loopback(struct mlx4_en_priv *priv)
79 {
80         uint32_t loopback_ok = 0;
81         int i;
82         bool gro_enabled;
83
84         priv->loopback_ok = 0;
85         priv->validate_loopback = 1;
86         gro_enabled = priv->dev->feat & NETIF_F_GRO;
87
88         mlx4_en_update_loopback_state(priv->dev, priv->dev->feat);
89         priv->dev->feat &= ~NETIF_F_GRO;
90
91         /* xmit */
92         if (mlx4_en_test_loopback_xmit(priv)) {
93                 en_err(priv, "Transmitting loopback packet failed\n");
94                 goto mlx4_en_test_loopback_exit;
95         }
96
97         /* polling for result */
98         for (i = 0; i < MLX4_EN_LOOPBACK_RETRIES; ++i) {
99                 kthread_usleep(1000 * MLX4_EN_LOOPBACK_TIMEOUT);
100                 if (priv->loopback_ok) {
101                         loopback_ok = 1;
102                         break;
103                 }
104         }
105         if (!loopback_ok)
106                 en_err(priv, "Loopback packet didn't arrive\n");
107
108 mlx4_en_test_loopback_exit:
109
110         priv->validate_loopback = 0;
111
112         if (gro_enabled)
113                 priv->dev->feat |= NETIF_F_GRO;
114
115         mlx4_en_update_loopback_state(priv->dev, priv->dev->feat);
116         return !loopback_ok;
117 }
118
119
120 static int mlx4_en_test_link(struct mlx4_en_priv *priv)
121 {
122         if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))
123                 return -ENOMEM;
124         if (priv->port_state.link_state == 1)
125                 return 0;
126         else
127                 return 1;
128 }
129
130 static int mlx4_en_test_speed(struct mlx4_en_priv *priv)
131 {
132
133         if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))
134                 return -ENOMEM;
135
136         /* The device supports 100M, 1G, 10G, 20G, 40G and 56G speed */
137         if (priv->port_state.link_speed != SPEED_100 &&
138             priv->port_state.link_speed != SPEED_1000 &&
139             priv->port_state.link_speed != SPEED_10000 &&
140             priv->port_state.link_speed != SPEED_20000 &&
141             priv->port_state.link_speed != SPEED_40000 &&
142             priv->port_state.link_speed != SPEED_56000)
143                 return priv->port_state.link_speed;
144
145         return 0;
146 }
147
148
149 void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
150                          uint64_t *buf)
151 {
152         panic("Disabled");
153 #if 0 // AKAROS_PORT
154         struct mlx4_en_priv *priv = netdev_priv(dev);
155         struct mlx4_en_dev *mdev = priv->mdev;
156         int i, carrier_ok;
157
158         memset(buf, 0, sizeof(uint64_t) * MLX4_EN_NUM_SELF_TEST);
159
160         if (*flags & ETH_TEST_FL_OFFLINE) {
161                 /* disable the interface */
162                 carrier_ok = netif_carrier_ok(dev);
163
164                 netif_carrier_off(dev);
165                 /* Wait until all tx queues are empty.
166                  * there should not be any additional incoming traffic
167                  * since we turned the carrier off */
168                 kthread_usleep(1000 * 200);
169
170                 if (priv->mdev->dev->caps.flags &
171                                         MLX4_DEV_CAP_FLAG_UC_LOOPBACK) {
172                         buf[3] = mlx4_en_test_registers(priv);
173                         if (priv->port_up)
174                                 buf[4] = mlx4_en_test_loopback(priv);
175                 }
176
177                 if (carrier_ok)
178                         netif_carrier_on(dev);
179
180         }
181         buf[0] = mlx4_test_interrupts(mdev->dev);
182         buf[1] = mlx4_en_test_link(priv);
183         buf[2] = mlx4_en_test_speed(priv);
184
185         for (i = 0; i < MLX4_EN_NUM_SELF_TEST; i++) {
186                 if (buf[i])
187                         *flags |= ETH_TEST_FL_FAILED;
188         }
189 #endif
190 }