SWDEV-361376 - Add python wrapper

- Add generator for python wrapper
- Add interface, exception and init files
- Add CMake custom targets

Change-Id: I63c1d94fbb587387c22f559a3db79987eb214a2e
Signed-off-by: Dejan Andjelkovic <Dejan.Andjelkovic@amd.com>


[ROCm/amdsmi commit: 6064f160a3]

projects/amdsmi/src/amd_smi/amd_smi.cc

@@ -62,6 +62,7 @@
 #include "amd_smi/impl/amd_smi_system.h"
 #include "amd_smi/impl/amd_smi_socket.h"
 #include "amd_smi/impl/amd_smi_gpu_device.h"
+#include "amd_smi/impl/amd_smi_uuid.h"
 #include "rocm_smi/rocm_smi.h"
 #include "rocm_smi/rocm_smi_common.h"
 #include "amd_smi/impl/amdgpu_drm.h"
@@ -253,7 +254,7 @@ amdsmi_status_t amdsmi_get_board_info(amdsmi_device_handle device_handle, amdsmi
                 static_cast<amd::smi::AMDSmiGPUDevice*>(device_handle);
 
     if (gpu_device->check_if_drm_is_supported()) {
-    	status = smi_amdgpu_get_board_info(gpu_device, board_info);
+        status = smi_amdgpu_get_board_info(gpu_device, board_info);
     }
     else {
         status = rsmi_wrapper(rsmi_dev_name_get, device_handle, board_info->product_name, AMDSMI_PRODUCT_NAME_LENGTH);
@@ -492,8 +493,8 @@ amdsmi_get_asic_info(amdsmi_device_handle device_handle, amdsmi_asic_info_t *inf
         return AMDSMI_STATUS_INVAL;
     }
 
-	struct drm_amdgpu_info_device dev_info = {};
-	struct drm_amdgpu_info_vbios vbios = {};
+    struct drm_amdgpu_info_device dev_info = {};
+    struct drm_amdgpu_info_vbios vbios = {};
     char* name;
     char *tmp;
 
@@ -501,7 +502,7 @@ amdsmi_get_asic_info(amdsmi_device_handle device_handle, amdsmi_asic_info_t *inf
             static_cast<amd::smi::AMDSmiGPUDevice*>(device_handle);
     amdsmi_status_t status;
     if (gpu_device->check_if_drm_is_supported()){
-    	status = gpu_device->amdgpu_query_info(AMDGPU_INFO_DEV_INFO, sizeof(struct drm_amdgpu_info_device), &dev_info);
+        status = gpu_device->amdgpu_query_info(AMDGPU_INFO_DEV_INFO, sizeof(struct drm_amdgpu_info_device), &dev_info);
         if (status != AMDSMI_STATUS_SUCCESS) return status;
         status = gpu_device->amdgpu_query_vbios(&vbios);
         if (status != AMDSMI_STATUS_SUCCESS) return status;
@@ -965,7 +966,7 @@ amdsmi_get_power_cap_info(amdsmi_device_handle device_handle,
     status = smi_amdgpu_get_power_cap(gpudevice, &power_cap);
 
     info->power_cap = power_cap;
-    status = smi_amdgpu_get_ranges(gpudevice, CLOCK_TYPE_GFX,
+    status = smi_amdgpu_get_ranges(gpudevice, CLK_TYPE_GFX,
             NULL, NULL, &dpm);
     info->dpm_cap = dpm;
 
@@ -1059,10 +1060,10 @@ amdsmi_status_t amdsmi_dev_gpu_clk_freq_get(amdsmi_device_handle device_handle,
         return AMDSMI_STATUS_INVAL;
 
     // Get from gpu_metrics
-    if (clk_type == CLOCK_TYPE_VCLK0 ||
-        clk_type == CLOCK_TYPE_VCLK1 ||
-        clk_type == CLOCK_TYPE_DCLK0 ||
-        clk_type == CLOCK_TYPE_DCLK1 ) {
+    if (clk_type == CLK_TYPE_VCLK0 ||
+        clk_type == CLK_TYPE_VCLK1 ||
+        clk_type == CLK_TYPE_DCLK0 ||
+        clk_type == CLK_TYPE_DCLK1 ) {
         amdsmi_gpu_metrics_t metric_info;
         auto r_status = amdsmi_dev_gpu_metrics_info_get(
                 device_handle, &metric_info);
@@ -1070,19 +1071,19 @@ amdsmi_status_t amdsmi_dev_gpu_clk_freq_get(amdsmi_device_handle device_handle,
             return r_status;
 
         f->num_supported = 1;
-        if (clk_type == CLOCK_TYPE_VCLK0) {
+        if (clk_type == CLK_TYPE_VCLK0) {
             f->current = metric_info.current_vclk0;
             f->frequency[0] = metric_info.average_vclk0_frequency;
         }
-        if (clk_type == CLOCK_TYPE_VCLK1) {
+        if (clk_type == CLK_TYPE_VCLK1) {
             f->current = metric_info.current_vclk1;
             f->frequency[0] = metric_info.average_vclk1_frequency;
         }
-        if (clk_type == CLOCK_TYPE_DCLK0) {
+        if (clk_type == CLK_TYPE_DCLK0) {
             f->current = metric_info.current_dclk0;
             f->frequency[0] = metric_info.average_dclk0_frequency;
         }
-        if (clk_type == CLOCK_TYPE_DCLK1) {
+        if (clk_type == CLK_TYPE_DCLK1) {
             f->current = metric_info.current_dclk1;
             f->frequency[0] = metric_info.average_dclk1_frequency;
         }
@@ -1098,10 +1099,10 @@ amdsmi_status_t amdsmi_dev_gpu_clk_freq_get(amdsmi_device_handle device_handle,
 amdsmi_status_t amdsmi_dev_gpu_clk_freq_set(amdsmi_device_handle device_handle,
                          amdsmi_clk_type_t clk_type, uint64_t freq_bitmask) {
     // Not support the clock type read from gpu_metrics
-    if (clk_type == CLOCK_TYPE_VCLK0 ||
-        clk_type == CLOCK_TYPE_VCLK1 ||
-        clk_type == CLOCK_TYPE_DCLK0 ||
-        clk_type == CLOCK_TYPE_DCLK1 ) {
+    if (clk_type == CLK_TYPE_VCLK0 ||
+        clk_type == CLK_TYPE_VCLK1 ||
+        clk_type == CLK_TYPE_DCLK0 ||
+        clk_type == CLK_TYPE_DCLK1 ) {
             return AMDSMI_STATUS_NOT_SUPPORTED;
     }
 
@@ -1269,12 +1270,12 @@ amdsmi_get_vbios_info(amdsmi_device_handle dev, amdsmi_vbios_info_t *info) {
     if (info == nullptr) {
         return AMDSMI_STATUS_INVAL;
     }
-	struct drm_amdgpu_info_vbios vbios = {};
+    struct drm_amdgpu_info_vbios vbios = {};
 
     amd::smi::AMDSmiGPUDevice* gpu_device =
             static_cast<amd::smi::AMDSmiGPUDevice*>(dev);
     amdsmi_status_t status;
-	if (gpu_device->check_if_drm_is_supported()){
+    if (gpu_device->check_if_drm_is_supported()){
         status = gpu_device->amdgpu_query_vbios(&vbios);
         if (status != AMDSMI_STATUS_SUCCESS) {
             return status;
@@ -1290,7 +1291,7 @@ amdsmi_get_vbios_info(amdsmi_device_handle dev, amdsmi_vbios_info_t *info) {
         return AMDSMI_STATUS_NOT_SUPPORTED;
     }
 
-	return AMDSMI_STATUS_SUCCESS;
+    return AMDSMI_STATUS_SUCCESS;
 }
 
 amdsmi_status_t
@@ -1334,13 +1335,13 @@ amdsmi_get_power_limit(amdsmi_device_handle dev, amdsmi_power_limit_t *limit) {
 }
 
 amdsmi_status_t
-amdsmi_get_clock_measure(amdsmi_device_handle dev, amdsmi_clk_type_t clk_type, amdsmi_clock_measure_t *info) {
+amdsmi_get_clock_measure(amdsmi_device_handle dev, amdsmi_clk_type_t clk_type, amdsmi_clk_measure_t *info) {
     if (info == nullptr) {
         return AMDSMI_STATUS_INVAL;
     }
 
-    if (clk_type >= CLOCK_TYPE__MAX) {
-        printf("Domain value greater or equals CLOCK_TYPE__MAX value. Return code: %d", AMDSMI_STATUS_INVAL);
+    if (clk_type >= CLK_TYPE__MAX) {
+        printf("Domain value greater or equals CLK_TYPE__MAX value. Return code: %d", AMDSMI_STATUS_INVAL);
         return AMDSMI_STATUS_INVAL;
     }
 
@@ -1362,19 +1363,19 @@ amdsmi_get_clock_measure(amdsmi_device_handle dev, amdsmi_clk_type_t clk_type, a
     info->max_clk = max_freq;
 
     switch (clk_type) {
-    case CLOCK_TYPE_GFX:
+    case CLK_TYPE_GFX:
         info->avg_clk = metrics.average_gfxclk_frequency;
         info->cur_clk = metrics.current_gfxclk;
         break;
-    case CLOCK_TYPE_MEM:
+    case CLK_TYPE_MEM:
         info->avg_clk = metrics.average_uclk_frequency;
         info->cur_clk = metrics.current_uclk;
         break;
-    case CLOCK_TYPE_VCLK0:
+    case CLK_TYPE_VCLK0:
         info->avg_clk = metrics.average_vclk0_frequency;
         info->cur_clk = metrics.current_vclk0;
         break;
-    case CLOCK_TYPE_VCLK1:
+    case CLK_TYPE_VCLK1:
         info->avg_clk = metrics.average_vclk1_frequency;
         info->cur_clk = metrics.current_vclk1;
         break;
@@ -1485,7 +1486,7 @@ amdsmi_get_temperature_measure(amdsmi_device_handle dev, amdsmi_temperature_type
 }
 
 amdsmi_status_t
-amdsmi_get_ras_features_enabled(amdsmi_device_handle device_handle, amdsmi_gpu_block block, amdsmi_ras_err_state_t *state) {
+amdsmi_get_ras_block_features_enabled(amdsmi_device_handle device_handle, amdsmi_gpu_block block, amdsmi_ras_err_state_t *state) {
     if (state == nullptr || block > AMDSMI_GPU_BLOCK_LAST) {
         return AMDSMI_STATUS_INVAL;
     }
@@ -1610,9 +1611,40 @@ amdsmi_get_process_info(amdsmi_device_handle dev, amdsmi_process_handle process,
     return AMDSMI_STATUS_SUCCESS;
 }
 
+amdsmi_status_t
+amdsmi_get_power_measure(amdsmi_device_handle dev, amdsmi_power_measure_t *info) {
+    if (info == nullptr) {
+        return AMDSMI_STATUS_INVAL;
+    }
+
+    amdsmi_gpu_metrics_t metrics = {};
+    amd::smi::AMDSmiGPUDevice* gpu_device =
+            static_cast<amd::smi::AMDSmiGPUDevice*>(dev);
+    amdsmi_status_t status;
+
+    status = amdsmi_dev_gpu_metrics_info_get(dev, &metrics);
+    if (status != AMDSMI_STATUS_SUCCESS) {
+        return status;
+    }
+
+    int64_t voltage_read = 0;
+
+    status = amdsmi_dev_volt_metric_get(dev, AMDSMI_VOLT_TYPE_VDDGFX, AMDSMI_VOLT_CURRENT, &voltage_read);
+    if (status != AMDSMI_STATUS_SUCCESS) {
+        return status;
+    }
+
+    info->voltage_gfx = voltage_read;
+
+    info->average_socket_power = metrics.average_socket_power;
+    info->energy_accumulator = metrics.energy_accumulator;
+
+    return status;
+}
+
 amdsmi_status_t
 amdsmi_get_target_frequency_range(amdsmi_device_handle dev, amdsmi_clk_type_t clk_type, amdsmi_frequency_range_t *range) {
-    if (range == nullptr || clk_type > CLOCK_TYPE__MAX) {
+    if (range == nullptr || clk_type > CLK_TYPE__MAX) {
         return AMDSMI_STATUS_INVAL;
     }
 
@@ -1636,16 +1668,16 @@ amdsmi_get_target_frequency_range(amdsmi_device_handle dev, amdsmi_clk_type_t cl
     range->supported_freq_range.upper_bound = (long)max;
     max = 0;
     switch (clk_type) {
-    case CLOCK_TYPE_GFX:
+    case CLK_TYPE_GFX:
         max = metrics.current_gfxclk;
         break;
-    case CLOCK_TYPE_MEM:
+    case CLK_TYPE_MEM:
         max = metrics.current_uclk;
         break;
-    case CLOCK_TYPE_VCLK0:
+    case CLK_TYPE_VCLK0:
         max = metrics.current_vclk0;
         break;
-    case CLOCK_TYPE_VCLK1:
+    case CLK_TYPE_VCLK1:
         max = metrics.current_vclk1;
         break;
     default:
@@ -1655,3 +1687,158 @@ amdsmi_get_target_frequency_range(amdsmi_device_handle dev, amdsmi_clk_type_t cl
 
     return AMDSMI_STATUS_SUCCESS;
 }
+
+amdsmi_status_t
+amdsmi_get_driver_version(amdsmi_device_handle dev, int *length, char *version) {
+    if (length == nullptr || version == nullptr) {
+        return AMDSMI_STATUS_INVAL;
+    }
+    amdsmi_status_t status = AMDSMI_STATUS_SUCCESS;
+    amd::smi::AMDSmiGPUDevice* gpu_device =
+            static_cast<amd::smi::AMDSmiGPUDevice*>(dev);
+    status = smi_amdgpu_get_driver_version(gpu_device, length, version);
+
+    return status;
+}
+
+amdsmi_status_t
+amdsmi_get_device_uuid(amdsmi_device_handle dev, unsigned int *uuid_length, char *uuid) {
+    if (uuid_length == nullptr || uuid == nullptr) {
+        return AMDSMI_STATUS_INVAL;
+    }
+
+    amd::smi::AMDSmiGPUDevice* gpu_device =
+            static_cast<amd::smi::AMDSmiGPUDevice*>(dev);
+    amdsmi_status_t status = AMDSMI_STATUS_SUCCESS;
+    SMIGPUDEVICE_MUTEX(gpu_device->get_mutex())
+
+    FILE *fp;
+    size_t len = AMDSMI_GPU_UUID_SIZE;
+    ssize_t nread;
+    amdsmi_asic_info_t asic_info = {};
+    const uint8_t fcn = 0xff;
+
+    std::string path = "/sys/class/drm/" + gpu_device->get_gpu_path() + "/device/uuid_info";
+    status = amdsmi_get_asic_info(dev, &asic_info);
+    if (status != AMDSMI_STATUS_SUCCESS) {
+        printf("Getting asic info failed. Return code: %d", status);
+        return status;
+    }
+
+    fp = fopen(path.c_str(), "rb");
+    if (!fp) {
+        /* generate random UUID */
+        status = amdsmi_uuid_gen(uuid, strtoul(asic_info.asic_serial, nullptr, AMDSMI_NORMAL_STRING_LENGTH), (uint16_t)asic_info.device_id, fcn);
+        return status;
+    }
+
+    nread = getline(&uuid, &len, fp);
+    if (nread <= 0) {
+        /* generate random UUID */
+        status = amdsmi_uuid_gen(uuid, strtoul(asic_info.asic_serial, nullptr, AMDSMI_NORMAL_STRING_LENGTH), (uint16_t)asic_info.device_id, fcn);
+        fclose(fp);
+        return status;
+    }
+
+    fclose(fp);
+    return status;
+}
+
+amdsmi_status_t
+amdsmi_get_pcie_link_status(amdsmi_device_handle dev, amdsmi_pcie_info_t *info){
+    if (info == nullptr) {
+        return AMDSMI_STATUS_INVAL;
+    }
+    amdsmi_status_t status = AMDSMI_STATUS_SUCCESS;
+    amdsmi_gpu_metrics_t metric_info = {};
+    status = amdsmi_dev_gpu_metrics_info_get(
+            dev, &metric_info);
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    info->pcie_lanes = metric_info.pcie_link_width;
+    info->pcie_speed = metric_info.pcie_link_speed;
+
+    return status;
+}
+
+amdsmi_status_t amdsmi_get_pcie_link_caps(amdsmi_device_handle dev, amdsmi_pcie_info_t *info) {
+    if (info == nullptr) {
+        return AMDSMI_STATUS_INVAL;
+    }
+
+    amdsmi_status_t status = AMDSMI_STATUS_SUCCESS;
+    amd::smi::AMDSmiGPUDevice* gpu_device =
+            static_cast<amd::smi::AMDSmiGPUDevice*>(dev);
+
+    SMIGPUDEVICE_MUTEX(gpu_device->get_mutex())
+
+    char buff[AMDSMI_NORMAL_STRING_LENGTH];
+    FILE* fp;
+    double pcie_speed = 0;
+    unsigned pcie_width = 0;
+    amdsmi_asic_info_t asic_info = {};
+
+    memset((void *)info, 0, sizeof(*info));
+
+    std::string path_max_link_width = "/sys/class/drm/" +
+        gpu_device->get_gpu_path() + "/device/max_link_width";
+    fp = fopen(path_max_link_width.c_str(), "r");
+    if (fp) {
+        fscanf(fp, "%d", &pcie_width);
+        fclose(fp);
+    } else {
+        printf("Failed to open file: %s \n", path_max_link_width.c_str());
+        return AMDSMI_STATUS_API_FAILED;
+    }
+    info->pcie_lanes = (uint16_t)pcie_width;
+
+    std::string path_max_link_speed = "/sys/class/drm/" +
+        gpu_device->get_gpu_path() + "/device/max_link_speed";
+    fp = fopen(path_max_link_speed.c_str(), "r");
+    if (fp) {
+        fscanf(fp, "%lf %s", &pcie_speed, buff);
+        fclose(fp);
+    } else {
+        printf("Failed to open file: %s \n", path_max_link_speed.c_str());
+        return AMDSMI_STATUS_API_FAILED;
+    }
+
+    status = amdsmi_get_asic_info(dev, &asic_info);
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    if (pcie_speed == 0 && asic_info.device_id == 29538)
+        pcie_speed = 16;
+
+    info->pcie_speed = pcie_speed * 1000;
+
+    return status;
+}
+
+amdsmi_status_t amdsmi_get_device_handle_from_bdf(amdsmi_bdf_t bdf,
+                                    amdsmi_device_handle* device_handles,
+                                    uint32_t device_count,
+                                    amdsmi_device_handle* device_handle){
+    if (device_handles == nullptr) {
+        return AMDSMI_STATUS_INVAL;
+    }
+    amdsmi_status_t status = AMDSMI_STATUS_SUCCESS;
+
+    for(auto idx = 0; idx < device_count; idx++) {
+        amd::smi::AMDSmiGPUDevice* gpu_device = nullptr;
+        status = get_gpu_device_from_handle(device_handles[idx], &gpu_device);
+        if (status != AMDSMI_STATUS_SUCCESS) {
+            return status;
+        }
+        amdsmi_bdf_t found_bdf = gpu_device->get_bdf();
+        if (bdf.bus_number == found_bdf.bus_number &&
+            bdf.device_number == found_bdf.device_number &&
+            bdf.domain_number == found_bdf.domain_number &&
+            bdf.function_number == found_bdf.function_number) {
+                *device_handle = device_handles[idx];
+                return AMDSMI_STATUS_SUCCESS;
+            }
+    }
+    return AMDSMI_STATUS_API_FAILED;
+}

projects/amdsmi/src/amd_smi/amd_smi_utils.cc

@@ -51,18 +51,18 @@ static bool isAMDGPU(std::string dev_path) {
   std::string vend_path = dev_path + "/device/vendor";
   std::string vbios_v_path = dev_path + "/device/vbios_version";
   if (!amd::smi::FileExists(vend_path.c_str())) {
-    return false;
+	return false;
   }
 
   if (!amd::smi::FileExists(vbios_v_path.c_str())) {
-    return false;
+	return false;
   }
 
   std::ifstream fs;
   fs.open(vend_path);
 
   if (!fs.is_open()) {
-      return false;
+	  return false;
   }
 
   uint32_t vendor_id;
@@ -72,7 +72,7 @@ static bool isAMDGPU(std::string dev_path) {
   fs.close();
 
   if (vendor_id == kAmdGpuId) {
-    return true;
+	return true;
   }
   return false;
 }
@@ -199,16 +199,16 @@ amdsmi_status_t smi_amdgpu_get_ranges(amd::smi::AMDSmiGPUDevice* device, amdsmi_
 	unsigned int max, min, dpm;
 
 	switch (domain) {
-	case CLOCK_TYPE_GFX:
+	case CLK_TYPE_GFX:
 		fullpath += "/pp_dpm_sclk";
 		break;
-	case CLOCK_TYPE_MEM:
+	case CLK_TYPE_MEM:
 		fullpath += "/pp_dpm_mclk";
 		break;
-	case CLOCK_TYPE_VCLK0:
+	case CLK_TYPE_VCLK0:
 		fullpath += "/pp_dpm_vclk";
 		break;
-	case CLOCK_TYPE_VCLK1:
+	case CLK_TYPE_VCLK1:
 		fullpath += "/pp_dpm_vclk1";
 		break;
 	default:
@@ -380,3 +380,81 @@ amdsmi_status_t smi_amdgpu_get_ecc_error_count(amd::smi::AMDSmiGPUDevice* device
 
 	return AMDSMI_STATUS_SUCCESS;
 }
+
+amdsmi_status_t smi_amdgpu_get_driver_version(amd::smi::AMDSmiGPUDevice* device, int *length, char *version) {
+	if (!device->check_if_drm_is_supported()) {
+		return AMDSMI_STATUS_NOT_SUPPORTED;
+	}
+	SMIGPUDEVICE_MUTEX(device->get_mutex())
+	amdsmi_status_t status = AMDSMI_STATUS_SUCCESS;
+	FILE *fp;
+	char *tmp, *ptr, *token;
+	char *ver = NULL;
+	int i = 0;
+	size_t len;
+
+	if (length)
+		len = *length < AMDSMI_MAX_DRIVER_VERSION_LENGTH ? *length :
+		AMDSMI_MAX_DRIVER_VERSION_LENGTH;
+	else
+		len = AMDSMI_MAX_DRIVER_VERSION_LENGTH;
+
+	std::string path = "/sys/module/amdgpu/version";
+
+	fp = fopen(path.c_str(), "r");
+	if (!fp){
+		fp = fopen("/proc/version", "r");
+		if (!fp) {
+			status = AMDSMI_STATUS_IO;
+			return status;
+		}
+
+		len = 0;
+		if (getline(&ver, &len, fp) <= 0) {
+			status = AMDSMI_STATUS_IO;
+			fclose(fp);
+			free(ver);
+			return status;
+		}
+
+		fclose(fp);
+
+		ptr = ver;
+		token = strtok_r(ptr, " ", &tmp);
+
+		if (!token) {
+			free(ver);
+			status = AMDSMI_STATUS_IO;
+			return status;
+		}
+		for (i = 0; i < 2; i++) {
+			ptr = strtok_r(NULL, " ", &tmp);
+			if (!ptr)
+				break;
+		}
+		if (i != 2 || !ptr) {
+			free(ver);
+			status = AMDSMI_STATUS_IO;
+			return status;
+		}
+		if (length)
+			len = *length < AMDSMI_MAX_DRIVER_VERSION_LENGTH ? *length :
+			AMDSMI_MAX_DRIVER_VERSION_LENGTH;
+		else
+			len = AMDSMI_MAX_DRIVER_VERSION_LENGTH;
+
+		strncpy(version, ptr,  len);
+		free(ver);
+	} else {
+		if ((len = getline(&version, &len, fp)) <= 0)
+			status = AMDSMI_STATUS_IO;
+
+		fclose(fp);
+		if (length) {
+			*length = version[len-1] == '\n' ? len - 1 : len;
+		}
+		version[len-1] = version[len-1] == '\n' ? '\0' : version[len-1];
+	}
+
+	return status;
+}

projects/amdsmi/src/amd_smi/amd_smi_uuid.cc

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "amd_smi/amd_smi.h"
+#include "amd_smi/impl/amd_smi_uuid.h"
+
+#include <string.h>
+#include <cstdio>
+
+typedef struct uuid_s {
+	union {
+		struct {
+			uint32_t did    : 16;
+			uint32_t fcn    : 8;
+			uint32_t asic_7 : 8;
+		};
+		uint32_t time_low;
+	};
+	uint32_t time_mid  : 16;
+	uint32_t time_high : 12;
+	uint32_t version   : 4;
+	uint8_t clk_seq_hi : 6;
+	uint8_t variant	   : 2;
+	union {
+		uint8_t clk_seq_low;
+		uint8_t asic_6;
+	};
+	uint16_t asic_4;
+	uint32_t asic_0;
+} uuid_t;
+
+static void print_uuid(char *str, uuid_t *uuid)
+{
+	sprintf(str, "%08x", uuid->time_low);
+	sprintf(str + 8, "-");
+	sprintf(str + 9, "%04x", uuid->time_mid);
+	sprintf(str + 13, "-");
+	sprintf(str + 14, "%04x", (uuid->version << 12) | uuid->time_high);
+	sprintf(str + 18, "-");
+	sprintf(str + 14 + 5, "%02x", (uuid->variant << 6) | uuid->clk_seq_hi);
+	sprintf(str + 16 + 5, "%02x", uuid->clk_seq_low);
+	sprintf(str + 18 + 5, "-");
+	sprintf(str + 19 + 5, "%04x", uuid->asic_4);
+	sprintf(str + 23 + 5, "%08x", uuid->asic_0);
+	str[31 + 5] = 0;
+}
+
+static void insert_asic_serial(uuid_t *uuid, uint64_t serial)
+{
+	uuid->asic_0 = (uint32_t)serial;
+	uuid->asic_4 = (uint16_t)(serial >> 4 * 8) & 0xFFFF;
+	uuid->asic_6 = (uint8_t)(serial >> 6 * 8) & 0xFF;
+	uuid->asic_7 = (uint32_t)(serial >> 7 * 8) & 0xFF;
+}
+
+static void insert_did(uuid_t *uuid, uint16_t did)
+{
+	uuid->did = did;
+}
+
+static void insert_fcn(uuid_t *uuid, uint8_t fcn_idx)
+{
+	uuid->fcn = fcn_idx;
+}
+
+static void insert_clk_seq(uuid_t *uuid, uint16_t seq)
+{
+	uuid->clk_seq_low = (uint8_t)seq;
+	uuid->clk_seq_hi = (seq >> 8) & 0x3fU;
+}
+
+amdsmi_status_t amdsmi_uuid_gen(char *str, uint64_t serial, uint16_t did, uint8_t idx)
+{
+	uuid_t uuid;
+	memset(&uuid, 0, sizeof(uuid_t));
+
+	insert_clk_seq(&uuid, 0);
+	insert_did(&uuid, did);
+	insert_fcn(&uuid, idx);
+	insert_asic_serial(&uuid, serial);
+
+	uuid.version = 1;
+	uuid.variant = 2;
+
+	print_uuid(str, &uuid);
+
+	return AMDSMI_STATUS_SUCCESS;
+}