1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT)
3 * Copyright (c) 2019 Microsemi Corporation
10 #include <dm/of_access.h>
11 #include <dm/of_addr.h>
12 #include <fdt_support.h>
14 #include <linux/ioport.h>
19 #include "mscc_xfer.h"
20 #include "mscc_miim.h"
23 #define PHY_CFG_ENA 0x3
24 #define PHY_CFG_COMMON_RST BIT(2)
25 #define PHY_CFG_RST (0x3 << 3)
27 #define PHY_STAT_SUPERVISOR_COMPLETE BIT(0)
29 #define ANA_AC_RAM_CTRL_RAM_INIT 0x14fdc
30 #define ANA_AC_STAT_GLOBAL_CFG_PORT_RESET 0x15474
32 #define ANA_CL_PORT_VLAN_CFG(x) (0xa018 + 0xc8 * (x))
33 #define ANA_CL_PORT_VLAN_CFG_AWARE_ENA BIT(19)
34 #define ANA_CL_PORT_VLAN_CFG_POP_CNT(x) ((x) << 17)
36 #define ANA_L2_COMMON_FWD_CFG 0x18498
37 #define ANA_L2_COMMON_FWD_CFG_CPU_DMAC_COPY_ENA BIT(6)
39 #define ASM_CFG_STAT_CFG 0xb08
40 #define ASM_CFG_PORT(x) (0xb74 + 0x4 * (x))
41 #define ASM_CFG_PORT_NO_PREAMBLE_ENA BIT(8)
42 #define ASM_CFG_PORT_INJ_FORMAT_CFG(x) ((x) << 1)
43 #define ASM_RAM_CTRL_RAM_INIT 0xbfc
45 #define DEV_DEV_CFG_DEV_RST_CTRL 0x0
46 #define DEV_DEV_CFG_DEV_RST_CTRL_SPEED_SEL(x) ((x) << 20)
47 #define DEV_MAC_CFG_MAC_ENA 0x24
48 #define DEV_MAC_CFG_MAC_ENA_RX_ENA BIT(4)
49 #define DEV_MAC_CFG_MAC_ENA_TX_ENA BIT(0)
50 #define DEV_MAC_CFG_MAC_IFG 0x3c
51 #define DEV_MAC_CFG_MAC_IFG_TX_IFG(x) ((x) << 8)
52 #define DEV_MAC_CFG_MAC_IFG_RX_IFG2(x) ((x) << 4)
53 #define DEV_MAC_CFG_MAC_IFG_RX_IFG1(x) (x)
54 #define DEV_PCS1G_CFG_PCS1G_CFG 0x48
55 #define DEV_PCS1G_CFG_PCS1G_CFG_PCS_ENA BIT(0)
56 #define DEV_PCS1G_CFG_PCS1G_MODE 0x4c
57 #define DEV_PCS1G_CFG_PCS1G_SD 0x50
58 #define DEV_PCS1G_CFG_PCS1G_ANEG 0x54
59 #define DEV_PCS1G_CFG_PCS1G_ANEG_ADV_ABILITY(x) ((x) << 16)
61 #define LRN_COMMON_ACCESS_CTRL 0x0
62 #define LRN_COMMON_ACCESS_CTRL_MAC_TABLE_ACCESS_SHOT BIT(0)
63 #define LRN_COMMON_MAC_ACCESS_CFG0 0x4
64 #define LRN_COMMON_MAC_ACCESS_CFG1 0x8
65 #define LRN_COMMON_MAC_ACCESS_CFG2 0xc
66 #define LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_ADDR(x) (x)
67 #define LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_TYPE(x) ((x) << 12)
68 #define LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_VLD BIT(15)
69 #define LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_LOCKED BIT(16)
70 #define LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_CPU_COPY BIT(23)
71 #define LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_CPU_QU(x) ((x) << 24)
73 #define QFWD_SYSTEM_SWITCH_PORT_MODE(x) (0x4400 + 0x4 * (x))
74 #define QFWD_SYSTEM_SWITCH_PORT_MODE_PORT_ENA BIT(17)
76 #define QS_XTR_GRP_CFG(x) (4 * (x))
77 #define QS_INJ_GRP_CFG(x) (0x24 + (x) * 4)
79 #define QSYS_SYSTEM_RESET_CFG 0x1048
80 #define QSYS_CALCFG_CAL_AUTO 0x1134
81 #define QSYS_CALCFG_CAL_CTRL 0x113c
82 #define QSYS_CALCFG_CAL_CTRL_CAL_MODE(x) ((x) << 11)
83 #define QSYS_RAM_CTRL_RAM_INIT 0x1140
85 #define REW_RAM_CTRL_RAM_INIT 0xFFF4
91 #define PGID_BROADCAST 50
92 #define PGID_UNICAST 51
94 static const char * const regs_names[] = {
96 "ana_ac", "ana_cl", "ana_l2", "asm", "lrn", "qfwd", "qs", "qsys", "rew",
99 #define REGS_NAMES_COUNT ARRAY_SIZE(regs_names) + 1
102 enum servalt_ctrl_regs {
114 #define SERVALT_MIIM_BUS_COUNT 2
116 struct servalt_phy_port_t {
121 struct servalt_private {
122 void __iomem *regs[REGS_NAMES_COUNT];
123 struct mii_dev *bus[SERVALT_MIIM_BUS_COUNT];
124 struct servalt_phy_port_t ports[MAX_PORT];
127 static const unsigned long servalt_regs_qs[] = {
128 [MSCC_QS_XTR_RD] = 0x8,
129 [MSCC_QS_XTR_FLUSH] = 0x18,
130 [MSCC_QS_XTR_DATA_PRESENT] = 0x1c,
131 [MSCC_QS_INJ_WR] = 0x2c,
132 [MSCC_QS_INJ_CTRL] = 0x34,
135 static struct mscc_miim_dev miim[SERVALT_MIIM_BUS_COUNT];
136 static int miim_count = -1;
138 static void mscc_phy_reset(void)
140 writel(0, BASE_DEVCPU_GCB + GCB_PHY_CFG + PHY_CFG);
141 writel(PHY_CFG_RST | PHY_CFG_COMMON_RST
142 | PHY_CFG_ENA, BASE_DEVCPU_GCB + GCB_PHY_CFG + PHY_CFG);
143 if (wait_for_bit_le32((const void *)(BASE_DEVCPU_GCB + GCB_PHY_CFG) +
144 PHY_STAT, PHY_STAT_SUPERVISOR_COMPLETE,
145 true, 2000, false)) {
146 pr_err("Timeout in phy reset\n");
150 static void servalt_cpu_capture_setup(struct servalt_private *priv)
152 /* ASM: No preamble and IFH prefix on CPU injected frames */
153 writel(ASM_CFG_PORT_NO_PREAMBLE_ENA |
154 ASM_CFG_PORT_INJ_FORMAT_CFG(1),
155 priv->regs[ASM] + ASM_CFG_PORT(CPU_PORT));
157 /* Set Manual injection via DEVCPU_QS registers for CPU queue 0 */
158 writel(0x5, priv->regs[QS] + QS_INJ_GRP_CFG(0));
160 /* Set Manual extraction via DEVCPU_QS registers for CPU queue 0 */
161 writel(0x7, priv->regs[QS] + QS_XTR_GRP_CFG(0));
163 /* Enable CPU port for any frame transfer */
164 setbits_le32(priv->regs[QFWD] + QFWD_SYSTEM_SWITCH_PORT_MODE(CPU_PORT),
165 QFWD_SYSTEM_SWITCH_PORT_MODE_PORT_ENA);
167 /* Send a copy to CPU when found as forwarding entry */
168 setbits_le32(priv->regs[ANA_L2] + ANA_L2_COMMON_FWD_CFG,
169 ANA_L2_COMMON_FWD_CFG_CPU_DMAC_COPY_ENA);
172 static void servalt_port_init(struct servalt_private *priv, int port)
174 void __iomem *regs = priv->regs[port];
177 writel(DEV_PCS1G_CFG_PCS1G_CFG_PCS_ENA,
178 regs + DEV_PCS1G_CFG_PCS1G_CFG);
180 /* Disable Signal Detect */
181 writel(0, regs + DEV_PCS1G_CFG_PCS1G_SD);
183 /* Enable MAC RX and TX */
184 writel(DEV_MAC_CFG_MAC_ENA_RX_ENA |
185 DEV_MAC_CFG_MAC_ENA_TX_ENA,
186 regs + DEV_MAC_CFG_MAC_ENA);
188 /* Clear sgmii_mode_ena */
189 writel(0, regs + DEV_PCS1G_CFG_PCS1G_MODE);
192 * Clear sw_resolve_ena(bit 0) and set adv_ability to
193 * something meaningful just in case
195 writel(DEV_PCS1G_CFG_PCS1G_ANEG_ADV_ABILITY(0x20),
196 regs + DEV_PCS1G_CFG_PCS1G_ANEG);
198 /* Set MAC IFG Gaps */
199 writel(DEV_MAC_CFG_MAC_IFG_TX_IFG(4) |
200 DEV_MAC_CFG_MAC_IFG_RX_IFG1(5) |
201 DEV_MAC_CFG_MAC_IFG_RX_IFG2(1),
202 regs + DEV_MAC_CFG_MAC_IFG);
204 /* Set link speed and release all resets */
205 writel(DEV_DEV_CFG_DEV_RST_CTRL_SPEED_SEL(2),
206 regs + DEV_DEV_CFG_DEV_RST_CTRL);
208 /* Make VLAN aware for CPU traffic */
209 writel(ANA_CL_PORT_VLAN_CFG_AWARE_ENA |
210 ANA_CL_PORT_VLAN_CFG_POP_CNT(1) |
212 priv->regs[ANA_CL] + ANA_CL_PORT_VLAN_CFG(port));
214 /* Enable CPU port for any frame transfer */
215 setbits_le32(priv->regs[QFWD] + QFWD_SYSTEM_SWITCH_PORT_MODE(port),
216 QFWD_SYSTEM_SWITCH_PORT_MODE_PORT_ENA);
219 static int ram_init(u32 val, void __iomem *addr)
223 if (wait_for_bit_le32(addr, BIT(1), false, 2000, false)) {
224 printf("Timeout in memory reset, reg = 0x%08x\n", val);
231 static int servalt_switch_init(struct servalt_private *priv)
233 /* Initialize memories */
234 ram_init(0x3, priv->regs[QSYS] + QSYS_RAM_CTRL_RAM_INIT);
235 ram_init(0x3, priv->regs[ASM] + ASM_RAM_CTRL_RAM_INIT);
236 ram_init(0x3, priv->regs[ANA_AC] + ANA_AC_RAM_CTRL_RAM_INIT);
237 ram_init(0x3, priv->regs[REW] + REW_RAM_CTRL_RAM_INIT);
240 writel(0x1, priv->regs[ANA_AC] + ANA_AC_STAT_GLOBAL_CFG_PORT_RESET);
241 writel(0x1, priv->regs[ASM] + ASM_CFG_STAT_CFG);
243 /* Enable switch-core and queue system */
244 writel(0x1, priv->regs[QSYS] + QSYS_SYSTEM_RESET_CFG);
249 static void servalt_switch_config(struct servalt_private *priv)
251 writel(0x55555555, priv->regs[QSYS] + QSYS_CALCFG_CAL_AUTO);
253 writel(readl(priv->regs[QSYS] + QSYS_CALCFG_CAL_CTRL) |
254 QSYS_CALCFG_CAL_CTRL_CAL_MODE(8),
255 priv->regs[QSYS] + QSYS_CALCFG_CAL_CTRL);
258 static int servalt_initialize(struct servalt_private *priv)
262 /* Initialize switch memories, enable core */
263 ret = servalt_switch_init(priv);
267 servalt_switch_config(priv);
269 for (i = 0; i < MAX_PORT; i++)
270 servalt_port_init(priv, i);
272 servalt_cpu_capture_setup(priv);
278 int servalt_vlant_wait_for_completion(struct servalt_private *priv)
280 if (wait_for_bit_le32(priv->regs[LRN] + LRN_COMMON_ACCESS_CTRL,
281 LRN_COMMON_ACCESS_CTRL_MAC_TABLE_ACCESS_SHOT,
288 static int servalt_mac_table_add(struct servalt_private *priv,
289 const unsigned char mac[ETH_ALEN], int pgid)
291 u32 macl = 0, mach = 0;
294 * Set the MAC address to handle and the vlan associated in a format
295 * understood by the hardware.
297 mach |= MAC_VID << 16;
298 mach |= ((u32)mac[0]) << 8;
299 mach |= ((u32)mac[1]) << 0;
300 macl |= ((u32)mac[2]) << 24;
301 macl |= ((u32)mac[3]) << 16;
302 macl |= ((u32)mac[4]) << 8;
303 macl |= ((u32)mac[5]) << 0;
305 writel(mach, priv->regs[LRN] + LRN_COMMON_MAC_ACCESS_CFG0);
306 writel(macl, priv->regs[LRN] + LRN_COMMON_MAC_ACCESS_CFG1);
308 writel(LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_ADDR(pgid) |
309 LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_TYPE(0x3) |
310 LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_CPU_COPY |
311 LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_CPU_QU(0) |
312 LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_VLD |
313 LRN_COMMON_MAC_ACCESS_CFG2_MAC_ENTRY_LOCKED,
314 priv->regs[LRN] + LRN_COMMON_MAC_ACCESS_CFG2);
316 writel(LRN_COMMON_ACCESS_CTRL_MAC_TABLE_ACCESS_SHOT,
317 priv->regs[LRN] + LRN_COMMON_ACCESS_CTRL);
319 return servalt_vlant_wait_for_completion(priv);
322 static int servalt_write_hwaddr(struct udevice *dev)
324 struct servalt_private *priv = dev_get_priv(dev);
325 struct eth_pdata *pdata = dev_get_platdata(dev);
327 return servalt_mac_table_add(priv, pdata->enetaddr, PGID_UNICAST);
330 static int servalt_start(struct udevice *dev)
332 struct servalt_private *priv = dev_get_priv(dev);
333 struct eth_pdata *pdata = dev_get_platdata(dev);
334 const unsigned char mac[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff,
338 ret = servalt_initialize(priv);
342 /* Set MAC address tables entries for CPU redirection */
343 ret = servalt_mac_table_add(priv, mac, PGID_BROADCAST);
347 ret = servalt_mac_table_add(priv, pdata->enetaddr, PGID_UNICAST);
354 static void servalt_stop(struct udevice *dev)
358 static int servalt_send(struct udevice *dev, void *packet, int length)
360 struct servalt_private *priv = dev_get_priv(dev);
364 memset(ifh, '\0', IFH_LEN * 4);
366 /* Set DST PORT_MASK */
368 ifh[1] = htonl(0x1FFFFF);
370 /* Set DST_MODE to INJECT and UPDATE_FCS */
371 ifh[5] = htonl(0x4c0);
373 return mscc_send(priv->regs[QS], servalt_regs_qs,
374 ifh, IFH_LEN, buf, length);
377 static int servalt_recv(struct udevice *dev, int flags, uchar **packetp)
379 struct servalt_private *priv = dev_get_priv(dev);
380 u32 *rxbuf = (u32 *)net_rx_packets[0];
383 byte_cnt = mscc_recv(priv->regs[QS], servalt_regs_qs, rxbuf, IFH_LEN,
386 *packetp = net_rx_packets[0];
391 static struct mii_dev *get_mdiobus(phys_addr_t base, unsigned long size)
395 for (i = 0; i < SERVALT_MIIM_BUS_COUNT; ++i)
396 if (miim[i].miim_base == base && miim[i].miim_size == size)
402 static void add_port_entry(struct servalt_private *priv, size_t index,
403 size_t phy_addr, struct mii_dev *bus)
405 priv->ports[index].phy_addr = phy_addr;
406 priv->ports[index].bus = bus;
409 static int servalt_probe(struct udevice *dev)
411 struct servalt_private *priv = dev_get_priv(dev);
415 phys_addr_t addr_base;
416 unsigned long addr_size;
417 ofnode eth_node, node, mdio_node;
420 struct ofnode_phandle_args phandle;
425 /* Get registers and map them to the private structure */
426 for (i = 0; i < ARRAY_SIZE(regs_names); i++) {
427 priv->regs[i] = dev_remap_addr_name(dev, regs_names[i]);
428 if (!priv->regs[i]) {
430 ("Error can't get regs base addresses for %s\n",
436 /* Initialize miim buses */
437 memset(&miim, 0x0, sizeof(struct mscc_miim_dev) *
438 SERVALT_MIIM_BUS_COUNT);
440 /* iterate all the ports and find out on which bus they are */
442 eth_node = dev_read_first_subnode(dev);
443 for (node = ofnode_first_subnode(eth_node);
445 node = ofnode_next_subnode(node)) {
446 if (ofnode_read_resource(node, 0, &res))
450 ofnode_parse_phandle_with_args(node, "phy-handle", NULL, 0, 0,
453 /* Get phy address on mdio bus */
454 if (ofnode_read_resource(phandle.node, 0, &res))
456 phy_addr = res.start;
459 mdio_node = ofnode_get_parent(phandle.node);
461 if (ofnode_read_resource(mdio_node, 0, &res))
463 faddr = cpu_to_fdt32(res.start);
465 addr_base = ofnode_translate_address(mdio_node, &faddr);
466 addr_size = res.end - res.start;
468 /* If the bus is new then create a new bus */
469 if (!get_mdiobus(addr_base, addr_size))
470 priv->bus[miim_count] =
471 mscc_mdiobus_init(miim, &miim_count, addr_base,
474 /* Connect mdio bus with the port */
475 bus = get_mdiobus(addr_base, addr_size);
476 add_port_entry(priv, i, phy_addr, bus);
481 for (i = 0; i < MAX_PORT; i++) {
482 if (!priv->ports[i].bus)
485 phy_connect(priv->ports[i].bus, priv->ports[i].phy_addr, dev,
486 PHY_INTERFACE_MODE_NONE);
492 static int servalt_remove(struct udevice *dev)
494 struct servalt_private *priv = dev_get_priv(dev);
497 for (i = 0; i < SERVALT_MIIM_BUS_COUNT; i++) {
498 mdio_unregister(priv->bus[i]);
499 mdio_free(priv->bus[i]);
505 static const struct eth_ops servalt_ops = {
506 .start = servalt_start,
507 .stop = servalt_stop,
508 .send = servalt_send,
509 .recv = servalt_recv,
510 .write_hwaddr = servalt_write_hwaddr,
513 static const struct udevice_id mscc_servalt_ids[] = {
514 {.compatible = "mscc,vsc7437-switch" },
518 U_BOOT_DRIVER(servalt) = {
519 .name = "servalt-switch",
521 .of_match = mscc_servalt_ids,
522 .probe = servalt_probe,
523 .remove = servalt_remove,
525 .priv_auto_alloc_size = sizeof(struct servalt_private),
526 .platdata_auto_alloc_size = sizeof(struct eth_pdata),