// SPDX-License-Identifier: GPL-2.0
/* Intel DWMAC platform driver
 *
 * Copyright(C) 2020 Intel Corporation
 */

#include <linux/ethtool.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/stmmac.h>

#include "dwmac4.h"
#include "stmmac.h"
#include "stmmac_platform.h"

struct intel_dwmac {
 struct device *dev;
 struct clk *tx_clk;
 const struct intel_dwmac_data *data;
};

struct intel_dwmac_data {
 unsigned long ptp_ref_clk_rate;
 unsigned long tx_clk_rate;
 bool tx_clk_en;
};

static const struct intel_dwmac_data kmb_data = {
 .ptp_ref_clk_rate = 200000000,
 .tx_clk_rate = 125000000,
 .tx_clk_en = true,
};

static const struct of_device_id intel_eth_plat_match[] = {
 { .compatible = "intel,keembay-dwmac", .data = &kmb_data },
 { }
};
MODULE_DEVICE_TABLE(of, intel_eth_plat_match);

static int intel_eth_plat_probe(struct platform_device *pdev)
{
 struct plat_stmmacenet_data *plat_dat;
 struct stmmac_resources stmmac_res;
 struct intel_dwmac *dwmac;
 unsigned long rate;
 int ret;

 ret = stmmac_get_platform_resources(pdev, &stmmac_res);
 if (ret)
  return ret;

 plat_dat = devm_stmmac_probe_config_dt(pdev, stmmac_res.mac);
 if (IS_ERR(plat_dat)) {
  dev_err(&pdev->dev, "dt configuration failed\n");
  return PTR_ERR(plat_dat);
 }

 dwmac = devm_kzalloc(&pdev->dev, sizeof(*dwmac), GFP_KERNEL);
 if (!dwmac)
  return -ENOMEM;

 dwmac->dev = &pdev->dev;
 dwmac->tx_clk = NULL;

 /*
 * This cannot return NULL at this point because the driver’s
 * compatibility with the device has already been validated in
 * platform_match().
 */
 dwmac->data = device_get_match_data(&pdev->dev);

 /* Enable TX clock */
 if (dwmac->data->tx_clk_en) {
  dwmac->tx_clk = devm_clk_get(&pdev->dev, "tx_clk");
  if (IS_ERR(dwmac->tx_clk))
   return PTR_ERR(dwmac->tx_clk);

  ret = clk_prepare_enable(dwmac->tx_clk);
  if (ret) {
   dev_err(&pdev->dev,
    "Failed to enable tx_clk\n");
   return ret;
  }

  /* Check and configure TX clock rate */
  rate = clk_get_rate(dwmac->tx_clk);
  if (dwmac->data->tx_clk_rate &&
      rate != dwmac->data->tx_clk_rate) {
   rate = dwmac->data->tx_clk_rate;
   ret = clk_set_rate(dwmac->tx_clk, rate);
   if (ret) {
    dev_err(&pdev->dev,
     "Failed to set tx_clk\n");
    goto err_tx_clk_disable;
   }
  }

  /* Check and configure PTP ref clock rate */
  rate = clk_get_rate(plat_dat->clk_ptp_ref);
  if (dwmac->data->ptp_ref_clk_rate &&
      rate != dwmac->data->ptp_ref_clk_rate) {
   rate = dwmac->data->ptp_ref_clk_rate;
   ret = clk_set_rate(plat_dat->clk_ptp_ref, rate);
   if (ret) {
    dev_err(&pdev->dev,
     "Failed to set clk_ptp_ref\n");
    goto err_tx_clk_disable;
   }
  }
 }

 plat_dat->clk_tx_i = dwmac->tx_clk;
 plat_dat->set_clk_tx_rate = stmmac_set_clk_tx_rate;
 plat_dat->bsp_priv = dwmac;

 ret = stmmac_dvr_probe(&pdev->dev, plat_dat, &stmmac_res);
 if (ret)
  goto err_tx_clk_disable;

 return 0;

err_tx_clk_disable:
 if (dwmac->data->tx_clk_en)
  clk_disable_unprepare(dwmac->tx_clk);
 return ret;
}

static void intel_eth_plat_remove(struct platform_device *pdev)
{
 struct intel_dwmac *dwmac = get_stmmac_bsp_priv(&pdev->dev);

 stmmac_pltfr_remove(pdev);
 if (dwmac->data->tx_clk_en)
  clk_disable_unprepare(dwmac->tx_clk);
}

static struct platform_driver intel_eth_plat_driver = {
 .probe  = intel_eth_plat_probe,
 .remove = intel_eth_plat_remove,
 .driver = {
  .name  = "intel-eth-plat",
  .pm  = &stmmac_pltfr_pm_ops,
  .of_match_table = intel_eth_plat_match,
 },
};
module_platform_driver(intel_eth_plat_driver);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Intel DWMAC platform driver");