~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,11 +1,5 @@
1		-/* This program is free software; you can redistribute it and/or modify
2		- * it under the terms of the GNU General Public License as published by
3		- * the Free Software Foundation; version 2 of the License
4		- *
5		- * This program is distributed in the hope that it will be useful,
6		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
7		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8		- * GNU General Public License for more details.
	1	+// SPDX-License-Identifier: GPL-2.0-only
	2	+/*
9	3	*
10	4	* Copyright (C) 2009-2016 John Crispin <blogic@openwrt.org>
11	5	* Copyright (C) 2009-2016 Felix Fietkau <nbd@openwrt.org>
..	..	@@ -24,6 +18,7 @@
24	18	#include <linux/tcp.h>
25	19	#include <linux/interrupt.h>
26	20	#include <linux/pinctrl/devinfo.h>
	21	+#include <linux/phylink.h>
27	22
28	23	#include "mtk_eth_soc.h"
29	24
..	..	@@ -54,8 +49,10 @@
54	49	};
55	50
56	51	static const char * const mtk_clks_source_name[] = {
57		- "ethif", "esw", "gp0", "gp1", "gp2", "trgpll", "sgmii_tx250m",
58		- "sgmii_rx250m", "sgmii_cdr_ref", "sgmii_cdr_fb", "sgmii_ck", "eth2pll"
	52	+ "ethif", "sgmiitop", "esw", "gp0", "gp1", "gp2", "fe", "trgpll",
	53	+ "sgmii_tx250m", "sgmii_rx250m", "sgmii_cdr_ref", "sgmii_cdr_fb",
	54	+ "sgmii2_tx250m", "sgmii2_rx250m", "sgmii2_cdr_ref", "sgmii2_cdr_fb",
	55	+ "sgmii_ck", "eth2pll",
59	56	};
60	57
61	58	void mtk_w32(struct mtk_eth *eth, u32 val, unsigned reg)
..	..	@@ -66,6 +63,17 @@
66	63	u32 mtk_r32(struct mtk_eth *eth, unsigned reg)
67	64	{
68	65	return __raw_readl(eth->base + reg);
	66	+}
	67	+
	68	+static u32 mtk_m32(struct mtk_eth *eth, u32 mask, u32 set, unsigned reg)
	69	+{
	70	+ u32 val;
	71	+
	72	+ val = mtk_r32(eth, reg);
	73	+ val &= ~mask;
	74	+ val \|= set;
	75	+ mtk_w32(eth, val, reg);
	76	+ return reg;
69	77	}
70	78
71	79	static int mtk_mdio_busy_wait(struct mtk_eth *eth)
..	..	@@ -138,10 +146,45 @@
138	146	return _mtk_mdio_read(eth, phy_addr, phy_reg);
139	147	}
140	148
141		-static void mtk_gmac0_rgmii_adjust(struct mtk_eth *eth, int speed)
	149	+static int mt7621_gmac0_rgmii_adjust(struct mtk_eth *eth,
	150	+ phy_interface_t interface)
	151	+{
	152	+ u32 val;
	153	+
	154	+ /* Check DDR memory type.
	155	+ * Currently TRGMII mode with DDR2 memory is not supported.
	156	+ */
	157	+ regmap_read(eth->ethsys, ETHSYS_SYSCFG, &val);
	158	+ if (interface == PHY_INTERFACE_MODE_TRGMII &&
	159	+ val & SYSCFG_DRAM_TYPE_DDR2) {
	160	+ dev_err(eth->dev,
	161	+ "TRGMII mode with DDR2 memory is not supported!\n");
	162	+ return -EOPNOTSUPP;
	163	+ }
	164	+
	165	+ val = (interface == PHY_INTERFACE_MODE_TRGMII) ?
	166	+ ETHSYS_TRGMII_MT7621_DDR_PLL : 0;
	167	+
	168	+ regmap_update_bits(eth->ethsys, ETHSYS_CLKCFG0,
	169	+ ETHSYS_TRGMII_MT7621_MASK, val);
	170	+
	171	+ return 0;
	172	+}
	173	+
	174	+static void mtk_gmac0_rgmii_adjust(struct mtk_eth *eth,
	175	+ phy_interface_t interface, int speed)
142	176	{
143	177	u32 val;
144	178	int ret;
	179	+
	180	+ if (interface == PHY_INTERFACE_MODE_TRGMII) {
	181	+ mtk_w32(eth, TRGMII_MODE, INTF_MODE);
	182	+ val = 500000000;
	183	+ ret = clk_set_rate(eth->clks[MTK_CLK_TRGPLL], val);
	184	+ if (ret)
	185	+ dev_err(eth->dev, "Failed to set trgmii pll: %d\n", ret);
	186	+ return;
	187	+ }
145	188
146	189	val = (speed == SPEED_1000) ?
147	190	INTF_MODE_RGMII_1000 : INTF_MODE_RGMII_10_100;
..	..	@@ -165,217 +208,354 @@
165	208	mtk_w32(eth, val, TRGMII_TCK_CTRL);
166	209	}
167	210
168		-static void mtk_gmac_sgmii_hw_setup(struct mtk_eth *eth, int mac_id)
	211	+static void mtk_mac_config(struct phylink_config *config, unsigned int mode,
	212	+ const struct phylink_link_state *state)
169	213	{
170		- u32 val;
	214	+ struct mtk_mac *mac = container_of(config, struct mtk_mac,
	215	+ phylink_config);
	216	+ struct mtk_eth *eth = mac->hw;
	217	+ u32 mcr_cur, mcr_new, sid, i;
	218	+ int val, ge_mode, err = 0;
171	219
172		- /* Setup the link timer and QPHY power up inside SGMIISYS */
173		- regmap_write(eth->sgmiisys, SGMSYS_PCS_LINK_TIMER,
174		- SGMII_LINK_TIMER_DEFAULT);
	220	+ /* MT76x8 has no hardware settings between for the MAC */
	221	+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628) &&
	222	+ mac->interface != state->interface) {
	223	+ /* Setup soc pin functions */
	224	+ switch (state->interface) {
	225	+ case PHY_INTERFACE_MODE_TRGMII:
	226	+ if (mac->id)
	227	+ goto err_phy;
	228	+ if (!MTK_HAS_CAPS(mac->hw->soc->caps,
	229	+ MTK_GMAC1_TRGMII))
	230	+ goto err_phy;
	231	+ fallthrough;
	232	+ case PHY_INTERFACE_MODE_RGMII_TXID:
	233	+ case PHY_INTERFACE_MODE_RGMII_RXID:
	234	+ case PHY_INTERFACE_MODE_RGMII_ID:
	235	+ case PHY_INTERFACE_MODE_RGMII:
	236	+ case PHY_INTERFACE_MODE_MII:
	237	+ case PHY_INTERFACE_MODE_REVMII:
	238	+ case PHY_INTERFACE_MODE_RMII:
	239	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_RGMII)) {
	240	+ err = mtk_gmac_rgmii_path_setup(eth, mac->id);
	241	+ if (err)
	242	+ goto init_err;
	243	+ }
	244	+ break;
	245	+ case PHY_INTERFACE_MODE_1000BASEX:
	246	+ case PHY_INTERFACE_MODE_2500BASEX:
	247	+ case PHY_INTERFACE_MODE_SGMII:
	248	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII)) {
	249	+ err = mtk_gmac_sgmii_path_setup(eth, mac->id);
	250	+ if (err)
	251	+ goto init_err;
	252	+ }
	253	+ break;
	254	+ case PHY_INTERFACE_MODE_GMII:
	255	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_GEPHY)) {
	256	+ err = mtk_gmac_gephy_path_setup(eth, mac->id);
	257	+ if (err)
	258	+ goto init_err;
	259	+ }
	260	+ break;
	261	+ default:
	262	+ goto err_phy;
	263	+ }
175	264
176		- regmap_read(eth->sgmiisys, SGMSYS_SGMII_MODE, &val);
177		- val \|= SGMII_REMOTE_FAULT_DIS;
178		- regmap_write(eth->sgmiisys, SGMSYS_SGMII_MODE, val);
	265	+ /* Setup clock for 1st gmac */
	266	+ if (!mac->id && state->interface != PHY_INTERFACE_MODE_SGMII &&
	267	+ !phy_interface_mode_is_8023z(state->interface) &&
	268	+ MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GMAC1_TRGMII)) {
	269	+ if (MTK_HAS_CAPS(mac->hw->soc->caps,
	270	+ MTK_TRGMII_MT7621_CLK)) {
	271	+ if (mt7621_gmac0_rgmii_adjust(mac->hw,
	272	+ state->interface))
	273	+ goto err_phy;
	274	+ } else {
	275	+ mtk_gmac0_rgmii_adjust(mac->hw,
	276	+ state->interface,
	277	+ state->speed);
179	278
180		- regmap_read(eth->sgmiisys, SGMSYS_PCS_CONTROL_1, &val);
181		- val \|= SGMII_AN_RESTART;
182		- regmap_write(eth->sgmiisys, SGMSYS_PCS_CONTROL_1, val);
	279	+ /* mt7623_pad_clk_setup */
	280	+ for (i = 0 ; i < NUM_TRGMII_CTRL; i++)
	281	+ mtk_w32(mac->hw,
	282	+ TD_DM_DRVP(8) \| TD_DM_DRVN(8),
	283	+ TRGMII_TD_ODT(i));
183	284
184		- regmap_read(eth->sgmiisys, SGMSYS_QPHY_PWR_STATE_CTRL, &val);
185		- val &= ~SGMII_PHYA_PWD;
186		- regmap_write(eth->sgmiisys, SGMSYS_QPHY_PWR_STATE_CTRL, val);
	285	+ /* Assert/release MT7623 RXC reset */
	286	+ mtk_m32(mac->hw, 0, RXC_RST \| RXC_DQSISEL,
	287	+ TRGMII_RCK_CTRL);
	288	+ mtk_m32(mac->hw, RXC_RST, 0, TRGMII_RCK_CTRL);
	289	+ }
	290	+ }
187	291
188		- /* Determine MUX for which GMAC uses the SGMII interface */
189		- if (MTK_HAS_CAPS(eth->soc->caps, MTK_DUAL_GMAC_SHARED_SGMII)) {
	292	+ ge_mode = 0;
	293	+ switch (state->interface) {
	294	+ case PHY_INTERFACE_MODE_MII:
	295	+ case PHY_INTERFACE_MODE_GMII:
	296	+ ge_mode = 1;
	297	+ break;
	298	+ case PHY_INTERFACE_MODE_REVMII:
	299	+ ge_mode = 2;
	300	+ break;
	301	+ case PHY_INTERFACE_MODE_RMII:
	302	+ if (mac->id)
	303	+ goto err_phy;
	304	+ ge_mode = 3;
	305	+ break;
	306	+ default:
	307	+ break;
	308	+ }
	309	+
	310	+ /* put the gmac into the right mode */
190	311	regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val);
191		- val &= ~SYSCFG0_SGMII_MASK;
192		- val \|= !mac_id ? SYSCFG0_SGMII_GMAC1 : SYSCFG0_SGMII_GMAC2;
	312	+ val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, mac->id);
	313	+ val \|= SYSCFG0_GE_MODE(ge_mode, mac->id);
193	314	regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val);
194	315
195		- dev_info(eth->dev, "setup shared sgmii for gmac=%d\n",
196		- mac_id);
	316	+ mac->interface = state->interface;
