Skip to contentSkip to conversation

DGFX HWMON Enhancement

PATCH Superseded Badal Nilawar 2 participants 10 messages Oct 18, 2023 – Oct 26, 2023

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

v2 cover DGFX HWMON Enhancement

This series contains some enhancements to xe hwmon.
The patch "Expose power1_max_interval" is, with couple of fixes, from previous series https://patchwork.freedesktop.org/series/118934/

v2:
- Fix review comments (Anshuman)

Badal Nilawar (3):
drm/xe/hwmon: Wrap 64 bit reg accesses to xe_hwmon_process_reg drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock drm/xe/hwmon: Expose power1_max_interval

 .../ABI/testing/sysfs-driver-intel-xe-hwmon   |   9 +
 drivers/gpu/drm/xe/regs/xe_mchbar_regs.h      |   8 +
 drivers/gpu/drm/xe/xe_hwmon.c                 | 353 ++++++++++++------
 3 files changed, 257 insertions(+), 113 deletions(-)
Signature · 1 line
2.25.1
#1 lore raw

PATCH v2 1/3 drm/xe/hwmon: Wrap 64 bit reg accesses to xe_hwmon_process_reg

Maintain single wrapper for 32 bit and 64 bit reg accesses

Cc Anshuman Gupta <[email protected]>
Cc Ashutosh Dixit <[email protected]>
---
 drivers/gpu/drm/xe/xe_hwmon.c | 122 +++++++++++++---------------------
 1 file changed, 45 insertions(+), 77 deletions(-)
drivers/gpu/drm/xe/xe_hwmon.c +45 -77
index 9ac05994a967..08c7289723ae 100644
@@ -26,9 +26,9 @@ enum xe_hwmon_reg {
 };
 
 enum xe_hwmon_reg_operation {
-	REG_READ,
-	REG_WRITE,
-	REG_RMW,
+	REG_READ32,
+	REG_RMW32,
+	REG_READ64,
 };
 
 /*
@@ -95,49 +95,34 @@ static u32 xe_hwmon_get_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon_reg)
 	return reg.raw;
 }
 
-static int xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon_reg,
-				enum xe_hwmon_reg_operation operation, u32 *value,
-				u32 clr, u32 set)
+static void xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg hwmon_reg,
+				 enum xe_hwmon_reg_operation operation, u64 *value,
+				 u32 clr, u32 set)
 {
 	struct xe_reg reg;
 
 	reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg);
 
 	if (!reg.raw)
-		return -EOPNOTSUPP;
+		return;
 
 	switch (operation) {
-	case REG_READ:
+	case REG_READ32:
 		*value = xe_mmio_read32(hwmon->gt, reg);
-		return 0;
-	case REG_WRITE:
-		xe_mmio_write32(hwmon->gt, reg, *value);
-		return 0;
-	case REG_RMW:
+		break;
+	case REG_RMW32:
 		*value = xe_mmio_rmw32(hwmon->gt, reg, clr, set);
-		return 0;
+		break;
+	case REG_READ64:
+		*value = xe_mmio_read64_2x32(hwmon->gt, reg);
+		break;
 	default:
 		drm_warn(&gt_to_xe(hwmon->gt)->drm, "Invalid xe hwmon reg operation: %d\n",
 			 operation);
-		return -EOPNOTSUPP;
+		break;
 	}
 }
 
-static int xe_hwmon_process_reg_read64(struct xe_hwmon *hwmon,
-				       enum xe_hwmon_reg hwmon_reg, u64 *value)
-{
-	struct xe_reg reg;
-
-	reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg);
-
-	if (!reg.raw)
-		return -EOPNOTSUPP;
-
-	*value = xe_mmio_read64_2x32(hwmon->gt, reg);
-
-	return 0;
-}
-
 #define PL1_DISABLE 0
 
 /*
@@ -146,42 +131,39 @@ static int xe_hwmon_process_reg_read64(struct xe_hwmon *hwmon,
  * same pattern for sysfs, allow arbitrary PL1 limits to be set but display
  * clamped values when read.
  */
-static int xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)
+static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)
 {
-	u32 reg_val;
-	u64 reg_val64, min, max;
+	u64 reg_val, min, max;
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ, &reg_val, 0, 0);
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ32, &reg_val, 0, 0);
 	/* Check if PL1 limit is disabled */
 	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
 		*value = PL1_DISABLE;
-		return 0;
+		return;
 	}
 
 	reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val);
 	*value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon->scl_shift_power);
 
-	xe_hwmon_process_reg_read64(hwmon, REG_PKG_POWER_SKU, &reg_val64);
-	min = REG_FIELD_GET(PKG_MIN_PWR, reg_val64);
+	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU, REG_READ64, &reg_val, 0, 0);
+	min = REG_FIELD_GET(PKG_MIN_PWR, reg_val);
 	min = mul_u64_u32_shr(min, SF_POWER, hwmon->scl_shift_power);
-	max = REG_FIELD_GET(PKG_MAX_PWR, reg_val64);
+	max = REG_FIELD_GET(PKG_MAX_PWR, reg_val);
 	max = mul_u64_u32_shr(max, SF_POWER, hwmon->scl_shift_power);
 
 	if (min && max)
 		*value = clamp_t(u64, *value, min, max);
-
-	return 0;
 }
 
 static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
 {
-	u32 reg_val;
+	u64 reg_val;
 
 	/* Disable PL1 limit and verify, as limit cannot be disabled on all platforms */
 	if (value == PL1_DISABLE) {
-		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW, &reg_val,
+		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW32, &reg_val,
 				     PKG_PWR_LIM_1_EN, 0);
-		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ, &reg_val,
+		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ32, &reg_val,
 				     PKG_PWR_LIM_1_EN, 0);
 
 		if (reg_val & PKG_PWR_LIM_1_EN)
@@ -192,21 +174,19 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
 	reg_val = DIV_ROUND_CLOSEST_ULL((u64)value << hwmon->scl_shift_power, SF_POWER);
 	reg_val = PKG_PWR_LIM_1_EN | REG_FIELD_PREP(PKG_PWR_LIM_1, reg_val);
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW, &reg_val,
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW32, &reg_val,
 			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
 
 	return 0;
 }
 
-static int xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, long *value)
+static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, long *value)
 {
-	u32 reg_val;
+	u64 reg_val;
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU, REG_READ, &reg_val, 0, 0);
+	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU, REG_READ32, &reg_val, 0, 0);
 	reg_val = REG_FIELD_GET(PKG_TDP, reg_val);
 	*value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon->scl_shift_power);
-
-	return 0;
 }
 
 /*
@@ -233,13 +213,11 @@ static void
 xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)
 {
 	struct xe_hwmon_energy_info *ei = &hwmon->ei;
-	u32 reg_val;
-
-	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
+	u64 reg_val;
 
 	mutex_lock(&hwmon->hwmon_lock);
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS, REG_READ,
+	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS, REG_READ32,
 			     &reg_val, 0, 0);
 
 	if (reg_val >= ei->reg_val_prev)
@@ -253,8 +231,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)
 				  hwmon->scl_shift_energy);
 
 	mutex_unlock(&hwmon->hwmon_lock);
-
-	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
 }
 
 static const struct hwmon_channel_info *hwmon_info[] = {
@@ -284,16 +260,14 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32 uval)
 			      uval);
 }
 
-static int xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
+static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
 {
-	u32 reg_val;
+	u64 reg_val;
 
 	xe_hwmon_process_reg(hwmon, REG_GT_PERF_STATUS,
-			     REG_READ, &reg_val, 0, 0);
+			     REG_READ32, &reg_val, 0, 0);
 	/* HW register value in units of 2.5 millivolt */
 	*value = DIV_ROUND_CLOSEST(REG_FIELD_GET(VOLTAGE_MASK, reg_val) * 2500, SF_VOLTAGE);
-
-	return 0;
 }
 
 static umode_t
@@ -322,9 +296,11 @@ xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int chan, long *val)
 
 	switch (attr) {
 	case hwmon_power_max:
-		return xe_hwmon_power_max_read(hwmon, val);
+		xe_hwmon_power_max_read(hwmon, val);
+		return 0;
 	case hwmon_power_rated_max:
-		return xe_hwmon_power_rated_max_read(hwmon, val);
+		xe_hwmon_power_rated_max_read(hwmon, val);
+		return 0;
 	case hwmon_power_crit:
 		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
 		if (ret)
@@ -418,21 +394,13 @@ xe_hwmon_in_is_visible(struct xe_hwmon *hwmon, u32 attr)
 static int
 xe_hwmon_in_read(struct xe_hwmon *hwmon, u32 attr, long *val)
 {
-	int ret;
-
-	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
-
 	switch (attr) {
 	case hwmon_in_input:
-		ret = xe_hwmon_get_voltage(hwmon, val);
-		break;
+		xe_hwmon_get_voltage(hwmon, val);
+		return 0;
 	default:
-		ret = -EOPNOTSUPP;
+		return -EOPNOTSUPP;
 	}
-
-	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
-
-	return ret;
 }
 
 static umode_t
@@ -564,15 +532,15 @@ xe_hwmon_get_preregistration_info(struct xe_device *xe)
 {
 	struct xe_hwmon *hwmon = xe->hwmon;
 	long energy;
-	u32 val_sku_unit = 0;
-	int ret;
+	u64 val_sku_unit = 0;
 
-	ret = xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU_UNIT, REG_READ, &val_sku_unit, 0, 0);
 	/*
 	 * The contents of register PKG_POWER_SKU_UNIT do not change,
 	 * so read it once and store the shift values.
 	 */
-	if (!ret) {
+	if (xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT)) {
+		xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU_UNIT,
+				     REG_READ32, &val_sku_unit, 0, 0);
 		hwmon->scl_shift_power = REG_FIELD_GET(PKG_PWR_UNIT, val_sku_unit);
 		hwmon->scl_shift_energy = REG_FIELD_GET(PKG_ENERGY_UNIT, val_sku_unit);
 	}
Signature · 1 line
2.25.1
Reviewed-by on v2 1/3
#2 lore raw

