1// SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2/* Microsemi Ocelot Switch driver
   3 *
   4 * This contains glue logic between the switchdev driver operations and the
   5 * mscc_ocelot_switch_lib.
   6 *
   7 * Copyright (c) 2017, 2019 Microsemi Corporation
   8 * Copyright 2020-2021 NXP
   9 */
  10
  11#include <linux/dsa/ocelot.h>
  12#include <linux/if_bridge.h>
  13#include <linux/of_net.h>
  14#include <linux/phy/phy.h>
  15#include <net/pkt_cls.h>
  16#include "ocelot.h"
  17#include "ocelot_police.h"
  18#include "ocelot_vcap.h"
  19#include "ocelot_fdma.h"
  20
  21#define OCELOT_MAC_QUIRKS	OCELOT_QUIRK_QSGMII_PORTS_MUST_BE_UP
  22
  23struct ocelot_dump_ctx {
  24	struct net_device *dev;
  25	struct sk_buff *skb;
  26	struct netlink_callback *cb;
  27	int idx;
  28};
  29
  30static bool ocelot_netdevice_dev_check(const struct net_device *dev);
  31
  32static struct ocelot *devlink_port_to_ocelot(struct devlink_port *dlp)
  33{
  34	return devlink_priv(dlp->devlink);
  35}
  36
  37static int devlink_port_to_port(struct devlink_port *dlp)
  38{
  39	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
  40
  41	return dlp - ocelot->devlink_ports;
  42}
  43
  44static int ocelot_devlink_sb_pool_get(struct devlink *dl,
  45				      unsigned int sb_index, u16 pool_index,
  46				      struct devlink_sb_pool_info *pool_info)
  47{
  48	struct ocelot *ocelot = devlink_priv(dl);
  49
  50	return ocelot_sb_pool_get(ocelot, sb_index, pool_index, pool_info);
  51}
  52
  53static int ocelot_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index,
  54				      u16 pool_index, u32 size,
  55				      enum devlink_sb_threshold_type threshold_type,
  56				      struct netlink_ext_ack *extack)
  57{
  58	struct ocelot *ocelot = devlink_priv(dl);
  59
  60	return ocelot_sb_pool_set(ocelot, sb_index, pool_index, size,
  61				  threshold_type, extack);
  62}
  63
  64static int ocelot_devlink_sb_port_pool_get(struct devlink_port *dlp,
  65					   unsigned int sb_index, u16 pool_index,
  66					   u32 *p_threshold)
  67{
  68	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
  69	int port = devlink_port_to_port(dlp);
  70
  71	return ocelot_sb_port_pool_get(ocelot, port, sb_index, pool_index,
  72				       p_threshold);
  73}
  74
  75static int ocelot_devlink_sb_port_pool_set(struct devlink_port *dlp,
  76					   unsigned int sb_index, u16 pool_index,
  77					   u32 threshold,
  78					   struct netlink_ext_ack *extack)
  79{
  80	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
  81	int port = devlink_port_to_port(dlp);
  82
  83	return ocelot_sb_port_pool_set(ocelot, port, sb_index, pool_index,
  84				       threshold, extack);
  85}
  86
  87static int
  88ocelot_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp,
  89				   unsigned int sb_index, u16 tc_index,
  90				   enum devlink_sb_pool_type pool_type,
  91				   u16 *p_pool_index, u32 *p_threshold)
  92{
  93	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
  94	int port = devlink_port_to_port(dlp);
  95
  96	return ocelot_sb_tc_pool_bind_get(ocelot, port, sb_index, tc_index,
  97					  pool_type, p_pool_index,
  98					  p_threshold);
  99}
 100
 101static int
 102ocelot_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp,
 103				   unsigned int sb_index, u16 tc_index,
 104				   enum devlink_sb_pool_type pool_type,
 105				   u16 pool_index, u32 threshold,
 106				   struct netlink_ext_ack *extack)
 107{
 108	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
 109	int port = devlink_port_to_port(dlp);
 110
 111	return ocelot_sb_tc_pool_bind_set(ocelot, port, sb_index, tc_index,
 112					  pool_type, pool_index, threshold,
 113					  extack);
 114}
 115
 116static int ocelot_devlink_sb_occ_snapshot(struct devlink *dl,
 117					  unsigned int sb_index)
 118{
 119	struct ocelot *ocelot = devlink_priv(dl);
 120
 121	return ocelot_sb_occ_snapshot(ocelot, sb_index);
 122}
 123
 124static int ocelot_devlink_sb_occ_max_clear(struct devlink *dl,
 125					   unsigned int sb_index)
 126{
 127	struct ocelot *ocelot = devlink_priv(dl);
 128
 129	return ocelot_sb_occ_max_clear(ocelot, sb_index);
 130}
 131
 132static int ocelot_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,
 133					       unsigned int sb_index,
 134					       u16 pool_index, u32 *p_cur,
 135					       u32 *p_max)
 136{
 137	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
 138	int port = devlink_port_to_port(dlp);
 139
 140	return ocelot_sb_occ_port_pool_get(ocelot, port, sb_index, pool_index,
 141					   p_cur, p_max);
 142}
 143
 144static int
 145ocelot_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,
 146				       unsigned int sb_index, u16 tc_index,
 147				       enum devlink_sb_pool_type pool_type,
 148				       u32 *p_cur, u32 *p_max)
 149{
 150	struct ocelot *ocelot = devlink_port_to_ocelot(dlp);
 151	int port = devlink_port_to_port(dlp);
 152
 153	return ocelot_sb_occ_tc_port_bind_get(ocelot, port, sb_index,
 154					      tc_index, pool_type,
 155					      p_cur, p_max);
 156}
 157
 158const struct devlink_ops ocelot_devlink_ops = {
 159	.sb_pool_get			= ocelot_devlink_sb_pool_get,
 160	.sb_pool_set			= ocelot_devlink_sb_pool_set,
 161	.sb_port_pool_get		= ocelot_devlink_sb_port_pool_get,
 162	.sb_port_pool_set		= ocelot_devlink_sb_port_pool_set,
 163	.sb_tc_pool_bind_get		= ocelot_devlink_sb_tc_pool_bind_get,
 164	.sb_tc_pool_bind_set		= ocelot_devlink_sb_tc_pool_bind_set,
 165	.sb_occ_snapshot		= ocelot_devlink_sb_occ_snapshot,
 166	.sb_occ_max_clear		= ocelot_devlink_sb_occ_max_clear,
 167	.sb_occ_port_pool_get		= ocelot_devlink_sb_occ_port_pool_get,
 168	.sb_occ_tc_port_bind_get	= ocelot_devlink_sb_occ_tc_port_bind_get,
 169};
 170
 171int ocelot_port_devlink_init(struct ocelot *ocelot, int port,
 172			     enum devlink_port_flavour flavour)
 173{
 174	struct devlink_port *dlp = &ocelot->devlink_ports[port];
 175	int id_len = sizeof(ocelot->base_mac);
 176	struct devlink *dl = ocelot->devlink;
 177	struct devlink_port_attrs attrs = {};
 178
 179	memset(dlp, 0, sizeof(*dlp));
 180	memcpy(attrs.switch_id.id, &ocelot->base_mac, id_len);
 181	attrs.switch_id.id_len = id_len;
 182	attrs.phys.port_number = port;
 183	attrs.flavour = flavour;
 184
 185	devlink_port_attrs_set(dlp, &attrs);
 186
 187	return devlink_port_register(dl, dlp, port);
 188}
 189
 190void ocelot_port_devlink_teardown(struct ocelot *ocelot, int port)
 191{
 192	struct devlink_port *dlp = &ocelot->devlink_ports[port];
 193
 194	devlink_port_unregister(dlp);
 195}
 196
 197int ocelot_setup_tc_cls_flower(struct ocelot_port_private *priv,
 198			       struct flow_cls_offload *f,
 199			       bool ingress)
 200{
 201	struct ocelot *ocelot = priv->port.ocelot;
 202	int port = priv->port.index;
 203
 204	if (!ingress)
 205		return -EOPNOTSUPP;
 206
 207	switch (f->command) {
 208	case FLOW_CLS_REPLACE:
 209		return ocelot_cls_flower_replace(ocelot, port, f, ingress);
 210	case FLOW_CLS_DESTROY:
 211		return ocelot_cls_flower_destroy(ocelot, port, f, ingress);
 212	case FLOW_CLS_STATS:
 213		return ocelot_cls_flower_stats(ocelot, port, f, ingress);
 214	default:
 215		return -EOPNOTSUPP;
 216	}
 217}
 218
 219static int ocelot_setup_tc_cls_matchall_police(struct ocelot_port_private *priv,
 220					       struct tc_cls_matchall_offload *f,
 221					       bool ingress,
 222					       struct netlink_ext_ack *extack)
 223{
 224	struct flow_action_entry *action = &f->rule->action.entries[0];
 225	struct ocelot *ocelot = priv->port.ocelot;
 226	struct ocelot_policer pol = { 0 };
 227	int port = priv->port.index;
 
 228	int err;
 229
 230	if (!ingress) {
 231		NL_SET_ERR_MSG_MOD(extack, "Only ingress is supported");
 232		return -EOPNOTSUPP;
 233	}
 234
 235	if (priv->tc.police_id && priv->tc.police_id != f->cookie) {
 236		NL_SET_ERR_MSG_MOD(extack,
 237				   "Only one policer per port is supported");
 238		return -EEXIST;
 239	}
 240
 241	err = ocelot_policer_validate(&f->rule->action, action, extack);
 242	if (err)
 243		return err;
 244
 245	pol.rate = (u32)div_u64(action->police.rate_bytes_ps, 1000) * 8;
 246	pol.burst = action->police.burst;
 247
 248	err = ocelot_port_policer_add(ocelot, port, &pol);
 249	if (err) {
 250		NL_SET_ERR_MSG_MOD(extack, "Could not add policer");
 251		return err;
 252	}
 253
 254	priv->tc.police_id = f->cookie;
 255	priv->tc.offload_cnt++;
 256
 257	return 0;
 258}
 259
 260static int ocelot_setup_tc_cls_matchall_mirred(struct ocelot_port_private *priv,
 261					       struct tc_cls_matchall_offload *f,
 262					       bool ingress,
 263					       struct netlink_ext_ack *extack)
 264{
 265	struct flow_action *action = &f->rule->action;
 266	struct ocelot *ocelot = priv->port.ocelot;
 267	struct ocelot_port_private *other_priv;
 268	const struct flow_action_entry *a;
 269	int err;
 270
 271	if (f->common.protocol != htons(ETH_P_ALL))
 272		return -EOPNOTSUPP;
 273
 274	if (!flow_action_basic_hw_stats_check(action, extack))
 275		return -EOPNOTSUPP;
 276
 277	a = &action->entries[0];
 278	if (!a->dev)
 279		return -EINVAL;
 280
 281	if (!ocelot_netdevice_dev_check(a->dev)) {
 282		NL_SET_ERR_MSG_MOD(extack,
 283				   "Destination not an ocelot port");
 284		return -EOPNOTSUPP;
 285	}
 286
 287	other_priv = netdev_priv(a->dev);
 288
 289	err = ocelot_port_mirror_add(ocelot, priv->port.index,
 290				     other_priv->port.index, ingress, extack);
 291	if (err)
 292		return err;
 293
 294	if (ingress)
 295		priv->tc.ingress_mirred_id = f->cookie;
 296	else
 297		priv->tc.egress_mirred_id = f->cookie;
 298	priv->tc.offload_cnt++;
 299
 300	return 0;
 301}
 302
 303static int ocelot_del_tc_cls_matchall_police(struct ocelot_port_private *priv,
 304					     struct netlink_ext_ack *extack)
 305{
 306	struct ocelot *ocelot = priv->port.ocelot;
 307	int port = priv->port.index;
 308	int err;
 309
 310	err = ocelot_port_policer_del(ocelot, port);
 311	if (err) {
 312		NL_SET_ERR_MSG_MOD(extack,
 313				   "Could not delete policer");
 314		return err;
 315	}
 316
 317	priv->tc.police_id = 0;
 318	priv->tc.offload_cnt--;
 319
 320	return 0;
 321}
 322
 323static int ocelot_del_tc_cls_matchall_mirred(struct ocelot_port_private *priv,
 324					     bool ingress,
 325					     struct netlink_ext_ack *extack)
 326{
 327	struct ocelot *ocelot = priv->port.ocelot;
 328	int port = priv->port.index;
 329
 330	ocelot_port_mirror_del(ocelot, port, ingress);
 331
 332	if (ingress)
 333		priv->tc.ingress_mirred_id = 0;
 334	else
 335		priv->tc.egress_mirred_id = 0;
 336	priv->tc.offload_cnt--;
 337
 338	return 0;
 339}
 340
 341static int ocelot_setup_tc_cls_matchall(struct ocelot_port_private *priv,
 342					struct tc_cls_matchall_offload *f,
 343					bool ingress)
 344{
 345	struct netlink_ext_ack *extack = f->common.extack;
 346	struct flow_action_entry *action;
 347
 348	switch (f->command) {
 349	case TC_CLSMATCHALL_REPLACE:
 350		if (!flow_offload_has_one_action(&f->rule->action)) {
 351			NL_SET_ERR_MSG_MOD(extack,
 352					   "Only one action is supported");
 353			return -EOPNOTSUPP;
 354		}
 355
 356		if (priv->tc.block_shared) {
 357			NL_SET_ERR_MSG_MOD(extack,
 358					   "Matchall offloads not supported on shared blocks");
 359			return -EOPNOTSUPP;
 360		}
 361
 362		action = &f->rule->action.entries[0];
 363
 364		switch (action->id) {
 365		case FLOW_ACTION_POLICE:
 366			return ocelot_setup_tc_cls_matchall_police(priv, f,
 367								   ingress,
 368								   extack);
 369			break;
 370		case FLOW_ACTION_MIRRED:
 371			return ocelot_setup_tc_cls_matchall_mirred(priv, f,
 372								   ingress,
 373								   extack);
 374		default:
 375			NL_SET_ERR_MSG_MOD(extack, "Unsupported action");
 376			return -EOPNOTSUPP;
 377		}
 378
 379		break;
 380	case TC_CLSMATCHALL_DESTROY:
 381		action = &f->rule->action.entries[0];
 
 
 382
 383		if (f->cookie == priv->tc.police_id)
 384			return ocelot_del_tc_cls_matchall_police(priv, extack);
 385		else if (f->cookie == priv->tc.ingress_mirred_id ||
 386			 f->cookie == priv->tc.egress_mirred_id)
 387			return ocelot_del_tc_cls_matchall_mirred(priv, ingress,
 388								 extack);
 389		else
 
 
 
 
 
 
 
 390			return -ENOENT;
 391
 392		break;
 
 
 
 
 
 
 
 
 393	case TC_CLSMATCHALL_STATS:
 394	default:
 395		return -EOPNOTSUPP;
 396	}
 397}
 398
 399static int ocelot_setup_tc_block_cb(enum tc_setup_type type,
 400				    void *type_data,
 401				    void *cb_priv, bool ingress)
 402{
 403	struct ocelot_port_private *priv = cb_priv;
 404
 405	if (!tc_cls_can_offload_and_chain0(priv->dev, type_data))
 406		return -EOPNOTSUPP;
 407
 408	switch (type) {
 409	case TC_SETUP_CLSMATCHALL:
 410		return ocelot_setup_tc_cls_matchall(priv, type_data, ingress);
 411	case TC_SETUP_CLSFLOWER:
 412		return ocelot_setup_tc_cls_flower(priv, type_data, ingress);
 413	default:
 414		return -EOPNOTSUPP;
 415	}
 416}
 417
 418static int ocelot_setup_tc_block_cb_ig(enum tc_setup_type type,
 419				       void *type_data,
 420				       void *cb_priv)
 421{
 422	return ocelot_setup_tc_block_cb(type, type_data,
 423					cb_priv, true);
 424}
 425
 426static int ocelot_setup_tc_block_cb_eg(enum tc_setup_type type,
 427				       void *type_data,
 428				       void *cb_priv)
 429{
 430	return ocelot_setup_tc_block_cb(type, type_data,
 431					cb_priv, false);
 432}
 433
 434static LIST_HEAD(ocelot_block_cb_list);
 435
 436static int ocelot_setup_tc_block(struct ocelot_port_private *priv,
 437				 struct flow_block_offload *f)
 438{
 439	struct flow_block_cb *block_cb;
 440	flow_setup_cb_t *cb;
 441
 442	if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) {
 443		cb = ocelot_setup_tc_block_cb_ig;
 444		priv->tc.block_shared = f->block_shared;
 445	} else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) {
 446		cb = ocelot_setup_tc_block_cb_eg;
 447	} else {
 448		return -EOPNOTSUPP;
 449	}
 450
 451	f->driver_block_list = &ocelot_block_cb_list;
 452
 453	switch (f->command) {
 454	case FLOW_BLOCK_BIND:
 455		if (flow_block_cb_is_busy(cb, priv, &ocelot_block_cb_list))
 456			return -EBUSY;
 457
 458		block_cb = flow_block_cb_alloc(cb, priv, priv, NULL);
 459		if (IS_ERR(block_cb))
 460			return PTR_ERR(block_cb);
 461
 462		flow_block_cb_add(block_cb, f);
 463		list_add_tail(&block_cb->driver_list, f->driver_block_list);
 464		return 0;
 465	case FLOW_BLOCK_UNBIND:
 466		block_cb = flow_block_cb_lookup(f->block, cb, priv);
 467		if (!block_cb)
 468			return -ENOENT;
 469
 470		flow_block_cb_remove(block_cb, f);
 471		list_del(&block_cb->driver_list);
 472		return 0;
 473	default:
 474		return -EOPNOTSUPP;
 475	}
 476}
 477
 478static int ocelot_setup_tc(struct net_device *dev, enum tc_setup_type type,
 479			   void *type_data)
 480{
 481	struct ocelot_port_private *priv = netdev_priv(dev);
 482
 483	switch (type) {
 484	case TC_SETUP_BLOCK:
 485		return ocelot_setup_tc_block(priv, type_data);
 486	default:
 487		return -EOPNOTSUPP;
 488	}
 489	return 0;
 490}
 491
 
 
 
 
 
 
 
 
 
 492static int ocelot_vlan_vid_add(struct net_device *dev, u16 vid, bool pvid,
 493			       bool untagged)
 494{
 495	struct ocelot_port_private *priv = netdev_priv(dev);
 496	struct ocelot_port *ocelot_port = &priv->port;
 497	struct ocelot *ocelot = ocelot_port->ocelot;
 498	int port = priv->port.index;
 499	int ret;
 500
 501	ret = ocelot_vlan_add(ocelot, port, vid, pvid, untagged);
 502	if (ret)
 503		return ret;
 504
 505	/* Add the port MAC address to with the right VLAN information */
 506	ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr, vid,
 507			  ENTRYTYPE_LOCKED);
 508
 509	return 0;
 510}
 511
 512static int ocelot_vlan_vid_del(struct net_device *dev, u16 vid)
 513{
 514	struct ocelot_port_private *priv = netdev_priv(dev);
 515	struct ocelot *ocelot = priv->port.ocelot;
 516	int port = priv->port.index;
 517	int ret;
 518
 519	/* 8021q removes VID 0 on module unload for all interfaces
 520	 * with VLAN filtering feature. We need to keep it to receive
 521	 * untagged traffic.
 522	 */
 523	if (vid == OCELOT_STANDALONE_PVID)
 524		return 0;
 525
 526	ret = ocelot_vlan_del(ocelot, port, vid);
 527	if (ret)
 528		return ret;
 529
 530	/* Del the port MAC address to with the right VLAN information */
 531	ocelot_mact_forget(ocelot, dev->dev_addr, vid);
 532
 533	return 0;
 534}
 535
 536static int ocelot_port_open(struct net_device *dev)
 537{
 538	struct ocelot_port_private *priv = netdev_priv(dev);
 
 
 
 
 539
 540	phylink_start(priv->phylink);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 541
 542	return 0;
 543}
 544
 545static int ocelot_port_stop(struct net_device *dev)
 546{
 547	struct ocelot_port_private *priv = netdev_priv(dev);
 
 
 548
 549	phylink_stop(priv->phylink);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 550
 551	return 0;
 552}
 553
 554static netdev_tx_t ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev)
 555{
 556	struct ocelot_port_private *priv = netdev_priv(dev);
 
 557	struct ocelot_port *ocelot_port = &priv->port;
 558	struct ocelot *ocelot = ocelot_port->ocelot;
 559	int port = priv->port.index;
 560	u32 rew_op = 0;
 561
 562	if (!static_branch_unlikely(&ocelot_fdma_enabled) &&
 563	    !ocelot_can_inject(ocelot, 0))
 
 
 
 
 
 564		return NETDEV_TX_BUSY;
 565
 566	/* Check if timestamping is needed */
 567	if (ocelot->ptp && (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {
 568		struct sk_buff *clone = NULL;
 569
 570		if (ocelot_port_txtstamp_request(ocelot, port, skb, &clone)) {
 571			kfree_skb(skb);
 572			return NETDEV_TX_OK;
 573		}
 574
 575		if (clone)
 576			OCELOT_SKB_CB(skb)->clone = clone;
 577
 578		rew_op = ocelot_ptp_rew_op(skb);
 
 
 
 579	}
 580
 581	if (static_branch_unlikely(&ocelot_fdma_enabled)) {
 582		ocelot_fdma_inject_frame(ocelot, port, rew_op, skb, dev);
 583	} else {
 584		ocelot_port_inject_frame(ocelot, port, 0, rew_op, skb);
 585
 586		consume_skb(skb);
 587	}
 
 588
 589	return NETDEV_TX_OK;
 590}
 
 
 591
 592enum ocelot_action_type {
 593	OCELOT_MACT_LEARN,
 594	OCELOT_MACT_FORGET,
 595};
 596
 597struct ocelot_mact_work_ctx {
 598	struct work_struct work;
 599	struct ocelot *ocelot;
 600	enum ocelot_action_type type;
 601	union {
 602		/* OCELOT_MACT_LEARN */
 603		struct {
 604			unsigned char addr[ETH_ALEN];
 605			u16 vid;
 606			enum macaccess_entry_type entry_type;
 607			int pgid;
 608		} learn;
 609		/* OCELOT_MACT_FORGET */
 610		struct {
 611			unsigned char addr[ETH_ALEN];
 612			u16 vid;
 613		} forget;
 614	};
 615};
 616
 617#define ocelot_work_to_ctx(x) \
 618	container_of((x), struct ocelot_mact_work_ctx, work)
 619
 620static void ocelot_mact_work(struct work_struct *work)
 621{
 622	struct ocelot_mact_work_ctx *w = ocelot_work_to_ctx(work);
 623	struct ocelot *ocelot = w->ocelot;
 624
 625	switch (w->type) {
 626	case OCELOT_MACT_LEARN:
 627		ocelot_mact_learn(ocelot, w->learn.pgid, w->learn.addr,
 628				  w->learn.vid, w->learn.entry_type);
 629		break;
 630	case OCELOT_MACT_FORGET:
 631		ocelot_mact_forget(ocelot, w->forget.addr, w->forget.vid);
 632		break;
 633	default:
 634		break;
 635	}
 636
 637	kfree(w);
 638}
 
 
 
 639
 640static int ocelot_enqueue_mact_action(struct ocelot *ocelot,
 641				      const struct ocelot_mact_work_ctx *ctx)
 642{
 643	struct ocelot_mact_work_ctx *w = kmemdup(ctx, sizeof(*w), GFP_ATOMIC);
 644
 645	if (!w)
 646		return -ENOMEM;
 647
 648	w->ocelot = ocelot;
 649	INIT_WORK(&w->work, ocelot_mact_work);
 650	queue_work(ocelot->owq, &w->work);
 651
 652	return 0;
 653}
 654
 655static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr)
 656{
 657	struct ocelot_port_private *priv = netdev_priv(dev);
 658	struct ocelot_port *ocelot_port = &priv->port;
 659	struct ocelot *ocelot = ocelot_port->ocelot;
 660	struct ocelot_mact_work_ctx w;
 661
 662	ether_addr_copy(w.forget.addr, addr);
 663	w.forget.vid = OCELOT_STANDALONE_PVID;
 664	w.type = OCELOT_MACT_FORGET;
 665
 666	return ocelot_enqueue_mact_action(ocelot, &w);
 667}
 668
 669static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr)
 670{
 671	struct ocelot_port_private *priv = netdev_priv(dev);
 672	struct ocelot_port *ocelot_port = &priv->port;
 673	struct ocelot *ocelot = ocelot_port->ocelot;
 674	struct ocelot_mact_work_ctx w;
 675
 676	ether_addr_copy(w.learn.addr, addr);
 677	w.learn.vid = OCELOT_STANDALONE_PVID;
 678	w.learn.pgid = PGID_CPU;
 679	w.learn.entry_type = ENTRYTYPE_LOCKED;
 680	w.type = OCELOT_MACT_LEARN;
 681
 682	return ocelot_enqueue_mact_action(ocelot, &w);
 
 683}
 684
 685static void ocelot_set_rx_mode(struct net_device *dev)
 686{
 687	struct ocelot_port_private *priv = netdev_priv(dev);
 688	struct ocelot *ocelot = priv->port.ocelot;
 689	u32 val;
 690	int i;
 691
 692	/* This doesn't handle promiscuous mode because the bridge core is
 693	 * setting IFF_PROMISC on all slave interfaces and all frames would be
 694	 * forwarded to the CPU port.
 695	 */
 696	val = GENMASK(ocelot->num_phys_ports - 1, 0);
 697	for_each_nonreserved_multicast_dest_pgid(ocelot, i)
 698		ocelot_write_rix(ocelot, val, ANA_PGID_PGID, i);
 699
 700	__dev_mc_sync(dev, ocelot_mc_sync, ocelot_mc_unsync);
 701}
 702
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 703static int ocelot_port_set_mac_address(struct net_device *dev, void *p)
 704{
 705	struct ocelot_port_private *priv = netdev_priv(dev);
 706	struct ocelot_port *ocelot_port = &priv->port;
 707	struct ocelot *ocelot = ocelot_port->ocelot;
 708	const struct sockaddr *addr = p;
 709
 710	/* Learn the new net device MAC address in the mac table. */
 711	ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data,
 712			  OCELOT_STANDALONE_PVID, ENTRYTYPE_LOCKED);
 713	/* Then forget the previous one. */
 714	ocelot_mact_forget(ocelot, dev->dev_addr, OCELOT_STANDALONE_PVID);
 715
 716	eth_hw_addr_set(dev, addr->sa_data);
 717	return 0;
 718}
 719
 720static void ocelot_get_stats64(struct net_device *dev,
 721			       struct rtnl_link_stats64 *stats)
 722{
 723	struct ocelot_port_private *priv = netdev_priv(dev);
 724	struct ocelot *ocelot = priv->port.ocelot;
 725	int port = priv->port.index;
 726
 727	return ocelot_port_get_stats64(ocelot, port, stats);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 728}
 729
 730static int ocelot_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 731			       struct net_device *dev,
 732			       const unsigned char *addr,
 733			       u16 vid, u16 flags, bool *notified,
 734			       struct netlink_ext_ack *extack)
 735{
 736	struct ocelot_port_private *priv = netdev_priv(dev);
 737	struct ocelot_port *ocelot_port = &priv->port;
 738	struct ocelot *ocelot = ocelot_port->ocelot;
 739	int port = priv->port.index;
 740
 741	return ocelot_fdb_add(ocelot, port, addr, vid, ocelot_port->bridge);
 742}
 743
 744static int ocelot_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
 745			       struct net_device *dev,
 746			       const unsigned char *addr, u16 vid,
 747			       bool *notified, struct netlink_ext_ack *extack)
 748{
 749	struct ocelot_port_private *priv = netdev_priv(dev);
 750	struct ocelot_port *ocelot_port = &priv->port;
 751	struct ocelot *ocelot = ocelot_port->ocelot;
 752	int port = priv->port.index;
 753
 754	return ocelot_fdb_del(ocelot, port, addr, vid, ocelot_port->bridge);
 755}
 756
 757static int ocelot_port_fdb_do_dump(const unsigned char *addr, u16 vid,
 758				   bool is_static, void *data)
 759{
 760	struct ocelot_dump_ctx *dump = data;
 761	u32 portid = NETLINK_CB(dump->cb->skb).portid;
 762	u32 seq = dump->cb->nlh->nlmsg_seq;
 763	struct nlmsghdr *nlh;
 764	struct ndmsg *ndm;
 765
 766	if (dump->idx < dump->cb->args[2])
 767		goto skip;
 768
 769	nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
 770			sizeof(*ndm), NLM_F_MULTI);
 771	if (!nlh)
 772		return -EMSGSIZE;
 773
 774	ndm = nlmsg_data(nlh);
 775	ndm->ndm_family  = AF_BRIDGE;
 776	ndm->ndm_pad1    = 0;
 777	ndm->ndm_pad2    = 0;
 778	ndm->ndm_flags   = NTF_SELF;
 779	ndm->ndm_type    = 0;
 780	ndm->ndm_ifindex = dump->dev->ifindex;
 781	ndm->ndm_state   = is_static ? NUD_NOARP : NUD_REACHABLE;
 782
 783	if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))
 784		goto nla_put_failure;
 785
 786	if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))
 787		goto nla_put_failure;
 788
 789	nlmsg_end(dump->skb, nlh);
 790
 791skip:
 792	dump->idx++;
 793	return 0;
 794
 795nla_put_failure:
 796	nlmsg_cancel(dump->skb, nlh);
 797	return -EMSGSIZE;
 798}
 799
 800static int ocelot_port_fdb_dump(struct sk_buff *skb,
 801				struct netlink_callback *cb,
 802				struct net_device *dev,
 803				struct net_device *filter_dev, int *idx)
 804{
 805	struct ocelot_port_private *priv = netdev_priv(dev);
 806	struct ocelot *ocelot = priv->port.ocelot;
 807	struct ocelot_dump_ctx dump = {
 808		.dev = dev,
 809		.skb = skb,
 810		.cb = cb,
 811		.idx = *idx,
 812	};
 813	int port = priv->port.index;
 814	int ret;
 815
 816	ret = ocelot_fdb_dump(ocelot, port, ocelot_port_fdb_do_dump, &dump);
 817
 818	*idx = dump.idx;
 819
 820	return ret;
 821}
 822
 823static int ocelot_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
 824				  u16 vid)
 825{
 826	return ocelot_vlan_vid_add(dev, vid, false, false);
 827}
 828
 829static int ocelot_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
 830				   u16 vid)
 831{
 832	return ocelot_vlan_vid_del(dev, vid);
 833}
 834
 835static void ocelot_vlan_mode(struct ocelot *ocelot, int port,
 836			     netdev_features_t features)
 837{
 838	u32 val;
 839
 840	/* Filtering */
 841	val = ocelot_read(ocelot, ANA_VLANMASK);
 842	if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
 843		val |= BIT(port);
 844	else
 845		val &= ~BIT(port);
 846	ocelot_write(ocelot, val, ANA_VLANMASK);
 847}
 848
 849static int ocelot_set_features(struct net_device *dev,
 850			       netdev_features_t features)
 851{
 852	netdev_features_t changed = dev->features ^ features;
 853	struct ocelot_port_private *priv = netdev_priv(dev);
 854	struct ocelot *ocelot = priv->port.ocelot;
 855	int port = priv->port.index;
 856
 857	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) &&
 858	    priv->tc.offload_cnt) {
 859		netdev_err(dev,
 860			   "Cannot disable HW TC offload while offloads active\n");
 861		return -EBUSY;
 862	}
 863
 864	if (changed & NETIF_F_HW_VLAN_CTAG_FILTER)
 865		ocelot_vlan_mode(ocelot, port, features);
 866
 867	return 0;
 868}
 869
 
 
 
 
 
 
 
 
 
 
 
 
 870static int ocelot_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 871{
 872	struct ocelot_port_private *priv = netdev_priv(dev);
 873	struct ocelot *ocelot = priv->port.ocelot;
 874	int port = priv->port.index;
 875
 876	/* If the attached PHY device isn't capable of timestamping operations,
 877	 * use our own (when possible).
 878	 */
 879	if (!phy_has_hwtstamp(dev->phydev) && ocelot->ptp) {
 880		switch (cmd) {
 881		case SIOCSHWTSTAMP:
 882			return ocelot_hwstamp_set(ocelot, port, ifr);
 883		case SIOCGHWTSTAMP:
 884			return ocelot_hwstamp_get(ocelot, port, ifr);
 885		}
 886	}
 887
 888	return phy_mii_ioctl(dev->phydev, ifr, cmd);
 889}
 890
 891static int ocelot_change_mtu(struct net_device *dev, int new_mtu)
 892{
 893	struct ocelot_port_private *priv = netdev_priv(dev);
 894	struct ocelot_port *ocelot_port = &priv->port;
 895	struct ocelot *ocelot = ocelot_port->ocelot;
 896
 897	ocelot_port_set_maxlen(ocelot, priv->port.index, new_mtu);
 898	WRITE_ONCE(dev->mtu, new_mtu);
 899
 900	return 0;
 901}
 902
 903static const struct net_device_ops ocelot_port_netdev_ops = {
 904	.ndo_open			= ocelot_port_open,
 905	.ndo_stop			= ocelot_port_stop,
 906	.ndo_start_xmit			= ocelot_port_xmit,
 907	.ndo_change_mtu			= ocelot_change_mtu,
 908	.ndo_set_rx_mode		= ocelot_set_rx_mode,
 
 909	.ndo_set_mac_address		= ocelot_port_set_mac_address,
 910	.ndo_get_stats64		= ocelot_get_stats64,
 911	.ndo_fdb_add			= ocelot_port_fdb_add,
 912	.ndo_fdb_del			= ocelot_port_fdb_del,
 913	.ndo_fdb_dump			= ocelot_port_fdb_dump,
 914	.ndo_vlan_rx_add_vid		= ocelot_vlan_rx_add_vid,
 915	.ndo_vlan_rx_kill_vid		= ocelot_vlan_rx_kill_vid,
 916	.ndo_set_features		= ocelot_set_features,
 
 917	.ndo_setup_tc			= ocelot_setup_tc,
 918	.ndo_eth_ioctl			= ocelot_ioctl,
 919};
 920
 921struct net_device *ocelot_port_to_netdev(struct ocelot *ocelot, int port)
 922{
 923	struct ocelot_port *ocelot_port = ocelot->ports[port];
 924	struct ocelot_port_private *priv;
 925
 926	if (!ocelot_port)
 927		return NULL;
 928
 929	priv = container_of(ocelot_port, struct ocelot_port_private, port);
 930
 931	return priv->dev;
 932}
 933
 934/* Checks if the net_device instance given to us originates from our driver */
 935static bool ocelot_netdevice_dev_check(const struct net_device *dev)
 936{
 937	return dev->netdev_ops == &ocelot_port_netdev_ops;
 938}
 939
 940int ocelot_netdev_to_port(struct net_device *dev)
 941{
 942	struct ocelot_port_private *priv;
 943
 944	if (!dev || !ocelot_netdevice_dev_check(dev))
 945		return -EINVAL;
 946
 947	priv = netdev_priv(dev);
 948
 949	return priv->port.index;
 950}
 951
 952static void ocelot_port_get_strings(struct net_device *netdev, u32 sset,
 953				    u8 *data)
 954{
 955	struct ocelot_port_private *priv = netdev_priv(netdev);
 956	struct ocelot *ocelot = priv->port.ocelot;
 957	int port = priv->port.index;
 958
 959	ocelot_get_strings(ocelot, port, sset, data);
 960}
 961
 962static void ocelot_port_get_ethtool_stats(struct net_device *dev,
 963					  struct ethtool_stats *stats,
 964					  u64 *data)
 965{
 966	struct ocelot_port_private *priv = netdev_priv(dev);
 967	struct ocelot *ocelot = priv->port.ocelot;
 968	int port = priv->port.index;
 969
 970	ocelot_get_ethtool_stats(ocelot, port, data);
 971}
 972
 973static int ocelot_port_get_sset_count(struct net_device *dev, int sset)
 974{
 975	struct ocelot_port_private *priv = netdev_priv(dev);
 976	struct ocelot *ocelot = priv->port.ocelot;
 977	int port = priv->port.index;
 978
 979	return ocelot_get_sset_count(ocelot, port, sset);
 980}
 981
 982static int ocelot_port_get_ts_info(struct net_device *dev,
 983				   struct kernel_ethtool_ts_info *info)
 984{
 985	struct ocelot_port_private *priv = netdev_priv(dev);
 986	struct ocelot *ocelot = priv->port.ocelot;
 987	int port = priv->port.index;
 988
 989	if (!ocelot->ptp)
 990		return ethtool_op_get_ts_info(dev, info);
 991
 992	return ocelot_get_ts_info(ocelot, port, info);
 993}
 994
 995static const struct ethtool_ops ocelot_ethtool_ops = {
 996	.get_strings		= ocelot_port_get_strings,
 997	.get_ethtool_stats	= ocelot_port_get_ethtool_stats,
 998	.get_sset_count		= ocelot_port_get_sset_count,
 999	.get_link_ksettings	= phy_ethtool_get_link_ksettings,
1000	.set_link_ksettings	= phy_ethtool_set_link_ksettings,
1001	.get_ts_info		= ocelot_port_get_ts_info,
1002};
1003
1004static void ocelot_port_attr_stp_state_set(struct ocelot *ocelot, int port,
 
1005					   u8 state)
1006{
 
 
 
1007	ocelot_bridge_stp_state_set(ocelot, port, state);
1008}
1009
1010static void ocelot_port_attr_ageing_set(struct ocelot *ocelot, int port,
1011					unsigned long ageing_clock_t)
1012{
1013	unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
1014	u32 ageing_time = jiffies_to_msecs(ageing_jiffies);
1015
1016	ocelot_set_ageing_time(ocelot, ageing_time);
1017}
1018
1019static void ocelot_port_attr_mc_set(struct ocelot *ocelot, int port, bool mc)
1020{
1021	u32 cpu_fwd_mcast = ANA_PORT_CPU_FWD_CFG_CPU_IGMP_REDIR_ENA |
1022			    ANA_PORT_CPU_FWD_CFG_CPU_MLD_REDIR_ENA |
1023			    ANA_PORT_CPU_FWD_CFG_CPU_IPMC_CTRL_COPY_ENA;
1024	u32 val = 0;
1025
1026	if (mc)
1027		val = cpu_fwd_mcast;
1028
1029	ocelot_rmw_gix(ocelot, val, cpu_fwd_mcast,
1030		       ANA_PORT_CPU_FWD_CFG, port);
1031}
1032
1033static int ocelot_port_attr_set(struct net_device *dev, const void *ctx,
1034				const struct switchdev_attr *attr,
1035				struct netlink_ext_ack *extack)
1036{
1037	struct ocelot_port_private *priv = netdev_priv(dev);
1038	struct ocelot *ocelot = priv->port.ocelot;
1039	int port = priv->port.index;
1040	int err = 0;
1041
1042	if (ctx && ctx != priv)
1043		return 0;
1044
1045	switch (attr->id) {
1046	case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
1047		ocelot_port_attr_stp_state_set(ocelot, port, attr->u.stp_state);
 
1048		break;
1049	case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
1050		ocelot_port_attr_ageing_set(ocelot, port, attr->u.ageing_time);
1051		break;
1052	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
1053		ocelot_port_vlan_filtering(ocelot, port, attr->u.vlan_filtering,
1054					   extack);
1055		break;
1056	case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
1057		ocelot_port_attr_mc_set(ocelot, port, !attr->u.mc_disabled);
1058		break;
1059	case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
1060		err = ocelot_port_pre_bridge_flags(ocelot, port,
1061						   attr->u.brport_flags);
1062		break;
1063	case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
1064		ocelot_port_bridge_flags(ocelot, port, attr->u.brport_flags);
1065		break;
1066	default:
1067		err = -EOPNOTSUPP;
1068		break;
1069	}
1070
1071	return err;
1072}
1073
1074static int ocelot_vlan_vid_prepare(struct net_device *dev, u16 vid, bool pvid,
1075				   bool untagged, struct netlink_ext_ack *extack)
1076{
1077	struct ocelot_port_private *priv = netdev_priv(dev);
1078	struct ocelot_port *ocelot_port = &priv->port;
1079	struct ocelot *ocelot = ocelot_port->ocelot;
1080	int port = priv->port.index;
1081
1082	return ocelot_vlan_prepare(ocelot, port, vid, pvid, untagged, extack);
1083}
1084
1085static int ocelot_port_obj_add_vlan(struct net_device *dev,
1086				    const struct switchdev_obj_port_vlan *vlan,
1087				    struct netlink_ext_ack *extack)
1088{
1089	bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1090	bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1091	int ret;
 
1092
1093	ret = ocelot_vlan_vid_prepare(dev, vlan->vid, pvid, untagged, extack);
1094	if (ret)
1095		return ret;
 
 
 
 
1096
1097	return ocelot_vlan_vid_add(dev, vlan->vid, pvid, untagged);
1098}
1099
1100static int ocelot_port_obj_add_mdb(struct net_device *dev,
1101				   const struct switchdev_obj_port_mdb *mdb)
1102{
1103	struct ocelot_port_private *priv = netdev_priv(dev);
1104	struct ocelot_port *ocelot_port = &priv->port;
1105	struct ocelot *ocelot = ocelot_port->ocelot;
1106	int port = priv->port.index;
1107
1108	return ocelot_port_mdb_add(ocelot, port, mdb, ocelot_port->bridge);
1109}
1110
1111static int ocelot_port_obj_del_mdb(struct net_device *dev,
1112				   const struct switchdev_obj_port_mdb *mdb)
1113{
1114	struct ocelot_port_private *priv = netdev_priv(dev);
1115	struct ocelot_port *ocelot_port = &priv->port;
1116	struct ocelot *ocelot = ocelot_port->ocelot;
1117	int port = priv->port.index;
1118
1119	return ocelot_port_mdb_del(ocelot, port, mdb, ocelot_port->bridge);
1120}
1121
1122static int ocelot_port_obj_mrp_add(struct net_device *dev,
1123				   const struct switchdev_obj_mrp *mrp)
1124{
1125	struct ocelot_port_private *priv = netdev_priv(dev);
1126	struct ocelot_port *ocelot_port = &priv->port;
1127	struct ocelot *ocelot = ocelot_port->ocelot;
1128	int port = priv->port.index;
1129
1130	return ocelot_mrp_add(ocelot, port, mrp);
1131}
1132
1133static int ocelot_port_obj_mrp_del(struct net_device *dev,
1134				   const struct switchdev_obj_mrp *mrp)
 
