/**
 * Copyright (c) 2015-2019, NVIDIA CORPORATION. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/platform/tegra/emc_bwmgr.h>
#include <linux/platform/tegra/isomgr.h>
#include <linux/debugfs.h>
#include <linux/thermal.h>
#include <linux/version.h>
#include <soc/tegra/chip-id.h>

#define CREATE_TRACE_POINTS
#include <trace/events/bwmgr.h>

u8 bwmgr_dram_efficiency;
u8 bwmgr_dram_num_channels;
/* flag to determine supported memory and channel configuration */
u8 bwmgr_dram_config_supported;
u32 *bwmgr_dram_iso_eff_table;
u32 *bwmgr_dram_noniso_eff_table;
u32 *bwmgr_max_nvdis_bw_reqd;
u32 *bwmgr_max_vi_bw_reqd;
int *bwmgr_slope;
u32 *bwmgr_vi_bw_reqd_offset;
int bwmgr_iso_bw_percentage;
enum bwmgr_dram_types bwmgr_dram_type;
int emc_to_dram_freq_factor;

#define IS_HANDLE_VALID(x) ((x >= bwmgr.bwmgr_client) && \
		(x < bwmgr.bwmgr_client + TEGRA_BWMGR_CLIENT_COUNT))

struct tegra_bwmgr_client {
	unsigned long bw;
	unsigned long iso_bw;
	unsigned long cap;
	unsigned long iso_cap;
	unsigned long floor;
	int refcount;
};

/* TODO: Manage client state in a dynamic list */
static struct {
	struct tegra_bwmgr_client bwmgr_client[TEGRA_BWMGR_CLIENT_COUNT];
	struct mutex lock;
	unsigned long emc_min_rate;
	unsigned long emc_max_rate;
	struct clk *emc_clk;
	struct task_struct *task;
	bool status;
	struct bwmgr_ops *ops;
	bool override;
} bwmgr;

static struct dram_refresh_alrt {
	unsigned long cur_state;
	u32 max_cooling_state;
	struct thermal_cooling_device *cdev;
} *galert_data;

static bool clk_update_disabled;

static struct {
	unsigned long bw;
	unsigned long iso_bw;
	unsigned long non_iso_cap;
	unsigned long iso_cap;
	unsigned long floor;
	unsigned long total_bw_aftr_eff;
	unsigned long iso_bw_aftr_eff;
	unsigned long calc_freq;
	unsigned long req_freq;
} debug_info;

static void bwmgr_debugfs_init(void);

/* keep in sync with tegra_bwmgr_client_id */
static const char * const tegra_bwmgr_client_names[] = {
	"cpu_cluster_0",
	"cpu_cluster_1",
	"cpu_cluster_2",
	"cpu_cluster_3",
	"disp_0",
	"disp_1",
	"disp_2",
	"disp1_la_emc",
	"disp2_la_emc",
	"usbd",
	"xhci",
	"sdmmc1",
	"sdmmc2",
	"sdmmc3",
	"sdmmc4",
	"mon",
	"gpu",
	"msenc",
	"nvenc1",
	"nvjpg",
	"nvdec",
	"nvdec1",
	"tsec",
	"tsecb",
	"vi",
	"ispa",
	"ispb",
	"camera",
	"camera_non_iso",
	"camrtc",
	"isomgr",
	"thermal",
	"vic",
	"adsp",
	"adma",
	"pcie",
	"pcie_1",
	"pcie_2",
	"pcie_3",
	"pcie_4",
	"pcie_5",
	"bbc_0",
	"eqos",
	"se0",
	"se1",
	"se2",
	"se3",
	"se4",
	"pmqos",
	"nvpmodel",
	"debug",
	"nvdla0",
	"nvdla1",
	"null",
};

#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_TRACEPOINTS)
static const char *bwmgr_req_to_name(enum tegra_bwmgr_request_type req)
{
	/* Keep in sync with enum tegra_bwmgr_request_type. */
	switch (req) {
	case TEGRA_BWMGR_SET_EMC_FLOOR:
		return "TEGRA_BWMGR_SET_EMC_FLOOR";
	case TEGRA_BWMGR_SET_EMC_CAP:
		return "TEGRA_BWMGR_SET_EMC_CAP";
	case TEGRA_BWMGR_SET_EMC_ISO_CAP:
		return "TEGRA_BWMGR_SET_EMC_ISO_CAP";
	case TEGRA_BWMGR_SET_EMC_SHARED_BW:
		return "TEGRA_BWMGR_SET_EMC_SHARED_BW";
	case TEGRA_BWMGR_SET_EMC_SHARED_BW_ISO:
		return "TEGRA_BWMGR_SET_EMC_SHARED_BW_ISO";
	default:
		return "INVALID_REQUEST";
	}
}
#endif /* defined(CONFIG_DEBUG_FS) && defined(CONFIG_TRACEPOINTS) */

