board input power: rename instances of "pwr" to "power"

kikkiakki · kikkiakki · commit b85a8a72b3e3 · 2025-05-14T11:41:30.000-04:00
Replace the abbreviation "pwr" with "power" to improve readability.

Signed-off-by: Petra Alexson &lt;palexson@tenstorrent.com&gt;
diff --git a/app/dmc/src/main.c b/app/dmc/src/main.c
@@ -127,7 +127,7 @@ void process_cm2dm_message(struct bh_chip *chip)
 	}
 }
 
-void ina228_pwr_update(void)
+void ina228_power_update(void)
 {
 	struct sensor_value sensor_val;
 
@@ -137,11 +137,11 @@ void ina228_pwr_update(void)
 	int32_t power = (sensor_val.val1 << 16) + (sensor_val.val2 * 65536ULL) / 1000000ULL;
 
 	ARRAY_FOR_EACH_PTR(BH_CHIPS, chip) {
-		bh_chip_set_input_pwr(chip, &power);
+		bh_chip_set_input_power(chip, &power);
 	}
 }
 
-uint16_t detect_max_pwr(void)
+uint16_t detect_max_power(void)
 {
 	static const struct gpio_dt_spec psu_sense0 =
 		GPIO_DT_SPEC_GET_OR(DT_PATH(psu_sense0), gpios, {0});
@@ -154,28 +154,28 @@ uint16_t detect_max_pwr(void)
 	int sense0_val = gpio_pin_get_dt(&psu_sense0);
 	int sense1_val = gpio_pin_get_dt(&psu_sense1);
 
-	uint16_t psu_pwr;
+	uint16_t psu_power;
 
 	if (!sense0_val && !sense1_val) {
-		psu_pwr = 600;
+		psu_power = 600;
 	} else if (sense0_val && !sense1_val) {
-		psu_pwr = 450;
+		psu_power = 450;
 	} else if (!sense0_val && sense1_val) {
-		psu_pwr = 300;
+		psu_power = 300;
 	} else {
 		/* Pins could either be open or shorted together */
 		/* Pull down one and check the other */
 		gpio_pin_configure_dt(&psu_sense0, GPIO_OUTPUT_LOW);
 		if (!gpio_pin_get_dt(&psu_sense1)) {
 			/* If shorted together then max power is 150W */
-			psu_pwr = 150;
+			psu_power = 150;
 		} else {
-			psu_pwr = 0;
+			psu_power = 0;
 		}
 		gpio_pin_configure_dt(&psu_sense0, GPIO_INPUT);
 	}
 
-	return psu_pwr;
+	return psu_power;
 }
 
 int main(void)
@@ -298,7 +298,7 @@ int main(void)
 	dmStaticInfo static_info =
 		(dmStaticInfo){.version = 1, .bl_version = 0, .app_version = APPVERSION};
 
