This source file includes following definitions.
- _dpu_vbif_wait_for_xin_halt
- _dpu_vbif_apply_dynamic_ot_limit
- _dpu_vbif_get_ot_limit
- dpu_vbif_set_ot_limit
- dpu_vbif_set_qos_remap
- dpu_vbif_clear_errors
- dpu_vbif_init_memtypes
- dpu_debugfs_vbif_init
1
2
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
16
17
18
19
20 static 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
58
59
60
61
62 static 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
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
98
99
100
101
102 static 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
120
121
122 if (ot_lim == 0)
123 goto exit;
124
125
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
135 exit:
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
143
144
145
146
147
148 void 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
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
208 void 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
263 void 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
280 void 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
297 void 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