static inline bool bwmgr_lock(void)
{
	/* disallow rentrance, avoid deadlock */
	if (unlikely(bwmgr.task == current)) {
		pr_err("bwmgr: %s deadlock ?\n", __func__);
		dump_stack();
		return false;
	}
	mutex_lock(&bwmgr.lock);
	bwmgr.task = current;
	return true;
}

static inline bool bwmgr_unlock(void)
{
	/* detect mismatched calls */
	if (unlikely(bwmgr.task != current)) {
		pr_err("bwmgr: %s mismatch ?\n", __func__);
		dump_stack();
		return false;
	}
	bwmgr.task = NULL;
	mutex_unlock(&bwmgr.lock);
	return true;
}

/* call with bwmgr lock held except during init*/
static void purge_client(struct tegra_bwmgr_client *handle)
{
	handle->bw = 0;
	handle->iso_bw = 0;
	handle->cap = bwmgr.emc_max_rate;
	handle->iso_cap = bwmgr.emc_max_rate;
	handle->floor = 0;
	handle->refcount = 0;
}

static unsigned long tegra_bwmgr_apply_efficiency(
		unsigned long total_bw, unsigned long iso_bw,
		unsigned long max_rate, u64 usage_flags,
		unsigned long *iso_bw_min, unsigned long iso_bw_nvdis,
		unsigned long iso_bw_vi)
{
	return bwmgr.ops->bwmgr_apply_efficiency(total_bw, iso_bw,
			max_rate, usage_flags, iso_bw_min,
			iso_bw_nvdis, iso_bw_vi);
}

/* call with bwmgr lock held */
static int bwmgr_update_clk(void)
{
	int i;
	unsigned long bw = 0;
	unsigned long iso_bw = 0; // iso_bw_guarantee
	unsigned long iso_bw_nvdis = 0; //DISP0 + DISP1 + DISP2
	unsigned long iso_bw_vi = 0; //CAMERA
	unsigned long iso_bw_other_clients = 0; //Other ISO clients
	unsigned long non_iso_cap = bwmgr.emc_max_rate;
	unsigned long iso_cap = bwmgr.emc_max_rate;
	unsigned long floor = 0;
	unsigned long iso_bw_min;
	u64 iso_client_flags = 0;
	int ret = 0;

	/* sizeof(iso_client_flags) */
	BUILD_BUG_ON(TEGRA_BWMGR_CLIENT_COUNT > 64);
	/* check that lock is held */
	if (unlikely(bwmgr.task != current)) {
		pr_err("bwmgr: %s called without lock\n", __func__);
		return -EINVAL;
	}

	if (bwmgr.override)
		return 0;

	for (i = 0; i < TEGRA_BWMGR_CLIENT_COUNT; i++) {
		bw += bwmgr.bwmgr_client[i].bw;
		bw = min(bw, bwmgr.emc_max_rate);

		if (bwmgr.bwmgr_client[i].iso_bw > 0) {
			iso_client_flags |= BIT(i);

			if ((i == TEGRA_BWMGR_CLIENT_DISP0) ||
					(i == TEGRA_BWMGR_CLIENT_DISP1) ||
					(i == TEGRA_BWMGR_CLIENT_DISP2)) {
				iso_bw_nvdis += bwmgr.bwmgr_client[i].iso_bw;
				iso_bw_nvdis = min(iso_bw_nvdis,
							bwmgr.emc_max_rate);
			} else if (i == TEGRA_BWMGR_CLIENT_CAMERA) {
				iso_bw_vi += bwmgr.bwmgr_client[i].iso_bw;
				iso_bw_vi = min(iso_bw_vi, bwmgr.emc_max_rate);
			} else {
				iso_bw_other_clients +=
						bwmgr.bwmgr_client[i].iso_bw;
				iso_bw_other_clients = min(iso_bw_other_clients,
							bwmgr.emc_max_rate);
			}

			iso_bw = iso_bw_nvdis + iso_bw_vi +
						iso_bw_other_clients;
			iso_bw = min(iso_bw, bwmgr.emc_max_rate);
		}

		non_iso_cap = min(non_iso_cap, bwmgr.bwmgr_client[i].cap);
		iso_cap = min(iso_cap, bwmgr.bwmgr_client[i].iso_cap);
		floor = max(floor, bwmgr.bwmgr_client[i].floor);
	}
	debug_info.bw = bw;
	debug_info.iso_bw = iso_bw;
	debug_info.floor = floor;
	debug_info.iso_cap = iso_cap;
	debug_info.non_iso_cap = non_iso_cap;
	bw += iso_bw;
	bw = tegra_bwmgr_apply_efficiency(
			bw, iso_bw, bwmgr.emc_max_rate,
			iso_client_flags, &iso_bw_min,
			iso_bw_nvdis, iso_bw_vi);
	debug_info.total_bw_aftr_eff = bw;
	debug_info.iso_bw_aftr_eff = iso_bw_min;
	floor = min(floor, bwmgr.emc_max_rate);
	bw = max(bw, floor);
	bw = min(bw, min(iso_cap, max(non_iso_cap, iso_bw_min)));
	debug_info.calc_freq = bw;
	debug_info.req_freq = bw;

	ret = clk_set_rate(bwmgr.emc_clk, bw);
	if (ret)
		pr_err
		("bwmgr: clk_set_rate failed for freq %lu Hz with errno %d\n",
				bw, ret);

	return ret;
}

