Implemented functionality of hardware input pins on PB6/PB7

stm32/aioc-fw/Inc/aioc.h

@@ -2,6 +2,7 @@
 #define AIOC_H_
 
 #define AIOC_IRQ_PRIO_SYSTICK    6
+#define AIOC_IRQ_PRIO_IO         5
 #define AIOC_IRQ_PRIO_USB        4
 #define AIOC_IRQ_PRIO_SERIAL     3
 #define AIOC_IRQ_PRIO_AUDIO      2

stm32/aioc-fw/Src/cos.h

@@ -4,9 +4,10 @@
 #include <stdint.h>
 #include "stm32f3xx_hal.h"
 #include "usb_hid.h"
+#include "usb_serial.h"
 #include "settings.h"
 
-static inline void COS_SetState(uint8_t state)
+static inline void COS_VirtualSetState(uint8_t state)
 {
     LED_SET(0, state & 0x01 ? 1 : 0);
 

stm32/aioc-fw/Src/io.c

@@ -0,0 +1,82 @@
+#include "io.h"
+#include "usb_hid.h"
+#include "usb_serial.h"
+#include "settings.h"
+
+void IO_IN_EXTI_ISR(void)
+{
+    if (EXTI->PR & IO_IN_PIN_1_EXTI_PR) {
+        uint8_t state = IO_IN_GPIO->IDR & IO_IN_PIN_1 ? 0x00 : 0x01;
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX0] & SETTINGS_REG_CM108_IOMUX0_BTN1SRC_IO1_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLUP : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX1] & SETTINGS_REG_CM108_IOMUX1_BTN2SRC_IO1_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLDN : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX2] & SETTINGS_REG_CM108_IOMUX2_BTN3SRC_IO1_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_PLAYMUTE : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX3] & SETTINGS_REG_CM108_IOMUX3_BTN4SRC_IO1_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_RECMUTE : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX0] & SETTINGS_REG_SERIAL_IOMUX0_DCDSRC_IO1_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DCD : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX1] & SETTINGS_REG_SERIAL_IOMUX1_DSRSRC_IO1_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DSR : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX2] & SETTINGS_REG_SERIAL_IOMUX2_RISRC_IO1_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_RI : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX3] & SETTINGS_REG_SERIAL_IOMUX3_BRKSRC_IO1_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_BREAK : 0x00);
+        }
+    }
+
+    if (EXTI->PR & IO_IN_PIN_2_EXTI_PR) {
+        uint8_t state = IO_IN_GPIO->IDR & IO_IN_PIN_2 ? 0x00 : 0x01;
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX0] & SETTINGS_REG_CM108_IOMUX0_BTN1SRC_IO2_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLUP : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX1] & SETTINGS_REG_CM108_IOMUX1_BTN2SRC_IO2_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_VOLDN : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX2] & SETTINGS_REG_CM108_IOMUX2_BTN3SRC_IO2_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_PLAYMUTE : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_CM108_IOMUX3] & SETTINGS_REG_CM108_IOMUX3_BTN4SRC_IO2_MASK) {
+            USB_HIDSendButtonState(state & 0x01 ? USB_HID_BUTTON_RECMUTE : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX0] & SETTINGS_REG_SERIAL_IOMUX0_DCDSRC_IO2_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DCD : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX1] & SETTINGS_REG_SERIAL_IOMUX1_DSRSRC_IO2_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_DSR : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX2] & SETTINGS_REG_SERIAL_IOMUX2_RISRC_IO2_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_RI : 0x00);
+        }
+
+        if (settingsRegMap[SETTINGS_REG_SERIAL_IOMUX3] & SETTINGS_REG_SERIAL_IOMUX3_BRKSRC_IO2_MASK) {
+            USB_SerialSendLineState(state & 0x01 ? USB_SERIAL_LINESTATE_BREAK : 0x00);
+        }
+    }
+
+    /* Clear flags */
+    EXTI->PR = IO_IN_PIN_1_EXTI_PR | IO_IN_PIN_2_EXTI_PR;
+}

