// SPDX-License-Identifier: GPL-2.0
//
// rcpm.c - Freescale QorIQ RCPM driver
//
// Copyright 2019-2020 NXP
//
// Author: Ran Wang <ran.wang_1@nxp.com>

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/suspend.h>
#include <linux/kernel.h>
#include <linux/acpi.h>

#define RCPM_WAKEUP_CELL_MAX_SIZE 7

struct rcpm {
 unsigned int wakeup_cells;
 void __iomem *ippdexpcr_base;
 bool  little_endian;
};

#define  SCFG_SPARECR8 0x051c

static void copy_ippdexpcr1_setting(u32 val)
{
 struct device_node *np;
 void __iomem *regs;
 u32 reg_val;

 np = of_find_compatible_node(NULL, NULL, "fsl,ls1021a-scfg");
 if (!np)
  return;

 regs = of_iomap(np, 0);
 of_node_put(np);
 if (!regs)
  return;

 reg_val = ioread32be(regs + SCFG_SPARECR8);
 iowrite32be(val | reg_val, regs + SCFG_SPARECR8);

 iounmap(regs);
}

/**
 * rcpm_pm_prepare - performs device-level tasks associated with power
 * management, such as programming related to the wakeup source control.
 * @dev: Device to handle.
 *
 */
static int rcpm_pm_prepare(struct device *dev)
{
 int i, ret, idx;
 void __iomem *base;
 struct wakeup_source *ws;
 struct rcpm  *rcpm;
 struct device_node *np = dev->of_node;
 u32 value[RCPM_WAKEUP_CELL_MAX_SIZE + 1];
 u32 setting[RCPM_WAKEUP_CELL_MAX_SIZE] = {0};

 rcpm = dev_get_drvdata(dev);
 if (!rcpm)
  return -EINVAL;

 base = rcpm->ippdexpcr_base;
 idx = wakeup_sources_read_lock();

 /* Begin with first registered wakeup source */
 for_each_wakeup_source(ws) {

  /* skip object which is not attached to device */
  if (!ws->dev || !ws->dev->parent)
   continue;

  ret = device_property_read_u32_array(ws->dev->parent,
    "fsl,rcpm-wakeup", value,
    rcpm->wakeup_cells + 1);

  if (ret)
   continue;

  /*
   * For DT mode, would handle devices with "fsl,rcpm-wakeup"
   * pointing to the current RCPM node.
   *
   * For ACPI mode, currently we assume there is only one
   * RCPM controller existing.
 */
  if (is_of_node(dev->fwnode))
   if (np->phandle != value[0])
    continue;

  /* Property "#fsl,rcpm-wakeup-cells" of rcpm node defines the
   * number of IPPDEXPCR register cells, and "fsl,rcpm-wakeup"
   * of wakeup source IP contains an integer array: <phandle to
   * RCPM node, IPPDEXPCR0 setting, IPPDEXPCR1 setting,
   * IPPDEXPCR2 setting, etc>.
   *
   * So we will go thought them to collect setting data.
 */
  for (i = 0; i < rcpm->wakeup_cells; i++)
   setting[i] |= value[i + 1];
 }

 wakeup_sources_read_unlock(idx);

 /* Program all IPPDEXPCRn once */
 for (i = 0; i < rcpm->wakeup_cells; i++) {
  u32 tmp = setting[i];
  void __iomem *address = base + i * 4;

  if (!tmp)
   continue;

  /* We can only OR related bits */
  if (rcpm->little_endian) {
   tmp |= ioread32(address);
   iowrite32(tmp, address);
  } else {
   tmp |= ioread32be(address);
   iowrite32be(tmp, address);
  }
  /*
   * Workaround of errata A-008646 on SoC LS1021A:
   * There is a bug of register ippdexpcr1.
   * Reading configuration register RCPM_IPPDEXPCR1
   * always return zero. So save ippdexpcr1's value
   * to register SCFG_SPARECR8.And the value of
   * ippdexpcr1 will be read from SCFG_SPARECR8.
 */
  if (dev_of_node(dev) && (i == 1))
   if (of_device_is_compatible(np, "fsl,ls1021a-rcpm"))
    copy_ippdexpcr1_setting(tmp);
 }

 return 0;
}

static const struct dev_pm_ops rcpm_pm_ops = {
 .prepare =  rcpm_pm_prepare,
};

static int rcpm_probe(struct platform_device *pdev)
{
 struct device *dev = &pdev->dev;
 struct rcpm *rcpm;
 int ret;

 rcpm = devm_kzalloc(dev, sizeof(*rcpm), GFP_KERNEL);
 if (!rcpm)
  return -ENOMEM;

 rcpm->ippdexpcr_base = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(rcpm->ippdexpcr_base)) {
  ret =  PTR_ERR(rcpm->ippdexpcr_base);
  return ret;
 }

 rcpm->little_endian = device_property_read_bool(
   &pdev->dev, "little-endian");

 ret = device_property_read_u32(&pdev->dev,
   "#fsl,rcpm-wakeup-cells", &rcpm->wakeup_cells);
 if (ret)
  return ret;

 dev_set_drvdata(&pdev->dev, rcpm);

 return 0;
}

static const struct of_device_id rcpm_of_match[] = {
 { .compatible = "fsl,qoriq-rcpm-2.1+", },
 {}
};
MODULE_DEVICE_TABLE(of, rcpm_of_match);

#ifdef CONFIG_ACPI
static const struct acpi_device_id rcpm_acpi_ids[] = {
 {"NXP0015",},
 { }
};
MODULE_DEVICE_TABLE(acpi, rcpm_acpi_ids);
#endif

static struct platform_driver rcpm_driver = {
 .driver = {
  .name = "rcpm",
  .of_match_table = rcpm_of_match,
  .acpi_match_table = ACPI_PTR(rcpm_acpi_ids),
  .pm = &rcpm_pm_ops,
 },
 .probe = rcpm_probe,
};

module_platform_driver(rcpm_driver);