slave.c 29.8 KB
Newer Older
1 2
/*
 * net/dsa/slave.c - Slave device handling
3
 * Copyright (c) 2008-2009 Marvell Semiconductor
4 5 6 7 8 9 10 11
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#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 17
#include <linux/of_net.h>
#include <linux/of_mdio.h>
18
#include <linux/mdio.h>
19
#include <net/rtnetlink.h>
S
Scott Feldman 已提交
20
#include <net/switchdev.h>
21
#include <linux/if_bridge.h>
22
#include <linux/netpoll.h>
23 24 25 26 27 28 29
#include "dsa_priv.h"

/* slave mii_bus handling ***************************************************/
static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
{
	struct dsa_switch *ds = bus->priv;

30
	if (ds->phys_mii_mask & (1 << addr))
31 32 33 34 35 36 37 38 39
		return ds->drv->phy_read(ds, addr, reg);

	return 0xffff;
}

static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
{
	struct dsa_switch *ds = bus->priv;

40
	if (ds->phys_mii_mask & (1 << addr))
41 42 43 44 45 46 47 48 49 50 51
		return ds->drv->phy_write(ds, addr, reg, val);

	return 0;
}

void dsa_slave_mii_bus_init(struct dsa_switch *ds)
{
	ds->slave_mii_bus->priv = (void *)ds;
	ds->slave_mii_bus->name = "dsa slave smi";
	ds->slave_mii_bus->read = dsa_slave_phy_read;
	ds->slave_mii_bus->write = dsa_slave_phy_write;
52
	snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d", ds->index);
53
	ds->slave_mii_bus->parent = ds->dev;
54
	ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
55 56 57 58
}


/* slave device handling ****************************************************/
N
Nicolas Dichtel 已提交
59
static int dsa_slave_get_iflink(const struct net_device *dev)
60 61 62
{
	struct dsa_slave_priv *p = netdev_priv(dev);

N
Nicolas Dichtel 已提交
63
	return p->parent->dst->master_netdev->ifindex;
64 65
}

66 67 68 69 70
static inline bool dsa_port_is_bridged(struct dsa_slave_priv *p)
{
	return !!p->bridge_dev;
}

71 72
static int dsa_slave_open(struct net_device *dev)
{
73
	struct dsa_slave_priv *p = netdev_priv(dev);
74
	struct net_device *master = p->parent->dst->master_netdev;
75
	struct dsa_switch *ds = p->parent;
76 77
	u8 stp_state = dsa_port_is_bridged(p) ?
			BR_STATE_BLOCKING : BR_STATE_FORWARDING;
78 79 80 81 82
	int err;

	if (!(master->flags & IFF_UP))
		return -ENETDOWN;

83
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
84
		err = dev_uc_add(master, dev->dev_addr);
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
		if (err < 0)
			goto out;
	}

	if (dev->flags & IFF_ALLMULTI) {
		err = dev_set_allmulti(master, 1);
		if (err < 0)
			goto del_unicast;
	}
	if (dev->flags & IFF_PROMISC) {
		err = dev_set_promiscuity(master, 1);
		if (err < 0)
			goto clear_allmulti;
	}

100 101 102 103 104 105
	if (ds->drv->port_enable) {
		err = ds->drv->port_enable(ds, p->port, p->phy);
		if (err)
			goto clear_promisc;
	}

106 107
	if (ds->drv->port_stp_state_set)
		ds->drv->port_stp_state_set(ds, p->port, stp_state);
108

109 110 111
	if (p->phy)
		phy_start(p->phy);

112
	return 0;
113

114 115
clear_promisc:
	if (dev->flags & IFF_PROMISC)
116
		dev_set_promiscuity(master, -1);
117 118 119 120
clear_allmulti:
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(master, -1);
del_unicast:
121
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
122
		dev_uc_del(master, dev->dev_addr);
123 124
out:
	return err;
125 126 127 128
}

static int dsa_slave_close(struct net_device *dev)
{
129
	struct dsa_slave_priv *p = netdev_priv(dev);
130
	struct net_device *master = p->parent->dst->master_netdev;
131
	struct dsa_switch *ds = p->parent;
132

133 134 135
	if (p->phy)
		phy_stop(p->phy);

136
	dev_mc_unsync(master, dev);
137
	dev_uc_unsync(master, dev);
138 139 140 141 142
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(master, -1);
	if (dev->flags & IFF_PROMISC)
		dev_set_promiscuity(master, -1);

143
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
144
		dev_uc_del(master, dev->dev_addr);
145

146 147 148
	if (ds->drv->port_disable)
		ds->drv->port_disable(ds, p->port, p->phy);

149 150
	if (ds->drv->port_stp_state_set)
		ds->drv->port_stp_state_set(ds, p->port, BR_STATE_DISABLED);
151

152 153 154 155 156 157
	return 0;
}

