drivers/gpu/drm/msm/disp/dpu1/dpu_vbif.c

   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  */
  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  */
  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  */
 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  */
 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
 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
 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
 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
 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
 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