?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum_fid.c
blob54262af4e98f713b7533cb758c2dd6eda181eabc
1 /*
2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_fid.c
3 * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2017 Ido Schimmel <idosch@mellanox.com>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the names of the copyright holders nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * Alternatively, this software may be distributed under the terms of the
19 * GNU General Public License ("GPL") version 2 as published by the Free
20 * Software Foundation.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include <linux/kernel.h>
36 #include <linux/bitops.h>
37 #include <linux/if_vlan.h>
38 #include <linux/if_bridge.h>
39 #include <linux/netdevice.h>
40 #include <linux/rtnetlink.h>
41
42 #include "spectrum.h"
43 #include "reg.h"
44
45 struct mlxsw_sp_fid_family;
46
47 struct mlxsw_sp_fid_core {
48 struct mlxsw_sp_fid_family *fid_family_arr[MLXSW_SP_FID_TYPE_MAX];
49 unsigned int *port_fid_mappings;
50 };
51
52 struct mlxsw_sp_fid {
53 struct list_head list;
54 struct mlxsw_sp_rif *rif;
55 unsigned int ref_count;
56 u16 fid_index;
57 struct mlxsw_sp_fid_family *fid_family;
58 };
59
60 struct mlxsw_sp_fid_8021q {
61 struct mlxsw_sp_fid common;
62 u16 vid;
63 };
64
65 struct mlxsw_sp_fid_8021d {
66 struct mlxsw_sp_fid common;
67 int br_ifindex;
68 };
69
70 struct mlxsw_sp_flood_table {
71 enum mlxsw_sp_flood_type packet_type;
72 enum mlxsw_reg_sfgc_bridge_type bridge_type;
73 enum mlxsw_flood_table_type table_type;
74 int table_index;
75 };
76
77 struct mlxsw_sp_fid_ops {
78 void (*setup)(struct mlxsw_sp_fid *fid, const void *arg);
79 int (*configure)(struct mlxsw_sp_fid *fid);
80 void (*deconfigure)(struct mlxsw_sp_fid *fid);
81 int (*index_alloc)(struct mlxsw_sp_fid *fid, const void *arg,
82 u16 *p_fid_index);
83 bool (*compare)(const struct mlxsw_sp_fid *fid,
84 const void *arg);
85 u16 (*flood_index)(const struct mlxsw_sp_fid *fid);
86 int (*port_vid_map)(struct mlxsw_sp_fid *fid,
87 struct mlxsw_sp_port *port, u16 vid);
88 void (*port_vid_unmap)(struct mlxsw_sp_fid *fid,
89 struct mlxsw_sp_port *port, u16 vid);
90 };
91
92 struct mlxsw_sp_fid_family {
93 enum mlxsw_sp_fid_type type;
94 size_t fid_size;
95 u16 start_index;
96 u16 end_index;
97 struct list_head fids_list;
98 unsigned long *fids_bitmap;
99 const struct mlxsw_sp_flood_table *flood_tables;
100 int nr_flood_tables;
101 enum mlxsw_sp_rif_type rif_type;
102 const struct mlxsw_sp_fid_ops *ops;
103 struct mlxsw_sp *mlxsw_sp;
104 };
105
106 static const int mlxsw_sp_sfgc_uc_packet_types[MLXSW_REG_SFGC_TYPE_MAX] = {
107 [MLXSW_REG_SFGC_TYPE_UNKNOWN_UNICAST] = 1,
108 };
109
110 static const int mlxsw_sp_sfgc_bc_packet_types[MLXSW_REG_SFGC_TYPE_MAX] = {
111 [MLXSW_REG_SFGC_TYPE_BROADCAST] = 1,
112 [MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_NON_IP] = 1,
113 [MLXSW_REG_SFGC_TYPE_IPV4_LINK_LOCAL] = 1,
114 [MLXSW_REG_SFGC_TYPE_IPV6_ALL_HOST] = 1,
115 [MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_IPV6] = 1,
116 };
117
118 static const int mlxsw_sp_sfgc_mc_packet_types[MLXSW_REG_SFGC_TYPE_MAX] = {
119 [MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_IPV4] = 1,
120 };
121
122 static const int *mlxsw_sp_packet_type_sfgc_types[] = {
123 [MLXSW_SP_FLOOD_TYPE_UC] = mlxsw_sp_sfgc_uc_packet_types,
124 [MLXSW_SP_FLOOD_TYPE_BC] = mlxsw_sp_sfgc_bc_packet_types,
125 [MLXSW_SP_FLOOD_TYPE_MC] = mlxsw_sp_sfgc_mc_packet_types,
126 };
127
128 static const struct mlxsw_sp_flood_table *
129 mlxsw_sp_fid_flood_table_lookup(const struct mlxsw_sp_fid *fid,
130 enum mlxsw_sp_flood_type packet_type)
131 {
132 struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
133 int i;
134
135 for (i = 0; i < fid_family->nr_flood_tables; i++) {
136 if (fid_family->flood_tables[i].packet_type != packet_type)
137 continue;
138 return &fid_family->flood_tables[i];
139 }
140
141 return NULL;
142 }
143
144 int mlxsw_sp_fid_flood_set(struct mlxsw_sp_fid *fid,
145 enum mlxsw_sp_flood_type packet_type, u8 local_port,
146 bool member)
147 {
148 struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
149 const struct mlxsw_sp_fid_ops *ops = fid_family->ops;
150 const struct mlxsw_sp_flood_table *flood_table;
151 char *sftr_pl;
152 int err;
153
154 if (WARN_ON(!fid_family->flood_tables || !ops->flood_index))
155 return -EINVAL;
156
157 flood_table = mlxsw_sp_fid_flood_table_lookup(fid, packet_type);
158 if (!flood_table)
159 return -ESRCH;
160
161 sftr_pl = kmalloc(MLXSW_REG_SFTR_LEN, GFP_KERNEL);
162 if (!sftr_pl)
163 return -ENOMEM;
164
165 mlxsw_reg_sftr_pack(sftr_pl, flood_table->table_index,
166 ops->flood_index(fid), flood_table->table_type, 1,
167 local_port, member);
168 err = mlxsw_reg_write(fid_family->mlxsw_sp->core, MLXSW_REG(sftr),
169 sftr_pl);
170 kfree(sftr_pl);
171 return err;
172 }
173
174 int mlxsw_sp_fid_port_vid_map(struct mlxsw_sp_fid *fid,
175 struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
176 {
177 if (WARN_ON(!fid->fid_family->ops->port_vid_map))
178 return -EINVAL;
179 return fid->fid_family->ops->port_vid_map(fid, mlxsw_sp_port, vid);
180 }
181
182 void mlxsw_sp_fid_port_vid_unmap(struct mlxsw_sp_fid *fid,
183 struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
184 {
185 fid->fid_family->ops->port_vid_unmap(fid, mlxsw_sp_port, vid);
186 }
187
188 enum mlxsw_sp_rif_type mlxsw_sp_fid_rif_type(const struct mlxsw_sp_fid *fid)
189 {
190 return fid->fid_family->rif_type;
191 }
192
193 u16 mlxsw_sp_fid_index(const struct mlxsw_sp_fid *fid)
194 {
195 return fid->fid_index;
196 }
197
198 enum mlxsw_sp_fid_type mlxsw_sp_fid_type(const struct mlxsw_sp_fid *fid)
199 {
200 return fid->fid_family->type;
201 }
202
203 void mlxsw_sp_fid_rif_set(struct mlxsw_sp_fid *fid, struct mlxsw_sp_rif *rif)
204 {
205 fid->rif = rif;
206 }
207
208 enum mlxsw_sp_rif_type
209 mlxsw_sp_fid_type_rif_type(const struct mlxsw_sp *mlxsw_sp,
210 enum mlxsw_sp_fid_type type)
211 {
212 struct mlxsw_sp_fid_core *fid_core = mlxsw_sp->fid_core;
213
214 return fid_core->fid_family_arr[type]->rif_type;
215 }
216
217 static struct mlxsw_sp_fid_8021q *
218 mlxsw_sp_fid_8021q_fid(const struct mlxsw_sp_fid *fid)
219 {
220 return container_of(fid, struct mlxsw_sp_fid_8021q, common);
221 }
222
223 u16 mlxsw_sp_fid_8021q_vid(const struct mlxsw_sp_fid *fid)
224 {
225 return mlxsw_sp_fid_8021q_fid(fid)->vid;
226 }
227
228 static void mlxsw_sp_fid_8021q_setup(struct mlxsw_sp_fid *fid, const void *arg)
229 {
230 u16 vid = *(u16 *) arg;
231
232 mlxsw_sp_fid_8021q_fid(fid)->vid = vid;
233 }
234
235 static enum mlxsw_reg_sfmr_op mlxsw_sp_sfmr_op(bool valid)
236 {
237 return valid ? MLXSW_REG_SFMR_OP_CREATE_FID :
238 MLXSW_REG_SFMR_OP_DESTROY_FID;
239 }
240
241 static int mlxsw_sp_fid_op(struct mlxsw_sp *mlxsw_sp, u16 fid_index,
242 u16 fid_offset, bool valid)
243 {
244 char sfmr_pl[MLXSW_REG_SFMR_LEN];
245
246 mlxsw_reg_sfmr_pack(sfmr_pl, mlxsw_sp_sfmr_op(valid), fid_index,
247 fid_offset);
248 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
249 }
250
251 static int mlxsw_sp_fid_vid_map(struct mlxsw_sp *mlxsw_sp, u16 fid_index,
252 u16 vid, bool valid)
253 {
254 enum mlxsw_reg_svfa_mt mt = MLXSW_REG_SVFA_MT_VID_TO_FID;
255 char svfa_pl[MLXSW_REG_SVFA_LEN];
256
257 mlxsw_reg_svfa_pack(svfa_pl, 0, mt, valid, fid_index, vid);
258 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
259 }
260
261 static int __mlxsw_sp_fid_port_vid_map(struct mlxsw_sp *mlxsw_sp, u16 fid_index,
262 u8 local_port, u16 vid, bool valid)
263 {
264 enum mlxsw_reg_svfa_mt mt = MLXSW_REG_SVFA_MT_PORT_VID_TO_FID;
265 char svfa_pl[MLXSW_REG_SVFA_LEN];
266
267 mlxsw_reg_svfa_pack(svfa_pl, local_port, mt, valid, fid_index, vid);
268 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
269 }
270
271 static int mlxsw_sp_fid_8021q_configure(struct mlxsw_sp_fid *fid)
272 {
273 struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
274 struct mlxsw_sp_fid_8021q *fid_8021q;
275 int err;
276
277 err = mlxsw_sp_fid_op(mlxsw_sp, fid->fid_index, fid->fid_index, true);
278 if (err)
279 return err;
280
281 fid_8021q = mlxsw_sp_fid_8021q_fid(fid);
282 err = mlxsw_sp_fid_vid_map(mlxsw_sp, fid->fid_index, fid_8021q->vid,
283 true);
284 if (err)
285 goto err_fid_map;
286
287 return 0;
288
289 err_fid_map:
290 mlxsw_sp_fid_op(mlxsw_sp, fid->fid_index, 0, false);
291 return err;
292 }
293
294 static void mlxsw_sp_fid_8021q_deconfigure(struct mlxsw_sp_fid *fid)
295 {
296 struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
297 struct mlxsw_sp_fid_8021q *fid_8021q;
298
299 fid_8021q = mlxsw_sp_fid_8021q_fid(fid);
300 mlxsw_sp_fid_vid_map(mlxsw_sp, fid->fid_index, fid_8021q->vid, false);
301 mlxsw_sp_fid_op(mlxsw_sp, fid->fid_index, 0, false);
302 }
303
304 static int mlxsw_sp_fid_8021q_index_alloc(struct mlxsw_sp_fid *fid,
305 const void *arg, u16 *p_fid_index)
306 {
307 struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
308 u16 vid = *(u16 *) arg;
309
310 /* Use 1:1 mapping for simplicity although not a must */
311 if (vid < fid_family->start_index || vid > fid_family->end_index)
312 return -EINVAL;
313 *p_fid_index = vid;
314
315 return 0;
316 }
317
318 static bool
319 mlxsw_sp_fid_8021q_compare(const struct mlxsw_sp_fid *fid, const void *arg)
320 {
321 u16 vid = *(u16 *) arg;
322
323 return mlxsw_sp_fid_8021q_fid(fid)->vid == vid;
324 }
325
326 static u16 mlxsw_sp_fid_8021q_flood_index(const struct mlxsw_sp_fid *fid)
327 {
328 return fid->fid_index;
329 }
330
331 static int mlxsw_sp_fid_8021q_port_vid_map(struct mlxsw_sp_fid *fid,
332 struct mlxsw_sp_port *mlxsw_sp_port,
333 u16 vid)
334 {
335 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
336 u8 local_port = mlxsw_sp_port->local_port;
337
338 /* In case there are no {Port, VID} => FID mappings on the port,
339 * we can use the global VID => FID mapping we created when the
340 * FID was configured.
341 */
342 if (mlxsw_sp->fid_core->port_fid_mappings[local_port] == 0)
343 return 0;
344 return __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index, local_port,
345 vid, true);
346 }
347
348 static void
349 mlxsw_sp_fid_8021q_port_vid_unmap(struct mlxsw_sp_fid *fid,
350 struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
351 {
352 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
353 u8 local_port = mlxsw_sp_port->local_port;
354
355 if (mlxsw_sp->fid_core->port_fid_mappings[local_port] == 0)
356 return;
357 __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index, local_port, vid,
358 false);
359 }
360
361 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_8021q_ops = {
362 .setup = mlxsw_sp_fid_8021q_setup,
363 .configure = mlxsw_sp_fid_8021q_configure,
364 .deconfigure = mlxsw_sp_fid_8021q_deconfigure,
365 .index_alloc = mlxsw_sp_fid_8021q_index_alloc,
366 .compare = mlxsw_sp_fid_8021q_compare,
367 .flood_index = mlxsw_sp_fid_8021q_flood_index,
368 .port_vid_map = mlxsw_sp_fid_8021q_port_vid_map,
369 .port_vid_unmap = mlxsw_sp_fid_8021q_port_vid_unmap,
370 };
371
372 static const struct mlxsw_sp_flood_table mlxsw_sp_fid_8021q_flood_tables[] = {
373 {
374 .packet_type = MLXSW_SP_FLOOD_TYPE_UC,
375 .bridge_type = MLXSW_REG_SFGC_BRIDGE_TYPE_1Q_FID,
376 .table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET,
377 .table_index = 0,
378 },
379 {
380 .packet_type = MLXSW_SP_FLOOD_TYPE_MC,
381 .bridge_type = MLXSW_REG_SFGC_BRIDGE_TYPE_1Q_FID,
382 .table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET,
383 .table_index = 1,
384 },
385 {
386 .packet_type = MLXSW_SP_FLOOD_TYPE_BC,
387 .bridge_type = MLXSW_REG_SFGC_BRIDGE_TYPE_1Q_FID,
388 .table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET,
389 .table_index = 2,
390 },
391 };
392
393 /* Range and flood configuration must match mlxsw_config_profile */
394 static const struct mlxsw_sp_fid_family mlxsw_sp_fid_8021q_family = {
395 .type = MLXSW_SP_FID_TYPE_8021Q,
396 .fid_size = sizeof(struct mlxsw_sp_fid_8021q),
397 .start_index = 1,
398 .end_index = VLAN_VID_MASK,
399 .flood_tables = mlxsw_sp_fid_8021q_flood_tables,
400 .nr_flood_tables = ARRAY_SIZE(mlxsw_sp_fid_8021q_flood_tables),
401 .rif_type = MLXSW_SP_RIF_TYPE_VLAN,
402 .ops = &mlxsw_sp_fid_8021q_ops,
403 };
404
405 static struct mlxsw_sp_fid_8021d *
406 mlxsw_sp_fid_8021d_fid(const struct mlxsw_sp_fid *fid)
407 {
408 return container_of(fid, struct mlxsw_sp_fid_8021d, common);
409 }
410
411 static void mlxsw_sp_fid_8021d_setup(struct mlxsw_sp_fid *fid, const void *arg)
412 {
413 int br_ifindex = *(int *) arg;
414
415 mlxsw_sp_fid_8021d_fid(fid)->br_ifindex = br_ifindex;
416 }
417
418 static int mlxsw_sp_fid_8021d_configure(struct mlxsw_sp_fid *fid)
419 {
420 struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
421
422 return mlxsw_sp_fid_op(fid_family->mlxsw_sp, fid->fid_index, 0, true);
423 }
424
425 static void mlxsw_sp_fid_8021d_deconfigure(struct mlxsw_sp_fid *fid)
426 {
427 mlxsw_sp_fid_op(fid->fid_family->mlxsw_sp, fid->fid_index, 0, false);
428 }
429
430 static int mlxsw_sp_fid_8021d_index_alloc(struct mlxsw_sp_fid *fid,
431 const void *arg, u16 *p_fid_index)
432 {
433 struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
434 u16 nr_fids, fid_index;
435
436 nr_fids = fid_family->end_index - fid_family->start_index + 1;
437 fid_index = find_first_zero_bit(fid_family->fids_bitmap, nr_fids);
438 if (fid_index == nr_fids)
439 return -ENOBUFS;
440 *p_fid_index = fid_family->start_index + fid_index;
441
442 return 0;
443 }
444
445 static bool
446 mlxsw_sp_fid_8021d_compare(const struct mlxsw_sp_fid *fid, const void *arg)
447 {
448 int br_ifindex = *(int *) arg;
449
450 return mlxsw_sp_fid_8021d_fid(fid)->br_ifindex == br_ifindex;
451 }
452
453 static u16 mlxsw_sp_fid_8021d_flood_index(const struct mlxsw_sp_fid *fid)
454 {
455 return fid->fid_index - fid->fid_family->start_index;
456 }
457
458 static int mlxsw_sp_port_vp_mode_trans(struct mlxsw_sp_port *mlxsw_sp_port)
459 {
460 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
461 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
462 int err;
463
464 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
465 list) {
466 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
467 u16 vid = mlxsw_sp_port_vlan->vid;
468
469 if (!fid)
470 continue;
471
472 err = __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index,
473 mlxsw_sp_port->local_port,
474 vid, true);
475 if (err)
476 goto err_fid_port_vid_map;
477 }
478
479 err = mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, true);
480 if (err)
481 goto err_port_vp_mode_set;
482
483 return 0;
484
485 err_port_vp_mode_set:
486 err_fid_port_vid_map:
487 list_for_each_entry_continue_reverse(mlxsw_sp_port_vlan,
488 &mlxsw_sp_port->vlans_list, list) {
489 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
490 u16 vid = mlxsw_sp_port_vlan->vid;
491
492 if (!fid)
493 continue;
494
495 __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index,
496 mlxsw_sp_port->local_port, vid,
497 false);
498 }
499 return err;
500 }
501
502 static void mlxsw_sp_port_vlan_mode_trans(struct mlxsw_sp_port *mlxsw_sp_port)
503 {
504 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
505 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
506
507 mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, false);
508
509 list_for_each_entry_reverse(mlxsw_sp_port_vlan,
510 &mlxsw_sp_port->vlans_list, list) {
511 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
512 u16 vid = mlxsw_sp_port_vlan->vid;
513
514 if (!fid)
515 continue;
516
517 __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index,
518 mlxsw_sp_port->local_port, vid,
519 false);
520 }
521 }
522
523 static int mlxsw_sp_fid_8021d_port_vid_map(struct mlxsw_sp_fid *fid,
524 struct mlxsw_sp_port *mlxsw_sp_port,
525 u16 vid)
526 {
527 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
528 u8 local_port = mlxsw_sp_port->local_port;
529 int err;
530
531 err = __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index,
532 mlxsw_sp_port->local_port, vid, true);
533 if (err)
534 return err;
535
536 if (mlxsw_sp->fid_core->port_fid_mappings[local_port]++ == 0) {
537 err = mlxsw_sp_port_vp_mode_trans(mlxsw_sp_port);
538 if (err)
539 goto err_port_vp_mode_trans;
540 }
541
542 return 0;
543
544 err_port_vp_mode_trans:
545 mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
546 __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index,
547 mlxsw_sp_port->local_port, vid, false);
548 return err;
549 }
550
551 static void
552 mlxsw_sp_fid_8021d_port_vid_unmap(struct mlxsw_sp_fid *fid,
553 struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
554 {
555 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
556 u8 local_port = mlxsw_sp_port->local_port;
557
558 if (mlxsw_sp->fid_core->port_fid_mappings[local_port] == 1)
559 mlxsw_sp_port_vlan_mode_trans(mlxsw_sp_port);
560 mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
561 __mlxsw_sp_fid_port_vid_map(mlxsw_sp, fid->fid_index,
562 mlxsw_sp_port->local_port, vid, false);
563 }
564
565 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_8021d_ops = {
566 .setup = mlxsw_sp_fid_8021d_setup,
567 .configure = mlxsw_sp_fid_8021d_configure,
568 .deconfigure = mlxsw_sp_fid_8021d_deconfigure,
569 .index_alloc = mlxsw_sp_fid_8021d_index_alloc,
570 .compare = mlxsw_sp_fid_8021d_compare,
571 .flood_index = mlxsw_sp_fid_8021d_flood_index,
572 .port_vid_map = mlxsw_sp_fid_8021d_port_vid_map,
573 .port_vid_unmap = mlxsw_sp_fid_8021d_port_vid_unmap,
574 };
575
576 static const struct mlxsw_sp_flood_table mlxsw_sp_fid_8021d_flood_tables[] = {
577 {
578 .packet_type = MLXSW_SP_FLOOD_TYPE_UC,
579 .bridge_type = MLXSW_REG_SFGC_BRIDGE_TYPE_VFID,
580 .table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID,
581 .table_index = 0,
582 },
583 {
584 .packet_type = MLXSW_SP_FLOOD_TYPE_MC,
585 .bridge_type = MLXSW_REG_SFGC_BRIDGE_TYPE_VFID,
586 .table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID,
587 .table_index = 1,
588 },
589 {
590 .packet_type = MLXSW_SP_FLOOD_TYPE_BC,
591 .bridge_type = MLXSW_REG_SFGC_BRIDGE_TYPE_VFID,
592 .table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID,
593 .table_index = 2,
594 },
595 };
596
597 /* Range and flood configuration must match mlxsw_config_profile */
598 static const struct mlxsw_sp_fid_family mlxsw_sp_fid_8021d_family = {
599 .type = MLXSW_SP_FID_TYPE_8021D,
600 .fid_size = sizeof(struct mlxsw_sp_fid_8021d),
601 .start_index = VLAN_N_VID,
602 .end_index = VLAN_N_VID + MLXSW_SP_FID_8021D_MAX - 1,
603 .flood_tables = mlxsw_sp_fid_8021d_flood_tables,
604 .nr_flood_tables = ARRAY_SIZE(mlxsw_sp_fid_8021d_flood_tables),
605 .rif_type = MLXSW_SP_RIF_TYPE_FID,
606 .ops = &mlxsw_sp_fid_8021d_ops,
607 };
608
609 static int mlxsw_sp_fid_rfid_configure(struct mlxsw_sp_fid *fid)
610 {
611 /* rFIDs are allocated by the device during init */
612 return 0;
613 }
614
615 static void mlxsw_sp_fid_rfid_deconfigure(struct mlxsw_sp_fid *fid)
616 {
617 }
618
619 static int mlxsw_sp_fid_rfid_index_alloc(struct mlxsw_sp_fid *fid,
620 const void *arg, u16 *p_fid_index)
621 {
622 u16 rif_index = *(u16 *) arg;
623
624 *p_fid_index = fid->fid_family->start_index + rif_index;
625
626 return 0;
627 }
628
629 static bool mlxsw_sp_fid_rfid_compare(const struct mlxsw_sp_fid *fid,
630 const void *arg)
631 {
632 u16 rif_index = *(u16 *) arg;
633
634 return fid->fid_index == rif_index + fid->fid_family->start_index;
635 }
636
637 static int mlxsw_sp_fid_rfid_port_vid_map(struct mlxsw_sp_fid *fid,
638 struct mlxsw_sp_port *mlxsw_sp_port,
639 u16 vid)
640 {
641 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
642 u8 local_port = mlxsw_sp_port->local_port;
643 int err;
644
645 /* We only need to transition the port to virtual mode since
646 * {Port, VID} => FID is done by the firmware upon RIF creation.
647 */
648 if (mlxsw_sp->fid_core->port_fid_mappings[local_port]++ == 0) {
649 err = mlxsw_sp_port_vp_mode_trans(mlxsw_sp_port);
650 if (err)
651 goto err_port_vp_mode_trans;
652 }
653
654 return 0;
655
656 err_port_vp_mode_trans:
657 mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
658 return err;
659 }
660
661 static void
662 mlxsw_sp_fid_rfid_port_vid_unmap(struct mlxsw_sp_fid *fid,
663 struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
664 {
665 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
666 u8 local_port = mlxsw_sp_port->local_port;
667
668 if (mlxsw_sp->fid_core->port_fid_mappings[local_port] == 1)
669 mlxsw_sp_port_vlan_mode_trans(mlxsw_sp_port);
670 mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
671 }
672
673 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_rfid_ops = {
674 .configure = mlxsw_sp_fid_rfid_configure,
675 .deconfigure = mlxsw_sp_fid_rfid_deconfigure,
676 .index_alloc = mlxsw_sp_fid_rfid_index_alloc,
677 .compare = mlxsw_sp_fid_rfid_compare,
678 .port_vid_map = mlxsw_sp_fid_rfid_port_vid_map,
679 .port_vid_unmap = mlxsw_sp_fid_rfid_port_vid_unmap,
680 };
681
682 #define MLXSW_SP_RFID_BASE (15 * 1024)
683 #define MLXSW_SP_RFID_MAX 1024
684
685 static const struct mlxsw_sp_fid_family mlxsw_sp_fid_rfid_family = {
686 .type = MLXSW_SP_FID_TYPE_RFID,
687 .fid_size = sizeof(struct mlxsw_sp_fid),
688 .start_index = MLXSW_SP_RFID_BASE,
689 .end_index = MLXSW_SP_RFID_BASE + MLXSW_SP_RFID_MAX - 1,
690 .rif_type = MLXSW_SP_RIF_TYPE_SUBPORT,
691 .ops = &mlxsw_sp_fid_rfid_ops,
692 };
693
694 static int mlxsw_sp_fid_dummy_configure(struct mlxsw_sp_fid *fid)
695 {
696 struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
697
698 return mlxsw_sp_fid_op(mlxsw_sp, fid->fid_index, 0, true);
699 }
700
701 static void mlxsw_sp_fid_dummy_deconfigure(struct mlxsw_sp_fid *fid)
702 {
703 mlxsw_sp_fid_op(fid->fid_family->mlxsw_sp, fid->fid_index, 0, false);
704 }
705
706 static int mlxsw_sp_fid_dummy_index_alloc(struct mlxsw_sp_fid *fid,
707 const void *arg, u16 *p_fid_index)
708 {
709 *p_fid_index = fid->fid_family->start_index;
710
711 return 0;
712 }
713
714 static bool mlxsw_sp_fid_dummy_compare(const struct mlxsw_sp_fid *fid,
715 const void *arg)
716 {
717 return true;
718 }
719
720 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_dummy_ops = {
721 .configure = mlxsw_sp_fid_dummy_configure,
722 .deconfigure = mlxsw_sp_fid_dummy_deconfigure,
723 .index_alloc = mlxsw_sp_fid_dummy_index_alloc,
724 .compare = mlxsw_sp_fid_dummy_compare,
725 };
726
727 static const struct mlxsw_sp_fid_family mlxsw_sp_fid_dummy_family = {
728 .type = MLXSW_SP_FID_TYPE_DUMMY,
729 .fid_size = sizeof(struct mlxsw_sp_fid),
730 .start_index = MLXSW_SP_RFID_BASE - 1,
731 .end_index = MLXSW_SP_RFID_BASE - 1,
732 .ops = &mlxsw_sp_fid_dummy_ops,
733 };
734
735 static const struct mlxsw_sp_fid_family *mlxsw_sp_fid_family_arr[] = {
736 [MLXSW_SP_FID_TYPE_8021Q] = &mlxsw_sp_fid_8021q_family,
737 [MLXSW_SP_FID_TYPE_8021D] = &mlxsw_sp_fid_8021d_family,
738 [MLXSW_SP_FID_TYPE_RFID] = &mlxsw_sp_fid_rfid_family,
739 [MLXSW_SP_FID_TYPE_DUMMY] = &mlxsw_sp_fid_dummy_family,
740 };
741
742 static struct mlxsw_sp_fid *mlxsw_sp_fid_get(struct mlxsw_sp *mlxsw_sp,
743 enum mlxsw_sp_fid_type type,
744 const void *arg)
745 {
746 struct mlxsw_sp_fid_family *fid_family;
747 struct mlxsw_sp_fid *fid;
748 u16 fid_index;
749 int err;
750
751 fid_family = mlxsw_sp->fid_core->fid_family_arr[type];
752 list_for_each_entry(fid, &fid_family->fids_list, list) {
753 if (!fid->fid_family->ops->compare(fid, arg))
754 continue;
755 fid->ref_count++;
756 return fid;
757 }
758
759 fid = kzalloc(fid_family->fid_size, GFP_KERNEL);
760 if (!fid)
761 return ERR_PTR(-ENOMEM);
762 fid->fid_family = fid_family;
763
764 err = fid->fid_family->ops->index_alloc(fid, arg, &fid_index);
765 if (err)
766 goto err_index_alloc;
767 fid->fid_index = fid_index;
768 __set_bit(fid_index - fid_family->start_index, fid_family->fids_bitmap);
769
770 if (fid->fid_family->ops->setup)
771 fid->fid_family->ops->setup(fid, arg);
772
773 err = fid->fid_family->ops->configure(fid);
774 if (err)
775 goto err_configure;
776
777 list_add(&fid->list, &fid_family->fids_list);
778 fid->ref_count++;
779 return fid;
780
781 err_configure:
782 __clear_bit(fid_index - fid_family->start_index,
783 fid_family->fids_bitmap);
784 err_index_alloc:
785 kfree(fid);
786 return ERR_PTR(err);
787 }
788
789 void mlxsw_sp_fid_put(struct mlxsw_sp_fid *fid)
790 {
791 struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
792
793 if (--fid->ref_count == 1 && fid->rif) {
794 /* Destroy the associated RIF and let it drop the last
795 * reference on the FID.
796 */
797 return mlxsw_sp_rif_destroy(fid->rif);
798 } else if (fid->ref_count == 0) {
799 list_del(&fid->list);
800 fid->fid_family->ops->deconfigure(fid);
801 __clear_bit(fid->fid_index - fid_family->start_index,
802 fid_family->fids_bitmap);
803 kfree(fid);
804 }
805 }
806
807 struct mlxsw_sp_fid *mlxsw_sp_fid_8021q_get(struct mlxsw_sp *mlxsw_sp, u16 vid)
808 {
809 return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_8021Q, &vid);
810 }
811
812 struct mlxsw_sp_fid *mlxsw_sp_fid_8021d_get(struct mlxsw_sp *mlxsw_sp,
813 int br_ifindex)
814 {
815 return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_8021D, &br_ifindex);
816 }
817
818 struct mlxsw_sp_fid *mlxsw_sp_fid_rfid_get(struct mlxsw_sp *mlxsw_sp,
819 u16 rif_index)
820 {
821 return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_RFID, &rif_index);
822 }
823
824 struct mlxsw_sp_fid *mlxsw_sp_fid_dummy_get(struct mlxsw_sp *mlxsw_sp)
825 {
826 return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_DUMMY, NULL);
827 }
828
829 static int
830 mlxsw_sp_fid_flood_table_init(struct mlxsw_sp_fid_family *fid_family,
831 const struct mlxsw_sp_flood_table *flood_table)
832 {
833 enum mlxsw_sp_flood_type packet_type = flood_table->packet_type;
834 const int *sfgc_packet_types;
835 int i;
836
837 sfgc_packet_types = mlxsw_sp_packet_type_sfgc_types[packet_type];
838 for (i = 0; i < MLXSW_REG_SFGC_TYPE_MAX; i++) {
839 struct mlxsw_sp *mlxsw_sp = fid_family->mlxsw_sp;
840 char sfgc_pl[MLXSW_REG_SFGC_LEN];
841 int err;
842
843 if (!sfgc_packet_types[i])
844 continue;
845 mlxsw_reg_sfgc_pack(sfgc_pl, i, flood_table->bridge_type,
846 flood_table->table_type,
847 flood_table->table_index);
848 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfgc), sfgc_pl);
849 if (err)
850 return err;
851 }
852
853 return 0;
854 }
855
856 static int
857 mlxsw_sp_fid_flood_tables_init(struct mlxsw_sp_fid_family *fid_family)
858 {
859 int i;
860
861 for (i = 0; i < fid_family->nr_flood_tables; i++) {
862 const struct mlxsw_sp_flood_table *flood_table;
863 int err;
864
865 flood_table = &fid_family->flood_tables[i];
866 err = mlxsw_sp_fid_flood_table_init(fid_family, flood_table);
867 if (err)
868 return err;
869 }
870
871 return 0;
872 }
873
874 static int mlxsw_sp_fid_family_register(struct mlxsw_sp *mlxsw_sp,
875 const struct mlxsw_sp_fid_family *tmpl)
876 {
877 u16 nr_fids = tmpl->end_index - tmpl->start_index + 1;
878 struct mlxsw_sp_fid_family *fid_family;
879 int err;
880
881 fid_family = kmemdup(tmpl, sizeof(*fid_family), GFP_KERNEL);
882 if (!fid_family)
883 return -ENOMEM;
884
885 fid_family->mlxsw_sp = mlxsw_sp;
886 INIT_LIST_HEAD(&fid_family->fids_list);
887 fid_family->fids_bitmap = kcalloc(BITS_TO_LONGS(nr_fids),
888 sizeof(unsigned long), GFP_KERNEL);
889 if (!fid_family->fids_bitmap) {
890 err = -ENOMEM;
891 goto err_alloc_fids_bitmap;
892 }
893
894 if (fid_family->flood_tables) {
895 err = mlxsw_sp_fid_flood_tables_init(fid_family);
896 if (err)
897 goto err_fid_flood_tables_init;
898 }
899
900 mlxsw_sp->fid_core->fid_family_arr[tmpl->type] = fid_family;
901
902 return 0;
903
904 err_fid_flood_tables_init:
905 kfree(fid_family->fids_bitmap);
906 err_alloc_fids_bitmap:
907 kfree(fid_family);
908 return err;
909 }
910
911 static void
912 mlxsw_sp_fid_family_unregister(struct mlxsw_sp *mlxsw_sp,
913 struct mlxsw_sp_fid_family *fid_family)
914 {
915 mlxsw_sp->fid_core->fid_family_arr[fid_family->type] = NULL;
916 kfree(fid_family->fids_bitmap);
917 WARN_ON_ONCE(!list_empty(&fid_family->fids_list));
918 kfree(fid_family);
919 }
920
921 int mlxsw_sp_port_fids_init(struct mlxsw_sp_port *mlxsw_sp_port)
922 {
923 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
924
925 /* Track number of FIDs configured on the port with mapping type
926 * PORT_VID_TO_FID, so that we know when to transition the port
927 * back to non-virtual (VLAN) mode.
928 */
929 mlxsw_sp->fid_core->port_fid_mappings[mlxsw_sp_port->local_port] = 0;
930
931 return mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, false);
932 }
933
934 void mlxsw_sp_port_fids_fini(struct mlxsw_sp_port *mlxsw_sp_port)
935 {
936 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
937
938 mlxsw_sp->fid_core->port_fid_mappings[mlxsw_sp_port->local_port] = 0;
939 }
940
941 int mlxsw_sp_fids_init(struct mlxsw_sp *mlxsw_sp)
942 {
943 unsigned int max_ports = mlxsw_core_max_ports(mlxsw_sp->core);
944 struct mlxsw_sp_fid_core *fid_core;
945 int err, i;
946
947 fid_core = kzalloc(sizeof(*mlxsw_sp->fid_core), GFP_KERNEL);
948 if (!fid_core)
949 return -ENOMEM;
950 mlxsw_sp->fid_core = fid_core;
951
952 fid_core->port_fid_mappings = kcalloc(max_ports, sizeof(unsigned int),
953 GFP_KERNEL);
954 if (!fid_core->port_fid_mappings) {
955 err = -ENOMEM;
956 goto err_alloc_port_fid_mappings;
957 }
958
959 for (i = 0; i < MLXSW_SP_FID_TYPE_MAX; i++) {
960 err = mlxsw_sp_fid_family_register(mlxsw_sp,
961 mlxsw_sp_fid_family_arr[i]);
962
963 if (err)
964 goto err_fid_ops_register;
965 }
966
967 return 0;
968
969 err_fid_ops_register:
970 for (i--; i >= 0; i--) {
971 struct mlxsw_sp_fid_family *fid_family;
972
973 fid_family = fid_core->fid_family_arr[i];
974 mlxsw_sp_fid_family_unregister(mlxsw_sp, fid_family);
975 }
976 kfree(fid_core->port_fid_mappings);
977 err_alloc_port_fid_mappings:
978 kfree(fid_core);
979 return err;
980 }
981
982 void mlxsw_sp_fids_fini(struct mlxsw_sp *mlxsw_sp)
983 {
984 struct mlxsw_sp_fid_core *fid_core = mlxsw_sp->fid_core;
985 int i;
986
987 for (i = 0; i < MLXSW_SP_FID_TYPE_MAX; i++)
988 mlxsw_sp_fid_family_unregister(mlxsw_sp,
989 fid_core->fid_family_arr[i]);
990 kfree(fid_core->port_fid_mappings);
991 kfree(fid_core);
992 }
CRIS linux kernel tree