197	317	}
198	318
199		- /* Setup the GMAC1 going through SGMII path when SoC also support
200		- * ESW on GMAC1
201		- */
202		- if (MTK_HAS_CAPS(eth->soc->caps, MTK_GMAC1_ESW \| MTK_GMAC1_SGMII) &&
203		- !mac_id) {
204		- mtk_w32(eth, 0, MTK_MAC_MISC);
205		- dev_info(eth->dev, "setup gmac1 going through sgmii");
	319	+ /* SGMII */
	320	+ if (state->interface == PHY_INTERFACE_MODE_SGMII \|\|
	321	+ phy_interface_mode_is_8023z(state->interface)) {
	322	+ /* The path GMAC to SGMII will be enabled once the SGMIISYS is
	323	+ * being setup done.
	324	+ */
	325	+ regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val);
	326	+
	327	+ regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0,
	328	+ SYSCFG0_SGMII_MASK,
	329	+ ~(u32)SYSCFG0_SGMII_MASK);
	330	+
	331	+ /* Decide how GMAC and SGMIISYS be mapped */
	332	+ sid = (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_SGMII)) ?
	333	+ 0 : mac->id;
	334	+
	335	+ /* Setup SGMIISYS with the determined property */
	336	+ if (state->interface != PHY_INTERFACE_MODE_SGMII)
	337	+ err = mtk_sgmii_setup_mode_force(eth->sgmii, sid,
	338	+ state);
	339	+ else if (phylink_autoneg_inband(mode))
	340	+ err = mtk_sgmii_setup_mode_an(eth->sgmii, sid);
	341	+
	342	+ if (err)
	343	+ goto init_err;
	344	+
	345	+ regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0,
	346	+ SYSCFG0_SGMII_MASK, val);
	347	+ } else if (phylink_autoneg_inband(mode)) {
	348	+ dev_err(eth->dev,
	349	+ "In-band mode not supported in non SGMII mode!\n");
	350	+ return;
206	351	}
	352	+
	353	+ /* Setup gmac */
	354	+ mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
	355	+ mcr_new = mcr_cur;
	356	+ mcr_new \|= MAC_MCR_MAX_RX_1536 \| MAC_MCR_IPG_CFG \| MAC_MCR_FORCE_MODE \|
	357	+ MAC_MCR_BACKOFF_EN \| MAC_MCR_BACKPR_EN \| MAC_MCR_FORCE_LINK \|
	358	+ MAC_MCR_RX_FIFO_CLR_DIS;
	359	+
	360	+ /* Only update control register when needed! */
	361	+ if (mcr_new != mcr_cur)
	362	+ mtk_w32(mac->hw, mcr_new, MTK_MAC_MCR(mac->id));
	363	+
	364	+ return;
	365	+
	366	+err_phy:
	367	+ dev_err(eth->dev, "%s: GMAC%d mode %s not supported!\n", __func__,
	368	+ mac->id, phy_modes(state->interface));
	369	+ return;
	370	+
	371	+init_err:
	372	+ dev_err(eth->dev, "%s: GMAC%d mode %s err: %d!\n", __func__,
	373	+ mac->id, phy_modes(state->interface), err);
207	374	}
208	375
209		-static void mtk_phy_link_adjust(struct net_device *dev)
	376	+static void mtk_mac_pcs_get_state(struct phylink_config *config,
	377	+ struct phylink_link_state *state)
210	378	{
211		- struct mtk_mac *mac = netdev_priv(dev);
212		- u16 lcl_adv = 0, rmt_adv = 0;
213		- u8 flowctrl;
214		- u32 mcr = MAC_MCR_MAX_RX_1536 \| MAC_MCR_IPG_CFG \|
215		- MAC_MCR_FORCE_MODE \| MAC_MCR_TX_EN \|
216		- MAC_MCR_RX_EN \| MAC_MCR_BACKOFF_EN \|
217		- MAC_MCR_BACKPR_EN;
	379	+ struct mtk_mac *mac = container_of(config, struct mtk_mac,
	380	+ phylink_config);
	381	+ u32 pmsr = mtk_r32(mac->hw, MTK_MAC_MSR(mac->id));
218	382
219		- if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
220		- return;
	383	+ state->link = (pmsr & MAC_MSR_LINK);
	384	+ state->duplex = (pmsr & MAC_MSR_DPX) >> 1;
221	385
222		- switch (dev->phydev->speed) {
	386	+ switch (pmsr & (MAC_MSR_SPEED_1000 \| MAC_MSR_SPEED_100)) {
	387	+ case 0:
	388	+ state->speed = SPEED_10;
	389	+ break;
	390	+ case MAC_MSR_SPEED_100:
	391	+ state->speed = SPEED_100;
	392	+ break;
	393	+ case MAC_MSR_SPEED_1000:
	394	+ state->speed = SPEED_1000;
	395	+ break;
	396	+ default:
	397	+ state->speed = SPEED_UNKNOWN;
	398	+ break;
	399	+ }
	400	+
	401	+ state->pause &= (MLO_PAUSE_RX \| MLO_PAUSE_TX);
	402	+ if (pmsr & MAC_MSR_RX_FC)
	403	+ state->pause \|= MLO_PAUSE_RX;
	404	+ if (pmsr & MAC_MSR_TX_FC)
	405	+ state->pause \|= MLO_PAUSE_TX;
	406	+}
	407	+
	408	+static void mtk_mac_an_restart(struct phylink_config *config)
	409	+{
	410	+ struct mtk_mac *mac = container_of(config, struct mtk_mac,
	411	+ phylink_config);
	412	+
	413	+ mtk_sgmii_restart_an(mac->hw, mac->id);
	414	+}
	415	+
	416	+static void mtk_mac_link_down(struct phylink_config *config, unsigned int mode,
	417	+ phy_interface_t interface)
	418	+{
	419	+ struct mtk_mac *mac = container_of(config, struct mtk_mac,
	420	+ phylink_config);
	421	+ u32 mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
	422	+
	423	+ mcr &= ~(MAC_MCR_TX_EN \| MAC_MCR_RX_EN);
	424	+ mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
	425	+}
	426	+
	427	+static void mtk_mac_link_up(struct phylink_config *config,
	428	+ struct phy_device *phy,
	429	+ unsigned int mode, phy_interface_t interface,
	430	+ int speed, int duplex, bool tx_pause, bool rx_pause)
	431	+{
	432	+ struct mtk_mac *mac = container_of(config, struct mtk_mac,
	433	+ phylink_config);
	434	+ u32 mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
	435	+
	436	+ mcr &= ~(MAC_MCR_SPEED_100 \| MAC_MCR_SPEED_1000 \|
	437	+ MAC_MCR_FORCE_DPX \| MAC_MCR_FORCE_TX_FC \|
	438	+ MAC_MCR_FORCE_RX_FC);
	439	+
	440	+ /* Configure speed */
	441	+ switch (speed) {
	442	+ case SPEED_2500:
223	443	case SPEED_1000:
224	444	mcr \|= MAC_MCR_SPEED_1000;
225	445	break;
226	446	case SPEED_100:
227	447	mcr \|= MAC_MCR_SPEED_100;
228	448	break;
229		- };
	449	+ }
230	450
231		- if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GMAC1_TRGMII) &&
232		- !mac->id && !mac->trgmii)
233		- mtk_gmac0_rgmii_adjust(mac->hw, dev->phydev->speed);
234		-
235		- if (dev->phydev->link)
236		- mcr \|= MAC_MCR_FORCE_LINK;
237		-
238		- if (dev->phydev->duplex) {
	451	+ /* Configure duplex */
	452	+ if (duplex == DUPLEX_FULL)
239	453	mcr \|= MAC_MCR_FORCE_DPX;
240	454
241		- if (dev->phydev->pause)
242		- rmt_adv = LPA_PAUSE_CAP;
243		- if (dev->phydev->asym_pause)
244		- rmt_adv \|= LPA_PAUSE_ASYM;
	455	+ /* Configure pause modes - phylink will avoid these for half duplex */
	456	+ if (tx_pause)
	457	+ mcr \|= MAC_MCR_FORCE_TX_FC;
	458	+ if (rx_pause)
	459	+ mcr \|= MAC_MCR_FORCE_RX_FC;
245	460
246		- if (dev->phydev->advertising & ADVERTISED_Pause)
247		- lcl_adv \|= ADVERTISE_PAUSE_CAP;
248		- if (dev->phydev->advertising & ADVERTISED_Asym_Pause)
249		- lcl_adv \|= ADVERTISE_PAUSE_ASYM;
250		-
251		- flowctrl = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv);
252		-
253		- if (flowctrl & FLOW_CTRL_TX)
254		- mcr \|= MAC_MCR_FORCE_TX_FC;
255		- if (flowctrl & FLOW_CTRL_RX)
256		- mcr \|= MAC_MCR_FORCE_RX_FC;
257		-
258		- netif_dbg(mac->hw, link, dev, "rx pause %s, tx pause %s\n",
259		- flowctrl & FLOW_CTRL_RX ? "enabled" : "disabled",
260		- flowctrl & FLOW_CTRL_TX ? "enabled" : "disabled");
261		- }
262		-
	461	+ mcr \|= MAC_MCR_TX_EN \| MAC_MCR_RX_EN;
263	462	mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
264		-
265		- if (dev->phydev->link)
266		- netif_carrier_on(dev);
267		- else
268		- netif_carrier_off(dev);
269		-
270		- if (!of_phy_is_fixed_link(mac->of_node))
271		- phy_print_status(dev->phydev);
272	463	}
273	464
274		-static int mtk_phy_connect_node(struct mtk_eth eth, struct mtk_mac mac,
275		- struct device_node *phy_node)
	465	+static void mtk_validate(struct phylink_config *config,
	466	+ unsigned long *supported,
	467	+ struct phylink_link_state *state)
276	468	{
277		- struct phy_device *phydev;
278		- int phy_mode;
	469	+ struct mtk_mac *mac = container_of(config, struct mtk_mac,
	470	+ phylink_config);
	471	+ __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
279	472
280		- phy_mode = of_get_phy_mode(phy_node);
281		- if (phy_mode < 0) {
282		- dev_err(eth->dev, "incorrect phy-mode %d\n", phy_mode);
283		- return -EINVAL;
	473	+ if (state->interface != PHY_INTERFACE_MODE_NA &&
	474	+ state->interface != PHY_INTERFACE_MODE_MII &&
	475	+ state->interface != PHY_INTERFACE_MODE_GMII &&
	476	+ !(MTK_HAS_CAPS(mac->hw->soc->caps, MTK_RGMII) &&
	477	+ phy_interface_mode_is_rgmii(state->interface)) &&
	478	+ !(MTK_HAS_CAPS(mac->hw->soc->caps, MTK_TRGMII) &&
	479	+ !mac->id && state->interface == PHY_INTERFACE_MODE_TRGMII) &&
	480	+ !(MTK_HAS_CAPS(mac->hw->soc->caps, MTK_SGMII) &&
	481	+ (state->interface == PHY_INTERFACE_MODE_SGMII \|\|
	482	+ phy_interface_mode_is_8023z(state->interface)))) {
	483	+ linkmode_zero(supported);
	484	+ return;
284	485	}
285	486
286		- phydev = of_phy_connect(eth->netdev[mac->id], phy_node,
287		- mtk_phy_link_adjust, 0, phy_mode);
288		- if (!phydev) {
289		- dev_err(eth->dev, "could not connect to PHY\n");
290		- return -ENODEV;
291		- }
	487	+ phylink_set_port_modes(mask);
	488	+ phylink_set(mask, Autoneg);
292	489
293		- dev_info(eth->dev,
294		- "connected mac %d to PHY at %s [uid=%08x, driver=%s]\n",
295		- mac->id, phydev_name(phydev), phydev->phy_id,
296		- phydev->drv->name);
297		-
298		- return 0;
299		-}
300		-
301		-static int mtk_phy_connect(struct net_device *dev)
302		-{
303		- struct mtk_mac *mac = netdev_priv(dev);
304		- struct mtk_eth *eth;
305		- struct device_node *np;
306		- u32 val;
307		-
308		- eth = mac->hw;
309		- np = of_parse_phandle(mac->of_node, "phy-handle", 0);
310		- if (!np && of_phy_is_fixed_link(mac->of_node))
311		- if (!of_phy_register_fixed_link(mac->of_node))
312		- np = of_node_get(mac->of_node);
313		- if (!np)
314		- return -ENODEV;
315		-
316		- mac->ge_mode = 0;
317		- switch (of_get_phy_mode(np)) {
	490	+ switch (state->interface) {
318	491	case PHY_INTERFACE_MODE_TRGMII:
319		- mac->trgmii = true;
320		- case PHY_INTERFACE_MODE_RGMII_TXID:
321		- case PHY_INTERFACE_MODE_RGMII_RXID:
322		- case PHY_INTERFACE_MODE_RGMII_ID:
	492	+ phylink_set(mask, 1000baseT_Full);
	493	+ break;
	494	+ case PHY_INTERFACE_MODE_1000BASEX:
	495	+ case PHY_INTERFACE_MODE_2500BASEX:
	496	+ phylink_set(mask, 1000baseX_Full);
	497	+ phylink_set(mask, 2500baseX_Full);
	498	+ break;
	499	+ case PHY_INTERFACE_MODE_GMII:
323	500	case PHY_INTERFACE_MODE_RGMII:
324		- break;
	501	+ case PHY_INTERFACE_MODE_RGMII_ID:
	502	+ case PHY_INTERFACE_MODE_RGMII_RXID:
	503	+ case PHY_INTERFACE_MODE_RGMII_TXID:
	504	+ phylink_set(mask, 1000baseT_Half);
	505	+ fallthrough;
325	506	case PHY_INTERFACE_MODE_SGMII:
326		- if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII))
327		- mtk_gmac_sgmii_hw_setup(eth, mac->id);
328		- break;
	507	+ phylink_set(mask, 1000baseT_Full);
	508	+ phylink_set(mask, 1000baseX_Full);
	509	+ fallthrough;
329	510	case PHY_INTERFACE_MODE_MII:
330		- mac->ge_mode = 1;
331		- break;
332		- case PHY_INTERFACE_MODE_REVMII:
333		- mac->ge_mode = 2;
334		- break;
335	511	case PHY_INTERFACE_MODE_RMII:
336		- if (!mac->id)
337		- goto err_phy;
338		- mac->ge_mode = 3;
339		- break;
	512	+ case PHY_INTERFACE_MODE_REVMII:
	513	+ case PHY_INTERFACE_MODE_NA:
340	514	default:
341		- goto err_phy;
	515	+ phylink_set(mask, 10baseT_Half);
	516	+ phylink_set(mask, 10baseT_Full);
	517	+ phylink_set(mask, 100baseT_Half);
	518	+ phylink_set(mask, 100baseT_Full);
	519	+ break;
342	520	}
343	521
344		- /* put the gmac into the right mode */
345		- regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val);
346		- val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, mac->id);
347		- val \|= SYSCFG0_GE_MODE(mac->ge_mode, mac->id);
348		- regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val);
	522	+ if (state->interface == PHY_INTERFACE_MODE_NA) {
	523	+ if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_SGMII)) {
	524	+ phylink_set(mask, 1000baseT_Full);
	525	+ phylink_set(mask, 1000baseX_Full);
	526	+ phylink_set(mask, 2500baseX_Full);
	527	+ }
	528	+ if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_RGMII)) {
	529	+ phylink_set(mask, 1000baseT_Full);
	530	+ phylink_set(mask, 1000baseT_Half);
	531	+ phylink_set(mask, 1000baseX_Full);
	532	+ }
	533	+ if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GEPHY)) {
	534	+ phylink_set(mask, 1000baseT_Full);
	535	+ phylink_set(mask, 1000baseT_Half);
	536	+ }
	537	+ }
