drivers/net/ethernet/stmicro/stmmac/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   The full GNU General Public License is included in this distribution in
  16   the file called "COPYING".
  17
  18   Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
  19 *******************************************************************************/
  20
  21 #include <linux/platform_device.h>
  22 #include <linux/module.h>
  23 #include <linux/io.h>
  24 #include <linux/of.h>
  25 #include <linux/of_net.h>
  26 #include <linux/of_device.h>
  27 #include <linux/of_mdio.h>
  28
  29 #include "stmmac.h"
  30 #include "stmmac_platform.h"
  31
  32 #ifdef CONFIG_OF
  33
  34 /**
  35  * dwmac1000_validate_mcast_bins - validates the number of Multicast filter bins
  36  * @mcast_bins: Multicast filtering bins
  37  * Description:
  38  * this function validates the number of Multicast filtering bins specified
  39  * by the configuration through the device tree. The Synopsys GMAC supports
  40  * 64 bins, 128 bins, or 256 bins. "bins" refer to the division of CRC
  41  * number space. 64 bins correspond to 6 bits of the CRC, 128 corresponds
  42  * to 7 bits, and 256 refers to 8 bits of the CRC. Any other setting is
  43  * invalid and will cause the filtering algorithm to use Multicast
  44  * promiscuous mode.
  45  */
  46 static int dwmac1000_validate_mcast_bins(int mcast_bins)
  47 {
  48         int x = mcast_bins;
  49
  50         switch (x) {
  51         case HASH_TABLE_SIZE:
  52         case 128:
  53         case 256:
  54                 break;
  55         default:
  56                 x = 0;
  57                 pr_info("Hash table entries set to unexpected value %d",
  58                         mcast_bins);
  59                 break;
  60         }
  61         return x;
  62 }
  63
  64 /**
  65  * dwmac1000_validate_ucast_entries - validate the Unicast address entries
  66  * @ucast_entries: number of Unicast address entries
  67  * Description:
  68  * This function validates the number of Unicast address entries supported
  69  * by a particular Synopsys 10/100/1000 controller. The Synopsys controller
  70  * supports 1..32, 64, or 128 Unicast filter entries for it's Unicast filter
  71  * logic. This function validates a valid, supported configuration is
  72  * selected, and defaults to 1 Unicast address if an unsupported
  73  * configuration is selected.
  74  */
  75 static int dwmac1000_validate_ucast_entries(int ucast_entries)
  76 {
  77         int x = ucast_entries;
  78
  79         switch (x) {
  80         case 1 ... 32:
  81         case 64:
  82         case 128:
  83                 break;
  84         default:
  85                 x = 1;
  86                 pr_info("Unicast table entries set to unexpected value %d\n",
  87                         ucast_entries);
  88                 break;
  89         }
  90         return x;
  91 }
  92
  93 /**
  94  * stmmac_axi_setup - parse DT parameters for programming the AXI register
  95  * @pdev: platform device
  96  * @priv: driver private struct.
  97  * Description:
  98  * if required, from device-tree the AXI internal register can be tuned
  99  * by using platform parameters.
 100  */
 101 static struct stmmac_axi *stmmac_axi_setup(struct platform_device *pdev)
 102 {
 103         struct device_node *np;
 104         struct stmmac_axi *axi;
 105
 106         np = of_parse_phandle(pdev->dev.of_node, "snps,axi-config", 0);
 107         if (!np)
 108                 return NULL;
 109
 110         axi = devm_kzalloc(&pdev->dev, sizeof(*axi), GFP_KERNEL);
 111         if (!axi) {
 112                 of_node_put(np);
 113                 return ERR_PTR(-ENOMEM);
 114         }
 115
 116         axi->axi_lpi_en = of_property_read_bool(np, "snps,lpi_en");
 117         axi->axi_xit_frm = of_property_read_bool(np, "snps,xit_frm");
 118         axi->axi_kbbe = of_property_read_bool(np, "snps,axi_kbbe");
 119         axi->axi_fb = of_property_read_bool(np, "snps,axi_fb");
 120         axi->axi_mb = of_property_read_bool(np, "snps,axi_mb");
 121         axi->axi_rb =  of_property_read_bool(np, "snps,axi_rb");
 122
 123         if (of_property_read_u32(np, "snps,wr_osr_lmt", &axi->axi_wr_osr_lmt))
 124                 axi->axi_wr_osr_lmt = 1;
 125         if (of_property_read_u32(np, "snps,rd_osr_lmt", &axi->axi_rd_osr_lmt))
 126                 axi->axi_rd_osr_lmt = 1;
 127         of_property_read_u32_array(np, "snps,blen", axi->axi_blen, AXI_BLEN);
 128         of_node_put(np);
 129
 130         return axi;
 131 }
 132
 133 /**
 134  * stmmac_mtl_setup - parse DT parameters for multiple queues configuration
 135  * @pdev: platform device
 136  */
 137 static void stmmac_mtl_setup(struct platform_device *pdev,
 138                              struct plat_stmmacenet_data *plat)
 139 {
 140         struct device_node *q_node;
 141         struct device_node *rx_node;
 142         struct device_node *tx_node;
 143         u8 queue = 0;
 144
 145         /* For backwards-compatibility with device trees that don't have any
 146          * snps,mtl-rx-config or snps,mtl-tx-config properties, we fall back
 147          * to one RX and TX queues each.
 148          */
 149         plat->rx_queues_to_use = 1;
 150         plat->tx_queues_to_use = 1;
 151
 152         /* First Queue must always be in DCB mode. As MTL_QUEUE_DCB = 1 we need
 153          * to always set this, otherwise Queue will be classified as AVB
 154          * (because MTL_QUEUE_AVB = 0).
 155          */
 156         plat->rx_queues_cfg[0].mode_to_use = MTL_QUEUE_DCB;
 157         plat->tx_queues_cfg[0].mode_to_use = MTL_QUEUE_DCB;
 158
 159         rx_node = of_parse_phandle(pdev->dev.of_node, "snps,mtl-rx-config", 0);
 160         if (!rx_node)
 161                 return;
 162
 163         tx_node = of_parse_phandle(pdev->dev.of_node, "snps,mtl-tx-config", 0);
 164         if (!tx_node) {
 165                 of_node_put(rx_node);
 166                 return;
 167         }
 168
 169         /* Processing RX queues common config */
 170         if (of_property_read_u32(rx_node, "snps,rx-queues-to-use",
 171                                  &plat->rx_queues_to_use))
 172                 plat->rx_queues_to_use = 1;
 173
 174         if (of_property_read_bool(rx_node, "snps,rx-sched-sp"))
 175                 plat->rx_sched_algorithm = MTL_RX_ALGORITHM_SP;
 176         else if (of_property_read_bool(rx_node, "snps,rx-sched-wsp"))
 177                 plat->rx_sched_algorithm = MTL_RX_ALGORITHM_WSP;
 178         else
 179                 plat->rx_sched_algorithm = MTL_RX_ALGORITHM_SP;
 180
 181         /* Processing individual RX queue config */
 182         for_each_child_of_node(rx_node, q_node) {
 183                 if (queue >= plat->rx_queues_to_use)
 184                         break;
 185
 186                 if (of_property_read_bool(q_node, "snps,dcb-algorithm"))
 187                         plat->rx_queues_cfg[queue].mode_to_use = MTL_QUEUE_DCB;
 188                 else if (of_property_read_bool(q_node, "snps,avb-algorithm"))
 189                         plat->rx_queues_cfg[queue].mode_to_use = MTL_QUEUE_AVB;
 190                 else
 191                         plat->rx_queues_cfg[queue].mode_to_use = MTL_QUEUE_DCB;
 192
 193                 if (of_property_read_u32(q_node, "snps,map-to-dma-channel",
 194                                          &plat->rx_queues_cfg[queue].chan))
 195                         plat->rx_queues_cfg[queue].chan = queue;
 196                 /* TODO: Dynamic mapping to be included in the future */
 197
 198                 if (of_property_read_u32(q_node, "snps,priority",
 199                                         &plat->rx_queues_cfg[queue].prio)) {
 200                         plat->rx_queues_cfg[queue].prio = 0;
 201                         plat->rx_queues_cfg[queue].use_prio = false;
 202                 } else {
 203                         plat->rx_queues_cfg[queue].use_prio = true;
 204                 }
 205
 206                 /* RX queue specific packet type routing */
 207                 if (of_property_read_bool(q_node, "snps,route-avcp"))
 208                         plat->rx_queues_cfg[queue].pkt_route = PACKET_AVCPQ;
 209                 else if (of_property_read_bool(q_node, "snps,route-ptp"))
 210                         plat->rx_queues_cfg[queue].pkt_route = PACKET_PTPQ;
 211                 else if (of_property_read_bool(q_node, "snps,route-dcbcp"))
 212                         plat->rx_queues_cfg[queue].pkt_route = PACKET_DCBCPQ;
 213                 else if (of_property_read_bool(q_node, "snps,route-up"))
 214                         plat->rx_queues_cfg[queue].pkt_route = PACKET_UPQ;
 215                 else if (of_property_read_bool(q_node, "snps,route-multi-broad"))
 216                         plat->rx_queues_cfg[queue].pkt_route = PACKET_MCBCQ;
 217                 else
 218                         plat->rx_queues_cfg[queue].pkt_route = 0x0;
 219
 220                 queue++;
 221         }
 222
 223         /* Processing TX queues common config */
 224         if (of_property_read_u32(tx_node, "snps,tx-queues-to-use",
 225                                  &plat->tx_queues_to_use))
 226                 plat->tx_queues_to_use = 1;
 227
 228         if (of_property_read_bool(tx_node, "snps,tx-sched-wrr"))
 229                 plat->tx_sched_algorithm = MTL_TX_ALGORITHM_WRR;
 230         else if (of_property_read_bool(tx_node, "snps,tx-sched-wfq"))
 231                 plat->tx_sched_algorithm = MTL_TX_ALGORITHM_WFQ;
 232         else if (of_property_read_bool(tx_node, "snps,tx-sched-dwrr"))
 233                 plat->tx_sched_algorithm = MTL_TX_ALGORITHM_DWRR;
 234         else if (of_property_read_bool(tx_node, "snps,tx-sched-sp"))
 235                 plat->tx_sched_algorithm = MTL_TX_ALGORITHM_SP;
 236         else
 237                 plat->tx_sched_algorithm = MTL_TX_ALGORITHM_SP;
 238
 239         queue = 0;
 240
 241         /* Processing individual TX queue config */
 242         for_each_child_of_node(tx_node, q_node) {
 243                 if (queue >= plat->tx_queues_to_use)
 244                         break;
 245
 246                 if (of_property_read_u32(q_node, "snps,weight",
 247                                          &plat->tx_queues_cfg[queue].weight))
 248                         plat->tx_queues_cfg[queue].weight = 0x10 + queue;
 249
 250                 if (of_property_read_bool(q_node, "snps,dcb-algorithm")) {
 251                         plat->tx_queues_cfg[queue].mode_to_use = MTL_QUEUE_DCB;
 252                 } else if (of_property_read_bool(q_node,
 253                                                  "snps,avb-algorithm")) {
 254                         plat->tx_queues_cfg[queue].mode_to_use = MTL_QUEUE_AVB;
 255
 256                         /* Credit Base Shaper parameters used by AVB */
 257                         if (of_property_read_u32(q_node, "snps,send_slope",
 258                                 &plat->tx_queues_cfg[queue].send_slope))
 259                                 plat->tx_queues_cfg[queue].send_slope = 0x0;
 260                         if (of_property_read_u32(q_node, "snps,idle_slope",
 261                                 &plat->tx_queues_cfg[queue].idle_slope))
 262                                 plat->tx_queues_cfg[queue].idle_slope = 0x0;
 263                         if (of_property_read_u32(q_node, "snps,high_credit",
 264                                 &plat->tx_queues_cfg[queue].high_credit))
 265                                 plat->tx_queues_cfg[queue].high_credit = 0x0;
 266                         if (of_property_read_u32(q_node, "snps,low_credit",
 267                                 &plat->tx_queues_cfg[queue].low_credit))
 268                                 plat->tx_queues_cfg[queue].low_credit = 0x0;
 269                 } else {
 270                         plat->tx_queues_cfg[queue].mode_to_use = MTL_QUEUE_DCB;
 271                 }
 272
 273                 if (of_property_read_u32(q_node, "snps,priority",
 274                                         &plat->tx_queues_cfg[queue].prio)) {
 275                         plat->tx_queues_cfg[queue].prio = 0;
 276                         plat->tx_queues_cfg[queue].use_prio = false;
 277                 } else {
 278                         plat->tx_queues_cfg[queue].use_prio = true;
 279                 }
 280
 281                 queue++;
 282         }
 283
 284         of_node_put(rx_node);
 285         of_node_put(tx_node);
 286         of_node_put(q_node);
 287 }
 288
 289 /**
 290  * stmmac_dt_phy - parse device-tree driver parameters to allocate PHY resources
 291  * @plat: driver data platform structure
 292  * @np: device tree node
 293  * @dev: device pointer
 294  * Description:
 295  * The mdio bus will be allocated in case of a phy transceiver is on board;
 296  * it will be NULL if the fixed-link is configured.
 297  * If there is the "snps,dwmac-mdio" sub-node the mdio will be allocated
 298  * in any case (for DSA, mdio must be registered even if fixed-link).
 299  * The table below sums the supported configurations:
 300  *      -------------------------------
 301  *      snps,phy-addr   |     Y
 302  *      -------------------------------
 303  *      phy-handle      |     Y
 304  *      -------------------------------
 305  *      fixed-link      |     N
 306  *      -------------------------------
 307  *      snps,dwmac-mdio |
 308  *        even if       |     Y
 309  *      fixed-link      |
 310  *      -------------------------------
 311  *
 312  * It returns 0 in case of success otherwise -ENODEV.
 313  */
 314 static int stmmac_dt_phy(struct plat_stmmacenet_data *plat,
 315                          struct device_node *np, struct device *dev)
 316 {
 317         bool mdio = true;
 318         static const struct of_device_id need_mdio_ids[] = {
 319                 { .compatible = "snps,dwc-qos-ethernet-4.10" },
 320                 { .compatible = "allwinner,sun8i-a83t-emac" },
 321                 { .compatible = "allwinner,sun8i-h3-emac" },
 322                 { .compatible = "allwinner,sun8i-v3s-emac" },
 323                 { .compatible = "allwinner,sun50i-a64-emac" },
 324                 {},
 325         };
 326
 327         /* If phy-handle property is passed from DT, use it as the PHY */
 328         plat->phy_node = of_parse_phandle(np, "phy-handle", 0);
 329         if (plat->phy_node)
 330                 dev_dbg(dev, "Found phy-handle subnode\n");
 331
 332         /* If phy-handle is not specified, check if we have a fixed-phy */
 333         if (!plat->phy_node && of_phy_is_fixed_link(np)) {
 334                 if ((of_phy_register_fixed_link(np) < 0))
 335                         return -ENODEV;
 336
 337                 dev_dbg(dev, "Found fixed-link subnode\n");
 338                 plat->phy_node = of_node_get(np);
 339                 mdio = false;
 340         }
 341
 342         if (of_match_node(need_mdio_ids, np)) {
 343                 plat->mdio_node = of_get_child_by_name(np, "mdio");
 344         } else {
 345                 /**
 346                  * If snps,dwmac-mdio is passed from DT, always register
 347                  * the MDIO
 348                  */
 349                 for_each_child_of_node(np, plat->mdio_node) {
 350                         if (of_device_is_compatible(plat->mdio_node,
 351                                                     "snps,dwmac-mdio"))
 352                                 break;
 353                 }
 354         }
 355
 356         if (plat->mdio_node) {
 357                 dev_dbg(dev, "Found MDIO subnode\n");
 358                 mdio = true;
 359         }
 360
 361         if (mdio)
 362                 plat->mdio_bus_data =
 363                         devm_kzalloc(dev, sizeof(struct stmmac_mdio_bus_data),
 364                                      GFP_KERNEL);
 365         return 0;
 366 }
 367
 368 /**
 369  * stmmac_probe_config_dt - parse device-tree driver parameters
 370  * @pdev: platform_device structure
 371  * @mac: MAC address to use
 372  * Description:
 373  * this function is to read the driver parameters from device-tree and
 374  * set some private fields that will be used by the main at runtime.
 375  */
 376 struct plat_stmmacenet_data *
 377 stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
 378 {
 379         struct device_node *np = pdev->dev.of_node;
 380         struct plat_stmmacenet_data *plat;
 381         struct stmmac_dma_cfg *dma_cfg;
 382
 383         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
 384         if (!plat)
 385                 return ERR_PTR(-ENOMEM);
 386
 387         *mac = of_get_mac_address(np);
 388         plat->interface = of_get_phy_mode(np);
 389
 390         /* Get max speed of operation from device tree */
 391         if (of_property_read_u32(np, "max-speed", &plat->max_speed))
 392                 plat->max_speed = -1;
 393
 394         plat->bus_id = of_alias_get_id(np, "ethernet");
 395         if (plat->bus_id < 0)
 396                 plat->bus_id = 0;
 397
 398         /* Default to phy auto-detection */
 399         plat->phy_addr = -1;
 400
 401         /* "snps,phy-addr" is not a standard property. Mark it as deprecated
 402          * and warn of its use. Remove this when phy node support is added.
 403          */
 404         if (of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr) == 0)
 405                 dev_warn(&pdev->dev, "snps,phy-addr property is deprecated\n");
 406
 407         /* To Configure PHY by using all device-tree supported properties */
 408         if (stmmac_dt_phy(plat, np, &pdev->dev))
 409                 return ERR_PTR(-ENODEV);
 410
 411         of_property_read_u32(np, "tx-fifo-depth", &plat->tx_fifo_size);
 412
 413         of_property_read_u32(np, "rx-fifo-depth", &plat->rx_fifo_size);
 414
 415         plat->force_sf_dma_mode =
 416                 of_property_read_bool(np, "snps,force_sf_dma_mode");
 417
 418         plat->en_tx_lpi_clockgating =
 419                 of_property_read_bool(np, "snps,en-tx-lpi-clockgating");
 420
 421         /* Set the maxmtu to a default of JUMBO_LEN in case the
 422          * parameter is not present in the device tree.
 423          */
 424         plat->maxmtu = JUMBO_LEN;
 425
 426         /* Set default value for multicast hash bins */
 427         plat->multicast_filter_bins = HASH_TABLE_SIZE;
 428
 429         /* Set default value for unicast filter entries */
 430         plat->unicast_filter_entries = 1;
 431
 432         /*
 433          * Currently only the properties needed on SPEAr600
 434          * are provided. All other properties should be added
 435          * once needed on other platforms.
 436          */
 437         if (of_device_is_compatible(np, "st,spear600-gmac") ||
 438                 of_device_is_compatible(np, "snps,dwmac-3.50a") ||
 439                 of_device_is_compatible(np, "snps,dwmac-3.70a") ||
 440                 of_device_is_compatible(np, "snps,dwmac")) {
 441                 /* Note that the max-frame-size parameter as defined in the
 442                  * ePAPR v1.1 spec is defined as max-frame-size, it's
 443                  * actually used as the IEEE definition of MAC Client
 444                  * data, or MTU. The ePAPR specification is confusing as
 445                  * the definition is max-frame-size, but usage examples
 446                  * are clearly MTUs
 447                  */
 448                 of_property_read_u32(np, "max-frame-size", &plat->maxmtu);
 449                 of_property_read_u32(np, "snps,multicast-filter-bins",
 450                                      &plat->multicast_filter_bins);
 451                 of_property_read_u32(np, "snps,perfect-filter-entries",
 452                                      &plat->unicast_filter_entries);
 453                 plat->unicast_filter_entries = dwmac1000_validate_ucast_entries(
 454                                                plat->unicast_filter_entries);
 455                 plat->multicast_filter_bins = dwmac1000_validate_mcast_bins(
 456                                               plat->multicast_filter_bins);
 457                 plat->has_gmac = 1;
 458                 plat->pmt = 1;
 459         }
 460
 461         if (of_device_is_compatible(np, "snps,dwmac-3.40a")) {
 462                 plat->has_gmac = 1;
 463                 plat->enh_desc = 1;
 464                 plat->tx_coe = 1;
 465                 plat->bugged_jumbo = 1;
 466                 plat->pmt = 1;
 467         }
 468
 469         if (of_device_is_compatible(np, "snps,dwmac-4.00") ||
 470             of_device_is_compatible(np, "snps,dwmac-4.10a")) {
 471                 plat->has_gmac4 = 1;
 472                 plat->has_gmac = 0;
 473                 plat->pmt = 1;
 474                 plat->tso_en = of_property_read_bool(np, "snps,tso");
 475         }
 476
 477         if (of_device_is_compatible(np, "snps,dwmac-3.610") ||
 478                 of_device_is_compatible(np, "snps,dwmac-3.710")) {
 479                 plat->enh_desc = 1;
 480                 plat->bugged_jumbo = 1;
 481                 plat->force_sf_dma_mode = 1;
 482         }
 483
 484         dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg),
 485                                GFP_KERNEL);
 486         if (!dma_cfg) {
 487                 stmmac_remove_config_dt(pdev, plat);
 488                 return ERR_PTR(-ENOMEM);
 489         }
 490         plat->dma_cfg = dma_cfg;
 491
 492         of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl);
 493         if (!dma_cfg->pbl)
 494                 dma_cfg->pbl = DEFAULT_DMA_PBL;
 495         of_property_read_u32(np, "snps,txpbl", &dma_cfg->txpbl);
 496         of_property_read_u32(np, "snps,rxpbl", &dma_cfg->rxpbl);
 497         dma_cfg->pblx8 = !of_property_read_bool(np, "snps,no-pbl-x8");
 498
 499         dma_cfg->aal = of_property_read_bool(np, "snps,aal");
 500         dma_cfg->fixed_burst = of_property_read_bool(np, "snps,fixed-burst");
 501         dma_cfg->mixed_burst = of_property_read_bool(np, "snps,mixed-burst");
 502
 503         plat->force_thresh_dma_mode = of_property_read_bool(np, "snps,force_thresh_dma_mode");
 504         if (plat->force_thresh_dma_mode) {
 505                 plat->force_sf_dma_mode = 0;
 506                 pr_warn("force_sf_dma_mode is ignored if force_thresh_dma_mode is set.");
 507         }
 508
 509         of_property_read_u32(np, "snps,ps-speed", &plat->mac_port_sel_speed);
 510
 511         plat->axi = stmmac_axi_setup(pdev);
 512
 513         stmmac_mtl_setup(pdev, plat);
 514
 515         /* clock setup */
 516         plat->stmmac_clk = devm_clk_get(&pdev->dev,
 517                                         STMMAC_RESOURCE_NAME);
 518         if (IS_ERR(plat->stmmac_clk)) {
 519                 dev_warn(&pdev->dev, "Cannot get CSR clock\n");
 520                 plat->stmmac_clk = NULL;
 521         }
 522         clk_prepare_enable(plat->stmmac_clk);
 523
 524         plat->pclk = devm_clk_get(&pdev->dev, "pclk");
 525         if (IS_ERR(plat->pclk)) {
 526                 if (PTR_ERR(plat->pclk) == -EPROBE_DEFER)
 527                         goto error_pclk_get;
 528
 529                 plat->pclk = NULL;
 530         }
 531         clk_prepare_enable(plat->pclk);
 532
 533         /* Fall-back to main clock in case of no PTP ref is passed */
 534         plat->clk_ptp_ref = devm_clk_get(&pdev->dev, "ptp_ref");
 535         if (IS_ERR(plat->clk_ptp_ref)) {
 536                 plat->clk_ptp_rate = clk_get_rate(plat->stmmac_clk);
 537                 plat->clk_ptp_ref = NULL;
 538                 dev_warn(&pdev->dev, "PTP uses main clock\n");
 539         } else {
 540                 plat->clk_ptp_rate = clk_get_rate(plat->clk_ptp_ref);
 541                 dev_dbg(&pdev->dev, "PTP rate %d\n", plat->clk_ptp_rate);
 542         }
 543
 544         plat->stmmac_rst = devm_reset_control_get(&pdev->dev,
 545                                                   STMMAC_RESOURCE_NAME);
 546         if (IS_ERR(plat->stmmac_rst)) {
 547                 if (PTR_ERR(plat->stmmac_rst) == -EPROBE_DEFER)
 548                         goto error_hw_init;
 549
 550                 dev_info(&pdev->dev, "no reset control found\n");
 551                 plat->stmmac_rst = NULL;
 552         }
 553
 554         return plat;
 555
 556 error_hw_init:
 557         clk_disable_unprepare(plat->pclk);
 558 error_pclk_get:
 559         clk_disable_unprepare(plat->stmmac_clk);
 560
 561         return ERR_PTR(-EPROBE_DEFER);
 562 }
 563
 564 /**
 565  * stmmac_remove_config_dt - undo the effects of stmmac_probe_config_dt()
 566  * @pdev: platform_device structure
 567  * @plat: driver data platform structure
 568  *
 569  * Release resources claimed by stmmac_probe_config_dt().
 570  */
 571 void stmmac_remove_config_dt(struct platform_device *pdev,
 572                              struct plat_stmmacenet_data *plat)
 573 {
 574         struct device_node *np = pdev->dev.of_node;
 575
 576         if (of_phy_is_fixed_link(np))
 577                 of_phy_deregister_fixed_link(np);
 578         of_node_put(plat->phy_node);
 579         of_node_put(plat->mdio_node);
 580 }
 581 #else
 582 struct plat_stmmacenet_data *
 583 stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
 584 {
 585         return ERR_PTR(-EINVAL);
 586 }
 587
 588 void stmmac_remove_config_dt(struct platform_device *pdev,
 589                              struct plat_stmmacenet_data *plat)
 590 {
 591 }
 592 #endif /* CONFIG_OF */
 593 EXPORT_SYMBOL_GPL(stmmac_probe_config_dt);
 594 EXPORT_SYMBOL_GPL(stmmac_remove_config_dt);
 595
 596 int stmmac_get_platform_resources(struct platform_device *pdev,
 597                                   struct stmmac_resources *stmmac_res)
 598 {
 599         struct resource *res;
 600
 601         memset(stmmac_res, 0, sizeof(*stmmac_res));
 602
 603         /* Get IRQ information early to have an ability to ask for deferred
 604          * probe if needed before we went too far with resource allocation.
 605          */
 606         stmmac_res->irq = platform_get_irq_byname(pdev, "macirq");
 607         if (stmmac_res->irq < 0) {
 608                 if (stmmac_res->irq != -EPROBE_DEFER) {
 609                         dev_err(&pdev->dev,
 610                                 "MAC IRQ configuration information not found\n");
 611                 }
 612                 return stmmac_res->irq;
 613         }
 614
 615         /* On some platforms e.g. SPEAr the wake up irq differs from the mac irq
 616          * The external wake up irq can be passed through the platform code
 617          * named as "eth_wake_irq"
 618          *
 619          * In case the wake up interrupt is not passed from the platform
 620          * so the driver will continue to use the mac irq (ndev->irq)
 621          */
 622         stmmac_res->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
 623         if (stmmac_res->wol_irq < 0) {
 624                 if (stmmac_res->wol_irq == -EPROBE_DEFER)
 625                         return -EPROBE_DEFER;
 626                 stmmac_res->wol_irq = stmmac_res->irq;
 627         }
 628
 629         stmmac_res->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
 630         if (stmmac_res->lpi_irq == -EPROBE_DEFER)
 631                 return -EPROBE_DEFER;
 632
 633         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 634         stmmac_res->addr = devm_ioremap_resource(&pdev->dev, res);
 635
 636         return PTR_ERR_OR_ZERO(stmmac_res->addr);
 637 }
 638 EXPORT_SYMBOL_GPL(stmmac_get_platform_resources);
 639
 640 /**
 641  * stmmac_pltfr_remove
 642  * @pdev: platform device pointer
 643  * Description: this function calls the main to free the net resources
 644  * and calls the platforms hook and release the resources (e.g. mem).
 645  */
 646 int stmmac_pltfr_remove(struct platform_device *pdev)
 647 {
 648         struct net_device *ndev = platform_get_drvdata(pdev);
 649         struct stmmac_priv *priv = netdev_priv(ndev);
 650         struct plat_stmmacenet_data *plat = priv->plat;
 651         int ret = stmmac_dvr_remove(&pdev->dev);
 652
 653         if (plat->exit)
 654                 plat->exit(pdev, plat->bsp_priv);
 655
 656         stmmac_remove_config_dt(pdev, plat);
 657
 658         return ret;
 659 }
 660 EXPORT_SYMBOL_GPL(stmmac_pltfr_remove);
 661
 662 #ifdef CONFIG_PM_SLEEP
 663 /**
 664  * stmmac_pltfr_suspend
 665  * @dev: device pointer
 666  * Description: this function is invoked when suspend the driver and it direcly
 667  * call the main suspend function and then, if required, on some platform, it
 668  * can call an exit helper.
 669  */
 670 static int stmmac_pltfr_suspend(struct device *dev)
 671 {
 672         int ret;
 673         struct net_device *ndev = dev_get_drvdata(dev);
 674         struct stmmac_priv *priv = netdev_priv(ndev);
 675         struct platform_device *pdev = to_platform_device(dev);
 676
 677         ret = stmmac_suspend(dev);
 678         if (priv->plat->exit)
 679                 priv->plat->exit(pdev, priv->plat->bsp_priv);
 680
 681         return ret;
 682 }
 683
 684 /**
 685  * stmmac_pltfr_resume
 686  * @dev: device pointer
 687  * Description: this function is invoked when resume the driver before calling
 688  * the main resume function, on some platforms, it can call own init helper
 689  * if required.
 690  */
 691 static int stmmac_pltfr_resume(struct device *dev)
 692 {
 693         struct net_device *ndev = dev_get_drvdata(dev);
 694         struct stmmac_priv *priv = netdev_priv(ndev);
 695         struct platform_device *pdev = to_platform_device(dev);
 696
 697         if (priv->plat->init)
 698                 priv->plat->init(pdev, priv->plat->bsp_priv);
 699
 700         return stmmac_resume(dev);
 701 }
 702 #endif /* CONFIG_PM_SLEEP */
 703
 704 SIMPLE_DEV_PM_OPS(stmmac_pltfr_pm_ops, stmmac_pltfr_suspend,
 705                                        stmmac_pltfr_resume);
 706 EXPORT_SYMBOL_GPL(stmmac_pltfr_pm_ops);
 707
 708 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet platform support");
 709 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
 710 MODULE_LICENSE("GPL");