Re: [Intel-xe] [PATCH v2 1/3] drm/xe/hwmon: Wrap 64 bit reg accesses to xe_hwmon_process_reg

Quoted 12 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 19, 2023 12:34 AM
To: [email protected]
Cc: Gupta, Anshuman <[email protected]>; Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: [PATCH v2 1/3] drm/xe/hwmon: Wrap 64 bit reg accesses to xe_hwmon_process_reg

Quoted 1 line

Maintain single wrapper for 32 bit and 64 bit reg accesses

Missing full stop here.
The patch should do only the stuff mentioned in subject, converting function to void should be another patch.
With that,

Quoted 313 lines
Cc Anshuman Gupta <[email protected]>
Cc Ashutosh Dixit <[email protected]>
---
 drivers/gpu/drm/xe/xe_hwmon.c | 122 +++++++++++++---------------------
 1 file changed, 45 insertions(+), 77 deletions(-)
(quoted diff) +0 -0

b/drivers/gpu/drm/xe/xe_hwmon.c index 9ac05994a967..08c7289723ae 100644

drivers/gpu/drm/xe/xe_hwmon.c +15 -17
@@ -26,9 +26,9 @@ enum xe_hwmon_reg {
 };
 
 enum xe_hwmon_reg_operation {
-	REG_READ,
-	REG_WRITE,
-	REG_RMW,
+	REG_READ32,
+	REG_RMW32,
+	REG_READ64,
 };
 
 /*
@@ -95,49 +95,34 @@ static u32 xe_hwmon_get_reg(struct xe_hwmon
 *hwmon, enum xe_hwmon_reg hwmon_reg)
 	return reg.raw;
 }
 
-static int xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum
 xe_hwmon_reg hwmon_reg,
-				enum xe_hwmon_reg_operation operation,
 u32 *value,
-				u32 clr, u32 set)
+static void xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum
 xe_hwmon_reg hwmon_reg,
+				 enum xe_hwmon_reg_operation operation,
 u64 *value,
+				 u32 clr, u32 set)
 {
 	struct xe_reg reg;
 
 	reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg);
 
 	if (!reg.raw)
-		return -EOPNOTSUPP;
+		return;
 
 	switch (operation) {
-	case REG_READ:
+	case REG_READ32:
 		*value = xe_mmio_read32(hwmon->gt, reg);
-		return 0;
-	case REG_WRITE:
-		xe_mmio_write32(hwmon->gt, reg, *value);
-		return 0;
-	case REG_RMW:
+		break;
+	case REG_RMW32:
 		*value = xe_mmio_rmw32(hwmon->gt, reg, clr, set);
-		return 0;
+		break;
+	case REG_READ64:
+		*value = xe_mmio_read64_2x32(hwmon->gt, reg);
+		break;
 	default:
 		drm_warn(&gt_to_xe(hwmon->gt)->drm, "Invalid xe hwmon
 reg operation: %d\n",
 			 operation);
-		return -EOPNOTSUPP;
+		break;
 	}
 }
 
-static int xe_hwmon_process_reg_read64(struct xe_hwmon *hwmon,
-				       enum xe_hwmon_reg hwmon_reg, u64

*value)

drivers/gpu/drm/xe/xe_hwmon.c +10 -24
-{
-	struct xe_reg reg;
-
-	reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg);
-
-	if (!reg.raw)
-		return -EOPNOTSUPP;
-
-	*value = xe_mmio_read64_2x32(hwmon->gt, reg);
-
-	return 0;
-}
-
 #define PL1_DISABLE 0
 
 /*
@@ -146,42 +131,39 @@ static int xe_hwmon_process_reg_read64(struct
 xe_hwmon *hwmon,
  * same pattern for sysfs, allow arbitrary PL1 limits to be set but display
  * clamped values when read.
  */
-static int xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long
 *value)
+static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long
+*value)
 {
-	u32 reg_val;
-	u64 reg_val64, min, max;
+	u64 reg_val, min, max;
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ,
 &reg_val, 0, 0);
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_READ32, &reg_val,
+0, 0);
 	/* Check if PL1 limit is disabled */
 	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
 		*value = PL1_DISABLE;
-		return 0;
+		return;
 	}
 
 	reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val);
 	*value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon-
 >scl_shift_power);
 
-	xe_hwmon_process_reg_read64(hwmon, REG_PKG_POWER_SKU,
 &reg_val64);
-	min = REG_FIELD_GET(PKG_MIN_PWR, reg_val64);
+	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU,
 REG_READ64, &reg_val, 0, 0);
+	min = REG_FIELD_GET(PKG_MIN_PWR, reg_val);
 	min = mul_u64_u32_shr(min, SF_POWER, hwmon->scl_shift_power);
-	max = REG_FIELD_GET(PKG_MAX_PWR, reg_val64);
+	max = REG_FIELD_GET(PKG_MAX_PWR, reg_val);
 	max = mul_u64_u32_shr(max, SF_POWER, hwmon->scl_shift_power);
 
 	if (min && max)
 		*value = clamp_t(u64, *value, min, max);
-
-	return 0;
 }
 
 static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long
 value)  {
-	u32 reg_val;
+	u64 reg_val;
 
 	/* Disable PL1 limit and verify, as limit cannot be disabled on all

platforms */

drivers/gpu/drm/xe/xe_hwmon.c +0 -1
 	if (value == PL1_DISABLE) {
-		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW32, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +0 -1
 				     PKG_PWR_LIM_1_EN, 0);
-		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_READ, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_READ32, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +2 -2
 				     PKG_PWR_LIM_1_EN, 0);
 
 		if (reg_val & PKG_PWR_LIM_1_EN)
@@ -192,21 +174,19 @@ static int xe_hwmon_power_max_write(struct
 xe_hwmon *hwmon, long value)
 	reg_val = DIV_ROUND_CLOSEST_ULL((u64)value << hwmon-
 >scl_shift_power, SF_POWER);
 	reg_val = PKG_PWR_LIM_1_EN | REG_FIELD_PREP(PKG_PWR_LIM_1,
 reg_val);
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW,
 &reg_val,
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_RMW32, &reg_val,
 			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
 
 	return 0;
 }
 
-static int xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,
 long *value)
+static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,

long

drivers/gpu/drm/xe/xe_hwmon.c +2 -2
+*value)
 {
-	u32 reg_val;
+	u64 reg_val;
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU, REG_READ,

&reg_val, 0, 0);

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU,

REG_READ32, &reg_val,
+0, 0);

drivers/gpu/drm/xe/xe_hwmon.c +0 -0
 	reg_val = REG_FIELD_GET(PKG_TDP, reg_val);
 	*value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon-
Quoted 1 line

scl_shift_power);

drivers/gpu/drm/xe/xe_hwmon.c +2 -6
-
-	return 0;
 }
 
 /*
@@ -233,13 +213,11 @@ static void
 xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)  {
 	struct xe_hwmon_energy_info *ei = &hwmon->ei;
-	u32 reg_val;
-
-	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
+	u64 reg_val;
 
 	mutex_lock(&hwmon->hwmon_lock);
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,
 REG_READ,
+	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,
 REG_READ32,
 			     &reg_val, 0, 0);
 
drivers/gpu/drm/xe/xe_hwmon.c +0 -2
 	if (reg_val >= ei->reg_val_prev)
@@ -253,8 +231,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon,
 long *energy)
 				  hwmon->scl_shift_energy);
 
 	mutex_unlock(&hwmon->hwmon_lock);
-
-	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
 }
 

static const struct hwmon_channel_info *hwmon_info[] = { @@ -284,16
+260,14 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32 uval)

drivers/gpu/drm/xe/xe_hwmon.c +3 -3
 			      uval);
 }
 
-static int xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
+static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
 {
-	u32 reg_val;
+	u64 reg_val;
 
 	xe_hwmon_process_reg(hwmon, REG_GT_PERF_STATUS,
-			     REG_READ, &reg_val, 0, 0);
+			     REG_READ32, &reg_val, 0, 0);
 	/* HW register value in units of 2.5 millivolt */
 	*value = DIV_ROUND_CLOSEST(REG_FIELD_GET(VOLTAGE_MASK,

reg_val) * 2500, SF_VOLTAGE);

drivers/gpu/drm/xe/xe_hwmon.c +4 -4
-
-	return 0;
 }
 
 static umode_t
