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