Tighten typing and fix ENET init flags

Adds explicit integer/float casts and fixed-width enum/return types across GD32, NTP/PTP, SPI, TCP, and backup-register code to avoid implicit narrowing and signedness issues. It also updates ENET initialization to use `ENET_RECEIVEALL` instead of `ENET_CUSTOM`, and includes minor cleanup (IWYU keep pragma and corrected namespace comment).

Author: vanvught

lib-dmxnode/include/dmxnode.h

@@ -80,7 +80,7 @@ inline static constexpr const char kLtpUpper[] = "LTP";
 
 enum class Direction { kInput, kOutput, kDisable };
 
-enum class FailSafe { kHold, kOff, kOn, kPlayback, kRecord };
+enum class FailSafe : uint8_t { kHold, kOff, kOn, kPlayback, kRecord };
 
 namespace failsafe {
 inline static constexpr const char kHold[] = "hold";

lib-gd32/device/enet/ptp/gd32_ptp.cpp

@@ -168,8 +168,8 @@ void Gd32PtpUpdateTime(const gd32::ptp::time_t* time) {
 }
 
 bool Gd32AdjFrequency(uint32_t adjust_ppb) {
-    const uint64_t kAdjust = static_cast<uint64_t>(gd32::ptp::kAdjFreqBaseAddend) * adjust_ppb;
-    const uint32_t kAddend = gd32::ptp::kAdjFreqBaseAddend + (kAdjust / 1000000000ULL);
+    const auto kAdjust = static_cast<uint64_t>(gd32::ptp::kAdjFreqBaseAddend) * adjust_ppb;
+    const auto kAddend = gd32::ptp::kAdjFreqBaseAddend + static_cast<uint32_t>(kAdjust / 1000000000ULL);
 
     enet_ptp_timestamp_addend_config(kAddend);
 

lib-gd32/src/f/gd32_adc.cpp

@@ -23,7 +23,7 @@
  * THE SOFTWARE.
  */
 
-#include "gd32.h"
+#include "gd32.h" // IWYU pragma: keep
 #include "timing.h"
 
 void Gd32AdcInit() {
@@ -86,20 +86,20 @@ void Gd32AdcInit() {
 }
 
 float G32AdcGetTemp() {
-    const float kTemperature = (1.43f - ADC_IDATA0(ADC0) * 3.3f / 4096U) * 1000U / 4.3f + 25U;
+    const float kTemperature = (1.43f - static_cast<float>(ADC_IDATA0(ADC0)) * 3.3f / 4096U) * 1000U / 4.3f + 25U;
     adc_software_trigger_enable(ADC0, ADC_INSERTED_CHANNEL);
     return kTemperature;
 }
 
 float Gd32AdcGetVref() {
-    const float kVrefValue = (ADC_IDATA1(ADC0) * 3.3f / 4096U);
+    const float kVrefValue = static_cast<float>(ADC_IDATA1(ADC0)) * 3.3f / 4096U;
     adc_software_trigger_enable(ADC0, ADC_INSERTED_CHANNEL);
     return kVrefValue;
 }
 
 #if defined(GD32F4XX)
 float Gd32AdcGetVbat() {
-    const float kVrefValue = (ADC_IDATA2(ADC0) * 3.3f / 4096U) * 4U;
+    const float kVrefValue = (static_cast<float>(ADC_IDATA2(ADC0)) * 3.3f / 4096U) * 4U;
     adc_software_trigger_enable(ADC0, ADC_INSERTED_CHANNEL);
     return kVrefValue;
 }

lib-gd32/src/f/gd32_spi.cpp

@@ -265,7 +265,7 @@ static inline char BitbangSpiWriteRead(char c) {
         GPIO_BOP(SPI_BITBANG_SCK_GPIOx) = SPI_BITBANG_SCK_GPIO_PINx;
 
         if ((GPIO_ISTAT(SPI_BITBANG_MISO_GPIOx) & SPI_BITBANG_MISO_GPIO_PINx) == SPI_BITBANG_MISO_GPIO_PINx) {
-            r |= (mask);
+            r |= static_cast<char>(mask);
         }
 
         __ISB();

lib-gd32/src/gd32_bkp.cpp

@@ -44,10 +44,10 @@ void bkp_data_write(bkp_data_register_enum register_number, uint16_t data) {
 uint16_t bkp_data_read(bkp_data_register_enum register_number) {
     switch (register_number) {
         case BKP_DATA_0:
-            return RTC_BKP0;
+            return static_cast<uint16_t>(RTC_BKP0);
             break;
         case BKP_DATA_1:
-            return RTC_BKP1;
+            return static_cast<uint16_t>(RTC_BKP1);
             break;
         default:
             assert(false && "Invalid register_number");

lib-hwclock/src/gd32/internal/hwclockrtc.cpp

@@ -47,12 +47,12 @@
 #include "gd32.h"
 
 #if defined(GD32F4XX) || defined(GD32H7XX)
-static int BCD2DEC(int val) {
-    return (((val) & 0x0f) + (val >> 4) * 10);
+static uint8_t BCD2DEC(int val) {
+    return static_cast<uint8_t>(((val) & 0x0f) + static_cast<uint8_t>(val >> 4) * 10U);
 }
 
-static int DEC2BCD(int val) {
-    return ((((val) / 10) << 4) + val % 10);
+static uint8_t DEC2BCD(int val) {
+    return static_cast<uint8_t>(((static_cast<uint8_t>(val) / 10U) << 4) + (static_cast<uint8_t>(val) % 10U));
 }
 #define RTC_CLOCK_SOURCE_LXTAL
 static rtc_parameter_struct rtc_initpara;

lib-network/src/apps/ntp/gd32/ptp/ntpclient.cpp

@@ -85,9 +85,9 @@ T4 - local receive timestamp of the previous response (t4)
 
 namespace net::globals::ptp {
 extern uint32_t timestamp[2];
-} // namespace net::globals
+} // namespace net::globals::ptp
 
-#define _NTPFRAC_(x) (4294U * static_cast<uint32_t>(x) + ((1981U * static_cast<uint32_t>(x)) >> 11) + ((2911U * static_cast<uint32_t>(x)) >> 28))
+#define _NTPFRAC_(x) (4294U * (x) + ((1981U * (x)) >> 11) + ((2911U * (x)) >> 28))
 #define NTPFRAC(x) _NTPFRAC_(x / 1000)
 // The reverse of the above, needed if we want to set our microsecond
 // clock (via clock_settime) based on the incoming time in NTP format.
@@ -279,11 +279,11 @@ static void UpdatePtpTime() {
     int32_t diff_seconds2, diff_nano_seconds2;
     Difference(s_ntp_client.t4, s_ntp_client.t3, diff_seconds2, diff_nano_seconds2);
 
-    auto offset_seconds = static_cast<int64_t>(diff_seconds1) + static_cast<int64_t>(diff_seconds2);
-    auto offset_nano_seconds = static_cast<int64_t>(diff_nano_seconds1) + static_cast<int64_t>(diff_nano_seconds2);
+    const auto kOffsetSeconds = static_cast<int64_t>(diff_seconds1) + static_cast<int64_t>(diff_seconds2);
+    const auto kOffsetNanoSeconds = static_cast<int64_t>(diff_nano_seconds1) + static_cast<int64_t>(diff_nano_seconds2);
 
-    const int32_t kOffsetSecondsAverage = offset_seconds / 2;
-    const int32_t kOffsetNanosverage = offset_nano_seconds / 2;
+    const auto kOffsetSecondsAverage = static_cast<int32_t>(kOffsetSeconds / 2U);
+    const auto kOffsetNanosverage = static_cast<int32_t>(kOffsetNanoSeconds / 2U);
 
     gd32::ptp::time_t ptp_offset = {.tv_sec = kOffsetSecondsAverage, .tv_nsec = kOffsetNanosverage};
     gd32::NormalizeTime(&ptp_offset);

lib-network/src/core/tcp.cpp

@@ -507,7 +507,7 @@ static void SendSegment(Tcb* tcb, const SendInfo& send_info, bool track_rtx = tr
         auto& r = tcb->rtx.q[(tcb->rtx.head + tcb->rtx.count) % kTcpUnackMax];
         r.seq = send_info.SEQ;
         r.len = static_cast<uint16_t>(tcb->TX.size);
-        r.consumed = r.len + ((send_info.CTL & Control::SYN) ? 1U : 0U) + ((send_info.CTL & Control::FIN) ? 1U : 0U);
+        r.consumed = static_cast<uint16_t>(r.len + ((send_info.CTL & Control::SYN) ? 1U : 0) + ((send_info.CTL & Control::FIN) ? 1U : 0));
         r.ctl = send_info.CTL;
         r.retries = 0;
         r.last_sent = timing::Millis();

lib-network/src/emac/gd32/emac.cpp

@@ -127,9 +127,9 @@ void AdjustLink(emac::phy::Status phy_status) {
     }
 
 #if defined(GD32H7XX)
-    const auto kEnetInitStatus = enet_init(ENETx, mediamode, ENET_AUTOCHECKSUM_DROP_FAILFRAMES, ENET_CUSTOM);
+    const auto kEnetInitStatus = enet_init(ENETx, mediamode, ENET_AUTOCHECKSUM_DROP_FAILFRAMES, ENET_RECEIVEALL);
 #else
-    const auto kEnetInitStatus = enet_init(mediamode, ENET_AUTOCHECKSUM_DROP_FAILFRAMES, ENET_CUSTOM);
+    const auto kEnetInitStatus = enet_init(mediamode, ENET_AUTOCHECKSUM_DROP_FAILFRAMES, ENET_RECEIVEALL);
 #endif
 
     if (kEnetInitStatus != SUCCESS) {