stm32/aioc-fw/Src/io.h

@@ -0,0 +1,132 @@
+#ifndef IO_H_
+#define IO_H_
+
+#include <stdint.h>
+#include "stm32f3xx_hal.h"
+#include "aioc.h"
+#include "led.h"
+#include "settings.h"
+
+#define IO_PTT_MASK_NONE        0x00
+#define IO_PTT_MASK_PTT1        0x01
+#define IO_PTT_MASK_PTT2        0x02
+
+#define IO_OUT_GPIO             GPIOA
+#define IO_OUT_PIN_1            GPIO_PIN_1
+#define IO_OUT_PIN_2            GPIO_PIN_0
+#define IO_IN_GPIO              GPIOB
+#define IO_IN_PIN_1             GPIO_PIN_6
+#define IO_IN_PIN_2             GPIO_PIN_7
+#define IO_IN_EXTI_ISR          EXTI9_5_IRQHandler
+#define IO_IN_PIN_1_EXTI_PR     EXTI_PR_PR6
+#define IO_IN_PIN_2_EXTI_PR     EXTI_PR_PR7
+#define IO_IN_IRQN              EXTI9_5_IRQn
+
+static inline void IO_PTTAssert(uint8_t pttMask)
+{
+    __disable_irq();
+
+    if (pttMask & IO_PTT_MASK_PTT1) {
+        IO_OUT_GPIO->BSRR = IO_OUT_PIN_1;
+        LED_SET(1, 1);
+
+        /* Update debug register */
+        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
+    }
+
+    if (pttMask & IO_PTT_MASK_PTT2) {
+        IO_OUT_GPIO->BSRR = IO_OUT_PIN_2;
+        LED_SET(0, 1);
+
+        /* Update debug register */
+        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
+    }
+
+    __enable_irq();
+}
+
+static inline void IO_PTTDeassert(uint8_t pttMask)
+{
+    __disable_irq();
+
+    if (pttMask & IO_PTT_MASK_PTT1) {
+        IO_OUT_GPIO->BRR = IO_OUT_PIN_1;
+        LED_SET(1, 0);
+
+        /* Update debug register */
+        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
+    }
+
+    if (pttMask & IO_PTT_MASK_PTT2) {
+        IO_OUT_GPIO->BRR = IO_OUT_PIN_2;
+        LED_SET(0, 0);
+
+        /* Update debug register */
+        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
+    }
+
+    __enable_irq();
+}
+
+static inline void IO_PTTControl(uint8_t pttMask)
+{
+    /* TODO: Using this function, both PTTs can only be asserted/deasserted simultaneously.
+     * Switch to using fully event(edge) driven PTT assertion/deassertion using functions below */
+
+    if (pttMask & IO_PTT_MASK_PTT1) {
+        IO_PTTAssert(IO_PTT_MASK_PTT1);
+    } else {
+        IO_PTTDeassert(IO_PTT_MASK_PTT1);
+    }
+
+    if (pttMask & IO_PTT_MASK_PTT2) {
+        IO_PTTAssert(IO_PTT_MASK_PTT2);
+    } else {
+        IO_PTTDeassert(IO_PTT_MASK_PTT2);
+    }
+
+}
+
+static inline  uint8_t IO_PTTStatus(void)
+{
+    uint32_t inputReg = IO_OUT_GPIO->IDR;
+
+    return (inputReg & IO_OUT_PIN_1 ? IO_PTT_MASK_PTT1 : 0) |
+           (inputReg & IO_OUT_PIN_2 ? IO_PTT_MASK_PTT2 : 0);
+}
+
+static inline  void IO_Init(void)
+{
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+
+    /* Set up output GPIOs */
+    GPIO_InitTypeDef outGPIO = {
+        .Pin = (IO_OUT_PIN_2 | IO_OUT_PIN_1),
+        .Mode = GPIO_MODE_OUTPUT_PP,
+        .Pull = GPIO_PULLDOWN,
+        .Speed = GPIO_SPEED_FREQ_LOW,
+        .Alternate = 0
+    };
+    HAL_GPIO_Init(IO_OUT_GPIO, &outGPIO);
+
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+
+    /* Set up input GPIOs */
+    GPIO_InitTypeDef inGPIO = {
+        .Pin = (IO_IN_PIN_2 | IO_IN_PIN_1),
+        .Mode = GPIO_MODE_IT_RISING_FALLING,
+        .Pull = GPIO_PULLUP,
+        .Speed = GPIO_SPEED_FREQ_LOW,
+        .Alternate = 0
+    };
+    HAL_GPIO_Init(IO_IN_GPIO, &inGPIO);
+
+    /* Clear any external interrupt and enable */
+    EXTI->PR = IO_IN_PIN_1_EXTI_PR | IO_IN_PIN_2_EXTI_PR;
+    NVIC_SetPriority(IO_IN_IRQN, AIOC_IRQ_PRIO_IO);
+    NVIC_ClearPendingIRQ(IO_IN_IRQN);
+    NVIC_EnableIRQ(IO_IN_IRQN);
+}
+
+
+#endif /* IO_H_ */

