slave.c (7d9a6ef558f6ff375aab9e29f08124cb0daa9bc5) slave.c (49463b7f2da1a115404b02c5533bc2c2125833a3)
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.

--- 41 unchanged lines hidden (view full) ---

50
51void 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",
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.

--- 41 unchanged lines hidden (view full) ---

50
51void 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);
58 ds->dst->index, 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 ****************************************************/
65static int dsa_slave_get_iflink(const struct net_device *dev)
66{
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 ****************************************************/
65static 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;
67 return dsa_slave_to_master(dev)->ifindex;
70}
71
72static int dsa_slave_open(struct net_device *dev)
73{
68}
69
70static int dsa_slave_open(struct net_device *dev)
71{
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;
72 struct net_device *master = dsa_slave_to_master(dev);
73 struct dsa_port *dp = dsa_slave_to_port(dev);
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)

--- 6 unchanged lines hidden (view full) ---

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
74 int err;
75
76 if (!(master->flags & IFF_UP))
77 return -ENETDOWN;
78
79 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
80 err = dev_uc_add(master, dev->dev_addr);
81 if (err < 0)

--- 6 unchanged lines hidden (view full) ---

88 goto del_unicast;
89 }
90 if (dev->flags & IFF_PROMISC) {
91 err = dev_set_promiscuity(master, 1);
92 if (err < 0)
93 goto clear_allmulti;
94 }
95
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 }
96 err = dsa_port_enable(dp, dev->phydev);
97 if (err)
98 goto clear_promisc;
106
99
107 dsa_port_set_state_now(p->dp, stp_state);
100 if (dev->phydev)
101 phy_start(dev->phydev);
108
102
109 if (p->phy)
110 phy_start(p->phy);
111
112 return 0;
113
114clear_promisc:
115 if (dev->flags & IFF_PROMISC)
116 dev_set_promiscuity(master, -1);
117clear_allmulti:
118 if (dev->flags & IFF_ALLMULTI)
119 dev_set_allmulti(master, -1);
120del_unicast:
121 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
122 dev_uc_del(master, dev->dev_addr);
123out:
124 return err;
125}
126
127static int dsa_slave_close(struct net_device *dev)
128{
103 return 0;
104
105clear_promisc:
106 if (dev->flags & IFF_PROMISC)
107 dev_set_promiscuity(master, -1);
108clear_allmulti:
109 if (dev->flags & IFF_ALLMULTI)
110 dev_set_allmulti(master, -1);
111del_unicast:
112 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
113 dev_uc_del(master, dev->dev_addr);
114out:
115 return err;
116}
117
118static int dsa_slave_close(struct net_device *dev)
119{
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;
120 struct net_device *master = dsa_slave_to_master(dev);
121 struct dsa_port *dp = dsa_slave_to_port(dev);
132
122
133 if (p->phy)
134 phy_stop(p->phy);
123 if (dev->phydev)
124 phy_stop(dev->phydev);
135
125
126 dsa_port_disable(dp, dev->phydev);
127
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
128 dev_mc_unsync(master, dev);
129 dev_uc_unsync(master, dev);
130 if (dev->flags & IFF_ALLMULTI)
131 dev_set_allmulti(master, -1);
132 if (dev->flags & IFF_PROMISC)
133 dev_set_promiscuity(master, -1);
134
135 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
136 dev_uc_del(master, dev->dev_addr);
137
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
154static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
155{
138 return 0;
139}
140
141static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
142{
156 struct dsa_slave_priv *p = netdev_priv(dev);
157 struct net_device *master = dsa_master_netdev(p);
143 struct net_device *master = dsa_slave_to_master(dev);
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
165static void dsa_slave_set_rx_mode(struct net_device *dev)
166{
144
145 if (change & IFF_ALLMULTI)
146 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
147 if (change & IFF_PROMISC)
148 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
149}
150
151static void dsa_slave_set_rx_mode(struct net_device *dev)
152{
167 struct dsa_slave_priv *p = netdev_priv(dev);
168 struct net_device *master = dsa_master_netdev(p);
153 struct net_device *master = dsa_slave_to_master(dev);
169
170 dev_mc_sync(master, dev);
171 dev_uc_sync(master, dev);
172}
173
174static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
175{
154
155 dev_mc_sync(master, dev);
156 dev_uc_sync(master, dev);
157}
158
159static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
160{
176 struct dsa_slave_priv *p = netdev_priv(dev);
177 struct net_device *master = dsa_master_netdev(p);
161 struct net_device *master = dsa_slave_to_master(dev);
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;

--- 64 unchanged lines hidden (view full) ---

250 return -EMSGSIZE;
251}
252
253static int
254dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
255 struct net_device *dev, struct net_device *filter_dev,
256 int *idx)
257{
162 struct sockaddr *addr = a;
163 int err;
164
165 if (!is_valid_ether_addr(addr->sa_data))
166 return -EADDRNOTAVAIL;
167
168 if (!(dev->flags & IFF_UP))
169 goto out;

--- 64 unchanged lines hidden (view full) ---

234 return -EMSGSIZE;
235}
236
237static int
238dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
239 struct net_device *dev, struct net_device *filter_dev,
240 int *idx)
241{
242 struct dsa_port *dp = dsa_slave_to_port(dev);
258 struct dsa_slave_dump_ctx dump = {
259 .dev = dev,
260 .skb = skb,
261 .cb = cb,
262 .idx = *idx,
263 };
243 struct dsa_slave_dump_ctx dump = {
244 .dev = dev,
245 .skb = skb,
246 .cb = cb,
247 .idx = *idx,
248 };
264 struct dsa_slave_priv *p = netdev_priv(dev);
265 struct dsa_port *dp = p->dp;
266 struct dsa_switch *ds = dp->ds;
267 int err;
268
249 int err;
250
269 if (!ds->ops->port_fdb_dump)
270 return -EOPNOTSUPP;
271
272 err = ds->ops->port_fdb_dump(ds, dp->index,
273 dsa_slave_port_fdb_do_dump,
274 &dump);
251 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump);
275 *idx = dump.idx;
252 *idx = dump.idx;
253
276 return err;
277}
278
279static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
280{
254 return err;
255}
256
257static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
258{
281 struct dsa_slave_priv *p = netdev_priv(dev);
259 if (!dev->phydev)
260 return -ENODEV;
282
261
283 if (p->phy != NULL)
284 return phy_mii_ioctl(p->phy, ifr, cmd);
285
286 return -EOPNOTSUPP;
262 return phy_mii_ioctl(dev->phydev, ifr, cmd);
287}
288
289static int dsa_slave_port_attr_set(struct net_device *dev,
290 const struct switchdev_attr *attr,
291 struct switchdev_trans *trans)
292{
263}
264
265static int dsa_slave_port_attr_set(struct net_device *dev,
266 const struct switchdev_attr *attr,
267 struct switchdev_trans *trans)
268{
293 struct dsa_slave_priv *p = netdev_priv(dev);
294 struct dsa_port *dp = p->dp;
269 struct dsa_port *dp = dsa_slave_to_port(dev);
295 int ret;
296
297 switch (attr->id) {
298 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
299 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
300 break;
301 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
302 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,

--- 9 unchanged lines hidden (view full) ---

312
313 return ret;
314}
315
316static int dsa_slave_port_obj_add(struct net_device *dev,
317 const struct switchdev_obj *obj,
318 struct switchdev_trans *trans)
319{
270 int ret;
271
272 switch (attr->id) {
273 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
274 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
275 break;
276 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
277 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,

--- 9 unchanged lines hidden (view full) ---

287
288 return ret;
289}
290
291static int dsa_slave_port_obj_add(struct net_device *dev,
292 const struct switchdev_obj *obj,
293 struct switchdev_trans *trans)
294{
320 struct dsa_slave_priv *p = netdev_priv(dev);
321 struct dsa_port *dp = p->dp;
295 struct dsa_port *dp = dsa_slave_to_port(dev);
322 int err;
323
324 /* For the prepare phase, ensure the full set of changes is feasable in
325 * one go in order to signal a failure properly. If an operation is not
326 * supported, return -EOPNOTSUPP.
327 */
328
329 switch (obj->id) {

--- 10 unchanged lines hidden (view full) ---

340 }
341
342 return err;
343}
344
345static int dsa_slave_port_obj_del(struct net_device *dev,
346 const struct switchdev_obj *obj)
347{
296 int err;
297
298 /* For the prepare phase, ensure the full set of changes is feasable in
299 * one go in order to signal a failure properly. If an operation is not
300 * supported, return -EOPNOTSUPP.
301 */
302
303 switch (obj->id) {

--- 10 unchanged lines hidden (view full) ---

314 }
315
316 return err;
317}
318
319static int dsa_slave_port_obj_del(struct net_device *dev,
320 const struct switchdev_obj *obj)
321{
348 struct dsa_slave_priv *p = netdev_priv(dev);
349 struct dsa_port *dp = p->dp;
322 struct dsa_port *dp = dsa_slave_to_port(dev);
350 int err;
351
352 switch (obj->id) {
353 case SWITCHDEV_OBJ_ID_PORT_MDB:
354 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
355 break;
356 case SWITCHDEV_OBJ_ID_PORT_VLAN:
357 err = dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));

--- 4 unchanged lines hidden (view full) ---

362 }
363
364 return err;
365}
366
367static int dsa_slave_port_attr_get(struct net_device *dev,
368 struct switchdev_attr *attr)
369{
323 int err;
324
325 switch (obj->id) {
326 case SWITCHDEV_OBJ_ID_PORT_MDB:
327 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
328 break;
329 case SWITCHDEV_OBJ_ID_PORT_VLAN:
330 err = dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));

