amdgpu/pm: Optimize emit_clock_levels for arcturus - part 1

 Use variables to remove the multiple nested ternary expressions and
 improve readability. This will help to optimize the code duplication
 in the switch statement
 Also Changed:
  Modify function arcturus_get_clk_table to void function as it
    always returns 0
  Use const string "attempt_string" to cut down on repetition

Signed-off-by: Darren Powell <darren.powell@amd.com>
Reviewed-by: Lijo Lazar <lijo.lazar@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c b/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c
index 753a427ec20f3833bbed9f655e63636e0e1df387..7f8ed455c5c3f2d1aa2e1393a2cf3d5a2f6f3e04 100644 (file)
--- a/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c
+++ b/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c
@@ -569,9 +569,9 @@ static int arcturus_populate_umd_state_clk(struct smu_context *smu)
        return 0;
 }
 
-static int arcturus_get_clk_table(struct smu_context *smu,
-                       struct pp_clock_levels_with_latency *clocks,
-                       struct smu_11_0_dpm_table *dpm_table)
+static void arcturus_get_clk_table(struct smu_context *smu,
+                                  struct pp_clock_levels_with_latency *clocks,
+                                  struct smu_11_0_dpm_table *dpm_table)
 {
        uint32_t i;
 
@@ -584,8 +584,6 @@ static int arcturus_get_clk_table(struct smu_context *smu,
                        dpm_table->dpm_levels[i].value * 1000;
                clocks->data[i].latency_in_us = 0;
        }
-
-       return 0;
 }
 
 static int arcturus_freqs_in_same_level(int32_t frequency1,
@@ -767,7 +765,9 @@ static int arcturus_emit_clk_levels(struct smu_context *smu,
        struct smu_11_0_dpm_context *dpm_context = NULL;
        uint32_t gen_speed, lane_width;
        uint32_t i, cur_value = 0;
-
+       bool freq_match;
+       unsigned int clock_mhz;
+       static const char attempt_string[] = "Attempt to get current";
 
        if (amdgpu_ras_intr_triggered()) {
                *offset += sysfs_emit_at(buf, *offset, "unavailable\n");
@@ -780,143 +780,131 @@ static int arcturus_emit_clk_levels(struct smu_context *smu,
        case SMU_SCLK:
                ret = arcturus_get_current_clk_freq_by_table(smu, SMU_GFXCLK, &cur_value);
                if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get current gfx clk Failed!");
+                       dev_err(smu->adev->dev, "%s gfx clk Failed!", attempt_string);
                        return ret;
                }
 
                single_dpm_table = &(dpm_context->dpm_tables.gfx_table);
-               ret = arcturus_get_clk_table(smu, &clocks, single_dpm_table);
-               if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get gfx clk levels Failed!");
-                       return ret;
-               }
+               arcturus_get_clk_table(smu, &clocks, single_dpm_table);
 
                /*
                 * For DPM disabled case, there will be only one clock level.
                 * And it's safe to assume that is always the current clock.
                 */
-               for (i = 0; i < clocks.num_levels; i++)
+               for (i = 0; i < clocks.num_levels; i++) {
+                       clock_mhz = clocks.data[i].clocks_in_khz / 1000;
+                       freq_match = arcturus_freqs_in_same_level(clock_mhz, cur_value);
+
                        *offset += sysfs_emit_at(buf, *offset, "%d: %uMhz %s\n", i,
-                                       clocks.data[i].clocks_in_khz / 1000,
+                                       clock_mhz,
                                        (clocks.num_levels == 1) ? "*" :
-                                       (arcturus_freqs_in_same_level(
-                                       clocks.data[i].clocks_in_khz / 1000,
-                                       cur_value) ? "*" : ""));
+                                               (freq_match ? "*" : ""));
+               }
                break;
 
        case SMU_MCLK:
                ret = arcturus_get_current_clk_freq_by_table(smu, SMU_UCLK, &cur_value);
                if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get current mclk Failed!");
+                       dev_err(smu->adev->dev, "%s mclk Failed!", attempt_string);
                        return ret;
                }
 
                single_dpm_table = &(dpm_context->dpm_tables.uclk_table);
-               ret = arcturus_get_clk_table(smu, &clocks, single_dpm_table);
-               if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get memory clk levels Failed!");
-                       return ret;
-               }
+               arcturus_get_clk_table(smu, &clocks, single_dpm_table);
+
+               for (i = 0; i < clocks.num_levels; i++) {
+                       clock_mhz = clocks.data[i].clocks_in_khz / 1000;
+                       freq_match = arcturus_freqs_in_same_level(clock_mhz, cur_value);
 
-               for (i = 0; i < clocks.num_levels; i++)
                        *offset += sysfs_emit_at(buf, *offset, "%d: %uMhz %s\n",
-                               i, clocks.data[i].clocks_in_khz / 1000,
+                               i, clock_mhz,
                                (clocks.num_levels == 1) ? "*" :
-                               (arcturus_freqs_in_same_level(
-                               clocks.data[i].clocks_in_khz / 1000,
-                               cur_value) ? "*" : ""));
+                                       (freq_match ? "*" : ""));
+               }
                break;
 
        case SMU_SOCCLK:
                ret = arcturus_get_current_clk_freq_by_table(smu, SMU_SOCCLK, &cur_value);
                if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get current socclk Failed!");
