/*
 * (C) COPYRIGHT RockChip Limited. All rights reserved.
 *
 * This program is free software and is provided to you under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation, and any use by you of this program is subject to the terms
 * of such GNU licence.
 */

/**
 * @file rk.c
 * implementation of platform_specific_code on rk platforms, such as rk3328h.
 *
 * mali_device_driver(MDD) includes 2 parts :
 *	.DP : platform_dependent_part :
 *		located in <mdd_src_dir>/mali/platform/<platform_name>/
 *	.DP : common_part :
 *		common part implemented by ARM.
 */

#define ENABLE_DEBUG_LOG
#include "custom_log.h"

#include <linux/platform_device.h>
#include <linux/version.h>
#include <linux/pm.h>
#include <linux/of.h>
#include <linux/clk.h>
#include <linux/regulator/consumer.h>
#ifdef CONFIG_PM
#include <linux/pm_runtime.h>
#endif
#include <linux/workqueue.h>
#include <linux/dma-mapping.h>
#include <linux/pm_runtime.h>
#include <linux/delay.h>
#include <linux/regmap.h>
#include <linux/mfd/syscon.h>
#include <linux/rockchip/cpu.h>
#include <soc/rockchip/rockchip_ipa.h>
#include <soc/rockchip/rockchip_opp_select.h>

#include <linux/mali/mali_utgard.h>
#include "mali_kernel_common.h"
#include "../../common/mali_osk_mali.h"

/*---------------------------------------------------------------------------*/

u32 mali_group_error;

/*---------------------------------------------------------------------------*/

#define RK3528_GPU_SD_SLP_HAST	0x10024
#define DEFAULT_UTILISATION_PERIOD_IN_MS (100)

/*
 * rk_platform_context_of_mali_device.
 */
struct rk_context {
	/* mali device. */
	struct device *dev;
	struct regmap *grf;
	/* is the GPU powered on?  */
	bool is_powered;
	/* debug only, the period in ms to count gpu_utilisation. */
	unsigned int utilisation_period;
};

struct rk_context *s_rk_context;

/*---------------------------------------------------------------------------*/

#ifdef CONFIG_MALI_DEVFREQ
static ssize_t utilisation_period_show(struct device *dev,
				       struct device_attribute *attr,
				       char *buf)
{
	struct rk_context *platform = s_rk_context;
	ssize_t ret = 0;

	ret += snprintf(buf, PAGE_SIZE, "%u\n", platform->utilisation_period);

	return ret;
}

static ssize_t utilisation_period_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf,
					size_t count)
{
	struct rk_context *platform = s_rk_context;
	int ret = 0;

	ret = kstrtouint(buf, 0, &platform->utilisation_period);
	if (ret) {
		E("invalid input period : %s.", buf);
		return ret;
	}
	D("set utilisation_period to '%d'.", platform->utilisation_period);

	return count;
}

static ssize_t utilisation_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
	struct rk_context *platform = s_rk_context;
	struct mali_device *mdev = dev_get_drvdata(dev);
	ssize_t ret = 0;
	unsigned long period_in_us = platform->utilisation_period * 1000;
	unsigned long total_time;
	unsigned long busy_time;
	unsigned long utilisation;

	mali_pm_reset_dvfs_utilisation(mdev);
	usleep_range(period_in_us, period_in_us + 100);
	mali_pm_get_dvfs_utilisation(mdev, &total_time, &busy_time);

	/* 'devfreq_dev_profile' instance registered to devfreq
	 * also uses mali_pm_reset_dvfs_utilisation()
	 * and mali_pm_get_dvfs_utilisation().
	 * So, it's better to disable GPU DVFS before reading this node.
	 */
	D("total_time : %lu, busy_time : %lu.", total_time, busy_time);

	utilisation = busy_time / (total_time / 100);
	ret += snprintf(buf, PAGE_SIZE, "%lu\n", utilisation);

	return ret;
}

static DEVICE_ATTR_RW(utilisation_period);
static DEVICE_ATTR_RO(utilisation);
#endif

