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