static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
158
	struct net_device *master = p->parent->dst->master_netdev;
159 160 161 162 163 164 165 166 167 168

	if (change & IFF_ALLMULTI)
		dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
	if (change & IFF_PROMISC)
		dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
}

static void dsa_slave_set_rx_mode(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
169
	struct net_device *master = p->parent->dst->master_netdev;
170 171

	dev_mc_sync(master, dev);
172
	dev_uc_sync(master, dev);
173 174
}

175
static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
176
{
177
	struct dsa_slave_priv *p = netdev_priv(dev);
178
	struct net_device *master = p->parent->dst->master_netdev;
179 180 181 182 183 184 185 186 187
	struct sockaddr *addr = a;
	int err;

	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

	if (!(dev->flags & IFF_UP))
		goto out;

188
	if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
189
		err = dev_uc_add(master, addr->sa_data);
190 191 192 193
		if (err < 0)
			return err;
	}

194
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
195
		dev_uc_del(master, dev->dev_addr);
196 197

out:
J
Joe Perches 已提交
198
	ether_addr_copy(dev->dev_addr, addr->sa_data);
199 200 201 202

	return 0;
}

203
static int dsa_slave_port_vlan_add(struct net_device *dev,
204
				   const struct switchdev_obj_port_vlan *vlan,
205
				   struct switchdev_trans *trans)
206 207 208 209
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

210
	if (switchdev_trans_ph_prepare(trans)) {
211
		if (!ds->drv->port_vlan_prepare || !ds->drv->port_vlan_add)
212 213
			return -EOPNOTSUPP;

214
		return ds->drv->port_vlan_prepare(ds, p->port, vlan, trans);
215 216
	}

217 218
	ds->drv->port_vlan_add(ds, p->port, vlan, trans);

219 220 221 222
	return 0;
}

static int dsa_slave_port_vlan_del(struct net_device *dev,
223
				   const struct switchdev_obj_port_vlan *vlan)
224 225 226 227 228 229 230
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (!ds->drv->port_vlan_del)
		return -EOPNOTSUPP;

231
	return ds->drv->port_vlan_del(ds, p->port, vlan);
232 233 234
}

static int dsa_slave_port_vlan_dump(struct net_device *dev,
235
				    struct switchdev_obj_port_vlan *vlan,
236
				    switchdev_obj_dump_cb_t *cb)
237 238 239 240
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

241 242 243
	if (ds->drv->port_vlan_dump)
		return ds->drv->port_vlan_dump(ds, p->port, vlan, cb);

V
Vivien Didelot 已提交
244
	return -EOPNOTSUPP;
245 246
}

247
static int dsa_slave_port_fdb_add(struct net_device *dev,
248
				  const struct switchdev_obj_port_fdb *fdb,
249
				  struct switchdev_trans *trans)
250 251 252
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
V
Vivien Didelot 已提交
253

254 255 256
	if (switchdev_trans_ph_prepare(trans)) {
		if (!ds->drv->port_fdb_prepare || !ds->drv->port_fdb_add)
			return -EOPNOTSUPP;
257

258 259 260 261
		return ds->drv->port_fdb_prepare(ds, p->port, fdb, trans);
	}

	ds->drv->port_fdb_add(ds, p->port, fdb, trans);
262

263
	return 0;
264 265
}

266
static int dsa_slave_port_fdb_del(struct net_device *dev,
267
				  const struct switchdev_obj_port_fdb *fdb)
268 269 270 271 272
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
	int ret = -EOPNOTSUPP;

273
	if (ds->drv->port_fdb_del)
274
		ret = ds->drv->port_fdb_del(ds, p->port, fdb);
275 276 277 278

	return ret;
}

279
static int dsa_slave_port_fdb_dump(struct net_device *dev,
280
				   struct switchdev_obj_port_fdb *fdb,
281
				   switchdev_obj_dump_cb_t *cb)
282 283 284 285
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

286 287 288
	if (ds->drv->port_fdb_dump)
		return ds->drv->port_fdb_dump(ds, p->port, fdb, cb);

V
Vivien Didelot 已提交
289
	return -EOPNOTSUPP;
290 291
}

292 293 294 295 296
static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
	struct dsa_slave_priv *p = netdev_priv(dev);

	if (p->phy != NULL)
297
		return phy_mii_ioctl(p->phy, ifr, cmd);
298 299 300 301

	return -EOPNOTSUPP;
}

302 303 304
static int dsa_slave_stp_state_set(struct net_device *dev,
				   const struct switchdev_attr *attr,
				   struct switchdev_trans *trans)
305 306 307 308
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

309 310
	if (switchdev_trans_ph_prepare(trans))
		return ds->drv->port_stp_state_set ? 0 : -EOPNOTSUPP;
311