static int rk_context_create_sysfs_files(struct device *dev)
{
#ifdef CONFIG_MALI_DEVFREQ
	int ret;

	ret = device_create_file(dev, &dev_attr_utilisation_period);
	if (ret) {
		E("fail to create sysfs file 'utilisation_period'.");
		goto out;
	}

	ret = device_create_file(dev, &dev_attr_utilisation);
	if (ret) {
		E("fail to create sysfs file 'utilisation'.");
		goto remove_utilisation_period;
	}

	return 0;

remove_utilisation_period:
	device_remove_file(dev, &dev_attr_utilisation_period);
out:
	return ret;
#else
	return 0;
#endif
}

static void rk_context_remove_sysfs_files(struct device *dev)
{
#ifdef CONFIG_MALI_DEVFREQ
	device_remove_file(dev, &dev_attr_utilisation_period);
	device_remove_file(dev, &dev_attr_utilisation);
#endif
}

/*---------------------------------------------------------------------------*/

/*
 * Init rk_platform_context of mali_device.
 */
static int rk_context_init(struct platform_device *pdev)
{
	int ret = 0;
	struct device *dev = &pdev->dev;
	struct rk_context *platform; /* platform_context */

	platform = kzalloc(sizeof(*platform), GFP_KERNEL);
	if (!platform) {
		E("no mem.");
		return _MALI_OSK_ERR_NOMEM;
	}

	platform->dev = dev;
	platform->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
							"rockchip,grf");
	if (IS_ERR(platform->grf))
		platform->grf = NULL;
	platform->is_powered = false;

	platform->utilisation_period = DEFAULT_UTILISATION_PERIOD_IN_MS;

	ret = rk_context_create_sysfs_files(dev);
	if (ret) {
		E("fail to create sysfs files, ret = %d", ret);
		goto EXIT;
	}

	s_rk_context = platform;

	pm_runtime_set_autosuspend_delay(dev, 1000);
	pm_runtime_use_autosuspend(dev);
	pm_runtime_enable(dev);

EXIT:
	return ret;
}

static void rk_context_deinit(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct rk_context *platform = s_rk_context;

	pm_runtime_disable(dev);

	s_rk_context = NULL;

	rk_context_remove_sysfs_files(dev);

	if (platform) {
		platform->is_powered = false;
		platform->dev = NULL;
		kfree(platform);
	}
}

/*---------------------------------------------------------------------------*/
/* for devfreq cooling. */

#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_DEVFREQ_THERMAL)

#define FALLBACK_STATIC_TEMPERATURE 55000

static u32 dynamic_coefficient;
static u32 static_coefficient;
static s32 ts[4];
static struct thermal_zone_device *gpu_tz;
static struct ipa_power_model_data *model_data;

/* Calculate gpu static power example for reference */
static unsigned long rk_model_static_power(struct devfreq *devfreq,
					   unsigned long voltage)
{
	int temperature, temp;
	int temp_squared, temp_cubed, temp_scaling_factor;
	const unsigned long voltage_cubed = (voltage * voltage * voltage) >> 10;
	unsigned long static_power;

	if (gpu_tz) {
		int ret;

		ret = gpu_tz->ops->get_temp(gpu_tz, &temperature);
		if (ret) {
			MALI_DEBUG_PRINT(2, ("fail to read temp: %d\n", ret));
			temperature = FALLBACK_STATIC_TEMPERATURE;
		}
	} else {
		temperature = FALLBACK_STATIC_TEMPERATURE;
	}

	/* Calculate the temperature scaling factor. To be applied to the
	 * voltage scaled power.
	 */
	temp = temperature / 1000;
	temp_squared = temp * temp;
	temp_cubed = temp_squared * temp;
	temp_scaling_factor =
			(ts[3] * temp_cubed)
			+ (ts[2] * temp_squared)
			+ (ts[1] * temp)
			+ ts[0];

	static_power = (((static_coefficient * voltage_cubed) >> 20)
			* temp_scaling_factor)
		       / 1000000;

	return static_power;
}

