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