--- 4 unchanged lines hidden (view full) ---

335 }
336
337 return err;
338}
339
340static int dsa_slave_port_attr_get(struct net_device *dev,
341 struct switchdev_attr *attr)
342{
370 struct dsa_slave_priv *p = netdev_priv(dev);
371 struct dsa_switch *ds = p->dp->ds;
343 struct dsa_port *dp = dsa_slave_to_port(dev);
344 struct dsa_switch *ds = dp->ds;
372
373 switch (attr->id) {
374 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
375 attr->u.ppid.id_len = sizeof(ds->index);
376 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
377 break;
378 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
379 attr->u.brport_flags_support = 0;
380 break;
381 default:
382 return -EOPNOTSUPP;
383 }
384
385 return 0;
386}
387
345
346 switch (attr->id) {
347 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
348 attr->u.ppid.id_len = sizeof(ds->index);
349 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
350 break;
351 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
352 attr->u.brport_flags_support = 0;
353 break;
354 default:
355 return -EOPNOTSUPP;
356 }
357
358 return 0;
359}
360
388static inline netdev_tx_t dsa_netpoll_send_skb(struct dsa_slave_priv *p,
389 struct sk_buff *skb)
361static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev,
362 struct sk_buff *skb)
390{
391#ifdef CONFIG_NET_POLL_CONTROLLER
363{
364#ifdef CONFIG_NET_POLL_CONTROLLER
365 struct dsa_slave_priv *p = netdev_priv(dev);
366
392 if (p->netpoll)
393 netpoll_send_skb(p->netpoll, skb);
394#else
395 BUG();
396#endif
397 return NETDEV_TX_OK;
398}
399

--- 17 unchanged lines hidden (view full) ---

417 kfree_skb(skb);
418 return NETDEV_TX_OK;
419 }
420
421 /* SKB for netpoll still need to be mangled with the protocol-specific
422 * tag to be successfully transmitted
423 */
424 if (unlikely(netpoll_tx_running(dev)))
367 if (p->netpoll)
368 netpoll_send_skb(p->netpoll, skb);
369#else
370 BUG();
371#endif
372 return NETDEV_TX_OK;
373}
374

--- 17 unchanged lines hidden (view full) ---

