LPC55S69_NS: Add explicit pinmap support

Author: mprse

targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/analogin_api.c

@@ -32,19 +32,25 @@ extern void ADC_ClockPower_Configuration(void);
 #define MAX_FADC 6000000
 #define MAX_ADC_CLOCK 80000000
 
-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 clkval;
     uint32_t clkdiv = 1;
 
-    obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC);
+    obj->adc = (ADCName)pinmap->peripheral;
     MBED_ASSERT(obj->adc != (ADCName)NC);
 
     uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;
     adc_config_t adc_config;
     uint32_t reg;
-    uint32_t pin_number = pin & 0x1F;
-    uint8_t port_number = pin / 32;
+    uint32_t pin_number = pinmap->pin & 0x1F;
+    uint8_t port_number = pinmap->pin / 32;
 
     ADC_ClockPower_Configuration();
 
@@ -64,13 +70,24 @@ void analogin_init(analogin_t *obj, PinName pin)
     adc_config.clockDividerNumber = (clkdiv - 1);
 
     ADC_Init(adc_addrs[instance], &adc_config);
-    pinmap_pinout(pin, PinMap_ADC);
+    pin_function(pinmap->pin, pinmap->function);
+    pin_mode(pinmap->pin, PullNone);
 
     /* Clear the DIGIMODE & MODE bits */
     reg = IOCON->PIO[port_number][pin_number] & ~(IOCON_PIO_DIGIMODE_MASK | IOCON_PIO_MODE_MASK);
     IOCON->PIO[port_number][pin_number] = reg;
 }
 
+void analogin_init(analogin_t *obj, PinName pin)
+{
+    int peripheral = (int)pinmap_peripheral(pin, PinMap_ADC);
+    int function = (int)pinmap_find_function(pin, PinMap_ADC);
+
+    const PinMap explicit_pinmap = {pin, peripheral, function};
+
+    ANALOGIN_INIT_DIRECT(obj, &explicit_pinmap);
+}
+
 uint16_t analogin_read_u16(analogin_t *obj)
 {
     uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;

targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/i2c_api.c

@@ -26,11 +26,15 @@
 /* Array of I2C peripheral base address. */
 static I2C_Type *const i2c_addrs[] = I2C_BASE_PTRS;
 
-void i2c_init(i2c_t *obj, PinName sda, PinName scl)
+#if EXPLICIT_PINMAP_READY
+#define I2C_INIT_DIRECT i2c_init_direct
+void i2c_init_direct(i2c_t *obj, const i2c_pinmap_t *pinmap)
+#else
+#define I2C_INIT_DIRECT _i2c_init_direct
+static void _i2c_init_direct(i2c_t *obj, const i2c_pinmap_t *pinmap)
+#endif
 {
-    uint32_t i2c_sda = pinmap_peripheral(sda, PinMap_I2C_SDA);
-    uint32_t i2c_scl = pinmap_peripheral(scl, PinMap_I2C_SCL);
-    obj->instance = pinmap_merge(i2c_sda, i2c_scl);
+    obj->instance = (uint32_t) pinmap->peripheral;
     obj->next_repeated_start = 0;
     obj->issue_start = 0;
     MBED_ASSERT((int)obj->instance != NC);
@@ -87,8 +91,25 @@ void i2c_init(i2c_t *obj, PinName sda, PinName scl)
     I2C_MasterGetDefaultConfig(&master_config);
     I2C_MasterInit(i2c_addrs[obj->instance], &master_config, 12000000);
 
-    pinmap_pinout(sda, PinMap_I2C_SDA);
-    pinmap_pinout(scl, PinMap_I2C_SCL);
+    pin_function(pinmap->sda_pin, pinmap->sda_function);
+    pin_mode(pinmap->sda_pin, PullNone);
+    pin_function(pinmap->scl_pin, pinmap->scl_function);
+    pin_mode(pinmap->scl_pin, PullNone);
+}
+
+void i2c_init(i2c_t *obj, PinName sda, PinName scl)
+{
+    uint32_t i2c_sda = pinmap_peripheral(sda, PinMap_I2C_SDA);
+    uint32_t i2c_scl = pinmap_peripheral(scl, PinMap_I2C_SCL);
+
+    int peripheral = (int)pinmap_merge(i2c_sda, i2c_scl);
+
+    int sda_function = (int)pinmap_find_function(sda, PinMap_I2C_SDA);
+    int scl_function = (int)pinmap_find_function(scl, PinMap_I2C_SCL);
+
+    const i2c_pinmap_t explicit_i2c_pinmap = {peripheral, sda, sda_function, scl, scl_function};
+
+    I2C_INIT_DIRECT(obj, &explicit_i2c_pinmap);
 }
 
 int i2c_start(i2c_t *obj)

targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/lp_analogin_api.c

@@ -32,18 +32,24 @@ extern void ADC_ClockPower_Configuration(void);
 
 #define LPADC_USER_CMDID 1U /* CMD1 */
 
-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
 {
     gpio_t gpio;
 
-    obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC);
+    obj->adc = (ADCName)pinmap->peripheral;
     MBED_ASSERT(obj->adc != (ADCName)NC);
 
     uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;
     lpadc_config_t adc_config;
     uint32_t reg;
-    uint32_t pin_number = pin & 0x1F;
-    uint8_t port_number = pin / 32;
+    uint32_t pin_number = pinmap->pin & 0x1F;
+    uint8_t port_number = pinmap->pin / 32;
 
     ADC_ClockPower_Configuration();
 
@@ -75,10 +81,11 @@ void analogin_init(analogin_t *obj, PinName pin)
     LPADC_DoAutoCalibration(adc_addrs[instance]);
 #endif /* FSL_FEATURE_LPADC_HAS_CFG_CALOFS */
 
-    pinmap_pinout(pin, PinMap_ADC);
+    pin_function(pinmap->pin, pinmap->function);
+    pin_mode(pinmap->pin, PullNone);
 
     /* Need to ensure the pin is in input mode */
-    gpio_init(&gpio, pin);
+    gpio_init(&gpio, pinmap->pin);
     gpio_dir(&gpio, PIN_INPUT);
 
     reg = IOCON->PIO[port_number][pin_number];
@@ -101,6 +108,16 @@ void analogin_init(analogin_t *obj, PinName pin)
     IOCON->PIO[port_number][pin_number] = reg;
 }
 