312 313 314
	ds->drv->port_stp_state_set(ds, p->port, attr->u.stp_state);

	return 0;
315 316
}

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
static int dsa_slave_vlan_filtering(struct net_device *dev,
				    const struct switchdev_attr *attr,
				    struct switchdev_trans *trans)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	/* bridge skips -EOPNOTSUPP, so skip the prepare phase */
	if (switchdev_trans_ph_prepare(trans))
		return 0;

	if (ds->drv->port_vlan_filtering)
		return ds->drv->port_vlan_filtering(ds, p->port,
						    attr->u.vlan_filtering);

	return 0;
}

335
static int dsa_slave_port_attr_set(struct net_device *dev,
336
				   const struct switchdev_attr *attr,
337
				   struct switchdev_trans *trans)
338
{
339
	int ret;
340 341

	switch (attr->id) {
342
	case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
343
		ret = dsa_slave_stp_state_set(dev, attr, trans);
344
		break;
345 346 347
	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
		ret = dsa_slave_vlan_filtering(dev, attr, trans);
		break;
348 349 350 351 352 353 354 355
	default:
		ret = -EOPNOTSUPP;
		break;
	}

	return ret;
}

356
static int dsa_slave_port_obj_add(struct net_device *dev,
357
				  const struct switchdev_obj *obj,
358
				  struct switchdev_trans *trans)
359 360 361 362 363 364 365 366
{
	int err;

	/* For the prepare phase, ensure the full set of changes is feasable in
	 * one go in order to signal a failure properly. If an operation is not
	 * supported, return -EOPNOTSUPP.
	 */

367
	switch (obj->id) {
368
	case SWITCHDEV_OBJ_ID_PORT_FDB:
369 370 371
		err = dsa_slave_port_fdb_add(dev,
					     SWITCHDEV_OBJ_PORT_FDB(obj),
					     trans);
372
		break;
373
	case SWITCHDEV_OBJ_ID_PORT_VLAN:
374 375 376
		err = dsa_slave_port_vlan_add(dev,
					      SWITCHDEV_OBJ_PORT_VLAN(obj),
					      trans);
377
		break;
378 379 380 381 382 383 384 385 386
	default:
		err = -EOPNOTSUPP;
		break;
	}

	return err;
}

static int dsa_slave_port_obj_del(struct net_device *dev,
387
				  const struct switchdev_obj *obj)
388 389 390
{
	int err;

391
	switch (obj->id) {
392
	case SWITCHDEV_OBJ_ID_PORT_FDB:
393 394
		err = dsa_slave_port_fdb_del(dev,
					     SWITCHDEV_OBJ_PORT_FDB(obj));
395
		break;
396
	case SWITCHDEV_OBJ_ID_PORT_VLAN:
397 398
		err = dsa_slave_port_vlan_del(dev,
					      SWITCHDEV_OBJ_PORT_VLAN(obj));
399
		break;
400 401 402 403 404 405 406 407 408
	default:
		err = -EOPNOTSUPP;
		break;
	}

	return err;
}

static int dsa_slave_port_obj_dump(struct net_device *dev,
409 410
				   struct switchdev_obj *obj,
				   switchdev_obj_dump_cb_t *cb)
411 412 413
{
	int err;

414
	switch (obj->id) {
415
	case SWITCHDEV_OBJ_ID_PORT_FDB:
416 417 418
		err = dsa_slave_port_fdb_dump(dev,
					      SWITCHDEV_OBJ_PORT_FDB(obj),
					      cb);
419
		break;
420
	case SWITCHDEV_OBJ_ID_PORT_VLAN:
421 422 423
		err = dsa_slave_port_vlan_dump(dev,
					       SWITCHDEV_OBJ_PORT_VLAN(obj),
					       cb);
424
		break;
425 426 427 428 429 430 431 432
	default:
		err = -EOPNOTSUPP;
		break;
	}

	return err;
}

433 434 435 436 437 438 439 440 441
static int dsa_slave_bridge_port_join(struct net_device *dev,
				      struct net_device *br)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
	int ret = -EOPNOTSUPP;

	p->bridge_dev = br;

442 443
	if (ds->drv->port_bridge_join)
		ret = ds->drv->port_bridge_join(ds, p->port, br);
444

445
	return ret == -EOPNOTSUPP ? 0 : ret;
446 447
}

448
static void dsa_slave_bridge_port_leave(struct net_device *dev)
449 450 451 452 453
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;


454
	if (ds->drv->port_bridge_leave)
455
		ds->drv->port_bridge_leave(ds, p->port);
456 457 458 459 460 461

	p->bridge_dev = NULL;

	/* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
	 * so allow it to be in BR_STATE_FORWARDING to be kept functional
	 */
462 463
	if (ds->drv->port_stp_state_set)
		ds->drv->port_stp_state_set(ds, p->port, BR_STATE_FORWARDING);
