drivers/gpu/drm/amd/display/dc/clk_mgr/clk_mgr.c

   1 /*
   2  * Copyright 2012-16 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25
  26 #include <linux/slab.h>
  27
  28 #include "dal_asic_id.h"
  29 #include "dc_types.h"
  30 #include "dccg.h"
  31 #include "clk_mgr_internal.h"
  32
  33 #include "dce100/dce_clk_mgr.h"
  34 #include "dce110/dce110_clk_mgr.h"
  35 #include "dce112/dce112_clk_mgr.h"
  36 #include "dce120/dce120_clk_mgr.h"
  37 #include "dce60/dce60_clk_mgr.h"
  38 #include "dcn10/rv1_clk_mgr.h"
  39 #include "dcn10/rv2_clk_mgr.h"
  40 #include "dcn20/dcn20_clk_mgr.h"
  41 #include "dcn21/rn_clk_mgr.h"
  42 #if defined(CONFIG_DRM_AMD_DC_DCN3_0)
  43 #include "dcn30/dcn30_clk_mgr.h"
  44 #endif
  45
  46
  47 int clk_mgr_helper_get_active_display_cnt(
  48                 struct dc *dc,
  49                 struct dc_state *context)
  50 {
  51         int i, display_count;
  52
  53         display_count = 0;
  54         for (i = 0; i < context->stream_count; i++) {
  55                 const struct dc_stream_state *stream = context->streams[i];
  56
  57                 /*
  58                  * Only notify active stream or virtual stream.
  59                  * Need to notify virtual stream to work around
  60                  * headless case. HPD does not fire when system is in
  61                  * S0i2.
  62                  */
  63                 if (!stream->dpms_off || stream->signal == SIGNAL_TYPE_VIRTUAL)
  64                         display_count++;
  65         }
  66
  67         return display_count;
  68 }
  69
  70 int clk_mgr_helper_get_active_plane_cnt(
  71                 struct dc *dc,
  72                 struct dc_state *context)
  73 {
  74         int i, total_plane_count;
  75
  76         total_plane_count = 0;
  77         for (i = 0; i < context->stream_count; i++) {
  78                 const struct dc_stream_status stream_status = context->stream_status[i];
  79
  80                 /*
  81                  * Sum up plane_count for all streams ( active and virtual ).
  82                  */
  83                 total_plane_count += stream_status.plane_count;
  84         }
  85
  86         return total_plane_count;
  87 }
  88
  89 void clk_mgr_exit_optimized_pwr_state(const struct dc *dc, struct clk_mgr *clk_mgr)
  90 {
  91         struct dc_link *edp_link = get_edp_link(dc);
  92
  93         if (dc->hwss.exit_optimized_pwr_state)
  94                 dc->hwss.exit_optimized_pwr_state(dc, dc->current_state);
  95
  96         if (edp_link) {
  97                 clk_mgr->psr_allow_active_cache = edp_link->psr_settings.psr_allow_active;
  98                 dc_link_set_psr_allow_active(edp_link, false, false);
  99         }
 100
 101 }
 102
 103 void clk_mgr_optimize_pwr_state(const struct dc *dc, struct clk_mgr *clk_mgr)
 104 {
 105         struct dc_link *edp_link = get_edp_link(dc);
 106
 107         if (edp_link)
 108                 dc_link_set_psr_allow_active(edp_link, clk_mgr->psr_allow_active_cache, false);
 109
 110         if (dc->hwss.optimize_pwr_state)
 111                 dc->hwss.optimize_pwr_state(dc, dc->current_state);
 112
 113 }
 114
 115 struct clk_mgr *dc_clk_mgr_create(struct dc_context *ctx, struct pp_smu_funcs *pp_smu, struct dccg *dccg)
 116 {
 117         struct hw_asic_id asic_id = ctx->asic_id;
 118
 119         struct clk_mgr_internal *clk_mgr = kzalloc(sizeof(*clk_mgr), GFP_KERNEL);
 120
 121         if (clk_mgr == NULL) {
 122                 BREAK_TO_DEBUGGER();
 123                 return NULL;
 124         }
 125
 126         switch (asic_id.chip_family) {
 127 #if defined(CONFIG_DRM_AMD_DC_SI)
 128         case FAMILY_SI:
 129                 dce60_clk_mgr_construct(ctx, clk_mgr);
 130                 break;
 131 #endif
 132         case FAMILY_CI:
 133         case FAMILY_KV:
 134                 dce_clk_mgr_construct(ctx, clk_mgr);
 135                 break;
 136         case FAMILY_CZ:
 137                 dce110_clk_mgr_construct(ctx, clk_mgr);
 138                 break;
 139         case FAMILY_VI:
 140                 if (ASIC_REV_IS_TONGA_P(asic_id.hw_internal_rev) ||
 141                                 ASIC_REV_IS_FIJI_P(asic_id.hw_internal_rev)) {
 142                         dce_clk_mgr_construct(ctx, clk_mgr);
 143                         break;
 144                 }
 145                 if (ASIC_REV_IS_POLARIS10_P(asic_id.hw_internal_rev) ||
 146                                 ASIC_REV_IS_POLARIS11_M(asic_id.hw_internal_rev) ||
 147                                 ASIC_REV_IS_POLARIS12_V(asic_id.hw_internal_rev)) {
 148                         dce112_clk_mgr_construct(ctx, clk_mgr);
 149                         break;
 150                 }
 151                 if (ASIC_REV_IS_VEGAM(asic_id.hw_internal_rev)) {
 152                         dce112_clk_mgr_construct(ctx, clk_mgr);
 153                         break;
 154                 }
 155                 break;
 156         case FAMILY_AI:
 157                 if (ASICREV_IS_VEGA20_P(asic_id.hw_internal_rev))
 158                         dce121_clk_mgr_construct(ctx, clk_mgr);
 159                 else
 160                         dce120_clk_mgr_construct(ctx, clk_mgr);
 161                 break;
 162
 163 #if defined(CONFIG_DRM_AMD_DC_DCN)
 164         case FAMILY_RV:
 165                 if (ASICREV_IS_RENOIR(asic_id.hw_internal_rev)) {
 166                         rn_clk_mgr_construct(ctx, clk_mgr, pp_smu, dccg);
 167                         break;
 168                 }
 169
 170                 if (ASICREV_IS_GREEN_SARDINE(asic_id.hw_internal_rev)) {
 171                         rn_clk_mgr_construct(ctx, clk_mgr, pp_smu, dccg);
 172                         break;
 173                 }
 174                 if (ASICREV_IS_RAVEN2(asic_id.hw_internal_rev)) {
 175                         rv2_clk_mgr_construct(ctx, clk_mgr, pp_smu);
 176                         break;
 177                 }
 178                 if (ASICREV_IS_RAVEN(asic_id.hw_internal_rev) ||
 179                                 ASICREV_IS_PICASSO(asic_id.hw_internal_rev)) {
 180                         rv1_clk_mgr_construct(ctx, clk_mgr, pp_smu);
 181                         break;
 182                 }
 183                 break;
 184
 185         case FAMILY_NV:
 186 #if defined(CONFIG_DRM_AMD_DC_DCN3_0)
 187                 if (ASICREV_IS_SIENNA_CICHLID_P(asic_id.hw_internal_rev)) {
 188                         dcn3_clk_mgr_construct(ctx, clk_mgr, pp_smu, dccg);
 189                         break;
 190                 }
 191 #endif
 192                 dcn20_clk_mgr_construct(ctx, clk_mgr, pp_smu, dccg);
 193                 break;
 194 #endif  /* Family RV and NV*/
 195
 196         default:
 197                 ASSERT(0); /* Unknown Asic */
 198                 break;
 199         }
 200
 201         return &clk_mgr->base;
 202 }
 203
 204 void dc_destroy_clk_mgr(struct clk_mgr *clk_mgr_base)
 205 {
 206         struct clk_mgr_internal *clk_mgr = TO_CLK_MGR_INTERNAL(clk_mgr_base);
 207 #ifdef CONFIG_DRM_AMD_DC_DCN3_0
 208
 209         switch (clk_mgr_base->ctx->asic_id.chip_family) {
 210         case FAMILY_NV:
 211                 if (ASICREV_IS_SIENNA_CICHLID_P(clk_mgr_base->ctx->asic_id.hw_internal_rev)) {
 212                         dcn3_clk_mgr_destroy(clk_mgr);
 213                         break;
 214                 }
 215         }
 216 #endif
 217
 218         kfree(clk_mgr);
 219 }
 220