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

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

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ 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/slave.c - Slave device handling
  3  * Copyright (c) 2008-2009 Marvell Semiconductor
  4  *
  5  * This program is free software; you can redistribute it and/or modify
  6  * it under the terms of the GNU General Public License as published by
  7  * the Free Software Foundation; either version 2 of the License, or
  8  * (at your option) any later version.
  9  */
 10 
 11 #include <linux/list.h>
 12 #include <linux/etherdevice.h>
 13 #include <linux/netdevice.h>
 14 #include <linux/phy.h>
 15 #include <linux/phy_fixed.h>
 16 #include <linux/of_net.h>
 17 #include <linux/of_mdio.h>
 18 #include <linux/mdio.h>
 19 #include <linux/list.h>
 20 #include <net/rtnetlink.h>
 21 #include <net/pkt_cls.h>
 22 #include <net/tc_act/tc_mirred.h>
 23 #include <linux/if_bridge.h>
 24 #include <linux/netpoll.h>
 25 
 26 #include "dsa_priv.h"
 27 
 28 static bool dsa_slave_dev_check(struct net_device *dev);
 29 
 30 /* slave mii_bus handling ***************************************************/
 31 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
 32 {
 33         struct dsa_switch *ds = bus->priv;
 34 
 35         if (ds->phys_mii_mask & (1 << addr))
 36                 return ds->ops->phy_read(ds, addr, reg);
 37 
 38         return 0xffff;
 39 }
 40 
 41 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
 42 {
 43         struct dsa_switch *ds = bus->priv;
 44 
 45         if (ds->phys_mii_mask & (1 << addr))
 46                 return ds->ops->phy_write(ds, addr, reg, val);
 47 
 48         return 0;
 49 }
 50 
 51 void dsa_slave_mii_bus_init(struct dsa_switch *ds)
 52 {
 53         ds->slave_mii_bus->priv = (void *)ds;
 54         ds->slave_mii_bus->name = "dsa slave smi";
 55         ds->slave_mii_bus->read = dsa_slave_phy_read;
 56         ds->slave_mii_bus->write = dsa_slave_phy_write;
 57         snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
 58                  ds->dst->tree, ds->index);
 59         ds->slave_mii_bus->parent = ds->dev;
 60         ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
 61 }
 62 
 63 
 64 /* slave device handling ****************************************************/
 65 static int dsa_slave_get_iflink(const struct net_device *dev)
 66 {
 67         struct dsa_slave_priv *p = netdev_priv(dev);
 68 
 69         return dsa_master_netdev(p)->ifindex;
 70 }
 71 
 72 static int dsa_slave_open(struct net_device *dev)
 73 {
 74         struct dsa_slave_priv *p = netdev_priv(dev);
 75         struct dsa_port *dp = p->dp;
 76         struct dsa_switch *ds = dp->ds;
 77         struct net_device *master = dsa_master_netdev(p);
 78         u8 stp_state = dp->bridge_dev ? BR_STATE_BLOCKING : BR_STATE_FORWARDING;
 79         int err;
 80 
 81         if (!(master->flags & IFF_UP))
 82                 return -ENETDOWN;
 83 
 84         if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
 85                 err = dev_uc_add(master, dev->dev_addr);
 86                 if (err < 0)
 87                         goto out;
 88         }
 89 
 90         if (dev->flags & IFF_ALLMULTI) {
 91                 err = dev_set_allmulti(master, 1);
 92                 if (err < 0)
 93                         goto del_unicast;
 94         }
 95         if (dev->flags & IFF_PROMISC) {
 96                 err = dev_set_promiscuity(master, 1);
 97                 if (err < 0)
 98                         goto clear_allmulti;
 99         }