464 465
}

466 467
static int dsa_slave_port_attr_get(struct net_device *dev,
				   struct switchdev_attr *attr)
468 469 470 471
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

472
	switch (attr->id) {
473
	case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
474 475
		attr->u.ppid.id_len = sizeof(ds->index);
		memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
476 477 478 479
		break;
	default:
		return -EOPNOTSUPP;
	}
480 481 482 483

	return 0;
}

484 485 486 487 488 489 490 491 492 493 494 495
static inline netdev_tx_t dsa_netpoll_send_skb(struct dsa_slave_priv *p,
					       struct sk_buff *skb)
{
#ifdef CONFIG_NET_POLL_CONTROLLER
	if (p->netpoll)
		netpoll_send_skb(p->netpoll, skb);
#else
	BUG();
#endif
	return NETDEV_TX_OK;
}

496 497 498
static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
499
	struct sk_buff *nskb;
500

501 502
	dev->stats.tx_packets++;
	dev->stats.tx_bytes += skb->len;
503

504 505 506 507
	/* Transmit function may have to reallocate the original SKB */
	nskb = p->xmit(skb, dev);
	if (!nskb)
		return NETDEV_TX_OK;
508

509 510 511 512 513 514
	/* SKB for netpoll still need to be mangled with the protocol-specific
	 * tag to be successfully transmitted
	 */
	if (unlikely(netpoll_tx_running(dev)))
		return dsa_netpoll_send_skb(p, nskb);

515 516 517 518 519
	/* Queue the SKB for transmission on the parent interface, but
	 * do not modify its EtherType
	 */
	nskb->dev = p->parent->dst->master_netdev;
	dev_queue_xmit(nskb);
520 521 522 523

	return NETDEV_TX_OK;
}

524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
/* ethtool operations *******************************************************/
static int
dsa_slave_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	int err;

	err = -EOPNOTSUPP;
	if (p->phy != NULL) {
		err = phy_read_status(p->phy);
		if (err == 0)
			err = phy_ethtool_gset(p->phy, cmd);
	}

	return err;
}

static int
dsa_slave_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct dsa_slave_priv *p = netdev_priv(dev);

	if (p->phy != NULL)
		return phy_ethtool_sset(p->phy, cmd);

	return -EOPNOTSUPP;
}

static void dsa_slave_get_drvinfo(struct net_device *dev,
				  struct ethtool_drvinfo *drvinfo)
{
555 556 557 558
	strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
	strlcpy(drvinfo->version, dsa_driver_version, sizeof(drvinfo->version));
	strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
	strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
559 560
}

561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
static int dsa_slave_get_regs_len(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (ds->drv->get_regs_len)
		return ds->drv->get_regs_len(ds, p->port);

	return -EOPNOTSUPP;
}

static void
dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (ds->drv->get_regs)
		ds->drv->get_regs(ds, p->port, regs, _p);
}

582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
static int dsa_slave_nway_reset(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);

	if (p->phy != NULL)
		return genphy_restart_aneg(p->phy);

	return -EOPNOTSUPP;
}

static u32 dsa_slave_get_link(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);

	if (p->phy != NULL) {
		genphy_update_link(p->phy);
		return p->phy->link;
	}

	return -EOPNOTSUPP;
}

604 605 606 607 608
static int dsa_slave_get_eeprom_len(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

609
	if (ds->cd && ds->cd->eeprom_len)
A
Andrew Lunn 已提交
610
		return ds->cd->eeprom_len;
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641

	if (ds->drv->get_eeprom_len)
		return ds->drv->get_eeprom_len(ds);

	return 0;
}

static int dsa_slave_get_eeprom(struct net_device *dev,
				struct ethtool_eeprom *eeprom, u8 *data)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (ds->drv->get_eeprom)
		return ds->drv->get_eeprom(ds, eeprom, data);

	return -EOPNOTSUPP;
}

static int dsa_slave_set_eeprom(struct net_device *dev,
				struct ethtool_eeprom *eeprom, u8 *data)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (ds->drv->set_eeprom)
		return ds->drv->set_eeprom(ds, eeprom, data);

	return -EOPNOTSUPP;
}