struct tegra_bwmgr_client *tegra_bwmgr_register(
		enum tegra_bwmgr_client_id client)
{
	if (!bwmgr_dram_config_supported) {
		pr_err("bwmgr: ddr config not supported\n");
		WARN_ON(true);
		return ERR_PTR(-EINVAL);
	}

	if ((client >= TEGRA_BWMGR_CLIENT_COUNT) || (client < 0)) {
		pr_err("bwmgr: invalid client id %d tried to register",
				client);
		WARN_ON(true);
		return ERR_PTR(-EINVAL);
	}

	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__, tegra_bwmgr_client_names[client]);
		return ERR_PTR(-EINVAL);
	}

	(bwmgr.bwmgr_client + client)->refcount++;

	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__, tegra_bwmgr_client_names[client]);
		return ERR_PTR(-EINVAL);
	}
	return (bwmgr.bwmgr_client + client);
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_register);

void tegra_bwmgr_unregister(struct tegra_bwmgr_client *handle)
{
	if (!IS_HANDLE_VALID(handle)) {
		WARN_ON(true);
		return;
	}

	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
		return;
	}
	handle->refcount--;

	if (handle->refcount <= 0) {
		if (handle->refcount < 0) {
			pr_err("bwmgr: Mismatched unregister call, client %ld\n",
				handle - bwmgr.bwmgr_client);
			WARN_ON(true);
		}
		purge_client(handle);
	}

	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
		return;
	}
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_unregister);

u8 tegra_bwmgr_get_dram_num_channels(void)
{
	return bwmgr_dram_num_channels;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_get_dram_num_channels);

unsigned long tegra_bwmgr_get_max_emc_rate(void)
{
	return bwmgr.emc_max_rate;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_get_max_emc_rate);

/* Returns the ratio between dram and emc freq based on the type of dram */
int bwmgr_get_emc_to_dram_freq_factor(void)
{
	return emc_to_dram_freq_factor;
}
EXPORT_SYMBOL_GPL(bwmgr_get_emc_to_dram_freq_factor);

/* Returns the actual emc frequency calculated using the dram
 * frequency and emc_to_dram conversion factor
 */
unsigned long tegra_bwmgr_get_core_emc_rate(void)
{
	return (unsigned long)(tegra_bwmgr_get_emc_rate() /
		bwmgr_get_emc_to_dram_freq_factor());
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_get_core_emc_rate);

unsigned long tegra_bwmgr_round_rate(unsigned long bw)
{
	if (bwmgr.emc_clk)
		return clk_round_rate(bwmgr.emc_clk, bw);

	return 0;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_round_rate);

int tegra_bwmgr_set_emc(struct tegra_bwmgr_client *handle, unsigned long val,
		enum tegra_bwmgr_request_type req)
{
	int ret = 0;
	bool update_clk = false;

	if (!bwmgr.emc_clk)
		return 0;

	if (!bwmgr.status)
		return 0;

	if (!bwmgr_dram_config_supported) {
		pr_err("bwmgr: ddr config not supported\n");
		WARN_ON(true);
		return -EINVAL;
	}

	if (!IS_HANDLE_VALID(handle)) {
		pr_err("bwmgr: client sent bad handle %p\n",
				handle);
		WARN_ON(true);
		return -EINVAL;
	}

	if (req >= TEGRA_BWMGR_SET_EMC_REQ_COUNT) {
		pr_err("bwmgr: client %ld sent bad request type %d\n",
				handle - bwmgr.bwmgr_client, req);
		WARN_ON(true);
		return -EINVAL;
	}

	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
		return -EINVAL;
	}

#ifdef CONFIG_TRACEPOINTS
	trace_tegra_bwmgr_set_emc(
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client],
			val, bwmgr_req_to_name(req));
