1// SPDX-License-Identifier: (GPL-2.0 OR MIT)
2/*
3 * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates.
4 * stmmac HW Interface Handling
5 */
6
7#include "common.h"
8#include "stmmac.h"
9#include "stmmac_ptp.h"
10
11static u32 stmmac_get_id(struct stmmac_priv *priv, u32 id_reg)
12{
13	u32 reg = readl(priv->ioaddr + id_reg);
14
15	if (!reg) {
16		dev_info(priv->device, "Version ID not available\n");
17		return 0x0;
18	}
19
20	dev_info(priv->device, "User ID: 0x%x, Synopsys ID: 0x%x\n",
21			(unsigned int)(reg & GENMASK(15, 8)) >> 8,
22			(unsigned int)(reg & GENMASK(7, 0)));
23	return reg & GENMASK(7, 0);
24}
25
26static u32 stmmac_get_dev_id(struct stmmac_priv *priv, u32 id_reg)
27{
28	u32 reg = readl(priv->ioaddr + id_reg);
29
30	if (!reg) {
31		dev_info(priv->device, "Version ID not available\n");
32		return 0x0;
33	}
34
35	return (reg & GENMASK(15, 8)) >> 8;
36}
37
38static void stmmac_dwmac_mode_quirk(struct stmmac_priv *priv)
39{
40	struct mac_device_info *mac = priv->hw;
41
42	if (priv->chain_mode) {
43		dev_info(priv->device, "Chain mode enabled\n");
44		priv->mode = STMMAC_CHAIN_MODE;
45		mac->mode = &chain_mode_ops;
46	} else {
47		dev_info(priv->device, "Ring mode enabled\n");
48		priv->mode = STMMAC_RING_MODE;
49		mac->mode = &ring_mode_ops;
50	}
51}
52
53static int stmmac_dwmac1_quirks(struct stmmac_priv *priv)
54{
55	struct mac_device_info *mac = priv->hw;
56
57	if (priv->plat->enh_desc) {
58		dev_info(priv->device, "Enhanced/Alternate descriptors\n");
59
60		/* GMAC older than 3.50 has no extended descriptors */
61		if (priv->synopsys_id >= DWMAC_CORE_3_50) {
62			dev_info(priv->device, "Enabled extended descriptors\n");
63			priv->extend_desc = 1;
64		} else {
65			dev_warn(priv->device, "Extended descriptors not supported\n");
66		}
67
68		mac->desc = &enh_desc_ops;
69	} else {
70		dev_info(priv->device, "Normal descriptors\n");
71		mac->desc = &ndesc_ops;
72	}
73
74	stmmac_dwmac_mode_quirk(priv);
75	return 0;
76}
77
78static int stmmac_dwmac4_quirks(struct stmmac_priv *priv)
79{
80	stmmac_dwmac_mode_quirk(priv);
81	return 0;
82}
83
84static int stmmac_dwxlgmac_quirks(struct stmmac_priv *priv)
85{
86	priv->hw->xlgmac = true;
87	return 0;
88}
89
90int stmmac_reset(struct stmmac_priv *priv, void __iomem *ioaddr)
91{
92	struct plat_stmmacenet_data *plat = priv ? priv->plat : NULL;
93
94	if (!priv)
95		return -EINVAL;
96
97	if (plat && plat->fix_soc_reset)
98		return plat->fix_soc_reset(plat, ioaddr);
99
100	return stmmac_do_callback(priv, dma, reset, ioaddr);
101}
102
103static const struct stmmac_hwif_entry {
104	bool gmac;
105	bool gmac4;
106	bool xgmac;
107	u32 min_id;
108	u32 dev_id;
109	const struct stmmac_regs_off regs;
110	const void *desc;
111	const void *dma;
112	const void *mac;
113	const void *hwtimestamp;
114	const void *mode;
115	const void *tc;
116	const void *mmc;
117	int (*setup)(struct stmmac_priv *priv);
118	int (*quirks)(struct stmmac_priv *priv);
119} stmmac_hw[] = {
120	/* NOTE: New HW versions shall go to the end of this table */
121	{
122		.gmac = false,
123		.gmac4 = false,
124		.xgmac = false,
125		.min_id = 0,
126		.regs = {
127			.ptp_off = PTP_GMAC3_X_OFFSET,
128			.mmc_off = MMC_GMAC3_X_OFFSET,
129		},
130		.desc = NULL,
131		.dma = &dwmac100_dma_ops,
132		.mac = &dwmac100_ops,
133		.hwtimestamp = &stmmac_ptp,
134		.mode = NULL,
135		.tc = NULL,
136		.mmc = &dwmac_mmc_ops,
137		.setup = dwmac100_setup,
138		.quirks = stmmac_dwmac1_quirks,
139	}, {
140		.gmac = true,
141		.gmac4 = false,
142		.xgmac = false,
143		.min_id = 0,
144		.regs = {
145			.ptp_off = PTP_GMAC3_X_OFFSET,
146			.mmc_off = MMC_GMAC3_X_OFFSET,
147		},
148		.desc = NULL,
149		.dma = &dwmac1000_dma_ops,
150		.mac = &dwmac1000_ops,
151		.hwtimestamp = &stmmac_ptp,
152		.mode = NULL,
153		.tc = NULL,
154		.mmc = &dwmac_mmc_ops,
155		.setup = dwmac1000_setup,
156		.quirks = stmmac_dwmac1_quirks,
157	}, {
158		.gmac = false,
159		.gmac4 = true,
160		.xgmac = false,
161		.min_id = 0,
162		.regs = {
163			.ptp_off = PTP_GMAC4_OFFSET,
164			.mmc_off = MMC_GMAC4_OFFSET,
165		},
166		.desc = &dwmac4_desc_ops,
167		.dma = &dwmac4_dma_ops,
168		.mac = &dwmac4_ops,
169		.hwtimestamp = &stmmac_ptp,
170		.mode = NULL,
171		.tc = &dwmac510_tc_ops,
172		.mmc = &dwmac_mmc_ops,
173		.setup = dwmac4_setup,
174		.quirks = stmmac_dwmac4_quirks,
175	}, {
176		.gmac = false,
177		.gmac4 = true,
178		.xgmac = false,
179		.min_id = DWMAC_CORE_4_00,
180		.regs = {
181			.ptp_off = PTP_GMAC4_OFFSET,
182			.mmc_off = MMC_GMAC4_OFFSET,
183		},
184		.desc = &dwmac4_desc_ops,
185		.dma = &dwmac4_dma_ops,
186		.mac = &dwmac410_ops,
187		.hwtimestamp = &stmmac_ptp,
188		.mode = &dwmac4_ring_mode_ops,
189		.tc = &dwmac510_tc_ops,
190		.mmc = &dwmac_mmc_ops,
191		.setup = dwmac4_setup,
192		.quirks = NULL,
193	}, {
194		.gmac = false,
195		.gmac4 = true,
196		.xgmac = false,
197		.min_id = DWMAC_CORE_4_10,
198		.regs = {
199			.ptp_off = PTP_GMAC4_OFFSET,
200			.mmc_off = MMC_GMAC4_OFFSET,
201		},
202		.desc = &dwmac4_desc_ops,
203		.dma = &dwmac410_dma_ops,
204		.mac = &dwmac410_ops,
205		.hwtimestamp = &stmmac_ptp,
206		.mode = &dwmac4_ring_mode_ops,
207		.tc = &dwmac510_tc_ops,
208		.mmc = &dwmac_mmc_ops,
209		.setup = dwmac4_setup,
210		.quirks = NULL,
211	}, {
212		.gmac = false,
213		.gmac4 = true,
214		.xgmac = false,
215		.min_id = DWMAC_CORE_5_10,
216		.regs = {
217			.ptp_off = PTP_GMAC4_OFFSET,
218			.mmc_off = MMC_GMAC4_OFFSET,
219		},
220		.desc = &dwmac4_desc_ops,
221		.dma = &dwmac410_dma_ops,
222		.mac = &dwmac510_ops,
223		.hwtimestamp = &stmmac_ptp,
224		.mode = &dwmac4_ring_mode_ops,
225		.tc = &dwmac510_tc_ops,
226		.mmc = &dwmac_mmc_ops,
227		.setup = dwmac4_setup,
228		.quirks = NULL,
229	}, {
230		.gmac = false,
231		.gmac4 = false,
232		.xgmac = true,
233		.min_id = DWXGMAC_CORE_2_10,
234		.dev_id = DWXGMAC_ID,
235		.regs = {
236			.ptp_off = PTP_XGMAC_OFFSET,
237			.mmc_off = MMC_XGMAC_OFFSET,
238		},
239		.desc = &dwxgmac210_desc_ops,
240		.dma = &dwxgmac210_dma_ops,
241		.mac = &dwxgmac210_ops,
242		.hwtimestamp = &stmmac_ptp,
243		.mode = NULL,
244		.tc = &dwmac510_tc_ops,
245		.mmc = &dwxgmac_mmc_ops,
246		.setup = dwxgmac2_setup,
247		.quirks = NULL,
248	}, {
249		.gmac = false,
250		.gmac4 = false,
251		.xgmac = true,
252		.min_id = DWXLGMAC_CORE_2_00,
253		.dev_id = DWXLGMAC_ID,
254		.regs = {
255			.ptp_off = PTP_XGMAC_OFFSET,
256			.mmc_off = MMC_XGMAC_OFFSET,
257		},
258		.desc = &dwxgmac210_desc_ops,
259		.dma = &dwxgmac210_dma_ops,
260		.mac = &dwxlgmac2_ops,
261		.hwtimestamp = &stmmac_ptp,
262		.mode = NULL,
263		.tc = &dwmac510_tc_ops,
264		.mmc = &dwxgmac_mmc_ops,
265		.setup = dwxlgmac2_setup,
266		.quirks = stmmac_dwxlgmac_quirks,
267	},
268};
269
270int stmmac_hwif_init(struct stmmac_priv *priv)
271{
272	bool needs_xgmac = priv->plat->has_xgmac;
273	bool needs_gmac4 = priv->plat->has_gmac4;
274	bool needs_gmac = priv->plat->has_gmac;
275	const struct stmmac_hwif_entry *entry;
276	struct mac_device_info *mac;
277	bool needs_setup = true;
278	u32 id, dev_id = 0;
279	int i, ret;
280
281	if (needs_gmac) {
282		id = stmmac_get_id(priv, GMAC_VERSION);
283	} else if (needs_gmac4 || needs_xgmac) {
284		id = stmmac_get_id(priv, GMAC4_VERSION);
285		if (needs_xgmac)
286			dev_id = stmmac_get_dev_id(priv, GMAC4_VERSION);
287	} else {
288		id = 0;
289	}
290
291	/* Save ID for later use */
292	priv->synopsys_id = id;
293
294	/* Lets assume some safe values first */
295	priv->ptpaddr = priv->ioaddr +
296		(needs_gmac4 ? PTP_GMAC4_OFFSET : PTP_GMAC3_X_OFFSET);
297	priv->mmcaddr = priv->ioaddr +
298		(needs_gmac4 ? MMC_GMAC4_OFFSET : MMC_GMAC3_X_OFFSET);
299
300	/* Check for HW specific setup first */
301	if (priv->plat->setup) {
302		mac = priv->plat->setup(priv);
303		needs_setup = false;
304	} else {
305		mac = devm_kzalloc(priv->device, sizeof(*mac), GFP_KERNEL);
306	}
307
308	if (!mac)
309		return -ENOMEM;
310
311	/* Fallback to generic HW */
312	for (i = ARRAY_SIZE(stmmac_hw) - 1; i >= 0; i--) {
313		entry = &stmmac_hw[i];
314
315		if (needs_gmac ^ entry->gmac)
316			continue;
317		if (needs_gmac4 ^ entry->gmac4)
318			continue;
319		if (needs_xgmac ^ entry->xgmac)
320			continue;
321		/* Use synopsys_id var because some setups can override this */
322		if (priv->synopsys_id < entry->min_id)
323			continue;
324		if (needs_xgmac && (dev_id ^ entry->dev_id))
325			continue;
326
327		/* Only use generic HW helpers if needed */
328		mac->desc = mac->desc ? : entry->desc;
329		mac->dma = mac->dma ? : entry->dma;
330		mac->mac = mac->mac ? : entry->mac;
331		mac->ptp = mac->ptp ? : entry->hwtimestamp;
332		mac->mode = mac->mode ? : entry->mode;
333		mac->tc = mac->tc ? : entry->tc;
334		mac->mmc = mac->mmc ? : entry->mmc;
335
336		priv->hw = mac;
337		priv->ptpaddr = priv->ioaddr + entry->regs.ptp_off;
338		priv->mmcaddr = priv->ioaddr + entry->regs.mmc_off;
339
340		/* Entry found */
341		if (needs_setup) {
342			ret = entry->setup(priv);
343			if (ret)
344				return ret;
345		}
346
347		/* Save quirks, if needed for posterior use */
348		priv->hwif_quirks = entry->quirks;
349		return 0;
350	}
351
352	dev_err(priv->device, "Failed to find HW IF (id=0x%x, gmac=%d/%d)\n",
353			id, needs_gmac, needs_gmac4);
354	return -EINVAL;
355}
356