642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
static void dsa_slave_get_strings(struct net_device *dev,
				  uint32_t stringset, uint8_t *data)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (stringset == ETH_SS_STATS) {
		int len = ETH_GSTRING_LEN;

		strncpy(data, "tx_packets", len);
		strncpy(data + len, "tx_bytes", len);
		strncpy(data + 2 * len, "rx_packets", len);
		strncpy(data + 3 * len, "rx_bytes", len);
		if (ds->drv->get_strings != NULL)
			ds->drv->get_strings(ds, p->port, data + 4 * len);
	}
}

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
static void dsa_cpu_port_get_ethtool_stats(struct net_device *dev,
					   struct ethtool_stats *stats,
					   uint64_t *data)
{
	struct dsa_switch_tree *dst = dev->dsa_ptr;
	struct dsa_switch *ds = dst->ds[0];
	s8 cpu_port = dst->cpu_port;
	int count = 0;

	if (dst->master_ethtool_ops.get_sset_count) {
		count = dst->master_ethtool_ops.get_sset_count(dev,
							       ETH_SS_STATS);
		dst->master_ethtool_ops.get_ethtool_stats(dev, stats, data);
	}

	if (ds->drv->get_ethtool_stats)
		ds->drv->get_ethtool_stats(ds, cpu_port, data + count);
}

static int dsa_cpu_port_get_sset_count(struct net_device *dev, int sset)
{
	struct dsa_switch_tree *dst = dev->dsa_ptr;
	struct dsa_switch *ds = dst->ds[0];
	int count = 0;

	if (dst->master_ethtool_ops.get_sset_count)
		count += dst->master_ethtool_ops.get_sset_count(dev, sset);

	if (sset == ETH_SS_STATS && ds->drv->get_sset_count)
		count += ds->drv->get_sset_count(ds);

	return count;
}

static void dsa_cpu_port_get_strings(struct net_device *dev,
				     uint32_t stringset, uint8_t *data)
{
	struct dsa_switch_tree *dst = dev->dsa_ptr;
	struct dsa_switch *ds = dst->ds[0];
	s8 cpu_port = dst->cpu_port;
	int len = ETH_GSTRING_LEN;
	int mcount = 0, count;
	unsigned int i;
	uint8_t pfx[4];
	uint8_t *ndata;

	snprintf(pfx, sizeof(pfx), "p%.2d", cpu_port);
	/* We do not want to be NULL-terminated, since this is a prefix */
	pfx[sizeof(pfx) - 1] = '_';

	if (dst->master_ethtool_ops.get_sset_count) {
		mcount = dst->master_ethtool_ops.get_sset_count(dev,
								ETH_SS_STATS);
		dst->master_ethtool_ops.get_strings(dev, stringset, data);
	}

	if (stringset == ETH_SS_STATS && ds->drv->get_strings) {
		ndata = data + mcount * len;
		/* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
		 * the output after to prepend our CPU port prefix we
		 * constructed earlier
		 */
		ds->drv->get_strings(ds, cpu_port, ndata);
		count = ds->drv->get_sset_count(ds);
		for (i = 0; i < count; i++) {
			memmove(ndata + (i * len + sizeof(pfx)),
				ndata + i * len, len - sizeof(pfx));
			memcpy(ndata + i * len, pfx, sizeof(pfx));
		}
	}
}

732 733 734 735 736 737 738
static void dsa_slave_get_ethtool_stats(struct net_device *dev,
					struct ethtool_stats *stats,
					uint64_t *data)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

739 740 741 742
	data[0] = dev->stats.tx_packets;
	data[1] = dev->stats.tx_bytes;
	data[2] = dev->stats.rx_packets;
	data[3] = dev->stats.rx_bytes;
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
	if (ds->drv->get_ethtool_stats != NULL)
		ds->drv->get_ethtool_stats(ds, p->port, data + 4);
}

static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (sset == ETH_SS_STATS) {
		int count;

		count = 4;
		if (ds->drv->get_sset_count != NULL)
			count += ds->drv->get_sset_count(ds);

		return count;
	}

	return -EOPNOTSUPP;
}

765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (ds->drv->get_wol)
		ds->drv->get_wol(ds, p->port, w);
}

static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
	int ret = -EOPNOTSUPP;

	if (ds->drv->set_wol)
		ret = ds->drv->set_wol(ds, p->port, w);

	return ret;
}

786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
	int ret;

	if (!ds->drv->set_eee)
		return -EOPNOTSUPP;

	ret = ds->drv->set_eee(ds, p->port, p->phy, e);
	if (ret)
		return ret;

	if (p->phy)
		ret = phy_ethtool_set_eee(p->phy, e);

	return ret;
}

static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
	int ret;

	if (!ds->drv->get_eee)
		return -EOPNOTSUPP;

	ret = ds->drv->get_eee(ds, p->port, e);
	if (ret)
		return ret;

	if (p->phy)
		ret = phy_ethtool_get_eee(p->phy, e);

	return ret;
}

824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
#ifdef CONFIG_NET_POLL_CONTROLLER
static int dsa_slave_netpoll_setup(struct net_device *dev,
				   struct netpoll_info *ni)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;
	struct net_device *master = ds->dst->master_netdev;
	struct netpoll *netpoll;
	int err = 0;

	netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
	if (!netpoll)
		return -ENOMEM;

	err = __netpoll_setup(netpoll, master);
	if (err) {
		kfree(netpoll);
		goto out;
	}

	p->netpoll = netpoll;
out:
	return err;
}

static void dsa_slave_netpoll_cleanup(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct netpoll *netpoll = p->netpoll;

	if (!netpoll)
		return;

	p->netpoll = NULL;

	__netpoll_free_async(netpoll);
}

static void dsa_slave_poll_controller(struct net_device *dev)
{
}
#endif

867 868 869 870
static const struct ethtool_ops dsa_slave_ethtool_ops = {
	.get_settings		= dsa_slave_get_settings,
	.set_settings		= dsa_slave_set_settings,
	.get_drvinfo		= dsa_slave_get_drvinfo,
871 872
	.get_regs_len		= dsa_slave_get_regs_len,
	.get_regs		= dsa_slave_get_regs,
873 874
	.nway_reset		= dsa_slave_nway_reset,
	.get_link		= dsa_slave_get_link,
875 876 877
	.get_eeprom_len		= dsa_slave_get_eeprom_len,
	.get_eeprom		= dsa_slave_get_eeprom,
	.set_eeprom		= dsa_slave_set_eeprom,
878 879 880
	.get_strings		= dsa_slave_get_strings,
	.get_ethtool_stats	= dsa_slave_get_ethtool_stats,
	.get_sset_count		= dsa_slave_get_sset_count,
881 882
	.set_wol		= dsa_slave_set_wol,
	.get_wol		= dsa_slave_get_wol,
883 884
	.set_eee		= dsa_slave_set_eee,
	.get_eee		= dsa_slave_get_eee,
885 886
};

887 888
static struct ethtool_ops dsa_cpu_port_ethtool_ops;

889
static const struct net_device_ops dsa_slave_netdev_ops = {
890 891
	.ndo_open	 	= dsa_slave_open,
	.ndo_stop		= dsa_slave_close,
892
	.ndo_start_xmit		= dsa_slave_xmit,
893 894 895
	.ndo_change_rx_flags	= dsa_slave_change_rx_flags,
	.ndo_set_rx_mode	= dsa_slave_set_rx_mode,
	.ndo_set_mac_address	= dsa_slave_set_mac_address,
896 897 898
	.ndo_fdb_add		= switchdev_port_fdb_add,
	.ndo_fdb_del		= switchdev_port_fdb_del,
	.ndo_fdb_dump		= switchdev_port_fdb_dump,
899
	.ndo_do_ioctl		= dsa_slave_ioctl,
N
Nicolas Dichtel 已提交
900
	.ndo_get_iflink		= dsa_slave_get_iflink,
901 902 903 904 905
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_netpoll_setup	= dsa_slave_netpoll_setup,
	.ndo_netpoll_cleanup	= dsa_slave_netpoll_cleanup,
	.ndo_poll_controller	= dsa_slave_poll_controller,
#endif
906 907 908
	.ndo_bridge_getlink	= switchdev_port_bridge_getlink,
	.ndo_bridge_setlink	= switchdev_port_bridge_setlink,
	.ndo_bridge_dellink	= switchdev_port_bridge_dellink,
S
Scott Feldman 已提交
909 910
};

J
Jiri Pirko 已提交
911
static const struct switchdev_ops dsa_slave_switchdev_ops = {
912
	.switchdev_port_attr_get	= dsa_slave_port_attr_get,
913
	.switchdev_port_attr_set	= dsa_slave_port_attr_set,
914 915 916
	.switchdev_port_obj_add		= dsa_slave_port_obj_add,
	.switchdev_port_obj_del		= dsa_slave_port_obj_del,
	.switchdev_port_obj_dump	= dsa_slave_port_obj_dump,
917
};
918

919 920 921 922
static struct device_type dsa_type = {
	.name	= "dsa",
};

923 924 925
static void dsa_slave_adjust_link(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
926
	struct dsa_switch *ds = p->parent;
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
	unsigned int status_changed = 0;

	if (p->old_link != p->phy->link) {
		status_changed = 1;
		p->old_link = p->phy->link;
	}

	if (p->old_duplex != p->phy->duplex) {
		status_changed = 1;
		p->old_duplex = p->phy->duplex;
	}

	if (p->old_pause != p->phy->pause) {
		status_changed = 1;
		p->old_pause = p->phy->pause;
	}

944 945 946
	if (ds->drv->adjust_link && status_changed)
		ds->drv->adjust_link(ds, p->port, p->phy);

947 948 949 950
	if (status_changed)
		phy_print_status(p->phy);
}

951 952 953
static int dsa_slave_fixed_link_update(struct net_device *dev,
				       struct fixed_phy_status *status)
{
954 955 956 957 958 959 960 961 962
	struct dsa_slave_priv *p;
	struct dsa_switch *ds;

	if (dev) {
		p = netdev_priv(dev);
		ds = p->parent;
		if (ds->drv->fixed_link_update)
			ds->drv->fixed_link_update(ds, p->port, status);
	}
963 964 965 966