#endif /* CONFIG_TRACEPOINTS */

	switch (req) {
	case TEGRA_BWMGR_SET_EMC_FLOOR:
		if (handle->floor != val) {
			handle->floor = val;
			update_clk = true;
		}
		break;

	case TEGRA_BWMGR_SET_EMC_CAP:
		if (val == 0)
			val = bwmgr.emc_max_rate;

		if (handle->cap != val) {
			handle->cap = val;
			update_clk = true;
		}
		break;

	case TEGRA_BWMGR_SET_EMC_ISO_CAP:
		if (val == 0)
			val = bwmgr.emc_max_rate;

		if (handle->iso_cap != val) {
			handle->iso_cap = val;
			update_clk = true;
		}
		break;

	case TEGRA_BWMGR_SET_EMC_SHARED_BW:
		if (handle->bw != val) {
			handle->bw = val;
			update_clk = true;
		}
		break;

	case TEGRA_BWMGR_SET_EMC_SHARED_BW_ISO:
		if (handle->iso_bw != val) {
			handle->iso_bw = val;
			update_clk = true;
		}
		break;

	default:
		WARN_ON(true);
		if (!bwmgr_unlock()) {
			pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
			return -EINVAL;
		}
		return -EINVAL;
	}

	if (update_clk && !clk_update_disabled)
		ret = bwmgr_update_clk();

	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
		return -EINVAL;
	}

	return ret;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_set_emc);

int tegra_bwmgr_get_client_info(struct tegra_bwmgr_client *handle,
		unsigned long *out_val,
		enum tegra_bwmgr_request_type req)
{
	if (!bwmgr.emc_clk)
		return 0;

	if (!bwmgr.status)
		return 0;

	if (!bwmgr_dram_config_supported) {
		pr_err("bwmgr: ddr config not supported\n");
		WARN_ON(true);
		return -EINVAL;
	}

	if (!IS_HANDLE_VALID(handle)) {
		pr_err("bwmgr: client sent bad handle %p\n",
				handle);
		WARN_ON(true);
		return -EINVAL;
	}

	if (req >= TEGRA_BWMGR_SET_EMC_REQ_COUNT) {
		pr_err("bwmgr: client %ld sent bad request type %d\n",
				handle - bwmgr.bwmgr_client, req);
		WARN_ON(true);
		return -EINVAL;
	}

	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
		return -EINVAL;
	}

	switch (req) {
	case TEGRA_BWMGR_SET_EMC_FLOOR:
		*out_val = handle->floor;
		break;

	case TEGRA_BWMGR_SET_EMC_CAP:
		*out_val = handle->cap;
		break;

	case TEGRA_BWMGR_SET_EMC_ISO_CAP:
		*out_val = handle->iso_cap;
		break;

	case TEGRA_BWMGR_SET_EMC_SHARED_BW:
		*out_val = handle->bw;
		break;

	case TEGRA_BWMGR_SET_EMC_SHARED_BW_ISO:
		*out_val = handle->iso_bw;
		break;

	default:
		WARN_ON(true);
		if (!bwmgr_unlock()) {
			pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
			return -EINVAL;
		}
		return -EINVAL;
	}

	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed for client %s\n",
			__func__,
			tegra_bwmgr_client_names[handle - bwmgr.bwmgr_client]);
		return -EINVAL;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_get_client_info);

int tegra_bwmgr_notifier_register(struct notifier_block *nb)
{
	if (!nb)
		return -EINVAL;

	if (bwmgr.emc_clk)
		return clk_notifier_register(bwmgr.emc_clk, nb);
	else
		return -ENODEV;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_notifier_register);

int tegra_bwmgr_notifier_unregister(struct notifier_block *nb)
{
	if (!nb)
		return -EINVAL;

	if (bwmgr.emc_clk)
		return clk_notifier_unregister(bwmgr.emc_clk, nb);
	else
		return -ENODEV;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_notifier_unregister);

unsigned long tegra_bwmgr_get_emc_rate(void)
{
	if (bwmgr.emc_clk)
		return clk_get_rate(bwmgr.emc_clk);

	return 0;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_get_emc_rate);

/* bwmgr_get_lowest_iso_emc_freq
 * bwmgr_apply_efficiency function will use this api to calculate
 * the lowest emc frequency that satisfies the requests of ISO clients.
 *
 * A return value of 0 indicates that the requested
 * iso bandwidth cannot be supported.
 */
unsigned long bwmgr_get_lowest_iso_emc_freq(long iso_bw,
				long iso_bw_nvdis, long iso_bw_vi)
{
	return bwmgr.ops->get_best_iso_freq(iso_bw, iso_bw_nvdis, iso_bw_vi);
}
EXPORT_SYMBOL_GPL(bwmgr_get_lowest_iso_emc_freq);

/* tegra_bwmgr_get_max_iso_bw
 * This function returns the max iso bw.
 * This is applicable from t19x onwards, where max_iso is different
 * based on clients requesting.
 * This should not be called on pre t19x and returns 0 in those cases
 */
u32 tegra_bwmgr_get_max_iso_bw(enum tegra_iso_client client)
{
	if (bwmgr.ops->get_max_iso_bw)
		return bwmgr.ops->get_max_iso_bw(client);

	return 0;
}
EXPORT_SYMBOL_GPL(tegra_bwmgr_get_max_iso_bw);