@@ -322,9 +296,11 @@ xe_hwmon_power_read(struct xe_hwmon
 *hwmon, u32 attr, int chan, long *val)
 
 	switch (attr) {
 	case hwmon_power_max:
-		return xe_hwmon_power_max_read(hwmon, val);
+		xe_hwmon_power_max_read(hwmon, val);
+		return 0;
 	case hwmon_power_rated_max:
-		return xe_hwmon_power_rated_max_read(hwmon, val);
+		xe_hwmon_power_rated_max_read(hwmon, val);
+		return 0;
 	case hwmon_power_crit:
 		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
drivers/gpu/drm/xe/xe_hwmon.c +7 -15
 		if (ret)
@@ -418,21 +394,13 @@ xe_hwmon_in_is_visible(struct xe_hwmon
 *hwmon, u32 attr)  static int  xe_hwmon_in_read(struct xe_hwmon *hwmon,
 u32 attr, long *val)  {
-	int ret;
-
-	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
-
 	switch (attr) {
 	case hwmon_in_input:
-		ret = xe_hwmon_get_voltage(hwmon, val);
-		break;
+		xe_hwmon_get_voltage(hwmon, val);
+		return 0;
 	default:
-		ret = -EOPNOTSUPP;
+		return -EOPNOTSUPP;
 	}
-
-	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
-
-	return ret;
 }
 
 static umode_t
@@ -564,15 +532,15 @@ xe_hwmon_get_preregistration_info(struct
 xe_device *xe)  {
 	struct xe_hwmon *hwmon = xe->hwmon;
 	long energy;
-	u32 val_sku_unit = 0;
-	int ret;
+	u64 val_sku_unit = 0;
 
-	ret = xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU_UNIT,
 REG_READ, &val_sku_unit, 0, 0);
 	/*
 	 * The contents of register PKG_POWER_SKU_UNIT do not change,
 	 * so read it once and store the shift values.
 	 */
-	if (!ret) {
+	if (xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT)) {
+		xe_hwmon_process_reg(hwmon,
 REG_PKG_POWER_SKU_UNIT,
+				     REG_READ32, &val_sku_unit, 0, 0);
 		hwmon->scl_shift_power = REG_FIELD_GET(PKG_PWR_UNIT,

val_sku_unit);
hwmon->scl_shift_energy =
REG_FIELD_GET(PKG_ENERGY_UNIT, val_sku_unit);
}
--
2.25.1

#3 lore raw

Re: [Intel-xe] [PATCH v2 1/3] drm/xe/hwmon: Wrap 64 bit reg accesses to xe_hwmon_process_reg

Quoted 12 lines · Anshuman
Quoted 12 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 19, 2023 12:34 AM
To: [email protected]
Cc: Gupta, Anshuman <[email protected]>; Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: [PATCH v2 1/3] drm/xe/hwmon: Wrap 64 bit reg accesses to xe_hwmon_process_reg

Quoted 4 lines
Quoted 1 line

Maintain single wrapper for 32 bit and 64 bit reg accesses

Missing full stop here.
The patch should do only the stuff mentioned in subject, converting function to void should be another patch.

I think I will rename patch as refactor patch and add some details about it in commit message.

Regards,
Badal

Quoted 316 lines

With that,

Quoted 313 lines
Cc Anshuman Gupta <[email protected]>
Cc Ashutosh Dixit <[email protected]>
---
  drivers/gpu/drm/xe/xe_hwmon.c | 122 +++++++++++++---------------------
  1 file changed, 45 insertions(+), 77 deletions(-)
(quoted diff) +0 -0

b/drivers/gpu/drm/xe/xe_hwmon.c index 9ac05994a967..08c7289723ae 100644

drivers/gpu/drm/xe/xe_hwmon.c +15 -17
@@ -26,9 +26,9 @@ enum xe_hwmon_reg {
  };
 
  enum xe_hwmon_reg_operation {
-	REG_READ,
-	REG_WRITE,
-	REG_RMW,
+	REG_READ32,
+	REG_RMW32,
+	REG_READ64,
  };
 
  /*
@@ -95,49 +95,34 @@ static u32 xe_hwmon_get_reg(struct xe_hwmon
 *hwmon, enum xe_hwmon_reg hwmon_reg)
  	return reg.raw;
  }
 
-static int xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum
 xe_hwmon_reg hwmon_reg,
-				enum xe_hwmon_reg_operation operation,
 u32 *value,
-				u32 clr, u32 set)
+static void xe_hwmon_process_reg(struct xe_hwmon *hwmon, enum
 xe_hwmon_reg hwmon_reg,
+				 enum xe_hwmon_reg_operation operation,
 u64 *value,
+				 u32 clr, u32 set)
  {
  	struct xe_reg reg;
 
  	reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg);
 
  	if (!reg.raw)
-		return -EOPNOTSUPP;
+		return;
 
  	switch (operation) {
-	case REG_READ:
+	case REG_READ32:
  		*value = xe_mmio_read32(hwmon->gt, reg);
-		return 0;
-	case REG_WRITE:
-		xe_mmio_write32(hwmon->gt, reg, *value);
-		return 0;
-	case REG_RMW:
+		break;
+	case REG_RMW32:
  		*value = xe_mmio_rmw32(hwmon->gt, reg, clr, set);
-		return 0;
+		break;
+	case REG_READ64:
+		*value = xe_mmio_read64_2x32(hwmon->gt, reg);
+		break;
  	default:
  		drm_warn(&gt_to_xe(hwmon->gt)->drm, "Invalid xe hwmon
 reg operation: %d\n",
  			 operation);
-		return -EOPNOTSUPP;
+		break;
  	}
  }
 
-static int xe_hwmon_process_reg_read64(struct xe_hwmon *hwmon,
-				       enum xe_hwmon_reg hwmon_reg, u64

*value)

drivers/gpu/drm/xe/xe_hwmon.c +10 -24
-{
-	struct xe_reg reg;
-
-	reg.raw = xe_hwmon_get_reg(hwmon, hwmon_reg);
-
-	if (!reg.raw)
-		return -EOPNOTSUPP;
-
-	*value = xe_mmio_read64_2x32(hwmon->gt, reg);
-
-	return 0;
-}
-
  #define PL1_DISABLE 0
 
  /*
@@ -146,42 +131,39 @@ static int xe_hwmon_process_reg_read64(struct
 xe_hwmon *hwmon,
   * same pattern for sysfs, allow arbitrary PL1 limits to be set but display
   * clamped values when read.
   */
-static int xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long
 *value)
+static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long
+*value)
  {
-	u32 reg_val;
-	u64 reg_val64, min, max;
+	u64 reg_val, min, max;
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ,
 &reg_val, 0, 0);
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_READ32, &reg_val,
+0, 0);
  	/* Check if PL1 limit is disabled */
  	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
  		*value = PL1_DISABLE;
-		return 0;
+		return;
  	}
 
  	reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val);
  	*value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon-
 > scl_shift_power);
 
-	xe_hwmon_process_reg_read64(hwmon, REG_PKG_POWER_SKU,
 &reg_val64);
-	min = REG_FIELD_GET(PKG_MIN_PWR, reg_val64);
+	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU,
 REG_READ64, &reg_val, 0, 0);
+	min = REG_FIELD_GET(PKG_MIN_PWR, reg_val);
  	min = mul_u64_u32_shr(min, SF_POWER, hwmon->scl_shift_power);
-	max = REG_FIELD_GET(PKG_MAX_PWR, reg_val64);
+	max = REG_FIELD_GET(PKG_MAX_PWR, reg_val);
  	max = mul_u64_u32_shr(max, SF_POWER, hwmon->scl_shift_power);
 
  	if (min && max)
  		*value = clamp_t(u64, *value, min, max);
-
-	return 0;
  }
 
  static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long
 value)  {
-	u32 reg_val;
+	u64 reg_val;
 
  	/* Disable PL1 limit and verify, as limit cannot be disabled on all

platforms */
if (value == PL1_DISABLE) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -1
-		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW32, &reg_val,
PKG_PWR_LIM_1_EN, 0);

drivers/gpu/drm/xe/xe_hwmon.c +0 -1
-		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_READ, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_READ32, &reg_val,
PKG_PWR_LIM_1_EN, 0);

if (reg_val & PKG_PWR_LIM_1_EN)

drivers/gpu/drm/xe/xe_hwmon.c +2 -2
@@ -192,21 +174,19 @@ static int xe_hwmon_power_max_write(struct
 xe_hwmon *hwmon, long value)
  	reg_val = DIV_ROUND_CLOSEST_ULL((u64)value << hwmon-
 > scl_shift_power, SF_POWER);
  	reg_val = PKG_PWR_LIM_1_EN | REG_FIELD_PREP(PKG_PWR_LIM_1,
 reg_val);
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW,
 &reg_val,
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_RMW32, &reg_val,
  			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
 
  	return 0;
  }
 
-static int xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,
 long *value)
+static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,

long

drivers/gpu/drm/xe/xe_hwmon.c +2 -2
+*value)
  {
-	u32 reg_val;
+	u64 reg_val;
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU, REG_READ,

&reg_val, 0, 0);

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+	xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU,

REG_READ32, &reg_val,
+0, 0);
reg_val = REG_FIELD_GET(PKG_TDP, reg_val); *value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon-

Quoted 1 line

scl_shift_power);

drivers/gpu/drm/xe/xe_hwmon.c +2 -6
-
-	return 0;
  }
 
  /*
@@ -233,13 +213,11 @@ static void
  xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)  {
  	struct xe_hwmon_energy_info *ei = &hwmon->ei;
-	u32 reg_val;
-
-	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
+	u64 reg_val;
 
  	mutex_lock(&hwmon->hwmon_lock);
 
-	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,
 REG_READ,
+	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,
 REG_READ32,
  			     &reg_val, 0, 0);
 

if (reg_val >= ei->reg_val_prev)

drivers/gpu/drm/xe/xe_hwmon.c +0 -2
@@ -253,8 +231,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon,
 long *energy)
  				  hwmon->scl_shift_energy);
 
  	mutex_unlock(&hwmon->hwmon_lock);
-
-	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
  }
 

static const struct hwmon_channel_info *hwmon_info[] = { @@ -284,16
+260,14 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32 uval)
uval);
}

drivers/gpu/drm/xe/xe_hwmon.c +3 -3
-static int xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
+static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
  {
-	u32 reg_val;
+	u64 reg_val;
 
  	xe_hwmon_process_reg(hwmon, REG_GT_PERF_STATUS,
-			     REG_READ, &reg_val, 0, 0);
+			     REG_READ32, &reg_val, 0, 0);
  	/* HW register value in units of 2.5 millivolt */
  	*value = DIV_ROUND_CLOSEST(REG_FIELD_GET(VOLTAGE_MASK,

reg_val) * 2500, SF_VOLTAGE);

drivers/gpu/drm/xe/xe_hwmon.c +4 -4
-
-	return 0;
  }
 
  static umode_t
@@ -322,9 +296,11 @@ xe_hwmon_power_read(struct xe_hwmon
 *hwmon, u32 attr, int chan, long *val)
 
  	switch (attr) {
  	case hwmon_power_max:
-		return xe_hwmon_power_max_read(hwmon, val);
+		xe_hwmon_power_max_read(hwmon, val);
+		return 0;
  	case hwmon_power_rated_max:
-		return xe_hwmon_power_rated_max_read(hwmon, val);
+		xe_hwmon_power_rated_max_read(hwmon, val);
+		return 0;
  	case hwmon_power_crit:
  		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);

if (ret)

