1 /*******************************************************************************
2 This contains the functions to handle the platform driver.
4 Copyright (C) 2007-2011 STMicroelectronics Ltd
6 This program is free software; you can redistribute it and/or modify it
7 under the terms and conditions of the GNU General Public License,
8 version 2, as published by the Free Software Foundation.
10 This program is distributed in the hope it will be useful, but WITHOUT
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 You should have received a copy of the GNU General Public License along with
16 this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
22 Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
23 *******************************************************************************/
25 #include <linux/platform_device.h>
28 #include <linux/of_net.h>
29 #include <linux/gpio.h>
30 #include <linux/of_gpio.h>
31 #include <linux/of_device.h>
32 #include <dt-bindings/gpio/gpio.h>
34 #include <linux/rockchip/iomap.h>
35 #include <linux/rockchip/grf.h>
36 #include <linux/regulator/consumer.h>
38 #define grf_readl(offset) readl_relaxed(RK_GRF_VIRT + offset)
39 #define grf_writel(v, offset) do { writel_relaxed(v, RK_GRF_VIRT + offset); dsb(); } while (0)
43 #define GMAC_PHY_INTF_SEL_RGMII ((0x01C0 << 16) | (0x0040))
44 #define GMAC_PHY_INTF_SEL_RMII ((0x01C0 << 16) | (0x0100))
45 #define GMAC_FLOW_CTRL ((0x0200 << 16) | (0x0200))
46 #define GMAC_FLOW_CTRL_CLR ((0x0200 << 16) | (0x0000))
47 #define GMAC_SPEED_10M ((0x0400 << 16) | (0x0000))
48 #define GMAC_SPEED_100M ((0x0400 << 16) | (0x0400))
49 #define GMAC_RMII_CLK_25M ((0x0800 << 16) | (0x0800))
50 #define GMAC_RMII_CLK_2_5M ((0x0800 << 16) | (0x0000))
51 #define GMAC_CLK_125M ((0x3000 << 16) | (0x0000))
52 #define GMAC_CLK_25M ((0x3000 << 16) | (0x3000))
53 #define GMAC_CLK_2_5M ((0x3000 << 16) | (0x2000))
54 #define GMAC_RMII_MODE ((0x4000 << 16) | (0x4000))
55 #define GMAC_RMII_MODE_CLR ((0x4000 << 16) | (0x0000))
59 #define GMAC_TXCLK_DLY_ENABLE ((0x4000 << 16) | (0x4000))
60 #define GMAC_TXCLK_DLY_DISABLE ((0x4000 << 16) | (0x0000))
61 #define GMAC_RXCLK_DLY_ENABLE ((0x8000 << 16) | (0x8000))
62 #define GMAC_RXCLK_DLY_DISABLE ((0x8000 << 16) | (0x0000))
63 #define GMAC_CLK_RX_DL_CFG(val) ((0x3F80 << 16) | (val<<7)) // 7bit
64 #define GMAC_CLK_TX_DL_CFG(val) ((0x007F << 16) | (val)) // 7bit
66 static void SET_RGMII(int type, int tx_delay, int rx_delay)
68 if (type == RK3288_GMAC) {
69 grf_writel(GMAC_PHY_INTF_SEL_RGMII, RK3288_GRF_SOC_CON1);
70 grf_writel(GMAC_RMII_MODE_CLR, RK3288_GRF_SOC_CON1);
71 grf_writel(GMAC_RXCLK_DLY_ENABLE, RK3288_GRF_SOC_CON3);
72 grf_writel(GMAC_TXCLK_DLY_ENABLE, RK3288_GRF_SOC_CON3);
73 grf_writel(GMAC_CLK_RX_DL_CFG(rx_delay), RK3288_GRF_SOC_CON3);
74 grf_writel(GMAC_CLK_TX_DL_CFG(tx_delay), RK3288_GRF_SOC_CON3);
75 pr_info("tx delay=0x%x\nrx delay=0x%x\n", tx_delay, rx_delay);
76 //grf_writel(0xffffffff,RK3288_GRF_GPIO3D_E);
77 //grf_writel(grf_readl(RK3288_GRF_GPIO4B_E) | 0x3<<2<<16 | 0x3<<2, RK3288_GRF_GPIO4B_E);
78 //grf_writel(0xffffffff,RK3288_GRF_GPIO4A_E);
79 } else if (type == RK312X_GMAC) {
80 grf_writel(GMAC_PHY_INTF_SEL_RGMII, RK312X_GRF_MAC_CON1);
81 grf_writel(GMAC_RMII_MODE_CLR, RK312X_GRF_MAC_CON1);
82 grf_writel(GMAC_RXCLK_DLY_ENABLE, RK312X_GRF_MAC_CON0);
83 grf_writel(GMAC_TXCLK_DLY_ENABLE, RK312X_GRF_MAC_CON0);
84 grf_writel(GMAC_CLK_RX_DL_CFG(rx_delay), RK312X_GRF_MAC_CON0);
85 grf_writel(GMAC_CLK_TX_DL_CFG(tx_delay), RK312X_GRF_MAC_CON0);
86 pr_info("tx delay=0x%x\nrx delay=0x%x\n", tx_delay, rx_delay);
90 static void SET_RMII(int type)
92 if (type == RK3288_GMAC) {
93 grf_writel(GMAC_PHY_INTF_SEL_RMII, RK3288_GRF_SOC_CON1);
94 grf_writel(GMAC_RMII_MODE, RK3288_GRF_SOC_CON1);
95 } else if (type == RK312X_GMAC) {
96 grf_writel(GMAC_PHY_INTF_SEL_RMII, RK312X_GRF_MAC_CON1);
97 grf_writel(GMAC_RMII_MODE, RK312X_GRF_MAC_CON1);
101 static void SET_RGMII_10M(int type)
103 if (type == RK3288_GMAC) {
104 grf_writel(GMAC_CLK_2_5M, RK3288_GRF_SOC_CON1);
105 } else if (type == RK312X_GMAC) {
106 grf_writel(GMAC_CLK_2_5M, RK312X_GRF_MAC_CON1);
110 static void SET_RGMII_100M(int type)
112 if (type == RK3288_GMAC) {
113 grf_writel(GMAC_CLK_25M, RK3288_GRF_SOC_CON1);
114 } else if (type == RK312X_GMAC) {
115 grf_writel(GMAC_CLK_25M, RK312X_GRF_MAC_CON1);
119 static void SET_RGMII_1000M(int type)
121 if (type == RK3288_GMAC) {
122 grf_writel(GMAC_CLK_125M, RK3288_GRF_SOC_CON1);
123 } else if (type == RK312X_GMAC) {
124 grf_writel(GMAC_CLK_125M, RK312X_GRF_MAC_CON1);
128 static void SET_RMII_10M(int type)
130 if (type == RK3288_GMAC) {
131 grf_writel(GMAC_RMII_CLK_2_5M, RK3288_GRF_SOC_CON1);
132 grf_writel(GMAC_SPEED_10M, RK3288_GRF_SOC_CON1);
133 } else if (type == RK312X_GMAC) {
134 grf_writel(GMAC_RMII_CLK_2_5M, RK312X_GRF_MAC_CON1);
135 grf_writel(GMAC_SPEED_10M, RK312X_GRF_MAC_CON1);
139 static void SET_RMII_100M(int type)
141 if (type == RK3288_GMAC) {
142 grf_writel(GMAC_RMII_CLK_25M, RK3288_GRF_SOC_CON1);
143 grf_writel(GMAC_SPEED_100M, RK3288_GRF_SOC_CON1);
144 } else if (type == RK312X_GMAC) {
145 grf_writel(GMAC_RMII_CLK_25M, RK312X_GRF_MAC_CON1);
146 grf_writel(GMAC_SPEED_100M, RK312X_GRF_MAC_CON1);
150 struct bsp_priv g_bsp_priv;
152 int gmac_clk_init(struct device *device)
154 struct bsp_priv * bsp_priv = &g_bsp_priv;
156 bsp_priv->clk_enable = false;
158 bsp_priv->mac_clk_rx = clk_get(device,"mac_clk_rx");
159 if (IS_ERR(bsp_priv->mac_clk_rx)) {
160 pr_warn("%s: warning: cannot get mac_clk_rx clock\n", __func__);
163 bsp_priv->mac_clk_tx = clk_get(device,"mac_clk_tx");
164 if (IS_ERR(bsp_priv->mac_clk_tx)) {
165 pr_warn("%s: warning: cannot get mac_clk_tx clock\n", __func__);
168 bsp_priv->clk_mac_ref = clk_get(device,"clk_mac_ref");
169 if (IS_ERR(bsp_priv->clk_mac_ref)) {
170 pr_warn("%s: warning: cannot get clk_mac_ref clock\n", __func__);
173 bsp_priv->clk_mac_refout = clk_get(device,"clk_mac_refout");
174 if (IS_ERR(bsp_priv->clk_mac_refout)) {
175 pr_warn("%s: warning: cannot get clk_mac_refout clock\n", __func__);
178 bsp_priv->aclk_mac = clk_get(device,"aclk_mac");
179 if (IS_ERR(bsp_priv->aclk_mac)) {
180 pr_warn("%s: warning: cannot get aclk_mac clock\n", __func__);
183 bsp_priv->pclk_mac = clk_get(device,"pclk_mac");
184 if (IS_ERR(bsp_priv->pclk_mac)) {
185 pr_warn("%s: warning: cannot get pclk_mac clock\n", __func__);
188 bsp_priv->clk_mac_pll = clk_get(device,"clk_mac_pll");
189 if (IS_ERR(bsp_priv->clk_mac_pll)) {
190 pr_warn("%s: warning: cannot get clk_mac_pll clock\n", __func__);
193 bsp_priv->gmac_clkin = clk_get(device,"gmac_clkin");
194 if (IS_ERR(bsp_priv->gmac_clkin)) {
195 pr_warn("%s: warning: cannot get gmac_clkin clock\n", __func__);
198 bsp_priv->clk_mac = clk_get(device, "clk_mac");
199 if (IS_ERR(bsp_priv->clk_mac)) {
200 pr_warn("%s: warning: cannot get clk_mac clock\n", __func__);
203 if (bsp_priv->clock_input) {
204 if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
205 clk_set_rate(bsp_priv->gmac_clkin, 50000000);
207 clk_set_parent(bsp_priv->clk_mac, bsp_priv->gmac_clkin);
209 if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
210 clk_set_rate(bsp_priv->clk_mac_pll, 50000000);
212 clk_set_parent(bsp_priv->clk_mac, bsp_priv->clk_mac_pll);
217 static int gmac_clk_enable(bool enable) {
219 struct bsp_priv * bsp_priv = &g_bsp_priv;
220 phy_iface = bsp_priv->phy_iface;
223 if (!bsp_priv->clk_enable) {
224 if (phy_iface == PHY_INTERFACE_MODE_RMII) {
225 if (!IS_ERR(bsp_priv->mac_clk_rx))
226 clk_prepare_enable(bsp_priv->mac_clk_rx);
228 if (!IS_ERR(bsp_priv->clk_mac_ref))
229 clk_prepare_enable(bsp_priv->clk_mac_ref);
231 if (!IS_ERR(bsp_priv->clk_mac_refout))
232 clk_prepare_enable(bsp_priv->clk_mac_refout);
235 if (!IS_ERR(bsp_priv->aclk_mac))
236 clk_prepare_enable(bsp_priv->aclk_mac);
238 if (!IS_ERR(bsp_priv->pclk_mac))
239 clk_prepare_enable(bsp_priv->pclk_mac);
241 if (!IS_ERR(bsp_priv->mac_clk_tx))
242 clk_prepare_enable(bsp_priv->mac_clk_tx);
244 if (!IS_ERR(bsp_priv->clk_mac))
245 clk_prepare_enable(bsp_priv->clk_mac);
248 bsp_priv->clk_enable = true;
251 if (bsp_priv->clk_enable) {
252 if (phy_iface == PHY_INTERFACE_MODE_RMII) {
253 if (!IS_ERR(bsp_priv->mac_clk_rx))
254 clk_disable_unprepare(bsp_priv->mac_clk_rx);
256 if (!IS_ERR(bsp_priv->clk_mac_ref))
257 clk_disable_unprepare(bsp_priv->clk_mac_ref);
259 if (!IS_ERR(bsp_priv->clk_mac_refout))
260 clk_disable_unprepare(bsp_priv->clk_mac_refout);
263 if (!IS_ERR(bsp_priv->aclk_mac))
264 clk_disable_unprepare(bsp_priv->aclk_mac);
266 if (!IS_ERR(bsp_priv->pclk_mac))
267 clk_disable_unprepare(bsp_priv->pclk_mac);
269 if (!IS_ERR(bsp_priv->mac_clk_tx))
270 clk_disable_unprepare(bsp_priv->mac_clk_tx);
272 if (!IS_ERR(bsp_priv->clk_mac))
273 clk_disable_unprepare(bsp_priv->clk_mac);
275 bsp_priv->clk_enable = false;
282 static int power_on_by_pmu(bool enable) {
283 struct bsp_priv * bsp_priv = &g_bsp_priv;
284 struct regulator * ldo;
285 char * ldostr = bsp_priv->pmu_regulator;
288 if (ldostr == NULL) {
289 pr_err("%s: no ldo found\n", __func__);
293 ldo = regulator_get(NULL, ldostr);
295 pr_err("\n%s get ldo %s failed\n", __func__, ldostr);
298 if(!regulator_is_enabled(ldo)) {
299 regulator_set_voltage(ldo, 3300000, 3300000);
300 ret = regulator_enable(ldo);
302 pr_err("%s: faild to enable %s\n", __func__, ldostr);
304 pr_info("turn on ldo done.\n");
307 pr_warn("%s is enabled before enable", ldostr);
310 if(regulator_is_enabled(ldo)) {
311 ret = regulator_disable(ldo);
313 pr_err("%s: faild to disable %s\n", __func__, ldostr);
315 pr_info("turn off ldo done.\n");
318 pr_warn("%s is disabled before disable", ldostr);
327 static int power_on_by_gpio(bool enable) {
328 struct bsp_priv * bsp_priv = &g_bsp_priv;
331 if (gpio_is_valid(bsp_priv->power_io)) {
332 gpio_direction_output(bsp_priv->power_io, bsp_priv->power_io_level);
336 if (gpio_is_valid(bsp_priv->power_io)) {
337 gpio_direction_output(bsp_priv->power_io, !bsp_priv->power_io_level);
344 static int phy_power_on(bool enable)
346 struct bsp_priv *bsp_priv = &g_bsp_priv;
349 printk("%s: enable = %d \n", __func__, enable);
351 if (bsp_priv->power_ctrl_by_pmu) {
352 ret = power_on_by_pmu(enable);
354 ret = power_on_by_gpio(enable);
359 if (gpio_is_valid(bsp_priv->reset_io)) {
360 gpio_direction_output(bsp_priv->reset_io, bsp_priv->reset_io_level);
362 gpio_direction_output(bsp_priv->reset_io, !bsp_priv->reset_io_level);
368 if (gpio_is_valid(bsp_priv->reset_io)) {
369 gpio_direction_output(bsp_priv->reset_io, bsp_priv->reset_io_level);
376 int stmmc_pltfr_init(struct platform_device *pdev) {
379 struct bsp_priv *bsp_priv;
382 pr_info("%s: \n", __func__);
386 if ((pdev->dev.pins) && (pdev->dev.pins->p)) {
387 gmac_state = pinctrl_lookup_state(pdev->dev.pins->p, "default");
388 if (IS_ERR(gmac_state)) {
389 dev_err(&pdev->dev, "no gmc pinctrl state\n");
393 pinctrl_select_state(pdev->dev.pins->p, gmac_state);
397 bsp_priv = &g_bsp_priv;
398 phy_iface = bsp_priv->phy_iface;
400 if (!gpio_is_valid(bsp_priv->power_io)) {
401 pr_err("%s: ERROR: Get power-gpio failed.\n", __func__);
403 err = gpio_request(bsp_priv->power_io, "gmac_phy_power");
405 pr_err("%s: ERROR: Request gmac phy power pin failed.\n", __func__);
409 if (!gpio_is_valid(bsp_priv->reset_io)) {
410 pr_err("%s: ERROR: Get reset-gpio failed.\n", __func__);
412 err = gpio_request(bsp_priv->reset_io, "gmac_phy_reset");
414 pr_err("%s: ERROR: Request gmac phy reset pin failed.\n", __func__);
418 if (bsp_priv->phyirq_io > 0) {
419 err = gpio_request(bsp_priv->phyirq_io, "gmac_phyirq");
421 printk("gmac_phyirq: failed to request GPIO %d,"
422 " error %d\n", bsp_priv->phyirq_io, err);
424 err = gpio_direction_input(bsp_priv->phyirq_io);
426 pr_err("gmac_phyirq: failed to configure input"
427 " direction for GPIO %d, error %d\n",
428 bsp_priv->phyirq_io, err);
429 gpio_free(bsp_priv->phyirq_io);
431 irq = gpio_to_irq(bsp_priv->phyirq_io);
434 pr_err("gpio-keys: Unable to get irq number for GPIO %d, error %d\n", bsp_priv->phyirq_io, err);
435 gpio_free(bsp_priv->phyirq_io);
437 struct plat_stmmacenet_data *plat_dat = dev_get_platdata(&pdev->dev);
439 plat_dat->mdio_bus_data->probed_phy_irq = irq;
441 pr_err("%s: plat_data is NULL\n", __func__);
448 if (phy_iface == PHY_INTERFACE_MODE_RGMII) {
449 pr_info("%s: init for RGMII\n", __func__);
450 SET_RGMII(bsp_priv->chip, bsp_priv->tx_delay, bsp_priv->rx_delay);
451 } else if (phy_iface == PHY_INTERFACE_MODE_RMII) {
452 pr_info("%s: init for RMII\n", __func__);
453 SET_RMII(bsp_priv->chip);
455 pr_err("%s: ERROR: NO interface defined!\n", __func__);
461 void stmmc_pltfr_fix_mac_speed(void *priv, unsigned int speed){
462 struct bsp_priv * bsp_priv = priv;
465 pr_info("%s: fix speed to %d\n", __func__, speed);
468 interface = bsp_priv->phy_iface;
471 if (interface == PHY_INTERFACE_MODE_RGMII) {
472 pr_info("%s: fix speed for RGMII\n", __func__);
476 SET_RGMII_10M(bsp_priv->chip);
480 SET_RGMII_100M(bsp_priv->chip);
484 SET_RGMII_1000M(bsp_priv->chip);
488 pr_err("%s: ERROR: speed %d is not defined!\n", __func__, speed);
492 } else if (interface == PHY_INTERFACE_MODE_RMII) {
493 pr_info("%s: fix speed for RMII\n", __func__);
496 SET_RMII_10M(bsp_priv->chip);
500 SET_RMII_100M(bsp_priv->chip);
504 pr_err("%s: ERROR: speed %d is not defined!\n", __func__, speed);
508 pr_err("%s: ERROR: NO interface defined!\n", __func__);
514 static int stmmac_probe_config_dt(struct platform_device *pdev,
515 struct plat_stmmacenet_data *plat,
518 struct device_node *np = pdev->dev.of_node;
519 enum of_gpio_flags flags;
521 const char * strings = NULL;
527 *mac = of_get_mac_address(np);
528 plat->interface = of_get_phy_mode(np);
530 plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
531 sizeof(struct stmmac_mdio_bus_data),
534 plat->init = stmmc_pltfr_init;
535 plat->fix_mac_speed = stmmc_pltfr_fix_mac_speed;
537 ret = of_property_read_string(np, "pmu_regulator", &strings);
539 pr_err("%s: Can not read property: pmu_regulator.\n", __func__);
540 g_bsp_priv.power_ctrl_by_pmu = false;
542 pr_info("%s: ethernet phy power controled by pmu(%s).\n", __func__, strings);
543 g_bsp_priv.power_ctrl_by_pmu = true;
544 strcpy(g_bsp_priv.pmu_regulator, strings);
547 ret = of_property_read_u32(np, "pmu_enable_level", &value);
549 pr_err("%s: Can not read property: pmu_enable_level.\n", __func__);
550 g_bsp_priv.power_ctrl_by_pmu = false;
552 pr_info("%s: ethernet phy power controled by pmu(level = %s).\n", __func__, (value == 1)?"HIGH":"LOW");
553 g_bsp_priv.power_ctrl_by_pmu = true;
554 g_bsp_priv.pmu_enable_level = value;
557 ret = of_property_read_string(np, "clock_in_out", &strings);
559 pr_err("%s: Can not read property: clock_in_out.\n", __func__);
560 g_bsp_priv.clock_input = true;
562 pr_info("%s: clock input or output? (%s).\n", __func__, strings);
563 if (!strcmp(strings, "input")) {
564 g_bsp_priv.clock_input = true;
566 g_bsp_priv.clock_input = false;
570 ret = of_property_read_u32(np, "tx_delay", &value);
572 g_bsp_priv.tx_delay = 0x30;
573 pr_err("%s: Can not read property: tx_delay. set tx_delay to 0x%x\n", __func__, g_bsp_priv.tx_delay);
575 pr_info("%s: TX delay(0x%x).\n", __func__, value);
576 g_bsp_priv.tx_delay = value;
579 ret = of_property_read_u32(np, "rx_delay", &value);
581 g_bsp_priv.rx_delay = 0x10;
582 pr_err("%s: Can not read property: rx_delay. set rx_delay to 0x%x\n", __func__, g_bsp_priv.rx_delay);
584 pr_info("%s: RX delay(0x%x).\n", __func__, value);
585 g_bsp_priv.rx_delay = value;
588 g_bsp_priv.phyirq_io =
589 of_get_named_gpio_flags(np, "phyirq-gpio", 0, &flags);
590 g_bsp_priv.phyirq_io_level = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
592 g_bsp_priv.reset_io =
593 of_get_named_gpio_flags(np, "reset-gpio", 0, &flags);
594 g_bsp_priv.reset_io_level = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
595 g_bsp_priv.power_io =
596 of_get_named_gpio_flags(np, "power-gpio", 0, &flags);
597 g_bsp_priv.power_io_level = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
599 g_bsp_priv.phy_iface = plat->interface;
600 g_bsp_priv.phy_power_on = phy_power_on;
601 g_bsp_priv.gmac_clk_enable = gmac_clk_enable;
603 plat->bsp_priv = &g_bsp_priv;
606 * Currently only the properties needed on SPEAr600
607 * are provided. All other properties should be added
608 * once needed on other platforms.
610 if (of_device_is_compatible(np, "rockchip,rk3288-gmac") ||
611 of_device_is_compatible(np, "rockchip,rk312x-gmac")) {
616 if (of_device_is_compatible(np, "rockchip,rk3288-gmac")) {
617 g_bsp_priv.chip = RK3288_GMAC;
618 printk("%s: is rockchip,rk3288-gmac", __func__);
619 } if (of_device_is_compatible(np, "rockchip,rk312x-gmac")) {
620 g_bsp_priv.chip = RK312X_GMAC;
621 printk("%s: is rockchip,rk312x-gmac", __func__);
627 static int stmmac_probe_config_dt(struct platform_device *pdev,
628 struct plat_stmmacenet_data *plat,
633 #endif /* CONFIG_OF */
637 * @pdev: platform device pointer
638 * Description: platform_device probe function. It allocates
639 * the necessary resources and invokes the main to init
640 * the net device, register the mdio bus etc.
642 static int stmmac_pltfr_probe(struct platform_device *pdev)
645 struct resource *res;
646 struct device *dev = &pdev->dev;
647 void __iomem *addr = NULL;
648 struct stmmac_priv *priv = NULL;
649 struct plat_stmmacenet_data *plat_dat = NULL;
650 const char *mac = NULL;
652 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
656 addr = devm_ioremap_resource(dev, res);
658 return PTR_ERR(addr);
660 if (pdev->dev.of_node) {
661 plat_dat = devm_kzalloc(&pdev->dev,
662 sizeof(struct plat_stmmacenet_data),
665 pr_err("%s: ERROR: no memory", __func__);
669 ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
671 pr_err("%s: main dt probe failed", __func__);
675 pdev->dev.platform_data = plat_dat;
678 plat_dat = pdev->dev.platform_data;
681 /* Custom initialisation (if needed)*/
682 if (plat_dat->init) {
683 ret = plat_dat->init(pdev);
688 gmac_clk_init(&(pdev->dev));
690 priv = stmmac_dvr_probe(&(pdev->dev), plat_dat, addr);
692 pr_err("%s: main driver probe failed", __func__);
697 /* Get MAC address if available (DT) */
699 memcpy(priv->dev->dev_addr, mac, ETH_ALEN);
701 /* Get the MAC information */
702 priv->dev->irq = platform_get_irq_byname(pdev, "macirq");
703 if (priv->dev->irq == -ENXIO) {
704 pr_err("%s: ERROR: MAC IRQ configuration "
705 "information not found\n", __func__);
710 * On some platforms e.g. SPEAr the wake up irq differs from the mac irq
711 * The external wake up irq can be passed through the platform code
712 * named as "eth_wake_irq"
714 * In case the wake up interrupt is not passed from the platform
715 * so the driver will continue to use the mac irq (ndev->irq)
717 priv->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
718 if (priv->wol_irq == -ENXIO)
719 priv->wol_irq = priv->dev->irq;
721 priv->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
723 platform_set_drvdata(pdev, priv->dev);
725 pr_debug("STMMAC platform driver registration completed");
731 * stmmac_pltfr_remove
732 * @pdev: platform device pointer
733 * Description: this function calls the main to free the net resources
734 * and calls the platforms hook and release the resources (e.g. mem).
736 static int stmmac_pltfr_remove(struct platform_device *pdev)
738 struct net_device *ndev = platform_get_drvdata(pdev);
739 struct stmmac_priv *priv = netdev_priv(ndev);
740 int ret = stmmac_dvr_remove(ndev);
742 if (priv->plat->exit)
743 priv->plat->exit(pdev);
745 platform_set_drvdata(pdev, NULL);
751 static int stmmac_pltfr_suspend(struct device *dev)
753 struct net_device *ndev = dev_get_drvdata(dev);
755 return stmmac_suspend(ndev);
758 static int stmmac_pltfr_resume(struct device *dev)
760 struct net_device *ndev = dev_get_drvdata(dev);
762 return stmmac_resume(ndev);
765 int stmmac_pltfr_freeze(struct device *dev)
768 struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
769 struct net_device *ndev = dev_get_drvdata(dev);
770 struct platform_device *pdev = to_platform_device(dev);
772 ret = stmmac_freeze(ndev);
774 plat_dat->exit(pdev);
779 int stmmac_pltfr_restore(struct device *dev)
781 struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
782 struct net_device *ndev = dev_get_drvdata(dev);
783 struct platform_device *pdev = to_platform_device(dev);
786 plat_dat->init(pdev);
788 return stmmac_restore(ndev);
791 static const struct dev_pm_ops stmmac_pltfr_pm_ops = {
792 .suspend = stmmac_pltfr_suspend,
793 .resume = stmmac_pltfr_resume,
794 .freeze = stmmac_pltfr_freeze,
795 .thaw = stmmac_pltfr_restore,
796 .restore = stmmac_pltfr_restore,
799 static const struct dev_pm_ops stmmac_pltfr_pm_ops;
800 #endif /* CONFIG_PM */
802 static const struct of_device_id stmmac_dt_ids[] = {
803 { .compatible = "rockchip,rk3288-gmac"},
804 { .compatible = "rockchip,rk312x-gmac"},
807 MODULE_DEVICE_TABLE(of, stmmac_dt_ids);
809 struct platform_driver stmmac_pltfr_driver = {
810 .probe = stmmac_pltfr_probe,
811 .remove = stmmac_pltfr_remove,
813 .name = STMMAC_RESOURCE_NAME,
814 .owner = THIS_MODULE,
815 .pm = &stmmac_pltfr_pm_ops,
816 .of_match_table = of_match_ptr(stmmac_dt_ids),
820 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PLATFORM driver");
821 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
822 MODULE_LICENSE("GPL");