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         /* TODO */
  72         return 0;
  73 }
  74
  75 int pem_task_set_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  76 {
  77         /* TODO */
  78         return 0;
  79 }
  80
  81 int pem_task_reset_boot_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  82 {
  83         /* TODO */
  84         return 0;
  85 }
  86
  87 int pem_task_update_new_power_state_clocks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  88 {
  89         /* TODO */
  90         return 0;
  91 }
  92
  93 int pem_task_system_shutdown(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
  94 {
  95         /* TODO */
  96         return 0;
  97 }
  98
  99 int pem_task_register_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 100 {
 101         /* TODO */
 102         return 0;
 103 }
 104
 105 int pem_task_unregister_interrupts(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 106 {
 107         return pem_unregister_interrupts(eventmgr);
 108 }
 109
 110 int pem_task_get_boot_state_id(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 111 {
 112         int result;
 113
 114         result = psm_get_state_by_classification(eventmgr,
 115                 PP_StateClassificationFlag_Boot,
 116                 &(event_data->requested_state_id)
 117         );
 118
 119         if (0 == result)
 120                 pem_set_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID);
 121         else
 122                 pem_unset_event_data_valid(event_data->valid_fields, PEM_EventDataValid_RequestedStateID);
 123
 124         return result;
 125 }
 126
 127 int pem_task_enable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 128 {
 129         return phm_enable_dynamic_state_management(eventmgr->hwmgr);
 130 }
 131
 132 int pem_task_disable_dynamic_state_management(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 133 {
 134         /* TODO */
 135         return 0;
 136 }
 137
 138 int pem_task_enable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 139 {
 140         return phm_enable_clock_power_gatings(eventmgr->hwmgr);
 141 }
 142
 143 int pem_task_powerdown_uvd_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 144 {
 145         return phm_powerdown_uvd(eventmgr->hwmgr);
 146 }
 147
 148 int pem_task_powerdown_vce_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 149 {
 150         phm_powergate_uvd(eventmgr->hwmgr, true);
 151         phm_powergate_vce(eventmgr->hwmgr, true);
 152         return 0;
 153 }
 154
 155 int pem_task_disable_clock_power_gatings_tasks(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 156 {
 157         /* TODO */
 158         return 0;
 159 }
 160
 161 int pem_task_start_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 162 {
 163         /* TODO */
 164         return 0;
 165 }
 166
 167 int pem_task_stop_asic_block_usage(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 168 {
 169         /* TODO */
 170         return 0;
 171 }
 172
 173 int pem_task_setup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 174 {
 175         return phm_setup_asic(eventmgr->hwmgr);
 176 }
 177
 178 int pem_task_cleanup_asic(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 179 {
 180         /* TODO */
 181         return 0;
 182 }
 183
 184 int pem_task_store_dal_configuration(struct pp_eventmgr *eventmgr, const struct amd_display_configuration *display_config)
 185 {
 186         /* TODO */
 187         return 0;
 188         /*phm_store_dal_configuration_data(eventmgr->hwmgr, display_config) */
 189 }
 190
 191 int pem_task_notify_hw_mgr_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 192 {
 193         if (pem_is_hw_access_blocked(eventmgr))
 194                 return 0;
 195
 196         return phm_display_configuration_changed(eventmgr->hwmgr);
 197 }
 198
 199 int pem_task_notify_hw_mgr_pre_display_configuration_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 200 {
 201         return 0;
 202 }
 203
 204 int pem_task_notify_smc_display_config_after_power_state_adjustment(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 205 {
 206         if (pem_is_hw_access_blocked(eventmgr))
 207                 return 0;
 208
 209         return phm_notify_smc_display_config_after_ps_adjustment(eventmgr->hwmgr);
 210 }
 211
 212 int pem_task_block_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 213 {
 214         eventmgr->block_adjust_power_state = true;
 215         /* to do PHM_ResetIPSCounter(pEventMgr->pHwMgr);*/
 216         return 0;
 217 }
 218
 219 int pem_task_unblock_adjust_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 220 {
 221         eventmgr->block_adjust_power_state = false;
 222         return 0;
 223 }
 224
 225 int pem_task_notify_power_state_change(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 226 {
 227         /* TODO */
 228         return 0;
 229 }
 230
 231 int pem_task_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 232 {
 233         /* TODO */
 234         return 0;
 235 }
 236
 237 int pem_task_un_block_hw_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 238 {
 239         /* TODO */
 240         return 0;
 241 }
 242
 243 int pem_task_reset_display_phys_access(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 244 {
 245         /* TODO */
 246         return 0;
 247 }
 248
 249 int pem_task_set_cpu_power_state(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 250 {
 251         /* TODO */
 252         return 0;
 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_performance_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 *)((uint64_t)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         range.max = TEMP_RANGE_MAX;
 423         range.min = TEMP_RANGE_MIN;
 424
 425         return phm_start_thermal_controller(eventmgr->hwmgr, &range);
 426 }
 427
 428 int pem_task_uninitialize_thermal_controller(struct pp_eventmgr *eventmgr, struct pem_event_data *event_data)
 429 {
 430         return phm_stop_thermal_controller(eventmgr->hwmgr);
 431 }