stm32/aioc-fw/Src/main.c

@@ -2,9 +2,9 @@
 #include "aioc.h"
 #include "settings.h"
 #include "led.h"
-#include "ptt.h"
 #include "usb.h"
 #include <assert.h>
+#include <io.h>
 #include <stdio.h>
 
 // from ST application note AN2606
@@ -185,7 +185,7 @@ int main(void)
     LED_MODE(0, LED_MODE_SLOWPULSE2X);
     LED_MODE(1, LED_MODE_SLOWPULSE2X);
 
-    PTT_Init();
+    IO_Init();
 
     USB_Init();
 

stm32/aioc-fw/Src/ptt.h

@@ -1,106 +0,0 @@
-#ifndef PTT_H_
-#define PTT_H_
-
-#include <stdint.h>
-#include "stm32f3xx_hal.h"
-#include "aioc.h"
-#include "led.h"
-#include "settings.h"
-
-#define PTT_MASK_NONE       0x00
-#define PTT_MASK_PTT1       0x01
-#define PTT_MASK_PTT2       0x02
-
-#define PTT_GPIO            GPIOA
-#define PTT_PIN_PTT1        GPIO_PIN_1
-#define PTT_PIN_PTT2        GPIO_PIN_0
-
-static inline void PTT_Assert(uint8_t pttMask)
-{
-    __disable_irq();
-
-    if (pttMask & PTT_MASK_PTT1) {
-        PTT_GPIO->BSRR = PTT_PIN_PTT1;
-        LED_SET(1, 1);
-
-        /* Update debug register */
-        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
-    }
-
-    if (pttMask & PTT_MASK_PTT2) {
-        PTT_GPIO->BSRR = PTT_PIN_PTT2;
-        LED_SET(0, 1);
-
-        /* Update debug register */
-        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
-    }
-
-    __enable_irq();
-}
-
-static inline void PTT_Deassert(uint8_t pttMask)
-{
-    __disable_irq();
-
-    if (pttMask & PTT_MASK_PTT1) {
-        PTT_GPIO->BRR = PTT_PIN_PTT1;
-        LED_SET(1, 0);
-
-        /* Update debug register */
-        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT1STATE_MASK;
-    }
-
-    if (pttMask & PTT_MASK_PTT2) {
-        PTT_GPIO->BRR = PTT_PIN_PTT2;
-        LED_SET(0, 0);
-
-        /* Update debug register */
-        settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_PTT2STATE_MASK;
-    }
-
-    __enable_irq();
-}
-
-static inline void PTT_Control(uint8_t pttMask)
-{
-    /* TODO: Using this function, both PTTs can only be asserted/deasserted simultaneously.
-     * Switch to using fully event(edge) driven PTT assertion/deassertion using functions below */
-
-    if (pttMask & PTT_MASK_PTT1) {
-        PTT_Assert(PTT_MASK_PTT1);
-    } else {
-        PTT_Deassert(PTT_MASK_PTT1);
-    }
-
-    if (pttMask & PTT_MASK_PTT2) {
-        PTT_Assert(PTT_MASK_PTT2);
-    } else {
-        PTT_Deassert(PTT_MASK_PTT2);
-    }
-
-}
-
-static inline  uint8_t PTT_Status(void)
-{
-    uint32_t inputReg = PTT_GPIO->IDR;
-
-    return (inputReg & PTT_PIN_PTT1 ? PTT_MASK_PTT1 : 0) |
-           (inputReg & PTT_PIN_PTT2 ? PTT_MASK_PTT2 : 0);
-}
-
-static inline  void PTT_Init(void)
-{
-    __HAL_RCC_GPIOA_CLK_ENABLE();
-
-    /* Set up PTT GPIOs */
-    GPIO_InitTypeDef pttGPIO = {
-        .Pin = (PTT_PIN_PTT2 | PTT_PIN_PTT1),
-        .Mode = GPIO_MODE_OUTPUT_PP,
-        .Pull = GPIO_PULLDOWN,
-        .Speed = GPIO_SPEED_FREQ_LOW,
-        .Alternate = 0
-    };
-    HAL_GPIO_Init(PTT_GPIO, &pttGPIO);
-}
-
-#endif /* PTT_H_ */