int bwmgr_iso_bw_percentage_max(void)
{
	return bwmgr_iso_bw_percentage;
}
EXPORT_SYMBOL_GPL(bwmgr_iso_bw_percentage_max);

unsigned long bwmgr_freq_to_bw(unsigned long freq)
{
	return bwmgr.ops->freq_to_bw(freq);
}
EXPORT_SYMBOL_GPL(bwmgr_freq_to_bw);

unsigned long bwmgr_bw_to_freq(unsigned long bw)
{
	return bwmgr.ops->bw_to_freq(bw);
}
EXPORT_SYMBOL_GPL(bwmgr_bw_to_freq);

u32 bwmgr_dvfs_latency(u32 ufreq)
{
	return bwmgr.ops->dvfs_latency(ufreq);
}
EXPORT_SYMBOL_GPL(bwmgr_dvfs_latency);

/* Get maximum throttle state supported by bwmgr cooling device. */
static int dram_ref_alert_cdev_max_state(struct thermal_cooling_device *tcd,
			unsigned long *state)
{
	struct dram_refresh_alrt *alert_data = tcd->devdata;

	if (!alert_data)
		return -EINVAL;

	*state = (unsigned long)alert_data->max_cooling_state;
	return 0;
}

/* Get current throttle state of the bwmgr cooling device. */
static int dram_ref_alert_cdev_cur_state(struct thermal_cooling_device *tcd,
			unsigned long *state)
{
	struct dram_refresh_alrt *alert_data = tcd->devdata;

	if (!alert_data)
		return -EINVAL;

	*state = alert_data->cur_state;
	return 0;
}

static int tegra_bwmgr_update_efficiency(unsigned long cur_state,
				unsigned long prev_state)
{
	int ret = 0;

#ifdef CONFIG_TRACEPOINTS
	trace_tegra_bwmgr_update_efficiency(
			cur_state, prev_state);
#endif /* CONFIG_TRACEPOINTS */

	/* At this point, the thermal framework has indicated that
	 * the trip point has been crossed for AO-therm zone. However,
	 * this does not guarantee dram refresh rate has been changed.
	 * talk to bpmp at this point to find out if dram refresh rate
	 * has changed or not. This will be implemented once the bpmp
	 * IPC's are ready.For now update efficiency.
	 */
	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed\n", __func__);
		return -EINVAL;
	}

	if (bwmgr.override) {
		bwmgr_unlock();
		return 0;
	}

	if (bwmgr.ops->update_efficiency)
		bwmgr.ops->update_efficiency(cur_state);

	if (!clk_update_disabled)
		ret = bwmgr_update_clk();

	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed.\n", __func__);
		return -EINVAL;
	}

	return ret;
}

/* Set current throttle state of the bwmgr cooling device. */
static int dram_ref_alert_cdev_set_state(struct thermal_cooling_device *tcd,
				unsigned long state)
{
	int ret = 0;
	unsigned long prev_state;
	struct dram_refresh_alrt *alert_data = tcd->devdata;

	if (!alert_data)
		return -EINVAL;

	prev_state = alert_data->cur_state;
	alert_data->cur_state = state;

	ret = tegra_bwmgr_update_efficiency(state, prev_state);

	return ret;
}

/*
 * Cooling device operations.
 */
static struct thermal_cooling_device_ops dram_ref_alert_cdev_ops = {
	.get_max_state = dram_ref_alert_cdev_max_state,
	.get_cur_state = dram_ref_alert_cdev_cur_state,
	.set_cur_state = dram_ref_alert_cdev_set_state,
};

int __init bwmgr_init(void)
{
	int i;
	struct device_node *dn;
	long round_rate;
	struct clk *emc_master_clk;

	mutex_init(&bwmgr.lock);

	if (tegra_get_chip_id() == TEGRA210)
		bwmgr.ops = bwmgr_eff_init_t21x();
	else if (tegra_get_chip_id() == TEGRA186)
		bwmgr.ops = bwmgr_eff_init_t18x();
	else if (tegra_get_chip_id() == TEGRA194)
		bwmgr.ops = bwmgr_eff_init_t19x();
	else
		/*
		 * Fall back to t19x if we are running on a new chip.
		 */
		bwmgr.ops = bwmgr_eff_init_t19x();

	dn = of_find_compatible_node(NULL, NULL, "nvidia,bwmgr");
	if (dn == NULL) {
		pr_err("bwmgr: dt node not found.\n");
		return -ENODEV;
	}

	bwmgr.emc_clk = of_clk_get(dn, 0);
	if (IS_ERR_OR_NULL(bwmgr.emc_clk)) {
		pr_err("bwmgr: couldn't find emc clock.\n");
		bwmgr.emc_clk = NULL;
		WARN_ON(true);
		return -ENODEV;
	}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 14, 0)
	clk_prepare_enable(bwmgr.emc_clk);