drivers/gpu/drm/xe/xe_hwmon.c +7 -15
@@ -418,21 +394,13 @@ xe_hwmon_in_is_visible(struct xe_hwmon
 *hwmon, u32 attr)  static int  xe_hwmon_in_read(struct xe_hwmon *hwmon,
 u32 attr, long *val)  {
-	int ret;
-
-	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
-
  	switch (attr) {
  	case hwmon_in_input:
-		ret = xe_hwmon_get_voltage(hwmon, val);
-		break;
+		xe_hwmon_get_voltage(hwmon, val);
+		return 0;
  	default:
-		ret = -EOPNOTSUPP;
+		return -EOPNOTSUPP;
  	}
-
-	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
-
-	return ret;
  }
 
  static umode_t
@@ -564,15 +532,15 @@ xe_hwmon_get_preregistration_info(struct
 xe_device *xe)  {
  	struct xe_hwmon *hwmon = xe->hwmon;
  	long energy;
-	u32 val_sku_unit = 0;
-	int ret;
+	u64 val_sku_unit = 0;
 
-	ret = xe_hwmon_process_reg(hwmon, REG_PKG_POWER_SKU_UNIT,
 REG_READ, &val_sku_unit, 0, 0);
  	/*
  	 * The contents of register PKG_POWER_SKU_UNIT do not change,
  	 * so read it once and store the shift values.
  	 */
-	if (!ret) {
+	if (xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU_UNIT)) {
+		xe_hwmon_process_reg(hwmon,
 REG_PKG_POWER_SKU_UNIT,
+				     REG_READ32, &val_sku_unit, 0, 0);
  		hwmon->scl_shift_power = REG_FIELD_GET(PKG_PWR_UNIT,

val_sku_unit);
hwmon->scl_shift_energy =
REG_FIELD_GET(PKG_ENERGY_UNIT, val_sku_unit);
}
--
2.25.1

#4 lore raw

PATCH v2 2/3 drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

In reply to Badal Nilawar

Take hwmon_lock while accessing hwmon rw attributes. For readonly attributes its not required to take lock as reads are protected by sysfs layer and therefore sequential.

Cc Ashutosh Dixit <[email protected]>
Cc Anshuman Gupta <[email protected]>
---
 drivers/gpu/drm/xe/xe_hwmon.c | 92 ++++++++++++++++++++---------------
 1 file changed, 52 insertions(+), 40 deletions(-)
drivers/gpu/drm/xe/xe_hwmon.c +52 -40
index 08c7289723ae..c87d028f1955 100644
@@ -47,7 +47,7 @@ struct xe_hwmon_energy_info {
 struct xe_hwmon {
 	struct device *hwmon_dev;
 	struct xe_gt *gt;
-	struct mutex hwmon_lock; /* rmw operations*/
+	struct mutex hwmon_lock; /* For rw attributes */
 	int scl_shift_power;
 	int scl_shift_energy;
 	struct xe_hwmon_energy_info ei;	/*  Energy info for energy1_input */
@@ -135,11 +135,13 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)
 {
 	u64 reg_val, min, max;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
 	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ32, &reg_val, 0, 0);
 	/* Check if PL1 limit is disabled */
 	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
 		*value = PL1_DISABLE;
-		return;
+		goto unlock;
 	}
 
 	reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val);
@@ -153,12 +155,17 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)
 
 	if (min && max)
 		*value = clamp_t(u64, *value, min, max);
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
 }
 
 static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
 {
+	int ret = 0;
 	u64 reg_val;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
 	/* Disable PL1 limit and verify, as limit cannot be disabled on all platforms */
 	if (value == PL1_DISABLE) {
 		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW32, &reg_val,
@@ -166,8 +173,10 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
 		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ32, &reg_val,
 				     PKG_PWR_LIM_1_EN, 0);
 
-		if (reg_val & PKG_PWR_LIM_1_EN)
-			return -EOPNOTSUPP;
+		if (reg_val & PKG_PWR_LIM_1_EN) {
+			ret = -EOPNOTSUPP;
+			goto unlock;
+		}
 	}
 
 	/* Computation in 64-bits to avoid overflow. Round to nearest. */
@@ -176,8 +185,9 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
 
 	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW32, &reg_val,
 			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
-
-	return 0;
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
 }
 
 static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, long *value)
@@ -215,8 +225,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)
 	struct xe_hwmon_energy_info *ei = &hwmon->ei;
 	u64 reg_val;
 
-	mutex_lock(&hwmon->hwmon_lock);
-
 	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS, REG_READ32,
 			     &reg_val, 0, 0);
 
@@ -229,8 +237,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)
 
 	*energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY,
 				  hwmon->scl_shift_energy);
-
-	mutex_unlock(&hwmon->hwmon_lock);
 }
 
 static const struct hwmon_channel_info *hwmon_info[] = {
@@ -260,6 +266,38 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32 uval)
 			      uval);
 }
 
+static int xe_hwmon_power_curr_crit_read(struct xe_hwmon *hwmon, long *value, u32 scale_factor)
+{
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
+	if (ret)
+		goto unlock;
+
+	*value = mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
+				 scale_factor, POWER_SETUP_I1_SHIFT);
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
+static int xe_hwmon_power_curr_crit_write(struct xe_hwmon *hwmon, long value, u32 scale_factor)
+{
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	uval = DIV_ROUND_CLOSEST_ULL(value << POWER_SETUP_I1_SHIFT, scale_factor);
+	ret = xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
 static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)
 {
 	u64 reg_val;
@@ -291,9 +329,6 @@ xe_hwmon_power_is_visible(struct xe_hwmon *hwmon, u32 attr, int chan)
 static int
 xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int chan, long *val)
 {
-	int ret;
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_power_max:
 		xe_hwmon_power_max_read(hwmon, val);
@@ -302,14 +337,7 @@ xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int chan, long *val)
 		xe_hwmon_power_rated_max_read(hwmon, val);
 		return 0;
 	case hwmon_power_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (!(uval & POWER_SETUP_I1_WATTS))
-			return -ENODEV;
-		*val = mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_POWER, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val, SF_POWER);
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -318,14 +346,11 @@ xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int chan, long *val)
 static int
 xe_hwmon_power_write(struct xe_hwmon *hwmon, u32 attr, int chan, long val)
 {
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_power_max:
 		return xe_hwmon_power_max_write(hwmon, val);
 	case hwmon_power_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val << POWER_SETUP_I1_SHIFT, SF_POWER);
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val, SF_POWER);
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -348,19 +373,9 @@ xe_hwmon_curr_is_visible(const struct xe_hwmon *hwmon, u32 attr)
 static int
 xe_hwmon_curr_read(struct xe_hwmon *hwmon, u32 attr, long *val)
 {
-	int ret;
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_curr_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (uval & POWER_SETUP_I1_WATTS)
-			return -ENODEV;
-		*val = mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_CURR, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val, SF_CURR);
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -369,12 +384,9 @@ xe_hwmon_curr_read(struct xe_hwmon *hwmon, u32 attr, long *val)
 static int
 xe_hwmon_curr_write(struct xe_hwmon *hwmon, u32 attr, long val)
 {
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_curr_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val << POWER_SETUP_I1_SHIFT, SF_CURR);
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val, SF_CURR);
 	default:
 		return -EOPNOTSUPP;
 	}
Signature · 1 line
2.25.1
#5 lore raw

Re: [Intel-xe] [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 12 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 19, 2023 12:34 AM
To: [email protected]
Cc: Gupta, Anshuman <[email protected]>; Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 3 lines

Take hwmon_lock while accessing hwmon rw attributes. For readonly attributes its not required to take lock as reads are protected by sysfs layer and therefore sequential.

This patch should only have functionality related to locking, why this is adding xe_hwmon_power_curr_crit_write and xe_hwmon_power_curr_crit_read ?

Quoted 15 lines
Cc Ashutosh Dixit <[email protected]>
Cc Anshuman Gupta <[email protected]>
---
 drivers/gpu/drm/xe/xe_hwmon.c | 92 ++++++++++++++++++++--------------
(quoted diff) +0 -1
-
 1 file changed, 52 insertions(+), 40 deletions(-)
(quoted diff) +0 -0

b/drivers/gpu/drm/xe/xe_hwmon.c index 08c7289723ae..c87d028f1955 100644

drivers/gpu/drm/xe/xe_hwmon.c struct xe_hwmon_energy_info { struct xe_hwmon { · line 49

Quoted 4 lines
drivers/gpu/drm/xe/xe_hwmon.c +1 -1
@@ -47,7 +47,7 @@ struct xe_hwmon_energy_info {  struct xe_hwmon {
 	struct device *hwmon_dev;
 	struct xe_gt *gt;
-	struct mutex hwmon_lock; /* rmw operations*/
+	struct mutex hwmon_lock; /* For rw attributes */

Make this Kernel Doc comment, and this is wrongly placed here in .c , structure are declared In headers in all xe files, and requires kernel doc comment.
Thanks,
Anshuman Gupta.

Quoted 215 lines
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
 	int scl_shift_power;
 	int scl_shift_energy;
 	struct xe_hwmon_energy_info ei;	/*  Energy info for

energy1_input */

drivers/gpu/drm/xe/xe_hwmon.c +3 -1
@@ -135,11 +135,13 @@ static void xe_hwmon_power_max_read(struct
 xe_hwmon *hwmon, long *value)  {
 	u64 reg_val, min, max;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
 	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_READ32, &reg_val, 0, 0);
 	/* Check if PL1 limit is disabled */
 	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
 		*value = PL1_DISABLE;
-		return;
+		goto unlock;
 	}
 

reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val); @@ -153,12
+155,17 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)

drivers/gpu/drm/xe/xe_hwmon.c +2 -0
 	if (min && max)
 		*value = clamp_t(u64, *value, min, max);
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
 }
 
 static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long

value) {

drivers/gpu/drm/xe/xe_hwmon.c +3 -0
+	int ret = 0;
 	u64 reg_val;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
 	/* Disable PL1 limit and verify, as limit cannot be disabled on all

platforms */

drivers/gpu/drm/xe/xe_hwmon.c +0 -0
 	if (value == PL1_DISABLE) {
 		xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW32, &reg_val, @@ -166,8 +173,10 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
REG_READ32, &reg_val,

drivers/gpu/drm/xe/xe_hwmon.c +7 -4
 				     PKG_PWR_LIM_1_EN, 0);
 
-		if (reg_val & PKG_PWR_LIM_1_EN)
-			return -EOPNOTSUPP;
+		if (reg_val & PKG_PWR_LIM_1_EN) {
+			ret = -EOPNOTSUPP;
+			goto unlock;
+		}
 	}
 
 	/* Computation in 64-bits to avoid overflow. Round to nearest. */
