Clean code by dropping unnecessary ones.
Signed-off-by: Evan Quan <evan.quan@amd.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
                *(uint32_t *)data *= 100;
                *size = 4;
                break;
+       case AMDGPU_PP_SENSOR_VDDGFX:
+               ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
+               *size = 4;
+               break;
        default:
-               ret = smu_v11_0_read_sensor(smu, sensor, data, size);
+               ret = -EOPNOTSUPP;
+               break;
        }
        mutex_unlock(&smu->sensor_lock);
 
        .set_default_dpm_table = arcturus_set_default_dpm_table,
        .populate_umd_state_clk = arcturus_populate_umd_state_clk,
        .get_thermal_temperature_range = arcturus_get_thermal_temperature_range,
-       .get_current_clk_freq_by_table = arcturus_get_current_clk_freq_by_table,
        .print_clk_levels = arcturus_print_clk_levels,
        .force_clk_levels = arcturus_force_clk_levels,
        .read_sensor = arcturus_read_sensor,
 
        int (*get_fan_speed_rpm)(struct smu_context *smu, uint32_t *speed);
        int (*set_watermarks_table)(struct smu_context *smu, void *watermarks,
                                    struct dm_pp_wm_sets_with_clock_ranges_soc15 *clock_ranges);
-       int (*get_current_clk_freq_by_table)(struct smu_context *smu,
-                                            enum smu_clk_type clk_type,
-                                            uint32_t *value);
        int (*get_thermal_temperature_range)(struct smu_context *smu, struct smu_temperature_range *range);
        int (*get_uclk_dpm_states)(struct smu_context *smu, uint32_t *clocks_in_khz, uint32_t *num_states);
        int (*set_default_od_settings)(struct smu_context *smu);
 
 
 int smu_v11_0_set_power_limit(struct smu_context *smu, uint32_t n);
 
-int smu_v11_0_get_current_clk_freq(struct smu_context *smu,
-                                         enum smu_clk_type clk_id,
-                                         uint32_t *value);
-
 int smu_v11_0_init_max_sustainable_clocks(struct smu_context *smu);
 
 int smu_v11_0_enable_thermal_alert(struct smu_context *smu);
 
 int smu_v11_0_disable_thermal_alert(struct smu_context *smu);
 
-int smu_v11_0_read_sensor(struct smu_context *smu,
-                                enum amd_pp_sensors sensor,
-                                void *data, uint32_t *size);
+int smu_v11_0_get_gfx_vdd(struct smu_context *smu, uint32_t *value);
 
 int smu_v11_0_set_min_deep_sleep_dcefclk(struct smu_context *smu, uint32_t clk);
 
 
 
 int smu_v12_0_set_gfx_cgpg(struct smu_context *smu, bool enable);
 
-int smu_v12_0_read_sensor(struct smu_context *smu,
-                         enum amd_pp_sensors sensor,
-                         void *data, uint32_t *size);
-
 uint32_t smu_v12_0_get_gfxoff_status(struct smu_context *smu);
 
 int smu_v12_0_gfx_off_control(struct smu_context *smu, bool enable);
 int smu_v12_0_get_enabled_mask(struct smu_context *smu,
                                      uint32_t *feature_mask, uint32_t num);
 
-int smu_v12_0_get_current_clk_freq(struct smu_context *smu,
-                                         enum smu_clk_type clk_id,
-                                         uint32_t *value);
-
 int smu_v12_0_get_dpm_ultimate_freq(struct smu_context *smu, enum smu_clk_type clk_type,
                                                 uint32_t *min, uint32_t *max);
 
 
                *(uint32_t *)data *= 100;
                *size = 4;
                break;
+       case AMDGPU_PP_SENSOR_VDDGFX:
+               ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
+               *size = 4;
+               break;
        default:
-               ret = smu_v11_0_read_sensor(smu, sensor, data, size);
+               ret = -EOPNOTSUPP;
+               break;
        }
        mutex_unlock(&smu->sensor_lock);
 
        .set_default_dpm_table = navi10_set_default_dpm_table,
        .dpm_set_vcn_enable = navi10_dpm_set_vcn_enable,
        .dpm_set_jpeg_enable = navi10_dpm_set_jpeg_enable,
-       .get_current_clk_freq_by_table = navi10_get_current_clk_freq_by_table,
        .print_clk_levels = navi10_print_clk_levels,
        .force_clk_levels = navi10_force_clk_levels,
        .populate_umd_state_clk = navi10_populate_umd_state_clk,
 
                *size = 4;
                break;
        default:
-               ret = smu_v12_0_read_sensor(smu, sensor, data, size);
+               ret = -EOPNOTSUPP;
+               break;
        }
        mutex_unlock(&smu->sensor_lock);
 
        .get_current_power_state = renoir_get_current_power_state,
        .dpm_set_vcn_enable = renoir_dpm_set_vcn_enable,
        .dpm_set_jpeg_enable = renoir_dpm_set_jpeg_enable,
-       .get_current_clk_freq_by_table = renoir_get_current_clk_freq_by_table,
        .force_dpm_limit_value = renoir_force_dpm_limit_value,
        .unforce_dpm_levels = renoir_unforce_dpm_levels,
        .get_workload_type = renoir_get_workload_type,
 
                *(uint32_t *)data *= 100;
                *size = 4;
                break;