349	538
350		- /* couple phydev to net_device */
351		- if (mtk_phy_connect_node(eth, mac, np))
352		- goto err_phy;
	539	+ phylink_set(mask, Pause);
	540	+ phylink_set(mask, Asym_Pause);
353	541
354		- dev->phydev->autoneg = AUTONEG_ENABLE;
355		- dev->phydev->speed = 0;
356		- dev->phydev->duplex = 0;
	542	+ linkmode_and(supported, supported, mask);
	543	+ linkmode_and(state->advertising, state->advertising, mask);
357	544
358		- if (of_phy_is_fixed_link(mac->of_node))
359		- dev->phydev->supported \|=
360		- SUPPORTED_Pause \| SUPPORTED_Asym_Pause;
361		-
362		- dev->phydev->supported &= PHY_GBIT_FEATURES \| SUPPORTED_Pause \|
363		- SUPPORTED_Asym_Pause;
364		- dev->phydev->advertising = dev->phydev->supported \|
365		- ADVERTISED_Autoneg;
366		- phy_start_aneg(dev->phydev);
367		-
368		- of_node_put(np);
369		-
370		- return 0;
371		-
372		-err_phy:
373		- if (of_phy_is_fixed_link(mac->of_node))
374		- of_phy_deregister_fixed_link(mac->of_node);
375		- of_node_put(np);
376		- dev_err(eth->dev, "%s: invalid phy\n", __func__);
377		- return -EINVAL;
	545	+ /* We can only operate at 2500BaseX or 1000BaseX. If requested
	546	+ * to advertise both, only report advertising at 2500BaseX.
	547	+ */
	548	+ phylink_helper_basex_speed(state);
378	549	}
	550	+
	551	+static const struct phylink_mac_ops mtk_phylink_ops = {
	552	+ .validate = mtk_validate,
	553	+ .mac_pcs_get_state = mtk_mac_pcs_get_state,
	554	+ .mac_an_restart = mtk_mac_an_restart,
	555	+ .mac_config = mtk_mac_config,
	556	+ .mac_link_down = mtk_mac_link_down,
	557	+ .mac_link_up = mtk_mac_link_up,
	558	+};
379	559
380	560	static int mtk_mdio_init(struct mtk_eth *eth)
381	561	{
..	..	@@ -405,7 +585,7 @@
405	585	eth->mii_bus->priv = eth;
406	586	eth->mii_bus->parent = eth->dev;
407	587
408		- snprintf(eth->mii_bus->id, MII_BUS_ID_SIZE, "%s", mii_np->name);
	588	+ snprintf(eth->mii_bus->id, MII_BUS_ID_SIZE, "%pOFn", mii_np);
409	589	ret = of_mdiobus_register(eth->mii_bus, mii_np);
410	590
411	591	err_put_node:
..	..	@@ -427,8 +607,8 @@
427	607	u32 val;
428	608
429	609	spin_lock_irqsave(&eth->tx_irq_lock, flags);
430		- val = mtk_r32(eth, MTK_QDMA_INT_MASK);
431		- mtk_w32(eth, val & ~mask, MTK_QDMA_INT_MASK);
	610	+ val = mtk_r32(eth, eth->tx_int_mask_reg);
	611	+ mtk_w32(eth, val & ~mask, eth->tx_int_mask_reg);
432	612	spin_unlock_irqrestore(&eth->tx_irq_lock, flags);
433	613	}
434	614
..	..	@@ -438,8 +618,8 @@
438	618	u32 val;
439	619
440	620	spin_lock_irqsave(&eth->tx_irq_lock, flags);
441		- val = mtk_r32(eth, MTK_QDMA_INT_MASK);
442		- mtk_w32(eth, val \| mask, MTK_QDMA_INT_MASK);
	621	+ val = mtk_r32(eth, eth->tx_int_mask_reg);
	622	+ mtk_w32(eth, val \| mask, eth->tx_int_mask_reg);
443	623	spin_unlock_irqrestore(&eth->tx_irq_lock, flags);
444	624	}
445	625
..	..	@@ -469,6 +649,7 @@
469	649	{
470	650	int ret = eth_mac_addr(dev, p);
471	651	struct mtk_mac *mac = netdev_priv(dev);
	652	+ struct mtk_eth *eth = mac->hw;
472	653	const char *macaddr = dev->dev_addr;
473	654
474	655	if (ret)
..	..	@@ -478,11 +659,19 @@
478	659	return -EBUSY;
479	660
480	661	spin_lock_bh(&mac->hw->page_lock);
481		- mtk_w32(mac->hw, (macaddr[0] << 8) \| macaddr[1],
482		- MTK_GDMA_MAC_ADRH(mac->id));
483		- mtk_w32(mac->hw, (macaddr[2] << 24) \| (macaddr[3] << 16) \|
484		- (macaddr[4] << 8) \| macaddr[5],
485		- MTK_GDMA_MAC_ADRL(mac->id));
	662	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	663	+ mtk_w32(mac->hw, (macaddr[0] << 8) \| macaddr[1],
	664	+ MT7628_SDM_MAC_ADRH);
	665	+ mtk_w32(mac->hw, (macaddr[2] << 24) \| (macaddr[3] << 16) \|
	666	+ (macaddr[4] << 8) \| macaddr[5],
	667	+ MT7628_SDM_MAC_ADRL);
	668	+ } else {
	669	+ mtk_w32(mac->hw, (macaddr[0] << 8) \| macaddr[1],
	670	+ MTK_GDMA_MAC_ADRH(mac->id));
	671	+ mtk_w32(mac->hw, (macaddr[2] << 24) \| (macaddr[3] << 16) \|
	672	+ (macaddr[4] << 8) \| macaddr[5],
	673	+ MTK_GDMA_MAC_ADRL(mac->id));
	674	+ }
486	675	spin_unlock_bh(&mac->hw->page_lock);
487	676
488	677	return 0;
..	..	@@ -491,32 +680,53 @@
491	680	void mtk_stats_update_mac(struct mtk_mac *mac)
492	681	{
493	682	struct mtk_hw_stats *hw_stats = mac->hw_stats;
494		- unsigned int base = MTK_GDM1_TX_GBCNT;
495		- u64 stats;
496		-
497		- base += hw_stats->reg_offset;
	683	+ struct mtk_eth *eth = mac->hw;
498	684
499	685	u64_stats_update_begin(&hw_stats->syncp);
500	686
501		- hw_stats->rx_bytes += mtk_r32(mac->hw, base);
502		- stats = mtk_r32(mac->hw, base + 0x04);
503		- if (stats)
504		- hw_stats->rx_bytes += (stats << 32);
505		- hw_stats->rx_packets += mtk_r32(mac->hw, base + 0x08);
506		- hw_stats->rx_overflow += mtk_r32(mac->hw, base + 0x10);
507		- hw_stats->rx_fcs_errors += mtk_r32(mac->hw, base + 0x14);
508		- hw_stats->rx_short_errors += mtk_r32(mac->hw, base + 0x18);
509		- hw_stats->rx_long_errors += mtk_r32(mac->hw, base + 0x1c);
510		- hw_stats->rx_checksum_errors += mtk_r32(mac->hw, base + 0x20);
511		- hw_stats->rx_flow_control_packets +=
512		- mtk_r32(mac->hw, base + 0x24);
513		- hw_stats->tx_skip += mtk_r32(mac->hw, base + 0x28);
514		- hw_stats->tx_collisions += mtk_r32(mac->hw, base + 0x2c);
515		- hw_stats->tx_bytes += mtk_r32(mac->hw, base + 0x30);
516		- stats = mtk_r32(mac->hw, base + 0x34);
517		- if (stats)
518		- hw_stats->tx_bytes += (stats << 32);
519		- hw_stats->tx_packets += mtk_r32(mac->hw, base + 0x38);
	687	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	688	+ hw_stats->tx_packets += mtk_r32(mac->hw, MT7628_SDM_TPCNT);
	689	+ hw_stats->tx_bytes += mtk_r32(mac->hw, MT7628_SDM_TBCNT);
	690	+ hw_stats->rx_packets += mtk_r32(mac->hw, MT7628_SDM_RPCNT);
	691	+ hw_stats->rx_bytes += mtk_r32(mac->hw, MT7628_SDM_RBCNT);
	692	+ hw_stats->rx_checksum_errors +=
	693	+ mtk_r32(mac->hw, MT7628_SDM_CS_ERR);
	694	+ } else {
	695	+ unsigned int offs = hw_stats->reg_offset;
	696	+ u64 stats;
	697	+
	698	+ hw_stats->rx_bytes += mtk_r32(mac->hw,
	699	+ MTK_GDM1_RX_GBCNT_L + offs);
	700	+ stats = mtk_r32(mac->hw, MTK_GDM1_RX_GBCNT_H + offs);
	701	+ if (stats)
	702	+ hw_stats->rx_bytes += (stats << 32);
	703	+ hw_stats->rx_packets +=
	704	+ mtk_r32(mac->hw, MTK_GDM1_RX_GPCNT + offs);
	705	+ hw_stats->rx_overflow +=
	706	+ mtk_r32(mac->hw, MTK_GDM1_RX_OERCNT + offs);
	707	+ hw_stats->rx_fcs_errors +=
	708	+ mtk_r32(mac->hw, MTK_GDM1_RX_FERCNT + offs);
	709	+ hw_stats->rx_short_errors +=
	710	+ mtk_r32(mac->hw, MTK_GDM1_RX_SERCNT + offs);
	711	+ hw_stats->rx_long_errors +=
	712	+ mtk_r32(mac->hw, MTK_GDM1_RX_LENCNT + offs);
	713	+ hw_stats->rx_checksum_errors +=
	714	+ mtk_r32(mac->hw, MTK_GDM1_RX_CERCNT + offs);
	715	+ hw_stats->rx_flow_control_packets +=
	716	+ mtk_r32(mac->hw, MTK_GDM1_RX_FCCNT + offs);
	717	+ hw_stats->tx_skip +=
	718	+ mtk_r32(mac->hw, MTK_GDM1_TX_SKIPCNT + offs);
	719	+ hw_stats->tx_collisions +=
	720	+ mtk_r32(mac->hw, MTK_GDM1_TX_COLCNT + offs);
	721	+ hw_stats->tx_bytes +=
	722	+ mtk_r32(mac->hw, MTK_GDM1_TX_GBCNT_L + offs);
	723	+ stats = mtk_r32(mac->hw, MTK_GDM1_TX_GBCNT_H + offs);
	724	+ if (stats)
	725	+ hw_stats->tx_bytes += (stats << 32);
	726	+ hw_stats->tx_packets +=
	727	+ mtk_r32(mac->hw, MTK_GDM1_TX_GPCNT + offs);
	728	+ }
	729	+
520	730	u64_stats_update_end(&hw_stats->syncp);
521	731	}
522	732
..	..	@@ -597,6 +807,17 @@
597	807	rxd->rxd4 = READ_ONCE(dma_rxd->rxd4);
598	808	}
599	809
	810	+static void *mtk_max_lro_buf_alloc(gfp_t gfp_mask)
	811	+{
	812	+ unsigned int size = mtk_max_frag_size(MTK_MAX_LRO_RX_LENGTH);
	813	+ unsigned long data;
	814	+
	815	+ data = __get_free_pages(gfp_mask \| __GFP_COMP \| __GFP_NOWARN,
	816	+ get_order(size));
	817	+
	818	+ return (void *)data;
	819	+}
	820	+
