2 * Copyright 2019 Advanced Micro Devices, Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
24 #include <linux/firmware.h>
26 #include "amdgpu_smu.h"
27 #include "atomfirmware.h"
28 #include "amdgpu_atomfirmware.h"
29 #include "smu_v11_0.h"
30 #include "soc15_common.h"
32 #include "vega20_ppt.h"
33 #include "navi10_ppt.h"
35 #include "asic_reg/thm/thm_11_0_2_offset.h"
36 #include "asic_reg/thm/thm_11_0_2_sh_mask.h"
37 #include "asic_reg/mp/mp_11_0_offset.h"
38 #include "asic_reg/mp/mp_11_0_sh_mask.h"
39 #include "asic_reg/nbio/nbio_7_4_offset.h"
40 #include "asic_reg/smuio/smuio_11_0_0_offset.h"
41 #include "asic_reg/smuio/smuio_11_0_0_sh_mask.h"
43 MODULE_FIRMWARE("amdgpu/vega20_smc.bin");
44 MODULE_FIRMWARE("amdgpu/navi10_smc.bin");
46 #define SMU11_VOLTAGE_SCALE 4
48 static int smu_v11_0_send_msg_without_waiting(struct smu_context *smu,
51 struct amdgpu_device *adev = smu->adev;
52 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_66, msg);
56 static int smu_v11_0_read_arg(struct smu_context *smu, uint32_t *arg)
58 struct amdgpu_device *adev = smu->adev;
60 *arg = RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_82);
64 static int smu_v11_0_wait_for_response(struct smu_context *smu)
66 struct amdgpu_device *adev = smu->adev;
67 uint32_t cur_value, i;
69 for (i = 0; i < adev->usec_timeout; i++) {
70 cur_value = RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90);
71 if ((cur_value & MP1_C2PMSG_90__CONTENT_MASK) != 0)
76 /* timeout means wrong logic */
77 if (i == adev->usec_timeout)
80 return RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90) == 0x1 ? 0 : -EIO;
83 static int smu_v11_0_send_msg(struct smu_context *smu, uint16_t msg)
85 struct amdgpu_device *adev = smu->adev;
86 int ret = 0, index = 0;
88 index = smu_msg_get_index(smu, msg);
92 smu_v11_0_wait_for_response(smu);
94 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90, 0);
96 smu_v11_0_send_msg_without_waiting(smu, (uint16_t)index);
98 ret = smu_v11_0_wait_for_response(smu);
101 pr_err("Failed to send message 0x%x, response 0x%x\n", index,
109 smu_v11_0_send_msg_with_param(struct smu_context *smu, uint16_t msg,
113 struct amdgpu_device *adev = smu->adev;
114 int ret = 0, index = 0;
116 index = smu_msg_get_index(smu, msg);
120 ret = smu_v11_0_wait_for_response(smu);
122 pr_err("Failed to send message 0x%x, response 0x%x, param 0x%x\n",
125 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90, 0);
127 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_82, param);
129 smu_v11_0_send_msg_without_waiting(smu, (uint16_t)index);
131 ret = smu_v11_0_wait_for_response(smu);
133 pr_err("Failed to send message 0x%x, response 0x%x param 0x%x\n",
139 static int smu_v11_0_init_microcode(struct smu_context *smu)
141 struct amdgpu_device *adev = smu->adev;
142 const char *chip_name;
145 const struct smc_firmware_header_v1_0 *hdr;
146 const struct common_firmware_header *header;
147 struct amdgpu_firmware_info *ucode = NULL;
149 switch (adev->asic_type) {
151 chip_name = "vega20";
154 chip_name = "navi10";
160 snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_smc.bin", chip_name);
162 err = request_firmware(&adev->pm.fw, fw_name, adev->dev);
165 err = amdgpu_ucode_validate(adev->pm.fw);
169 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
170 amdgpu_ucode_print_smc_hdr(&hdr->header);
171 adev->pm.fw_version = le32_to_cpu(hdr->header.ucode_version);
173 if (adev->firmware.load_type == AMDGPU_FW_LOAD_PSP) {
174 ucode = &adev->firmware.ucode[AMDGPU_UCODE_ID_SMC];
175 ucode->ucode_id = AMDGPU_UCODE_ID_SMC;
176 ucode->fw = adev->pm.fw;
177 header = (const struct common_firmware_header *)ucode->fw->data;
178 adev->firmware.fw_size +=
179 ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);
184 DRM_ERROR("smu_v11_0: Failed to load firmware \"%s\"\n",
186 release_firmware(adev->pm.fw);
192 static int smu_v11_0_load_microcode(struct smu_context *smu)
194 struct amdgpu_device *adev = smu->adev;
196 const struct smc_firmware_header_v1_0 *hdr;
197 uint32_t addr_start = MP1_SRAM;
199 uint32_t mp1_fw_flags;
201 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
202 src = (const uint32_t *)(adev->pm.fw->data +
203 le32_to_cpu(hdr->header.ucode_array_offset_bytes));
205 for (i = 1; i < MP1_SMC_SIZE/4 - 1; i++) {
206 WREG32_PCIE(addr_start, src[i]);
210 WREG32_PCIE(MP1_Public | (smnMP1_PUB_CTRL & 0xffffffff),
211 1 & MP1_SMN_PUB_CTRL__RESET_MASK);
212 WREG32_PCIE(MP1_Public | (smnMP1_PUB_CTRL & 0xffffffff),
213 1 & ~MP1_SMN_PUB_CTRL__RESET_MASK);
215 for (i = 0; i < adev->usec_timeout; i++) {
216 mp1_fw_flags = RREG32_PCIE(MP1_Public |
217 (smnMP1_FIRMWARE_FLAGS & 0xffffffff));
218 if ((mp1_fw_flags & MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED_MASK) >>
219 MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED__SHIFT)
224 if (i == adev->usec_timeout)
230 static int smu_v11_0_check_fw_status(struct smu_context *smu)
232 struct amdgpu_device *adev = smu->adev;
233 uint32_t mp1_fw_flags;
235 mp1_fw_flags = RREG32_PCIE(MP1_Public |
236 (smnMP1_FIRMWARE_FLAGS & 0xffffffff));
238 if ((mp1_fw_flags & MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED_MASK) >>
239 MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED__SHIFT)
245 static int smu_v11_0_check_fw_version(struct smu_context *smu)
247 uint32_t if_version = 0xff, smu_version = 0xff;
249 uint8_t smu_minor, smu_debug;
252 ret = smu_get_smc_version(smu, &if_version, &smu_version);
256 smu_major = (smu_version >> 16) & 0xffff;
257 smu_minor = (smu_version >> 8) & 0xff;
258 smu_debug = (smu_version >> 0) & 0xff;
260 pr_info("SMU Driver IF Version = 0x%08x, SMU FW Version = 0x%08x (%d.%d.%d)\n",
261 if_version, smu_version, smu_major, smu_minor, smu_debug);
263 if (if_version != smu->smc_if_version) {
264 pr_err("SMU driver if version not matched\n");
271 static int smu_v11_0_set_pptable_v2_0(struct smu_context *smu, void **table, uint32_t *size)
273 struct amdgpu_device *adev = smu->adev;
274 uint32_t ppt_offset_bytes;
275 const struct smc_firmware_header_v2_0 *v2;
277 v2 = (const struct smc_firmware_header_v2_0 *) adev->pm.fw->data;
279 ppt_offset_bytes = le32_to_cpu(v2->ppt_offset_bytes);
280 *size = le32_to_cpu(v2->ppt_size_bytes);
281 *table = (uint8_t *)v2 + ppt_offset_bytes;
286 static int smu_v11_0_set_pptable_v2_1(struct smu_context *smu, void **table, uint32_t *size, uint32_t pptable_id)
288 struct amdgpu_device *adev = smu->adev;
289 const struct smc_firmware_header_v2_1 *v2_1;
290 struct smc_soft_pptable_entry *entries;
291 uint32_t pptable_count = 0;
294 v2_1 = (const struct smc_firmware_header_v2_1 *) adev->pm.fw->data;
295 entries = (struct smc_soft_pptable_entry *)
296 ((uint8_t *)v2_1 + le32_to_cpu(v2_1->pptable_entry_offset));
297 pptable_count = le32_to_cpu(v2_1->pptable_count);
298 for (i = 0; i < pptable_count; i++) {
299 if (le32_to_cpu(entries[i].id) == pptable_id) {
300 *table = ((uint8_t *)v2_1 + le32_to_cpu(entries[i].ppt_offset_bytes));
301 *size = le32_to_cpu(entries[i].ppt_size_bytes);
306 if (i == pptable_count)
312 static int smu_v11_0_setup_pptable(struct smu_context *smu)
314 struct amdgpu_device *adev = smu->adev;
315 const struct smc_firmware_header_v1_0 *hdr;
320 uint16_t version_major, version_minor;
322 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
323 version_major = le16_to_cpu(hdr->header.header_version_major);
324 version_minor = le16_to_cpu(hdr->header.header_version_minor);
325 if (version_major == 2 && smu->smu_table.boot_values.pp_table_id > 0) {
326 switch (version_minor) {
328 ret = smu_v11_0_set_pptable_v2_0(smu, &table, &size);
331 ret = smu_v11_0_set_pptable_v2_1(smu, &table, &size,
332 smu->smu_table.boot_values.pp_table_id);
342 index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1,
345 ret = smu_get_atom_data_table(smu, index, (uint16_t *)&size, &frev, &crev,
351 if (!smu->smu_table.power_play_table)
352 smu->smu_table.power_play_table = table;
353 if (!smu->smu_table.power_play_table_size)
354 smu->smu_table.power_play_table_size = size;
359 static int smu_v11_0_init_dpm_context(struct smu_context *smu)
361 struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
363 if (smu_dpm->dpm_context || smu_dpm->dpm_context_size != 0)
366 return smu_alloc_dpm_context(smu);
369 static int smu_v11_0_fini_dpm_context(struct smu_context *smu)
371 struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
373 if (!smu_dpm->dpm_context || smu_dpm->dpm_context_size == 0)
376 kfree(smu_dpm->dpm_context);
377 kfree(smu_dpm->golden_dpm_context);
378 kfree(smu_dpm->dpm_current_power_state);
379 kfree(smu_dpm->dpm_request_power_state);
380 smu_dpm->dpm_context = NULL;
381 smu_dpm->golden_dpm_context = NULL;
382 smu_dpm->dpm_context_size = 0;
383 smu_dpm->dpm_current_power_state = NULL;
384 smu_dpm->dpm_request_power_state = NULL;
389 static int smu_v11_0_init_smc_tables(struct smu_context *smu)
391 struct smu_table_context *smu_table = &smu->smu_table;
392 struct smu_table *tables = NULL;
395 if (smu_table->tables || smu_table->table_count == 0)
398 tables = kcalloc(SMU_TABLE_COUNT, sizeof(struct smu_table),
403 smu_table->tables = tables;
405 ret = smu_tables_init(smu, tables);
409 ret = smu_v11_0_init_dpm_context(smu);
416 static int smu_v11_0_fini_smc_tables(struct smu_context *smu)
418 struct smu_table_context *smu_table = &smu->smu_table;
421 if (!smu_table->tables || smu_table->table_count == 0)
424 kfree(smu_table->tables);
425 kfree(smu_table->metrics_table);
426 smu_table->tables = NULL;
427 smu_table->table_count = 0;
428 smu_table->metrics_table = NULL;
429 smu_table->metrics_time = 0;
431 ret = smu_v11_0_fini_dpm_context(smu);
437 static int smu_v11_0_init_power(struct smu_context *smu)
439 struct smu_power_context *smu_power = &smu->smu_power;
441 if (!smu->pm_enabled)
443 if (smu_power->power_context || smu_power->power_context_size != 0)
446 smu_power->power_context = kzalloc(sizeof(struct smu_11_0_dpm_context),
448 if (!smu_power->power_context)
450 smu_power->power_context_size = sizeof(struct smu_11_0_dpm_context);
455 static int smu_v11_0_fini_power(struct smu_context *smu)
457 struct smu_power_context *smu_power = &smu->smu_power;
459 if (!smu->pm_enabled)
461 if (!smu_power->power_context || smu_power->power_context_size == 0)
464 kfree(smu_power->power_context);
465 smu_power->power_context = NULL;
466 smu_power->power_context_size = 0;
471 int smu_v11_0_get_vbios_bootup_values(struct smu_context *smu)
476 struct atom_common_table_header *header;
477 struct atom_firmware_info_v3_3 *v_3_3;
478 struct atom_firmware_info_v3_1 *v_3_1;
480 index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1,
483 ret = smu_get_atom_data_table(smu, index, &size, &frev, &crev,
484 (uint8_t **)&header);
488 if (header->format_revision != 3) {
489 pr_err("unknown atom_firmware_info version! for smu11\n");
493 switch (header->content_revision) {
497 v_3_1 = (struct atom_firmware_info_v3_1 *)header;
498 smu->smu_table.boot_values.revision = v_3_1->firmware_revision;
499 smu->smu_table.boot_values.gfxclk = v_3_1->bootup_sclk_in10khz;
500 smu->smu_table.boot_values.uclk = v_3_1->bootup_mclk_in10khz;
501 smu->smu_table.boot_values.socclk = 0;
502 smu->smu_table.boot_values.dcefclk = 0;
503 smu->smu_table.boot_values.vddc = v_3_1->bootup_vddc_mv;
504 smu->smu_table.boot_values.vddci = v_3_1->bootup_vddci_mv;
505 smu->smu_table.boot_values.mvddc = v_3_1->bootup_mvddc_mv;
506 smu->smu_table.boot_values.vdd_gfx = v_3_1->bootup_vddgfx_mv;
507 smu->smu_table.boot_values.cooling_id = v_3_1->coolingsolution_id;
508 smu->smu_table.boot_values.pp_table_id = 0;
512 v_3_3 = (struct atom_firmware_info_v3_3 *)header;
513 smu->smu_table.boot_values.revision = v_3_3->firmware_revision;
514 smu->smu_table.boot_values.gfxclk = v_3_3->bootup_sclk_in10khz;
515 smu->smu_table.boot_values.uclk = v_3_3->bootup_mclk_in10khz;
516 smu->smu_table.boot_values.socclk = 0;
517 smu->smu_table.boot_values.dcefclk = 0;
518 smu->smu_table.boot_values.vddc = v_3_3->bootup_vddc_mv;
519 smu->smu_table.boot_values.vddci = v_3_3->bootup_vddci_mv;
520 smu->smu_table.boot_values.mvddc = v_3_3->bootup_mvddc_mv;
521 smu->smu_table.boot_values.vdd_gfx = v_3_3->bootup_vddgfx_mv;
522 smu->smu_table.boot_values.cooling_id = v_3_3->coolingsolution_id;
523 smu->smu_table.boot_values.pp_table_id = v_3_3->pplib_pptable_id;
529 static int smu_v11_0_get_clk_info_from_vbios(struct smu_context *smu)
532 struct amdgpu_device *adev = smu->adev;
533 struct atom_get_smu_clock_info_parameters_v3_1 input = {0};
534 struct atom_get_smu_clock_info_output_parameters_v3_1 *output;
536 input.clk_id = SMU11_SYSPLL0_SOCCLK_ID;
537 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
538 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
541 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
546 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
547 smu->smu_table.boot_values.socclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
549 memset(&input, 0, sizeof(input));
550 input.clk_id = SMU11_SYSPLL0_DCEFCLK_ID;
551 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
552 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
555 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
560 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
561 smu->smu_table.boot_values.dcefclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
563 memset(&input, 0, sizeof(input));
564 input.clk_id = SMU11_SYSPLL0_ECLK_ID;
565 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
566 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
569 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
574 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
575 smu->smu_table.boot_values.eclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
577 memset(&input, 0, sizeof(input));
578 input.clk_id = SMU11_SYSPLL0_VCLK_ID;
579 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
580 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
583 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
588 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
589 smu->smu_table.boot_values.vclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
591 memset(&input, 0, sizeof(input));
592 input.clk_id = SMU11_SYSPLL0_DCLK_ID;
593 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
594 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
597 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
602 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
603 smu->smu_table.boot_values.dclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
608 static int smu_v11_0_notify_memory_pool_location(struct smu_context *smu)
610 struct smu_table_context *smu_table = &smu->smu_table;
611 struct smu_table *memory_pool = &smu_table->memory_pool;
614 uint32_t address_low, address_high;
616 if (memory_pool->size == 0 || memory_pool->cpu_addr == NULL)
619 address = (uintptr_t)memory_pool->cpu_addr;
620 address_high = (uint32_t)upper_32_bits(address);
621 address_low = (uint32_t)lower_32_bits(address);
623 ret = smu_send_smc_msg_with_param(smu,
624 SMU_MSG_SetSystemVirtualDramAddrHigh,
628 ret = smu_send_smc_msg_with_param(smu,
629 SMU_MSG_SetSystemVirtualDramAddrLow,
634 address = memory_pool->mc_address;
635 address_high = (uint32_t)upper_32_bits(address);
636 address_low = (uint32_t)lower_32_bits(address);
638 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramAddrHigh,
642 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramAddrLow,
646 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramSize,
647 (uint32_t)memory_pool->size);
654 static int smu_v11_0_check_pptable(struct smu_context *smu)
658 ret = smu_check_powerplay_table(smu);
662 static int smu_v11_0_parse_pptable(struct smu_context *smu)
666 struct smu_table_context *table_context = &smu->smu_table;
667 struct smu_table *table = &table_context->tables[SMU_TABLE_PPTABLE];
669 if (table_context->driver_pptable)
672 table_context->driver_pptable = kzalloc(table->size, GFP_KERNEL);
674 if (!table_context->driver_pptable)
677 ret = smu_store_powerplay_table(smu);
681 ret = smu_append_powerplay_table(smu);
686 static int smu_v11_0_populate_smc_pptable(struct smu_context *smu)
690 ret = smu_set_default_dpm_table(smu);
695 static int smu_v11_0_write_pptable(struct smu_context *smu)
697 struct smu_table_context *table_context = &smu->smu_table;
700 ret = smu_update_table(smu, SMU_TABLE_PPTABLE,
701 table_context->driver_pptable, true);
706 static int smu_v11_0_write_watermarks_table(struct smu_context *smu)
709 struct smu_table_context *smu_table = &smu->smu_table;
710 struct smu_table *table = NULL;
712 table = &smu_table->tables[SMU_TABLE_WATERMARKS];
716 if (!table->cpu_addr)
719 ret = smu_update_table(smu, SMU_TABLE_WATERMARKS, table->cpu_addr,
725 static int smu_v11_0_set_deep_sleep_dcefclk(struct smu_context *smu, uint32_t clk)
729 ret = smu_send_smc_msg_with_param(smu,
730 SMU_MSG_SetMinDeepSleepDcefclk, clk);
732 pr_err("SMU11 attempt to set divider for DCEFCLK Failed!");
737 static int smu_v11_0_set_min_dcef_deep_sleep(struct smu_context *smu)
739 struct smu_table_context *table_context = &smu->smu_table;
741 if (!smu->pm_enabled)
746 return smu_set_deep_sleep_dcefclk(smu,
747 table_context->boot_values.dcefclk / 100);
750 static int smu_v11_0_set_tool_table_location(struct smu_context *smu)
753 struct smu_table *tool_table = &smu->smu_table.tables[SMU_TABLE_PMSTATUSLOG];
755 if (tool_table->mc_address) {
756 ret = smu_send_smc_msg_with_param(smu,
757 SMU_MSG_SetToolsDramAddrHigh,
758 upper_32_bits(tool_table->mc_address));
760 ret = smu_send_smc_msg_with_param(smu,
761 SMU_MSG_SetToolsDramAddrLow,
762 lower_32_bits(tool_table->mc_address));
768 static int smu_v11_0_init_display_count(struct smu_context *smu, uint32_t count)
772 if (!smu->pm_enabled)
774 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_NumOfDisplays, count);
778 static int smu_v11_0_update_feature_enable_state(struct smu_context *smu, uint32_t feature_id, bool enabled)
780 uint32_t feature_low = 0, feature_high = 0;
783 if (!smu->pm_enabled)
785 if (feature_id >= 0 && feature_id < 31)
786 feature_low = (1 << feature_id);
787 else if (feature_id > 31 && feature_id < 63)
788 feature_high = (1 << feature_id);
793 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesLow,
797 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesHigh,
803 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesLow,
807 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesHigh,
817 static int smu_v11_0_set_allowed_mask(struct smu_context *smu)
819 struct smu_feature *feature = &smu->smu_feature;
821 uint32_t feature_mask[2];
823 mutex_lock(&feature->mutex);
824 if (bitmap_empty(feature->allowed, SMU_FEATURE_MAX) || feature->feature_num < 64)
827 bitmap_copy((unsigned long *)feature_mask, feature->allowed, 64);
829 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskHigh,
834 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskLow,
840 mutex_unlock(&feature->mutex);
844 static int smu_v11_0_get_enabled_mask(struct smu_context *smu,
845 uint32_t *feature_mask, uint32_t num)
847 uint32_t feature_mask_high = 0, feature_mask_low = 0;
850 if (!feature_mask || num < 2)
853 ret = smu_send_smc_msg(smu, SMU_MSG_GetEnabledSmuFeaturesHigh);
856 ret = smu_read_smc_arg(smu, &feature_mask_high);
860 ret = smu_send_smc_msg(smu, SMU_MSG_GetEnabledSmuFeaturesLow);
863 ret = smu_read_smc_arg(smu, &feature_mask_low);
867 feature_mask[0] = feature_mask_low;
868 feature_mask[1] = feature_mask_high;
873 static int smu_v11_0_system_features_control(struct smu_context *smu,
876 struct smu_feature *feature = &smu->smu_feature;
877 uint32_t feature_mask[2];
880 if (smu->pm_enabled) {
881 ret = smu_send_smc_msg(smu, (en ? SMU_MSG_EnableAllSmuFeatures :
882 SMU_MSG_DisableAllSmuFeatures));
887 ret = smu_feature_get_enabled_mask(smu, feature_mask, 2);
891 bitmap_copy(feature->enabled, (unsigned long *)&feature_mask,
892 feature->feature_num);
893 bitmap_copy(feature->supported, (unsigned long *)&feature_mask,
894 feature->feature_num);
899 static int smu_v11_0_notify_display_change(struct smu_context *smu)
903 if (!smu->pm_enabled)
905 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_UCLK_BIT) &&
906 smu->adev->gmc.vram_type == AMDGPU_VRAM_TYPE_HBM)
907 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetUclkFastSwitch, 1);
913 smu_v11_0_get_max_sustainable_clock(struct smu_context *smu, uint32_t *clock,
914 enum smu_clk_type clock_select)
918 if (!smu->pm_enabled)
920 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetDcModeMaxDpmFreq,
921 smu_clk_get_index(smu, clock_select) << 16);
923 pr_err("[GetMaxSustainableClock] Failed to get max DC clock from SMC!");
927 ret = smu_read_smc_arg(smu, clock);
934 /* if DC limit is zero, return AC limit */
935 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMaxDpmFreq,
936 smu_clk_get_index(smu, clock_select) << 16);
938 pr_err("[GetMaxSustainableClock] failed to get max AC clock from SMC!");
942 ret = smu_read_smc_arg(smu, clock);
947 static int smu_v11_0_init_max_sustainable_clocks(struct smu_context *smu)
949 struct smu_11_0_max_sustainable_clocks *max_sustainable_clocks;
952 max_sustainable_clocks = kzalloc(sizeof(struct smu_11_0_max_sustainable_clocks),
954 smu->smu_table.max_sustainable_clocks = (void *)max_sustainable_clocks;
956 max_sustainable_clocks->uclock = smu->smu_table.boot_values.uclk / 100;
957 max_sustainable_clocks->soc_clock = smu->smu_table.boot_values.socclk / 100;
958 max_sustainable_clocks->dcef_clock = smu->smu_table.boot_values.dcefclk / 100;
959 max_sustainable_clocks->display_clock = 0xFFFFFFFF;
960 max_sustainable_clocks->phy_clock = 0xFFFFFFFF;
961 max_sustainable_clocks->pixel_clock = 0xFFFFFFFF;
963 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_UCLK_BIT)) {
964 ret = smu_v11_0_get_max_sustainable_clock(smu,
965 &(max_sustainable_clocks->uclock),
968 pr_err("[%s] failed to get max UCLK from SMC!",
974 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {
975 ret = smu_v11_0_get_max_sustainable_clock(smu,
976 &(max_sustainable_clocks->soc_clock),
979 pr_err("[%s] failed to get max SOCCLK from SMC!",
985 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT)) {
986 ret = smu_v11_0_get_max_sustainable_clock(smu,
987 &(max_sustainable_clocks->dcef_clock),
990 pr_err("[%s] failed to get max DCEFCLK from SMC!",
995 ret = smu_v11_0_get_max_sustainable_clock(smu,
996 &(max_sustainable_clocks->display_clock),
999 pr_err("[%s] failed to get max DISPCLK from SMC!",
1003 ret = smu_v11_0_get_max_sustainable_clock(smu,
1004 &(max_sustainable_clocks->phy_clock),
1007 pr_err("[%s] failed to get max PHYCLK from SMC!",
1011 ret = smu_v11_0_get_max_sustainable_clock(smu,
1012 &(max_sustainable_clocks->pixel_clock),
1015 pr_err("[%s] failed to get max PIXCLK from SMC!",
1021 if (max_sustainable_clocks->soc_clock < max_sustainable_clocks->uclock)
1022 max_sustainable_clocks->uclock = max_sustainable_clocks->soc_clock;
1027 static int smu_v11_0_get_power_limit(struct smu_context *smu,
1034 mutex_lock(&smu->mutex);
1035 *limit = smu->default_power_limit;
1036 if (smu->od_enabled) {
1037 *limit *= (100 + smu->smu_table.TDPODLimit);
1040 mutex_unlock(&smu->mutex);
1042 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetPptLimit,
1043 smu_power_get_index(smu, SMU_POWER_SOURCE_AC) << 16);
1045 pr_err("[%s] get PPT limit failed!", __func__);
1048 smu_read_smc_arg(smu, limit);
1049 smu->power_limit = *limit;
1055 static int smu_v11_0_set_power_limit(struct smu_context *smu, uint32_t n)
1057 uint32_t max_power_limit;
1061 n = smu->default_power_limit;
1063 max_power_limit = smu->default_power_limit;
1065 if (smu->od_enabled) {
1066 max_power_limit *= (100 + smu->smu_table.TDPODLimit);
1067 max_power_limit /= 100;
1070 if (smu_feature_is_enabled(smu, SMU_FEATURE_PPT_BIT))
1071 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetPptLimit, n);
1073 pr_err("[%s] Set power limit Failed!", __func__);
1080 static int smu_v11_0_get_current_clk_freq(struct smu_context *smu,
1081 enum smu_clk_type clk_id,
1087 if (clk_id >= SMU_CLK_COUNT || !value)
1090 /* if don't has GetDpmClockFreq Message, try get current clock by SmuMetrics_t */
1091 if (smu_msg_get_index(smu, SMU_MSG_GetDpmClockFreq) == 0)
1092 ret = smu_get_current_clk_freq_by_table(smu, clk_id, &freq);
1094 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetDpmClockFreq,
1095 (smu_clk_get_index(smu, clk_id) << 16));
1099 ret = smu_read_smc_arg(smu, &freq);
1110 static int smu_v11_0_set_thermal_range(struct smu_context *smu,
1111 struct smu_temperature_range *range)
1113 struct amdgpu_device *adev = smu->adev;
1114 int low = SMU_THERMAL_MINIMUM_ALERT_TEMP *
1115 SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
1116 int high = SMU_THERMAL_MAXIMUM_ALERT_TEMP *
1117 SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
1123 if (low < range->min)
1125 if (high > range->max)
1131 val = RREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_CTRL);
1132 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, MAX_IH_CREDIT, 5);
1133 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, THERM_IH_HW_ENA, 1);
1134 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, THERM_INTH_MASK, 0);
1135 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, THERM_INTL_MASK, 0);
1136 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, DIG_THERM_INTH, (high / SMU_TEMPERATURE_UNITS_PER_CENTIGRADES));
1137 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, DIG_THERM_INTL, (low / SMU_TEMPERATURE_UNITS_PER_CENTIGRADES));
1138 val = val & (~THM_THERMAL_INT_CTRL__THERM_TRIGGER_MASK_MASK);
1140 WREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_CTRL, val);
1145 static int smu_v11_0_enable_thermal_alert(struct smu_context *smu)
1147 struct amdgpu_device *adev = smu->adev;
1150 val |= (1 << THM_THERMAL_INT_ENA__THERM_INTH_CLR__SHIFT);
1151 val |= (1 << THM_THERMAL_INT_ENA__THERM_INTL_CLR__SHIFT);
1152 val |= (1 << THM_THERMAL_INT_ENA__THERM_TRIGGER_CLR__SHIFT);
1154 WREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_ENA, val);
1159 static int smu_v11_0_start_thermal_control(struct smu_context *smu)
1162 struct smu_temperature_range range = {
1172 struct amdgpu_device *adev = smu->adev;
1174 if (!smu->pm_enabled)
1176 ret = smu_get_thermal_temperature_range(smu, &range);
1178 if (smu->smu_table.thermal_controller_type) {
1179 ret = smu_v11_0_set_thermal_range(smu, &range);
1183 ret = smu_v11_0_enable_thermal_alert(smu);
1187 ret = smu_set_thermal_fan_table(smu);
1192 adev->pm.dpm.thermal.min_temp = range.min;
1193 adev->pm.dpm.thermal.max_temp = range.max;
1194 adev->pm.dpm.thermal.max_edge_emergency_temp = range.edge_emergency_max;
1195 adev->pm.dpm.thermal.min_hotspot_temp = range.hotspot_min;
1196 adev->pm.dpm.thermal.max_hotspot_crit_temp = range.hotspot_crit_max;
1197 adev->pm.dpm.thermal.max_hotspot_emergency_temp = range.hotspot_emergency_max;
1198 adev->pm.dpm.thermal.min_mem_temp = range.mem_min;
1199 adev->pm.dpm.thermal.max_mem_crit_temp = range.mem_crit_max;
1200 adev->pm.dpm.thermal.max_mem_emergency_temp = range.mem_emergency_max;
1205 static uint16_t convert_to_vddc(uint8_t vid)
1207 return (uint16_t) ((6200 - (vid * 25)) / SMU11_VOLTAGE_SCALE);
1210 static int smu_v11_0_get_gfx_vdd(struct smu_context *smu, uint32_t *value)
1212 struct amdgpu_device *adev = smu->adev;
1213 uint32_t vdd = 0, val_vid = 0;
1217 val_vid = (RREG32_SOC15(SMUIO, 0, mmSMUSVI0_TEL_PLANE0) &
1218 SMUSVI0_TEL_PLANE0__SVI0_PLANE0_VDDCOR_MASK) >>
1219 SMUSVI0_TEL_PLANE0__SVI0_PLANE0_VDDCOR__SHIFT;
1221 vdd = (uint32_t)convert_to_vddc((uint8_t)val_vid);
1229 static int smu_v11_0_read_sensor(struct smu_context *smu,
1230 enum amd_pp_sensors sensor,
1231 void *data, uint32_t *size)
1235 case AMDGPU_PP_SENSOR_GFX_MCLK:
1236 ret = smu_get_current_clk_freq(smu, SMU_UCLK, (uint32_t *)data);
1239 case AMDGPU_PP_SENSOR_GFX_SCLK:
1240 ret = smu_get_current_clk_freq(smu, SMU_GFXCLK, (uint32_t *)data);
1243 case AMDGPU_PP_SENSOR_VDDGFX:
1244 ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
1247 case AMDGPU_PP_SENSOR_MIN_FAN_RPM:
1248 *(uint32_t *)data = 0;
1252 ret = smu_common_read_sensor(smu, sensor, data, size);
1256 /* try get sensor data by asic */
1258 ret = smu_asic_read_sensor(smu, sensor, data, size);
1267 smu_v11_0_display_clock_voltage_request(struct smu_context *smu,
1268 struct pp_display_clock_request
1271 enum amd_pp_clock_type clk_type = clock_req->clock_type;
1273 enum smu_clk_type clk_select = 0;
1274 uint32_t clk_freq = clock_req->clock_freq_in_khz / 1000;
1276 if (!smu->pm_enabled)
1278 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT) ||
1279 smu_feature_is_enabled(smu, SMU_FEATURE_DPM_UCLK_BIT)) {
1281 case amd_pp_dcef_clock:
1282 clk_select = SMU_DCEFCLK;
1284 case amd_pp_disp_clock:
1285 clk_select = SMU_DISPCLK;
1287 case amd_pp_pixel_clock:
1288 clk_select = SMU_PIXCLK;
1290 case amd_pp_phy_clock:
1291 clk_select = SMU_PHYCLK;
1293 case amd_pp_mem_clock:
1294 clk_select = SMU_UCLK;
1297 pr_info("[%s] Invalid Clock Type!", __func__);
1305 mutex_lock(&smu->mutex);
1306 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetHardMinByFreq,
1307 (smu_clk_get_index(smu, clk_select) << 16) | clk_freq);
1308 mutex_unlock(&smu->mutex);
1316 smu_v11_0_set_watermarks_for_clock_ranges(struct smu_context *smu, struct
1317 dm_pp_wm_sets_with_clock_ranges_soc15
1321 struct smu_table *watermarks = &smu->smu_table.tables[SMU_TABLE_WATERMARKS];
1322 void *table = watermarks->cpu_addr;
1324 if (!smu->disable_watermark &&
1325 smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT) &&
1326 smu_feature_is_enabled(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {
1327 smu_set_watermarks_table(smu, table, clock_ranges);
1328 smu->watermarks_bitmap |= WATERMARKS_EXIST;
1329 smu->watermarks_bitmap &= ~WATERMARKS_LOADED;
1335 static int smu_v11_0_gfx_off_control(struct smu_context *smu, bool enable)
1338 struct amdgpu_device *adev = smu->adev;
1340 switch (adev->asic_type) {
1344 if (!(adev->pm.pp_feature & PP_GFXOFF_MASK))
1346 mutex_lock(&smu->mutex);
1348 ret = smu_send_smc_msg(smu, SMU_MSG_AllowGfxOff);
1350 ret = smu_send_smc_msg(smu, SMU_MSG_DisallowGfxOff);
1351 mutex_unlock(&smu->mutex);
1360 static int smu_v11_0_get_current_rpm(struct smu_context *smu,
1361 uint32_t *current_rpm)
1365 ret = smu_send_smc_msg(smu, SMU_MSG_GetCurrentRpm);
1368 pr_err("Attempt to get current RPM from SMC Failed!\n");
1372 smu_read_smc_arg(smu, current_rpm);
1378 smu_v11_0_get_fan_control_mode(struct smu_context *smu)
1380 if (!smu_feature_is_enabled(smu, SMU_FEATURE_FAN_CONTROL_BIT))
1381 return AMD_FAN_CTRL_MANUAL;
1383 return AMD_FAN_CTRL_AUTO;
1387 smu_v11_0_smc_fan_control(struct smu_context *smu, bool start)
1391 if (smu_feature_is_supported(smu, SMU_FEATURE_FAN_CONTROL_BIT))
1394 ret = smu_feature_set_enabled(smu, SMU_FEATURE_FAN_CONTROL_BIT, start);
1396 pr_err("[%s]%s smc FAN CONTROL feature failed!",
1397 __func__, (start ? "Start" : "Stop"));
1403 smu_v11_0_set_fan_static_mode(struct smu_context *smu, uint32_t mode)
1405 struct amdgpu_device *adev = smu->adev;
1407 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL2,
1408 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL2),
1409 CG_FDO_CTRL2, TMIN, 0));
1410 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL2,
1411 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL2),
1412 CG_FDO_CTRL2, FDO_PWM_MODE, mode));
1418 smu_v11_0_set_fan_speed_percent(struct smu_context *smu, uint32_t speed)
1420 struct amdgpu_device *adev = smu->adev;
1429 if (smu_v11_0_smc_fan_control(smu, stop))
1431 duty100 = REG_GET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL1),
1432 CG_FDO_CTRL1, FMAX_DUTY100);
1436 tmp64 = (uint64_t)speed * duty100;
1438 duty = (uint32_t)tmp64;
1440 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL0,
1441 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL0),
1442 CG_FDO_CTRL0, FDO_STATIC_DUTY, duty));
1444 return smu_v11_0_set_fan_static_mode(smu, FDO_PWM_MODE_STATIC);
1448 smu_v11_0_set_fan_control_mode(struct smu_context *smu,
1456 case AMD_FAN_CTRL_NONE:
1457 ret = smu_v11_0_set_fan_speed_percent(smu, 100);
1459 case AMD_FAN_CTRL_MANUAL:
1460 ret = smu_v11_0_smc_fan_control(smu, stop);
1462 case AMD_FAN_CTRL_AUTO:
1463 ret = smu_v11_0_smc_fan_control(smu, start);
1470 pr_err("[%s]Set fan control mode failed!", __func__);
1477 static int smu_v11_0_set_fan_speed_rpm(struct smu_context *smu,
1480 struct amdgpu_device *adev = smu->adev;
1482 uint32_t tach_period, crystal_clock_freq;
1488 mutex_lock(&(smu->mutex));
1489 ret = smu_v11_0_smc_fan_control(smu, stop);
1491 goto set_fan_speed_rpm_failed;
1493 crystal_clock_freq = amdgpu_asic_get_xclk(adev);
1494 tach_period = 60 * crystal_clock_freq * 10000 / (8 * speed);
1495 WREG32_SOC15(THM, 0, mmCG_TACH_CTRL,
1496 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_TACH_CTRL),
1497 CG_TACH_CTRL, TARGET_PERIOD,
1500 ret = smu_v11_0_set_fan_static_mode(smu, FDO_PWM_MODE_STATIC_RPM);
1502 set_fan_speed_rpm_failed:
1503 mutex_unlock(&(smu->mutex));
1507 #define XGMI_STATE_D0 1
1508 #define XGMI_STATE_D3 0
1510 static int smu_v11_0_set_xgmi_pstate(struct smu_context *smu,
1514 mutex_lock(&(smu->mutex));
1515 ret = smu_send_smc_msg_with_param(smu,
1516 SMU_MSG_SetXgmiMode,
1517 pstate ? XGMI_STATE_D0 : XGMI_STATE_D3);
1518 mutex_unlock(&(smu->mutex));
1522 #define THM_11_0__SRCID__THM_DIG_THERM_L2H 0 /* ASIC_TEMP > CG_THERMAL_INT.DIG_THERM_INTH */
1523 #define THM_11_0__SRCID__THM_DIG_THERM_H2L 1 /* ASIC_TEMP < CG_THERMAL_INT.DIG_THERM_INTL */
1525 static int smu_v11_0_irq_process(struct amdgpu_device *adev,
1526 struct amdgpu_irq_src *source,
1527 struct amdgpu_iv_entry *entry)
1529 uint32_t client_id = entry->client_id;
1530 uint32_t src_id = entry->src_id;
1532 if (client_id == SOC15_IH_CLIENTID_THM) {
1534 case THM_11_0__SRCID__THM_DIG_THERM_L2H:
1535 pr_warn("GPU over temperature range detected on PCIe %d:%d.%d!\n",
1536 PCI_BUS_NUM(adev->pdev->devfn),
1537 PCI_SLOT(adev->pdev->devfn),
1538 PCI_FUNC(adev->pdev->devfn));
1540 case THM_11_0__SRCID__THM_DIG_THERM_H2L:
1541 pr_warn("GPU under temperature range detected on PCIe %d:%d.%d!\n",
1542 PCI_BUS_NUM(adev->pdev->devfn),
1543 PCI_SLOT(adev->pdev->devfn),
1544 PCI_FUNC(adev->pdev->devfn));
1547 pr_warn("GPU under temperature range unknown src id (%d), detected on PCIe %d:%d.%d!\n",
1549 PCI_BUS_NUM(adev->pdev->devfn),
1550 PCI_SLOT(adev->pdev->devfn),
1551 PCI_FUNC(adev->pdev->devfn));
1560 static const struct amdgpu_irq_src_funcs smu_v11_0_irq_funcs =
1562 .process = smu_v11_0_irq_process,
1565 static int smu_v11_0_register_irq_handler(struct smu_context *smu)
1567 struct amdgpu_device *adev = smu->adev;
1568 struct amdgpu_irq_src *irq_src = smu->irq_source;
1571 /* already register */
1575 irq_src = kzalloc(sizeof(struct amdgpu_irq_src), GFP_KERNEL);
1578 smu->irq_source = irq_src;
1580 irq_src->funcs = &smu_v11_0_irq_funcs;
1582 ret = amdgpu_irq_add_id(adev, SOC15_IH_CLIENTID_THM,
1583 THM_11_0__SRCID__THM_DIG_THERM_L2H,
1588 ret = amdgpu_irq_add_id(adev, SOC15_IH_CLIENTID_THM,
1589 THM_11_0__SRCID__THM_DIG_THERM_H2L,
1597 static int smu_v11_0_set_azalia_d3_pme(struct smu_context *smu)
1601 mutex_lock(&smu->mutex);
1602 ret = smu_send_smc_msg(smu, SMU_MSG_BacoAudioD3PME);
1603 mutex_unlock(&smu->mutex);
1608 static const struct smu_funcs smu_v11_0_funcs = {
1609 .init_microcode = smu_v11_0_init_microcode,
1610 .load_microcode = smu_v11_0_load_microcode,
1611 .check_fw_status = smu_v11_0_check_fw_status,
1612 .check_fw_version = smu_v11_0_check_fw_version,
1613 .send_smc_msg = smu_v11_0_send_msg,
1614 .send_smc_msg_with_param = smu_v11_0_send_msg_with_param,
1615 .read_smc_arg = smu_v11_0_read_arg,
1616 .setup_pptable = smu_v11_0_setup_pptable,
1617 .init_smc_tables = smu_v11_0_init_smc_tables,
1618 .fini_smc_tables = smu_v11_0_fini_smc_tables,
1619 .init_power = smu_v11_0_init_power,
1620 .fini_power = smu_v11_0_fini_power,
1621 .get_vbios_bootup_values = smu_v11_0_get_vbios_bootup_values,
1622 .get_clk_info_from_vbios = smu_v11_0_get_clk_info_from_vbios,
1623 .notify_memory_pool_location = smu_v11_0_notify_memory_pool_location,
1624 .check_pptable = smu_v11_0_check_pptable,
1625 .parse_pptable = smu_v11_0_parse_pptable,
1626 .populate_smc_pptable = smu_v11_0_populate_smc_pptable,
1627 .write_pptable = smu_v11_0_write_pptable,
1628 .write_watermarks_table = smu_v11_0_write_watermarks_table,
1629 .set_min_dcef_deep_sleep = smu_v11_0_set_min_dcef_deep_sleep,
1630 .set_tool_table_location = smu_v11_0_set_tool_table_location,
1631 .init_display_count = smu_v11_0_init_display_count,
1632 .set_allowed_mask = smu_v11_0_set_allowed_mask,
1633 .get_enabled_mask = smu_v11_0_get_enabled_mask,
1634 .system_features_control = smu_v11_0_system_features_control,
1635 .update_feature_enable_state = smu_v11_0_update_feature_enable_state,
1636 .notify_display_change = smu_v11_0_notify_display_change,
1637 .get_power_limit = smu_v11_0_get_power_limit,
1638 .set_power_limit = smu_v11_0_set_power_limit,
1639 .get_current_clk_freq = smu_v11_0_get_current_clk_freq,
1640 .init_max_sustainable_clocks = smu_v11_0_init_max_sustainable_clocks,
1641 .start_thermal_control = smu_v11_0_start_thermal_control,
1642 .read_sensor = smu_v11_0_read_sensor,
1643 .set_deep_sleep_dcefclk = smu_v11_0_set_deep_sleep_dcefclk,
1644 .display_clock_voltage_request = smu_v11_0_display_clock_voltage_request,
1645 .set_watermarks_for_clock_ranges = smu_v11_0_set_watermarks_for_clock_ranges,
1646 .get_current_rpm = smu_v11_0_get_current_rpm,
1647 .get_fan_control_mode = smu_v11_0_get_fan_control_mode,
1648 .set_fan_control_mode = smu_v11_0_set_fan_control_mode,
1649 .set_fan_speed_percent = smu_v11_0_set_fan_speed_percent,
1650 .set_fan_speed_rpm = smu_v11_0_set_fan_speed_rpm,
1651 .set_xgmi_pstate = smu_v11_0_set_xgmi_pstate,
1652 .gfx_off_control = smu_v11_0_gfx_off_control,
1653 .register_irq_handler = smu_v11_0_register_irq_handler,
1654 .set_azalia_d3_pme = smu_v11_0_set_azalia_d3_pme,
1657 void smu_v11_0_set_smu_funcs(struct smu_context *smu)
1659 struct amdgpu_device *adev = smu->adev;
1661 smu->funcs = &smu_v11_0_funcs;
1662 switch (adev->asic_type) {
1664 vega20_set_ppt_funcs(smu);
1667 navi10_set_ppt_funcs(smu);
1670 pr_warn("Unknown asic for smu11\n");