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