add stmac read mac form eeprom

hc

2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c

 kernel/drivers/net/ethernet/mellanox/mlx5/core/lib/vxlan.c
..
..
@@ -32,159 +32,116 @@
32
32
 
33
33
 #include <linux/kernel.h>
34
34
 #include <linux/module.h>
35
+#include <linux/refcount.h>
35
36
 #include <linux/mlx5/driver.h>
37
+#include <net/vxlan.h>
36
38
 #include "mlx5_core.h"
37
39
 #include "vxlan.h"
38
40
 
39
41
 struct mlx5_vxlan {
40
42
 	struct mlx5_core_dev		*mdev;
41
-	spinlock_t			lock; /* protect vxlan table */
42
43
 	/* max_num_ports is usuallly 4, 16 buckets is more than enough */
43
44
 	DECLARE_HASHTABLE(htable, 4);
44
-	int				num_ports;
45
45
 	struct mutex                    sync_lock; /* sync add/del port HW operations */
46
46
 };
47
47
 
48
48
 struct mlx5_vxlan_port {
49
49
 	struct hlist_node hlist;
50
-	atomic_t refcount;
51
50
 	u16 udp_port;
52
51
 };
53
52
 
54
-static inline u8 mlx5_vxlan_max_udp_ports(struct mlx5_core_dev *mdev)
55
-{
56
-	return MLX5_CAP_ETH(mdev, max_vxlan_udp_ports) ?: 4;
57
-}
58
-
59
53
 static int mlx5_vxlan_core_add_port_cmd(struct mlx5_core_dev *mdev, u16 port)
60
54
 {
61
-	u32 in[MLX5_ST_SZ_DW(add_vxlan_udp_dport_in)]   = {0};
62
-	u32 out[MLX5_ST_SZ_DW(add_vxlan_udp_dport_out)] = {0};
55
+	u32 in[MLX5_ST_SZ_DW(add_vxlan_udp_dport_in)] = {};
63
56
 
64
57
 	MLX5_SET(add_vxlan_udp_dport_in, in, opcode,
65
58
 		 MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT);
66
59
 	MLX5_SET(add_vxlan_udp_dport_in, in, vxlan_udp_port, port);
67
-	return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
60
+	return mlx5_cmd_exec_in(mdev, add_vxlan_udp_dport, in);
68
61
 }
69
62
 
70
63
 static int mlx5_vxlan_core_del_port_cmd(struct mlx5_core_dev *mdev, u16 port)
71
64
 {
72
-	u32 in[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_in)]   = {0};
73
-	u32 out[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_out)] = {0};
65
+	u32 in[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_in)] = {};
74
66
 
75
67
 	MLX5_SET(delete_vxlan_udp_dport_in, in, opcode,
76
68
 		 MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT);
77
69
 	MLX5_SET(delete_vxlan_udp_dport_in, in, vxlan_udp_port, port);
78
-	return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
70
+	return mlx5_cmd_exec_in(mdev, delete_vxlan_udp_dport, in);
79
71
 }
80
72
 