600	821	/* the qdma core needs scratch memory to be setup */
601	822	static int mtk_init_fq_dma(struct mtk_eth *eth)
602	823	{
..	..	@@ -605,10 +826,10 @@
605	826	dma_addr_t dma_addr;
606	827	int i;
607	828
608		- eth->scratch_ring = dma_zalloc_coherent(eth->dev,
609		- cnt * sizeof(struct mtk_tx_dma),
610		- &eth->phy_scratch_ring,
611		- GFP_ATOMIC);
	829	+ eth->scratch_ring = dma_alloc_coherent(eth->dev,
	830	+ cnt * sizeof(struct mtk_tx_dma),
	831	+ &eth->phy_scratch_ring,
	832	+ GFP_ATOMIC);
612	833	if (unlikely(!eth->scratch_ring))
613	834	return -ENOMEM;
614	835
..	..	@@ -658,24 +879,75 @@
658	879	return &ring->buf[idx];
659	880	}
660	881
	882	+static struct mtk_tx_dma qdma_to_pdma(struct mtk_tx_ring ring,
	883	+ struct mtk_tx_dma *dma)
	884	+{
	885	+ return ring->dma_pdma - ring->dma + dma;
	886	+}
	887	+
	888	+static int txd_to_idx(struct mtk_tx_ring ring, struct mtk_tx_dma dma)
	889	+{
	890	+ return ((void )dma - (void )ring->dma) / sizeof(*dma);
	891	+}
	892	+
661	893	static void mtk_tx_unmap(struct mtk_eth eth, struct mtk_tx_buf tx_buf)
662	894	{
663		- if (tx_buf->flags & MTK_TX_FLAGS_SINGLE0) {
664		- dma_unmap_single(eth->dev,
665		- dma_unmap_addr(tx_buf, dma_addr0),
666		- dma_unmap_len(tx_buf, dma_len0),
667		- DMA_TO_DEVICE);
668		- } else if (tx_buf->flags & MTK_TX_FLAGS_PAGE0) {
669		- dma_unmap_page(eth->dev,
670		- dma_unmap_addr(tx_buf, dma_addr0),
671		- dma_unmap_len(tx_buf, dma_len0),
672		- DMA_TO_DEVICE);
	895	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	896	+ if (tx_buf->flags & MTK_TX_FLAGS_SINGLE0) {
	897	+ dma_unmap_single(eth->dev,
	898	+ dma_unmap_addr(tx_buf, dma_addr0),
	899	+ dma_unmap_len(tx_buf, dma_len0),
	900	+ DMA_TO_DEVICE);
	901	+ } else if (tx_buf->flags & MTK_TX_FLAGS_PAGE0) {
	902	+ dma_unmap_page(eth->dev,
	903	+ dma_unmap_addr(tx_buf, dma_addr0),
	904	+ dma_unmap_len(tx_buf, dma_len0),
	905	+ DMA_TO_DEVICE);
	906	+ }
	907	+ } else {
	908	+ if (dma_unmap_len(tx_buf, dma_len0)) {
	909	+ dma_unmap_page(eth->dev,
	910	+ dma_unmap_addr(tx_buf, dma_addr0),
	911	+ dma_unmap_len(tx_buf, dma_len0),
	912	+ DMA_TO_DEVICE);
	913	+ }
	914	+
	915	+ if (dma_unmap_len(tx_buf, dma_len1)) {
	916	+ dma_unmap_page(eth->dev,
	917	+ dma_unmap_addr(tx_buf, dma_addr1),
	918	+ dma_unmap_len(tx_buf, dma_len1),
	919	+ DMA_TO_DEVICE);
	920	+ }
673	921	}
	922	+
674	923	tx_buf->flags = 0;
675	924	if (tx_buf->skb &&
676	925	(tx_buf->skb != (struct sk_buff *)MTK_DMA_DUMMY_DESC))
677	926	dev_kfree_skb_any(tx_buf->skb);
678	927	tx_buf->skb = NULL;
	928	+}
	929	+
	930	+static void setup_tx_buf(struct mtk_eth eth, struct mtk_tx_buf tx_buf,
	931	+ struct mtk_tx_dma *txd, dma_addr_t mapped_addr,
	932	+ size_t size, int idx)
	933	+{
	934	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	935	+ dma_unmap_addr_set(tx_buf, dma_addr0, mapped_addr);
	936	+ dma_unmap_len_set(tx_buf, dma_len0, size);
	937	+ } else {
	938	+ if (idx & 1) {
	939	+ txd->txd3 = mapped_addr;
	940	+ txd->txd2 \|= TX_DMA_PLEN1(size);
	941	+ dma_unmap_addr_set(tx_buf, dma_addr1, mapped_addr);
	942	+ dma_unmap_len_set(tx_buf, dma_len1, size);
	943	+ } else {
	944	+ tx_buf->skb = (struct sk_buff *)MTK_DMA_DUMMY_DESC;
	945	+ txd->txd1 = mapped_addr;
	946	+ txd->txd2 = TX_DMA_PLEN0(size);
	947	+ dma_unmap_addr_set(tx_buf, dma_addr0, mapped_addr);
	948	+ dma_unmap_len_set(tx_buf, dma_len0, size);
	949	+ }
	950	+ }
679	951	}
680	952
681	953	static int mtk_tx_map(struct sk_buff skb, struct net_device dev,
..	..	@@ -684,13 +956,16 @@
684	956	struct mtk_mac *mac = netdev_priv(dev);
685	957	struct mtk_eth *eth = mac->hw;
686	958	struct mtk_tx_dma itxd, txd;
	959	+ struct mtk_tx_dma itxd_pdma, txd_pdma;
687	960	struct mtk_tx_buf itx_buf, tx_buf;
688	961	dma_addr_t mapped_addr;
689	962	unsigned int nr_frags;
690	963	int i, n_desc = 1;
691	964	u32 txd4 = 0, fport;
	965	+ int k = 0;
692	966
693	967	itxd = ring->next_free;
	968	+ itxd_pdma = qdma_to_pdma(ring, itxd);
694	969	if (itxd == ring->last_free)
695	970	return -ENOMEM;
696	971
..	..	@@ -721,26 +996,37 @@
721	996	itx_buf->flags \|= MTK_TX_FLAGS_SINGLE0;
722	997	itx_buf->flags \|= (!mac->id) ? MTK_TX_FLAGS_FPORT0 :
723	998	MTK_TX_FLAGS_FPORT1;
724		- dma_unmap_addr_set(itx_buf, dma_addr0, mapped_addr);
725		- dma_unmap_len_set(itx_buf, dma_len0, skb_headlen(skb));
	999	+ setup_tx_buf(eth, itx_buf, itxd_pdma, mapped_addr, skb_headlen(skb),
	1000	+ k++);
726	1001
727	1002	/* TX SG offload */
728	1003	txd = itxd;
	1004	+ txd_pdma = qdma_to_pdma(ring, txd);
729	1005	nr_frags = skb_shinfo(skb)->nr_frags;
	1006	+
730	1007	for (i = 0; i < nr_frags; i++) {
731		- struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
	1008	+ skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
732	1009	unsigned int offset = 0;
733	1010	int frag_size = skb_frag_size(frag);
734	1011
735	1012	while (frag_size) {
736	1013	bool last_frag = false;
737	1014	unsigned int frag_map_size;
	1015	+ bool new_desc = true;
738	1016
739		- txd = mtk_qdma_phys_to_virt(ring, txd->txd2);
740		- if (txd == ring->last_free)
741		- goto err_dma;
	1017	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA) \|\|
	1018	+ (i & 0x1)) {
	1019	+ txd = mtk_qdma_phys_to_virt(ring, txd->txd2);
	1020	+ txd_pdma = qdma_to_pdma(ring, txd);
	1021	+ if (txd == ring->last_free)
	1022	+ goto err_dma;
742	1023
743		- n_desc++;
	1024	+ n_desc++;
	1025	+ } else {
	1026	+ new_desc = false;
	1027	+ }
	1028	+
	1029	+
744	1030	frag_map_size = min(frag_size, MTK_TX_DMA_BUF_LEN);
745	1031	mapped_addr = skb_frag_dma_map(eth->dev, frag, offset,
746	1032	frag_map_size,
..	..	@@ -759,14 +1045,16 @@
759	1045	WRITE_ONCE(txd->txd4, fport);
760	1046
761	1047	tx_buf = mtk_desc_to_tx_buf(ring, txd);
762		- memset(tx_buf, 0, sizeof(*tx_buf));
	1048	+ if (new_desc)
	1049	+ memset(tx_buf, 0, sizeof(*tx_buf));
763	1050	tx_buf->skb = (struct sk_buff *)MTK_DMA_DUMMY_DESC;
764	1051	tx_buf->flags \|= MTK_TX_FLAGS_PAGE0;
765	1052	tx_buf->flags \|= (!mac->id) ? MTK_TX_FLAGS_FPORT0 :
766	1053	MTK_TX_FLAGS_FPORT1;
767	1054
768		- dma_unmap_addr_set(tx_buf, dma_addr0, mapped_addr);
769		- dma_unmap_len_set(tx_buf, dma_len0, frag_map_size);
	1055	+ setup_tx_buf(eth, tx_buf, txd_pdma, mapped_addr,
	1056	+ frag_map_size, k++);
	1057	+
770	1058	frag_size -= frag_map_size;
771	1059	offset += frag_map_size;
772	1060	}
..	..	@@ -778,6 +1066,12 @@
778	1066	WRITE_ONCE(itxd->txd4, txd4);
779	1067	WRITE_ONCE(itxd->txd3, (TX_DMA_SWC \| TX_DMA_PLEN0(skb_headlen(skb)) \|
780	1068	(!nr_frags * TX_DMA_LS0)));
	1069	+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	1070	+ if (k & 0x1)
	1071	+ txd_pdma->txd2 \|= TX_DMA_LS0;
	1072	+ else
	1073	+ txd_pdma->txd2 \|= TX_DMA_LS1;
	1074	+ }
781	1075
782	1076	netdev_sent_queue(dev, skb->len);
783	1077	skb_tx_timestamp(skb);
..	..	@@ -790,8 +1084,15 @@
790	1084	*/
791	1085	wmb();
792	1086
793		- if (netif_xmit_stopped(netdev_get_tx_queue(dev, 0)) \|\| !skb->xmit_more)
794		- mtk_w32(eth, txd->txd2, MTK_QTX_CTX_PTR);
	1087	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	1088	+ if (netif_xmit_stopped(netdev_get_tx_queue(dev, 0)) \|\|
	1089	+ !netdev_xmit_more())
	1090	+ mtk_w32(eth, txd->txd2, MTK_QTX_CTX_PTR);
	1091	+ } else {
	1092	+ int next_idx = NEXT_DESP_IDX(txd_to_idx(ring, txd),
	1093	+ ring->dma_size);
	1094	+ mtk_w32(eth, next_idx, MT7628_TX_CTX_IDX0);
	1095	+ }
795	1096
796	1097	return 0;
797	1098
..	..	@@ -803,7 +1104,11 @@
803	1104	mtk_tx_unmap(eth, tx_buf);
804	1105
805	1106	itxd->txd3 = TX_DMA_LS0 \| TX_DMA_OWNER_CPU;
	1107	+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
	1108	+ itxd_pdma->txd2 = TX_DMA_DESP2_DEF;
	1109	+
806	1110	itxd = mtk_qdma_phys_to_virt(ring, itxd->txd2);
	1111	+ itxd_pdma = qdma_to_pdma(ring, itxd);
807	1112	} while (itxd != txd);
808	1113
809	1114	return -ENOMEM;
..	..	@@ -812,13 +1117,14 @@
812	1117	static inline int mtk_cal_txd_req(struct sk_buff *skb)
813	1118	{
814	1119	int i, nfrags;
815		- struct skb_frag_struct *frag;
	1120	+ skb_frag_t *frag;
816	1121
817	1122	nfrags = 1;
818	1123	if (skb_is_gso(skb)) {
819	1124	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
820	1125	frag = &skb_shinfo(skb)->frags[i];
821		- nfrags += DIV_ROUND_UP(frag->size, MTK_TX_DMA_BUF_LEN);
	1126	+ nfrags += DIV_ROUND_UP(skb_frag_size(frag),
	1127	+ MTK_TX_DMA_BUF_LEN);
822	1128	}
823	1129	} else {
824	1130	nfrags += skb_shinfo(skb)->nr_frags;
..	..	@@ -863,7 +1169,7 @@
863	1169	}
864	1170	}
865	1171
866		-static int mtk_start_xmit(struct sk_buff skb, struct net_device dev)
	1172	+static netdev_tx_t mtk_start_xmit(struct sk_buff skb, struct net_device dev)
