drm/xe/hwmon: Remove type casting

Refactor: eliminate type casts by using proper u32
declarations.

v2:
- Address review comments. (Karthik)

v3:
- Use the proper u32 type and drop cast. (Lucas De Marchi)
- Modify variable when actually using u64 value.
- Change r value to reg_value with u32 type.

v4:
- Remove newline between trailer and Signed-off-by. (Lucas De Marchi)
- Change reg_val to val for more user-friendly logging.
- Use mul_u32_u32 function since both values are u32.

v5:
- mul_u32_u32 function with shift. (Lucas De Marchi)

Fixes: 7596d839f6228 ("drm/xe/hwmon: Add support to manage power limits though mailbox")
Signed-off-by: Mallesh Koujalagi <mallesh.koujalagi@intel.com>
Reviewed-by: Lucas De Marchi <lucas.demarchi@intel.com>
Link: https://lore.kernel.org/r/20250912113458.2815172-1-mallesh.koujalagi@intel.com
Signed-off-by: Lucas De Marchi <lucas.demarchi@intel.com>
(cherry picked from commit 4e1d3b5e6423dc841acd8691d75626b3d3b2b6a8)
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>

diff --git a/drivers/gpu/drm/xe/xe_hwmon.c b/drivers/gpu/drm/xe/xe_hwmon.c
index c17ed1ae86493cfc5542460575c170870bbcab79..c5b63e10bb91135b384333b78913d29c70706473 100644 (file)
--- a/drivers/gpu/drm/xe/xe_hwmon.c
+++ b/drivers/gpu/drm/xe/xe_hwmon.c
@@ -286,7 +286,7 @@ static struct xe_reg xe_hwmon_get_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg
  */
 static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, u32 attr, int channel, long *value)
 {
-       u64 reg_val = 0, min, max;
+       u32 reg_val = 0;
        struct xe_device *xe = hwmon->xe;
        struct xe_reg rapl_limit, pkg_power_sku;
        struct xe_mmio *mmio = xe_root_tile_mmio(xe);
@@ -294,7 +294,7 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, u32 attr, int channe
        mutex_lock(&hwmon->hwmon_lock);
 
        if (hwmon->xe->info.has_mbx_power_limits) {
-               xe_hwmon_pcode_read_power_limit(hwmon, attr, channel, (u32 *)&reg_val);
+               xe_hwmon_pcode_read_power_limit(hwmon, attr, channel, &reg_val);
        } else {
                rapl_limit = xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, channel);
                pkg_power_sku = xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU, channel);
@@ -304,19 +304,21 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, u32 attr, int channe
        /* Check if PL limits are disabled. */
        if (!(reg_val & PWR_LIM_EN)) {
                *value = PL_DISABLE;
-               drm_info(&hwmon->xe->drm, "%s disabled for channel %d, val 0x%016llx\n",
+               drm_info(&hwmon->xe->drm, "%s disabled for channel %d, val 0x%08x\n",
                         PWR_ATTR_TO_STR(attr), channel, reg_val);
                goto unlock;
        }
 
        reg_val = REG_FIELD_GET(PWR_LIM_VAL, reg_val);
-       *value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon->scl_shift_power);
+       *value = mul_u32_u32(reg_val, SF_POWER) >> hwmon->scl_shift_power;
 
        /* For platforms with mailbox power limit support clamping would be done by pcode. */
        if (!hwmon->xe->info.has_mbx_power_limits) {
-               reg_val = xe_mmio_read64_2x32(mmio, pkg_power_sku);
-               min = REG_FIELD_GET(PKG_MIN_PWR, reg_val);
-               max = REG_FIELD_GET(PKG_MAX_PWR, reg_val);
+               u64 pkg_pwr, min, max;
+
+               pkg_pwr = xe_mmio_read64_2x32(mmio, pkg_power_sku);
+               min = REG_FIELD_GET(PKG_MIN_PWR, pkg_pwr);
+               max = REG_FIELD_GET(PKG_MAX_PWR, pkg_pwr);
                min = mul_u64_u32_shr(min, SF_POWER, hwmon->scl_shift_power);
                max = mul_u64_u32_shr(max, SF_POWER, hwmon->scl_shift_power);
                if (min && max)
@@ -493,8 +495,8 @@ xe_hwmon_power_max_interval_show(struct device *dev, struct device_attribute *at
 {
        struct xe_hwmon *hwmon = dev_get_drvdata(dev);
        struct xe_mmio *mmio = xe_root_tile_mmio(hwmon->xe);
-       u32 x, y, x_w = 2; /* 2 bits */
-       u64 r, tau4, out;
+       u32 reg_val, x, y, x_w = 2; /* 2 bits */
+       u64 tau4, out;
        int channel = (to_sensor_dev_attr(attr)->index % 2) ? CHANNEL_PKG : CHANNEL_CARD;
        u32 power_attr = (to_sensor_dev_attr(attr)->index > 1) ? PL2_HWMON_ATTR : PL1_HWMON_ATTR;
 
@@ -505,23 +507,24 @@ xe_hwmon_power_max_interval_show(struct device *dev, struct device_attribute *at
        mutex_lock(&hwmon->hwmon_lock);
 
        if (hwmon->xe->info.has_mbx_power_limits) {
-               ret = xe_hwmon_pcode_read_power_limit(hwmon, power_attr, channel, (u32 *)&r);
+               ret = xe_hwmon_pcode_read_power_limit(hwmon, power_attr, channel, &reg_val);
                if (ret) {
                        drm_err(&hwmon->xe->drm,
-                               "power interval read fail, ch %d, attr %d, r 0%llx, ret %d\n",
-                               channel, power_attr, r, ret);
-                       r = 0;
+                               "power interval read fail, ch %d, attr %d, val 0x%08x, ret %d\n",
+                               channel, power_attr, reg_val, ret);
+                       reg_val = 0;
                }
        } else {
-               r = xe_mmio_read32(mmio, xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, channel));
+               reg_val = xe_mmio_read32(mmio, xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT,
+                                                               channel));
        }
 
        mutex_unlock(&hwmon->hwmon_lock);
 
        xe_pm_runtime_put(hwmon->xe);
 
-       x = REG_FIELD_GET(PWR_LIM_TIME_X, r);
-       y = REG_FIELD_GET(PWR_LIM_TIME_Y, r);
+       x = REG_FIELD_GET(PWR_LIM_TIME_X, reg_val);
+       y = REG_FIELD_GET(PWR_LIM_TIME_Y, reg_val);
 
        /*
         * tau = (1 + (x / 4)) * power(2,y), x = bits(23:22), y = bits(21:17)