@@ -176,8 +185,9 @@ static int xe_hwmon_power_max_write(struct
 xe_hwmon *hwmon, long value)
 
 	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_RMW32, &reg_val,
 			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
-
-	return 0;
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
 }

static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,
long *value) @@ -215,8 +225,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)

drivers/gpu/drm/xe/xe_hwmon.c +0 -2
 	struct xe_hwmon_energy_info *ei = &hwmon->ei;
 	u64 reg_val;
 
-	mutex_lock(&hwmon->hwmon_lock);
-
 	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,

REG_READ32,

drivers/gpu/drm/xe/xe_hwmon.c +0 -2
 			     &reg_val, 0, 0);
@@ -229,8 +237,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon,
 long *energy)
 
 	*energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY,
 				  hwmon->scl_shift_energy);
-
-	mutex_unlock(&hwmon->hwmon_lock);
 }
 

static const struct hwmon_channel_info *hwmon_info[] = { @@ -260,6
+266,38 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32 uval)

drivers/gpu/drm/xe/xe_hwmon.c +12 -0
 			      uval);
 }
 
+static int xe_hwmon_power_curr_crit_read(struct xe_hwmon *hwmon, long
+*value, u32 scale_factor) {
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
+	if (ret)
+		goto unlock;
+
+	*value =

mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),

drivers/gpu/drm/xe/xe_hwmon.c +14 -0
+				 scale_factor, POWER_SETUP_I1_SHIFT);
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
+static int xe_hwmon_power_curr_crit_write(struct xe_hwmon *hwmon, long
+value, u32 scale_factor) {
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	uval = DIV_ROUND_CLOSEST_ULL(value << POWER_SETUP_I1_SHIFT,

scale_factor);

drivers/gpu/drm/xe/xe_hwmon.c +7 -11
+	ret = xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
 static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)  {
 	u64 reg_val;
@@ -291,9 +329,6 @@ xe_hwmon_power_is_visible(struct xe_hwmon
 *hwmon, u32 attr, int chan)  static int  xe_hwmon_power_read(struct
 xe_hwmon *hwmon, u32 attr, int chan, long *val)  {
-	int ret;
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_power_max:
 		xe_hwmon_power_max_read(hwmon, val);
@@ -302,14 +337,7 @@ xe_hwmon_power_read(struct xe_hwmon
 *hwmon, u32 attr, int chan, long *val)
 		xe_hwmon_power_rated_max_read(hwmon, val);
 		return 0;
 	case hwmon_power_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (!(uval & POWER_SETUP_I1_WATTS))
-			return -ENODEV;
-		*val =
 mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_POWER, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val,
 SF_POWER);
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -318,14 +346,11 @@ xe_hwmon_power_read(struct xe_hwmon
 *hwmon, u32 attr, int chan, long *val)  static int

xe_hwmon_power_write(struct xe_hwmon *hwmon, u32 attr, int chan, long val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_power_max:
 		return xe_hwmon_power_max_write(hwmon, val);
 	case hwmon_power_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val <<

POWER_SETUP_I1_SHIFT, SF_POWER);

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val,

SF_POWER);

drivers/gpu/drm/xe/xe_hwmon.c +1 -11
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -348,19 +373,9 @@ xe_hwmon_curr_is_visible(const struct xe_hwmon
 *hwmon, u32 attr)  static int  xe_hwmon_curr_read(struct xe_hwmon
 *hwmon, u32 attr, long *val)  {
-	int ret;
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_curr_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (uval & POWER_SETUP_I1_WATTS)
-			return -ENODEV;
-		*val =
 mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_CURR, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val,
 SF_CURR);
 	default:
 		return -EOPNOTSUPP;
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
 	}
@@ -369,12 +384,9 @@ xe_hwmon_curr_read(struct xe_hwmon *hwmon,

u32 attr, long *val) static int xe_hwmon_curr_write(struct xe_hwmon *hwmon, u32 attr, long val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	u32 uval;
-
 	switch (attr) {
 	case hwmon_curr_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val <<

POWER_SETUP_I1_SHIFT, SF_CURR);

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val,

SF_CURR);

drivers/gpu/drm/xe/xe_hwmon.c +0 -1
 	default:
 		return -EOPNOTSUPP;
 	}
--

2.25.1

#6 lore raw

Re: [Intel-xe] [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 12 lines · Anshuman
Quoted 12 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 19, 2023 12:34 AM
To: [email protected]
Cc: Gupta, Anshuman <[email protected]>; Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 5 lines
Quoted 3 lines

Take hwmon_lock while accessing hwmon rw attributes. For readonly attributes its not required to take lock as reads are protected by sysfs layer and therefore sequential.

This patch should only have functionality related to locking, why this is adding xe_hwmon_power_curr_crit_write and xe_hwmon_power_curr_crit_read ?

Sure, will add these functions to refactor patch.

Quoted 9 lines
Quoted 9 lines
Cc Ashutosh Dixit <[email protected]>
Cc Anshuman Gupta <[email protected]>
---
  drivers/gpu/drm/xe/xe_hwmon.c | 92 ++++++++++++++++++++--------------
-
  1 file changed, 52 insertions(+), 40 deletions(-)
Quoted 12 lines

drivers/gpu/drm/xe/xe_hwmon.c struct xe_hwmon_energy_info { struct xe_hwmon { · line 49

Quoted 10 lines
(quoted diff) +0 -0

b/drivers/gpu/drm/xe/xe_hwmon.c index 08c7289723ae..c87d028f1955 100644

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
@@ -47,7 +47,7 @@ struct xe_hwmon_energy_info {  struct xe_hwmon {
  	struct device *hwmon_dev;
  	struct xe_gt *gt;
-	struct mutex hwmon_lock; /* rmw operations*/
+	struct mutex hwmon_lock; /* For rw attributes */

Make this Kernel Doc comment, and this is wrongly placed here in .c , structure are declared In headers in all xe files, and requires kernel doc comment.

Sure will add kernel doc comment. Struct added here as it is used only in this file. Infact in drivers/gpu/drm/xe/xe_mocs.c has structures defined in it.

Regards,
Badal

Quoted 218 lines

Thanks,
Anshuman Gupta.

Quoted 215 lines
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
  	int scl_shift_power;
  	int scl_shift_energy;
  	struct xe_hwmon_energy_info ei;	/*  Energy info for

energy1_input */

drivers/gpu/drm/xe/xe_hwmon.c +3 -1
@@ -135,11 +135,13 @@ static void xe_hwmon_power_max_read(struct
 xe_hwmon *hwmon, long *value)  {
  	u64 reg_val, min, max;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
  	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_READ32, &reg_val, 0, 0);
  	/* Check if PL1 limit is disabled */
  	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
  		*value = PL1_DISABLE;
-		return;
+		goto unlock;
  	}
 

reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val); @@ -153,12
+155,17 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)

  	if (min && max)
  		*value = clamp_t(u64, *value, min, max);
drivers/gpu/drm/xe/xe_hwmon.c +2 -0
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
  }
 
  static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long

value) {

drivers/gpu/drm/xe/xe_hwmon.c +3 -0
+	int ret = 0;
  	u64 reg_val;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
  	/* Disable PL1 limit and verify, as limit cannot be disabled on all

platforms */
if (value == PL1_DISABLE) {
xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
REG_RMW32, &reg_val, @@ -166,8 +173,10 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
REG_READ32, &reg_val,
PKG_PWR_LIM_1_EN, 0);

drivers/gpu/drm/xe/xe_hwmon.c +7 -4
-		if (reg_val & PKG_PWR_LIM_1_EN)
-			return -EOPNOTSUPP;
+		if (reg_val & PKG_PWR_LIM_1_EN) {
+			ret = -EOPNOTSUPP;
+			goto unlock;
+		}
  	}
 
  	/* Computation in 64-bits to avoid overflow. Round to nearest. */
@@ -176,8 +185,9 @@ static int xe_hwmon_power_max_write(struct
 xe_hwmon *hwmon, long value)
 
  	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
 REG_RMW32, &reg_val,
  			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
-
-	return 0;
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
  }

static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,
long *value) @@ -215,8 +225,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)
struct xe_hwmon_energy_info *ei = &hwmon->ei; u64 reg_val;

drivers/gpu/drm/xe/xe_hwmon.c +0 -2
-	mutex_lock(&hwmon->hwmon_lock);
-
  	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,

REG_READ32,
&reg_val, 0, 0);

drivers/gpu/drm/xe/xe_hwmon.c +0 -2
@@ -229,8 +237,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon,
 long *energy)
 
  	*energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY,
  				  hwmon->scl_shift_energy);
-
-	mutex_unlock(&hwmon->hwmon_lock);
  }
 

static const struct hwmon_channel_info *hwmon_info[] = { @@ -260,6
+266,38 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32 uval)
uval);
}

drivers/gpu/drm/xe/xe_hwmon.c +12 -0
+static int xe_hwmon_power_curr_crit_read(struct xe_hwmon *hwmon, long
+*value, u32 scale_factor) {
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
+	if (ret)
+		goto unlock;
+
+	*value =

mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),