81
-static struct mlx5_vxlan_port*
82
-mlx5_vxlan_lookup_port_locked(struct mlx5_vxlan *vxlan, u16 port)
73
+bool mlx5_vxlan_lookup_port(struct mlx5_vxlan *vxlan, u16 port)
83
74
 {
84
75
 	struct mlx5_vxlan_port *vxlanp;
85
-
86
-	hash_for_each_possible(vxlan->htable, vxlanp, hlist, port) {
87
-		if (vxlanp->udp_port == port)
88
-			return vxlanp;
89
-	}
90
-
91
-	return NULL;
92
-}
93
-
94
-struct mlx5_vxlan_port *mlx5_vxlan_lookup_port(struct mlx5_vxlan *vxlan, u16 port)
95
-{
96
-	struct mlx5_vxlan_port *vxlanp;
76
+	bool found = false;
97
77
 
98
78
 	if (!mlx5_vxlan_allowed(vxlan))
99
79
 		return NULL;
100
80
 
101
-	spin_lock_bh(&vxlan->lock);
102
-	vxlanp = mlx5_vxlan_lookup_port_locked(vxlan, port);
103
-	spin_unlock_bh(&vxlan->lock);
81
+	rcu_read_lock();
82
+	hash_for_each_possible_rcu(vxlan->htable, vxlanp, hlist, port)
83
+		if (vxlanp->udp_port == port) {
84
+			found = true;
85
+			break;
86
+		}
87
+	rcu_read_unlock();
104
88
 
105
-	return vxlanp;
89
+	return found;
90
+}
91
+
92
+static struct mlx5_vxlan_port *vxlan_lookup_port(struct mlx5_vxlan *vxlan, u16 port)
93
+{
94
+	struct mlx5_vxlan_port *vxlanp;
95
+
96
+	hash_for_each_possible(vxlan->htable, vxlanp, hlist, port)
97
+		if (vxlanp->udp_port == port)
98
+			return vxlanp;
99
+	return NULL;
106
100
 }
107
101
 
108
102
 int mlx5_vxlan_add_port(struct mlx5_vxlan *vxlan, u16 port)
