NUCLEO_F303RE: Add explicit pinmap support

Author: mprse

targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/TARGET_NUCLEO_F303RE/PeripheralPinMaps.h

@@ -38,6 +38,9 @@
 extern "C" {
 #endif
 
+/* If this macro is defined, then constexpr utility functions for pin-map seach can be used. */
+#define EXPLICIT_PINMAP_READY 1
+
 typedef enum {
     ALT0  = 0x100,
     ALT1  = 0x200,

targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/TARGET_NUCLEO_F303RE/PeripheralPins.c

@@ -37,25 +37,29 @@
 #include "mbed_debug.h"
 #include "PeripheralPins.h"
 
-void analogin_init(analogin_t *obj, PinName pin)
+#if EXPLICIT_PINMAP_READY
+#define ANALOGIN_INIT_DIRECT analogin_init_direct
+void analogin_init_direct(analogin_t *obj, const PinMap *pinmap)
+#else
+#define ANALOGIN_INIT_DIRECT _analogin_init_direct
+static void _analogin_init_direct(analogin_t *obj, const PinMap *pinmap)
+#endif
 {
-    uint32_t function = (uint32_t)NC;
+    uint32_t function = (uint32_t)pinmap->function;
+
+    // Get the peripheral name from the pin and assign it to the object
+    obj->handle.Instance = (ADC_TypeDef *)pinmap->peripheral;
 
     // ADC Internal Channels "pins"  (Temperature, Vref, Vbat, ...)
     //   are described in PinNames.h and PeripheralPins.c
     //   Pin value must be between 0xF0 and 0xFF
-    if ((pin < 0xF0) || (pin >= 0x100)) {
+    if ((pinmap->pin < 0xF0) || (pinmap->pin >= 0x100)) {
         // Normal channels
-        // Get the peripheral name from the pin and assign it to the object
-        obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC);
-        // Get the functions (adc channel) from the pin and assign it to the object
-        function = pinmap_function(pin, PinMap_ADC);
         // Configure GPIO
-        pinmap_pinout(pin, PinMap_ADC);
+        pin_function(pinmap->pin, pinmap->function);
+        pin_mode(pinmap->pin, PullNone);
     } else {
         // Internal channels
-        obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC_Internal);
-        function = pinmap_function(pin, PinMap_ADC_Internal);
         // No GPIO configuration for internal channels
     }
     MBED_ASSERT(obj->handle.Instance != (ADC_TypeDef *)NC);
@@ -64,7 +68,7 @@ void analogin_init(analogin_t *obj, PinName pin)
     obj->channel = STM_PIN_CHANNEL(function);
 
     // Save pin number for the read function
-    obj->pin = pin;
+    obj->pin = pinmap->pin;
 
     // Configure ADC object structures
     obj->handle.State = HAL_ADC_STATE_RESET;
@@ -113,6 +117,24 @@ void analogin_init(analogin_t *obj, PinName pin)
     }
 }
 
+void analogin_init(analogin_t *obj, PinName pin)
+{
+    int peripheral;
+    int function;
+
+    if ((pin < 0xF0) || (pin >= 0x100)) {
+        peripheral = (int)pinmap_peripheral(pin, PinMap_ADC);
+        function = (int)pinmap_find_function(pin, PinMap_ADC);
+    } else {
+        peripheral = (int)pinmap_peripheral(pin, PinMap_ADC_Internal);
+        function = (int)pinmap_find_function(pin, PinMap_ADC_Internal);
+    }
+
+    const PinMap explicit_pinmap = {pin, peripheral, function};
+
+    ANALOGIN_INIT_DIRECT(obj, &explicit_pinmap);
+}
+
 uint16_t adc_read(analogin_t *obj)
 {
     ADC_ChannelConfTypeDef sConfig = {0};

targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/TARGET_NUCLEO_F303RE/PinNames.h

@@ -39,16 +39,22 @@
 static int pa4_used = 0;
 static int pa5_used = 0;
 
-void analogout_init(dac_t *obj, PinName pin)
+#if EXPLICIT_PINMAP_READY
+#define ANALOGOUT_INIT_DIRECT analogout_init_direct
+void analogout_init_direct(dac_t *obj, const PinMap *pinmap)
+#else
+#define ANALOGOUT_INIT_DIRECT _analogout_init_direct
+static void _analogout_init_direct(dac_t *obj, const PinMap *pinmap)
+#endif
 {
     DAC_ChannelConfTypeDef sConfig = {0};
 
     // Get the peripheral name from the pin and assign it to the object
-    obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC);
+    obj->dac = (DACName)pinmap->peripheral;
     MBED_ASSERT(obj->dac != (DACName)NC);
 
     // Get the pin function and assign the used channel to the object
-    uint32_t function = pinmap_function(pin, PinMap_DAC);
+    uint32_t function = (uint32_t)pinmap->function;
     MBED_ASSERT(function != (uint32_t)NC);
 
     // Save the channel for the write and read functions
@@ -67,10 +73,11 @@ void analogout_init(dac_t *obj, PinName pin)
     }
 
     // Configure GPIO