867	1173	{
868	1174	struct mtk_mac *mac = netdev_priv(dev);
869	1175	struct mtk_eth *eth = mac->hw;
..	..	@@ -933,7 +1239,7 @@
933	1239
934	1240	for (i = 0; i < MTK_MAX_RX_RING_NUM; i++) {
935	1241	ring = &eth->rx_ring[i];
936		- idx = NEXT_RX_DESP_IDX(ring->calc_idx, ring->dma_size);
	1242	+ idx = NEXT_DESP_IDX(ring->calc_idx, ring->dma_size);
937	1243	if (ring->dma[idx].rxd2 & RX_DMA_DONE) {
938	1244	ring->calc_idx_update = true;
939	1245	return ring;
..	..	@@ -976,13 +1282,13 @@
976	1282	struct net_device *netdev;
977	1283	unsigned int pktlen;
978	1284	dma_addr_t dma_addr;
979		- int mac = 0;
	1285	+ int mac;
980	1286
981	1287	ring = mtk_get_rx_ring(eth);
982	1288	if (unlikely(!ring))
983	1289	goto rx_done;
984	1290
985		- idx = NEXT_RX_DESP_IDX(ring->calc_idx, ring->dma_size);
	1291	+ idx = NEXT_DESP_IDX(ring->calc_idx, ring->dma_size);
986	1292	rxd = &ring->dma[idx];
987	1293	data = ring->data[idx];
988	1294
..	..	@@ -991,9 +1297,13 @@
991	1297	break;
992	1298
993	1299	/* find out which mac the packet come from. values start at 1 */
994		- mac = (trxd.rxd4 >> RX_DMA_FPORT_SHIFT) &
995		- RX_DMA_FPORT_MASK;
996		- mac--;
	1300	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	1301	+ mac = 0;
	1302	+ } else {
	1303	+ mac = (trxd.rxd4 >> RX_DMA_FPORT_SHIFT) &
	1304	+ RX_DMA_FPORT_MASK;
	1305	+ mac--;
	1306	+ }
997	1307
998	1308	if (unlikely(mac < 0 \|\| mac >= MTK_MAC_COUNT \|\|
999	1309	!eth->netdev[mac]))
..	..	@@ -1005,13 +1315,17 @@
1005	1315	goto release_desc;
1006	1316
1007	1317	/* alloc new buffer */
1008		- new_data = napi_alloc_frag(ring->frag_size);
	1318	+ if (ring->frag_size <= PAGE_SIZE)
	1319	+ new_data = napi_alloc_frag(ring->frag_size);
	1320	+ else
	1321	+ new_data = mtk_max_lro_buf_alloc(GFP_ATOMIC);
1009	1322	if (unlikely(!new_data)) {
1010	1323	netdev->stats.rx_dropped++;
1011	1324	goto release_desc;
1012	1325	}
1013	1326	dma_addr = dma_map_single(eth->dev,
1014		- new_data + NET_SKB_PAD,
	1327	+ new_data + NET_SKB_PAD +
	1328	+ eth->ip_align,
1015	1329	ring->buf_size,
1016	1330	DMA_FROM_DEVICE);
1017	1331	if (unlikely(dma_mapping_error(eth->dev, dma_addr))) {
..	..	@@ -1034,7 +1348,7 @@
1034	1348	pktlen = RX_DMA_GET_PLEN0(trxd.rxd2);
1035	1349	skb->dev = netdev;
1036	1350	skb_put(skb, pktlen);
1037		- if (trxd.rxd4 & RX_DMA_L4_VALID)
	1351	+ if (trxd.rxd4 & eth->rx_dma_l4_valid)
1038	1352	skb->ip_summed = CHECKSUM_UNNECESSARY;
1039	1353	else
1040	1354	skb_checksum_none_assert(skb);
..	..	@@ -1051,7 +1365,10 @@
1051	1365	rxd->rxd1 = (unsigned int)dma_addr;
1052	1366
1053	1367	release_desc:
1054		- rxd->rxd2 = RX_DMA_PLEN0(ring->buf_size);
	1368	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
	1369	+ rxd->rxd2 = RX_DMA_LSO;
	1370	+ else
	1371	+ rxd->rxd2 = RX_DMA_PLEN0(ring->buf_size);
1055	1372
1056	1373	ring->calc_idx = idx;
1057	1374
..	..	@@ -1070,19 +1387,14 @@
1070	1387	return done;
1071	1388	}
1072	1389
1073		-static int mtk_poll_tx(struct mtk_eth *eth, int budget)
	1390	+static int mtk_poll_tx_qdma(struct mtk_eth *eth, int budget,
	1391	+ unsigned int done, unsigned int bytes)
1074	1392	{
1075	1393	struct mtk_tx_ring *ring = &eth->tx_ring;
1076	1394	struct mtk_tx_dma *desc;
1077	1395	struct sk_buff *skb;
1078	1396	struct mtk_tx_buf *tx_buf;
1079		- unsigned int done[MTK_MAX_DEVS];
1080		- unsigned int bytes[MTK_MAX_DEVS];
1081	1397	u32 cpu, dma;
1082		- int total = 0, i;
1083		-
1084		- memset(done, 0, sizeof(done));
1085		- memset(bytes, 0, sizeof(bytes));
1086	1398
1087	1399	cpu = mtk_r32(eth, MTK_QTX_CRX_PTR);
1088	1400	dma = mtk_r32(eth, MTK_QTX_DRX_PTR);
..	..	@@ -1120,6 +1432,62 @@
1120	1432
1121	1433	mtk_w32(eth, cpu, MTK_QTX_CRX_PTR);
1122	1434
	1435	+ return budget;
	1436	+}
	1437	+
	1438	+static int mtk_poll_tx_pdma(struct mtk_eth *eth, int budget,
	1439	+ unsigned int done, unsigned int bytes)
	1440	+{
	1441	+ struct mtk_tx_ring *ring = &eth->tx_ring;
	1442	+ struct mtk_tx_dma *desc;
	1443	+ struct sk_buff *skb;
	1444	+ struct mtk_tx_buf *tx_buf;
	1445	+ u32 cpu, dma;
	1446	+
	1447	+ cpu = ring->cpu_idx;
	1448	+ dma = mtk_r32(eth, MT7628_TX_DTX_IDX0);
	1449	+
	1450	+ while ((cpu != dma) && budget) {
	1451	+ tx_buf = &ring->buf[cpu];
	1452	+ skb = tx_buf->skb;
	1453	+ if (!skb)
	1454	+ break;
	1455	+
	1456	+ if (skb != (struct sk_buff *)MTK_DMA_DUMMY_DESC) {
	1457	+ bytes[0] += skb->len;
	1458	+ done[0]++;
	1459	+ budget--;
	1460	+ }
	1461	+
	1462	+ mtk_tx_unmap(eth, tx_buf);
	1463	+
	1464	+ desc = &ring->dma[cpu];
	1465	+ ring->last_free = desc;
	1466	+ atomic_inc(&ring->free_count);
	1467	+
	1468	+ cpu = NEXT_DESP_IDX(cpu, ring->dma_size);
	1469	+ }
	1470	+
	1471	+ ring->cpu_idx = cpu;
	1472	+
	1473	+ return budget;
	1474	+}
	1475	+
	1476	+static int mtk_poll_tx(struct mtk_eth *eth, int budget)
	1477	+{
	1478	+ struct mtk_tx_ring *ring = &eth->tx_ring;
	1479	+ unsigned int done[MTK_MAX_DEVS];
	1480	+ unsigned int bytes[MTK_MAX_DEVS];
	1481	+ int total = 0, i;
	1482	+
	1483	+ memset(done, 0, sizeof(done));
	1484	+ memset(bytes, 0, sizeof(bytes));
	1485	+
	1486	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
	1487	+ budget = mtk_poll_tx_qdma(eth, budget, done, bytes);
	1488	+ else
	1489	+ budget = mtk_poll_tx_pdma(eth, budget, done, bytes);
	1490	+
1123	1491	for (i = 0; i < MTK_MAC_COUNT; i++) {
1124	1492	if (!eth->netdev[i] \|\| !done[i])
1125	1493	continue;
..	..	@@ -1151,13 +1519,14 @@
1151	1519	u32 status, mask;
1152	1520	int tx_done = 0;
1153	1521
1154		- mtk_handle_status_irq(eth);
1155		- mtk_w32(eth, MTK_TX_DONE_INT, MTK_QMTK_INT_STATUS);
	1522	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
	1523	+ mtk_handle_status_irq(eth);
	1524	+ mtk_w32(eth, MTK_TX_DONE_INT, eth->tx_int_status_reg);
1156	1525	tx_done = mtk_poll_tx(eth, budget);
1157	1526
1158	1527	if (unlikely(netif_msg_intr(eth))) {
1159		- status = mtk_r32(eth, MTK_QMTK_INT_STATUS);
1160		- mask = mtk_r32(eth, MTK_QDMA_INT_MASK);
	1528	+ status = mtk_r32(eth, eth->tx_int_status_reg);
	1529	+ mask = mtk_r32(eth, eth->tx_int_mask_reg);
1161	1530	dev_info(eth->dev,
1162	1531	"done tx %d, intr 0x%08x/0x%x\n",
1163	1532	tx_done, status, mask);
..	..	@@ -1166,7 +1535,7 @@
1166	1535	if (tx_done == budget)
1167	1536	return budget;
1168	1537
1169		- status = mtk_r32(eth, MTK_QMTK_INT_STATUS);
	1538	+ status = mtk_r32(eth, eth->tx_int_status_reg);
1170	1539	if (status & MTK_TX_DONE_INT)
1171	1540	return budget;
1172	1541
..	..	@@ -1220,8 +1589,8 @@
1220	1589	if (!ring->buf)
1221	1590	goto no_tx_mem;
1222	1591
1223		- ring->dma = dma_zalloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
1224		- &ring->phys, GFP_ATOMIC);
	1592	+ ring->dma = dma_alloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
	1593	+ &ring->phys, GFP_ATOMIC);
1225	1594	if (!ring->dma)
1226	1595	goto no_tx_mem;
1227	1596
..	..	@@ -1233,6 +1602,24 @@
1233	1602	ring->dma[i].txd3 = TX_DMA_LS0 \| TX_DMA_OWNER_CPU;
1234	1603	}
1235	1604
	1605	+ /* On MT7688 (PDMA only) this driver uses the ring->dma structs
	1606	+ * only as the framework. The real HW descriptors are the PDMA
	1607	+ * descriptors in ring->dma_pdma.
	1608	+ */
	1609	+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	1610	+ ring->dma_pdma = dma_alloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
	1611	+ &ring->phys_pdma,
	1612	+ GFP_ATOMIC);
	1613	+ if (!ring->dma_pdma)
	1614	+ goto no_tx_mem;
	1615	+
	1616	+ for (i = 0; i < MTK_DMA_SIZE; i++) {
	1617	+ ring->dma_pdma[i].txd2 = TX_DMA_DESP2_DEF;
	1618	+ ring->dma_pdma[i].txd4 = 0;
	1619	+ }
	1620	+ }
	1621	+
	1622	+ ring->dma_size = MTK_DMA_SIZE;
1236	1623	atomic_set(&ring->free_count, MTK_DMA_SIZE - 2);
1237	1624	ring->next_free = &ring->dma[0];
1238	1625	ring->last_free = &ring->dma[MTK_DMA_SIZE - 1];
..	..	@@ -1243,15 +1630,23 @@
1243	1630	*/
1244	1631	wmb();
1245	1632
1246		- mtk_w32(eth, ring->phys, MTK_QTX_CTX_PTR);
1247		- mtk_w32(eth, ring->phys, MTK_QTX_DTX_PTR);
1248		- mtk_w32(eth,
1249		- ring->phys + ((MTK_DMA_SIZE - 1) * sz),
1250		- MTK_QTX_CRX_PTR);
1251		- mtk_w32(eth,
1252		- ring->phys + ((MTK_DMA_SIZE - 1) * sz),
1253		- MTK_QTX_DRX_PTR);
1254		- mtk_w32(eth, (QDMA_RES_THRES << 8) \| QDMA_RES_THRES, MTK_QTX_CFG(0));
	1633	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	1634	+ mtk_w32(eth, ring->phys, MTK_QTX_CTX_PTR);
	1635	+ mtk_w32(eth, ring->phys, MTK_QTX_DTX_PTR);
	1636	+ mtk_w32(eth,
	1637	+ ring->phys + ((MTK_DMA_SIZE - 1) * sz),
	1638	+ MTK_QTX_CRX_PTR);
	1639	+ mtk_w32(eth,
	1640	+ ring->phys + ((MTK_DMA_SIZE - 1) * sz),
	1641	+ MTK_QTX_DRX_PTR);
	1642	+ mtk_w32(eth, (QDMA_RES_THRES << 8) \| QDMA_RES_THRES,
	1643	+ MTK_QTX_CFG(0));
	1644	+ } else {
	1645	+ mtk_w32(eth, ring->phys_pdma, MT7628_TX_BASE_PTR0);
	1646	+ mtk_w32(eth, MTK_DMA_SIZE, MT7628_TX_MAX_CNT0);
	1647	+ mtk_w32(eth, 0, MT7628_TX_CTX_IDX0);
	1648	+ mtk_w32(eth, MT7628_PST_DTX_IDX0, MTK_PDMA_RST_IDX);
	1649	+ }
