drivers/net/ethernet/rockchip/gmac/stmmac_platform.c

   1 /*******************************************************************************
   2   This contains the functions to handle the platform driver.
   3
   4   Copyright (C) 2007-2011  STMicroelectronics Ltd
   5
   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.
   9
  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
  13   more details.
  14
  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.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
  23 *******************************************************************************/
  24
  25 #include <linux/platform_device.h>
  26 #include <linux/io.h>
  27 #include <linux/of.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>
  33 #include "stmmac.h"
  34 #include <linux/rockchip/iomap.h>
  35 #include <linux/rockchip/grf.h>
  36
  37 #define grf_readl(offset)       readl_relaxed(RK_GRF_VIRT + offset)
  38 #define grf_writel(v, offset)   do { writel_relaxed(v, RK_GRF_VIRT + offset); dsb(); } while (0)
  39
  40 // RK3288_GRF_SOC_CON1
  41 #define GMAC_PHY_INTF_SEL_RGMII ((0x01C0 << 16) | (0x0040))
  42 #define GMAC_PHY_INTF_SEL_RMII  ((0x01C0 << 16) | (0x0100))
  43 #define GMAC_FLOW_CTRL          ((0x0200 << 16) | (0x0200))
  44 #define GMAC_FLOW_CTRL_CLR      ((0x0200 << 16) | (0x0000))
  45 #define GMAC_SPEED_10M          ((0x0400 << 16) | (0x0400))
  46 #define GMAC_SPEED_100M         ((0x0400 << 16) | (0x0000))
  47 #define GMAC_RMII_CLK_25M       ((0x0800 << 16) | (0x0800))
  48 #define GMAC_RMII_CLK_2_5M      ((0x0800 << 16) | (0x0000))
  49 #define GMAC_CLK_125M           ((0x3000 << 16) | (0x0000))
  50 #define GMAC_CLK_25M            ((0x3000 << 16) | (0x3000))
  51 #define GMAC_CLK_2_5M           ((0x3000 << 16) | (0x2000))
  52 #define GMAC_RMII_MODE          ((0x4000 << 16) | (0x4000))
  53 #define GMAC_RMII_MODE_CLR      ((0x4000 << 16) | (0x0000))
  54
  55 // RK3288_GRF_SOC_CON3
  56 #define GMAC_TXCLK_DLY_ENABLE   ((0x4000 << 16) | (0x4000))
  57 #define GMAC_TXCLK_DLY_DISABLE  ((0x4000 << 16) | (0x0000))
  58 #define GMAC_RXCLK_DLY_ENABLE   ((0x8000 << 16) | (0x8000))
  59 #define GMAC_RXCLK_DLY_DISABLE  ((0x8000 << 16) | (0x0000))
  60 #if 0
  61 #define GMAC_CLK_RX_DL_CFG      ((0x3F80 << 16) | (0x0800))
  62 #define GMAC_CLK_TX_DL_CFG      ((0x007F << 16) | (0x0040))
  63 #else
  64 #define GMAC_CLK_RX_DL_CFG(val) ((0x3F80 << 16) | (val<<7))        // 7bit
  65 #define GMAC_CLK_TX_DL_CFG(val) ((0x007F << 16) | (val))           // 7bit
  66 #endif
  67 struct bsp_priv g_bsp_priv;
  68
  69 static int phy_power_on(struct plat_stmmacenet_data *plat, int enable)
  70 {
  71         struct bsp_priv * bsp_priv;
  72
  73         printk("enter %s ,enable = %d \n",__func__,enable);
  74
  75         if ((plat) && (plat->bsp_priv)) {
  76                 bsp_priv = plat->bsp_priv;
  77         } else {
  78                 printk("ERROR: platform data or private data is NULL. %s\n", __FUNCTION__);
  79                 return -1;
  80         }
  81
  82         if (enable) {
  83                 //power on
  84                 if (gpio_is_valid(bsp_priv->power_io)) {
  85                         gpio_direction_output(bsp_priv->power_io, !bsp_priv->power_io_level);
  86                         msleep(10);
  87                         gpio_direction_output(bsp_priv->power_io, bsp_priv->power_io_level);
  88                         //gpio_set_value(bsp_priv->power_io, 1);
  89                 }
  90
  91                 //reset
  92                 if (gpio_is_valid(bsp_priv->reset_io)) {
  93                         gpio_direction_output(bsp_priv->reset_io, bsp_priv->reset_io_level);
  94                         //gpio_set_value(bsp_priv->reset_io, 0);
  95                         msleep(10);
  96                         gpio_direction_output(bsp_priv->reset_io, !bsp_priv->reset_io_level);
  97                 }
  98                 msleep(100);
  99         } else {
 100                 //power off
 101                 if (gpio_is_valid(bsp_priv->power_io)) {
 102                         gpio_direction_output(bsp_priv->power_io, !bsp_priv->power_io_level);
 103                         //gpio_set_value(bsp_priv->power_io, 0);
 104                 }
 105         }
 106
 107         return 0;
 108 }
 109
 110 int stmmc_pltfr_init(struct platform_device *pdev) {
 111         struct pinctrl_state *gmac_state;
 112         int phy_iface;
 113         int err;
 114
 115         printk("enter func %s...\n", __func__);
 116
 117 //iomux
 118 #if 0
 119         if ((pdev->dev.pins) && (pdev->dev.pins->p)) {
 120                 gmac_state = pinctrl_lookup_state(pdev->dev.pins->p, "default");
 121                 if (IS_ERR(gmac_state)) {
 122                                 dev_err(&pdev->dev, "no gmc pinctrl state\n");
 123                                 return -1;
 124                 }
 125
 126                 pinctrl_select_state(pdev->dev.pins->p, gmac_state);
 127         }
 128 #endif
 129
 130         struct bsp_priv * bsp_priv = &g_bsp_priv;
 131         phy_iface = bsp_priv->phy_iface;
 132 //power
 133         if (!gpio_is_valid(bsp_priv->power_io)) {
 134                 printk("%s: ERROR: Get power-gpio failed.\n", __func__);
 135                 //return -EINVAL;
 136         }
 137
 138         err = gpio_request(bsp_priv->power_io, "gmac_phy_power");
 139         if (err) {
 140                 printk("%s: ERROR: Request gmac phy power pin failed.\n", __func__);
 141                 //return -EINVAL;
 142         }
 143
 144         if (!gpio_is_valid(bsp_priv->reset_io)) {
 145                 printk("%s: ERROR: Get reset-gpio failed.\n", __func__);
 146                 //return -EINVAL;
 147         }
 148
 149         err = gpio_request(bsp_priv->reset_io, "gmac_phy_reset");
 150         if (err) {
 151                 printk("%s: ERROR: Request gmac phy reset pin failed.\n", __func__);
 152                 //return -EINVAL;
 153         }
 154
 155 //rmii or rgmii
 156         if (phy_iface & PHY_INTERFACE_MODE_RGMII) {
 157                 printk("init for RGMII\n");
 158                 grf_writel(GMAC_PHY_INTF_SEL_RGMII, RK3288_GRF_SOC_CON1);
 159                 grf_writel(GMAC_RMII_MODE_CLR, RK3288_GRF_SOC_CON1);
 160                 grf_writel(GMAC_RXCLK_DLY_ENABLE, RK3288_GRF_SOC_CON3);
 161                 grf_writel(GMAC_TXCLK_DLY_ENABLE, RK3288_GRF_SOC_CON3);
 162                 grf_writel(GMAC_CLK_RX_DL_CFG(0x10), RK3288_GRF_SOC_CON3);
 163                 grf_writel(GMAC_CLK_TX_DL_CFG(0x40), RK3288_GRF_SOC_CON3);
 164         } else if (phy_iface & PHY_INTERFACE_MODE_RMII) {
 165                 printk("init for RMII\n");
 166                 grf_writel(GMAC_PHY_INTF_SEL_RMII, RK3288_GRF_SOC_CON1);
 167                 grf_writel(GMAC_RMII_MODE, RK3288_GRF_SOC_CON1);
 168         } else {
 169                 printk("ERROR: NO interface defined!\n");
 170         }
 171
 172         return 0;
 173 }
 174
 175 void * stmmc_pltfr_fix_mac_speed(void *priv, unsigned int speed){
 176         printk("enter func %s...\n", __func__);
 177         struct bsp_priv * bsp_priv = priv;
 178         int interface;
 179
 180         printk("fix speed to %d\n", speed);
 181
 182         if (bsp_priv) {
 183                 interface = bsp_priv->phy_iface;
 184         }
 185
 186         if (interface & PHY_INTERFACE_MODE_RGMII) {
 187                 printk("fix speed for RGMII\n");
 188
 189                 switch (speed) {
 190                         case 10: {
 191                                 grf_writel(GMAC_CLK_2_5M, RK3288_GRF_SOC_CON1);
 192                                 break;
 193                         }
 194                         case 100: {
 195                                 grf_writel(GMAC_CLK_25M, RK3288_GRF_SOC_CON1);
 196                                 break;
 197                         }
 198                         case 1000: {
 199                                 grf_writel(GMAC_CLK_125M, RK3288_GRF_SOC_CON1);
 200                                 break;
 201                         }
 202                         default: {
 203                                 printk("ERROR: speed %d is not defined!\n");
 204                         }
 205                 }
 206
 207         } else if (interface & PHY_INTERFACE_MODE_RMII) {
 208                 printk("fix speed for RMII\n");
 209                 switch (speed) {
 210                         case 10: {
 211                                 grf_writel(GMAC_RMII_CLK_2_5M, RK3288_GRF_SOC_CON1);
 212                                 break;
 213                         }
 214                         case 100: {
 215                                 grf_writel(GMAC_RMII_CLK_25M, RK3288_GRF_SOC_CON1);
 216                                 break;
 217                         }
 218                         default: {
 219                                 printk("ERROR: speed %d is not defined!\n");
 220                         }
 221                 }
 222         } else {
 223                 printk("ERROR: NO interface defined!\n");
 224         }
 225
 226         return NULL;
 227 }
 228
 229
 230 #ifdef CONFIG_OF
 231 static int stmmac_probe_config_dt(struct platform_device *pdev,
 232                                   struct plat_stmmacenet_data *plat,
 233                                   const char **mac)
 234 {
 235         struct device_node *np = pdev->dev.of_node;
 236         enum of_gpio_flags flags;
 237
 238         if (!np)
 239                 return -ENODEV;
 240
 241         *mac = of_get_mac_address(np);
 242         plat->interface = of_get_phy_mode(np);
 243         plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
 244                                            sizeof(struct stmmac_mdio_bus_data),
 245                                            GFP_KERNEL);
 246
 247         plat->init = stmmc_pltfr_init;
 248         plat->fix_mac_speed = stmmc_pltfr_fix_mac_speed;
 249
 250         g_bsp_priv.reset_io =
 251                         of_get_named_gpio_flags(np, "reset-gpio", 0, &flags);
 252         g_bsp_priv.reset_io_level = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
 253         g_bsp_priv.power_io =
 254                         of_get_named_gpio_flags(np, "power-gpio", 0, &flags);
 255         g_bsp_priv.power_io_level = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
 256
 257         g_bsp_priv.phy_iface = plat->interface;
 258         g_bsp_priv.phy_power_on = phy_power_on;
 259
 260         plat->bsp_priv = &g_bsp_priv;
 261
 262         /*
 263          * Currently only the properties needed on SPEAr600
 264          * are provided. All other properties should be added
 265          * once needed on other platforms.
 266          */
 267         if (of_device_is_compatible(np, "rockchip,gmac")) {
 268                 plat->has_gmac = 1;
 269                 plat->pmt = 1;
 270         }
 271
 272         return 0;
 273 }
 274 #else
 275 static int stmmac_probe_config_dt(struct platform_device *pdev,
 276                                   struct plat_stmmacenet_data *plat,
 277                                   const char **mac)
 278 {
 279         return -ENOSYS;
 280 }
 281 #endif /* CONFIG_OF */
 282
 283 /**
 284  * stmmac_pltfr_probe
 285  * @pdev: platform device pointer
 286  * Description: platform_device probe function. It allocates
 287  * the necessary resources and invokes the main to init
 288  * the net device, register the mdio bus etc.
 289  */
 290 static int stmmac_pltfr_probe(struct platform_device *pdev)
 291 {
 292         int ret = 0;
 293         struct resource *res;
 294         struct device *dev = &pdev->dev;
 295         void __iomem *addr = NULL;
 296         struct stmmac_priv *priv = NULL;
 297         struct plat_stmmacenet_data *plat_dat = NULL;
 298         const char *mac = NULL;
 299
 300         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 301         if (!res)
 302                 return -ENODEV;
 303
 304         addr = devm_ioremap_resource(dev, res);
 305         if (IS_ERR(addr))
 306                 return PTR_ERR(addr);
 307
 308         if (pdev->dev.of_node) {
 309                 plat_dat = devm_kzalloc(&pdev->dev,
 310                                         sizeof(struct plat_stmmacenet_data),
 311                                         GFP_KERNEL);
 312                 if (!plat_dat) {
 313                         pr_err("%s: ERROR: no memory", __func__);
 314                         return  -ENOMEM;
 315                 }
 316
 317                 ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
 318                 if (ret) {
 319                         pr_err("%s: main dt probe failed", __func__);
 320                         return ret;
 321                 }
 322         } else {
 323                 plat_dat = pdev->dev.platform_data;
 324         }
 325
 326         /* Custom initialisation (if needed)*/
 327         if (plat_dat->init) {
 328                 ret = plat_dat->init(pdev);
 329                 if (unlikely(ret))
 330                         return ret;
 331         }
 332
 333         priv = stmmac_dvr_probe(&(pdev->dev), plat_dat, addr);
 334         if (!priv) {
 335                 pr_err("%s: main driver probe failed", __func__);
 336                 return -ENODEV;
 337         }
 338
 339         /* Get MAC address if available (DT) */
 340         if (mac)
 341                 memcpy(priv->dev->dev_addr, mac, ETH_ALEN);
 342
 343         /* Get the MAC information */
 344         priv->dev->irq = platform_get_irq_byname(pdev, "macirq");
 345         if (priv->dev->irq == -ENXIO) {
 346                 pr_err("%s: ERROR: MAC IRQ configuration "
 347                        "information not found\n", __func__);
 348                 return -ENXIO;
 349         }
 350
 351         /*
 352          * On some platforms e.g. SPEAr the wake up irq differs from the mac irq
 353          * The external wake up irq can be passed through the platform code
 354          * named as "eth_wake_irq"
 355          *
 356          * In case the wake up interrupt is not passed from the platform
 357          * so the driver will continue to use the mac irq (ndev->irq)
 358          */
 359         priv->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
 360         if (priv->wol_irq == -ENXIO)
 361                 priv->wol_irq = priv->dev->irq;
 362
 363         priv->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
 364
 365         platform_set_drvdata(pdev, priv->dev);
 366
 367         pr_debug("STMMAC platform driver registration completed");
 368
 369         return 0;
 370 }
 371
 372 /**
 373  * stmmac_pltfr_remove
 374  * @pdev: platform device pointer
 375  * Description: this function calls the main to free the net resources
 376  * and calls the platforms hook and release the resources (e.g. mem).
 377  */
 378 static int stmmac_pltfr_remove(struct platform_device *pdev)
 379 {
 380         struct net_device *ndev = platform_get_drvdata(pdev);
 381         struct stmmac_priv *priv = netdev_priv(ndev);
 382         int ret = stmmac_dvr_remove(ndev);
 383
 384         if (priv->plat->exit)
 385                 priv->plat->exit(pdev);
 386
 387         platform_set_drvdata(pdev, NULL);
 388
 389         return ret;
 390 }
 391
 392 #ifdef CONFIG_PM
 393 static int stmmac_pltfr_suspend(struct device *dev)
 394 {
 395         struct net_device *ndev = dev_get_drvdata(dev);
 396
 397         return stmmac_suspend(ndev);
 398 }
 399
 400 static int stmmac_pltfr_resume(struct device *dev)
 401 {
 402         struct net_device *ndev = dev_get_drvdata(dev);
 403
 404         return stmmac_resume(ndev);
 405 }
 406
 407 int stmmac_pltfr_freeze(struct device *dev)
 408 {
 409         int ret;
 410         struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
 411         struct net_device *ndev = dev_get_drvdata(dev);
 412         struct platform_device *pdev = to_platform_device(dev);
 413
 414         ret = stmmac_freeze(ndev);
 415         if (plat_dat->exit)
 416                 plat_dat->exit(pdev);
 417
 418         return ret;
 419 }
 420
 421 int stmmac_pltfr_restore(struct device *dev)
 422 {
 423         struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
 424         struct net_device *ndev = dev_get_drvdata(dev);
 425         struct platform_device *pdev = to_platform_device(dev);
 426
 427         if (plat_dat->init)
 428                 plat_dat->init(pdev);
 429
 430         return stmmac_restore(ndev);
 431 }
 432
 433 static const struct dev_pm_ops stmmac_pltfr_pm_ops = {
 434         .suspend = stmmac_pltfr_suspend,
 435         .resume = stmmac_pltfr_resume,
 436         .freeze = stmmac_pltfr_freeze,
 437         .thaw = stmmac_pltfr_restore,
 438         .restore = stmmac_pltfr_restore,
 439 };
 440 #else
 441 static const struct dev_pm_ops stmmac_pltfr_pm_ops;
 442 #endif /* CONFIG_PM */
 443
 444 static const struct of_device_id stmmac_dt_ids[] = {
 445         { .compatible = "rockchip,gmac"},
 446         { /* sentinel */ }
 447 };
 448 MODULE_DEVICE_TABLE(of, stmmac_dt_ids);
 449
 450 struct platform_driver stmmac_pltfr_driver = {
 451         .probe = stmmac_pltfr_probe,
 452         .remove = stmmac_pltfr_remove,
 453         .driver = {
 454                    .name = STMMAC_RESOURCE_NAME,
 455                    .owner = THIS_MODULE,
 456                    .pm = &stmmac_pltfr_pm_ops,
 457                    .of_match_table = of_match_ptr(stmmac_dt_ids),
 458                    },
 459 };
 460
 461 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PLATFORM driver");
 462 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
 463 MODULE_LICENSE("GPL");