Fix narrowing casts and ENET init mode

Tightens several arithmetic/conversion paths with explicit casts in PTP, ADC, SPI, BKP, NTP, and TCP code to avoid implicit narrowing and signed/unsigned issues. It also updates ENET initialization to use `ENET_RECEIVEALL` instead of `ENET_CUSTOM` on GD32 targets, aligning link reconfiguration with the intended receive behavior.

Author: vanvught

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-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) {