1255	1650
1256	1651	return 0;
1257	1652
..	..	@@ -1277,6 +1672,14 @@
1277	1672	ring->dma,
1278	1673	ring->phys);
1279	1674	ring->dma = NULL;
	1675	+ }
	1676	+
	1677	+ if (ring->dma_pdma) {
	1678	+ dma_free_coherent(eth->dev,
	1679	+ MTK_DMA_SIZE * sizeof(*ring->dma_pdma),
	1680	+ ring->dma_pdma,
	1681	+ ring->phys_pdma);
	1682	+ ring->dma_pdma = NULL;
1280	1683	}
1281	1684	}
1282	1685
..	..	@@ -1312,27 +1715,33 @@
1312	1715	return -ENOMEM;
1313	1716
1314	1717	for (i = 0; i < rx_dma_size; i++) {
1315		- ring->data[i] = netdev_alloc_frag(ring->frag_size);
	1718	+ if (ring->frag_size <= PAGE_SIZE)
	1719	+ ring->data[i] = netdev_alloc_frag(ring->frag_size);
	1720	+ else
	1721	+ ring->data[i] = mtk_max_lro_buf_alloc(GFP_KERNEL);
1316	1722	if (!ring->data[i])
1317	1723	return -ENOMEM;
1318	1724	}
1319	1725
1320		- ring->dma = dma_zalloc_coherent(eth->dev,
1321		- rx_dma_size * sizeof(*ring->dma),
1322		- &ring->phys, GFP_ATOMIC);
	1726	+ ring->dma = dma_alloc_coherent(eth->dev,
	1727	+ rx_dma_size * sizeof(*ring->dma),
	1728	+ &ring->phys, GFP_ATOMIC);
1323	1729	if (!ring->dma)
1324	1730	return -ENOMEM;
1325	1731
1326	1732	for (i = 0; i < rx_dma_size; i++) {
1327	1733	dma_addr_t dma_addr = dma_map_single(eth->dev,
1328		- ring->data[i] + NET_SKB_PAD,
	1734	+ ring->data[i] + NET_SKB_PAD + eth->ip_align,
1329	1735	ring->buf_size,
1330	1736	DMA_FROM_DEVICE);
1331	1737	if (unlikely(dma_mapping_error(eth->dev, dma_addr)))
1332	1738	return -ENOMEM;
1333	1739	ring->dma[i].rxd1 = (unsigned int)dma_addr;
1334	1740
1335		- ring->dma[i].rxd2 = RX_DMA_PLEN0(ring->buf_size);
	1741	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
	1742	+ ring->dma[i].rxd2 = RX_DMA_LSO;
	1743	+ else
	1744	+ ring->dma[i].rxd2 = RX_DMA_PLEN0(ring->buf_size);
1336	1745	}
1337	1746	ring->dma_size = rx_dma_size;
1338	1747	ring->calc_idx_update = false;
..	..	@@ -1575,6 +1984,9 @@
1575	1984	struct ethtool_rx_flow_spec *fsp =
1576	1985	(struct ethtool_rx_flow_spec *)&cmd->fs;
1577	1986
	1987	+ if (fsp->location >= ARRAY_SIZE(mac->hwlro_ip))
	1988	+ return -EINVAL;
	1989	+
1578	1990	/* only tcp dst ipv4 is meaningful, others are meaningless */
1579	1991	fsp->flow_type = TCP_V4_FLOW;
1580	1992	fsp->h_u.tcp_ip4_spec.ip4dst = ntohl(mac->hwlro_ip[fsp->location]);
..	..	@@ -1601,6 +2013,9 @@
1601	2013	int i;
1602	2014
1603	2015	for (i = 0; i < MTK_MAX_LRO_IP_CNT; i++) {
	2016	+ if (cnt == cmd->rule_cnt)
	2017	+ return -EMSGSIZE;
	2018	+
1604	2019	if (mac->hwlro_ip[i]) {
1605	2020	rule_locs[cnt] = i;
1606	2021	cnt++;
..	..	@@ -1648,9 +2063,16 @@
1648	2063	unsigned long t_start = jiffies;
1649	2064
1650	2065	while (1) {
1651		- if (!(mtk_r32(eth, MTK_QDMA_GLO_CFG) &
1652		- (MTK_RX_DMA_BUSY \| MTK_TX_DMA_BUSY)))
1653		- return 0;
	2066	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	2067	+ if (!(mtk_r32(eth, MTK_QDMA_GLO_CFG) &
	2068	+ (MTK_RX_DMA_BUSY \| MTK_TX_DMA_BUSY)))
	2069	+ return 0;
	2070	+ } else {
	2071	+ if (!(mtk_r32(eth, MTK_PDMA_GLO_CFG) &
	2072	+ (MTK_RX_DMA_BUSY \| MTK_TX_DMA_BUSY)))
	2073	+ return 0;
	2074	+ }
	2075	+
1654	2076	if (time_after(jiffies, t_start + MTK_DMA_BUSY_TIMEOUT))
1655	2077	break;
1656	2078	}
..	..	@@ -1667,20 +2089,24 @@
1667	2089	if (mtk_dma_busy_wait(eth))
1668	2090	return -EBUSY;
1669	2091
1670		- /* QDMA needs scratch memory for internal reordering of the
1671		- * descriptors
1672		- */
1673		- err = mtk_init_fq_dma(eth);
1674		- if (err)
1675		- return err;
	2092	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	2093	+ /* QDMA needs scratch memory for internal reordering of the
	2094	+ * descriptors
	2095	+ */
	2096	+ err = mtk_init_fq_dma(eth);
	2097	+ if (err)
	2098	+ return err;
	2099	+ }
1676	2100
1677	2101	err = mtk_tx_alloc(eth);
1678	2102	if (err)
1679	2103	return err;
1680	2104
1681		- err = mtk_rx_alloc(eth, 0, MTK_RX_FLAGS_QDMA);
1682		- if (err)
1683		- return err;
	2105	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	2106	+ err = mtk_rx_alloc(eth, 0, MTK_RX_FLAGS_QDMA);
	2107	+ if (err)
	2108	+ return err;
	2109	+ }
1684	2110
1685	2111	err = mtk_rx_alloc(eth, 0, MTK_RX_FLAGS_NORMAL);
1686	2112	if (err)
..	..	@@ -1697,10 +2123,14 @@
1697	2123	return err;
1698	2124	}
1699	2125
1700		- /* Enable random early drop and set drop threshold automatically */
1701		- mtk_w32(eth, FC_THRES_DROP_MODE \| FC_THRES_DROP_EN \| FC_THRES_MIN,
1702		- MTK_QDMA_FC_THRES);
1703		- mtk_w32(eth, 0x0, MTK_QDMA_HRED2);
	2126	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	2127	+ /* Enable random early drop and set drop threshold
	2128	+ * automatically
	2129	+ */
	2130	+ mtk_w32(eth, FC_THRES_DROP_MODE \| FC_THRES_DROP_EN \|
	2131	+ FC_THRES_MIN, MTK_QDMA_FC_THRES);
	2132	+ mtk_w32(eth, 0x0, MTK_QDMA_HRED2);
	2133	+ }
1704	2134
1705	2135	return 0;
1706	2136	}
..	..	@@ -1733,7 +2163,7 @@
1733	2163	kfree(eth->scratch_head);
1734	2164	}
1735	2165
1736		-static void mtk_tx_timeout(struct net_device *dev)
	2166	+static void mtk_tx_timeout(struct net_device *dev, unsigned int txqueue)
1737	2167	{
1738	2168	struct mtk_mac *mac = netdev_priv(dev);
1739	2169	struct mtk_eth *eth = mac->hw;
..	..	@@ -1768,6 +2198,22 @@
1768	2198	return IRQ_HANDLED;
1769	2199	}
1770	2200
	2201	+static irqreturn_t mtk_handle_irq(int irq, void *_eth)
	2202	+{
	2203	+ struct mtk_eth *eth = _eth;
	2204	+
	2205	+ if (mtk_r32(eth, MTK_PDMA_INT_MASK) & MTK_RX_DONE_INT) {
	2206	+ if (mtk_r32(eth, MTK_PDMA_INT_STATUS) & MTK_RX_DONE_INT)
	2207	+ mtk_handle_irq_rx(irq, _eth);
	2208	+ }
	2209	+ if (mtk_r32(eth, eth->tx_int_mask_reg) & MTK_TX_DONE_INT) {
	2210	+ if (mtk_r32(eth, eth->tx_int_status_reg) & MTK_TX_DONE_INT)
	2211	+ mtk_handle_irq_tx(irq, _eth);
	2212	+ }
	2213	+
	2214	+ return IRQ_HANDLED;
	2215	+}
	2216	+
1771	2217	#ifdef CONFIG_NET_POLL_CONTROLLER
1772	2218	static void mtk_poll_controller(struct net_device *dev)
1773	2219	{
..	..	@@ -1793,32 +2239,76 @@
1793	2239	return err;
1794	2240	}
1795	2241
1796		- mtk_w32(eth,
1797		- MTK_TX_WB_DDONE \| MTK_TX_DMA_EN \|
1798		- MTK_DMA_SIZE_16DWORDS \| MTK_NDP_CO_PRO \|
1799		- MTK_RX_DMA_EN \| MTK_RX_2B_OFFSET \|
1800		- MTK_RX_BT_32DWORDS,
1801		- MTK_QDMA_GLO_CFG);
	2242	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	2243	+ mtk_w32(eth,
	2244	+ MTK_TX_WB_DDONE \| MTK_TX_DMA_EN \|
	2245	+ MTK_DMA_SIZE_16DWORDS \| MTK_NDP_CO_PRO \|
	2246	+ MTK_RX_DMA_EN \| MTK_RX_2B_OFFSET \|
	2247	+ MTK_RX_BT_32DWORDS,
	2248	+ MTK_QDMA_GLO_CFG);
1802	2249
1803		- mtk_w32(eth,
1804		- MTK_RX_DMA_EN \| rx_2b_offset \|
1805		- MTK_RX_BT_32DWORDS \| MTK_MULTI_EN,
1806		- MTK_PDMA_GLO_CFG);
	2250	+ mtk_w32(eth,
	2251	+ MTK_RX_DMA_EN \| rx_2b_offset \|
	2252	+ MTK_RX_BT_32DWORDS \| MTK_MULTI_EN,
	2253	+ MTK_PDMA_GLO_CFG);
	2254	+ } else {
	2255	+ mtk_w32(eth, MTK_TX_WB_DDONE \| MTK_TX_DMA_EN \| MTK_RX_DMA_EN \|
	2256	+ MTK_MULTI_EN \| MTK_PDMA_SIZE_8DWORDS,
	2257	+ MTK_PDMA_GLO_CFG);
	2258	+ }