109
103
 {
110
104
 	struct mlx5_vxlan_port *vxlanp;
111
-	int ret = -ENOSPC;
105
+	int ret;
112
106
 
113
-	vxlanp = mlx5_vxlan_lookup_port(vxlan, port);
114
-	if (vxlanp) {
115
-		atomic_inc(&vxlanp->refcount);
116
-		return 0;
107
+	vxlanp = kzalloc(sizeof(*vxlanp), GFP_KERNEL);
108
+	if (!vxlanp)
109
+		return -ENOMEM;
110
+	vxlanp->udp_port = port;
111
+
112
+	ret = mlx5_vxlan_core_add_port_cmd(vxlan->mdev, port);
113
+	if (ret) {
114
+		kfree(vxlanp);
115
+		return ret;
117
116
 	}
118
117
 
119
118
 	mutex_lock(&vxlan->sync_lock);
120
-	if (vxlan->num_ports >= mlx5_vxlan_max_udp_ports(vxlan->mdev)) {
121
-		mlx5_core_info(vxlan->mdev,
122
-			       "UDP port (%d) not offloaded, max number of UDP ports (%d) are already offloaded\n",
123
-			       port, mlx5_vxlan_max_udp_ports(vxlan->mdev));
124
-		ret = -ENOSPC;
125
-		goto unlock;
126
-	}
127
-
128
-	ret = mlx5_vxlan_core_add_port_cmd(vxlan->mdev, port);
129
-	if (ret)
130
-		goto unlock;
131
-
132
-	vxlanp = kzalloc(sizeof(*vxlanp), GFP_KERNEL);
133
-	if (!vxlanp) {
134
-		ret = -ENOMEM;
135
-		goto err_delete_port;
136
-	}
137
-
138
-	vxlanp->udp_port = port;
139
-	atomic_set(&vxlanp->refcount, 1);
140
-
141
-	spin_lock_bh(&vxlan->lock);
142
-	hash_add(vxlan->htable, &vxlanp->hlist, port);
143
-	spin_unlock_bh(&vxlan->lock);
144
-
145
-	vxlan->num_ports++;
119
+	hash_add_rcu(vxlan->htable, &vxlanp->hlist, port);
146
120
 	mutex_unlock(&vxlan->sync_lock);
121
+
147
122
 	return 0;
148
-
149
-err_delete_port:
150
-	mlx5_vxlan_core_del_port_cmd(vxlan->mdev, port);
151
-
152
-unlock:
153
-	mutex_unlock(&vxlan->sync_lock);
154
-	return ret;
155
123
 }
156
124
 
157
125
 int mlx5_vxlan_del_port(struct mlx5_vxlan *vxlan, u16 port)
158
126
 {
159
127
 	struct mlx5_vxlan_port *vxlanp;
160
-	bool remove = false;
161
128
 	int ret = 0;
162
129
 
163
130
 	mutex_lock(&vxlan->sync_lock);
164
131
 
165
-	spin_lock_bh(&vxlan->lock);
166
-	vxlanp = mlx5_vxlan_lookup_port_locked(vxlan, port);
167
-	if (!vxlanp) {
132
+	vxlanp = vxlan_lookup_port(vxlan, port);
133
+	if (WARN_ON(!vxlanp)) {
168
134
 		ret = -ENOENT;
169
135
 		goto out_unlock;
170
136
 	}
171
137
 
172
-	if (atomic_dec_and_test(&vxlanp->refcount)) {
173
-		hash_del(&vxlanp->hlist);
174
-		remove = true;
175
-	}
138
+	hash_del_rcu(&vxlanp->hlist);
139
+	synchronize_rcu();
140
+	mlx5_vxlan_core_del_port_cmd(vxlan->mdev, port);
141
+	kfree(vxlanp);
176
142
 
177
143
 out_unlock:
178
-	spin_unlock_bh(&vxlan->lock);
179
-
180
-	if (remove) {
181
-		mlx5_vxlan_core_del_port_cmd(vxlan->mdev, port);
182
-		kfree(vxlanp);
183
-		vxlan->num_ports--;
184
-	}
185
-
186
144
 	mutex_unlock(&vxlan->sync_lock);
187
-
188
145
 	return ret;
189
146
 }
190
147
 
..
..
@@ -201,16 +158,26 @@
201
158
 
202
159
 	vxlan->mdev = mdev;
203
160
 	mutex_init(&vxlan->sync_lock);
204
-	spin_lock_init(&vxlan->lock);
205
161
 	hash_init(vxlan->htable);
206
162
 
207
-	/* Hardware adds 4789 by default */
208
-	mlx5_vxlan_add_port(vxlan, 4789);
163
+	/* Hardware adds 4789 (IANA_VXLAN_UDP_PORT) by default */
164
+	mlx5_vxlan_add_port(vxlan, IANA_VXLAN_UDP_PORT);
209
165
 
210
166
 	return vxlan;
211
167
 }
212
168
 
213
169
 void mlx5_vxlan_destroy(struct mlx5_vxlan *vxlan)
170
+{
171
+	if (!mlx5_vxlan_allowed(vxlan))
172
+		return;
173
+
174
+	mlx5_vxlan_del_port(vxlan, IANA_VXLAN_UDP_PORT);
175
+	WARN_ON(!hash_empty(vxlan->htable));
176
+
177
+	kfree(vxlan);
178
+}
179
+
180
+void mlx5_vxlan_reset_to_default(struct mlx5_vxlan *vxlan)
214
181
 {
215
182
 	struct mlx5_vxlan_port *vxlanp;
216
183
 	struct hlist_node *tmp;
..
..
@@ -219,12 +186,12 @@
219
186
 	if (!mlx5_vxlan_allowed(vxlan))
220
187
 		return;
221
188
 
222
-	/* Lockless since we are the only hash table consumers*/
223
189
 	hash_for_each_safe(vxlan->htable, bkt, tmp, vxlanp, hlist) {
224
-		hash_del(&vxlanp->hlist);
225
-		mlx5_vxlan_core_del_port_cmd(vxlan->mdev, vxlanp->udp_port);
226
-		kfree(vxlanp);
190
+		/* Don't delete default UDP port added by the HW.
191
+		 * Remove only user configured ports
192
+		 */
193
+		if (vxlanp->udp_port == IANA_VXLAN_UDP_PORT)
194
+			continue;
195
+		mlx5_vxlan_del_port(vxlan, vxlanp->udp_port);
227
196
 	}
228
-
229
-	kfree(vxlan);
230
197
 }