-    pinmap_pinout(pin, PinMap_DAC);
+    pin_function(pinmap->pin, pinmap->function);
+    pin_mode(pinmap->pin, PullNone);
 
     // Save the pin for future use
-    obj->pin = pin;
+    obj->pin = pinmap->pin;
 
     // Enable DAC clock
     if (obj->dac == DAC_1) {
@@ -101,11 +108,11 @@ void analogout_init(dac_t *obj, PinName pin)
     sConfig.DAC_OutputSwitch = DAC_OUTPUTSWITCH_ENABLE;
 #endif
 
-    if (pin == PA_4) {
+    if (pinmap->pin == PA_4) {
         pa4_used = 1;
     }
 
-    if (pin == PA_5) {
+    if (pinmap->pin == PA_5) {
         pa5_used = 1;
     }
 
@@ -116,6 +123,16 @@ void analogout_init(dac_t *obj, PinName pin)
     analogout_write_u16(obj, 0);
 }
 
+void analogout_init(dac_t *obj, PinName pin)
+{
+    int peripheral = (int)pinmap_peripheral(pin, PinMap_DAC);
+    int function = (int)pinmap_find_function(pin, PinMap_DAC);
+
+    const PinMap explicit_pinmap = {pin, peripheral, function};
+
+    ANALOGOUT_INIT_DIRECT(obj, &explicit_pinmap);
+}
+
 void analogout_free(dac_t *obj)
 {
     // Reset DAC and disable clock

targets/TARGET_STM/TARGET_STM32F3/analogin_device.c

@@ -96,6 +96,8 @@ struct i2c_s {
     int hz;
     PinName sda;
     PinName scl;
+    int sda_func;
+    int scl_func;
     IRQn_Type event_i2cIRQ;
     IRQn_Type error_i2cIRQ;
     uint32_t XferOperation;

targets/TARGET_STM/TARGET_STM32F3/analogout_device.c

@@ -643,57 +643,87 @@ void serial_rx_abort_asynch(serial_t *obj)
  * Set HW Control Flow
  * @param obj    The serial object
  * @param type   The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS)
- * @param rxflow Pin for the rxflow
- * @param txflow Pin for the txflow
+ * @param pinmap Pointer to structure which holds static pinmap
  */
-void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
+#if EXPLICIT_PINMAP_READY
+#define SERIAL_SET_FC_DIRECT serial_set_flow_control_direct
+void serial_set_flow_control_direct(serial_t *obj, FlowControl type, const serial_fc_pinmap_t *pinmap)
+#else
+#define SERIAL_SET_FC_DIRECT _serial_set_flow_control_direct
+static void _serial_set_flow_control_direct(serial_t *obj, FlowControl type, const serial_fc_pinmap_t *pinmap)
+#endif
 {
     struct serial_s *obj_s = SERIAL_S(obj);
 
-    // Checked used UART name (UART_1, UART_2, ...)
-    UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS);
-    UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS);
-    if (((UARTName)pinmap_merge(uart_rts, obj_s->uart) == (UARTName)NC) || ((UARTName)pinmap_merge(uart_cts, obj_s->uart) == (UARTName)NC)) {
-        MBED_ASSERT(0);
-        return;
-    }
-
     if (type == FlowControlNone) {
         // Disable hardware flow control
         obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
     }
     if (type == FlowControlRTS) {
         // Enable RTS
-        MBED_ASSERT(uart_rts != (UARTName)NC);
+        MBED_ASSERT(pinmap->rx_flow_pin != (UARTName)NC);
         obj_s->hw_flow_ctl = UART_HWCONTROL_RTS;
-        obj_s->pin_rts = rxflow;
+        obj_s->pin_rts = pinmap->rx_flow_pin;
         // Enable the pin for RTS function
-        pinmap_pinout(rxflow, PinMap_UART_RTS);
+        pin_function(pinmap->rx_flow_pin, pinmap->rx_flow_function);
+        pin_mode(pinmap->rx_flow_pin, PullNone);
     }
     if (type == FlowControlCTS) {
         // Enable CTS
-        MBED_ASSERT(uart_cts != (UARTName)NC);
+        MBED_ASSERT(pinmap->tx_flow_pin != (UARTName)NC);
         obj_s->hw_flow_ctl = UART_HWCONTROL_CTS;
-        obj_s->pin_cts = txflow;
+        obj_s->pin_cts = pinmap->tx_flow_pin;
         // Enable the pin for CTS function
-        pinmap_pinout(txflow, PinMap_UART_CTS);
+        pin_function(pinmap->tx_flow_pin, pinmap->tx_flow_function);
+        pin_mode(pinmap->tx_flow_pin, PullNone);
     }
     if (type == FlowControlRTSCTS) {
         // Enable CTS & RTS
-        MBED_ASSERT(uart_rts != (UARTName)NC);
-        MBED_ASSERT(uart_cts != (UARTName)NC);
+        MBED_ASSERT(pinmap->rx_flow_pin != (UARTName)NC);
+        MBED_ASSERT(pinmap->tx_flow_pin != (UARTName)NC);
         obj_s->hw_flow_ctl = UART_HWCONTROL_RTS_CTS;
-        obj_s->pin_rts = rxflow;
-        obj_s->pin_cts = txflow;
+        obj_s->pin_rts = pinmap->rx_flow_pin;;
+        obj_s->pin_cts = pinmap->tx_flow_pin;;
         // Enable the pin for CTS function
-        pinmap_pinout(txflow, PinMap_UART_CTS);
+        pin_function(pinmap->tx_flow_pin, pinmap->tx_flow_function);
+        pin_mode(pinmap->tx_flow_pin, PullNone);
         // Enable the pin for RTS function
-        pinmap_pinout(rxflow, PinMap_UART_RTS);
+        pin_function(pinmap->rx_flow_pin, pinmap->rx_flow_function);
+        pin_mode(pinmap->rx_flow_pin, PullNone);
     }
 
     init_uart(obj);
 }
 
+/**
+ * Set HW Control Flow
+ * @param obj    The serial object
+ * @param type   The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS)
+ * @param rxflow Pin for the rxflow
+ * @param txflow Pin for the txflow
+ */
+void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
+{
+    struct serial_s *obj_s = SERIAL_S(obj);
+
+    UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS);
+    UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS);
+
+    if (((UARTName)pinmap_merge(uart_rts, obj_s->uart) == (UARTName)NC) || ((UARTName)pinmap_merge(uart_cts, obj_s->uart) == (UARTName)NC)) {
+        MBED_ASSERT(0);
+        return;
+    }
+
+    int peripheral = (int)pinmap_merge(uart_rts, uart_cts);
+
+    int tx_flow_function = (int)pinmap_find_function(txflow, PinMap_UART_CTS);
+    int rx_flow_function = (int)pinmap_find_function(rxflow, PinMap_UART_RTS);
+
+    const serial_fc_pinmap_t explicit_uart_fc_pinmap = {peripheral, txflow, tx_flow_function, rxflow, rx_flow_function};
+
+    SERIAL_SET_FC_DIRECT(obj, type, &explicit_uart_fc_pinmap);
+}
+
 #endif /* DEVICE_SERIAL_FC */
 
 #endif /* DEVICE_SERIAL */