stm32/aioc-fw/Src/settings.h

@@ -68,7 +68,7 @@ extern uint32_t settingsRegMap[SETTINGS_REGMAP_SIZE];
 #define SETTINGS_REG_CM108_IOMUX0                           0x44
 #define SETTINGS_REG_CM108_IOMUX0_DEFAULT                   (SETTINGS_REG_CM108_IOMUX0_BTN1SRC_DFLT)
 /* BTN1SRC: Volume-Up Button source */
-#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_DFLT              (SETTINGS_REG_CM108_IOMUX0_BTN1SRC_NONE_MASK)
+#define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_DFLT              (SETTINGS_REG_CM108_IOMUX0_BTN1SRC_IO2_MASK)
 #define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_OFFS              0
 #define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_MASK              0xFFFFFFFFUL
 #define SETTINGS_REG_CM108_IOMUX0_BTN1SRC_NONE_MASK         0x00000000UL

stm32/aioc-fw/Src/usb_audio.c

@@ -1,9 +1,9 @@
+#include <io.h>
 #include "usb_audio.h"
 #include "stm32f3xx_hal.h"
 #include "aioc.h"
 #include "tusb.h"
 #include "usb.h"
-#include "ptt.h"
 #include "cos.h"
 #include <math.h>
 
@@ -775,11 +775,11 @@ void TIM16_IRQHandler(void)
             settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_VPTTSTATE_MASK;
 
             /* Assert enabled PTTs */
-            uint8_t pttMask = PTT_MASK_NONE;
+            uint8_t pttMask = IO_PTT_MASK_NONE;
-            pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? PTT_MASK_PTT1 : 0;
+            pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? IO_PTT_MASK_PTT1 : 0;
-            pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? PTT_MASK_PTT2 : 0;
+            pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? IO_PTT_MASK_PTT2 : 0;
 
