1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
2 /* Microsemi Ocelot Switch driver
4 * This contains glue logic between the switchdev driver operations and the
5 * mscc_ocelot_switch_lib.
7 * Copyright (c) 2017, 2019 Microsemi Corporation
8 * Copyright 2020-2021 NXP Semiconductors
11 #include <linux/if_bridge.h>
12 #include <linux/of_net.h>
13 #include <linux/phy/phy.h>
14 #include <net/pkt_cls.h>
16 #include "ocelot_vcap.h"
18 #define OCELOT_MAC_QUIRKS OCELOT_QUIRK_QSGMII_PORTS_MUST_BE_UP
20 static struct ocelot
*devlink_port_to_ocelot(struct devlink_port
*dlp
)
22 return devlink_priv(dlp
->devlink
);
25 static int devlink_port_to_port(struct devlink_port
*dlp
)
27 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
29 return dlp
- ocelot
->devlink_ports
;
32 static int ocelot_devlink_sb_pool_get(struct devlink
*dl
,
33 unsigned int sb_index
, u16 pool_index
,
34 struct devlink_sb_pool_info
*pool_info
)
36 struct ocelot
*ocelot
= devlink_priv(dl
);
38 return ocelot_sb_pool_get(ocelot
, sb_index
, pool_index
, pool_info
);
41 static int ocelot_devlink_sb_pool_set(struct devlink
*dl
, unsigned int sb_index
,
42 u16 pool_index
, u32 size
,
43 enum devlink_sb_threshold_type threshold_type
,
44 struct netlink_ext_ack
*extack
)
46 struct ocelot
*ocelot
= devlink_priv(dl
);
48 return ocelot_sb_pool_set(ocelot
, sb_index
, pool_index
, size
,
49 threshold_type
, extack
);
52 static int ocelot_devlink_sb_port_pool_get(struct devlink_port
*dlp
,
53 unsigned int sb_index
, u16 pool_index
,
56 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
57 int port
= devlink_port_to_port(dlp
);
59 return ocelot_sb_port_pool_get(ocelot
, port
, sb_index
, pool_index
,
63 static int ocelot_devlink_sb_port_pool_set(struct devlink_port
*dlp
,
64 unsigned int sb_index
, u16 pool_index
,
66 struct netlink_ext_ack
*extack
)
68 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
69 int port
= devlink_port_to_port(dlp
);
71 return ocelot_sb_port_pool_set(ocelot
, port
, sb_index
, pool_index
,
76 ocelot_devlink_sb_tc_pool_bind_get(struct devlink_port
*dlp
,
77 unsigned int sb_index
, u16 tc_index
,
78 enum devlink_sb_pool_type pool_type
,
79 u16
*p_pool_index
, u32
*p_threshold
)
81 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
82 int port
= devlink_port_to_port(dlp
);
84 return ocelot_sb_tc_pool_bind_get(ocelot
, port
, sb_index
, tc_index
,
85 pool_type
, p_pool_index
,
90 ocelot_devlink_sb_tc_pool_bind_set(struct devlink_port
*dlp
,
91 unsigned int sb_index
, u16 tc_index
,
92 enum devlink_sb_pool_type pool_type
,
93 u16 pool_index
, u32 threshold
,
94 struct netlink_ext_ack
*extack
)
96 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
97 int port
= devlink_port_to_port(dlp
);
99 return ocelot_sb_tc_pool_bind_set(ocelot
, port
, sb_index
, tc_index
,
100 pool_type
, pool_index
, threshold
,
104 static int ocelot_devlink_sb_occ_snapshot(struct devlink
*dl
,
105 unsigned int sb_index
)
107 struct ocelot
*ocelot
= devlink_priv(dl
);
109 return ocelot_sb_occ_snapshot(ocelot
, sb_index
);
112 static int ocelot_devlink_sb_occ_max_clear(struct devlink
*dl
,
113 unsigned int sb_index
)
115 struct ocelot
*ocelot
= devlink_priv(dl
);
117 return ocelot_sb_occ_max_clear(ocelot
, sb_index
);
120 static int ocelot_devlink_sb_occ_port_pool_get(struct devlink_port
*dlp
,
121 unsigned int sb_index
,
122 u16 pool_index
, u32
*p_cur
,
125 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
126 int port
= devlink_port_to_port(dlp
);
128 return ocelot_sb_occ_port_pool_get(ocelot
, port
, sb_index
, pool_index
,
133 ocelot_devlink_sb_occ_tc_port_bind_get(struct devlink_port
*dlp
,
134 unsigned int sb_index
, u16 tc_index
,
135 enum devlink_sb_pool_type pool_type
,
136 u32
*p_cur
, u32
*p_max
)
138 struct ocelot
*ocelot
= devlink_port_to_ocelot(dlp
);
139 int port
= devlink_port_to_port(dlp
);
141 return ocelot_sb_occ_tc_port_bind_get(ocelot
, port
, sb_index
,
146 const struct devlink_ops ocelot_devlink_ops
= {
147 .sb_pool_get
= ocelot_devlink_sb_pool_get
,
148 .sb_pool_set
= ocelot_devlink_sb_pool_set
,
149 .sb_port_pool_get
= ocelot_devlink_sb_port_pool_get
,
150 .sb_port_pool_set
= ocelot_devlink_sb_port_pool_set
,
151 .sb_tc_pool_bind_get
= ocelot_devlink_sb_tc_pool_bind_get
,
152 .sb_tc_pool_bind_set
= ocelot_devlink_sb_tc_pool_bind_set
,
153 .sb_occ_snapshot
= ocelot_devlink_sb_occ_snapshot
,
154 .sb_occ_max_clear
= ocelot_devlink_sb_occ_max_clear
,
155 .sb_occ_port_pool_get
= ocelot_devlink_sb_occ_port_pool_get
,
156 .sb_occ_tc_port_bind_get
= ocelot_devlink_sb_occ_tc_port_bind_get
,
159 int ocelot_port_devlink_init(struct ocelot
*ocelot
, int port
,
160 enum devlink_port_flavour flavour
)
162 struct devlink_port
*dlp
= &ocelot
->devlink_ports
[port
];
163 int id_len
= sizeof(ocelot
->base_mac
);
164 struct devlink
*dl
= ocelot
->devlink
;
165 struct devlink_port_attrs attrs
= {};
167 memset(dlp
, 0, sizeof(*dlp
));
168 memcpy(attrs
.switch_id
.id
, &ocelot
->base_mac
, id_len
);
169 attrs
.switch_id
.id_len
= id_len
;
170 attrs
.phys
.port_number
= port
;
171 attrs
.flavour
= flavour
;
173 devlink_port_attrs_set(dlp
, &attrs
);
175 return devlink_port_register(dl
, dlp
, port
);
178 void ocelot_port_devlink_teardown(struct ocelot
*ocelot
, int port
)
180 struct devlink_port
*dlp
= &ocelot
->devlink_ports
[port
];
182 devlink_port_unregister(dlp
);
185 static struct devlink_port
*ocelot_get_devlink_port(struct net_device
*dev
)
187 struct ocelot_port_private
*priv
= netdev_priv(dev
);
188 struct ocelot
*ocelot
= priv
->port
.ocelot
;
189 int port
= priv
->chip_port
;
191 return &ocelot
->devlink_ports
[port
];
194 int ocelot_setup_tc_cls_flower(struct ocelot_port_private
*priv
,
195 struct flow_cls_offload
*f
,
198 struct ocelot
*ocelot
= priv
->port
.ocelot
;
199 int port
= priv
->chip_port
;
204 switch (f
->command
) {
205 case FLOW_CLS_REPLACE
:
206 return ocelot_cls_flower_replace(ocelot
, port
, f
, ingress
);
207 case FLOW_CLS_DESTROY
:
208 return ocelot_cls_flower_destroy(ocelot
, port
, f
, ingress
);
210 return ocelot_cls_flower_stats(ocelot
, port
, f
, ingress
);
216 static int ocelot_setup_tc_cls_matchall(struct ocelot_port_private
*priv
,
217 struct tc_cls_matchall_offload
*f
,
220 struct netlink_ext_ack
*extack
= f
->common
.extack
;
221 struct ocelot
*ocelot
= priv
->port
.ocelot
;
222 struct ocelot_policer pol
= { 0 };
223 struct flow_action_entry
*action
;
224 int port
= priv
->chip_port
;
228 NL_SET_ERR_MSG_MOD(extack
, "Only ingress is supported");
232 switch (f
->command
) {
233 case TC_CLSMATCHALL_REPLACE
:
234 if (!flow_offload_has_one_action(&f
->rule
->action
)) {
235 NL_SET_ERR_MSG_MOD(extack
,
236 "Only one action is supported");
240 if (priv
->tc
.block_shared
) {
241 NL_SET_ERR_MSG_MOD(extack
,
242 "Rate limit is not supported on shared blocks");
246 action
= &f
->rule
->action
.entries
[0];
248 if (action
->id
!= FLOW_ACTION_POLICE
) {
249 NL_SET_ERR_MSG_MOD(extack
, "Unsupported action");
253 if (priv
->tc
.police_id
&& priv
->tc
.police_id
!= f
->cookie
) {
254 NL_SET_ERR_MSG_MOD(extack
,
255 "Only one policer per port is supported");
259 if (action
->police
.rate_pkt_ps
) {
260 NL_SET_ERR_MSG_MOD(extack
,
261 "QoS offload not support packets per second");
265 pol
.rate
= (u32
)div_u64(action
->police
.rate_bytes_ps
, 1000) * 8;
266 pol
.burst
= action
->police
.burst
;
268 err
= ocelot_port_policer_add(ocelot
, port
, &pol
);
270 NL_SET_ERR_MSG_MOD(extack
, "Could not add policer");
274 priv
->tc
.police_id
= f
->cookie
;
275 priv
->tc
.offload_cnt
++;
277 case TC_CLSMATCHALL_DESTROY
:
278 if (priv
->tc
.police_id
!= f
->cookie
)
281 err
= ocelot_port_policer_del(ocelot
, port
);
283 NL_SET_ERR_MSG_MOD(extack
,
284 "Could not delete policer");
287 priv
->tc
.police_id
= 0;
288 priv
->tc
.offload_cnt
--;
290 case TC_CLSMATCHALL_STATS
:
296 static int ocelot_setup_tc_block_cb(enum tc_setup_type type
,
298 void *cb_priv
, bool ingress
)
300 struct ocelot_port_private
*priv
= cb_priv
;
302 if (!tc_cls_can_offload_and_chain0(priv
->dev
, type_data
))
306 case TC_SETUP_CLSMATCHALL
:
307 return ocelot_setup_tc_cls_matchall(priv
, type_data
, ingress
);
308 case TC_SETUP_CLSFLOWER
:
309 return ocelot_setup_tc_cls_flower(priv
, type_data
, ingress
);
315 static int ocelot_setup_tc_block_cb_ig(enum tc_setup_type type
,
319 return ocelot_setup_tc_block_cb(type
, type_data
,
323 static int ocelot_setup_tc_block_cb_eg(enum tc_setup_type type
,
327 return ocelot_setup_tc_block_cb(type
, type_data
,
331 static LIST_HEAD(ocelot_block_cb_list
);
333 static int ocelot_setup_tc_block(struct ocelot_port_private
*priv
,
334 struct flow_block_offload
*f
)
336 struct flow_block_cb
*block_cb
;
339 if (f
->binder_type
== FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS
) {
340 cb
= ocelot_setup_tc_block_cb_ig
;
341 priv
->tc
.block_shared
= f
->block_shared
;
342 } else if (f
->binder_type
== FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS
) {
343 cb
= ocelot_setup_tc_block_cb_eg
;
348 f
->driver_block_list
= &ocelot_block_cb_list
;
350 switch (f
->command
) {
351 case FLOW_BLOCK_BIND
:
352 if (flow_block_cb_is_busy(cb
, priv
, &ocelot_block_cb_list
))
355 block_cb
= flow_block_cb_alloc(cb
, priv
, priv
, NULL
);
356 if (IS_ERR(block_cb
))
357 return PTR_ERR(block_cb
);
359 flow_block_cb_add(block_cb
, f
);
360 list_add_tail(&block_cb
->driver_list
, f
->driver_block_list
);
362 case FLOW_BLOCK_UNBIND
:
363 block_cb
= flow_block_cb_lookup(f
->block
, cb
, priv
);
367 flow_block_cb_remove(block_cb
, f
);
368 list_del(&block_cb
->driver_list
);
375 static int ocelot_setup_tc(struct net_device
*dev
, enum tc_setup_type type
,
378 struct ocelot_port_private
*priv
= netdev_priv(dev
);
382 return ocelot_setup_tc_block(priv
, type_data
);
389 static int ocelot_vlan_vid_add(struct net_device
*dev
, u16 vid
, bool pvid
,
392 struct ocelot_port_private
*priv
= netdev_priv(dev
);
393 struct ocelot_port
*ocelot_port
= &priv
->port
;
394 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
395 int port
= priv
->chip_port
;
398 ret
= ocelot_vlan_add(ocelot
, port
, vid
, pvid
, untagged
);
402 /* Add the port MAC address to with the right VLAN information */
403 ocelot_mact_learn(ocelot
, PGID_CPU
, dev
->dev_addr
, vid
,
409 static int ocelot_vlan_vid_del(struct net_device
*dev
, u16 vid
)
411 struct ocelot_port_private
*priv
= netdev_priv(dev
);
412 struct ocelot
*ocelot
= priv
->port
.ocelot
;
413 int port
= priv
->chip_port
;
416 /* 8021q removes VID 0 on module unload for all interfaces
417 * with VLAN filtering feature. We need to keep it to receive
423 ret
= ocelot_vlan_del(ocelot
, port
, vid
);
427 /* Del the port MAC address to with the right VLAN information */
428 ocelot_mact_forget(ocelot
, dev
->dev_addr
, vid
);
433 static int ocelot_port_open(struct net_device
*dev
)
435 struct ocelot_port_private
*priv
= netdev_priv(dev
);
437 phylink_start(priv
->phylink
);
442 static int ocelot_port_stop(struct net_device
*dev
)
444 struct ocelot_port_private
*priv
= netdev_priv(dev
);
446 phylink_stop(priv
->phylink
);
451 static netdev_tx_t
ocelot_port_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
453 struct ocelot_port_private
*priv
= netdev_priv(dev
);
454 struct ocelot_port
*ocelot_port
= &priv
->port
;
455 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
456 int port
= priv
->chip_port
;
459 if (!ocelot_can_inject(ocelot
, 0))
460 return NETDEV_TX_BUSY
;
462 /* Check if timestamping is needed */
463 if (ocelot
->ptp
&& (skb_shinfo(skb
)->tx_flags
& SKBTX_HW_TSTAMP
)) {
464 struct sk_buff
*clone
= NULL
;
466 if (ocelot_port_txtstamp_request(ocelot
, port
, skb
, &clone
)) {
472 OCELOT_SKB_CB(skb
)->clone
= clone
;
474 rew_op
= ocelot_ptp_rew_op(skb
);
477 ocelot_port_inject_frame(ocelot
, port
, 0, rew_op
, skb
);
484 enum ocelot_action_type
{
489 struct ocelot_mact_work_ctx
{
490 struct work_struct work
;
491 struct ocelot
*ocelot
;
492 enum ocelot_action_type type
;
494 /* OCELOT_MACT_LEARN */
496 unsigned char addr
[ETH_ALEN
];
498 enum macaccess_entry_type entry_type
;
501 /* OCELOT_MACT_FORGET */
503 unsigned char addr
[ETH_ALEN
];
509 #define ocelot_work_to_ctx(x) \
510 container_of((x), struct ocelot_mact_work_ctx, work)
512 static void ocelot_mact_work(struct work_struct
*work
)
514 struct ocelot_mact_work_ctx
*w
= ocelot_work_to_ctx(work
);
515 struct ocelot
*ocelot
= w
->ocelot
;
518 case OCELOT_MACT_LEARN
:
519 ocelot_mact_learn(ocelot
, w
->learn
.pgid
, w
->learn
.addr
,
520 w
->learn
.vid
, w
->learn
.entry_type
);
522 case OCELOT_MACT_FORGET
:
523 ocelot_mact_forget(ocelot
, w
->forget
.addr
, w
->forget
.vid
);
532 static int ocelot_enqueue_mact_action(struct ocelot
*ocelot
,
533 const struct ocelot_mact_work_ctx
*ctx
)
535 struct ocelot_mact_work_ctx
*w
= kmemdup(ctx
, sizeof(*w
), GFP_ATOMIC
);
541 INIT_WORK(&w
->work
, ocelot_mact_work
);
542 queue_work(ocelot
->owq
, &w
->work
);
547 static int ocelot_mc_unsync(struct net_device
*dev
, const unsigned char *addr
)
549 struct ocelot_port_private
*priv
= netdev_priv(dev
);
550 struct ocelot_port
*ocelot_port
= &priv
->port
;
551 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
552 struct ocelot_mact_work_ctx w
;
554 ether_addr_copy(w
.forget
.addr
, addr
);
555 w
.forget
.vid
= ocelot_port
->pvid_vlan
.vid
;
556 w
.type
= OCELOT_MACT_FORGET
;
558 return ocelot_enqueue_mact_action(ocelot
, &w
);
561 static int ocelot_mc_sync(struct net_device
*dev
, const unsigned char *addr
)
563 struct ocelot_port_private
*priv
= netdev_priv(dev
);
564 struct ocelot_port
*ocelot_port
= &priv
->port
;
565 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
566 struct ocelot_mact_work_ctx w
;
568 ether_addr_copy(w
.learn
.addr
, addr
);
569 w
.learn
.vid
= ocelot_port
->pvid_vlan
.vid
;
570 w
.learn
.pgid
= PGID_CPU
;
571 w
.learn
.entry_type
= ENTRYTYPE_LOCKED
;
572 w
.type
= OCELOT_MACT_LEARN
;
574 return ocelot_enqueue_mact_action(ocelot
, &w
);
577 static void ocelot_set_rx_mode(struct net_device
*dev
)
579 struct ocelot_port_private
*priv
= netdev_priv(dev
);
580 struct ocelot
*ocelot
= priv
->port
.ocelot
;
584 /* This doesn't handle promiscuous mode because the bridge core is
585 * setting IFF_PROMISC on all slave interfaces and all frames would be
586 * forwarded to the CPU port.
588 val
= GENMASK(ocelot
->num_phys_ports
- 1, 0);
589 for_each_nonreserved_multicast_dest_pgid(ocelot
, i
)
590 ocelot_write_rix(ocelot
, val
, ANA_PGID_PGID
, i
);
592 __dev_mc_sync(dev
, ocelot_mc_sync
, ocelot_mc_unsync
);
595 static int ocelot_port_set_mac_address(struct net_device
*dev
, void *p
)
597 struct ocelot_port_private
*priv
= netdev_priv(dev
);
598 struct ocelot_port
*ocelot_port
= &priv
->port
;
599 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
600 const struct sockaddr
*addr
= p
;
602 /* Learn the new net device MAC address in the mac table. */
603 ocelot_mact_learn(ocelot
, PGID_CPU
, addr
->sa_data
,
604 ocelot_port
->pvid_vlan
.vid
, ENTRYTYPE_LOCKED
);
605 /* Then forget the previous one. */
606 ocelot_mact_forget(ocelot
, dev
->dev_addr
, ocelot_port
->pvid_vlan
.vid
);
608 ether_addr_copy(dev
->dev_addr
, addr
->sa_data
);
612 static void ocelot_get_stats64(struct net_device
*dev
,
613 struct rtnl_link_stats64
*stats
)
615 struct ocelot_port_private
*priv
= netdev_priv(dev
);
616 struct ocelot
*ocelot
= priv
->port
.ocelot
;
617 int port
= priv
->chip_port
;
619 /* Configure the port to read the stats from */
620 ocelot_write(ocelot
, SYS_STAT_CFG_STAT_VIEW(port
),
624 stats
->rx_bytes
= ocelot_read(ocelot
, SYS_COUNT_RX_OCTETS
);
625 stats
->rx_packets
= ocelot_read(ocelot
, SYS_COUNT_RX_SHORTS
) +
626 ocelot_read(ocelot
, SYS_COUNT_RX_FRAGMENTS
) +
627 ocelot_read(ocelot
, SYS_COUNT_RX_JABBERS
) +
628 ocelot_read(ocelot
, SYS_COUNT_RX_LONGS
) +
629 ocelot_read(ocelot
, SYS_COUNT_RX_64
) +
630 ocelot_read(ocelot
, SYS_COUNT_RX_65_127
) +
631 ocelot_read(ocelot
, SYS_COUNT_RX_128_255
) +
632 ocelot_read(ocelot
, SYS_COUNT_RX_256_1023
) +
633 ocelot_read(ocelot
, SYS_COUNT_RX_1024_1526
) +
634 ocelot_read(ocelot
, SYS_COUNT_RX_1527_MAX
);
635 stats
->multicast
= ocelot_read(ocelot
, SYS_COUNT_RX_MULTICAST
);
636 stats
->rx_dropped
= dev
->stats
.rx_dropped
;
639 stats
->tx_bytes
= ocelot_read(ocelot
, SYS_COUNT_TX_OCTETS
);
640 stats
->tx_packets
= ocelot_read(ocelot
, SYS_COUNT_TX_64
) +
641 ocelot_read(ocelot
, SYS_COUNT_TX_65_127
) +
642 ocelot_read(ocelot
, SYS_COUNT_TX_128_511
) +
643 ocelot_read(ocelot
, SYS_COUNT_TX_512_1023
) +
644 ocelot_read(ocelot
, SYS_COUNT_TX_1024_1526
) +
645 ocelot_read(ocelot
, SYS_COUNT_TX_1527_MAX
);
646 stats
->tx_dropped
= ocelot_read(ocelot
, SYS_COUNT_TX_DROPS
) +
647 ocelot_read(ocelot
, SYS_COUNT_TX_AGING
);
648 stats
->collisions
= ocelot_read(ocelot
, SYS_COUNT_TX_COLLISION
);
651 static int ocelot_port_fdb_add(struct ndmsg
*ndm
, struct nlattr
*tb
[],
652 struct net_device
*dev
,
653 const unsigned char *addr
,
655 struct netlink_ext_ack
*extack
)
657 struct ocelot_port_private
*priv
= netdev_priv(dev
);
658 struct ocelot
*ocelot
= priv
->port
.ocelot
;
659 int port
= priv
->chip_port
;
661 return ocelot_fdb_add(ocelot
, port
, addr
, vid
);
664 static int ocelot_port_fdb_del(struct ndmsg
*ndm
, struct nlattr
*tb
[],
665 struct net_device
*dev
,
666 const unsigned char *addr
, u16 vid
)
668 struct ocelot_port_private
*priv
= netdev_priv(dev
);
669 struct ocelot
*ocelot
= priv
->port
.ocelot
;
670 int port
= priv
->chip_port
;
672 return ocelot_fdb_del(ocelot
, port
, addr
, vid
);
675 static int ocelot_port_fdb_dump(struct sk_buff
*skb
,
676 struct netlink_callback
*cb
,
677 struct net_device
*dev
,
678 struct net_device
*filter_dev
, int *idx
)
680 struct ocelot_port_private
*priv
= netdev_priv(dev
);
681 struct ocelot
*ocelot
= priv
->port
.ocelot
;
682 struct ocelot_dump_ctx dump
= {
688 int port
= priv
->chip_port
;
691 ret
= ocelot_fdb_dump(ocelot
, port
, ocelot_port_fdb_do_dump
, &dump
);
698 static int ocelot_vlan_rx_add_vid(struct net_device
*dev
, __be16 proto
,
701 return ocelot_vlan_vid_add(dev
, vid
, false, false);
704 static int ocelot_vlan_rx_kill_vid(struct net_device
*dev
, __be16 proto
,
707 return ocelot_vlan_vid_del(dev
, vid
);
710 static void ocelot_vlan_mode(struct ocelot
*ocelot
, int port
,
711 netdev_features_t features
)
716 val
= ocelot_read(ocelot
, ANA_VLANMASK
);
717 if (features
& NETIF_F_HW_VLAN_CTAG_FILTER
)
721 ocelot_write(ocelot
, val
, ANA_VLANMASK
);
724 static int ocelot_set_features(struct net_device
*dev
,
725 netdev_features_t features
)
727 netdev_features_t changed
= dev
->features
^ features
;
728 struct ocelot_port_private
*priv
= netdev_priv(dev
);
729 struct ocelot
*ocelot
= priv
->port
.ocelot
;
730 int port
= priv
->chip_port
;
732 if ((dev
->features
& NETIF_F_HW_TC
) > (features
& NETIF_F_HW_TC
) &&
733 priv
->tc
.offload_cnt
) {
735 "Cannot disable HW TC offload while offloads active\n");
739 if (changed
& NETIF_F_HW_VLAN_CTAG_FILTER
)
740 ocelot_vlan_mode(ocelot
, port
, features
);
745 static int ocelot_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
747 struct ocelot_port_private
*priv
= netdev_priv(dev
);
748 struct ocelot
*ocelot
= priv
->port
.ocelot
;
749 int port
= priv
->chip_port
;
751 /* If the attached PHY device isn't capable of timestamping operations,
752 * use our own (when possible).
754 if (!phy_has_hwtstamp(dev
->phydev
) && ocelot
->ptp
) {
757 return ocelot_hwstamp_set(ocelot
, port
, ifr
);
759 return ocelot_hwstamp_get(ocelot
, port
, ifr
);
763 return phy_mii_ioctl(dev
->phydev
, ifr
, cmd
);
766 static const struct net_device_ops ocelot_port_netdev_ops
= {
767 .ndo_open
= ocelot_port_open
,
768 .ndo_stop
= ocelot_port_stop
,
769 .ndo_start_xmit
= ocelot_port_xmit
,
770 .ndo_set_rx_mode
= ocelot_set_rx_mode
,
771 .ndo_set_mac_address
= ocelot_port_set_mac_address
,
772 .ndo_get_stats64
= ocelot_get_stats64
,
773 .ndo_fdb_add
= ocelot_port_fdb_add
,
774 .ndo_fdb_del
= ocelot_port_fdb_del
,
775 .ndo_fdb_dump
= ocelot_port_fdb_dump
,
776 .ndo_vlan_rx_add_vid
= ocelot_vlan_rx_add_vid
,
777 .ndo_vlan_rx_kill_vid
= ocelot_vlan_rx_kill_vid
,
778 .ndo_set_features
= ocelot_set_features
,
779 .ndo_setup_tc
= ocelot_setup_tc
,
780 .ndo_eth_ioctl
= ocelot_ioctl
,
781 .ndo_get_devlink_port
= ocelot_get_devlink_port
,
784 struct net_device
*ocelot_port_to_netdev(struct ocelot
*ocelot
, int port
)
786 struct ocelot_port
*ocelot_port
= ocelot
->ports
[port
];
787 struct ocelot_port_private
*priv
;
792 priv
= container_of(ocelot_port
, struct ocelot_port_private
, port
);
797 /* Checks if the net_device instance given to us originates from our driver */
798 static bool ocelot_netdevice_dev_check(const struct net_device
*dev
)
800 return dev
->netdev_ops
== &ocelot_port_netdev_ops
;
803 int ocelot_netdev_to_port(struct net_device
*dev
)
805 struct ocelot_port_private
*priv
;
807 if (!dev
|| !ocelot_netdevice_dev_check(dev
))
810 priv
= netdev_priv(dev
);
812 return priv
->chip_port
;
815 static void ocelot_port_get_strings(struct net_device
*netdev
, u32 sset
,
818 struct ocelot_port_private
*priv
= netdev_priv(netdev
);
819 struct ocelot
*ocelot
= priv
->port
.ocelot
;
820 int port
= priv
->chip_port
;
822 ocelot_get_strings(ocelot
, port
, sset
, data
);
825 static void ocelot_port_get_ethtool_stats(struct net_device
*dev
,
826 struct ethtool_stats
*stats
,
829 struct ocelot_port_private
*priv
= netdev_priv(dev
);
830 struct ocelot
*ocelot
= priv
->port
.ocelot
;
831 int port
= priv
->chip_port
;
833 ocelot_get_ethtool_stats(ocelot
, port
, data
);
836 static int ocelot_port_get_sset_count(struct net_device
*dev
, int sset
)
838 struct ocelot_port_private
*priv
= netdev_priv(dev
);
839 struct ocelot
*ocelot
= priv
->port
.ocelot
;
840 int port
= priv
->chip_port
;
842 return ocelot_get_sset_count(ocelot
, port
, sset
);
845 static int ocelot_port_get_ts_info(struct net_device
*dev
,
846 struct ethtool_ts_info
*info
)
848 struct ocelot_port_private
*priv
= netdev_priv(dev
);
849 struct ocelot
*ocelot
= priv
->port
.ocelot
;
850 int port
= priv
->chip_port
;
853 return ethtool_op_get_ts_info(dev
, info
);
855 return ocelot_get_ts_info(ocelot
, port
, info
);
858 static const struct ethtool_ops ocelot_ethtool_ops
= {
859 .get_strings
= ocelot_port_get_strings
,
860 .get_ethtool_stats
= ocelot_port_get_ethtool_stats
,
861 .get_sset_count
= ocelot_port_get_sset_count
,
862 .get_link_ksettings
= phy_ethtool_get_link_ksettings
,
863 .set_link_ksettings
= phy_ethtool_set_link_ksettings
,
864 .get_ts_info
= ocelot_port_get_ts_info
,
867 static void ocelot_port_attr_stp_state_set(struct ocelot
*ocelot
, int port
,
870 ocelot_bridge_stp_state_set(ocelot
, port
, state
);
873 static void ocelot_port_attr_ageing_set(struct ocelot
*ocelot
, int port
,
874 unsigned long ageing_clock_t
)
876 unsigned long ageing_jiffies
= clock_t_to_jiffies(ageing_clock_t
);
877 u32 ageing_time
= jiffies_to_msecs(ageing_jiffies
);
879 ocelot_set_ageing_time(ocelot
, ageing_time
);
882 static void ocelot_port_attr_mc_set(struct ocelot
*ocelot
, int port
, bool mc
)
884 u32 cpu_fwd_mcast
= ANA_PORT_CPU_FWD_CFG_CPU_IGMP_REDIR_ENA
|
885 ANA_PORT_CPU_FWD_CFG_CPU_MLD_REDIR_ENA
|
886 ANA_PORT_CPU_FWD_CFG_CPU_IPMC_CTRL_COPY_ENA
;
892 ocelot_rmw_gix(ocelot
, val
, cpu_fwd_mcast
,
893 ANA_PORT_CPU_FWD_CFG
, port
);
896 static int ocelot_port_attr_set(struct net_device
*dev
, const void *ctx
,
897 const struct switchdev_attr
*attr
,
898 struct netlink_ext_ack
*extack
)
900 struct ocelot_port_private
*priv
= netdev_priv(dev
);
901 struct ocelot
*ocelot
= priv
->port
.ocelot
;
902 int port
= priv
->chip_port
;
905 if (ctx
&& ctx
!= priv
)
909 case SWITCHDEV_ATTR_ID_PORT_STP_STATE
:
910 ocelot_port_attr_stp_state_set(ocelot
, port
, attr
->u
.stp_state
);
912 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME
:
913 ocelot_port_attr_ageing_set(ocelot
, port
, attr
->u
.ageing_time
);
915 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING
:
916 ocelot_port_vlan_filtering(ocelot
, port
, attr
->u
.vlan_filtering
);
918 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED
:
919 ocelot_port_attr_mc_set(ocelot
, port
, !attr
->u
.mc_disabled
);
921 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS
:
922 err
= ocelot_port_pre_bridge_flags(ocelot
, port
,
923 attr
->u
.brport_flags
);
925 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
:
926 ocelot_port_bridge_flags(ocelot
, port
, attr
->u
.brport_flags
);
936 static int ocelot_vlan_vid_prepare(struct net_device
*dev
, u16 vid
, bool pvid
,
937 bool untagged
, struct netlink_ext_ack
*extack
)
939 struct ocelot_port_private
*priv
= netdev_priv(dev
);
940 struct ocelot_port
*ocelot_port
= &priv
->port
;
941 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
942 int port
= priv
->chip_port
;
944 return ocelot_vlan_prepare(ocelot
, port
, vid
, pvid
, untagged
, extack
);
947 static int ocelot_port_obj_add_vlan(struct net_device
*dev
,
948 const struct switchdev_obj_port_vlan
*vlan
,
949 struct netlink_ext_ack
*extack
)
951 bool untagged
= vlan
->flags
& BRIDGE_VLAN_INFO_UNTAGGED
;
952 bool pvid
= vlan
->flags
& BRIDGE_VLAN_INFO_PVID
;
955 ret
= ocelot_vlan_vid_prepare(dev
, vlan
->vid
, pvid
, untagged
, extack
);
959 return ocelot_vlan_vid_add(dev
, vlan
->vid
, pvid
, untagged
);
962 static int ocelot_port_obj_add_mdb(struct net_device
*dev
,
963 const struct switchdev_obj_port_mdb
*mdb
)
965 struct ocelot_port_private
*priv
= netdev_priv(dev
);
966 struct ocelot_port
*ocelot_port
= &priv
->port
;
967 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
968 int port
= priv
->chip_port
;
970 return ocelot_port_mdb_add(ocelot
, port
, mdb
);
973 static int ocelot_port_obj_del_mdb(struct net_device
*dev
,
974 const struct switchdev_obj_port_mdb
*mdb
)
976 struct ocelot_port_private
*priv
= netdev_priv(dev
);
977 struct ocelot_port
*ocelot_port
= &priv
->port
;
978 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
979 int port
= priv
->chip_port
;
981 return ocelot_port_mdb_del(ocelot
, port
, mdb
);
984 static int ocelot_port_obj_mrp_add(struct net_device
*dev
,
985 const struct switchdev_obj_mrp
*mrp
)
987 struct ocelot_port_private
*priv
= netdev_priv(dev
);
988 struct ocelot_port
*ocelot_port
= &priv
->port
;
989 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
990 int port
= priv
->chip_port
;
992 return ocelot_mrp_add(ocelot
, port
, mrp
);
995 static int ocelot_port_obj_mrp_del(struct net_device
*dev
,
996 const struct switchdev_obj_mrp
*mrp
)
998 struct ocelot_port_private
*priv
= netdev_priv(dev
);
999 struct ocelot_port
*ocelot_port
= &priv
->port
;
1000 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1001 int port
= priv
->chip_port
;
1003 return ocelot_mrp_del(ocelot
, port
, mrp
);
1007 ocelot_port_obj_mrp_add_ring_role(struct net_device
*dev
,
1008 const struct switchdev_obj_ring_role_mrp
*mrp
)
1010 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1011 struct ocelot_port
*ocelot_port
= &priv
->port
;
1012 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1013 int port
= priv
->chip_port
;
1015 return ocelot_mrp_add_ring_role(ocelot
, port
, mrp
);
1019 ocelot_port_obj_mrp_del_ring_role(struct net_device
*dev
,
1020 const struct switchdev_obj_ring_role_mrp
*mrp
)
1022 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1023 struct ocelot_port
*ocelot_port
= &priv
->port
;
1024 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1025 int port
= priv
->chip_port
;
1027 return ocelot_mrp_del_ring_role(ocelot
, port
, mrp
);
1030 static int ocelot_port_obj_add(struct net_device
*dev
, const void *ctx
,
1031 const struct switchdev_obj
*obj
,
1032 struct netlink_ext_ack
*extack
)
1034 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1037 if (ctx
&& ctx
!= priv
)
1041 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
1042 ret
= ocelot_port_obj_add_vlan(dev
,
1043 SWITCHDEV_OBJ_PORT_VLAN(obj
),
1046 case SWITCHDEV_OBJ_ID_PORT_MDB
:
1047 ret
= ocelot_port_obj_add_mdb(dev
, SWITCHDEV_OBJ_PORT_MDB(obj
));
1049 case SWITCHDEV_OBJ_ID_MRP
:
1050 ret
= ocelot_port_obj_mrp_add(dev
, SWITCHDEV_OBJ_MRP(obj
));
1052 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP
:
1053 ret
= ocelot_port_obj_mrp_add_ring_role(dev
,
1054 SWITCHDEV_OBJ_RING_ROLE_MRP(obj
));
1063 static int ocelot_port_obj_del(struct net_device
*dev
, const void *ctx
,
1064 const struct switchdev_obj
*obj
)
1066 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1069 if (ctx
&& ctx
!= priv
)
1073 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
1074 ret
= ocelot_vlan_vid_del(dev
,
1075 SWITCHDEV_OBJ_PORT_VLAN(obj
)->vid
);
1077 case SWITCHDEV_OBJ_ID_PORT_MDB
:
1078 ret
= ocelot_port_obj_del_mdb(dev
, SWITCHDEV_OBJ_PORT_MDB(obj
));
1080 case SWITCHDEV_OBJ_ID_MRP
:
1081 ret
= ocelot_port_obj_mrp_del(dev
, SWITCHDEV_OBJ_MRP(obj
));
1083 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP
:
1084 ret
= ocelot_port_obj_mrp_del_ring_role(dev
,
1085 SWITCHDEV_OBJ_RING_ROLE_MRP(obj
));
1094 static void ocelot_inherit_brport_flags(struct ocelot
*ocelot
, int port
,
1095 struct net_device
*brport_dev
)
1097 struct switchdev_brport_flags flags
= {0};
1100 flags
.mask
= BR_LEARNING
| BR_FLOOD
| BR_MCAST_FLOOD
| BR_BCAST_FLOOD
;
1102 for_each_set_bit(flag
, &flags
.mask
, 32)
1103 if (br_port_flag_is_set(brport_dev
, BIT(flag
)))
1104 flags
.val
|= BIT(flag
);
1106 ocelot_port_bridge_flags(ocelot
, port
, flags
);
1109 static void ocelot_clear_brport_flags(struct ocelot
*ocelot
, int port
)
1111 struct switchdev_brport_flags flags
;
1113 flags
.mask
= BR_LEARNING
| BR_FLOOD
| BR_MCAST_FLOOD
| BR_BCAST_FLOOD
;
1114 flags
.val
= flags
.mask
& ~BR_LEARNING
;
1116 ocelot_port_bridge_flags(ocelot
, port
, flags
);
1119 static int ocelot_switchdev_sync(struct ocelot
*ocelot
, int port
,
1120 struct net_device
*brport_dev
,
1121 struct net_device
*bridge_dev
,
1122 struct netlink_ext_ack
*extack
)
1124 clock_t ageing_time
;
1127 ocelot_inherit_brport_flags(ocelot
, port
, brport_dev
);
1129 stp_state
= br_port_get_stp_state(brport_dev
);
1130 ocelot_bridge_stp_state_set(ocelot
, port
, stp_state
);
1132 ageing_time
= br_get_ageing_time(bridge_dev
);
1133 ocelot_port_attr_ageing_set(ocelot
, port
, ageing_time
);
1135 return ocelot_port_vlan_filtering(ocelot
, port
,
1136 br_vlan_enabled(bridge_dev
));
1139 static int ocelot_switchdev_unsync(struct ocelot
*ocelot
, int port
)
1143 err
= ocelot_port_vlan_filtering(ocelot
, port
, false);
1147 ocelot_clear_brport_flags(ocelot
, port
);
1149 ocelot_bridge_stp_state_set(ocelot
, port
, BR_STATE_FORWARDING
);
1154 static int ocelot_netdevice_bridge_join(struct net_device
*dev
,
1155 struct net_device
*brport_dev
,
1156 struct net_device
*bridge
,
1157 struct netlink_ext_ack
*extack
)
1159 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1160 struct ocelot_port
*ocelot_port
= &priv
->port
;
1161 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1162 int port
= priv
->chip_port
;
1165 ocelot_port_bridge_join(ocelot
, port
, bridge
);
1167 err
= switchdev_bridge_port_offload(brport_dev
, dev
, priv
,
1168 &ocelot_netdevice_nb
,
1169 &ocelot_switchdev_blocking_nb
,
1172 goto err_switchdev_offload
;
1174 err
= ocelot_switchdev_sync(ocelot
, port
, brport_dev
, bridge
, extack
);
1176 goto err_switchdev_sync
;
1181 switchdev_bridge_port_unoffload(brport_dev
, priv
,
1182 &ocelot_netdevice_nb
,
1183 &ocelot_switchdev_blocking_nb
);
1184 err_switchdev_offload
:
1185 ocelot_port_bridge_leave(ocelot
, port
, bridge
);
1189 static void ocelot_netdevice_pre_bridge_leave(struct net_device
*dev
,
1190 struct net_device
*brport_dev
)
1192 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1194 switchdev_bridge_port_unoffload(brport_dev
, priv
,
1195 &ocelot_netdevice_nb
,
1196 &ocelot_switchdev_blocking_nb
);
1199 static int ocelot_netdevice_bridge_leave(struct net_device
*dev
,
1200 struct net_device
*brport_dev
,
1201 struct net_device
*bridge
)
1203 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1204 struct ocelot_port
*ocelot_port
= &priv
->port
;
1205 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1206 int port
= priv
->chip_port
;
1209 err
= ocelot_switchdev_unsync(ocelot
, port
);
1213 ocelot_port_bridge_leave(ocelot
, port
, bridge
);
1218 static int ocelot_netdevice_lag_join(struct net_device
*dev
,
1219 struct net_device
*bond
,
1220 struct netdev_lag_upper_info
*info
,
1221 struct netlink_ext_ack
*extack
)
1223 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1224 struct ocelot_port
*ocelot_port
= &priv
->port
;
1225 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1226 struct net_device
*bridge_dev
;
1227 int port
= priv
->chip_port
;
1230 err
= ocelot_port_lag_join(ocelot
, port
, bond
, info
);
1231 if (err
== -EOPNOTSUPP
) {
1232 NL_SET_ERR_MSG_MOD(extack
, "Offloading not supported");
1236 bridge_dev
= netdev_master_upper_dev_get(bond
);
1237 if (!bridge_dev
|| !netif_is_bridge_master(bridge_dev
))
1240 err
= ocelot_netdevice_bridge_join(dev
, bond
, bridge_dev
, extack
);
1242 goto err_bridge_join
;
1247 ocelot_port_lag_leave(ocelot
, port
, bond
);
1251 static void ocelot_netdevice_pre_lag_leave(struct net_device
*dev
,
1252 struct net_device
*bond
)
1254 struct net_device
*bridge_dev
;
1256 bridge_dev
= netdev_master_upper_dev_get(bond
);
1257 if (!bridge_dev
|| !netif_is_bridge_master(bridge_dev
))
1260 ocelot_netdevice_pre_bridge_leave(dev
, bond
);
1263 static int ocelot_netdevice_lag_leave(struct net_device
*dev
,
1264 struct net_device
*bond
)
1266 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1267 struct ocelot_port
*ocelot_port
= &priv
->port
;
1268 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1269 struct net_device
*bridge_dev
;
1270 int port
= priv
->chip_port
;
1272 ocelot_port_lag_leave(ocelot
, port
, bond
);
1274 bridge_dev
= netdev_master_upper_dev_get(bond
);
1275 if (!bridge_dev
|| !netif_is_bridge_master(bridge_dev
))
1278 return ocelot_netdevice_bridge_leave(dev
, bond
, bridge_dev
);
1281 static int ocelot_netdevice_changeupper(struct net_device
*dev
,
1282 struct net_device
*brport_dev
,
1283 struct netdev_notifier_changeupper_info
*info
)
1285 struct netlink_ext_ack
*extack
;
1288 extack
= netdev_notifier_info_to_extack(&info
->info
);
1290 if (netif_is_bridge_master(info
->upper_dev
)) {
1292 err
= ocelot_netdevice_bridge_join(dev
, brport_dev
,
1296 err
= ocelot_netdevice_bridge_leave(dev
, brport_dev
,
1299 if (netif_is_lag_master(info
->upper_dev
)) {
1301 err
= ocelot_netdevice_lag_join(dev
, info
->upper_dev
,
1302 info
->upper_info
, extack
);
1304 ocelot_netdevice_lag_leave(dev
, info
->upper_dev
);
1307 return notifier_from_errno(err
);
1310 /* Treat CHANGEUPPER events on an offloaded LAG as individual CHANGEUPPER
1311 * events for the lower physical ports of the LAG.
1312 * If the LAG upper isn't offloaded, ignore its CHANGEUPPER events.
1313 * In case the LAG joined a bridge, notify that we are offloading it and can do
1314 * forwarding in hardware towards it.
1317 ocelot_netdevice_lag_changeupper(struct net_device
*dev
,
1318 struct netdev_notifier_changeupper_info
*info
)
1320 struct net_device
*lower
;
1321 struct list_head
*iter
;
1322 int err
= NOTIFY_DONE
;
1324 netdev_for_each_lower_dev(dev
, lower
, iter
) {
1325 struct ocelot_port_private
*priv
= netdev_priv(lower
);
1326 struct ocelot_port
*ocelot_port
= &priv
->port
;
1328 if (ocelot_port
->bond
!= dev
)
1331 err
= ocelot_netdevice_changeupper(lower
, dev
, info
);
1333 return notifier_from_errno(err
);
1340 ocelot_netdevice_prechangeupper(struct net_device
*dev
,
1341 struct net_device
*brport_dev
,
1342 struct netdev_notifier_changeupper_info
*info
)
1344 if (netif_is_bridge_master(info
->upper_dev
) && !info
->linking
)
1345 ocelot_netdevice_pre_bridge_leave(dev
, brport_dev
);
1347 if (netif_is_lag_master(info
->upper_dev
) && !info
->linking
)
1348 ocelot_netdevice_pre_lag_leave(dev
, info
->upper_dev
);
1354 ocelot_netdevice_lag_prechangeupper(struct net_device
*dev
,
1355 struct netdev_notifier_changeupper_info
*info
)
1357 struct net_device
*lower
;
1358 struct list_head
*iter
;
1359 int err
= NOTIFY_DONE
;
1361 netdev_for_each_lower_dev(dev
, lower
, iter
) {
1362 struct ocelot_port_private
*priv
= netdev_priv(lower
);
1363 struct ocelot_port
*ocelot_port
= &priv
->port
;
1365 if (ocelot_port
->bond
!= dev
)
1368 err
= ocelot_netdevice_prechangeupper(dev
, lower
, info
);
1377 ocelot_netdevice_changelowerstate(struct net_device
*dev
,
1378 struct netdev_lag_lower_state_info
*info
)
1380 struct ocelot_port_private
*priv
= netdev_priv(dev
);
1381 bool is_active
= info
->link_up
&& info
->tx_enabled
;
1382 struct ocelot_port
*ocelot_port
= &priv
->port
;
1383 struct ocelot
*ocelot
= ocelot_port
->ocelot
;
1384 int port
= priv
->chip_port
;
1386 if (!ocelot_port
->bond
)
1389 if (ocelot_port
->lag_tx_active
== is_active
)
1392 ocelot_port_lag_change(ocelot
, port
, is_active
);
1397 static int ocelot_netdevice_event(struct notifier_block
*unused
,
1398 unsigned long event
, void *ptr
)
1400 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1403 case NETDEV_PRECHANGEUPPER
: {
1404 struct netdev_notifier_changeupper_info
*info
= ptr
;
1406 if (ocelot_netdevice_dev_check(dev
))
1407 return ocelot_netdevice_prechangeupper(dev
, dev
, info
);
1409 if (netif_is_lag_master(dev
))
1410 return ocelot_netdevice_lag_prechangeupper(dev
, info
);
1414 case NETDEV_CHANGEUPPER
: {
1415 struct netdev_notifier_changeupper_info
*info
= ptr
;
1417 if (ocelot_netdevice_dev_check(dev
))
1418 return ocelot_netdevice_changeupper(dev
, dev
, info
);
1420 if (netif_is_lag_master(dev
))
1421 return ocelot_netdevice_lag_changeupper(dev
, info
);
1425 case NETDEV_CHANGELOWERSTATE
: {
1426 struct netdev_notifier_changelowerstate_info
*info
= ptr
;
1428 if (!ocelot_netdevice_dev_check(dev
))
1431 return ocelot_netdevice_changelowerstate(dev
,
1432 info
->lower_state_info
);
1441 struct notifier_block ocelot_netdevice_nb __read_mostly
= {
1442 .notifier_call
= ocelot_netdevice_event
,
1445 static int ocelot_switchdev_event(struct notifier_block
*unused
,
1446 unsigned long event
, void *ptr
)
1448 struct net_device
*dev
= switchdev_notifier_info_to_dev(ptr
);
1452 case SWITCHDEV_PORT_ATTR_SET
:
1453 err
= switchdev_handle_port_attr_set(dev
, ptr
,
1454 ocelot_netdevice_dev_check
,
1455 ocelot_port_attr_set
);
1456 return notifier_from_errno(err
);
1462 struct notifier_block ocelot_switchdev_nb __read_mostly
= {
1463 .notifier_call
= ocelot_switchdev_event
,
1466 static int ocelot_switchdev_blocking_event(struct notifier_block
*unused
,
1467 unsigned long event
, void *ptr
)
1469 struct net_device
*dev
= switchdev_notifier_info_to_dev(ptr
);
1473 /* Blocking events. */
1474 case SWITCHDEV_PORT_OBJ_ADD
:
1475 err
= switchdev_handle_port_obj_add(dev
, ptr
,
1476 ocelot_netdevice_dev_check
,
1477 ocelot_port_obj_add
);
1478 return notifier_from_errno(err
);
1479 case SWITCHDEV_PORT_OBJ_DEL
:
1480 err
= switchdev_handle_port_obj_del(dev
, ptr
,
1481 ocelot_netdevice_dev_check
,
1482 ocelot_port_obj_del
);
1483 return notifier_from_errno(err
);
1484 case SWITCHDEV_PORT_ATTR_SET
:
1485 err
= switchdev_handle_port_attr_set(dev
, ptr
,
1486 ocelot_netdevice_dev_check
,
1487 ocelot_port_attr_set
);
1488 return notifier_from_errno(err
);
1494 struct notifier_block ocelot_switchdev_blocking_nb __read_mostly
= {
1495 .notifier_call
= ocelot_switchdev_blocking_event
,
1498 static void vsc7514_phylink_validate(struct phylink_config
*config
,
1499 unsigned long *supported
,
1500 struct phylink_link_state
*state
)
1502 struct net_device
*ndev
= to_net_dev(config
->dev
);
1503 struct ocelot_port_private
*priv
= netdev_priv(ndev
);
1504 struct ocelot_port
*ocelot_port
= &priv
->port
;
1505 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask
) = {};
1507 if (state
->interface
!= PHY_INTERFACE_MODE_NA
&&
1508 state
->interface
!= ocelot_port
->phy_mode
) {
1509 bitmap_zero(supported
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
1513 phylink_set_port_modes(mask
);
1515 phylink_set(mask
, Pause
);
1516 phylink_set(mask
, Autoneg
);
1517 phylink_set(mask
, Asym_Pause
);
1518 phylink_set(mask
, 10baseT_Half
);
1519 phylink_set(mask
, 10baseT_Full
);
1520 phylink_set(mask
, 100baseT_Half
);
1521 phylink_set(mask
, 100baseT_Full
);
1522 phylink_set(mask
, 1000baseT_Half
);
1523 phylink_set(mask
, 1000baseT_Full
);
1524 phylink_set(mask
, 1000baseX_Full
);
1525 phylink_set(mask
, 2500baseT_Full
);
1526 phylink_set(mask
, 2500baseX_Full
);
1528 bitmap_and(supported
, supported
, mask
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
1529 bitmap_and(state
->advertising
, state
->advertising
, mask
,
1530 __ETHTOOL_LINK_MODE_MASK_NBITS
);
1533 static void vsc7514_phylink_mac_config(struct phylink_config
*config
,
1534 unsigned int link_an_mode
,
1535 const struct phylink_link_state
*state
)
1537 struct net_device
*ndev
= to_net_dev(config
->dev
);
1538 struct ocelot_port_private
*priv
= netdev_priv(ndev
);
1539 struct ocelot_port
*ocelot_port
= &priv
->port
;
1541 /* Disable HDX fast control */
1542 ocelot_port_writel(ocelot_port
, DEV_PORT_MISC_HDX_FAST_DIS
,
1545 /* SGMII only for now */
1546 ocelot_port_writel(ocelot_port
, PCS1G_MODE_CFG_SGMII_MODE_ENA
,
1548 ocelot_port_writel(ocelot_port
, PCS1G_SD_CFG_SD_SEL
, PCS1G_SD_CFG
);
1551 ocelot_port_writel(ocelot_port
, PCS1G_CFG_PCS_ENA
, PCS1G_CFG
);
1553 /* No aneg on SGMII */
1554 ocelot_port_writel(ocelot_port
, 0, PCS1G_ANEG_CFG
);
1557 ocelot_port_writel(ocelot_port
, 0, PCS1G_LB_CFG
);
1560 static void vsc7514_phylink_mac_link_down(struct phylink_config
*config
,
1561 unsigned int link_an_mode
,
1562 phy_interface_t interface
)
1564 struct net_device
*ndev
= to_net_dev(config
->dev
);
1565 struct ocelot_port_private
*priv
= netdev_priv(ndev
);
1566 struct ocelot
*ocelot
= priv
->port
.ocelot
;
1567 int port
= priv
->chip_port
;
1569 ocelot_phylink_mac_link_down(ocelot
, port
, link_an_mode
, interface
,
1573 static void vsc7514_phylink_mac_link_up(struct phylink_config
*config
,
1574 struct phy_device
*phydev
,
1575 unsigned int link_an_mode
,
1576 phy_interface_t interface
,
1577 int speed
, int duplex
,
1578 bool tx_pause
, bool rx_pause
)
1580 struct net_device
*ndev
= to_net_dev(config
->dev
);
1581 struct ocelot_port_private
*priv
= netdev_priv(ndev
);
1582 struct ocelot
*ocelot
= priv
->port
.ocelot
;
1583 int port
= priv
->chip_port
;
1585 ocelot_phylink_mac_link_up(ocelot
, port
, phydev
, link_an_mode
,
1586 interface
, speed
, duplex
,
1587 tx_pause
, rx_pause
, OCELOT_MAC_QUIRKS
);
1590 static const struct phylink_mac_ops ocelot_phylink_ops
= {
1591 .validate
= vsc7514_phylink_validate
,
1592 .mac_config
= vsc7514_phylink_mac_config
,
1593 .mac_link_down
= vsc7514_phylink_mac_link_down
,
1594 .mac_link_up
= vsc7514_phylink_mac_link_up
,
1597 static int ocelot_port_phylink_create(struct ocelot
*ocelot
, int port
,
1598 struct device_node
*portnp
)
1600 struct ocelot_port
*ocelot_port
= ocelot
->ports
[port
];
1601 struct ocelot_port_private
*priv
;
1602 struct device
*dev
= ocelot
->dev
;
1603 phy_interface_t phy_mode
;
1604 struct phylink
*phylink
;
1607 of_get_phy_mode(portnp
, &phy_mode
);
1608 /* DT bindings of internal PHY ports are broken and don't
1609 * specify a phy-mode
1611 if (phy_mode
== PHY_INTERFACE_MODE_NA
)
1612 phy_mode
= PHY_INTERFACE_MODE_INTERNAL
;
1614 if (phy_mode
!= PHY_INTERFACE_MODE_SGMII
&&
1615 phy_mode
!= PHY_INTERFACE_MODE_QSGMII
&&
1616 phy_mode
!= PHY_INTERFACE_MODE_INTERNAL
) {
1617 dev_err(dev
, "unsupported phy mode %s for port %d\n",
1618 phy_modes(phy_mode
), port
);
1622 /* Ensure clock signals and speed are set on all QSGMII links */
1623 if (phy_mode
== PHY_INTERFACE_MODE_QSGMII
)
1624 ocelot_port_rmwl(ocelot_port
, 0,
1625 DEV_CLOCK_CFG_MAC_TX_RST
|
1626 DEV_CLOCK_CFG_MAC_TX_RST
,
1629 ocelot_port
->phy_mode
= phy_mode
;
1631 if (phy_mode
!= PHY_INTERFACE_MODE_INTERNAL
) {
1632 struct phy
*serdes
= of_phy_get(portnp
, NULL
);
1634 if (IS_ERR(serdes
)) {
1635 err
= PTR_ERR(serdes
);
1636 dev_err_probe(dev
, err
,
1637 "missing SerDes phys for port %d\n",
1642 err
= phy_set_mode_ext(serdes
, PHY_MODE_ETHERNET
, phy_mode
);
1645 dev_err(dev
, "Could not SerDes mode on port %d: %pe\n",
1646 port
, ERR_PTR(err
));
1651 priv
= container_of(ocelot_port
, struct ocelot_port_private
, port
);
1653 priv
->phylink_config
.dev
= &priv
->dev
->dev
;
1654 priv
->phylink_config
.type
= PHYLINK_NETDEV
;
1656 phylink
= phylink_create(&priv
->phylink_config
,
1657 of_fwnode_handle(portnp
),
1658 phy_mode
, &ocelot_phylink_ops
);
1659 if (IS_ERR(phylink
)) {
1660 err
= PTR_ERR(phylink
);
1661 dev_err(dev
, "Could not create phylink (%pe)\n", phylink
);
1665 priv
->phylink
= phylink
;
1667 err
= phylink_of_phy_connect(phylink
, portnp
, 0);
1669 dev_err(dev
, "Could not connect to PHY: %pe\n", ERR_PTR(err
));
1670 phylink_destroy(phylink
);
1671 priv
->phylink
= NULL
;
1678 int ocelot_probe_port(struct ocelot
*ocelot
, int port
, struct regmap
*target
,
1679 struct device_node
*portnp
)
1681 struct ocelot_port_private
*priv
;
1682 struct ocelot_port
*ocelot_port
;
1683 struct net_device
*dev
;
1686 dev
= alloc_etherdev(sizeof(struct ocelot_port_private
));
1689 SET_NETDEV_DEV(dev
, ocelot
->dev
);
1690 priv
= netdev_priv(dev
);
1692 priv
->chip_port
= port
;
1693 ocelot_port
= &priv
->port
;
1694 ocelot_port
->ocelot
= ocelot
;
1695 ocelot_port
->target
= target
;
1696 ocelot
->ports
[port
] = ocelot_port
;
1698 dev
->netdev_ops
= &ocelot_port_netdev_ops
;
1699 dev
->ethtool_ops
= &ocelot_ethtool_ops
;
1701 dev
->hw_features
|= NETIF_F_HW_VLAN_CTAG_FILTER
| NETIF_F_RXFCS
|
1703 dev
->features
|= NETIF_F_HW_VLAN_CTAG_FILTER
| NETIF_F_HW_TC
;
1705 memcpy(dev
->dev_addr
, ocelot
->base_mac
, ETH_ALEN
);
1706 dev
->dev_addr
[ETH_ALEN
- 1] += port
;
1707 ocelot_mact_learn(ocelot
, PGID_CPU
, dev
->dev_addr
,
1708 ocelot_port
->pvid_vlan
.vid
, ENTRYTYPE_LOCKED
);
1710 ocelot_init_port(ocelot
, port
);
1712 err
= ocelot_port_phylink_create(ocelot
, port
, portnp
);
1716 err
= register_netdev(dev
);
1718 dev_err(ocelot
->dev
, "register_netdev failed\n");
1725 ocelot
->ports
[port
] = NULL
;
1731 void ocelot_release_port(struct ocelot_port
*ocelot_port
)
1733 struct ocelot_port_private
*priv
= container_of(ocelot_port
,
1734 struct ocelot_port_private
,
1737 unregister_netdev(priv
->dev
);
1739 if (priv
->phylink
) {
1741 phylink_disconnect_phy(priv
->phylink
);
1744 phylink_destroy(priv
->phylink
);
1747 free_netdev(priv
->dev
);