drivers/gpu/drm/xe/xe_hwmon.c +14 -0
+				 scale_factor, POWER_SETUP_I1_SHIFT);
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
+static int xe_hwmon_power_curr_crit_write(struct xe_hwmon *hwmon, long
+value, u32 scale_factor) {
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	uval = DIV_ROUND_CLOSEST_ULL(value << POWER_SETUP_I1_SHIFT,

scale_factor);

drivers/gpu/drm/xe/xe_hwmon.c +7 -11
+	ret = xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
  static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)  {
  	u64 reg_val;
@@ -291,9 +329,6 @@ xe_hwmon_power_is_visible(struct xe_hwmon
 *hwmon, u32 attr, int chan)  static int  xe_hwmon_power_read(struct
 xe_hwmon *hwmon, u32 attr, int chan, long *val)  {
-	int ret;
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_power_max:
  		xe_hwmon_power_max_read(hwmon, val);
@@ -302,14 +337,7 @@ xe_hwmon_power_read(struct xe_hwmon
 *hwmon, u32 attr, int chan, long *val)
  		xe_hwmon_power_rated_max_read(hwmon, val);
  		return 0;
  	case hwmon_power_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (!(uval & POWER_SETUP_I1_WATTS))
-			return -ENODEV;
-		*val =
 mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_POWER, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val,
 SF_POWER);
  	default:
  		return -EOPNOTSUPP;
  	}
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
@@ -318,14 +346,11 @@ xe_hwmon_power_read(struct xe_hwmon
 *hwmon, u32 attr, int chan, long *val)  static int

xe_hwmon_power_write(struct xe_hwmon *hwmon, u32 attr, int chan, long val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_power_max:
  		return xe_hwmon_power_max_write(hwmon, val);
  	case hwmon_power_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val <<

POWER_SETUP_I1_SHIFT, SF_POWER);

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val,

SF_POWER);
default:
return -EOPNOTSUPP;
}

drivers/gpu/drm/xe/xe_hwmon.c +1 -11
@@ -348,19 +373,9 @@ xe_hwmon_curr_is_visible(const struct xe_hwmon
 *hwmon, u32 attr)  static int  xe_hwmon_curr_read(struct xe_hwmon
 *hwmon, u32 attr, long *val)  {
-	int ret;
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_curr_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (uval & POWER_SETUP_I1_WATTS)
-			return -ENODEV;
-		*val =
 mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_CURR, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val,
 SF_CURR);
  	default:
  		return -EOPNOTSUPP;
  	}
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
@@ -369,12 +384,9 @@ xe_hwmon_curr_read(struct xe_hwmon *hwmon,

u32 attr, long *val) static int xe_hwmon_curr_write(struct xe_hwmon *hwmon, u32 attr, long val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_curr_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val <<

POWER_SETUP_I1_SHIFT, SF_CURR);

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val,

SF_CURR);
default:
return -EOPNOTSUPP;
}
--
2.25.1

#7 lore raw

Re: [Intel-xe] [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 56 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 26, 2023 3:47 PM
To: Gupta, Anshuman <[email protected]>; intel- [email protected]
Cc: Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: Re: [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 12 lines · Anshuman
Quoted 12 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 19, 2023 12:34 AM
To: [email protected]
Cc: Gupta, Anshuman <[email protected]>; Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: [PATCH v2 2/3] drm/xe/hwmon: Protect hwmon rw attributes with hwmon_lock

Quoted 5 lines
Quoted 3 lines

Take hwmon_lock while accessing hwmon rw attributes. For readonly attributes its not required to take lock as reads are protected by sysfs layer and therefore sequential.

This patch should only have functionality related to locking, why this is adding xe_hwmon_power_curr_crit_write and

xe_hwmon_power_curr_crit_read ?
Sure, will add these functions to refactor patch.

Quoted 10 lines
Quoted 10 lines
Cc Ashutosh Dixit <[email protected]>
Cc Anshuman Gupta <[email protected]>
---
  drivers/gpu/drm/xe/xe_hwmon.c | 92
++++++++++++++++++++--------------
-
  1 file changed, 52 insertions(+), 40 deletions(-)
Quoted 12 lines

drivers/gpu/drm/xe/xe_hwmon.c struct xe_hwmon_energy_info { struct xe_hwmon { · line 49

Quoted 10 lines
(quoted diff) +0 -0

b/drivers/gpu/drm/xe/xe_hwmon.c index 08c7289723ae..c87d028f1955 100644

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
@@ -47,7 +47,7 @@ struct xe_hwmon_energy_info {  struct xe_hwmon {
  	struct device *hwmon_dev;
  	struct xe_gt *gt;
-	struct mutex hwmon_lock; /* rmw operations*/
+	struct mutex hwmon_lock; /* For rw attributes */

Make this Kernel Doc comment, and this is wrongly placed here in .c , structure are declared In headers in all xe files, and requires kernel doc

Quoted 3 lines

comment.
Sure will add kernel doc comment. Struct added here as it is used only in this file. Infact in drivers/gpu/drm/xe/xe_mocs.c has structures defined in it.

Pl you can keep it in the same file.
Thanks,
Anshuman Gupta.

Quoted 228 lines

Regards,
Badal

Quoted 36 lines

Thanks,
Anshuman Gupta.

Quoted 34 lines
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
  	int scl_shift_power;
  	int scl_shift_energy;
  	struct xe_hwmon_energy_info ei;	/*  Energy info for

energy1_input */

drivers/gpu/drm/xe/xe_hwmon.c +3 -1
@@ -135,11 +135,13 @@ static void xe_hwmon_power_max_read(struct
 xe_hwmon *hwmon, long *value)  {
  	u64 reg_val, min, max;
 
+	mutex_lock(&hwmon->hwmon_lock);
+
  	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_READ32,
 &reg_val, 0, 0);
  	/* Check if PL1 limit is disabled */
  	if (!(reg_val & PKG_PWR_LIM_1_EN)) {
  		*value = PL1_DISABLE;
-		return;
+		goto unlock;
  	}
 

reg_val = REG_FIELD_GET(PKG_PWR_LIM_1, reg_val); @@ -153,12
+155,17 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, long *value)

  	if (min && max)
  		*value = clamp_t(u64, *value, min, max);
drivers/gpu/drm/xe/xe_hwmon.c +2 -0
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
  }
 
  static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long

value) {

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+	int ret = 0;
  	u64 reg_val;
Quoted 6 lines
Quoted 6 lines
drivers/gpu/drm/xe/xe_hwmon.c +2 -0
+	mutex_lock(&hwmon->hwmon_lock);
+
  	/* Disable PL1 limit and verify, as limit cannot be disabled on

all platforms */
if (value == PL1_DISABLE) {
xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW32,

Quoted 3 lines
Quoted 3 lines

&reg_val, @@ -166,8 +173,10 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, long value)
xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_READ32,

Quoted 31 lines
Quoted 31 lines

&reg_val,
PKG_PWR_LIM_1_EN, 0);

drivers/gpu/drm/xe/xe_hwmon.c +7 -4
-		if (reg_val & PKG_PWR_LIM_1_EN)
-			return -EOPNOTSUPP;
+		if (reg_val & PKG_PWR_LIM_1_EN) {
+			ret = -EOPNOTSUPP;
+			goto unlock;
+		}
  	}
 
  	/* Computation in 64-bits to avoid overflow. Round to nearest. */
@@ -176,8 +185,9 @@ static int xe_hwmon_power_max_write(struct
 xe_hwmon *hwmon, long value)
 
  	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT, REG_RMW32,
 &reg_val,
  			     PKG_PWR_LIM_1_EN | PKG_PWR_LIM_1, reg_val);
-
-	return 0;
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
  }

static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon,
long *value) @@ -215,8 +225,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)
struct xe_hwmon_energy_info *ei = &hwmon->ei;
u64 reg_val;

Quoted 3 lines

drivers/gpu/drm/xe/xe_hwmon.c xe_hwmon_energy_get(struct xe_hwmon *hwmon, long *energy)

Quoted 3 lines
drivers/gpu/drm/xe/xe_hwmon.c +0 -2
-	mutex_lock(&hwmon->hwmon_lock);
-
  	xe_hwmon_process_reg(hwmon, REG_PKG_ENERGY_STATUS,

REG_READ32,

Quoted 3 lines

drivers/gpu/drm/xe/xe_hwmon.c xe_hwmon_energy_get(struct xe_hwmon *hwmon,

Quoted 3 lines

&reg_val, 0, 0);

drivers/gpu/drm/xe/xe_hwmon.c +0 -0
@@ -229,8 +237,6 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon,

long

Quoted 43 lines
Quoted 43 lines
drivers/gpu/drm/xe/xe_hwmon.c +0 -2
 *energy)
 
  	*energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY,
  				  hwmon->scl_shift_energy);
-
-	mutex_unlock(&hwmon->hwmon_lock);
  }
 

static const struct hwmon_channel_info *hwmon_info[] = { @@ -260,6
+266,38 @@ static int xe_hwmon_pcode_write_i1(struct xe_gt *gt, u32

drivers/gpu/drm/xe/xe_hwmon.c +13 -0
+uval)
  			      uval);
  }
 
+static int xe_hwmon_power_curr_crit_read(struct xe_hwmon *hwmon,
+long *value, u32 scale_factor) {
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
+	if (ret)
+		goto unlock;
+
+	*value =

mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),

drivers/gpu/drm/xe/xe_hwmon.c +14 -0
+				 scale_factor, POWER_SETUP_I1_SHIFT);
+unlock:
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
+static int xe_hwmon_power_curr_crit_write(struct xe_hwmon *hwmon,
+long value, u32 scale_factor) {
+	int ret;
+	u32 uval;
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	uval = DIV_ROUND_CLOSEST_ULL(value << POWER_SETUP_I1_SHIFT,

scale_factor);

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+	ret = xe_hwmon_pcode_write_i1(hwmon->gt, uval);
Quoted 8 lines

drivers/gpu/drm/xe/xe_hwmon.c xe_hwmon_power_is_visible(struct xe_hwmon

Quoted 8 lines
drivers/gpu/drm/xe/xe_hwmon.c +5 -0
+
+	mutex_unlock(&hwmon->hwmon_lock);
+	return ret;
+}
+
  static void xe_hwmon_get_voltage(struct xe_hwmon *hwmon, long *value)  {
  	u64 reg_val;
@@ -291,9 +329,6 @@ xe_hwmon_power_is_visible(struct xe_hwmon

*hwmon,

Quoted 8 lines

drivers/gpu/drm/xe/xe_hwmon.c xe_hwmon_power_is_visible(struct xe_hwmon *hwmon, u32 attr, int chan)

Quoted 8 lines

u32 attr, int chan) static int xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int chan, long *val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	int ret;
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_power_max:
  		xe_hwmon_power_max_read(hwmon, val); @@ -302,14 +337,7

@@

Quoted 12 lines
Quoted 12 lines

xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int chan, long *val)
xe_hwmon_power_rated_max_read(hwmon, val); return 0;
case hwmon_power_crit:

drivers/gpu/drm/xe/xe_hwmon.c +0 -6
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (!(uval & POWER_SETUP_I1_WATTS))
-			return -ENODEV;
-		*val =

mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),

