slave.c 12.1 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 12
 *
 * 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>
#include <linux/netdevice.h>
13
#include <linux/etherdevice.h>
14
#include <linux/phy.h>
15 16
#include <linux/of_net.h>
#include <linux/of_mdio.h>
17 18 19 20 21 22 23
#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;

24
	if (ds->phys_mii_mask & (1 << addr))
25 26 27 28 29 30 31 32 33
		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;

34
	if (ds->phys_mii_mask & (1 << addr))
35 36 37 38 39 40 41 42 43 44 45
		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;
46 47
	snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d:%.2x",
			ds->index, ds->pd->sw_addr);
48
	ds->slave_mii_bus->parent = &ds->master_mii_bus->dev;
49 50 51 52
}


/* slave device handling ****************************************************/
53 54 55 56
static int dsa_slave_init(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);

57
	dev->iflink = p->parent->dst->master_netdev->ifindex;
58 59 60 61

	return 0;
}

62 63
static int dsa_slave_open(struct net_device *dev)
{
64
	struct dsa_slave_priv *p = netdev_priv(dev);
65
	struct net_device *master = p->parent->dst->master_netdev;
66 67 68 69 70
	int err;

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

71
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
72
		err = dev_uc_add(master, dev->dev_addr);
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
		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;
	}

88
	return 0;
89 90 91 92 93

clear_allmulti:
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(master, -1);
del_unicast:
94
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
95
		dev_uc_del(master, dev->dev_addr);
96 97
out:
	return err;
98 99 100 101
}

static int dsa_slave_close(struct net_device *dev)
{
102
	struct dsa_slave_priv *p = netdev_priv(dev);
103
	struct net_device *master = p->parent->dst->master_netdev;
104 105

	dev_mc_unsync(master, dev);
106
	dev_uc_unsync(master, dev);
107 108 109 110 111
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(master, -1);
	if (dev->flags & IFF_PROMISC)
		dev_set_promiscuity(master, -1);

112
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
113
		dev_uc_del(master, dev->dev_addr);
114

115 116 117 118 119 120
	return 0;
}

static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
121
	struct net_device *master = p->parent->dst->master_netdev;
122 123 124 125 126 127 128 129 130 131

	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);
132
	struct net_device *master = p->parent->dst->master_netdev;
133 134

	dev_mc_sync(master, dev);
135
	dev_uc_sync(master, dev);
136 137
}

138
static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
139
{
140
	struct dsa_slave_priv *p = netdev_priv(dev);
141
	struct net_device *master = p->parent->dst->master_netdev;
142 143 144 145 146 147 148 149 150
	struct sockaddr *addr = a;
	int err;

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

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

151
	if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
152
		err = dev_uc_add(master, addr->sa_data);
153 154 155 156
		if (err < 0)
			return err;
	}

157
	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
158
		dev_uc_del(master, dev->dev_addr);
159 160

out:
J
Joe Perches 已提交
161
	ether_addr_copy(dev->dev_addr, addr->sa_data);
162 163 164 165 166 167 168 169 170

	return 0;
}

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)
171
		return phy_mii_ioctl(p->phy, ifr, cmd);
172 173 174 175

	return -EOPNOTSUPP;
}

176 177 178 179 180 181 182 183
static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch_tree *dst = p->parent->dst;

	return dst->ops->xmit(skb, dev);
}

184 185 186 187 188 189 190 191 192 193 194
static netdev_tx_t dsa_slave_notag_xmit(struct sk_buff *skb,
					struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);

	skb->dev = p->parent->dst->master_netdev;
	dev_queue_xmit(skb);

	return NETDEV_TX_OK;
}

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226

/* 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)
{
227 228 229 230
	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));
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
}

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;
}

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);
	}
}

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;

	data[0] = p->dev->stats.tx_packets;
	data[1] = p->dev->stats.tx_bytes;
	data[2] = p->dev->stats.rx_packets;
	data[3] = p->dev->stats.rx_bytes;
	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;
}

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,
	.nway_reset		= dsa_slave_nway_reset,
	.get_link		= dsa_slave_get_link,
	.get_strings		= dsa_slave_get_strings,
	.get_ethtool_stats	= dsa_slave_get_ethtool_stats,
	.get_sset_count		= dsa_slave_get_sset_count,
};

317
static const struct net_device_ops dsa_slave_netdev_ops = {
318
	.ndo_init		= dsa_slave_init,
319 320
	.ndo_open	 	= dsa_slave_open,
	.ndo_stop		= dsa_slave_close,
321
	.ndo_start_xmit		= dsa_slave_xmit,
322 323 324 325 326
	.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,
	.ndo_do_ioctl		= dsa_slave_ioctl,
};
327

328 329 330 331 332
static const struct dsa_device_ops notag_netdev_ops = {
	.xmit	= dsa_slave_notag_xmit,
	.rcv	= NULL,
};

333 334 335
static void dsa_slave_adjust_link(struct net_device *dev)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
336
	struct dsa_switch *ds = p->parent;
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
	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;
	}

354 355 356
	if (ds->drv->adjust_link && status_changed)
		ds->drv->adjust_link(ds, p->port, p->phy);

357 358 359 360
	if (status_changed)
		phy_print_status(p->phy);
}

361 362 363 364 365 366 367 368 369 370 371 372
static int dsa_slave_fixed_link_update(struct net_device *dev,
				       struct fixed_phy_status *status)
{
	struct dsa_slave_priv *p = netdev_priv(dev);
	struct dsa_switch *ds = p->parent;

	if (ds->drv->fixed_link_update)
		ds->drv->fixed_link_update(ds, p->port, status);

	return 0;
}

373
/* slave device setup *******************************************************/
374 375 376 377 378 379
static void dsa_slave_phy_setup(struct dsa_slave_priv *p,
				struct net_device *slave_dev)
{
	struct dsa_switch *ds = p->parent;
	struct dsa_chip_data *cd = ds->pd;
	struct device_node *phy_dn, *port_dn;
380
	bool phy_is_fixed = false;
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
	int ret;