+                       dev_err(smu->adev->dev, "%s socclk Failed!", attempt_string);
                        return ret;
                }
 
                single_dpm_table = &(dpm_context->dpm_tables.soc_table);
-               ret = arcturus_get_clk_table(smu, &clocks, single_dpm_table);
-               if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get socclk levels Failed!");
-                       return ret;
-               }
+               arcturus_get_clk_table(smu, &clocks, single_dpm_table);
+
+               for (i = 0; i < clocks.num_levels; i++) {
+                       clock_mhz = clocks.data[i].clocks_in_khz / 1000;
+                       freq_match = arcturus_freqs_in_same_level(clock_mhz, cur_value);
 
-               for (i = 0; i < clocks.num_levels; i++)
                        *offset += sysfs_emit_at(buf, *offset, "%d: %uMhz %s\n",
-                               i, clocks.data[i].clocks_in_khz / 1000,
+                               i, clock_mhz,
                                (clocks.num_levels == 1) ? "*" :
-                               (arcturus_freqs_in_same_level(
-                               clocks.data[i].clocks_in_khz / 1000,
-                               cur_value) ? "*" : ""));
+                                       (freq_match ? "*" : ""));
+               }
                break;
 
        case SMU_FCLK:
                ret = arcturus_get_current_clk_freq_by_table(smu, SMU_FCLK, &cur_value);
                if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get current fclk Failed!");
+                       dev_err(smu->adev->dev, "%s fclk Failed!", attempt_string);
                        return ret;
                }
 
                single_dpm_table = &(dpm_context->dpm_tables.fclk_table);
-               ret = arcturus_get_clk_table(smu, &clocks, single_dpm_table);
-               if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get fclk levels Failed!");
-                       return ret;
-               }
+               arcturus_get_clk_table(smu, &clocks, single_dpm_table);
+
+               for (i = 0; i < single_dpm_table->count; i++) {
+                       clock_mhz = clocks.data[i].clocks_in_khz / 1000;
+                       freq_match = arcturus_freqs_in_same_level(clock_mhz, cur_value);
 
-               for (i = 0; i < single_dpm_table->count; i++)
                        *offset += sysfs_emit_at(buf, *offset, "%d: %uMhz %s\n",
                                i, single_dpm_table->dpm_levels[i].value,
                                (clocks.num_levels == 1) ? "*" :
-                               (arcturus_freqs_in_same_level(
-                               clocks.data[i].clocks_in_khz / 1000,
-                               cur_value) ? "*" : ""));
+                                       (freq_match ? "*" : ""));
+               }
                break;
 
        case SMU_VCLK:
                ret = arcturus_get_current_clk_freq_by_table(smu, SMU_VCLK, &cur_value);
                if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get current vclk Failed!");
+                       dev_err(smu->adev->dev, "%s vclk Failed!", attempt_string);
                        return ret;
                }
 
                single_dpm_table = &(dpm_context->dpm_tables.vclk_table);
-               ret = arcturus_get_clk_table(smu, &clocks, single_dpm_table);
-               if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get vclk levels Failed!");
-                       return ret;
-               }
+               arcturus_get_clk_table(smu, &clocks, single_dpm_table);
+
+               for (i = 0; i < single_dpm_table->count; i++) {
+                       clock_mhz = clocks.data[i].clocks_in_khz / 1000;
+                       freq_match = arcturus_freqs_in_same_level(clock_mhz, cur_value);
 
-               for (i = 0; i < single_dpm_table->count; i++)
                        *offset += sysfs_emit_at(buf, *offset, "%d: %uMhz %s\n",
                                i, single_dpm_table->dpm_levels[i].value,
                                (clocks.num_levels == 1) ? "*" :
-                               (arcturus_freqs_in_same_level(
-                               clocks.data[i].clocks_in_khz / 1000,
-                               cur_value) ? "*" : ""));
+                                       (freq_match ? "*" : ""));
+               }
                break;
 
        case SMU_DCLK:
                ret = arcturus_get_current_clk_freq_by_table(smu, SMU_DCLK, &cur_value);
                if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get current dclk Failed!");
+                       dev_err(smu->adev->dev, "%s dclk Failed!", attempt_string);
                        return ret;
                }
 
                single_dpm_table = &(dpm_context->dpm_tables.dclk_table);
-               ret = arcturus_get_clk_table(smu, &clocks, single_dpm_table);
-               if (ret) {
-                       dev_err(smu->adev->dev, "Attempt to get dclk levels Failed!");
-                       return ret;
-               }
+               arcturus_get_clk_table(smu, &clocks, single_dpm_table);
+
+               for (i = 0; i < single_dpm_table->count; i++) {
+                       clock_mhz = clocks.data[i].clocks_in_khz / 1000;
+                       freq_match = arcturus_freqs_in_same_level(clock_mhz, cur_value);
 
-               for (i = 0; i < single_dpm_table->count; i++)
                        *offset += sysfs_emit_at(buf, *offset, "%d: %uMhz %s\n",
                                i, single_dpm_table->dpm_levels[i].value,
                                (clocks.num_levels == 1) ? "*" :
-                               (arcturus_freqs_in_same_level(
-                               clocks.data[i].clocks_in_khz / 1000,
-                               cur_value) ? "*" : ""));
+                                       (freq_match ? "*" : ""));
+               }
                break;
 
        case SMU_PCIE: