1 From 6b8a7257e7bcb56782c3f8048311670fe6a80209 Mon Sep 17 00:00:00 2001
2 From: John Crispin <blogic@openwrt.org>
3 Date: Mon, 11 Apr 2016 03:11:54 +0200
4 Subject: [PATCH 101/102] net: mediatek add gsw/mt7530 driver
6 Signed-off-by: John Crispin <blogic@openwrt.org>
8 drivers/net/ethernet/mediatek/Makefile | 2 +-
9 drivers/net/ethernet/mediatek/gsw_mt7620.h | 251 +++++++
10 drivers/net/ethernet/mediatek/gsw_mt7623.c | 1084 +++++++++++++++++++++++++++
11 drivers/net/ethernet/mediatek/mt7530.c | 808 ++++++++++++++++++++
12 drivers/net/ethernet/mediatek/mt7530.h | 20 +
13 drivers/net/ethernet/mediatek/mtk_eth_soc.c | 59 +-
14 drivers/net/ethernet/mediatek/mtk_eth_soc.h | 5 +
15 7 files changed, 2199 insertions(+), 30 deletions(-)
16 create mode 100644 drivers/net/ethernet/mediatek/gsw_mt7620.h
17 create mode 100644 drivers/net/ethernet/mediatek/gsw_mt7623.c
18 create mode 100644 drivers/net/ethernet/mediatek/mt7530.c
19 create mode 100644 drivers/net/ethernet/mediatek/mt7530.h
21 --- a/drivers/net/ethernet/mediatek/Makefile
22 +++ b/drivers/net/ethernet/mediatek/Makefile
24 # Makefile for the Mediatek SoCs built-in ethernet macs
27 -obj-$(CONFIG_NET_MEDIATEK_SOC) += mtk_eth_soc.o
28 +obj-$(CONFIG_NET_MEDIATEK_SOC) += mt7530.o gsw_mt7623.o mtk_eth_soc.o
30 +++ b/drivers/net/ethernet/mediatek/gsw_mt7620.h
32 +/* This program is free software; you can redistribute it and/or modify
33 + * it under the terms of the GNU General Public License as published by
34 + * the Free Software Foundation; version 2 of the License
36 + * This program is distributed in the hope that it will be useful,
37 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
38 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
39 + * GNU General Public License for more details.
41 + * Copyright (C) 2009-2016 John Crispin <blogic@openwrt.org>
42 + * Copyright (C) 2009-2016 Felix Fietkau <nbd@openwrt.org>
43 + * Copyright (C) 2013-2016 Michael Lee <igvtee@gmail.com>
46 +#ifndef _RALINK_GSW_MT7620_H__
47 +#define _RALINK_GSW_MT7620_H__
49 +#define GSW_REG_PHY_TIMEOUT (5 * HZ)
51 +#define MT7620_GSW_REG_PIAC 0x0004
53 +#define GSW_NUM_VLANS 16
54 +#define GSW_NUM_VIDS 4096
55 +#define GSW_NUM_PORTS 7
58 +#define GSW_MDIO_ACCESS BIT(31)
59 +#define GSW_MDIO_READ BIT(19)
60 +#define GSW_MDIO_WRITE BIT(18)
61 +#define GSW_MDIO_START BIT(16)
62 +#define GSW_MDIO_ADDR_SHIFT 20
63 +#define GSW_MDIO_REG_SHIFT 25
65 +#define GSW_REG_PORT_PMCR(x) (0x3000 + (x * 0x100))
66 +#define GSW_REG_PORT_STATUS(x) (0x3008 + (x * 0x100))
67 +#define GSW_REG_SMACCR0 0x3fE4
68 +#define GSW_REG_SMACCR1 0x3fE8
69 +#define GSW_REG_CKGCR 0x3ff0
71 +#define GSW_REG_IMR 0x7008
72 +#define GSW_REG_ISR 0x700c
73 +#define GSW_REG_GPC1 0x7014
75 +#define SYSC_REG_CHIP_REV_ID 0x0c
76 +#define SYSC_REG_CFG 0x10
77 +#define SYSC_REG_CFG1 0x14
78 +#define RST_CTRL_MCM BIT(2)
79 +#define SYSC_PAD_RGMII2_MDIO 0x58
80 +#define SYSC_GPIO_MODE 0x60
82 +#define PORT_IRQ_ST_CHG 0x7f
84 +#define MT7621_ESW_PHY_POLLING 0x0000
85 +#define MT7620_ESW_PHY_POLLING 0x7000
87 +#define PMCR_IPG BIT(18)
88 +#define PMCR_MAC_MODE BIT(16)
89 +#define PMCR_FORCE BIT(15)
90 +#define PMCR_TX_EN BIT(14)
91 +#define PMCR_RX_EN BIT(13)
92 +#define PMCR_BACKOFF BIT(9)
93 +#define PMCR_BACKPRES BIT(8)
94 +#define PMCR_RX_FC BIT(5)
95 +#define PMCR_TX_FC BIT(4)
96 +#define PMCR_SPEED(_x) (_x << 2)
97 +#define PMCR_DUPLEX BIT(1)
98 +#define PMCR_LINK BIT(0)
100 +#define PHY_AN_EN BIT(31)
101 +#define PHY_PRE_EN BIT(30)
102 +#define PMY_MDC_CONF(_x) ((_x & 0x3f) << 24)
104 +/* ethernet subsystem config register */
105 +#define ETHSYS_SYSCFG0 0x14
106 +/* ethernet subsystem clock register */
107 +#define ETHSYS_CLKCFG0 0x2c
108 +#define ETHSYS_TRGMII_CLK_SEL362_5 BIT(11)
110 +/* p5 RGMII wrapper TX clock control register */
111 +#define MT7530_P5RGMIITXCR 0x7b04
112 +/* p5 RGMII wrapper RX clock control register */
113 +#define MT7530_P5RGMIIRXCR 0x7b00
114 +/* TRGMII TDX ODT registers */
115 +#define MT7530_TRGMII_TD0_ODT 0x7a54
116 +#define MT7530_TRGMII_TD1_ODT 0x7a5c
117 +#define MT7530_TRGMII_TD2_ODT 0x7a64
118 +#define MT7530_TRGMII_TD3_ODT 0x7a6c
119 +#define MT7530_TRGMII_TD4_ODT 0x7a74
120 +#define MT7530_TRGMII_TD5_ODT 0x7a7c
121 +/* TRGMII TCK ctrl register */
122 +#define MT7530_TRGMII_TCK_CTRL 0x7a78
123 +/* TRGMII Tx ctrl register */
124 +#define MT7530_TRGMII_TXCTRL 0x7a40
125 +/* port 6 extended control register */
126 +#define MT7530_P6ECR 0x7830
127 +/* IO driver control register */
128 +#define MT7530_IO_DRV_CR 0x7810
129 +/* top signal control register */
130 +#define MT7530_TOP_SIG_CTRL 0x7808
131 +/* modified hwtrap register */
132 +#define MT7530_MHWTRAP 0x7804
133 +/* hwtrap status register */
134 +#define MT7530_HWTRAP 0x7800
135 +/* status interrupt register */
136 +#define MT7530_SYS_INT_STS 0x700c
137 +/* system nterrupt register */
138 +#define MT7530_SYS_INT_EN 0x7008
139 +/* system control register */
140 +#define MT7530_SYS_CTRL 0x7000
141 +/* port MAC status register */
142 +#define MT7530_PMSR_P(x) (0x3008 + (x * 0x100))
143 +/* port MAC control register */
144 +#define MT7530_PMCR_P(x) (0x3000 + (x * 0x100))
146 +#define MT7621_XTAL_SHIFT 6
147 +#define MT7621_XTAL_MASK 0x7
148 +#define MT7621_XTAL_25 6
149 +#define MT7621_XTAL_40 3
150 +#define MT7621_MDIO_DRV_MASK (3 << 4)
151 +#define MT7621_GE1_MODE_MASK (3 << 12)
153 +#define TRGMII_TXCTRL_TXC_INV BIT(30)
154 +#define P6ECR_INTF_MODE_RGMII BIT(1)
155 +#define P5RGMIIRXCR_C_ALIGN BIT(8)
156 +#define P5RGMIIRXCR_DELAY_2 BIT(1)
157 +#define P5RGMIITXCR_DELAY_2 (BIT(8) | BIT(2))
159 +/* TOP_SIG_CTRL bits */
160 +#define TOP_SIG_CTRL_NORMAL (BIT(17) | BIT(16))
163 +#define MHWTRAP_MANUAL BIT(16)
164 +#define MHWTRAP_P5_MAC_SEL BIT(13)
165 +#define MHWTRAP_P6_DIS BIT(8)
166 +#define MHWTRAP_P5_RGMII_MODE BIT(7)
167 +#define MHWTRAP_P5_DIS BIT(6)
168 +#define MHWTRAP_PHY_ACCESS BIT(5)
171 +#define HWTRAP_XTAL_SHIFT 9
172 +#define HWTRAP_XTAL_MASK 0x3
175 +#define SYS_CTRL_SW_RST BIT(1)
176 +#define SYS_CTRL_REG_RST BIT(0)
179 +#define PMCR_IFG_XMIT_96 BIT(18)
180 +#define PMCR_MAC_MODE BIT(16)
181 +#define PMCR_FORCE_MODE BIT(15)
182 +#define PMCR_TX_EN BIT(14)
183 +#define PMCR_RX_EN BIT(13)
184 +#define PMCR_BACK_PRES_EN BIT(9)
185 +#define PMCR_BACKOFF_EN BIT(8)
186 +#define PMCR_TX_FC_EN BIT(5)
187 +#define PMCR_RX_FC_EN BIT(4)
188 +#define PMCR_FORCE_SPEED_1000 BIT(3)
189 +#define PMCR_FORCE_FDX BIT(1)
190 +#define PMCR_FORCE_LNK BIT(0)
191 +#define PMCR_FIXED_LINK (PMCR_IFG_XMIT_96 | PMCR_MAC_MODE | \
192 + PMCR_FORCE_MODE | PMCR_TX_EN | PMCR_RX_EN | \
193 + PMCR_BACK_PRES_EN | PMCR_BACKOFF_EN | \
194 + PMCR_FORCE_SPEED_1000 | PMCR_FORCE_FDX | \
197 +#define PMCR_FIXED_LINK_FC (PMCR_FIXED_LINK | \
198 + PMCR_TX_FC_EN | PMCR_RX_FC_EN)
200 +/* TRGMII control registers */
201 +#define GSW_INTF_MODE 0x390
202 +#define GSW_TRGMII_TD0_ODT 0x354
203 +#define GSW_TRGMII_TD1_ODT 0x35c
204 +#define GSW_TRGMII_TD2_ODT 0x364
205 +#define GSW_TRGMII_TD3_ODT 0x36c
206 +#define GSW_TRGMII_TXCTL_ODT 0x374
207 +#define GSW_TRGMII_TCK_ODT 0x37c
208 +#define GSW_TRGMII_RCK_CTRL 0x300
210 +#define INTF_MODE_TRGMII BIT(1)
211 +#define TRGMII_RCK_CTRL_RX_RST BIT(31)
214 +/* possible XTAL speed */
215 +#define MT7623_XTAL_40 0
216 +#define MT7623_XTAL_20 1
217 +#define MT7623_XTAL_25 3
219 +/* GPIO port control registers */
220 +#define GPIO_OD33_CTRL8 0x4c0
221 +#define GPIO_BIAS_CTRL 0xed0
222 +#define GPIO_DRV_SEL10 0xf00
224 +/* on MT7620 the functio of port 4 can be software configured */
230 +/* struct mt7620_gsw - the structure that holds the SoC specific data
231 + * @dev: The Device struct
232 + * @base: The base address
233 + * @piac_offset: The PIAC base may change depending on SoC
234 + * @irq: The IRQ we are using
235 + * @port4: The port4 mode on MT7620
236 + * @autopoll: Is MDIO autopolling enabled
237 + * @ethsys: The ethsys register map
238 + * @pctl: The pin control register map
239 + * @clk_trgpll: The trgmii pll clock
242 + struct mtk_eth *eth;
243 + struct device *dev;
244 + void __iomem *base;
248 + unsigned long int autopoll;
250 + struct regmap *ethsys;
251 + struct regmap *pctl;
253 + struct clk *clk_trgpll;
259 +/* switch register I/O wrappers */
260 +void mtk_switch_w32(struct mt7620_gsw *gsw, u32 val, unsigned reg);
261 +u32 mtk_switch_r32(struct mt7620_gsw *gsw, unsigned reg);
263 +/* the callback used by the driver core to bringup the switch */
264 +int mtk_gsw_init(struct mtk_eth *eth);
266 +/* MDIO access wrappers */
267 +int mt7620_mdio_write(struct mii_bus *bus, int phy_addr, int phy_reg, u16 val);
268 +int mt7620_mdio_read(struct mii_bus *bus, int phy_addr, int phy_reg);
269 +void mt7620_mdio_link_adjust(struct mtk_eth *eth, int port);
270 +int mt7620_has_carrier(struct mtk_eth *eth);
271 +void mt7620_print_link_state(struct mtk_eth *eth, int port, int link,
272 + int speed, int duplex);
273 +void mt7530_mdio_w32(struct mt7620_gsw *gsw, u32 reg, u32 val);
274 +u32 mt7530_mdio_r32(struct mt7620_gsw *gsw, u32 reg);
275 +void mt7530_mdio_m32(struct mt7620_gsw *gsw, u32 mask, u32 set, u32 reg);
277 +u32 _mtk_mdio_write(struct mtk_eth *eth, u32 phy_addr,
278 + u32 phy_register, u32 write_data);
279 +u32 _mtk_mdio_read(struct mtk_eth *eth, int phy_addr, int phy_reg);
280 +void mt7620_handle_carrier(struct mtk_eth *eth);
284 +++ b/drivers/net/ethernet/mediatek/gsw_mt7623.c
286 +/* This program is free software; you can redistribute it and/or modify
287 + * it under the terms of the GNU General Public License as published by
288 + * the Free Software Foundation; version 2 of the License
290 + * This program is distributed in the hope that it will be useful,
291 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
292 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
293 + * GNU General Public License for more details.
295 + * Copyright (C) 2009-2016 John Crispin <blogic@openwrt.org>
296 + * Copyright (C) 2009-2016 Felix Fietkau <nbd@openwrt.org>
297 + * Copyright (C) 2013-2016 Michael Lee <igvtee@gmail.com>
300 +#include <linux/module.h>
301 +#include <linux/kernel.h>
302 +#include <linux/types.h>
303 +#include <linux/platform_device.h>
304 +#include <linux/of_device.h>
305 +#include <linux/of_irq.h>
306 +#include <linux/of_gpio.h>
307 +#include <linux/of_mdio.h>
308 +#include <linux/clk.h>
309 +#include <linux/mfd/syscon.h>
310 +#include <linux/regulator/consumer.h>
311 +#include <linux/pm_runtime.h>
312 +#include <linux/regmap.h>
313 +#include <linux/reset.h>
314 +#include <linux/mii.h>
315 +#include <linux/interrupt.h>
316 +#include <linux/netdevice.h>
317 +#include <linux/dma-mapping.h>
318 +#include <linux/phy.h>
319 +#include <linux/ethtool.h>
320 +#include <linux/version.h>
321 +#include <linux/atomic.h>
323 +#include "mtk_eth_soc.h"
324 +#include "gsw_mt7620.h"
327 +#define ETHSYS_CLKCFG0 0x2c
328 +#define ETHSYS_TRGMII_CLK_SEL362_5 BIT(11)
330 +void mt7530_mdio_w32(struct mt7620_gsw *gsw, u32 reg, u32 val)
332 + _mtk_mdio_write(gsw->eth, 0x1f, 0x1f, (reg >> 6) & 0x3ff);
333 + _mtk_mdio_write(gsw->eth, 0x1f, (reg >> 2) & 0xf, val & 0xffff);
334 + _mtk_mdio_write(gsw->eth, 0x1f, 0x10, val >> 16);
337 +u32 mt7530_mdio_r32(struct mt7620_gsw *gsw, u32 reg)
341 + _mtk_mdio_write(gsw->eth, 0x1f, 0x1f, (reg >> 6) & 0x3ff);
342 + low = _mtk_mdio_read(gsw->eth, 0x1f, (reg >> 2) & 0xf);
343 + high = _mtk_mdio_read(gsw->eth, 0x1f, 0x10);
345 + return (high << 16) | (low & 0xffff);
348 +void mt7530_mdio_m32(struct mt7620_gsw *gsw, u32 mask, u32 set, u32 reg)
350 + u32 val = mt7530_mdio_r32(gsw, reg);
354 + mt7530_mdio_w32(gsw, reg, val);
357 +void mtk_switch_w32(struct mt7620_gsw *gsw, u32 val, unsigned reg)
359 + mtk_w32(gsw->eth, val, reg + 0x10000);
362 +u32 mtk_switch_r32(struct mt7620_gsw *gsw, unsigned reg)
364 + return mtk_r32(gsw->eth, reg + 0x10000);
367 +void mtk_switch_m32(struct mt7620_gsw *gsw, u32 mask, u32 set, unsigned reg)
369 + u32 val = mtk_switch_r32(gsw, reg);
374 + mtk_switch_w32(gsw, val, reg);
377 +int mt7623_gsw_config(struct mtk_eth *eth)
379 + if (eth->mii_bus && eth->mii_bus->phy_map[0x1f])
380 + mt7530_probe(eth->dev, NULL, eth->mii_bus, 1);
385 +static irqreturn_t gsw_interrupt_mt7623(int irq, void *_eth)
387 + struct mtk_eth *eth = (struct mtk_eth *)_eth;
388 + struct mt7620_gsw *gsw = (struct mt7620_gsw *)eth->sw_priv;
391 + reg = mt7530_mdio_r32(gsw, 0x700c);
393 + for (i = 0; i < 5; i++)
394 + if (reg & BIT(i)) {
397 + link = mt7530_mdio_r32(gsw,
398 + 0x3008 + (i * 0x100)) & 0x1;
402 + "port %d link up\n", i);
405 + "port %d link down\n", i);
408 +// mt7620_handle_carrier(eth);
409 + mt7530_mdio_w32(gsw, 0x700c, 0x1f);
411 + return IRQ_HANDLED;
414 +static void wait_loop(struct mt7620_gsw *gsw)
419 + for (i = 0; i < 320; i = i + 1)
420 + read_data = mtk_switch_r32(gsw, 0x610);
423 +static void trgmii_calibration_7623(struct mt7620_gsw *gsw)
426 + unsigned int tap_a[5] = { 0, 0, 0, 0, 0 }; /* minumum delay for all correct */
427 + unsigned int tap_b[5] = { 0, 0, 0, 0, 0 }; /* maximum delay for all correct */
428 + unsigned int final_tap[5];
429 + unsigned int rxc_step_size;
430 + unsigned int rxd_step_size;
431 + unsigned int read_data;
433 + unsigned int rd_wd;
435 + unsigned int err_cnt[5];
436 + unsigned int init_toggle_data;
437 + unsigned int err_flag[5];
438 + unsigned int err_total_flag;
439 + unsigned int training_word;
440 + unsigned int rd_tap;
443 + u32 TRGMII_7623_base;
444 + u32 TRGMII_7623_RD_0;
445 + u32 TRGMII_RCK_CTRL;
447 + TRGMII_7623_base = 0x300; /* 0xFB110300 */
448 + TRGMII_7623_RD_0 = TRGMII_7623_base + 0x10;
449 + TRGMII_RCK_CTRL = TRGMII_7623_base;
450 + rxd_step_size = 0x1;
451 + rxc_step_size = 0x4;
452 + init_toggle_data = 0x00000055;
453 + training_word = 0x000000AC;
455 + /* RX clock gating in MT7623 */
456 + mtk_switch_m32(gsw, 0x3fffffff, 0, TRGMII_7623_base + 0x04);
458 + /* Assert RX reset in MT7623 */
459 + mtk_switch_m32(gsw, 0, 0x80000000, TRGMII_7623_base + 0x00);
461 + /* Set TX OE edge in MT7623 */
462 + mtk_switch_m32(gsw, 0, 0x00002000, TRGMII_7623_base + 0x78);
464 + /* Disable RX clock gating in MT7623 */
465 + mtk_switch_m32(gsw, 0, 0xC0000000, TRGMII_7623_base + 0x04);
467 + /* Release RX reset in MT7623 */
468 + mtk_switch_m32(gsw, 0x7fffffff, 0, TRGMII_7623_base);
470 + for (i = 0; i < 5; i++)
471 + mtk_switch_m32(gsw, 0, 0x80000000, TRGMII_7623_RD_0 + i * 8);
473 + pr_err("Enable Training Mode in MT7530\n");
474 + read_data = mt7530_mdio_r32(gsw, 0x7A40);
475 + read_data |= 0xC0000000;
476 + mt7530_mdio_w32(gsw, 0x7A40, read_data); /* Enable Training Mode in MT7530 */
477 + err_total_flag = 0;
478 + pr_err("Adjust RXC delay in MT7623\n");
480 + while (err_total_flag == 0 && read_data != 0x68) {
481 + pr_err("2nd Enable EDGE CHK in MT7623\n");
482 + /* Enable EDGE CHK in MT7623 */
483 + for (i = 0; i < 5; i++)
484 + mtk_switch_m32(gsw, 0x4fffffff, 0x40000000, TRGMII_7623_RD_0 + i * 8);
487 + err_total_flag = 1;
488 + for (i = 0; i < 5; i++) {
490 + mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8) >> 8;
491 + err_cnt[i] &= 0x0000000f;
492 + rd_wd = mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8) >> 16;
493 + rd_wd &= 0x000000ff;
494 + val = mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8);
495 + pr_err("ERR_CNT = %d, RD_WD =%x, TRGMII_7623_RD_0=%x\n",
496 + err_cnt[i], rd_wd, val);
497 + if (err_cnt[i] != 0) {
499 + } else if (rd_wd != 0x55) {
504 + err_total_flag = err_flag[i] & err_total_flag;
507 + pr_err("2nd Disable EDGE CHK in MT7623\n");
508 + /* Disable EDGE CHK in MT7623 */
509 + for (i = 0; i < 5; i++)
510 + mtk_switch_m32(gsw, 0x4fffffff, 0x40000000, TRGMII_7623_RD_0 + i * 8);
512 + pr_err("2nd Disable EDGE CHK in MT7623\n");
513 + /* Adjust RXC delay */
514 + /* RX clock gating in MT7623 */
515 + mtk_switch_m32(gsw, 0x3fffffff, 0, TRGMII_7623_base + 0x04);
516 + read_data = mtk_switch_r32(gsw, TRGMII_7623_base);
517 + if (err_total_flag == 0) {
518 + tmp = (read_data & 0x0000007f) + rxc_step_size;
519 + pr_err(" RXC delay = %d\n", tmp);
521 + read_data &= 0xffffff80;
524 + read_data &= 0xffffff80;
526 + mtk_switch_w32(gsw, read_data, TRGMII_7623_base);
528 + tmp = (read_data & 0x0000007f) + 16;
529 + pr_err(" RXC delay = %d\n", tmp);
531 + read_data &= 0xffffff80;
534 + read_data &= 0xffffff80;
536 + mtk_switch_w32(gsw, read_data, TRGMII_7623_base);
538 + read_data &= 0x000000ff;
540 + /* Disable RX clock gating in MT7623 */
541 + mtk_switch_m32(gsw, 0, 0xC0000000, TRGMII_7623_base + 0x04);
542 + for (i = 0; i < 5; i++)
543 + mtk_switch_m32(gsw, 0, 0x80000000, TRGMII_7623_RD_0 + i * 8);
546 + /* Read RD_WD MT7623 */
547 + for (i = 0; i < 5; i++) {
549 + while (err_flag[i] != 0 && rd_tap != 128) {
550 + /* Enable EDGE CHK in MT7623 */
551 + mtk_switch_m32(gsw, 0x4fffffff, 0x40000000, TRGMII_7623_RD_0 + i * 8);
554 + read_data = mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8);
555 + err_cnt[i] = (read_data >> 8) & 0x0000000f; /* Read MT7623 Errcnt */
556 + rd_wd = (read_data >> 16) & 0x000000ff;
557 + if (err_cnt[i] != 0 || rd_wd != 0x55) {
562 + /* Disable EDGE CHK in MT7623 */
563 + mtk_switch_m32(gsw, 0x4fffffff, 0x40000000, TRGMII_7623_RD_0 + i * 8);
565 + if (err_flag[i] != 0) {
566 + rd_tap = (read_data & 0x0000007f) + rxd_step_size; /* Add RXD delay in MT7623 */
567 + read_data = (read_data & 0xffffff80) | rd_tap;
568 + mtk_switch_w32(gsw, read_data,
569 + TRGMII_7623_RD_0 + i * 8);
572 + rd_tap = (read_data & 0x0000007f) + 48;
573 + read_data = (read_data & 0xffffff80) | rd_tap;
574 + mtk_switch_w32(gsw, read_data,
575 + TRGMII_7623_RD_0 + i * 8);
579 + pr_err("MT7623 %dth bit Tap_a = %d\n", i, tap_a[i]);
581 + /* pr_err("Last While Loop\n"); */
582 + for (i = 0; i < 5; i++) {
583 + while ((err_flag[i] == 0) && (rd_tap != 128)) {
584 + read_data = mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8);
585 + rd_tap = (read_data & 0x0000007f) + rxd_step_size; /* Add RXD delay in MT7623 */
586 + read_data = (read_data & 0xffffff80) | rd_tap;
587 + mtk_switch_w32(gsw, read_data, TRGMII_7623_RD_0 + i * 8);
588 + /* Enable EDGE CHK in MT7623 */
590 + mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8) | 0x40000000;
592 + mtk_switch_w32(gsw, val, TRGMII_7623_RD_0 + i * 8);
594 + read_data = mtk_switch_r32(gsw, TRGMII_7623_RD_0 + i * 8);
595 + err_cnt[i] = (read_data >> 8) & 0x0000000f; /* Read MT7623 Errcnt */
596 + rd_wd = (read_data >> 16) & 0x000000ff;
597 + if (err_cnt[i] != 0 || rd_wd != 0x55) {
603 + /* Disable EDGE CHK in MT7623 */
604 + mtk_switch_m32(gsw, 0x4fffffff, 0x40000000, TRGMII_7623_RD_0 + i * 8);
609 + tap_b[i] = rd_tap; /* -rxd_step_size; */
610 + pr_err("MT7623 %dth bit Tap_b = %d\n", i, tap_b[i]);
611 + final_tap[i] = (tap_a[i] + tap_b[i]) / 2; /* Calculate RXD delay = (TAP_A + TAP_B)/2 */
612 + read_data = (read_data & 0xffffff80) | final_tap[i];
613 + mtk_switch_w32(gsw, read_data, TRGMII_7623_RD_0 + i * 8);
616 + read_data = mt7530_mdio_r32(gsw, 0x7A40);
617 + read_data &= 0x3fffffff;
618 + mt7530_mdio_w32(gsw, 0x7A40, read_data);
621 +static void trgmii_calibration_7530(struct mt7620_gsw *gsw)
624 + unsigned int tap_a[5] = { 0, 0, 0, 0, 0 };
625 + unsigned int tap_b[5] = { 0, 0, 0, 0, 0 };
626 + unsigned int final_tap[5];
627 + unsigned int rxc_step_size;
628 + unsigned int rxd_step_size;
629 + unsigned int read_data;
630 + unsigned int tmp = 0;
632 + unsigned int err_cnt[5];
633 + unsigned int rd_wd;
634 + unsigned int init_toggle_data;
635 + unsigned int err_flag[5];
636 + unsigned int err_total_flag;
637 + unsigned int training_word;
638 + unsigned int rd_tap;
640 + u32 TRGMII_7623_base;
641 + u32 TRGMII_7530_RD_0;
642 + u32 TRGMII_RCK_CTRL;
643 + u32 TRGMII_7530_base;
644 + u32 TRGMII_7530_TX_base;
647 + TRGMII_7623_base = 0x300;
648 + TRGMII_7530_base = 0x7A00;
649 + TRGMII_7530_RD_0 = TRGMII_7530_base + 0x10;
650 + TRGMII_RCK_CTRL = TRGMII_7623_base;
651 + rxd_step_size = 0x1;
652 + rxc_step_size = 0x8;
653 + init_toggle_data = 0x00000055;
654 + training_word = 0x000000AC;
656 + TRGMII_7530_TX_base = TRGMII_7530_base + 0x50;
658 + /* pr_err("Calibration begin ........\n"); */
659 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x40) | 0x80000000;
660 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x40);
661 + read_data = mt7530_mdio_r32(gsw, 0x7a10);
662 + /* pr_err("TRGMII_7530_RD_0 is %x\n", read_data); */
664 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base + 0x04);
665 + read_data &= 0x3fffffff;
666 + mt7530_mdio_w32(gsw, TRGMII_7530_base + 0x04, read_data); /* RX clock gating in MT7530 */
668 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base + 0x78);
669 + read_data |= 0x00002000;
670 + mt7530_mdio_w32(gsw, TRGMII_7530_base + 0x78, read_data); /* Set TX OE edge in MT7530 */
672 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base);
673 + read_data |= 0x80000000;
674 + mt7530_mdio_w32(gsw, TRGMII_7530_base, read_data); /* Assert RX reset in MT7530 */
676 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base);
677 + read_data &= 0x7fffffff;
678 + mt7530_mdio_w32(gsw, TRGMII_7530_base, read_data); /* Release RX reset in MT7530 */
680 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base + 0x04);
681 + read_data |= 0xC0000000;
682 + mt7530_mdio_w32(gsw, TRGMII_7530_base + 0x04, read_data); /* Disable RX clock gating in MT7530 */
684 + /* pr_err("Enable Training Mode in MT7623\n"); */
685 + /*Enable Training Mode in MT7623 */
686 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x40) | 0x80000000;
687 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x40);
688 + if (gsw->trgmii_force == 2000) {
689 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x40) | 0xC0000000;
690 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x40);
692 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x40) | 0x80000000;
693 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x40);
695 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x078) & 0xfffff0ff;
696 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x078);
697 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x50) & 0xfffff0ff;
698 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x50);
699 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x58) & 0xfffff0ff;
700 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x58);
701 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x60) & 0xfffff0ff;
702 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x60);
703 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x68) & 0xfffff0ff;
704 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x68);
705 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x70) & 0xfffff0ff;
706 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x70);
707 + val = mtk_switch_r32(gsw, TRGMII_7623_base + 0x78) & 0x00000800;
708 + mtk_switch_w32(gsw, val, TRGMII_7623_base + 0x78);
709 + err_total_flag = 0;
710 + /* pr_err("Adjust RXC delay in MT7530\n"); */
712 + while (err_total_flag == 0 && (read_data != 0x68)) {
713 + /* pr_err("2nd Enable EDGE CHK in MT7530\n"); */
714 + /* Enable EDGE CHK in MT7530 */
715 + for (i = 0; i < 5; i++) {
717 + mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
718 + read_data |= 0x40000000;
719 + read_data &= 0x4fffffff;
720 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
723 + /* pr_err("2nd Disable EDGE CHK in MT7530\n"); */
725 + mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
726 + /* pr_err("***** MT7530 %dth bit ERR_CNT =%x\n",i, err_cnt[i]); */
727 + /* pr_err("MT7530 %dth bit ERR_CNT =%x\n",i, err_cnt[i]); */
729 + err_cnt[i] &= 0x0000ff0f;
730 + rd_wd = err_cnt[i] >> 8;
731 + rd_wd &= 0x000000ff;
732 + err_cnt[i] &= 0x0000000f;
733 + /* read_data = mt7530_mdio_r32(gsw,0x7a10,&read_data); */
734 + if (err_cnt[i] != 0) {
736 + } else if (rd_wd != 0x55) {
742 + err_total_flag = err_flag[i];
744 + err_total_flag = err_flag[i] & err_total_flag;
746 + /* Disable EDGE CHK in MT7530 */
748 + mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
749 + read_data |= 0x40000000;
750 + read_data &= 0x4fffffff;
751 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
755 + /*Adjust RXC delay */
756 + if (err_total_flag == 0) {
757 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base);
758 + read_data |= 0x80000000;
759 + mt7530_mdio_w32(gsw, TRGMII_7530_base, read_data); /* Assert RX reset in MT7530 */
762 + mt7530_mdio_r32(gsw, TRGMII_7530_base + 0x04);
763 + read_data &= 0x3fffffff;
764 + mt7530_mdio_w32(gsw, TRGMII_7530_base + 0x04, read_data); /* RX clock gating in MT7530 */
766 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base);
769 + tmp += rxc_step_size;
770 + /* pr_err("Current rxc delay = %d\n", tmp); */
771 + read_data &= 0xffffff80;
773 + mt7530_mdio_w32(gsw, TRGMII_7530_base, read_data);
774 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base);
775 + /* pr_err("Current RXC delay = %x\n", read_data); */
777 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_base);
778 + read_data &= 0x7fffffff;
779 + mt7530_mdio_w32(gsw, TRGMII_7530_base, read_data); /* Release RX reset in MT7530 */
782 + mt7530_mdio_r32(gsw, TRGMII_7530_base + 0x04);
783 + read_data |= 0xc0000000;
784 + mt7530_mdio_w32(gsw, TRGMII_7530_base + 0x04, read_data); /* Disable RX clock gating in MT7530 */
785 + pr_err("####### MT7530 RXC delay is %d\n", tmp);
789 + pr_err("Finish RXC Adjustment while loop\n");
791 + /* pr_err("Read RD_WD MT7530\n"); */
792 + /* Read RD_WD MT7530 */
793 + for (i = 0; i < 5; i++) {
795 + while (err_flag[i] != 0 && rd_tap != 128) {
796 + /* Enable EDGE CHK in MT7530 */
798 + mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
799 + read_data |= 0x40000000;
800 + read_data &= 0x4fffffff;
801 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
804 + err_cnt[i] = (read_data >> 8) & 0x0000000f;
805 + rd_wd = (read_data >> 16) & 0x000000ff;
806 + if (err_cnt[i] != 0 || rd_wd != 0x55) {
811 + if (err_flag[i] != 0) {
812 + rd_tap = (read_data & 0x0000007f) + rxd_step_size; /* Add RXD delay in MT7530 */
813 + read_data = (read_data & 0xffffff80) | rd_tap;
814 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
818 + tap_a[i] = (read_data & 0x0000007f); /* Record the min delay TAP_A */
819 + rd_tap = tap_a[i] + 0x4;
820 + read_data = (read_data & 0xffffff80) | rd_tap;
821 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
825 + /* Disable EDGE CHK in MT7530 */
827 + mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
828 + read_data |= 0x40000000;
829 + read_data &= 0x4fffffff;
830 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
835 + pr_err("MT7530 %dth bit Tap_a = %d\n", i, tap_a[i]);
838 + /* pr_err("Last While Loop\n"); */
839 + for (i = 0; i < 5; i++) {
841 + while (err_flag[i] == 0 && (rd_tap != 128)) {
842 + /* Enable EDGE CHK in MT7530 */
843 + read_data = mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
844 + read_data |= 0x40000000;
845 + read_data &= 0x4fffffff;
846 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
849 + err_cnt[i] = (read_data >> 8) & 0x0000000f;
850 + rd_wd = (read_data >> 16) & 0x000000ff;
851 + if (err_cnt[i] != 0 || rd_wd != 0x55)
856 + if (err_flag[i] == 0 && (rd_tap != 128)) {
857 + /* Add RXD delay in MT7530 */
858 + rd_tap = (read_data & 0x0000007f) + rxd_step_size;
859 + read_data = (read_data & 0xffffff80) | rd_tap;
860 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
863 + /* Disable EDGE CHK in MT7530 */
865 + mt7530_mdio_r32(gsw, TRGMII_7530_RD_0 + i * 8);
866 + read_data |= 0x40000000;
867 + read_data &= 0x4fffffff;
868 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8,
872 + tap_b[i] = rd_tap; /* - rxd_step_size; */
873 + pr_err("MT7530 %dth bit Tap_b = %d\n", i, tap_b[i]);
874 + /* Calculate RXD delay = (TAP_A + TAP_B)/2 */
875 + final_tap[i] = (tap_a[i] + tap_b[i]) / 2;
876 + /* pr_err("########****** MT7530 %dth bit Final Tap = %d\n", i, final_tap[i]); */
878 + read_data = (read_data & 0xffffff80) | final_tap[i];
879 + mt7530_mdio_w32(gsw, TRGMII_7530_RD_0 + i * 8, read_data);
882 + if (gsw->trgmii_force == 2000)
883 + mtk_switch_m32(gsw, 0x7fffffff, 0, TRGMII_7623_base + 0x40);
885 + mtk_switch_m32(gsw, 0x3fffffff, 0, TRGMII_7623_base + 0x40);
889 +static void mt7530_trgmii_clock_setting(struct mt7620_gsw *gsw, u32 xtal_mode)
895 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
896 + _mtk_mdio_write(gsw->eth, 0, 14, 0x410);
897 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
898 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1);
899 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
900 + _mtk_mdio_write(gsw->eth, 0, 14, 0x404);
901 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
903 + if (xtal_mode == 1) {
905 + if (gsw->trgmii_force == 2600)
907 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1a00);
908 + else if (gsw->trgmii_force == 2000)
910 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1400);
911 + } else if (xtal_mode == 2) {
913 + if (gsw->trgmii_force == 2600)
915 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1040);
916 + else if (gsw->trgmii_force == 2000)
918 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0c80);
920 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
921 + _mtk_mdio_write(gsw->eth, 0, 14, 0x405);
922 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
923 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0);
924 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
925 + _mtk_mdio_write(gsw->eth, 0, 14, 0x409);
926 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
927 + if (xtal_mode == 1)
929 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0057);
932 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0087);
933 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
934 + _mtk_mdio_write(gsw->eth, 0, 14, 0x40a);
935 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
936 + if (xtal_mode == 1)
938 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0057);
941 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0087);
943 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
944 + _mtk_mdio_write(gsw->eth, 0, 14, 0x403);
945 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
946 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1800);
948 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
949 + _mtk_mdio_write(gsw->eth, 0, 14, 0x403);
950 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
951 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1c00);
953 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
954 + _mtk_mdio_write(gsw->eth, 0, 14, 0x401);
955 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
956 + _mtk_mdio_write(gsw->eth, 0, 14, 0xc020);
958 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
959 + _mtk_mdio_write(gsw->eth, 0, 14, 0x406);
960 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
961 + _mtk_mdio_write(gsw->eth, 0, 14, 0xa030);
963 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
964 + _mtk_mdio_write(gsw->eth, 0, 14, 0x406);
965 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
966 + _mtk_mdio_write(gsw->eth, 0, 14, 0xa038);
968 +// udelay(120); /* for MT7623 bring up test */
970 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
971 + _mtk_mdio_write(gsw->eth, 0, 14, 0x410);
972 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
973 + _mtk_mdio_write(gsw->eth, 0, 14, 0x3);
975 + regValue = mt7530_mdio_r32(gsw, 0x7830);
976 + regValue &= 0xFFFFFFFC;
977 + regValue |= 0x00000001;
978 + mt7530_mdio_w32(gsw, 0x7830, regValue);
980 + regValue = mt7530_mdio_r32(gsw, 0x7a40);
981 + regValue &= ~(0x1 << 30);
982 + regValue &= ~(0x1 << 28);
983 + mt7530_mdio_w32(gsw, 0x7a40, regValue);
985 + mt7530_mdio_w32(gsw, 0x7a78, 0x55);
986 +// udelay(100); /* for mt7623 bring up test */
988 + mtk_switch_m32(gsw, 0x7fffffff, 0, 0x300);
990 + trgmii_calibration_7623(gsw);
991 + trgmii_calibration_7530(gsw);
993 + mtk_switch_m32(gsw, 0, 0x80000000, 0x300);
994 + mtk_switch_m32(gsw, 0, 0x7fffffff, 0x300);
996 + /*MT7530 RXC reset */
997 + regValue = mt7530_mdio_r32(gsw, 0x7a00);
998 + regValue |= (0x1 << 31);
999 + mt7530_mdio_w32(gsw, 0x7a00, regValue);
1001 + regValue &= ~(0x1 << 31);
1002 + mt7530_mdio_w32(gsw, 0x7a00, regValue);
1006 +static void mt7623_hw_init(struct mtk_eth *eth, struct mt7620_gsw *gsw, struct device_node *np)
1012 + regmap_update_bits(gsw->ethsys, ETHSYS_CLKCFG0,
1013 + ETHSYS_TRGMII_CLK_SEL362_5,
1014 + ETHSYS_TRGMII_CLK_SEL362_5);
1016 + /* reset the TRGMII core */
1017 + mtk_switch_m32(gsw, 0, INTF_MODE_TRGMII, GSW_INTF_MODE);
1018 + /* Assert MT7623 RXC reset */
1019 + mtk_switch_m32(gsw, 0, TRGMII_RCK_CTRL_RX_RST, GSW_TRGMII_RCK_CTRL);
1021 + /* Hardware reset Switch */
1022 + device_reset(eth->dev);
1024 + /* Wait for Switch Reset Completed*/
1025 + for (i = 0; i < 100; i++) {
1027 + if (mt7530_mdio_r32(gsw, MT7530_HWTRAP))
1031 + /* turn off all PHYs */
1032 + for (i = 0; i <= 4; i++) {
1033 + val = _mtk_mdio_read(gsw->eth, i, 0x0);
1035 + _mtk_mdio_write(gsw->eth, i, 0x0, val);
1038 + /* reset the switch */
1039 + mt7530_mdio_w32(gsw, MT7530_SYS_CTRL,
1040 + SYS_CTRL_SW_RST | SYS_CTRL_REG_RST);
1043 + /* GE1, Force 1000M/FD, FC ON */
1044 + mt7530_mdio_w32(gsw, MT7530_PMCR_P(6), PMCR_FIXED_LINK_FC);
1046 + /* GE2, Force 1000M/FD, FC ON */
1047 + mt7530_mdio_w32(gsw, MT7530_PMCR_P(5), PMCR_FIXED_LINK_FC);
1049 + /* Enable Port 6, P5 as GMAC5, P5 disable */
1050 + val = mt7530_mdio_r32(gsw, MT7530_MHWTRAP);
1051 + if (gsw->eth->mac[0] &&
1052 + of_phy_is_fixed_link(gsw->eth->mac[0]->of_node))
1053 + /* Enable Port 6 */
1054 + val &= ~MHWTRAP_P6_DIS;
1056 + /* Disable Port 6 */
1057 + val |= MHWTRAP_P6_DIS;
1058 + if (gsw->eth->mac[1] &&
1059 + of_phy_is_fixed_link(gsw->eth->mac[1]->of_node)) {
1060 + /* Enable Port 5 */
1061 + val &= ~MHWTRAP_P5_DIS;
1062 + /* Port 5 as PHY */
1063 + val &= ~MHWTRAP_P5_MAC_SEL;
1065 + /* Disable Port 5 */
1066 + val |= MHWTRAP_P5_DIS;
1067 + /* Port 5 as GMAC */
1068 + val |= MHWTRAP_P5_MAC_SEL;
1070 + mt7530_mdio_w32(gsw, MT7530_PMCR_P(5), 0x8000);
1072 + /* gphy to port 0/4 */
1078 + /* Set MT7530 phy direct access mode**/
1079 + val &= ~MHWTRAP_PHY_ACCESS;
1080 + /* manual override of HW-Trap */
1081 + val |= MHWTRAP_MANUAL;
1082 + mt7530_mdio_w32(gsw, MT7530_MHWTRAP, val);
1083 + dev_info(gsw->dev, "Setting MHWTRAP to 0x%08x\n", val);
1085 + val = mt7530_mdio_r32(gsw, 0x7800);
1086 + val = (val >> 9) & 0x3;
1089 + /* 25Mhz Xtal - do nothing */
1090 + } else if (val == 0x2) {
1094 + /* disable MT7530 core clock */
1095 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
1096 + _mtk_mdio_write(gsw->eth, 0, 14, 0x410);
1097 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
1098 + _mtk_mdio_write(gsw->eth, 0, 14, 0x0);
1100 + /* disable MT7530 PLL */
1101 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
1102 + _mtk_mdio_write(gsw->eth, 0, 14, 0x40d);
1103 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
1104 + _mtk_mdio_write(gsw->eth, 0, 14, 0x2020);
1106 + /* for MT7530 core clock = 500Mhz */
1107 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
1108 + _mtk_mdio_write(gsw->eth, 0, 14, 0x40e);
1109 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
1110 + _mtk_mdio_write(gsw->eth, 0, 14, 0x119);
1112 + /* enable MT7530 PLL */
1113 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
1114 + _mtk_mdio_write(gsw->eth, 0, 14, 0x40d);
1115 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
1116 + _mtk_mdio_write(gsw->eth, 0, 14, 0x2820);
1120 + /* enable MT7530 core clock */
1121 + _mtk_mdio_write(gsw->eth, 0, 13, 0x1f);
1122 + _mtk_mdio_write(gsw->eth, 0, 14, 0x410);
1123 + _mtk_mdio_write(gsw->eth, 0, 13, 0x401f);
1126 + /* 20Mhz Xtal - TODO */
1130 + _mtk_mdio_write(gsw->eth, 0, 14, 0x1);
1132 + /* set MT7530 central align */
1133 + val = mt7530_mdio_r32(gsw, 0x7830);
1136 + mt7530_mdio_w32(gsw, 0x7830, val);
1138 + val = mt7530_mdio_r32(gsw, 0x7a40);
1140 + mt7530_mdio_w32(gsw, 0x7a40, val);
1142 + mt7530_mdio_w32(gsw, 0x7a78, 0x855);
1144 + /* delay setting for 10/1000M */
1145 + mt7530_mdio_w32(gsw, 0x7b00, 0x104);
1146 + mt7530_mdio_w32(gsw, 0x7b04, 0x10);
1148 + /* lower Tx Driving */
1149 + mt7530_mdio_w32(gsw, 0x7a54, 0x88);
1150 + mt7530_mdio_w32(gsw, 0x7a5c, 0x88);
1151 + mt7530_mdio_w32(gsw, 0x7a64, 0x88);
1152 + mt7530_mdio_w32(gsw, 0x7a6c, 0x88);
1153 + mt7530_mdio_w32(gsw, 0x7a74, 0x88);
1154 + mt7530_mdio_w32(gsw, 0x7a7c, 0x88);
1155 + mt7530_mdio_w32(gsw, 0x7810, 0x11);
1157 + /* Set MT7623/MT7683 TX Driving */
1158 + mtk_switch_w32(gsw, 0x88, 0x354);
1159 + mtk_switch_w32(gsw, 0x88, 0x35c);
1160 + mtk_switch_w32(gsw, 0x88, 0x364);
1161 + mtk_switch_w32(gsw, 0x88, 0x36c);
1162 + mtk_switch_w32(gsw, 0x88, 0x374);
1163 + mtk_switch_w32(gsw, 0x88, 0x37c);
1165 + /* Set GE2 driving and slew rate */
1166 + regmap_write(gsw->pctl, 0xF00, 0xe00);
1167 + /* set GE2 TDSEL */
1168 + regmap_write(gsw->pctl, 0x4C0, 0x5);
1169 + /* set GE2 TUNE */
1170 + regmap_write(gsw->pctl, 0xED0, 0x0);
1172 + regmap_write(gsw->pctl, 0xb70, 0);
1173 + regmap_write(gsw->pctl, 0x250, 0xffff);
1174 + regmap_write(gsw->pctl, 0x260, 0xff);
1175 + regmap_write(gsw->pctl, 0x380, 0x37);
1176 + regmap_write(gsw->pctl, 0x390, 0x40);
1178 + mt7530_trgmii_clock_setting(gsw, xtal_mode);
1180 + //LANWANPartition(gsw);
1183 + for (i = 0; i <= 4; i++) {
1184 + _mtk_mdio_write(gsw->eth, i, 13, 0x7);
1185 + _mtk_mdio_write(gsw->eth, i, 14, 0x3C);
1186 + _mtk_mdio_write(gsw->eth, i, 13, 0x4007);
1187 + _mtk_mdio_write(gsw->eth, i, 14, 0x0);
1189 + /* Increase SlvDPSready time */
1190 + _mtk_mdio_write(gsw->eth, i, 31, 0x52b5);
1191 + _mtk_mdio_write(gsw->eth, i, 16, 0xafae);
1192 + _mtk_mdio_write(gsw->eth, i, 18, 0x2f);
1193 + _mtk_mdio_write(gsw->eth, i, 16, 0x8fae);
1195 + /* Incease post_update_timer */
1196 + _mtk_mdio_write(gsw->eth, i, 31, 0x3);
1197 + _mtk_mdio_write(gsw->eth, i, 17, 0x4b);
1199 + /* Adjust 100_mse_threshold */
1200 + _mtk_mdio_write(gsw->eth, i, 13, 0x1e);
1201 + _mtk_mdio_write(gsw->eth, i, 14, 0x123);
1202 + _mtk_mdio_write(gsw->eth, i, 13, 0x401e);
1203 + _mtk_mdio_write(gsw->eth, i, 14, 0xffff);
1206 + _mtk_mdio_write(gsw->eth, i, 13, 0x1e);
1207 + _mtk_mdio_write(gsw->eth, i, 14, 0xa6);
1208 + _mtk_mdio_write(gsw->eth, i, 13, 0x401e);
1209 + _mtk_mdio_write(gsw->eth, i, 14, 0x300);
1211 + /* Disable HW auto downshift*/
1212 + _mtk_mdio_write(gsw->eth, i, 31, 0x1);
1213 + val = _mtk_mdio_read(gsw->eth, i, 0x14);
1215 + _mtk_mdio_write(gsw->eth, i, 0x14, val);
1218 + /* turn on all PHYs */
1219 + for (i = 0; i <= 4; i++) {
1220 + val = _mtk_mdio_read(gsw->eth, i, 0);
1222 + _mtk_mdio_write(gsw->eth, i, 0, val);
1226 + mt7530_mdio_m32(gsw, 0, TOP_SIG_CTRL_NORMAL, MT7530_TOP_SIG_CTRL);
1229 +static const struct of_device_id mediatek_gsw_match[] = {
1230 + { .compatible = "mediatek,mt7623-gsw" },
1233 +MODULE_DEVICE_TABLE(of, mediatek_gsw_match);
1235 +int mtk_gsw_init(struct mtk_eth *eth)
1237 + struct device_node *np = eth->switch_np;
1238 + struct platform_device *pdev = of_find_device_by_node(np);
1239 + struct mt7620_gsw *gsw;
1244 + if (!of_device_is_compatible(np, mediatek_gsw_match->compatible))
1247 + gsw = platform_get_drvdata(pdev);
1251 + eth->sw_priv = gsw;
1253 + mt7623_hw_init(eth, gsw, np);
1255 + if (request_threaded_irq(gsw->irq, gsw_interrupt_mt7623, NULL, 0,
1257 + pr_err("fail to request irq\n");
1258 + mt7530_mdio_w32(gsw, 0x7008, 0x1f);
1263 +static int mt7623_gsw_probe(struct platform_device *pdev)
1265 + struct device_node *np = pdev->dev.of_node;
1266 + struct device_node *pctl;
1267 + int reset_pin, ret;
1268 + struct mt7620_gsw *gsw;
1269 + struct regulator *supply;
1271 + gsw = devm_kzalloc(&pdev->dev, sizeof(struct mt7620_gsw), GFP_KERNEL);
1275 + gsw->dev = &pdev->dev;
1276 + gsw->trgmii_force = 2000;
1277 + gsw->irq = irq_of_parse_and_map(np, 0);
1281 + gsw->ethsys = syscon_regmap_lookup_by_phandle(np, "mediatek,ethsys");
1282 + if (IS_ERR(gsw->ethsys))
1283 + return PTR_ERR(gsw->ethsys);
1285 + reset_pin = of_get_named_gpio(np, "mediatek,reset-pin", 0);
1286 + if (reset_pin < 0)
1289 + pctl = of_parse_phandle(np, "mediatek,pctl-regmap", 0);
1291 + return PTR_ERR(pctl);
1293 + gsw->pctl = syscon_node_to_regmap(pctl);
1295 + return PTR_ERR(pctl);
1297 + ret = devm_gpio_request(&pdev->dev, reset_pin, "mt7530-reset");
1301 + gsw->clk_trgpll = devm_clk_get(&pdev->dev, "trgpll");
1303 + if (IS_ERR(gsw->clk_trgpll))
1306 + supply = devm_regulator_get(&pdev->dev, "mt7530");
1307 + if (IS_ERR(supply))
1308 + return PTR_ERR(supply);
1310 + regulator_set_voltage(supply, 1000000, 1000000);
1311 + ret = regulator_enable(supply);
1313 + dev_err(&pdev->dev, "Failed to enable reg-7530: %d\n", ret);
1317 + gsw->wllll = of_property_read_bool(np, "mediatek,wllll");
1319 + pm_runtime_enable(&pdev->dev);
1320 + pm_runtime_get_sync(&pdev->dev);
1322 + ret = clk_set_rate(gsw->clk_trgpll, 500000000);
1326 + regmap_write(gsw->ethsys, 0x34, 0x800000);
1327 + regmap_write(gsw->ethsys, 0x34, 0x0);
1329 + clk_prepare_enable(gsw->clk_trgpll);
1331 + gpio_direction_output(reset_pin, 0);
1333 + gpio_set_value(reset_pin, 1);
1336 + platform_set_drvdata(pdev, gsw);
1341 +static int mt7623_gsw_remove(struct platform_device *pdev)
1343 + struct mt7620_gsw *gsw = platform_get_drvdata(pdev);
1345 + clk_disable_unprepare(gsw->clk_trgpll);
1347 + pm_runtime_put_sync(&pdev->dev);
1348 + pm_runtime_disable(&pdev->dev);
1350 + platform_set_drvdata(pdev, NULL);
1355 +static struct platform_driver gsw_driver = {
1356 + .probe = mt7623_gsw_probe,
1357 + .remove = mt7623_gsw_remove,
1359 + .name = "mt7623-gsw",
1360 + .owner = THIS_MODULE,
1361 + .of_match_table = mediatek_gsw_match,
1365 +module_platform_driver(gsw_driver);
1367 +MODULE_LICENSE("GPL");
1368 +MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
1369 +MODULE_DESCRIPTION("GBit switch driver for Mediatek MT7623 SoC");
1371 +++ b/drivers/net/ethernet/mediatek/mt7530.c
1374 + * This program is free software; you can redistribute it and/or
1375 + * modify it under the terms of the GNU General Public License
1376 + * as published by the Free Software Foundation; either version 2
1377 + * of the License, or (at your option) any later version.
1379 + * This program is distributed in the hope that it will be useful,
1380 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1381 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1382 + * GNU General Public License for more details.
1384 + * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
1387 +#include <linux/if.h>
1388 +#include <linux/module.h>
1389 +#include <linux/init.h>
1390 +#include <linux/list.h>
1391 +#include <linux/if_ether.h>
1392 +#include <linux/skbuff.h>
1393 +#include <linux/netdevice.h>
1394 +#include <linux/netlink.h>
1395 +#include <linux/bitops.h>
1396 +#include <net/genetlink.h>
1397 +#include <linux/switch.h>
1398 +#include <linux/delay.h>
1399 +#include <linux/phy.h>
1400 +#include <linux/netdevice.h>
1401 +#include <linux/etherdevice.h>
1402 +#include <linux/lockdep.h>
1403 +#include <linux/workqueue.h>
1404 +#include <linux/of_device.h>
1406 +#include "mt7530.h"
1408 +#define MT7530_CPU_PORT 6
1409 +#define MT7530_NUM_PORTS 8
1410 +#define MT7530_NUM_VLANS 16
1411 +#define MT7530_MAX_VID 4095
1412 +#define MT7530_MIN_VID 0
1415 +#define REG_ESW_VLAN_VTCR 0x90
1416 +#define REG_ESW_VLAN_VAWD1 0x94
1417 +#define REG_ESW_VLAN_VAWD2 0x98
1418 +#define REG_ESW_VLAN_VTIM(x) (0x100 + 4 * ((x) / 2))
1420 +#define REG_ESW_VLAN_VAWD1_IVL_MAC BIT(30)
1421 +#define REG_ESW_VLAN_VAWD1_VTAG_EN BIT(28)
1422 +#define REG_ESW_VLAN_VAWD1_VALID BIT(0)
1424 +/* vlan egress mode */
1426 + ETAG_CTRL_UNTAG = 0,
1427 + ETAG_CTRL_TAG = 2,
1428 + ETAG_CTRL_SWAP = 1,
1429 + ETAG_CTRL_STACK = 3,
1432 +#define REG_ESW_PORT_PCR(x) (0x2004 | ((x) << 8))
1433 +#define REG_ESW_PORT_PVC(x) (0x2010 | ((x) << 8))
1434 +#define REG_ESW_PORT_PPBV1(x) (0x2014 | ((x) << 8))
1436 +#define REG_HWTRAP 0x7804
1438 +#define MIB_DESC(_s , _o, _n) \
1445 +struct mt7xxx_mib_desc {
1446 + unsigned int size;
1447 + unsigned int offset;
1451 +#define MT7621_MIB_COUNTER_BASE 0x4000
1452 +#define MT7621_MIB_COUNTER_PORT_OFFSET 0x100
1453 +#define MT7621_STATS_TDPC 0x00
1454 +#define MT7621_STATS_TCRC 0x04
1455 +#define MT7621_STATS_TUPC 0x08
1456 +#define MT7621_STATS_TMPC 0x0C
1457 +#define MT7621_STATS_TBPC 0x10
1458 +#define MT7621_STATS_TCEC 0x14
1459 +#define MT7621_STATS_TSCEC 0x18
1460 +#define MT7621_STATS_TMCEC 0x1C
1461 +#define MT7621_STATS_TDEC 0x20
1462 +#define MT7621_STATS_TLCEC 0x24
1463 +#define MT7621_STATS_TXCEC 0x28
1464 +#define MT7621_STATS_TPPC 0x2C
1465 +#define MT7621_STATS_TL64PC 0x30
1466 +#define MT7621_STATS_TL65PC 0x34
1467 +#define MT7621_STATS_TL128PC 0x38
1468 +#define MT7621_STATS_TL256PC 0x3C
1469 +#define MT7621_STATS_TL512PC 0x40
1470 +#define MT7621_STATS_TL1024PC 0x44
1471 +#define MT7621_STATS_TOC 0x48
1472 +#define MT7621_STATS_RDPC 0x60
1473 +#define MT7621_STATS_RFPC 0x64
1474 +#define MT7621_STATS_RUPC 0x68
1475 +#define MT7621_STATS_RMPC 0x6C
1476 +#define MT7621_STATS_RBPC 0x70
1477 +#define MT7621_STATS_RAEPC 0x74
1478 +#define MT7621_STATS_RCEPC 0x78
1479 +#define MT7621_STATS_RUSPC 0x7C
1480 +#define MT7621_STATS_RFEPC 0x80
1481 +#define MT7621_STATS_ROSPC 0x84
1482 +#define MT7621_STATS_RJEPC 0x88
1483 +#define MT7621_STATS_RPPC 0x8C
1484 +#define MT7621_STATS_RL64PC 0x90
1485 +#define MT7621_STATS_RL65PC 0x94
1486 +#define MT7621_STATS_RL128PC 0x98
1487 +#define MT7621_STATS_RL256PC 0x9C
1488 +#define MT7621_STATS_RL512PC 0xA0
1489 +#define MT7621_STATS_RL1024PC 0xA4
1490 +#define MT7621_STATS_ROC 0xA8
1491 +#define MT7621_STATS_RDPC_CTRL 0xB0
1492 +#define MT7621_STATS_RDPC_ING 0xB4
1493 +#define MT7621_STATS_RDPC_ARL 0xB8
1495 +static const struct mt7xxx_mib_desc mt7621_mibs[] = {
1496 + MIB_DESC(1, MT7621_STATS_TDPC, "TxDrop"),
1497 + MIB_DESC(1, MT7621_STATS_TCRC, "TxCRC"),
1498 + MIB_DESC(1, MT7621_STATS_TUPC, "TxUni"),
1499 + MIB_DESC(1, MT7621_STATS_TMPC, "TxMulti"),
1500 + MIB_DESC(1, MT7621_STATS_TBPC, "TxBroad"),
1501 + MIB_DESC(1, MT7621_STATS_TCEC, "TxCollision"),
1502 + MIB_DESC(1, MT7621_STATS_TSCEC, "TxSingleCol"),
1503 + MIB_DESC(1, MT7621_STATS_TMCEC, "TxMultiCol"),
1504 + MIB_DESC(1, MT7621_STATS_TDEC, "TxDefer"),
1505 + MIB_DESC(1, MT7621_STATS_TLCEC, "TxLateCol"),
1506 + MIB_DESC(1, MT7621_STATS_TXCEC, "TxExcCol"),
1507 + MIB_DESC(1, MT7621_STATS_TPPC, "TxPause"),
1508 + MIB_DESC(1, MT7621_STATS_TL64PC, "Tx64Byte"),
1509 + MIB_DESC(1, MT7621_STATS_TL65PC, "Tx65Byte"),
1510 + MIB_DESC(1, MT7621_STATS_TL128PC, "Tx128Byte"),
1511 + MIB_DESC(1, MT7621_STATS_TL256PC, "Tx256Byte"),
1512 + MIB_DESC(1, MT7621_STATS_TL512PC, "Tx512Byte"),
1513 + MIB_DESC(1, MT7621_STATS_TL1024PC, "Tx1024Byte"),
1514 + MIB_DESC(2, MT7621_STATS_TOC, "TxByte"),
1515 + MIB_DESC(1, MT7621_STATS_RDPC, "RxDrop"),
1516 + MIB_DESC(1, MT7621_STATS_RFPC, "RxFiltered"),
1517 + MIB_DESC(1, MT7621_STATS_RUPC, "RxUni"),
1518 + MIB_DESC(1, MT7621_STATS_RMPC, "RxMulti"),
1519 + MIB_DESC(1, MT7621_STATS_RBPC, "RxBroad"),
1520 + MIB_DESC(1, MT7621_STATS_RAEPC, "RxAlignErr"),
1521 + MIB_DESC(1, MT7621_STATS_RCEPC, "RxCRC"),
1522 + MIB_DESC(1, MT7621_STATS_RUSPC, "RxUnderSize"),
1523 + MIB_DESC(1, MT7621_STATS_RFEPC, "RxFragment"),
1524 + MIB_DESC(1, MT7621_STATS_ROSPC, "RxOverSize"),
1525 + MIB_DESC(1, MT7621_STATS_RJEPC, "RxJabber"),
1526 + MIB_DESC(1, MT7621_STATS_RPPC, "RxPause"),
1527 + MIB_DESC(1, MT7621_STATS_RL64PC, "Rx64Byte"),
1528 + MIB_DESC(1, MT7621_STATS_RL65PC, "Rx65Byte"),
1529 + MIB_DESC(1, MT7621_STATS_RL128PC, "Rx128Byte"),
1530 + MIB_DESC(1, MT7621_STATS_RL256PC, "Rx256Byte"),
1531 + MIB_DESC(1, MT7621_STATS_RL512PC, "Rx512Byte"),
1532 + MIB_DESC(1, MT7621_STATS_RL1024PC, "Rx1024Byte"),
1533 + MIB_DESC(2, MT7621_STATS_ROC, "RxByte"),
1534 + MIB_DESC(1, MT7621_STATS_RDPC_CTRL, "RxCtrlDrop"),
1535 + MIB_DESC(1, MT7621_STATS_RDPC_ING, "RxIngDrop"),
1536 + MIB_DESC(1, MT7621_STATS_RDPC_ARL, "RxARLDrop")
1540 + /* Global attributes. */
1541 + MT7530_ATTR_ENABLE_VLAN,
1544 +struct mt7530_port_entry {
1548 +struct mt7530_vlan_entry {
1554 +struct mt7530_priv {
1555 + void __iomem *base;
1556 + struct mii_bus *bus;
1557 + struct switch_dev swdev;
1559 + bool global_vlan_enable;
1560 + struct mt7530_vlan_entry vlan_entries[MT7530_NUM_VLANS];
1561 + struct mt7530_port_entry port_entries[MT7530_NUM_PORTS];
1564 +struct mt7530_mapping {
1566 + u16 pvids[MT7530_NUM_PORTS];
1567 + u8 members[MT7530_NUM_VLANS];
1568 + u8 etags[MT7530_NUM_VLANS];
1569 + u16 vids[MT7530_NUM_VLANS];
1570 +} mt7530_defaults[] = {
1573 + .pvids = { 1, 1, 1, 1, 2, 1, 1 },
1574 + .members = { 0, 0x6f, 0x50 },
1575 + .etags = { 0, 0x40, 0x40 },
1576 + .vids = { 0, 1, 2 },
1579 + .pvids = { 2, 1, 1, 1, 1, 1, 1 },
1580 + .members = { 0, 0x7e, 0x41 },
1581 + .etags = { 0, 0x40, 0x40 },
1582 + .vids = { 0, 1, 2 },
1586 +struct mt7530_mapping*
1587 +mt7530_find_mapping(struct device_node *np)
1592 + if (of_property_read_string(np, "mediatek,portmap", &map))
1595 + for (i = 0; i < ARRAY_SIZE(mt7530_defaults); i++)
1596 + if (!strcmp(map, mt7530_defaults[i].name))
1597 + return &mt7530_defaults[i];
1603 +mt7530_apply_mapping(struct mt7530_priv *mt7530, struct mt7530_mapping *map)
1607 + for (i = 0; i < MT7530_NUM_PORTS; i++)
1608 + mt7530->port_entries[i].pvid = map->pvids[i];
1610 + for (i = 0; i < MT7530_NUM_VLANS; i++) {
1611 + mt7530->vlan_entries[i].member = map->members[i];
1612 + mt7530->vlan_entries[i].etags = map->etags[i];
1613 + mt7530->vlan_entries[i].vid = map->vids[i];
1618 +mt7530_reset_switch(struct switch_dev *dev)
1620 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1623 + memset(eth->port_entries, 0, sizeof(eth->port_entries));
1624 + memset(eth->vlan_entries, 0, sizeof(eth->vlan_entries));
1626 + /* set default vid of each vlan to the same number of vlan, so the vid
1627 + * won't need be set explicitly.
1629 + for (i = 0; i < MT7530_NUM_VLANS; i++) {
1630 + eth->vlan_entries[i].vid = i;
1637 +mt7530_get_vlan_enable(struct switch_dev *dev,
1638 + const struct switch_attr *attr,
1639 + struct switch_val *val)
1641 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1643 + val->value.i = eth->global_vlan_enable;
1649 +mt7530_set_vlan_enable(struct switch_dev *dev,
1650 + const struct switch_attr *attr,
1651 + struct switch_val *val)
1653 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1655 + eth->global_vlan_enable = val->value.i != 0;
1661 +mt7530_r32(struct mt7530_priv *eth, u32 reg)
1667 + mdiobus_write(eth->bus, 0x1f, 0x1f, (reg >> 6) & 0x3ff);
1668 + low = mdiobus_read(eth->bus, 0x1f, (reg >> 2) & 0xf);
1669 + high = mdiobus_read(eth->bus, 0x1f, 0x10);
1671 + return (high << 16) | (low & 0xffff);
1674 + val = ioread32(eth->base + reg);
1675 + pr_debug("MT7530 MDIO Read [%04x]=%08x\n", reg, val);
1681 +mt7530_w32(struct mt7530_priv *eth, u32 reg, u32 val)
1684 + mdiobus_write(eth->bus, 0x1f, 0x1f, (reg >> 6) & 0x3ff);
1685 + mdiobus_write(eth->bus, 0x1f, (reg >> 2) & 0xf, val & 0xffff);
1686 + mdiobus_write(eth->bus, 0x1f, 0x10, val >> 16);
1690 + pr_debug("MT7530 MDIO Write[%04x]=%08x\n", reg, val);
1691 + iowrite32(val, eth->base + reg);
1695 +mt7530_vtcr(struct mt7530_priv *eth, u32 cmd, u32 val)
1699 + mt7530_w32(eth, REG_ESW_VLAN_VTCR, BIT(31) | (cmd << 12) | val);
1701 + for (i = 0; i < 20; i++) {
1702 + u32 val = mt7530_r32(eth, REG_ESW_VLAN_VTCR);
1704 + if ((val & BIT(31)) == 0)
1710 + printk("mt7530: vtcr timeout\n");
1714 +mt7530_get_port_pvid(struct switch_dev *dev, int port, int *val)
1716 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1718 + if (port >= MT7530_NUM_PORTS)
1721 + *val = mt7530_r32(eth, REG_ESW_PORT_PPBV1(port));
1728 +mt7530_set_port_pvid(struct switch_dev *dev, int port, int pvid)
1730 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1732 + if (port >= MT7530_NUM_PORTS)
1735 + if (pvid < MT7530_MIN_VID || pvid > MT7530_MAX_VID)
1738 + eth->port_entries[port].pvid = pvid;
1744 +mt7530_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1746 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1753 + if (val->port_vlan < 0 || val->port_vlan >= MT7530_NUM_VLANS)
1756 + mt7530_vtcr(eth, 0, val->port_vlan);
1758 + member = mt7530_r32(eth, REG_ESW_VLAN_VAWD1);
1762 + etags = mt7530_r32(eth, REG_ESW_VLAN_VAWD2);
1764 + for (i = 0; i < MT7530_NUM_PORTS; i++) {
1765 + struct switch_port *p;
1768 + if (!(member & BIT(i)))
1771 + p = &val->value.ports[val->len++];
1774 + etag = (etags >> (i * 2)) & 0x3;
1776 + if (etag == ETAG_CTRL_TAG)
1777 + p->flags |= BIT(SWITCH_PORT_FLAG_TAGGED);
1778 + else if (etag != ETAG_CTRL_UNTAG)
1779 + printk("vlan egress tag control neither untag nor tag.\n");
1786 +mt7530_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1788 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1793 + if (val->port_vlan < 0 || val->port_vlan >= MT7530_NUM_VLANS ||
1794 + val->len > MT7530_NUM_PORTS)
1797 + for (i = 0; i < val->len; i++) {
1798 + struct switch_port *p = &val->value.ports[i];
1800 + if (p->id >= MT7530_NUM_PORTS)
1803 + member |= BIT(p->id);
1805 + if (p->flags & BIT(SWITCH_PORT_FLAG_TAGGED))
1806 + etags |= BIT(p->id);
1808 + eth->vlan_entries[val->port_vlan].member = member;
1809 + eth->vlan_entries[val->port_vlan].etags = etags;
1815 +mt7530_set_vid(struct switch_dev *dev, const struct switch_attr *attr,
1816 + struct switch_val *val)
1818 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1822 + vlan = val->port_vlan;
1823 + vid = (u16)val->value.i;
1825 + if (vlan < 0 || vlan >= MT7530_NUM_VLANS)
1828 + if (vid < MT7530_MIN_VID || vid > MT7530_MAX_VID)
1831 + eth->vlan_entries[vlan].vid = vid;
1836 +mt7530_get_vid(struct switch_dev *dev, const struct switch_attr *attr,
1837 + struct switch_val *val)
1839 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1843 + vlan = val->port_vlan;
1845 + vid = mt7530_r32(eth, REG_ESW_VLAN_VTIM(vlan));
1850 + val->value.i = vid;
1855 +mt7530_apply_config(struct switch_dev *dev)
1857 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1862 + if (!eth->global_vlan_enable) {
1863 + for (i = 0; i < MT7530_NUM_PORTS; i++)
1864 + mt7530_w32(eth, REG_ESW_PORT_PCR(i), 0x00ff0000);
1866 + for (i = 0; i < MT7530_NUM_PORTS; i++)
1867 + mt7530_w32(eth, REG_ESW_PORT_PVC(i), 0x810000c0);
1872 + /* set all ports as security mode */
1873 + for (i = 0; i < MT7530_NUM_PORTS; i++)
1874 + mt7530_w32(eth, REG_ESW_PORT_PCR(i), 0x00ff0003);
1876 + /* check if a port is used in tag/untag vlan egress mode */
1880 + for (i = 0; i < MT7530_NUM_VLANS; i++) {
1881 + u8 member = eth->vlan_entries[i].member;
1882 + u8 etags = eth->vlan_entries[i].etags;
1887 + for (j = 0; j < MT7530_NUM_PORTS; j++) {
1888 + if (!(member & BIT(j)))
1891 + if (etags & BIT(j))
1892 + tag_ports |= 1u << j;
1894 + untag_ports |= 1u << j;
1898 + /* set all untag-only ports as transparent and the rest as user port */
1899 + for (i = 0; i < MT7530_NUM_PORTS; i++) {
1900 + u32 pvc_mode = 0x81000000;
1902 + if (untag_ports & BIT(i) && !(tag_ports & BIT(i)))
1903 + pvc_mode = 0x810000c0;
1905 + mt7530_w32(eth, REG_ESW_PORT_PVC(i), pvc_mode);
1908 + for (i = 0; i < MT7530_NUM_VLANS; i++) {
1909 + u16 vid = eth->vlan_entries[i].vid;
1910 + u8 member = eth->vlan_entries[i].member;
1911 + u8 etags = eth->vlan_entries[i].etags;
1915 + val = mt7530_r32(eth, REG_ESW_VLAN_VTIM(i));
1921 + val |= (vid << 12);
1923 + mt7530_w32(eth, REG_ESW_VLAN_VTIM(i), val);
1925 + /* vlan port membership */
1927 + mt7530_w32(eth, REG_ESW_VLAN_VAWD1, REG_ESW_VLAN_VAWD1_IVL_MAC |
1928 + REG_ESW_VLAN_VAWD1_VTAG_EN | (member << 16) |
1929 + REG_ESW_VLAN_VAWD1_VALID);
1931 + mt7530_w32(eth, REG_ESW_VLAN_VAWD1, 0);
1935 + for (j = 0; j < MT7530_NUM_PORTS; j++) {
1936 + if (etags & BIT(j))
1937 + val |= ETAG_CTRL_TAG << (j * 2);
1939 + val |= ETAG_CTRL_UNTAG << (j * 2);
1941 + mt7530_w32(eth, REG_ESW_VLAN_VAWD2, val);
1943 + /* write to vlan table */
1944 + mt7530_vtcr(eth, 1, i);
1947 + /* Port Default PVID */
1948 + for (i = 0; i < MT7530_NUM_PORTS; i++) {
1950 + val = mt7530_r32(eth, REG_ESW_PORT_PPBV1(i));
1952 + val |= eth->port_entries[i].pvid;
1953 + mt7530_w32(eth, REG_ESW_PORT_PPBV1(i), val);
1960 +mt7530_get_port_link(struct switch_dev *dev, int port,
1961 + struct switch_port_link *link)
1963 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
1966 + if (port < 0 || port >= MT7530_NUM_PORTS)
1969 + pmsr = mt7530_r32(eth, 0x3008 + (0x100 * port));
1971 + link->link = pmsr & 1;
1972 + link->duplex = (pmsr >> 1) & 1;
1973 + speed = (pmsr >> 2) & 3;
1977 + link->speed = SWITCH_PORT_SPEED_10;
1980 + link->speed = SWITCH_PORT_SPEED_100;
1983 + case 3: /* forced gige speed can be 2 or 3 */
1984 + link->speed = SWITCH_PORT_SPEED_1000;
1987 + link->speed = SWITCH_PORT_SPEED_UNKNOWN;
1994 +static const struct switch_attr mt7530_global[] = {
1996 + .type = SWITCH_TYPE_INT,
1997 + .name = "enable_vlan",
1998 + .description = "VLAN mode (1:enabled)",
2000 + .id = MT7530_ATTR_ENABLE_VLAN,
2001 + .get = mt7530_get_vlan_enable,
2002 + .set = mt7530_set_vlan_enable,
2006 +static u64 get_mib_counter(struct mt7530_priv *eth, int i, int port)
2008 + unsigned int port_base;
2011 + port_base = MT7621_MIB_COUNTER_BASE +
2012 + MT7621_MIB_COUNTER_PORT_OFFSET * port;
2014 + t = mt7530_r32(eth, port_base + mt7621_mibs[i].offset);
2015 + if (mt7621_mibs[i].size == 2) {
2018 + hi = mt7530_r32(eth, port_base + mt7621_mibs[i].offset + 4);
2025 +static int mt7621_sw_get_port_mib(struct switch_dev *dev,
2026 + const struct switch_attr *attr,
2027 + struct switch_val *val)
2029 + static char buf[4096];
2030 + struct mt7530_priv *eth = container_of(dev, struct mt7530_priv, swdev);
2033 + if (val->port_vlan >= MT7530_NUM_PORTS)
2036 + len += snprintf(buf + len, sizeof(buf) - len,
2037 + "Port %d MIB counters\n", val->port_vlan);
2039 + for (i = 0; i < sizeof(mt7621_mibs) / sizeof(*mt7621_mibs); ++i) {
2041 + len += snprintf(buf + len, sizeof(buf) - len,
2042 + "%-11s: ", mt7621_mibs[i].name);
2043 + counter = get_mib_counter(eth, i, val->port_vlan);
2044 + len += snprintf(buf + len, sizeof(buf) - len, "%llu\n",
2048 + val->value.s = buf;
2053 +static const struct switch_attr mt7621_port[] = {
2055 + .type = SWITCH_TYPE_STRING,
2057 + .description = "Get MIB counters for port",
2058 + .get = mt7621_sw_get_port_mib,
2063 +static const struct switch_attr mt7530_port[] = {
2066 +static const struct switch_attr mt7530_vlan[] = {
2068 + .type = SWITCH_TYPE_INT,
2070 + .description = "VLAN ID (0-4094)",
2071 + .set = mt7530_set_vid,
2072 + .get = mt7530_get_vid,
2077 +static const struct switch_dev_ops mt7621_ops = {
2079 + .attr = mt7530_global,
2080 + .n_attr = ARRAY_SIZE(mt7530_global),
2083 + .attr = mt7621_port,
2084 + .n_attr = ARRAY_SIZE(mt7621_port),
2087 + .attr = mt7530_vlan,
2088 + .n_attr = ARRAY_SIZE(mt7530_vlan),
2090 + .get_vlan_ports = mt7530_get_vlan_ports,
2091 + .set_vlan_ports = mt7530_set_vlan_ports,
2092 + .get_port_pvid = mt7530_get_port_pvid,
2093 + .set_port_pvid = mt7530_set_port_pvid,
2094 + .get_port_link = mt7530_get_port_link,
2095 + .apply_config = mt7530_apply_config,
2096 + .reset_switch = mt7530_reset_switch,
2099 +static const struct switch_dev_ops mt7530_ops = {
2101 + .attr = mt7530_global,
2102 + .n_attr = ARRAY_SIZE(mt7530_global),
2105 + .attr = mt7530_port,
2106 + .n_attr = ARRAY_SIZE(mt7530_port),
2109 + .attr = mt7530_vlan,
2110 + .n_attr = ARRAY_SIZE(mt7530_vlan),
2112 + .get_vlan_ports = mt7530_get_vlan_ports,
2113 + .set_vlan_ports = mt7530_set_vlan_ports,
2114 + .get_port_pvid = mt7530_get_port_pvid,
2115 + .set_port_pvid = mt7530_set_port_pvid,
2116 + .get_port_link = mt7530_get_port_link,
2117 + .apply_config = mt7530_apply_config,
2118 + .reset_switch = mt7530_reset_switch,
2122 +mt7530_probe(struct device *dev, void __iomem *base, struct mii_bus *bus, int vlan)
2124 + struct switch_dev *swdev;
2125 + struct mt7530_priv *mt7530;
2126 + struct mt7530_mapping *map;
2129 + mt7530 = devm_kzalloc(dev, sizeof(struct mt7530_priv), GFP_KERNEL);
2133 + mt7530->base = base;
2134 + mt7530->bus = bus;
2135 + mt7530->global_vlan_enable = vlan;
2137 + swdev = &mt7530->swdev;
2139 + swdev->alias = "mt7530";
2140 + swdev->name = "mt7530";
2141 + } else if (IS_ENABLED(CONFIG_MACH_MT7623)) {
2142 + swdev->alias = "mt7623";
2143 + swdev->name = "mt7623";
2144 + } else if (IS_ENABLED(CONFIG_SOC_MT7621)) {
2145 + swdev->alias = "mt7621";
2146 + swdev->name = "mt7621";
2148 + swdev->alias = "mt7620";
2149 + swdev->name = "mt7620";
2151 + swdev->cpu_port = MT7530_CPU_PORT;
2152 + swdev->ports = MT7530_NUM_PORTS;
2153 + swdev->vlans = MT7530_NUM_VLANS;
2154 + if (IS_ENABLED(CONFIG_SOC_MT7621) || IS_ENABLED(CONFIG_MACH_MT7623))
2155 + swdev->ops = &mt7621_ops;
2157 + swdev->ops = &mt7530_ops;
2159 + ret = register_switch(swdev, NULL);
2161 + dev_err(dev, "failed to register mt7530\n");
2165 + mt7530_reset_switch(swdev);
2167 + map = mt7530_find_mapping(dev->of_node);
2169 + mt7530_apply_mapping(mt7530, map);
2170 + mt7530_apply_config(swdev);
2173 + if (!(IS_ENABLED(CONFIG_SOC_MT7621) || IS_ENABLED(CONFIG_MACH_MT7623)) && bus && mt7530_r32(mt7530, REG_HWTRAP) != 0x1117edf) {
2174 + dev_info(dev, "fixing up MHWTRAP register - bootloader probably played with it\n");
2175 + mt7530_w32(mt7530, REG_HWTRAP, 0x1117edf);
2177 + dev_info(dev, "loaded %s driver\n", swdev->name);
2182 +++ b/drivers/net/ethernet/mediatek/mt7530.h
2185 + * This program is free software; you can redistribute it and/or
2186 + * modify it under the terms of the GNU General Public License
2187 + * as published by the Free Software Foundation; either version 2
2188 + * of the License, or (at your option) any later version.
2190 + * This program is distributed in the hope that it will be useful,
2191 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2192 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2193 + * GNU General Public License for more details.
2195 + * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
2198 +#ifndef _MT7530_H__
2199 +#define _MT7530_H__
2201 +int mt7530_probe(struct device *dev, void __iomem *base, struct mii_bus *bus, int vlan);
2204 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
2205 +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
2208 #include "mtk_eth_soc.h"
2210 +/* the callback used by the driver core to bringup the switch */
2211 +int mtk_gsw_init(struct mtk_eth *eth);
2213 static int mtk_msg_level = -1;
2214 module_param_named(msg_level, mtk_msg_level, int, 0);
2215 MODULE_PARM_DESC(msg_level, "Message level (-1=defaults,0=none,...,16=all)");
2216 @@ -69,7 +72,7 @@ static int mtk_mdio_busy_wait(struct mtk
2218 if (time_after(jiffies, t_start + PHY_IAC_TIMEOUT))
2220 - usleep_range(10, 20);
2221 +// usleep_range(10, 20);
2224 dev_err(eth->dev, "mdio: MDIO timeout\n");
2225 @@ -1421,15 +1424,6 @@ static int __init mtk_hw_init(struct mtk
2226 reset_control_deassert(eth->rstc);
2227 usleep_range(10, 20);
2229 - /* Set GE2 driving and slew rate */
2230 - regmap_write(eth->pctl, GPIO_DRV_SEL10, 0xa00);
2232 - /* set GE2 TDSEL */
2233 - regmap_write(eth->pctl, GPIO_OD33_CTRL8, 0x5);
2235 - /* set GE2 TUNE */
2236 - regmap_write(eth->pctl, GPIO_BIAS_CTRL, 0x0);
2238 /* GE1, Force 1000M/FD, FC ON */
2239 mtk_w32(eth, MAC_MCR_FIXED_LINK, MTK_MAC_MCR(0));
2241 @@ -1452,6 +1446,8 @@ static int __init mtk_hw_init(struct mtk
2245 + mtk_gsw_init(eth);
2247 /* disable delay and normal interrupt */
2248 mtk_w32(eth, 0, MTK_QDMA_DELAY_INT);
2249 mtk_irq_disable(eth, ~0);
2250 @@ -1479,6 +1475,8 @@ static int __init mtk_hw_init(struct mtk
2251 mtk_w32(eth, val, MTK_GDMA_FWD_CFG(i));
2254 + mt7623_gsw_config(eth);
2259 @@ -1734,7 +1732,7 @@ static int mtk_add_mac(struct mtk_eth *e
2261 struct mtk_mac *mac;
2262 const __be32 *_id = of_get_property(np, "reg", NULL);
2267 dev_err(eth->dev, "missing mac id\n");
2268 @@ -1768,8 +1766,8 @@ static int mtk_add_mac(struct mtk_eth *e
2270 if (!mac->hw_stats) {
2271 dev_err(eth->dev, "failed to allocate counter memory\n");
2274 + free_netdev(eth->netdev[id]);
2277 spin_lock_init(&mac->hw_stats->stats_lock);
2278 mac->hw_stats->reg_offset = id * MTK_STAT_OFFSET;
2279 @@ -1783,21 +1781,9 @@ static int mtk_add_mac(struct mtk_eth *e
2280 eth->netdev[id]->features |= MTK_HW_FEATURES;
2281 eth->netdev[id]->ethtool_ops = &mtk_ethtool_ops;
2283 - err = register_netdev(eth->netdev[id]);
2285 - dev_err(eth->dev, "error bringing up device\n");
2288 eth->netdev[id]->irq = eth->irq[0];
2289 - netif_info(eth, probe, eth->netdev[id],
2290 - "mediatek frame engine at 0x%08lx, irq %d\n",
2291 - eth->netdev[id]->base_addr, eth->irq[0]);
2296 - free_netdev(eth->netdev[id]);
2300 static int mtk_probe(struct platform_device *pdev)
2301 @@ -1865,14 +1851,13 @@ static int mtk_probe(struct platform_dev
2302 clk_prepare_enable(eth->clk_gp1);
2303 clk_prepare_enable(eth->clk_gp2);
2305 + eth->switch_np = of_parse_phandle(pdev->dev.of_node,
2306 + "mediatek,switch", 0);
2308 eth->dev = &pdev->dev;
2309 eth->msg_enable = netif_msg_init(mtk_msg_level, MTK_DEFAULT_MSG_ENABLE);
2310 INIT_WORK(ð->pending_work, mtk_pending_work);
2312 - err = mtk_hw_init(eth);
2316 for_each_child_of_node(pdev->dev.of_node, mac_np) {
2317 if (!of_device_is_compatible(mac_np,
2318 "mediatek,eth-mac"))
2319 @@ -1886,6 +1871,22 @@ static int mtk_probe(struct platform_dev
2323 + err = mtk_hw_init(eth);
2327 + for (i = 0; i < MTK_MAX_DEVS; i++) {
2328 + if (!eth->netdev[i])
2330 + err = register_netdev(eth->netdev[i]);
2332 + dev_err(eth->dev, "error bringing up device\n");
2334 + netif_info(eth, probe, eth->netdev[i],
2335 + "mediatek frame engine at 0x%08lx, irq %d\n",
2336 + eth->netdev[i]->base_addr, eth->irq[0]);
2339 /* we run 2 devices on the same DMA ring so we need a dummy device
2342 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.h
2343 +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.h
2344 @@ -407,6 +407,9 @@ struct mtk_eth {
2345 struct clk *clk_gp2;
2346 struct mii_bus *mii_bus;
2347 struct work_struct pending_work;
2349 + struct device_node *switch_np;
2353 /* struct mtk_mac - the structure that holds the info about the MACs of the
2354 @@ -434,4 +437,6 @@ void mtk_stats_update_mac(struct mtk_mac
2355 void mtk_w32(struct mtk_eth *eth, u32 val, unsigned reg);
2356 u32 mtk_r32(struct mtk_eth *eth, unsigned reg);
2358 +int mt7623_gsw_config(struct mtk_eth *eth);
2360 #endif /* MTK_ETH_H */