icc: qcom: Refactor icc rpmh support

config INTERCONNECT_QCOM_LAHAINA

	tristate "LAHAINA interconnect driver"

	depends on INTERCONNECT_QCOM

	depends on QCOM_RPMH && QCOM_COMMAND_DB && OF

	help

	  This is a driver for the Qualcomm Technologies, Inc. Network-on-Chip

	  on lahaina-based platforms.

config INTERCONNECT_QCOM_SMD_RPM

	tristate

config INTERCONNECT_QCOM_BCM_VOTER

	tristate

config INTERCONNECT_QCOM_RPMH

	tristate

qnoc-sdm845-objs			:= sdm845.o

qnoc-lahaina-objs			:= lahaina.o

icc-smd-rpm-objs			:= smd-rpm.o

icc-bcm-voter-objs			:= bcm-voter.o

icc-rpmh-obj				:= icc-rpmh.o

obj-$(CONFIG_INTERCONNECT_QCOM_QCS404) += qnoc-qcs404.o

obj-$(CONFIG_INTERCONNECT_QCOM_SDM845) += qnoc-sdm845.o

obj-$(CONFIG_INTERCONNECT_QCOM_LAHAINA) += qnoc-lahaina.o

obj-$(CONFIG_INTERCONNECT_QCOM_SMD_RPM) += icc-smd-rpm.o

obj-$(CONFIG_INTERCONNECT_QCOM_BCM_VOTER) += icc-bcm-voter.o

obj-$(CONFIG_INTERCONNECT_QCOM_RPMH) += icc-rpmh.o

// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2019, The Linux Foundation. All rights reserved.

 *

 */

#include <linux/interconnect-provider.h>

#include <linux/list_sort.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/of_platform.h>

#include <linux/platform_device.h>

#include <soc/qcom/rpmh.h>

#include <soc/qcom/tcs.h>

#include "bcm-voter.h"

#include "icc-rpmh.h"

static LIST_HEAD(bcm_voters);

/**

 * struct bcm_voter - Bus Clock Manager voter

 * @dev: reference to the device that communicates with the BCM

 * @np: reference to the device node to match bcm voters

 * @lock: mutex to protect commit and wake/sleep lists in the voter

 * @commit_list: list containing bcms to be committed to hardware

 * @ws_list: list containing bcms that have different wake/sleep votes

 * @voter_node: list of bcm voters

 */

struct bcm_voter {

	struct device *dev;

	struct device_node *np;

	struct mutex lock;

	struct list_head commit_list;

	struct list_head ws_list;

	struct list_head voter_node;

};

static int cmp_vcd(void *priv, struct list_head *a, struct list_head *b)

{

	const struct qcom_icc_bcm *bcm_a =

			list_entry(a, struct qcom_icc_bcm, list);

	const struct qcom_icc_bcm *bcm_b =

			list_entry(b, struct qcom_icc_bcm, list);

	if (bcm_a->aux_data.vcd < bcm_b->aux_data.vcd)

		return -1;

	else if (bcm_a->aux_data.vcd == bcm_b->aux_data.vcd)

		return 0;

	else

		return 1;

}

static void bcm_aggregate(struct qcom_icc_bcm *bcm)

{

	size_t i, bucket;

	u64 agg_avg[QCOM_ICC_NUM_BUCKETS] = {0};

	u64 agg_peak[QCOM_ICC_NUM_BUCKETS] = {0};

	u64 temp;

	for (bucket = 0; bucket < QCOM_ICC_NUM_BUCKETS; bucket++) {

		for (i = 0; i < bcm->num_nodes; i++) {

			temp = bcm->nodes[i]->sum_avg[bucket] *

				bcm->aux_data.width;

			do_div(temp, bcm->nodes[i]->buswidth *

				bcm->nodes[i]->channels);

			agg_avg[bucket] = max(agg_avg[bucket], temp);

			temp = bcm->nodes[i]->max_peak[bucket] *

				bcm->aux_data.width;

			do_div(temp, bcm->nodes[i]->buswidth);

			agg_peak[bucket] = max(agg_peak[bucket], temp);

		}

		temp = agg_avg[bucket] * 1000ULL;

		do_div(temp, bcm->aux_data.unit);

		bcm->vote_x[bucket] = temp;

		temp = agg_peak[bucket] * 1000ULL;

		do_div(temp, bcm->aux_data.unit);

		bcm->vote_y[bucket] = temp;

	}

	if (bcm->keepalive && bcm->vote_x[QCOM_ICC_BUCKET_AMC] == 0 &&

	    bcm->vote_y[QCOM_ICC_BUCKET_AMC] == 0) {

		bcm->vote_x[QCOM_ICC_BUCKET_AMC] = 1;

		bcm->vote_x[QCOM_ICC_BUCKET_WAKE] = 1;

		bcm->vote_y[QCOM_ICC_BUCKET_AMC] = 1;

		bcm->vote_y[QCOM_ICC_BUCKET_WAKE] = 1;

	}

}

static inline void tcs_cmd_gen(struct tcs_cmd *cmd, u64 vote_x, u64 vote_y,

			u32 addr, bool commit)

{

	bool valid = true;

	if (!cmd)

		return;

	if (vote_x == 0 && vote_y == 0)

		valid = false;

	if (vote_x > BCM_TCS_CMD_VOTE_MASK)

		vote_x = BCM_TCS_CMD_VOTE_MASK;

	if (vote_y > BCM_TCS_CMD_VOTE_MASK)

		vote_y = BCM_TCS_CMD_VOTE_MASK;

	cmd->addr = addr;

	cmd->data = BCM_TCS_CMD(commit, valid, vote_x, vote_y);

	/*

	 * Set the wait for completion flag on command that need to be completed

	 * before the next command.

	 */

	if (commit)

		cmd->wait = true;

}

static void tcs_list_gen(struct list_head *bcm_list, int bucket,

			 struct tcs_cmd tcs_list[MAX_VCD],

			 int n[MAX_VCD])

{

	struct qcom_icc_bcm *bcm;

	bool commit;

	size_t idx = 0, batch = 0, cur_vcd_size = 0;

	memset(n, 0, sizeof(int) * MAX_VCD);

	list_for_each_entry(bcm, bcm_list, list) {

		commit = false;

		cur_vcd_size++;

		if ((list_is_last(&bcm->list, bcm_list)) ||

		    bcm->aux_data.vcd !=

			list_next_entry(bcm, list)->aux_data.vcd) {

			commit = true;

			cur_vcd_size = 0;

		}

		tcs_cmd_gen(&tcs_list[idx], bcm->vote_x[bucket],

			    bcm->vote_y[bucket], bcm->addr, commit);

		idx++;

		n[batch]++;

		/*

		 * Batch the BCMs in such a way that we do not split them in

		 * multiple payloads when they are under the same VCD. This is

		 * to ensure that every BCM is committed since we only set the

		 * commit bit on the last BCM request of every VCD.

		 */

		if (n[batch] >= MAX_RPMH_PAYLOAD) {

			if (!commit) {

				n[batch] = cur_vcd_size;

				n[batch + 1] = cur_vcd_size;

			}

			batch++;

		}

	}

}

/**

 * of_bcm_voter_get - gets a bcm voter handle from DT node

 * @dev: device pointer for the consumer device

 * @name: name for the bcm voter device

 *

 * This function will match a device_node pointer for the phandle

 * specified in the device DT and return a bcm_voter handle on success.

 *

 * Returns bcm_voter pointer or ERR_PTR() on error. EPROBE_DEFER is returned

 * when matching bcm voter is yet to be found.

 */

struct bcm_voter *of_bcm_voter_get(struct device *dev, const char *name)

{

	struct bcm_voter *voter = ERR_PTR(-EPROBE_DEFER);

	struct bcm_voter *temp;

	struct device_node *np, *node;

	int idx = 0;

	if (!dev || !dev->of_node)

		return ERR_PTR(-ENODEV);

	np = dev->of_node;

	if (name) {

		idx = of_property_match_string(np, "qcom,bcm-voter-names",

						name);

		if (idx < 0)

			return ERR_PTR(idx);

	}

	node = of_parse_phandle(np, "qcom,bcm-voters", idx);

	list_for_each_entry(temp, &bcm_voters, voter_node) {

		if (temp->np == node) {

			voter = temp;

			break;

		}

	}

	return voter;

}

EXPORT_SYMBOL(of_bcm_voter_get);

/**

 * qcom_icc_bcm_voter_add - queues up the bcm nodes that require updates

 * @voter: voter that the bcms are being added to

 * @bcm: bcm to add to the commit and wake sleep list

 */

void qcom_icc_bcm_voter_add(struct bcm_voter *voter, struct qcom_icc_bcm *bcm)

{

	if (!voter)

		return;

	mutex_lock(&voter->lock);

	list_add_tail(&bcm->list, &voter->commit_list);

	if (list_empty(&bcm->ws_list))

		list_add_tail(&bcm->ws_list, &voter->ws_list);

	mutex_unlock(&voter->lock);

}

EXPORT_SYMBOL(qcom_icc_bcm_voter_add);

/**

 * qcom_icc_bcm_voter_commit - generates and commits tcs cmds based on bcms

 * @voter: voter that needs flushing

 *

 * This function generates a set of AMC commands and flushes to the BCM device

 * associated with the voter. It conditionally generate WAKE and SLEEP commands

 * based on deltas between WAKE/SLEEP requirements. The ws_list persists

 * through multiple commit requests and bcm nodes are removed only when the

 * requirements for WAKE matches SLEEP.

 *

 * Returns 0 on success, or an appropriate error code otherwise.

 */

int qcom_icc_bcm_voter_commit(struct bcm_voter *voter)

{

	struct qcom_icc_bcm *bcm;

	struct qcom_icc_bcm *bcm_tmp;

	int commit_idx[MAX_VCD];

	struct tcs_cmd cmds[MAX_BCMS];

	int ret = 0;

	if (!voter)

		return 0;

	mutex_lock(&voter->lock);

	list_for_each_entry(bcm, &voter->commit_list, list)

		bcm_aggregate(bcm);

	/*

	 * Pre sort the BCMs based on VCD for ease of generating a command list

	 * that groups the BCMs with the same VCD together. VCDs are numbered

	 * with lowest being the most expensive time wise, ensuring that

	 * those commands are being sent the earliest in the queue. This needs

	 * to be sorted every commit since we can't guarantee the order in which

	 * the BCMs are added to the list.

	 */

	list_sort(NULL, &voter->commit_list, cmp_vcd);

	/*

	 * Construct the command list based on a pre ordered list of BCMs

	 * based on VCD.

	 */

	tcs_list_gen(&voter->commit_list, QCOM_ICC_BUCKET_AMC, cmds,

			commit_idx);

	if (!commit_idx[0])

		goto out;

	ret = rpmh_invalidate(voter->dev);

	if (ret) {

		pr_err("Error invalidating RPMH client (%d)\n", ret);

		goto out;

	}

	ret = rpmh_write_batch(voter->dev, RPMH_ACTIVE_ONLY_STATE,

			       cmds, commit_idx);

	if (ret) {

		pr_err("Error sending AMC RPMH requests (%d)\n", ret);

		goto out;

	}

	INIT_LIST_HEAD(&voter->commit_list);

	list_for_each_entry_safe(bcm, bcm_tmp, &voter->ws_list, ws_list) {

		/*

		 * Only generate WAKE and SLEEP commands if a resource's

		 * requirements change as the execution environment transitions

		 * between different power states.

		 */

		if (bcm->vote_x[QCOM_ICC_BUCKET_WAKE] !=

		    bcm->vote_x[QCOM_ICC_BUCKET_SLEEP] ||

		    bcm->vote_y[QCOM_ICC_BUCKET_WAKE] !=

		    bcm->vote_y[QCOM_ICC_BUCKET_SLEEP])

			list_add_tail(&bcm->list, &voter->commit_list);

		else

			list_del_init(&bcm->ws_list);

	}

	if (list_empty(&voter->commit_list))

		goto out;

	list_sort(NULL, &voter->commit_list, cmp_vcd);

	tcs_list_gen(&voter->commit_list, QCOM_ICC_BUCKET_WAKE, cmds,

			commit_idx);

	ret = rpmh_write_batch(voter->dev, RPMH_WAKE_ONLY_STATE, cmds,

				commit_idx);

	if (ret) {

		pr_err("Error sending WAKE RPMH requests (%d)\n", ret);

		goto out;

	}

	tcs_list_gen(&voter->commit_list, QCOM_ICC_BUCKET_SLEEP, cmds,

			commit_idx);

	ret = rpmh_write_batch(voter->dev, RPMH_SLEEP_STATE, cmds, commit_idx);

	if (ret) {

		pr_err("Error sending SLEEP RPMH requests (%d)\n", ret);

		goto out;

	}

out:

	INIT_LIST_HEAD(&voter->commit_list);

	mutex_unlock(&voter->lock);

	return ret;

}