#endif

	emc_master_clk = bwmgr.emc_clk;
	if (of_property_read_bool(dn, "nvidia,bwmgr-use-shared-master"))
		emc_master_clk = clk_get_parent(emc_master_clk);

	round_rate = clk_round_rate(emc_master_clk, 0);
	if (round_rate < 0) {
		bwmgr.emc_min_rate = 0;
		pr_err("bwmgr: couldn't get emc clock min rate.\n");
	} else
		bwmgr.emc_min_rate = (unsigned long)round_rate;

	/* Use LONG_MAX as downstream functions treats rate arg as signed */
	round_rate = clk_round_rate(emc_master_clk, LONG_MAX);
	if (round_rate < 0) {
		bwmgr.emc_max_rate = 0;
		pr_err("bwmgr: couldn't get emc clock max rate.\n");
	} else
		bwmgr.emc_max_rate = (unsigned long)round_rate;

	/* On some pre-si platforms max rate is acquired via DT */
	if (tegra_platform_is_sim() || tegra_platform_is_fpga()) {
		if (of_property_read_u64(dn, "max_rate_Hz",
					(u64 *) &round_rate) == 0) {
			pr_err("bwmgr: using max rate from device tree.\n");
			bwmgr.emc_max_rate = round_rate;
		}
	}

	for (i = 0; i < TEGRA_BWMGR_CLIENT_COUNT; i++)
		purge_client(bwmgr.bwmgr_client + i);

	bwmgr_debugfs_init();
	pmqos_bwmgr_init();

	/* Check status property is okay or not. */
	if (of_device_is_available(dn))
		bwmgr.status = true;
	else
		bwmgr.status = false;

	return 0;
}
subsys_initcall_sync(bwmgr_init);

void __exit bwmgr_exit(void)
{
	int i;

	for (i = 0; i < TEGRA_BWMGR_CLIENT_COUNT; i++)
		purge_client(bwmgr.bwmgr_client + i);

	bwmgr.emc_clk = NULL;
	mutex_destroy(&bwmgr.lock);

	if (galert_data)
		thermal_cooling_device_unregister(galert_data->cdev);

	kfree(galert_data);
}
module_exit(bwmgr_exit);

static int __init bwmgr_cooling_init(void)
{
	struct device_node *dn;
	char *cdev_type;
	const char *str;
	int ret = 0;

	galert_data = kzalloc(sizeof(struct dram_refresh_alrt),
					GFP_KERNEL);
	if (!galert_data)
		return -ENOMEM;

	dn = of_find_compatible_node(NULL, NULL, "nvidia,bwmgr");
	if (dn == NULL) {
		pr_err("bwmgr: dt node not found.\n");
		ret = -ENODEV;
		goto error;
	}

	if (of_property_read_string(dn, "cdev-type", &str) == 0) {
		cdev_type = (char *)str;
	} else {
		pr_info("bwmgr: missing cdev-type property\n");
		goto error;
	}

	if (of_property_read_u32(dn, "cooling-max-state",
				&(galert_data->max_cooling_state))) {
		pr_err("bwmgr: missing max_cooling_state property\n");
		ret = -EINVAL;
		goto error;
	}

	galert_data->cur_state = 0;
	galert_data->cdev = thermal_of_cooling_device_register(dn, cdev_type,
				galert_data, &dram_ref_alert_cdev_ops);

	if (IS_ERR(galert_data->cdev)) {
		ret = PTR_ERR(galert_data->cdev);
		pr_err("bwmgr: failed to register to thermal framework\n");
		goto error;
	}

	return 0;

error:
	kfree(galert_data);
	return ret;
}
late_initcall(bwmgr_cooling_init);
/* thermal_init is fs_init, make bwmgr_cooling_init late_init as it
 * depends on thermal_init
 */

#ifdef CONFIG_DEBUG_FS
static struct tegra_bwmgr_client *bwmgr_debugfs_client_handle;
static struct dentry *debugfs_dir;
static struct dentry *debugfs_node_floor;
static struct dentry *debugfs_node_cap;
static struct dentry *debugfs_node_iso_cap;
static struct dentry *debugfs_node_bw;
static struct dentry *debugfs_node_iso_bw;
static struct dentry *debugfs_node_emc_rate;
static struct dentry *debugfs_node_emc_min;
static struct dentry *debugfs_node_emc_max;
static struct dentry *debugfs_node_core_emc_rate;
static struct dentry *debugfs_node_clients_info;
static struct dentry *debugfs_node_dram_channels;

static int bwmgr_debugfs_emc_rate_set(void *data, u64 val)
{
	int ret = 0;

	if (!bwmgr_lock())
		return -EPERM;

	if (val == 0) {
		bwmgr.override = false;
		bwmgr_update_clk();
	} else if (bwmgr.emc_clk) {
		bwmgr.override = true;
		ret = clk_set_rate(bwmgr.emc_clk, val);
	}

	if (!bwmgr_unlock())
		return -EPERM;

	return ret;
}