/* Calculate gpu dynamic power example for reference */
static unsigned long rk_model_dynamic_power(struct devfreq *devfreq,
					    unsigned long freq,
					    unsigned long voltage)
{
	/* The inputs: freq (f) is in Hz, and voltage (v) in mV.
	 * The coefficient (c) is in mW/(MHz mV mV).
	 *
	 * This function calculates the dynamic power after this formula:
	 * Pdyn (mW) = c (mW/(MHz*mV*mV)) * v (mV) * v (mV) * f (MHz)
	 */
	const unsigned long v2 = (voltage * voltage) / 1000; /* m*(V*V) */
	const unsigned long f_mhz = freq / 1000000; /* MHz */
	unsigned long dynamic_power;

	dynamic_power = (dynamic_coefficient * v2 * f_mhz) / 1000000; /* mW */

	return dynamic_power;
}

static struct devfreq_cooling_power rk_cooling_ops = {
	.get_static_power = rk_model_static_power,
	.get_dynamic_power = rk_model_dynamic_power,
};

static unsigned long mali_devfreq_get_static_power(struct devfreq *devfreq,
						   unsigned long voltage)
{
	return rockchip_ipa_get_static_power(model_data, voltage);
}

static int power_model_simple_init(struct platform_device *pdev)
{
	struct device_node *power_model_node;
	const char *tz_name;
	u32 static_power, dynamic_power;
	u32 voltage, voltage_squared, voltage_cubed, frequency;

	if (of_find_compatible_node(pdev->dev.of_node, NULL, "simple-power-model")) {
		of_property_read_u32(pdev->dev.of_node,
				     "dynamic-power-coefficient",
				     (u32 *)&rk_cooling_ops.dyn_power_coeff);
		model_data = rockchip_ipa_power_model_init(&pdev->dev,
							   "gpu_leakage");
		if (IS_ERR_OR_NULL(model_data)) {
			model_data = NULL;
			dev_err(&pdev->dev, "failed to initialize power model\n");
		} else if (model_data->dynamic_coefficient) {
			rk_cooling_ops.dyn_power_coeff =
			model_data->dynamic_coefficient;
			rk_cooling_ops.get_dynamic_power = NULL;
			rk_cooling_ops.get_static_power = mali_devfreq_get_static_power;
		}
		if (!rk_cooling_ops.dyn_power_coeff) {
			dev_err(&pdev->dev, "failed to get dynamic-coefficient\n");
			return -EINVAL;
		}

		return 0;
	}

	power_model_node = of_get_child_by_name(pdev->dev.of_node,
			"power_model");
	if (!power_model_node) {
		dev_err(&pdev->dev, "could not find power_model node\n");
		return -ENODEV;
	}
	if (!of_device_is_compatible(power_model_node,
			"arm,mali-simple-power-model")) {
		dev_err(&pdev->dev, "power_model incompatible with simple power model\n");
		return -ENODEV;
	}

	if (of_property_read_string(power_model_node, "thermal-zone",
			&tz_name)) {
		dev_err(&pdev->dev, "ts in power_model not available\n");
		return -EINVAL;
	}

	gpu_tz = thermal_zone_get_zone_by_name(tz_name);
	if (IS_ERR(gpu_tz)) {
		pr_warn_ratelimited("Error getting gpu thermal zone '%s'(%ld), not yet ready?\n",
				tz_name,
				PTR_ERR(gpu_tz));
		gpu_tz = NULL;
	}

	if (of_property_read_u32(power_model_node, "static-power",
			&static_power)) {
		dev_err(&pdev->dev, "static-power in power_model not available\n");
		return -EINVAL;
	}
	if (of_property_read_u32(power_model_node, "dynamic-power",
			&dynamic_power)) {
		dev_err(&pdev->dev, "dynamic-power in power_model not available\n");
		return -EINVAL;
	}
	if (of_property_read_u32(power_model_node, "voltage",
			&voltage)) {
		dev_err(&pdev->dev, "voltage in power_model not available\n");
		return -EINVAL;
	}
	if (of_property_read_u32(power_model_node, "frequency",
			&frequency)) {
		dev_err(&pdev->dev, "frequency in power_model not available\n");
		return -EINVAL;
	}
	voltage_squared = (voltage * voltage) / 1000;
	voltage_cubed = voltage * voltage * voltage;
	static_coefficient = (static_power << 20) / (voltage_cubed >> 10);
	dynamic_coefficient = (((dynamic_power * 1000) / voltage_squared)
			* 1000) / frequency;

	if (of_property_read_u32_array(power_model_node, "ts", (u32 *)ts, 4)) {
		dev_err(&pdev->dev, "ts in power_model not available\n");
		return -EINVAL;
	}

	return 0;
}