	return 0;
}

967
/* slave device setup *******************************************************/
968
static int dsa_slave_phy_connect(struct dsa_slave_priv *p,
969 970
				 struct net_device *slave_dev,
				 int addr)
971 972 973
{
	struct dsa_switch *ds = p->parent;

974
	p->phy = mdiobus_get_phy(ds->slave_mii_bus, addr);
R
Russell King 已提交
975 976
	if (!p->phy) {
		netdev_err(slave_dev, "no phy at %d\n", addr);
977
		return -ENODEV;
R
Russell King 已提交
978
	}
979 980

	/* Use already configured phy mode */
981 982
	if (p->phy_interface == PHY_INTERFACE_MODE_NA)
		p->phy_interface = p->phy->interface;
983 984 985 986 987 988
	phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
			   p->phy_interface);

	return 0;
}

989
static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
990 991 992 993
				struct net_device *slave_dev)
{
	struct dsa_switch *ds = p->parent;
	struct device_node *phy_dn, *port_dn;
994
	bool phy_is_fixed = false;
995
	u32 phy_flags = 0;
996
	int mode, ret;
997

998
	port_dn = ds->ports[p->port].dn;
999 1000 1001 1002
	mode = of_get_phy_mode(port_dn);
	if (mode < 0)
		mode = PHY_INTERFACE_MODE_NA;
	p->phy_interface = mode;
1003 1004 1005 1006 1007 1008 1009 1010

	phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
	if (of_phy_is_fixed_link(port_dn)) {
		/* In the case of a fixed PHY, the DT node associated
		 * to the fixed PHY is the Port DT node
		 */
		ret = of_phy_register_fixed_link(port_dn);
		if (ret) {
R
Russell King 已提交
1011
			netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
1012
			return ret;
1013
		}
1014
		phy_is_fixed = true;
1015 1016 1017
		phy_dn = port_dn;
	}

1018 1019 1020
	if (ds->drv->get_phy_flags)
		phy_flags = ds->drv->get_phy_flags(ds, p->port);

1021
	if (phy_dn) {
R
Russell King 已提交
1022 1023
		int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn);

1024 1025 1026 1027 1028
		/* If this PHY address is part of phys_mii_mask, which means
		 * that we need to divert reads and writes to/from it, then we
		 * want to bind this device using the slave MII bus created by
		 * DSA to make that happen.
		 */
R
Russell King 已提交
1029 1030 1031 1032 1033
		if (!phy_is_fixed && phy_id >= 0 &&
		    (ds->phys_mii_mask & (1 << phy_id))) {
			ret = dsa_slave_phy_connect(p, slave_dev, phy_id);
			if (ret) {
				netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret);
1034
				return ret;
R
Russell King 已提交
1035
			}
1036 1037 1038 1039 1040 1041 1042
		} else {
			p->phy = of_phy_connect(slave_dev, phy_dn,
						dsa_slave_adjust_link,
						phy_flags,
						p->phy_interface);
		}
	}
1043

1044 1045 1046
	if (p->phy && phy_is_fixed)
		fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);

1047 1048 1049
	/* We could not connect to a designated PHY, so use the switch internal
	 * MDIO bus instead
	 */
1050
	if (!p->phy) {
1051
		ret = dsa_slave_phy_connect(p, slave_dev, p->port);
R
Russell King 已提交
1052 1053
		if (ret) {
			netdev_err(slave_dev, "failed to connect to port %d: %d\n", p->port, ret);
1054
			return ret;
R
Russell King 已提交
1055
		}
1056
	}
1057

1058 1059
	phy_attached_info(p->phy);

1060
	return 0;
1061 1062
}

1063 1064 1065 1066 1067 1068 1069 1070 1071
static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
					    struct netdev_queue *txq,
					    void *_unused)
{
	lockdep_set_class(&txq->_xmit_lock,
			  &dsa_slave_netdev_xmit_lock_key);
}

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
int dsa_slave_suspend(struct net_device *slave_dev)
{
	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	if (p->phy) {
		phy_stop(p->phy);
		p->old_pause = -1;
		p->old_link = -1;
		p->old_duplex = -1;
		phy_suspend(p->phy);
	}

	return 0;
}

int dsa_slave_resume(struct net_device *slave_dev)
{
	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	netif_device_attach(slave_dev);

	if (p->phy) {
		phy_resume(p->phy);
		phy_start(p->phy);
	}

	return 0;
}

1101 1102
int dsa_slave_create(struct dsa_switch *ds, struct device *parent,
		     int port, char *name)
