Merge "msm: cvp: Add operational fps based b/w vote" (2d883dd4) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/media/platform/msm/cvp/msm_cvp.c

+15 −41

Original line number	Original line	Diff line number	Diff line
	@@ -40,35 +40,6 @@ static enum hal_buffer get_hal_buftype(const char *str, unsigned int type)
	return buftype;		return buftype;
	}		}

	static int msm_cvp_scale_clocks_and_bus(struct msm_cvp_inst *inst)
	{
	int rc = 0;

	if (!inst \|\| !inst->core) {
	dprintk(CVP_ERR, "%s: invalid params\n", __func__);
	return -EINVAL;
	}

	rc = msm_cvp_set_clocks(inst->core);
	if (rc) {
	dprintk(CVP_ERR,
	"%s: failed set_clocks for inst %pK (%#x)\n",
	__func__, inst, hash32_ptr(inst->session));
	goto exit;
	}

	rc = msm_cvp_comm_vote_bus(inst->core);
	if (rc) {
	dprintk(CVP_ERR,
	"%s: failed vote_bus for inst %pK (%#x)\n",
	__func__, inst, hash32_ptr(inst->session));
	goto exit;
	}

	exit:
	return rc;
	}

	static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,		static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
	struct cvp_kmd_session_info *session)		struct cvp_kmd_session_info *session)
	{		{
	@@ -1245,7 +1216,7 @@ static int adjust_bw_freqs(void)
	unsigned int cvp_min_rate, cvp_max_rate, max_bw;		unsigned int cvp_min_rate, cvp_max_rate, max_bw;
	unsigned long core_sum = 0, ctlr_sum = 0, fw_sum = 0;		unsigned long core_sum = 0, ctlr_sum = 0, fw_sum = 0;
	unsigned long op_core_max = 0, op_ctlr_max = 0, op_fw_max = 0;		unsigned long op_core_max = 0, op_ctlr_max = 0, op_fw_max = 0;
	unsigned long bw_sum = 0;		unsigned long bw_sum = 0, op_bw_max = 0;
	int i, rc = 0;		int i, rc = 0;

	core = list_first_entry(&cvp_driver->cores, struct msm_cvp_core, list);		core = list_first_entry(&cvp_driver->cores, struct msm_cvp_core, list);
	@@ -1261,6 +1232,9 @@ static int adjust_bw_freqs(void)
	max_bw = bus->range[1];		max_bw = bus->range[1];

	list_for_each_entry(inst, &core->instances, list) {		list_for_each_entry(inst, &core->instances, list) {
			if (inst->state == MSM_CVP_CORE_INVALID \|\|
			inst->state == MSM_CVP_CORE_UNINIT)
			continue;
	core_sum += inst->power.clock_cycles_a;		core_sum += inst->power.clock_cycles_a;
	ctlr_sum += inst->power.clock_cycles_b;		ctlr_sum += inst->power.clock_cycles_b;
	fw_sum += inst->power.reserved[0];		fw_sum += inst->power.reserved[0];
	@@ -1271,6 +1245,8 @@ static int adjust_bw_freqs(void)
	op_fw_max = (op_fw_max >= inst->power.reserved[3]) ?		op_fw_max = (op_fw_max >= inst->power.reserved[3]) ?
	op_fw_max : inst->power.reserved[3];		op_fw_max : inst->power.reserved[3];
	bw_sum += inst->power.ddr_bw;		bw_sum += inst->power.ddr_bw;
			op_bw_max = (op_bw_max >= inst->power.reserved[4]) ?
			op_bw_max : inst->power.reserved[4];
	}		}

	core_sum = max_3(core_sum, ctlr_sum, fw_sum);		core_sum = max_3(core_sum, ctlr_sum, fw_sum);
	@@ -1278,6 +1254,7 @@ static int adjust_bw_freqs(void)
	op_core_max = (op_core_max > tbl[tbl_size - 1].clock_rate) ?		op_core_max = (op_core_max > tbl[tbl_size - 1].clock_rate) ?
	tbl[tbl_size - 1].clock_rate : op_core_max;		tbl[tbl_size - 1].clock_rate : op_core_max;
	core_sum = (core_sum >= op_core_max) ? core_sum : op_core_max;		core_sum = (core_sum >= op_core_max) ? core_sum : op_core_max;
			bw_sum = (bw_sum >= op_bw_max) ? bw_sum : op_bw_max;

	if (core_sum < tbl[0].clock_rate) {		if (core_sum < tbl[0].clock_rate) {
	core_sum = tbl[0].clock_rate;		core_sum = tbl[0].clock_rate;
	@@ -1287,7 +1264,7 @@ static int adjust_bw_freqs(void)
	break;		break;

	if (i == tbl_size) {		if (i == tbl_size) {
	dprintk(CVP_WARN, "%s out of range %llx\n",		dprintk(CVP_WARN, "%s clk vote out of range %lld\n",
	__func__, core_sum);		__func__, core_sum);
	return -ENOTSUPP;		return -ENOTSUPP;
	}		}
	@@ -1297,17 +1274,21 @@ static int adjust_bw_freqs(void)
	if (bw_sum > max_bw)		if (bw_sum > max_bw)
	bw_sum = max_bw;		bw_sum = max_bw;

	dprintk(CVP_DBG, "%s %d %lld %lld\n", __func__, core_sum, bw_sum, 0);		dprintk(CVP_DBG, "%s %lld %lld %lld\n", __func__,
			core_sum, bw_sum, op_bw_max);
	if (!cl->has_scaling) {		if (!cl->has_scaling) {
	dprintk(CVP_ERR, "Cannot scale CVP clock\n");		dprintk(CVP_ERR, "Cannot scale CVP clock\n");
	return -EINVAL;		return -EINVAL;
	}		}

	rc = clk_set_rate(cl->clk, core_sum);		ctlr_sum = core->curr_freq;
			core->curr_freq = core_sum;
			rc = msm_cvp_set_clocks(core);
	if (rc) {		if (rc) {
	dprintk(CVP_ERR,		dprintk(CVP_ERR,
	"Failed to set clock rate %u %s: %d %s\n",		"Failed to set clock rate %u %s: %d %s\n",
	core_sum, cl->name, rc, __func__);		core_sum, cl->name, rc, __func__);
			core->curr_freq = ctlr_sum;
	return rc;		return rc;
	}		}
	hdev->clk_freq = core_sum;		hdev->clk_freq = core_sum;
	@@ -1361,6 +1342,7 @@ static int msm_cvp_request_power(struct msm_cvp_inst *inst,
	inst->power.reserved[0] = div_by_1dot5(inst->power.reserved[0]);		inst->power.reserved[0] = div_by_1dot5(inst->power.reserved[0]);
	inst->power.reserved[2] = div_by_1dot5(inst->power.reserved[2]);		inst->power.reserved[2] = div_by_1dot5(inst->power.reserved[2]);
	inst->power.reserved[3] = div_by_1dot5(inst->power.reserved[3]);		inst->power.reserved[3] = div_by_1dot5(inst->power.reserved[3]);
			inst->power.reserved[4] = div_by_1dot5(inst->power.reserved[4]);

	/* Convert bps to KBps */		/* Convert bps to KBps */
	inst->power.ddr_bw = inst->power.ddr_bw >> 10;		inst->power.ddr_bw = inst->power.ddr_bw >> 10;
	@@ -1798,14 +1780,6 @@ int msm_cvp_session_deinit(struct msm_cvp_inst *inst)
	if (rc)		if (rc)
	dprintk(CVP_ERR, "%s: close failed\n", __func__);		dprintk(CVP_ERR, "%s: close failed\n", __func__);

	inst->clk_data.min_freq = 0;
	inst->clk_data.ddr_bw = 0;
	inst->clk_data.sys_cache_bw = 0;
	rc = msm_cvp_scale_clocks_and_bus(inst);
	if (rc)
	dprintk(CVP_ERR, "%s: failed to scale_clocks_and_bus\n",
	__func__);

	mutex_lock(&inst->cvpcpubufs.lock);		mutex_lock(&inst->cvpcpubufs.lock);
	list_for_each_entry_safe(cbuf, dummy, &inst->cvpcpubufs.list,		list_for_each_entry_safe(cbuf, dummy, &inst->cvpcpubufs.list,
	list) {		list) {

drivers/media/platform/msm/cvp/msm_cvp_clocks.c

+5 −76

Original line number	Original line	Diff line number	Diff line
	@@ -232,87 +232,16 @@ static unsigned long msm_cvp_calc_freq(struct msm_cvp_inst *inst,
	int msm_cvp_set_clocks(struct msm_cvp_core *core)		int msm_cvp_set_clocks(struct msm_cvp_core *core)
	{		{
	struct cvp_hfi_device *hdev;		struct cvp_hfi_device *hdev;
	unsigned long freq_core_1 = 0, freq_core_2 = 0, rate = 0;		int rc;
	unsigned long freq_core_max = 0;
	struct msm_cvp_inst *temp = NULL;
	int rc = 0, i = 0;
	struct allowed_clock_rates_table *allowed_clks_tbl = NULL;
	bool increment, decrement;

	hdev = core->device;		if (!core \|\| !core->device) {
	allowed_clks_tbl = core->resources.allowed_clks_tbl;		dprintk(CVP_ERR, "%s Invalid args: %pK\n", __func__, core);
	if (!allowed_clks_tbl) {
	dprintk(CVP_ERR,
	"%s Invalid parameters\n", __func__);
	return -EINVAL;		return -EINVAL;
	}		}

	mutex_lock(&core->lock);		hdev = core->device;
	increment = false;
	decrement = true;
	list_for_each_entry(temp, &core->instances, list) {

	if (temp->clk_data.core_id == CVP_CORE_ID_1)
	freq_core_1 += temp->clk_data.min_freq;
	else if (temp->clk_data.core_id == CVP_CORE_ID_2)
	freq_core_2 += temp->clk_data.min_freq;
	else if (temp->clk_data.core_id == CVP_CORE_ID_3) {
	freq_core_1 += temp->clk_data.min_freq;
	freq_core_2 += temp->clk_data.min_freq;
	}

	freq_core_max = max_t(unsigned long, freq_core_1, freq_core_2);

	if (msm_cvp_clock_voting) {
	dprintk(CVP_PROF,
	"msm_cvp_clock_voting %d\n",
	msm_cvp_clock_voting);
	freq_core_max = msm_cvp_clock_voting;
	break;
	}

	if (temp->clk_data.turbo_mode) {
	dprintk(CVP_PROF,
	"Found an instance with Turbo request\n");
	freq_core_max = msm_cvp_max_freq(core);
	break;
	}
	/* increment even if one session requested for it */
	if (temp->clk_data.dcvs_flags & MSM_CVP_DCVS_INCR)
	increment = true;
	/* decrement only if all sessions requested for it */
	if (!(temp->clk_data.dcvs_flags & MSM_CVP_DCVS_DECR))
	decrement = false;
	}

	/*
	* keep checking from lowest to highest rate until
	* table rate >= requested rate
	*/
	for (i = 0; i < core->resources.allowed_clks_tbl_size; i++) {
	rate = allowed_clks_tbl[i].clock_rate;
	if (rate >= freq_core_max)
	break;
	}
	if (increment) {
	if (i > 0)
	rate = allowed_clks_tbl[i-1].clock_rate;
	} else if (decrement) {
	if (i < (core->resources.allowed_clks_tbl_size - 1))
	rate = allowed_clks_tbl[i+1].clock_rate;
	}

	core->min_freq = freq_core_max;
	core->curr_freq = rate;
	mutex_unlock(&core->lock);

	dprintk(CVP_PROF,
	"%s: clock rate %lu requested %lu increment %d decrement %d\n",
	__func__, core->curr_freq, core->min_freq,
	increment, decrement);
	rc = call_hfi_op(hdev, scale_clocks,		rc = call_hfi_op(hdev, scale_clocks,
	hdev->hfi_device_data, core->curr_freq);		hdev->hfi_device_data, core->curr_freq);

	return rc;		return rc;
	}		}