1807	2259
1808	2260	return 0;
	2261	+}
	2262	+
	2263	+static void mtk_gdm_config(struct mtk_eth *eth, u32 config)
	2264	+{
	2265	+ int i;
	2266	+
	2267	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
	2268	+ return;
	2269	+
	2270	+ for (i = 0; i < MTK_MAC_COUNT; i++) {
	2271	+ u32 val = mtk_r32(eth, MTK_GDMA_FWD_CFG(i));
	2272	+
	2273	+ /* default setup the forward port to send frame to PDMA */
	2274	+ val &= ~0xffff;
	2275	+
	2276	+ /* Enable RX checksum */
	2277	+ val \|= MTK_GDMA_ICS_EN \| MTK_GDMA_TCS_EN \| MTK_GDMA_UCS_EN;
	2278	+
	2279	+ val \|= config;
	2280	+
	2281	+ mtk_w32(eth, val, MTK_GDMA_FWD_CFG(i));
	2282	+ }
	2283	+ /* Reset and enable PSE */
	2284	+ mtk_w32(eth, RST_GL_PSE, MTK_RST_GL);
	2285	+ mtk_w32(eth, 0, MTK_RST_GL);
1809	2286	}
1810	2287
1811	2288	static int mtk_open(struct net_device *dev)
1812	2289	{
1813	2290	struct mtk_mac *mac = netdev_priv(dev);
1814	2291	struct mtk_eth *eth = mac->hw;
	2292	+ int err;
	2293	+
	2294	+ err = phylink_of_phy_connect(mac->phylink, mac->of_node, 0);
	2295	+ if (err) {
	2296	+ netdev_err(dev, "%s: could not attach PHY: %d\n", __func__,
	2297	+ err);
	2298	+ return err;
	2299	+ }
1815	2300
1816	2301	/* we run 2 netdevs on the same dma ring so we only bring it up once */
1817	2302	if (!refcount_read(&eth->dma_refcnt)) {
1818	2303	int err = mtk_start_dma(eth);
1819	2304
1820	2305	if (err)
	2306	+ if (err) {
	2307	+ phylink_disconnect_phy(mac->phylink);
1821	2308	return err;
	2309	+ }
	2310	+
	2311	+ mtk_gdm_config(eth, MTK_GDMA_TO_PDMA);
1822	2312
1823	2313	napi_enable(&eth->tx_napi);
1824	2314	napi_enable(&eth->rx_napi);
..	..	@@ -1829,9 +2319,8 @@
1829	2319	else
1830	2320	refcount_inc(&eth->dma_refcnt);
1831	2321
1832		- phy_start(dev->phydev);
	2322	+ phylink_start(mac->phylink);
1833	2323	netif_start_queue(dev);
1834		-
1835	2324	return 0;
1836	2325	}
1837	2326
..	..	@@ -1863,19 +2352,25 @@
1863	2352	struct mtk_mac *mac = netdev_priv(dev);
1864	2353	struct mtk_eth *eth = mac->hw;
1865	2354
	2355	+ phylink_stop(mac->phylink);
	2356	+
1866	2357	netif_tx_disable(dev);
1867		- phy_stop(dev->phydev);
	2358	+
	2359	+ phylink_disconnect_phy(mac->phylink);
1868	2360
1869	2361	/* only shutdown DMA if this is the last user */
1870	2362	if (!refcount_dec_and_test(&eth->dma_refcnt))
1871	2363	return 0;
	2364	+
	2365	+ mtk_gdm_config(eth, MTK_GDMA_DROP_ALL);
1872	2366
1873	2367	mtk_tx_irq_disable(eth, MTK_TX_DONE_INT);
1874	2368	mtk_rx_irq_disable(eth, MTK_RX_DONE_INT);
1875	2369	napi_disable(&eth->tx_napi);
1876	2370	napi_disable(&eth->rx_napi);
1877	2371
1878		- mtk_stop_dma(eth, MTK_QDMA_GLO_CFG);
	2372	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
	2373	+ mtk_stop_dma(eth, MTK_QDMA_GLO_CFG);
1879	2374	mtk_stop_dma(eth, MTK_PDMA_GLO_CFG);
1880	2375
1881	2376	mtk_dma_free(eth);
..	..	@@ -1937,17 +2432,26 @@
1937	2432	if (ret)
1938	2433	goto err_disable_pm;
1939	2434
	2435	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	2436	+ ret = device_reset(eth->dev);
	2437	+ if (ret) {
	2438	+ dev_err(eth->dev, "MAC reset failed!\n");
	2439	+ goto err_disable_pm;
	2440	+ }
	2441	+
	2442	+ /* enable interrupt delay for RX */
	2443	+ mtk_w32(eth, MTK_PDMA_DELAY_RX_DELAY, MTK_PDMA_DELAY_INT);
	2444	+
	2445	+ /* disable delay and normal interrupt */
	2446	+ mtk_tx_irq_disable(eth, ~0);
	2447	+ mtk_rx_irq_disable(eth, ~0);
	2448	+
	2449	+ return 0;
	2450	+ }
	2451	+
	2452	+ /* Non-MT7628 handling... */
1940	2453	ethsys_reset(eth, RSTCTRL_FE);
1941	2454	ethsys_reset(eth, RSTCTRL_PPE);
1942		-
1943		- regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val);
1944		- for (i = 0; i < MTK_MAC_COUNT; i++) {
1945		- if (!eth->mac[i])
1946		- continue;
1947		- val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, eth->mac[i]->id);
1948		- val \|= SYSCFG0_GE_MODE(eth->mac[i]->ge_mode, eth->mac[i]->id);
1949		- }
1950		- regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val);
1951	2455
1952	2456	if (eth->pctl) {
1953	2457	/* Set GE2 driving and slew rate */
..	..	@@ -1961,11 +2465,11 @@
1961	2465	}
1962	2466
1963	2467	/* Set linkdown as the default for each GMAC. Its own MCR would be set
1964		- * up with the more appropriate value when mtk_phy_link_adjust call is
1965		- * being invoked.
	2468	+ * up with the more appropriate value when mtk_mac_config call is being
	2469	+ * invoked.
1966	2470	*/
1967	2471	for (i = 0; i < MTK_MAC_COUNT; i++)
1968		- mtk_w32(eth, 0, MTK_MAC_MCR(i));
	2472	+ mtk_w32(eth, MAC_MCR_FORCE_LINK_DOWN, MTK_MAC_MCR(i));
1969	2473
1970	2474	/* Indicates CDM to parse the MTK special tag from CPU
1971	2475	* which also is working out for untag packets.
..	..	@@ -1983,8 +2487,6 @@
1983	2487	mtk_w32(eth, 0, MTK_QDMA_DELAY_INT);
1984	2488	mtk_tx_irq_disable(eth, ~0);
1985	2489	mtk_rx_irq_disable(eth, ~0);
1986		- mtk_w32(eth, RST_GL_PSE, MTK_RST_GL);
1987		- mtk_w32(eth, 0, MTK_RST_GL);
1988	2490
1989	2491	/* FE int grouping */
1990	2492	mtk_w32(eth, MTK_TX_DONE_INT, MTK_PDMA_INT_GRP1);
..	..	@@ -1992,19 +2494,6 @@
1992	2494	mtk_w32(eth, MTK_TX_DONE_INT, MTK_QDMA_INT_GRP1);
1993	2495	mtk_w32(eth, MTK_RX_DONE_INT, MTK_QDMA_INT_GRP2);
1994	2496	mtk_w32(eth, 0x21021000, MTK_FE_INT_GRP);
1995		-
1996		- for (i = 0; i < 2; i++) {
1997		- u32 val = mtk_r32(eth, MTK_GDMA_FWD_CFG(i));
1998		-
1999		- /* setup the forward port to send frame to PDMA */
2000		- val &= ~0xffff;
2001		-
2002		- /* Enable RX checksum */
2003		- val \|= MTK_GDMA_ICS_EN \| MTK_GDMA_TCS_EN \| MTK_GDMA_UCS_EN;
2004		-
2005		- /* setup the mac dma */
2006		- mtk_w32(eth, val, MTK_GDMA_FWD_CFG(i));
2007		- }
2008	2497
2009	2498	return 0;
2010	2499
..	..	@@ -2035,7 +2524,7 @@
2035	2524	const char *mac_addr;
2036	2525
2037	2526	mac_addr = of_get_mac_address(mac->of_node);
2038		- if (mac_addr)
	2527	+ if (!IS_ERR(mac_addr))
2039	2528	ether_addr_copy(dev->dev_addr, mac_addr);
2040	2529
2041	2530	/* If the mac address is invalid, use random mac address */
..	..	@@ -2045,7 +2534,7 @@
2045	2534	dev->dev_addr);
2046	2535	}
2047	2536
2048		- return mtk_phy_connect(dev);
	2537	+ return 0;
2049	2538	}
2050	2539
2051	2540	static void mtk_uninit(struct net_device *dev)
..	..	@@ -2053,20 +2542,20 @@
2053	2542	struct mtk_mac *mac = netdev_priv(dev);
2054	2543	struct mtk_eth *eth = mac->hw;
2055	2544
2056		- phy_disconnect(dev->phydev);
2057		- if (of_phy_is_fixed_link(mac->of_node))
2058		- of_phy_deregister_fixed_link(mac->of_node);
	2545	+ phylink_disconnect_phy(mac->phylink);
