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"
34 #include "pp_thermal.h"
36 #include "asic_reg/thm/thm_11_0_2_offset.h"
37 #include "asic_reg/thm/thm_11_0_2_sh_mask.h"
38 #include "asic_reg/mp/mp_11_0_offset.h"
39 #include "asic_reg/mp/mp_11_0_sh_mask.h"
40 #include "asic_reg/nbio/nbio_7_4_offset.h"
41 #include "asic_reg/smuio/smuio_11_0_0_offset.h"
42 #include "asic_reg/smuio/smuio_11_0_0_sh_mask.h"
44 MODULE_FIRMWARE("amdgpu/vega20_smc.bin");
45 MODULE_FIRMWARE("amdgpu/navi10_smc.bin");
47 #define SMU11_THERMAL_MINIMUM_ALERT_TEMP 0
48 #define SMU11_THERMAL_MAXIMUM_ALERT_TEMP 255
50 #define SMU11_TEMPERATURE_UNITS_PER_CENTIGRADES 1000
51 #define SMU11_VOLTAGE_SCALE 4
53 static int smu_v11_0_send_msg_without_waiting(struct smu_context *smu,
56 struct amdgpu_device *adev = smu->adev;
57 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_66, msg);
61 static int smu_v11_0_read_arg(struct smu_context *smu, uint32_t *arg)
63 struct amdgpu_device *adev = smu->adev;
65 *arg = RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_82);
69 static int smu_v11_0_wait_for_response(struct smu_context *smu)
71 struct amdgpu_device *adev = smu->adev;
72 uint32_t cur_value, i;
74 for (i = 0; i < adev->usec_timeout; i++) {
75 cur_value = RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90);
76 if ((cur_value & MP1_C2PMSG_90__CONTENT_MASK) != 0)
81 /* timeout means wrong logic */
82 if (i == adev->usec_timeout)
85 return RREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90) == 0x1 ? 0 : -EIO;
88 static int smu_v11_0_send_msg(struct smu_context *smu, uint16_t msg)
90 struct amdgpu_device *adev = smu->adev;
91 int ret = 0, index = 0;
93 index = smu_msg_get_index(smu, msg);
97 smu_v11_0_wait_for_response(smu);
99 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90, 0);
101 smu_v11_0_send_msg_without_waiting(smu, (uint16_t)index);
103 ret = smu_v11_0_wait_for_response(smu);
106 pr_err("Failed to send message 0x%x, response 0x%x\n", index,
114 smu_v11_0_send_msg_with_param(struct smu_context *smu, uint16_t msg,
118 struct amdgpu_device *adev = smu->adev;
119 int ret = 0, index = 0;
121 index = smu_msg_get_index(smu, msg);
125 ret = smu_v11_0_wait_for_response(smu);
127 pr_err("Failed to send message 0x%x, response 0x%x, param 0x%x\n",
130 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_90, 0);
132 WREG32_SOC15(MP1, 0, mmMP1_SMN_C2PMSG_82, param);
134 smu_v11_0_send_msg_without_waiting(smu, (uint16_t)index);
136 ret = smu_v11_0_wait_for_response(smu);
138 pr_err("Failed to send message 0x%x, response 0x%x param 0x%x\n",
144 static int smu_v11_0_init_microcode(struct smu_context *smu)
146 struct amdgpu_device *adev = smu->adev;
147 const char *chip_name;
150 const struct smc_firmware_header_v1_0 *hdr;
151 const struct common_firmware_header *header;
152 struct amdgpu_firmware_info *ucode = NULL;
154 switch (adev->asic_type) {
156 chip_name = "vega20";
159 chip_name = "navi10";
165 snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_smc.bin", chip_name);
167 err = request_firmware(&adev->pm.fw, fw_name, adev->dev);
170 err = amdgpu_ucode_validate(adev->pm.fw);
174 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
175 amdgpu_ucode_print_smc_hdr(&hdr->header);
176 adev->pm.fw_version = le32_to_cpu(hdr->header.ucode_version);
178 if (adev->firmware.load_type == AMDGPU_FW_LOAD_PSP) {
179 ucode = &adev->firmware.ucode[AMDGPU_UCODE_ID_SMC];
180 ucode->ucode_id = AMDGPU_UCODE_ID_SMC;
181 ucode->fw = adev->pm.fw;
182 header = (const struct common_firmware_header *)ucode->fw->data;
183 adev->firmware.fw_size +=
184 ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);
189 DRM_ERROR("smu_v11_0: Failed to load firmware \"%s\"\n",
191 release_firmware(adev->pm.fw);
197 static int smu_v11_0_load_microcode(struct smu_context *smu)
199 struct amdgpu_device *adev = smu->adev;
201 const struct smc_firmware_header_v1_0 *hdr;
202 uint32_t addr_start = MP1_SRAM;
204 uint32_t mp1_fw_flags;
206 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
207 src = (const uint32_t *)(adev->pm.fw->data +
208 le32_to_cpu(hdr->header.ucode_array_offset_bytes));
210 for (i = 1; i < MP1_SMC_SIZE/4 - 1; i++) {
211 WREG32_PCIE(addr_start, src[i]);
215 WREG32_PCIE(MP1_Public | (smnMP1_PUB_CTRL & 0xffffffff),
216 1 & MP1_SMN_PUB_CTRL__RESET_MASK);
217 WREG32_PCIE(MP1_Public | (smnMP1_PUB_CTRL & 0xffffffff),
218 1 & ~MP1_SMN_PUB_CTRL__RESET_MASK);
220 for (i = 0; i < adev->usec_timeout; i++) {
221 mp1_fw_flags = RREG32_PCIE(MP1_Public |
222 (smnMP1_FIRMWARE_FLAGS & 0xffffffff));
223 if ((mp1_fw_flags & MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED_MASK) >>
224 MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED__SHIFT)
229 if (i == adev->usec_timeout)
235 static int smu_v11_0_check_fw_status(struct smu_context *smu)
237 struct amdgpu_device *adev = smu->adev;
238 uint32_t mp1_fw_flags;
240 mp1_fw_flags = RREG32_PCIE(MP1_Public |
241 (smnMP1_FIRMWARE_FLAGS & 0xffffffff));
243 if ((mp1_fw_flags & MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED_MASK) >>
244 MP1_FIRMWARE_FLAGS__INTERRUPTS_ENABLED__SHIFT)
250 static int smu_v11_0_check_fw_version(struct smu_context *smu)
252 uint32_t if_version = 0xff, smu_version = 0xff;
254 uint8_t smu_minor, smu_debug;
257 ret = smu_get_smc_version(smu, &if_version, &smu_version);
261 smu_major = (smu_version >> 16) & 0xffff;
262 smu_minor = (smu_version >> 8) & 0xff;
263 smu_debug = (smu_version >> 0) & 0xff;
265 pr_info("SMU Driver IF Version = 0x%08x, SMU FW Version = 0x%08x (%d.%d.%d)\n",
266 if_version, smu_version, smu_major, smu_minor, smu_debug);
268 if (if_version != smu->smc_if_version) {
269 pr_err("SMU driver if version not matched\n");
276 static int smu_v11_0_set_pptable_v2_0(struct smu_context *smu, void **table, uint32_t *size)
278 struct amdgpu_device *adev = smu->adev;
279 uint32_t ppt_offset_bytes;
280 const struct smc_firmware_header_v2_0 *v2;
282 v2 = (const struct smc_firmware_header_v2_0 *) adev->pm.fw->data;
284 ppt_offset_bytes = le32_to_cpu(v2->ppt_offset_bytes);
285 *size = le32_to_cpu(v2->ppt_size_bytes);
286 *table = (uint8_t *)v2 + ppt_offset_bytes;
291 static int smu_v11_0_set_pptable_v2_1(struct smu_context *smu, void **table, uint32_t *size, uint32_t pptable_id)
293 struct amdgpu_device *adev = smu->adev;
294 const struct smc_firmware_header_v2_1 *v2_1;
295 struct smc_soft_pptable_entry *entries;
296 uint32_t pptable_count = 0;
299 v2_1 = (const struct smc_firmware_header_v2_1 *) adev->pm.fw->data;
300 entries = (struct smc_soft_pptable_entry *)
301 ((uint8_t *)v2_1 + le32_to_cpu(v2_1->pptable_entry_offset));
302 pptable_count = le32_to_cpu(v2_1->pptable_count);
303 for (i = 0; i < pptable_count; i++) {
304 if (le32_to_cpu(entries[i].id) == pptable_id) {
305 *table = ((uint8_t *)v2_1 + le32_to_cpu(entries[i].ppt_offset_bytes));
306 *size = le32_to_cpu(entries[i].ppt_size_bytes);
311 if (i == pptable_count)
317 static int smu_v11_0_setup_pptable(struct smu_context *smu)
319 struct amdgpu_device *adev = smu->adev;
320 const struct smc_firmware_header_v1_0 *hdr;
325 uint16_t version_major, version_minor;
327 hdr = (const struct smc_firmware_header_v1_0 *) adev->pm.fw->data;
328 version_major = le16_to_cpu(hdr->header.header_version_major);
329 version_minor = le16_to_cpu(hdr->header.header_version_minor);
330 if (version_major == 2 && smu->smu_table.boot_values.pp_table_id > 0) {
331 switch (version_minor) {
333 ret = smu_v11_0_set_pptable_v2_0(smu, &table, &size);
336 ret = smu_v11_0_set_pptable_v2_1(smu, &table, &size,
337 smu->smu_table.boot_values.pp_table_id);
347 index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1,
350 ret = smu_get_atom_data_table(smu, index, (uint16_t *)&size, &frev, &crev,
356 if (!smu->smu_table.power_play_table)
357 smu->smu_table.power_play_table = table;
358 if (!smu->smu_table.power_play_table_size)
359 smu->smu_table.power_play_table_size = size;
364 static int smu_v11_0_init_dpm_context(struct smu_context *smu)
366 struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
368 if (smu_dpm->dpm_context || smu_dpm->dpm_context_size != 0)
371 return smu_alloc_dpm_context(smu);
374 static int smu_v11_0_fini_dpm_context(struct smu_context *smu)
376 struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
378 if (!smu_dpm->dpm_context || smu_dpm->dpm_context_size == 0)
381 kfree(smu_dpm->dpm_context);
382 kfree(smu_dpm->golden_dpm_context);
383 kfree(smu_dpm->dpm_current_power_state);
384 kfree(smu_dpm->dpm_request_power_state);
385 smu_dpm->dpm_context = NULL;
386 smu_dpm->golden_dpm_context = NULL;
387 smu_dpm->dpm_context_size = 0;
388 smu_dpm->dpm_current_power_state = NULL;
389 smu_dpm->dpm_request_power_state = NULL;
394 static int smu_v11_0_init_smc_tables(struct smu_context *smu)
396 struct smu_table_context *smu_table = &smu->smu_table;
397 struct smu_table *tables = NULL;
400 if (smu_table->tables || smu_table->table_count == 0)
403 tables = kcalloc(SMU_TABLE_COUNT, sizeof(struct smu_table),
408 smu_table->tables = tables;
410 ret = smu_tables_init(smu, tables);
414 ret = smu_v11_0_init_dpm_context(smu);
421 static int smu_v11_0_fini_smc_tables(struct smu_context *smu)
423 struct smu_table_context *smu_table = &smu->smu_table;
426 if (!smu_table->tables || smu_table->table_count == 0)
429 kfree(smu_table->tables);
430 kfree(smu_table->metrics_table);
431 smu_table->tables = NULL;
432 smu_table->table_count = 0;
433 smu_table->metrics_table = NULL;
434 smu_table->metrics_time = 0;
436 ret = smu_v11_0_fini_dpm_context(smu);
442 static int smu_v11_0_init_power(struct smu_context *smu)
444 struct smu_power_context *smu_power = &smu->smu_power;
446 if (!smu->pm_enabled)
448 if (smu_power->power_context || smu_power->power_context_size != 0)
451 smu_power->power_context = kzalloc(sizeof(struct smu_11_0_dpm_context),
453 if (!smu_power->power_context)
455 smu_power->power_context_size = sizeof(struct smu_11_0_dpm_context);
460 static int smu_v11_0_fini_power(struct smu_context *smu)
462 struct smu_power_context *smu_power = &smu->smu_power;
464 if (!smu->pm_enabled)
466 if (!smu_power->power_context || smu_power->power_context_size == 0)
469 kfree(smu_power->power_context);
470 smu_power->power_context = NULL;
471 smu_power->power_context_size = 0;
476 int smu_v11_0_get_vbios_bootup_values(struct smu_context *smu)
481 struct atom_common_table_header *header;
482 struct atom_firmware_info_v3_3 *v_3_3;
483 struct atom_firmware_info_v3_1 *v_3_1;
485 index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1,
488 ret = smu_get_atom_data_table(smu, index, &size, &frev, &crev,
489 (uint8_t **)&header);
493 if (header->format_revision != 3) {
494 pr_err("unknown atom_firmware_info version! for smu11\n");
498 switch (header->content_revision) {
502 v_3_1 = (struct atom_firmware_info_v3_1 *)header;
503 smu->smu_table.boot_values.revision = v_3_1->firmware_revision;
504 smu->smu_table.boot_values.gfxclk = v_3_1->bootup_sclk_in10khz;
505 smu->smu_table.boot_values.uclk = v_3_1->bootup_mclk_in10khz;
506 smu->smu_table.boot_values.socclk = 0;
507 smu->smu_table.boot_values.dcefclk = 0;
508 smu->smu_table.boot_values.vddc = v_3_1->bootup_vddc_mv;
509 smu->smu_table.boot_values.vddci = v_3_1->bootup_vddci_mv;
510 smu->smu_table.boot_values.mvddc = v_3_1->bootup_mvddc_mv;
511 smu->smu_table.boot_values.vdd_gfx = v_3_1->bootup_vddgfx_mv;
512 smu->smu_table.boot_values.cooling_id = v_3_1->coolingsolution_id;
513 smu->smu_table.boot_values.pp_table_id = 0;
517 v_3_3 = (struct atom_firmware_info_v3_3 *)header;
518 smu->smu_table.boot_values.revision = v_3_3->firmware_revision;
519 smu->smu_table.boot_values.gfxclk = v_3_3->bootup_sclk_in10khz;
520 smu->smu_table.boot_values.uclk = v_3_3->bootup_mclk_in10khz;
521 smu->smu_table.boot_values.socclk = 0;
522 smu->smu_table.boot_values.dcefclk = 0;
523 smu->smu_table.boot_values.vddc = v_3_3->bootup_vddc_mv;
524 smu->smu_table.boot_values.vddci = v_3_3->bootup_vddci_mv;
525 smu->smu_table.boot_values.mvddc = v_3_3->bootup_mvddc_mv;
526 smu->smu_table.boot_values.vdd_gfx = v_3_3->bootup_vddgfx_mv;
527 smu->smu_table.boot_values.cooling_id = v_3_3->coolingsolution_id;
528 smu->smu_table.boot_values.pp_table_id = v_3_3->pplib_pptable_id;
534 static int smu_v11_0_get_clk_info_from_vbios(struct smu_context *smu)
537 struct amdgpu_device *adev = smu->adev;
538 struct atom_get_smu_clock_info_parameters_v3_1 input = {0};
539 struct atom_get_smu_clock_info_output_parameters_v3_1 *output;
541 input.clk_id = SMU11_SYSPLL0_SOCCLK_ID;
542 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
543 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
546 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
551 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
552 smu->smu_table.boot_values.socclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
554 memset(&input, 0, sizeof(input));
555 input.clk_id = SMU11_SYSPLL0_DCEFCLK_ID;
556 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
557 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
560 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
565 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
566 smu->smu_table.boot_values.dcefclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
568 memset(&input, 0, sizeof(input));
569 input.clk_id = SMU11_SYSPLL0_ECLK_ID;
570 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
571 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
574 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
579 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
580 smu->smu_table.boot_values.eclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
582 memset(&input, 0, sizeof(input));
583 input.clk_id = SMU11_SYSPLL0_VCLK_ID;
584 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
585 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
588 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
593 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
594 smu->smu_table.boot_values.vclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
596 memset(&input, 0, sizeof(input));
597 input.clk_id = SMU11_SYSPLL0_DCLK_ID;
598 input.command = GET_SMU_CLOCK_INFO_V3_1_GET_CLOCK_FREQ;
599 index = get_index_into_master_table(atom_master_list_of_command_functions_v2_1,
602 ret = amdgpu_atom_execute_table(adev->mode_info.atom_context, index,
607 output = (struct atom_get_smu_clock_info_output_parameters_v3_1 *)&input;
608 smu->smu_table.boot_values.dclk = le32_to_cpu(output->atom_smu_outputclkfreq.smu_clock_freq_hz) / 10000;
613 static int smu_v11_0_notify_memory_pool_location(struct smu_context *smu)
615 struct smu_table_context *smu_table = &smu->smu_table;
616 struct smu_table *memory_pool = &smu_table->memory_pool;
619 uint32_t address_low, address_high;
621 if (memory_pool->size == 0 || memory_pool->cpu_addr == NULL)
624 address = (uintptr_t)memory_pool->cpu_addr;
625 address_high = (uint32_t)upper_32_bits(address);
626 address_low = (uint32_t)lower_32_bits(address);
628 ret = smu_send_smc_msg_with_param(smu,
629 SMU_MSG_SetSystemVirtualDramAddrHigh,
633 ret = smu_send_smc_msg_with_param(smu,
634 SMU_MSG_SetSystemVirtualDramAddrLow,
639 address = memory_pool->mc_address;
640 address_high = (uint32_t)upper_32_bits(address);
641 address_low = (uint32_t)lower_32_bits(address);
643 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramAddrHigh,
647 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramAddrLow,
651 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DramLogSetDramSize,
652 (uint32_t)memory_pool->size);
659 static int smu_v11_0_check_pptable(struct smu_context *smu)
663 ret = smu_check_powerplay_table(smu);
667 static int smu_v11_0_parse_pptable(struct smu_context *smu)
671 struct smu_table_context *table_context = &smu->smu_table;
672 struct smu_table *table = &table_context->tables[SMU_TABLE_PPTABLE];
674 if (table_context->driver_pptable)
677 table_context->driver_pptable = kzalloc(table->size, GFP_KERNEL);
679 if (!table_context->driver_pptable)
682 ret = smu_store_powerplay_table(smu);
686 ret = smu_append_powerplay_table(smu);
691 static int smu_v11_0_populate_smc_pptable(struct smu_context *smu)
695 ret = smu_set_default_dpm_table(smu);
700 static int smu_v11_0_write_pptable(struct smu_context *smu)
702 struct smu_table_context *table_context = &smu->smu_table;
705 ret = smu_update_table(smu, SMU_TABLE_PPTABLE,
706 table_context->driver_pptable, true);
711 static int smu_v11_0_write_watermarks_table(struct smu_context *smu)
714 struct smu_table_context *smu_table = &smu->smu_table;
715 struct smu_table *table = NULL;
717 table = &smu_table->tables[SMU_TABLE_WATERMARKS];
721 if (!table->cpu_addr)
724 ret = smu_update_table(smu, SMU_TABLE_WATERMARKS, table->cpu_addr,
730 static int smu_v11_0_set_deep_sleep_dcefclk(struct smu_context *smu, uint32_t clk)
734 ret = smu_send_smc_msg_with_param(smu,
735 SMU_MSG_SetMinDeepSleepDcefclk, clk);
737 pr_err("SMU11 attempt to set divider for DCEFCLK Failed!");
742 static int smu_v11_0_set_min_dcef_deep_sleep(struct smu_context *smu)
744 struct smu_table_context *table_context = &smu->smu_table;
746 if (!smu->pm_enabled)
751 return smu_set_deep_sleep_dcefclk(smu,
752 table_context->boot_values.dcefclk / 100);
755 static int smu_v11_0_set_tool_table_location(struct smu_context *smu)
758 struct smu_table *tool_table = &smu->smu_table.tables[SMU_TABLE_PMSTATUSLOG];
760 if (tool_table->mc_address) {
761 ret = smu_send_smc_msg_with_param(smu,
762 SMU_MSG_SetToolsDramAddrHigh,
763 upper_32_bits(tool_table->mc_address));
765 ret = smu_send_smc_msg_with_param(smu,
766 SMU_MSG_SetToolsDramAddrLow,
767 lower_32_bits(tool_table->mc_address));
773 static int smu_v11_0_init_display(struct smu_context *smu)
777 if (!smu->pm_enabled)
779 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_NumOfDisplays, 0);
783 static int smu_v11_0_update_feature_enable_state(struct smu_context *smu, uint32_t feature_id, bool enabled)
785 uint32_t feature_low = 0, feature_high = 0;
788 if (!smu->pm_enabled)
790 if (feature_id >= 0 && feature_id < 31)
791 feature_low = (1 << feature_id);
792 else if (feature_id > 31 && feature_id < 63)
793 feature_high = (1 << feature_id);
798 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesLow,
802 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesHigh,
808 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesLow,
812 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesHigh,
822 static int smu_v11_0_set_allowed_mask(struct smu_context *smu)
824 struct smu_feature *feature = &smu->smu_feature;
826 uint32_t feature_mask[2];
828 mutex_lock(&feature->mutex);
829 if (bitmap_empty(feature->allowed, SMU_FEATURE_MAX) || feature->feature_num < 64)
832 bitmap_copy((unsigned long *)feature_mask, feature->allowed, 64);
834 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskHigh,
839 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskLow,
845 mutex_unlock(&feature->mutex);
849 static int smu_v11_0_get_enabled_mask(struct smu_context *smu,
850 uint32_t *feature_mask, uint32_t num)
852 uint32_t feature_mask_high = 0, feature_mask_low = 0;
855 if (!feature_mask || num < 2)
858 ret = smu_send_smc_msg(smu, SMU_MSG_GetEnabledSmuFeaturesHigh);
861 ret = smu_read_smc_arg(smu, &feature_mask_high);
865 ret = smu_send_smc_msg(smu, SMU_MSG_GetEnabledSmuFeaturesLow);
868 ret = smu_read_smc_arg(smu, &feature_mask_low);
872 feature_mask[0] = feature_mask_low;
873 feature_mask[1] = feature_mask_high;
878 static int smu_v11_0_system_features_control(struct smu_context *smu,
881 struct smu_feature *feature = &smu->smu_feature;
882 uint32_t feature_mask[2];
885 if (smu->pm_enabled) {
886 ret = smu_send_smc_msg(smu, (en ? SMU_MSG_EnableAllSmuFeatures :
887 SMU_MSG_DisableAllSmuFeatures));
892 ret = smu_feature_get_enabled_mask(smu, feature_mask, 2);
896 bitmap_copy(feature->enabled, (unsigned long *)&feature_mask,
897 feature->feature_num);
898 bitmap_copy(feature->supported, (unsigned long *)&feature_mask,
899 feature->feature_num);
904 static int smu_v11_0_notify_display_change(struct smu_context *smu)
908 if (!smu->pm_enabled)
910 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_UCLK_BIT) &&
911 smu->adev->gmc.vram_type == AMDGPU_VRAM_TYPE_HBM)
912 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetUclkFastSwitch, 1);
918 smu_v11_0_get_max_sustainable_clock(struct smu_context *smu, uint32_t *clock,
919 enum smu_clk_type clock_select)
923 if (!smu->pm_enabled)
925 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetDcModeMaxDpmFreq,
926 smu_clk_get_index(smu, clock_select) << 16);
928 pr_err("[GetMaxSustainableClock] Failed to get max DC clock from SMC!");
932 ret = smu_read_smc_arg(smu, clock);
939 /* if DC limit is zero, return AC limit */
940 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMaxDpmFreq,
941 smu_clk_get_index(smu, clock_select) << 16);
943 pr_err("[GetMaxSustainableClock] failed to get max AC clock from SMC!");
947 ret = smu_read_smc_arg(smu, clock);
952 static int smu_v11_0_init_max_sustainable_clocks(struct smu_context *smu)
954 struct smu_11_0_max_sustainable_clocks *max_sustainable_clocks;
957 max_sustainable_clocks = kzalloc(sizeof(struct smu_11_0_max_sustainable_clocks),
959 smu->smu_table.max_sustainable_clocks = (void *)max_sustainable_clocks;
961 max_sustainable_clocks->uclock = smu->smu_table.boot_values.uclk / 100;
962 max_sustainable_clocks->soc_clock = smu->smu_table.boot_values.socclk / 100;
963 max_sustainable_clocks->dcef_clock = smu->smu_table.boot_values.dcefclk / 100;
964 max_sustainable_clocks->display_clock = 0xFFFFFFFF;
965 max_sustainable_clocks->phy_clock = 0xFFFFFFFF;
966 max_sustainable_clocks->pixel_clock = 0xFFFFFFFF;
968 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_UCLK_BIT)) {
969 ret = smu_v11_0_get_max_sustainable_clock(smu,
970 &(max_sustainable_clocks->uclock),
973 pr_err("[%s] failed to get max UCLK from SMC!",
979 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {
980 ret = smu_v11_0_get_max_sustainable_clock(smu,
981 &(max_sustainable_clocks->soc_clock),
984 pr_err("[%s] failed to get max SOCCLK from SMC!",
990 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT)) {
991 ret = smu_v11_0_get_max_sustainable_clock(smu,
992 &(max_sustainable_clocks->dcef_clock),
995 pr_err("[%s] failed to get max DCEFCLK from SMC!",
1000 ret = smu_v11_0_get_max_sustainable_clock(smu,
1001 &(max_sustainable_clocks->display_clock),
1004 pr_err("[%s] failed to get max DISPCLK from SMC!",
1008 ret = smu_v11_0_get_max_sustainable_clock(smu,
1009 &(max_sustainable_clocks->phy_clock),
1012 pr_err("[%s] failed to get max PHYCLK from SMC!",
1016 ret = smu_v11_0_get_max_sustainable_clock(smu,
1017 &(max_sustainable_clocks->pixel_clock),
1020 pr_err("[%s] failed to get max PIXCLK from SMC!",
1026 if (max_sustainable_clocks->soc_clock < max_sustainable_clocks->uclock)
1027 max_sustainable_clocks->uclock = max_sustainable_clocks->soc_clock;
1032 static int smu_v11_0_get_power_limit(struct smu_context *smu,
1039 mutex_lock(&smu->mutex);
1040 *limit = smu->default_power_limit;
1041 if (smu->od_enabled) {
1042 *limit *= (100 + smu->smu_table.TDPODLimit);
1045 mutex_unlock(&smu->mutex);
1047 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetPptLimit,
1048 smu_power_get_index(smu, SMU_POWER_SOURCE_AC) << 16);
1050 pr_err("[%s] get PPT limit failed!", __func__);
1053 smu_read_smc_arg(smu, limit);
1054 smu->power_limit = *limit;
1060 static int smu_v11_0_set_power_limit(struct smu_context *smu, uint32_t n)
1062 uint32_t max_power_limit;
1066 n = smu->default_power_limit;
1068 max_power_limit = smu->default_power_limit;
1070 if (smu->od_enabled) {
1071 max_power_limit *= (100 + smu->smu_table.TDPODLimit);
1072 max_power_limit /= 100;
1075 if (smu_feature_is_enabled(smu, SMU_FEATURE_PPT_BIT))
1076 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetPptLimit, n);
1078 pr_err("[%s] Set power limit Failed!", __func__);
1085 static int smu_v11_0_get_current_clk_freq(struct smu_context *smu,
1086 enum smu_clk_type clk_id,
1092 if (clk_id >= SMU_CLK_COUNT || !value)
1095 /* if don't has GetDpmClockFreq Message, try get current clock by SmuMetrics_t */
1096 if (smu_msg_get_index(smu, SMU_MSG_GetDpmClockFreq) == 0)
1097 ret = smu_get_current_clk_freq_by_table(smu, clk_id, &freq);
1099 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetDpmClockFreq,
1100 (smu_clk_get_index(smu, clk_id) << 16));
1104 ret = smu_read_smc_arg(smu, &freq);
1115 static int smu_v11_0_get_thermal_range(struct smu_context *smu,
1116 struct PP_TemperatureRange *range)
1118 PPTable_t *pptable = smu->smu_table.driver_pptable;
1119 memcpy(range, &SMU7ThermalWithDelayPolicy[0], sizeof(struct PP_TemperatureRange));
1121 range->max = pptable->TedgeLimit *
1122 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1123 range->edge_emergency_max = (pptable->TedgeLimit + CTF_OFFSET_EDGE) *
1124 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1125 range->hotspot_crit_max = pptable->ThotspotLimit *
1126 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1127 range->hotspot_emergency_max = (pptable->ThotspotLimit + CTF_OFFSET_HOTSPOT) *
1128 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1129 range->mem_crit_max = pptable->ThbmLimit *
1130 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1131 range->mem_emergency_max = (pptable->ThbmLimit + CTF_OFFSET_HBM)*
1132 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1137 static int smu_v11_0_set_thermal_range(struct smu_context *smu,
1138 struct PP_TemperatureRange *range)
1140 struct amdgpu_device *adev = smu->adev;
1141 int low = SMU11_THERMAL_MINIMUM_ALERT_TEMP *
1142 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1143 int high = SMU11_THERMAL_MAXIMUM_ALERT_TEMP *
1144 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1147 if (low < range->min)
1149 if (high > range->max)
1155 val = RREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_CTRL);
1156 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, MAX_IH_CREDIT, 5);
1157 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, THERM_IH_HW_ENA, 1);
1158 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, DIG_THERM_INTH, (high / PP_TEMPERATURE_UNITS_PER_CENTIGRADES));
1159 val = REG_SET_FIELD(val, THM_THERMAL_INT_CTRL, DIG_THERM_INTL, (low / PP_TEMPERATURE_UNITS_PER_CENTIGRADES));
1160 val = val & (~THM_THERMAL_INT_CTRL__THERM_TRIGGER_MASK_MASK);
1162 WREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_CTRL, val);
1167 static int smu_v11_0_enable_thermal_alert(struct smu_context *smu)
1169 struct amdgpu_device *adev = smu->adev;
1172 val |= (1 << THM_THERMAL_INT_ENA__THERM_INTH_CLR__SHIFT);
1173 val |= (1 << THM_THERMAL_INT_ENA__THERM_INTL_CLR__SHIFT);
1174 val |= (1 << THM_THERMAL_INT_ENA__THERM_TRIGGER_CLR__SHIFT);
1176 WREG32_SOC15(THM, 0, mmTHM_THERMAL_INT_ENA, val);
1181 static int smu_v11_0_start_thermal_control(struct smu_context *smu)
1184 struct PP_TemperatureRange range = {
1194 struct amdgpu_device *adev = smu->adev;
1196 if (!smu->pm_enabled)
1198 smu_v11_0_get_thermal_range(smu, &range);
1200 if (smu->smu_table.thermal_controller_type) {
1201 ret = smu_v11_0_set_thermal_range(smu, &range);
1205 ret = smu_v11_0_enable_thermal_alert(smu);
1208 ret = smu_set_thermal_fan_table(smu);
1213 adev->pm.dpm.thermal.min_temp = range.min;
1214 adev->pm.dpm.thermal.max_temp = range.max;
1215 adev->pm.dpm.thermal.max_edge_emergency_temp = range.edge_emergency_max;
1216 adev->pm.dpm.thermal.min_hotspot_temp = range.hotspot_min;
1217 adev->pm.dpm.thermal.max_hotspot_crit_temp = range.hotspot_crit_max;
1218 adev->pm.dpm.thermal.max_hotspot_emergency_temp = range.hotspot_emergency_max;
1219 adev->pm.dpm.thermal.min_mem_temp = range.mem_min;
1220 adev->pm.dpm.thermal.max_mem_crit_temp = range.mem_crit_max;
1221 adev->pm.dpm.thermal.max_mem_emergency_temp = range.mem_emergency_max;
1226 static int smu_v11_0_thermal_get_temperature(struct smu_context *smu,
1227 enum amd_pp_sensors sensor,
1230 struct amdgpu_device *adev = smu->adev;
1231 SmuMetrics_t metrics;
1238 ret = smu_v11_0_get_metrics_table(smu, &metrics);
1243 case AMDGPU_PP_SENSOR_HOTSPOT_TEMP:
1244 temp = RREG32_SOC15(THM, 0, mmCG_MULT_THERMAL_STATUS);
1245 temp = (temp & CG_MULT_THERMAL_STATUS__CTF_TEMP_MASK) >>
1246 CG_MULT_THERMAL_STATUS__CTF_TEMP__SHIFT;
1248 temp = temp & 0x1ff;
1249 temp *= SMU11_TEMPERATURE_UNITS_PER_CENTIGRADES;
1253 case AMDGPU_PP_SENSOR_EDGE_TEMP:
1254 *value = metrics.TemperatureEdge *
1255 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1257 case AMDGPU_PP_SENSOR_MEM_TEMP:
1258 *value = metrics.TemperatureHBM *
1259 PP_TEMPERATURE_UNITS_PER_CENTIGRADES;
1262 pr_err("Invalid sensor for retrieving temp\n");
1268 static uint16_t convert_to_vddc(uint8_t vid)
1270 return (uint16_t) ((6200 - (vid * 25)) / SMU11_VOLTAGE_SCALE);
1273 static int smu_v11_0_get_gfx_vdd(struct smu_context *smu, uint32_t *value)
1275 struct amdgpu_device *adev = smu->adev;
1276 uint32_t vdd = 0, val_vid = 0;
1280 val_vid = (RREG32_SOC15(SMUIO, 0, mmSMUSVI0_TEL_PLANE0) &
1281 SMUSVI0_TEL_PLANE0__SVI0_PLANE0_VDDCOR_MASK) >>
1282 SMUSVI0_TEL_PLANE0__SVI0_PLANE0_VDDCOR__SHIFT;
1284 vdd = (uint32_t)convert_to_vddc((uint8_t)val_vid);
1292 static int smu_v11_0_read_sensor(struct smu_context *smu,
1293 enum amd_pp_sensors sensor,
1294 void *data, uint32_t *size)
1298 case AMDGPU_PP_SENSOR_GFX_MCLK:
1299 ret = smu_get_current_clk_freq(smu, SMU_UCLK, (uint32_t *)data);
1302 case AMDGPU_PP_SENSOR_GFX_SCLK:
1303 ret = smu_get_current_clk_freq(smu, SMU_GFXCLK, (uint32_t *)data);
1306 case AMDGPU_PP_SENSOR_VDDGFX:
1307 ret = smu_v11_0_get_gfx_vdd(smu, (uint32_t *)data);
1310 case AMDGPU_PP_SENSOR_MIN_FAN_RPM:
1311 *(uint32_t *)data = 0;
1315 ret = smu_common_read_sensor(smu, sensor, data, size);
1319 /* try get sensor data by asic */
1321 ret = smu_asic_read_sensor(smu, sensor, data, size);
1330 smu_v11_0_display_clock_voltage_request(struct smu_context *smu,
1331 struct pp_display_clock_request
1334 enum amd_pp_clock_type clk_type = clock_req->clock_type;
1336 enum smu_clk_type clk_select = 0;
1337 uint32_t clk_freq = clock_req->clock_freq_in_khz / 1000;
1339 if (!smu->pm_enabled)
1341 if (smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT)) {
1343 case amd_pp_dcef_clock:
1344 clk_select = SMU_DCEFCLK;
1346 case amd_pp_disp_clock:
1347 clk_select = SMU_DISPCLK;
1349 case amd_pp_pixel_clock:
1350 clk_select = SMU_PIXCLK;
1352 case amd_pp_phy_clock:
1353 clk_select = SMU_PHYCLK;
1356 pr_info("[%s] Invalid Clock Type!", __func__);
1364 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetHardMinByFreq,
1365 (smu_clk_get_index(smu, clk_select) << 16) | clk_freq);
1373 smu_v11_0_set_watermarks_for_clock_ranges(struct smu_context *smu, struct
1374 dm_pp_wm_sets_with_clock_ranges_soc15
1378 struct smu_table *watermarks = &smu->smu_table.tables[SMU_TABLE_WATERMARKS];
1379 void *table = watermarks->cpu_addr;
1381 if (!smu->disable_watermark &&
1382 smu_feature_is_enabled(smu, SMU_FEATURE_DPM_DCEFCLK_BIT) &&
1383 smu_feature_is_enabled(smu, SMU_FEATURE_DPM_SOCCLK_BIT)) {
1384 smu_set_watermarks_table(smu, table, clock_ranges);
1385 smu->watermarks_bitmap |= WATERMARKS_EXIST;
1386 smu->watermarks_bitmap &= ~WATERMARKS_LOADED;
1392 static int smu_v11_0_gfx_off_control(struct smu_context *smu, bool enable)
1395 struct amdgpu_device *adev = smu->adev;
1397 switch (adev->asic_type) {
1401 if (!(adev->pm.pp_feature & PP_GFXOFF_MASK))
1403 mutex_lock(&smu->mutex);
1405 ret = smu_send_smc_msg(smu, SMU_MSG_AllowGfxOff);
1407 ret = smu_send_smc_msg(smu, SMU_MSG_DisallowGfxOff);
1408 mutex_unlock(&smu->mutex);
1418 static int smu_v11_0_get_clock_ranges(struct smu_context *smu,
1420 enum smu_clk_type clock_select,
1426 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMaxDpmFreq,
1427 smu_clk_get_index(smu, clock_select) << 16);
1429 pr_err("[GetClockRanges] Failed to get max clock from SMC!\n");
1432 smu_read_smc_arg(smu, clock);
1434 ret = smu_send_smc_msg_with_param(smu, SMU_MSG_GetMinDpmFreq,
1435 smu_clk_get_index(smu, clock_select) << 16);
1437 pr_err("[GetClockRanges] Failed to get min clock from SMC!\n");
1440 smu_read_smc_arg(smu, clock);
1446 static uint32_t smu_v11_0_dpm_get_sclk(struct smu_context *smu, bool low)
1451 if (!smu_feature_is_enabled(smu, SMU_FEATURE_DPM_GFXCLK_BIT)) {
1452 pr_err("[GetSclks]: gfxclk dpm not enabled!\n");
1457 ret = smu_v11_0_get_clock_ranges(smu, &gfx_clk, SMU_GFXCLK, false);
1459 pr_err("[GetSclks]: fail to get min SMU_GFXCLK\n");
1463 ret = smu_v11_0_get_clock_ranges(smu, &gfx_clk, SMU_GFXCLK, true);
1465 pr_err("[GetSclks]: fail to get max SMU_GFXCLK\n");
1470 return (gfx_clk * 100);
1473 static uint32_t smu_v11_0_dpm_get_mclk(struct smu_context *smu, bool low)
1478 if (!smu_feature_is_enabled(smu, SMU_FEATURE_DPM_UCLK_BIT)) {
1479 pr_err("[GetMclks]: memclk dpm not enabled!\n");
1484 ret = smu_v11_0_get_clock_ranges(smu, &mem_clk, SMU_UCLK, false);
1486 pr_err("[GetMclks]: fail to get min SMU_UCLK\n");
1490 ret = smu_v11_0_get_clock_ranges(smu, &mem_clk, SMU_GFXCLK, true);
1492 pr_err("[GetMclks]: fail to get max SMU_UCLK\n");
1497 return (mem_clk * 100);
1500 static int smu_v11_0_set_od8_default_settings(struct smu_context *smu,
1503 struct smu_table_context *table_context = &smu->smu_table;
1504 struct smu_table *table = &table_context->tables[SMU_TABLE_OVERDRIVE];
1508 * TODO: Enable overdrive for navi10, that replies on smc/pptable
1511 if (smu->adev->asic_type == CHIP_NAVI10)
1515 if (table_context->overdrive_table)
1518 table_context->overdrive_table = kzalloc(table->size, GFP_KERNEL);
1520 if (!table_context->overdrive_table)
1523 ret = smu_update_table(smu, SMU_TABLE_OVERDRIVE,
1524 table_context->overdrive_table, false);
1526 pr_err("Failed to export over drive table!\n");
1530 smu_set_default_od8_settings(smu);
1533 ret = smu_update_table(smu, SMU_TABLE_OVERDRIVE,
1534 table_context->overdrive_table, true);
1536 pr_err("Failed to import over drive table!\n");
1543 static int smu_v11_0_update_od8_settings(struct smu_context *smu,
1547 struct smu_table_context *table_context = &smu->smu_table;
1550 ret = smu_update_table(smu, SMU_TABLE_OVERDRIVE,
1551 table_context->overdrive_table, false);
1553 pr_err("Failed to export over drive table!\n");
1557 smu_update_specified_od8_value(smu, index, value);
1559 ret = smu_update_table(smu, SMU_TABLE_OVERDRIVE,
1560 table_context->overdrive_table, true);
1562 pr_err("Failed to import over drive table!\n");
1569 static int smu_v11_0_get_current_rpm(struct smu_context *smu,
1570 uint32_t *current_rpm)
1574 ret = smu_send_smc_msg(smu, SMU_MSG_GetCurrentRpm);
1577 pr_err("Attempt to get current RPM from SMC Failed!\n");
1581 smu_read_smc_arg(smu, current_rpm);
1587 smu_v11_0_get_fan_control_mode(struct smu_context *smu)
1589 if (!smu_feature_is_enabled(smu, SMU_FEATURE_FAN_CONTROL_BIT))
1590 return AMD_FAN_CTRL_MANUAL;
1592 return AMD_FAN_CTRL_AUTO;
1596 smu_v11_0_smc_fan_control(struct smu_context *smu, bool start)
1600 if (smu_feature_is_supported(smu, SMU_FEATURE_FAN_CONTROL_BIT))
1603 ret = smu_feature_set_enabled(smu, SMU_FEATURE_FAN_CONTROL_BIT, start);
1605 pr_err("[%s]%s smc FAN CONTROL feature failed!",
1606 __func__, (start ? "Start" : "Stop"));
1612 smu_v11_0_set_fan_static_mode(struct smu_context *smu, uint32_t mode)
1614 struct amdgpu_device *adev = smu->adev;
1616 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL2,
1617 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL2),
1618 CG_FDO_CTRL2, TMIN, 0));
1619 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL2,
1620 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL2),
1621 CG_FDO_CTRL2, FDO_PWM_MODE, mode));
1627 smu_v11_0_set_fan_speed_percent(struct smu_context *smu, uint32_t speed)
1629 struct amdgpu_device *adev = smu->adev;
1638 if (smu_v11_0_smc_fan_control(smu, stop))
1640 duty100 = REG_GET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL1),
1641 CG_FDO_CTRL1, FMAX_DUTY100);
1645 tmp64 = (uint64_t)speed * duty100;
1647 duty = (uint32_t)tmp64;
1649 WREG32_SOC15(THM, 0, mmCG_FDO_CTRL0,
1650 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_FDO_CTRL0),
1651 CG_FDO_CTRL0, FDO_STATIC_DUTY, duty));
1653 return smu_v11_0_set_fan_static_mode(smu, FDO_PWM_MODE_STATIC);
1657 smu_v11_0_set_fan_control_mode(struct smu_context *smu,
1665 case AMD_FAN_CTRL_NONE:
1666 ret = smu_v11_0_set_fan_speed_percent(smu, 100);
1668 case AMD_FAN_CTRL_MANUAL:
1669 ret = smu_v11_0_smc_fan_control(smu, stop);
1671 case AMD_FAN_CTRL_AUTO:
1672 ret = smu_v11_0_smc_fan_control(smu, start);
1679 pr_err("[%s]Set fan control mode failed!", __func__);
1686 static int smu_v11_0_set_fan_speed_rpm(struct smu_context *smu,
1689 struct amdgpu_device *adev = smu->adev;
1691 uint32_t tach_period, crystal_clock_freq;
1697 mutex_lock(&(smu->mutex));
1698 ret = smu_v11_0_smc_fan_control(smu, stop);
1700 goto set_fan_speed_rpm_failed;
1702 crystal_clock_freq = amdgpu_asic_get_xclk(adev);
1703 tach_period = 60 * crystal_clock_freq * 10000 / (8 * speed);
1704 WREG32_SOC15(THM, 0, mmCG_TACH_CTRL,
1705 REG_SET_FIELD(RREG32_SOC15(THM, 0, mmCG_TACH_CTRL),
1706 CG_TACH_CTRL, TARGET_PERIOD,
1709 ret = smu_v11_0_set_fan_static_mode(smu, FDO_PWM_MODE_STATIC_RPM);
1711 set_fan_speed_rpm_failed:
1712 mutex_unlock(&(smu->mutex));
1716 #define XGMI_STATE_D0 1
1717 #define XGMI_STATE_D3 0
1719 static int smu_v11_0_set_xgmi_pstate(struct smu_context *smu,
1723 mutex_lock(&(smu->mutex));
1724 ret = smu_send_smc_msg_with_param(smu,
1725 SMU_MSG_SetXgmiMode,
1726 pstate ? XGMI_STATE_D0 : XGMI_STATE_D3);
1727 mutex_unlock(&(smu->mutex));
1731 static const struct smu_funcs smu_v11_0_funcs = {
1732 .init_microcode = smu_v11_0_init_microcode,
1733 .load_microcode = smu_v11_0_load_microcode,
1734 .check_fw_status = smu_v11_0_check_fw_status,
1735 .check_fw_version = smu_v11_0_check_fw_version,
1736 .send_smc_msg = smu_v11_0_send_msg,
1737 .send_smc_msg_with_param = smu_v11_0_send_msg_with_param,
1738 .read_smc_arg = smu_v11_0_read_arg,
1739 .setup_pptable = smu_v11_0_setup_pptable,
1740 .init_smc_tables = smu_v11_0_init_smc_tables,
1741 .fini_smc_tables = smu_v11_0_fini_smc_tables,
1742 .init_power = smu_v11_0_init_power,
1743 .fini_power = smu_v11_0_fini_power,
1744 .get_vbios_bootup_values = smu_v11_0_get_vbios_bootup_values,
1745 .get_clk_info_from_vbios = smu_v11_0_get_clk_info_from_vbios,
1746 .notify_memory_pool_location = smu_v11_0_notify_memory_pool_location,
1747 .check_pptable = smu_v11_0_check_pptable,
1748 .parse_pptable = smu_v11_0_parse_pptable,
1749 .populate_smc_pptable = smu_v11_0_populate_smc_pptable,
1750 .write_pptable = smu_v11_0_write_pptable,
1751 .write_watermarks_table = smu_v11_0_write_watermarks_table,
1752 .set_min_dcef_deep_sleep = smu_v11_0_set_min_dcef_deep_sleep,
1753 .set_tool_table_location = smu_v11_0_set_tool_table_location,
1754 .init_display = smu_v11_0_init_display,
1755 .set_allowed_mask = smu_v11_0_set_allowed_mask,
1756 .get_enabled_mask = smu_v11_0_get_enabled_mask,
1757 .system_features_control = smu_v11_0_system_features_control,
1758 .update_feature_enable_state = smu_v11_0_update_feature_enable_state,
1759 .notify_display_change = smu_v11_0_notify_display_change,
1760 .get_power_limit = smu_v11_0_get_power_limit,
1761 .set_power_limit = smu_v11_0_set_power_limit,
1762 .get_current_clk_freq = smu_v11_0_get_current_clk_freq,
1763 .init_max_sustainable_clocks = smu_v11_0_init_max_sustainable_clocks,
1764 .start_thermal_control = smu_v11_0_start_thermal_control,
1765 .read_sensor = smu_v11_0_read_sensor,
1766 .set_deep_sleep_dcefclk = smu_v11_0_set_deep_sleep_dcefclk,
1767 .display_clock_voltage_request = smu_v11_0_display_clock_voltage_request,
1768 .set_watermarks_for_clock_ranges = smu_v11_0_set_watermarks_for_clock_ranges,
1769 .get_sclk = smu_v11_0_dpm_get_sclk,
1770 .get_mclk = smu_v11_0_dpm_get_mclk,
1771 .set_od8_default_settings = smu_v11_0_set_od8_default_settings,
1772 .update_od8_settings = smu_v11_0_update_od8_settings,
1773 .get_current_rpm = smu_v11_0_get_current_rpm,
1774 .get_fan_control_mode = smu_v11_0_get_fan_control_mode,
1775 .set_fan_control_mode = smu_v11_0_set_fan_control_mode,
1776 .set_fan_speed_percent = smu_v11_0_set_fan_speed_percent,
1777 .set_fan_speed_rpm = smu_v11_0_set_fan_speed_rpm,
1778 .set_xgmi_pstate = smu_v11_0_set_xgmi_pstate,
1779 .gfx_off_control = smu_v11_0_gfx_off_control,
1782 void smu_v11_0_set_smu_funcs(struct smu_context *smu)
1784 struct amdgpu_device *adev = smu->adev;
1786 smu->funcs = &smu_v11_0_funcs;
1787 switch (adev->asic_type) {
1789 vega20_set_ppt_funcs(smu);
1792 navi10_set_ppt_funcs(smu);
1795 pr_warn("Unknown asic for smu11\n");