	port_dn = cd->port_dn[p->port];
	p->phy_interface = of_get_phy_mode(port_dn);

	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) {
			pr_err("failed to register fixed PHY\n");
			return;
		}
396
		phy_is_fixed = true;
397 398 399 400 401 402 403 404
		phy_dn = port_dn;
	}

	if (phy_dn)
		p->phy = of_phy_connect(slave_dev, phy_dn,
					dsa_slave_adjust_link, 0,
					p->phy_interface);

405 406 407
	if (p->phy && phy_is_fixed)
		fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);

408 409 410 411 412 413 414 415 416 417
	/* We could not connect to a designated PHY, so use the switch internal
	 * MDIO bus instead
	 */
	if (!p->phy)
		p->phy = ds->slave_mii_bus->phy_map[p->port];
	else
		pr_info("attached PHY at address %d [%s]\n",
			p->phy->addr, p->phy->drv->name);
}

418 419 420 421
struct net_device *
dsa_slave_create(struct dsa_switch *ds, struct device *parent,
		 int port, char *name)
{
422
	struct net_device *master = ds->dst->master_netdev;
423 424 425 426
	struct net_device *slave_dev;
	struct dsa_slave_priv *p;
	int ret;

427 428
	slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name,
				 NET_NAME_UNKNOWN, ether_setup);
429 430 431 432
	if (slave_dev == NULL)
		return slave_dev;

	slave_dev->features = master->vlan_features;
433
	slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
434
	eth_hw_addr_inherit(slave_dev, master);
435
	slave_dev->tx_queue_len = 0;
436
	slave_dev->netdev_ops = &dsa_slave_netdev_ops;
437

438
	switch (ds->dst->tag_protocol) {
439
#ifdef CONFIG_NET_DSA_TAG_DSA
440
	case DSA_TAG_PROTO_DSA:
441
		ds->dst->ops = &dsa_netdev_ops;
442 443
		break;
#endif
444
#ifdef CONFIG_NET_DSA_TAG_EDSA
445
	case DSA_TAG_PROTO_EDSA:
446
		ds->dst->ops = &edsa_netdev_ops;
447
		break;
448 449
#endif
#ifdef CONFIG_NET_DSA_TAG_TRAILER
450
	case DSA_TAG_PROTO_TRAILER:
451
		ds->dst->ops = &trailer_netdev_ops;
452
		break;
453 454
#endif
#ifdef CONFIG_NET_DSA_TAG_BRCM
455
	case DSA_TAG_PROTO_BRCM:
456 457
		ds->dst->ops = &brcm_netdev_ops;
		break;
458 459
#endif
	default:
460 461
		ds->dst->ops = &notag_netdev_ops;
		break;
462
	}
463

464
	SET_NETDEV_DEV(slave_dev, parent);
465
	slave_dev->dev.of_node = ds->pd->port_dn[port];
466 467 468 469 470 471
	slave_dev->vlan_features = master->vlan_features;

	p = netdev_priv(slave_dev);
	p->dev = slave_dev;
	p->parent = ds;
	p->port = port;
472 473 474 475 476 477

	p->old_pause = -1;
	p->old_link = -1;
	p->old_duplex = -1;

	dsa_slave_phy_setup(p, slave_dev);
478 479 480 481 482 483 484 485 486 487 488 489

	ret = register_netdev(slave_dev);
	if (ret) {
		printk(KERN_ERR "%s: error %d registering interface %s\n",
				master->name, ret, slave_dev->name);
		free_netdev(slave_dev);
		return NULL;
	}

	netif_carrier_off(slave_dev);

	if (p->phy != NULL) {
490
		phy_attach(slave_dev, dev_name(&p->phy->dev),
491
			   PHY_INTERFACE_MODE_GMII);
492 493 494 495 496 497 498 499 500 501

		p->phy->autoneg = AUTONEG_ENABLE;
		p->phy->speed = 0;
		p->phy->duplex = 0;
		p->phy->advertising = p->phy->supported | ADVERTISED_Autoneg;
		phy_start_aneg(p->phy);
	}

	return slave_dev;
}