-            PTT_Assert(pttMask);
+            IO_PTTAssert(pttMask);
         }
     } else if (flags & TIM_SR_CC1IF) {
         /* The idle timeout (without any action on the DAC) was reached. Disable timer and deassert PTT */
@@ -789,11 +789,11 @@ void TIM16_IRQHandler(void)
         settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_VPTTSTATE_MASK;
 
         /* Deassert enabled PTTs */
-        uint8_t pttMask = PTT_MASK_NONE;
+        uint8_t pttMask = IO_PTT_MASK_NONE;
-        pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? PTT_MASK_PTT1 : 0;
+        pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_VPTT_MASK ? IO_PTT_MASK_PTT1 : 0;
-        pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? PTT_MASK_PTT2 : 0;
+        pttMask |= settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_VPTT_MASK ? IO_PTT_MASK_PTT2 : 0;
 
-        PTT_Deassert(pttMask);
+        IO_PTTDeassert(pttMask);
     }
 
     TIM16->SR = ~flags;
@@ -815,7 +815,7 @@ void TIM17_IRQHandler(void)
             settingsRegMap[SETTINGS_REG_INFO_AUDIO0] |= SETTINGS_REG_INFO_AIOC0_VCOSSTATE_MASK;
 
             /* Set COS state */
-            COS_SetState(0x01);
+            COS_VirtualSetState(0x01);
         }
     } else if (flags & TIM_SR_CC1IF) {
         /* The idle timeout (without any action on the ADC) was reached. Disable timer and notify host */
@@ -825,7 +825,7 @@ void TIM17_IRQHandler(void)
         settingsRegMap[SETTINGS_REG_INFO_AUDIO0] &= ~SETTINGS_REG_INFO_AIOC0_VCOSSTATE_MASK;
 
         /* Set COS state */
-        COS_SetState(0x00);
+        COS_VirtualSetState(0x00);
     }
 
     TIM17->SR = ~flags;

stm32/aioc-fw/Src/usb_hid.c

@@ -1,6 +1,6 @@
+#include <io.h>
 #include "usb_hid.h"
 #include "tusb.h"
-#include "ptt.h"
 #include "settings.h"
 #include "usb_descriptors.h"
 
@@ -28,41 +28,41 @@ static bool SendReport(void)
 
 static void ControlPTT(uint8_t gpio)
 {
-    uint8_t pttMask = PTT_MASK_NONE;
+    uint8_t pttMask = IO_PTT_MASK_NONE;
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO1_MASK) {
-        pttMask |= gpio & 0x01 ? PTT_MASK_PTT1 : 0;
+        pttMask |= gpio & 0x01 ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO2_MASK) {
-        pttMask |= gpio & 0x02 ? PTT_MASK_PTT1 : 0;
+        pttMask |= gpio & 0x02 ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO3_MASK) {
-        pttMask |= gpio & 0x04 ? PTT_MASK_PTT1 : 0;
+        pttMask |= gpio & 0x04 ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_CM108GPIO4_MASK) {
-        pttMask |= gpio & 0x08 ? PTT_MASK_PTT1 : 0;
+        pttMask |= gpio & 0x08 ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO1_MASK) {
-        pttMask |= gpio & 0x01 ? PTT_MASK_PTT2 : 0;
+        pttMask |= gpio & 0x01 ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO2_MASK) {
-        pttMask |= gpio & 0x02 ? PTT_MASK_PTT2 : 0;
+        pttMask |= gpio & 0x02 ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO3_MASK) {
-        pttMask |= gpio & 0x04 ? PTT_MASK_PTT2 : 0;
+        pttMask |= gpio & 0x04 ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_CM108GPIO4_MASK) {
-        pttMask |= gpio & 0x08 ? PTT_MASK_PTT2 : 0;
+        pttMask |= gpio & 0x08 ? IO_PTT_MASK_PTT2 : 0;
     }
 
-    PTT_Control(pttMask);
+    IO_PTTControl(pttMask);
 }
 
 // Invoked when received GET_REPORT control request

stm32/aioc-fw/Src/usb_serial.c

@@ -1,9 +1,9 @@
+#include <io.h>
 #include "usb_serial.h"
 #include "stm32f3xx_hal.h"
 #include "aioc.h"
 #include "tusb.h"
 #include "led.h"