392 kfree_skb(skb);
393 return NETDEV_TX_OK;
394 }
395
396 /* SKB for netpoll still need to be mangled with the protocol-specific
397 * tag to be successfully transmitted
398 */
399 if (unlikely(netpoll_tx_running(dev)))
425 return dsa_netpoll_send_skb(p, nskb);
400 return dsa_slave_netpoll_send_skb(dev, nskb);
426
427 /* Queue the SKB for transmission on the parent interface, but
428 * do not modify its EtherType
429 */
401
402 /* Queue the SKB for transmission on the parent interface, but
403 * do not modify its EtherType
404 */
430 nskb->dev = dsa_master_netdev(p);
405 nskb->dev = dsa_slave_to_master(dev);
431 dev_queue_xmit(nskb);
432
433 return NETDEV_TX_OK;
434}
435
436/* ethtool operations *******************************************************/
406 dev_queue_xmit(nskb);
407
408 return NETDEV_TX_OK;
409}
410
411/* ethtool operations *******************************************************/
437static int
438dsa_slave_get_link_ksettings(struct net_device *dev,
439 struct ethtool_link_ksettings *cmd)
440{
441 struct dsa_slave_priv *p = netdev_priv(dev);
442
412
443 if (!p->phy)
444 return -EOPNOTSUPP;
445
446 phy_ethtool_ksettings_get(p->phy, cmd);
447
448 return 0;
449}
450
451static int
452dsa_slave_set_link_ksettings(struct net_device *dev,
453 const struct ethtool_link_ksettings *cmd)
454{
455 struct dsa_slave_priv *p = netdev_priv(dev);
456
457 if (p->phy != NULL)
458 return phy_ethtool_ksettings_set(p->phy, cmd);
459
460 return -EOPNOTSUPP;
461}
462
463static void dsa_slave_get_drvinfo(struct net_device *dev,
464 struct ethtool_drvinfo *drvinfo)
465{
466 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
467 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
468 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
469}
470
471static int dsa_slave_get_regs_len(struct net_device *dev)
472{
413static void dsa_slave_get_drvinfo(struct net_device *dev,
414 struct ethtool_drvinfo *drvinfo)
415{
416 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
417 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
418 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
419}
420
421static int dsa_slave_get_regs_len(struct net_device *dev)
422{
473 struct dsa_slave_priv *p = netdev_priv(dev);
474 struct dsa_switch *ds = p->dp->ds;
423 struct dsa_port *dp = dsa_slave_to_port(dev);
424 struct dsa_switch *ds = dp->ds;
475
476 if (ds->ops->get_regs_len)
425
426 if (ds->ops->get_regs_len)
477 return ds->ops->get_regs_len(ds, p->dp->index);
427 return ds->ops->get_regs_len(ds, dp->index);
478
479 return -EOPNOTSUPP;
480}
481
482static void
483dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
484{
428
429 return -EOPNOTSUPP;
430}
431
432static void
433dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
434{
485 struct dsa_slave_priv *p = netdev_priv(dev);
486 struct dsa_switch *ds = p->dp->ds;
435 struct dsa_port *dp = dsa_slave_to_port(dev);
436 struct dsa_switch *ds = dp->ds;
487
488 if (ds->ops->get_regs)
437
438 if (ds->ops->get_regs)
489 ds->ops->get_regs(ds, p->dp->index, regs, _p);
439 ds->ops->get_regs(ds, dp->index, regs, _p);
490}
491
440}
441
492static int dsa_slave_nway_reset(struct net_device *dev)
493{
494 struct dsa_slave_priv *p = netdev_priv(dev);
495
496 if (p->phy != NULL)
497 return genphy_restart_aneg(p->phy);
498
499 return -EOPNOTSUPP;
500}
501
502static u32 dsa_slave_get_link(struct net_device *dev)
503{
442static u32 dsa_slave_get_link(struct net_device *dev)
443{
504 struct dsa_slave_priv *p = netdev_priv(dev);
444 if (!dev->phydev)
445 return -ENODEV;
505
446
506 if (p->phy != NULL) {
507 genphy_update_link(p->phy);
508 return p->phy->link;
509 }
447 genphy_update_link(dev->phydev);
510
448
511 return -EOPNOTSUPP;
449 return dev->phydev->link;
512}
513
514static int dsa_slave_get_eeprom_len(struct net_device *dev)
515{
450}
451
452static int dsa_slave_get_eeprom_len(struct net_device *dev)
453{
516 struct dsa_slave_priv *p = netdev_priv(dev);
517 struct dsa_switch *ds = p->dp->ds;
454 struct dsa_port *dp = dsa_slave_to_port(dev);
455 struct dsa_switch *ds = dp->ds;
518
519 if (ds->cd && ds->cd->eeprom_len)
520 return ds->cd->eeprom_len;
521
522 if (ds->ops->get_eeprom_len)
523 return ds->ops->get_eeprom_len(ds);
524
525 return 0;
526}
527
528static int dsa_slave_get_eeprom(struct net_device *dev,
529 struct ethtool_eeprom *eeprom, u8 *data)
530{
456
457 if (ds->cd && ds->cd->eeprom_len)
458 return ds->cd->eeprom_len;
459
460 if (ds->ops->get_eeprom_len)
461 return ds->ops->get_eeprom_len(ds);
462
463 return 0;
464}
465
466static int dsa_slave_get_eeprom(struct net_device *dev,
467 struct ethtool_eeprom *eeprom, u8 *data)
468{
531 struct dsa_slave_priv *p = netdev_priv(dev);
532 struct dsa_switch *ds = p->dp->ds;
469 struct dsa_port *dp = dsa_slave_to_port(dev);
470 struct dsa_switch *ds = dp->ds;
533
534 if (ds->ops->get_eeprom)
535 return ds->ops->get_eeprom(ds, eeprom, data);
536
537 return -EOPNOTSUPP;
538}
539
540static int dsa_slave_set_eeprom(struct net_device *dev,
541 struct ethtool_eeprom *eeprom, u8 *data)
542{
471
472 if (ds->ops->get_eeprom)
473 return ds->ops->get_eeprom(ds, eeprom, data);
474
475 return -EOPNOTSUPP;
476}
477
478static int dsa_slave_set_eeprom(struct net_device *dev,
479 struct ethtool_eeprom *eeprom, u8 *data)
480{
543 struct dsa_slave_priv *p = netdev_priv(dev);
544 struct dsa_switch *ds = p->dp->ds;
481 struct dsa_port *dp = dsa_slave_to_port(dev);
482 struct dsa_switch *ds = dp->ds;
545
546 if (ds->ops->set_eeprom)
547 return ds->ops->set_eeprom(ds, eeprom, data);
548
549 return -EOPNOTSUPP;
550}
551
552static void dsa_slave_get_strings(struct net_device *dev,
553 uint32_t stringset, uint8_t *data)
554{
483
484 if (ds->ops->set_eeprom)
485 return ds->ops->set_eeprom(ds, eeprom, data);
486
487 return -EOPNOTSUPP;
488}
489
490static void dsa_slave_get_strings(struct net_device *dev,
491 uint32_t stringset, uint8_t *data)
492{
555 struct dsa_slave_priv *p = netdev_priv(dev);
556 struct dsa_switch *ds = p->dp->ds;
493 struct dsa_port *dp = dsa_slave_to_port(dev);
494 struct dsa_switch *ds = dp->ds;
557
558 if (stringset == ETH_SS_STATS) {
559 int len = ETH_GSTRING_LEN;
560
561 strncpy(data, "tx_packets", len);
562 strncpy(data + len, "tx_bytes", len);
563 strncpy(data + 2 * len, "rx_packets", len);
564 strncpy(data + 3 * len, "rx_bytes", len);
565 if (ds->ops->get_strings)
495
496 if (stringset == ETH_SS_STATS) {
497 int len = ETH_GSTRING_LEN;
498
499 strncpy(data, "tx_packets", len);
500 strncpy(data + len, "tx_bytes", len);
501 strncpy(data + 2 * len, "rx_packets", len);
502 strncpy(data + 3 * len, "rx_bytes", len);
503 if (ds->ops->get_strings)
566 ds->ops->get_strings(ds, p->dp->index, data + 4 * len);
504 ds->ops->get_strings(ds, dp->index, data + 4 * len);
567 }
568}
569
505 }
506}
507
570static void dsa_cpu_port_get_ethtool_stats(struct net_device *dev,
571 struct ethtool_stats *stats,
572 uint64_t *data)
573{
574 struct dsa_switch_tree *dst = dev->dsa_ptr;
575 struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
576 struct dsa_switch *ds = cpu_dp->ds;
577 s8 cpu_port = cpu_dp->index;
578 int count = 0;
579
580 if (cpu_dp->ethtool_ops.get_sset_count) {
581 count = cpu_dp->ethtool_ops.get_sset_count(dev, ETH_SS_STATS);
582 cpu_dp->ethtool_ops.get_ethtool_stats(dev, stats, data);
583 }
584
585 if (ds->ops->get_ethtool_stats)
586 ds->ops->get_ethtool_stats(ds, cpu_port, data + count);
587}
588
589static int dsa_cpu_port_get_sset_count(struct net_device *dev, int sset)
590{
591 struct dsa_switch_tree *dst = dev->dsa_ptr;
592 struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
593 struct dsa_switch *ds = cpu_dp->ds;
594 int count = 0;
595
596 if (cpu_dp->ethtool_ops.get_sset_count)
597 count += cpu_dp->ethtool_ops.get_sset_count(dev, sset);
598
599 if (sset == ETH_SS_STATS && ds->ops->get_sset_count)
600 count += ds->ops->get_sset_count(ds);
601
602 return count;
603}
604
605static void dsa_cpu_port_get_strings(struct net_device *dev,
606 uint32_t stringset, uint8_t *data)
607{
608 struct dsa_switch_tree *dst = dev->dsa_ptr;
609 struct dsa_port *cpu_dp = dsa_get_cpu_port(dst);
610 struct dsa_switch *ds = cpu_dp->ds;
611 s8 cpu_port = cpu_dp->index;
612 int len = ETH_GSTRING_LEN;
613 int mcount = 0, count;
614 unsigned int i;
615 uint8_t pfx[4];
616 uint8_t *ndata;
617
618 snprintf(pfx, sizeof(pfx), "p%.2d", cpu_port);
619 /* We do not want to be NULL-terminated, since this is a prefix */
620 pfx[sizeof(pfx) - 1] = '_';
621
622 if (cpu_dp->ethtool_ops.get_sset_count) {
623 mcount = cpu_dp->ethtool_ops.get_sset_count(dev, ETH_SS_STATS);
624 cpu_dp->ethtool_ops.get_strings(dev, stringset, data);
625 }
626
627 if (stringset == ETH_SS_STATS && ds->ops->get_strings) {
628 ndata = data + mcount * len;
629 /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
630 * the output after to prepend our CPU port prefix we
631 * constructed earlier
632 */
633 ds->ops->get_strings(ds, cpu_port, ndata);
634 count = ds->ops->get_sset_count(ds);
635 for (i = 0; i < count; i++) {
636 memmove(ndata + (i * len + sizeof(pfx)),
637 ndata + i * len, len - sizeof(pfx));
638 memcpy(ndata + i * len, pfx, sizeof(pfx));
639 }
640 }
641}
642
643static void dsa_slave_get_ethtool_stats(struct net_device *dev,
644 struct ethtool_stats *stats,
645 uint64_t *data)
646{
508static void dsa_slave_get_ethtool_stats(struct net_device *dev,
509 struct ethtool_stats *stats,
510 uint64_t *data)
511{
512 struct dsa_port *dp = dsa_slave_to_port(dev);
647 struct dsa_slave_priv *p = netdev_priv(dev);
513 struct dsa_slave_priv *p = netdev_priv(dev);
648 struct dsa_switch *ds = p->dp->ds;
514 struct dsa_switch *ds = dp->ds;
649 struct pcpu_sw_netstats *s;
650 unsigned int start;
651 int i;
652
653 for_each_possible_cpu(i) {
654 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
655
656 s = per_cpu_ptr(p->stats64, i);

--- 5 unchanged lines hidden (view full) ---

662 rx_bytes = s->rx_bytes;
663 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
664 data[0] += tx_packets;
665 data[1] += tx_bytes;
666 data[2] += rx_packets;
667 data[3] += rx_bytes;
668 }
669 if (ds->ops->get_ethtool_stats)
515 struct pcpu_sw_netstats *s;
516 unsigned int start;
517 int i;
518
519 for_each_possible_cpu(i) {
520 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
521
522 s = per_cpu_ptr(p->stats64, i);

--- 5 unchanged lines hidden (view full) ---

528 rx_bytes = s->rx_bytes;
529 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
530 data[0] += tx_packets;
531 data[1] += tx_bytes;
532 data[2] += rx_packets;
533 data[3] += rx_bytes;
534 }
535 if (ds->ops->get_ethtool_stats)
670 ds->ops->get_ethtool_stats(ds, p->dp->index, data + 4);
536 ds->ops->get_ethtool_stats(ds, dp->index, data + 4);
671}
672
673static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
674{
537}
538
539static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
540{
675 struct dsa_slave_priv *p = netdev_priv(dev);
676 struct dsa_switch *ds = p->dp->ds;
541 struct dsa_port *dp = dsa_slave_to_port(dev);
542 struct dsa_switch *ds = dp->ds;
677
678 if (sset == ETH_SS_STATS) {
679 int count;
680
681 count = 4;
682 if (ds->ops->get_sset_count)
683 count += ds->ops->get_sset_count(ds);
684
685 return count;
686 }
687
688 return -EOPNOTSUPP;
689}
690
691static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
692{
543
544 if (sset == ETH_SS_STATS) {
545 int count;
546
547 count = 4;
548 if (ds->ops->get_sset_count)
549 count += ds->ops->get_sset_count(ds);
550
551 return count;
552 }
553
554 return -EOPNOTSUPP;
555}
556
557static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
558{
693 struct dsa_slave_priv *p = netdev_priv(dev);
694 struct dsa_switch *ds = p->dp->ds;
559 struct dsa_port *dp = dsa_slave_to_port(dev);
560 struct dsa_switch *ds = dp->ds;
695
696 if (ds->ops->get_wol)
561
562 if (ds->ops->get_wol)
697 ds->ops->get_wol(ds, p->dp->index, w);
563 ds->ops->get_wol(ds, dp->index, w);
698}
699
700static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
701{
564}
565
566static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
567{
702 struct dsa_slave_priv *p = netdev_priv(dev);
703 struct dsa_switch *ds = p->dp->ds;
568 struct dsa_port *dp = dsa_slave_to_port(dev);
569 struct dsa_switch *ds = dp->ds;
704 int ret = -EOPNOTSUPP;
705
706 if (ds->ops->set_wol)
570 int ret = -EOPNOTSUPP;
571
572 if (ds->ops->set_wol)
707 ret = ds->ops->set_wol(ds, p->dp->index, w);
573 ret = ds->ops->set_wol(ds, dp->index, w);
708
709 return ret;
710}
711
712static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
713{
574
575 return ret;
576}
577
578static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
579{
714 struct dsa_slave_priv *p = netdev_priv(dev);
715 struct dsa_switch *ds = p->dp->ds;
580 struct dsa_port *dp = dsa_slave_to_port(dev);
581 struct dsa_switch *ds = dp->ds;
716 int ret;
717
718 /* Port's PHY and MAC both need to be EEE capable */
582 int ret;
583
584 /* Port's PHY and MAC both need to be EEE capable */
719 if (!p->phy)
585 if (!dev->phydev)
720 return -ENODEV;
721
722 if (!ds->ops->set_mac_eee)
723 return -EOPNOTSUPP;
724
586 return -ENODEV;
587
588 if (!ds->ops->set_mac_eee)
589 return -EOPNOTSUPP;
590
725 ret = ds->ops->set_mac_eee(ds, p->dp->index, e);
591 ret = ds->ops->set_mac_eee(ds, dp->index, e);
726 if (ret)
727 return ret;
728
729 if (e->eee_enabled) {
592 if (ret)
593 return ret;
594
595 if (e->eee_enabled) {
730 ret = phy_init_eee(p->phy, 0);
596 ret = phy_init_eee(dev->phydev, 0);
731 if (ret)
732 return ret;
733 }
734
597 if (ret)
598 return ret;
599 }
600
735 return phy_ethtool_set_eee(p->phy, e);
601 return phy_ethtool_set_eee(dev->phydev, e);
736}
737
738static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
739{
602}
603
604static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
605{
740 struct dsa_slave_priv *p = netdev_priv(dev);
741 struct dsa_switch *ds = p->dp->ds;
606 struct dsa_port *dp = dsa_slave_to_port(dev);
607 struct dsa_switch *ds = dp->ds;
742 int ret;
743
744 /* Port's PHY and MAC both need to be EEE capable */
608 int ret;
609
610 /* Port's PHY and MAC both need to be EEE capable */
745 if (!p->phy)
611 if (!dev->phydev)
746 return -ENODEV;
747
748 if (!ds->ops->get_mac_eee)
749 return -EOPNOTSUPP;
750
612 return -ENODEV;
613
614 if (!ds->ops->get_mac_eee)
615 return -EOPNOTSUPP;
616
751 ret = ds->ops->get_mac_eee(ds, p->dp->index, e);
617 ret = ds->ops->get_mac_eee(ds, dp->index, e);
752 if (ret)
753 return ret;
754
618 if (ret)
619 return ret;
620
755 return phy_ethtool_get_eee(p->phy, e);
621 return phy_ethtool_get_eee(dev->phydev, e);
756}
757
758#ifdef CONFIG_NET_POLL_CONTROLLER
759static int dsa_slave_netpoll_setup(struct net_device *dev,
760 struct netpoll_info *ni)
761{
622}
623
624#ifdef CONFIG_NET_POLL_CONTROLLER
625static int dsa_slave_netpoll_setup(struct net_device *dev,
626 struct netpoll_info *ni)
627{
628 struct net_device *master = dsa_slave_to_master(dev);
762 struct dsa_slave_priv *p = netdev_priv(dev);
629 struct dsa_slave_priv *p = netdev_priv(dev);
763 struct net_device *master = dsa_master_netdev(p);
764 struct netpoll *netpoll;
765 int err = 0;
766
767 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
768 if (!netpoll)
769 return -ENOMEM;
770
771 err = __netpoll_setup(netpoll, master);

--- 23 unchanged lines hidden (view full) ---

795static void dsa_slave_poll_controller(struct net_device *dev)
796{
797}
798#endif
799
800static int dsa_slave_get_phys_port_name(struct net_device *dev,
801 char *name, size_t len)
802{
630 struct netpoll *netpoll;
631 int err = 0;
632
633 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
634 if (!netpoll)
635 return -ENOMEM;
636
637 err = __netpoll_setup(netpoll, master);

--- 23 unchanged lines hidden (view full) ---

661static void dsa_slave_poll_controller(struct net_device *dev)
662{
663}
664#endif
665
666static int dsa_slave_get_phys_port_name(struct net_device *dev,
667 char *name, size_t len)
668{
803 struct dsa_slave_priv *p = netdev_priv(dev);
669 struct dsa_port *dp = dsa_slave_to_port(dev);
804
670
805 if (snprintf(name, len, "p%d", p->dp->index) >= len)
671 if (snprintf(name, len, "p%d", dp->index) >= len)
806 return -EINVAL;
807
808 return 0;
809}
810
811static struct dsa_mall_tc_entry *
672 return -EINVAL;
673
674 return 0;
675}
676
677static struct dsa_mall_tc_entry *
812dsa_slave_mall_tc_entry_find(struct dsa_slave_priv *p,
813 unsigned long cookie)
678dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie)
814{
679{
680 struct dsa_slave_priv *p = netdev_priv(dev);
815 struct dsa_mall_tc_entry *mall_tc_entry;
816
817 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
818 if (mall_tc_entry->cookie == cookie)
819 return mall_tc_entry;
820
821 return NULL;
822}
823
824static int dsa_slave_add_cls_matchall(struct net_device *dev,
825 struct tc_cls_matchall_offload *cls,
826 bool ingress)
827{
681 struct dsa_mall_tc_entry *mall_tc_entry;
682
683 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
684 if (mall_tc_entry->cookie == cookie)
685 return mall_tc_entry;
686
687 return NULL;
688}
689
690static int dsa_slave_add_cls_matchall(struct net_device *dev,
691 struct tc_cls_matchall_offload *cls,
692 bool ingress)
693{
694 struct dsa_port *dp = dsa_slave_to_port(dev);
828 struct dsa_slave_priv *p = netdev_priv(dev);
829 struct dsa_mall_tc_entry *mall_tc_entry;
830 __be16 protocol = cls->common.protocol;
695 struct dsa_slave_priv *p = netdev_priv(dev);
696 struct dsa_mall_tc_entry *mall_tc_entry;
697 __be16 protocol = cls->common.protocol;
831 struct dsa_switch *ds = p->dp->ds;
832 struct net *net = dev_net(dev);
698 struct net *net = dev_net(dev);
833 struct dsa_slave_priv *to_p;
699 struct dsa_switch *ds = dp->ds;
834 struct net_device *to_dev;
835 const struct tc_action *a;
700 struct net_device *to_dev;
701 const struct tc_action *a;
702 struct dsa_port *to_dp;
836 int err = -EOPNOTSUPP;
837 LIST_HEAD(actions);
838 int ifindex;
839
840 if (!ds->ops->port_mirror_add)
841 return err;
842
843 if (!tcf_exts_has_one_action(cls->exts))

--- 16 unchanged lines hidden (view full) ---

860 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
861 if (!mall_tc_entry)
862 return -ENOMEM;
863
864 mall_tc_entry->cookie = cls->cookie;
865 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
866 mirror = &mall_tc_entry->mirror;
867
703 int err = -EOPNOTSUPP;
704 LIST_HEAD(actions);
705 int ifindex;
706
707 if (!ds->ops->port_mirror_add)
708 return err;
709
710 if (!tcf_exts_has_one_action(cls->exts))

--- 16 unchanged lines hidden (view full) ---

727 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
728 if (!mall_tc_entry)
729 return -ENOMEM;
730
731 mall_tc_entry->cookie = cls->cookie;
732 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
733 mirror = &mall_tc_entry->mirror;
734
868 to_p = netdev_priv(to_dev);
735 to_dp = dsa_slave_to_port(to_dev);
869
736
870 mirror->to_local_port = to_p->dp->index;
737 mirror->to_local_port = to_dp->index;
871 mirror->ingress = ingress;
872
738 mirror->ingress = ingress;
739
873 err = ds->ops->port_mirror_add(ds, p->dp->index, mirror,
874 ingress);
740 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress);
875 if (err) {
876 kfree(mall_tc_entry);
877 return err;
878 }
879
880 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
881 }
882
883 return 0;
884}
885
886static void dsa_slave_del_cls_matchall(struct net_device *dev,
887 struct tc_cls_matchall_offload *cls)
888{
741 if (err) {
742 kfree(mall_tc_entry);
743 return err;
744 }
745
746 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
747 }
748
749 return 0;
750}
751
752static void dsa_slave_del_cls_matchall(struct net_device *dev,
753 struct tc_cls_matchall_offload *cls)
754{
889 struct dsa_slave_priv *p = netdev_priv(dev);
755 struct dsa_port *dp = dsa_slave_to_port(dev);
890 struct dsa_mall_tc_entry *mall_tc_entry;
756 struct dsa_mall_tc_entry *mall_tc_entry;
891 struct dsa_switch *ds = p->dp->ds;
757 struct dsa_switch *ds = dp->ds;
892
893 if (!ds->ops->port_mirror_del)
894 return;
895
758
759 if (!ds->ops->port_mirror_del)
760 return;
761
896 mall_tc_entry = dsa_slave_mall_tc_entry_find(p, cls->cookie);
762 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie);
897 if (!mall_tc_entry)
898 return;
899
900 list_del(&mall_tc_entry->list);
901
902 switch (mall_tc_entry->type) {
903 case DSA_PORT_MALL_MIRROR:
763 if (!mall_tc_entry)
764 return;
765
766 list_del(&mall_tc_entry->list);
767
768 switch (mall_tc_entry->type) {
769 case DSA_PORT_MALL_MIRROR:
904 ds->ops->port_mirror_del(ds, p->dp->index,
905 &mall_tc_entry->mirror);
770 ds->ops->port_mirror_del(ds, dp->index, &mall_tc_entry->mirror);
906 break;
907 default:
908 WARN_ON(1);
909 }
910
911 kfree(mall_tc_entry);
912}
913
914static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
771 break;
772 default:
773 WARN_ON(1);
774 }
775
776 kfree(mall_tc_entry);
777}
778
779static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
915 struct tc_cls_matchall_offload *cls)
780 struct tc_cls_matchall_offload *cls,
781 bool ingress)
916{
782{
917 bool ingress;
918
919 if (is_classid_clsact_ingress(cls->common.classid))
920 ingress = true;
921 else if (is_classid_clsact_egress(cls->common.classid))
922 ingress = false;
923 else
924 return -EOPNOTSUPP;
925
926 if (cls->common.chain_index)
927 return -EOPNOTSUPP;
928
929 switch (cls->command) {
930 case TC_CLSMATCHALL_REPLACE:
931 return dsa_slave_add_cls_matchall(dev, cls, ingress);
932 case TC_CLSMATCHALL_DESTROY:
933 dsa_slave_del_cls_matchall(dev, cls);
934 return 0;
935 default:
936 return -EOPNOTSUPP;
937 }
938}
939
783 if (cls->common.chain_index)
784 return -EOPNOTSUPP;
785
786 switch (cls->command) {
787 case TC_CLSMATCHALL_REPLACE:
788 return dsa_slave_add_cls_matchall(dev, cls, ingress);
789 case TC_CLSMATCHALL_DESTROY:
790 dsa_slave_del_cls_matchall(dev, cls);
791 return 0;
792 default:
793 return -EOPNOTSUPP;
794 }
795}
796
797static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
798 void *cb_priv, bool ingress)
799{
800 struct net_device *dev = cb_priv;
801
802 if (!tc_can_offload(dev))
803 return -EOPNOTSUPP;
804
805 switch (type) {
806 case TC_SETUP_CLSMATCHALL:
807 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress);
808 default:
809 return -EOPNOTSUPP;
810 }
811}
812
813static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type,
814 void *type_data, void *cb_priv)
815{
816 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true);
817}
818
819static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
820 void *type_data, void *cb_priv)
821{
822 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
823}
824
825static int dsa_slave_setup_tc_block(struct net_device *dev,
826 struct tc_block_offload *f)
827{
828 tc_setup_cb_t *cb;
829
830 if (f->binder_type == TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
831 cb = dsa_slave_setup_tc_block_cb_ig;
832 else if (f->binder_type == TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
833 cb = dsa_slave_setup_tc_block_cb_eg;
834 else
835 return -EOPNOTSUPP;
836
837 switch (f->command) {
838 case TC_BLOCK_BIND:
839 return tcf_block_cb_register(f->block, cb, dev, dev);
840 case TC_BLOCK_UNBIND:
841 tcf_block_cb_unregister(f->block, cb, dev);
842 return 0;
843 default:
844 return -EOPNOTSUPP;
845 }
846}
847
940static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
941 void *type_data)
942{
943 switch (type) {
848static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
849 void *type_data)
850{
851 switch (type) {
944 case TC_SETUP_CLSMATCHALL:
945 return dsa_slave_setup_tc_cls_matchall(dev, type_data);
852 case TC_SETUP_BLOCK:
853 return dsa_slave_setup_tc_block(dev, type_data);
946 default:
947 return -EOPNOTSUPP;
948 }
949}
950
951static void dsa_slave_get_stats64(struct net_device *dev,
952 struct rtnl_link_stats64 *stats)
953{

--- 17 unchanged lines hidden (view full) ---

971
972 stats->tx_packets += tx_packets;
973 stats->tx_bytes += tx_bytes;
974 stats->rx_packets += rx_packets;
975 stats->rx_bytes += rx_bytes;
976 }
977}
978
854 default:
855 return -EOPNOTSUPP;
856 }
857}
858
859static void dsa_slave_get_stats64(struct net_device *dev,
860 struct rtnl_link_stats64 *stats)
861{

--- 17 unchanged lines hidden (view full) ---

879
880 stats->tx_packets += tx_packets;
881 stats->tx_bytes += tx_bytes;
882 stats->rx_packets += rx_packets;
883 stats->rx_bytes += rx_bytes;
884 }
885}
886
979void dsa_cpu_port_ethtool_init(struct ethtool_ops *ops)
980{
981 ops->get_sset_count = dsa_cpu_port_get_sset_count;
982 ops->get_ethtool_stats = dsa_cpu_port_get_ethtool_stats;
983 ops->get_strings = dsa_cpu_port_get_strings;
984}
985
986static int dsa_slave_get_rxnfc(struct net_device *dev,
987 struct ethtool_rxnfc *nfc, u32 *rule_locs)
988{
887static int dsa_slave_get_rxnfc(struct net_device *dev,
888 struct ethtool_rxnfc *nfc, u32 *rule_locs)
889{
989 struct dsa_slave_priv *p = netdev_priv(dev);
990 struct dsa_switch *ds = p->dp->ds;
890 struct dsa_port *dp = dsa_slave_to_port(dev);
891 struct dsa_switch *ds = dp->ds;
991
992 if (!ds->ops->get_rxnfc)
993 return -EOPNOTSUPP;
994
892
893 if (!ds->ops->get_rxnfc)
894 return -EOPNOTSUPP;
895
995 return ds->ops->get_rxnfc(ds, p->dp->index, nfc, rule_locs);
896 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);
996}
997
998static int dsa_slave_set_rxnfc(struct net_device *dev,
999 struct ethtool_rxnfc *nfc)
1000{
897}
898
899static int dsa_slave_set_rxnfc(struct net_device *dev,
900 struct ethtool_rxnfc *nfc)
901{
1001 struct dsa_slave_priv *p = netdev_priv(dev);
1002 struct dsa_switch *ds = p->dp->ds;
902 struct dsa_port *dp = dsa_slave_to_port(dev);
903 struct dsa_switch *ds = dp->ds;
1003
1004 if (!ds->ops->set_rxnfc)
1005 return -EOPNOTSUPP;
1006
904
905 if (!ds->ops->set_rxnfc)
906 return -EOPNOTSUPP;
907
1007 return ds->ops->set_rxnfc(ds, p->dp->index, nfc);
908 return ds->ops->set_rxnfc(ds, dp->index, nfc);
1008}
1009
1010static const struct ethtool_ops dsa_slave_ethtool_ops = {
1011 .get_drvinfo = dsa_slave_get_drvinfo,
1012 .get_regs_len = dsa_slave_get_regs_len,
1013 .get_regs = dsa_slave_get_regs,
909}
910
911static const struct ethtool_ops dsa_slave_ethtool_ops = {
912 .get_drvinfo = dsa_slave_get_drvinfo,
913 .get_regs_len = dsa_slave_get_regs_len,
914 .get_regs = dsa_slave_get_regs,
1014 .nway_reset = dsa_slave_nway_reset,
915 .nway_reset = phy_ethtool_nway_reset,
1015 .get_link = dsa_slave_get_link,
1016 .get_eeprom_len = dsa_slave_get_eeprom_len,
1017 .get_eeprom = dsa_slave_get_eeprom,
1018 .set_eeprom = dsa_slave_set_eeprom,
1019 .get_strings = dsa_slave_get_strings,
1020 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
1021 .get_sset_count = dsa_slave_get_sset_count,
1022 .set_wol = dsa_slave_set_wol,
1023 .get_wol = dsa_slave_get_wol,
1024 .set_eee = dsa_slave_set_eee,
1025 .get_eee = dsa_slave_get_eee,
916 .get_link = dsa_slave_get_link,
917 .get_eeprom_len = dsa_slave_get_eeprom_len,
918 .get_eeprom = dsa_slave_get_eeprom,
919 .set_eeprom = dsa_slave_set_eeprom,
920 .get_strings = dsa_slave_get_strings,
921 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
922 .get_sset_count = dsa_slave_get_sset_count,
923 .set_wol = dsa_slave_set_wol,
924 .get_wol = dsa_slave_get_wol,
925 .set_eee = dsa_slave_set_eee,
926 .get_eee = dsa_slave_get_eee,
1026 .get_link_ksettings = dsa_slave_get_link_ksettings,
1027 .set_link_ksettings = dsa_slave_set_link_ksettings,
927 .get_link_ksettings = phy_ethtool_get_link_ksettings,
928 .set_link_ksettings = phy_ethtool_set_link_ksettings,
1028 .get_rxnfc = dsa_slave_get_rxnfc,
1029 .set_rxnfc = dsa_slave_set_rxnfc,
1030};
1031
1032static const struct net_device_ops dsa_slave_netdev_ops = {
1033 .ndo_open = dsa_slave_open,
1034 .ndo_stop = dsa_slave_close,
1035 .ndo_start_xmit = dsa_slave_xmit,

--- 23 unchanged lines hidden (view full) ---

1059};
1060
1061static struct device_type dsa_type = {
1062 .name = "dsa",
1063};
1064
1065static void dsa_slave_adjust_link(struct net_device *dev)
1066{
929 .get_rxnfc = dsa_slave_get_rxnfc,
930 .set_rxnfc = dsa_slave_set_rxnfc,
931};
932
933static const struct net_device_ops dsa_slave_netdev_ops = {
934 .ndo_open = dsa_slave_open,
935 .ndo_stop = dsa_slave_close,
936 .ndo_start_xmit = dsa_slave_xmit,

--- 23 unchanged lines hidden (view full) ---

960};
961
962static struct device_type dsa_type = {
963 .name = "dsa",
964};
965
966static void dsa_slave_adjust_link(struct net_device *dev)
967{
968 struct dsa_port *dp = dsa_slave_to_port(dev);
1067 struct dsa_slave_priv *p = netdev_priv(dev);
969 struct dsa_slave_priv *p = netdev_priv(dev);
1068 struct dsa_switch *ds = p->dp->ds;
970 struct dsa_switch *ds = dp->ds;
1069 unsigned int status_changed = 0;
1070
971 unsigned int status_changed = 0;
972
1071 if (p->old_link != p->phy->link) {
973 if (p->old_link != dev->phydev->link) {
1072 status_changed = 1;
974 status_changed = 1;
1073 p->old_link = p->phy->link;
975 p->old_link = dev->phydev->link;
1074 }
1075
976 }
977
1076 if (p->old_duplex != p->phy->duplex) {
978 if (p->old_duplex != dev->phydev->duplex) {
1077 status_changed = 1;
979 status_changed = 1;
1078 p->old_duplex = p->phy->duplex;
980 p->old_duplex = dev->phydev->duplex;
1079 }
1080
981 }
982
1081 if (p->old_pause != p->phy->pause) {
983 if (p->old_pause != dev->phydev->pause) {
1082 status_changed = 1;
984 status_changed = 1;
1083 p->old_pause = p->phy->pause;
985 p->old_pause = dev->phydev->pause;
1084 }
1085
1086 if (ds->ops->adjust_link && status_changed)
986 }
987
988 if (ds->ops->adjust_link && status_changed)
1087 ds->ops->adjust_link(ds, p->dp->index, p->phy);
989 ds->ops->adjust_link(ds, dp->index, dev->phydev);
1088
1089 if (status_changed)
990
991 if (status_changed)
1090 phy_print_status(p->phy);
992 phy_print_status(dev->phydev);
1091}
1092
1093static int dsa_slave_fixed_link_update(struct net_device *dev,
1094 struct fixed_phy_status *status)
1095{
993}
994
995static int dsa_slave_fixed_link_update(struct net_device *dev,
996 struct fixed_phy_status *status)
997{
1096 struct dsa_slave_priv *p;
1097 struct dsa_switch *ds;
998 struct dsa_switch *ds;
999 struct dsa_port *dp;
1098
1099 if (dev) {
1000
1001 if (dev) {
1100 p = netdev_priv(dev);
1101 ds = p->dp->ds;
1002 dp = dsa_slave_to_port(dev);
1003 ds = dp->ds;
1102 if (ds->ops->fixed_link_update)
1004 if (ds->ops->fixed_link_update)
1103 ds->ops->fixed_link_update(ds, p->dp->index, status);
1005 ds->ops->fixed_link_update(ds, dp->index, status);
1104 }
1105
1106 return 0;
1107}
1108
1109/* slave device setup *******************************************************/
1006 }
1007
1008 return 0;
1009}
1010
1011/* slave device setup *******************************************************/
1110static int dsa_slave_phy_connect(struct dsa_slave_priv *p,
1111 struct net_device *slave_dev,
1112 int addr)
1012static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)
1113{
1013{
1114 struct dsa_switch *ds = p->dp->ds;
1014 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1015 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1016 struct dsa_switch *ds = dp->ds;
1115
1017
1116 p->phy = mdiobus_get_phy(ds->slave_mii_bus, addr);
1117 if (!p->phy) {
1018 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
1019 if (!slave_dev->phydev) {
1118 netdev_err(slave_dev, "no phy at %d\n", addr);
1119 return -ENODEV;
1120 }
1121
1122 /* Use already configured phy mode */
1123 if (p->phy_interface == PHY_INTERFACE_MODE_NA)
1020 netdev_err(slave_dev, "no phy at %d\n", addr);
1021 return -ENODEV;
1022 }
1023
1024 /* Use already configured phy mode */
1025 if (p->phy_interface == PHY_INTERFACE_MODE_NA)
1124 p->phy_interface = p->phy->interface;
1125 return phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
1126 p->phy_interface);
1026 p->phy_interface = slave_dev->phydev->interface;
1027
1028 return phy_connect_direct(slave_dev, slave_dev->phydev,
1029 dsa_slave_adjust_link, p->phy_interface);
1127}
1128
1030}
1031
1129static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
1130 struct net_device *slave_dev)
1032static int dsa_slave_phy_setup(struct net_device *slave_dev)
1131{
1033{
1132 struct dsa_switch *ds = p->dp->ds;
1133 struct device_node *phy_dn, *port_dn;
1034 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1035 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1036 struct device_node *port_dn = dp->dn;
1037 struct dsa_switch *ds = dp->ds;
1038 struct device_node *phy_dn;
1134 bool phy_is_fixed = false;
1135 u32 phy_flags = 0;
1136 int mode, ret;
1137
1039 bool phy_is_fixed = false;
1040 u32 phy_flags = 0;
1041 int mode, ret;
1042
1138 port_dn = p->dp->dn;
1139 mode = of_get_phy_mode(port_dn);
1140 if (mode < 0)
1141 mode = PHY_INTERFACE_MODE_NA;
1142 p->phy_interface = mode;
1143
1144 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
1145 if (!phy_dn && of_phy_is_fixed_link(port_dn)) {
1146 /* In the case of a fixed PHY, the DT node associated

--- 4 unchanged lines hidden (view full) ---

1151 netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
1152 return ret;
1153 }
1154 phy_is_fixed = true;
1155 phy_dn = of_node_get(port_dn);
1156 }
1157
1158 if (ds->ops->get_phy_flags)
1043 mode = of_get_phy_mode(port_dn);
1044 if (mode < 0)
1045 mode = PHY_INTERFACE_MODE_NA;
1046 p->phy_interface = mode;
1047
1048 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
1049 if (!phy_dn && of_phy_is_fixed_link(port_dn)) {
1050 /* In the case of a fixed PHY, the DT node associated

--- 4 unchanged lines hidden (view full) ---

1055 netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
1056 return ret;
1057 }
1058 phy_is_fixed = true;
1059 phy_dn = of_node_get(port_dn);
1060 }
1061
1062 if (ds->ops->get_phy_flags)
1159 phy_flags = ds->ops->get_phy_flags(ds, p->dp->index);
1063 phy_flags = ds->ops->get_phy_flags(ds, dp->index);
1160
1161 if (phy_dn) {
1064
1065 if (phy_dn) {
1162 int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn);
1163
1164 /* If this PHY address is part of phys_mii_mask, which means
1165 * that we need to divert reads and writes to/from it, then we
1166 * want to bind this device using the slave MII bus created by
1167 * DSA to make that happen.
1168 */
1169 if (!phy_is_fixed && phy_id >= 0 &&
1170 (ds->phys_mii_mask & (1 << phy_id))) {
1171 ret = dsa_slave_phy_connect(p, slave_dev, phy_id);
1172 if (ret) {
1173 netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret);
1174 of_node_put(phy_dn);
1175 return ret;
1176 }
1177 } else {
1178 p->phy = of_phy_connect(slave_dev, phy_dn,
1179 dsa_slave_adjust_link,
1180 phy_flags,
1181 p->phy_interface);
1182 }
1183
1066 slave_dev->phydev = of_phy_connect(slave_dev, phy_dn,
1067 dsa_slave_adjust_link,
1068 phy_flags,
1069 p->phy_interface);
1184 of_node_put(phy_dn);
1185 }
1186
1070 of_node_put(phy_dn);
1071 }
1072
1187 if (p->phy && phy_is_fixed)
1188 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);
1073 if (slave_dev->phydev && phy_is_fixed)
1074 fixed_phy_set_link_update(slave_dev->phydev,
1075 dsa_slave_fixed_link_update);
1189
1190 /* We could not connect to a designated PHY, so use the switch internal
1191 * MDIO bus instead
1192 */
1076
1077 /* We could not connect to a designated PHY, so use the switch internal
1078 * MDIO bus instead
1079 */
1193 if (!p->phy) {
1194 ret = dsa_slave_phy_connect(p, slave_dev, p->dp->index);
1080 if (!slave_dev->phydev) {
1081 ret = dsa_slave_phy_connect(slave_dev, dp->index);
1195 if (ret) {
1196 netdev_err(slave_dev, "failed to connect to port %d: %d\n",
1082 if (ret) {
1083 netdev_err(slave_dev, "failed to connect to port %d: %d\n",
1197 p->dp->index, ret);
1084 dp->index, ret);
1198 if (phy_is_fixed)
1199 of_phy_deregister_fixed_link(port_dn);
1200 return ret;
1201 }
1202 }
1203
1085 if (phy_is_fixed)
1086 of_phy_deregister_fixed_link(port_dn);
1087 return ret;
1088 }
1089 }
1090
1204 phy_attached_info(p->phy);
1091 phy_attached_info(slave_dev->phydev);
1205
1206 return 0;
1207}
1208
1209static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
1210static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
1211 struct netdev_queue *txq,
1212 void *_unused)
1213{
1214 lockdep_set_class(&txq->_xmit_lock,
1215 &dsa_slave_netdev_xmit_lock_key);
1216}
1217
1218int dsa_slave_suspend(struct net_device *slave_dev)
1219{
1220 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1221
1222 netif_device_detach(slave_dev);
1223
1092
1093 return 0;
1094}
1095
1096static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
1097static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
1098 struct netdev_queue *txq,
1099 void *_unused)
1100{
1101 lockdep_set_class(&txq->_xmit_lock,
1102 &dsa_slave_netdev_xmit_lock_key);
1103}
1104
1105int dsa_slave_suspend(struct net_device *slave_dev)
1106{
1107 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1108
1109 netif_device_detach(slave_dev);
1110
1224 if (p->phy) {
1225 phy_stop(p->phy);
1111 if (slave_dev->phydev) {
1112 phy_stop(slave_dev->phydev);
1226 p->old_pause = -1;
1227 p->old_link = -1;
1228 p->old_duplex = -1;
1113 p->old_pause = -1;
1114 p->old_link = -1;
1115 p->old_duplex = -1;
1229 phy_suspend(p->phy);
1116 phy_suspend(slave_dev->phydev);
1230 }
1231
1232 return 0;
1233}
1234
1235int dsa_slave_resume(struct net_device *slave_dev)
1236{
1117 }
1118
1119 return 0;
1120}
1121
1122int dsa_slave_resume(struct net_device *slave_dev)
1123{
1237 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1238
1239 netif_device_attach(slave_dev);
1240
1124 netif_device_attach(slave_dev);
1125
1241 if (p->phy) {
1242 phy_resume(p->phy);
1243 phy_start(p->phy);
1126 if (slave_dev->phydev) {
1127 phy_resume(slave_dev->phydev);
1128 phy_start(slave_dev->phydev);
1244 }
1245
1246 return 0;
1247}
1248
1129 }
1130
1131 return 0;
1132}
1133
1249int dsa_slave_create(struct dsa_port *port, const char *name)
1134static void dsa_slave_notify(struct net_device *dev, unsigned long val)
1250{
1135{
1136 struct net_device *master = dsa_slave_to_master(dev);
1137 struct dsa_port *dp = dsa_slave_to_port(dev);
1138 struct dsa_notifier_register_info rinfo = {
1139 .switch_number = dp->ds->index,
1140 .port_number = dp->index,
1141 .master = master,
1142 .info.dev = dev,
1143 };
1144
1145 call_dsa_notifiers(val, dev, &rinfo.info);
1146}
1147
1148int dsa_slave_create(struct dsa_port *port)
1149{
1150 struct dsa_port *cpu_dp = port->cpu_dp;
1151 struct net_device *master = cpu_dp->master;
1251 struct dsa_switch *ds = port->ds;
1152 struct dsa_switch *ds = port->ds;
1252 struct dsa_switch_tree *dst = ds->dst;
1253 struct net_device *master;
1153 const char *name = port->name;
1254 struct net_device *slave_dev;
1255 struct dsa_slave_priv *p;
1154 struct net_device *slave_dev;
1155 struct dsa_slave_priv *p;
1256 struct dsa_port *cpu_dp;
1257 int ret;
1258
1156 int ret;
1157
1259 cpu_dp = ds->dst->cpu_dp;
1260 master = cpu_dp->netdev;
1261
1262 if (!ds->num_tx_queues)
1263 ds->num_tx_queues = 1;
1264
1265 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1266 NET_NAME_UNKNOWN, ether_setup,
1267 ds->num_tx_queues, 1);
1268 if (slave_dev == NULL)
1269 return -ENOMEM;

--- 19 unchanged lines hidden (view full) ---

1289 p = netdev_priv(slave_dev);
1290 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1291 if (!p->stats64) {
1292 free_netdev(slave_dev);
1293 return -ENOMEM;
1294 }
1295 p->dp = port;
1296 INIT_LIST_HEAD(&p->mall_tc_list);
1158 if (!ds->num_tx_queues)
1159 ds->num_tx_queues = 1;
1160
1161 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1162 NET_NAME_UNKNOWN, ether_setup,
1163 ds->num_tx_queues, 1);
1164 if (slave_dev == NULL)
1165 return -ENOMEM;

