1
2
3
4
5
6
7
8
9
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/of.h>
18#include <linux/of_mdio.h>
19#include <linux/of_platform.h>
20#include <linux/of_net.h>
21#include <linux/of_gpio.h>
22#include <linux/netdevice.h>
23#include <linux/sysfs.h>
24#include <linux/phy_fixed.h>
25#include <linux/gpio/consumer.h>
26#include <linux/etherdevice.h>
27
28#include "dsa_priv.h"
29
30static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb,
31 struct net_device *dev)
32{
33
34 return skb;
35}
36
37static const struct dsa_device_ops none_ops = {
38 .xmit = dsa_slave_notag_xmit,
39 .rcv = NULL,
40};
41
42const struct dsa_device_ops *dsa_device_ops[DSA_TAG_LAST] = {
43#ifdef CONFIG_NET_DSA_TAG_BRCM
44 [DSA_TAG_PROTO_BRCM] = &brcm_netdev_ops,
45#endif
46#ifdef CONFIG_NET_DSA_TAG_DSA
47 [DSA_TAG_PROTO_DSA] = &dsa_netdev_ops,
48#endif
49#ifdef CONFIG_NET_DSA_TAG_EDSA
50 [DSA_TAG_PROTO_EDSA] = &edsa_netdev_ops,
51#endif
52#ifdef CONFIG_NET_DSA_TAG_KSZ
53 [DSA_TAG_PROTO_KSZ] = &ksz_netdev_ops,
54#endif
55#ifdef CONFIG_NET_DSA_TAG_LAN9303
56 [DSA_TAG_PROTO_LAN9303] = &lan9303_netdev_ops,
57#endif
58#ifdef CONFIG_NET_DSA_TAG_MTK
59 [DSA_TAG_PROTO_MTK] = &mtk_netdev_ops,
60#endif
61#ifdef CONFIG_NET_DSA_TAG_QCA
62 [DSA_TAG_PROTO_QCA] = &qca_netdev_ops,
63#endif
64#ifdef CONFIG_NET_DSA_TAG_TRAILER
65 [DSA_TAG_PROTO_TRAILER] = &trailer_netdev_ops,
66#endif
67 [DSA_TAG_PROTO_NONE] = &none_ops,
68};
69
70int dsa_cpu_dsa_setup(struct dsa_port *port)
71{
72 struct device_node *port_dn = port->dn;
73 struct dsa_switch *ds = port->ds;
74 struct phy_device *phydev;
75 int ret, mode;
76
77 if (of_phy_is_fixed_link(port_dn)) {
78 ret = of_phy_register_fixed_link(port_dn);
79 if (ret) {
80 dev_err(ds->dev, "failed to register fixed PHY\n");
81 return ret;
82 }
83 phydev = of_phy_find_device(port_dn);
84
85 mode = of_get_phy_mode(port_dn);
86 if (mode < 0)
87 mode = PHY_INTERFACE_MODE_NA;
88 phydev->interface = mode;
89
90 genphy_config_init(phydev);
91 genphy_read_status(phydev);
92 if (ds->ops->adjust_link)
93 ds->ops->adjust_link(ds, port->index, phydev);
94
95 put_device(&phydev->mdio.dev);
96 }
97
98 return 0;
99}
100
101const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol)
102{
103 const struct dsa_device_ops *ops;
104
105 if (tag_protocol >= DSA_TAG_LAST)
106 return ERR_PTR(-EINVAL);
107 ops = dsa_device_ops[tag_protocol];
108
109 if (!ops)
110 return ERR_PTR(-ENOPROTOOPT);
111
112 return ops;
113}
114
115int dsa_cpu_port_ethtool_setup(struct dsa_port *cpu_dp)
116{
117 struct dsa_switch *ds = cpu_dp->ds;
118 struct net_device *master;
119 struct ethtool_ops *cpu_ops;
120
121 master = cpu_dp->netdev;
122
123 cpu_ops = devm_kzalloc(ds->dev, sizeof(*cpu_ops), GFP_KERNEL);
124 if (!cpu_ops)
125 return -ENOMEM;
126
127 memcpy(&cpu_dp->ethtool_ops, master->ethtool_ops,
128 sizeof(struct ethtool_ops));
129 cpu_dp->orig_ethtool_ops = master->ethtool_ops;
130 memcpy(cpu_ops, &cpu_dp->ethtool_ops,
131 sizeof(struct ethtool_ops));
132 dsa_cpu_port_ethtool_init(cpu_ops);
133 master->ethtool_ops = cpu_ops;
134
135 return 0;
136}
137
138void dsa_cpu_port_ethtool_restore(struct dsa_port *cpu_dp)
139{
140 cpu_dp->netdev->ethtool_ops = cpu_dp->orig_ethtool_ops;
141}
142
143void dsa_cpu_dsa_destroy(struct dsa_port *port)
144{
145 struct device_node *port_dn = port->dn;
146
147 if (of_phy_is_fixed_link(port_dn))
148 of_phy_deregister_fixed_link(port_dn);
149}
150
151static int dev_is_class(struct device *dev, void *class)
152{
153 if (dev->class != NULL && !strcmp(dev->class->name, class))
154 return 1;
155
156 return 0;
157}
158
159static struct device *dev_find_class(struct device *parent, char *class)
160{
161 if (dev_is_class(parent, class)) {
162 get_device(parent);
163 return parent;
164 }
165
166 return device_find_child(parent, class, dev_is_class);
167}
168
169struct net_device *dsa_dev_to_net_device(struct device *dev)
170{
171 struct device *d;
172
173 d = dev_find_class(dev, "net");
174 if (d != NULL) {
175 struct net_device *nd;
176
177 nd = to_net_dev(d);
178 dev_hold(nd);
179 put_device(d);
180
181 return nd;
182 }
183
184 return NULL;
185}
186EXPORT_SYMBOL_GPL(dsa_dev_to_net_device);
187
188static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev,
189 struct packet_type *pt, struct net_device *unused)
190{
191 struct dsa_switch_tree *dst = dev->dsa_ptr;
192 struct sk_buff *nskb = NULL;
193 struct pcpu_sw_netstats *s;
194 struct dsa_slave_priv *p;
195
196 if (unlikely(dst == NULL)) {
197 kfree_skb(skb);
198 return 0;
199 }
200
201 skb = skb_unshare(skb, GFP_ATOMIC);
202 if (!skb)
203 return 0;
204
205 nskb = dst->rcv(skb, dev, pt);
206 if (!nskb) {
207 kfree_skb(skb);
208 return 0;
209 }
210
211 skb = nskb;
212 p = netdev_priv(skb->dev);
213 skb_push(skb, ETH_HLEN);
214 skb->pkt_type = PACKET_HOST;
215 skb->protocol = eth_type_trans(skb, skb->dev);
216
217 s = this_cpu_ptr(p->stats64);
218 u64_stats_update_begin(&s->syncp);
219 s->rx_packets++;
220 s->rx_bytes += skb->len;
221 u64_stats_update_end(&s->syncp);
222
223 netif_receive_skb(skb);
224
225 return 0;
226}
227
228#ifdef CONFIG_PM_SLEEP
229static bool dsa_is_port_initialized(struct dsa_switch *ds, int p)
230{
231 return ds->enabled_port_mask & (1 << p) && ds->ports[p].netdev;
232}
233
234int dsa_switch_suspend(struct dsa_switch *ds)
235{
236 int i, ret = 0;
237
238
239 for (i = 0; i < ds->num_ports; i++) {
240 if (!dsa_is_port_initialized(ds, i))
241 continue;
242
243 ret = dsa_slave_suspend(ds->ports[i].netdev);
244 if (ret)
245 return ret;
246 }
247
248 if (ds->ops->suspend)
249 ret = ds->ops->suspend(ds);
250
251 return ret;
252}
253EXPORT_SYMBOL_GPL(dsa_switch_suspend);
254
255int dsa_switch_resume(struct dsa_switch *ds)
256{
257 int i, ret = 0;
258
259 if (ds->ops->resume)
260 ret = ds->ops->resume(ds);
261
262 if (ret)
263 return ret;
264
265
266 for (i = 0; i < ds->num_ports; i++) {
267 if (!dsa_is_port_initialized(ds, i))
268 continue;
269
270 ret = dsa_slave_resume(ds->ports[i].netdev);
271 if (ret)
272 return ret;
273 }
274
275 return 0;
276}
277EXPORT_SYMBOL_GPL(dsa_switch_resume);
278#endif
279
280static struct packet_type dsa_pack_type __read_mostly = {
281 .type = cpu_to_be16(ETH_P_XDSA),
282 .func = dsa_switch_rcv,
283};
284
285static struct workqueue_struct *dsa_owq;
286
287bool dsa_schedule_work(struct work_struct *work)
288{
289 return queue_work(dsa_owq, work);
290}
291
292static int __init dsa_init_module(void)
293{
294 int rc;
295
296 dsa_owq = alloc_ordered_workqueue("dsa_ordered",
297 WQ_MEM_RECLAIM);
298 if (!dsa_owq)
299 return -ENOMEM;
300
301 rc = dsa_slave_register_notifier();
302 if (rc)
303 return rc;
304
305 rc = dsa_legacy_register();
306 if (rc)
307 return rc;
308
309 dev_add_pack(&dsa_pack_type);
310
311 return 0;
312}
313module_init(dsa_init_module);
314
315static void __exit dsa_cleanup_module(void)
316{
317 dsa_slave_unregister_notifier();
318 dev_remove_pack(&dsa_pack_type);
319 dsa_legacy_unregister();
320 destroy_workqueue(dsa_owq);
321}
322module_exit(dsa_cleanup_module);
323
324MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
325MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
326MODULE_LICENSE("GPL");
327MODULE_ALIAS("platform:dsa");
328