-	uint16_t max_pwr = detect_max_pwr();
+	uint16_t max_power = detect_max_power();
 
 	while (true) {
 		tt_event_wait(TT_EVENT_WAKE, K_MSEC(20));
@@ -341,14 +341,14 @@ int main(void)
 		ARRAY_FOR_EACH_PTR(BH_CHIPS, chip) {
 			if (chip->data.arc_needs_init_msg) {
 				if (bh_chip_set_static_info(chip, &static_info) == 0 &&
-				    bh_chip_set_board_pwr_lim(chip, max_pwr) == 0) {
+				    bh_chip_set_input_power_lim(chip, max_power) == 0) {
 					chip->data.arc_needs_init_msg = false;
 				}
 			}
 		}
 
 		if (IS_ENABLED(CONFIG_INA228)) {
-			ina228_pwr_update();
+			ina228_power_update();
 		}
 
 		if (IS_ENABLED(CONFIG_TT_FAN_CTRL)) {
diff --git a/include/tenstorrent/bh_chip.h b/include/tenstorrent/bh_chip.h
@@ -117,8 +117,8 @@ void bh_chip_cancel_bus_transfer_clear(struct bh_chip *chip);
 cm2dmMessageRet bh_chip_get_cm2dm_message(struct bh_chip *chip);
 int bh_chip_set_static_info(struct bh_chip *chip, dmStaticInfo *info);
 int bh_chip_set_input_current(struct bh_chip *chip, int32_t *current);
-int bh_chip_set_input_pwr(struct bh_chip *chip, uint32_t *power);
-int bh_chip_set_input_pwr_lim(struct bh_chip *chip, uint16_t max_pwr);
+int bh_chip_set_input_power(struct bh_chip *chip, uint32_t *power);
+int bh_chip_set_input_power_lim(struct bh_chip *chip, uint16_t max_power);
 int bh_chip_set_fan_rpm(struct bh_chip *chip, uint16_t rpm);
 
 void bh_chip_assert_asic_reset(const struct bh_chip *chip);
diff --git a/lib/tenstorrent/bh_arc/aiclk_ppm.h b/lib/tenstorrent/bh_arc/aiclk_ppm.h
@@ -14,7 +14,7 @@ typedef enum {
 	kAiclkArbMaxFastTDC,
 	kAiclkArbMaxTDC,
 	kAiclkArbMaxThm,
-	kAiclkArbMaxBoardPwr,
+	kAiclkArbMaxBoardPower,
 	kAiclkArbMaxVoltage,
 	kAiclkArbMaxGDDRThm,
 	kAiclkArbMaxCount,
diff --git a/lib/tenstorrent/bh_arc/cm2bm_msg.c b/lib/tenstorrent/bh_arc/cm2bm_msg.c
@@ -224,6 +224,7 @@ int32_t Bm2CmPingHandler(const uint8_t *data, uint8_t size)
 	return 0;
 }
 
+
 int32_t Bm2CmSendCurrentHandler(const uint8_t *data, uint8_t size)
 {
 	if (size != 4) {
@@ -235,7 +236,7 @@ int32_t Bm2CmSendCurrentHandler(const uint8_t *data, uint8_t size)
 	return 0;
 }
 
-int32_t Bm2CmSendPwrHandler(const uint8_t *data, uint8_t size)
+int32_t Bm2CmSendPowerHandler(const uint8_t *data, uint8_t size)
 {
 	if (size != 4) {
 		return -1;
diff --git a/lib/tenstorrent/bh_arc/cm2bm_msg.h b/lib/tenstorrent/bh_arc/cm2bm_msg.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024 Tenstorrent AI ULC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CM2BM_MSG_H
+#define CM2BM_MSG_H
+
+#include <stdint.h>
+#include <zephyr/toolchain.h>
+
+typedef enum {
+	kCm2BmMsgIdNull = 0,
+	kCm2BmMsgIdResetReq = 1,
+	kCm2BmMsgIdPing = 2,
+	kCm2BmMsgIdFanSpeedUpdate = 3,
+} Cm2BmMsgId;
+
+typedef struct {
+	uint8_t msg_id;
+	uint32_t data;
+} Cm2BmMsg;
+
+typedef struct {
+	uint8_t msg_id;
+	uint8_t seq_num;
+	uint32_t data;
+} __packed Cm2BmSmbusReqMsg;
+
+typedef struct {
+	uint8_t msg_id;
+	uint8_t seq_num;
+} __packed Cm2BmSmbusAckMsg;
+
+int32_t EnqueueCm2BmMsg(const Cm2BmMsg *msg);
+int32_t Cm2BmMsgReqSmbusHandler(uint8_t *data, uint8_t size);
+int32_t Cm2BmMsgAckSmbusHandler(const uint8_t *data, uint8_t size);
+int32_t ResetBoardByte(uint8_t *data, uint8_t size);
+
+void ChipResetRequest(void *arg);
+void UpdateFanSpeedRequest(uint32_t fan_speed);
+
+typedef struct bmStaticInfo {
+	/* Non-zero for valid data */
+	/* Allows for breaking changes */
+	uint32_t version;
+	uint32_t bl_version;
+	uint32_t app_version;
+} __packed bmStaticInfo;
+
+int32_t Bm2CmSendDataHandler(const uint8_t *data, uint8_t size);
+int32_t Bm2CmPingHandler(const uint8_t *data, uint8_t size);
+int32_t Bm2CmSendCurrentHandler(const uint8_t *data, uint8_t size);
+int32_t Bm2CmSendPowerHandler(const uint8_t *data, uint8_t size);
+int32_t GetInputCurrent(void);
+uint32_t GetInputPower(void);
+int32_t Bm2CmSendFanRPMHandler(const uint8_t *data, uint8_t size);
+
+#endif
diff --git a/lib/tenstorrent/bh_arc/cm2dm_msg.c b/lib/tenstorrent/bh_arc/cm2dm_msg.c
@@ -230,7 +230,7 @@ int32_t Dm2CmPingHandler(const uint8_t *data, uint8_t size)
 	return 0;
 }
 
-int32_t Dm2CmSendPwrHandler(const uint8_t *data, uint8_t size)
+int32_t Dm2CmSendPowerHandler(const uint8_t *data, uint8_t size)
 {
 	if (size != 4) {
 		return -1;
diff --git a/lib/tenstorrent/bh_arc/cm2dm_msg.h b/lib/tenstorrent/bh_arc/cm2dm_msg.h
@@ -53,7 +53,7 @@ typedef struct dmStaticInfo {
 int32_t Dm2CmSendDataHandler(const uint8_t *data, uint8_t size);
 int32_t Dm2CmPingHandler(const uint8_t *data, uint8_t size);
 int32_t Dm2CmSendCurrentHandler(const uint8_t *data, uint8_t size);
-int32_t Dm2CmSendPwrHandler(const uint8_t *data, uint8_t size);
+int32_t Dm2CmSendPowerHandler(const uint8_t *data, uint8_t size);
 int32_t GetInputCurrent(void);
 uint32_t GetInputPower(void);
 int32_t Dm2CmSendFanRPMHandler(const uint8_t *data, uint8_t size);
diff --git a/lib/tenstorrent/bh_arc/smbus_target.c b/lib/tenstorrent/bh_arc/smbus_target.c
@@ -174,13 +174,13 @@ static SmbusConfig smbus_config = {
 #ifndef CONFIG_TT_SMC_RECOVERY
 		[0x24] = {.valid = 1,
 			  .trans_type = kSmbusTransWriteWord,
-			  .handler = {.rcv_handler = &Dm2CmSetBoardPwrLimit}},
+			  .handler = {.rcv_handler = &Dm2CmSetBoardPowerLimit}},
 		[0x25] = {
 			.valid = 1,
 			.trans_type = kSmbusTransBlockWrite,
 			.expected_blocksize = 4,
 			.handler = {
-					.rcv_handler = &Dm2CmSendPwrHandler
+					.rcv_handler = &Dm2CmSendPowerHandler
 			}},
 #endif
 		[0xD8] = {.valid = 1,
diff --git a/lib/tenstorrent/bh_arc/telemetry.c b/lib/tenstorrent/bh_arc/telemetry.c
@@ -321,7 +321,7 @@ static void update_tag_table(void)
 	tag_table[47] = (struct telemetry_entry){TAG_GDDR_UNCORR_ERRS, GDDR_UNCORR_ERRS};
 	tag_table[48] = (struct telemetry_entry){TAG_MAX_GDDR_TEMP, MAX_GDDR_TEMP};
 	tag_table[49] = (struct telemetry_entry){TAG_ASIC_LOCATION, ASIC_LOCATION};
-	tag_table[50] = (struct telemetry_entry){TAG_BOARD_PWR_LIMIT, BOARD_PWR_LIMIT};
+	tag_table[50] = (struct telemetry_entry){TAG_BOARD_POWER_LIMIT, BOARD_POWER_LIMIT};
 	tag_table[51] = (struct telemetry_entry){TAG_INPUT_POWER, INPUT_POWER};
 	tag_table[52] = (struct telemetry_entry){TAG_TELEM_ENUM_COUNT, TELEM_ENUM_COUNT};
 }
@@ -381,7 +381,7 @@ void UpdateTelemetryNocTranslation(bool translation_enabled)
 	telemetry[NOC_TRANSLATION] = translation_enabled;
 }
 
-void UpdateTelemetryBoardPwrLimit(uint32_t pwr_limit)
+void UpdateTelemetryBoardPowerLimit(uint32_t power_limit)
 {
-	telemetry[BOARD_PWR_LIMIT] = pwr_limit;
+	telemetry[BOARD_POWER_LIMIT] = power_limit;
 }
diff --git a/lib/tenstorrent/bh_arc/telemetry.h b/lib/tenstorrent/bh_arc/telemetry.h
@@ -67,8 +67,8 @@
 #define TAG_GDDR_UNCORR_ERRS     50
 #define TAG_MAX_GDDR_TEMP        51
 #define TAG_ASIC_LOCATION        52
-#define TAG_BOARD_PWR_LIMIT      53
-#define TAG_INPUT_POWER			 54
+#define TAG_BOARD_POWER_LIMIT    53
+#define TAG_INPUT_POWER          54
 
 /* Enums are subject to updates */
 typedef enum {
@@ -123,7 +123,7 @@ typedef enum {
 	/* Board telemetry */
 	FAN_SPEED,
 	FAN_RPM,
-	BOARD_PWR_LIMIT,
+	BOARD_POWER_LIMIT,
 	INPUT_POWER,
 
 	/* Tile enablement/harvesting information */
@@ -160,6 +160,6 @@ int GetMaxGDDRTemp(void);
 void StartTelemetryTimer(void);
 void UpdateDmFwVersion(uint32_t bl_version, uint32_t app_version);
 void UpdateTelemetryNocTranslation(bool translation_enabled);
-void UpdateTelemetryBoardPwrLimit(uint32_t pwr_limit);
+void UpdateTelemetryBoardPowerLimit(uint32_t power_limit);
 
 #endif
diff --git a/lib/tenstorrent/bh_arc/throttler.c b/lib/tenstorrent/bh_arc/throttler.c
@@ -15,15 +15,15 @@
 #include "telemetry.h"
 
 #define kThrottlerAiclkScaleFactor 500.0F
-#define DEFAULT_BOARD_PWR_LIMIT 150
+#define DEFAULT_BOARD_POWER_LIMIT  150
 
 LOG_MODULE_REGISTER(throttler);
 typedef enum {
 	kThrottlerTDP,
 	kThrottlerFastTDC,
 	kThrottlerTDC,
 	kThrottlerThm,
-	kThrottlerBoardPwr,
+	kThrottlerBoardPower,
 	kThrottlerGDDRThm,
 	kThrottlerCount,
 } ThrottlerId;
@@ -37,35 +37,29 @@ typedef struct {
 /* They are passed in from the FW table in SPI */
 static const ThrottlerLimitRange throttler_limit_ranges[kThrottlerCount] = {
 	[kThrottlerTDP] = {
-
 			.min = 50,
 			.max = 500,
 		},
 	[kThrottlerFastTDC] = {
-
 			.min = 50,
 			.max = 500,
 		},
 	[kThrottlerTDC] = {
-
 			.min = 50,
 			.max = 400,
 		},
 	[kThrottlerThm] = {
-
 			.min = 50,
 			.max = 100,
 		},
-	[kThrottlerBoardPwr] = {
-
+	[kThrottlerBoardPower] = {
 			.min = 50,
 			.max = 600,
 		},
 	[kThrottlerGDDRThm] = {
-			.min = 50,
-			.max = 100,
-	}
-};
+		.min = 50,
+		.max = 100,
+	}};
 
 typedef struct {
 	float alpha_filter;
@@ -125,8 +119,8 @@ static Throttler throttler[kThrottlerCount] = {
 					.d_gain = 0,
 				},
 		},
-	[kThrottlerBoardPwr] = {
-			.arb_max = kAiclkArbMaxBoardPwr,
+	[kThrottlerBoardPower] = {
+			.arb_max = kAiclkArbMaxBoardPower,
 			.params = {
 
 					.alpha_filter = 1.0,
@@ -160,7 +154,7 @@ void InitThrottlers(void)
 	SetThrottlerLimit(kThrottlerFastTDC, get_fw_table()->chip_limits.tdc_fast_limit);
 	SetThrottlerLimit(kThrottlerTDC, get_fw_table()->chip_limits.tdc_limit);
 	SetThrottlerLimit(kThrottlerThm, get_fw_table()->chip_limits.thm_limit);
-	SetThrottlerLimit(kThrottlerBoardPwr, DEFAULT_BOARD_PWR_LIMIT);
+	SetThrottlerLimit(kThrottlerBoardPower, DEFAULT_BOARD_POWER_LIMIT);
 	SetThrottlerLimit(kThrottlerGDDRThm, get_fw_table()->chip_limits.gddr_thm_limit);
 }
 
@@ -195,27 +189,27 @@ void CalculateThrottlers(void)
 	UpdateThrottler(kThrottlerFastTDC, telemetry_internal_data.vcore_current);
 	UpdateThrottler(kThrottlerTDC, telemetry_internal_data.vcore_current);
 	UpdateThrottler(kThrottlerThm, telemetry_internal_data.asic_temperature);
-	UpdateThrottler(kThrottlerBoardPwr, ConvertTelemetryToFloat(GetInputPower()));
+	UpdateThrottler(kThrottlerBoardPower, ConvertTelemetryToFloat(GetInputPower()));
 	UpdateThrottler(kThrottlerGDDRThm, GetMaxGDDRTemp());
 
 	for (ThrottlerId i = 0; i < kThrottlerCount; i++) {
 		UpdateThrottlerArb(i);
 	}
 }
 
-int32_t Dm2CmSetBoardPwrLimit(const uint8_t *data, uint8_t size)
+int32_t Dm2CmSetBoardPowerLimit(const uint8_t *data, uint8_t size)
 {
 	if (size != 2) {
 		return -1;
 	}
 
-	uint32_t pwr_limit = sys_get_le16(data);
+	uint32_t power_limit = sys_get_le16(data);
 
-	LOG_INF("Cable Power Limit: %u\n", pwr_limit);
-	pwr_limit = MIN(pwr_limit, get_fw_table()->chip_limits.board_power_limit);
+	LOG_INF("Cable Power Limit: %u\n", power_limit);
+	power_limit = MIN(power_limit, get_fw_table()->chip_limits.board_power_limit);
 
-	SetThrottlerLimit(kThrottlerBoardPwr, pwr_limit);
-	UpdateTelemetryBoardPwrLimit(pwr_limit);
+	SetThrottlerLimit(kThrottlerBoardPower, power_limit);
+	UpdateTelemetryBoardPowerLimit(power_limit);
 
 	return 0;
 }
diff --git a/lib/tenstorrent/bh_arc/throttler.h b/lib/tenstorrent/bh_arc/throttler.h
@@ -8,6 +8,6 @@
 
 void InitThrottlers(void);
 void CalculateThrottlers(void);
-int32_t Dm2CmSetBoardPwrLimit(const uint8_t *data, uint8_t size);
+int32_t Dm2CmSetBoardPowerLimit(const uint8_t *data, uint8_t size);
 
 #endif
diff --git a/lib/tenstorrent/bh_chip/bh_chip.c b/lib/tenstorrent/bh_chip/bh_chip.c

Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ void process_cm2dm_message(struct bh_chip *chip)`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
`130`		`-void ina228_pwr_update(void)`
	`130`	`+void ina228_power_update(void)`
`131`	`131`	`{`
`132`	`132`	`struct sensor_value sensor_val;`
`133`	`133`
`@@ -137,11 +137,11 @@ void ina228_pwr_update(void)`
`137`	`137`	`int32_t power = (sensor_val.val1 << 16) + (sensor_val.val2 * 65536ULL) / 1000000ULL;`
`138`	`138`
`139`	`139`	`ARRAY_FOR_EACH_PTR(BH_CHIPS, chip) {`
`140`		`- bh_chip_set_input_pwr(chip, &power);`
	`140`	`+ bh_chip_set_input_power(chip, &power);`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
`144`		`-uint16_t detect_max_pwr(void)`
	`144`	`+uint16_t detect_max_power(void)`
`145`	`145`	`{`
`146`	`146`	`static const struct gpio_dt_spec psu_sense0 =`
`147`	`147`	`GPIO_DT_SPEC_GET_OR(DT_PATH(psu_sense0), gpios, {0});`
`@@ -154,28 +154,28 @@ uint16_t detect_max_pwr(void)`
`154`	`154`	`int sense0_val = gpio_pin_get_dt(&psu_sense0);`
`155`	`155`	`int sense1_val = gpio_pin_get_dt(&psu_sense1);`
`156`	`156`
`157`		`- uint16_t psu_pwr;`
	`157`	`+ uint16_t psu_power;`
`158`	`158`
`159`	`159`	`if (!sense0_val && !sense1_val) {`
`160`		`- psu_pwr = 600;`
	`160`	`+ psu_power = 600;`
`161`	`161`	`} else if (sense0_val && !sense1_val) {`
`162`		`- psu_pwr = 450;`
	`162`	`+ psu_power = 450;`
`163`	`163`	`} else if (!sense0_val && sense1_val) {`
`164`		`- psu_pwr = 300;`
	`164`	`+ psu_power = 300;`
`165`	`165`	`} else {`
`166`	`166`	`/* Pins could either be open or shorted together */`
`167`	`167`	`/* Pull down one and check the other */`
`168`	`168`	`gpio_pin_configure_dt(&psu_sense0, GPIO_OUTPUT_LOW);`
`169`	`169`	`if (!gpio_pin_get_dt(&psu_sense1)) {`
`170`	`170`	`/* If shorted together then max power is 150W */`
`171`		`- psu_pwr = 150;`
	`171`	`+ psu_power = 150;`
`172`	`172`	`} else {`
`173`		`- psu_pwr = 0;`
	`173`	`+ psu_power = 0;`
`174`	`174`	`}`
`175`	`175`	`gpio_pin_configure_dt(&psu_sense0, GPIO_INPUT);`
`176`	`176`	`}`
`177`	`177`
`178`		`- return psu_pwr;`
	`178`	`+ return psu_power;`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`int main(void)`
`@@ -298,7 +298,7 @@ int main(void)`
`298`	`298`	`dmStaticInfo static_info =`
`299`	`299`	`(dmStaticInfo){.version = 1, .bl_version = 0, .app_version = APPVERSION};`
`300`	`300`
`301`		`- uint16_t max_pwr = detect_max_pwr();`
	`301`	`+ uint16_t max_power = detect_max_power();`
`302`	`302`
`303`	`303`	`while (true) {`
`304`	`304`	`tt_event_wait(TT_EVENT_WAKE, K_MSEC(20));`
`@@ -341,14 +341,14 @@ int main(void)`
`341`	`341`	`ARRAY_FOR_EACH_PTR(BH_CHIPS, chip) {`
`342`	`342`	`if (chip->data.arc_needs_init_msg) {`
`343`	`343`	`if (bh_chip_set_static_info(chip, &static_info) == 0 &&`
`344`		`- bh_chip_set_board_pwr_lim(chip, max_pwr) == 0) {`
	`344`	`+ bh_chip_set_input_power_lim(chip, max_power) == 0) {`
`345`	`345`	`chip->data.arc_needs_init_msg = false;`
`346`	`346`	`}`
`347`	`347`	`}`
`348`	`348`	`}`
`349`	`349`
`350`	`350`	`if (IS_ENABLED(CONFIG_INA228)) {`
`351`		`- ina228_pwr_update();`
	`351`	`+ ina228_power_update();`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`if (IS_ENABLED(CONFIG_TT_FAN_CTRL)) {`
Original file line number	Diff line number	Diff line change
`@@ -224,6 +224,7 @@ int32_t Bm2CmPingHandler(const uint8_t *data, uint8_t size)`
`224`	`224`	`return 0;`
`225`	`225`	`}`
`226`	`226`
	`227`	`+`
`227`	`228`	`int32_t Bm2CmSendCurrentHandler(const uint8_t *data, uint8_t size)`
`228`	`229`	`{`
`229`	`230`	`if (size != 4) {`
`@@ -235,7 +236,7 @@ int32_t Bm2CmSendCurrentHandler(const uint8_t *data, uint8_t size)`
`235`	`236`	`return 0;`
`236`	`237`	`}`
`237`	`238`
`238`		`-int32_t Bm2CmSendPwrHandler(const uint8_t *data, uint8_t size)`
	`239`	`+int32_t Bm2CmSendPowerHandler(const uint8_t *data, uint8_t size)`
`239`	`240`	`{`
`240`	`241`	`if (size != 4) {`
`241`	`242`	`return -1;`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ int32_t Dm2CmPingHandler(const uint8_t *data, uint8_t size)`
`230`	`230`	`return 0;`
`231`	`231`	`}`
`232`	`232`
`233`		`-int32_t Dm2CmSendPwrHandler(const uint8_t *data, uint8_t size)`
	`233`	`+int32_t Dm2CmSendPowerHandler(const uint8_t *data, uint8_t size)`
`234`	`234`	`{`
`235`	`235`	`if (size != 4) {`
`236`	`236`	`return -1;`
Original file line number	Diff line number	Diff line change
`@@ -321,7 +321,7 @@ static void update_tag_table(void)`
`321`	`321`	`tag_table[47] = (struct telemetry_entry){TAG_GDDR_UNCORR_ERRS, GDDR_UNCORR_ERRS};`
`322`	`322`	`tag_table[48] = (struct telemetry_entry){TAG_MAX_GDDR_TEMP, MAX_GDDR_TEMP};`
`323`	`323`	`tag_table[49] = (struct telemetry_entry){TAG_ASIC_LOCATION, ASIC_LOCATION};`
`324`		`- tag_table[50] = (struct telemetry_entry){TAG_BOARD_PWR_LIMIT, BOARD_PWR_LIMIT};`
	`324`	`+ tag_table[50] = (struct telemetry_entry){TAG_BOARD_POWER_LIMIT, BOARD_POWER_LIMIT};`
`325`	`325`	`tag_table[51] = (struct telemetry_entry){TAG_INPUT_POWER, INPUT_POWER};`
`326`	`326`	`tag_table[52] = (struct telemetry_entry){TAG_TELEM_ENUM_COUNT, TELEM_ENUM_COUNT};`
`327`	`327`	`}`
`@@ -381,7 +381,7 @@ void UpdateTelemetryNocTranslation(bool translation_enabled)`
`381`	`381`	`telemetry[NOC_TRANSLATION] = translation_enabled;`
`382`	`382`	`}`
`383`	`383`
`384`		`-void UpdateTelemetryBoardPwrLimit(uint32_t pwr_limit)`
	`384`	`+void UpdateTelemetryBoardPowerLimit(uint32_t power_limit)`
`385`	`385`	`{`
`386`		`- telemetry[BOARD_PWR_LIMIT] = pwr_limit;`
	`386`	`+ telemetry[BOARD_POWER_LIMIT] = power_limit;`
`387`	`387`	`}`