+       case AMDGPU_PP_SENSOR_VDDGFX:
+               ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
+               *size = 4;
+               break;
        default:
-               ret = smu_v11_0_read_sensor(smu, sensor, data, size);
+               ret = -EOPNOTSUPP;
+               break;
        }
        mutex_unlock(&smu->sensor_lock);
 
        .set_default_dpm_table = sienna_cichlid_set_default_dpm_table,
        .dpm_set_vcn_enable = sienna_cichlid_dpm_set_vcn_enable,
        .dpm_set_jpeg_enable = sienna_cichlid_dpm_set_jpeg_enable,
-       .get_current_clk_freq_by_table = sienna_cichlid_get_current_clk_freq_by_table,
        .print_clk_levels = sienna_cichlid_print_clk_levels,
        .force_clk_levels = sienna_cichlid_force_clk_levels,
        .populate_umd_state_clk = sienna_cichlid_populate_umd_state_clk,
 
 #define smu_dpm_set_vcn_enable(smu, enable)                            smu_ppt_funcs(dpm_set_vcn_enable, 0, smu, enable)
 #define smu_dpm_set_jpeg_enable(smu, enable)                           smu_ppt_funcs(dpm_set_jpeg_enable, 0, smu, enable)
 #define smu_set_watermarks_table(smu, tab, clock_ranges)               smu_ppt_funcs(set_watermarks_table, 0, smu, tab, clock_ranges)
-#define smu_get_current_clk_freq_by_table(smu, clk_type, value)                smu_ppt_funcs(get_current_clk_freq_by_table, 0, smu, clk_type, value)
 #define smu_thermal_temperature_range_update(smu, range, rw)           smu_ppt_funcs(thermal_temperature_range_update, 0, smu, range, rw)
 #define smu_get_thermal_temperature_range(smu, range)                  smu_ppt_funcs(get_thermal_temperature_range, 0, smu, range)
 #define smu_register_irq_handler(smu)                                  smu_ppt_funcs(register_irq_handler, 0, smu)
 
        return 0;
 }
 
-int smu_v11_0_get_current_clk_freq(struct smu_context *smu,
-                                         enum smu_clk_type clk_id,
-                                         uint32_t *value)
-{
-       int ret = 0;
-       uint32_t freq = 0;
-
-       if (clk_id >= SMU_CLK_COUNT || !value)
-               return -EINVAL;
-
-       ret =  smu_get_current_clk_freq_by_table(smu, clk_id, &freq);
-       if (ret)
-               return ret;
-
-       freq *= 100;
-       *value = freq;
-
-       return ret;
-}
-
 int smu_v11_0_enable_thermal_alert(struct smu_context *smu)
 {
        int ret = 0;
        return (uint16_t) ((6200 - (vid * 25)) / SMU11_VOLTAGE_SCALE);
 }
 
-static int smu_v11_0_get_gfx_vdd(struct smu_context *smu, uint32_t *value)
+int smu_v11_0_get_gfx_vdd(struct smu_context *smu, uint32_t *value)
 {
        struct amdgpu_device *adev = smu->adev;
        uint32_t vdd = 0, val_vid = 0;
 
 }
 
-int smu_v11_0_read_sensor(struct smu_context *smu,
-                                enum amd_pp_sensors sensor,
-                                void *data, uint32_t *size)
-{
-       int ret = 0;
-
-       if(!data || !size)
-               return -EINVAL;
-
-       switch (sensor) {
-       case AMDGPU_PP_SENSOR_VDDGFX:
-               ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
-               *size = 4;
-               break;
-       default:
-               ret = -EOPNOTSUPP;
-               break;
-       }
-
-       if (ret)
-               *size = 0;
-
-       return ret;
-}
-
 int
 smu_v11_0_display_clock_voltage_request(struct smu_context *smu,
                                        struct pp_display_clock_request
 
                NULL);
 }
 
-int smu_v12_0_read_sensor(struct smu_context *smu,
-                                enum amd_pp_sensors sensor,
-                                void *data, uint32_t *size)
-{
-       int ret = 0;
-
-       if(!data || !size)
-               return -EINVAL;
-
-       switch (sensor) {
-       default:
-               ret = -EOPNOTSUPP;
-               break;
-       }
-
-       if (ret)
-               *size = 0;
-
-       return ret;
-}
-
 /**
  * smu_v12_0_get_gfxoff_status - get gfxoff status
  *
        return ret;
 }
 
-int smu_v12_0_get_current_clk_freq(struct smu_context *smu,
-                                         enum smu_clk_type clk_id,
-                                         uint32_t *value)
-{
-       int ret = 0;
-       uint32_t freq = 0;
-
-       if (clk_id >= SMU_CLK_COUNT || !value)
-               return -EINVAL;
-
-       ret = smu_get_current_clk_freq_by_table(smu, clk_id, &freq);
-       if (ret)
-               return ret;
-
-       freq *= 100;
-       *value = freq;
-
-       return ret;
-}
-
 int smu_v12_0_get_dpm_ultimate_freq(struct smu_context *smu, enum smu_clk_type clk_type,
                                                 uint32_t *min, uint32_t *max)
 {