-#include "ptt.h"
 #include "settings.h"
 #include "usb_descriptors.h"
 
@@ -47,7 +47,7 @@ void USB_SERIAL_UART_IRQ(void)
         /* RX register is not empty, get character and put into USB send buffer */
         if (tud_cdc_n_write_available(0) > 0) {
             uint8_t c = USB_SERIAL_UART->RDR;
-            uint8_t pttStatus = PTT_Status();
+            uint8_t pttStatus = IO_PTTStatus();
             uint8_t pttRxIgnoreMask = (settingsRegMap[SETTINGS_REG_SERIAL_CTRL] & SETTINGS_REG_SERIAL_CTRL_RXIGNPTT_MASK) >> SETTINGS_REG_SERIAL_CTRL_RXIGNPTT_OFFS;
 
             if (!(pttStatus & pttRxIgnoreMask) ) {
@@ -89,12 +89,12 @@ void tud_cdc_rx_cb(uint8_t itf)
 {
     TU_ASSERT(itf == 0, /**/);
 
-    uint8_t pttStatus = PTT_Status();
+    uint8_t pttStatus = IO_PTTStatus();
     uint8_t pttTxForceMask = (settingsRegMap[SETTINGS_REG_SERIAL_CTRL] & SETTINGS_REG_SERIAL_CTRL_TXFRCPTT_MASK) >> SETTINGS_REG_SERIAL_CTRL_TXFRCPTT_OFFS;
 
     if (pttStatus & pttTxForceMask) {
         /* Make sure the selected PTTs are disabled, since they might share a signal with the UART lines */
-        PTT_Control(pttStatus & ~pttTxForceMask);
+        IO_PTTControl(pttStatus & ~pttTxForceMask);
     }
 
     /* This enables the transmitter and the TX-empty interrupt, which handles writing UART data */
@@ -174,43 +174,43 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
 {
     TU_ASSERT(itf == 0, /**/);
 
-    uint8_t pttMask = PTT_MASK_NONE;
+    uint8_t pttMask = IO_PTT_MASK_NONE;
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALDTR_MASK) {
-        pttMask |= dtr ? PTT_MASK_PTT1 : 0;
+        pttMask |= dtr ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALRTS_MASK) {
-        pttMask |= rts ? PTT_MASK_PTT1 : 0;
+        pttMask |= rts ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALDTRNRTS_MASK) {
-        pttMask |= (dtr && !rts) ? PTT_MASK_PTT1 : 0;
+        pttMask |= (dtr && !rts) ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX0] & SETTINGS_REG_AIOC_IOMUX0_PTT1SRC_SERIALNDTRRTS_MASK) {
-        pttMask |= (!dtr && rts) ? PTT_MASK_PTT1 : 0;
+        pttMask |= (!dtr && rts) ? IO_PTT_MASK_PTT1 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALDTR_MASK) {
-        pttMask |= dtr ? PTT_MASK_PTT2 : 0;
+        pttMask |= dtr ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALRTS_MASK) {
-        pttMask |= rts ? PTT_MASK_PTT2 : 0;
+        pttMask |= rts ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALDTRNRTS_MASK) {
-        pttMask |= (dtr && !rts) ? PTT_MASK_PTT2 : 0;
+        pttMask |= (dtr && !rts) ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (settingsRegMap[SETTINGS_REG_AIOC_IOMUX1] & SETTINGS_REG_AIOC_IOMUX1_PTT2SRC_SERIALNDTRRTS_MASK) {
-        pttMask |= (!dtr && rts) ? PTT_MASK_PTT2 : 0;
+        pttMask |= (!dtr && rts) ? IO_PTT_MASK_PTT2 : 0;
     }
 
     if (! (USB_SERIAL_UART->CR1 & USART_CR1_TE) ) {
         /* Enable PTT only when UART transmitter is not currently transmitting */
-        PTT_Control(pttMask);
+        IO_PTTControl(pttMask);
     }
 }