drm/xe/hwmon: Update xe_hwmon_get_reg to return struct xe_reg

Return struct xe_reg instead of reg.raw from xe_hwmon_get_reg
to have abstracted usage of struct xe_reg.

v2:
 - Use xe_reg_is_valid function instead of XE_REG_IS_VALID macro
   as it is removed.

Signed-off-by: Karthik Poosa <karthik.poosa@intel.com>
Suggested-by: Lucas De Marchi <lucas.demarchi@intel.com>
Cc: Badal Nilawar <badal.nilawar@intel.com>
Reviewed-by: Lucas De Marchi <lucas.demarchi@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240405130127.1392426-3-karthik.poosa@intel.com
Signed-off-by: Lucas De Marchi <lucas.demarchi@intel.com>

diff --git a/drivers/gpu/drm/xe/xe_hwmon.c b/drivers/gpu/drm/xe/xe_hwmon.c
index 7e8caac..a3b2ec0 100644 (file)
--- a/drivers/gpu/drm/xe/xe_hwmon.c
+++ b/drivers/gpu/drm/xe/xe_hwmon.c
@@ -79,46 +79,46 @@ struct xe_hwmon {
        struct xe_hwmon_energy_info ei[CHANNEL_MAX];
 };
 
-static u32 xe_hwmon_get_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon_reg, int channel)
+static struct xe_reg xe_hwmon_get_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon_reg,
+                                     int channel)
 {
        struct xe_device *xe = gt_to_xe(hwmon->gt);
-       struct xe_reg reg = XE_REG(0);
 
        switch (hwmon_reg) {
        case REG_PKG_RAPL_LIMIT:
                if (xe->info.platform == XE_PVC && channel == CHANNEL_PKG)
-                       reg = PVC_GT0_PACKAGE_RAPL_LIMIT;
+                       return PVC_GT0_PACKAGE_RAPL_LIMIT;
                else if ((xe->info.platform == XE_DG2) && (channel == CHANNEL_PKG))
-                       reg = PCU_CR_PACKAGE_RAPL_LIMIT;
+                       return PCU_CR_PACKAGE_RAPL_LIMIT;
                break;
        case REG_PKG_POWER_SKU:
                if (xe->info.platform == XE_PVC && channel == CHANNEL_PKG)
-                       reg = PVC_GT0_PACKAGE_POWER_SKU;
+                       return PVC_GT0_PACKAGE_POWER_SKU;
                else if ((xe->info.platform == XE_DG2) && (channel == CHANNEL_PKG))
-                       reg = PCU_CR_PACKAGE_POWER_SKU;
+                       return PCU_CR_PACKAGE_POWER_SKU;
                break;
        case REG_PKG_POWER_SKU_UNIT:
                if (xe->info.platform == XE_PVC)
-                       reg = PVC_GT0_PACKAGE_POWER_SKU_UNIT;
+                       return PVC_GT0_PACKAGE_POWER_SKU_UNIT;
                else if (xe->info.platform == XE_DG2)
-                       reg = PCU_CR_PACKAGE_POWER_SKU_UNIT;
+                       return PCU_CR_PACKAGE_POWER_SKU_UNIT;
                break;
        case REG_GT_PERF_STATUS:
                if (xe->info.platform == XE_DG2 && channel == CHANNEL_PKG)
-                       reg = GT_PERF_STATUS;
+                       return GT_PERF_STATUS;
                break;
        case REG_PKG_ENERGY_STATUS:
                if (xe->info.platform == XE_PVC && channel == CHANNEL_PKG)
-                       reg = PVC_GT0_PLATFORM_ENERGY_STATUS;
+                       return PVC_GT0_PLATFORM_ENERGY_STATUS;
                else if ((xe->info.platform == XE_DG2) && (channel == CHANNEL_PKG))
-                       reg = PCU_CR_PACKAGE_ENERGY_STATUS;
+                       return PCU_CR_PACKAGE_ENERGY_STATUS;
                break;
        default:
                drm_warn(&xe->drm, "Unknown xe hwmon reg id: %d\n", hwmon_reg);
                break;
        }
 
-       return reg.raw;
+       return XE_REG(0);
 }
 
 static void xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon_reg,
@@ -127,9 +127,9 @@ static void xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon
 {
        struct xe_reg reg;
 
-       reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg, channel);
+       reg = xe_hwmon_get_reg(hwmon, hwmon_reg, channel);
 
-       if (!reg.raw)
+       if (!xe_reg_is_valid(reg))
                return;
 
        switch (operation) {
@@ -400,7 +400,7 @@ static umode_t xe_hwmon_attributes_visible(struct kobject *kobj,
 
        xe_pm_runtime_get(gt_to_xe(hwmon->gt));
 
-       ret = xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, index) ? attr->mode : 0;
+       ret = xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, index)) ? attr->mode : 0;
 
        xe_pm_runtime_put(gt_to_xe(hwmon->gt));
 
@@ -496,16 +496,19 @@ xe_hwmon_power_is_visible(struct xe_hwmon *hwmon, u32 attr, int channel)
 
        switch (attr) {
        case hwmon_power_max:
-               return xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, channel) ? 0664 : 0;
+               return xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT,
+                                      channel)) ? 0664 : 0;
        case hwmon_power_rated_max:
-               return xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU, channel) ? 0444 : 0;
+               return xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU,
+                                      channel)) ? 0444 : 0;
        case hwmon_power_crit:
                if (channel == CHANNEL_PKG)
                        return (xe_hwmon_pcode_read_i1(hwmon->gt, &uval) ||
                                !(uval & POWER_SETUP_I1_WATTS)) ? 0 : 0644;
                break;
        case hwmon_power_label:
-               return xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT, channel) ? 0444 : 0;
+               return xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT,
+                                      channel)) ? 0444 : 0;
        default:
                return 0;
        }
@@ -588,7 +591,8 @@ xe_hwmon_in_is_visible(struct xe_hwmon *hwmon, u32 attr, int channel)
        switch (attr) {
        case hwmon_in_input:
        case hwmon_in_label:
-               return xe_hwmon_get_reg(hwmon, REG_GT_PERF_STATUS, channel) ? 0444 : 0;
+               return xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_GT_PERF_STATUS,
+                                      channel)) ? 0444 : 0;
        default:
                return 0;
        }
@@ -612,7 +616,8 @@ xe_hwmon_energy_is_visible(struct xe_hwmon *hwmon, u32 attr, int channel)
        switch (attr) {
        case hwmon_energy_input:
        case hwmon_energy_label:
-               return xe_hwmon_get_reg(hwmon, REG_PKG_ENERGY_STATUS, channel) ? 0444 : 0;
+               return xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_PKG_ENERGY_STATUS,
+                                      channel)) ? 0444 : 0;
        default:
                return 0;
        }
@@ -763,7 +768,7 @@ xe_hwmon_get_preregistration_info(struct xe_device *xe)
         * The contents of register PKG_POWER_SKU_UNIT do not change,
         * so read it once and store the shift values.
         */
-       if (xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT, 0)) {
+       if (xe_reg_is_valid(xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT, 0))) {
                xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU_UNIT,
                                     REG_READ32, &val_sku_unit, 0, 0, 0);
                hwmon->scl_shift_power = REG_FIELD_GET(PKG_PWR_UNIT, val_sku_unit);