Quoted 8 lines

drivers/gpu/drm/xe/xe_hwmon.c xe_hwmon_power_read(struct xe_hwmon

Quoted 8 lines
drivers/gpu/drm/xe/xe_hwmon.c +1 -2
-				       SF_POWER, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val,

SF_POWER);
default:
return -EOPNOTSUPP;
}

drivers/gpu/drm/xe/xe_hwmon.c +0 -0
@@ -318,14 +346,11 @@ xe_hwmon_power_read(struct xe_hwmon

*hwmon, u32

Quoted 57 lines
Quoted 56 lines

attr, int chan, long *val) static int xe_hwmon_power_write(struct xe_hwmon *hwmon, u32 attr, int chan, long
val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_power_max:
  		return xe_hwmon_power_max_write(hwmon, val);
  	case hwmon_power_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val <<

POWER_SETUP_I1_SHIFT, SF_POWER);

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val,

SF_POWER);
default:
return -EOPNOTSUPP;
}

drivers/gpu/drm/xe/xe_hwmon.c +1 -11
@@ -348,19 +373,9 @@ xe_hwmon_curr_is_visible(const struct xe_hwmon
 *hwmon, u32 attr)  static int  xe_hwmon_curr_read(struct xe_hwmon
 *hwmon, u32 attr, long *val)  {
-	int ret;
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_curr_crit:
-		ret = xe_hwmon_pcode_read_i1(hwmon->gt, &uval);
-		if (ret)
-			return ret;
-		if (uval & POWER_SETUP_I1_WATTS)
-			return -ENODEV;
-		*val =
 mul_u64_u32_shr(REG_FIELD_GET(POWER_SETUP_I1_DATA_MASK, uval),
-				       SF_CURR, POWER_SETUP_I1_SHIFT);
-		return 0;
+		return xe_hwmon_power_curr_crit_read(hwmon, val,
 SF_CURR);
  	default:
  		return -EOPNOTSUPP;
  	}
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
@@ -369,12 +384,9 @@ xe_hwmon_curr_read(struct xe_hwmon *hwmon,

u32 attr, long *val) static int xe_hwmon_curr_write(struct xe_hwmon *hwmon, u32 attr, long val) {

drivers/gpu/drm/xe/xe_hwmon.c +0 -3
-	u32 uval;
-
  	switch (attr) {
  	case hwmon_curr_crit:
-		uval = DIV_ROUND_CLOSEST_ULL(val <<

POWER_SETUP_I1_SHIFT, SF_CURR);

drivers/gpu/drm/xe/xe_hwmon.c +1 -1
-		return xe_hwmon_pcode_write_i1(hwmon->gt, uval);
+		return xe_hwmon_power_curr_crit_write(hwmon, val,

SF_CURR);
default:
return -EOPNOTSUPP;
}
--
2.25.1

#8 lore raw

PATCH v2 3/3 drm/xe/hwmon: Expose power1_max_interval

In reply to Badal Nilawar

Expose power1_max_interval, that is the tau corresponding to PL1, as a custom hwmon attribute. Some bit manipulation is needed because of the format of PKG_PWR_LIM_1_TIME in
PACKAGE_RAPL_LIMIT register (1.x * power(2,y))

v2: Get rpm wake ref while accessing power1_max_interval
v3: %s/hwmon/xe_hwmon/
v4:
- As power1_max_interval is rw attr take lock in read function as well
- Refine comment about val to fix point conversion (Andi)
- Update kernel version and date in doc
v5:
- Fix review comments (Anshuman)

---
 .../ABI/testing/sysfs-driver-intel-xe-hwmon   |   9 ++
 drivers/gpu/drm/xe/regs/xe_mchbar_regs.h      |   8 +
 drivers/gpu/drm/xe/xe_hwmon.c                 | 149 +++++++++++++++++-
 3 files changed, 165 insertions(+), 1 deletion(-)
Documentation/ABI/testing/sysfs-driver-intel-xe-hwmon +9 -0
index 1a7a6c23e141..8c321bc9dc04 100644
@@ -59,3 +59,12 @@ Contact:	[email protected]
 Description:	RO. Energy input of device in microjoules.
 
 		Only supported for particular Intel xe graphics platforms.
+
+What:		/sys/devices/.../hwmon/hwmon<i>/power1_max_interval
+Date:		October 2023
+KernelVersion:	6.6
+Contact:	[email protected]
+Description:	RW. Sustained power limit interval (Tau in PL1/Tau) in
+		milliseconds over which sustained power is averaged.
+
+		Only supported for particular Intel xe graphics platforms.
drivers/gpu/drm/xe/regs/xe_mchbar_regs.h +8 -0
index d8ecbe1858d1..519dd1067a19 100644
@@ -22,15 +22,23 @@
 #define   PKG_TDP				GENMASK_ULL(14, 0)
 #define   PKG_MIN_PWR				GENMASK_ULL(30, 16)
 #define   PKG_MAX_PWR				GENMASK_ULL(46, 32)
+#define   PKG_MAX_WIN				GENMASK_ULL(54, 48)
+#define     PKG_MAX_WIN_X			GENMASK_ULL(54, 53)
+#define     PKG_MAX_WIN_Y			GENMASK_ULL(52, 48)
+
 
 #define PCU_CR_PACKAGE_POWER_SKU_UNIT		XE_REG(MCHBAR_MIRROR_BASE_SNB + 0x5938)
 #define   PKG_PWR_UNIT				REG_GENMASK(3, 0)
 #define   PKG_ENERGY_UNIT			REG_GENMASK(12, 8)
+#define   PKG_TIME_UNIT				REG_GENMASK(19, 16)
 
 #define PCU_CR_PACKAGE_ENERGY_STATUS		XE_REG(MCHBAR_MIRROR_BASE_SNB + 0x593c)
 
 #define PCU_CR_PACKAGE_RAPL_LIMIT		XE_REG(MCHBAR_MIRROR_BASE_SNB + 0x59a0)
 #define   PKG_PWR_LIM_1				REG_GENMASK(14, 0)
 #define   PKG_PWR_LIM_1_EN			REG_BIT(15)
+#define   PKG_PWR_LIM_1_TIME			REG_GENMASK(23, 17)
+#define   PKG_PWR_LIM_1_TIME_X			REG_GENMASK(23, 22)
+#define   PKG_PWR_LIM_1_TIME_Y			REG_GENMASK(21, 17)
 
 #endif /* _XE_MCHBAR_REGS_H_ */
drivers/gpu/drm/xe/xe_hwmon.c +148 -1

179 lines not on this page · raw message

Signature · 1 line
2.25.1
Reviewed-by on v2 3/3
#9 lore raw

Re: [Intel-xe] [PATCH v2 3/3] drm/xe/hwmon: Expose power1_max_interval

Quoted 178 lines

-----Original Message-----
From: Nilawar, Badal <[email protected]>
Sent: Thursday, October 19, 2023 12:34 AM
To: [email protected]
Cc: Gupta, Anshuman <[email protected]>; Dixit, Ashutosh <[email protected]>; [email protected]; Tauro, Riana <[email protected]>; Vivi, Rodrigo <[email protected]>
Subject: [PATCH v2 3/3] drm/xe/hwmon: Expose power1_max_interval

Expose power1_max_interval, that is the tau corresponding to PL1, as a custom hwmon attribute. Some bit manipulation is needed because of the format of PKG_PWR_LIM_1_TIME in PACKAGE_RAPL_LIMIT register (1.x * power(2,y))

v2: Get rpm wake ref while accessing power1_max_interval
v3: %s/hwmon/xe_hwmon/
v4:
- As power1_max_interval is rw attr take lock in read function as well
- Refine comment about val to fix point conversion (Andi)
- Update kernel version and date in doc
v5:
- Fix review comments (Anshuman)

---
 .../ABI/testing/sysfs-driver-intel-xe-hwmon   |   9 ++
 drivers/gpu/drm/xe/regs/xe_mchbar_regs.h      |   8 +
 drivers/gpu/drm/xe/xe_hwmon.c                 | 149 +++++++++++++++++-
 3 files changed, 165 insertions(+), 1 deletion(-)
Documentation/ABI/testing/sysfs-driver-intel-xe-hwmon +9 -0
index 1a7a6c23e141..8c321bc9dc04 100644
@@ -59,3 +59,12 @@ Contact:	[email protected]
 Description:	RO. Energy input of device in microjoules.
 
 		Only supported for particular Intel xe graphics platforms.
+
+What:		/sys/devices/.../hwmon/hwmon<i>/power1_max_interval
+Date:		October 2023
+KernelVersion:	6.6
+Contact:	[email protected]
+Description:	RW. Sustained power limit interval (Tau in PL1/Tau) in
+		milliseconds over which sustained power is averaged.
+
+		Only supported for particular Intel xe graphics platforms.
drivers/gpu/drm/xe/regs/xe_mchbar_regs.h +5 -0
index d8ecbe1858d1..519dd1067a19 100644
@@ -22,15 +22,23 @@
 #define   PKG_TDP				GENMASK_ULL(14, 0)
 #define   PKG_MIN_PWR				GENMASK_ULL(30,
 16)
 #define   PKG_MAX_PWR				GENMASK_ULL(46,
 32)
+#define   PKG_MAX_WIN				GENMASK_ULL(54,
 48)
+#define     PKG_MAX_WIN_X			GENMASK_ULL(54, 53)
+#define     PKG_MAX_WIN_Y			GENMASK_ULL(52, 48)
+
 
 #define PCU_CR_PACKAGE_POWER_SKU_UNIT
 	XE_REG(MCHBAR_MIRROR_BASE_SNB + 0x5938)
 #define   PKG_PWR_UNIT				REG_GENMASK(3, 0)
 #define   PKG_ENERGY_UNIT			REG_GENMASK(12, 8)