1103
{
1104
	struct net_device *master = ds->dst->master_netdev;
1105
	struct dsa_switch_tree *dst = ds->dst;
1106 1107 1108 1109
	struct net_device *slave_dev;
	struct dsa_slave_priv *p;
	int ret;

1110 1111
	slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name,
				 NET_NAME_UNKNOWN, ether_setup);
1112
	if (slave_dev == NULL)
1113
		return -ENOMEM;
1114 1115

	slave_dev->features = master->vlan_features;
1116
	slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
	if (master->ethtool_ops != &dsa_cpu_port_ethtool_ops) {
		memcpy(&dst->master_ethtool_ops, master->ethtool_ops,
		       sizeof(struct ethtool_ops));
		memcpy(&dsa_cpu_port_ethtool_ops, &dst->master_ethtool_ops,
		       sizeof(struct ethtool_ops));
		dsa_cpu_port_ethtool_ops.get_sset_count =
					dsa_cpu_port_get_sset_count;
		dsa_cpu_port_ethtool_ops.get_ethtool_stats =
					dsa_cpu_port_get_ethtool_stats;
		dsa_cpu_port_ethtool_ops.get_strings =
					dsa_cpu_port_get_strings;
		master->ethtool_ops = &dsa_cpu_port_ethtool_ops;
	}
1130
	eth_hw_addr_inherit(slave_dev, master);
1131
	slave_dev->priv_flags |= IFF_NO_QUEUE;
1132
	slave_dev->netdev_ops = &dsa_slave_netdev_ops;
J
Jiri Pirko 已提交
1133
	slave_dev->switchdev_ops = &dsa_slave_switchdev_ops;
1134
	SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1135

1136 1137 1138
	netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one,
				 NULL);

1139
	SET_NETDEV_DEV(slave_dev, parent);
1140
	slave_dev->dev.of_node = ds->ports[port].dn;
1141 1142 1143 1144 1145
	slave_dev->vlan_features = master->vlan_features;

	p = netdev_priv(slave_dev);
	p->parent = ds;
	p->port = port;
1146
	p->xmit = dst->tag_ops->xmit;
1147

1148 1149 1150 1151
	p->old_pause = -1;
	p->old_link = -1;
	p->old_duplex = -1;

1152
	ds->ports[port].netdev = slave_dev;
1153 1154
	ret = register_netdev(slave_dev);
	if (ret) {
1155 1156
		netdev_err(master, "error %d registering interface %s\n",
			   ret, slave_dev->name);
1157
		ds->ports[port].netdev = NULL;
1158
		free_netdev(slave_dev);
1159
		return ret;
1160 1161 1162 1163
	}

	netif_carrier_off(slave_dev);

A
Andrew Lunn 已提交
1164 1165 1166
	ret = dsa_slave_phy_setup(p, slave_dev);
	if (ret) {
		netdev_err(master, "error %d setting up slave phy\n", ret);
1167
		unregister_netdev(slave_dev);
A
Andrew Lunn 已提交
1168 1169 1170 1171
		free_netdev(slave_dev);
		return ret;
	}

1172
	return 0;
1173
}
1174

1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
void dsa_slave_destroy(struct net_device *slave_dev)
{
	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	netif_carrier_off(slave_dev);
	if (p->phy)
		phy_disconnect(p->phy);
	unregister_netdev(slave_dev);
	free_netdev(slave_dev);
}

1186 1187 1188 1189 1190
static bool dsa_slave_dev_check(struct net_device *dev)
{
	return dev->netdev_ops == &dsa_slave_netdev_ops;
}

1191 1192
static int dsa_slave_port_upper_event(struct net_device *dev,
				      unsigned long event, void *ptr)
1193
{
1194 1195
	struct netdev_notifier_changeupper_info *info = ptr;
	struct net_device *upper = info->upper_dev;
1196 1197
	int err = 0;

1198 1199 1200 1201 1202 1203 1204 1205
	switch (event) {
	case NETDEV_CHANGEUPPER:
		if (netif_is_bridge_master(upper)) {
			if (info->linking)
				err = dsa_slave_bridge_port_join(dev, upper);
			else
				dsa_slave_bridge_port_leave(dev);
		}
1206

1207 1208 1209 1210
		break;
	}

	return notifier_from_errno(err);
1211 1212
}

1213 1214
static int dsa_slave_port_event(struct net_device *dev, unsigned long event,
				void *ptr)
1215 1216 1217
{
	switch (event) {
	case NETDEV_CHANGEUPPER:
1218 1219
		return dsa_slave_port_upper_event(dev, event, ptr);
	}
1220

1221 1222
	return NOTIFY_DONE;
}
1223

1224 1225 1226 1227 1228 1229 1230
int dsa_slave_netdevice_event(struct notifier_block *unused,
			      unsigned long event, void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);

	if (dsa_slave_dev_check(dev))
		return dsa_slave_port_event(dev, event, ptr);
1231 1232 1233

	return NOTIFY_DONE;
}