drivers/net/ethernet/stmicro/stmmac/dwmac-rk.c

   1 /**
   2  * dwmac-rk.c - Rockchip RK3288 DWMAC specific glue layer
   3  *
   4  * Copyright (C) 2014 Chen-Zhi (Roger Chen)
   5  *
   6  * Chen-Zhi (Roger Chen)  <roger.chen@rock-chips.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/stmmac.h>
  20 #include <linux/bitops.h>
  21 #include <linux/clk.h>
  22 #include <linux/phy.h>
  23 #include <linux/of_net.h>
  24 #include <linux/gpio.h>
  25 #include <linux/module.h>
  26 #include <linux/of_gpio.h>
  27 #include <linux/of_device.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/regulator/consumer.h>
  30 #include <linux/delay.h>
  31 #include <linux/mfd/syscon.h>
  32 #include <linux/regmap.h>
  33
  34 #include "stmmac_platform.h"
  35
  36 struct rk_priv_data {
  37         struct platform_device *pdev;
  38         int phy_iface;
  39         struct regulator *regulator;
  40
  41         bool clk_enabled;
  42         bool clock_input;
  43
  44         struct clk *clk_mac;
  45         struct clk *gmac_clkin;
  46         struct clk *mac_clk_rx;
  47         struct clk *mac_clk_tx;
  48         struct clk *clk_mac_ref;
  49         struct clk *clk_mac_refout;
  50         struct clk *aclk_mac;
  51         struct clk *pclk_mac;
  52
  53         int tx_delay;
  54         int rx_delay;
  55
  56         struct regmap *grf;
  57 };
  58
  59 #define HIWORD_UPDATE(val, mask, shift) \
  60                 ((val) << (shift) | (mask) << ((shift) + 16))
  61
  62 #define GRF_BIT(nr)     (BIT(nr) | BIT(nr+16))
  63 #define GRF_CLR_BIT(nr) (BIT(nr+16))
  64
  65 #define RK3288_GRF_SOC_CON1     0x0248
  66 #define RK3288_GRF_SOC_CON3     0x0250
  67
  68 /*RK3288_GRF_SOC_CON1*/
  69 #define GMAC_PHY_INTF_SEL_RGMII (GRF_BIT(6) | GRF_CLR_BIT(7) | GRF_CLR_BIT(8))
  70 #define GMAC_PHY_INTF_SEL_RMII  (GRF_CLR_BIT(6) | GRF_CLR_BIT(7) | GRF_BIT(8))
  71 #define GMAC_FLOW_CTRL          GRF_BIT(9)
  72 #define GMAC_FLOW_CTRL_CLR      GRF_CLR_BIT(9)
  73 #define GMAC_SPEED_10M          GRF_CLR_BIT(10)
  74 #define GMAC_SPEED_100M         GRF_BIT(10)
  75 #define GMAC_RMII_CLK_25M       GRF_BIT(11)
  76 #define GMAC_RMII_CLK_2_5M      GRF_CLR_BIT(11)
  77 #define GMAC_CLK_125M           (GRF_CLR_BIT(12) | GRF_CLR_BIT(13))
  78 #define GMAC_CLK_25M            (GRF_BIT(12) | GRF_BIT(13))
  79 #define GMAC_CLK_2_5M           (GRF_CLR_BIT(12) | GRF_BIT(13))
  80 #define GMAC_RMII_MODE          GRF_BIT(14)
  81 #define GMAC_RMII_MODE_CLR      GRF_CLR_BIT(14)
  82
  83 /*RK3288_GRF_SOC_CON3*/
  84 #define GMAC_TXCLK_DLY_ENABLE   GRF_BIT(14)
  85 #define GMAC_TXCLK_DLY_DISABLE  GRF_CLR_BIT(14)
  86 #define GMAC_RXCLK_DLY_ENABLE   GRF_BIT(15)
  87 #define GMAC_RXCLK_DLY_DISABLE  GRF_CLR_BIT(15)
  88 #define GMAC_CLK_RX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 7)
  89 #define GMAC_CLK_TX_DL_CFG(val) HIWORD_UPDATE(val, 0x7F, 0)
  90
  91 static void set_to_rgmii(struct rk_priv_data *bsp_priv,
  92                          int tx_delay, int rx_delay)
  93 {
  94         struct device *dev = &bsp_priv->pdev->dev;
  95
  96         if (IS_ERR(bsp_priv->grf)) {
  97                 dev_err(dev, "Missing rockchip,grf property\n");
  98                 return;
  99         }
 100
 101         regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
 102                      GMAC_PHY_INTF_SEL_RGMII | GMAC_RMII_MODE_CLR);
 103         regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON3,
 104                      GMAC_RXCLK_DLY_ENABLE | GMAC_TXCLK_DLY_ENABLE |
 105                      GMAC_CLK_RX_DL_CFG(rx_delay) |
 106                      GMAC_CLK_TX_DL_CFG(tx_delay));
 107 }
 108
 109 static void set_to_rmii(struct rk_priv_data *bsp_priv)
 110 {
 111         struct device *dev = &bsp_priv->pdev->dev;
 112
 113         if (IS_ERR(bsp_priv->grf)) {
 114                 dev_err(dev, "Missing rockchip,grf property\n");
 115                 return;
 116         }
 117
 118         regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
 119                      GMAC_PHY_INTF_SEL_RMII | GMAC_RMII_MODE);
 120 }
 121
 122 static void set_rgmii_speed(struct rk_priv_data *bsp_priv, int speed)
 123 {
 124         struct device *dev = &bsp_priv->pdev->dev;
 125
 126         if (IS_ERR(bsp_priv->grf)) {
 127                 dev_err(dev, "Missing rockchip,grf property\n");
 128                 return;
 129         }
 130
 131         if (speed == 10)
 132                 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1, GMAC_CLK_2_5M);
 133         else if (speed == 100)
 134                 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1, GMAC_CLK_25M);
 135         else if (speed == 1000)
 136                 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1, GMAC_CLK_125M);
 137         else
 138                 dev_err(dev, "unknown speed value for RGMII! speed=%d", speed);
 139 }
 140
 141 static void set_rmii_speed(struct rk_priv_data *bsp_priv, int speed)
 142 {
 143         struct device *dev = &bsp_priv->pdev->dev;
 144
 145         if (IS_ERR(bsp_priv->grf)) {
 146                 dev_err(dev, "Missing rockchip,grf property\n");
 147                 return;
 148         }
 149
 150         if (speed == 10) {
 151                 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
 152                              GMAC_RMII_CLK_2_5M | GMAC_SPEED_10M);
 153         } else if (speed == 100) {
 154                 regmap_write(bsp_priv->grf, RK3288_GRF_SOC_CON1,
 155                              GMAC_RMII_CLK_25M | GMAC_SPEED_100M);
 156         } else {
 157                 dev_err(dev, "unknown speed value for RMII! speed=%d", speed);
 158         }
 159 }
 160
 161 static int gmac_clk_init(struct rk_priv_data *bsp_priv)
 162 {
 163         struct device *dev = &bsp_priv->pdev->dev;
 164
 165         bsp_priv->clk_enabled = false;
 166
 167         bsp_priv->mac_clk_rx = devm_clk_get(dev, "mac_clk_rx");
 168         if (IS_ERR(bsp_priv->mac_clk_rx))
 169                 dev_err(dev, "cannot get clock %s\n",
 170                         "mac_clk_rx");
 171
 172         bsp_priv->mac_clk_tx = devm_clk_get(dev, "mac_clk_tx");
 173         if (IS_ERR(bsp_priv->mac_clk_tx))
 174                 dev_err(dev, "cannot get clock %s\n",
 175                         "mac_clk_tx");
 176
 177         bsp_priv->aclk_mac = devm_clk_get(dev, "aclk_mac");
 178         if (IS_ERR(bsp_priv->aclk_mac))
 179                 dev_err(dev, "cannot get clock %s\n",
 180                         "aclk_mac");
 181
 182         bsp_priv->pclk_mac = devm_clk_get(dev, "pclk_mac");
 183         if (IS_ERR(bsp_priv->pclk_mac))
 184                 dev_err(dev, "cannot get clock %s\n",
 185                         "pclk_mac");
 186
 187         bsp_priv->clk_mac = devm_clk_get(dev, "stmmaceth");
 188         if (IS_ERR(bsp_priv->clk_mac))
 189                 dev_err(dev, "cannot get clock %s\n",
 190                         "stmmaceth");
 191
 192         if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
 193                 bsp_priv->clk_mac_ref = devm_clk_get(dev, "clk_mac_ref");
 194                 if (IS_ERR(bsp_priv->clk_mac_ref))
 195                         dev_err(dev, "cannot get clock %s\n",
 196                                 "clk_mac_ref");
 197
 198                 if (!bsp_priv->clock_input) {
 199                         bsp_priv->clk_mac_refout =
 200                                 devm_clk_get(dev, "clk_mac_refout");
 201                         if (IS_ERR(bsp_priv->clk_mac_refout))
 202                                 dev_err(dev, "cannot get clock %s\n",
 203                                         "clk_mac_refout");
 204                 }
 205         }
 206
 207         if (bsp_priv->clock_input) {
 208                 dev_info(dev, "clock input from PHY\n");
 209         } else {
 210                 if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII)
 211                         clk_set_rate(bsp_priv->clk_mac, 50000000);
 212         }
 213
 214         return 0;
 215 }
 216
 217 static int gmac_clk_enable(struct rk_priv_data *bsp_priv, bool enable)
 218 {
 219         int phy_iface = phy_iface = bsp_priv->phy_iface;
 220
 221         if (enable) {
 222                 if (!bsp_priv->clk_enabled) {
 223                         if (phy_iface == PHY_INTERFACE_MODE_RMII) {
 224                                 if (!IS_ERR(bsp_priv->mac_clk_rx))
 225                                         clk_prepare_enable(
 226                                                 bsp_priv->mac_clk_rx);
 227
 228                                 if (!IS_ERR(bsp_priv->clk_mac_ref))
 229                                         clk_prepare_enable(
 230                                                 bsp_priv->clk_mac_ref);
 231
 232                                 if (!IS_ERR(bsp_priv->clk_mac_refout))
 233                                         clk_prepare_enable(
 234                                                 bsp_priv->clk_mac_refout);
 235                         }
 236
 237                         if (!IS_ERR(bsp_priv->aclk_mac))
 238                                 clk_prepare_enable(bsp_priv->aclk_mac);
 239
 240                         if (!IS_ERR(bsp_priv->pclk_mac))
 241                                 clk_prepare_enable(bsp_priv->pclk_mac);
 242
 243                         if (!IS_ERR(bsp_priv->mac_clk_tx))
 244                                 clk_prepare_enable(bsp_priv->mac_clk_tx);
 245
 246                         /**
 247                          * if (!IS_ERR(bsp_priv->clk_mac))
 248                          *      clk_prepare_enable(bsp_priv->clk_mac);
 249                          */
 250                         mdelay(5);
 251                         bsp_priv->clk_enabled = true;
 252                 }
 253         } else {
 254                 if (bsp_priv->clk_enabled) {
 255                         if (phy_iface == PHY_INTERFACE_MODE_RMII) {
 256                                 if (!IS_ERR(bsp_priv->mac_clk_rx))
 257                                         clk_disable_unprepare(
 258                                                 bsp_priv->mac_clk_rx);
 259
 260                                 if (!IS_ERR(bsp_priv->clk_mac_ref))
 261                                         clk_disable_unprepare(
 262                                                 bsp_priv->clk_mac_ref);
 263
 264                                 if (!IS_ERR(bsp_priv->clk_mac_refout))
 265                                         clk_disable_unprepare(
 266                                                 bsp_priv->clk_mac_refout);
 267                         }
 268
 269                         if (!IS_ERR(bsp_priv->aclk_mac))
 270                                 clk_disable_unprepare(bsp_priv->aclk_mac);
 271
 272                         if (!IS_ERR(bsp_priv->pclk_mac))
 273                                 clk_disable_unprepare(bsp_priv->pclk_mac);
 274
 275                         if (!IS_ERR(bsp_priv->mac_clk_tx))
 276                                 clk_disable_unprepare(bsp_priv->mac_clk_tx);
 277                         /**
 278                          * if (!IS_ERR(bsp_priv->clk_mac))
 279                          *      clk_disable_unprepare(bsp_priv->clk_mac);
 280                          */
 281                         bsp_priv->clk_enabled = false;
 282                 }
 283         }
 284
 285         return 0;
 286 }
 287
 288 static int phy_power_on(struct rk_priv_data *bsp_priv, bool enable)
 289 {
 290         struct regulator *ldo = bsp_priv->regulator;
 291         int ret;
 292         struct device *dev = &bsp_priv->pdev->dev;
 293
 294         if (!ldo) {
 295                 dev_err(dev, "no regulator found\n");
 296                 return -1;
 297         }
 298
 299         if (enable) {
 300                 ret = regulator_enable(ldo);
 301                 if (ret)
 302                         dev_err(dev, "fail to enable phy-supply\n");
 303         } else {
 304                 ret = regulator_disable(ldo);
 305                 if (ret)
 306                         dev_err(dev, "fail to disable phy-supply\n");
 307         }
 308
 309         return 0;
 310 }
 311
 312 static void *rk_gmac_setup(struct platform_device *pdev)
 313 {
 314         struct rk_priv_data *bsp_priv;
 315         struct device *dev = &pdev->dev;
 316         int ret;
 317         const char *strings = NULL;
 318         int value;
 319
 320         bsp_priv = devm_kzalloc(dev, sizeof(*bsp_priv), GFP_KERNEL);
 321         if (!bsp_priv)
 322                 return ERR_PTR(-ENOMEM);
 323
 324         bsp_priv->phy_iface = of_get_phy_mode(dev->of_node);
 325
 326         bsp_priv->regulator = devm_regulator_get_optional(dev, "phy");
 327         if (IS_ERR(bsp_priv->regulator)) {
 328                 if (PTR_ERR(bsp_priv->regulator) == -EPROBE_DEFER) {
 329                         dev_err(dev, "phy regulator is not available yet, deferred probing\n");
 330                         return ERR_PTR(-EPROBE_DEFER);
 331                 }
 332                 dev_err(dev, "no regulator found\n");
 333                 bsp_priv->regulator = NULL;
 334         }
 335
 336         ret = of_property_read_string(dev->of_node, "clock_in_out", &strings);
 337         if (ret) {
 338                 dev_err(dev, "Can not read property: clock_in_out.\n");
 339                 bsp_priv->clock_input = true;
 340         } else {
 341                 dev_info(dev, "clock input or output? (%s).\n",
 342                          strings);
 343                 if (!strcmp(strings, "input"))
 344                         bsp_priv->clock_input = true;
 345                 else
 346                         bsp_priv->clock_input = false;
 347         }
 348
 349         ret = of_property_read_u32(dev->of_node, "tx_delay", &value);
 350         if (ret) {
 351                 bsp_priv->tx_delay = 0x30;
 352                 dev_err(dev, "Can not read property: tx_delay.");
 353                 dev_err(dev, "set tx_delay to 0x%x\n",
 354                         bsp_priv->tx_delay);
 355         } else {
 356                 dev_info(dev, "TX delay(0x%x).\n", value);
 357                 bsp_priv->tx_delay = value;
 358         }
 359
 360         ret = of_property_read_u32(dev->of_node, "rx_delay", &value);
 361         if (ret) {
 362                 bsp_priv->rx_delay = 0x10;
 363                 dev_err(dev, "Can not read property: rx_delay.");
 364                 dev_err(dev, "set rx_delay to 0x%x\n",
 365                         bsp_priv->rx_delay);
 366         } else {
 367                 dev_info(dev, "RX delay(0x%x).\n", value);
 368                 bsp_priv->rx_delay = value;
 369         }
 370
 371         bsp_priv->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
 372                                                         "rockchip,grf");
 373         bsp_priv->pdev = pdev;
 374
 375         /*rmii or rgmii*/
 376         if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RGMII) {
 377                 dev_info(dev, "init for RGMII\n");
 378                 set_to_rgmii(bsp_priv, bsp_priv->tx_delay, bsp_priv->rx_delay);
 379         } else if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII) {
 380                 dev_info(dev, "init for RMII\n");
 381                 set_to_rmii(bsp_priv);
 382         } else {
 383                 dev_err(dev, "NO interface defined!\n");
 384         }
 385
 386         gmac_clk_init(bsp_priv);
 387
 388         return bsp_priv;
 389 }
 390
 391 static int rk_gmac_init(struct platform_device *pdev, void *priv)
 392 {
 393         struct rk_priv_data *bsp_priv = priv;
 394         int ret;
 395
 396         ret = phy_power_on(bsp_priv, true);
 397         if (ret)
 398                 return ret;
 399
 400         ret = gmac_clk_enable(bsp_priv, true);
 401         if (ret)
 402                 return ret;
 403
 404         return 0;
 405 }
 406
 407 static void rk_gmac_exit(struct platform_device *pdev, void *priv)
 408 {
 409         struct rk_priv_data *gmac = priv;
 410
 411         phy_power_on(gmac, false);
 412         gmac_clk_enable(gmac, false);
 413 }
 414
 415 static void rk_fix_speed(void *priv, unsigned int speed)
 416 {
 417         struct rk_priv_data *bsp_priv = priv;
 418         struct device *dev = &bsp_priv->pdev->dev;
 419
 420         if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RGMII)
 421                 set_rgmii_speed(bsp_priv, speed);
 422         else if (bsp_priv->phy_iface == PHY_INTERFACE_MODE_RMII)
 423                 set_rmii_speed(bsp_priv, speed);
 424         else
 425                 dev_err(dev, "unsupported interface %d", bsp_priv->phy_iface);
 426 }
 427
 428 static const struct stmmac_of_data rk3288_gmac_data = {
 429         .has_gmac = 1,
 430         .fix_mac_speed = rk_fix_speed,
 431         .setup = rk_gmac_setup,
 432         .init = rk_gmac_init,
 433         .exit = rk_gmac_exit,
 434 };
 435
 436 static const struct of_device_id rk_gmac_dwmac_match[] = {
 437         { .compatible = "rockchip,rk3288-gmac", .data = &rk3288_gmac_data},
 438         { }
 439 };
 440 MODULE_DEVICE_TABLE(of, rk_gmac_dwmac_match);
 441
 442 static struct platform_driver rk_gmac_dwmac_driver = {
 443         .probe  = stmmac_pltfr_probe,
 444         .remove = stmmac_pltfr_remove,
 445         .driver = {
 446                 .name           = "rk_gmac-dwmac",
 447                 .pm             = &stmmac_pltfr_pm_ops,
 448                 .of_match_table = rk_gmac_dwmac_match,
 449         },
 450 };
 451 module_platform_driver(rk_gmac_dwmac_driver);
 452
 453 MODULE_AUTHOR("Chen-Zhi (Roger Chen) <roger.chen@rock-chips.com>");
 454 MODULE_DESCRIPTION("Rockchip RK3288 DWMAC specific glue layer");
 455 MODULE_LICENSE("GPL");