--- 19 unchanged lines hidden (view full) ---

1185 p = netdev_priv(slave_dev);
1186 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1187 if (!p->stats64) {
1188 free_netdev(slave_dev);
1189 return -ENOMEM;
1190 }
1191 p->dp = port;
1192 INIT_LIST_HEAD(&p->mall_tc_list);
1297 p->xmit = dst->tag_ops->xmit;
1193 p->xmit = cpu_dp->tag_ops->xmit;
1298
1299 p->old_pause = -1;
1300 p->old_link = -1;
1301 p->old_duplex = -1;
1302
1194
1195 p->old_pause = -1;
1196 p->old_link = -1;
1197 p->old_duplex = -1;
1198
1303 port->netdev = slave_dev;
1199 port->slave = slave_dev;
1304
1305 netif_carrier_off(slave_dev);
1306
1200
1201 netif_carrier_off(slave_dev);
1202
1307 ret = dsa_slave_phy_setup(p, slave_dev);
1203 ret = dsa_slave_phy_setup(slave_dev);
1308 if (ret) {
1309 netdev_err(master, "error %d setting up slave phy\n", ret);
1310 goto out_free;
1311 }
1312
1204 if (ret) {
1205 netdev_err(master, "error %d setting up slave phy\n", ret);
1206 goto out_free;
1207 }
1208
1209 dsa_slave_notify(slave_dev, DSA_PORT_REGISTER);
1210
1313 ret = register_netdev(slave_dev);
1314 if (ret) {
1315 netdev_err(master, "error %d registering interface %s\n",
1316 ret, slave_dev->name);
1317 goto out_phy;
1318 }
1319
1320 return 0;
1321
1322out_phy:
1211 ret = register_netdev(slave_dev);
1212 if (ret) {
1213 netdev_err(master, "error %d registering interface %s\n",
1214 ret, slave_dev->name);
1215 goto out_phy;
1216 }
1217
1218 return 0;
1219
1220out_phy:
1323 phy_disconnect(p->phy);
1324 if (of_phy_is_fixed_link(p->dp->dn))
1325 of_phy_deregister_fixed_link(p->dp->dn);
1221 phy_disconnect(slave_dev->phydev);
1222 if (of_phy_is_fixed_link(port->dn))
1223 of_phy_deregister_fixed_link(port->dn);
1326out_free:
1327 free_percpu(p->stats64);
1328 free_netdev(slave_dev);
1224out_free:
1225 free_percpu(p->stats64);
1226 free_netdev(slave_dev);
1329 port->netdev = NULL;
1227 port->slave = NULL;
1330 return ret;
1331}
1332
1333void dsa_slave_destroy(struct net_device *slave_dev)
1334{
1228 return ret;
1229}
1230
1231void dsa_slave_destroy(struct net_device *slave_dev)
1232{
1233 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1335 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1234 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1336 struct device_node *port_dn;
1235 struct device_node *port_dn = dp->dn;
1337
1236
1338 port_dn = p->dp->dn;
1339
1340 netif_carrier_off(slave_dev);
1237 netif_carrier_off(slave_dev);
1341 if (p->phy) {
1342 phy_disconnect(p->phy);
1238 if (slave_dev->phydev) {
1239 phy_disconnect(slave_dev->phydev);
1343
1344 if (of_phy_is_fixed_link(port_dn))
1345 of_phy_deregister_fixed_link(port_dn);
1346 }
1240
1241 if (of_phy_is_fixed_link(port_dn))
1242 of_phy_deregister_fixed_link(port_dn);
1243 }
1244 dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
1347 unregister_netdev(slave_dev);
1348 free_percpu(p->stats64);
1349 free_netdev(slave_dev);
1350}
1351
1352static bool dsa_slave_dev_check(struct net_device *dev)
1353{
1354 return dev->netdev_ops == &dsa_slave_netdev_ops;
1355}
1356
1357static int dsa_slave_changeupper(struct net_device *dev,
1358 struct netdev_notifier_changeupper_info *info)
1359{
1245 unregister_netdev(slave_dev);
1246 free_percpu(p->stats64);
1247 free_netdev(slave_dev);
1248}
1249
1250static bool dsa_slave_dev_check(struct net_device *dev)
1251{
1252 return dev->netdev_ops == &dsa_slave_netdev_ops;
1253}
1254
1255static int dsa_slave_changeupper(struct net_device *dev,
1256 struct netdev_notifier_changeupper_info *info)
1257{
1360 struct dsa_slave_priv *p = netdev_priv(dev);
1361 struct dsa_port *dp = p->dp;
1258 struct dsa_port *dp = dsa_slave_to_port(dev);
1362 int err = NOTIFY_DONE;
1363
1364 if (netif_is_bridge_master(info->upper_dev)) {
1365 if (info->linking) {
1366 err = dsa_port_bridge_join(dp, info->upper_dev);
1367 err = notifier_from_errno(err);
1368 } else {
1369 dsa_port_bridge_leave(dp, info->upper_dev);

--- 4 unchanged lines hidden (view full) ---

1374 return err;
1375}
1376
1377static int dsa_slave_netdevice_event(struct notifier_block *nb,
1378 unsigned long event, void *ptr)
1379{
1380 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1381
1259 int err = NOTIFY_DONE;
1260
1261 if (netif_is_bridge_master(info->upper_dev)) {
1262 if (info->linking) {
1263 err = dsa_port_bridge_join(dp, info->upper_dev);
1264 err = notifier_from_errno(err);
1265 } else {
1266 dsa_port_bridge_leave(dp, info->upper_dev);

--- 4 unchanged lines hidden (view full) ---

1271 return err;
1272}
1273
1274static int dsa_slave_netdevice_event(struct notifier_block *nb,
1275 unsigned long event, void *ptr)
1276{
1277 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1278
1382 if (dev->netdev_ops != &dsa_slave_netdev_ops)
1279 if (!dsa_slave_dev_check(dev))
1383 return NOTIFY_DONE;
1384
1385 if (event == NETDEV_CHANGEUPPER)
1386 return dsa_slave_changeupper(dev, ptr);
1387
1388 return NOTIFY_DONE;
1389}
1390

--- 5 unchanged lines hidden (view full) ---

1396};
1397
1398static void dsa_slave_switchdev_event_work(struct work_struct *work)
1399{
1400 struct dsa_switchdev_event_work *switchdev_work =
1401 container_of(work, struct dsa_switchdev_event_work, work);
1402 struct net_device *dev = switchdev_work->dev;
1403 struct switchdev_notifier_fdb_info *fdb_info;
1280 return NOTIFY_DONE;
1281
1282 if (event == NETDEV_CHANGEUPPER)
1283 return dsa_slave_changeupper(dev, ptr);
1284
1285 return NOTIFY_DONE;
1286}
1287

--- 5 unchanged lines hidden (view full) ---

1293};
1294
1295static void dsa_slave_switchdev_event_work(struct work_struct *work)
1296{
1297 struct dsa_switchdev_event_work *switchdev_work =
1298 container_of(work, struct dsa_switchdev_event_work, work);
1299 struct net_device *dev = switchdev_work->dev;
1300 struct switchdev_notifier_fdb_info *fdb_info;
1404 struct dsa_slave_priv *p = netdev_priv(dev);
1301 struct dsa_port *dp = dsa_slave_to_port(dev);
1405 int err;
1406
1407 rtnl_lock();
1408 switch (switchdev_work->event) {
1409 case SWITCHDEV_FDB_ADD_TO_DEVICE:
1410 fdb_info = &switchdev_work->fdb_info;
1302 int err;
1303
1304 rtnl_lock();
1305 switch (switchdev_work->event) {
1306 case SWITCHDEV_FDB_ADD_TO_DEVICE:
1307 fdb_info = &switchdev_work->fdb_info;
1411 err = dsa_port_fdb_add(p->dp, fdb_info->addr, fdb_info->vid);
1308 err = dsa_port_fdb_add(dp, fdb_info->addr, fdb_info->vid);
1412 if (err) {
1413 netdev_dbg(dev, "fdb add failed err=%d\n", err);
1414 break;
1415 }
1416 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
1417 &fdb_info->info);
1418 break;
1419
1420 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1421 fdb_info = &switchdev_work->fdb_info;
1309 if (err) {
1310 netdev_dbg(dev, "fdb add failed err=%d\n", err);
1311 break;
1312 }
1313 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
1314 &fdb_info->info);
1315 break;
1316
1317 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1318 fdb_info = &switchdev_work->fdb_info;
1422 err = dsa_port_fdb_del(p->dp, fdb_info->addr, fdb_info->vid);
1319 err = dsa_port_fdb_del(dp, fdb_info->addr, fdb_info->vid);
1423 if (err) {
1424 netdev_dbg(dev, "fdb del failed err=%d\n", err);
1425 dev_close(dev);
1426 }
1427 break;
1428 }
1429 rtnl_unlock();
1430

--- 100 unchanged lines hidden --- 		1320 if (err) {
1321 netdev_dbg(dev, "fdb del failed err=%d\n", err);
1322 dev_close(dev);
1323 }
1324 break;
1325 }
1326 rtnl_unlock();
1327

--- 100 unchanged lines hidden ---