2059	2546	mtk_tx_irq_disable(eth, ~0);
2060	2547	mtk_rx_irq_disable(eth, ~0);
2061	2548	}
2062	2549
2063	2550	static int mtk_do_ioctl(struct net_device dev, struct ifreq ifr, int cmd)
2064	2551	{
	2552	+ struct mtk_mac *mac = netdev_priv(dev);
	2553	+
2065	2554	switch (cmd) {
2066	2555	case SIOCGMIIPHY:
2067	2556	case SIOCGMIIREG:
2068	2557	case SIOCSMIIREG:
2069		- return phy_mii_ioctl(dev->phydev, ifr, cmd);
	2558	+ return phylink_mii_ioctl(mac->phylink, ifr, cmd);
2070	2559	default:
2071	2560	break;
2072	2561	}
..	..	@@ -2106,16 +2595,6 @@
2106	2595	pinctrl_select_state(eth->dev->pins->p,
2107	2596	eth->dev->pins->default_state);
2108	2597	mtk_hw_init(eth);
2109		-
2110		- for (i = 0; i < MTK_MAC_COUNT; i++) {
2111		- if (!eth->mac[i] \|\|
2112		- of_phy_is_fixed_link(eth->mac[i]->of_node))
2113		- continue;
2114		- err = phy_init_hw(eth->netdev[i]->phydev);
2115		- if (err)
2116		- dev_err(eth->dev, "%s: PHY init failed.\n",
2117		- eth->netdev[i]->name);
2118		- }
2119	2598
2120	2599	/* restart DMA and enable IRQs */
2121	2600	for (i = 0; i < MTK_MAC_COUNT; i++) {
..	..	@@ -2179,9 +2658,7 @@
2179	2658	if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
2180	2659	return -EBUSY;
2181	2660
2182		- phy_ethtool_ksettings_get(ndev->phydev, cmd);
2183		-
2184		- return 0;
	2661	+ return phylink_ethtool_ksettings_get(mac->phylink, cmd);
2185	2662	}
2186	2663
2187	2664	static int mtk_set_link_ksettings(struct net_device *ndev,
..	..	@@ -2192,7 +2669,7 @@
2192	2669	if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
2193	2670	return -EBUSY;
2194	2671
2195		- return phy_ethtool_ksettings_set(ndev->phydev, cmd);
	2672	+ return phylink_ethtool_ksettings_set(mac->phylink, cmd);
2196	2673	}
2197	2674
2198	2675	static void mtk_get_drvinfo(struct net_device *dev,
..	..	@@ -2226,22 +2703,10 @@
2226	2703	if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
2227	2704	return -EBUSY;
2228	2705
2229		- return genphy_restart_aneg(dev->phydev);
2230		-}
	2706	+ if (!mac->phylink)
	2707	+ return -ENOTSUPP;
2231	2708
2232		-static u32 mtk_get_link(struct net_device *dev)
2233		-{
2234		- struct mtk_mac *mac = netdev_priv(dev);
2235		- int err;
2236		-
2237		- if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
2238		- return -EBUSY;
2239		-
2240		- err = genphy_update_link(dev->phydev);
2241		- if (err)
2242		- return ethtool_op_get_link(dev);
2243		-
2244		- return dev->phydev->link;
	2709	+ return phylink_ethtool_nway_reset(mac->phylink);
2245	2710	}
2246	2711
2247	2712	static void mtk_get_strings(struct net_device dev, u32 stringset, u8 data)
..	..	@@ -2361,7 +2826,7 @@
2361	2826	.get_msglevel = mtk_get_msglevel,
2362	2827	.set_msglevel = mtk_set_msglevel,
2363	2828	.nway_reset = mtk_nway_reset,
2364		- .get_link = mtk_get_link,
	2829	+ .get_link = ethtool_op_get_link,
2365	2830	.get_strings = mtk_get_strings,
2366	2831	.get_sset_count = mtk_get_sset_count,
2367	2832	.get_ethtool_stats = mtk_get_ethtool_stats,
..	..	@@ -2389,8 +2854,10 @@
2389	2854
2390	2855	static int mtk_add_mac(struct mtk_eth eth, struct device_node np)
2391	2856	{
2392		- struct mtk_mac *mac;
2393	2857	const __be32 *_id = of_get_property(np, "reg", NULL);
	2858	+ phy_interface_t phy_mode;
	2859	+ struct phylink *phylink;
	2860	+ struct mtk_mac *mac;
2394	2861	int id, err;
2395	2862
2396	2863	if (!_id) {
..	..	@@ -2435,18 +2902,43 @@
2435	2902	u64_stats_init(&mac->hw_stats->syncp);
2436	2903	mac->hw_stats->reg_offset = id * MTK_STAT_OFFSET;
2437	2904
	2905	+ /* phylink create */
	2906	+ err = of_get_phy_mode(np, &phy_mode);
	2907	+ if (err) {
	2908	+ dev_err(eth->dev, "incorrect phy-mode\n");
	2909	+ goto free_netdev;
	2910	+ }
	2911	+
	2912	+ /* mac config is not set */
	2913	+ mac->interface = PHY_INTERFACE_MODE_NA;
	2914	+ mac->mode = MLO_AN_PHY;
	2915	+ mac->speed = SPEED_UNKNOWN;
	2916	+
	2917	+ mac->phylink_config.dev = &eth->netdev[id]->dev;
	2918	+ mac->phylink_config.type = PHYLINK_NETDEV;
	2919	+
	2920	+ phylink = phylink_create(&mac->phylink_config,
	2921	+ of_fwnode_handle(mac->of_node),
	2922	+ phy_mode, &mtk_phylink_ops);
	2923	+ if (IS_ERR(phylink)) {
	2924	+ err = PTR_ERR(phylink);
	2925	+ goto free_netdev;
	2926	+ }
	2927	+
	2928	+ mac->phylink = phylink;
	2929	+
2438	2930	SET_NETDEV_DEV(eth->netdev[id], eth->dev);
2439	2931	eth->netdev[id]->watchdog_timeo = 5 * HZ;
2440	2932	eth->netdev[id]->netdev_ops = &mtk_netdev_ops;
2441	2933	eth->netdev[id]->base_addr = (unsigned long)eth->base;
2442	2934
2443		- eth->netdev[id]->hw_features = MTK_HW_FEATURES;
	2935	+ eth->netdev[id]->hw_features = eth->soc->hw_features;
2444	2936	if (eth->hwlro)
2445	2937	eth->netdev[id]->hw_features \|= NETIF_F_LRO;
2446	2938
2447		- eth->netdev[id]->vlan_features = MTK_HW_FEATURES &
	2939	+ eth->netdev[id]->vlan_features = eth->soc->hw_features &
2448	2940	~(NETIF_F_HW_VLAN_CTAG_TX \| NETIF_F_HW_VLAN_CTAG_RX);
2449		- eth->netdev[id]->features \|= MTK_HW_FEATURES;
	2941	+ eth->netdev[id]->features \|= eth->soc->hw_features;
2450	2942	eth->netdev[id]->ethtool_ops = &mtk_ethtool_ops;
2451	2943
2452	2944	eth->netdev[id]->irq = eth->irq[0];
..	..	@@ -2463,11 +2955,9 @@
2463	2955
2464	2956	static int mtk_probe(struct platform_device *pdev)
2465	2957	{
2466		- struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2467	2958	struct device_node *mac_np;
2468	2959	struct mtk_eth *eth;
2469		- int err;
2470		- int i;
	2960	+ int err, i;
2471	2961
2472	2962	eth = devm_kzalloc(&pdev->dev, sizeof(*eth), GFP_KERNEL);
2473	2963	if (!eth)
..	..	@@ -2476,29 +2966,58 @@
2476	2966	eth->soc = of_device_get_match_data(&pdev->dev);
2477	2967
2478	2968	eth->dev = &pdev->dev;
2479		- eth->base = devm_ioremap_resource(&pdev->dev, res);
	2969	+ eth->base = devm_platform_ioremap_resource(pdev, 0);
2480	2970	if (IS_ERR(eth->base))
2481	2971	return PTR_ERR(eth->base);
	2972	+
	2973	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
	2974	+ eth->tx_int_mask_reg = MTK_QDMA_INT_MASK;
	2975	+ eth->tx_int_status_reg = MTK_QDMA_INT_STATUS;
	2976	+ } else {
	2977	+ eth->tx_int_mask_reg = MTK_PDMA_INT_MASK;
	2978	+ eth->tx_int_status_reg = MTK_PDMA_INT_STATUS;
	2979	+ }
	2980	+
	2981	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	2982	+ eth->rx_dma_l4_valid = RX_DMA_L4_VALID_PDMA;
	2983	+ eth->ip_align = NET_IP_ALIGN;
	2984	+ } else {
	2985	+ eth->rx_dma_l4_valid = RX_DMA_L4_VALID;
	2986	+ }
2482	2987
2483	2988	spin_lock_init(&eth->page_lock);
2484	2989	spin_lock_init(&eth->tx_irq_lock);
2485	2990	spin_lock_init(&eth->rx_irq_lock);
2486	2991
2487		- eth->ethsys = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
2488		- "mediatek,ethsys");
2489		- if (IS_ERR(eth->ethsys)) {
2490		- dev_err(&pdev->dev, "no ethsys regmap found\n");
2491		- return PTR_ERR(eth->ethsys);
	2992	+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	2993	+ eth->ethsys = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
	2994	+ "mediatek,ethsys");
	2995	+ if (IS_ERR(eth->ethsys)) {
	2996	+ dev_err(&pdev->dev, "no ethsys regmap found\n");
	2997	+ return PTR_ERR(eth->ethsys);
	2998	+ }
	2999	+ }
	3000	+
	3001	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_INFRA)) {
	3002	+ eth->infra = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
	3003	+ "mediatek,infracfg");
	3004	+ if (IS_ERR(eth->infra)) {
	3005	+ dev_err(&pdev->dev, "no infracfg regmap found\n");
	3006	+ return PTR_ERR(eth->infra);
	3007	+ }
2492	3008	}
2493	3009
2494	3010	if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII)) {
2495		- eth->sgmiisys =
2496		- syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
2497		- "mediatek,sgmiisys");
2498		- if (IS_ERR(eth->sgmiisys)) {
2499		- dev_err(&pdev->dev, "no sgmiisys regmap found\n");
2500		- return PTR_ERR(eth->sgmiisys);
2501		- }
	3011	+ eth->sgmii = devm_kzalloc(eth->dev, sizeof(*eth->sgmii),
	3012	+ GFP_KERNEL);
	3013	+ if (!eth->sgmii)
	3014	+ return -ENOMEM;
	3015	+
	3016	+ err = mtk_sgmii_init(eth->sgmii, pdev->dev.of_node,
	3017	+ eth->soc->ana_rgc3);
	3018	+
	3019	+ if (err)
	3020	+ return err;
2502	3021	}
2503	3022
2504	3023	if (eth->soc->required_pctl) {
..	..	@@ -2511,7 +3030,10 @@
2511	3030	}
2512	3031
2513	3032	for (i = 0; i < 3; i++) {
2514		- eth->irq[i] = platform_get_irq(pdev, i);
	3033	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_INT) && i > 0)
	3034	+ eth->irq[i] = eth->irq[0];
	3035	+ else
	3036	+ eth->irq[i] = platform_get_irq(pdev, i);
2515	3037	if (eth->irq[i] < 0) {
2516	3038	dev_err(&pdev->dev, "no IRQ%d resource found\n", i);
2517	3039	return -ENXIO;
..	..	@@ -2550,23 +3072,36 @@
2550	3072	continue;
2551	3073
2552	3074	err = mtk_add_mac(eth, mac_np);
2553		- if (err)
	3075	+ if (err) {
	3076	+ of_node_put(mac_np);
2554	3077	goto err_deinit_hw;
	3078	+ }
2555	3079	}
2556	3080
2557		- err = devm_request_irq(eth->dev, eth->irq[1], mtk_handle_irq_tx, 0,
2558		- dev_name(eth->dev), eth);
	3081	+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_INT)) {
	3082	+ err = devm_request_irq(eth->dev, eth->irq[0],
	3083	+ mtk_handle_irq, 0,
	3084	+ dev_name(eth->dev), eth);
	3085	+ } else {
	3086	+ err = devm_request_irq(eth->dev, eth->irq[1],
	3087	+ mtk_handle_irq_tx, 0,
	3088	+ dev_name(eth->dev), eth);
	3089	+ if (err)
	3090	+ goto err_free_dev;
	3091	+
	3092	+ err = devm_request_irq(eth->dev, eth->irq[2],
	3093	+ mtk_handle_irq_rx, 0,
	3094	+ dev_name(eth->dev), eth);
	3095	+ }
2559	3096	if (err)
2560	3097	goto err_free_dev;
2561	3098
2562		- err = devm_request_irq(eth->dev, eth->irq[2], mtk_handle_irq_rx, 0,
2563		- dev_name(eth->dev), eth);
2564		- if (err)
2565		- goto err_free_dev;
2566		-
2567		- err = mtk_mdio_init(eth);
2568		- if (err)
2569		- goto err_free_dev;
	3099	+ /* No MT7628/88 support yet */
	3100	+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
	3101	+ err = mtk_mdio_init(eth);
	3102	+ if (err)
	3103	+ goto err_free_dev;
	3104	+ }
2570	3105
2571	3106	for (i = 0; i < MTK_MAX_DEVS; i++) {
2572	3107	if (!eth->netdev[i])
..	..	@@ -2608,6 +3143,7 @@
2608	3143	static int mtk_remove(struct platform_device *pdev)
2609	3144	{
2610	3145	struct mtk_eth *eth = platform_get_drvdata(pdev);
	3146	+ struct mtk_mac *mac;
2611	3147	int i;
2612	3148
2613	3149	/* stop all devices to make sure that dma is properly shut down */
..	..	@@ -2615,6 +3151,8 @@
2615	3151	if (!eth->netdev[i])
2616	3152	continue;
2617	3153	mtk_stop(eth->netdev[i]);
	3154	+ mac = netdev_priv(eth->netdev[i]);
	3155	+ phylink_disconnect_phy(mac->phylink);
2618	3156	}
2619	3157
2620	3158	mtk_hw_deinit(eth);
..	..	@@ -2628,27 +3166,56 @@
2628	3166	}
2629	3167
2630	3168	static const struct mtk_soc_data mt2701_data = {
2631		- .caps = MTK_GMAC1_TRGMII \| MTK_HWLRO,
	3169	+ .caps = MT7623_CAPS \| MTK_HWLRO,
	3170	+ .hw_features = MTK_HW_FEATURES,
2632	3171	.required_clks = MT7623_CLKS_BITMAP,
2633	3172	.required_pctl = true,
2634	3173	};
2635	3174
	3175	+static const struct mtk_soc_data mt7621_data = {
	3176	+ .caps = MT7621_CAPS,
	3177	+ .hw_features = MTK_HW_FEATURES,
	3178	+ .required_clks = MT7621_CLKS_BITMAP,
	3179	+ .required_pctl = false,
	3180	+};
	3181	+
2636	3182	static const struct mtk_soc_data mt7622_data = {
2637		- .caps = MTK_DUAL_GMAC_SHARED_SGMII \| MTK_GMAC1_ESW \| MTK_HWLRO,
	3183	+ .ana_rgc3 = 0x2028,
	3184	+ .caps = MT7622_CAPS \| MTK_HWLRO,
	3185	+ .hw_features = MTK_HW_FEATURES,
2638	3186	.required_clks = MT7622_CLKS_BITMAP,
2639	3187	.required_pctl = false,
2640	3188	};
2641	3189
2642	3190	static const struct mtk_soc_data mt7623_data = {
2643		- .caps = MTK_GMAC1_TRGMII \| MTK_HWLRO,
	3191	+ .caps = MT7623_CAPS \| MTK_HWLRO,
	3192	+ .hw_features = MTK_HW_FEATURES,
2644	3193	.required_clks = MT7623_CLKS_BITMAP,
2645	3194	.required_pctl = true,
2646	3195	};
2647	3196
	3197	+static const struct mtk_soc_data mt7629_data = {
	3198	+ .ana_rgc3 = 0x128,
	3199	+ .caps = MT7629_CAPS \| MTK_HWLRO,
	3200	+ .hw_features = MTK_HW_FEATURES,
	3201	+ .required_clks = MT7629_CLKS_BITMAP,
	3202	+ .required_pctl = false,
	3203	+};
	3204	+
	3205	+static const struct mtk_soc_data rt5350_data = {
	3206	+ .caps = MT7628_CAPS,
	3207	+ .hw_features = MTK_HW_FEATURES_MT7628,
	3208	+ .required_clks = MT7628_CLKS_BITMAP,
	3209	+ .required_pctl = false,
	3210	+};
	3211	+
2648	3212	const struct of_device_id of_mtk_match[] = {
2649	3213	{ .compatible = "mediatek,mt2701-eth", .data = &mt2701_data},
	3214	+ { .compatible = "mediatek,mt7621-eth", .data = &mt7621_data},
2650	3215	{ .compatible = "mediatek,mt7622-eth", .data = &mt7622_data},
2651	3216	{ .compatible = "mediatek,mt7623-eth", .data = &mt7623_data},
	3217	+ { .compatible = "mediatek,mt7629-eth", .data = &mt7629_data},
	3218	+ { .compatible = "ralink,rt5350-eth", .data = &rt5350_data},
2652	3219	{},
2653	3220	};
2654	3221	MODULE_DEVICE_TABLE(of, of_mtk_match);