1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * net/dsa/dsa.c - Hardware switch handling 4 * Copyright (c) 2008-2009 Marvell Semiconductor 5 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org> 6 */ 7 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> 14 #include <linux/of.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> 23 24 #include "dsa_priv.h" 25 26 static LIST_HEAD(dsa_tag_drivers_list); 27 static DEFINE_MUTEX(dsa_tag_drivers_lock); 28 29 static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb, 30 struct net_device *dev) 31 { 32 /* Just return the original SKB */ 33 return skb; 34 } 35 36 static const struct dsa_device_ops none_ops = { 37 .name = "none", 38 .proto = DSA_TAG_PROTO_NONE, 39 .xmit = dsa_slave_notag_xmit, 40 .rcv = NULL, 41 }; 42 43 DSA_TAG_DRIVER(none_ops); 44 45 static void dsa_tag_driver_register(struct dsa_tag_driver *dsa_tag_driver, 46 struct module *owner) 47 { 48 dsa_tag_driver->owner = owner; 49 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); 53 } 54 55 void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[], 56 unsigned int count, struct module *owner) 57 { 58 unsigned int i; 59 60 for (i = 0; i < count; i++) 61 dsa_tag_driver_register(dsa_tag_driver_array[i], owner); 62 } 63 64 static void dsa_tag_driver_unregister(struct dsa_tag_driver *dsa_tag_driver) 65 { 66 mutex_lock(&dsa_tag_drivers_lock); 67 list_del(&dsa_tag_driver->list); 68 mutex_unlock(&dsa_tag_drivers_lock); 69 } 70 EXPORT_SYMBOL_GPL(dsa_tag_drivers_register); 71 72 void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[], 73 unsigned int count) 74 { 75 unsigned int i; 76 77 for (i = 0; i < count; i++) 78 dsa_tag_driver_unregister(dsa_tag_driver_array[i]); 79 } 80 EXPORT_SYMBOL_GPL(dsa_tag_drivers_unregister); 81 82 const char *dsa_tag_protocol_to_str(const struct dsa_device_ops *ops) 83 { 84 return ops->name; 85 }; 86 87 const struct dsa_device_ops *dsa_tag_driver_get(int tag_protocol) 88 { 89 struct dsa_tag_driver *dsa_tag_driver; 90 const struct dsa_device_ops *ops; 91 char module_name[128]; 92 bool found = false; 93 94 snprintf(module_name, 127, "%s%d", DSA_TAG_DRIVER_ALIAS, 95 tag_protocol); 96 97 request_module(module_name); 98 99 mutex_lock(&dsa_tag_drivers_lock); 100 list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) { 101 ops = dsa_tag_driver->ops; 102 if (ops->proto == tag_protocol) { 103 found = true; 104 break; 105 } 106 } 107 108 if (found) { 109 if (!try_module_get(dsa_tag_driver->owner)) 110 ops = ERR_PTR(-ENOPROTOOPT); 111 } else { 112 ops = ERR_PTR(-ENOPROTOOPT); 113 } 114 115 mutex_unlock(&dsa_tag_drivers_lock); 116 117 return ops; 118 } 119 120 void dsa_tag_driver_put(const struct dsa_device_ops *ops) 121 { 122 struct dsa_tag_driver *dsa_tag_driver; 123 124 mutex_lock(&dsa_tag_drivers_lock); 125 list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) { 126 if (dsa_tag_driver->ops == ops) { 127 module_put(dsa_tag_driver->owner); 128 break; 129 } 130 } 131 mutex_unlock(&dsa_tag_drivers_lock); 132 } 133 134 static int dev_is_class(struct device *dev, void *class) 135 { 136 if (dev->class != NULL && !strcmp(dev->class->name, class)) 137 return 1; 138 139 return 0; 140 } 141 142 static struct device *dev_find_class(struct device *parent, char *class) 143 { 144 if (dev_is_class(parent, class)) { 145 get_device(parent); 146 return parent; 147 } 148 149 return device_find_child(parent, class, dev_is_class); 150 } 151 152 struct net_device *dsa_dev_to_net_device(struct device *dev) 153 { 154 struct device *d; 155 156 d = dev_find_class(dev, "net"); 157 if (d != NULL) { 158 struct net_device *nd; 159 160 nd = to_net_dev(d); 161 dev_hold(nd); 162 put_device(d); 163 164 return nd; 165 } 166 167 return NULL; 168 } 169 EXPORT_SYMBOL_GPL(dsa_dev_to_net_device); 170 171 /* Determine if we should defer delivery of skb until we have a rx timestamp. 172 * 173 * Called from dsa_switch_rcv. For now, this will only work if tagging is 174 * enabled on the switch. Normally the MAC driver would retrieve the hardware 175 * timestamp when it reads the packet out of the hardware. However in a DSA 176 * switch, the DSA driver owning the interface to which the packet is 177 * delivered is never notified unless we do so here. 178 */ 179 static bool dsa_skb_defer_rx_timestamp(struct dsa_slave_priv *p, 180 struct sk_buff *skb) 181 { 182 struct dsa_switch *ds = p->dp->ds; 183 unsigned int type; 184 185 if (skb_headroom(skb) < ETH_HLEN) 186 return false; 187 188 __skb_push(skb, ETH_HLEN); 189 190 type = ptp_classify_raw(skb); 191 192 __skb_pull(skb, ETH_HLEN); 193 194 if (type == PTP_CLASS_NONE) 195 return false; 196 197 if (likely(ds->ops->port_rxtstamp)) 198 return ds->ops->port_rxtstamp(ds, p->dp->index, skb, type); 199 200 return false; 201 } 202 203 static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev, 204 struct packet_type *pt, struct net_device *unused) 205 { 206 struct dsa_port *cpu_dp = dev->dsa_ptr; 207 struct sk_buff *nskb = NULL; 208 struct pcpu_sw_netstats *s; 209 struct dsa_slave_priv *p; 210 211 if (unlikely(!cpu_dp)) { 212 kfree_skb(skb); 213 return 0; 214 } 215 216 skb = skb_unshare(skb, GFP_ATOMIC); 217 if (!skb) 218 return 0; 219 220 nskb = cpu_dp->rcv(skb, dev, pt); 221 if (!nskb) { 222 kfree_skb(skb); 223 return 0; 224 } 225 226 skb = nskb; 227 p = netdev_priv(skb->dev); 228 skb_push(skb, ETH_HLEN); 229 skb->pkt_type = PACKET_HOST; 230 skb->protocol = eth_type_trans(skb, skb->dev); 231 232 s = this_cpu_ptr(p->stats64); 233 u64_stats_update_begin(&s->syncp); 234 s->rx_packets++; 235 s->rx_bytes += skb->len; 236 u64_stats_update_end(&s->syncp); 237 238 if (dsa_skb_defer_rx_timestamp(p, skb)) 239 return 0; 240 241 netif_receive_skb(skb); 242 243 return 0; 244 } 245 246 #ifdef CONFIG_PM_SLEEP 247 static bool dsa_is_port_initialized(struct dsa_switch *ds, int p) 248 { 249 const struct dsa_port *dp = dsa_to_port(ds, p); 250 251 return dp->type == DSA_PORT_TYPE_USER && dp->slave; 252 } 253 254 int dsa_switch_suspend(struct dsa_switch *ds) 255 { 256 int i, ret = 0; 257 258 /* Suspend slave network devices */ 259 for (i = 0; i < ds->num_ports; i++) { 260 if (!dsa_is_port_initialized(ds, i)) 261 continue; 262 263 ret = dsa_slave_suspend(dsa_to_port(ds, i)->slave); 264 if (ret) 265 return ret; 266 } 267 268 if (ds->ops->suspend) 269 ret = ds->ops->suspend(ds); 270 271 return ret; 272 } 273 EXPORT_SYMBOL_GPL(dsa_switch_suspend); 274 275 int dsa_switch_resume(struct dsa_switch *ds) 276 { 277 int i, ret = 0; 278 279 if (ds->ops->resume) 280 ret = ds->ops->resume(ds); 281 282 if (ret) 283 return ret; 284 285 /* Resume slave network devices */ 286 for (i = 0; i < ds->num_ports; i++) { 287 if (!dsa_is_port_initialized(ds, i)) 288 continue; 289 290 ret = dsa_slave_resume(dsa_to_port(ds, i)->slave); 291 if (ret) 292 return ret; 293 } 294 295 return 0; 296 } 297 EXPORT_SYMBOL_GPL(dsa_switch_resume); 298 #endif 299 300 static struct packet_type dsa_pack_type __read_mostly = { 301 .type = cpu_to_be16(ETH_P_XDSA), 302 .func = dsa_switch_rcv, 303 }; 304 305 static struct workqueue_struct *dsa_owq; 306 307 bool dsa_schedule_work(struct work_struct *work) 308 { 309 return queue_work(dsa_owq, work); 310 } 311 312 static ATOMIC_NOTIFIER_HEAD(dsa_notif_chain); 313 314 int register_dsa_notifier(struct notifier_block *nb) 315 { 316 return atomic_notifier_chain_register(&dsa_notif_chain, nb); 317 } 318 EXPORT_SYMBOL_GPL(register_dsa_notifier); 319 320 int unregister_dsa_notifier(struct notifier_block *nb) 321 { 322 return atomic_notifier_chain_unregister(&dsa_notif_chain, nb); 323 } 324 EXPORT_SYMBOL_GPL(unregister_dsa_notifier); 325 326 int call_dsa_notifiers(unsigned long val, struct net_device *dev, 327 struct dsa_notifier_info *info) 328 { 329 info->dev = dev; 330 return atomic_notifier_call_chain(&dsa_notif_chain, val, info); 331 } 332 EXPORT_SYMBOL_GPL(call_dsa_notifiers); 333 334 int dsa_devlink_param_get(struct devlink *dl, u32 id, 335 struct devlink_param_gset_ctx *ctx) 336 { 337 struct dsa_devlink_priv *dl_priv; 338 struct dsa_switch *ds; 339 340 dl_priv = devlink_priv(dl); 341 ds = dl_priv->ds; 342 343 if (!ds->ops->devlink_param_get) 344 return -EOPNOTSUPP; 345 346 return ds->ops->devlink_param_get(ds, id, ctx); 347 } 348 EXPORT_SYMBOL_GPL(dsa_devlink_param_get); 349 350 int dsa_devlink_param_set(struct devlink *dl, u32 id, 351 struct devlink_param_gset_ctx *ctx) 352 { 353 struct dsa_devlink_priv *dl_priv; 354 struct dsa_switch *ds; 355 356 dl_priv = devlink_priv(dl); 357 ds = dl_priv->ds; 358 359 if (!ds->ops->devlink_param_set) 360 return -EOPNOTSUPP; 361 362 return ds->ops->devlink_param_set(ds, id, ctx); 363 } 364 EXPORT_SYMBOL_GPL(dsa_devlink_param_set); 365 366 int dsa_devlink_params_register(struct dsa_switch *ds, 367 const struct devlink_param *params, 368 size_t params_count) 369 { 370 return devlink_params_register(ds->devlink, params, params_count); 371 } 372 EXPORT_SYMBOL_GPL(dsa_devlink_params_register); 373 374 void dsa_devlink_params_unregister(struct dsa_switch *ds, 375 const struct devlink_param *params, 376 size_t params_count) 377 { 378 devlink_params_unregister(ds->devlink, params, params_count); 379 } 380 EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister); 381 382 int dsa_devlink_resource_register(struct dsa_switch *ds, 383 const char *resource_name, 384 u64 resource_size, 385 u64 resource_id, 386 u64 parent_resource_id, 387 const struct devlink_resource_size_params *size_params) 388 { 389 return devlink_resource_register(ds->devlink, resource_name, 390 resource_size, resource_id, 391 parent_resource_id, 392 size_params); 393 } 394 EXPORT_SYMBOL_GPL(dsa_devlink_resource_register); 395 396 void dsa_devlink_resources_unregister(struct dsa_switch *ds) 397 { 398 devlink_resources_unregister(ds->devlink, NULL); 399 } 400 EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister); 401 402 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds, 403 u64 resource_id, 404 devlink_resource_occ_get_t *occ_get, 405 void *occ_get_priv) 406 { 407 return devlink_resource_occ_get_register(ds->devlink, resource_id, 408 occ_get, occ_get_priv); 409 } 410 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register); 411 412 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds, 413 u64 resource_id) 414 { 415 devlink_resource_occ_get_unregister(ds->devlink, resource_id); 416 } 417 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister); 418 419 static int __init dsa_init_module(void) 420 { 421 int rc; 422 423 dsa_owq = alloc_ordered_workqueue("dsa_ordered", 424 WQ_MEM_RECLAIM); 425 if (!dsa_owq) 426 return -ENOMEM; 427 428 rc = dsa_slave_register_notifier(); 429 if (rc) 430 goto register_notifier_fail; 431 432 dev_add_pack(&dsa_pack_type); 433 434 dsa_tag_driver_register(&DSA_TAG_DRIVER_NAME(none_ops), 435 THIS_MODULE); 436 437 return 0; 438 439 register_notifier_fail: 440 destroy_workqueue(dsa_owq); 441 442 return rc; 443 } 444 module_init(dsa_init_module); 445 446 static void __exit dsa_cleanup_module(void) 447 { 448 dsa_tag_driver_unregister(&DSA_TAG_DRIVER_NAME(none_ops)); 449 450 dsa_slave_unregister_notifier(); 451 dev_remove_pack(&dsa_pack_type); 452 destroy_workqueue(dsa_owq); 453 } 454 module_exit(dsa_cleanup_module); 455 456 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); 457 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); 458 MODULE_LICENSE("GPL"); 459 MODULE_ALIAS("platform:dsa"); 460