Tidy casts and formatting across drivers

Cleans up mixed formatting and explicit integer casts in config storage, firmware install, UART, and network code. Also updates config store to use the global UTC helper and refreshes a few debug messages and state names for consistency.

Author: vanvught

lib-configstore/include/configstore.h

@@ -2,7 +2,7 @@
  * @file firmware.cpp
  *
  */
-/* Copyright (C) 2025 by Arjan van Vught mailto:info@gd32-dmx.org
+/* Copyright (C) 2025-2026 by Arjan van Vught mailto:info@gd32-dmx.org
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -33,76 +33,75 @@
 
 #include "firmware.h"
 #include "ubootheader.h"
- #include "firmware/debug/debug_debug.h"
+#include "firmware/debug/debug_debug.h"
 
 namespace firmware {
 enum class State {
-	IDLE, START, CONTINUE
+	kIdle, kStart, kContinue
 };
 
-static auto s_State = State::IDLE;
+static auto s_State = State::kIdle;
 static uint32_t s_nCRC;
 
-bool firmware_install_start(const uint8_t *pBuffer, const uint32_t nBufferSize) {
+bool firmware_install_start(const uint8_t *buffer, uint32_t buffer_size) {
 	DEBUG_ENTRY();
-	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(pBuffer), nBufferSize);
+	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(buffer), static_cast<unsigned>(buffer_size));
 
-	assert(s_State == State::IDLE);
-	s_State = State::START;
+	assert(s_State == State::kIdle);
+	s_State = State::kStart;
 
-	assert(sizeof(struct TImageHeader) <= nBufferSize);
+	assert(sizeof(struct TImageHeader) <= buffer_size);
 
-	UBootHeader uBootHeader(pBuffer);
-	uBootHeader.Dump();
+	UBootHeader uboot_header(buffer);
+	uboot_header.Dump();
 
-	const auto isValid = uBootHeader.IsValid();
-	DEBUG_PRINTF("Firmware is valid? %s", isValid ? "Yes" : "No");
+	const auto kIsValid = uboot_header.IsValid();
+	DEBUG_PRINTF("Firmware is valid? %s", kIsValid ? "Yes" : "No");
 
-	if (!isValid) {
+	if (!kIsValid) {
 		DEBUG_EXIT();
 		return false;
 	}
 
-	const uint32_t nFirmwareChunk = nBufferSize - sizeof(struct TImageHeader);
+	const uint32_t kFirmwareChunk = buffer_size - sizeof(struct TImageHeader);
 
-	if (nFirmwareChunk > 0) {
-		DEBUG_PRINTF("Firmware: Chunk = %u", nFirmwareChunk);
+	if (kFirmwareChunk > 0) {
+		DEBUG_PRINTF("Firmware: Chunk = %u", static_cast<unsigned>(kFirmwareChunk));
 
-		const auto *pFirmware = pBuffer + sizeof(struct TImageHeader);
+		const auto *firmware = buffer + sizeof(struct TImageHeader);
 
-		s_nCRC = crc32(0, pFirmware, nFirmwareChunk);
+		s_nCRC = crc32(0, firmware, kFirmwareChunk);
 	}
 
 	DEBUG_EXIT();
 	return true;
 }
 
-bool firmware_install_continue(const uint8_t *pBuffer, const uint32_t nBufferSize) {
+bool firmware_install_continue(const uint8_t *buffer, uint32_t buffer_size) {
 	DEBUG_ENTRY();
-	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(pBuffer), nBufferSize);
+	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(buffer), static_cast<unsigned>(buffer_size));
 
-	assert((s_State == State::START) || (s_State == State::CONTINUE));
-	s_State = State::CONTINUE;
+	assert((s_State == State::kStart) || (s_State == State::kContinue));
+	s_State = State::kContinue;
 
-	s_nCRC = crc32(s_nCRC, pBuffer, nBufferSize);
+	s_nCRC = crc32(s_nCRC, buffer, buffer_size);
 
 	DEBUG_EXIT();
 	return true;
 }
 
-bool firmware_install_end(const uint8_t *pBuffer, const uint32_t nBufferSize) {
+bool firmware_install_end(const uint8_t *buffer, uint32_t buffer_size) {
 	DEBUG_ENTRY();
-	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(pBuffer), nBufferSize);
+	DEBUG_PRINTF("Firmware: Buffer = %p, Buffer size = %u", reinterpret_cast<const void *>(buffer), static_cast<unsigned>(buffer_size));
 
-	assert(s_State == State::CONTINUE);
-	s_State = State::IDLE;
+	assert(s_State == State::kContinue);
+	s_State = State::kIdle;
 
-	s_nCRC = crc32(s_nCRC, pBuffer, nBufferSize);
+	s_nCRC = crc32(s_nCRC, buffer, buffer_size);
 
-	DEBUG_PRINTF("CRC: %x", s_nCRC);
+	DEBUG_PRINTF("CRC: %x", static_cast<unsigned>(s_nCRC));
 
 	DEBUG_EXIT();
 	return true;
 }
-
 }  // namespace firmware

lib-flashcodeinstall/src/firmware.cpp

@@ -28,6 +28,7 @@
 
 #include <cstdint>
 #include <cstdio>
+#include <cstdarg>
 
 #include "gd32_uart.h"
 #if defined(CONFIG_USART0_ENABLE_TX_DMA) || defined(CONFIG_USART0_ENABLE_RX_DMA)

lib-gd32/src/uart0/uart0.cpp

@@ -46,15 +46,15 @@ void SetDomainName(const char* domainname);
 const char* DomainName();
 
 #if defined(H3) || defined(GD32)
-[[nodiscard]] inline constexpr const char* InterfaceName() {
+[[nodiscard]] constexpr const char* InterfaceName() {
     return "eth0";
 }
 #else
 const char* InterfaceName();
 #endif
 
 #if defined(H3) || defined(GD32)
-inline constexpr uint32_t InterfaceIndex() {
+constexpr uint32_t InterfaceIndex() {
     return 1;
 }
 #else
@@ -73,21 +73,25 @@ void SetAutoIp();
 bool AutoIp();
 
 // DHCP
-inline constexpr bool IsDhcpCapable() {
+constexpr bool IsDhcpCapable() {
     return true;
 }
 
-inline constexpr bool IsDhcpKnown() {
+constexpr bool IsDhcpKnown() {
     return true;
 }
 
 void EnableDhcp();
 bool Dhcp();
 
 inline char AddressingMode() {
-    if (AutoIp()) return 'Z';                     // Zeroconf
-    if (IsDhcpKnown()) return Dhcp() ? 'D' : 'S'; // DHCP or Static
-    return 'U';                                   // Unknown
+    if (AutoIp()) {
+        return 'Z'; // Zeroconf
+    }
+    if (IsDhcpKnown()) {
+        return Dhcp() ? 'D' : 'S'; // DHCP or Static
+    }
+    return 'U'; // Unknown
 }
 
 struct Counters {
@@ -99,7 +103,7 @@ struct Counters {
     } tx;
 };
 
-void GetCounters(Counters& out);
+void GetCounters(Counters& counters);
 } // namespace network::iface
 
 #endif // NETWORK_IFACE_H_

lib-network/include/network_iface.h

@@ -87,7 +87,7 @@ namespace net::globals::ptp {
 extern uint32_t timestamp[2];
 } // namespace net::globals::ptp
 
-#define _NTPFRAC_(x) (4294U * (x) + ((1981U * (x)) >> 11) + ((2911U * (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.
@@ -130,7 +130,15 @@ static void Print([[maybe_unused]] const char* text, [[maybe_unused]] const stru
 #ifndef NDEBUG
     const auto kSeconds = static_cast<time_t>(timestamp->seconds - ntp::kJan1970);
     const auto* local_time = localtime(&kSeconds);
-    printf("%s %02d:%02d:%02d.%06d %04d [%u][0x%.8x]\n", text, local_time->tm_hour, local_time->tm_min, local_time->tm_sec, USEC(timestamp->fraction), local_time->tm_year + 1900, timestamp->seconds, timestamp->fraction);
+    printf("%s %02d:%02d:%02d.%06d %04d [%u][0x%.8x]\n", 
+      text, 
+      static_cast<int>(local_time->tm_hour), 
+      static_cast<int>(local_time->tm_min), 
+      static_cast<int>(local_time->tm_sec), 
+      static_cast<int>(USEC(timestamp->fraction)), 
+      local_time->tm_year + 1900, 
+      static_cast<int>(timestamp->seconds), 
+      static_cast<unsigned>(timestamp->fraction));
 #endif
 }
 
@@ -237,9 +245,13 @@ static void Send() {
     network::udp::SendWithTimestamp(s_ntp_client.handle, reinterpret_cast<const uint8_t*>(&s_ntp_client.request), kRequestSize, s_ntp_client.server_ip, network::iana::Ports::kPortNtp);
 
 #ifndef NDEBUG
-    printf("Request:  org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n", __builtin_bswap32(s_ntp_client.request.origin_timestamp_s), __builtin_bswap32(s_ntp_client.request.origin_timestamp_f),
-           __builtin_bswap32(s_ntp_client.request.receive_timestamp_s), __builtin_bswap32(s_ntp_client.request.receive_timestamp_f), __builtin_bswap32(s_ntp_client.request.transmit_timestamp_s),
-           __builtin_bswap32(s_ntp_client.request.transmit_timestamp_f));
+    printf("Request:  org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n",
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.origin_timestamp_s)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.origin_timestamp_f)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.receive_timestamp_s)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.receive_timestamp_f)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.transmit_timestamp_s)),  // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(s_ntp_client.request.transmit_timestamp_f))); // NOLINT
 #endif
 
     if (s_ntp_client.state.x > 0) {
@@ -273,10 +285,12 @@ static inline int32_t AbsInt32(int32_t x) {
 }
 
 static void UpdatePtpTime() {
-    int32_t diff_seconds1, diff_nano_seconds1;
+    int32_t diff_seconds1;
+    int32_t diff_nano_seconds1;
     Difference(s_ntp_client.t1, s_ntp_client.t2, diff_seconds1, diff_nano_seconds1);
 
-    int32_t diff_seconds2, diff_nano_seconds2;
+    int32_t diff_seconds2;
+    int32_t diff_nano_seconds2;
     Difference(s_ntp_client.t4, s_ntp_client.t3, diff_seconds2, diff_nano_seconds2);
 
     const auto kOffsetSeconds = static_cast<int64_t>(diff_seconds1) + static_cast<int64_t>(diff_seconds2);
@@ -292,7 +306,7 @@ static void UpdatePtpTime() {
     gd32::ptp::ptptime ptp_get;
     Gd32PtpGetTime(&ptp_get);
 
-    s_ntp_client.request.reference_timestamp_s = __builtin_bswap32(static_cast<uint32_t>(ptp_get.tv_sec) + ntp::kJan1970);
+    s_ntp_client.request.reference_timestamp_s = __builtin_bswap32(ptp_get.tv_sec + ntp::kJan1970);
     s_ntp_client.request.reference_timestamp_f = __builtin_bswap32(NTPFRAC(ptp_get.tv_nsec));
 
     if ((ptp_offset.tv_sec == 0) && (ptp_offset.tv_nsec > -999999) && (ptp_offset.tv_nsec < 999999)) {
@@ -350,7 +364,13 @@ static void UpdatePtpTime() {
         sign = '-';
     }
 
-    printf(" %s : offset=%c%d.%09d delay=%d.%09d\n", s_ntp_client.state.mode == ntp::Modes::kBasic ? "Basic" : "Interleaved", sign, ptp_offset.tv_sec, ptp_offset.tv_nsec, ptp_delay.tv_sec, ptp_delay.tv_nsec);
+    printf(" %s : offset=%c%d.%09d delay=%d.%09d\n", 
+      s_ntp_client.state.mode == ntp::Modes::kBasic ? "Basic" : "Interleaved", 
+      sign, 
+      static_cast<int>(ptp_offset.tv_sec), 
+      static_cast<int>(ptp_offset.tv_nsec), 
+      static_cast<int>(ptp_delay.tv_sec), 
+      static_cast<int>(ptp_delay.tv_nsec));
 #endif
 }
 
@@ -369,8 +389,13 @@ static void UpdatePtpTime() {
 static void Process() {
     const auto* const kReply = s_ntp_client.reply;
 #ifndef NDEBUG
-    printf("Response: org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n", __builtin_bswap32(kReply->origin_timestamp_s), __builtin_bswap32(kReply->origin_timestamp_f), __builtin_bswap32(kReply->receive_timestamp_s),
-           __builtin_bswap32(kReply->receive_timestamp_f), __builtin_bswap32(kReply->transmit_timestamp_s), __builtin_bswap32(kReply->transmit_timestamp_f));
+    printf("Response: org=%.8x%.8x rx=%.8x%.8x tx=%.8x%.8x\n",
+           static_cast<unsigned>(__builtin_bswap32(kReply->origin_timestamp_s)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->origin_timestamp_f)),    // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->receive_timestamp_s)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->receive_timestamp_f)),   // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->transmit_timestamp_s)),  // NOLINT
+           static_cast<unsigned>(__builtin_bswap32(kReply->transmit_timestamp_f))); // NOLINT
 #endif
     // If the origin timestamp is equal to the transmit timestamp, the response is in the basic mode.
     if ((kReply->origin_timestamp_s == s_ntp_client.request.transmit_timestamp_s) && (kReply->origin_timestamp_f == s_ntp_client.request.transmit_timestamp_f)) {

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

@@ -244,7 +244,7 @@ template <network::arp::EthSend S> static void Query(uint32_t destination_ip, vo
             network::memory::Allocator::Instance().Free(record_found->packet.p);
         }
 
-        printf("size=%u\n", size);
+        printf("size=%u\n", static_cast<unsigned>(size));
         assert(size <= network::memory::kBlockSize);
         record_found->packet.p = network::memory::Allocator::Instance().Allocate();
         assert(record_found->packet.p != nullptr);

lib-network/src/core/ipv4/arp.cpp

@@ -39,6 +39,6 @@ void emac_debug_run() {
 #endif
 
     if ((rxfifo_drop != 0) || (rxdma_drop != 0)) {
-        printf("%u: RxFIFO: %u RxDMA: %u\n", ++s_counter, rxfifo_drop, rxdma_drop);
+        printf("%u: RxFIFO: %u RxDMA: %u\n", static_cast<unsigned>(++s_counter), static_cast<unsigned>(rxfifo_drop), static_cast<unsigned>(rxdma_drop));
     }
 }

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

@@ -359,7 +359,7 @@ void Send(uint32_t length) {
 
 // Transmits an Ethernet frame with data copying.
 void Send(void* buffer, uint32_t length) {
-    DEBUG_PRINTF("%p -> %u", buffer, length);
+    DEBUG_PRINTF("%p -> %u", buffer, static_cast<unsigned>(length));
 
     assert(nullptr != buffer);
     assert(length <= ENET_MAX_FRAME_SIZE);

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

@@ -66,7 +66,7 @@ bool Config(uint16_t address) {
 
     const auto kAhbClk = rcu_clock_freq_get(CK_AHB);
 
-    DEBUG_PRINTF("kAhbClk=%u", kAhbClk);
+    DEBUG_PRINTF("kAhbClk=%u", static_cast<unsigned>(kAhbClk));
 
 #if defined GD32F10X_CL
     if (ENET_RANGE(kAhbClk, 20000000U, 35000000U)) {
@@ -163,7 +163,7 @@ bool Config(uint16_t address) {
         }
 
         if (!(value & emac::mmi::BMCR_RESET)) {
-            DEBUG_PRINTF("%u", millis() - kMillis);
+            DEBUG_PRINTF("%u", static_cast<unsigned>(millis() - kMillis));
             DEBUG_EXIT();
             return true;
         }
@@ -175,7 +175,7 @@ bool Config(uint16_t address) {
         return false;
     }
 
-    DEBUG_PRINTF("%u", millis() - kMillis);
+    DEBUG_PRINTF("%u", static_cast<unsigned>(millis() - kMillis));
     DEBUG_EXIT();
     return true;
 }