1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright 2019-2021 NXP
4 * This is an umbrella module for all network switches that are
5 * register-compatible with Ocelot and that perform I/O to their host CPU
6 * through an NPI (Node Processor Interface) Ethernet port.
8 #include <uapi/linux/if_bridge.h>
9 #include <soc/mscc/ocelot_vcap.h>
10 #include <soc/mscc/ocelot_qsys.h>
11 #include <soc/mscc/ocelot_sys.h>
12 #include <soc/mscc/ocelot_dev.h>
13 #include <soc/mscc/ocelot_ana.h>
14 #include <soc/mscc/ocelot_ptp.h>
15 #include <soc/mscc/ocelot.h>
16 #include <linux/dsa/8021q.h>
17 #include <linux/dsa/ocelot.h>
18 #include <linux/platform_device.h>
19 #include <linux/ptp_classify.h>
20 #include <linux/module.h>
21 #include <linux/of_net.h>
22 #include <linux/pci.h>
24 #include <linux/pcs-lynx.h>
25 #include <net/pkt_sched.h>
29 static int felix_tag_8021q_rxvlan_add(struct felix
*felix
, int port
, u16 vid
,
30 bool pvid
, bool untagged
)
32 struct ocelot_vcap_filter
*outer_tagging_rule
;
33 struct ocelot
*ocelot
= &felix
->ocelot
;
34 struct dsa_switch
*ds
= felix
->ds
;
35 int key_length
, upstream
, err
;
37 /* We don't need to install the rxvlan into the other ports' filtering
38 * tables, because we're just pushing the rxvlan when sending towards
44 key_length
= ocelot
->vcap
[VCAP_ES0
].keys
[VCAP_ES0_IGR_PORT
].length
;
45 upstream
= dsa_upstream_port(ds
, port
);
47 outer_tagging_rule
= kzalloc(sizeof(struct ocelot_vcap_filter
),
49 if (!outer_tagging_rule
)
52 outer_tagging_rule
->key_type
= OCELOT_VCAP_KEY_ANY
;
53 outer_tagging_rule
->prio
= 1;
54 outer_tagging_rule
->id
.cookie
= port
;
55 outer_tagging_rule
->id
.tc_offload
= false;
56 outer_tagging_rule
->block_id
= VCAP_ES0
;
57 outer_tagging_rule
->type
= OCELOT_VCAP_FILTER_OFFLOAD
;
58 outer_tagging_rule
->lookup
= 0;
59 outer_tagging_rule
->ingress_port
.value
= port
;
60 outer_tagging_rule
->ingress_port
.mask
= GENMASK(key_length
- 1, 0);
61 outer_tagging_rule
->egress_port
.value
= upstream
;
62 outer_tagging_rule
->egress_port
.mask
= GENMASK(key_length
- 1, 0);
63 outer_tagging_rule
->action
.push_outer_tag
= OCELOT_ES0_TAG
;
64 outer_tagging_rule
->action
.tag_a_tpid_sel
= OCELOT_TAG_TPID_SEL_8021AD
;
65 outer_tagging_rule
->action
.tag_a_vid_sel
= 1;
66 outer_tagging_rule
->action
.vid_a_val
= vid
;
68 err
= ocelot_vcap_filter_add(ocelot
, outer_tagging_rule
, NULL
);
70 kfree(outer_tagging_rule
);
75 static int felix_tag_8021q_txvlan_add(struct felix
*felix
, int port
, u16 vid
,
76 bool pvid
, bool untagged
)
78 struct ocelot_vcap_filter
*untagging_rule
, *redirect_rule
;
79 struct ocelot
*ocelot
= &felix
->ocelot
;
80 struct dsa_switch
*ds
= felix
->ds
;
83 /* tag_8021q.c assumes we are implementing this via port VLAN
84 * membership, which we aren't. So we don't need to add any VCAP filter
87 if (ocelot
->ports
[port
]->is_dsa_8021q_cpu
)
90 untagging_rule
= kzalloc(sizeof(struct ocelot_vcap_filter
), GFP_KERNEL
);
94 redirect_rule
= kzalloc(sizeof(struct ocelot_vcap_filter
), GFP_KERNEL
);
96 kfree(untagging_rule
);
100 upstream
= dsa_upstream_port(ds
, port
);
102 untagging_rule
->key_type
= OCELOT_VCAP_KEY_ANY
;
103 untagging_rule
->ingress_port_mask
= BIT(upstream
);
104 untagging_rule
->vlan
.vid
.value
= vid
;
105 untagging_rule
->vlan
.vid
.mask
= VLAN_VID_MASK
;
106 untagging_rule
->prio
= 1;
107 untagging_rule
->id
.cookie
= port
;
108 untagging_rule
->id
.tc_offload
= false;
109 untagging_rule
->block_id
= VCAP_IS1
;
110 untagging_rule
->type
= OCELOT_VCAP_FILTER_OFFLOAD
;
111 untagging_rule
->lookup
= 0;
112 untagging_rule
->action
.vlan_pop_cnt_ena
= true;
113 untagging_rule
->action
.vlan_pop_cnt
= 1;
114 untagging_rule
->action
.pag_override_mask
= 0xff;
115 untagging_rule
->action
.pag_val
= port
;
117 err
= ocelot_vcap_filter_add(ocelot
, untagging_rule
, NULL
);
119 kfree(untagging_rule
);
120 kfree(redirect_rule
);
124 redirect_rule
->key_type
= OCELOT_VCAP_KEY_ANY
;
125 redirect_rule
->ingress_port_mask
= BIT(upstream
);
126 redirect_rule
->pag
= port
;
127 redirect_rule
->prio
= 1;
128 redirect_rule
->id
.cookie
= port
;
129 redirect_rule
->id
.tc_offload
= false;
130 redirect_rule
->block_id
= VCAP_IS2
;
131 redirect_rule
->type
= OCELOT_VCAP_FILTER_OFFLOAD
;
132 redirect_rule
->lookup
= 0;
133 redirect_rule
->action
.mask_mode
= OCELOT_MASK_MODE_REDIRECT
;
134 redirect_rule
->action
.port_mask
= BIT(port
);
136 err
= ocelot_vcap_filter_add(ocelot
, redirect_rule
, NULL
);
138 ocelot_vcap_filter_del(ocelot
, untagging_rule
);
139 kfree(redirect_rule
);
146 static int felix_tag_8021q_vlan_add(struct dsa_switch
*ds
, int port
, u16 vid
,
149 bool untagged
= flags
& BRIDGE_VLAN_INFO_UNTAGGED
;
150 bool pvid
= flags
& BRIDGE_VLAN_INFO_PVID
;
151 struct ocelot
*ocelot
= ds
->priv
;
153 if (vid_is_dsa_8021q_rxvlan(vid
))
154 return felix_tag_8021q_rxvlan_add(ocelot_to_felix(ocelot
),
155 port
, vid
, pvid
, untagged
);
157 if (vid_is_dsa_8021q_txvlan(vid
))
158 return felix_tag_8021q_txvlan_add(ocelot_to_felix(ocelot
),
159 port
, vid
, pvid
, untagged
);
164 static int felix_tag_8021q_rxvlan_del(struct felix
*felix
, int port
, u16 vid
)
166 struct ocelot_vcap_filter
*outer_tagging_rule
;
167 struct ocelot_vcap_block
*block_vcap_es0
;
168 struct ocelot
*ocelot
= &felix
->ocelot
;
170 block_vcap_es0
= &ocelot
->block
[VCAP_ES0
];
172 outer_tagging_rule
= ocelot_vcap_block_find_filter_by_id(block_vcap_es0
,
174 /* In rxvlan_add, we had the "if (!pvid) return 0" logic to avoid
175 * installing outer tagging ES0 rules where they weren't needed.
176 * But in rxvlan_del, the API doesn't give us the "flags" anymore,
177 * so that forces us to be slightly sloppy here, and just assume that
178 * if we didn't find an outer_tagging_rule it means that there was
179 * none in the first place, i.e. rxvlan_del is called on a non-pvid
180 * port. This is most probably true though.
182 if (!outer_tagging_rule
)
185 return ocelot_vcap_filter_del(ocelot
, outer_tagging_rule
);
188 static int felix_tag_8021q_txvlan_del(struct felix
*felix
, int port
, u16 vid
)
190 struct ocelot_vcap_filter
*untagging_rule
, *redirect_rule
;
191 struct ocelot_vcap_block
*block_vcap_is1
;
192 struct ocelot_vcap_block
*block_vcap_is2
;
193 struct ocelot
*ocelot
= &felix
->ocelot
;
196 if (ocelot
->ports
[port
]->is_dsa_8021q_cpu
)
199 block_vcap_is1
= &ocelot
->block
[VCAP_IS1
];
200 block_vcap_is2
= &ocelot
->block
[VCAP_IS2
];
202 untagging_rule
= ocelot_vcap_block_find_filter_by_id(block_vcap_is1
,
207 err
= ocelot_vcap_filter_del(ocelot
, untagging_rule
);
211 redirect_rule
= ocelot_vcap_block_find_filter_by_id(block_vcap_is2
,
216 return ocelot_vcap_filter_del(ocelot
, redirect_rule
);
219 static int felix_tag_8021q_vlan_del(struct dsa_switch
*ds
, int port
, u16 vid
)
221 struct ocelot
*ocelot
= ds
->priv
;
223 if (vid_is_dsa_8021q_rxvlan(vid
))
224 return felix_tag_8021q_rxvlan_del(ocelot_to_felix(ocelot
),
227 if (vid_is_dsa_8021q_txvlan(vid
))
228 return felix_tag_8021q_txvlan_del(ocelot_to_felix(ocelot
),
234 /* Alternatively to using the NPI functionality, that same hardware MAC
235 * connected internally to the enetc or fman DSA master can be configured to
236 * use the software-defined tag_8021q frame format. As far as the hardware is
237 * concerned, it thinks it is a "dumb switch" - the queues of the CPU port
238 * module are now disconnected from it, but can still be accessed through
239 * register-based MMIO.
241 static void felix_8021q_cpu_port_init(struct ocelot
*ocelot
, int port
)
243 ocelot
->ports
[port
]->is_dsa_8021q_cpu
= true;
246 /* Overwrite PGID_CPU with the non-tagging port */
247 ocelot_write_rix(ocelot
, BIT(port
), ANA_PGID_PGID
, PGID_CPU
);
249 ocelot_apply_bridge_fwd_mask(ocelot
);
252 static void felix_8021q_cpu_port_deinit(struct ocelot
*ocelot
, int port
)
254 ocelot
->ports
[port
]->is_dsa_8021q_cpu
= false;
256 /* Restore PGID_CPU */
257 ocelot_write_rix(ocelot
, BIT(ocelot
->num_phys_ports
), ANA_PGID_PGID
,
260 ocelot_apply_bridge_fwd_mask(ocelot
);
263 /* Set up a VCAP IS2 rule for delivering PTP frames to the CPU port module.
264 * If the quirk_no_xtr_irq is in place, then also copy those PTP frames to the
265 * tag_8021q CPU port.
267 static int felix_setup_mmio_filtering(struct felix
*felix
)
269 unsigned long user_ports
= dsa_user_ports(felix
->ds
);
270 struct ocelot_vcap_filter
*redirect_rule
;
271 struct ocelot_vcap_filter
*tagging_rule
;
272 struct ocelot
*ocelot
= &felix
->ocelot
;
273 struct dsa_switch
*ds
= felix
->ds
;
274 int cpu
= -1, port
, ret
;
276 tagging_rule
= kzalloc(sizeof(struct ocelot_vcap_filter
), GFP_KERNEL
);
280 redirect_rule
= kzalloc(sizeof(struct ocelot_vcap_filter
), GFP_KERNEL
);
281 if (!redirect_rule
) {
286 for (port
= 0; port
< ocelot
->num_phys_ports
; port
++) {
287 if (dsa_is_cpu_port(ds
, port
)) {
296 tagging_rule
->key_type
= OCELOT_VCAP_KEY_ETYPE
;
297 *(__be16
*)tagging_rule
->key
.etype
.etype
.value
= htons(ETH_P_1588
);
298 *(__be16
*)tagging_rule
->key
.etype
.etype
.mask
= htons(0xffff);
299 tagging_rule
->ingress_port_mask
= user_ports
;
300 tagging_rule
->prio
= 1;
301 tagging_rule
->id
.cookie
= ocelot
->num_phys_ports
;
302 tagging_rule
->id
.tc_offload
= false;
303 tagging_rule
->block_id
= VCAP_IS1
;
304 tagging_rule
->type
= OCELOT_VCAP_FILTER_OFFLOAD
;
305 tagging_rule
->lookup
= 0;
306 tagging_rule
->action
.pag_override_mask
= 0xff;
307 tagging_rule
->action
.pag_val
= ocelot
->num_phys_ports
;
309 ret
= ocelot_vcap_filter_add(ocelot
, tagging_rule
, NULL
);
312 kfree(redirect_rule
);
316 redirect_rule
->key_type
= OCELOT_VCAP_KEY_ANY
;
317 redirect_rule
->ingress_port_mask
= user_ports
;
318 redirect_rule
->pag
= ocelot
->num_phys_ports
;
319 redirect_rule
->prio
= 1;
320 redirect_rule
->id
.cookie
= ocelot
->num_phys_ports
;
321 redirect_rule
->id
.tc_offload
= false;
322 redirect_rule
->block_id
= VCAP_IS2
;
323 redirect_rule
->type
= OCELOT_VCAP_FILTER_OFFLOAD
;
324 redirect_rule
->lookup
= 0;
325 redirect_rule
->action
.cpu_copy_ena
= true;
326 if (felix
->info
->quirk_no_xtr_irq
) {
327 /* Redirect to the tag_8021q CPU but also copy PTP packets to
328 * the CPU port module
330 redirect_rule
->action
.mask_mode
= OCELOT_MASK_MODE_REDIRECT
;
331 redirect_rule
->action
.port_mask
= BIT(cpu
);
333 /* Trap PTP packets only to the CPU port module (which is
334 * redirected to the NPI port)
336 redirect_rule
->action
.mask_mode
= OCELOT_MASK_MODE_PERMIT_DENY
;
337 redirect_rule
->action
.port_mask
= 0;
340 ret
= ocelot_vcap_filter_add(ocelot
, redirect_rule
, NULL
);
342 ocelot_vcap_filter_del(ocelot
, tagging_rule
);
343 kfree(redirect_rule
);
347 /* The ownership of the CPU port module's queues might have just been
348 * transferred to the tag_8021q tagger from the NPI-based tagger.
349 * So there might still be all sorts of crap in the queues. On the
350 * other hand, the MMIO-based matching of PTP frames is very brittle,
351 * so we need to be careful that there are no extra frames to be
352 * dequeued over MMIO, since we would never know to discard them.
354 ocelot_drain_cpu_queue(ocelot
, 0);
359 static int felix_teardown_mmio_filtering(struct felix
*felix
)
361 struct ocelot_vcap_filter
*tagging_rule
, *redirect_rule
;
362 struct ocelot_vcap_block
*block_vcap_is1
;
363 struct ocelot_vcap_block
*block_vcap_is2
;
364 struct ocelot
*ocelot
= &felix
->ocelot
;
367 block_vcap_is1
= &ocelot
->block
[VCAP_IS1
];
368 block_vcap_is2
= &ocelot
->block
[VCAP_IS2
];
370 tagging_rule
= ocelot_vcap_block_find_filter_by_id(block_vcap_is1
,
371 ocelot
->num_phys_ports
,
376 err
= ocelot_vcap_filter_del(ocelot
, tagging_rule
);
380 redirect_rule
= ocelot_vcap_block_find_filter_by_id(block_vcap_is2
,
381 ocelot
->num_phys_ports
,
386 return ocelot_vcap_filter_del(ocelot
, redirect_rule
);
389 static int felix_setup_tag_8021q(struct dsa_switch
*ds
, int cpu
)
391 struct ocelot
*ocelot
= ds
->priv
;
392 struct felix
*felix
= ocelot_to_felix(ocelot
);
393 unsigned long cpu_flood
;
396 felix_8021q_cpu_port_init(ocelot
, cpu
);
398 for (port
= 0; port
< ds
->num_ports
; port
++) {
399 if (dsa_is_unused_port(ds
, port
))
402 /* This overwrites ocelot_init():
403 * Do not forward BPDU frames to the CPU port module,
405 * - When these packets are injected from the tag_8021q
406 * CPU port, we want them to go out, not loop back
408 * - STP traffic ingressing on a user port should go to
409 * the tag_8021q CPU port, not to the hardware CPU
412 ocelot_write_gix(ocelot
,
413 ANA_PORT_CPU_FWD_BPDU_CFG_BPDU_REDIR_ENA(0),
414 ANA_PORT_CPU_FWD_BPDU_CFG
, port
);
417 /* In tag_8021q mode, the CPU port module is unused, except for PTP
418 * frames. So we want to disable flooding of any kind to the CPU port
419 * module, since packets going there will end in a black hole.
421 cpu_flood
= ANA_PGID_PGID_PGID(BIT(ocelot
->num_phys_ports
));
422 ocelot_rmw_rix(ocelot
, 0, cpu_flood
, ANA_PGID_PGID
, PGID_UC
);
423 ocelot_rmw_rix(ocelot
, 0, cpu_flood
, ANA_PGID_PGID
, PGID_MC
);
424 ocelot_rmw_rix(ocelot
, 0, cpu_flood
, ANA_PGID_PGID
, PGID_BC
);
426 err
= dsa_tag_8021q_register(ds
, htons(ETH_P_8021AD
));
430 err
= felix_setup_mmio_filtering(felix
);
432 goto out_tag_8021q_unregister
;
436 out_tag_8021q_unregister
:
437 dsa_tag_8021q_unregister(ds
);
441 static void felix_teardown_tag_8021q(struct dsa_switch
*ds
, int cpu
)
443 struct ocelot
*ocelot
= ds
->priv
;
444 struct felix
*felix
= ocelot_to_felix(ocelot
);
447 err
= felix_teardown_mmio_filtering(felix
);
449 dev_err(ds
->dev
, "felix_teardown_mmio_filtering returned %d",
452 dsa_tag_8021q_unregister(ds
);
454 for (port
= 0; port
< ds
->num_ports
; port
++) {
455 if (dsa_is_unused_port(ds
, port
))
458 /* Restore the logic from ocelot_init:
459 * do not forward BPDU frames to the front ports.
461 ocelot_write_gix(ocelot
,
462 ANA_PORT_CPU_FWD_BPDU_CFG_BPDU_REDIR_ENA(0xffff),
463 ANA_PORT_CPU_FWD_BPDU_CFG
,
467 felix_8021q_cpu_port_deinit(ocelot
, cpu
);
470 /* The CPU port module is connected to the Node Processor Interface (NPI). This
471 * is the mode through which frames can be injected from and extracted to an
472 * external CPU, over Ethernet. In NXP SoCs, the "external CPU" is the ARM CPU
473 * running Linux, and this forms a DSA setup together with the enetc or fman
476 static void felix_npi_port_init(struct ocelot
*ocelot
, int port
)
480 ocelot_write(ocelot
, QSYS_EXT_CPU_CFG_EXT_CPUQ_MSK_M
|
481 QSYS_EXT_CPU_CFG_EXT_CPU_PORT(port
),
484 /* NPI port Injection/Extraction configuration */
485 ocelot_fields_write(ocelot
, port
, SYS_PORT_MODE_INCL_XTR_HDR
,
486 ocelot
->npi_xtr_prefix
);
487 ocelot_fields_write(ocelot
, port
, SYS_PORT_MODE_INCL_INJ_HDR
,
488 ocelot
->npi_inj_prefix
);
490 /* Disable transmission of pause frames */
491 ocelot_fields_write(ocelot
, port
, SYS_PAUSE_CFG_PAUSE_ENA
, 0);
494 static void felix_npi_port_deinit(struct ocelot
*ocelot
, int port
)
496 /* Restore hardware defaults */
497 int unused_port
= ocelot
->num_phys_ports
+ 2;
501 ocelot_write(ocelot
, QSYS_EXT_CPU_CFG_EXT_CPU_PORT(unused_port
),
504 ocelot_fields_write(ocelot
, port
, SYS_PORT_MODE_INCL_XTR_HDR
,
505 OCELOT_TAG_PREFIX_DISABLED
);
506 ocelot_fields_write(ocelot
, port
, SYS_PORT_MODE_INCL_INJ_HDR
,
507 OCELOT_TAG_PREFIX_DISABLED
);
509 /* Enable transmission of pause frames */
510 ocelot_fields_write(ocelot
, port
, SYS_PAUSE_CFG_PAUSE_ENA
, 1);
513 static int felix_setup_tag_npi(struct dsa_switch
*ds
, int cpu
)
515 struct ocelot
*ocelot
= ds
->priv
;
516 unsigned long cpu_flood
;
518 felix_npi_port_init(ocelot
, cpu
);
520 /* Include the CPU port module (and indirectly, the NPI port)
521 * in the forwarding mask for unknown unicast - the hardware
522 * default value for ANA_FLOODING_FLD_UNICAST excludes
523 * BIT(ocelot->num_phys_ports), and so does ocelot_init,
524 * since Ocelot relies on whitelisting MAC addresses towards
526 * We do this because DSA does not yet perform RX filtering,
527 * and the NPI port does not perform source address learning,
528 * so traffic sent to Linux is effectively unknown from the
529 * switch's perspective.
531 cpu_flood
= ANA_PGID_PGID_PGID(BIT(ocelot
->num_phys_ports
));
532 ocelot_rmw_rix(ocelot
, cpu_flood
, cpu_flood
, ANA_PGID_PGID
, PGID_UC
);
533 ocelot_rmw_rix(ocelot
, cpu_flood
, cpu_flood
, ANA_PGID_PGID
, PGID_MC
);
534 ocelot_rmw_rix(ocelot
, cpu_flood
, cpu_flood
, ANA_PGID_PGID
, PGID_BC
);
539 static void felix_teardown_tag_npi(struct dsa_switch
*ds
, int cpu
)
541 struct ocelot
*ocelot
= ds
->priv
;
543 felix_npi_port_deinit(ocelot
, cpu
);
546 static int felix_set_tag_protocol(struct dsa_switch
*ds
, int cpu
,
547 enum dsa_tag_protocol proto
)
552 case DSA_TAG_PROTO_SEVILLE
:
553 case DSA_TAG_PROTO_OCELOT
:
554 err
= felix_setup_tag_npi(ds
, cpu
);
556 case DSA_TAG_PROTO_OCELOT_8021Q
:
557 err
= felix_setup_tag_8021q(ds
, cpu
);
560 err
= -EPROTONOSUPPORT
;
566 static void felix_del_tag_protocol(struct dsa_switch
*ds
, int cpu
,
567 enum dsa_tag_protocol proto
)
570 case DSA_TAG_PROTO_SEVILLE
:
571 case DSA_TAG_PROTO_OCELOT
:
572 felix_teardown_tag_npi(ds
, cpu
);
574 case DSA_TAG_PROTO_OCELOT_8021Q
:
575 felix_teardown_tag_8021q(ds
, cpu
);
582 /* This always leaves the switch in a consistent state, because although the
583 * tag_8021q setup can fail, the NPI setup can't. So either the change is made,
584 * or the restoration is guaranteed to work.
586 static int felix_change_tag_protocol(struct dsa_switch
*ds
, int cpu
,
587 enum dsa_tag_protocol proto
)
589 struct ocelot
*ocelot
= ds
->priv
;
590 struct felix
*felix
= ocelot_to_felix(ocelot
);
591 enum dsa_tag_protocol old_proto
= felix
->tag_proto
;
594 if (proto
!= DSA_TAG_PROTO_SEVILLE
&&
595 proto
!= DSA_TAG_PROTO_OCELOT
&&
596 proto
!= DSA_TAG_PROTO_OCELOT_8021Q
)
597 return -EPROTONOSUPPORT
;
599 felix_del_tag_protocol(ds
, cpu
, old_proto
);
601 err
= felix_set_tag_protocol(ds
, cpu
, proto
);
603 felix_set_tag_protocol(ds
, cpu
, old_proto
);
607 felix
->tag_proto
= proto
;
612 static enum dsa_tag_protocol
felix_get_tag_protocol(struct dsa_switch
*ds
,
614 enum dsa_tag_protocol mp
)
616 struct ocelot
*ocelot
= ds
->priv
;
617 struct felix
*felix
= ocelot_to_felix(ocelot
);
619 return felix
->tag_proto
;
622 static int felix_set_ageing_time(struct dsa_switch
*ds
,
623 unsigned int ageing_time
)
625 struct ocelot
*ocelot
= ds
->priv
;
627 ocelot_set_ageing_time(ocelot
, ageing_time
);
632 static int felix_fdb_dump(struct dsa_switch
*ds
, int port
,
633 dsa_fdb_dump_cb_t
*cb
, void *data
)
635 struct ocelot
*ocelot
= ds
->priv
;
637 return ocelot_fdb_dump(ocelot
, port
, cb
, data
);
640 static int felix_fdb_add(struct dsa_switch
*ds
, int port
,
641 const unsigned char *addr
, u16 vid
)
643 struct ocelot
*ocelot
= ds
->priv
;
645 return ocelot_fdb_add(ocelot
, port
, addr
, vid
);
648 static int felix_fdb_del(struct dsa_switch
*ds
, int port
,
649 const unsigned char *addr
, u16 vid
)
651 struct ocelot
*ocelot
= ds
->priv
;
653 return ocelot_fdb_del(ocelot
, port
, addr
, vid
);
656 static int felix_mdb_add(struct dsa_switch
*ds
, int port
,
657 const struct switchdev_obj_port_mdb
*mdb
)
659 struct ocelot
*ocelot
= ds
->priv
;
661 return ocelot_port_mdb_add(ocelot
, port
, mdb
);
664 static int felix_mdb_del(struct dsa_switch
*ds
, int port
,
665 const struct switchdev_obj_port_mdb
*mdb
)
667 struct ocelot
*ocelot
= ds
->priv
;
669 return ocelot_port_mdb_del(ocelot
, port
, mdb
);
672 static void felix_bridge_stp_state_set(struct dsa_switch
*ds
, int port
,
675 struct ocelot
*ocelot
= ds
->priv
;
677 return ocelot_bridge_stp_state_set(ocelot
, port
, state
);
680 static int felix_pre_bridge_flags(struct dsa_switch
*ds
, int port
,
681 struct switchdev_brport_flags val
,
682 struct netlink_ext_ack
*extack
)
684 struct ocelot
*ocelot
= ds
->priv
;
686 return ocelot_port_pre_bridge_flags(ocelot
, port
, val
);
689 static int felix_bridge_flags(struct dsa_switch
*ds
, int port
,
690 struct switchdev_brport_flags val
,
691 struct netlink_ext_ack
*extack
)
693 struct ocelot
*ocelot
= ds
->priv
;
695 ocelot_port_bridge_flags(ocelot
, port
, val
);
700 static int felix_bridge_join(struct dsa_switch
*ds
, int port
,
701 struct net_device
*br
)
703 struct ocelot
*ocelot
= ds
->priv
;
705 ocelot_port_bridge_join(ocelot
, port
, br
);
710 static void felix_bridge_leave(struct dsa_switch
*ds
, int port
,
711 struct net_device
*br
)
713 struct ocelot
*ocelot
= ds
->priv
;
715 ocelot_port_bridge_leave(ocelot
, port
, br
);
718 static int felix_lag_join(struct dsa_switch
*ds
, int port
,
719 struct net_device
*bond
,
720 struct netdev_lag_upper_info
*info
)
722 struct ocelot
*ocelot
= ds
->priv
;
724 return ocelot_port_lag_join(ocelot
, port
, bond
, info
);
727 static int felix_lag_leave(struct dsa_switch
*ds
, int port
,
728 struct net_device
*bond
)
730 struct ocelot
*ocelot
= ds
->priv
;
732 ocelot_port_lag_leave(ocelot
, port
, bond
);
737 static int felix_lag_change(struct dsa_switch
*ds
, int port
)
739 struct dsa_port
*dp
= dsa_to_port(ds
, port
);
740 struct ocelot
*ocelot
= ds
->priv
;
742 ocelot_port_lag_change(ocelot
, port
, dp
->lag_tx_enabled
);
747 static int felix_vlan_prepare(struct dsa_switch
*ds
, int port
,
748 const struct switchdev_obj_port_vlan
*vlan
,
749 struct netlink_ext_ack
*extack
)
751 struct ocelot
*ocelot
= ds
->priv
;
752 u16 flags
= vlan
->flags
;
754 /* Ocelot switches copy frames as-is to the CPU, so the flags:
755 * egress-untagged or not, pvid or not, make no difference. This
756 * behavior is already better than what DSA just tries to approximate
757 * when it installs the VLAN with the same flags on the CPU port.
758 * Just accept any configuration, and don't let ocelot deny installing
759 * multiple native VLANs on the NPI port, because the switch doesn't
760 * look at the port tag settings towards the NPI interface anyway.
762 if (port
== ocelot
->npi
)
765 return ocelot_vlan_prepare(ocelot
, port
, vlan
->vid
,
766 flags
& BRIDGE_VLAN_INFO_PVID
,
767 flags
& BRIDGE_VLAN_INFO_UNTAGGED
,
771 static int felix_vlan_filtering(struct dsa_switch
*ds
, int port
, bool enabled
,
772 struct netlink_ext_ack
*extack
)
774 struct ocelot
*ocelot
= ds
->priv
;
776 return ocelot_port_vlan_filtering(ocelot
, port
, enabled
, extack
);
779 static int felix_vlan_add(struct dsa_switch
*ds
, int port
,
780 const struct switchdev_obj_port_vlan
*vlan
,
781 struct netlink_ext_ack
*extack
)
783 struct ocelot
*ocelot
= ds
->priv
;
784 u16 flags
= vlan
->flags
;
787 err
= felix_vlan_prepare(ds
, port
, vlan
, extack
);
791 return ocelot_vlan_add(ocelot
, port
, vlan
->vid
,
792 flags
& BRIDGE_VLAN_INFO_PVID
,
793 flags
& BRIDGE_VLAN_INFO_UNTAGGED
);
796 static int felix_vlan_del(struct dsa_switch
*ds
, int port
,
797 const struct switchdev_obj_port_vlan
*vlan
)
799 struct ocelot
*ocelot
= ds
->priv
;
801 return ocelot_vlan_del(ocelot
, port
, vlan
->vid
);
804 static void felix_phylink_validate(struct dsa_switch
*ds
, int port
,
805 unsigned long *supported
,
806 struct phylink_link_state
*state
)
808 struct ocelot
*ocelot
= ds
->priv
;
809 struct felix
*felix
= ocelot_to_felix(ocelot
);
811 if (felix
->info
->phylink_validate
)
812 felix
->info
->phylink_validate(ocelot
, port
, supported
, state
);
815 static void felix_phylink_mac_config(struct dsa_switch
*ds
, int port
,
816 unsigned int link_an_mode
,
817 const struct phylink_link_state
*state
)
819 struct ocelot
*ocelot
= ds
->priv
;
820 struct felix
*felix
= ocelot_to_felix(ocelot
);
821 struct dsa_port
*dp
= dsa_to_port(ds
, port
);
823 if (felix
->pcs
[port
])
824 phylink_set_pcs(dp
->pl
, &felix
->pcs
[port
]->pcs
);
827 static void felix_phylink_mac_link_down(struct dsa_switch
*ds
, int port
,
828 unsigned int link_an_mode
,
829 phy_interface_t interface
)
831 struct ocelot
*ocelot
= ds
->priv
;
833 ocelot_phylink_mac_link_down(ocelot
, port
, link_an_mode
, interface
,
837 static void felix_phylink_mac_link_up(struct dsa_switch
*ds
, int port
,
838 unsigned int link_an_mode
,
839 phy_interface_t interface
,
840 struct phy_device
*phydev
,
841 int speed
, int duplex
,
842 bool tx_pause
, bool rx_pause
)
844 struct ocelot
*ocelot
= ds
->priv
;
845 struct felix
*felix
= ocelot_to_felix(ocelot
);
847 ocelot_phylink_mac_link_up(ocelot
, port
, phydev
, link_an_mode
,
848 interface
, speed
, duplex
, tx_pause
, rx_pause
,
851 if (felix
->info
->port_sched_speed_set
)
852 felix
->info
->port_sched_speed_set(ocelot
, port
, speed
);
855 static void felix_port_qos_map_init(struct ocelot
*ocelot
, int port
)
859 ocelot_rmw_gix(ocelot
,
860 ANA_PORT_QOS_CFG_QOS_PCP_ENA
,
861 ANA_PORT_QOS_CFG_QOS_PCP_ENA
,
865 for (i
= 0; i
< OCELOT_NUM_TC
* 2; i
++) {
866 ocelot_rmw_ix(ocelot
,
867 (ANA_PORT_PCP_DEI_MAP_DP_PCP_DEI_VAL
& i
) |
868 ANA_PORT_PCP_DEI_MAP_QOS_PCP_DEI_VAL(i
),
869 ANA_PORT_PCP_DEI_MAP_DP_PCP_DEI_VAL
|
870 ANA_PORT_PCP_DEI_MAP_QOS_PCP_DEI_VAL_M
,
871 ANA_PORT_PCP_DEI_MAP
,
876 static void felix_get_strings(struct dsa_switch
*ds
, int port
,
877 u32 stringset
, u8
*data
)
879 struct ocelot
*ocelot
= ds
->priv
;
881 return ocelot_get_strings(ocelot
, port
, stringset
, data
);
884 static void felix_get_ethtool_stats(struct dsa_switch
*ds
, int port
, u64
*data
)
886 struct ocelot
*ocelot
= ds
->priv
;
888 ocelot_get_ethtool_stats(ocelot
, port
, data
);
891 static int felix_get_sset_count(struct dsa_switch
*ds
, int port
, int sset
)
893 struct ocelot
*ocelot
= ds
->priv
;
895 return ocelot_get_sset_count(ocelot
, port
, sset
);
898 static int felix_get_ts_info(struct dsa_switch
*ds
, int port
,
899 struct ethtool_ts_info
*info
)
901 struct ocelot
*ocelot
= ds
->priv
;
903 return ocelot_get_ts_info(ocelot
, port
, info
);
906 static int felix_parse_ports_node(struct felix
*felix
,
907 struct device_node
*ports_node
,
908 phy_interface_t
*port_phy_modes
)
910 struct ocelot
*ocelot
= &felix
->ocelot
;
911 struct device
*dev
= felix
->ocelot
.dev
;
912 struct device_node
*child
;
914 for_each_available_child_of_node(ports_node
, child
) {
915 phy_interface_t phy_mode
;
919 /* Get switch port number from DT */
920 if (of_property_read_u32(child
, "reg", &port
) < 0) {
921 dev_err(dev
, "Port number not defined in device tree "
922 "(property \"reg\")\n");
927 /* Get PHY mode from DT */
928 err
= of_get_phy_mode(child
, &phy_mode
);
930 dev_err(dev
, "Failed to read phy-mode or "
931 "phy-interface-type property for port %d\n",
937 err
= felix
->info
->prevalidate_phy_mode(ocelot
, port
, phy_mode
);
939 dev_err(dev
, "Unsupported PHY mode %s on port %d\n",
940 phy_modes(phy_mode
), port
);
945 port_phy_modes
[port
] = phy_mode
;
951 static int felix_parse_dt(struct felix
*felix
, phy_interface_t
*port_phy_modes
)
953 struct device
*dev
= felix
->ocelot
.dev
;
954 struct device_node
*switch_node
;
955 struct device_node
*ports_node
;
958 switch_node
= dev
->of_node
;
960 ports_node
= of_get_child_by_name(switch_node
, "ports");
962 dev_err(dev
, "Incorrect bindings: absent \"ports\" node\n");
966 err
= felix_parse_ports_node(felix
, ports_node
, port_phy_modes
);
967 of_node_put(ports_node
);
972 static int felix_init_structs(struct felix
*felix
, int num_phys_ports
)
974 struct ocelot
*ocelot
= &felix
->ocelot
;
975 phy_interface_t
*port_phy_modes
;
979 ocelot
->num_phys_ports
= num_phys_ports
;
980 ocelot
->ports
= devm_kcalloc(ocelot
->dev
, num_phys_ports
,
981 sizeof(struct ocelot_port
*), GFP_KERNEL
);
985 ocelot
->map
= felix
->info
->map
;
986 ocelot
->stats_layout
= felix
->info
->stats_layout
;
987 ocelot
->num_stats
= felix
->info
->num_stats
;
988 ocelot
->num_mact_rows
= felix
->info
->num_mact_rows
;
989 ocelot
->vcap
= felix
->info
->vcap
;
990 ocelot
->ops
= felix
->info
->ops
;
991 ocelot
->npi_inj_prefix
= OCELOT_TAG_PREFIX_SHORT
;
992 ocelot
->npi_xtr_prefix
= OCELOT_TAG_PREFIX_SHORT
;
993 ocelot
->devlink
= felix
->ds
->devlink
;
995 port_phy_modes
= kcalloc(num_phys_ports
, sizeof(phy_interface_t
),
1000 err
= felix_parse_dt(felix
, port_phy_modes
);
1002 kfree(port_phy_modes
);
1006 for (i
= 0; i
< TARGET_MAX
; i
++) {
1007 struct regmap
*target
;
1009 if (!felix
->info
->target_io_res
[i
].name
)
1012 memcpy(&res
, &felix
->info
->target_io_res
[i
], sizeof(res
));
1013 res
.flags
= IORESOURCE_MEM
;
1014 res
.start
+= felix
->switch_base
;
1015 res
.end
+= felix
->switch_base
;
1017 target
= ocelot_regmap_init(ocelot
, &res
);
1018 if (IS_ERR(target
)) {
1019 dev_err(ocelot
->dev
,
1020 "Failed to map device memory space\n");
1021 kfree(port_phy_modes
);
1022 return PTR_ERR(target
);
1025 ocelot
->targets
[i
] = target
;
1028 err
= ocelot_regfields_init(ocelot
, felix
->info
->regfields
);
1030 dev_err(ocelot
->dev
, "failed to init reg fields map\n");
1031 kfree(port_phy_modes
);
1035 for (port
= 0; port
< num_phys_ports
; port
++) {
1036 struct ocelot_port
*ocelot_port
;
1037 struct regmap
*target
;
1039 ocelot_port
= devm_kzalloc(ocelot
->dev
,
1040 sizeof(struct ocelot_port
),
1043 dev_err(ocelot
->dev
,
1044 "failed to allocate port memory\n");
1045 kfree(port_phy_modes
);
1049 memcpy(&res
, &felix
->info
->port_io_res
[port
], sizeof(res
));
1050 res
.flags
= IORESOURCE_MEM
;
1051 res
.start
+= felix
->switch_base
;
1052 res
.end
+= felix
->switch_base
;
1054 target
= ocelot_regmap_init(ocelot
, &res
);
1055 if (IS_ERR(target
)) {
1056 dev_err(ocelot
->dev
,
1057 "Failed to map memory space for port %d\n",
1059 kfree(port_phy_modes
);
1060 return PTR_ERR(target
);
1063 ocelot_port
->phy_mode
= port_phy_modes
[port
];
1064 ocelot_port
->ocelot
= ocelot
;
1065 ocelot_port
->target
= target
;
1066 ocelot
->ports
[port
] = ocelot_port
;
1069 kfree(port_phy_modes
);
1071 if (felix
->info
->mdio_bus_alloc
) {
1072 err
= felix
->info
->mdio_bus_alloc(ocelot
);
1080 static void ocelot_port_purge_txtstamp_skb(struct ocelot
*ocelot
, int port
,
1081 struct sk_buff
*skb
)
1083 struct ocelot_port
*ocelot_port
= ocelot
->ports
[port
];
1084 struct sk_buff
*clone
= OCELOT_SKB_CB(skb
)->clone
;
1085 struct sk_buff
*skb_match
= NULL
, *skb_tmp
;
1086 unsigned long flags
;
1091 spin_lock_irqsave(&ocelot_port
->tx_skbs
.lock
, flags
);
1093 skb_queue_walk_safe(&ocelot_port
->tx_skbs
, skb
, skb_tmp
) {
1096 __skb_unlink(skb
, &ocelot_port
->tx_skbs
);
1101 spin_unlock_irqrestore(&ocelot_port
->tx_skbs
.lock
, flags
);
1103 WARN_ONCE(!skb_match
,
1104 "Could not find skb clone in TX timestamping list\n");
1107 #define work_to_xmit_work(w) \
1108 container_of((w), struct felix_deferred_xmit_work, work)
1110 static void felix_port_deferred_xmit(struct kthread_work
*work
)
1112 struct felix_deferred_xmit_work
*xmit_work
= work_to_xmit_work(work
);
1113 struct dsa_switch
*ds
= xmit_work
->dp
->ds
;
1114 struct sk_buff
*skb
= xmit_work
->skb
;
1115 u32 rew_op
= ocelot_ptp_rew_op(skb
);
1116 struct ocelot
*ocelot
= ds
->priv
;
1117 int port
= xmit_work
->dp
->index
;
1121 if (ocelot_can_inject(ocelot
, 0))
1125 } while (--retries
);
1128 dev_err(ocelot
->dev
, "port %d failed to inject skb\n",
1130 ocelot_port_purge_txtstamp_skb(ocelot
, port
, skb
);
1135 ocelot_port_inject_frame(ocelot
, port
, 0, rew_op
, skb
);
1141 static int felix_port_setup_tagger_data(struct dsa_switch
*ds
, int port
)
1143 struct dsa_port
*dp
= dsa_to_port(ds
, port
);
1144 struct ocelot
*ocelot
= ds
->priv
;
1145 struct felix
*felix
= ocelot_to_felix(ocelot
);
1146 struct felix_port
*felix_port
;
1148 if (!dsa_port_is_user(dp
))
1151 felix_port
= kzalloc(sizeof(*felix_port
), GFP_KERNEL
);
1155 felix_port
->xmit_worker
= felix
->xmit_worker
;
1156 felix_port
->xmit_work_fn
= felix_port_deferred_xmit
;
1158 dp
->priv
= felix_port
;
1163 static void felix_port_teardown_tagger_data(struct dsa_switch
*ds
, int port
)
1165 struct dsa_port
*dp
= dsa_to_port(ds
, port
);
1166 struct felix_port
*felix_port
= dp
->priv
;
1175 /* Hardware initialization done here so that we can allocate structures with
1176 * devm without fear of dsa_register_switch returning -EPROBE_DEFER and causing
1177 * us to allocate structures twice (leak memory) and map PCI memory twice
1178 * (which will not work).
1180 static int felix_setup(struct dsa_switch
*ds
)
1182 struct ocelot
*ocelot
= ds
->priv
;
1183 struct felix
*felix
= ocelot_to_felix(ocelot
);
1186 err
= felix_init_structs(felix
, ds
->num_ports
);
1190 err
= ocelot_init(ocelot
);
1192 goto out_mdiobus_free
;
1195 err
= ocelot_init_timestamp(ocelot
, felix
->info
->ptp_caps
);
1197 dev_err(ocelot
->dev
,
1198 "Timestamp initialization failed\n");
1203 felix
->xmit_worker
= kthread_create_worker(0, "felix_xmit");
1204 if (IS_ERR(felix
->xmit_worker
)) {
1205 err
= PTR_ERR(felix
->xmit_worker
);
1206 goto out_deinit_timestamp
;
1209 for (port
= 0; port
< ds
->num_ports
; port
++) {
1210 if (dsa_is_unused_port(ds
, port
))
1213 ocelot_init_port(ocelot
, port
);
1215 /* Set the default QoS Classification based on PCP and DEI
1218 felix_port_qos_map_init(ocelot
, port
);
1220 err
= felix_port_setup_tagger_data(ds
, port
);
1223 "port %d failed to set up tagger data: %pe\n",
1224 port
, ERR_PTR(err
));
1225 goto out_deinit_ports
;
1229 err
= ocelot_devlink_sb_register(ocelot
);
1231 goto out_deinit_ports
;
1233 for (port
= 0; port
< ds
->num_ports
; port
++) {
1234 if (!dsa_is_cpu_port(ds
, port
))
1237 /* The initial tag protocol is NPI which always returns 0, so
1238 * there's no real point in checking for errors.
1240 felix_set_tag_protocol(ds
, port
, felix
->tag_proto
);
1244 ds
->mtu_enforcement_ingress
= true;
1245 ds
->assisted_learning_on_cpu_port
= true;
1250 for (port
= 0; port
< ocelot
->num_phys_ports
; port
++) {
1251 if (dsa_is_unused_port(ds
, port
))
1254 felix_port_teardown_tagger_data(ds
, port
);
1255 ocelot_deinit_port(ocelot
, port
);
1258 kthread_destroy_worker(felix
->xmit_worker
);
1260 out_deinit_timestamp
:
1261 ocelot_deinit_timestamp(ocelot
);
1262 ocelot_deinit(ocelot
);
1265 if (felix
->info
->mdio_bus_free
)
1266 felix
->info
->mdio_bus_free(ocelot
);
1271 static void felix_teardown(struct dsa_switch
*ds
)
1273 struct ocelot
*ocelot
= ds
->priv
;
1274 struct felix
*felix
= ocelot_to_felix(ocelot
);
1277 for (port
= 0; port
< ds
->num_ports
; port
++) {
1278 if (!dsa_is_cpu_port(ds
, port
))
1281 felix_del_tag_protocol(ds
, port
, felix
->tag_proto
);
1285 for (port
= 0; port
< ocelot
->num_phys_ports
; port
++) {
1286 if (dsa_is_unused_port(ds
, port
))
1289 felix_port_teardown_tagger_data(ds
, port
);
1290 ocelot_deinit_port(ocelot
, port
);
1293 kthread_destroy_worker(felix
->xmit_worker
);
1295 ocelot_devlink_sb_unregister(ocelot
);
1296 ocelot_deinit_timestamp(ocelot
);
1297 ocelot_deinit(ocelot
);
1299 if (felix
->info
->mdio_bus_free
)
1300 felix
->info
->mdio_bus_free(ocelot
);
1303 static int felix_hwtstamp_get(struct dsa_switch
*ds
, int port
,
1306 struct ocelot
*ocelot
= ds
->priv
;
1308 return ocelot_hwstamp_get(ocelot
, port
, ifr
);
1311 static int felix_hwtstamp_set(struct dsa_switch
*ds
, int port
,
1314 struct ocelot
*ocelot
= ds
->priv
;
1316 return ocelot_hwstamp_set(ocelot
, port
, ifr
);
1319 static bool felix_check_xtr_pkt(struct ocelot
*ocelot
, unsigned int ptp_type
)
1321 struct felix
*felix
= ocelot_to_felix(ocelot
);
1324 if (felix
->tag_proto
!= DSA_TAG_PROTO_OCELOT_8021Q
)
1327 if (!felix
->info
->quirk_no_xtr_irq
)
1330 if (ptp_type
== PTP_CLASS_NONE
)
1333 while (ocelot_read(ocelot
, QS_XTR_DATA_PRESENT
) & BIT(grp
)) {
1334 struct sk_buff
*skb
;
1337 err
= ocelot_xtr_poll_frame(ocelot
, grp
, &skb
);
1341 /* We trap to the CPU port module all PTP frames, but
1342 * felix_rxtstamp() only gets called for event frames.
1343 * So we need to avoid sending duplicate general
1344 * message frames by running a second BPF classifier
1345 * here and dropping those.
1347 __skb_push(skb
, ETH_HLEN
);
1349 type
= ptp_classify_raw(skb
);
1351 __skb_pull(skb
, ETH_HLEN
);
1353 if (type
== PTP_CLASS_NONE
) {
1363 ocelot_drain_cpu_queue(ocelot
, 0);
1368 static bool felix_rxtstamp(struct dsa_switch
*ds
, int port
,
1369 struct sk_buff
*skb
, unsigned int type
)
1371 u8
*extraction
= skb
->data
- ETH_HLEN
- OCELOT_TAG_LEN
;
1372 struct skb_shared_hwtstamps
*shhwtstamps
;
1373 struct ocelot
*ocelot
= ds
->priv
;
1374 u32 tstamp_lo
, tstamp_hi
;
1375 struct timespec64 ts
;
1378 /* If the "no XTR IRQ" workaround is in use, tell DSA to defer this skb
1379 * for RX timestamping. Then free it, and poll for its copy through
1380 * MMIO in the CPU port module, and inject that into the stack from
1381 * ocelot_xtr_poll().
1383 if (felix_check_xtr_pkt(ocelot
, type
)) {
1388 ocelot_ptp_gettime64(&ocelot
->ptp_info
, &ts
);
1389 tstamp
= ktime_set(ts
.tv_sec
, ts
.tv_nsec
);
1391 ocelot_xfh_get_rew_val(extraction
, &val
);
1392 tstamp_lo
= (u32
)val
;
1394 tstamp_hi
= tstamp
>> 32;
1395 if ((tstamp
& 0xffffffff) < tstamp_lo
)
1398 tstamp
= ((u64
)tstamp_hi
<< 32) | tstamp_lo
;
1400 shhwtstamps
= skb_hwtstamps(skb
);
1401 memset(shhwtstamps
, 0, sizeof(struct skb_shared_hwtstamps
));
1402 shhwtstamps
->hwtstamp
= tstamp
;
1406 static void felix_txtstamp(struct dsa_switch
*ds
, int port
,
1407 struct sk_buff
*skb
)
1409 struct ocelot
*ocelot
= ds
->priv
;
1410 struct sk_buff
*clone
= NULL
;
1415 if (ocelot_port_txtstamp_request(ocelot
, port
, skb
, &clone
)) {
1416 dev_err_ratelimited(ds
->dev
,
1417 "port %d delivering skb without TX timestamp\n",
1423 OCELOT_SKB_CB(skb
)->clone
= clone
;
1426 static int felix_change_mtu(struct dsa_switch
*ds
, int port
, int new_mtu
)
1428 struct ocelot
*ocelot
= ds
->priv
;
1430 ocelot_port_set_maxlen(ocelot
, port
, new_mtu
);
1435 static int felix_get_max_mtu(struct dsa_switch
*ds
, int port
)
1437 struct ocelot
*ocelot
= ds
->priv
;
1439 return ocelot_get_max_mtu(ocelot
, port
);
1442 static int felix_cls_flower_add(struct dsa_switch
*ds
, int port
,
1443 struct flow_cls_offload
*cls
, bool ingress
)
1445 struct ocelot
*ocelot
= ds
->priv
;
1447 return ocelot_cls_flower_replace(ocelot
, port
, cls
, ingress
);
1450 static int felix_cls_flower_del(struct dsa_switch
*ds
, int port
,
1451 struct flow_cls_offload
*cls
, bool ingress
)
1453 struct ocelot
*ocelot
= ds
->priv
;
1455 return ocelot_cls_flower_destroy(ocelot
, port
, cls
, ingress
);
1458 static int felix_cls_flower_stats(struct dsa_switch
*ds
, int port
,
1459 struct flow_cls_offload
*cls
, bool ingress
)
1461 struct ocelot
*ocelot
= ds
->priv
;
1463 return ocelot_cls_flower_stats(ocelot
, port
, cls
, ingress
);
1466 static int felix_port_policer_add(struct dsa_switch
*ds
, int port
,
1467 struct dsa_mall_policer_tc_entry
*policer
)
1469 struct ocelot
*ocelot
= ds
->priv
;
1470 struct ocelot_policer pol
= {
1471 .rate
= div_u64(policer
->rate_bytes_per_sec
, 1000) * 8,
1472 .burst
= policer
->burst
,
1475 return ocelot_port_policer_add(ocelot
, port
, &pol
);
1478 static void felix_port_policer_del(struct dsa_switch
*ds
, int port
)
1480 struct ocelot
*ocelot
= ds
->priv
;
1482 ocelot_port_policer_del(ocelot
, port
);
1485 static int felix_port_setup_tc(struct dsa_switch
*ds
, int port
,
1486 enum tc_setup_type type
,
1489 struct ocelot
*ocelot
= ds
->priv
;
1490 struct felix
*felix
= ocelot_to_felix(ocelot
);
1492 if (felix
->info
->port_setup_tc
)
1493 return felix
->info
->port_setup_tc(ds
, port
, type
, type_data
);
1498 static int felix_sb_pool_get(struct dsa_switch
*ds
, unsigned int sb_index
,
1500 struct devlink_sb_pool_info
*pool_info
)
1502 struct ocelot
*ocelot
= ds
->priv
;
1504 return ocelot_sb_pool_get(ocelot
, sb_index
, pool_index
, pool_info
);
1507 static int felix_sb_pool_set(struct dsa_switch
*ds
, unsigned int sb_index
,
1508 u16 pool_index
, u32 size
,
1509 enum devlink_sb_threshold_type threshold_type
,
1510 struct netlink_ext_ack
*extack
)
1512 struct ocelot
*ocelot
= ds
->priv
;
1514 return ocelot_sb_pool_set(ocelot
, sb_index
, pool_index
, size
,
1515 threshold_type
, extack
);
1518 static int felix_sb_port_pool_get(struct dsa_switch
*ds
, int port
,
1519 unsigned int sb_index
, u16 pool_index
,
1522 struct ocelot
*ocelot
= ds
->priv
;
1524 return ocelot_sb_port_pool_get(ocelot
, port
, sb_index
, pool_index
,
1528 static int felix_sb_port_pool_set(struct dsa_switch
*ds
, int port
,
1529 unsigned int sb_index
, u16 pool_index
,
1530 u32 threshold
, struct netlink_ext_ack
*extack
)
1532 struct ocelot
*ocelot
= ds
->priv
;
1534 return ocelot_sb_port_pool_set(ocelot
, port
, sb_index
, pool_index
,
1538 static int felix_sb_tc_pool_bind_get(struct dsa_switch
*ds
, int port
,
1539 unsigned int sb_index
, u16 tc_index
,
1540 enum devlink_sb_pool_type pool_type
,
1541 u16
*p_pool_index
, u32
*p_threshold
)
1543 struct ocelot
*ocelot
= ds
->priv
;
1545 return ocelot_sb_tc_pool_bind_get(ocelot
, port
, sb_index
, tc_index
,
1546 pool_type
, p_pool_index
,
1550 static int felix_sb_tc_pool_bind_set(struct dsa_switch
*ds
, int port
,
1551 unsigned int sb_index
, u16 tc_index
,
1552 enum devlink_sb_pool_type pool_type
,
1553 u16 pool_index
, u32 threshold
,
1554 struct netlink_ext_ack
*extack
)
1556 struct ocelot
*ocelot
= ds
->priv
;
1558 return ocelot_sb_tc_pool_bind_set(ocelot
, port
, sb_index
, tc_index
,
1559 pool_type
, pool_index
, threshold
,
1563 static int felix_sb_occ_snapshot(struct dsa_switch
*ds
,
1564 unsigned int sb_index
)
1566 struct ocelot
*ocelot
= ds
->priv
;
1568 return ocelot_sb_occ_snapshot(ocelot
, sb_index
);
1571 static int felix_sb_occ_max_clear(struct dsa_switch
*ds
,
1572 unsigned int sb_index
)
1574 struct ocelot
*ocelot
= ds
->priv
;
1576 return ocelot_sb_occ_max_clear(ocelot
, sb_index
);
1579 static int felix_sb_occ_port_pool_get(struct dsa_switch
*ds
, int port
,
1580 unsigned int sb_index
, u16 pool_index
,
1581 u32
*p_cur
, u32
*p_max
)
1583 struct ocelot
*ocelot
= ds
->priv
;
1585 return ocelot_sb_occ_port_pool_get(ocelot
, port
, sb_index
, pool_index
,
1589 static int felix_sb_occ_tc_port_bind_get(struct dsa_switch
*ds
, int port
,
1590 unsigned int sb_index
, u16 tc_index
,
1591 enum devlink_sb_pool_type pool_type
,
1592 u32
*p_cur
, u32
*p_max
)
1594 struct ocelot
*ocelot
= ds
->priv
;
1596 return ocelot_sb_occ_tc_port_bind_get(ocelot
, port
, sb_index
, tc_index
,
1597 pool_type
, p_cur
, p_max
);
1600 static int felix_mrp_add(struct dsa_switch
*ds
, int port
,
1601 const struct switchdev_obj_mrp
*mrp
)
1603 struct ocelot
*ocelot
= ds
->priv
;
1605 return ocelot_mrp_add(ocelot
, port
, mrp
);
1608 static int felix_mrp_del(struct dsa_switch
*ds
, int port
,
1609 const struct switchdev_obj_mrp
*mrp
)
1611 struct ocelot
*ocelot
= ds
->priv
;
1613 return ocelot_mrp_add(ocelot
, port
, mrp
);
1617 felix_mrp_add_ring_role(struct dsa_switch
*ds
, int port
,
1618 const struct switchdev_obj_ring_role_mrp
*mrp
)
1620 struct ocelot
*ocelot
= ds
->priv
;
1622 return ocelot_mrp_add_ring_role(ocelot
, port
, mrp
);
1626 felix_mrp_del_ring_role(struct dsa_switch
*ds
, int port
,
1627 const struct switchdev_obj_ring_role_mrp
*mrp
)
1629 struct ocelot
*ocelot
= ds
->priv
;
1631 return ocelot_mrp_del_ring_role(ocelot
, port
, mrp
);
1634 const struct dsa_switch_ops felix_switch_ops
= {
1635 .get_tag_protocol
= felix_get_tag_protocol
,
1636 .change_tag_protocol
= felix_change_tag_protocol
,
1637 .setup
= felix_setup
,
1638 .teardown
= felix_teardown
,
1639 .set_ageing_time
= felix_set_ageing_time
,
1640 .get_strings
= felix_get_strings
,
1641 .get_ethtool_stats
= felix_get_ethtool_stats
,
1642 .get_sset_count
= felix_get_sset_count
,
1643 .get_ts_info
= felix_get_ts_info
,
1644 .phylink_validate
= felix_phylink_validate
,
1645 .phylink_mac_config
= felix_phylink_mac_config
,
1646 .phylink_mac_link_down
= felix_phylink_mac_link_down
,
1647 .phylink_mac_link_up
= felix_phylink_mac_link_up
,
1648 .port_fdb_dump
= felix_fdb_dump
,
1649 .port_fdb_add
= felix_fdb_add
,
1650 .port_fdb_del
= felix_fdb_del
,
1651 .port_mdb_add
= felix_mdb_add
,
1652 .port_mdb_del
= felix_mdb_del
,
1653 .port_pre_bridge_flags
= felix_pre_bridge_flags
,
1654 .port_bridge_flags
= felix_bridge_flags
,
1655 .port_bridge_join
= felix_bridge_join
,
1656 .port_bridge_leave
= felix_bridge_leave
,
1657 .port_lag_join
= felix_lag_join
,
1658 .port_lag_leave
= felix_lag_leave
,
1659 .port_lag_change
= felix_lag_change
,
1660 .port_stp_state_set
= felix_bridge_stp_state_set
,
1661 .port_vlan_filtering
= felix_vlan_filtering
,
1662 .port_vlan_add
= felix_vlan_add
,
1663 .port_vlan_del
= felix_vlan_del
,
1664 .port_hwtstamp_get
= felix_hwtstamp_get
,
1665 .port_hwtstamp_set
= felix_hwtstamp_set
,
1666 .port_rxtstamp
= felix_rxtstamp
,
1667 .port_txtstamp
= felix_txtstamp
,
1668 .port_change_mtu
= felix_change_mtu
,
1669 .port_max_mtu
= felix_get_max_mtu
,
1670 .port_policer_add
= felix_port_policer_add
,
1671 .port_policer_del
= felix_port_policer_del
,
1672 .cls_flower_add
= felix_cls_flower_add
,
1673 .cls_flower_del
= felix_cls_flower_del
,
1674 .cls_flower_stats
= felix_cls_flower_stats
,
1675 .port_setup_tc
= felix_port_setup_tc
,
1676 .devlink_sb_pool_get
= felix_sb_pool_get
,
1677 .devlink_sb_pool_set
= felix_sb_pool_set
,
1678 .devlink_sb_port_pool_get
= felix_sb_port_pool_get
,
1679 .devlink_sb_port_pool_set
= felix_sb_port_pool_set
,
1680 .devlink_sb_tc_pool_bind_get
= felix_sb_tc_pool_bind_get
,
1681 .devlink_sb_tc_pool_bind_set
= felix_sb_tc_pool_bind_set
,
1682 .devlink_sb_occ_snapshot
= felix_sb_occ_snapshot
,
1683 .devlink_sb_occ_max_clear
= felix_sb_occ_max_clear
,
1684 .devlink_sb_occ_port_pool_get
= felix_sb_occ_port_pool_get
,
1685 .devlink_sb_occ_tc_port_bind_get
= felix_sb_occ_tc_port_bind_get
,
1686 .port_mrp_add
= felix_mrp_add
,
1687 .port_mrp_del
= felix_mrp_del
,
1688 .port_mrp_add_ring_role
= felix_mrp_add_ring_role
,
1689 .port_mrp_del_ring_role
= felix_mrp_del_ring_role
,
1690 .tag_8021q_vlan_add
= felix_tag_8021q_vlan_add
,
1691 .tag_8021q_vlan_del
= felix_tag_8021q_vlan_del
,
1694 struct net_device
*felix_port_to_netdev(struct ocelot
*ocelot
, int port
)
1696 struct felix
*felix
= ocelot_to_felix(ocelot
);
1697 struct dsa_switch
*ds
= felix
->ds
;
1699 if (!dsa_is_user_port(ds
, port
))
1702 return dsa_to_port(ds
, port
)->slave
;
1705 int felix_netdev_to_port(struct net_device
*dev
)
1707 struct dsa_port
*dp
;
1709 dp
= dsa_port_from_netdev(dev
);