1// SPDX-License-Identifier: GPL-2.0-only
  2/* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved.
  3 */
  4
  5#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
  6
  7#include <linux/debugfs.h>
  8#include <linux/delay.h>
  9
 10#include "dpu_vbif.h"
 11#include "dpu_hw_vbif.h"
 12#include "dpu_trace.h"
 13
 14/**
 15 * _dpu_vbif_wait_for_xin_halt - wait for the xin to halt
 16 * @vbif:	Pointer to hardware vbif driver
 17 * @xin_id:	Client interface identifier
 18 * @return:	0 if success; error code otherwise
 19 */
 20static int _dpu_vbif_wait_for_xin_halt(struct dpu_hw_vbif *vbif, u32 xin_id)
 21{
 22	ktime_t timeout;
 23	bool status;
 24	int rc;
 25
 26	if (!vbif || !vbif->cap || !vbif->ops.get_halt_ctrl) {
 27		DPU_ERROR("invalid arguments vbif %d\n", vbif != 0);
 28		return -EINVAL;
 29	}
 30
 31	timeout = ktime_add_us(ktime_get(), vbif->cap->xin_halt_timeout);
 32	for (;;) {
 33		status = vbif->ops.get_halt_ctrl(vbif, xin_id);
 34		if (status)
 35			break;
 36		if (ktime_compare_safe(ktime_get(), timeout) > 0) {
 37			status = vbif->ops.get_halt_ctrl(vbif, xin_id);
 38			break;
 39		}
 40		usleep_range(501, 1000);
 41	}
 42
 43	if (!status) {
 44		rc = -ETIMEDOUT;
 45		DPU_ERROR("VBIF %d client %d not halting. TIMEDOUT.\n",
 46				vbif->idx - VBIF_0, xin_id);
 47	} else {
 48		rc = 0;
 49		DPU_DEBUG("VBIF %d client %d is halted\n",
 50				vbif->idx - VBIF_0, xin_id);
 51	}
 52
 53	return rc;
 54}
 55
 56/**
 57 * _dpu_vbif_apply_dynamic_ot_limit - determine OT based on usecase parameters
 58 * @vbif:	Pointer to hardware vbif driver
 59 * @ot_lim:	Pointer to OT limit to be modified
 60 * @params:	Pointer to usecase parameters
 61 */
 62static void _dpu_vbif_apply_dynamic_ot_limit(struct dpu_hw_vbif *vbif,
 63		u32 *ot_lim, struct dpu_vbif_set_ot_params *params)
 64{
 65	u64 pps;
 66	const struct dpu_vbif_dynamic_ot_tbl *tbl;
 67	u32 i;
 68
 69	if (!vbif || !(vbif->cap->features & BIT(DPU_VBIF_QOS_OTLIM)))
 70		return;
 71
 72	/* Dynamic OT setting done only for WFD */
 73	if (!params->is_wfd)
 74		return;
 75
 76	pps = params->frame_rate;
 77	pps *= params->width;
 78	pps *= params->height;
 79
 80	tbl = params->rd ? &vbif->cap->dynamic_ot_rd_tbl :
 81			&vbif->cap->dynamic_ot_wr_tbl;
 82
 83	for (i = 0; i < tbl->count; i++) {
 84		if (pps <= tbl->cfg[i].pps) {
 85			*ot_lim = tbl->cfg[i].ot_limit;
 86			break;
 87		}
 88	}
 89
 90	DPU_DEBUG("vbif:%d xin:%d w:%d h:%d fps:%d pps:%llu ot:%u\n",
 91			vbif->idx - VBIF_0, params->xin_id,
 92			params->width, params->height, params->frame_rate,
 93			pps, *ot_lim);
 94}
 95
 96/**
 97 * _dpu_vbif_get_ot_limit - get OT based on usecase & configuration parameters
 98 * @vbif:	Pointer to hardware vbif driver
 99 * @params:	Pointer to usecase parameters
100 * @return:	OT limit
101 */
102static u32 _dpu_vbif_get_ot_limit(struct dpu_hw_vbif *vbif,
103	struct dpu_vbif_set_ot_params *params)
104{
105	u32 ot_lim = 0;
106	u32 val;
107
108	if (!vbif || !vbif->cap) {
109		DPU_ERROR("invalid arguments vbif %d\n", vbif != 0);
110		return -EINVAL;
111	}
112
113	if (vbif->cap->default_ot_wr_limit && !params->rd)
114		ot_lim = vbif->cap->default_ot_wr_limit;
115	else if (vbif->cap->default_ot_rd_limit && params->rd)
116		ot_lim = vbif->cap->default_ot_rd_limit;
117
118	/*
119	 * If default ot is not set from dt/catalog,
120	 * then do not configure it.
121	 */
122	if (ot_lim == 0)
123		goto exit;
124
125	/* Modify the limits if the target and the use case requires it */
126	_dpu_vbif_apply_dynamic_ot_limit(vbif, &ot_lim, params);
127
128	if (vbif && vbif->ops.get_limit_conf) {
129		val = vbif->ops.get_limit_conf(vbif,
130				params->xin_id, params->rd);
131		if (val == ot_lim)
132			ot_lim = 0;
133	}
134
135exit:
136	DPU_DEBUG("vbif:%d xin:%d ot_lim:%d\n",
137			vbif->idx - VBIF_0, params->xin_id, ot_lim);
138	return ot_lim;
139}
140
141/**
142 * dpu_vbif_set_ot_limit - set OT based on usecase & configuration parameters
143 * @vbif:	Pointer to hardware vbif driver
144 * @params:	Pointer to usecase parameters
145 *
146 * Note this function would block waiting for bus halt.
147 */
148void dpu_vbif_set_ot_limit(struct dpu_kms *dpu_kms,
149		struct dpu_vbif_set_ot_params *params)
150{
151	struct dpu_hw_vbif *vbif = NULL;
152	struct dpu_hw_mdp *mdp;
153	bool forced_on = false;
154	u32 ot_lim;
155	int ret, i;
156
157	if (!dpu_kms) {
158		DPU_ERROR("invalid arguments\n");
159		return;
160	}
161	mdp = dpu_kms->hw_mdp;
162
163	for (i = 0; i < ARRAY_SIZE(dpu_kms->hw_vbif); i++) {
164		if (dpu_kms->hw_vbif[i] &&
165				dpu_kms->hw_vbif[i]->idx == params->vbif_idx)
166			vbif = dpu_kms->hw_vbif[i];
167	}
168
169	if (!vbif || !mdp) {
170		DPU_DEBUG("invalid arguments vbif %d mdp %d\n",
171				vbif != 0, mdp != 0);
172		return;
173	}
174
175	if (!mdp->ops.setup_clk_force_ctrl ||
176			!vbif->ops.set_limit_conf ||
177			!vbif->ops.set_halt_ctrl)
178		return;
179
180	/* set write_gather_en for all write clients */
181	if (vbif->ops.set_write_gather_en && !params->rd)
182		vbif->ops.set_write_gather_en(vbif, params->xin_id);
183
184	ot_lim = _dpu_vbif_get_ot_limit(vbif, params) & 0xFF;
185
186	if (ot_lim == 0)
187		return;
188
189	trace_dpu_perf_set_ot(params->num, params->xin_id, ot_lim,
190		params->vbif_idx);
191
192	forced_on = mdp->ops.setup_clk_force_ctrl(mdp, params->clk_ctrl, true);
193
194	vbif->ops.set_limit_conf(vbif, params->xin_id, params->rd, ot_lim);
195
196	vbif->ops.set_halt_ctrl(vbif, params->xin_id, true);
197
198	ret = _dpu_vbif_wait_for_xin_halt(vbif, params->xin_id);
199	if (ret)
200		trace_dpu_vbif_wait_xin_halt_fail(vbif->idx, params->xin_id);
201
202	vbif->ops.set_halt_ctrl(vbif, params->xin_id, false);
203
204	if (forced_on)
205		mdp->ops.setup_clk_force_ctrl(mdp, params->clk_ctrl, false);
206}
207
208void dpu_vbif_set_qos_remap(struct dpu_kms *dpu_kms,
209		struct dpu_vbif_set_qos_params *params)
210{
211	struct dpu_hw_vbif *vbif = NULL;
212	struct dpu_hw_mdp *mdp;
213	bool forced_on = false;
214	const struct dpu_vbif_qos_tbl *qos_tbl;
215	int i;
216
217	if (!dpu_kms || !params || !dpu_kms->hw_mdp) {
218		DPU_ERROR("invalid arguments\n");
219		return;
220	}
221	mdp = dpu_kms->hw_mdp;
222
223	for (i = 0; i < ARRAY_SIZE(dpu_kms->hw_vbif); i++) {
224		if (dpu_kms->hw_vbif[i] &&
225				dpu_kms->hw_vbif[i]->idx == params->vbif_idx) {
226			vbif = dpu_kms->hw_vbif[i];
227			break;
228		}
229	}
230
231	if (!vbif || !vbif->cap) {
232		DPU_ERROR("invalid vbif %d\n", params->vbif_idx);
233		return;
234	}
235
236	if (!vbif->ops.set_qos_remap || !mdp->ops.setup_clk_force_ctrl) {
237		DPU_DEBUG("qos remap not supported\n");
238		return;
239	}
240
241	qos_tbl = params->is_rt ? &vbif->cap->qos_rt_tbl :
242			&vbif->cap->qos_nrt_tbl;
243
244	if (!qos_tbl->npriority_lvl || !qos_tbl->priority_lvl) {
245		DPU_DEBUG("qos tbl not defined\n");
246		return;
247	}
248
249	forced_on = mdp->ops.setup_clk_force_ctrl(mdp, params->clk_ctrl, true);
250
251	for (i = 0; i < qos_tbl->npriority_lvl; i++) {
252		DPU_DEBUG("vbif:%d xin:%d lvl:%d/%d\n",
253				params->vbif_idx, params->xin_id, i,
254				qos_tbl->priority_lvl[i]);
255		vbif->ops.set_qos_remap(vbif, params->xin_id, i,
256				qos_tbl->priority_lvl[i]);
257	}
258
259	if (forced_on)
260		mdp->ops.setup_clk_force_ctrl(mdp, params->clk_ctrl, false);
261}
262
263void dpu_vbif_clear_errors(struct dpu_kms *dpu_kms)
264{
265	struct dpu_hw_vbif *vbif;
266	u32 i, pnd, src;
267
268	for (i = 0; i < ARRAY_SIZE(dpu_kms->hw_vbif); i++) {
269		vbif = dpu_kms->hw_vbif[i];
270		if (vbif && vbif->ops.clear_errors) {
271			vbif->ops.clear_errors(vbif, &pnd, &src);
272			if (pnd || src) {
273				DRM_DEBUG_KMS("VBIF %d: pnd 0x%X, src 0x%X\n",
274					      vbif->idx - VBIF_0, pnd, src);
275			}
276		}
277	}
278}
279
280void dpu_vbif_init_memtypes(struct dpu_kms *dpu_kms)
281{
282	struct dpu_hw_vbif *vbif;
283	int i, j;
284
285	for (i = 0; i < ARRAY_SIZE(dpu_kms->hw_vbif); i++) {
286		vbif = dpu_kms->hw_vbif[i];
287		if (vbif && vbif->cap && vbif->ops.set_mem_type) {
288			for (j = 0; j < vbif->cap->memtype_count; j++)
289				vbif->ops.set_mem_type(
290						vbif, j, vbif->cap->memtype[j]);
291		}
292	}
293}
294
295#ifdef CONFIG_DEBUG_FS
296
297void dpu_debugfs_vbif_init(struct dpu_kms *dpu_kms, struct dentry *debugfs_root)
298{
299	char vbif_name[32];
300	struct dentry *entry, *debugfs_vbif;
301	int i, j;
302
303	entry = debugfs_create_dir("vbif", debugfs_root);
304
305	for (i = 0; i < dpu_kms->catalog->vbif_count; i++) {
306		struct dpu_vbif_cfg *vbif = &dpu_kms->catalog->vbif[i];
307
308		snprintf(vbif_name, sizeof(vbif_name), "%d", vbif->id);
309
310		debugfs_vbif = debugfs_create_dir(vbif_name, entry);
311
312		debugfs_create_u32("features", 0600, debugfs_vbif,
313			(u32 *)&vbif->features);
314
315		debugfs_create_u32("xin_halt_timeout", 0400, debugfs_vbif,
316			(u32 *)&vbif->xin_halt_timeout);
317
318		debugfs_create_u32("default_rd_ot_limit", 0400, debugfs_vbif,
319			(u32 *)&vbif->default_ot_rd_limit);
320
321		debugfs_create_u32("default_wr_ot_limit", 0400, debugfs_vbif,
322			(u32 *)&vbif->default_ot_wr_limit);
323
324		for (j = 0; j < vbif->dynamic_ot_rd_tbl.count; j++) {
325			struct dpu_vbif_dynamic_ot_cfg *cfg =
326					&vbif->dynamic_ot_rd_tbl.cfg[j];
327
328			snprintf(vbif_name, sizeof(vbif_name),
329					"dynamic_ot_rd_%d_pps", j);
330			debugfs_create_u64(vbif_name, 0400, debugfs_vbif,
331					(u64 *)&cfg->pps);
332			snprintf(vbif_name, sizeof(vbif_name),
333					"dynamic_ot_rd_%d_ot_limit", j);
334			debugfs_create_u32(vbif_name, 0400, debugfs_vbif,
335					(u32 *)&cfg->ot_limit);
336		}
337
338		for (j = 0; j < vbif->dynamic_ot_wr_tbl.count; j++) {
339			struct dpu_vbif_dynamic_ot_cfg *cfg =
340					&vbif->dynamic_ot_wr_tbl.cfg[j];
341
342			snprintf(vbif_name, sizeof(vbif_name),
343					"dynamic_ot_wr_%d_pps", j);
344			debugfs_create_u64(vbif_name, 0400, debugfs_vbif,
345					(u64 *)&cfg->pps);
346			snprintf(vbif_name, sizeof(vbif_name),
347					"dynamic_ot_wr_%d_ot_limit", j);
348			debugfs_create_u32(vbif_name, 0400, debugfs_vbif,
349					(u32 *)&cfg->ot_limit);
350		}
351	}
352}
353#endif