+void analogin_init(analogin_t *obj, PinName pin)
+{
+    int peripheral = (int)pinmap_peripheral(pin, PinMap_ADC);
+    int function = (int)pinmap_find_function(pin, PinMap_ADC);
+
+    const PinMap explicit_pinmap = {pin, peripheral, function};
+
+    ANALOGIN_INIT_DIRECT(obj, &explicit_pinmap);
+}
+
 uint16_t analogin_read_u16(analogin_t *obj)
 {
     uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;

targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/serial_api.c

@@ -38,11 +38,15 @@ static USART_Type *const uart_addrs[] = USART_BASE_PTRS;
 int stdio_uart_inited = 0;
 serial_t stdio_uart;
 
-void serial_init(serial_t *obj, PinName tx, PinName rx)
+#if EXPLICIT_PINMAP_READY
+#define SERIAL_INIT_DIRECT serial_init_direct
+void serial_init_direct(serial_t *obj, const serial_pinmap_t *pinmap)
+#else
+#define SERIAL_INIT_DIRECT _serial_init_direct
+static void _serial_init_direct(serial_t *obj, const serial_pinmap_t *pinmap)
+#endif
 {
-    uint32_t uart_tx = pinmap_peripheral(tx, PinMap_UART_TX);
-    uint32_t uart_rx = pinmap_peripheral(rx, PinMap_UART_RX);
-    obj->index = pinmap_merge(uart_tx, uart_rx);
+    obj->index = (uint32_t)pinmap->peripheral;
     MBED_ASSERT((int)obj->index != NC);
 
     usart_config_t config;
@@ -101,14 +105,14 @@ void serial_init(serial_t *obj, PinName tx, PinName rx)
 
     USART_Init(uart_addrs[obj->index], &config, 12000000);
 
-    pinmap_pinout(tx, PinMap_UART_TX);
-    pinmap_pinout(rx, PinMap_UART_RX);
+    pin_function(pinmap->tx_pin, pinmap->tx_function);
+    pin_function(pinmap->rx_pin, pinmap->rx_function);
 
-    if (tx != NC) {
-        pin_mode(tx, PullUp);
+    if (pinmap->tx_pin != NC) {
+        pin_mode(pinmap->tx_pin, PullUp);
     }
-    if (rx != NC) {
-        pin_mode(rx, PullUp);
+    if (pinmap->rx_pin != NC) {
+        pin_mode(pinmap->rx_pin, PullUp);
     }
 
     if (obj->index == STDIO_UART) {
@@ -117,6 +121,21 @@ void serial_init(serial_t *obj, PinName tx, PinName rx)
     }
 }
 
+void serial_init(serial_t *obj, PinName tx, PinName rx)
+{
+    uint32_t uart_tx = pinmap_peripheral(tx, PinMap_UART_TX);
+    uint32_t uart_rx = pinmap_peripheral(rx, PinMap_UART_RX);
+
+    int peripheral = (int)pinmap_merge(uart_tx, uart_rx);
+
+    int tx_function = (int)pinmap_find_function(tx, PinMap_UART_TX);
+    int rx_function = (int)pinmap_find_function(rx, PinMap_UART_RX);
+
+    const serial_pinmap_t explicit_uart_pinmap = {peripheral, tx, tx_function, rx, rx_function, false};
+
+    SERIAL_INIT_DIRECT(obj, &explicit_uart_pinmap);
+}
+
 void serial_free(serial_t *obj)
 {
     USART_Deinit(uart_addrs[obj->index]);
@@ -386,39 +405,45 @@ void serial_break_clear(serial_t *obj)
 /*
  * Only hardware flow control is implemented in this API.
  */
-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
 {
     gpio_t gpio;
 
     switch(type) {
         case FlowControlRTS:
-            pinmap_pinout(rxflow, PinMap_UART_RTS);
+            pin_function(pinmap->rx_flow_pin, pinmap->rx_flow_function);
+            pin_mode(pinmap->rx_flow_pin, PullNone);
             uart_addrs[obj->index]->CFG &= ~USART_CFG_CTSEN_MASK;
             break;
 
         case FlowControlCTS:
             /* Do not use RTS, configure pin to GPIO input */
-            if (rxflow != NC) {
-                gpio_init(&gpio, rxflow);
-                gpio_dir(&gpio, PIN_INPUT);
-            }
+            gpio_init(&gpio, pinmap->rx_flow_pin);
+            gpio_dir(&gpio, PIN_INPUT);
 
-            pinmap_pinout(txflow, PinMap_UART_CTS);
+            pin_function(pinmap->tx_flow_pin, pinmap->tx_flow_function);
+            pin_mode(pinmap->tx_flow_pin, PullNone);
             uart_addrs[obj->index]->CFG |= USART_CFG_CTSEN_MASK;
             break;
 
         case FlowControlRTSCTS:
-            pinmap_pinout(rxflow, PinMap_UART_RTS);
-            pinmap_pinout(txflow, PinMap_UART_CTS);
+            pin_function(pinmap->rx_flow_pin, pinmap->rx_flow_function);
+            pin_mode(pinmap->rx_flow_pin, PullNone);
+            pin_function(pinmap->tx_flow_pin, pinmap->tx_flow_function);
+            pin_mode(pinmap->tx_flow_pin, PullNone);
             uart_addrs[obj->index]->CFG |= USART_CFG_CTSEN_MASK;
             break;
 
         case FlowControlNone:
             /* Do not use RTS, configure pin to GPIO input */
-            if (rxflow != NC) {
-                gpio_init(&gpio, rxflow);
-                gpio_dir(&gpio, PIN_INPUT);
-            }
+            gpio_init(&gpio, pinmap->rx_flow_pin);
+            gpio_dir(&gpio, PIN_INPUT);
 
             uart_addrs[obj->index]->CFG &= ~USART_CFG_CTSEN_MASK;
             break;
@@ -427,6 +452,17 @@ void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, Pi
             break;
     }
 }
+
+void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
+{
+    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 = {0, txflow, tx_flow_function, rxflow, rx_flow_function};
+
+    SERIAL_SET_FC_DIRECT(obj, type, &explicit_uart_fc_pinmap);
+}
+
 #endif
 const PinMap *serial_tx_pinmap()
 {

targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/spi_api.c

@@ -30,17 +30,15 @@
 static SPI_Type *const spi_address[] = SPI_BASE_PTRS;
 static int baud_rate = 0;
 
-void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
+#if EXPLICIT_PINMAP_READY
+#define SPI_INIT_DIRECT spi_init_direct
+void spi_init_direct(spi_t *obj, const spi_pinmap_t *pinmap)
+#else
+#define SPI_INIT_DIRECT _spi_init_direct
+static void _spi_init_direct(spi_t *obj, const spi_pinmap_t *pinmap)
+#endif
 {
-    // determine the SPI to use
-    uint32_t spi_mosi = pinmap_peripheral(mosi, PinMap_SPI_MOSI);
-    uint32_t spi_miso = pinmap_peripheral(miso, PinMap_SPI_MISO);
-    uint32_t spi_sclk = pinmap_peripheral(sclk, PinMap_SPI_SCLK);
-    uint32_t spi_ssel = pinmap_peripheral(ssel, PinMap_SPI_SSEL);
-    uint32_t spi_data = pinmap_merge(spi_mosi, spi_miso);
-    uint32_t spi_cntl = pinmap_merge(spi_sclk, spi_ssel);
-
-    obj->instance = pinmap_merge(spi_data, spi_cntl);
+    obj->instance = pinmap->peripheral;
     MBED_ASSERT((int)obj->instance != NC);
     obj->ssel_num = 0;
 
@@ -92,15 +90,42 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel
     }
 
     // pin out the spi pins
-    pinmap_pinout(mosi, PinMap_SPI_MOSI);
-    pinmap_pinout(miso, PinMap_SPI_MISO);
-    pinmap_pinout(sclk, PinMap_SPI_SCLK);
-    if (ssel != NC) {
-        pinmap_pinout(ssel, PinMap_SPI_SSEL);
-        obj->ssel_num = pinmap_function(ssel, PinMap_SPI_SSEL) >> SSELNUM_SHIFT;
+    pin_function(pinmap->mosi_pin, pinmap->mosi_function);
+    pin_mode(pinmap->mosi_pin, PullNone);
+    pin_function(pinmap->miso_pin, pinmap->miso_function);
+    pin_mode(pinmap->miso_pin, PullNone);
+    pin_function(pinmap->sclk_pin, pinmap->sclk_function);
+    pin_mode(pinmap->sclk_pin, PullNone);
+    if (pinmap->ssel_pin != NC) {
+        pin_function(pinmap->ssel_pin, pinmap->ssel_function);
+        pin_mode(pinmap->ssel_pin, PullNone);
+        obj->ssel_num = pinmap->ssel_function >> SSELNUM_SHIFT;
     }
 }
 
+void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
+{
+    // determine the SPI to use
+    uint32_t spi_mosi = pinmap_peripheral(mosi, PinMap_SPI_MOSI);
+    uint32_t spi_miso = pinmap_peripheral(miso, PinMap_SPI_MISO);
+    uint32_t spi_sclk = pinmap_peripheral(sclk, PinMap_SPI_SCLK);
+    uint32_t spi_ssel = pinmap_peripheral(ssel, PinMap_SPI_SSEL);
+    uint32_t spi_data = pinmap_merge(spi_mosi, spi_miso);
+    uint32_t spi_cntl = pinmap_merge(spi_sclk, spi_ssel);
+
+    int peripheral = (int)pinmap_merge(spi_data, spi_cntl);
+
+    // pin out the spi pins
+    int mosi_function = (int)pinmap_find_function(mosi, PinMap_SPI_MOSI);
+    int miso_function = (int)pinmap_find_function(miso, PinMap_SPI_MISO);
+    int sclk_function = (int)pinmap_find_function(sclk, PinMap_SPI_SCLK);
+    int ssel_function = (int)pinmap_find_function(ssel, PinMap_SPI_SSEL);
+
+    const spi_pinmap_t explicit_spi_pinmap = {peripheral, mosi, mosi_function, miso, miso_function, sclk, sclk_function, ssel, ssel_function};
+
+    SPI_INIT_DIRECT(obj, &explicit_spi_pinmap);
+}
+
 void spi_free(spi_t *obj)
 {
     SPI_Deinit(spi_address[obj->instance]);