static int bwmgr_debugfs_emc_rate_get(void *data, u64 *val)
{
	*val = tegra_bwmgr_get_emc_rate();
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_emc_rate, bwmgr_debugfs_emc_rate_get,
		bwmgr_debugfs_emc_rate_set, "%llu\n");

static int bwmgr_debugfs_core_emc_rate_get(void *data, u64 *val)
{
	*val = tegra_bwmgr_get_core_emc_rate();
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_core_emc_rate,
	bwmgr_debugfs_core_emc_rate_get, NULL, "%llu\n");

static int bwmgr_debugfs_dram_channels_get(void *data, u64 *val)
{
	*val = bwmgr_dram_num_channels;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_dram_channels,
	bwmgr_debugfs_dram_channels_get, NULL, "%llu\n");

static int bwmgr_debugfs_floor_set(void *data, u64 val)
{
	tegra_bwmgr_set_emc(bwmgr_debugfs_client_handle, val,
			TEGRA_BWMGR_SET_EMC_FLOOR);
	return 0;
}

static int bwmgr_debugfs_floor_get(void *data, u64 *val)
{
	*val = bwmgr_debugfs_client_handle->floor;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_floor, bwmgr_debugfs_floor_get,
		bwmgr_debugfs_floor_set, "%llu\n");

static int bwmgr_debugfs_cap_set(void *data, u64 val)
{
	tegra_bwmgr_set_emc(bwmgr_debugfs_client_handle, val,
			TEGRA_BWMGR_SET_EMC_CAP);
	return 0;
}

static int bwmgr_debugfs_cap_get(void *data, u64 *val)
{
	*val = bwmgr_debugfs_client_handle->cap;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_cap, bwmgr_debugfs_cap_get,
		bwmgr_debugfs_cap_set, "%llu\n");

static int bwmgr_debugfs_iso_cap_set(void *data, u64 val)
{
	tegra_bwmgr_set_emc(bwmgr_debugfs_client_handle, val,
			TEGRA_BWMGR_SET_EMC_ISO_CAP);
	return 0;
}

static int bwmgr_debugfs_iso_cap_get(void *data, u64 *val)
{
	*val = bwmgr_debugfs_client_handle->iso_cap;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_iso_cap, bwmgr_debugfs_iso_cap_get,
		bwmgr_debugfs_iso_cap_set, "%llu\n");

static int bwmgr_debugfs_bw_set(void *data, u64 val)
{
	tegra_bwmgr_set_emc(bwmgr_debugfs_client_handle, val,
			TEGRA_BWMGR_SET_EMC_SHARED_BW);
	return 0;
}

static int bwmgr_debugfs_bw_get(void *data, u64 *val)
{
	*val = bwmgr_debugfs_client_handle->bw;
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_bw, bwmgr_debugfs_bw_get,
		bwmgr_debugfs_bw_set, "%llu\n");

static int bwmgr_debugfs_iso_bw_set(void *data, u64 val)
{
	tegra_bwmgr_set_emc(bwmgr_debugfs_client_handle, val,
			TEGRA_BWMGR_SET_EMC_SHARED_BW_ISO);
	return 0;
}

static int bwmgr_debugfs_iso_bw_get(void *data, u64 *val)
{
	*val = bwmgr_debugfs_client_handle->iso_bw;
	return 0;
}

static int bwmgr_clients_info_show(struct seq_file *s, void *data)
{
	int i;

	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed\n", __func__);
		return -EINVAL;
	}
	seq_printf(s, "%15s%15s%15s%15s%15s%15s (Khz)\n", "Client",
			"Floor", "SharedBw", "SharedIsoBw", "Cap",
			"IsoCap");
	for (i = 0; i < TEGRA_BWMGR_CLIENT_COUNT; i++) {
		seq_printf(s, "%14s%s%15lu%15lu%15lu%15lu%15lu\n",
				tegra_bwmgr_client_names[i],
				bwmgr.bwmgr_client[i].refcount ? "*" : " ",
				bwmgr.bwmgr_client[i].floor / 1000,
				bwmgr.bwmgr_client[i].bw / 1000,
				bwmgr.bwmgr_client[i].iso_bw / 1000,
				bwmgr.bwmgr_client[i].cap / 1000,
				bwmgr.bwmgr_client[i].iso_cap / 1000);
	}
	seq_printf(s, "Total BW requested                              : %lu (Khz)\n",
				 debug_info.bw / 1000);
	seq_printf(s, "Total ISO_BW requested                          : %lu (Khz)\n",
				 debug_info.iso_bw / 1000);
	seq_printf(s, "Effective floor request                         : %lu (Khz)\n",
				 debug_info.floor / 1000);
	seq_printf(s, "Effective NON_ISO_CAP                           : %lu (Khz)\n",
				 debug_info.non_iso_cap / 1000);
	seq_printf(s, "Effective ISO_CAP                               : %lu (Khz)\n",
				 debug_info.iso_cap / 1000);
	seq_printf(s, "Total BW + ISO_BW                               : %lu (Khz)\n",
				 (debug_info.bw + debug_info.iso_bw) / 1000);
	seq_printf(s, "Total BW+ISO_BW after applying efficieny numbers: %lu (Khz)\n",
				 debug_info.total_bw_aftr_eff / 1000);
	seq_printf(s, "Total ISO_BW after applying efficiency          : %lu (Khz)\n",
				 debug_info.iso_bw_aftr_eff / 1000);
	seq_printf(s, "EMC calculated rate                             : %lu (Khz)\n",
				 debug_info.calc_freq / 1000);
	seq_printf(s, "EMC requested(rounded) rate                     : %lu (Khz)\n",
				 debug_info.req_freq / 1000);
	seq_printf(s, "EMC current rate                                : %lu (Khz)\n",
				 tegra_bwmgr_get_emc_rate() / 1000);
	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed\n", __func__);
		return -EINVAL;
	}
	return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(fops_debugfs_iso_bw, bwmgr_debugfs_iso_bw_get,
		bwmgr_debugfs_iso_bw_set, "%llu\n");

