1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * DOC: dwmac-rk.c - Rockchip RK3288 DWMAC specific glue layer
5 * Copyright (C) 2014 Chen-Zhi (Roger Chen)
7 * Chen-Zhi (Roger Chen) <roger.chen@rock-chips.com>
10 #include <linux/stmmac.h>
11 #include <linux/bitops.h>
12 #include <linux/clk.h>
13 #include <linux/phy.h>
14 #include <linux/of_net.h>
15 #include <linux/gpio.h>
16 #include <linux/module.h>
17 #include <linux/of_gpio.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_device.h>
20 #include <linux/regulator/consumer.h>
21 #include <linux/delay.h>
22 #include <linux/mfd/syscon.h>
23 #include <linux/regmap.h>
24 #include <linux/pm_runtime.h>
26 #include "stmmac_platform.h"
30 void (*set_to_rgmii)(struct rk_priv_data *bsp_priv,
31 int tx_delay, int rx_delay);
32 void (*set_to_rmii)(struct rk_priv_data *bsp_priv);
33 void (*set_rgmii_speed)(struct rk_priv_data *bsp_priv, int speed);
34 void (*set_rmii_speed)(struct rk_priv_data *bsp_priv, int speed);
35 void (*integrated_phy_powerup)(struct rk_priv_data *bsp_priv);
40 struct platform_device *pdev;
41 phy_interface_t phy_iface;
43 struct regulator *regulator;
45 const struct rk_gmac_ops *ops;
52 struct clk *gmac_clkin;
53 struct clk *mac_clk_rx;
54 struct clk *mac_clk_tx;
55 struct clk *clk_mac_ref;
56 struct clk *clk_mac_refout;
57 struct clk *clk_mac_speed;
62 struct reset_control *phy_reset;
70 #define HIWORD_UPDATE(val, mask, shift) \
71 ((val) << (shift) | (mask) << ((shift) + 16))
73 #define GRF_BIT(nr) (BIT(nr) | BIT(nr+16))
74 #define GRF_CLR_BIT(nr) (BIT(nr+16))
76 #define DELAY_ENABLE(soc, tx, rx) \
77 (((tx) ? soc##_GMAC_TXCLK_DLY_ENABLE : soc##_GMAC_TXCLK_DLY_DISABLE) | \
78 ((rx) ? soc##_GMAC_RXCLK_DLY_ENABLE : soc##_GMAC_RXCLK_DLY_DISABLE))
80 #define PX30_GRF_GMAC_CON1 0x0904
82 /* PX30_GRF_GMAC_CON1 */
83 #define PX30_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(4) | GRF_CLR_BIT(5) | \
85 #define PX30_GMAC_SPEED_10M GRF_CLR_BIT(2)
86 #define PX30_GMAC_SPEED_100M GRF_BIT(2)
88 static void px30_set_to_rmii(struct rk_priv_data *bsp_priv)
90 struct device *dev = &bsp_priv->pdev->dev;
92 if (IS_ERR(bsp_priv->grf)) {
93 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
97 regmap_write(bsp_priv->grf, PX30_GRF_GMAC_CON1,
98 PX30_GMAC_PHY_INTF_SEL_RMII);
101 static void px30_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
103 struct device *dev = &bsp_priv->pdev->dev;
106 if (IS_ERR(bsp_priv->clk_mac_speed)) {
107 dev_err(dev, "%s: Missing clk_mac_speed clock\n", __func__);
112 regmap_write(bsp_priv->grf, PX30_GRF_GMAC_CON1,
113 PX30_GMAC_SPEED_10M);
115 ret = clk_set_rate(bsp_priv->clk_mac_speed, 2500000);
117 dev_err(dev, "%s: set clk_mac_speed rate 2500000 failed: %d\n",
119 } else if (speed == 100) {
120 regmap_write(bsp_priv->grf, PX30_GRF_GMAC_CON1,
121 PX30_GMAC_SPEED_100M);
123 ret = clk_set_rate(bsp_priv->clk_mac_speed, 25000000);
125 dev_err(dev, "%s: set clk_mac_speed rate 25000000 failed: %d\n",
129 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
133 static const struct rk_gmac_ops px30_ops = {
134 .set_to_rmii = px30_set_to_rmii,
135 .set_rmii_speed = px30_set_rmii_speed,
138 #define RK3128_GRF_MAC_CON0 0x0168
139 #define RK3128_GRF_MAC_CON1 0x016c
141 /* RK3128_GRF_MAC_CON0 */
142 #define RK3128_GMAC_TXCLK_DLY_ENABLE GRF_BIT(14)
143 #define RK3128_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(14)
144 #define RK3128_GMAC_RXCLK_DLY_ENABLE GRF_BIT(15)
145 #define RK3128_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(15)
146 #define RK3128_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 7)
147 #define RK3128_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
149 /* RK3128_GRF_MAC_CON1 */
150 #define RK3128_GMAC_PHY_INTF_SEL_RGMII \
151 (GRF_BIT(6) | GRF_CLR_BIT(7) | GRF_CLR_BIT(8))
152 #define RK3128_GMAC_PHY_INTF_SEL_RMII \
153 (GRF_CLR_BIT(6) | GRF_CLR_BIT(7) | GRF_BIT(8))
154 #define RK3128_GMAC_FLOW_CTRL GRF_BIT(9)
155 #define RK3128_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(9)
156 #define RK3128_GMAC_SPEED_10M GRF_CLR_BIT(10)
157 #define RK3128_GMAC_SPEED_100M GRF_BIT(10)
158 #define RK3128_GMAC_RMII_CLK_25M GRF_BIT(11)
159 #define RK3128_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(11)
160 #define RK3128_GMAC_CLK_125M (GRF_CLR_BIT(12) | GRF_CLR_BIT(13))
161 #define RK3128_GMAC_CLK_25M (GRF_BIT(12) | GRF_BIT(13))
162 #define RK3128_GMAC_CLK_2_5M (GRF_CLR_BIT(12) | GRF_BIT(13))
163 #define RK3128_GMAC_RMII_MODE GRF_BIT(14)
164 #define RK3128_GMAC_RMII_MODE_CLR GRF_CLR_BIT(14)
166 static void rk3128_set_to_rgmii(struct rk_priv_data *bsp_priv,
167 int tx_delay, int rx_delay)
169 struct device *dev = &bsp_priv->pdev->dev;
171 if (IS_ERR(bsp_priv->grf)) {
172 dev_err(dev, "Missing rockchip,grf property\n");
176 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
177 RK3128_GMAC_PHY_INTF_SEL_RGMII |
178 RK3128_GMAC_RMII_MODE_CLR);
179 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON0,
180 DELAY_ENABLE(RK3128, tx_delay, rx_delay) |
181 RK3128_GMAC_CLK_RX_DL_CFG(rx_delay) |
182 RK3128_GMAC_CLK_TX_DL_CFG(tx_delay));
185 static void rk3128_set_to_rmii(struct rk_priv_data *bsp_priv)
187 struct device *dev = &bsp_priv->pdev->dev;
189 if (IS_ERR(bsp_priv->grf)) {
190 dev_err(dev, "Missing rockchip,grf property\n");
194 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
195 RK3128_GMAC_PHY_INTF_SEL_RMII | RK3128_GMAC_RMII_MODE);
198 static void rk3128_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
200 struct device *dev = &bsp_priv->pdev->dev;
202 if (IS_ERR(bsp_priv->grf)) {
203 dev_err(dev, "Missing rockchip,grf property\n");
208 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
209 RK3128_GMAC_CLK_2_5M);
210 else if (speed == 100)
211 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
212 RK3128_GMAC_CLK_25M);
213 else if (speed == 1000)
214 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
215 RK3128_GMAC_CLK_125M);
217 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
220 static void rk3128_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
222 struct device *dev = &bsp_priv->pdev->dev;
224 if (IS_ERR(bsp_priv->grf)) {
225 dev_err(dev, "Missing rockchip,grf property\n");
230 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
231 RK3128_GMAC_RMII_CLK_2_5M |
232 RK3128_GMAC_SPEED_10M);
233 } else if (speed == 100) {
234 regmap_write(bsp_priv->grf, RK3128_GRF_MAC_CON1,
235 RK3128_GMAC_RMII_CLK_25M |
236 RK3128_GMAC_SPEED_100M);
238 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
242 static const struct rk_gmac_ops rk3128_ops = {
243 .set_to_rgmii = rk3128_set_to_rgmii,
244 .set_to_rmii = rk3128_set_to_rmii,
245 .set_rgmii_speed = rk3128_set_rgmii_speed,
246 .set_rmii_speed = rk3128_set_rmii_speed,
249 #define RK3228_GRF_MAC_CON0 0x0900
250 #define RK3228_GRF_MAC_CON1 0x0904
252 #define RK3228_GRF_CON_MUX 0x50
254 /* RK3228_GRF_MAC_CON0 */
255 #define RK3228_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 7)
256 #define RK3228_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
258 /* RK3228_GRF_MAC_CON1 */
259 #define RK3228_GMAC_PHY_INTF_SEL_RGMII \
260 (GRF_BIT(4) | GRF_CLR_BIT(5) | GRF_CLR_BIT(6))
261 #define RK3228_GMAC_PHY_INTF_SEL_RMII \
262 (GRF_CLR_BIT(4) | GRF_CLR_BIT(5) | GRF_BIT(6))
263 #define RK3228_GMAC_FLOW_CTRL GRF_BIT(3)
264 #define RK3228_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(3)
265 #define RK3228_GMAC_SPEED_10M GRF_CLR_BIT(2)
266 #define RK3228_GMAC_SPEED_100M GRF_BIT(2)
267 #define RK3228_GMAC_RMII_CLK_25M GRF_BIT(7)
268 #define RK3228_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(7)
269 #define RK3228_GMAC_CLK_125M (GRF_CLR_BIT(8) | GRF_CLR_BIT(9))
270 #define RK3228_GMAC_CLK_25M (GRF_BIT(8) | GRF_BIT(9))
271 #define RK3228_GMAC_CLK_2_5M (GRF_CLR_BIT(8) | GRF_BIT(9))
272 #define RK3228_GMAC_RMII_MODE GRF_BIT(10)
273 #define RK3228_GMAC_RMII_MODE_CLR GRF_CLR_BIT(10)
274 #define RK3228_GMAC_TXCLK_DLY_ENABLE GRF_BIT(0)
275 #define RK3228_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(0)
276 #define RK3228_GMAC_RXCLK_DLY_ENABLE GRF_BIT(1)
277 #define RK3228_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(1)
279 /* RK3228_GRF_COM_MUX */
280 #define RK3228_GRF_CON_MUX_GMAC_INTEGRATED_PHY GRF_BIT(15)
282 static void rk3228_set_to_rgmii(struct rk_priv_data *bsp_priv,
283 int tx_delay, int rx_delay)
285 struct device *dev = &bsp_priv->pdev->dev;
287 if (IS_ERR(bsp_priv->grf)) {
288 dev_err(dev, "Missing rockchip,grf property\n");
292 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
293 RK3228_GMAC_PHY_INTF_SEL_RGMII |
294 RK3228_GMAC_RMII_MODE_CLR |
295 DELAY_ENABLE(RK3228, tx_delay, rx_delay));
297 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON0,
298 RK3228_GMAC_CLK_RX_DL_CFG(rx_delay) |
299 RK3228_GMAC_CLK_TX_DL_CFG(tx_delay));
302 static void rk3228_set_to_rmii(struct rk_priv_data *bsp_priv)
304 struct device *dev = &bsp_priv->pdev->dev;
306 if (IS_ERR(bsp_priv->grf)) {
307 dev_err(dev, "Missing rockchip,grf property\n");
311 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
312 RK3228_GMAC_PHY_INTF_SEL_RMII |
313 RK3228_GMAC_RMII_MODE);
315 /* set MAC to RMII mode */
316 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1, GRF_BIT(11));
319 static void rk3228_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
321 struct device *dev = &bsp_priv->pdev->dev;
323 if (IS_ERR(bsp_priv->grf)) {
324 dev_err(dev, "Missing rockchip,grf property\n");
329 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
330 RK3228_GMAC_CLK_2_5M);
331 else if (speed == 100)
332 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
333 RK3228_GMAC_CLK_25M);
334 else if (speed == 1000)
335 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
336 RK3228_GMAC_CLK_125M);
338 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
341 static void rk3228_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
343 struct device *dev = &bsp_priv->pdev->dev;
345 if (IS_ERR(bsp_priv->grf)) {
346 dev_err(dev, "Missing rockchip,grf property\n");
351 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
352 RK3228_GMAC_RMII_CLK_2_5M |
353 RK3228_GMAC_SPEED_10M);
354 else if (speed == 100)
355 regmap_write(bsp_priv->grf, RK3228_GRF_MAC_CON1,
356 RK3228_GMAC_RMII_CLK_25M |
357 RK3228_GMAC_SPEED_100M);
359 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
362 static void rk3228_integrated_phy_powerup(struct rk_priv_data *priv)
364 regmap_write(priv->grf, RK3228_GRF_CON_MUX,
365 RK3228_GRF_CON_MUX_GMAC_INTEGRATED_PHY);
368 static const struct rk_gmac_ops rk3228_ops = {
369 .set_to_rgmii = rk3228_set_to_rgmii,
370 .set_to_rmii = rk3228_set_to_rmii,
371 .set_rgmii_speed = rk3228_set_rgmii_speed,
372 .set_rmii_speed = rk3228_set_rmii_speed,
373 .integrated_phy_powerup = rk3228_integrated_phy_powerup,
376 #define RK3288_GRF_SOC_CON1 0x0248
377 #define RK3288_GRF_SOC_CON3 0x0250
379 /*RK3288_GRF_SOC_CON1*/
380 #define RK3288_GMAC_PHY_INTF_SEL_RGMII (GRF_BIT(6) | GRF_CLR_BIT(7) | \
382 #define RK3288_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(6) | GRF_CLR_BIT(7) | \
384 #define RK3288_GMAC_FLOW_CTRL GRF_BIT(9)
385 #define RK3288_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(9)
386 #define RK3288_GMAC_SPEED_10M GRF_CLR_BIT(10)
387 #define RK3288_GMAC_SPEED_100M GRF_BIT(10)
388 #define RK3288_GMAC_RMII_CLK_25M GRF_BIT(11)
389 #define RK3288_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(11)
390 #define RK3288_GMAC_CLK_125M (GRF_CLR_BIT(12) | GRF_CLR_BIT(13))
391 #define RK3288_GMAC_CLK_25M (GRF_BIT(12) | GRF_BIT(13))
392 #define RK3288_GMAC_CLK_2_5M (GRF_CLR_BIT(12) | GRF_BIT(13))
393 #define RK3288_GMAC_RMII_MODE GRF_BIT(14)
394 #define RK3288_GMAC_RMII_MODE_CLR GRF_CLR_BIT(14)
396 /*RK3288_GRF_SOC_CON3*/
397 #define RK3288_GMAC_TXCLK_DLY_ENABLE GRF_BIT(14)
398 #define RK3288_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(14)
399 #define RK3288_GMAC_RXCLK_DLY_ENABLE GRF_BIT(15)
400 #define RK3288_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(15)
401 #define RK3288_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 7)
402 #define RK3288_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
404 static void rk3288_set_to_rgmii(struct rk_priv_data *bsp_priv,
405 int tx_delay, int rx_delay)
407 struct device *dev = &bsp_priv->pdev->dev;
409 if (IS_ERR(bsp_priv->grf)) {
410 dev_err(dev, "Missing rockchip,grf property\n");
414 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
415 RK3288_GMAC_PHY_INTF_SEL_RGMII |
416 RK3288_GMAC_RMII_MODE_CLR);
417 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON3,
418 DELAY_ENABLE(RK3288, tx_delay, rx_delay) |
419 RK3288_GMAC_CLK_RX_DL_CFG(rx_delay) |
420 RK3288_GMAC_CLK_TX_DL_CFG(tx_delay));
423 static void rk3288_set_to_rmii(struct rk_priv_data *bsp_priv)
425 struct device *dev = &bsp_priv->pdev->dev;
427 if (IS_ERR(bsp_priv->grf)) {
428 dev_err(dev, "Missing rockchip,grf property\n");
432 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
433 RK3288_GMAC_PHY_INTF_SEL_RMII | RK3288_GMAC_RMII_MODE);
436 static void rk3288_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
438 struct device *dev = &bsp_priv->pdev->dev;
440 if (IS_ERR(bsp_priv->grf)) {
441 dev_err(dev, "Missing rockchip,grf property\n");
446 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
447 RK3288_GMAC_CLK_2_5M);
448 else if (speed == 100)
449 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
450 RK3288_GMAC_CLK_25M);
451 else if (speed == 1000)
452 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
453 RK3288_GMAC_CLK_125M);
455 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
458 static void rk3288_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
460 struct device *dev = &bsp_priv->pdev->dev;
462 if (IS_ERR(bsp_priv->grf)) {
463 dev_err(dev, "Missing rockchip,grf property\n");
468 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
469 RK3288_GMAC_RMII_CLK_2_5M |
470 RK3288_GMAC_SPEED_10M);
471 } else if (speed == 100) {
472 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
473 RK3288_GMAC_RMII_CLK_25M |
474 RK3288_GMAC_SPEED_100M);
476 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
480 static const struct rk_gmac_ops rk3288_ops = {
481 .set_to_rgmii = rk3288_set_to_rgmii,
482 .set_to_rmii = rk3288_set_to_rmii,
483 .set_rgmii_speed = rk3288_set_rgmii_speed,
484 .set_rmii_speed = rk3288_set_rmii_speed,
487 #define RK3308_GRF_MAC_CON0 0x04a0
489 /* RK3308_GRF_MAC_CON0 */
490 #define RK3308_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(2) | GRF_CLR_BIT(3) | \
492 #define RK3308_GMAC_FLOW_CTRL GRF_BIT(3)
493 #define RK3308_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(3)
494 #define RK3308_GMAC_SPEED_10M GRF_CLR_BIT(0)
495 #define RK3308_GMAC_SPEED_100M GRF_BIT(0)
497 static void rk3308_set_to_rmii(struct rk_priv_data *bsp_priv)
499 struct device *dev = &bsp_priv->pdev->dev;
501 if (IS_ERR(bsp_priv->grf)) {
502 dev_err(dev, "Missing rockchip,grf property\n");
506 regmap_write(bsp_priv->grf, RK3308_GRF_MAC_CON0,
507 RK3308_GMAC_PHY_INTF_SEL_RMII);
510 static void rk3308_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
512 struct device *dev = &bsp_priv->pdev->dev;
514 if (IS_ERR(bsp_priv->grf)) {
515 dev_err(dev, "Missing rockchip,grf property\n");
520 regmap_write(bsp_priv->grf, RK3308_GRF_MAC_CON0,
521 RK3308_GMAC_SPEED_10M);
522 } else if (speed == 100) {
523 regmap_write(bsp_priv->grf, RK3308_GRF_MAC_CON0,
524 RK3308_GMAC_SPEED_100M);
526 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
530 static const struct rk_gmac_ops rk3308_ops = {
531 .set_to_rmii = rk3308_set_to_rmii,
532 .set_rmii_speed = rk3308_set_rmii_speed,
535 #define RK3328_GRF_MAC_CON0 0x0900
536 #define RK3328_GRF_MAC_CON1 0x0904
537 #define RK3328_GRF_MAC_CON2 0x0908
538 #define RK3328_GRF_MACPHY_CON1 0xb04
540 /* RK3328_GRF_MAC_CON0 */
541 #define RK3328_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 7)
542 #define RK3328_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
544 /* RK3328_GRF_MAC_CON1 */
545 #define RK3328_GMAC_PHY_INTF_SEL_RGMII \
546 (GRF_BIT(4) | GRF_CLR_BIT(5) | GRF_CLR_BIT(6))
547 #define RK3328_GMAC_PHY_INTF_SEL_RMII \
548 (GRF_CLR_BIT(4) | GRF_CLR_BIT(5) | GRF_BIT(6))
549 #define RK3328_GMAC_FLOW_CTRL GRF_BIT(3)
550 #define RK3328_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(3)
551 #define RK3328_GMAC_SPEED_10M GRF_CLR_BIT(2)
552 #define RK3328_GMAC_SPEED_100M GRF_BIT(2)
553 #define RK3328_GMAC_RMII_CLK_25M GRF_BIT(7)
554 #define RK3328_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(7)
555 #define RK3328_GMAC_CLK_125M (GRF_CLR_BIT(11) | GRF_CLR_BIT(12))
556 #define RK3328_GMAC_CLK_25M (GRF_BIT(11) | GRF_BIT(12))
557 #define RK3328_GMAC_CLK_2_5M (GRF_CLR_BIT(11) | GRF_BIT(12))
558 #define RK3328_GMAC_RMII_MODE GRF_BIT(9)
559 #define RK3328_GMAC_RMII_MODE_CLR GRF_CLR_BIT(9)
560 #define RK3328_GMAC_TXCLK_DLY_ENABLE GRF_BIT(0)
561 #define RK3328_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(0)
562 #define RK3328_GMAC_RXCLK_DLY_ENABLE GRF_BIT(1)
563 #define RK3328_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(0)
565 /* RK3328_GRF_MACPHY_CON1 */
566 #define RK3328_MACPHY_RMII_MODE GRF_BIT(9)
568 static void rk3328_set_to_rgmii(struct rk_priv_data *bsp_priv,
569 int tx_delay, int rx_delay)
571 struct device *dev = &bsp_priv->pdev->dev;
573 if (IS_ERR(bsp_priv->grf)) {
574 dev_err(dev, "Missing rockchip,grf property\n");
578 regmap_write(bsp_priv->grf, RK3328_GRF_MAC_CON1,
579 RK3328_GMAC_PHY_INTF_SEL_RGMII |
580 RK3328_GMAC_RMII_MODE_CLR |
581 RK3328_GMAC_RXCLK_DLY_ENABLE |
582 RK3328_GMAC_TXCLK_DLY_ENABLE);
584 regmap_write(bsp_priv->grf, RK3328_GRF_MAC_CON0,
585 RK3328_GMAC_CLK_RX_DL_CFG(rx_delay) |
586 RK3328_GMAC_CLK_TX_DL_CFG(tx_delay));
589 static void rk3328_set_to_rmii(struct rk_priv_data *bsp_priv)
591 struct device *dev = &bsp_priv->pdev->dev;
594 if (IS_ERR(bsp_priv->grf)) {
595 dev_err(dev, "Missing rockchip,grf property\n");
599 reg = bsp_priv->integrated_phy ? RK3328_GRF_MAC_CON2 :
602 regmap_write(bsp_priv->grf, reg,
603 RK3328_GMAC_PHY_INTF_SEL_RMII |
604 RK3328_GMAC_RMII_MODE);
607 static void rk3328_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
609 struct device *dev = &bsp_priv->pdev->dev;
611 if (IS_ERR(bsp_priv->grf)) {
612 dev_err(dev, "Missing rockchip,grf property\n");
617 regmap_write(bsp_priv->grf, RK3328_GRF_MAC_CON1,
618 RK3328_GMAC_CLK_2_5M);
619 else if (speed == 100)
620 regmap_write(bsp_priv->grf, RK3328_GRF_MAC_CON1,
621 RK3328_GMAC_CLK_25M);
622 else if (speed == 1000)
623 regmap_write(bsp_priv->grf, RK3328_GRF_MAC_CON1,
624 RK3328_GMAC_CLK_125M);
626 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
629 static void rk3328_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
631 struct device *dev = &bsp_priv->pdev->dev;
634 if (IS_ERR(bsp_priv->grf)) {
635 dev_err(dev, "Missing rockchip,grf property\n");
639 reg = bsp_priv->integrated_phy ? RK3328_GRF_MAC_CON2 :
643 regmap_write(bsp_priv->grf, reg,
644 RK3328_GMAC_RMII_CLK_2_5M |
645 RK3328_GMAC_SPEED_10M);
646 else if (speed == 100)
647 regmap_write(bsp_priv->grf, reg,
648 RK3328_GMAC_RMII_CLK_25M |
649 RK3328_GMAC_SPEED_100M);
651 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
654 static void rk3328_integrated_phy_powerup(struct rk_priv_data *priv)
656 regmap_write(priv->grf, RK3328_GRF_MACPHY_CON1,
657 RK3328_MACPHY_RMII_MODE);
660 static const struct rk_gmac_ops rk3328_ops = {
661 .set_to_rgmii = rk3328_set_to_rgmii,
662 .set_to_rmii = rk3328_set_to_rmii,
663 .set_rgmii_speed = rk3328_set_rgmii_speed,
664 .set_rmii_speed = rk3328_set_rmii_speed,
665 .integrated_phy_powerup = rk3328_integrated_phy_powerup,
668 #define RK3366_GRF_SOC_CON6 0x0418
669 #define RK3366_GRF_SOC_CON7 0x041c
671 /* RK3366_GRF_SOC_CON6 */
672 #define RK3366_GMAC_PHY_INTF_SEL_RGMII (GRF_BIT(9) | GRF_CLR_BIT(10) | \
674 #define RK3366_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(9) | GRF_CLR_BIT(10) | \
676 #define RK3366_GMAC_FLOW_CTRL GRF_BIT(8)
677 #define RK3366_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(8)
678 #define RK3366_GMAC_SPEED_10M GRF_CLR_BIT(7)
679 #define RK3366_GMAC_SPEED_100M GRF_BIT(7)
680 #define RK3366_GMAC_RMII_CLK_25M GRF_BIT(3)
681 #define RK3366_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(3)
682 #define RK3366_GMAC_CLK_125M (GRF_CLR_BIT(4) | GRF_CLR_BIT(5))
683 #define RK3366_GMAC_CLK_25M (GRF_BIT(4) | GRF_BIT(5))
684 #define RK3366_GMAC_CLK_2_5M (GRF_CLR_BIT(4) | GRF_BIT(5))
685 #define RK3366_GMAC_RMII_MODE GRF_BIT(6)
686 #define RK3366_GMAC_RMII_MODE_CLR GRF_CLR_BIT(6)
688 /* RK3366_GRF_SOC_CON7 */
689 #define RK3366_GMAC_TXCLK_DLY_ENABLE GRF_BIT(7)
690 #define RK3366_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(7)
691 #define RK3366_GMAC_RXCLK_DLY_ENABLE GRF_BIT(15)
692 #define RK3366_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(15)
693 #define RK3366_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 8)
694 #define RK3366_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
696 static void rk3366_set_to_rgmii(struct rk_priv_data *bsp_priv,
697 int tx_delay, int rx_delay)
699 struct device *dev = &bsp_priv->pdev->dev;
701 if (IS_ERR(bsp_priv->grf)) {
702 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
706 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
707 RK3366_GMAC_PHY_INTF_SEL_RGMII |
708 RK3366_GMAC_RMII_MODE_CLR);
709 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON7,
710 DELAY_ENABLE(RK3366, tx_delay, rx_delay) |
711 RK3366_GMAC_CLK_RX_DL_CFG(rx_delay) |
712 RK3366_GMAC_CLK_TX_DL_CFG(tx_delay));
715 static void rk3366_set_to_rmii(struct rk_priv_data *bsp_priv)
717 struct device *dev = &bsp_priv->pdev->dev;
719 if (IS_ERR(bsp_priv->grf)) {
720 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
724 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
725 RK3366_GMAC_PHY_INTF_SEL_RMII | RK3366_GMAC_RMII_MODE);
728 static void rk3366_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
730 struct device *dev = &bsp_priv->pdev->dev;
732 if (IS_ERR(bsp_priv->grf)) {
733 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
738 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
739 RK3366_GMAC_CLK_2_5M);
740 else if (speed == 100)
741 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
742 RK3366_GMAC_CLK_25M);
743 else if (speed == 1000)
744 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
745 RK3366_GMAC_CLK_125M);
747 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
750 static void rk3366_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
752 struct device *dev = &bsp_priv->pdev->dev;
754 if (IS_ERR(bsp_priv->grf)) {
755 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
760 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
761 RK3366_GMAC_RMII_CLK_2_5M |
762 RK3366_GMAC_SPEED_10M);
763 } else if (speed == 100) {
764 regmap_write(bsp_priv->grf, RK3366_GRF_SOC_CON6,
765 RK3366_GMAC_RMII_CLK_25M |
766 RK3366_GMAC_SPEED_100M);
768 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
772 static const struct rk_gmac_ops rk3366_ops = {
773 .set_to_rgmii = rk3366_set_to_rgmii,
774 .set_to_rmii = rk3366_set_to_rmii,
775 .set_rgmii_speed = rk3366_set_rgmii_speed,
776 .set_rmii_speed = rk3366_set_rmii_speed,
779 #define RK3368_GRF_SOC_CON15 0x043c
780 #define RK3368_GRF_SOC_CON16 0x0440
782 /* RK3368_GRF_SOC_CON15 */
783 #define RK3368_GMAC_PHY_INTF_SEL_RGMII (GRF_BIT(9) | GRF_CLR_BIT(10) | \
785 #define RK3368_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(9) | GRF_CLR_BIT(10) | \
787 #define RK3368_GMAC_FLOW_CTRL GRF_BIT(8)
788 #define RK3368_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(8)
789 #define RK3368_GMAC_SPEED_10M GRF_CLR_BIT(7)
790 #define RK3368_GMAC_SPEED_100M GRF_BIT(7)
791 #define RK3368_GMAC_RMII_CLK_25M GRF_BIT(3)
792 #define RK3368_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(3)
793 #define RK3368_GMAC_CLK_125M (GRF_CLR_BIT(4) | GRF_CLR_BIT(5))
794 #define RK3368_GMAC_CLK_25M (GRF_BIT(4) | GRF_BIT(5))
795 #define RK3368_GMAC_CLK_2_5M (GRF_CLR_BIT(4) | GRF_BIT(5))
796 #define RK3368_GMAC_RMII_MODE GRF_BIT(6)
797 #define RK3368_GMAC_RMII_MODE_CLR GRF_CLR_BIT(6)
799 /* RK3368_GRF_SOC_CON16 */
800 #define RK3368_GMAC_TXCLK_DLY_ENABLE GRF_BIT(7)
801 #define RK3368_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(7)
802 #define RK3368_GMAC_RXCLK_DLY_ENABLE GRF_BIT(15)
803 #define RK3368_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(15)
804 #define RK3368_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 8)
805 #define RK3368_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
807 static void rk3368_set_to_rgmii(struct rk_priv_data *bsp_priv,
808 int tx_delay, int rx_delay)
810 struct device *dev = &bsp_priv->pdev->dev;
812 if (IS_ERR(bsp_priv->grf)) {
813 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
817 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
818 RK3368_GMAC_PHY_INTF_SEL_RGMII |
819 RK3368_GMAC_RMII_MODE_CLR);
820 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON16,
821 DELAY_ENABLE(RK3368, tx_delay, rx_delay) |
822 RK3368_GMAC_CLK_RX_DL_CFG(rx_delay) |
823 RK3368_GMAC_CLK_TX_DL_CFG(tx_delay));
826 static void rk3368_set_to_rmii(struct rk_priv_data *bsp_priv)
828 struct device *dev = &bsp_priv->pdev->dev;
830 if (IS_ERR(bsp_priv->grf)) {
831 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
835 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
836 RK3368_GMAC_PHY_INTF_SEL_RMII | RK3368_GMAC_RMII_MODE);
839 static void rk3368_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
841 struct device *dev = &bsp_priv->pdev->dev;
843 if (IS_ERR(bsp_priv->grf)) {
844 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
849 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
850 RK3368_GMAC_CLK_2_5M);
851 else if (speed == 100)
852 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
853 RK3368_GMAC_CLK_25M);
854 else if (speed == 1000)
855 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
856 RK3368_GMAC_CLK_125M);
858 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
861 static void rk3368_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
863 struct device *dev = &bsp_priv->pdev->dev;
865 if (IS_ERR(bsp_priv->grf)) {
866 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
871 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
872 RK3368_GMAC_RMII_CLK_2_5M |
873 RK3368_GMAC_SPEED_10M);
874 } else if (speed == 100) {
875 regmap_write(bsp_priv->grf, RK3368_GRF_SOC_CON15,
876 RK3368_GMAC_RMII_CLK_25M |
877 RK3368_GMAC_SPEED_100M);
879 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
883 static const struct rk_gmac_ops rk3368_ops = {
884 .set_to_rgmii = rk3368_set_to_rgmii,
885 .set_to_rmii = rk3368_set_to_rmii,
886 .set_rgmii_speed = rk3368_set_rgmii_speed,
887 .set_rmii_speed = rk3368_set_rmii_speed,
890 #define RK3399_GRF_SOC_CON5 0xc214
891 #define RK3399_GRF_SOC_CON6 0xc218
893 /* RK3399_GRF_SOC_CON5 */
894 #define RK3399_GMAC_PHY_INTF_SEL_RGMII (GRF_BIT(9) | GRF_CLR_BIT(10) | \
896 #define RK3399_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(9) | GRF_CLR_BIT(10) | \
898 #define RK3399_GMAC_FLOW_CTRL GRF_BIT(8)
899 #define RK3399_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(8)
900 #define RK3399_GMAC_SPEED_10M GRF_CLR_BIT(7)
901 #define RK3399_GMAC_SPEED_100M GRF_BIT(7)
902 #define RK3399_GMAC_RMII_CLK_25M GRF_BIT(3)
903 #define RK3399_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(3)
904 #define RK3399_GMAC_CLK_125M (GRF_CLR_BIT(4) | GRF_CLR_BIT(5))
905 #define RK3399_GMAC_CLK_25M (GRF_BIT(4) | GRF_BIT(5))
906 #define RK3399_GMAC_CLK_2_5M (GRF_CLR_BIT(4) | GRF_BIT(5))
907 #define RK3399_GMAC_RMII_MODE GRF_BIT(6)
908 #define RK3399_GMAC_RMII_MODE_CLR GRF_CLR_BIT(6)
910 /* RK3399_GRF_SOC_CON6 */
911 #define RK3399_GMAC_TXCLK_DLY_ENABLE GRF_BIT(7)
912 #define RK3399_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(7)
913 #define RK3399_GMAC_RXCLK_DLY_ENABLE GRF_BIT(15)
914 #define RK3399_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(15)
915 #define RK3399_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 8)
916 #define RK3399_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
918 static void rk3399_set_to_rgmii(struct rk_priv_data *bsp_priv,
919 int tx_delay, int rx_delay)
921 struct device *dev = &bsp_priv->pdev->dev;
923 if (IS_ERR(bsp_priv->grf)) {
924 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
928 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
929 RK3399_GMAC_PHY_INTF_SEL_RGMII |
930 RK3399_GMAC_RMII_MODE_CLR);
931 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON6,
932 DELAY_ENABLE(RK3399, tx_delay, rx_delay) |
933 RK3399_GMAC_CLK_RX_DL_CFG(rx_delay) |
934 RK3399_GMAC_CLK_TX_DL_CFG(tx_delay));
937 static void rk3399_set_to_rmii(struct rk_priv_data *bsp_priv)
939 struct device *dev = &bsp_priv->pdev->dev;
941 if (IS_ERR(bsp_priv->grf)) {
942 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
946 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
947 RK3399_GMAC_PHY_INTF_SEL_RMII | RK3399_GMAC_RMII_MODE);
950 static void rk3399_set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
952 struct device *dev = &bsp_priv->pdev->dev;
954 if (IS_ERR(bsp_priv->grf)) {
955 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
960 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
961 RK3399_GMAC_CLK_2_5M);
962 else if (speed == 100)
963 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
964 RK3399_GMAC_CLK_25M);
965 else if (speed == 1000)
966 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
967 RK3399_GMAC_CLK_125M);
969 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
972 static void rk3399_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
974 struct device *dev = &bsp_priv->pdev->dev;
976 if (IS_ERR(bsp_priv->grf)) {
977 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
982 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
983 RK3399_GMAC_RMII_CLK_2_5M |
984 RK3399_GMAC_SPEED_10M);
985 } else if (speed == 100) {
986 regmap_write(bsp_priv->grf, RK3399_GRF_SOC_CON5,
987 RK3399_GMAC_RMII_CLK_25M |
988 RK3399_GMAC_SPEED_100M);
990 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
994 static const struct rk_gmac_ops rk3399_ops = {
995 .set_to_rgmii = rk3399_set_to_rgmii,
996 .set_to_rmii = rk3399_set_to_rmii,
997 .set_rgmii_speed = rk3399_set_rgmii_speed,
998 .set_rmii_speed = rk3399_set_rmii_speed,
1001 #define RK3568_GRF_GMAC0_CON0 0x0380
1002 #define RK3568_GRF_GMAC0_CON1 0x0384
1003 #define RK3568_GRF_GMAC1_CON0 0x0388
1004 #define RK3568_GRF_GMAC1_CON1 0x038c
1006 /* RK3568_GRF_GMAC0_CON1 && RK3568_GRF_GMAC1_CON1 */
1007 #define RK3568_GMAC_PHY_INTF_SEL_RGMII \
1008 (GRF_BIT(4) | GRF_CLR_BIT(5) | GRF_CLR_BIT(6))
1009 #define RK3568_GMAC_PHY_INTF_SEL_RMII \
1010 (GRF_CLR_BIT(4) | GRF_CLR_BIT(5) | GRF_BIT(6))
1011 #define RK3568_GMAC_FLOW_CTRL GRF_BIT(3)
1012 #define RK3568_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(3)
1013 #define RK3568_GMAC_RXCLK_DLY_ENABLE GRF_BIT(1)
1014 #define RK3568_GMAC_RXCLK_DLY_DISABLE GRF_CLR_BIT(1)
1015 #define RK3568_GMAC_TXCLK_DLY_ENABLE GRF_BIT(0)
1016 #define RK3568_GMAC_TXCLK_DLY_DISABLE GRF_CLR_BIT(0)
1018 /* RK3568_GRF_GMAC0_CON0 && RK3568_GRF_GMAC1_CON0 */
1019 #define RK3568_GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 8)
1020 #define RK3568_GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
1022 static void rk3568_set_to_rgmii(struct rk_priv_data *bsp_priv,
1023 int tx_delay, int rx_delay)
1025 struct device *dev = &bsp_priv->pdev->dev;
1028 if (IS_ERR(bsp_priv->grf)) {
1029 dev_err(dev, "Missing rockchip,grf property\n");
1033 con0 = (bsp_priv->id == 1) ? RK3568_GRF_GMAC1_CON0 :
1034 RK3568_GRF_GMAC0_CON0;
1035 con1 = (bsp_priv->id == 1) ? RK3568_GRF_GMAC1_CON1 :
1036 RK3568_GRF_GMAC0_CON1;
1038 regmap_write(bsp_priv->grf, con0,
1039 RK3568_GMAC_CLK_RX_DL_CFG(rx_delay) |
1040 RK3568_GMAC_CLK_TX_DL_CFG(tx_delay));
1042 regmap_write(bsp_priv->grf, con1,
1043 RK3568_GMAC_PHY_INTF_SEL_RGMII |
1044 RK3568_GMAC_RXCLK_DLY_ENABLE |
1045 RK3568_GMAC_TXCLK_DLY_ENABLE);
1048 static void rk3568_set_to_rmii(struct rk_priv_data *bsp_priv)
1050 struct device *dev = &bsp_priv->pdev->dev;
1053 if (IS_ERR(bsp_priv->grf)) {
1054 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
1058 con1 = (bsp_priv->id == 1) ? RK3568_GRF_GMAC1_CON1 :
1059 RK3568_GRF_GMAC0_CON1;
1060 regmap_write(bsp_priv->grf, con1, RK3568_GMAC_PHY_INTF_SEL_RMII);
1063 static void rk3568_set_gmac_speed(struct rk_priv_data *bsp_priv, int speed)
1065 struct device *dev = &bsp_priv->pdev->dev;
1080 dev_err(dev, "unknown speed value for GMAC speed=%d", speed);
1084 ret = clk_set_rate(bsp_priv->clk_mac_speed, rate);
1086 dev_err(dev, "%s: set clk_mac_speed rate %ld failed %d\n",
1087 __func__, rate, ret);
1090 static const struct rk_gmac_ops rk3568_ops = {
1091 .set_to_rgmii = rk3568_set_to_rgmii,
1092 .set_to_rmii = rk3568_set_to_rmii,
1093 .set_rgmii_speed = rk3568_set_gmac_speed,
1094 .set_rmii_speed = rk3568_set_gmac_speed,
1096 0xfe2a0000, /* gmac0 */
1097 0xfe010000, /* gmac1 */
1102 #define RV1108_GRF_GMAC_CON0 0X0900
1104 /* RV1108_GRF_GMAC_CON0 */
1105 #define RV1108_GMAC_PHY_INTF_SEL_RMII (GRF_CLR_BIT(4) | GRF_CLR_BIT(5) | \
1107 #define RV1108_GMAC_FLOW_CTRL GRF_BIT(3)
1108 #define RV1108_GMAC_FLOW_CTRL_CLR GRF_CLR_BIT(3)
1109 #define RV1108_GMAC_SPEED_10M GRF_CLR_BIT(2)
1110 #define RV1108_GMAC_SPEED_100M GRF_BIT(2)
1111 #define RV1108_GMAC_RMII_CLK_25M GRF_BIT(7)
1112 #define RV1108_GMAC_RMII_CLK_2_5M GRF_CLR_BIT(7)
1114 static void rv1108_set_to_rmii(struct rk_priv_data *bsp_priv)
1116 struct device *dev = &bsp_priv->pdev->dev;
1118 if (IS_ERR(bsp_priv->grf)) {
1119 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
1123 regmap_write(bsp_priv->grf, RV1108_GRF_GMAC_CON0,
1124 RV1108_GMAC_PHY_INTF_SEL_RMII);
1127 static void rv1108_set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
1129 struct device *dev = &bsp_priv->pdev->dev;
1131 if (IS_ERR(bsp_priv->grf)) {
1132 dev_err(dev, "%s: Missing rockchip,grf property\n", __func__);
1137 regmap_write(bsp_priv->grf, RV1108_GRF_GMAC_CON0,
1138 RV1108_GMAC_RMII_CLK_2_5M |
1139 RV1108_GMAC_SPEED_10M);
1140 } else if (speed == 100) {
1141 regmap_write(bsp_priv->grf, RV1108_GRF_GMAC_CON0,
1142 RV1108_GMAC_RMII_CLK_25M |
1143 RV1108_GMAC_SPEED_100M);
1145 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
1149 static const struct rk_gmac_ops rv1108_ops = {
1150 .set_to_rmii = rv1108_set_to_rmii,
1151 .set_rmii_speed = rv1108_set_rmii_speed,
1154 #define RK_GRF_MACPHY_CON0 0xb00
1155 #define RK_GRF_MACPHY_CON1 0xb04
1156 #define RK_GRF_MACPHY_CON2 0xb08
1157 #define RK_GRF_MACPHY_CON3 0xb0c
1159 #define RK_MACPHY_ENABLE GRF_BIT(0)
1160 #define RK_MACPHY_DISABLE GRF_CLR_BIT(0)
1161 #define RK_MACPHY_CFG_CLK_50M GRF_BIT(14)
1162 #define RK_GMAC2PHY_RMII_MODE (GRF_BIT(6) | GRF_CLR_BIT(7))
1163 #define RK_GRF_CON2_MACPHY_ID HIWORD_UPDATE(0x1234, 0xffff, 0)
1164 #define RK_GRF_CON3_MACPHY_ID HIWORD_UPDATE(0x35, 0x3f, 0)
1166 static void rk_gmac_integrated_phy_powerup(struct rk_priv_data *priv)
1168 if (priv->ops->integrated_phy_powerup)
1169 priv->ops->integrated_phy_powerup(priv);
1171 regmap_write(priv->grf, RK_GRF_MACPHY_CON0, RK_MACPHY_CFG_CLK_50M);
1172 regmap_write(priv->grf, RK_GRF_MACPHY_CON0, RK_GMAC2PHY_RMII_MODE);
1174 regmap_write(priv->grf, RK_GRF_MACPHY_CON2, RK_GRF_CON2_MACPHY_ID);
1175 regmap_write(priv->grf, RK_GRF_MACPHY_CON3, RK_GRF_CON3_MACPHY_ID);
1177 if (priv->phy_reset) {
1178 /* PHY needs to be disabled before trying to reset it */
1179 regmap_write(priv->grf, RK_GRF_MACPHY_CON0, RK_MACPHY_DISABLE);
1180 if (priv->phy_reset)
1181 reset_control_assert(priv->phy_reset);
1182 usleep_range(10, 20);
1183 if (priv->phy_reset)
1184 reset_control_deassert(priv->phy_reset);
1185 usleep_range(10, 20);
1186 regmap_write(priv->grf, RK_GRF_MACPHY_CON0, RK_MACPHY_ENABLE);
1191 static void rk_gmac_integrated_phy_powerdown(struct rk_priv_data *priv)
1193 regmap_write(priv->grf, RK_GRF_MACPHY_CON0, RK_MACPHY_DISABLE);
1194 if (priv->phy_reset)
1195 reset_control_assert(priv->phy_reset);
1198 static int rk_gmac_clk_init(struct plat_stmmacenet_data *plat)
1200 struct rk_priv_data *bsp_priv = plat->bsp_priv;
1201 struct device *dev = &bsp_priv->pdev->dev;
1204 bsp_priv->clk_enabled = false;
1206 bsp_priv->mac_clk_rx = devm_clk_get(dev, "mac_clk_rx");
1207 if (IS_ERR(bsp_priv->mac_clk_rx))
1208 dev_err(dev, "cannot get clock %s\n",
1211 bsp_priv->mac_clk_tx = devm_clk_get(dev, "mac_clk_tx");
1212 if (IS_ERR(bsp_priv->mac_clk_tx))
1213 dev_err(dev, "cannot get clock %s\n",
1216 bsp_priv->aclk_mac = devm_clk_get(dev, "aclk_mac");
1217 if (IS_ERR(bsp_priv->aclk_mac))
1218 dev_err(dev, "cannot get clock %s\n",
1221 bsp_priv->pclk_mac = devm_clk_get(dev, "pclk_mac");
1222 if (IS_ERR(bsp_priv->pclk_mac))
1223 dev_err(dev, "cannot get clock %s\n",
1226 bsp_priv->clk_mac = devm_clk_get(dev, "stmmaceth");
1227 if (IS_ERR(bsp_priv->clk_mac))
1228 dev_err(dev, "cannot get clock %s\n",
1231 if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
1232 bsp_priv->clk_mac_ref = devm_clk_get(dev, "clk_mac_ref");
1233 if (IS_ERR(bsp_priv->clk_mac_ref))
1234 dev_err(dev, "cannot get clock %s\n",
1237 if (!bsp_priv->clock_input) {
1238 bsp_priv->clk_mac_refout =
1239 devm_clk_get(dev, "clk_mac_refout");
1240 if (IS_ERR(bsp_priv->clk_mac_refout))
1241 dev_err(dev, "cannot get clock %s\n",
1246 bsp_priv->clk_mac_speed = devm_clk_get(dev, "clk_mac_speed");
1247 if (IS_ERR(bsp_priv->clk_mac_speed))
1248 dev_err(dev, "cannot get clock %s\n", "clk_mac_speed");
1250 if (bsp_priv->clock_input) {
1251 dev_info(dev, "clock input from PHY\n");
1253 if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII)
1254 clk_set_rate(bsp_priv->clk_mac, 50000000);
1257 if (plat->phy_node && bsp_priv->integrated_phy) {
1258 bsp_priv->clk_phy = of_clk_get(plat->phy_node, 0);
1259 if (IS_ERR(bsp_priv->clk_phy)) {
1260 ret = PTR_ERR(bsp_priv->clk_phy);
1261 dev_err(dev, "Cannot get PHY clock: %d\n", ret);
1264 clk_set_rate(bsp_priv->clk_phy, 50000000);
1270 static int gmac_clk_enable(struct rk_priv_data *bsp_priv, bool enable)
1272 int phy_iface = bsp_priv->phy_iface;
1275 if (!bsp_priv->clk_enabled) {
1276 if (phy_iface == PHY_INTERFACE_MODE_RMII) {
1277 if (!IS_ERR(bsp_priv->mac_clk_rx))
1279 bsp_priv->mac_clk_rx);
1281 if (!IS_ERR(bsp_priv->clk_mac_ref))
1283 bsp_priv->clk_mac_ref);
1285 if (!IS_ERR(bsp_priv->clk_mac_refout))
1287 bsp_priv->clk_mac_refout);
1290 if (!IS_ERR(bsp_priv->clk_phy))
1291 clk_prepare_enable(bsp_priv->clk_phy);
1293 if (!IS_ERR(bsp_priv->aclk_mac))
1294 clk_prepare_enable(bsp_priv->aclk_mac);
1296 if (!IS_ERR(bsp_priv->pclk_mac))
1297 clk_prepare_enable(bsp_priv->pclk_mac);
1299 if (!IS_ERR(bsp_priv->mac_clk_tx))
1300 clk_prepare_enable(bsp_priv->mac_clk_tx);
1302 if (!IS_ERR(bsp_priv->clk_mac_speed))
1303 clk_prepare_enable(bsp_priv->clk_mac_speed);
1306 * if (!IS_ERR(bsp_priv->clk_mac))
1307 * clk_prepare_enable(bsp_priv->clk_mac);
1310 bsp_priv->clk_enabled = true;
1313 if (bsp_priv->clk_enabled) {
1314 if (phy_iface == PHY_INTERFACE_MODE_RMII) {
1315 clk_disable_unprepare(bsp_priv->mac_clk_rx);
1317 clk_disable_unprepare(bsp_priv->clk_mac_ref);
1319 clk_disable_unprepare(bsp_priv->clk_mac_refout);
1322 clk_disable_unprepare(bsp_priv->clk_phy);
1324 clk_disable_unprepare(bsp_priv->aclk_mac);
1326 clk_disable_unprepare(bsp_priv->pclk_mac);
1328 clk_disable_unprepare(bsp_priv->mac_clk_tx);
1330 clk_disable_unprepare(bsp_priv->clk_mac_speed);
1332 * if (!IS_ERR(bsp_priv->clk_mac))
1333 * clk_disable_unprepare(bsp_priv->clk_mac);
1335 bsp_priv->clk_enabled = false;
1342 static int phy_power_on(struct rk_priv_data *bsp_priv, bool enable)
1344 struct regulator *ldo = bsp_priv->regulator;
1346 struct device *dev = &bsp_priv->pdev->dev;
1352 ret = regulator_enable(ldo);
1354 dev_err(dev, "fail to enable phy-supply\n");
1356 ret = regulator_disable(ldo);
1358 dev_err(dev, "fail to disable phy-supply\n");
1364 static struct rk_priv_data *rk_gmac_setup(struct platform_device *pdev,
1365 struct plat_stmmacenet_data *plat,
1366 const struct rk_gmac_ops *ops)
1368 struct rk_priv_data *bsp_priv;
1369 struct device *dev = &pdev->dev;
1370 struct resource *res;
1372 const char *strings = NULL;
1375 bsp_priv = devm_kzalloc(dev, sizeof(*bsp_priv), GFP_KERNEL);
1377 return ERR_PTR(-ENOMEM);
1379 of_get_phy_mode(dev->of_node, &bsp_priv->phy_iface);
1380 bsp_priv->ops = ops;
1382 /* Some SoCs have multiple MAC controllers, which need
1383 * to be distinguished.
1385 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1389 while (ops->regs[i]) {
1390 if (ops->regs[i] == res->start) {
1398 bsp_priv->regulator = devm_regulator_get_optional(dev, "phy");
1399 if (IS_ERR(bsp_priv->regulator)) {
1400 if (PTR_ERR(bsp_priv->regulator) == -EPROBE_DEFER) {
1401 dev_err(dev, "phy regulator is not available yet, deferred probing\n");
1402 return ERR_PTR(-EPROBE_DEFER);
1404 dev_err(dev, "no regulator found\n");
1405 bsp_priv->regulator = NULL;
1408 ret = of_property_read_string(dev->of_node, "clock_in_out", &strings);
1410 dev_err(dev, "Can not read property: clock_in_out.\n");
1411 bsp_priv->clock_input = true;
1413 dev_info(dev, "clock input or output? (%s).\n",
1415 if (!strcmp(strings, "input"))
1416 bsp_priv->clock_input = true;
1418 bsp_priv->clock_input = false;
1421 ret = of_property_read_u32(dev->of_node, "tx_delay", &value);
1423 bsp_priv->tx_delay = 0x30;
1424 dev_err(dev, "Can not read property: tx_delay.");
1425 dev_err(dev, "set tx_delay to 0x%x\n",
1426 bsp_priv->tx_delay);
1428 dev_info(dev, "TX delay(0x%x).\n", value);
1429 bsp_priv->tx_delay = value;
1432 ret = of_property_read_u32(dev->of_node, "rx_delay", &value);
1434 bsp_priv->rx_delay = 0x10;
1435 dev_err(dev, "Can not read property: rx_delay.");
1436 dev_err(dev, "set rx_delay to 0x%x\n",
1437 bsp_priv->rx_delay);
1439 dev_info(dev, "RX delay(0x%x).\n", value);
1440 bsp_priv->rx_delay = value;
1443 bsp_priv->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
1446 if (plat->phy_node) {
1447 bsp_priv->integrated_phy = of_property_read_bool(plat->phy_node,
1448 "phy-is-integrated");
1449 if (bsp_priv->integrated_phy) {
1450 bsp_priv->phy_reset = of_reset_control_get(plat->phy_node, NULL);
1451 if (IS_ERR(bsp_priv->phy_reset)) {
1452 dev_err(&pdev->dev, "No PHY reset control found.\n");
1453 bsp_priv->phy_reset = NULL;
1457 dev_info(dev, "integrated PHY? (%s).\n",
1458 bsp_priv->integrated_phy ? "yes" : "no");
1460 bsp_priv->pdev = pdev;
1465 static int rk_gmac_check_ops(struct rk_priv_data *bsp_priv)
1467 switch (bsp_priv->phy_iface) {
1468 case PHY_INTERFACE_MODE_RGMII:
1469 case PHY_INTERFACE_MODE_RGMII_ID:
1470 case PHY_INTERFACE_MODE_RGMII_RXID:
1471 case PHY_INTERFACE_MODE_RGMII_TXID:
1472 if (!bsp_priv->ops->set_to_rgmii)
1475 case PHY_INTERFACE_MODE_RMII:
1476 if (!bsp_priv->ops->set_to_rmii)
1480 dev_err(&bsp_priv->pdev->dev,
1481 "unsupported interface %d", bsp_priv->phy_iface);
1486 static int rk_gmac_powerup(struct rk_priv_data *bsp_priv)
1489 struct device *dev = &bsp_priv->pdev->dev;
1491 ret = rk_gmac_check_ops(bsp_priv);
1495 ret = gmac_clk_enable(bsp_priv, true);
1500 switch (bsp_priv->phy_iface) {
1501 case PHY_INTERFACE_MODE_RGMII:
1502 dev_info(dev, "init for RGMII\n");
1503 bsp_priv->ops->set_to_rgmii(bsp_priv, bsp_priv->tx_delay,
1504 bsp_priv->rx_delay);
1506 case PHY_INTERFACE_MODE_RGMII_ID:
1507 dev_info(dev, "init for RGMII_ID\n");
1508 bsp_priv->ops->set_to_rgmii(bsp_priv, 0, 0);
1510 case PHY_INTERFACE_MODE_RGMII_RXID:
1511 dev_info(dev, "init for RGMII_RXID\n");
1512 bsp_priv->ops->set_to_rgmii(bsp_priv, bsp_priv->tx_delay, 0);
1514 case PHY_INTERFACE_MODE_RGMII_TXID:
1515 dev_info(dev, "init for RGMII_TXID\n");
1516 bsp_priv->ops->set_to_rgmii(bsp_priv, 0, bsp_priv->rx_delay);
1518 case PHY_INTERFACE_MODE_RMII:
1519 dev_info(dev, "init for RMII\n");
1520 bsp_priv->ops->set_to_rmii(bsp_priv);
1523 dev_err(dev, "NO interface defined!\n");
1526 ret = phy_power_on(bsp_priv, true);
1528 gmac_clk_enable(bsp_priv, false);
1532 pm_runtime_get_sync(dev);
1534 if (bsp_priv->integrated_phy)
1535 rk_gmac_integrated_phy_powerup(bsp_priv);
1540 static void rk_gmac_powerdown(struct rk_priv_data *gmac)
1542 if (gmac->integrated_phy)
1543 rk_gmac_integrated_phy_powerdown(gmac);
1545 pm_runtime_put_sync(&gmac->pdev->dev);
1547 phy_power_on(gmac, false);
1548 gmac_clk_enable(gmac, false);
1551 static void rk_fix_speed(void *priv, unsigned int speed)
1553 struct rk_priv_data *bsp_priv = priv;
1554 struct device *dev = &bsp_priv->pdev->dev;
1556 switch (bsp_priv->phy_iface) {
1557 case PHY_INTERFACE_MODE_RGMII:
1558 case PHY_INTERFACE_MODE_RGMII_ID:
1559 case PHY_INTERFACE_MODE_RGMII_RXID:
1560 case PHY_INTERFACE_MODE_RGMII_TXID:
1561 if (bsp_priv->ops->set_rgmii_speed)
1562 bsp_priv->ops->set_rgmii_speed(bsp_priv, speed);
1564 case PHY_INTERFACE_MODE_RMII:
1565 if (bsp_priv->ops->set_rmii_speed)
1566 bsp_priv->ops->set_rmii_speed(bsp_priv, speed);
1569 dev_err(dev, "unsupported interface %d", bsp_priv->phy_iface);
1573 static int rk_gmac_probe(struct platform_device *pdev)
1575 struct plat_stmmacenet_data *plat_dat;
1576 struct stmmac_resources stmmac_res;
1577 const struct rk_gmac_ops *data;
1580 data = of_device_get_match_data(&pdev->dev);
1582 dev_err(&pdev->dev, "no of match data provided\n");
1586 ret = stmmac_get_platform_resources(pdev, &stmmac_res);
1590 plat_dat = stmmac_probe_config_dt(pdev, stmmac_res.mac);
1591 if (IS_ERR(plat_dat))
1592 return PTR_ERR(plat_dat);
1594 /* If the stmmac is not already selected as gmac4,
1595 * then make sure we fallback to gmac.
1597 if (!plat_dat->has_gmac4)
1598 plat_dat->has_gmac = true;
1599 plat_dat->fix_mac_speed = rk_fix_speed;
1601 plat_dat->bsp_priv = rk_gmac_setup(pdev, plat_dat, data);
1602 if (IS_ERR(plat_dat->bsp_priv)) {
1603 ret = PTR_ERR(plat_dat->bsp_priv);
1604 goto err_remove_config_dt;
1607 ret = rk_gmac_clk_init(plat_dat);
1609 goto err_remove_config_dt;
1611 ret = rk_gmac_powerup(plat_dat->bsp_priv);
1613 goto err_remove_config_dt;
1615 ret = stmmac_dvr_probe(&pdev->dev, plat_dat, &stmmac_res);
1617 goto err_gmac_powerdown;
1622 rk_gmac_powerdown(plat_dat->bsp_priv);
1623 err_remove_config_dt:
1624 stmmac_remove_config_dt(pdev, plat_dat);
1629 static int rk_gmac_remove(struct platform_device *pdev)
1631 struct rk_priv_data *bsp_priv = get_stmmac_bsp_priv(&pdev->dev);
1632 int ret = stmmac_dvr_remove(&pdev->dev);
1634 rk_gmac_powerdown(bsp_priv);
1639 #ifdef CONFIG_PM_SLEEP
1640 static int rk_gmac_suspend(struct device *dev)
1642 struct rk_priv_data *bsp_priv = get_stmmac_bsp_priv(dev);
1643 int ret = stmmac_suspend(dev);
1645 /* Keep the PHY up if we use Wake-on-Lan. */
1646 if (!device_may_wakeup(dev)) {
1647 rk_gmac_powerdown(bsp_priv);
1648 bsp_priv->suspended = true;
1654 static int rk_gmac_resume(struct device *dev)
1656 struct rk_priv_data *bsp_priv = get_stmmac_bsp_priv(dev);
1658 /* The PHY was up for Wake-on-Lan. */
1659 if (bsp_priv->suspended) {
1660 rk_gmac_powerup(bsp_priv);
1661 bsp_priv->suspended = false;
1664 return stmmac_resume(dev);
1666 #endif /* CONFIG_PM_SLEEP */
1668 static SIMPLE_DEV_PM_OPS(rk_gmac_pm_ops, rk_gmac_suspend, rk_gmac_resume);
1670 static const struct of_device_id rk_gmac_dwmac_match[] = {
1671 { .compatible = "rockchip,px30-gmac", .data = &px30_ops },
1672 { .compatible = "rockchip,rk3128-gmac", .data = &rk3128_ops },
1673 { .compatible = "rockchip,rk3228-gmac", .data = &rk3228_ops },
1674 { .compatible = "rockchip,rk3288-gmac", .data = &rk3288_ops },
1675 { .compatible = "rockchip,rk3308-gmac", .data = &rk3308_ops },
1676 { .compatible = "rockchip,rk3328-gmac", .data = &rk3328_ops },
1677 { .compatible = "rockchip,rk3366-gmac", .data = &rk3366_ops },
1678 { .compatible = "rockchip,rk3368-gmac", .data = &rk3368_ops },
1679 { .compatible = "rockchip,rk3399-gmac", .data = &rk3399_ops },
1680 { .compatible = "rockchip,rk3568-gmac", .data = &rk3568_ops },
1681 { .compatible = "rockchip,rv1108-gmac", .data = &rv1108_ops },
1684 MODULE_DEVICE_TABLE(of, rk_gmac_dwmac_match);
1686 static struct platform_driver rk_gmac_dwmac_driver = {
1687 .probe = rk_gmac_probe,
1688 .remove = rk_gmac_remove,
1690 .name = "rk_gmac-dwmac",
1691 .pm = &rk_gmac_pm_ops,
1692 .of_match_table = rk_gmac_dwmac_match,
1695 module_platform_driver(rk_gmac_dwmac_driver);
1697 MODULE_AUTHOR("Chen-Zhi (Roger Chen) <roger.chen@rock-chips.com>");
1698 MODULE_DESCRIPTION("Rockchip RK3288 DWMAC specific glue layer");
1699 MODULE_LICENSE("GPL");