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 return dsa_is_user_port(ds, p) && ds->ports[p].slave; 250 } 251 252 int dsa_switch_suspend(struct dsa_switch *ds) 253 { 254 int i, ret = 0; 255 256 /* Suspend slave network devices */ 257 for (i = 0; i < ds->num_ports; i++) { 258 if (!dsa_is_port_initialized(ds, i)) 259 continue; 260 261 ret = dsa_slave_suspend(ds->ports[i].slave); 262 if (ret) 263 return ret; 264 } 265 266 if (ds->ops->suspend) 267 ret = ds->ops->suspend(ds); 268 269 return ret; 270 } 271 EXPORT_SYMBOL_GPL(dsa_switch_suspend); 272 273 int dsa_switch_resume(struct dsa_switch *ds) 274 { 275 int i, ret = 0; 276 277 if (ds->ops->resume) 278 ret = ds->ops->resume(ds); 279 280 if (ret) 281 return ret; 282 283 /* Resume slave network devices */ 284 for (i = 0; i < ds->num_ports; i++) { 285 if (!dsa_is_port_initialized(ds, i)) 286 continue; 287 288 ret = dsa_slave_resume(ds->ports[i].slave); 289 if (ret) 290 return ret; 291 } 292 293 return 0; 294 } 295 EXPORT_SYMBOL_GPL(dsa_switch_resume); 296 #endif 297 298 static struct packet_type dsa_pack_type __read_mostly = { 299 .type = cpu_to_be16(ETH_P_XDSA), 300 .func = dsa_switch_rcv, 301 }; 302 303 static struct workqueue_struct *dsa_owq; 304 305 bool dsa_schedule_work(struct work_struct *work) 306 { 307 return queue_work(dsa_owq, work); 308 } 309 310 static ATOMIC_NOTIFIER_HEAD(dsa_notif_chain); 311 312 int register_dsa_notifier(struct notifier_block *nb) 313 { 314 return atomic_notifier_chain_register(&dsa_notif_chain, nb); 315 } 316 EXPORT_SYMBOL_GPL(register_dsa_notifier); 317 318 int unregister_dsa_notifier(struct notifier_block *nb) 319 { 320 return atomic_notifier_chain_unregister(&dsa_notif_chain, nb); 321 } 322 EXPORT_SYMBOL_GPL(unregister_dsa_notifier); 323 324 int call_dsa_notifiers(unsigned long val, struct net_device *dev, 325 struct dsa_notifier_info *info) 326 { 327 info->dev = dev; 328 return atomic_notifier_call_chain(&dsa_notif_chain, val, info); 329 } 330 EXPORT_SYMBOL_GPL(call_dsa_notifiers); 331 332 static int __init dsa_init_module(void) 333 { 334 int rc; 335 336 dsa_owq = alloc_ordered_workqueue("dsa_ordered", 337 WQ_MEM_RECLAIM); 338 if (!dsa_owq) 339 return -ENOMEM; 340 341 rc = dsa_slave_register_notifier(); 342 if (rc) 343 goto register_notifier_fail; 344 345 dev_add_pack(&dsa_pack_type); 346 347 dsa_tag_driver_register(&DSA_TAG_DRIVER_NAME(none_ops), 348 THIS_MODULE); 349 350 return 0; 351 352 register_notifier_fail: 353 destroy_workqueue(dsa_owq); 354 355 return rc; 356 } 357 module_init(dsa_init_module); 358 359 static void __exit dsa_cleanup_module(void) 360 { 361 dsa_tag_driver_unregister(&DSA_TAG_DRIVER_NAME(none_ops)); 362 363 dsa_slave_unregister_notifier(); 364 dev_remove_pack(&dsa_pack_type); 365 destroy_workqueue(dsa_owq); 366 } 367 module_exit(dsa_cleanup_module); 368 369 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); 370 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); 371 MODULE_LICENSE("GPL"); 372 MODULE_ALIAS("platform:dsa"); 373