~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/dsa/dsa.c

Version: ~ [ linux-4.18-rc6 ] ~ [ linux-4.17.9 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.57 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.114 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.143 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.116 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * net/dsa/dsa.c - Hardware switch handling
  3  * Copyright (c) 2008-2009 Marvell Semiconductor
  4  * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation; either version 2 of the License, or
  9  * (at your option) any later version.
 10  */
 11 
 12 #include <linux/device.h>
 13 #include <linux/list.h>
 14 #include <linux/platform_device.h>
 15 #include <linux/slab.h>
 16 #include <linux/module.h>
 17 #include <linux/notifier.h>
 18 #include <linux/of.h>
 19 #include <linux/of_mdio.h>
 20 #include <linux/of_platform.h>
 21 #include <linux/of_net.h>
 22 #include <linux/of_gpio.h>
 23 #include <linux/netdevice.h>
 24 #include <linux/sysfs.h>
 25 #include <linux/phy_fixed.h>
 26 #include <linux/ptp_classify.h>
 27 #include <linux/gpio/consumer.h>
 28 #include <linux/etherdevice.h>
 29 
 30 #include "dsa_priv.h"
 31 
 32 static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb,
 33                                             struct net_device *dev)
 34 {
 35         /* Just return the original SKB */
 36         return skb;
 37 }
 38 
 39 static const struct dsa_device_ops none_ops = {
 40         .xmit   = dsa_slave_notag_xmit,
 41         .rcv    = NULL,
 42 };
 43 
 44 const struct dsa_device_ops *dsa_device_ops[DSA_TAG_LAST] = {
 45 #ifdef CONFIG_NET_DSA_TAG_BRCM
 46         [DSA_TAG_PROTO_BRCM] = &brcm_netdev_ops,
 47 #endif
 48 #ifdef CONFIG_NET_DSA_TAG_BRCM_PREPEND
 49         [DSA_TAG_PROTO_BRCM_PREPEND] = &brcm_prepend_netdev_ops,
 50 #endif
 51 #ifdef CONFIG_NET_DSA_TAG_DSA
 52         [DSA_TAG_PROTO_DSA] = &dsa_netdev_ops,
 53 #endif
 54 #ifdef CONFIG_NET_DSA_TAG_EDSA
 55         [DSA_TAG_PROTO_EDSA] = &edsa_netdev_ops,
 56 #endif
 57 #ifdef CONFIG_NET_DSA_TAG_KSZ
 58         [DSA_TAG_PROTO_KSZ] = &ksz_netdev_ops,
 59 #endif
 60 #ifdef CONFIG_NET_DSA_TAG_LAN9303
 61         [DSA_TAG_PROTO_LAN9303] = &lan9303_netdev_ops,
 62 #endif
 63 #ifdef CONFIG_NET_DSA_TAG_MTK
 64         [DSA_TAG_PROTO_MTK] = &mtk_netdev_ops,
 65 #endif
 66 #ifdef CONFIG_NET_DSA_TAG_QCA
 67         [DSA_TAG_PROTO_QCA] = &qca_netdev_ops,
 68 #endif
 69 #ifdef CONFIG_NET_DSA_TAG_TRAILER
 70         [DSA_TAG_PROTO_TRAILER] = &trailer_netdev_ops,
 71 #endif
 72         [DSA_TAG_PROTO_NONE] = &none_ops,
 73 };
 74 
 75 const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol)
 76 {
 77         const struct dsa_device_ops *ops;
 78 
 79         if (tag_protocol >= DSA_TAG_LAST)
 80                 return ERR_PTR(-EINVAL);
 81         ops = dsa_device_ops[tag_protocol];
 82 
 83         if (!ops)
 84                 return ERR_PTR(-ENOPROTOOPT);
 85 
 86         return ops;
 87 }
 88 
 89 static int dev_is_class(struct device *dev, void *class)
 90 {
 91         if (dev->class != NULL && !strcmp(dev->class->name, class))
 92                 return 1;
 93 
 94         return 0;
 95 }
 96 
 97 static struct device *dev_find_class(struct device *parent, char *class)
 98 {
 99         if (dev_is_class(parent, class)) {
100                 get_device(parent);
101                 return parent;
102         }
103 
104         return device_find_child(parent, class, dev_is_class);
105 }
106 
107 struct net_device *dsa_dev_to_net_device(struct device *dev)
108 {
109         struct device *d;
110 
111         d = dev_find_class(dev, "net");
112         if (d != NULL) {
113                 struct net_device *nd;
114 
115                 nd = to_net_dev(d);
116                 dev_hold(nd);
117                 put_device(d);
118 
119                 return nd;
120         }
121 
122         return NULL;
123 }
124 EXPORT_SYMBOL_GPL(dsa_dev_to_net_device);
125 
126 /* Determine if we should defer delivery of skb until we have a rx timestamp.
127  *
128  * Called from dsa_switch_rcv. For now, this will only work if tagging is
129  * enabled on the switch. Normally the MAC driver would retrieve the hardware
130  * timestamp when it reads the packet out of the hardware. However in a DSA
131  * switch, the DSA driver owning the interface to which the packet is
132  * delivered is never notified unless we do so here.
133  */
134 static bool dsa_skb_defer_rx_timestamp(struct dsa_slave_priv *p,
135                                        struct sk_buff *skb)
136 {
137         struct dsa_switch *ds = p->dp->ds;
138         unsigned int type;
139 
140         if (skb_headroom(skb) < ETH_HLEN)
141                 return false;
142 
143         __skb_push(skb, ETH_HLEN);
144 
145         type = ptp_classify_raw(skb);
146 
147         __skb_pull(skb, ETH_HLEN);
148 
149         if (type == PTP_CLASS_NONE)
150                 return false;
151 
152         if (likely(ds->ops->port_rxtstamp))
153                 return ds->ops->port_rxtstamp(ds, p->dp->index, skb, type);
154 
155         return false;
156 }
157 
158 static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev,
159                           struct packet_type *pt, struct net_device *unused)
160 {
161         struct dsa_port *cpu_dp = dev->dsa_ptr;
162         struct sk_buff *nskb = NULL;
163         struct pcpu_sw_netstats *s;
164         struct dsa_slave_priv *p;
165 
166         if (unlikely(!cpu_dp)) {
167                 kfree_skb(skb);
168                 return 0;
169         }
170 
171         skb = skb_unshare(skb, GFP_ATOMIC);
172         if (!skb)
173                 return 0;
174 
175         nskb = cpu_dp->rcv(skb, dev, pt);
176         if (!nskb) {
177                 kfree_skb(skb);
178                 return 0;
179         }
180 
181         skb = nskb;
182         p = netdev_priv(skb->dev);
183         skb_push(skb, ETH_HLEN);
184         skb->pkt_type = PACKET_HOST;
185         skb->protocol = eth_type_trans(skb, skb->dev);
186 
187         s = this_cpu_ptr(p->stats64);
188         u64_stats_update_begin(&s->syncp);
189         s->rx_packets++;
190         s->rx_bytes += skb->len;
191         u64_stats_update_end(&s->syncp);
192 
193         if (dsa_skb_defer_rx_timestamp(p, skb))
194                 return 0;
195 
196         netif_receive_skb(skb);
197 
198         return 0;
199 }
200 
201 #ifdef CONFIG_PM_SLEEP
202 static bool dsa_is_port_initialized(struct dsa_switch *ds, int p)
203 {
204         return dsa_is_user_port(ds, p) && ds->ports[p].slave;
205 }
206 
207 int dsa_switch_suspend(struct dsa_switch *ds)
208 {
209         int i, ret = 0;
210 
211         /* Suspend slave network devices */
212         for (i = 0; i < ds->num_ports; i++) {
213                 if (!dsa_is_port_initialized(ds, i))
214                         continue;
215 
216                 ret = dsa_slave_suspend(ds->ports[i].slave);
217                 if (ret)
218                         return ret;
219         }
220 
221         if (ds->ops->suspend)
222                 ret = ds->ops->suspend(ds);
223 
224         return ret;
225 }
226 EXPORT_SYMBOL_GPL(dsa_switch_suspend);
227 
228 int dsa_switch_resume(struct dsa_switch *ds)
229 {
230         int i, ret = 0;
231 
232         if (ds->ops->resume)
233                 ret = ds->ops->resume(ds);
234 
235         if (ret)
236                 return ret;
237 
238         /* Resume slave network devices */
239         for (i = 0; i < ds->num_ports; i++) {
240                 if (!dsa_is_port_initialized(ds, i))
241                         continue;
242 
243                 ret = dsa_slave_resume(ds->ports[i].slave);
244                 if (ret)
245                         return ret;
246         }
247 
248         return 0;
249 }
250 EXPORT_SYMBOL_GPL(dsa_switch_resume);
251 #endif
252 
253 static struct packet_type dsa_pack_type __read_mostly = {
254         .type   = cpu_to_be16(ETH_P_XDSA),
255         .func   = dsa_switch_rcv,
256 };
257 
258 static struct workqueue_struct *dsa_owq;
259 
260 bool dsa_schedule_work(struct work_struct *work)
261 {
262         return queue_work(dsa_owq, work);
263 }
264 
265 static ATOMIC_NOTIFIER_HEAD(dsa_notif_chain);
266 
267 int register_dsa_notifier(struct notifier_block *nb)
268 {
269         return atomic_notifier_chain_register(&dsa_notif_chain, nb);
270 }
271 EXPORT_SYMBOL_GPL(register_dsa_notifier);
272 
273 int unregister_dsa_notifier(struct notifier_block *nb)
274 {
275         return atomic_notifier_chain_unregister(&dsa_notif_chain, nb);
276 }
277 EXPORT_SYMBOL_GPL(unregister_dsa_notifier);
278 
279 int call_dsa_notifiers(unsigned long val, struct net_device *dev,
280                        struct dsa_notifier_info *info)
281 {
282         info->dev = dev;
283         return atomic_notifier_call_chain(&dsa_notif_chain, val, info);
284 }
285 EXPORT_SYMBOL_GPL(call_dsa_notifiers);
286 
287 static int __init dsa_init_module(void)
288 {
289         int rc;
290 
291         dsa_owq = alloc_ordered_workqueue("dsa_ordered",
292                                           WQ_MEM_RECLAIM);
293         if (!dsa_owq)
294                 return -ENOMEM;
295 
296         rc = dsa_slave_register_notifier();
297         if (rc)
298                 return rc;
299 
300         rc = dsa_legacy_register();
301         if (rc)
302                 return rc;
303 
304         dev_add_pack(&dsa_pack_type);
305 
306         return 0;
307 }
308 module_init(dsa_init_module);
309 
310 static void __exit dsa_cleanup_module(void)
311 {
312         dsa_slave_unregister_notifier();
313         dev_remove_pack(&dsa_pack_type);
314         dsa_legacy_unregister();
315         destroy_workqueue(dsa_owq);
316 }
317 module_exit(dsa_cleanup_module);
318 
319 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
320 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
321 MODULE_LICENSE("GPL");
322 MODULE_ALIAS("platform:dsa");
323 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp