Merge "msm: msm_bus: Add ACV voting" into msm-4.9 (e2918217) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/soc/qcom/msm_bus/msm_bus_arb_rpmh.c

+74 −27

Original line number	Diff line number	Diff line
		@@ -26,6 +26,8 @@

		#define MSM_BUS_MAS_ALC 144
		#define MSM_BUS_RSC_APPS 8000
		#define MSM_BUS_RSC_DISP 8001
		#define BCM_TCS_CMD_ACV_APPS 0x8

		struct bus_search_type {
		struct list_head link;
		@@ -127,16 +129,14 @@ static void bcm_add_bus_req(struct device *dev)
		goto exit_bcm_add_bus_req;
		}

		if (cur_dev->node_info->bcm_req_idx != -1)
		goto exit_bcm_add_bus_req;

		if (!cur_dev->node_info->num_bcm_devs)
		goto exit_bcm_add_bus_req;

		for (i = 0; i < cur_dev->node_info->num_bcm_devs; i++) {
		if (cur_dev->node_info->bcm_req_idx[i] != -1)
		continue;
		bcm_dev = to_msm_bus_node(cur_dev->node_info->bcm_devs[i]);
		max_num_lnodes = bcm_dev->bcmdev->num_bus_devs;

		if (!bcm_dev->num_lnodes) {
		bcm_dev->lnode_list = devm_kzalloc(dev,
		sizeof(struct link_node) * max_num_lnodes,
		@@ -183,7 +183,7 @@ static void bcm_add_bus_req(struct device *dev)

		lnode->in_use = 1;
		lnode->bus_dev_id = cur_dev->node_info->id;
		cur_dev->node_info->bcm_req_idx = lnode_idx;
		cur_dev->node_info->bcm_req_idx[i] = lnode_idx;
		memset(lnode->lnode_ib, 0, sizeof(uint64_t) * NUM_CTX);
		memset(lnode->lnode_ab, 0, sizeof(uint64_t) * NUM_CTX);
		}
		@@ -483,11 +483,35 @@ static int getpath(struct device src_dev, int dest, const char cl_name)
		return first_hop;
		}

		static void bcm_update_acv_req(struct msm_bus_node_device_type *cur_rsc,
		uint64_t max_ab, uint64_t max_ib,
		uint64_t vec_a, uint64_t vec_b,
		uint32_t *acv, int ctx)
		{
		uint32_t acv_bmsk = 0;
		/*
		* Base ACV voting on current RSC until mapping is set up in commanddb
		* that allows us to vote ACV based on master.
		*/

		if (cur_rsc->node_info->id == MSM_BUS_RSC_APPS)
		acv_bmsk = BCM_TCS_CMD_ACV_APPS;

		if (max_ab == 0 && max_ib == 0)
		acv = acv & ~acv_bmsk;
		else
		acv = acv \| acv_bmsk;
		*vec_a = 0;
		vec_b = acv;
		}

		static void bcm_update_bus_req(struct device *dev, int ctx)
		{
		struct msm_bus_node_device_type *cur_dev = NULL;
		struct msm_bus_node_device_type *bcm_dev = NULL;
		int i;
		struct msm_bus_node_device_type *cur_rsc = NULL;

		int i, j;
		uint64_t max_ib = 0;
		uint64_t max_ab = 0;
		int lnode_idx = 0;
		@@ -507,7 +531,7 @@ static void bcm_update_bus_req(struct device *dev, int ctx)
		if (!bcm_dev)
		goto exit_bcm_update_bus_req;

		lnode_idx = cur_dev->node_info->bcm_req_idx;
		lnode_idx = cur_dev->node_info->bcm_req_idx[i];
		bcm_dev->lnode_list[lnode_idx].lnode_ib[ctx] =
		msm_bus_div64(cur_dev->node_bw[ctx].max_ib *
		(uint64_t)bcm_dev->bcmdev->width,
		@@ -519,19 +543,19 @@ static void bcm_update_bus_req(struct device *dev, int ctx)
		cur_dev->node_info->agg_params.buswidth *
		cur_dev->node_info->agg_params.num_aggports);

		for (i = 0; i < bcm_dev->num_lnodes; i++) {
		for (j = 0; j < bcm_dev->num_lnodes; j++) {
		if (ctx == ACTIVE_CTX) {
		max_ib = max(max_ib,
		max(bcm_dev->lnode_list[i].lnode_ib[ACTIVE_CTX],
		bcm_dev->lnode_list[i].lnode_ib[DUAL_CTX]));
		max(bcm_dev->lnode_list[j].lnode_ib[ACTIVE_CTX],
		bcm_dev->lnode_list[j].lnode_ib[DUAL_CTX]));
		max_ab = max(max_ab,
		bcm_dev->lnode_list[i].lnode_ab[ACTIVE_CTX] +
		bcm_dev->lnode_list[i].lnode_ab[DUAL_CTX]);
		bcm_dev->lnode_list[j].lnode_ab[ACTIVE_CTX] +
		bcm_dev->lnode_list[j].lnode_ab[DUAL_CTX]);
		} else {
		max_ib = max(max_ib,
		bcm_dev->lnode_list[i].lnode_ib[ctx]);
		bcm_dev->lnode_list[j].lnode_ib[ctx]);
		max_ab = max(max_ab,
		bcm_dev->lnode_list[i].lnode_ab[ctx]);
		bcm_dev->lnode_list[j].lnode_ab[ctx]);
		}
		}
		bcm_dev->node_bw[ctx].max_ab = max_ab;
		@@ -540,9 +564,19 @@ static void bcm_update_bus_req(struct device *dev, int ctx)
		max_ab = msm_bus_div64(max_ab, bcm_dev->bcmdev->unit_size);
		max_ib = msm_bus_div64(max_ib, bcm_dev->bcmdev->unit_size);

		if (bcm_dev->node_info->id == MSM_BUS_BCM_ACV) {
		cur_rsc = to_msm_bus_node(bcm_dev->node_info->
		rsc_devs[0]);
		bcm_update_acv_req(cur_rsc, max_ab, max_ib,
		&bcm_dev->node_vec[ctx].vec_a,
		&bcm_dev->node_vec[ctx].vec_b,
		&cur_rsc->rscdev->acv[ctx], ctx);

		} else {
		bcm_dev->node_vec[ctx].vec_a = max_ab;
		bcm_dev->node_vec[ctx].vec_b = max_ib;
		}
		}
		exit_bcm_update_bus_req:
		return;
		}
		@@ -551,7 +585,8 @@ static void bcm_query_bus_req(struct device *dev, int ctx)
		{
		struct msm_bus_node_device_type *cur_dev = NULL;
		struct msm_bus_node_device_type *bcm_dev = NULL;
		int i;
		struct msm_bus_node_device_type *cur_rsc = NULL;
		int i, j;
		uint64_t max_query_ib = 0;
		uint64_t max_query_ab = 0;
		int lnode_idx = 0;
		@@ -571,7 +606,7 @@ static void bcm_query_bus_req(struct device *dev, int ctx)
		if (!bcm_dev)
		goto exit_bcm_query_bus_req;

		lnode_idx = cur_dev->node_info->bcm_req_idx;
		lnode_idx = cur_dev->node_info->bcm_req_idx[i];
		bcm_dev->lnode_list[lnode_idx].lnode_query_ib[ctx] =
		msm_bus_div64(cur_dev->node_bw[ctx].max_query_ib *
		(uint64_t)bcm_dev->bcmdev->width,
		@@ -583,25 +618,25 @@ static void bcm_query_bus_req(struct device *dev, int ctx)
		cur_dev->node_info->agg_params.num_aggports *
		cur_dev->node_info->agg_params.buswidth);

		for (i = 0; i < bcm_dev->num_lnodes; i++) {
		for (j = 0; j < bcm_dev->num_lnodes; j++) {
		if (ctx == ACTIVE_CTX) {
		max_query_ib = max(max_query_ib,
		max(bcm_dev->lnode_list[i].
		max(bcm_dev->lnode_list[j].
		lnode_query_ib[ACTIVE_CTX],
		bcm_dev->lnode_list[i].
		bcm_dev->lnode_list[j].
		lnode_query_ib[DUAL_CTX]));

		max_query_ab = max(max_query_ab,
		bcm_dev->lnode_list[i].
		bcm_dev->lnode_list[j].
		lnode_query_ab[ACTIVE_CTX] +
		bcm_dev->lnode_list[i].
		bcm_dev->lnode_list[j].
		lnode_query_ab[DUAL_CTX]);
		} else {
		max_query_ib = max(max_query_ib,
		bcm_dev->lnode_list[i].
		bcm_dev->lnode_list[j].
		lnode_query_ib[ctx]);
		max_query_ab = max(max_query_ab,
		bcm_dev->lnode_list[i].
		bcm_dev->lnode_list[j].
		lnode_query_ab[ctx]);
		}
		}
		@@ -611,6 +646,18 @@ static void bcm_query_bus_req(struct device *dev, int ctx)
		max_query_ib = msm_bus_div64(max_query_ib,
		bcm_dev->bcmdev->unit_size);

		if (bcm_dev->node_info->id == MSM_BUS_BCM_ACV) {
		cur_rsc = to_msm_bus_node(bcm_dev->node_info->
		rsc_devs[0]);
		bcm_update_acv_req(cur_rsc, max_query_ab, max_query_ib,
		&bcm_dev->node_vec[ctx].query_vec_a,
		&bcm_dev->node_vec[ctx].query_vec_b,
		&cur_rsc->rscdev->query_acv[ctx], ctx);
		} else {
		bcm_dev->node_vec[ctx].query_vec_a = max_query_ab;
		bcm_dev->node_vec[ctx].query_vec_b = max_query_ib;
		}

		bcm_dev->node_bw[ctx].max_query_ab = max_query_ab;
		bcm_dev->node_bw[ctx].max_query_ib = max_query_ib;
		}

drivers/soc/qcom/msm_bus/msm_bus_fabric_rpmh.c

+48 −25

Original line number	Diff line number	Diff line
		@@ -418,8 +418,8 @@ static int tcs_cmd_query_list_gen(struct tcs_cmd *cmdlist_active)
		commit = true;
		}
		tcs_cmd_gen(cur_bcm, &cmdlist_active[k],
		cur_bcm->node_bw[ACTIVE_CTX].max_query_ib,
		cur_bcm->node_bw[ACTIVE_CTX].max_query_ab,
		cur_bcm->node_vec[ACTIVE_CTX].query_vec_a,
		cur_bcm->node_vec[ACTIVE_CTX].query_vec_b,
		commit);
		k++;
		}
		@@ -433,19 +433,22 @@ static int bcm_clist_add(struct msm_bus_node_device_type *cur_dev)
		{
		int ret = 0;
		int cur_vcd = 0;
		int i = 0;
		struct msm_bus_node_device_type *cur_bcm = NULL;

		if (!cur_dev->node_info->num_bcm_devs)
		goto exit_bcm_clist_add;

		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[0]);
		for (i = 0; i < cur_dev->node_info->num_bcm_devs; i++) {
		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[i]);
		cur_vcd = cur_bcm->bcmdev->clk_domain;

		if (!cur_bcm->node_info->num_rsc_devs)
		goto exit_bcm_clist_add;

		if (!cur_rsc)
		cur_rsc = to_msm_bus_node(cur_bcm->node_info->rsc_devs[0]);
		cur_rsc = to_msm_bus_node(cur_bcm->node_info->
		rsc_devs[0]);

		if (!cur_bcm->dirty) {
		list_add_tail(&cur_bcm->link,
		@@ -453,6 +456,7 @@ static int bcm_clist_add(struct msm_bus_node_device_type *cur_dev)
		cur_bcm->dirty = true;
		}
		cur_bcm->updated = false;
		}

		exit_bcm_clist_add:
		return ret;
		@@ -462,17 +466,20 @@ static int bcm_query_list_add(struct msm_bus_node_device_type *cur_dev)
		{
		int ret = 0;
		int cur_vcd = 0;
		int i = 0;
		struct msm_bus_node_device_type *cur_bcm = NULL;

		if (!cur_dev->node_info->num_bcm_devs)
		goto exit_bcm_query_list_add;

		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[0]);
		for (i = 0; i < cur_dev->node_info->num_bcm_devs; i++) {
		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[i]);
		cur_vcd = cur_bcm->bcmdev->clk_domain;

		if (!cur_bcm->query_dirty)
		list_add_tail(&cur_bcm->query_link,
		&bcm_query_list_inorder[cur_vcd]);
		}

		exit_bcm_query_list_add:
		return ret;
		@@ -481,12 +488,14 @@ static int bcm_query_list_add(struct msm_bus_node_device_type *cur_dev)
		static int bcm_clist_clean(struct msm_bus_node_device_type *cur_dev)
		{
		int ret = 0;
		int i = 0;
		struct msm_bus_node_device_type *cur_bcm = NULL;

		if (!cur_dev->node_info->num_bcm_devs)
		goto exit_bcm_clist_clean;

		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[0]);
		for (i = 0; i < cur_dev->node_info->num_bcm_devs; i++) {
		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[i]);

		if (cur_bcm->node_vec[DUAL_CTX].vec_a == 0 &&
		cur_bcm->node_vec[ACTIVE_CTX].vec_a == 0 &&
		@@ -496,6 +505,7 @@ static int bcm_clist_clean(struct msm_bus_node_device_type *cur_dev)
		cur_bcm->dirty = false;
		list_del_init(&cur_bcm->link);
		}
		}

		exit_bcm_clist_clean:
		return ret;
		@@ -504,15 +514,18 @@ static int bcm_clist_clean(struct msm_bus_node_device_type *cur_dev)
		static int bcm_query_list_clean(struct msm_bus_node_device_type *cur_dev)
		{
		int ret = 0;
		int i = 0;
		struct msm_bus_node_device_type *cur_bcm = NULL;

		if (!cur_dev->node_info->num_bcm_devs)
		goto exit_bcm_clist_add;

		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[0]);
		for (i = 0; i < cur_dev->node_info->num_bcm_devs; i++) {
		cur_bcm = to_msm_bus_node(cur_dev->node_info->bcm_devs[i]);

		cur_bcm->query_dirty = false;
		list_del_init(&cur_bcm->query_link);
		}

		exit_bcm_clist_add:
		return ret;
		@@ -1081,7 +1094,7 @@ static int msm_bus_init_clk(struct device *bus_dev,
		static int msm_bus_copy_node_info(struct msm_bus_node_device_type *pdata,
		struct device *bus_dev)
		{
		int ret = 0;
		int ret = 0, i = 0;
		struct msm_bus_node_info_type *node_info = NULL;
		struct msm_bus_node_info_type *pdata_node_info = NULL;
		struct msm_bus_node_device_type *bus_node = NULL;
		@@ -1100,7 +1113,17 @@ static int msm_bus_copy_node_info(struct msm_bus_node_device_type *pdata,

		node_info->name = pdata_node_info->name;
		node_info->id = pdata_node_info->id;
		node_info->bcm_req_idx = -1;
		node_info->bcm_req_idx = devm_kzalloc(bus_dev,
		sizeof(int) * pdata_node_info->num_bcm_devs,
		GFP_KERNEL);
		if (!node_info->bcm_req_idx) {
		ret = -ENOMEM;
		goto exit_copy_node_info;
		}

		for (i = 0; i < pdata_node_info->num_bcm_devs; i++)
		node_info->bcm_req_idx[i] = -1;

		node_info->bus_device_id = pdata_node_info->bus_device_id;
		node_info->mas_rpm_id = pdata_node_info->mas_rpm_id;
		node_info->slv_rpm_id = pdata_node_info->slv_rpm_id;

drivers/soc/qcom/msm_bus/msm_bus_rpmh.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -71,12 +71,16 @@ struct nodebw {
		struct nodevector {
		uint64_t vec_a;
		uint64_t vec_b;
		uint64_t query_vec_a;
		uint64_t query_vec_b;
		};

		struct msm_bus_rsc_device_type {
		struct rpmh_client *mbox;
		struct list_head bcm_clist[VCD_MAX_CNT];
		int req_state;
		uint32_t acv[NUM_CTX];
		uint32_t query_acv[NUM_CTX];
		};

		struct msm_bus_bcm_device_type {
		@@ -157,7 +161,7 @@ struct msm_bus_node_info_type {
		struct device **black_connections;
		struct device **bcm_devs;
		struct device **rsc_devs;
		int bcm_req_idx;
		int *bcm_req_idx;
		unsigned int bus_device_id;
		struct device *bus_device;
		struct rule_update_path_info rule;