1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net/dsa/dsa.c - Hardware switch handling
4 * Copyright (c) 2008-2009 Marvell Semiconductor
5 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
8 #include <linux/device.h>
9 #include <linux/list.h>
10 #include <linux/platform_device.h>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13 #include <linux/notifier.h>
15 #include <linux/of_mdio.h>
16 #include <linux/of_platform.h>
17 #include <linux/of_net.h>
18 #include <linux/netdevice.h>
19 #include <linux/sysfs.h>
20 #include <linux/phy_fixed.h>
21 #include <linux/ptp_classify.h>
22 #include <linux/etherdevice.h>
26 static LIST_HEAD(dsa_tag_drivers_list
);
27 static DEFINE_MUTEX(dsa_tag_drivers_lock
);
29 static struct sk_buff
*dsa_slave_notag_xmit(struct sk_buff
*skb
,
30 struct net_device
*dev
)
32 /* Just return the original SKB */
36 static const struct dsa_device_ops none_ops
= {
38 .proto
= DSA_TAG_PROTO_NONE
,
39 .xmit
= dsa_slave_notag_xmit
,
43 DSA_TAG_DRIVER(none_ops
);
45 static void dsa_tag_driver_register(struct dsa_tag_driver
*dsa_tag_driver
,
48 dsa_tag_driver
->owner
= owner
;
50 mutex_lock(&dsa_tag_drivers_lock
);
51 list_add_tail(&dsa_tag_driver
->list
, &dsa_tag_drivers_list
);
52 mutex_unlock(&dsa_tag_drivers_lock
);
55 void dsa_tag_drivers_register(struct dsa_tag_driver
*dsa_tag_driver_array
[],
56 unsigned int count
, struct module
*owner
)
60 for (i
= 0; i
< count
; i
++)
61 dsa_tag_driver_register(dsa_tag_driver_array
[i
], owner
);
64 static void dsa_tag_driver_unregister(struct dsa_tag_driver
*dsa_tag_driver
)
66 mutex_lock(&dsa_tag_drivers_lock
);
67 list_del(&dsa_tag_driver
->list
);
68 mutex_unlock(&dsa_tag_drivers_lock
);
70 EXPORT_SYMBOL_GPL(dsa_tag_drivers_register
);
72 void dsa_tag_drivers_unregister(struct dsa_tag_driver
*dsa_tag_driver_array
[],
77 for (i
= 0; i
< count
; i
++)
78 dsa_tag_driver_unregister(dsa_tag_driver_array
[i
]);
80 EXPORT_SYMBOL_GPL(dsa_tag_drivers_unregister
);
82 const char *dsa_tag_protocol_to_str(const struct dsa_device_ops
*ops
)
87 /* Function takes a reference on the module owning the tagger,
88 * so dsa_tag_driver_put must be called afterwards.
90 const struct dsa_device_ops
*dsa_find_tagger_by_name(const char *buf
)
92 const struct dsa_device_ops
*ops
= ERR_PTR(-ENOPROTOOPT
);
93 struct dsa_tag_driver
*dsa_tag_driver
;
95 mutex_lock(&dsa_tag_drivers_lock
);
96 list_for_each_entry(dsa_tag_driver
, &dsa_tag_drivers_list
, list
) {
97 const struct dsa_device_ops
*tmp
= dsa_tag_driver
->ops
;
99 if (!sysfs_streq(buf
, tmp
->name
))
102 if (!try_module_get(dsa_tag_driver
->owner
))
108 mutex_unlock(&dsa_tag_drivers_lock
);
113 const struct dsa_device_ops
*dsa_tag_driver_get(int tag_protocol
)
115 struct dsa_tag_driver
*dsa_tag_driver
;
116 const struct dsa_device_ops
*ops
;
119 request_module("%s%d", DSA_TAG_DRIVER_ALIAS
, tag_protocol
);
121 mutex_lock(&dsa_tag_drivers_lock
);
122 list_for_each_entry(dsa_tag_driver
, &dsa_tag_drivers_list
, list
) {
123 ops
= dsa_tag_driver
->ops
;
124 if (ops
->proto
== tag_protocol
) {
131 if (!try_module_get(dsa_tag_driver
->owner
))
132 ops
= ERR_PTR(-ENOPROTOOPT
);
134 ops
= ERR_PTR(-ENOPROTOOPT
);
137 mutex_unlock(&dsa_tag_drivers_lock
);
142 void dsa_tag_driver_put(const struct dsa_device_ops
*ops
)
144 struct dsa_tag_driver
*dsa_tag_driver
;
146 mutex_lock(&dsa_tag_drivers_lock
);
147 list_for_each_entry(dsa_tag_driver
, &dsa_tag_drivers_list
, list
) {
148 if (dsa_tag_driver
->ops
== ops
) {
149 module_put(dsa_tag_driver
->owner
);
153 mutex_unlock(&dsa_tag_drivers_lock
);
156 static int dev_is_class(struct device
*dev
, void *class)
158 if (dev
->class != NULL
&& !strcmp(dev
->class->name
, class))
164 static struct device
*dev_find_class(struct device
*parent
, char *class)
166 if (dev_is_class(parent
, class)) {
171 return device_find_child(parent
, class, dev_is_class
);
174 struct net_device
*dsa_dev_to_net_device(struct device
*dev
)
178 d
= dev_find_class(dev
, "net");
180 struct net_device
*nd
;
191 EXPORT_SYMBOL_GPL(dsa_dev_to_net_device
);
193 /* Determine if we should defer delivery of skb until we have a rx timestamp.
195 * Called from dsa_switch_rcv. For now, this will only work if tagging is
196 * enabled on the switch. Normally the MAC driver would retrieve the hardware
197 * timestamp when it reads the packet out of the hardware. However in a DSA
198 * switch, the DSA driver owning the interface to which the packet is
199 * delivered is never notified unless we do so here.
201 static bool dsa_skb_defer_rx_timestamp(struct dsa_slave_priv
*p
,
204 struct dsa_switch
*ds
= p
->dp
->ds
;
207 if (skb_headroom(skb
) < ETH_HLEN
)
210 __skb_push(skb
, ETH_HLEN
);
212 type
= ptp_classify_raw(skb
);
214 __skb_pull(skb
, ETH_HLEN
);
216 if (type
== PTP_CLASS_NONE
)
219 if (likely(ds
->ops
->port_rxtstamp
))
220 return ds
->ops
->port_rxtstamp(ds
, p
->dp
->index
, skb
, type
);
225 static int dsa_switch_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
226 struct packet_type
*pt
, struct net_device
*unused
)
228 struct dsa_port
*cpu_dp
= dev
->dsa_ptr
;
229 struct sk_buff
*nskb
= NULL
;
230 struct dsa_slave_priv
*p
;
232 if (unlikely(!cpu_dp
)) {
237 skb
= skb_unshare(skb
, GFP_ATOMIC
);
241 nskb
= cpu_dp
->rcv(skb
, dev
);
248 skb_push(skb
, ETH_HLEN
);
249 skb
->pkt_type
= PACKET_HOST
;
250 skb
->protocol
= eth_type_trans(skb
, skb
->dev
);
252 if (unlikely(!dsa_slave_dev_check(skb
->dev
))) {
253 /* Packet is to be injected directly on an upper
254 * device, e.g. a team/bond, so skip all DSA-port
261 p
= netdev_priv(skb
->dev
);
263 if (unlikely(cpu_dp
->ds
->untag_bridge_pvid
)) {
264 nskb
= dsa_untag_bridge_pvid(skb
);
272 dev_sw_netstats_rx_add(skb
->dev
, skb
->len
);
274 if (dsa_skb_defer_rx_timestamp(p
, skb
))
277 gro_cells_receive(&p
->gcells
, skb
);
282 #ifdef CONFIG_PM_SLEEP
283 static bool dsa_is_port_initialized(struct dsa_switch
*ds
, int p
)
285 const struct dsa_port
*dp
= dsa_to_port(ds
, p
);
287 return dp
->type
== DSA_PORT_TYPE_USER
&& dp
->slave
;
290 int dsa_switch_suspend(struct dsa_switch
*ds
)
294 /* Suspend slave network devices */
295 for (i
= 0; i
< ds
->num_ports
; i
++) {
296 if (!dsa_is_port_initialized(ds
, i
))
299 ret
= dsa_slave_suspend(dsa_to_port(ds
, i
)->slave
);
304 if (ds
->ops
->suspend
)
305 ret
= ds
->ops
->suspend(ds
);
309 EXPORT_SYMBOL_GPL(dsa_switch_suspend
);
311 int dsa_switch_resume(struct dsa_switch
*ds
)
316 ret
= ds
->ops
->resume(ds
);
321 /* Resume slave network devices */
322 for (i
= 0; i
< ds
->num_ports
; i
++) {
323 if (!dsa_is_port_initialized(ds
, i
))
326 ret
= dsa_slave_resume(dsa_to_port(ds
, i
)->slave
);
333 EXPORT_SYMBOL_GPL(dsa_switch_resume
);
336 static struct packet_type dsa_pack_type __read_mostly
= {
337 .type
= cpu_to_be16(ETH_P_XDSA
),
338 .func
= dsa_switch_rcv
,
341 static struct workqueue_struct
*dsa_owq
;
343 bool dsa_schedule_work(struct work_struct
*work
)
345 return queue_work(dsa_owq
, work
);
348 void dsa_flush_workqueue(void)
350 flush_workqueue(dsa_owq
);
353 int dsa_devlink_param_get(struct devlink
*dl
, u32 id
,
354 struct devlink_param_gset_ctx
*ctx
)
356 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
358 if (!ds
->ops
->devlink_param_get
)
361 return ds
->ops
->devlink_param_get(ds
, id
, ctx
);
363 EXPORT_SYMBOL_GPL(dsa_devlink_param_get
);
365 int dsa_devlink_param_set(struct devlink
*dl
, u32 id
,
366 struct devlink_param_gset_ctx
*ctx
)
368 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
370 if (!ds
->ops
->devlink_param_set
)
373 return ds
->ops
->devlink_param_set(ds
, id
, ctx
);
375 EXPORT_SYMBOL_GPL(dsa_devlink_param_set
);
377 int dsa_devlink_params_register(struct dsa_switch
*ds
,
378 const struct devlink_param
*params
,
381 return devlink_params_register(ds
->devlink
, params
, params_count
);
383 EXPORT_SYMBOL_GPL(dsa_devlink_params_register
);
385 void dsa_devlink_params_unregister(struct dsa_switch
*ds
,
386 const struct devlink_param
*params
,
389 devlink_params_unregister(ds
->devlink
, params
, params_count
);
391 EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister
);
393 int dsa_devlink_resource_register(struct dsa_switch
*ds
,
394 const char *resource_name
,
397 u64 parent_resource_id
,
398 const struct devlink_resource_size_params
*size_params
)
400 return devlink_resource_register(ds
->devlink
, resource_name
,
401 resource_size
, resource_id
,
405 EXPORT_SYMBOL_GPL(dsa_devlink_resource_register
);
407 void dsa_devlink_resources_unregister(struct dsa_switch
*ds
)
409 devlink_resources_unregister(ds
->devlink
, NULL
);
411 EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister
);
413 void dsa_devlink_resource_occ_get_register(struct dsa_switch
*ds
,
415 devlink_resource_occ_get_t
*occ_get
,
418 return devlink_resource_occ_get_register(ds
->devlink
, resource_id
,
419 occ_get
, occ_get_priv
);
421 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register
);
423 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch
*ds
,
426 devlink_resource_occ_get_unregister(ds
->devlink
, resource_id
);
428 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister
);
430 struct devlink_region
*
431 dsa_devlink_region_create(struct dsa_switch
*ds
,
432 const struct devlink_region_ops
*ops
,
433 u32 region_max_snapshots
, u64 region_size
)
435 return devlink_region_create(ds
->devlink
, ops
, region_max_snapshots
,
438 EXPORT_SYMBOL_GPL(dsa_devlink_region_create
);
440 struct devlink_region
*
441 dsa_devlink_port_region_create(struct dsa_switch
*ds
,
443 const struct devlink_port_region_ops
*ops
,
444 u32 region_max_snapshots
, u64 region_size
)
446 struct dsa_port
*dp
= dsa_to_port(ds
, port
);
448 return devlink_port_region_create(&dp
->devlink_port
, ops
,
449 region_max_snapshots
,
452 EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create
);
454 void dsa_devlink_region_destroy(struct devlink_region
*region
)
456 devlink_region_destroy(region
);
458 EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy
);
460 struct dsa_port
*dsa_port_from_netdev(struct net_device
*netdev
)
462 if (!netdev
|| !dsa_slave_dev_check(netdev
))
463 return ERR_PTR(-ENODEV
);
465 return dsa_slave_to_port(netdev
);
467 EXPORT_SYMBOL_GPL(dsa_port_from_netdev
);
469 static int __init
dsa_init_module(void)
473 dsa_owq
= alloc_ordered_workqueue("dsa_ordered",
478 rc
= dsa_slave_register_notifier();
480 goto register_notifier_fail
;
482 dev_add_pack(&dsa_pack_type
);
484 dsa_tag_driver_register(&DSA_TAG_DRIVER_NAME(none_ops
),
489 register_notifier_fail
:
490 destroy_workqueue(dsa_owq
);
494 module_init(dsa_init_module
);
496 static void __exit
dsa_cleanup_module(void)
498 dsa_tag_driver_unregister(&DSA_TAG_DRIVER_NAME(none_ops
));
500 dsa_slave_unregister_notifier();
501 dev_remove_pack(&dsa_pack_type
);
502 destroy_workqueue(dsa_owq
);
504 module_exit(dsa_cleanup_module
);
506 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
507 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
508 MODULE_LICENSE("GPL");
509 MODULE_ALIAS("platform:dsa");