1135{
1136	struct ocelot_port_private *priv = netdev_priv(dev);
1137	struct ocelot_port *ocelot_port = &priv->port;
1138	struct ocelot *ocelot = ocelot_port->ocelot;
1139	int port = priv->port.index;
1140
1141	return ocelot_mrp_del(ocelot, port, mrp);
1142}
1143
1144static int
1145ocelot_port_obj_mrp_add_ring_role(struct net_device *dev,
1146				  const struct switchdev_obj_ring_role_mrp *mrp)
1147{
1148	struct ocelot_port_private *priv = netdev_priv(dev);
1149	struct ocelot_port *ocelot_port = &priv->port;
1150	struct ocelot *ocelot = ocelot_port->ocelot;
1151	int port = priv->port.index;
1152
1153	return ocelot_mrp_add_ring_role(ocelot, port, mrp);
1154}
1155
1156static int
1157ocelot_port_obj_mrp_del_ring_role(struct net_device *dev,
1158				  const struct switchdev_obj_ring_role_mrp *mrp)
1159{
1160	struct ocelot_port_private *priv = netdev_priv(dev);
1161	struct ocelot_port *ocelot_port = &priv->port;
1162	struct ocelot *ocelot = ocelot_port->ocelot;
1163	int port = priv->port.index;
1164
1165	return ocelot_mrp_del_ring_role(ocelot, port, mrp);
1166}
1167
1168static int ocelot_port_obj_add(struct net_device *dev, const void *ctx,
1169			       const struct switchdev_obj *obj,
 
1170			       struct netlink_ext_ack *extack)
1171{
1172	struct ocelot_port_private *priv = netdev_priv(dev);
1173	int ret = 0;
1174
1175	if (ctx && ctx != priv)
1176		return 0;
1177
1178	switch (obj->id) {
1179	case SWITCHDEV_OBJ_ID_PORT_VLAN:
1180		ret = ocelot_port_obj_add_vlan(dev,
1181					       SWITCHDEV_OBJ_PORT_VLAN(obj),
1182					       extack);
1183		break;
1184	case SWITCHDEV_OBJ_ID_PORT_MDB:
1185		ret = ocelot_port_obj_add_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj));
1186		break;
1187	case SWITCHDEV_OBJ_ID_MRP:
1188		ret = ocelot_port_obj_mrp_add(dev, SWITCHDEV_OBJ_MRP(obj));
1189		break;
1190	case SWITCHDEV_OBJ_ID_RING_ROLE_MRP:
1191		ret = ocelot_port_obj_mrp_add_ring_role(dev,
1192							SWITCHDEV_OBJ_RING_ROLE_MRP(obj));
1193		break;
1194	default:
1195		return -EOPNOTSUPP;
1196	}
1197
1198	return ret;
1199}
1200
1201static int ocelot_port_obj_del(struct net_device *dev, const void *ctx,
1202			       const struct switchdev_obj *obj)
1203{
1204	struct ocelot_port_private *priv = netdev_priv(dev);
1205	int ret = 0;
1206
1207	if (ctx && ctx != priv)
1208		return 0;
1209
1210	switch (obj->id) {
1211	case SWITCHDEV_OBJ_ID_PORT_VLAN:
1212		ret = ocelot_vlan_vid_del(dev,
1213					  SWITCHDEV_OBJ_PORT_VLAN(obj)->vid);
1214		break;
1215	case SWITCHDEV_OBJ_ID_PORT_MDB:
1216		ret = ocelot_port_obj_del_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj));
1217		break;
1218	case SWITCHDEV_OBJ_ID_MRP:
1219		ret = ocelot_port_obj_mrp_del(dev, SWITCHDEV_OBJ_MRP(obj));
1220		break;
1221	case SWITCHDEV_OBJ_ID_RING_ROLE_MRP:
1222		ret = ocelot_port_obj_mrp_del_ring_role(dev,
1223							SWITCHDEV_OBJ_RING_ROLE_MRP(obj));
1224		break;
1225	default:
1226		return -EOPNOTSUPP;
1227	}
1228
1229	return ret;
1230}
1231
1232static void ocelot_inherit_brport_flags(struct ocelot *ocelot, int port,
1233					struct net_device *brport_dev)
1234{
1235	struct switchdev_brport_flags flags = {0};
1236	int flag;
1237
1238	flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
1239
1240	for_each_set_bit(flag, &flags.mask, 32)
1241		if (br_port_flag_is_set(brport_dev, BIT(flag)))
1242			flags.val |= BIT(flag);
1243
1244	ocelot_port_bridge_flags(ocelot, port, flags);
1245}
1246
1247static void ocelot_clear_brport_flags(struct ocelot *ocelot, int port)
1248{
1249	struct switchdev_brport_flags flags;
1250
1251	flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
1252	flags.val = flags.mask & ~BR_LEARNING;
1253
1254	ocelot_port_bridge_flags(ocelot, port, flags);
1255}
1256
1257static int ocelot_switchdev_sync(struct ocelot *ocelot, int port,
1258				 struct net_device *brport_dev,
1259				 struct net_device *bridge_dev,
1260				 struct netlink_ext_ack *extack)
1261{
1262	clock_t ageing_time;
1263	u8 stp_state;
1264
1265	ocelot_inherit_brport_flags(ocelot, port, brport_dev);
1266
1267	stp_state = br_port_get_stp_state(brport_dev);
1268	ocelot_bridge_stp_state_set(ocelot, port, stp_state);
1269
1270	ageing_time = br_get_ageing_time(bridge_dev);
1271	ocelot_port_attr_ageing_set(ocelot, port, ageing_time);
1272
1273	return ocelot_port_vlan_filtering(ocelot, port,
1274					  br_vlan_enabled(bridge_dev),
1275					  extack);
1276}
1277
1278static int ocelot_switchdev_unsync(struct ocelot *ocelot, int port)
1279{
1280	int err;
1281
1282	err = ocelot_port_vlan_filtering(ocelot, port, false, NULL);
1283	if (err)
1284		return err;
1285
1286	ocelot_clear_brport_flags(ocelot, port);
1287
1288	ocelot_bridge_stp_state_set(ocelot, port, BR_STATE_FORWARDING);
1289
1290	return 0;
1291}
1292
1293static int ocelot_bridge_num_get(struct ocelot *ocelot,
1294				 const struct net_device *bridge_dev)
1295{
1296	int bridge_num = ocelot_bridge_num_find(ocelot, bridge_dev);
1297
1298	if (bridge_num < 0) {
1299		/* First port that offloads this bridge */
1300		bridge_num = find_first_zero_bit(&ocelot->bridges,
1301						 ocelot->num_phys_ports);
1302
1303		set_bit(bridge_num, &ocelot->bridges);
1304	}
1305
1306	return bridge_num;
1307}
1308
1309static void ocelot_bridge_num_put(struct ocelot *ocelot,
1310				  const struct net_device *bridge_dev,
1311				  int bridge_num)
1312{
1313	/* Check if the bridge is still in use, otherwise it is time
1314	 * to clean it up so we can reuse this bridge_num later.
1315	 */
1316	if (!ocelot_bridge_num_find(ocelot, bridge_dev))
1317		clear_bit(bridge_num, &ocelot->bridges);
1318}
1319
1320static int ocelot_netdevice_bridge_join(struct net_device *dev,
1321					struct net_device *brport_dev,
1322					struct net_device *bridge,
1323					struct netlink_ext_ack *extack)
1324{
1325	struct ocelot_port_private *priv = netdev_priv(dev);
1326	struct ocelot_port *ocelot_port = &priv->port;
1327	struct ocelot *ocelot = ocelot_port->ocelot;
1328	int port = priv->port.index;
1329	int bridge_num, err;
1330
1331	bridge_num = ocelot_bridge_num_get(ocelot, bridge);
1332
1333	err = ocelot_port_bridge_join(ocelot, port, bridge, bridge_num,
1334				      extack);
1335	if (err)
1336		goto err_join;
1337
1338	err = switchdev_bridge_port_offload(brport_dev, dev, priv,
1339					    &ocelot_switchdev_nb,
1340					    &ocelot_switchdev_blocking_nb,
1341					    false, extack);
1342	if (err)
1343		goto err_switchdev_offload;
1344
1345	err = ocelot_switchdev_sync(ocelot, port, brport_dev, bridge, extack);
1346	if (err)
1347		goto err_switchdev_sync;
1348
1349	return 0;
1350
1351err_switchdev_sync:
1352	switchdev_bridge_port_unoffload(brport_dev, priv,
1353					&ocelot_switchdev_nb,
1354					&ocelot_switchdev_blocking_nb);
1355err_switchdev_offload:
1356	ocelot_port_bridge_leave(ocelot, port, bridge);
1357err_join:
1358	ocelot_bridge_num_put(ocelot, bridge, bridge_num);
1359	return err;
1360}
1361
1362static void ocelot_netdevice_pre_bridge_leave(struct net_device *dev,
1363					      struct net_device *brport_dev)
1364{
1365	struct ocelot_port_private *priv = netdev_priv(dev);
1366
1367	switchdev_bridge_port_unoffload(brport_dev, priv,
1368					&ocelot_switchdev_nb,
1369					&ocelot_switchdev_blocking_nb);
1370}
1371
1372static int ocelot_netdevice_bridge_leave(struct net_device *dev,
1373					 struct net_device *brport_dev,
1374					 struct net_device *bridge)
1375{
1376	struct ocelot_port_private *priv = netdev_priv(dev);
1377	struct ocelot_port *ocelot_port = &priv->port;
1378	struct ocelot *ocelot = ocelot_port->ocelot;
1379	int bridge_num = ocelot_port->bridge_num;
1380	int port = priv->port.index;
1381	int err;
1382
1383	err = ocelot_switchdev_unsync(ocelot, port);
1384	if (err)
1385		return err;
1386
1387	ocelot_port_bridge_leave(ocelot, port, bridge);
1388	ocelot_bridge_num_put(ocelot, bridge, bridge_num);
1389
1390	return 0;
1391}
1392
1393static int ocelot_netdevice_lag_join(struct net_device *dev,
1394				     struct net_device *bond,
1395				     struct netdev_lag_upper_info *info,
1396				     struct netlink_ext_ack *extack)
1397{
1398	struct ocelot_port_private *priv = netdev_priv(dev);
1399	struct ocelot_port *ocelot_port = &priv->port;
1400	struct ocelot *ocelot = ocelot_port->ocelot;
1401	struct net_device *bridge_dev;
1402	int port = priv->port.index;
1403	int err;
1404
1405	err = ocelot_port_lag_join(ocelot, port, bond, info, extack);
1406	if (err == -EOPNOTSUPP)
1407		/* Offloading not supported, fall back to software LAG */
1408		return 0;
1409
1410	bridge_dev = netdev_master_upper_dev_get(bond);
1411	if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
1412		return 0;
1413
1414	err = ocelot_netdevice_bridge_join(dev, bond, bridge_dev, extack);
1415	if (err)
1416		goto err_bridge_join;
1417
1418	return 0;
1419
1420err_bridge_join:
1421	ocelot_port_lag_leave(ocelot, port, bond);
1422	return err;
1423}
1424
1425static void ocelot_netdevice_pre_lag_leave(struct net_device *dev,
1426					   struct net_device *bond)
1427{
1428	struct net_device *bridge_dev;
1429
1430	bridge_dev = netdev_master_upper_dev_get(bond);
1431	if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
1432		return;
1433
1434	ocelot_netdevice_pre_bridge_leave(dev, bond);
1435}
1436
1437static int ocelot_netdevice_lag_leave(struct net_device *dev,
1438				      struct net_device *bond)
 