#endif

/*---------------------------------------------------------------------------*/

#ifdef CONFIG_PM

static int rk_platform_enable_clk_gpu(struct device *dev)
{
	int ret = 0;
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_HAVE_CLK)
	struct mali_device *mdev = dev_get_drvdata(dev);

	ret = clk_bulk_enable(mdev->num_clks, mdev->clks);
#endif
	return ret;
}

static void rk_platform_disable_clk_gpu(struct device *dev)
{
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_HAVE_CLK)
	struct mali_device *mdev = dev_get_drvdata(dev);

	clk_bulk_disable(mdev->num_clks, mdev->clks);
#endif
}

static int rk_platform_enable_gpu_regulator(struct device *dev)
{
	int ret = 0;
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_REGULATOR)
	struct mali_device *mdev = dev_get_drvdata(dev);

	if (mdev->regulator)
		ret = regulator_enable(mdev->regulator);
#endif
	return ret;
}

static void rk_platform_disable_gpu_regulator(struct device *dev)
{
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_REGULATOR)
	struct mali_device *mdev = dev_get_drvdata(dev);

	if (mdev->regulator)
		regulator_disable(mdev->regulator);
#endif
}

static int rk_platform_power_on_gpu(struct device *dev)
{
	struct rk_context *platform = s_rk_context;
	int ret = 0;

	if (!(platform->is_powered)) {
		ret = rk_platform_enable_clk_gpu(dev);
		if (ret) {
			E("fail to enable clk_gpu, ret : %d.", ret);
			goto fail_to_enable_clk;
		}

		ret = rk_platform_enable_gpu_regulator(dev);
		if (ret) {
			E("fail to enable vdd_gpu, ret : %d.", ret);
			goto fail_to_enable_regulator;
		}

		if (cpu_is_rk3528()) {
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_HAVE_CLK)
			struct mali_device *mdev = dev_get_drvdata(dev);

			clk_set_rate(mdev->clock, mdev->current_freq);
#endif
			if (platform->grf)
				regmap_write(platform->grf,
					     RK3528_GPU_SD_SLP_HAST,
					     0xffff0000);
		}

		platform->is_powered = true;
	}

	return 0;

fail_to_enable_regulator:
	rk_platform_disable_clk_gpu(dev);

fail_to_enable_clk:
	return ret;
}

static void rk_platform_power_off_gpu(struct device *dev)
{
	struct rk_context *platform = s_rk_context;

	if (platform->is_powered) {
		if (cpu_is_rk3528()) {
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_HAVE_CLK)
			struct mali_device *mdev = dev_get_drvdata(dev);

			//use normal pll 200M for gpu when suspend
			clk_set_rate(mdev->clock, 200000000);
#endif
			if (platform->grf)
				regmap_write(platform->grf,
					     RK3528_GPU_SD_SLP_HAST,
					     0xfffffffd);
		}
		rk_platform_disable_clk_gpu(dev);
		rk_platform_disable_gpu_regulator(dev);

		platform->is_powered = false;
	}
}

int rk_platform_init_opp_table(struct device *dev)
{
	return rockchip_init_opp_table(dev, NULL, "gpu_leakage", "mali");
}

static int mali_runtime_suspend(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_runtime_suspend() called\n"));

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->runtime_suspend) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->runtime_suspend(device);
	}

	if (!ret)
		rk_platform_power_off_gpu(device);

	return ret;
}