EXPORT_SYMBOL(qcom_icc_bcm_voter_commit);

static int qcom_icc_bcm_voter_probe(struct platform_device *pdev)

{

	struct bcm_voter *voter;

	voter = devm_kzalloc(&pdev->dev, sizeof(*voter), GFP_KERNEL);

	if (!voter)

		return -ENOMEM;

	voter->dev = &pdev->dev;

	voter->np = pdev->dev.of_node;

	mutex_init(&voter->lock);

	INIT_LIST_HEAD(&voter->commit_list);

	INIT_LIST_HEAD(&voter->ws_list);

	list_add_tail(&voter->voter_node, &bcm_voters);

	return 0;

}

static const struct of_device_id bcm_voter_of_match[] = {

	{ .compatible = "qcom,sdm845-bcm-voter" },

	{ .compatible = "qcom,bcm-voter" },

	{ },

};

static struct platform_driver qcom_icc_bcm_voter_driver = {

	.probe = qcom_icc_bcm_voter_probe,

	.driver = {

		.name		= "sdm845_bcm_voter",

		.of_match_table = bcm_voter_of_match,

	},

};

module_platform_driver(qcom_icc_bcm_voter_driver);

MODULE_DESCRIPTION("QTI BCM Voter interconnect driver");

MODULE_LICENSE("GPL v2");

/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (c) 2019, The Linux Foundation. All rights reserved.

 *

 */

#ifndef __DRIVERS_INTERCONNECT_QCOM_ICC_BCM_VOTER_H__

#define __DRIVERS_INTERCONNECT_QCOM_ICC_BCM_VOTER_H__

#include <soc/qcom/cmd-db.h>

#include <soc/qcom/rpmh.h>

#include <soc/qcom/tcs.h>

#include "icc-rpmh.h"

#define DEFINE_QBCM(_name, _bcmname, _keepalive, _numnodes, ...)	\

		static struct qcom_icc_bcm _name = {			\

		.name = _bcmname,					\

		.keepalive = _keepalive,				\

		.num_nodes = _numnodes,					\

		.nodes = { __VA_ARGS__ },				\

	}

struct bcm_voter *of_bcm_voter_get(struct device *dev, const char *name);

void qcom_icc_bcm_voter_add(struct bcm_voter *voter, struct qcom_icc_bcm *bcm);

int qcom_icc_bcm_voter_commit(struct bcm_voter *voter);

#endif

// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2019, The Linux Foundation. All rights reserved.

 *

 */

#include <asm/div64.h>

#include <dt-bindings/interconnect/qcom,sdm845.h>

#include <linux/interconnect.h>

#include <linux/interconnect-provider.h>

#include "icc-rpmh.h"

#include "bcm-voter.h"

/**

 * qcom_icc_pre_aggregate - cleans up stale values from prior icc_set

 * @node: icc node to operate on

 */

void qcom_icc_pre_aggregate(struct icc_node *node)

{

	size_t i;

	struct qcom_icc_node *qn;

	qn = node->data;

	for (i = 0; i < QCOM_ICC_NUM_BUCKETS; i++) {

		qn->sum_avg[i] = 0;

		qn->max_peak[i] = 0;

	}

}

EXPORT_SYMBOL(qcom_icc_pre_aggregate);

/**

 * qcom_icc_aggregate - aggregate bw for buckets indicated by tag

 * @node: node to aggregate

 * @tag: tag to indicate which buckets to aggregate

 * @avg_bw: new bw to sum aggregate

 * @peak_bw: new bw to max aggregate

 * @agg_avg: existing aggregate avg bw val

 * @agg_peak: existing aggregate peak bw val

 */

int qcom_icc_aggregate(struct icc_node *node, u32 tag, u32 avg_bw,

		       u32 peak_bw, u32 *agg_avg, u32 *agg_peak)

{

	size_t i;

	struct qcom_icc_node *qn;

	struct qcom_icc_provider *qp;

	qn = node->data;

	qp = to_qcom_provider(node->provider);

	if (!tag)

		tag = QCOM_ICC_TAG_ALWAYS;

	for (i = 0; i < QCOM_ICC_NUM_BUCKETS; i++) {

		if (tag & BIT(i)) {

			qn->sum_avg[i] += avg_bw;

			qn->max_peak[i] = max_t(u32, qn->max_peak[i], peak_bw);

		}

	}

	*agg_avg += avg_bw;

	*agg_peak = max_t(u32, *agg_peak, peak_bw);

	for (i = 0; i < qn->num_bcms; i++)

		qcom_icc_bcm_voter_add(qp->voter, qn->bcms[i]);

	return 0;

}

EXPORT_SYMBOL(qcom_icc_aggregate);

/**

 * qcom_icc_set - set the constraints based on path

 * @src: source node for the path to set constraints on

 * @dst: destination node for the path to set constraints on

 *

 * Return: 0 on success, or an error code otherwise

 */

int qcom_icc_set(struct icc_node *src, struct icc_node *dst)

{

	struct qcom_icc_provider *qp;

	struct icc_node *node;

	if (!src)

		node = dst;

	else

		node = src;

	qp = to_qcom_provider(node->provider);

	qcom_icc_bcm_voter_commit(qp->voter);

	return 0;

}

EXPORT_SYMBOL(qcom_icc_set);

/**

 * qcom_icc_bcm_init - populates bcm aux data and connect qnodes

 * @bcm: bcm to be initialized

 * @dev: associated provider device

 *

 * Return: 0 on success, or an error code otherwise

 */

int qcom_icc_bcm_init(struct qcom_icc_bcm *bcm, struct device *dev)

{

	struct qcom_icc_node *qn;

	const struct bcm_db *data;

	size_t data_count;

	int i;

	bcm->addr = cmd_db_read_addr(bcm->name);

	if (!bcm->addr) {

		dev_err(dev, "%s could not find RPMh address\n",

			bcm->name);

		return -EINVAL;

	}

	data = cmd_db_read_aux_data(bcm->name, &data_count);

	if (IS_ERR(data)) {

		dev_err(dev, "%s command db read error (%ld)\n",

			bcm->name, PTR_ERR(data));

		return PTR_ERR(data);

	}

	if (!data_count) {

		dev_err(dev, "%s command db missing or partial aux data\n",

			bcm->name);

		return -EINVAL;

	}

	bcm->aux_data.unit = le32_to_cpu(data->unit);

	bcm->aux_data.width = le16_to_cpu(data->width);

	bcm->aux_data.vcd = data->vcd;

	bcm->aux_data.reserved = data->reserved;

	INIT_LIST_HEAD(&bcm->list);

	INIT_LIST_HEAD(&bcm->ws_list);

	/*

	 * Link Qnodes to their respective BCMs

	 */

	for (i = 0; i < bcm->num_nodes; i++) {

		qn = bcm->nodes[i];

		qn->bcms[qn->num_bcms] = bcm;

		qn->num_bcms++;

	}

	return 0;

}

EXPORT_SYMBOL(qcom_icc_bcm_init);