ports: analog: Improve supervisor portability

- *usb.c*: Place USB hardware clock / power into separate init_usb functions.
- *internal_flash.c*: Move Flash and Instruction Cache Controller
operations into different functions for different targets.
- *port.c*: Create macros abstracting RTC alarms & enables for different
register structures.

Signed-off-by: Brandon-Hurst <brandon.hurst97@gmail.com>

Author: Brandon-Hurst

ports/analog/supervisor/internal_flash.c

@@ -67,25 +67,77 @@ static const flash_layout_t flash_layout[] = {
 };
 // must be able to hold a full page (for re-writing upon erase)
 static uint32_t page_buffer[FLASH_PAGE_SIZE / 4] = {0x0};
+
+static void icc_flush(void) {
+    // Flush all instruction cache
+    // ME18 has bug where top-level sysctrl flush bit only works once.
+    // Have to use low-level flush bits for each ICC instance.
+    MXC_ICC_Flush(MXC_ICC0);
+}
+static void icc_enable(void) {
+    MXC_ICC_Enable(MXC_ICC0);
+}
+static void icc_disable(void) {
+    MXC_ICC_Disable(MXC_ICC0);
+}
+
+static void flash_lock(void) {
+    MXC_FLC0->ctrl |= MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
+    MXC_FLC1->ctrl |= MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
+}
+
 #elif defined(MAX32650)
 static const flash_layout_t flash_layout[] = {
     { 0x10000000, FLASH_PAGE_SIZE, 192},
 };
 // must be able to hold a full page (for re-writing upon erase)
 static uint32_t page_buffer[FLASH_PAGE_SIZE / 4] = {0x0};
+
+static void icc_flush(void) {
+    // Flush all instruction cache
+    MXC_ICC_Flush();
+}
+static void icc_enable(void) {
+    MXC_ICC_Enable();
+}
+static void icc_disable(void) {
+    MXC_ICC_Disable();
+}
+
+static void flash_lock(void) {
+    MXC_FLC->ctrl |= MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
+}
 #elif defined(MAX32665)
-// MAX32666 has two flash banks, but we do not actually need to 
+// MAX32666 has two flash banks, but we do not actually need to
 // treat them separately
 static const flash_layout_t flash_layout[] = {
     { 0x10000000, FLASH_PAGE_SIZE, 64},
     { 0x10080000, FLASH_PAGE_SIZE, 64},
 };
 // must be able to hold a full page (for re-writing upon erase)
 static uint32_t page_buffer[FLASH_PAGE_SIZE / 4] = {0x0};
+
+static void icc_flush(void) {
+    // Flush all instruction cache
+    MXC_ICC_Flush();
+}
+static void icc_enable(void) {
+    MXC_ICC_Enable();
+}
+static void icc_disable(void) {
+    MXC_ICC_Disable();
+}
+
+static void flash_lock(void) {
+    MXC_FLC0->cn |= MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
+    MXC_FLC1->cn |= MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
+}
 #else
 #error "Invalid BOARD. Please set BOARD equal to any board under 'boards/'."
 #endif
 
+
+
 static inline int32_t block2addr(uint32_t block) {
     if (block >= 0 && block < INTERNAL_FLASH_FILESYSTEM_NUM_BLOCKS) {
         return CIRCUITPY_INTERNAL_FLASH_FILESYSTEM_START_ADDR + block * FILESYSTEM_BLOCK_SIZE;
@@ -110,9 +162,9 @@ int flash_get_sector_info(uint32_t addr, uint32_t *start_addr, uint32_t *size) {
         flash_layout_t bank = flash_layout[i];
 
         // Determine if the flash bank is a hit for this address
-        if  ((addr >= bank.base_addr) &&
+        if ((addr >= bank.base_addr) &&
             (addr < bank.base_addr + bank.sector_size * bank.num_sectors)
-        ) {
+            ) {
             // Assign the sector index assuming uniform sector sizes
             sector_index = i * bank.num_sectors + ((addr - bank.base_addr) / bank.sector_size);
             *start_addr = flash_layout[0].base_addr + (sector_index * bank.sector_size);
@@ -137,12 +189,7 @@ uint32_t supervisor_flash_get_block_count(void) {
 }
 
 void port_internal_flash_flush(void) {
-
-    // Flush all instruction cache
-    // ME18 has bug where top-level sysctrl flush bit only works once.
-    // Have to use low-level flush bits for each ICC instance.
-    MXC_ICC_Flush(MXC_ICC0);
-    MXC_ICC_Flush(MXC_ICC1);
+    icc_flush();
 
     // Clear the line fill buffer by reading 2 pages from flash
     volatile uint32_t *line_addr;
@@ -199,7 +246,7 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num,
         blocks_left = (page_size - (dest_addr - page_start)) / FILESYSTEM_BLOCK_SIZE;
         count = MIN(num_blocks, blocks_left);
 
-        MXC_ICC_Disable(MXC_ICC0);
+        icc_disable();
 
         // Buffer the page of flash to erase
         MXC_FLC_Read(page_start, page_buffer, page_size);
@@ -209,11 +256,7 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num,
             error = MXC_FLC_PageErase(dest_addr);
             );
         if (error != E_NO_ERROR) {
-            // lock flash & reset
-            MXC_FLC0->ctrl = (MXC_FLC0->ctrl & ~MXC_F_FLC_REVA_CTRL_UNLOCK) | MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
-            #if defined(MAX32666)
-            MXC_FLC1->ctrl = (MXC_FLC1->ctrl & ~MXC_F_FLC_REVA_CTRL_UNLOCK) | MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
-            #endif
+            flash_lock();
             reset_into_safe_mode(SAFE_MODE_FLASH_WRITE_FAIL);
         }
 
@@ -228,14 +271,11 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num,
             );
         if (error != E_NO_ERROR) {
             // lock flash & reset
-            MXC_FLC0->ctrl = (MXC_FLC0->ctrl & ~MXC_F_FLC_REVA_CTRL_UNLOCK) | MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
-            #if defined(MAX32666)
-            MXC_FLC1->ctrl = (MXC_FLC1->ctrl & ~MXC_F_FLC_REVA_CTRL_UNLOCK) | MXC_S_FLC_REVA_CTRL_UNLOCK_LOCKED;
-            #endif
+            flash_lock();
             reset_into_safe_mode(SAFE_MODE_FLASH_WRITE_FAIL);
         }
 
-        MXC_ICC_Enable(MXC_ICC0);
+        icc_enable();
 
         block_num += count;
         src += count * FILESYSTEM_BLOCK_SIZE;

ports/analog/supervisor/port.c

@@ -48,6 +48,36 @@
 // true random number generator, TRNG
 #include "trng.h"
 
+// Define macros for RTC flags for portability
+#if defined(MAX32690)
+#define TOD_FLAG MXC_F_RTC_CTRL_TOD_ALARM
+#define SSEC_FLAG MXC_F_RTC_CTRL_SSEC_ALARM
+#define RDY_FLAG MXC_F_RTC_CTRL_RDY
+
+#define TOD_ENABLE MXC_F_RTC_CTRL_TOD_ALARM_IE
+#define SSEC_ENABLE MXC_F_RTC_CTRL_SSEC_ALARM_IE
+#define RDY_ENABLE MXC_F_RTC_CTRL_RDY_IE
+#define RTC_ENABLE MXC_F_RTC_CTRL_EN
+#elif defined(MAX32650)
+#define TOD_FLAG MXC_F_RTC_CTRL_TOD_ALARM_FL
+#define SSEC_FLAG MXC_F_RTC_CTRL_SSEC_ALARM_FL
+#define RDY_FLAG MXC_F_RTC_CTRL_READY
+
+#define TOD_ENABLE MXC_F_RTC_CTRL_TOD_ALARM_EN
+#define SSEC_ENABLE MXC_F_RTC_CTRL_SSEC_ALARM_EN
+#define RDY_ENABLE MXC_F_RTC_CTRL_READY_INT_EN
+#define RTC_ENABLE MXC_F_RTC_CTRL_ENABLE
+#elif defined(MAX32665)
+#define TOD_FLAG MXC_F_RTC_CTRL_ALDF
+#define SSEC_FLAG MXC_F_RTC_CTRL_ALSF
+#define RDY_FLAG MXC_F_RTC_CTRL_RDY
+
+#define TOD_ENABLE MXC_F_RTC_CTRL_ADE
+#define SSEC_ENABLE MXC_F_RTC_CTRL_ASE
+#define RDY_ENABLE MXC_F_RTC_CTRL_RDYE
+#define RTC_ENABLE MXC_F_RTC_CTRL_RTCE
+#endif
+
 // msec to RTC subsec ticks (4 kHz)
 /* Converts a time in milleseconds to equivalent RSSA register value */
 #define MSEC_TO_SS_ALARM(x) (0 - ((x * 4096) / 1000))
@@ -100,12 +130,6 @@ safe_mode_t port_init(void) {
         }
     }
 
-    // Enable clock to RTC peripheral
-    MXC_GCR->clkctrl |= MXC_F_GCR_CLKCTRL_ERTCO_EN;
-    while (!(MXC_GCR->clkctrl & MXC_F_GCR_CLKCTRL_ERTCO_RDY)) {
-        ;
-    }
-
     NVIC_EnableIRQ(RTC_IRQn);
     NVIC_EnableIRQ(USB_IRQn);
 
@@ -116,9 +140,9 @@ safe_mode_t port_init(void) {
     ;
 
     // enable 1 sec RTC SSEC alarm
-    MXC_RTC_DisableInt(MXC_F_RTC_CTRL_SSEC_ALARM_IE);
+    MXC_RTC_DisableInt(SSEC_ENABLE);
     MXC_RTC_SetSubsecondAlarm(MSEC_TO_SS_ALARM(1000));
-    MXC_RTC_EnableInt(MXC_F_RTC_CTRL_SSEC_ALARM_IE);
+    MXC_RTC_EnableInt(SSEC_ENABLE);
 
     // Enable RTC
     while (MXC_RTC_Start() != E_SUCCESS) {
@@ -142,14 +166,14 @@ void RTC_IRQHandler(void) {
     int flags = MXC_RTC_GetFlags();
 
     switch (flags) {
-        case MXC_F_RTC_CTRL_SSEC_ALARM:
-            MXC_RTC_ClearFlags(MXC_F_RTC_CTRL_SSEC_ALARM);
+        case SSEC_FLAG:
+            MXC_RTC_ClearFlags(SSEC_FLAG);
             break;
-        case MXC_F_RTC_CTRL_TOD_ALARM:
-            MXC_RTC_ClearFlags(MXC_F_RTC_CTRL_TOD_ALARM);
+        case TOD_FLAG:
+            MXC_RTC_ClearFlags(TOD_FLAG);
             break;
-        case MXC_F_RTC_CTRL_RDY:
-            MXC_RTC_ClearFlags(MXC_F_RTC_CTRL_RDY);
+        case RDY_FLAG:
+            MXC_RTC_ClearFlags(RDY_FLAG);
             break;
         default:
             break;
@@ -217,7 +241,7 @@ uint32_t port_get_saved_word(void) {
 uint64_t port_get_raw_ticks(uint8_t *subticks) {
     // Ensure we can read from ssec register as soon as we can
     // MXC function does cross-tick / busy checking of RTC controller
-    if (MXC_RTC->ctrl & MXC_F_RTC_CTRL_EN) {
+    if (MXC_RTC->ctrl & RTC_ENABLE) {
         // NOTE: RTC_GetTime always returns BUSY if RTC is not running
         while ((MXC_RTC_GetTime(&sec, &subsec)) != E_NO_ERROR) {
             ;
@@ -261,8 +285,7 @@ void port_interrupt_after_ticks(uint32_t ticks) {
     ticks_msec = (ticks / TICKS_PER_SEC) * 1000;
 
     // Disable RTC interrupts
-    MXC_RTC_DisableInt(MXC_F_RTC_CTRL_SSEC_ALARM_IE |
-        MXC_F_RTC_CTRL_TOD_ALARM_IE | MXC_F_RTC_CTRL_RDY_IE);
+    MXC_RTC_DisableInt(SSEC_ENABLE | TOD_ENABLE | RDY_ENABLE);
 
     // Stop RTC & store current time & ticks
     port_get_raw_ticks(NULL);
@@ -275,14 +298,14 @@ void port_interrupt_after_ticks(uint32_t ticks) {
     while (MXC_RTC_SetSubsecondAlarm(MSEC_TO_SS_ALARM(ticks_msec)) != E_SUCCESS) {
     }
 
-    MXC_RTC_EnableInt(MXC_F_RTC_CTRL_SSEC_ALARM_IE);
+    MXC_RTC_EnableInt(SSEC_ENABLE);
 
 }
 
 void port_idle_until_interrupt(void) {
     #if CIRCUITPY_RTC
     // Check if alarm triggers before we even got here
-    if (MXC_RTC_GetFlags() == (MXC_F_RTC_CTRL_TOD_ALARM | MXC_F_RTC_CTRL_SSEC_ALARM)) {
+    if (MXC_RTC_GetFlags() == (TOD_FLAG | SSEC_FLAG)) {
         return;
     }
     #endif

ports/analog/supervisor/usb.c

@@ -15,17 +15,39 @@
 // max32 includes
 #include "max32_port.h"
 
+#if defined(MAX32690)
+static void init_usb(void) {
+    // Enable 120 MHz IPO, then 0.9V LDO supplying USB
+    MXC_SYS_ClockSourceEnable(MXC_SYS_CLOCK_IPO);
+    MXC_MCR->ldoctrl |= MXC_F_MCR_LDOCTRL_0P9EN;
+
+    MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_USB);
+    MXC_SYS_Reset_Periph(MXC_SYS_RESET0_USB);
+}
+#elif defined(MAX32650)
+static void init_usb(void) {
+    // Enable the 96MHz clock, then enable USB
+    MXC_GCR->clk_ctrl |= MXC_F_GCR_CLK_CTRL_HIRC96_EN;
+    MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_USB);
+    MXC_SYS_Reset_Periph(MXC_SYS_RESET_USB);
+}
+#elif defined(MAX32665)
+static void init_usb(void) {
+    // Enable the 96MHz clock, then enable USB
+    MXC_GCR->clkcn |= MXC_F_GCR_CLKCN_HIRC96M_EN;
+    MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_USB);
+    MXC_SYS_Reset_Periph(MXC_SYS_RESET_USB);
+}
+#endif
+
 void init_usb_hardware(void) {
     // USB GPIOs are non-configurable on MAX32 devices
     // No need to add them to the never_reset list for mcu/Pin API.
 
     // 1 ms SysTick initialized in board.c
 
     // Enable requisite clocks & power for USB
-    MXC_SYS_ClockSourceEnable(MXC_SYS_CLOCK_IPO);
-    MXC_MCR->ldoctrl |= MXC_F_MCR_LDOCTRL_0P9EN;
-    MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_USB);
-    MXC_SYS_Reset_Periph(MXC_SYS_RESET0_USB);
+    init_usb();
 
     // Supervisor calls TinyUSB's dcd_init,
     // which initializes the USB PHY.