100 
101         if (ds->ops->port_enable) {
102                 err = ds->ops->port_enable(ds, p->dp->index, p->phy);
103                 if (err)
104                         goto clear_promisc;
105         }
106 
107         dsa_port_set_state_now(p->dp, stp_state);
108 
109         if (p->phy)
110                 phy_start(p->phy);
111 
112         return 0;
113 
114 clear_promisc:
115         if (dev->flags & IFF_PROMISC)
116                 dev_set_promiscuity(master, -1);
117 clear_allmulti:
118         if (dev->flags & IFF_ALLMULTI)
119                 dev_set_allmulti(master, -1);
120 del_unicast:
121         if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
122                 dev_uc_del(master, dev->dev_addr);
123 out:
124         return err;
125 }
126 
127 static int dsa_slave_close(struct net_device *dev)
128 {
129         struct dsa_slave_priv *p = netdev_priv(dev);
130         struct net_device *master = dsa_master_netdev(p);
131         struct dsa_switch *ds = p->dp->ds;
132 
133         if (p->phy)
134                 phy_stop(p->phy);
135 
136         dev_mc_unsync(master, dev);
137         dev_uc_unsync(master, dev);
138         if (dev->flags & IFF_ALLMULTI)
139                 dev_set_allmulti(master, -1);
140         if (dev->flags & IFF_PROMISC)
141                 dev_set_promiscuity(master, -1);
142 
143         if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
144                 dev_uc_del(master, dev->dev_addr);
145 
146         if (ds->ops->port_disable)
147                 ds->ops->port_disable(ds, p->dp->index, p->phy);
148 
149         dsa_port_set_state_now(p->dp, BR_STATE_DISABLED);
150 
151         return 0;
152 }
153 
154 static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
155 {
156         struct dsa_slave_priv *p = netdev_priv(dev);
157         struct net_device *master = dsa_master_netdev(p);
158 
159         if (change & IFF_ALLMULTI)
160                 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
161         if (change & IFF_PROMISC)
162                 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
163 }
164 
165 static void dsa_slave_set_rx_mode(struct net_device *dev)
166 {
167         struct dsa_slave_priv *p = netdev_priv(dev);
168         struct net_device *master = dsa_master_netdev(p);
169 
170         dev_mc_sync(master, dev);
171         dev_uc_sync(master, dev);
172 }
173 
174 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
175 {
176         struct dsa_slave_priv *p = netdev_priv(dev);
177         struct net_device *master = dsa_master_netdev(p);
178         struct sockaddr *addr = a;
179         int err;
180 
181         if (!is_valid_ether_addr(addr->sa_data))
182                 return -EADDRNOTAVAIL;
183 
184         if (!(dev->flags & IFF_UP))
185                 goto out;
186 
187         if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
188                 err = dev_uc_add(master, addr->sa_data);
189                 if (err < 0)
190                         return err;
191         }
192 
193         if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
194                 dev_uc_del(master, dev->dev_addr);
195 
196 out:
197         ether_addr_copy(dev->dev_addr, addr->sa_data);
198 
199         return 0;
200 }
201 
202 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
203 {
204         struct dsa_slave_priv *p = netdev_priv(dev);
205 
206         if (p->phy != NULL)
207                 return phy_mii_ioctl(p->phy, ifr, cmd);
208 
209         return -EOPNOTSUPP;
210 }
211 
212 static int dsa_slave_port_attr_set(struct net_device *dev,
213                                    const struct switchdev_attr *attr,
214                                    struct switchdev_trans *trans)
215 {
216         struct dsa_slave_priv *p = netdev_priv(dev);
217         struct dsa_port *dp = p->dp;
218         int ret;
219 
220         switch (attr->id) {
221         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
222                 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
223                 break;
224         case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
225                 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
226                                               trans);
227                 break;
228         case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
229                 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans);
230                 break;
231         default:
232                 ret = -EOPNOTSUPP;
233                 break;
234         }
235 
236         return ret;
237 }
238 
239 static int dsa_slave_port_obj_add(struct net_device *dev,
240                                   const struct switchdev_obj *obj,
241                                   struct switchdev_trans *trans)
242 {
243         struct dsa_slave_priv *p = netdev_priv(dev);
244         struct dsa_port *dp = p->dp;
245         int err;
246 
247         /* For the prepare phase, ensure the full set of changes is feasable in
248          * one go in order to signal a failure properly. If an operation is not
249          * supported, return -EOPNOTSUPP.
250          */
251 
252         switch (obj->id) {
253         case SWITCHDEV_OBJ_ID_PORT_FDB:
254                 err = dsa_port_fdb_add(dp, SWITCHDEV_OBJ_PORT_FDB(obj), trans);
255                 break;
256         case SWITCHDEV_OBJ_ID_PORT_MDB:
257                 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans);
258                 break;
259         case SWITCHDEV_OBJ_ID_PORT_VLAN:
260                 err = dsa_port_vlan_add(dp, SWITCHDEV_OBJ_PORT_VLAN(obj),
261                                         trans);
262                 break;
263         default:
264                 err = -EOPNOTSUPP;
265                 break;
266         }
267 
268         return err;
269 }
270 
271 static int dsa_slave_port_obj_del(struct net_device *dev,
272                                   const struct switchdev_obj *obj)
273 {
274         struct dsa_slave_priv *p = netdev_priv(dev);
275         struct dsa_port *dp = p->dp;
276         int err;
277 
278         switch (obj->id) {
279         case SWITCHDEV_OBJ_ID_PORT_FDB:
280                 err = dsa_port_fdb_del(dp, SWITCHDEV_OBJ_PORT_FDB(obj));
281                 break;
282         case SWITCHDEV_OBJ_ID_PORT_MDB:
283                 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
284                 break;
285         case SWITCHDEV_OBJ_ID_PORT_VLAN:
286                 err = dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));
287                 break;
288         default:
289                 err = -EOPNOTSUPP;
290                 break;
291         }
292 
293         return err;
294 }
295 
296 static int dsa_slave_port_obj_dump(struct net_device *dev,
297                                    struct switchdev_obj *obj,
298                                    switchdev_obj_dump_cb_t *cb)
299 {
300         struct dsa_slave_priv *p = netdev_priv(dev);
301         struct dsa_port *dp = p->dp;
302         int err;
303 
304         switch (obj->id) {
305         case SWITCHDEV_OBJ_ID_PORT_FDB:
306                 err = dsa_port_fdb_dump(dp, SWITCHDEV_OBJ_PORT_FDB(obj), cb);
307                 break;
308         case SWITCHDEV_OBJ_ID_PORT_MDB:
309                 err = dsa_port_mdb_dump(dp, SWITCHDEV_OBJ_PORT_MDB(obj), cb);
310                 break;
311         case SWITCHDEV_OBJ_ID_PORT_VLAN:
312                 err = dsa_port_vlan_dump(dp, SWITCHDEV_OBJ_PORT_VLAN(obj), cb);
313                 break;
314         default:
315                 err = -EOPNOTSUPP;
316                 break;
317         }
318 
319         return err;
320 }
321 
322 static int dsa_slave_port_attr_get(struct net_device *dev,
323                                    struct switchdev_attr *attr)
324 {
325         struct dsa_slave_priv *p = netdev_priv(dev);
326         struct dsa_switch *ds = p->dp->ds;
327 
328         switch (attr->id) {
329         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
330                 attr->u.ppid.id_len = sizeof(ds->index);
331                 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
332                 break;
333         default:
334                 return -EOPNOTSUPP;
335         }
336 
337         return 0;
338 }
339 
340 static inline netdev_tx_t dsa_netpoll_send_skb(struct dsa_slave_priv *p,
341                                                struct sk_buff *skb)
342 {
343 #ifdef CONFIG_NET_POLL_CONTROLLER
344         if (p->netpoll)
345                 netpoll_send_skb(p->netpoll, skb);
346 #else
347         BUG();
348 #endif
349         return NETDEV_TX_OK;
350 }
351 
352 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
353 {
354         struct dsa_slave_priv *p = netdev_priv(dev);
355         struct sk_buff *nskb;
356 
357         dev->stats.tx_packets++;
358         dev->stats.tx_bytes += skb->len;
359 
360         /* Transmit function may have to reallocate the original SKB,
361          * in which case it must have freed it. Only free it here on error.
362          */
363         nskb = p->xmit(skb, dev);
364         if (!nskb) {
365                 kfree_skb(skb);
366                 return NETDEV_TX_OK;
367         }
368 
369         /* SKB for netpoll still need to be mangled with the protocol-specific
370          * tag to be successfully transmitted
371          */
372         if (unlikely(netpoll_tx_running(dev)))
373                 return dsa_netpoll_send_skb(p, nskb);
374 
375         /* Queue the SKB for transmission on the parent interface, but
376          * do not modify its EtherType
377          */
378         nskb->dev = dsa_master_netdev(p);
379         dev_queue_xmit(nskb);
380 
381         return NETDEV_TX_OK;
382 }
383 
384 /* ethtool operations *******************************************************/
385 static int
386 dsa_slave_get_link_ksettings(struct net_device *dev,
387                              struct ethtool_link_ksettings *cmd)
388 {
389         struct dsa_slave_priv *p = netdev_priv(dev);
390 
391         if (!p->phy)
392                 return -EOPNOTSUPP;
393 
394         phy_ethtool_ksettings_get(p->phy, cmd);
395 
396         return 0;
397 }
398 
399 static int
400 dsa_slave_set_link_ksettings(struct net_device *dev,
401                              const struct ethtool_link_ksettings *cmd)
402 {
403         struct dsa_slave_priv *p = netdev_priv(dev);
404 
405         if (p->phy != NULL)
406                 return phy_ethtool_ksettings_set(p->phy, cmd);
407 
408         return -EOPNOTSUPP;
409 }
410 
411 static void dsa_slave_get_drvinfo(struct net_device *dev,
412                                   struct ethtool_drvinfo *drvinfo)
413 {
414         strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
415         strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
416         strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
417 }
418 
419 static int dsa_slave_get_regs_len(struct net_device *dev)
420 {
421         struct dsa_slave_priv *p = netdev_priv(dev);
422         struct dsa_switch *ds = p->dp->ds;
423 
424         if (ds->ops->get_regs_len)
425                 return ds->ops->get_regs_len(ds, p->dp->index);
426 
427         return -EOPNOTSUPP;
428 }
429 
430 static void
431 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
432 {
433         struct dsa_slave_priv *p = netdev_priv(dev);
434         struct dsa_switch *ds = p->dp->ds;
435 
436         if (ds->ops->get_regs)
437                 ds->ops->get_regs(ds, p->dp->index, regs, _p);
438 }
439 
440 static int dsa_slave_nway_reset(struct net_device *dev)
441 {
442         struct dsa_slave_priv *p = netdev_priv(dev);
443 
444         if (p->phy != NULL)
445                 return genphy_restart_aneg(p->phy);
446 
447         return -EOPNOTSUPP;
448 }
449 
450 static u32 dsa_slave_get_link(struct net_device *dev)
451 {
452         struct dsa_slave_priv *p = netdev_priv(dev);
453 
454         if (p->phy != NULL) {
455                 genphy_update_link(p->phy);
456                 return p->phy->link;
457         }
458 
459         return -EOPNOTSUPP;
460 }
461 
462 static int dsa_slave_get_eeprom_len(struct net_device *dev)
463 {
464         struct dsa_slave_priv *p = netdev_priv(dev);
465         struct dsa_switch *ds = p->dp->ds;
466 
467         if (ds->cd && ds->cd->eeprom_len)
468                 return ds->cd->eeprom_len;
469 
470         if (ds->ops->get_eeprom_len)
471                 return ds->ops->get_eeprom_len(ds);
472 
473         return 0;
474 }
475 
476 static int dsa_slave_get_eeprom(struct net_device *dev,
477                                 struct ethtool_eeprom *eeprom, u8 *data)
478 {
479         struct dsa_slave_priv *p = netdev_priv(dev);
480         struct dsa_switch *ds = p->dp->ds;
481 
482         if (ds->ops->get_eeprom)
483                 return ds->ops->get_eeprom(ds, eeprom, data);
484 
485         return -EOPNOTSUPP;
486 }
487 
488 static int dsa_slave_set_eeprom(struct net_device *dev,
489                                 struct ethtool_eeprom *eeprom, u8 *data)
490 {
491         struct dsa_slave_priv *p = netdev_priv(dev);
492         struct dsa_switch *ds = p->dp->ds;
493 
494         if (ds->ops->set_eeprom)
495                 return ds->ops->set_eeprom(ds, eeprom, data);
496 
497         return -EOPNOTSUPP;
498 }
499 
500 static void dsa_slave_get_strings(struct net_device *dev,
501                                   uint32_t stringset, uint8_t *data)
502 {
503         struct dsa_slave_priv *p = netdev_priv(dev);
504         struct dsa_switch *ds = p->dp->ds;
505 
506         if (stringset == ETH_SS_STATS) {
507                 int len = ETH_GSTRING_LEN;
508 
509                 strncpy(data, "tx_packets", len);
510                 strncpy(data + len, "tx_bytes", len);
511                 strncpy(data + 2 * len, "rx_packets", len);
512                 strncpy(data + 3 * len, "rx_bytes", len);
513                 if (ds->ops->get_strings)
514                         ds->ops->get_strings(ds, p->dp->index, data + 4 * len);
515         }
516 }
517 
518 static void dsa_cpu_port_get_ethtool_stats(struct net_device *dev,
519                                            struct ethtool_stats *stats,
520                                            uint64_t *data)
521 {
522         struct dsa_switch_tree *dst = dev->dsa_ptr;
523         struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
524         struct dsa_switch *ds = cpu_dp->ds;
525         s8 cpu_port = cpu_dp->index;
526         int count = 0;
527 
528         if (cpu_dp->ethtool_ops.get_sset_count) {
529                 count = cpu_dp->ethtool_ops.get_sset_count(dev, ETH_SS_STATS);
530                 cpu_dp->ethtool_ops.get_ethtool_stats(dev, stats, data);
531         }
532 
533         if (ds->ops->get_ethtool_stats)
534                 ds->ops->get_ethtool_stats(ds, cpu_port, data + count);
535 }
536 
537 static int dsa_cpu_port_get_sset_count(struct net_device *dev, int sset)
538 {
539         struct dsa_switch_tree *dst = dev->dsa_ptr;
540         struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
541         struct dsa_switch *ds = cpu_dp->ds;
542         int count = 0;
543 
544         if (cpu_dp->ethtool_ops.get_sset_count)
545                 count += cpu_dp->ethtool_ops.get_sset_count(dev, sset);
546 
547         if (sset == ETH_SS_STATS && ds->ops->get_sset_count)
548                 count += ds->ops->get_sset_count(ds);
549 
550         return count;
551 }
552 
553 static void dsa_cpu_port_get_strings(struct net_device *dev,
554                                      uint32_t stringset, uint8_t *data)
555 {
556         struct dsa_switch_tree *dst = dev->dsa_ptr;
557         struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
558         struct dsa_switch *ds = cpu_dp->ds;
559         s8 cpu_port = cpu_dp->index;
560         int len = ETH_GSTRING_LEN;
561         int mcount = 0, count;
562         unsigned int i;
563         uint8_t pfx[4];
564         uint8_t *ndata;
565 
566         snprintf(pfx, sizeof(pfx), "p%.2d", cpu_port);
567         /* We do not want to be NULL-terminated, since this is a prefix */
568         pfx[sizeof(pfx) - 1] = '_';
569 
570         if (cpu_dp->ethtool_ops.get_sset_count) {
571                 mcount = cpu_dp->ethtool_ops.get_sset_count(dev, ETH_SS_STATS);
572                 cpu_dp->ethtool_ops.get_strings(dev, stringset, data);
573         }
574 
575         if (stringset == ETH_SS_STATS && ds->ops->get_strings) {
576                 ndata = data + mcount * len;
577                 /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
578                  * the output after to prepend our CPU port prefix we
579                  * constructed earlier
580                  */
581                 ds->ops->get_strings(ds, cpu_port, ndata);
582                 count = ds->ops->get_sset_count(ds);
583                 for (i = 0; i < count; i++) {
584                         memmove(ndata + (i * len + sizeof(pfx)),
585                                 ndata + i * len, len - sizeof(pfx));
586                         memcpy(ndata + i * len, pfx, sizeof(pfx));
587                 }
588         }
589 }
590 
591 static void dsa_slave_get_ethtool_stats(struct net_device *dev,
592                                         struct ethtool_stats *stats,
593                                         uint64_t *data)
594 {
595         struct dsa_slave_priv *p = netdev_priv(dev);
596         struct dsa_switch *ds = p->dp->ds;
597 
598         data[0] = dev->stats.tx_packets;
599         data[1] = dev->stats.tx_bytes;
600         data[2] = dev->stats.rx_packets;
601         data[3] = dev->stats.rx_bytes;
602         if (ds->ops->get_ethtool_stats)
603                 ds->ops->get_ethtool_stats(ds, p->dp->index, data + 4);
604 }
605 
606 static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
607 {
608         struct dsa_slave_priv *p = netdev_priv(dev);
609         struct dsa_switch *ds = p->dp->ds;
610 
611         if (sset == ETH_SS_STATS) {
612                 int count;
613 
614                 count = 4;
615                 if (ds->ops->get_sset_count)
616                         count += ds->ops->get_sset_count(ds);
617 
618                 return count;
619         }
620 
621         return -EOPNOTSUPP;
622 }
623 
624 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
625 {
626         struct dsa_slave_priv *p = netdev_priv(dev);
627         struct dsa_switch *ds = p->dp->ds;
628 
629         if (ds->ops->get_wol)
630                 ds->ops->get_wol(ds, p->dp->index, w);
631 }
632 
633 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
634 {
635         struct dsa_slave_priv *p = netdev_priv(dev);
636         struct dsa_switch *ds = p->dp->ds;
637         int ret = -EOPNOTSUPP;
638 
639         if (ds->ops->set_wol)
640                 ret = ds->ops->set_wol(ds, p->dp->index, w);
641 
642         return ret;
643 }
644 
645 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
646 {
647         struct dsa_slave_priv *p = netdev_priv(dev);
648         struct dsa_switch *ds = p->dp->ds;
649         int ret;
650 
651         if (!ds->ops->set_eee)
652                 return -EOPNOTSUPP;
653 
654         ret = ds->ops->set_eee(ds, p->dp->index, p->phy, e);
655         if (ret)
656                 return ret;
657 
658         if (p->phy)
659                 ret = phy_ethtool_set_eee(p->phy, e);
660 
661         return ret;
662 }
663 
664 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
665 {
666         struct dsa_slave_priv *p = netdev_priv(dev);
667         struct dsa_switch *ds = p->dp->ds;
668         int ret;
669 
670         if (!ds->ops->get_eee)
671                 return -EOPNOTSUPP;
672 
673         ret = ds->ops->get_eee(ds, p->dp->index, e);
674         if (ret)
675                 return ret;
676 
677         if (p->phy)
678                 ret = phy_ethtool_get_eee(p->phy, e);
679 
680         return ret;
681 }
682 
683 #ifdef CONFIG_NET_POLL_CONTROLLER
684 static int dsa_slave_netpoll_setup(struct net_device *dev,
685                                    struct netpoll_info *ni)
686 {
687         struct dsa_slave_priv *p = netdev_priv(dev);
688         struct net_device *master = dsa_master_netdev(p);
689         struct netpoll *netpoll;
690         int err = 0;
691 
692         netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
693         if (!netpoll)
694                 return -ENOMEM;
695 
696         err = __netpoll_setup(netpoll, master);
697         if (err) {
698                 kfree(netpoll);
699                 goto out;
700         }
701 
702         p->netpoll = netpoll;
703 out:
704         return err;
705 }
706 
707 static void dsa_slave_netpoll_cleanup(struct net_device *dev)
708 {
709         struct dsa_slave_priv *p = netdev_priv(dev);
710         struct netpoll *netpoll = p->netpoll;
711 
712         if (!netpoll)
713                 return;
714 
715         p->netpoll = NULL;
716 
717         __netpoll_free_async(netpoll);
718 }
719 
720 static void dsa_slave_poll_controller(struct net_device *dev)
721 {
722 }
723 #endif
724 
725 static int dsa_slave_get_phys_port_name(struct net_device *dev,
726                                         char *name, size_t len)
727 {
728         struct dsa_slave_priv *p = netdev_priv(dev);
729 
730         if (snprintf(name, len, "p%d", p->dp->index) >= len)
731                 return -EINVAL;
732 
733         return 0;
734 }
735 
736 static struct dsa_mall_tc_entry *
737 dsa_slave_mall_tc_entry_find(struct dsa_slave_priv *p,
738                              unsigned long cookie)
739 {
740         struct dsa_mall_tc_entry *mall_tc_entry;
741 
742         list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
743                 if (mall_tc_entry->cookie == cookie)
744                         return mall_tc_entry;
745 
746         return NULL;
747 }
748 
749 static int dsa_slave_add_cls_matchall(struct net_device *dev,
750                                       __be16 protocol,
751                                       struct tc_cls_matchall_offload *cls,
752                                       bool ingress)
753 {
754         struct dsa_slave_priv *p = netdev_priv(dev);
755         struct dsa_mall_tc_entry *mall_tc_entry;
756         struct dsa_switch *ds = p->dp->ds;
757         struct net *net = dev_net(dev);
758         struct dsa_slave_priv *to_p;
759         struct net_device *to_dev;
760         const struct tc_action *a;
761         int err = -EOPNOTSUPP;
762         LIST_HEAD(actions);
763         int ifindex;
764 
765         if (!ds->ops->port_mirror_add)
766                 return err;
767 
768         if (!tc_single_action(cls->exts))
769                 return err;
770 
771         tcf_exts_to_list(cls->exts, &actions);
772         a = list_first_entry(&actions, struct tc_action, list);
773 
774         if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) {
775                 struct dsa_mall_mirror_tc_entry *mirror;
776 
777                 ifindex = tcf_mirred_ifindex(a);
778                 to_dev = __dev_get_by_index(net, ifindex);
779                 if (!to_dev)
780                         return -EINVAL;
781 
782                 if (!dsa_slave_dev_check(to_dev))
783                         return -EOPNOTSUPP;
784 
785                 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
786                 if (!mall_tc_entry)
787                         return -ENOMEM;
788 
789                 mall_tc_entry->cookie = cls->cookie;
790                 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
791                 mirror = &mall_tc_entry->mirror;
792 
793                 to_p = netdev_priv(to_dev);
794 
795                 mirror->to_local_port = to_p->dp->index;
796                 mirror->ingress = ingress;
797 
798                 err = ds->ops->port_mirror_add(ds, p->dp->index, mirror,
799                                                ingress);
800                 if (err) {
801                         kfree(mall_tc_entry);
802                         return err;
803                 }
804 
805                 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
806         }
807 
808         return 0;
809 }
810 
811 static void dsa_slave_del_cls_matchall(struct net_device *dev,
812                                        struct tc_cls_matchall_offload *cls)
813 {
814         struct dsa_slave_priv *p = netdev_priv(dev);
815         struct dsa_mall_tc_entry *mall_tc_entry;
816         struct dsa_switch *ds = p->dp->ds;
817 
818         if (!ds->ops->port_mirror_del)
819                 return;
820 
821         mall_tc_entry = dsa_slave_mall_tc_entry_find(p, cls->cookie);
822         if (!mall_tc_entry)
823                 return;
824 
825         list_del(&mall_tc_entry->list);
826 
827         switch (mall_tc_entry->type) {
828         case DSA_PORT_MALL_MIRROR:
829                 ds->ops->port_mirror_del(ds, p->dp->index,
830                                          &mall_tc_entry->mirror);
831                 break;
832         default:
833                 WARN_ON(1);
834         }
835 
836         kfree(mall_tc_entry);
837 }
838 
839 static int dsa_slave_setup_tc(struct net_device *dev, u32 handle,
840                               u32 chain_index, __be16 protocol,
841                               struct tc_to_netdev *tc)
842 {
843         bool ingress = TC_H_MAJ(handle) == TC_H_MAJ(TC_H_INGRESS);
844 
845         if (chain_index)
846                 return -EOPNOTSUPP;
847 
848         switch (tc->type) {
849         case TC_SETUP_MATCHALL:
850                 switch (tc->cls_mall->command) {
851                 case TC_CLSMATCHALL_REPLACE:
852                         return dsa_slave_add_cls_matchall(dev, protocol,
853                                                           tc->cls_mall,
854                                                           ingress);
855                 case TC_CLSMATCHALL_DESTROY:
856                         dsa_slave_del_cls_matchall(dev, tc->cls_mall);
857                         return 0;
858                 }
859         default:
860                 return -EOPNOTSUPP;
861         }
862 }
863 
864 void dsa_cpu_port_ethtool_init(struct ethtool_ops *ops)
865 {
866         ops->get_sset_count = dsa_cpu_port_get_sset_count;
867         ops->get_ethtool_stats = dsa_cpu_port_get_ethtool_stats;
868         ops->get_strings = dsa_cpu_port_get_strings;
869 }
870 
871 static int dsa_slave_get_rxnfc(struct net_device *dev,
872                                struct ethtool_rxnfc *nfc, u32 *rule_locs)
873 {
874         struct dsa_slave_priv *p = netdev_priv(dev);
875         struct dsa_switch *ds = p->dp->ds;
876 
877         if (!ds->ops->get_rxnfc)
878                 return -EOPNOTSUPP;
879 
880         return ds->ops->get_rxnfc(ds, p->dp->index, nfc, rule_locs);
881 }
882 
883 static int dsa_slave_set_rxnfc(struct net_device *dev,
884                                struct ethtool_rxnfc *nfc)
885 {
886         struct dsa_slave_priv *p = netdev_priv(dev);
887         struct dsa_switch *ds = p->dp->ds;
888 
889         if (!ds->ops->set_rxnfc)
890                 return -EOPNOTSUPP;
891 
892         return ds->ops->set_rxnfc(ds, p->dp->index, nfc);
893 }
894 
895 static const struct ethtool_ops dsa_slave_ethtool_ops = {
896         .get_drvinfo            = dsa_slave_get_drvinfo,
897         .get_regs_len           = dsa_slave_get_regs_len,
898         .get_regs               = dsa_slave_get_regs,
899         .nway_reset             = dsa_slave_nway_reset,
900         .get_link               = dsa_slave_get_link,
901         .get_eeprom_len         = dsa_slave_get_eeprom_len,
902         .get_eeprom             = dsa_slave_get_eeprom,
903         .set_eeprom             = dsa_slave_set_eeprom,
904         .get_strings            = dsa_slave_get_strings,
905         .get_ethtool_stats      = dsa_slave_get_ethtool_stats,
906         .get_sset_count         = dsa_slave_get_sset_count,
907         .set_wol                = dsa_slave_set_wol,
908         .get_wol                = dsa_slave_get_wol,
909         .set_eee                = dsa_slave_set_eee,
910         .get_eee                = dsa_slave_get_eee,
911         .get_link_ksettings     = dsa_slave_get_link_ksettings,
912         .set_link_ksettings     = dsa_slave_set_link_ksettings,
913         .get_rxnfc              = dsa_slave_get_rxnfc,
914         .set_rxnfc              = dsa_slave_set_rxnfc,
915 };
916 
917 static const struct net_device_ops dsa_slave_netdev_ops = {
918         .ndo_open               = dsa_slave_open,
919         .ndo_stop               = dsa_slave_close,
920         .ndo_start_xmit         = dsa_slave_xmit,
921         .ndo_change_rx_flags    = dsa_slave_change_rx_flags,
922         .ndo_set_rx_mode        = dsa_slave_set_rx_mode,
923         .ndo_set_mac_address    = dsa_slave_set_mac_address,
924         .ndo_fdb_add            = switchdev_port_fdb_add,
925         .ndo_fdb_del            = switchdev_port_fdb_del,
926         .ndo_fdb_dump           = switchdev_port_fdb_dump,
927         .ndo_do_ioctl           = dsa_slave_ioctl,
928         .ndo_get_iflink         = dsa_slave_get_iflink,
929 #ifdef CONFIG_NET_POLL_CONTROLLER
930         .ndo_netpoll_setup      = dsa_slave_netpoll_setup,
931         .ndo_netpoll_cleanup    = dsa_slave_netpoll_cleanup,
932         .ndo_poll_controller    = dsa_slave_poll_controller,
933 #endif
934         .ndo_bridge_getlink     = switchdev_port_bridge_getlink,
935         .ndo_bridge_setlink     = switchdev_port_bridge_setlink,
936         .ndo_bridge_dellink     = switchdev_port_bridge_dellink,
937         .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
938         .ndo_setup_tc           = dsa_slave_setup_tc,
939 };
940 
941 static const struct switchdev_ops dsa_slave_switchdev_ops = {
942         .switchdev_port_attr_get        = dsa_slave_port_attr_get,
943         .switchdev_port_attr_set        = dsa_slave_port_attr_set,
944         .switchdev_port_obj_add         = dsa_slave_port_obj_add,
945         .switchdev_port_obj_del         = dsa_slave_port_obj_del,
946         .switchdev_port_obj_dump        = dsa_slave_port_obj_dump,
947 };
948 
949 static struct device_type dsa_type = {
950         .name   = "dsa",
951 };
952 
953 static void dsa_slave_adjust_link(struct net_device *dev)
954 {
955         struct dsa_slave_priv *p = netdev_priv(dev);
956         struct dsa_switch *ds = p->dp->ds;
957         unsigned int status_changed = 0;
958 
959         if (p->old_link != p->phy->link) {
960                 status_changed = 1;
961                 p->old_link = p->phy->link;
962         }
963 
964         if (p->old_duplex != p->phy->duplex) {
965                 status_changed = 1;
966                 p->old_duplex = p->phy->duplex;
967         }
968 
969         if (p->old_pause != p->phy->pause) {
970                 status_changed = 1;
971                 p->old_pause = p->phy->pause;
972         }
973 
974         if (ds->ops->adjust_link && status_changed)
975                 ds->ops->adjust_link(ds, p->dp->index, p->phy);
976 
977         if (status_changed)
978                 phy_print_status(p->phy);
979 }
980 
981 static int dsa_slave_fixed_link_update(struct net_device *dev,
982                                        struct fixed_phy_status *status)
983 {
984         struct dsa_slave_priv *p;
985         struct dsa_switch *ds;
986 
987         if (dev) {
988                 p = netdev_priv(dev);
989                 ds = p->dp->ds;
990                 if (ds->ops->fixed_link_update)
991                         ds->ops->fixed_link_update(ds, p->dp->index, status);
992         }
993 
994         return 0;
995 }
996 
997 /* slave device setup *******************************************************/
998 static int dsa_slave_phy_connect(struct dsa_slave_priv *p,
999                                  struct net_device *slave_dev,
1000                                  int addr)
1001 {
1002         struct dsa_switch *ds = p->dp->ds;
1003 
1004         p->phy = mdiobus_get_phy(ds->slave_mii_bus, addr);
1005         if (!p->phy) {
1006                 netdev_err(slave_dev, "no phy at %d\n", addr);
1007                 return -ENODEV;
1008         }
1009 
1010         /* Use already configured phy mode */
1011         if (p->phy_interface == PHY_INTERFACE_MODE_NA)
1012                 p->phy_interface = p->phy->interface;
1013         return phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
1014                                   p->phy_interface);
1015 }
1016 
1017 static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
1018                                 struct net_device *slave_dev)
1019 {
1020         struct dsa_switch *ds = p->dp->ds;
1021         struct device_node *phy_dn, *port_dn;
1022         bool phy_is_fixed = false;
1023         u32 phy_flags = 0;
1024         int mode, ret;
1025 
1026         port_dn = p->dp->dn;
1027         mode = of_get_phy_mode(port_dn);
1028         if (mode < 0)
1029                 mode = PHY_INTERFACE_MODE_NA;
1030         p->phy_interface = mode;
1031 
1032         phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
1033         if (!phy_dn && of_phy_is_fixed_link(port_dn)) {
1034                 /* In the case of a fixed PHY, the DT node associated
1035                  * to the fixed PHY is the Port DT node
1036                  */
1037                 ret = of_phy_register_fixed_link(port_dn);
1038                 if (ret) {
1039                         netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
1040                         return ret;
1041                 }
1042                 phy_is_fixed = true;
1043                 phy_dn = of_node_get(port_dn);
1044         }
1045 
1046         if (ds->ops->get_phy_flags)
1047                 phy_flags = ds->ops->get_phy_flags(ds, p->dp->index);
1048 
1049         if (phy_dn) {
1050                 int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn);
1051 
1052                 /* If this PHY address is part of phys_mii_mask, which means
1053                  * that we need to divert reads and writes to/from it, then we
1054                  * want to bind this device using the slave MII bus created by
1055                  * DSA to make that happen.
1056                  */
1057                 if (!phy_is_fixed && phy_id >= 0 &&
1058                     (ds->phys_mii_mask & (1 << phy_id))) {
1059                         ret = dsa_slave_phy_connect(p, slave_dev, phy_id);
1060                         if (ret) {
1061                                 netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret);
1062                                 of_node_put(phy_dn);
1063                                 return ret;
1064                         }
1065                 } else {
1066                         p->phy = of_phy_connect(slave_dev, phy_dn,
1067                                                 dsa_slave_adjust_link,
1068                                                 phy_flags,
1069                                                 p->phy_interface);
1070                 }
1071 
1072                 of_node_put(phy_dn);
1073         }
1074 
1075         if (p->phy && phy_is_fixed)
1076                 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);
1077 
1078         /* We could not connect to a designated PHY, so use the switch internal
1079          * MDIO bus instead
1080          */
1081         if (!p->phy) {
1082                 ret = dsa_slave_phy_connect(p, slave_dev, p->dp->index);
1083                 if (ret) {
1084                         netdev_err(slave_dev, "failed to connect to port %d: %d\n",
1085                                    p->dp->index, ret);
1086                         if (phy_is_fixed)
1087                                 of_phy_deregister_fixed_link(port_dn);
1088                         return ret;
1089                 }
1090         }
1091 
1092         phy_attached_info(p->phy);
1093 
1094         return 0;
1095 }
1096 
1097 static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
1098 static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
1099                                             struct netdev_queue *txq,
1100                                             void *_unused)
1101 {
1102         lockdep_set_class(&txq->_xmit_lock,
1103                           &dsa_slave_netdev_xmit_lock_key);
1104 }
1105 
1106 int dsa_slave_suspend(struct net_device *slave_dev)
1107 {
1108         struct dsa_slave_priv *p = netdev_priv(slave_dev);
1109 
1110         netif_device_detach(slave_dev);
1111 
1112         if (p->phy) {
1113                 phy_stop(p->phy);
1114                 p->old_pause = -1;
1115                 p->old_link = -1;
1116                 p->old_duplex = -1;
1117                 phy_suspend(p->phy);
1118         }
1119 
1120         return 0;
1121 }
1122 
1123 int dsa_slave_resume(struct net_device *slave_dev)
1124 {
1125         struct dsa_slave_priv *p = netdev_priv(slave_dev);
1126 
1127         netif_device_attach(slave_dev);
1128 
1129         if (p->phy) {
1130                 phy_resume(p->phy);
1131                 phy_start(p->phy);
1132         }
1133 
1134         return 0;
1135 }
1136 
1137 int dsa_slave_create(struct dsa_switch *ds, struct device *parent,
1138                      int port, const char *name)
1139 {
1140         struct dsa_switch_tree *dst = ds->dst;
1141         struct net_device *master;
1142         struct net_device *slave_dev;
1143         struct dsa_slave_priv *p;
1144         struct dsa_port *cpu_dp;
1145         int ret;
1146 
1147         cpu_dp = ds->dst->cpu_dp;
1148         master = cpu_dp->netdev;
1149 
1150         slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name,
1151                                  NET_NAME_UNKNOWN, ether_setup);
1152         if (slave_dev == NULL)
1153                 return -ENOMEM;
1154 
1155         slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
1156         slave_dev->hw_features |= NETIF_F_HW_TC;
1157         slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1158         eth_hw_addr_inherit(slave_dev, master);
1159         slave_dev->priv_flags |= IFF_NO_QUEUE;
1160         slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1161         slave_dev->switchdev_ops = &dsa_slave_switchdev_ops;
1162         slave_dev->min_mtu = 0;
1163         slave_dev->max_mtu = ETH_MAX_MTU;
1164         SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1165 
1166         netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one,
1167                                  NULL);
1168 
1169         SET_NETDEV_DEV(slave_dev, parent);
1170         slave_dev->dev.of_node = ds->ports[port].dn;
1171         slave_dev->vlan_features = master->vlan_features;
1172 
1173         p = netdev_priv(slave_dev);
1174         p->dp = &ds->ports[port];
1175         INIT_LIST_HEAD(&p->mall_tc_list);
1176         p->xmit = dst->tag_ops->xmit;
1177 
1178         p->old_pause = -1;
1179         p->old_link = -1;
1180         p->old_duplex = -1;
1181 
1182         ds->ports[port].netdev = slave_dev;
1183 
1184         netif_carrier_off(slave_dev);
1185 
1186         ret = dsa_slave_phy_setup(p, slave_dev);
1187         if (ret) {
1188                 netdev_err(master, "error %d setting up slave phy\n", ret);
1189                 goto out_free;
1190         }
1191 
1192         ret = register_netdev(slave_dev);
1193         if (ret) {
1194                 netdev_err(master, "error %d registering interface %s\n",
1195                            ret, slave_dev->name);
1196                 goto out_phy;
1197         }
1198 
1199         return 0;
1200 
1201 out_phy:
1202         phy_disconnect(p->phy);
1203         if (of_phy_is_fixed_link(p->dp->dn))
1204                 of_phy_deregister_fixed_link(p->dp->dn);
1205 out_free:
1206         free_netdev(slave_dev);
1207         ds->ports[port].netdev = NULL;
1208         return ret;
1209 }
1210 
1211 void dsa_slave_destroy(struct net_device *slave_dev)
1212 {
1213         struct dsa_slave_priv *p = netdev_priv(slave_dev);
1214         struct device_node *port_dn;
1215 
1216         port_dn = p->dp->dn;
1217 
1218         netif_carrier_off(slave_dev);
1219         if (p->phy) {
1220                 phy_disconnect(p->phy);
1221 
1222                 if (of_phy_is_fixed_link(port_dn))
1223                         of_phy_deregister_fixed_link(port_dn);
1224         }
1225         unregister_netdev(slave_dev);
1226         free_netdev(slave_dev);
1227 }
1228 
1229 static bool dsa_slave_dev_check(struct net_device *dev)
1230 {
1231         return dev->netdev_ops == &dsa_slave_netdev_ops;
1232 }
1233 
1234 static int dsa_slave_changeupper(struct net_device *dev,
1235                                  struct netdev_notifier_changeupper_info *info)
1236 {
1237         struct dsa_slave_priv *p = netdev_priv(dev);
1238         struct dsa_port *dp = p->dp;
1239         int err = NOTIFY_DONE;
1240 
1241         if (netif_is_bridge_master(info->upper_dev)) {
1242                 if (info->linking) {
1243                         err = dsa_port_bridge_join(dp, info->upper_dev);
1244                         err = notifier_from_errno(err);
1245                 } else {
1246                         dsa_port_bridge_leave(dp, info->upper_dev);
1247                         err = NOTIFY_OK;
1248                 }
1249         }
1250 
1251         return err;
1252 }
1253 
1254 static int dsa_slave_netdevice_event(struct notifier_block *nb,
1255                                      unsigned long event, void *ptr)
1256 {
1257         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1258 
1259         if (dev->netdev_ops != &dsa_slave_netdev_ops)
1260                 return NOTIFY_DONE;
1261 
1262         if (event == NETDEV_CHANGEUPPER)
1263                 return dsa_slave_changeupper(dev, ptr);
1264 
1265         return NOTIFY_DONE;
1266 }
1267 
1268 static struct notifier_block dsa_slave_nb __read_mostly = {
1269         .notifier_call  = dsa_slave_netdevice_event,
1270 };
1271 
1272 int dsa_slave_register_notifier(void)
1273 {
1274         return register_netdevice_notifier(&dsa_slave_nb);
1275 }
1276 
1277 void dsa_slave_unregister_notifier(void)
1278 {
1279         int err;
1280 
1281         err = unregister_netdevice_notifier(&dsa_slave_nb);
1282         if (err)
1283                 pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
1284 }
1285 

~ [ 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