+#define   PKG_TIME_UNIT				REG_GENMASK(19,
 16)
 
 #define PCU_CR_PACKAGE_ENERGY_STATUS
 	XE_REG(MCHBAR_MIRROR_BASE_SNB + 0x593c)
 
 #define PCU_CR_PACKAGE_RAPL_LIMIT
	XE_REG(MCHBAR_MIRROR_BASE_SNB + 0x59a0)

#define PKG_PWR_LIM_1 REG_GENMASK(14,
0)
#define PKG_PWR_LIM_1_EN REG_BIT(15)
+#define PKG_PWR_LIM_1_TIME REG_GENMASK(23,
17)
+#define PKG_PWR_LIM_1_TIME_X REG_GENMASK(23,
22)
+#define PKG_PWR_LIM_1_TIME_Y REG_GENMASK(21,
17)

#endif /* _XE_MCHBAR_REGS_H_ */

(quoted diff) +0 -0

b/drivers/gpu/drm/xe/xe_hwmon.c index c87d028f1955..661d5269fb5b 100644

drivers/gpu/drm/xe/xe_hwmon.c +2 -0
@@ -38,6 +38,7 @@ enum xe_hwmon_reg_operation {
 #define SF_CURR		1000		/* milliamperes */
 #define SF_VOLTAGE	1000		/* millivolts */
 #define SF_ENERGY	1000000		/* microjoules */
+#define SF_TIME		1000		/* milliseconds */
 
 struct xe_hwmon_energy_info {
 	u32 reg_val_prev;
@@ -50,6 +51,7 @@ struct xe_hwmon {
 	struct mutex hwmon_lock; /* For rw attributes */
 	int scl_shift_power;
 	int scl_shift_energy;
+	int scl_shift_time;
 	struct xe_hwmon_energy_info ei;	/*  Energy info for

energy1_input */
};

drivers/gpu/drm/xe/xe_hwmon.c +41 -0
@@ -239,6 +241,149 @@ xe_hwmon_energy_get(struct xe_hwmon
 *hwmon, long *energy)
 				  hwmon->scl_shift_energy);
 }
 
+static ssize_t
+xe_hwmon_power1_max_interval_show(struct device *dev, struct
 device_attribute *attr,
+				  char *buf)
+{
+	struct xe_hwmon *hwmon = dev_get_drvdata(dev);
+	u32 x, y, x_w = 2; /* 2 bits */
+	u64 r, tau4, out;
+
+	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,
+			     REG_READ32, &r, 0, 0);
+
+	mutex_unlock(&hwmon->hwmon_lock);
+
+	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
+
+	x = REG_FIELD_GET(PKG_PWR_LIM_1_TIME_X, r);
+	y = REG_FIELD_GET(PKG_PWR_LIM_1_TIME_Y, r);
+
+	/*
+	 * tau = 1.x * power(2,y), x = bits(23:22), y = bits(21:17)
+	 *     = (4 | x) << (y - 2)
+	 *
+	 * Here (y - 2) ensures a 1.x fixed point representation of 1.x
+	 * As x is 2 bits so 1.x can be 1.0, 1.25, 1.50, 1.75
+	 *
+	 * As y can be < 2, we compute tau4 = (4 | x) << y
+	 * and then add 2 when doing the final right shift to account for units
+	 */
+	tau4 = ((1 << x_w) | x) << y;
+
+	/* val in hwmon interface units (millisec) */
+	out = mul_u64_u32_shr(tau4, SF_TIME, hwmon->scl_shift_time +
 x_w);
+
+	return sysfs_emit(buf, "%llu\n", out); }
+
+static ssize_t
+xe_hwmon_power1_max_interval_store(struct device *dev, struct

device_attribute *attr,

drivers/gpu/drm/xe/xe_hwmon.c +15 -0
+				   const char *buf, size_t count)
+{
+	struct xe_hwmon *hwmon = dev_get_drvdata(dev);
+	u32 x, y, rxy, x_w = 2; /* 2 bits */
+	u64 tau4, r, max_win;
+	unsigned long val;
+	int ret;
+
+	ret = kstrtoul(buf, 0, &val);
+	if (ret)
+		return ret;
+
+	/*
+	 * Max HW supported tau in '1.x * power(2,y)' format, x = 0, y = 0x12
+	 * The hwmon->scl_shift_time default of 0xa results in a max tau of
Quoted 1 line

256 seconds

"Add . full stop above"

Quoted 2 lines
drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+	 * For DG2, PVC PKG_PWR_SKU does not show valid PKG_MAX_WIN

so going with default

I think we need something like below, you can format that as code comment.
"Ideally we should have read PKG_MAX_WIN from PKG_PWR_SKU register but our discrete GPU does not provide the correct value, therefore using the default constant value, future discrete GPU should fix that and we should read the PKG_MAX_WIN from PKG_PWR_SKU "
With that.

" "

Quoted 119 lines
drivers/gpu/drm/xe/xe_hwmon.c +43 -0
+	 * For future platforms this limitation may get addressed.
+	 */
+#define PKG_MAX_WIN_DEFAULT 0x12ull
+
+	/*
+	 * val must be < max in hwmon interface units. The steps below are
+	 * explained in xe_hwmon_power1_max_interval_show()
+	 */
+	r = FIELD_PREP(PKG_MAX_WIN, PKG_MAX_WIN_DEFAULT);
+	x = REG_FIELD_GET(PKG_MAX_WIN_X, r);
+	y = REG_FIELD_GET(PKG_MAX_WIN_Y, r);
+	tau4 = ((1 << x_w) | x) << y;
+	max_win = mul_u64_u32_shr(tau4, SF_TIME, hwmon->scl_shift_time
+ x_w);
+
+	if (val > max_win)
+		return -EINVAL;
+
+	/* val in hw units */
+	val = DIV_ROUND_CLOSEST_ULL((u64)val << hwmon->scl_shift_time,
+SF_TIME);
+
+	/*
+	 * Convert val to 1.x * power(2,y)
+	 * y = ilog2(val)
+	 * x = (val - (1 << y)) >> (y - 2)
+	 */
+	if (!val) {
+		y = 0;
+		x = 0;
+	} else {
+		y = ilog2(val);
+		x = (val - (1ul << y)) << x_w >> y;
+	}
+
+	rxy = REG_FIELD_PREP(PKG_PWR_LIM_1_TIME_X, x) |
+REG_FIELD_PREP(PKG_PWR_LIM_1_TIME_Y, y);
+
+	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
+
+	mutex_lock(&hwmon->hwmon_lock);
+
+	xe_hwmon_process_reg(hwmon, REG_PKG_RAPL_LIMIT,

REG_RMW32, (u64 *)&r,

drivers/gpu/drm/xe/xe_hwmon.c +28 -0
+			     PKG_PWR_LIM_1_TIME, rxy);
+
+	mutex_unlock(&hwmon->hwmon_lock);
+
+	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
+
+	return count;
+}
+
+static SENSOR_DEVICE_ATTR(power1_max_interval, 0664,
+			  xe_hwmon_power1_max_interval_show,
+			  xe_hwmon_power1_max_interval_store, 0);
+
+static struct attribute *hwmon_attributes[] = {
+	&sensor_dev_attr_power1_max_interval.dev_attr.attr,
+	NULL
+};
+
+static umode_t xe_hwmon_attributes_visible(struct kobject *kobj,
+					   struct attribute *attr, int index) {
+	struct device *dev = kobj_to_dev(kobj);
+	struct xe_hwmon *hwmon = dev_get_drvdata(dev);
+	int ret = 0;
+
+	xe_device_mem_access_get(gt_to_xe(hwmon->gt));
+
+	if (attr == &sensor_dev_attr_power1_max_interval.dev_attr.attr)
+		ret = xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT) ?

attr->mode : 0;

drivers/gpu/drm/xe/xe_hwmon.c +15 -0
+
+	xe_device_mem_access_put(gt_to_xe(hwmon->gt));
+
+	return ret;
+}
+
+static const struct attribute_group hwmon_attrgroup = {
+	.attrs = hwmon_attributes,
+	.is_visible = xe_hwmon_attributes_visible, };
+
+static const struct attribute_group *hwmon_groups[] = {
+	&hwmon_attrgroup,
+	NULL
+};
+
 static const struct hwmon_channel_info *hwmon_info[] = {
 	HWMON_CHANNEL_INFO(power, HWMON_P_MAX |

HWMON_P_RATED_MAX | HWMON_P_CRIT),

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
 	HWMON_CHANNEL_INFO(curr, HWMON_C_CRIT), @@ -555,6
+700,7 @@ xe_hwmon_get_preregistration_info(struct xe_device *xe)
 				     REG_READ32, &val_sku_unit, 0, 0);
 		hwmon->scl_shift_power = REG_FIELD_GET(PKG_PWR_UNIT,

val_sku_unit);
hwmon->scl_shift_energy =
REG_FIELD_GET(PKG_ENERGY_UNIT, val_sku_unit);

drivers/gpu/drm/xe/xe_hwmon.c +1 -0
+		hwmon->scl_shift_time = REG_FIELD_GET(PKG_TIME_UNIT,

val_sku_unit);

drivers/gpu/drm/xe/xe_hwmon.c +2 -1
 	}
 
 	/*
@@ -601,7 +747,8 @@ void xe_hwmon_register(struct xe_device *xe)
 	/*  hwmon_dev points to device hwmon<i> */
 	hwmon->hwmon_dev =
 devm_hwmon_device_register_with_info(dev, "xe", hwmon,
 
 	&hwmon_chip_info,
-								NULL);
+
 	hwmon_groups);
+
drivers/gpu/drm/xe/xe_hwmon.c +0 -0
 	if (IS_ERR(hwmon->hwmon_dev)) {
 		drm_warn(&xe->drm, "Failed to register xe hwmon (%pe)\n",

hwmon->hwmon_dev);
xe->hwmon = NULL;
--
2.25.1