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 "smu_11_0_driver_if.h"
31 #include "soc15_common.h"
33 #include "vega20_ppt.h"
34 #include "navi10_ppt.h"
35 #include "pp_thermal.h"
37 #include "asic_reg/thm/thm_11_0_2_offset.h"
38 #include "asic_reg/thm/thm_11_0_2_sh_mask.h"
39 #include "asic_reg/mp/mp_11_0_offset.h"
40 #include "asic_reg/mp/mp_11_0_sh_mask.h"
41 #include "asic_reg/nbio/nbio_7_4_offset.h"
42 #include "asic_reg/smuio/smuio_11_0_0_offset.h"
43 #include "asic_reg/smuio/smuio_11_0_0_sh_mask.h"
45 MODULE_FIRMWARE("amdgpu/vega20_smc.bin");
46 MODULE_FIRMWARE("amdgpu/navi10_smc.bin");
48 #define SMU11_TOOL_SIZE 0x19000
49 #define SMU11_THERMAL_MINIMUM_ALERT_TEMP 0
50 #define SMU11_THERMAL_MAXIMUM_ALERT_TEMP 255
52 #define SMU11_TEMPERATURE_UNITS_PER_CENTIGRADES 1000
53 #define SMU11_VOLTAGE_SCALE 4
55 static int smu_v11_0_send_msg_without_waiting(struct smu_context *smu,
58 struct amdgpu_device *adev = smu->adev;
59 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_66, msg);
63 static int smu_v11_0_read_arg(struct smu_context *smu, uint32_t *arg)
65 struct amdgpu_device *adev = smu->adev;
67 *arg = RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_82);
71 static int smu_v11_0_wait_for_response(struct smu_context *smu)
73 struct amdgpu_device *adev = smu->adev;
74 uint32_t cur_value, i;
76 for (i = 0; i < adev->usec_timeout; i++) {
77 cur_value = RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90);
78 if ((cur_value & MP1_C2PMSG_90__CONTENT_MASK) != 0)
83 /* timeout means wrong logic */
84 if (i == adev->usec_timeout)
87 return RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90) == 0x1 ? 0 : -EIO;
90 static int smu_v11_0_send_msg(struct smu_context *smu, uint16_t msg)
92 struct amdgpu_device *adev = smu->adev;
93 int ret = 0, index = 0;
95 index = smu_msg_get_index(smu, msg);
99 smu_v11_0_wait_for_response(smu);
101 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90, 0);
103 smu_v11_0_send_msg_without_waiting(smu, (uint16_t)index);
105 ret = smu_v11_0_wait_for_response(smu);
108 pr_err("Failed to send message 0x%x, response 0x%x\n", index,
116 smu_v11_0_send_msg_with_param(struct smu_context *smu, uint16_t msg,
120 struct amdgpu_device *adev = smu->adev;
121 int ret = 0, index = 0;
123 index = smu_msg_get_index(smu, msg);
127 ret = smu_v11_0_wait_for_response(smu);
129 pr_err("Failed to send message 0x%x, response 0x%x, param 0x%x\n",
132 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90, 0);
134 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_82, param);
136 smu_v11_0_send_msg_without_waiting(smu, (uint16_t)index);
138 ret = smu_v11_0_wait_for_response(smu);
140 pr_err("Failed to send message 0x%x, response 0x%x param 0x%x\n",
146 static int smu_v11_0_init_microcode(struct smu_context *smu)
148 struct amdgpu_device *adev = smu->adev;
149 const char *chip_name;
152 const struct smc_firmware_header_v1_0 *hdr;
153 const struct common_firmware_header *header;
154 struct amdgpu_firmware_info *ucode = NULL;
156 switch (adev->asic_type) {
158 chip_name = "vega20";
161 chip_name = "navi10";
167 snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_smc.bin", chip_name);
169 err = request_firmware(&adev->pm.fw, fw_name, adev->dev);
172 err = amdgpu_ucode_validate(adev->pm.fw);
176 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
177 amdgpu_ucode_print_smc_hdr(&hdr->header);
178 adev->pm.fw_version = le32_to_cpu(hdr->header.ucode_version);
180 if (adev->firmware.load_type == AMDGPU_FW_LOAD_PSP) {
181 ucode = &adev->firmware.ucode[AMDGPU_UCODE_ID_SMC];
182 ucode->ucode_id = AMDGPU_UCODE_ID_SMC;
183 ucode->fw = adev->pm.fw;
184 header = (const struct common_firmware_header *)ucode->fw->data;
185 adev->firmware.fw_size +=
186 ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);
191 DRM_ERROR("smu_v11_0: Failed to load firmware \"%s\"\n",
193 release_firmware(adev->pm.fw);
199 static int smu_v11_0_load_microcode(struct smu_context *smu)
201 struct amdgpu_device *adev = smu->adev;
203 const struct smc_firmware_header_v1_0 *hdr;
204 uint32_t addr_start = MP1_SRAM;
206 uint32_t mp1_fw_flags;
208 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
209 src = (const uint32_t *)(adev->pm.fw->data +
210 le32_to_cpu(hdr->header.ucode_array_offset_bytes));
212 for (i = 1; i < MP1_SMC_SIZE/4 - 1; i++) {
213 WREG32_PCIE(addr_start, src[i]);
217 WREG32_PCIE(MP1_Public | (smnMP1_PUB_CTRL & 0xffffffff),
218 1 & MP1_SMN_PUB_CTRL__RESET_MASK);
219 WREG32_PCIE(MP1_Public | (smnMP1_PUB_CTRL & 0xffffffff),
220 1 & ~MP1_SMN_PUB_CTRL__RESET_MASK);
222 for (i = 0; i < adev->usec_timeout; i++) {
223 mp1_fw_flags = RREG32_PCIE(MP1_Public |
224 (smnMP1_FIRMWARE_FLAGS & 0xffffffff));
225 if ((mp1_fw_flags & MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED_MASK) >>
226 MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED__SHIFT)
231 if (i == adev->usec_timeout)
237 static int smu_v11_0_check_fw_status(struct smu_context *smu)
239 struct amdgpu_device *adev = smu->adev;
240 uint32_t mp1_fw_flags;
242 mp1_fw_flags = RREG32_PCIE(MP1_Public |
243 (smnMP1_FIRMWARE_FLAGS & 0xffffffff));
245 if ((mp1_fw_flags & MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED_MASK) >>
246 MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED__SHIFT)
252 static int smu_v11_0_check_fw_version(struct smu_context *smu)
254 uint32_t if_version = 0xff, smu_version = 0xff;
256 uint8_t smu_minor, smu_debug;
259 ret = smu_get_smc_version(smu, &if_version, &smu_version);
263 smu_major = (smu_version >> 16) & 0xffff;
264 smu_minor = (smu_version >> 8) & 0xff;
265 smu_debug = (smu_version >> 0) & 0xff;
267 pr_info("SMU Driver IF Version = 0x%08x, SMU FW Version = 0x%08x (%d.%d.%d)\n",
268 if_version, smu_version, smu_major, smu_minor, smu_debug);
270 if (if_version != smu->smc_if_version) {
271 pr_err("SMU driver if version not matched\n");
278 static int smu_v11_0_set_pptable_v2_0(struct smu_context *smu, void **table, uint32_t *size)
280 struct amdgpu_device *adev = smu->adev;
281 uint32_t ppt_offset_bytes;
282 const struct smc_firmware_header_v2_0 *v2;
284 v2 = (const struct smc_firmware_header_v2_0 *) adev->pm.fw->data;
286 ppt_offset_bytes = le32_to_cpu(v2->ppt_offset_bytes);
287 *size = le32_to_cpu(v2->ppt_size_bytes);
288 *table = (uint8_t *)v2 + ppt_offset_bytes;
293 static int smu_v11_0_set_pptable_v2_1(struct smu_context *smu, void **table, uint32_t *size, uint32_t pptable_id)
295 struct amdgpu_device *adev = smu->adev;
296 const struct smc_firmware_header_v2_1 *v2_1;
297 struct smc_soft_pptable_entry *entries;
298 uint32_t pptable_count = 0;
301 v2_1 = (const struct smc_firmware_header_v2_1 *) adev->pm.fw->data;
302 entries = (struct smc_soft_pptable_entry *)
303 ((uint8_t *)v2_1 + le32_to_cpu(v2_1->pptable_entry_offset));
304 pptable_count = le32_to_cpu(v2_1->pptable_count);
305 for (i = 0; i < pptable_count; i++) {
306 if (le32_to_cpu(entries[i].id) == pptable_id) {
307 *table = ((uint8_t *)v2_1 + le32_to_cpu(entries[i].ppt_offset_bytes));
308 *size = le32_to_cpu(entries[i].ppt_size_bytes);
313 if (i == pptable_count)
319 static int smu_v11_0_setup_pptable(struct smu_context *smu)
321 struct amdgpu_device *adev = smu->adev;
322 const struct smc_firmware_header_v1_0 *hdr;
327 uint16_t version_major, version_minor;
329 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
330 version_major = le16_to_cpu(hdr->header.header_version_major);
331 version_minor = le16_to_cpu(hdr->header.header_version_minor);
333 if (version_major == 2 && smu->smu_table.boot_values.pp_table_id > 0) {
334 switch (version_minor) {
336 ret = smu_v11_0_set_pptable_v2_0(smu, &table, &size);
339 ret = smu_v11_0_set_pptable_v2_1(smu, &table, &size,
340 smu->smu_table.boot_values.pp_table_id);
350 index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1,
353 ret = smu_get_atom_data_table(smu, index, (uint16_t *)&size, &frev, &crev,
359 if (!smu->smu_table.power_play_table)
360 smu->smu_table.power_play_table = table;
361 if (!smu->smu_table.power_play_table_size)
362 smu->smu_table.power_play_table_size = size;
367 static int smu_v11_0_init_dpm_context(struct smu_context *smu)
369 struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
371 if (smu_dpm->dpm_context || smu_dpm->dpm_context_size != 0)
374 return smu_alloc_dpm_context(smu);
377 static int smu_v11_0_fini_dpm_context(struct smu_context *smu)
379 struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
381 if (!smu_dpm->dpm_context || smu_dpm->dpm_context_size == 0)
384 kfree(smu_dpm->dpm_context);
385 kfree(smu_dpm->golden_dpm_context);
386 kfree(smu_dpm->dpm_current_power_state);
387 kfree(smu_dpm->dpm_request_power_state);
388 smu_dpm->dpm_context = NULL;
389 smu_dpm->golden_dpm_context = NULL;
390 smu_dpm->dpm_context_size = 0;
391 smu_dpm->dpm_current_power_state = NULL;
392 smu_dpm->dpm_request_power_state = NULL;
397 static int smu_v11_0_init_smc_tables(struct smu_context *smu)
399 struct smu_table_context *smu_table = &smu->smu_table;
400 struct smu_table *tables = NULL;
403 if (smu_table->tables || smu_table->table_count != 0)
406 tables = kcalloc(TABLE_COUNT, sizeof(struct smu_table), GFP_KERNEL);
410 smu_table->tables = tables;
411 smu_table->table_count = TABLE_COUNT;
413 SMU_TABLE_INIT(tables, TABLE_PPTABLE, sizeof(PPTable_t),
414 PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
415 SMU_TABLE_INIT(tables, TABLE_WATERMARKS, sizeof(Watermarks_t),
416 PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
417 SMU_TABLE_INIT(tables, TABLE_SMU_METRICS, sizeof(SmuMetrics_t),
418 PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
419 SMU_TABLE_INIT(tables, TABLE_OVERDRIVE, sizeof(OverDriveTable_t),
420 PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
421 SMU_TABLE_INIT(tables, TABLE_PMSTATUSLOG, SMU11_TOOL_SIZE, PAGE_SIZE,
422 AMDGPU_GEM_DOMAIN_VRAM);
423 SMU_TABLE_INIT(tables, TABLE_ACTIVITY_MONITOR_COEFF,
424 sizeof(DpmActivityMonitorCoeffInt_t),
426 AMDGPU_GEM_DOMAIN_VRAM);
428 ret = smu_v11_0_init_dpm_context(smu);
435 static int smu_v11_0_fini_smc_tables(struct smu_context *smu)
437 struct smu_table_context *smu_table = &smu->smu_table;
440 if (!smu_table->tables || smu_table->table_count == 0)
443 kfree(smu_table->tables);
444 smu_table->tables = NULL;
445 smu_table->table_count = 0;
447 ret = smu_v11_0_fini_dpm_context(smu);
453 static int smu_v11_0_init_power(struct smu_context *smu)
455 struct smu_power_context *smu_power = &smu->smu_power;
457 if (!smu->pm_enabled)
459 if (smu_power->power_context || smu_power->power_context_size != 0)
462 smu_power->power_context = kzalloc(sizeof(struct smu_11_0_dpm_context),
464 if (!smu_power->power_context)
466 smu_power->power_context_size = sizeof(struct smu_11_0_dpm_context);
468 smu->metrics_time = 0;
469 smu->metrics_table = kzalloc(sizeof(SmuMetrics_t), GFP_KERNEL);
470 if (!smu->metrics_table) {
471 kfree(smu_power->power_context);
478 static int smu_v11_0_fini_power(struct smu_context *smu)
480 struct smu_power_context *smu_power = &smu->smu_power;
482 if (!smu->pm_enabled)
484 if (!smu_power->power_context || smu_power->power_context_size == 0)
487 kfree(smu->metrics_table);
488 kfree(smu_power->power_context);
489 smu->metrics_table = NULL;
490 smu_power->power_context = NULL;
491 smu_power->power_context_size = 0;
496 int smu_v11_0_get_vbios_bootup_values(struct smu_context *smu)
501 struct atom_common_table_header *header;
502 struct atom_firmware_info_v3_3 *v_3_3;
503 struct atom_firmware_info_v3_1 *v_3_1;
505 index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1,
508 ret = smu_get_atom_data_table(smu, index, &size, &frev, &crev,
509 (uint8_t **)&header);
513 if (header->format_revision != 3) {
514 pr_err("unknown atom_firmware_info version! for smu11\n");
518 switch (header->content_revision) {
522 v_3_1 = (struct atom_firmware_info_v3_1 *)header;
523 smu->smu_table.boot_values.revision = v_3_1->firmware_revision;
524 smu->smu_table.boot_values.gfxclk = v_3_1->bootup_sclk_in10khz;
525 smu->smu_table.boot_values.uclk = v_3_1->bootup_mclk_in10khz;
526 smu->smu_table.boot_values.socclk = 0;
527 smu->smu_table.boot_values.dcefclk = 0;
528 smu->smu_table.boot_values.vddc = v_3_1->bootup_vddc_mv;
529 smu->smu_table.boot_values.vddci = v_3_1->bootup_vddci_mv;
530 smu->smu_table.boot_values.mvddc = v_3_1->bootup_mvddc_mv;
531 smu->smu_table.boot_values.vdd_gfx = v_3_1->bootup_vddgfx_mv;
532 smu->smu_table.boot_values.cooling_id = v_3_1->coolingsolution_id;
533 smu->smu_table.boot_values.pp_table_id = 0;
537 v_3_3 = (struct atom_firmware_info_v3_3 *)header;
538 smu->smu_table.boot_values.revision = v_3_3->firmware_revision;
539 smu->smu_table.boot_values.gfxclk = v_3_3->bootup_sclk_in10khz;
540 smu->smu_table.boot_values.uclk = v_3_3->bootup_mclk_in10khz;
541 smu->smu_table.boot_values.socclk = 0;
542 smu->smu_table.boot_values.dcefclk = 0;
543 smu->smu_table.boot_values.vddc = v_3_3->bootup_vddc_mv;
544 smu->smu_table.boot_values.vddci = v_3_3->bootup_vddci_mv;
545 smu->smu_table.boot_values.mvddc = v_3_3->bootup_mvddc_mv;
546 smu->smu_table.boot_values.vdd_gfx = v_3_3->bootup_vddgfx_mv;
547 smu->smu_table.boot_values.cooling_id = v_3_3->coolingsolution_id;
548 smu->smu_table.boot_values.pp_table_id = v_3_3->pplib_pptable_id;
554 static int smu_v11_0_get_clk_info_from_vbios(struct smu_context *smu)
557 struct amdgpu_device *adev = smu->adev;
558 struct atom_get_smu_clock_info_parameters_v3_1 input = {0};
559 struct atom_get_smu_clock_info_output_parameters_v3_1 *output;
561 input.clk_id = SMU11_SYSPLL0_SOCCLK_ID;
562 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
563 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
566 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
571 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
572 smu->smu_table.boot_values.socclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
574 memset(&input, 0, sizeof(input));
575 input.clk_id = SMU11_SYSPLL0_DCEFCLK_ID;
576 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
577 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
580 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
585 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
586 smu->smu_table.boot_values.dcefclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
588 memset(&input, 0, sizeof(input));
589 input.clk_id = SMU11_SYSPLL0_ECLK_ID;
590 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
591 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
594 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
599 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
600 smu->smu_table.boot_values.eclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
602 memset(&input, 0, sizeof(input));
603 input.clk_id = SMU11_SYSPLL0_VCLK_ID;
604 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
605 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
608 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
613 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
614 smu->smu_table.boot_values.vclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
616 memset(&input, 0, sizeof(input));
617 input.clk_id = SMU11_SYSPLL0_DCLK_ID;
618 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
619 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
622 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
627 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
628 smu->smu_table.boot_values.dclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
633 static int smu_v11_0_notify_memory_pool_location(struct smu_context *smu)
635 struct smu_table_context *smu_table = &smu->smu_table;
636 struct smu_table *memory_pool = &smu_table->memory_pool;
639 uint32_t address_low, address_high;
641 if (memory_pool->size == 0 || memory_pool->cpu_addr == NULL)
644 address = (uintptr_t)memory_pool->cpu_addr;
645 address_high = (uint32_t)upper_32_bits(address);
646 address_low = (uint32_t)lower_32_bits(address);
648 ret = smu_send_smc_msg_with_param(smu,
649 SMU_MSG_SetSystemVirtualDramAddrHigh,
653 ret = smu_send_smc_msg_with_param(smu,
654 SMU_MSG_SetSystemVirtualDramAddrLow,
659 address = memory_pool->mc_address;
660 address_high = (uint32_t)upper_32_bits(address);
661 address_low = (uint32_t)lower_32_bits(address);
663 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramAddrHigh,
667 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramAddrLow,
671 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramSize,
672 (uint32_t)memory_pool->size);
679 static int smu_v11_0_check_pptable(struct smu_context *smu)
683 ret = smu_check_powerplay_table(smu);
687 static int smu_v11_0_parse_pptable(struct smu_context *smu)
691 struct smu_table_context *table_context = &smu->smu_table;
693 if (table_context->driver_pptable)
696 table_context->driver_pptable = kzalloc(sizeof(PPTable_t), GFP_KERNEL);
698 if (!table_context->driver_pptable)
701 ret = smu_store_powerplay_table(smu);
705 ret = smu_append_powerplay_table(smu);
710 static int smu_v11_0_populate_smc_pptable(struct smu_context *smu)
714 ret = smu_set_default_dpm_table(smu);
719 static int smu_v11_0_write_pptable(struct smu_context *smu)
721 struct smu_table_context *table_context = &smu->smu_table;
724 ret = smu_update_table(smu, TABLE_PPTABLE, table_context->driver_pptable, true);
729 static int smu_v11_0_write_watermarks_table(struct smu_context *smu)
731 return smu_update_table(smu, TABLE_WATERMARKS,
732 smu->smu_table.tables[TABLE_WATERMARKS].cpu_addr, true);
735 static int smu_v11_0_set_deep_sleep_dcefclk(struct smu_context *smu, uint32_t clk)
739 ret = smu_send_smc_msg_with_param(smu,
740 SMU_MSG_SetMinDeepSleepDcefclk, clk);
742 pr_err("SMU11 attempt to set divider for DCEFCLK Failed!");
747 static int smu_v11_0_set_min_dcef_deep_sleep(struct smu_context *smu)
749 struct smu_table_context *table_context = &smu->smu_table;
751 if (!smu->pm_enabled)
756 return smu_set_deep_sleep_dcefclk(smu,
757 table_context->boot_values.dcefclk / 100);
760 static int smu_v11_0_set_tool_table_location(struct smu_context *smu)
763 struct smu_table *tool_table = &smu->smu_table.tables[TABLE_PMSTATUSLOG];
765 if (tool_table->mc_address) {
766 ret = smu_send_smc_msg_with_param(smu,
767 SMU_MSG_SetToolsDramAddrHigh,
768 upper_32_bits(tool_table->mc_address));
770 ret = smu_send_smc_msg_with_param(smu,
771 SMU_MSG_SetToolsDramAddrLow,
772 lower_32_bits(tool_table->mc_address));
778 static int smu_v11_0_init_display(struct smu_context *smu)
782 if (!smu->pm_enabled)
784 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_NumOfDisplays, 0);
788 static int smu_v11_0_update_feature_enable_state(struct smu_context *smu, uint32_t feature_id, bool enabled)
790 uint32_t feature_low = 0, feature_high = 0;
793 if (!smu->pm_enabled)
795 if (feature_id >= 0 && feature_id < 31)
796 feature_low = (1 << feature_id);
797 else if (feature_id > 31 && feature_id < 63)
798 feature_high = (1 << feature_id);
803 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesLow,
807 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesHigh,
813 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesLow,
817 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesHigh,
827 static int smu_v11_0_set_allowed_mask(struct smu_context *smu)
829 struct smu_feature *feature = &smu->smu_feature;
831 uint32_t feature_mask[2];
833 mutex_lock(&feature->mutex);
834 if (bitmap_empty(feature->allowed, SMU_FEATURE_MAX) || feature->feature_num < 64)
837 bitmap_copy((unsigned long *)feature_mask, feature->allowed, 64);
839 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskHigh,
844 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskLow,
850 mutex_unlock(&feature->mutex);
854 static int smu_v11_0_get_enabled_mask(struct smu_context *smu,
855 uint32_t *feature_mask, uint32_t num)
857 uint32_t feature_mask_high = 0, feature_mask_low = 0;
860 if (!feature_mask || num < 2)
863 ret = smu_send_smc_msg(smu, SMU_MSG_GetEnabledSmuFeaturesHigh);
866 ret = smu_read_smc_arg(smu, &feature_mask_high);
870 ret = smu_send_smc_msg(smu, SMU_MSG_GetEnabledSmuFeaturesLow);
873 ret = smu_read_smc_arg(smu, &feature_mask_low);
877 feature_mask[0] = feature_mask_low;
878 feature_mask[1] = feature_mask_high;
883 static int smu_v11_0_system_features_control(struct smu_context *smu,
886 struct smu_feature *feature = &smu->smu_feature;
887 uint32_t feature_mask[2];
890 if (smu->pm_enabled) {
891 ret = smu_send_smc_msg(smu, (en ? SMU_MSG_EnableAllSmuFeatures :
892 SMU_MSG_DisableAllSmuFeatures));
897 ret = smu_feature_get_enabled_mask(smu, feature_mask, 2);
901 bitmap_copy(feature->enabled, (unsigned long *)&feature_mask,
902 feature->feature_num);
903 bitmap_copy(feature->supported, (unsigned long *)&feature_mask,
904 feature->feature_num);
909 static int smu_v11_0_notify_display_change(struct smu_context *smu)
913 if (!smu->pm_enabled)
915 if (smu_feature_is_enabled(smu, FEATURE_DPM_UCLK_BIT))
916 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetUclkFastSwitch, 1);
922 smu_v11_0_get_max_sustainable_clock(struct smu_context *smu, uint32_t *clock,
923 PPCLK_e clock_select)
927 if (!smu->pm_enabled)
929 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetDcModeMaxDpmFreq,
932 pr_err("[GetMaxSustainableClock] Failed to get max DC clock from SMC!");
936 ret = smu_read_smc_arg(smu, clock);
943 /* if DC limit is zero, return AC limit */
944 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMaxDpmFreq,
947 pr_err("[GetMaxSustainableClock] failed to get max AC clock from SMC!");
951 ret = smu_read_smc_arg(smu, clock);
956 static int smu_v11_0_init_max_sustainable_clocks(struct smu_context *smu)
958 struct smu_11_0_max_sustainable_clocks *max_sustainable_clocks;
961 max_sustainable_clocks = kzalloc(sizeof(struct smu_11_0_max_sustainable_clocks),
963 smu->smu_table.max_sustainable_clocks = (void *)max_sustainable_clocks;
965 max_sustainable_clocks->uclock = smu->smu_table.boot_values.uclk / 100;
966 max_sustainable_clocks->soc_clock = smu->smu_table.boot_values.socclk / 100;
967 max_sustainable_clocks->dcef_clock = smu->smu_table.boot_values.dcefclk / 100;
968 max_sustainable_clocks->display_clock = 0xFFFFFFFF;
969 max_sustainable_clocks->phy_clock = 0xFFFFFFFF;
970 max_sustainable_clocks->pixel_clock = 0xFFFFFFFF;
972 if (smu_feature_is_enabled(smu, FEATURE_DPM_UCLK_BIT)) {
973 ret = smu_v11_0_get_max_sustainable_clock(smu,
974 &(max_sustainable_clocks->uclock),
977 pr_err("[%s] failed to get max UCLK from SMC!",
983 if (smu_feature_is_enabled(smu, FEATURE_DPM_SOCCLK_BIT)) {
984 ret = smu_v11_0_get_max_sustainable_clock(smu,
985 &(max_sustainable_clocks->soc_clock),
988 pr_err("[%s] failed to get max SOCCLK from SMC!",
994 if (smu_feature_is_enabled(smu, FEATURE_DPM_DCEFCLK_BIT)) {
995 ret = smu_v11_0_get_max_sustainable_clock(smu,
996 &(max_sustainable_clocks->dcef_clock),
999 pr_err("[%s] failed to get max DCEFCLK from SMC!",
1004 ret = smu_v11_0_get_max_sustainable_clock(smu,
1005 &(max_sustainable_clocks->display_clock),
1008 pr_err("[%s] failed to get max DISPCLK from SMC!",
1012 ret = smu_v11_0_get_max_sustainable_clock(smu,
1013 &(max_sustainable_clocks->phy_clock),
1016 pr_err("[%s] failed to get max PHYCLK from SMC!",
1020 ret = smu_v11_0_get_max_sustainable_clock(smu,
1021 &(max_sustainable_clocks->pixel_clock),
1024 pr_err("[%s] failed to get max PIXCLK from SMC!",
1030 if (max_sustainable_clocks->soc_clock < max_sustainable_clocks->uclock)
1031 max_sustainable_clocks->uclock = max_sustainable_clocks->soc_clock;
1036 static int smu_v11_0_get_power_limit(struct smu_context *smu,
1043 mutex_lock(&smu->mutex);
1044 *limit = smu->default_power_limit;
1045 if (smu->od_enabled) {
1046 *limit *= (100 + smu->smu_table.TDPODLimit);
1049 mutex_unlock(&smu->mutex);
1051 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetPptLimit,
1052 POWER_SOURCE_AC << 16);
1054 pr_err("[%s] get PPT limit failed!", __func__);
1057 smu_read_smc_arg(smu, limit);
1058 smu->power_limit = *limit;
1064 static int smu_v11_0_set_power_limit(struct smu_context *smu, uint32_t n)
1066 uint32_t max_power_limit;
1070 n = smu->default_power_limit;
1072 max_power_limit = smu->default_power_limit;
1074 if (smu->od_enabled) {
1075 max_power_limit *= (100 + smu->smu_table.TDPODLimit);
1076 max_power_limit /= 100;
1079 if (smu_feature_is_enabled(smu, FEATURE_PPT_BIT))
1080 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetPptLimit, n);
1082 pr_err("[%s] Set power limit Failed!", __func__);
1089 static int smu_v11_0_get_current_clk_freq(struct smu_context *smu, uint32_t clk_id, uint32_t *value)
1094 if (clk_id >= PPCLK_COUNT || !value)
1097 ret = smu_send_smc_msg_with_param(smu,
1098 SMU_MSG_GetDpmClockFreq, (clk_id << 16));
1102 ret = smu_read_smc_arg(smu, &freq);
1112 static int smu_v11_0_get_thermal_range(struct smu_context *smu,
1113 struct PP_TemperatureRange *range)
1115 PPTable_t *pptable = smu->smu_table.driver_pptable;
1116 memcpy(range, &SMU7ThermalWithDelayPolicy[0], sizeof(struct PP_TemperatureRange));
1118 range->max = pptable->TedgeLimit *
1119 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1120 range->edge_emergency_max = (pptable->TedgeLimit + CTF_OFFSET_EDGE) *
1121 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1122 range->hotspot_crit_max = pptable->ThotspotLimit *
1123 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1124 range->hotspot_emergency_max = (pptable->ThotspotLimit + CTF_OFFSET_HOTSPOT) *
1125 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1126 range->mem_crit_max = pptable->ThbmLimit *
1127 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1128 range->mem_emergency_max = (pptable->ThbmLimit + CTF_OFFSET_HBM)*
1129 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1134 static int smu_v11_0_set_thermal_range(struct smu_context *smu,
1135 struct PP_TemperatureRange *range)
1137 struct amdgpu_device *adev = smu->adev;
1138 int low = SMU11_THERMAL_MINIMUM_ALERT_TEMP *
1139 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1140 int high = SMU11_THERMAL_MAXIMUM_ALERT_TEMP *
1141 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1144 if (low < range->min)
1146 if (high > range->max)
1152 val = RREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_CTRL);
1153 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, MAX_IH_CREDIT, 5);
1154 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, THERM_IH_HW_ENA, 1);
1155 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, DIG_THERM_INTH, (high / PP_TEMPERATURE_UNITS_PER_CENTIGRADES));
1156 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, DIG_THERM_INTL, (low / PP_TEMPERATURE_UNITS_PER_CENTIGRADES));
1157 val = val & (~THM_THERMAL_INT_CTRL__THERM_TRIGGER_MASK_MASK);
1159 WREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_CTRL, val);
1164 static int smu_v11_0_enable_thermal_alert(struct smu_context *smu)
1166 struct amdgpu_device *adev = smu->adev;
1169 val |= (1 << THM_THERMAL_INT_ENA__THERM_INTH_CLR__SHIFT);
1170 val |= (1 << THM_THERMAL_INT_ENA__THERM_INTL_CLR__SHIFT);
1171 val |= (1 << THM_THERMAL_INT_ENA__THERM_TRIGGER_CLR__SHIFT);
1173 WREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_ENA, val);
1178 static int smu_v11_0_set_thermal_fan_table(struct smu_context *smu)
1181 struct smu_table_context *table_context = &smu->smu_table;
1182 PPTable_t *pptable = table_context->driver_pptable;
1184 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetFanTemperatureTarget,
1185 (uint32_t)pptable->FanTargetTemperature);
1190 static int smu_v11_0_start_thermal_control(struct smu_context *smu)
1193 struct PP_TemperatureRange range = {
1203 struct amdgpu_device *adev = smu->adev;
1205 if (!smu->pm_enabled)
1207 smu_v11_0_get_thermal_range(smu, &range);
1209 if (smu->smu_table.thermal_controller_type) {
1210 ret = smu_v11_0_set_thermal_range(smu, &range);
1214 ret = smu_v11_0_enable_thermal_alert(smu);
1217 ret = smu_v11_0_set_thermal_fan_table(smu);
1222 adev->pm.dpm.thermal.min_temp = range.min;
1223 adev->pm.dpm.thermal.max_temp = range.max;
1224 adev->pm.dpm.thermal.max_edge_emergency_temp = range.edge_emergency_max;
1225 adev->pm.dpm.thermal.min_hotspot_temp = range.hotspot_min;
1226 adev->pm.dpm.thermal.max_hotspot_crit_temp = range.hotspot_crit_max;
1227 adev->pm.dpm.thermal.max_hotspot_emergency_temp = range.hotspot_emergency_max;
1228 adev->pm.dpm.thermal.min_mem_temp = range.mem_min;
1229 adev->pm.dpm.thermal.max_mem_crit_temp = range.mem_crit_max;
1230 adev->pm.dpm.thermal.max_mem_emergency_temp = range.mem_emergency_max;
1235 static int smu_v11_0_get_metrics_table(struct smu_context *smu,
1236 SmuMetrics_t *metrics_table)
1240 if (!smu->metrics_time || time_after(jiffies, smu->metrics_time + HZ / 1000)) {
1241 ret = smu_update_table(smu, TABLE_SMU_METRICS,
1242 (void *)metrics_table, false);
1244 pr_info("Failed to export SMU metrics table!\n");
1247 memcpy(smu->metrics_table, metrics_table, sizeof(SmuMetrics_t));
1248 smu->metrics_time = jiffies;
1250 memcpy(metrics_table, smu->metrics_table, sizeof(SmuMetrics_t));
1255 static int smu_v11_0_get_current_activity_percent(struct smu_context *smu,
1256 enum amd_pp_sensors sensor,
1260 SmuMetrics_t metrics;
1265 ret = smu_v11_0_get_metrics_table(smu, &metrics);
1270 case AMDGPU_PP_SENSOR_GPU_LOAD:
1271 *value = metrics.AverageGfxActivity;
1273 case AMDGPU_PP_SENSOR_MEM_LOAD:
1274 *value = metrics.AverageUclkActivity;
1277 pr_err("Invalid sensor for retrieving clock activity\n");
1284 static int smu_v11_0_thermal_get_temperature(struct smu_context *smu,
1285 enum amd_pp_sensors sensor,
1288 struct amdgpu_device *adev = smu->adev;
1289 SmuMetrics_t metrics;
1296 ret = smu_v11_0_get_metrics_table(smu, &metrics);
1301 case AMDGPU_PP_SENSOR_HOTSPOT_TEMP:
1302 temp = RREG32_SOC15(THM, 0, mmCG_MULT_THERMAL_STATUS);
1303 temp = (temp & CG_MULT_THERMAL_STATUS__CTF_TEMP_MASK) >>
1304 CG_MULT_THERMAL_STATUS__CTF_TEMP__SHIFT;
1306 temp = temp & 0x1ff;
1307 temp *= SMU11_TEMPERATURE_UNITS_PER_CENTIGRADES;
1311 case AMDGPU_PP_SENSOR_EDGE_TEMP:
1312 *value = metrics.TemperatureEdge *
1313 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1315 case AMDGPU_PP_SENSOR_MEM_TEMP:
1316 *value = metrics.TemperatureHBM *
1317 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1320 pr_err("Invalid sensor for retrieving temp\n");
1327 static int smu_v11_0_get_gpu_power(struct smu_context *smu, uint32_t *value)
1330 SmuMetrics_t metrics;
1335 ret = smu_v11_0_get_metrics_table(smu, &metrics);
1339 *value = metrics.CurrSocketPower << 8;
1344 static uint16_t convert_to_vddc(uint8_t vid)
1346 return (uint16_t) ((6200 - (vid * 25)) / SMU11_VOLTAGE_SCALE);
1349 static int smu_v11_0_get_gfx_vdd(struct smu_context *smu, uint32_t *value)
1351 struct amdgpu_device *adev = smu->adev;
1352 uint32_t vdd = 0, val_vid = 0;
1356 val_vid = (RREG32_SOC15(SMUIO, 0, mmSMUSVI0_TEL_PLANE0) &
1357 SMUSVI0_TEL_PLANE0__SVI0_PLANE0_VDDCOR_MASK) >>
1358 SMUSVI0_TEL_PLANE0__SVI0_PLANE0_VDDCOR__SHIFT;
1360 vdd = (uint32_t)convert_to_vddc((uint8_t)val_vid);
1368 static int smu_v11_0_read_sensor(struct smu_context *smu,
1369 enum amd_pp_sensors sensor,
1370 void *data, uint32_t *size)
1372 struct smu_table_context *table_context = &smu->smu_table;
1373 PPTable_t *pptable = table_context->driver_pptable;
1376 case AMDGPU_PP_SENSOR_GPU_LOAD:
1377 case AMDGPU_PP_SENSOR_MEM_LOAD:
1378 ret = smu_v11_0_get_current_activity_percent(smu,
1383 case AMDGPU_PP_SENSOR_GFX_MCLK:
1384 ret = smu_get_current_clk_freq(smu, PPCLK_UCLK, (uint32_t *)data);
1387 case AMDGPU_PP_SENSOR_GFX_SCLK:
1388 ret = smu_get_current_clk_freq(smu, PPCLK_GFXCLK, (uint32_t *)data);
1391 case AMDGPU_PP_SENSOR_HOTSPOT_TEMP:
1392 case AMDGPU_PP_SENSOR_EDGE_TEMP:
1393 case AMDGPU_PP_SENSOR_MEM_TEMP:
1394 ret = smu_v11_0_thermal_get_temperature(smu, sensor, (uint32_t *)data);
1397 case AMDGPU_PP_SENSOR_GPU_POWER:
1398 ret = smu_v11_0_get_gpu_power(smu, (uint32_t *)data);
1401 case AMDGPU_PP_SENSOR_VDDGFX:
1402 ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
1405 case AMDGPU_PP_SENSOR_MIN_FAN_RPM:
1406 *(uint32_t *)data = 0;
1409 case AMDGPU_PP_SENSOR_MAX_FAN_RPM:
1410 *(uint32_t *)data = pptable->FanMaximumRpm;
1414 ret = smu_common_read_sensor(smu, sensor, data, size);
1418 /* try get sensor data by asic */
1420 ret = smu_asic_read_sensor(smu, sensor, data, size);
1429 smu_v11_0_display_clock_voltage_request(struct smu_context *smu,
1430 struct pp_display_clock_request
1433 enum amd_pp_clock_type clk_type = clock_req->clock_type;
1435 PPCLK_e clk_select = 0;
1436 uint32_t clk_freq = clock_req->clock_freq_in_khz / 1000;
1438 if (!smu->pm_enabled)
1440 if (smu_feature_is_enabled(smu, FEATURE_DPM_DCEFCLK_BIT)) {
1442 case amd_pp_dcef_clock:
1443 clk_select = PPCLK_DCEFCLK;
1445 case amd_pp_disp_clock:
1446 clk_select = PPCLK_DISPCLK;
1448 case amd_pp_pixel_clock:
1449 clk_select = PPCLK_PIXCLK;
1451 case amd_pp_phy_clock:
1452 clk_select = PPCLK_PHYCLK;
1455 pr_info("[%s] Invalid Clock Type!", __func__);
1463 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetHardMinByFreq,
1464 (clk_select << 16) | clk_freq);
1471 static int smu_v11_0_set_watermarks_table(struct smu_context *smu,
1472 Watermarks_t *table, struct
1473 dm_pp_wm_sets_with_clock_ranges_soc15
1478 if (!table || !clock_ranges)
1481 if (clock_ranges->num_wm_dmif_sets > 4 ||
1482 clock_ranges->num_wm_mcif_sets > 4)
1485 for (i = 0; i < clock_ranges->num_wm_dmif_sets; i++) {
1486 table->WatermarkRow[1][i].MinClock =
1487 cpu_to_le16((uint16_t)
1488 (clock_ranges->wm_dmif_clocks_ranges[i].wm_min_dcfclk_clk_in_khz /
1490 table->WatermarkRow[1][i].MaxClock =
1491 cpu_to_le16((uint16_t)
1492 (clock_ranges->wm_dmif_clocks_ranges[i].wm_max_dcfclk_clk_in_khz /
1494 table->WatermarkRow[1][i].MinUclk =
1495 cpu_to_le16((uint16_t)
1496 (clock_ranges->wm_dmif_clocks_ranges[i].wm_min_mem_clk_in_khz /
1498 table->WatermarkRow[1][i].MaxUclk =
1499 cpu_to_le16((uint16_t)
1500 (clock_ranges->wm_dmif_clocks_ranges[i].wm_max_mem_clk_in_khz /
1502 table->WatermarkRow[1][i].WmSetting = (uint8_t)
1503 clock_ranges->wm_dmif_clocks_ranges[i].wm_set_id;
1506 for (i = 0; i < clock_ranges->num_wm_mcif_sets; i++) {
1507 table->WatermarkRow[0][i].MinClock =
1508 cpu_to_le16((uint16_t)
1509 (clock_ranges->wm_mcif_clocks_ranges[i].wm_min_socclk_clk_in_khz /
1511 table->WatermarkRow[0][i].MaxClock =
1512 cpu_to_le16((uint16_t)
1513 (clock_ranges->wm_mcif_clocks_ranges[i].wm_max_socclk_clk_in_khz /
1515 table->WatermarkRow[0][i].MinUclk =
1516 cpu_to_le16((uint16_t)
1517 (clock_ranges->wm_mcif_clocks_ranges[i].wm_min_mem_clk_in_khz /
1519 table->WatermarkRow[0][i].MaxUclk =
1520 cpu_to_le16((uint16_t)
1521 (clock_ranges->wm_mcif_clocks_ranges[i].wm_max_mem_clk_in_khz /
1523 table->WatermarkRow[0][i].WmSetting = (uint8_t)
1524 clock_ranges->wm_mcif_clocks_ranges[i].wm_set_id;
1531 smu_v11_0_set_watermarks_for_clock_ranges(struct smu_context *smu, struct
1532 dm_pp_wm_sets_with_clock_ranges_soc15
1536 struct smu_table *watermarks = &smu->smu_table.tables[TABLE_WATERMARKS];
1537 Watermarks_t *table = watermarks->cpu_addr;
1539 if (!smu->disable_watermark &&
1540 smu_feature_is_enabled(smu, FEATURE_DPM_DCEFCLK_BIT) &&
1541 smu_feature_is_enabled(smu, FEATURE_DPM_SOCCLK_BIT)) {
1542 smu_v11_0_set_watermarks_table(smu, table, clock_ranges);
1543 smu->watermarks_bitmap |= WATERMARKS_EXIST;
1544 smu->watermarks_bitmap &= ~WATERMARKS_LOADED;
1550 static int smu_v11_0_get_clock_ranges(struct smu_context *smu,
1552 PPCLK_e clock_select,
1558 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMaxDpmFreq,
1559 (clock_select << 16));
1561 pr_err("[GetClockRanges] Failed to get max clock from SMC!\n");
1564 smu_read_smc_arg(smu, clock);
1566 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMinDpmFreq,
1567 (clock_select << 16));
1569 pr_err("[GetClockRanges] Failed to get min clock from SMC!\n");
1572 smu_read_smc_arg(smu, clock);
1578 static uint32_t smu_v11_0_dpm_get_sclk(struct smu_context *smu, bool low)
1583 if (!smu_feature_is_enabled(smu, FEATURE_DPM_GFXCLK_BIT)) {
1584 pr_err("[GetSclks]: gfxclk dpm not enabled!\n");
1589 ret = smu_v11_0_get_clock_ranges(smu, &gfx_clk, PPCLK_GFXCLK, false);
1591 pr_err("[GetSclks]: fail to get min PPCLK_GFXCLK\n");
1595 ret = smu_v11_0_get_clock_ranges(smu, &gfx_clk, PPCLK_GFXCLK, true);
1597 pr_err("[GetSclks]: fail to get max PPCLK_GFXCLK\n");
1602 return (gfx_clk * 100);
1605 static uint32_t smu_v11_0_dpm_get_mclk(struct smu_context *smu, bool low)
1610 if (!smu_feature_is_enabled(smu, FEATURE_DPM_UCLK_BIT)) {
1611 pr_err("[GetMclks]: memclk dpm not enabled!\n");
1616 ret = smu_v11_0_get_clock_ranges(smu, &mem_clk, PPCLK_UCLK, false);
1618 pr_err("[GetMclks]: fail to get min PPCLK_UCLK\n");
1622 ret = smu_v11_0_get_clock_ranges(smu, &mem_clk, PPCLK_GFXCLK, true);
1624 pr_err("[GetMclks]: fail to get max PPCLK_UCLK\n");
1629 return (mem_clk * 100);
1632 static int smu_v11_0_set_od8_default_settings(struct smu_context *smu,
1635 struct smu_table_context *table_context = &smu->smu_table;
1639 * TODO: Enable overdrive for navi10, that replies on smc/pptable
1642 if (smu->adev->asic_type == CHIP_NAVI10)
1646 if (table_context->overdrive_table)
1649 table_context->overdrive_table = kzalloc(sizeof(OverDriveTable_t), GFP_KERNEL);
1651 if (!table_context->overdrive_table)
1654 ret = smu_update_table(smu, TABLE_OVERDRIVE, table_context->overdrive_table, false);
1656 pr_err("Failed to export over drive table!\n");
1660 smu_set_default_od8_settings(smu);
1663 ret = smu_update_table(smu, TABLE_OVERDRIVE, table_context->overdrive_table, true);
1665 pr_err("Failed to import over drive table!\n");
1672 static int smu_v11_0_update_od8_settings(struct smu_context *smu,
1676 struct smu_table_context *table_context = &smu->smu_table;
1679 ret = smu_update_table(smu, TABLE_OVERDRIVE,
1680 table_context->overdrive_table, false);
1682 pr_err("Failed to export over drive table!\n");
1686 smu_update_specified_od8_value(smu, index, value);
1688 ret = smu_update_table(smu, TABLE_OVERDRIVE,
1689 table_context->overdrive_table, true);
1691 pr_err("Failed to import over drive table!\n");
1698 static int smu_v11_0_get_current_rpm(struct smu_context *smu,
1699 uint32_t *current_rpm)
1703 ret = smu_send_smc_msg(smu, SMU_MSG_GetCurrentRpm);
1706 pr_err("Attempt to get current RPM from SMC Failed!\n");
1710 smu_read_smc_arg(smu, current_rpm);
1716 smu_v11_0_get_fan_control_mode(struct smu_context *smu)
1718 if (!smu_feature_is_enabled(smu, FEATURE_FAN_CONTROL_BIT))
1719 return AMD_FAN_CTRL_MANUAL;
1721 return AMD_FAN_CTRL_AUTO;
1725 smu_v11_0_get_fan_speed_percent(struct smu_context *smu,
1729 uint32_t percent = 0;
1730 uint32_t current_rpm;
1731 PPTable_t *pptable = smu->smu_table.driver_pptable;
1733 ret = smu_v11_0_get_current_rpm(smu, ¤t_rpm);
1734 percent = current_rpm * 100 / pptable->FanMaximumRpm;
1735 *speed = percent > 100 ? 100 : percent;
1741 smu_v11_0_smc_fan_control(struct smu_context *smu, bool start)
1745 if (smu_feature_is_supported(smu, FEATURE_FAN_CONTROL_BIT))
1748 ret = smu_feature_set_enabled(smu, FEATURE_FAN_CONTROL_BIT, start);
1750 pr_err("[%s]%s smc FAN CONTROL feature failed!",
1751 __func__, (start ? "Start" : "Stop"));
1757 smu_v11_0_set_fan_static_mode(struct smu_context *smu, uint32_t mode)
1759 struct amdgpu_device *adev = smu->adev;
1761 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL2,
1762 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL2),
1763 CG_FDO_CTRL2, TMIN, 0));
1764 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL2,
1765 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL2),
1766 CG_FDO_CTRL2, FDO_PWM_MODE, mode));
1772 smu_v11_0_set_fan_speed_percent(struct smu_context *smu, uint32_t speed)
1774 struct amdgpu_device *adev = smu->adev;
1783 if (smu_v11_0_smc_fan_control(smu, stop))
1785 duty100 = REG_GET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL1),
1786 CG_FDO_CTRL1, FMAX_DUTY100);
1790 tmp64 = (uint64_t)speed * duty100;
1792 duty = (uint32_t)tmp64;
1794 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL0,
1795 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL0),
1796 CG_FDO_CTRL0, FDO_STATIC_DUTY, duty));
1798 return smu_v11_0_set_fan_static_mode(smu, FDO_PWM_MODE_STATIC);
1802 smu_v11_0_set_fan_control_mode(struct smu_context *smu,
1810 case AMD_FAN_CTRL_NONE:
1811 ret = smu_v11_0_set_fan_speed_percent(smu, 100);
1813 case AMD_FAN_CTRL_MANUAL:
1814 ret = smu_v11_0_smc_fan_control(smu, stop);
1816 case AMD_FAN_CTRL_AUTO:
1817 ret = smu_v11_0_smc_fan_control(smu, start);
1824 pr_err("[%s]Set fan control mode failed!", __func__);
1831 static int smu_v11_0_set_fan_speed_rpm(struct smu_context *smu,
1834 struct amdgpu_device *adev = smu->adev;
1836 uint32_t tach_period, crystal_clock_freq;
1842 mutex_lock(&(smu->mutex));
1843 ret = smu_v11_0_smc_fan_control(smu, stop);
1845 goto set_fan_speed_rpm_failed;
1847 crystal_clock_freq = amdgpu_asic_get_xclk(adev);
1848 tach_period = 60 * crystal_clock_freq * 10000 / (8 * speed);
1849 WREG32_SOC15(THM, 0, mmCG_TACH_CTRL,
1850 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_TACH_CTRL),
1851 CG_TACH_CTRL, TARGET_PERIOD,
1854 ret = smu_v11_0_set_fan_static_mode(smu, FDO_PWM_MODE_STATIC_RPM);
1856 set_fan_speed_rpm_failed:
1857 mutex_unlock(&(smu->mutex));
1861 static int smu_v11_0_set_xgmi_pstate(struct smu_context *smu,
1865 mutex_lock(&(smu->mutex));
1866 ret = smu_send_smc_msg_with_param(smu,
1867 SMU_MSG_SetXgmiMode,
1868 pstate ? XGMI_STATE_D0 : XGMI_STATE_D3);
1869 mutex_unlock(&(smu->mutex));
1873 static const struct smu_funcs smu_v11_0_funcs = {
1874 .init_microcode = smu_v11_0_init_microcode,
1875 .load_microcode = smu_v11_0_load_microcode,
1876 .check_fw_status = smu_v11_0_check_fw_status,
1877 .check_fw_version = smu_v11_0_check_fw_version,
1878 .send_smc_msg = smu_v11_0_send_msg,
1879 .send_smc_msg_with_param = smu_v11_0_send_msg_with_param,
1880 .read_smc_arg = smu_v11_0_read_arg,
1881 .setup_pptable = smu_v11_0_setup_pptable,
1882 .init_smc_tables = smu_v11_0_init_smc_tables,
1883 .fini_smc_tables = smu_v11_0_fini_smc_tables,
1884 .init_power = smu_v11_0_init_power,
1885 .fini_power = smu_v11_0_fini_power,
1886 .get_vbios_bootup_values = smu_v11_0_get_vbios_bootup_values,
1887 .get_clk_info_from_vbios = smu_v11_0_get_clk_info_from_vbios,
1888 .notify_memory_pool_location = smu_v11_0_notify_memory_pool_location,
1889 .check_pptable = smu_v11_0_check_pptable,
1890 .parse_pptable = smu_v11_0_parse_pptable,
1891 .populate_smc_pptable = smu_v11_0_populate_smc_pptable,
1892 .write_pptable = smu_v11_0_write_pptable,
1893 .write_watermarks_table = smu_v11_0_write_watermarks_table,
1894 .set_min_dcef_deep_sleep = smu_v11_0_set_min_dcef_deep_sleep,
1895 .set_tool_table_location = smu_v11_0_set_tool_table_location,
1896 .init_display = smu_v11_0_init_display,
1897 .set_allowed_mask = smu_v11_0_set_allowed_mask,
1898 .get_enabled_mask = smu_v11_0_get_enabled_mask,
1899 .system_features_control = smu_v11_0_system_features_control,
1900 .update_feature_enable_state = smu_v11_0_update_feature_enable_state,
1901 .notify_display_change = smu_v11_0_notify_display_change,
1902 .get_power_limit = smu_v11_0_get_power_limit,
1903 .set_power_limit = smu_v11_0_set_power_limit,
1904 .get_current_clk_freq = smu_v11_0_get_current_clk_freq,
1905 .init_max_sustainable_clocks = smu_v11_0_init_max_sustainable_clocks,
1906 .start_thermal_control = smu_v11_0_start_thermal_control,
1907 .read_sensor = smu_v11_0_read_sensor,
1908 .set_deep_sleep_dcefclk = smu_v11_0_set_deep_sleep_dcefclk,
1909 .display_clock_voltage_request = smu_v11_0_display_clock_voltage_request,
1910 .set_watermarks_for_clock_ranges = smu_v11_0_set_watermarks_for_clock_ranges,
1911 .get_sclk = smu_v11_0_dpm_get_sclk,
1912 .get_mclk = smu_v11_0_dpm_get_mclk,
1913 .set_od8_default_settings = smu_v11_0_set_od8_default_settings,
1914 .update_od8_settings = smu_v11_0_update_od8_settings,
1915 .get_current_rpm = smu_v11_0_get_current_rpm,
1916 .get_fan_control_mode = smu_v11_0_get_fan_control_mode,
1917 .set_fan_control_mode = smu_v11_0_set_fan_control_mode,
1918 .get_fan_speed_percent = smu_v11_0_get_fan_speed_percent,
1919 .set_fan_speed_percent = smu_v11_0_set_fan_speed_percent,
1920 .set_fan_speed_rpm = smu_v11_0_set_fan_speed_rpm,
1921 .set_xgmi_pstate = smu_v11_0_set_xgmi_pstate,
1924 void smu_v11_0_set_smu_funcs(struct smu_context *smu)
1926 struct amdgpu_device *adev = smu->adev;
1928 smu->funcs = &smu_v11_0_funcs;
1929 switch (adev->asic_type) {
1931 vega20_set_ppt_funcs(smu);
1934 navi10_set_ppt_funcs(smu);
1937 pr_warn("Unknown asic for smu11\n");