drivers/gpu/drm/amd/powerplay/eventmgr/eventtasks.c

   1 /*
   2  * Copyright 2015 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  */
  23
  24 #include "eventmgr.h"
  25 #include "eventinit.h"
  26 #include "eventmanagement.h"
  27 #include "eventmanager.h"
  28 #include "hardwaremanager.h"
  29 #include "eventtasks.h"
  30 #include "power_state.h"
  31 #include "hwmgr.h"
  32 #include "amd_powerplay.h"
  33 #include "psm.h"
  34
  35 #define TEMP_RANGE_MIN (90 * 1000)
  36 #define TEMP_RANGE_MAX (120 * 1000)
  37
  38 int pem_task_update_allowed_performance_levels(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  39 {
  40
  41         if (pem_is_hw_access_blocked(eventmgr))
  42                 return 0;
  43
  44         phm_force_dpm_levels(eventmgr->hwmgr, AMD_DPM_FORCED_LEVEL_AUTO);
  45
  46         return 0;
  47 }
  48
  49 /* eventtasks_generic.c */
  50 int pem_task_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  51 {
  52         struct pp_hwmgr *hwmgr;
  53
  54         if (pem_is_hw_access_blocked(eventmgr))
  55                 return 0;
  56
  57         hwmgr = eventmgr->hwmgr;
  58         if (event_data->pnew_power_state != NULL)
  59                 hwmgr->request_ps = event_data->pnew_power_state;
  60
  61         if (phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_DynamicPatchPowerState))
  62                 psm_adjust_power_state_dynamic(eventmgr, event_data->skip_state_adjust_rules);
  63         else
  64                 psm_adjust_power_state_static(eventmgr, event_data->skip_state_adjust_rules);
  65
  66         return 0;
  67 }
  68
  69 int pem_task_power_down_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  70 {
  71         return phm_power_down_asic(eventmgr->hwmgr);
  72 }
  73
  74 int pem_task_set_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  75 {
  76         if (pem_is_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID))
  77                 return psm_set_states(eventmgr, &(event_data->requested_state_id));
  78
  79         return 0;
  80 }
  81
  82 int pem_task_reset_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  83 {
  84         /* TODO */
  85         return 0;
  86 }
  87
  88 int pem_task_update_new_power_state_clocks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  89 {
  90         /* TODO */
  91         return 0;
  92 }
  93
  94 int pem_task_system_shutdown(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  95 {
  96         /* TODO */
  97         return 0;
  98 }
  99
 100 int pem_task_register_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 101 {
 102         /* TODO */
 103         return 0;
 104 }
 105
 106 int pem_task_unregister_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 107 {
 108         return pem_unregister_interrupts(eventmgr);
 109 }
 110
 111 int pem_task_get_boot_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 112 {
 113         int result;
 114
 115         result = psm_get_state_by_classification(eventmgr,
 116                 PP_StateClassificationFlag_Boot,
 117                 &(event_data->requested_state_id)
 118         );
 119
 120         if (0 == result)
 121                 pem_set_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID);
 122         else
 123                 pem_unset_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID);
 124
 125         return result;
 126 }
 127
 128 int pem_task_enable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 129 {
 130         return phm_enable_dynamic_state_management(eventmgr->hwmgr);
 131 }
 132
 133 int pem_task_disable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 134 {
 135         /* TODO */
 136         return 0;
 137 }
 138
 139 int pem_task_enable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 140 {
 141         return phm_enable_clock_power_gatings(eventmgr->hwmgr);
 142 }
 143
 144 int pem_task_powerdown_uvd_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 145 {
 146         return phm_powerdown_uvd(eventmgr->hwmgr);
 147 }
 148
 149 int pem_task_powerdown_vce_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 150 {
 151         phm_powergate_uvd(eventmgr->hwmgr, true);
 152         phm_powergate_vce(eventmgr->hwmgr, true);
 153         return 0;
 154 }
 155
 156 int pem_task_disable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 157 {
 158         /* TODO */
 159         return 0;
 160 }
 161
 162 int pem_task_start_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 163 {
 164         /* TODO */
 165         return 0;
 166 }
 167
 168 int pem_task_stop_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 169 {
 170         /* TODO */
 171         return 0;
 172 }
 173
 174 int pem_task_setup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 175 {
 176         return phm_setup_asic(eventmgr->hwmgr);
 177 }
 178
 179 int pem_task_cleanup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 180 {
 181         /* TODO */
 182         return 0;
 183 }
 184
 185 int pem_task_store_dal_configuration(struct pp_eventmgr *eventmgr, const struct amd_display_configuration *display_config)
 186 {
 187         /* TODO */
 188         return 0;
 189         /*phm_store_dal_configuration_data(eventmgr->hwmgr, display_config) */
 190 }
 191
 192 int pem_task_notify_hw_mgr_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 193 {
 194         if (pem_is_hw_access_blocked(eventmgr))
 195                 return 0;
 196
 197         return phm_display_configuration_changed(eventmgr->hwmgr);
 198 }
 199
 200 int pem_task_notify_hw_mgr_pre_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 201 {
 202         return 0;
 203 }
 204
 205 int pem_task_notify_smc_display_config_after_power_state_adjustment(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 206 {
 207         if (pem_is_hw_access_blocked(eventmgr))
 208                 return 0;
 209
 210         return phm_notify_smc_display_config_after_ps_adjustment(eventmgr->hwmgr);
 211 }
 212
 213 int pem_task_block_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 214 {
 215         eventmgr->block_adjust_power_state = true;
 216         /* to do PHM_ResetIPSCounter(pEventMgr->pHwMgr);*/
 217         return 0;
 218 }
 219
 220 int pem_task_unblock_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 221 {
 222         eventmgr->block_adjust_power_state = false;
 223         return 0;
 224 }
 225
 226 int pem_task_notify_power_state_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 227 {
 228         /* TODO */
 229         return 0;
 230 }
 231
 232 int pem_task_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 233 {
 234         /* TODO */
 235         return 0;
 236 }
 237
 238 int pem_task_un_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 239 {
 240         /* TODO */
 241         return 0;
 242 }
 243
 244 int pem_task_reset_display_phys_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 245 {
 246         /* TODO */
 247         return 0;
 248 }
 249
 250 int pem_task_set_cpu_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 251 {
 252         return phm_set_cpu_power_state(eventmgr->hwmgr);
 253 }
 254
 255 /*powersaving*/
 256
 257 int pem_task_set_power_source(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 258 {
 259         /* TODO */
 260         return 0;
 261 }
 262
 263 int pem_task_notify_hw_of_power_source(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 264 {
 265         /* TODO */
 266         return 0;
 267 }
 268
 269 int pem_task_get_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 270 {
 271         /* TODO */
 272         return 0;
 273 }
 274
 275 int pem_task_reset_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 276 {
 277         /* TODO */
 278         return 0;
 279 }
 280
 281 int pem_task_set_power_saving_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 282 {
 283         /* TODO */
 284         return 0;
 285 }
 286
 287 int pem_task_set_screen_state_on(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 288 {
 289         /* TODO */
 290         return 0;
 291 }
 292
 293 int pem_task_set_screen_state_off(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 294 {
 295         /* TODO */
 296         return 0;
 297 }
 298
 299 int pem_task_enable_voltage_island_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 300 {
 301         /* TODO */
 302         return 0;
 303 }
 304
 305 int pem_task_disable_voltage_island_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 306 {
 307         /* TODO */
 308         return 0;
 309 }
 310
 311 int pem_task_enable_cgpg(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 312 {
 313         /* TODO */
 314         return 0;
 315 }
 316
 317 int pem_task_disable_cgpg(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 318 {
 319         /* TODO */
 320         return 0;
 321 }
 322
 323 int pem_task_enable_clock_power_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 324 {
 325         /* TODO */
 326         return 0;
 327 }
 328
 329
 330 int pem_task_enable_gfx_clock_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 331 {
 332         /* TODO */
 333         return 0;
 334 }
 335
 336 int pem_task_disable_gfx_clock_gating(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 337 {
 338         /* TODO */
 339         return 0;
 340 }
 341
 342
 343 /* performance */
 344 int pem_task_set_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 345 {
 346         if (pem_is_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID))
 347                 return psm_set_states(eventmgr, &(event_data->requested_state_id));
 348
 349         return 0;
 350 }
 351
 352 int pem_task_conditionally_force_3d_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 353 {
 354         /* TODO */
 355         return 0;
 356 }
 357
 358 int pem_task_enable_stutter_mode(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 359 {
 360         /* TODO */
 361         return 0;
 362 }
 363
 364 int pem_task_get_2D_performance_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 365 {
 366         int result;
 367
 368         if (eventmgr->features[PP_Feature_PowerPlay].supported &&
 369                 !(eventmgr->features[PP_Feature_PowerPlay].enabled))
 370                         result = psm_get_state_by_classification(eventmgr,
 371                                         PP_StateClassificationFlag_Boot,
 372                                         &(event_data->requested_state_id));
 373         else if (eventmgr->features[PP_Feature_User2DPerformance].enabled)
 374                         result = psm_get_state_by_classification(eventmgr,
 375                                    PP_StateClassificationFlag_User2DPerformance,
 376                                         &(event_data->requested_state_id));
 377         else
 378                 result = psm_get_ui_state(eventmgr, PP_StateUILabel_Performance,
 379                                         &(event_data->requested_state_id));
 380
 381         if (0 == result)
 382                 pem_set_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID);
 383         else
 384                 pem_unset_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID);
 385
 386         return result;
 387 }
 388
 389 int pem_task_create_user_performance_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 390 {
 391         struct pp_power_state *state;
 392         int table_entries;
 393         struct pp_hwmgr *hwmgr = eventmgr->hwmgr;
 394         int i;
 395
 396         table_entries = hwmgr->num_ps;
 397         state = hwmgr->ps;
 398
 399 restart_search:
 400         for (i = 0; i < table_entries; i++) {
 401                 if (state->classification.ui_label & event_data->requested_ui_label) {
 402                         event_data->pnew_power_state = state;
 403                         return 0;
 404                 }
 405                 state = (struct pp_power_state *)((unsigned long)state + hwmgr->ps_size);
 406         }
 407
 408         switch (event_data->requested_ui_label) {
 409         case PP_StateUILabel_Battery:
 410         case PP_StateUILabel_Balanced:
 411                 event_data->requested_ui_label = PP_StateUILabel_Performance;
 412                 goto restart_search;
 413         default:
 414                 break;
 415         }
 416         return -1;
 417 }
 418
 419 int pem_task_initialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 420 {
 421         struct PP_TemperatureRange range;
 422
 423         range.max = TEMP_RANGE_MAX;
 424         range.min = TEMP_RANGE_MIN;
 425
 426         if (eventmgr == NULL || eventmgr->platform_descriptor == NULL)
 427                 return -EINVAL;
 428
 429         if (phm_cap_enabled(eventmgr->platform_descriptor->platformCaps, PHM_PlatformCaps_ThermalController))
 430                 return phm_start_thermal_controller(eventmgr->hwmgr, &range);
 431
 432         return 0;
 433 }
 434
 435 int pem_task_uninitialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 436 {
 437         return phm_stop_thermal_controller(eventmgr->hwmgr);
 438 }