1// SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2/*
   3 * DSA driver for:
   4 * Hirschmann Hellcreek TSN switch.
   5 *
   6 * Copyright (C) 2019-2021 Linutronix GmbH
   7 * Author Kurt Kanzenbach <kurt@linutronix.de>
   8 */
   9
  10#include <linux/kernel.h>
  11#include <linux/module.h>
  12#include <linux/device.h>
  13#include <linux/of.h>
 
  14#include <linux/of_mdio.h>
  15#include <linux/platform_device.h>
  16#include <linux/bitops.h>
  17#include <linux/if_bridge.h>
  18#include <linux/if_vlan.h>
  19#include <linux/etherdevice.h>
  20#include <linux/random.h>
  21#include <linux/iopoll.h>
  22#include <linux/mutex.h>
  23#include <linux/delay.h>
  24#include <net/dsa.h>
  25
  26#include "hellcreek.h"
  27#include "hellcreek_ptp.h"
  28#include "hellcreek_hwtstamp.h"
  29
  30static const struct hellcreek_counter hellcreek_counter[] = {
  31	{ 0x00, "RxFiltered", },
  32	{ 0x01, "RxOctets1k", },
  33	{ 0x02, "RxVTAG", },
  34	{ 0x03, "RxL2BAD", },
  35	{ 0x04, "RxOverloadDrop", },
  36	{ 0x05, "RxUC", },
  37	{ 0x06, "RxMC", },
  38	{ 0x07, "RxBC", },
  39	{ 0x08, "RxRS<64", },
  40	{ 0x09, "RxRS64", },
  41	{ 0x0a, "RxRS65_127", },
  42	{ 0x0b, "RxRS128_255", },
  43	{ 0x0c, "RxRS256_511", },
  44	{ 0x0d, "RxRS512_1023", },
  45	{ 0x0e, "RxRS1024_1518", },
  46	{ 0x0f, "RxRS>1518", },
  47	{ 0x10, "TxTailDropQueue0", },
  48	{ 0x11, "TxTailDropQueue1", },
  49	{ 0x12, "TxTailDropQueue2", },
  50	{ 0x13, "TxTailDropQueue3", },
  51	{ 0x14, "TxTailDropQueue4", },
  52	{ 0x15, "TxTailDropQueue5", },
  53	{ 0x16, "TxTailDropQueue6", },
  54	{ 0x17, "TxTailDropQueue7", },
  55	{ 0x18, "RxTrafficClass0", },
  56	{ 0x19, "RxTrafficClass1", },
  57	{ 0x1a, "RxTrafficClass2", },
  58	{ 0x1b, "RxTrafficClass3", },
  59	{ 0x1c, "RxTrafficClass4", },
  60	{ 0x1d, "RxTrafficClass5", },
  61	{ 0x1e, "RxTrafficClass6", },
  62	{ 0x1f, "RxTrafficClass7", },
  63	{ 0x21, "TxOctets1k", },
  64	{ 0x22, "TxVTAG", },
  65	{ 0x23, "TxL2BAD", },
  66	{ 0x25, "TxUC", },
  67	{ 0x26, "TxMC", },
  68	{ 0x27, "TxBC", },
  69	{ 0x28, "TxTS<64", },
  70	{ 0x29, "TxTS64", },
  71	{ 0x2a, "TxTS65_127", },
  72	{ 0x2b, "TxTS128_255", },
  73	{ 0x2c, "TxTS256_511", },
  74	{ 0x2d, "TxTS512_1023", },
  75	{ 0x2e, "TxTS1024_1518", },
  76	{ 0x2f, "TxTS>1518", },
  77	{ 0x30, "TxTrafficClassOverrun0", },
  78	{ 0x31, "TxTrafficClassOverrun1", },
  79	{ 0x32, "TxTrafficClassOverrun2", },
  80	{ 0x33, "TxTrafficClassOverrun3", },
  81	{ 0x34, "TxTrafficClassOverrun4", },
  82	{ 0x35, "TxTrafficClassOverrun5", },
  83	{ 0x36, "TxTrafficClassOverrun6", },
  84	{ 0x37, "TxTrafficClassOverrun7", },
  85	{ 0x38, "TxTrafficClass0", },
  86	{ 0x39, "TxTrafficClass1", },
  87	{ 0x3a, "TxTrafficClass2", },
  88	{ 0x3b, "TxTrafficClass3", },
  89	{ 0x3c, "TxTrafficClass4", },
  90	{ 0x3d, "TxTrafficClass5", },
  91	{ 0x3e, "TxTrafficClass6", },
  92	{ 0x3f, "TxTrafficClass7", },
  93};
  94
  95static u16 hellcreek_read(struct hellcreek *hellcreek, unsigned int offset)
  96{
  97	return readw(hellcreek->base + offset);
  98}
  99
 100static u16 hellcreek_read_ctrl(struct hellcreek *hellcreek)
 101{
 102	return readw(hellcreek->base + HR_CTRL_C);
 103}
 104
 105static u16 hellcreek_read_stat(struct hellcreek *hellcreek)
 106{
 107	return readw(hellcreek->base + HR_SWSTAT);
 108}
 109
 110static void hellcreek_write(struct hellcreek *hellcreek, u16 data,
 111			    unsigned int offset)
 112{
 113	writew(data, hellcreek->base + offset);
 114}
 115
 116static void hellcreek_select_port(struct hellcreek *hellcreek, int port)
 117{
 118	u16 val = port << HR_PSEL_PTWSEL_SHIFT;
 119
 120	hellcreek_write(hellcreek, val, HR_PSEL);
 121}
 122
 123static void hellcreek_select_prio(struct hellcreek *hellcreek, int prio)
 124{
 125	u16 val = prio << HR_PSEL_PRTCWSEL_SHIFT;
 126
 127	hellcreek_write(hellcreek, val, HR_PSEL);
 128}
 129
 130static void hellcreek_select_port_prio(struct hellcreek *hellcreek, int port,
 131				       int prio)
 132{
 133	u16 val = port << HR_PSEL_PTWSEL_SHIFT;
 134
 135	val |= prio << HR_PSEL_PRTCWSEL_SHIFT;
 136
 137	hellcreek_write(hellcreek, val, HR_PSEL);
 138}
 139
 140static void hellcreek_select_counter(struct hellcreek *hellcreek, int counter)
 141{
 142	u16 val = counter << HR_CSEL_SHIFT;
 143
 144	hellcreek_write(hellcreek, val, HR_CSEL);
 145
 146	/* Data sheet states to wait at least 20 internal clock cycles */
 147	ndelay(200);
 148}
 149
 150static void hellcreek_select_vlan(struct hellcreek *hellcreek, int vid,
 151				  bool pvid)
 152{
 153	u16 val = 0;
 154
 155	/* Set pvid bit first */
 156	if (pvid)
 157		val |= HR_VIDCFG_PVID;
 158	hellcreek_write(hellcreek, val, HR_VIDCFG);
 159
 160	/* Set vlan */
 161	val |= vid << HR_VIDCFG_VID_SHIFT;
 162	hellcreek_write(hellcreek, val, HR_VIDCFG);
 163}
 164
 165static void hellcreek_select_tgd(struct hellcreek *hellcreek, int port)
 166{
 167	u16 val = port << TR_TGDSEL_TDGSEL_SHIFT;
 168
 169	hellcreek_write(hellcreek, val, TR_TGDSEL);
 170}
 171
 172static int hellcreek_wait_until_ready(struct hellcreek *hellcreek)
 173{
 174	u16 val;
 175
 176	/* Wait up to 1ms, although 3 us should be enough */
 177	return readx_poll_timeout(hellcreek_read_ctrl, hellcreek,
 178				  val, val & HR_CTRL_C_READY,
 179				  3, 1000);
 180}
 181
 182static int hellcreek_wait_until_transitioned(struct hellcreek *hellcreek)
 183{
 184	u16 val;
 185
 186	return readx_poll_timeout_atomic(hellcreek_read_ctrl, hellcreek,
 187					 val, !(val & HR_CTRL_C_TRANSITION),
 188					 1, 1000);
 189}
 190
 191static int hellcreek_wait_fdb_ready(struct hellcreek *hellcreek)
 192{
 193	u16 val;
 194
 195	return readx_poll_timeout_atomic(hellcreek_read_stat, hellcreek,
 196					 val, !(val & HR_SWSTAT_BUSY),
 197					 1, 1000);
 198}
 199
 200static int hellcreek_detect(struct hellcreek *hellcreek)
 201{
 202	u16 id, rel_low, rel_high, date_low, date_high, tgd_ver;
 203	u8 tgd_maj, tgd_min;
 204	u32 rel, date;
 205
 206	id	  = hellcreek_read(hellcreek, HR_MODID_C);
 207	rel_low	  = hellcreek_read(hellcreek, HR_REL_L_C);
 208	rel_high  = hellcreek_read(hellcreek, HR_REL_H_C);
 209	date_low  = hellcreek_read(hellcreek, HR_BLD_L_C);
 210	date_high = hellcreek_read(hellcreek, HR_BLD_H_C);
 211	tgd_ver   = hellcreek_read(hellcreek, TR_TGDVER);
 212
 213	if (id != hellcreek->pdata->module_id)
 214		return -ENODEV;
 215
 216	rel	= rel_low | (rel_high << 16);
 217	date	= date_low | (date_high << 16);
 218	tgd_maj = (tgd_ver & TR_TGDVER_REV_MAJ_MASK) >> TR_TGDVER_REV_MAJ_SHIFT;
 219	tgd_min = (tgd_ver & TR_TGDVER_REV_MIN_MASK) >> TR_TGDVER_REV_MIN_SHIFT;
 220
 221	dev_info(hellcreek->dev, "Module ID=%02x Release=%04x Date=%04x TGD Version=%02x.%02x\n",
 222		 id, rel, date, tgd_maj, tgd_min);
 223
 224	return 0;
 225}
 226
 227static void hellcreek_feature_detect(struct hellcreek *hellcreek)
 228{
 229	u16 features;
 230
 231	features = hellcreek_read(hellcreek, HR_FEABITS0);
 232
 233	/* Only detect the size of the FDB table. The size and current
 234	 * utilization can be queried via devlink.
 235	 */
 236	hellcreek->fdb_entries = ((features & HR_FEABITS0_FDBBINS_MASK) >>
 237			       HR_FEABITS0_FDBBINS_SHIFT) * 32;
 238}
 239
 240static enum dsa_tag_protocol hellcreek_get_tag_protocol(struct dsa_switch *ds,
 241							int port,
 242							enum dsa_tag_protocol mp)
 243{
 244	return DSA_TAG_PROTO_HELLCREEK;
 245}
 246
 247static int hellcreek_port_enable(struct dsa_switch *ds, int port,
 248				 struct phy_device *phy)
 249{
 250	struct hellcreek *hellcreek = ds->priv;
 251	struct hellcreek_port *hellcreek_port;
 252	u16 val;
 253
 254	hellcreek_port = &hellcreek->ports[port];
 255
 256	dev_dbg(hellcreek->dev, "Enable port %d\n", port);
 257
 258	mutex_lock(&hellcreek->reg_lock);
 259
 260	hellcreek_select_port(hellcreek, port);
 261	val = hellcreek_port->ptcfg;
 262	val |= HR_PTCFG_ADMIN_EN;
 263	hellcreek_write(hellcreek, val, HR_PTCFG);
 264	hellcreek_port->ptcfg = val;
 265
 266	mutex_unlock(&hellcreek->reg_lock);
 267
 268	return 0;
 269}
 270
 271static void hellcreek_port_disable(struct dsa_switch *ds, int port)
 272{
 273	struct hellcreek *hellcreek = ds->priv;
 274	struct hellcreek_port *hellcreek_port;
 275	u16 val;
 276
 277	hellcreek_port = &hellcreek->ports[port];
 278
 279	dev_dbg(hellcreek->dev, "Disable port %d\n", port);
 280
 281	mutex_lock(&hellcreek->reg_lock);
 282
 283	hellcreek_select_port(hellcreek, port);
 284	val = hellcreek_port->ptcfg;
 285	val &= ~HR_PTCFG_ADMIN_EN;
 286	hellcreek_write(hellcreek, val, HR_PTCFG);
 287	hellcreek_port->ptcfg = val;
 288
 289	mutex_unlock(&hellcreek->reg_lock);
 290}
 291
 292static void hellcreek_get_strings(struct dsa_switch *ds, int port,
 293				  u32 stringset, uint8_t *data)
 294{
 295	int i;
 296
 297	for (i = 0; i < ARRAY_SIZE(hellcreek_counter); ++i)
 298		ethtool_puts(&data, hellcreek_counter[i].name);
 
 
 
 
 299}
 300
 301static int hellcreek_get_sset_count(struct dsa_switch *ds, int port, int sset)
 302{
 303	if (sset != ETH_SS_STATS)
 304		return 0;
 305
 306	return ARRAY_SIZE(hellcreek_counter);
 307}
 308
 309static void hellcreek_get_ethtool_stats(struct dsa_switch *ds, int port,
 310					uint64_t *data)
 311{
 312	struct hellcreek *hellcreek = ds->priv;
 313	struct hellcreek_port *hellcreek_port;
 314	int i;
 315
 316	hellcreek_port = &hellcreek->ports[port];
 317
 318	for (i = 0; i < ARRAY_SIZE(hellcreek_counter); ++i) {
 319		const struct hellcreek_counter *counter = &hellcreek_counter[i];
 320		u8 offset = counter->offset + port * 64;
 321		u16 high, low;
 322		u64 value;
 323
 324		mutex_lock(&hellcreek->reg_lock);
 325
 326		hellcreek_select_counter(hellcreek, offset);
 327
 328		/* The registers are locked internally by selecting the
 329		 * counter. So low and high can be read without reading high
 330		 * again.
 331		 */
 332		high  = hellcreek_read(hellcreek, HR_CRDH);
 333		low   = hellcreek_read(hellcreek, HR_CRDL);
 334		value = ((u64)high << 16) | low;
 335
 336		hellcreek_port->counter_values[i] += value;
 337		data[i] = hellcreek_port->counter_values[i];
 338
 339		mutex_unlock(&hellcreek->reg_lock);
 340	}
 341}
 342
 343static u16 hellcreek_private_vid(int port)
 344{
 345	return VLAN_N_VID - port + 1;
 346}
 347
 348static int hellcreek_vlan_prepare(struct dsa_switch *ds, int port,
 349				  const struct switchdev_obj_port_vlan *vlan,
 350				  struct netlink_ext_ack *extack)
 351{
 352	struct hellcreek *hellcreek = ds->priv;
 353	int i;
 354
 355	dev_dbg(hellcreek->dev, "VLAN prepare for port %d\n", port);
 356
 357	/* Restriction: Make sure that nobody uses the "private" VLANs. These
 358	 * VLANs are internally used by the driver to ensure port
 359	 * separation. Thus, they cannot be used by someone else.
 360	 */
 361	for (i = 0; i < hellcreek->pdata->num_ports; ++i) {
 362		const u16 restricted_vid = hellcreek_private_vid(i);
 363
 364		if (!dsa_is_user_port(ds, i))
 365			continue;
 366
 367		if (vlan->vid == restricted_vid) {
 368			NL_SET_ERR_MSG_MOD(extack, "VID restricted by driver");
 369			return -EBUSY;
 370		}
 371	}
 372
 373	return 0;
 374}
 375
 376static void hellcreek_select_vlan_params(struct hellcreek *hellcreek, int port,
 377					 int *shift, int *mask)
 378{
 379	switch (port) {
 380	case 0:
 381		*shift = HR_VIDMBRCFG_P0MBR_SHIFT;
 382		*mask  = HR_VIDMBRCFG_P0MBR_MASK;
 383		break;
 384	case 1:
 385		*shift = HR_VIDMBRCFG_P1MBR_SHIFT;
 386		*mask  = HR_VIDMBRCFG_P1MBR_MASK;
 387		break;
 388	case 2:
 389		*shift = HR_VIDMBRCFG_P2MBR_SHIFT;
 390		*mask  = HR_VIDMBRCFG_P2MBR_MASK;
 391		break;
 392	case 3:
 393		*shift = HR_VIDMBRCFG_P3MBR_SHIFT;
 394		*mask  = HR_VIDMBRCFG_P3MBR_MASK;
 395		break;
 396	default:
 397		*shift = *mask = 0;
 398		dev_err(hellcreek->dev, "Unknown port %d selected!\n", port);
 399	}
 400}
 401
 402static void hellcreek_apply_vlan(struct hellcreek *hellcreek, int port, u16 vid,
 403				 bool pvid, bool untagged)
 404{
 405	int shift, mask;
 406	u16 val;
 407
 408	dev_dbg(hellcreek->dev, "Apply VLAN: port=%d vid=%u pvid=%d untagged=%d",
 409		port, vid, pvid, untagged);
 410
 411	mutex_lock(&hellcreek->reg_lock);
 412
 413	hellcreek_select_port(hellcreek, port);
 414	hellcreek_select_vlan(hellcreek, vid, pvid);
 415
 416	/* Setup port vlan membership */
 417	hellcreek_select_vlan_params(hellcreek, port, &shift, &mask);
 418	val = hellcreek->vidmbrcfg[vid];
 419	val &= ~mask;
 420	if (untagged)
 421		val |= HELLCREEK_VLAN_UNTAGGED_MEMBER << shift;
 422	else
 423		val |= HELLCREEK_VLAN_TAGGED_MEMBER << shift;
 424
 425	hellcreek_write(hellcreek, val, HR_VIDMBRCFG);
 426	hellcreek->vidmbrcfg[vid] = val;
 427
 428	mutex_unlock(&hellcreek->reg_lock);
 429}
 430
 431static void hellcreek_unapply_vlan(struct hellcreek *hellcreek, int port,
 432				   u16 vid)
 433{
 434	int shift, mask;
 435	u16 val;
 436
 437	dev_dbg(hellcreek->dev, "Unapply VLAN: port=%d vid=%u\n", port, vid);
 438
 439	mutex_lock(&hellcreek->reg_lock);
 440
 441	hellcreek_select_vlan(hellcreek, vid, false);
 442
 443	/* Setup port vlan membership */
 444	hellcreek_select_vlan_params(hellcreek, port, &shift, &mask);
 445	val = hellcreek->vidmbrcfg[vid];
 446	val &= ~mask;
 447	val |= HELLCREEK_VLAN_NO_MEMBER << shift;
 448
 449	hellcreek_write(hellcreek, val, HR_VIDMBRCFG);
 450	hellcreek->vidmbrcfg[vid] = val;
 451
 452	mutex_unlock(&hellcreek->reg_lock);
 453}
 454
 455static int hellcreek_vlan_add(struct dsa_switch *ds, int port,
 456			      const struct switchdev_obj_port_vlan *vlan,
 457			      struct netlink_ext_ack *extack)
 458{
 459	bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
 460	bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
 461	struct hellcreek *hellcreek = ds->priv;
 462	int err;
 463
 464	err = hellcreek_vlan_prepare(ds, port, vlan, extack);
 465	if (err)
 466		return err;
 467
 468	dev_dbg(hellcreek->dev, "Add VLAN %d on port %d, %s, %s\n",
 469		vlan->vid, port, untagged ? "untagged" : "tagged",
 470		pvid ? "PVID" : "no PVID");
 471
 472	hellcreek_apply_vlan(hellcreek, port, vlan->vid, pvid, untagged);
 473
 474	return 0;
 475}
 476
 477static int hellcreek_vlan_del(struct dsa_switch *ds, int port,
 478			      const struct switchdev_obj_port_vlan *vlan)
 479{
 480	struct hellcreek *hellcreek = ds->priv;
 481
 482	dev_dbg(hellcreek->dev, "Remove VLAN %d on port %d\n", vlan->vid, port);
 483
 484	hellcreek_unapply_vlan(hellcreek, port, vlan->vid);
 485
 486	return 0;
 487}
 488
 489static void hellcreek_port_stp_state_set(struct dsa_switch *ds, int port,
 490					 u8 state)
 491{
 492	struct hellcreek *hellcreek = ds->priv;
 493	struct hellcreek_port *hellcreek_port;
 494	const char *new_state;
 495	u16 val;
 496
 497	mutex_lock(&hellcreek->reg_lock);
 498
 499	hellcreek_port = &hellcreek->ports[port];
 500	val = hellcreek_port->ptcfg;
 501
 502	switch (state) {
 503	case BR_STATE_DISABLED:
 504		new_state = "DISABLED";
 505		val |= HR_PTCFG_BLOCKED;
 506		val &= ~HR_PTCFG_LEARNING_EN;
 507		break;
 508	case BR_STATE_BLOCKING:
 509		new_state = "BLOCKING";
 510		val |= HR_PTCFG_BLOCKED;
 511		val &= ~HR_PTCFG_LEARNING_EN;
 512		break;
 513	case BR_STATE_LISTENING:
 514		new_state = "LISTENING";
 515		val |= HR_PTCFG_BLOCKED;
 516		val &= ~HR_PTCFG_LEARNING_EN;
 517		break;
 518	case BR_STATE_LEARNING:
 519		new_state = "LEARNING";
 520		val |= HR_PTCFG_BLOCKED;
 521		val |= HR_PTCFG_LEARNING_EN;
 522		break;
 523	case BR_STATE_FORWARDING:
 524		new_state = "FORWARDING";
 525		val &= ~HR_PTCFG_BLOCKED;
 526		val |= HR_PTCFG_LEARNING_EN;
 527		break;
 528	default:
 529		new_state = "UNKNOWN";
 530	}
 531
 532	hellcreek_select_port(hellcreek, port);
 533	hellcreek_write(hellcreek, val, HR_PTCFG);
 534	hellcreek_port->ptcfg = val;
 535
 536	mutex_unlock(&hellcreek->reg_lock);
 537
 538	dev_dbg(hellcreek->dev, "Configured STP state for port %d: %s\n",
 539		port, new_state);
 540}
 541
 542static void hellcreek_setup_ingressflt(struct hellcreek *hellcreek, int port,
 543				       bool enable)
 544{
 545	struct hellcreek_port *hellcreek_port = &hellcreek->ports[port];
 546	u16 ptcfg;
 547
 548	mutex_lock(&hellcreek->reg_lock);
 549
 550	ptcfg = hellcreek_port->ptcfg;
 551
 552	if (enable)
 553		ptcfg |= HR_PTCFG_INGRESSFLT;
 554	else
 555		ptcfg &= ~HR_PTCFG_INGRESSFLT;
 556
 557	hellcreek_select_port(hellcreek, port);
 558	hellcreek_write(hellcreek, ptcfg, HR_PTCFG);
 559	hellcreek_port->ptcfg = ptcfg;
 560
 561	mutex_unlock(&hellcreek->reg_lock);
 562}
 563
 564static void hellcreek_setup_vlan_awareness(struct hellcreek *hellcreek,
 565					   bool enable)
 566{
 567	u16 swcfg;
 568
 569	mutex_lock(&hellcreek->reg_lock);
 570
 571	swcfg = hellcreek->swcfg;
 572
 573	if (enable)
 574		swcfg |= HR_SWCFG_VLAN_UNAWARE;
 575	else
 576		swcfg &= ~HR_SWCFG_VLAN_UNAWARE;
 577
 578	hellcreek_write(hellcreek, swcfg, HR_SWCFG);
 579
 580	mutex_unlock(&hellcreek->reg_lock);
 581}
 582
 583/* Default setup for DSA: VLAN <X>: CPU and Port <X> egress untagged. */
 584static void hellcreek_setup_vlan_membership(struct dsa_switch *ds, int port,
 585					    bool enabled)
 586{
 587	const u16 vid = hellcreek_private_vid(port);
 588	int upstream = dsa_upstream_port(ds, port);
 589	struct hellcreek *hellcreek = ds->priv;
 590
 591	/* Apply vid to port as egress untagged and port vlan id */
 592	if (enabled)
 593		hellcreek_apply_vlan(hellcreek, port, vid, true, true);
 594	else
 595		hellcreek_unapply_vlan(hellcreek, port, vid);
 596
 597	/* Apply vid to cpu port as well */
 598	if (enabled)
 599		hellcreek_apply_vlan(hellcreek, upstream, vid, false, true);
 600	else
 601		hellcreek_unapply_vlan(hellcreek, upstream, vid);
 602}
 603
 604static void hellcreek_port_set_ucast_flood(struct hellcreek *hellcreek,
 605					   int port, bool enable)
 606{
 607	struct hellcreek_port *hellcreek_port;
 608	u16 val;
 609
 610	hellcreek_port = &hellcreek->ports[port];
 611
 612	dev_dbg(hellcreek->dev, "%s unicast flooding on port %d\n",
 613		enable ? "Enable" : "Disable", port);
 614
 615	mutex_lock(&hellcreek->reg_lock);
 616
 617	hellcreek_select_port(hellcreek, port);
 618	val = hellcreek_port->ptcfg;
 619	if (enable)
 620		val &= ~HR_PTCFG_UUC_FLT;
 621	else
 622		val |= HR_PTCFG_UUC_FLT;
 623	hellcreek_write(hellcreek, val, HR_PTCFG);
 624	hellcreek_port->ptcfg = val;
 625
 626	mutex_unlock(&hellcreek->reg_lock);
 627}
 628
 629static void hellcreek_port_set_mcast_flood(struct hellcreek *hellcreek,
 630					   int port, bool enable)
 631{
 632	struct hellcreek_port *hellcreek_port;
 633	u16 val;
 634
 635	hellcreek_port = &hellcreek->ports[port];
 636
 637	dev_dbg(hellcreek->dev, "%s multicast flooding on port %d\n",
 638		enable ? "Enable" : "Disable", port);
 639
 640	mutex_lock(&hellcreek->reg_lock);
 641
 642	hellcreek_select_port(hellcreek, port);
 643	val = hellcreek_port->ptcfg;
 644	if (enable)
 645		val &= ~HR_PTCFG_UMC_FLT;
 646	else
 647		val |= HR_PTCFG_UMC_FLT;
 648	hellcreek_write(hellcreek, val, HR_PTCFG);
 649	hellcreek_port->ptcfg = val;
 650
 651	mutex_unlock(&hellcreek->reg_lock);
 652}
 653
 654static int hellcreek_pre_bridge_flags(struct dsa_switch *ds, int port,
 655				      struct switchdev_brport_flags flags,
 656				      struct netlink_ext_ack *extack)
 657{
 658	if (flags.mask & ~(BR_FLOOD | BR_MCAST_FLOOD))
 659		return -EINVAL;
 660
 661	return 0;
 662}
 663
 664static int hellcreek_bridge_flags(struct dsa_switch *ds, int port,
 665				  struct switchdev_brport_flags flags,
 666				  struct netlink_ext_ack *extack)
 667{
 668	struct hellcreek *hellcreek = ds->priv;
 669
 670	if (flags.mask & BR_FLOOD)
 671		hellcreek_port_set_ucast_flood(hellcreek, port,
 672					       !!(flags.val & BR_FLOOD));
 673
 674	if (flags.mask & BR_MCAST_FLOOD)
 675		hellcreek_port_set_mcast_flood(hellcreek, port,
 676					       !!(flags.val & BR_MCAST_FLOOD));
 677
 678	return 0;
 679}
 680
 681static int hellcreek_port_bridge_join(struct dsa_switch *ds, int port,
 682				      struct dsa_bridge bridge,
 683				      bool *tx_fwd_offload,
 684				      struct netlink_ext_ack *extack)
 685{
 686	struct hellcreek *hellcreek = ds->priv;
 687
 688	dev_dbg(hellcreek->dev, "Port %d joins a bridge\n", port);
 689
 690	/* When joining a vlan_filtering bridge, keep the switch VLAN aware */
 691	if (!ds->vlan_filtering)
 692		hellcreek_setup_vlan_awareness(hellcreek, false);
 693
 694	/* Drop private vlans */
 695	hellcreek_setup_vlan_membership(ds, port, false);
 696
 697	return 0;
 698}
 699
 700static void hellcreek_port_bridge_leave(struct dsa_switch *ds, int port,
 701					struct dsa_bridge bridge)
 702{
 703	struct hellcreek *hellcreek = ds->priv;
 704
 705	dev_dbg(hellcreek->dev, "Port %d leaves a bridge\n", port);
 706
 707	/* Enable VLAN awareness */
 708	hellcreek_setup_vlan_awareness(hellcreek, true);
 709
 710	/* Enable private vlans */
 711	hellcreek_setup_vlan_membership(ds, port, true);
 712}
 713
 714static int __hellcreek_fdb_add(struct hellcreek *hellcreek,
 715			       const struct hellcreek_fdb_entry *entry)
 716{
 717	u16 meta = 0;
 718
 719	dev_dbg(hellcreek->dev, "Add static FDB entry: MAC=%pM, MASK=0x%02x, "
 720		"OBT=%d, PASS_BLOCKED=%d, REPRIO_EN=%d, PRIO=%d\n", entry->mac,
 721		entry->portmask, entry->is_obt, entry->pass_blocked,
 722		entry->reprio_en, entry->reprio_tc);
 723
 724	/* Add mac address */
 725	hellcreek_write(hellcreek, entry->mac[1] | (entry->mac[0] << 8), HR_FDBWDH);
 726	hellcreek_write(hellcreek, entry->mac[3] | (entry->mac[2] << 8), HR_FDBWDM);
 727	hellcreek_write(hellcreek, entry->mac[5] | (entry->mac[4] << 8), HR_FDBWDL);
 728
 729	/* Meta data */
 730	meta |= entry->portmask << HR_FDBWRM0_PORTMASK_SHIFT;
 731	if (entry->is_obt)
 732		meta |= HR_FDBWRM0_OBT;
 733	if (entry->pass_blocked)
 734		meta |= HR_FDBWRM0_PASS_BLOCKED;
 735	if (entry->reprio_en) {
 736		meta |= HR_FDBWRM0_REPRIO_EN;
 737		meta |= entry->reprio_tc << HR_FDBWRM0_REPRIO_TC_SHIFT;
 738	}
 739	hellcreek_write(hellcreek, meta, HR_FDBWRM0);
 740
 741	/* Commit */
 742	hellcreek_write(hellcreek, 0x00, HR_FDBWRCMD);
 743
 744	/* Wait until done */
 745	return hellcreek_wait_fdb_ready(hellcreek);
 746}
 747
 748static int __hellcreek_fdb_del(struct hellcreek *hellcreek,
 749			       const struct hellcreek_fdb_entry *entry)
 750{
 751	dev_dbg(hellcreek->dev, "Delete FDB entry: MAC=%pM!\n", entry->mac);
 752
 753	/* Delete by matching idx */
 754	hellcreek_write(hellcreek, entry->idx | HR_FDBWRCMD_FDBDEL, HR_FDBWRCMD);
 755
 756	/* Wait until done */
 757	return hellcreek_wait_fdb_ready(hellcreek);
 758}
 759
 760static void hellcreek_populate_fdb_entry(struct hellcreek *hellcreek,
 761					 struct hellcreek_fdb_entry *entry,
 762					 size_t idx)
 763{
 764	unsigned char addr[ETH_ALEN];
 765	u16 meta, mac;
 766
 767	/* Read values */
 768	meta	= hellcreek_read(hellcreek, HR_FDBMDRD);
 769	mac	= hellcreek_read(hellcreek, HR_FDBRDL);
 770	addr[5] = mac & 0xff;
 771	addr[4] = (mac & 0xff00) >> 8;
 772	mac	= hellcreek_read(hellcreek, HR_FDBRDM);
 773	addr[3] = mac & 0xff;
 774	addr[2] = (mac & 0xff00) >> 8;
 775	mac	= hellcreek_read(hellcreek, HR_FDBRDH);
 776	addr[1] = mac & 0xff;
 777	addr[0] = (mac & 0xff00) >> 8;
 778
 779	/* Populate @entry */
 780	memcpy(entry->mac, addr, sizeof(addr));
 781	entry->idx	    = idx;
 782	entry->portmask	    = (meta & HR_FDBMDRD_PORTMASK_MASK) >>
 783		HR_FDBMDRD_PORTMASK_SHIFT;
 784	entry->age	    = (meta & HR_FDBMDRD_AGE_MASK) >>
 785		HR_FDBMDRD_AGE_SHIFT;
 786	entry->is_obt	    = !!(meta & HR_FDBMDRD_OBT);
 787	entry->pass_blocked = !!(meta & HR_FDBMDRD_PASS_BLOCKED);
 788	entry->is_static    = !!(meta & HR_FDBMDRD_STATIC);
 789	entry->reprio_tc    = (meta & HR_FDBMDRD_REPRIO_TC_MASK) >>
 790		HR_FDBMDRD_REPRIO_TC_SHIFT;
 791	entry->reprio_en    = !!(meta & HR_FDBMDRD_REPRIO_EN);
 792}
 793
 794/* Retrieve the index of a FDB entry by mac address. Currently we search through
 795 * the complete table in hardware. If that's too slow, we might have to cache
 796 * the complete FDB table in software.
 797 */
 798static int hellcreek_fdb_get(struct hellcreek *hellcreek,
 799			     const unsigned char *dest,
 800			     struct hellcreek_fdb_entry *entry)
 801{
 802	size_t i;
 803
 804	/* Set read pointer to zero: The read of HR_FDBMAX (read-only register)
 805	 * should reset the internal pointer. But, that doesn't work. The vendor
 806	 * suggested a subsequent write as workaround. Same for HR_FDBRDH below.
 807	 */
 808	hellcreek_read(hellcreek, HR_FDBMAX);
 809	hellcreek_write(hellcreek, 0x00, HR_FDBMAX);
 810
 811	/* We have to read the complete table, because the switch/driver might
 812	 * enter new entries anywhere.
 813	 */
 814	for (i = 0; i < hellcreek->fdb_entries; ++i) {
 815		struct hellcreek_fdb_entry tmp = { 0 };
 816
 817		/* Read entry */
 818		hellcreek_populate_fdb_entry(hellcreek, &tmp, i);
 819
 820		/* Force next entry */
 821		hellcreek_write(hellcreek, 0x00, HR_FDBRDH);
 822
 823		if (memcmp(tmp.mac, dest, ETH_ALEN))
 824			continue;
 825
 826		/* Match found */
 827		memcpy(entry, &tmp, sizeof(*entry));
 828
 829		return 0;
 830	}
 831
 832	return -ENOENT;
 833}
 834
 835static int hellcreek_fdb_add(struct dsa_switch *ds, int port,
 836			     const unsigned char *addr, u16 vid,
 837			     struct dsa_db db)
 838{
 839	struct hellcreek_fdb_entry entry = { 0 };
 840	struct hellcreek *hellcreek = ds->priv;
 841	int ret;
 842
 843	dev_dbg(hellcreek->dev, "Add FDB entry for MAC=%pM\n", addr);
 844
 845	mutex_lock(&hellcreek->reg_lock);
 846
 847	ret = hellcreek_fdb_get(hellcreek, addr, &entry);
 848	if (ret) {
 849		/* Not found */
 850		memcpy(entry.mac, addr, sizeof(entry.mac));
 851		entry.portmask = BIT(port);
 852
 853		ret = __hellcreek_fdb_add(hellcreek, &entry);
 854		if (ret) {
 855			dev_err(hellcreek->dev, "Failed to add FDB entry!\n");
 856			goto out;
 857		}
 858	} else {
 859		/* Found */
 860		ret = __hellcreek_fdb_del(hellcreek, &entry);
 861		if (ret) {
 862			dev_err(hellcreek->dev, "Failed to delete FDB entry!\n");
 863			goto out;
 864		}
 865
 866		entry.portmask |= BIT(port);
 867
 868		ret = __hellcreek_fdb_add(hellcreek, &entry);
 869		if (ret) {
 870			dev_err(hellcreek->dev, "Failed to add FDB entry!\n");
 871			goto out;
 872		}
 873	}
 874
 875out:
 876	mutex_unlock(&hellcreek->reg_lock);
 877
 878	return ret;
 879}
 880
 881static int hellcreek_fdb_del(struct dsa_switch *ds, int port,
 882			     const unsigned char *addr, u16 vid,
 883			     struct dsa_db db)
 884{
 885	struct hellcreek_fdb_entry entry = { 0 };
 886	struct hellcreek *hellcreek = ds->priv;
 887	int ret;
 888
 889	dev_dbg(hellcreek->dev, "Delete FDB entry for MAC=%pM\n", addr);
 890
 891	mutex_lock(&hellcreek->reg_lock);
 892
 893	ret = hellcreek_fdb_get(hellcreek, addr, &entry);
 894	if (ret) {
 895		/* Not found */
 896		dev_err(hellcreek->dev, "FDB entry for deletion not found!\n");
 897	} else {
 898		/* Found */
 899		ret = __hellcreek_fdb_del(hellcreek, &entry);
 900		if (ret) {
 901			dev_err(hellcreek->dev, "Failed to delete FDB entry!\n");
 902			goto out;
 903		}
 904
 905		entry.portmask &= ~BIT(port);
 906
 907		if (entry.portmask != 0x00) {
 908			ret = __hellcreek_fdb_add(hellcreek, &entry);
 909			if (ret) {
 910				dev_err(hellcreek->dev, "Failed to add FDB entry!\n");
 911				goto out;
 912			}
 913		}
 914	}
 915
 916out:
 917	mutex_unlock(&hellcreek->reg_lock);
 918
 919	return ret;
 920}
 921
 922static int hellcreek_fdb_dump(struct dsa_switch *ds, int port,
 923			      dsa_fdb_dump_cb_t *cb, void *data)
 924{
 925	struct hellcreek *hellcreek = ds->priv;
 926	u16 entries;
 927	int ret = 0;
 928	size_t i;
 929
 930	mutex_lock(&hellcreek->reg_lock);
 931
 932	/* Set read pointer to zero: The read of HR_FDBMAX (read-only register)
 933	 * should reset the internal pointer. But, that doesn't work. The vendor
 934	 * suggested a subsequent write as workaround. Same for HR_FDBRDH below.
 935	 */
 936	entries = hellcreek_read(hellcreek, HR_FDBMAX);
 937	hellcreek_write(hellcreek, 0x00, HR_FDBMAX);
 938
 939	dev_dbg(hellcreek->dev, "FDB dump for port %d, entries=%d!\n", port, entries);
 940
 941	/* Read table */
 942	for (i = 0; i < hellcreek->fdb_entries; ++i) {
 943		struct hellcreek_fdb_entry entry = { 0 };
 944
 945		/* Read entry */
 946		hellcreek_populate_fdb_entry(hellcreek, &entry, i);
 947
 948		/* Force next entry */
 949		hellcreek_write(hellcreek, 0x00, HR_FDBRDH);
 950
 951		/* Check valid */
 952		if (is_zero_ether_addr(entry.mac))
 953			continue;
 954
 955		/* Check port mask */
 956		if (!(entry.portmask & BIT(port)))
 957			continue;
 958
 959		ret = cb(entry.mac, 0, entry.is_static, data);
 960		if (ret)
 961			break;
 962	}
 963
 964	mutex_unlock(&hellcreek->reg_lock);
 965
 966	return ret;
 967}
 968
 969static int hellcreek_vlan_filtering(struct dsa_switch *ds, int port,
 970				    bool vlan_filtering,
 971				    struct netlink_ext_ack *extack)
 972{
 973	struct hellcreek *hellcreek = ds->priv;
 974
 975	dev_dbg(hellcreek->dev, "%s VLAN filtering on port %d\n",
 976		vlan_filtering ? "Enable" : "Disable", port);
 977
 978	/* Configure port to drop packages with not known vids */
 979	hellcreek_setup_ingressflt(hellcreek, port, vlan_filtering);
 980
 981	/* Enable VLAN awareness on the switch. This save due to
 982	 * ds->vlan_filtering_is_global.
 983	 */
 984	hellcreek_setup_vlan_awareness(hellcreek, vlan_filtering);
 985
 986	return 0;
 987}
 988
 989static int hellcreek_enable_ip_core(struct hellcreek *hellcreek)
 990{
 991	int ret;
 992	u16 val;
 993
 994	mutex_lock(&hellcreek->reg_lock);
 995
 996	val = hellcreek_read(hellcreek, HR_CTRL_C);
 997	val |= HR_CTRL_C_ENABLE;
 998	hellcreek_write(hellcreek, val, HR_CTRL_C);
 999	ret = hellcreek_wait_until_transitioned(hellcreek);
1000
1001	mutex_unlock(&hellcreek->reg_lock);
1002
1003	return ret;
1004}
1005
1006static void hellcreek_setup_cpu_and_tunnel_port(struct hellcreek *hellcreek)
1007{
1008	struct hellcreek_port *tunnel_port = &hellcreek->ports[TUNNEL_PORT];
1009	struct hellcreek_port *cpu_port = &hellcreek->ports[CPU_PORT];
1010	u16 ptcfg = 0;
1011
1012	ptcfg |= HR_PTCFG_LEARNING_EN | HR_PTCFG_ADMIN_EN;
1013
1014	mutex_lock(&hellcreek->reg_lock);
1015
1016	hellcreek_select_port(hellcreek, CPU_PORT);
1017	hellcreek_write(hellcreek, ptcfg, HR_PTCFG);
1018
1019	hellcreek_select_port(hellcreek, TUNNEL_PORT);
1020	hellcreek_write(hellcreek, ptcfg, HR_PTCFG);
1021
1022	cpu_port->ptcfg	   = ptcfg;
1023	tunnel_port->ptcfg = ptcfg;
1024
1025	mutex_unlock(&hellcreek->reg_lock);
1026}
1027
1028static void hellcreek_setup_tc_identity_mapping(struct hellcreek *hellcreek)
1029{
1030	int i;
1031
1032	/* The switch has multiple egress queues per port. The queue is selected
1033	 * via the PCP field in the VLAN header. The switch internally deals
1034	 * with traffic classes instead of PCP values and this mapping is
1035	 * configurable.
1036	 *
1037	 * The default mapping is (PCP - TC):
1038	 *  7 - 7
1039	 *  6 - 6
1040	 *  5 - 5
1041	 *  4 - 4
1042	 *  3 - 3
1043	 *  2 - 1
1044	 *  1 - 0
1045	 *  0 - 2
1046	 *
1047	 * The default should be an identity mapping.
1048	 */
1049
1050	for (i = 0; i < 8; ++i) {
1051		mutex_lock(&hellcreek->reg_lock);
1052
1053		hellcreek_select_prio(hellcreek, i);
1054		hellcreek_write(hellcreek,
1055				i << HR_PRTCCFG_PCP_TC_MAP_SHIFT,
1056				HR_PRTCCFG);
1057
1058		mutex_unlock(&hellcreek->reg_lock);
1059	}
1060}
1061
1062static int hellcreek_setup_fdb(struct hellcreek *hellcreek)
1063{
1064	static struct hellcreek_fdb_entry l2_ptp = {
1065		/* MAC: 01-1B-19-00-00-00 */
1066		.mac	      = { 0x01, 0x1b, 0x19, 0x00, 0x00, 0x00 },
1067		.portmask     = 0x03,	/* Management ports */
1068		.age	      = 0,
1069		.is_obt	      = 0,
1070		.pass_blocked = 0,
1071		.is_static    = 1,
1072		.reprio_tc    = 6,	/* TC: 6 as per IEEE 802.1AS */
1073		.reprio_en    = 1,
1074	};
1075	static struct hellcreek_fdb_entry udp4_ptp = {
1076		/* MAC: 01-00-5E-00-01-81 */
1077		.mac	      = { 0x01, 0x00, 0x5e, 0x00, 0x01, 0x81 },
1078		.portmask     = 0x03,	/* Management ports */
1079		.age	      = 0,
1080		.is_obt	      = 0,
1081		.pass_blocked = 0,
1082		.is_static    = 1,
1083		.reprio_tc    = 6,
1084		.reprio_en    = 1,
1085	};
1086	static struct hellcreek_fdb_entry udp6_ptp = {
1087		/* MAC: 33-33-00-00-01-81 */
1088		.mac	      = { 0x33, 0x33, 0x00, 0x00, 0x01, 0x81 },
1089		.portmask     = 0x03,	/* Management ports */
1090		.age	      = 0,
1091		.is_obt	      = 0,
1092		.pass_blocked = 0,
1093		.is_static    = 1,
1094		.reprio_tc    = 6,
1095		.reprio_en    = 1,
1096	};
1097	static struct hellcreek_fdb_entry l2_p2p = {
1098		/* MAC: 01-80-C2-00-00-0E */
1099		.mac	      = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x0e },
1100		.portmask     = 0x03,	/* Management ports */
1101		.age	      = 0,
1102		.is_obt	      = 0,
1103		.pass_blocked = 1,
1104		.is_static    = 1,
1105		.reprio_tc    = 6,	/* TC: 6 as per IEEE 802.1AS */
1106		.reprio_en    = 1,
1107	};
1108	static struct hellcreek_fdb_entry udp4_p2p = {
1109		/* MAC: 01-00-5E-00-00-6B */
1110		.mac	      = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x6b },
1111		.portmask     = 0x03,	/* Management ports */
1112		.age	      = 0,
1113		.is_obt	      = 0,
1114		.pass_blocked = 1,
1115		.is_static    = 1,
1116		.reprio_tc    = 6,
1117		.reprio_en    = 1,
1118	};
1119	static struct hellcreek_fdb_entry udp6_p2p = {
1120		/* MAC: 33-33-00-00-00-6B */
1121		.mac	      = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x6b },
1122		.portmask     = 0x03,	/* Management ports */
1123		.age	      = 0,
1124		.is_obt	      = 0,
1125		.pass_blocked = 1,
1126		.is_static    = 1,
1127		.reprio_tc    = 6,
1128		.reprio_en    = 1,
1129	};
1130	static struct hellcreek_fdb_entry stp = {
1131		/* MAC: 01-80-C2-00-00-00 */
1132		.mac	      = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 },
1133		.portmask     = 0x03,	/* Management ports */
1134		.age	      = 0,
1135		.is_obt	      = 0,
1136		.pass_blocked = 1,
1137		.is_static    = 1,
1138		.reprio_tc    = 6,
1139		.reprio_en    = 1,
1140	};
1141	int ret;
1142
1143	mutex_lock(&hellcreek->reg_lock);
1144	ret = __hellcreek_fdb_add(hellcreek, &l2_ptp);
1145	if (ret)
1146		goto out;
1147	ret = __hellcreek_fdb_add(hellcreek, &udp4_ptp);
1148	if (ret)
1149		goto out;
1150	ret = __hellcreek_fdb_add(hellcreek, &udp6_ptp);
1151	if (ret)
1152		goto out;
1153	ret = __hellcreek_fdb_add(hellcreek, &l2_p2p);
1154	if (ret)
1155		goto out;
1156	ret = __hellcreek_fdb_add(hellcreek, &udp4_p2p);
1157	if (ret)
1158		goto out;
1159	ret = __hellcreek_fdb_add(hellcreek, &udp6_p2p);
1160	if (ret)
1161		goto out;
1162	ret = __hellcreek_fdb_add(hellcreek, &stp);
1163out:
1164	mutex_unlock(&hellcreek->reg_lock);
1165
1166	return ret;
1167}
1168
1169static int hellcreek_devlink_info_get(struct dsa_switch *ds,
1170				      struct devlink_info_req *req,
1171				      struct netlink_ext_ack *extack)
1172{
1173	struct hellcreek *hellcreek = ds->priv;
 
 
 
 
 
1174
1175	return devlink_info_version_fixed_put(req,
1176					      DEVLINK_INFO_VERSION_GENERIC_ASIC_ID,
1177					      hellcreek->pdata->name);
1178}
1179
1180static u64 hellcreek_devlink_vlan_table_get(void *priv)
1181{
1182	struct hellcreek *hellcreek = priv;
1183	u64 count = 0;
1184	int i;
1185
1186	mutex_lock(&hellcreek->reg_lock);
1187	for (i = 0; i < VLAN_N_VID; ++i)
1188		if (hellcreek->vidmbrcfg[i])
1189			count++;
1190	mutex_unlock(&hellcreek->reg_lock);
1191
1192	return count;
1193}
1194
1195static u64 hellcreek_devlink_fdb_table_get(void *priv)
1196{
1197	struct hellcreek *hellcreek = priv;
1198	u64 count = 0;
1199
1200	/* Reading this register has side effects. Synchronize against the other
1201	 * FDB operations.
1202	 */
1203	mutex_lock(&hellcreek->reg_lock);
1204	count = hellcreek_read(hellcreek, HR_FDBMAX);
1205	mutex_unlock(&hellcreek->reg_lock);
1206
1207	return count;
1208}
1209
1210static int hellcreek_setup_devlink_resources(struct dsa_switch *ds)
1211{
1212	struct devlink_resource_size_params size_vlan_params;
1213	struct devlink_resource_size_params size_fdb_params;
1214	struct hellcreek *hellcreek = ds->priv;
1215	int err;
1216
1217	devlink_resource_size_params_init(&size_vlan_params, VLAN_N_VID,
1218					  VLAN_N_VID,
1219					  1, DEVLINK_RESOURCE_UNIT_ENTRY);
1220
1221	devlink_resource_size_params_init(&size_fdb_params,
1222					  hellcreek->fdb_entries,
1223					  hellcreek->fdb_entries,
1224					  1, DEVLINK_RESOURCE_UNIT_ENTRY);
1225
1226	err = dsa_devlink_resource_register(ds, "VLAN", VLAN_N_VID,
1227					    HELLCREEK_DEVLINK_PARAM_ID_VLAN_TABLE,
1228					    DEVLINK_RESOURCE_ID_PARENT_TOP,
1229					    &size_vlan_params);
1230	if (err)
1231		goto out;
1232
1233	err = dsa_devlink_resource_register(ds, "FDB", hellcreek->fdb_entries,
1234					    HELLCREEK_DEVLINK_PARAM_ID_FDB_TABLE,
1235					    DEVLINK_RESOURCE_ID_PARENT_TOP,
1236					    &size_fdb_params);
1237	if (err)
1238		goto out;
1239
1240	dsa_devlink_resource_occ_get_register(ds,
1241					      HELLCREEK_DEVLINK_PARAM_ID_VLAN_TABLE,
1242					      hellcreek_devlink_vlan_table_get,
1243					      hellcreek);
1244
1245	dsa_devlink_resource_occ_get_register(ds,
1246					      HELLCREEK_DEVLINK_PARAM_ID_FDB_TABLE,
1247					      hellcreek_devlink_fdb_table_get,
1248					      hellcreek);
1249
1250	return 0;
1251
1252out:
1253	dsa_devlink_resources_unregister(ds);
1254
1255	return err;
1256}
1257
1258static int hellcreek_devlink_region_vlan_snapshot(struct devlink *dl,
1259						  const struct devlink_region_ops *ops,
1260						  struct netlink_ext_ack *extack,
1261						  u8 **data)
1262{
1263	struct hellcreek_devlink_vlan_entry *table, *entry;
1264	struct dsa_switch *ds = dsa_devlink_to_ds(dl);
1265	struct hellcreek *hellcreek = ds->priv;
1266	int i;
1267
1268	table = kcalloc(VLAN_N_VID, sizeof(*entry), GFP_KERNEL);
1269	if (!table)
1270		return -ENOMEM;
1271
1272	entry = table;
1273
1274	mutex_lock(&hellcreek->reg_lock);
1275	for (i = 0; i < VLAN_N_VID; ++i, ++entry) {
1276		entry->member = hellcreek->vidmbrcfg[i];
1277		entry->vid    = i;
1278	}
1279	mutex_unlock(&hellcreek->reg_lock);
1280
1281	*data = (u8 *)table;
1282
1283	return 0;
1284}
1285
1286static int hellcreek_devlink_region_fdb_snapshot(struct devlink *dl,
1287						 const struct devlink_region_ops *ops,
1288						 struct netlink_ext_ack *extack,
1289						 u8 **data)
1290{
1291	struct dsa_switch *ds = dsa_devlink_to_ds(dl);
1292	struct hellcreek_fdb_entry *table, *entry;
1293	struct hellcreek *hellcreek = ds->priv;
1294	size_t i;
1295
1296	table = kcalloc(hellcreek->fdb_entries, sizeof(*entry), GFP_KERNEL);
1297	if (!table)
1298		return -ENOMEM;
1299
1300	entry = table;
1301
1302	mutex_lock(&hellcreek->reg_lock);
1303
1304	/* Start table read */
1305	hellcreek_read(hellcreek, HR_FDBMAX);
1306	hellcreek_write(hellcreek, 0x00, HR_FDBMAX);
1307
1308	for (i = 0; i < hellcreek->fdb_entries; ++i, ++entry) {
1309		/* Read current entry */
1310		hellcreek_populate_fdb_entry(hellcreek, entry, i);
1311
1312		/* Advance read pointer */
1313		hellcreek_write(hellcreek, 0x00, HR_FDBRDH);
1314	}
1315
1316	mutex_unlock(&hellcreek->reg_lock);
1317
1318	*data = (u8 *)table;
1319
1320	return 0;
1321}
1322
1323static struct devlink_region_ops hellcreek_region_vlan_ops = {
1324	.name	    = "vlan",
1325	.snapshot   = hellcreek_devlink_region_vlan_snapshot,
1326	.destructor = kfree,
1327};
1328
1329static struct devlink_region_ops hellcreek_region_fdb_ops = {
1330	.name	    = "fdb",
1331	.snapshot   = hellcreek_devlink_region_fdb_snapshot,
1332	.destructor = kfree,
1333};
1334
1335static int hellcreek_setup_devlink_regions(struct dsa_switch *ds)
1336{
1337	struct hellcreek *hellcreek = ds->priv;
1338	struct devlink_region_ops *ops;
1339	struct devlink_region *region;
1340	u64 size;
1341	int ret;
1342
1343	/* VLAN table */
1344	size = VLAN_N_VID * sizeof(struct hellcreek_devlink_vlan_entry);
1345	ops  = &hellcreek_region_vlan_ops;
1346
1347	region = dsa_devlink_region_create(ds, ops, 1, size);
1348	if (IS_ERR(region))
1349		return PTR_ERR(region);
1350
1351	hellcreek->vlan_region = region;
1352
1353	/* FDB table */
1354	size = hellcreek->fdb_entries * sizeof(struct hellcreek_fdb_entry);
1355	ops  = &hellcreek_region_fdb_ops;
1356
1357	region = dsa_devlink_region_create(ds, ops, 1, size);
1358	if (IS_ERR(region)) {
1359		ret = PTR_ERR(region);
1360		goto err_fdb;
1361	}
1362
1363	hellcreek->fdb_region = region;
1364
1365	return 0;
1366
1367err_fdb:
1368	dsa_devlink_region_destroy(hellcreek->vlan_region);
1369
1370	return ret;
1371}
1372
1373static void hellcreek_teardown_devlink_regions(struct dsa_switch *ds)
1374{
1375	struct hellcreek *hellcreek = ds->priv;
1376
1377	dsa_devlink_region_destroy(hellcreek->fdb_region);
1378	dsa_devlink_region_destroy(hellcreek->vlan_region);
1379}
1380
1381static int hellcreek_setup(struct dsa_switch *ds)
1382{
1383	struct hellcreek *hellcreek = ds->priv;
1384	u16 swcfg = 0;
1385	int ret, i;
1386
1387	dev_dbg(hellcreek->dev, "Set up the switch\n");
1388
1389	/* Let's go */
1390	ret = hellcreek_enable_ip_core(hellcreek);
1391	if (ret) {
1392		dev_err(hellcreek->dev, "Failed to enable IP core!\n");
1393		return ret;
1394	}
1395
1396	/* Enable CPU/Tunnel ports */
1397	hellcreek_setup_cpu_and_tunnel_port(hellcreek);
1398
1399	/* Switch config: Keep defaults, enable FDB aging and learning and tag
1400	 * each frame from/to cpu port for DSA tagging.  Also enable the length
1401	 * aware shaping mode. This eliminates the need for Qbv guard bands.
1402	 */
1403	swcfg |= HR_SWCFG_FDBAGE_EN |
1404		HR_SWCFG_FDBLRN_EN  |
1405		HR_SWCFG_ALWAYS_OBT |
1406		(HR_SWCFG_LAS_ON << HR_SWCFG_LAS_MODE_SHIFT);
1407	hellcreek->swcfg = swcfg;
1408	hellcreek_write(hellcreek, swcfg, HR_SWCFG);
1409
1410	/* Initial vlan membership to reflect port separation */
1411	for (i = 0; i < ds->num_ports; ++i) {
1412		if (!dsa_is_user_port(ds, i))
1413			continue;
1414
1415		hellcreek_setup_vlan_membership(ds, i, true);
1416	}
1417
1418	/* Configure PCP <-> TC mapping */
1419	hellcreek_setup_tc_identity_mapping(hellcreek);
1420
1421	/* The VLAN awareness is a global switch setting. Therefore, mixed vlan
1422	 * filtering setups are not supported.
1423	 */
1424	ds->vlan_filtering_is_global = true;
1425	ds->needs_standalone_vlan_filtering = true;
1426
1427	/* Intercept _all_ PTP multicast traffic */
1428	ret = hellcreek_setup_fdb(hellcreek);
1429	if (ret) {
1430		dev_err(hellcreek->dev,
1431			"Failed to insert static PTP FDB entries\n");
1432		return ret;
1433	}
1434
1435	/* Register devlink resources with DSA */
1436	ret = hellcreek_setup_devlink_resources(ds);
1437	if (ret) {
1438		dev_err(hellcreek->dev,
1439			"Failed to setup devlink resources!\n");
1440		return ret;
1441	}
1442
1443	ret = hellcreek_setup_devlink_regions(ds);
1444	if (ret) {
1445		dev_err(hellcreek->dev,
1446			"Failed to setup devlink regions!\n");
1447		goto err_regions;
1448	}
1449
1450	return 0;
1451
1452err_regions:
1453	dsa_devlink_resources_unregister(ds);
1454
1455	return ret;
1456}
1457
1458static void hellcreek_teardown(struct dsa_switch *ds)
1459{
1460	hellcreek_teardown_devlink_regions(ds);
1461	dsa_devlink_resources_unregister(ds);
1462}
1463
1464static void hellcreek_phylink_get_caps(struct dsa_switch *ds, int port,
1465				       struct phylink_config *config)
 
1466{
 
1467	struct hellcreek *hellcreek = ds->priv;
1468
1469	__set_bit(PHY_INTERFACE_MODE_MII, config->supported_interfaces);
1470	__set_bit(PHY_INTERFACE_MODE_RGMII, config->supported_interfaces);
1471
1472	/* Include GMII - the hardware does not support this interface
1473	 * mode, but it's the default interface mode for phylib, so we
1474	 * need it for compatibility with existing DT.
1475	 */
1476	__set_bit(PHY_INTERFACE_MODE_GMII, config->supported_interfaces);
1477
1478	/* The MAC settings are a hardware configuration option and cannot be
1479	 * changed at run time or by strapping. Therefore the attached PHYs
1480	 * should be programmed to only advertise settings which are supported
1481	 * by the hardware.
1482	 */
1483	if (hellcreek->pdata->is_100_mbits)
1484		config->mac_capabilities = MAC_100FD;
1485	else
1486		config->mac_capabilities = MAC_1000FD;
 
 
 
 
 
1487}
1488
1489static int
1490hellcreek_port_prechangeupper(struct dsa_switch *ds, int port,
1491			      struct netdev_notifier_changeupper_info *info)
1492{
1493	struct hellcreek *hellcreek = ds->priv;
1494	bool used = true;
1495	int ret = -EBUSY;
1496	u16 vid;
1497	int i;
1498
1499	dev_dbg(hellcreek->dev, "Pre change upper for port %d\n", port);
1500
1501	/*
1502	 * Deny VLAN devices on top of lan ports with the same VLAN ids, because
1503	 * it breaks the port separation due to the private VLANs. Example:
1504	 *
1505	 * lan0.100 *and* lan1.100 cannot be used in parallel. However, lan0.99
1506	 * and lan1.100 works.
1507	 */
1508
1509	if (!is_vlan_dev(info->upper_dev))
1510		return 0;
1511
1512	vid = vlan_dev_vlan_id(info->upper_dev);
1513
1514	/* For all ports, check bitmaps */
1515	mutex_lock(&hellcreek->vlan_lock);
1516	for (i = 0; i < hellcreek->pdata->num_ports; ++i) {
1517		if (!dsa_is_user_port(ds, i))
1518			continue;
1519
1520		if (port == i)
1521			continue;
1522
1523		used = used && test_bit(vid, hellcreek->ports[i].vlan_dev_bitmap);
1524	}
1525
1526	if (used)
1527		goto out;
1528
1529	/* Update bitmap */
1530	set_bit(vid, hellcreek->ports[port].vlan_dev_bitmap);
1531
1532	ret = 0;
1533
1534out:
1535	mutex_unlock(&hellcreek->vlan_lock);
1536
1537	return ret;
1538}
1539
1540static void hellcreek_setup_maxsdu(struct hellcreek *hellcreek, int port,
1541				   const struct tc_taprio_qopt_offload *schedule)
1542{
1543	int tc;
1544
1545	for (tc = 0; tc < 8; ++tc) {
1546		u32 max_sdu = schedule->max_sdu[tc] + VLAN_ETH_HLEN - ETH_FCS_LEN;
1547		u16 val;
1548
1549		if (!schedule->max_sdu[tc])
1550			continue;
1551
1552		dev_dbg(hellcreek->dev, "Configure max-sdu %u for tc %d on port %d\n",
1553			max_sdu, tc, port);
1554
1555		hellcreek_select_port_prio(hellcreek, port, tc);
1556
1557		val = (max_sdu & HR_PTPRTCCFG_MAXSDU_MASK) << HR_PTPRTCCFG_MAXSDU_SHIFT;
1558
1559		hellcreek_write(hellcreek, val, HR_PTPRTCCFG);
1560	}
1561}
1562
1563static void hellcreek_reset_maxsdu(struct hellcreek *hellcreek, int port)
1564{
1565	int tc;
1566
1567	for (tc = 0; tc < 8; ++tc) {
1568		u16 val;
1569
1570		hellcreek_select_port_prio(hellcreek, port, tc);
1571
1572		val = (HELLCREEK_DEFAULT_MAX_SDU & HR_PTPRTCCFG_MAXSDU_MASK)
1573			<< HR_PTPRTCCFG_MAXSDU_SHIFT;
1574
1575		hellcreek_write(hellcreek, val, HR_PTPRTCCFG);
1576	}
1577}
1578
1579static void hellcreek_setup_gcl(struct hellcreek *hellcreek, int port,
1580				const struct tc_taprio_qopt_offload *schedule)
1581{
1582	const struct tc_taprio_sched_entry *cur, *initial, *next;
1583	size_t i;
1584
1585	cur = initial = &schedule->entries[0];
1586	next = cur + 1;
1587
1588	for (i = 1; i <= schedule->num_entries; ++i) {
1589		u16 data;
1590		u8 gates;
1591
1592		if (i == schedule->num_entries)
1593			gates = initial->gate_mask ^
1594				cur->gate_mask;
1595		else
1596			gates = next->gate_mask ^
1597				cur->gate_mask;
1598
1599		data = gates;
1600
1601		if (i == schedule->num_entries)
1602			data |= TR_GCLDAT_GCLWRLAST;
1603
1604		/* Gates states */
1605		hellcreek_write(hellcreek, data, TR_GCLDAT);
1606
1607		/* Time interval */
1608		hellcreek_write(hellcreek,
1609				cur->interval & 0x0000ffff,
1610				TR_GCLTIL);
1611		hellcreek_write(hellcreek,
1612				(cur->interval & 0xffff0000) >> 16,
1613				TR_GCLTIH);
1614
1615		/* Commit entry */
1616		data = ((i - 1) << TR_GCLCMD_GCLWRADR_SHIFT) |
1617			(initial->gate_mask <<
1618			 TR_GCLCMD_INIT_GATE_STATES_SHIFT);
1619		hellcreek_write(hellcreek, data, TR_GCLCMD);
1620
1621		cur++;
1622		next++;
1623	}
1624}
1625
1626static void hellcreek_set_cycle_time(struct hellcreek *hellcreek,
1627				     const struct tc_taprio_qopt_offload *schedule)
1628{
1629	u32 cycle_time = schedule->cycle_time;
1630
1631	hellcreek_write(hellcreek, cycle_time & 0x0000ffff, TR_CTWRL);
1632	hellcreek_write(hellcreek, (cycle_time & 0xffff0000) >> 16, TR_CTWRH);
1633}
1634
1635static void hellcreek_switch_schedule(struct hellcreek *hellcreek,
1636				      ktime_t start_time)
1637{
1638	struct timespec64 ts = ktime_to_timespec64(start_time);
1639
1640	/* Start schedule at this point of time */
1641	hellcreek_write(hellcreek, ts.tv_nsec & 0x0000ffff, TR_ESTWRL);
1642	hellcreek_write(hellcreek, (ts.tv_nsec & 0xffff0000) >> 16, TR_ESTWRH);
1643
1644	/* Arm timer, set seconds and switch schedule */
1645	hellcreek_write(hellcreek, TR_ESTCMD_ESTARM | TR_ESTCMD_ESTSWCFG |
1646			((ts.tv_sec & TR_ESTCMD_ESTSEC_MASK) <<
1647			 TR_ESTCMD_ESTSEC_SHIFT), TR_ESTCMD);
1648}
1649
1650static bool hellcreek_schedule_startable(struct hellcreek *hellcreek, int port)
1651{
1652	struct hellcreek_port *hellcreek_port = &hellcreek->ports[port];
1653	s64 base_time_ns, current_ns;
1654
1655	/* The switch allows a schedule to be started only eight seconds within
1656	 * the future. Therefore, check the current PTP time if the schedule is
1657	 * startable or not.
1658	 */
1659
1660	/* Use the "cached" time. That should be alright, as it's updated quite
1661	 * frequently in the PTP code.
1662	 */
1663	mutex_lock(&hellcreek->ptp_lock);
1664	current_ns = hellcreek->seconds * NSEC_PER_SEC + hellcreek->last_ts;
1665	mutex_unlock(&hellcreek->ptp_lock);
1666
1667	/* Calculate difference to admin base time */
1668	base_time_ns = ktime_to_ns(hellcreek_port->current_schedule->base_time);
1669
1670	return base_time_ns - current_ns < (s64)4 * NSEC_PER_SEC;
1671}
1672
1673static void hellcreek_start_schedule(struct hellcreek *hellcreek, int port)
1674{
1675	struct hellcreek_port *hellcreek_port = &hellcreek->ports[port];
1676	ktime_t base_time, current_time;
1677	s64 current_ns;
1678	u32 cycle_time;
1679
1680	/* First select port */
1681	hellcreek_select_tgd(hellcreek, port);
1682
1683	/* Forward base time into the future if needed */
1684	mutex_lock(&hellcreek->ptp_lock);
1685	current_ns = hellcreek->seconds * NSEC_PER_SEC + hellcreek->last_ts;
1686	mutex_unlock(&hellcreek->ptp_lock);
1687
1688	current_time = ns_to_ktime(current_ns);
1689	base_time    = hellcreek_port->current_schedule->base_time;
1690	cycle_time   = hellcreek_port->current_schedule->cycle_time;
1691
1692	if (ktime_compare(current_time, base_time) > 0) {
1693		s64 n;
1694
1695		n = div64_s64(ktime_sub_ns(current_time, base_time),
1696			      cycle_time);
1697		base_time = ktime_add_ns(base_time, (n + 1) * cycle_time);
1698	}
1699
1700	/* Set admin base time and switch schedule */
1701	hellcreek_switch_schedule(hellcreek, base_time);
1702
1703	taprio_offload_free(hellcreek_port->current_schedule);
1704	hellcreek_port->current_schedule = NULL;
1705
1706	dev_dbg(hellcreek->dev, "Armed EST timer for port %d\n",
1707		hellcreek_port->port);
1708}
1709
1710static void hellcreek_check_schedule(struct work_struct *work)
1711{
1712	struct delayed_work *dw = to_delayed_work(work);
1713	struct hellcreek_port *hellcreek_port;
1714	struct hellcreek *hellcreek;
1715	bool startable;
1716
1717	hellcreek_port = dw_to_hellcreek_port(dw);
1718	hellcreek = hellcreek_port->hellcreek;
1719
1720	mutex_lock(&hellcreek->reg_lock);
1721
1722	/* Check starting time */
1723	startable = hellcreek_schedule_startable(hellcreek,
1724						 hellcreek_port->port);
1725	if (startable) {
1726		hellcreek_start_schedule(hellcreek, hellcreek_port->port);
1727		mutex_unlock(&hellcreek->reg_lock);
1728		return;
1729	}
1730
1731	mutex_unlock(&hellcreek->reg_lock);
1732
1733	/* Reschedule */
1734	schedule_delayed_work(&hellcreek_port->schedule_work,
1735			      HELLCREEK_SCHEDULE_PERIOD);
1736}
1737
1738static int hellcreek_port_set_schedule(struct dsa_switch *ds, int port,
1739				       struct tc_taprio_qopt_offload *taprio)
1740{
1741	struct hellcreek *hellcreek = ds->priv;
1742	struct hellcreek_port *hellcreek_port;
1743	bool startable;
1744	u16 ctrl;
1745
1746	hellcreek_port = &hellcreek->ports[port];
1747
1748	dev_dbg(hellcreek->dev, "Configure traffic schedule on port %d\n",
1749		port);
1750
1751	/* First cancel delayed work */
1752	cancel_delayed_work_sync(&hellcreek_port->schedule_work);
1753
1754	mutex_lock(&hellcreek->reg_lock);
1755
1756	if (hellcreek_port->current_schedule) {
1757		taprio_offload_free(hellcreek_port->current_schedule);
1758		hellcreek_port->current_schedule = NULL;
1759	}
1760	hellcreek_port->current_schedule = taprio_offload_get(taprio);
1761
1762	/* Configure max sdu */
1763	hellcreek_setup_maxsdu(hellcreek, port, hellcreek_port->current_schedule);
1764
1765	/* Select tdg */
1766	hellcreek_select_tgd(hellcreek, port);
1767
1768	/* Enable gating and keep defaults */
1769	ctrl = (0xff << TR_TGDCTRL_ADMINGATESTATES_SHIFT) | TR_TGDCTRL_GATE_EN;
1770	hellcreek_write(hellcreek, ctrl, TR_TGDCTRL);
1771
1772	/* Cancel pending schedule */
1773	hellcreek_write(hellcreek, 0x00, TR_ESTCMD);
1774
1775	/* Setup a new schedule */
1776	hellcreek_setup_gcl(hellcreek, port, hellcreek_port->current_schedule);
1777
1778	/* Configure cycle time */
1779	hellcreek_set_cycle_time(hellcreek, hellcreek_port->current_schedule);
1780
1781	/* Check starting time */
1782	startable = hellcreek_schedule_startable(hellcreek, port);
1783	if (startable) {
1784		hellcreek_start_schedule(hellcreek, port);
1785		mutex_unlock(&hellcreek->reg_lock);
1786		return 0;
1787	}
1788
1789	mutex_unlock(&hellcreek->reg_lock);
1790
1791	/* Schedule periodic schedule check */
1792	schedule_delayed_work(&hellcreek_port->schedule_work,
1793			      HELLCREEK_SCHEDULE_PERIOD);
1794
1795	return 0;
1796}
1797
1798static int hellcreek_port_del_schedule(struct dsa_switch *ds, int port)
1799{
1800	struct hellcreek *hellcreek = ds->priv;
1801	struct hellcreek_port *hellcreek_port;
1802
1803	hellcreek_port = &hellcreek->ports[port];
1804
1805	dev_dbg(hellcreek->dev, "Remove traffic schedule on port %d\n", port);
1806
1807	/* First cancel delayed work */
1808	cancel_delayed_work_sync(&hellcreek_port->schedule_work);
1809
1810	mutex_lock(&hellcreek->reg_lock);
1811
1812	if (hellcreek_port->current_schedule) {
1813		taprio_offload_free(hellcreek_port->current_schedule);
1814		hellcreek_port->current_schedule = NULL;
1815	}
1816
1817	/* Reset max sdu */
1818	hellcreek_reset_maxsdu(hellcreek, port);
1819
1820	/* Select tgd */
1821	hellcreek_select_tgd(hellcreek, port);
1822
1823	/* Disable gating and return to regular switching flow */
1824	hellcreek_write(hellcreek, 0xff << TR_TGDCTRL_ADMINGATESTATES_SHIFT,
1825			TR_TGDCTRL);
1826
1827	mutex_unlock(&hellcreek->reg_lock);
1828
1829	return 0;
1830}
1831
1832static bool hellcreek_validate_schedule(struct hellcreek *hellcreek,
1833					struct tc_taprio_qopt_offload *schedule)
1834{
1835	size_t i;
1836
1837	/* Does this hellcreek version support Qbv in hardware? */
1838	if (!hellcreek->pdata->qbv_support)
1839		return false;
1840
1841	/* cycle time can only be 32bit */
1842	if (schedule->cycle_time > (u32)-1)
1843		return false;
1844
1845	/* cycle time extension is not supported */
1846	if (schedule->cycle_time_extension)
1847		return false;
1848
1849	/* Only set command is supported */
1850	for (i = 0; i < schedule->num_entries; ++i)
1851		if (schedule->entries[i].command != TC_TAPRIO_CMD_SET_GATES)
1852			return false;
1853
1854	return true;
1855}
1856
1857static int hellcreek_tc_query_caps(struct tc_query_caps_base *base)
1858{
1859	switch (base->type) {
1860	case TC_SETUP_QDISC_TAPRIO: {
1861		struct tc_taprio_caps *caps = base->caps;
1862
1863		caps->supports_queue_max_sdu = true;
1864
1865		return 0;
1866	}
1867	default:
1868		return -EOPNOTSUPP;
1869	}
1870}
1871
1872static int hellcreek_port_setup_tc(struct dsa_switch *ds, int port,
1873				   enum tc_setup_type type, void *type_data)
1874{
 
1875	struct hellcreek *hellcreek = ds->priv;
1876
1877	switch (type) {
1878	case TC_QUERY_CAPS:
1879		return hellcreek_tc_query_caps(type_data);
1880	case TC_SETUP_QDISC_TAPRIO: {
1881		struct tc_taprio_qopt_offload *taprio = type_data;
1882
1883		switch (taprio->cmd) {
1884		case TAPRIO_CMD_REPLACE:
1885			if (!hellcreek_validate_schedule(hellcreek, taprio))
1886				return -EOPNOTSUPP;
1887
1888			return hellcreek_port_set_schedule(ds, port, taprio);
1889		case TAPRIO_CMD_DESTROY:
1890			return hellcreek_port_del_schedule(ds, port);
1891		default:
1892			return -EOPNOTSUPP;
1893		}
1894	}
1895	default:
1896		return -EOPNOTSUPP;
1897	}
 
 
 
 
 
 
 
1898}
1899
1900static const struct dsa_switch_ops hellcreek_ds_ops = {
1901	.devlink_info_get      = hellcreek_devlink_info_get,
1902	.get_ethtool_stats     = hellcreek_get_ethtool_stats,
1903	.get_sset_count	       = hellcreek_get_sset_count,
1904	.get_strings	       = hellcreek_get_strings,
1905	.get_tag_protocol      = hellcreek_get_tag_protocol,
1906	.get_ts_info	       = hellcreek_get_ts_info,
1907	.phylink_get_caps      = hellcreek_phylink_get_caps,
1908	.port_bridge_flags     = hellcreek_bridge_flags,
1909	.port_bridge_join      = hellcreek_port_bridge_join,
1910	.port_bridge_leave     = hellcreek_port_bridge_leave,
1911	.port_disable	       = hellcreek_port_disable,
1912	.port_enable	       = hellcreek_port_enable,
1913	.port_fdb_add	       = hellcreek_fdb_add,
1914	.port_fdb_del	       = hellcreek_fdb_del,
1915	.port_fdb_dump	       = hellcreek_fdb_dump,
1916	.port_hwtstamp_set     = hellcreek_port_hwtstamp_set,
1917	.port_hwtstamp_get     = hellcreek_port_hwtstamp_get,
1918	.port_pre_bridge_flags = hellcreek_pre_bridge_flags,
1919	.port_prechangeupper   = hellcreek_port_prechangeupper,
1920	.port_rxtstamp	       = hellcreek_port_rxtstamp,
1921	.port_setup_tc	       = hellcreek_port_setup_tc,
1922	.port_stp_state_set    = hellcreek_port_stp_state_set,
1923	.port_txtstamp	       = hellcreek_port_txtstamp,
1924	.port_vlan_add	       = hellcreek_vlan_add,
1925	.port_vlan_del	       = hellcreek_vlan_del,
1926	.port_vlan_filtering   = hellcreek_vlan_filtering,
1927	.setup		       = hellcreek_setup,
1928	.teardown	       = hellcreek_teardown,
1929};
1930
1931static int hellcreek_probe(struct platform_device *pdev)
1932{
1933	struct device *dev = &pdev->dev;
1934	struct hellcreek *hellcreek;
1935	struct resource *res;
1936	int ret, i;
1937
1938	hellcreek = devm_kzalloc(dev, sizeof(*hellcreek), GFP_KERNEL);
1939	if (!hellcreek)
1940		return -ENOMEM;
1941
1942	hellcreek->vidmbrcfg = devm_kcalloc(dev, VLAN_N_VID,
1943					    sizeof(*hellcreek->vidmbrcfg),
1944					    GFP_KERNEL);
1945	if (!hellcreek->vidmbrcfg)
1946		return -ENOMEM;
1947
1948	hellcreek->pdata = of_device_get_match_data(dev);
1949
1950	hellcreek->ports = devm_kcalloc(dev, hellcreek->pdata->num_ports,
1951					sizeof(*hellcreek->ports),
1952					GFP_KERNEL);
1953	if (!hellcreek->ports)
1954		return -ENOMEM;
1955
1956	for (i = 0; i < hellcreek->pdata->num_ports; ++i) {
1957		struct hellcreek_port *port = &hellcreek->ports[i];
1958
1959		port->counter_values =
1960			devm_kcalloc(dev,
1961				     ARRAY_SIZE(hellcreek_counter),
1962				     sizeof(*port->counter_values),
1963				     GFP_KERNEL);
1964		if (!port->counter_values)
1965			return -ENOMEM;
1966
1967		port->vlan_dev_bitmap = devm_bitmap_zalloc(dev, VLAN_N_VID,
1968							   GFP_KERNEL);
 
 
 
1969		if (!port->vlan_dev_bitmap)
1970			return -ENOMEM;
1971
1972		port->hellcreek	= hellcreek;
1973		port->port	= i;
1974
1975		INIT_DELAYED_WORK(&port->schedule_work,
1976				  hellcreek_check_schedule);
1977	}
1978
1979	mutex_init(&hellcreek->reg_lock);
1980	mutex_init(&hellcreek->vlan_lock);
1981	mutex_init(&hellcreek->ptp_lock);
1982
1983	hellcreek->dev = dev;
1984
1985	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tsn");
1986	if (!res) {
1987		dev_err(dev, "No memory region provided!\n");
1988		return -ENODEV;
1989	}
1990
1991	hellcreek->base = devm_ioremap_resource(dev, res);
1992	if (IS_ERR(hellcreek->base))
1993		return PTR_ERR(hellcreek->base);
1994
1995	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ptp");
1996	if (!res) {
1997		dev_err(dev, "No PTP memory region provided!\n");
1998		return -ENODEV;
1999	}
2000
2001	hellcreek->ptp_base = devm_ioremap_resource(dev, res);
2002	if (IS_ERR(hellcreek->ptp_base))
2003		return PTR_ERR(hellcreek->ptp_base);
2004
2005	ret = hellcreek_detect(hellcreek);
2006	if (ret) {
2007		dev_err(dev, "No (known) chip found!\n");
2008		return ret;
2009	}
2010
2011	ret = hellcreek_wait_until_ready(hellcreek);
2012	if (ret) {
2013		dev_err(dev, "Switch didn't become ready!\n");
2014		return ret;
2015	}
2016
2017	hellcreek_feature_detect(hellcreek);
2018
2019	hellcreek->ds = devm_kzalloc(dev, sizeof(*hellcreek->ds), GFP_KERNEL);
2020	if (!hellcreek->ds)
2021		return -ENOMEM;
2022
2023	hellcreek->ds->dev	     = dev;
2024	hellcreek->ds->priv	     = hellcreek;
2025	hellcreek->ds->ops	     = &hellcreek_ds_ops;
2026	hellcreek->ds->num_ports     = hellcreek->pdata->num_ports;
2027	hellcreek->ds->num_tx_queues = HELLCREEK_NUM_EGRESS_QUEUES;
2028
2029	ret = dsa_register_switch(hellcreek->ds);
2030	if (ret) {
2031		dev_err_probe(dev, ret, "Unable to register switch\n");
2032		return ret;
2033	}
2034
2035	ret = hellcreek_ptp_setup(hellcreek);
2036	if (ret) {
2037		dev_err(dev, "Failed to setup PTP!\n");
2038		goto err_ptp_setup;
2039	}
2040
2041	ret = hellcreek_hwtstamp_setup(hellcreek);
2042	if (ret) {
2043		dev_err(dev, "Failed to setup hardware timestamping!\n");
2044		goto err_tstamp_setup;
2045	}
2046
2047	platform_set_drvdata(pdev, hellcreek);
2048
2049	return 0;
2050
2051err_tstamp_setup:
2052	hellcreek_ptp_free(hellcreek);
2053err_ptp_setup:
2054	dsa_unregister_switch(hellcreek->ds);
2055
2056	return ret;
2057}
2058
2059static void hellcreek_remove(struct platform_device *pdev)
2060{
2061	struct hellcreek *hellcreek = platform_get_drvdata(pdev);
2062
2063	if (!hellcreek)
2064		return;
2065
2066	hellcreek_hwtstamp_free(hellcreek);
2067	hellcreek_ptp_free(hellcreek);
2068	dsa_unregister_switch(hellcreek->ds);
2069}
2070
2071static void hellcreek_shutdown(struct platform_device *pdev)
2072{
2073	struct hellcreek *hellcreek = platform_get_drvdata(pdev);
2074
2075	if (!hellcreek)
2076		return;
2077
2078	dsa_switch_shutdown(hellcreek->ds);
2079
2080	platform_set_drvdata(pdev, NULL);
 
 
2081}
2082
2083static const struct hellcreek_platform_data de1soc_r1_pdata = {
2084	.name		 = "r4c30",
2085	.num_ports	 = 4,
2086	.is_100_mbits	 = 1,
2087	.qbv_support	 = 1,
2088	.qbv_on_cpu_port = 1,
2089	.qbu_support	 = 0,
2090	.module_id	 = 0x4c30,
2091};
2092
2093static const struct of_device_id hellcreek_of_match[] = {
2094	{
2095		.compatible = "hirschmann,hellcreek-de1soc-r1",
2096		.data	    = &de1soc_r1_pdata,
2097	},
2098	{ /* sentinel */ },
2099};
2100MODULE_DEVICE_TABLE(of, hellcreek_of_match);
2101
2102static struct platform_driver hellcreek_driver = {
2103	.probe	= hellcreek_probe,
2104	.remove = hellcreek_remove,
2105	.shutdown = hellcreek_shutdown,
2106	.driver = {
2107		.name = "hellcreek",
2108		.of_match_table = hellcreek_of_match,
2109	},
2110};
2111module_platform_driver(hellcreek_driver);
2112
2113MODULE_AUTHOR("Kurt Kanzenbach <kurt@linutronix.de>");
2114MODULE_DESCRIPTION("Hirschmann Hellcreek driver");
2115MODULE_LICENSE("Dual MIT/GPL");