1439{
1440	struct ocelot_port_private *priv = netdev_priv(dev);
1441	struct ocelot_port *ocelot_port = &priv->port;
1442	struct ocelot *ocelot = ocelot_port->ocelot;
1443	struct net_device *bridge_dev;
1444	int port = priv->port.index;
1445
1446	ocelot_port_lag_leave(ocelot, port, bond);
1447
1448	bridge_dev = netdev_master_upper_dev_get(bond);
1449	if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
1450		return 0;
1451
1452	return ocelot_netdevice_bridge_leave(dev, bond, bridge_dev);
1453}
1454
1455static int ocelot_netdevice_changeupper(struct net_device *dev,
1456					struct net_device *brport_dev,
1457					struct netdev_notifier_changeupper_info *info)
1458{
1459	struct netlink_ext_ack *extack;
1460	int err = 0;
1461
1462	extack = netdev_notifier_info_to_extack(&info->info);
1463
1464	if (netif_is_bridge_master(info->upper_dev)) {
1465		if (info->linking)
1466			err = ocelot_netdevice_bridge_join(dev, brport_dev,
1467							   info->upper_dev,
1468							   extack);
1469		else
1470			err = ocelot_netdevice_bridge_leave(dev, brport_dev,
1471							    info->upper_dev);
1472	}
1473	if (netif_is_lag_master(info->upper_dev)) {
1474		if (info->linking)
1475			err = ocelot_netdevice_lag_join(dev, info->upper_dev,
1476							info->upper_info, extack);
1477		else
1478			ocelot_netdevice_lag_leave(dev, info->upper_dev);
1479	}
1480
1481	return notifier_from_errno(err);
1482}
1483
1484/* Treat CHANGEUPPER events on an offloaded LAG as individual CHANGEUPPER
1485 * events for the lower physical ports of the LAG.
1486 * If the LAG upper isn't offloaded, ignore its CHANGEUPPER events.
1487 * In case the LAG joined a bridge, notify that we are offloading it and can do
1488 * forwarding in hardware towards it.
1489 */
1490static int
1491ocelot_netdevice_lag_changeupper(struct net_device *dev,
1492				 struct netdev_notifier_changeupper_info *info)
1493{
1494	struct net_device *lower;
1495	struct list_head *iter;
1496	int err = NOTIFY_DONE;
1497
1498	netdev_for_each_lower_dev(dev, lower, iter) {
1499		struct ocelot_port_private *priv = netdev_priv(lower);
1500		struct ocelot_port *ocelot_port = &priv->port;
1501
1502		if (ocelot_port->bond != dev)
1503			return NOTIFY_OK;
1504
1505		err = ocelot_netdevice_changeupper(lower, dev, info);
1506		if (err)
1507			return notifier_from_errno(err);
1508	}
1509
1510	return NOTIFY_DONE;
1511}
1512
1513static int
1514ocelot_netdevice_prechangeupper(struct net_device *dev,
1515				struct net_device *brport_dev,
1516				struct netdev_notifier_changeupper_info *info)
1517{
1518	if (netif_is_bridge_master(info->upper_dev) && !info->linking)
1519		ocelot_netdevice_pre_bridge_leave(dev, brport_dev);
1520
1521	if (netif_is_lag_master(info->upper_dev) && !info->linking)
1522		ocelot_netdevice_pre_lag_leave(dev, info->upper_dev);
1523
1524	return NOTIFY_DONE;
1525}
1526
1527static int
1528ocelot_netdevice_lag_prechangeupper(struct net_device *dev,
1529				    struct netdev_notifier_changeupper_info *info)
1530{
1531	struct net_device *lower;
1532	struct list_head *iter;
1533	int err = NOTIFY_DONE;
1534
1535	netdev_for_each_lower_dev(dev, lower, iter) {
1536		struct ocelot_port_private *priv = netdev_priv(lower);
1537		struct ocelot_port *ocelot_port = &priv->port;
1538
1539		if (ocelot_port->bond != dev)
1540			return NOTIFY_OK;
1541
1542		err = ocelot_netdevice_prechangeupper(dev, lower, info);
1543		if (err)
1544			return err;
1545	}
1546
1547	return NOTIFY_DONE;
1548}
1549
1550static int
1551ocelot_netdevice_changelowerstate(struct net_device *dev,
1552				  struct netdev_lag_lower_state_info *info)
1553{
1554	struct ocelot_port_private *priv = netdev_priv(dev);
1555	bool is_active = info->link_up && info->tx_enabled;
1556	struct ocelot_port *ocelot_port = &priv->port;
1557	struct ocelot *ocelot = ocelot_port->ocelot;
1558	int port = priv->port.index;
1559
1560	if (!ocelot_port->bond)
1561		return NOTIFY_DONE;
1562
1563	if (ocelot_port->lag_tx_active == is_active)
1564		return NOTIFY_DONE;
1565
1566	ocelot_port_lag_change(ocelot, port, is_active);
1567
1568	return NOTIFY_OK;
1569}
1570
1571static int ocelot_netdevice_event(struct notifier_block *unused,
1572				  unsigned long event, void *ptr)
1573{
 
1574	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
1575
1576	switch (event) {
1577	case NETDEV_PRECHANGEUPPER: {
1578		struct netdev_notifier_changeupper_info *info = ptr;
1579
1580		if (ocelot_netdevice_dev_check(dev))
1581			return ocelot_netdevice_prechangeupper(dev, dev, info);
1582
1583		if (netif_is_lag_master(dev))
1584			return ocelot_netdevice_lag_prechangeupper(dev, info);
1585
1586		break;
1587	}
1588	case NETDEV_CHANGEUPPER: {
1589		struct netdev_notifier_changeupper_info *info = ptr;
1590
1591		if (ocelot_netdevice_dev_check(dev))
1592			return ocelot_netdevice_changeupper(dev, dev, info);
1593
1594		if (netif_is_lag_master(dev))
1595			return ocelot_netdevice_lag_changeupper(dev, info);
 
 
 
 
 
 
 
1596
1597		break;
 
 
1598	}
1599	case NETDEV_CHANGELOWERSTATE: {
1600		struct netdev_notifier_changelowerstate_info *info = ptr;
1601
1602		if (!ocelot_netdevice_dev_check(dev))
1603			break;
1604
1605		return ocelot_netdevice_changelowerstate(dev,
1606							 info->lower_state_info);
1607	}
1608	default:
1609		break;
 
 
 
 
 
 
1610	}
1611
1612	return NOTIFY_DONE;
 
1613}
1614
1615struct notifier_block ocelot_netdevice_nb __read_mostly = {
1616	.notifier_call = ocelot_netdevice_event,
1617};
1618
1619static int ocelot_switchdev_event(struct notifier_block *unused,
1620				  unsigned long event, void *ptr)
1621{
1622	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1623	int err;
1624
1625	switch (event) {
1626	case SWITCHDEV_PORT_ATTR_SET:
1627		err = switchdev_handle_port_attr_set(dev, ptr,
1628						     ocelot_netdevice_dev_check,
1629						     ocelot_port_attr_set);
1630		return notifier_from_errno(err);
1631	}
1632
1633	return NOTIFY_DONE;
1634}
1635
1636struct notifier_block ocelot_switchdev_nb __read_mostly = {
1637	.notifier_call = ocelot_switchdev_event,
1638};
1639
1640static int ocelot_switchdev_blocking_event(struct notifier_block *unused,
1641					   unsigned long event, void *ptr)
1642{
1643	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1644	int err;
1645
1646	switch (event) {
1647		/* Blocking events. */
1648	case SWITCHDEV_PORT_OBJ_ADD:
1649		err = switchdev_handle_port_obj_add(dev, ptr,
1650						    ocelot_netdevice_dev_check,
1651						    ocelot_port_obj_add);
1652		return notifier_from_errno(err);
1653	case SWITCHDEV_PORT_OBJ_DEL:
1654		err = switchdev_handle_port_obj_del(dev, ptr,
1655						    ocelot_netdevice_dev_check,
1656						    ocelot_port_obj_del);
1657		return notifier_from_errno(err);
1658	case SWITCHDEV_PORT_ATTR_SET:
1659		err = switchdev_handle_port_attr_set(dev, ptr,
1660						     ocelot_netdevice_dev_check,
1661						     ocelot_port_attr_set);
1662		return notifier_from_errno(err);
1663	}
1664
1665	return NOTIFY_DONE;
1666}
1667
1668struct notifier_block ocelot_switchdev_blocking_nb __read_mostly = {
1669	.notifier_call = ocelot_switchdev_blocking_event,
1670};
1671
1672static void vsc7514_phylink_mac_config(struct phylink_config *config,
1673				       unsigned int link_an_mode,
1674				       const struct phylink_link_state *state)
1675{
1676	struct net_device *ndev = to_net_dev(config->dev);
1677	struct ocelot_port_private *priv = netdev_priv(ndev);
1678	struct ocelot *ocelot = priv->port.ocelot;
1679	int port = priv->port.index;
1680
1681	ocelot_phylink_mac_config(ocelot, port, link_an_mode, state);
1682}
1683
1684static void vsc7514_phylink_mac_link_down(struct phylink_config *config,
1685					  unsigned int link_an_mode,
1686					  phy_interface_t interface)
1687{
1688	struct net_device *ndev = to_net_dev(config->dev);
1689	struct ocelot_port_private *priv = netdev_priv(ndev);
1690	struct ocelot *ocelot = priv->port.ocelot;
1691	int port = priv->port.index;
1692
1693	ocelot_phylink_mac_link_down(ocelot, port, link_an_mode, interface,
1694				     OCELOT_MAC_QUIRKS);
1695}
1696
1697static void vsc7514_phylink_mac_link_up(struct phylink_config *config,
1698					struct phy_device *phydev,
1699					unsigned int link_an_mode,
1700					phy_interface_t interface,
1701					int speed, int duplex,
1702					bool tx_pause, bool rx_pause)
1703{
1704	struct net_device *ndev = to_net_dev(config->dev);
1705	struct ocelot_port_private *priv = netdev_priv(ndev);
1706	struct ocelot *ocelot = priv->port.ocelot;
1707	int port = priv->port.index;
1708
1709	ocelot_phylink_mac_link_up(ocelot, port, phydev, link_an_mode,
1710				   interface, speed, duplex,
1711				   tx_pause, rx_pause, OCELOT_MAC_QUIRKS);
1712}
1713
1714static const struct phylink_mac_ops ocelot_phylink_ops = {
1715	.mac_config		= vsc7514_phylink_mac_config,
1716	.mac_link_down		= vsc7514_phylink_mac_link_down,
1717	.mac_link_up		= vsc7514_phylink_mac_link_up,
1718};
1719
1720static int ocelot_port_phylink_create(struct ocelot *ocelot, int port,
1721				      struct device_node *portnp)
1722{
1723	struct ocelot_port *ocelot_port = ocelot->ports[port];
1724	struct ocelot_port_private *priv;
1725	struct device *dev = ocelot->dev;
1726	phy_interface_t phy_mode;
1727	struct phylink *phylink;
1728	int err;
1729
1730	of_get_phy_mode(portnp, &phy_mode);
1731	/* DT bindings of internal PHY ports are broken and don't
1732	 * specify a phy-mode
1733	 */
1734	if (phy_mode == PHY_INTERFACE_MODE_NA)
1735		phy_mode = PHY_INTERFACE_MODE_INTERNAL;
1736
1737	if (phy_mode != PHY_INTERFACE_MODE_SGMII &&
1738	    phy_mode != PHY_INTERFACE_MODE_QSGMII &&
1739	    phy_mode != PHY_INTERFACE_MODE_INTERNAL) {
1740		dev_err(dev, "unsupported phy mode %s for port %d\n",
1741			phy_modes(phy_mode), port);
1742		return -EINVAL;
1743	}
1744
1745	ocelot_port->phy_mode = phy_mode;
1746
1747	err = ocelot_port_configure_serdes(ocelot, port, portnp);
1748	if (err)
1749		return err;
1750
1751	priv = container_of(ocelot_port, struct ocelot_port_private, port);
1752
1753	priv->phylink_config.dev = &priv->dev->dev;
1754	priv->phylink_config.type = PHYLINK_NETDEV;
1755	priv->phylink_config.mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |
1756		MAC_10 | MAC_100 | MAC_1000FD | MAC_2500FD;
1757
1758	__set_bit(ocelot_port->phy_mode,
1759		  priv->phylink_config.supported_interfaces);
1760
1761	phylink = phylink_create(&priv->phylink_config,
1762				 of_fwnode_handle(portnp),
1763				 phy_mode, &ocelot_phylink_ops);
1764	if (IS_ERR(phylink)) {
1765		err = PTR_ERR(phylink);
1766		dev_err(dev, "Could not create phylink (%pe)\n", phylink);
1767		return err;
1768	}
1769
1770	priv->phylink = phylink;
1771
1772	err = phylink_of_phy_connect(phylink, portnp, 0);
1773	if (err) {
1774		dev_err(dev, "Could not connect to PHY: %pe\n", ERR_PTR(err));
1775		phylink_destroy(phylink);
1776		priv->phylink = NULL;
1777		return err;
1778	}
1779
1780	return 0;
1781}
1782
1783int ocelot_probe_port(struct ocelot *ocelot, int port, struct regmap *target,
1784		      struct device_node *portnp)
1785{
1786	struct ocelot_port_private *priv;
1787	struct ocelot_port *ocelot_port;
1788	struct net_device *dev;
1789	int err;
1790
1791	dev = alloc_etherdev(sizeof(struct ocelot_port_private));
1792	if (!dev)
1793		return -ENOMEM;
1794	SET_NETDEV_DEV(dev, ocelot->dev);
1795	priv = netdev_priv(dev);
1796	priv->dev = dev;
 
 
1797	ocelot_port = &priv->port;
1798	ocelot_port->ocelot = ocelot;
1799	ocelot_port->index = port;
1800	ocelot_port->target = target;
1801	ocelot->ports[port] = ocelot_port;
1802
1803	dev->netdev_ops = &ocelot_port_netdev_ops;
1804	dev->ethtool_ops = &ocelot_ethtool_ops;
1805	dev->max_mtu = OCELOT_JUMBO_MTU;
1806
1807	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_RXFCS |
1808		NETIF_F_HW_TC;
1809	dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_TC;
1810
1811	err = of_get_ethdev_address(portnp, dev);
1812	if (err)
1813		eth_hw_addr_gen(dev, ocelot->base_mac, port);
1814
1815	ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr,
1816			  OCELOT_STANDALONE_PVID, ENTRYTYPE_LOCKED);
1817
1818	ocelot_init_port(ocelot, port);
1819
1820	err = ocelot_port_phylink_create(ocelot, port, portnp);
1821	if (err)
1822		goto out;
1823
1824	if (ocelot->fdma)
1825		ocelot_fdma_netdev_init(ocelot, dev);
1826
1827	SET_NETDEV_DEVLINK_PORT(dev, &ocelot->devlink_ports[port]);
1828	err = register_netdev(dev);
1829	if (err) {
1830		dev_err(ocelot->dev, "register_netdev failed\n");
1831		goto out_fdma_deinit;
1832	}
1833
1834	return 0;
1835
1836out_fdma_deinit:
1837	if (ocelot->fdma)
1838		ocelot_fdma_netdev_deinit(ocelot, dev);
1839out:
1840	ocelot->ports[port] = NULL;
1841	free_netdev(dev);
1842
1843	return err;
1844}
1845
1846void ocelot_release_port(struct ocelot_port *ocelot_port)
1847{
1848	struct ocelot_port_private *priv = container_of(ocelot_port,
1849						struct ocelot_port_private,
1850						port);
1851	struct ocelot *ocelot = ocelot_port->ocelot;
1852	struct ocelot_fdma *fdma = ocelot->fdma;
1853
1854	unregister_netdev(priv->dev);
1855
1856	if (fdma)
1857		ocelot_fdma_netdev_deinit(ocelot, priv->dev);
1858
1859	if (priv->phylink) {
1860		rtnl_lock();
1861		phylink_disconnect_phy(priv->phylink);
1862		rtnl_unlock();
1863
1864		phylink_destroy(priv->phylink);
1865	}
1866
1867	free_netdev(priv->dev);
1868}