static int bwmgr_clients_info_open(struct inode *inode, struct file *file)
{
	return single_open(file, bwmgr_clients_info_show, inode->i_private);
}

static const struct file_operations fops_bwmgr_clients_info = {
	.open = bwmgr_clients_info_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

static void bwmgr_debugfs_init(void)
{
	bwmgr_debugfs_client_handle =
		tegra_bwmgr_register(TEGRA_BWMGR_CLIENT_DEBUG);

	if (IS_ERR_OR_NULL(bwmgr_debugfs_client_handle)) {
		bwmgr_debugfs_client_handle = NULL;
		pr_err("bwmgr: could not register bwmgr debugfs client\n");
		return;
	}

	debugfs_dir = debugfs_create_dir("tegra_bwmgr", NULL);
	if (debugfs_dir) {
		debugfs_create_bool(
			"clk_update_disabled", S_IRWXU, debugfs_dir,
			&clk_update_disabled);
		debugfs_node_emc_min = debugfs_create_u64(
			"emc_min_rate", S_IRUSR, debugfs_dir,
			(u64 *) &bwmgr.emc_min_rate);
		debugfs_node_emc_max = debugfs_create_u64(
			"emc_max_rate", S_IRUSR, debugfs_dir,
			(u64 *) &bwmgr.emc_max_rate);
		debugfs_node_core_emc_rate = debugfs_create_file(
			"core_emc_rate", S_IRUSR, debugfs_dir, NULL,
			 &fops_debugfs_core_emc_rate);
		debugfs_node_emc_rate = debugfs_create_file
			("emc_rate", S_IRUSR, debugfs_dir, NULL,
			 &fops_debugfs_emc_rate);
		debugfs_node_floor = debugfs_create_file
			("debug_client_floor", S_IRWXU, debugfs_dir, NULL,
			 &fops_debugfs_floor);
		debugfs_node_cap = debugfs_create_file
			("debug_client_cap", S_IRWXU, debugfs_dir, NULL,
			 &fops_debugfs_cap);
		debugfs_node_iso_cap = debugfs_create_file
			("debug_client_iso_cap", S_IRWXU, debugfs_dir, NULL,
			 &fops_debugfs_iso_cap);
		debugfs_node_bw = debugfs_create_file
			("debug_client_bw", S_IRWXU, debugfs_dir, NULL,
			 &fops_debugfs_bw);
		debugfs_node_iso_bw = debugfs_create_file
			("debug_client_iso_bw", S_IRWXU, debugfs_dir, NULL,
			 &fops_debugfs_iso_bw);
		debugfs_node_clients_info = debugfs_create_file
			("bwmgr_clients_info", S_IRUGO, debugfs_dir, NULL,
			 &fops_bwmgr_clients_info);
		debugfs_node_dram_channels = debugfs_create_file(
			"num_dram_channels", S_IRUSR, debugfs_dir, NULL,
			 &fops_debugfs_dram_channels);
	} else
		pr_err("bwmgr: error creating bwmgr debugfs dir.\n");

	if (!bwmgr_lock()) {
		pr_err("bwmgr: %s failed\n", __func__);
		return;
	}
	debug_info.non_iso_cap = bwmgr.emc_max_rate;
	debug_info.iso_cap = bwmgr.emc_max_rate;
	if (!bwmgr_unlock()) {
		pr_err("bwmgr: %s failed\n", __func__);
		return;
	}
}

#else
static void bwmgr_debugfs_init(void) {};
#endif /* CONFIG_DEBUG_FS */