static int mali_runtime_resume(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_runtime_resume() called\n"));

	rk_platform_power_on_gpu(device);

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->runtime_resume) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->runtime_resume(device);
	}

	return ret;
}

static int mali_runtime_idle(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_runtime_idle() called\n"));

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->runtime_idle) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->runtime_idle(device);
		if (ret)
			return ret;
	}

	return 0;
}
#endif

static int mali_os_suspend(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_os_suspend() called\n"));

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->suspend) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->suspend(device);
	}

	if (!ret)
		rk_platform_power_off_gpu(device);

	return ret;
}

static int mali_os_resume(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_os_resume() called\n"));

	rk_platform_power_on_gpu(device);

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->resume) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->resume(device);
	}

	return ret;
}

static int mali_os_freeze(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_os_freeze() called\n"));

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->freeze) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->freeze(device);
	}

	return ret;
}

static int mali_os_thaw(struct device *device)
{
	int ret = 0;

	MALI_DEBUG_PRINT(4, ("mali_os_thaw() called\n"));

	if (device->driver &&
	    device->driver->pm &&
	    device->driver->pm->thaw) {
		/* Need to notify Mali driver about this event */
		ret = device->driver->pm->thaw(device);
	}

	return ret;
}

static const struct dev_pm_ops mali_gpu_device_type_pm_ops = {
	.suspend = mali_os_suspend,
	.resume = mali_os_resume,
	.freeze = mali_os_freeze,
	.thaw = mali_os_thaw,
#ifdef CONFIG_PM
	.runtime_suspend = mali_runtime_suspend,
	.runtime_resume = mali_runtime_resume,
	.runtime_idle = mali_runtime_idle,
#endif
};

static const struct device_type mali_gpu_device_device_type = {
	.pm = &mali_gpu_device_type_pm_ops,
};

/*
 * platform_specific_data of platform_device of mali_gpu.
 */
static const struct mali_gpu_device_data mali_gpu_data = {
	.shared_mem_size = 1024 * 1024 * 1024, /* 1GB */
	.max_job_runtime = 60000, /* 60 seconds */
#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_DEVFREQ_THERMAL)
	.gpu_cooling_ops = &rk_cooling_ops,
#endif
};

static void mali_platform_device_add_config(struct platform_device *pdev)
{
	pdev->name = MALI_GPU_NAME_UTGARD,
	pdev->id = 0;
	pdev->dev.type = &mali_gpu_device_device_type;
	pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask,
	pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
}

/*---------------------------------------------------------------------------*/
/* platform_device_functions called by common_part. */

int mali_platform_device_init(struct platform_device *pdev)
{
	int err = 0;

	mali_platform_device_add_config(pdev);

	D("to add platform_specific_data to platform_device_of_mali.");
	err = platform_device_add_data(pdev,
				       &mali_gpu_data,
				       sizeof(mali_gpu_data));
	if (err) {
		E("fail to add platform_specific_data. err : %d.", err);
		goto add_data_failed;
	}

	err = rk_context_init(pdev);
	if (err) {
		E("fail to init rk_context. err : %d.", err);
		goto init_rk_context_failed;
	}

#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_DEVFREQ_THERMAL)
	if (of_machine_is_compatible("rockchip,rk3036"))
		return 0;

	err = power_model_simple_init(pdev);
	if (err) {
		E("fail to init simple_power_model, err : %d.", err);
		goto init_power_model_failed;
	}
#endif

	return 0;

#if defined(CONFIG_MALI_DEVFREQ) && defined(CONFIG_DEVFREQ_THERMAL)
init_power_model_failed:
	rk_context_deinit(pdev);
#endif
init_rk_context_failed:
add_data_failed:
	return err;
}

void mali_platform_device_deinit(struct platform_device *pdev)
{
	MALI_DEBUG_PRINT(4, ("mali_platform_device_unregister() called\n"));

	rk_context_deinit(pdev);
}