Diff: targets/TARGET_ublox/TARGET_HI2110/serial_api.c

Revision:

150:02e0a0aed4ec

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/targets/TARGET_ublox/TARGET_HI2110/serial_api.c	Tue Nov 08 17:45:16 2016 +0000
@@ -0,0 +1,819 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2016 u-blox
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* The serial driver connects UART HW to mbed and also associates the UART
+ * HW with physical pins.  Any physical pin can be linked to any UART,
+ * however the mbed serial port initialisation API makes no mention of
+ * which UART HW is to be used (only the pins) and hence the driver needs
+ * to make some decisions for itself.
+ *
+ * There are two and a half UARTs on the chip: UART0, UART1 and a
+ * lower-power, receive-only UART that is clocked from 32 kHz and can
+ * therefore be awake while the rest of the chip is sleeping peacefully.
+ * This provides maximal power saving, however the LP UART can only run
+ * at 9600 bits/s (which is quite sufficient for all NB-IoT needs).
+ *
+ * So, if the baud rate is 9600 the driver code configures the LP UART
+ * for Rx and UART0 for Tx. If the baud rate is not 9600 then it configures
+ * UART0 for both Rx and Tx.  Unless... the Tx pin is the pin UART1_TX (it
+ * is an mbed convention to use the Tx pin), which is p6, in which case UART1
+ * is configured instead.  This latter is not the normal case as this pin
+ * is intended to be used as a GPIO.
+ *
+ * If the baud rate is changed the driver reconfigures to match.
+ *
+ * TODO: implement asynchronous and flow control APIs.
+ */
+
+#include "mbed_assert.h"
+#include "serial_api.h"
+#include "pinmap.h"
+
+#include "cmsis.h"
+
+/* ----------------------------------------------------------------
+ * MACROS
+ * ----------------------------------------------------------------*/
+
+/* Registers banks for the standard UARTs */
+#define UART0_REG (*(volatile uart_ctrl_t *) UART0_BASE)
+#define UART1_REG (*(volatile uart_ctrl_t *) UART1_BASE)
+
+/* Masks for the UART control bits in the reset and clock enable registers */
+#define UART0_CTRL  (1 << 3)
+#define UART1_CTRL  (1 << 4)
+#define UARTLP_CTRL (1 << 6)
+
+/* Convert number of data bits to register values */
+#define MIN_NUM_UART_DATA_BITS 5
+#define MAX_NUM_UART_DATA_BITS 8
+#define REGISTER_DATA_BITS(x) ((x) - MIN_NUM_UART_DATA_BITS)
+
+/* Number of stop bits */
+#define NUM_UART_STOP_BITS_1 1
+#define NUM_UART_STOP_BITS_2 2
+
+/* ----------------------------------------------------------------
+ * TYPES
+ * ----------------------------------------------------------------*/
+
+/* Enum to identify the interrupt to the UART handler */
+typedef enum {
+    IRQ_UART_ID_0_AND_LP,
+    IRQ_UART_ID_1,
+    NUM_IRQ_IDS
+} irq_uart_id_t;
+
+/* ----------------------------------------------------------------
+ * GLOBAL VARIABLES
+ * ----------------------------------------------------------------*/
+
+/* The IRQ configuration variables, set up and named by mbed */
+static uint32_t serial_irq_ids[NUM_IRQ_IDS] = {0};
+static uart_irq_handler irq_handler = NULL;
+
+/* RTX needs these */
+int stdio_uart_inited = 0;
+serial_t stdio_uart;
+
+/* ----------------------------------------------------------------
+ * FUNCTION PROTOTYPES
+ * ----------------------------------------------------------------*/
+
+static void init_config(serial_t *obj);
+static void deinit_config(serial_t *obj);
+static void set_baud(serial_t *obj, uint32_t baud_rate);
+static void irq_enable(serial_t *obj);
+static void irq_disable(serial_t *obj);
+
+/* ----------------------------------------------------------------
+ * NON-API FUNCTIONS
+ * ----------------------------------------------------------------*/
+
+/* Initialise the given serial config by setting the pin functions
+ * and then resetting the relevant HW */
+static void init_config(serial_t *obj)
+{
+    uint32_t x;
+
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            pin_function(obj->rx_pin, PIN_FUNCTION_LP_UART);
+            pin_function(obj->tx_pin, PIN_FUNCTION_UART0_TXD);
+            CLKEN_REG_BITSET = UARTLP_CTRL | UART0_CTRL;
+            obj->reg_base = &UART0_REG;
+            obj->index = IRQ_UART_ID_0_AND_LP;
+            /* Reset the LPUART and UART0 HW */
+            /* NOTE: RESET_REG_BITTOG doesn't have the desired
+             * effect, need to use BITSET and then BITCLR */
+            RESET_REG_BITSET |= 1ul << 6;
+            RESET_REG_BITCLR |= 1ul << 6;
+            RESET_REG_BITSET |= 1ul << 3;
+            RESET_REG_BITCLR |= 1ul << 3;
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        {
+            pin_function(obj->rx_pin, PIN_FUNCTION_UART0_RXD);
+            pin_function(obj->tx_pin, PIN_FUNCTION_UART0_TXD);
+            CLKEN_REG_BITSET = UART0_CTRL;
+            obj->reg_base = &UART0_REG;
+            obj->index = IRQ_UART_ID_0_AND_LP;
+            /* Reset the UART0 HW */
+            RESET_REG_BITSET |= 1ul << 3;
+            RESET_REG_BITCLR |= 1ul << 3;
+        }
+        break;
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            pin_function(obj->rx_pin, PIN_FUNCTION_UART1_RXD);
+            pin_function(obj->tx_pin, PIN_FUNCTION_UART1_TXD);
+            CLKEN_REG_BITSET = UART1_CTRL;
+            obj->reg_base = &UART1_REG;
+            obj->index = IRQ_UART_ID_1;
+            /* Reset the UART1 HW */
+            RESET_REG_BITSET |= 1ul << 4;
+            RESET_REG_BITCLR |= 1ul << 4;
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+
+    /* Tickle the UART control register to make sure it is updated */
+    x = obj->reg_base->UARTLCR_H;
+    obj->reg_base->UARTLCR_H = x;
+
+    /* Set the FIFO. The meaning of the three FIFO interrupt-level
+     * bits are as follows:
+     *
+     * 0 = 1/8 full
+     * 1 = 1/4 full
+     * 2 = 1/2 full
+     * 3 = 3/4 full
+     * 4 = 7/8 full
+     *
+     * Set up the Rx FIFO to be used fully (but we will also set
+     * a timeout to get immediate notice) and also the Tx FIFO
+     * to be fully used. */
+     obj->reg_base->UARTIFLS = (obj->reg_base->UARTIFLS & ~(0x07 << 0)) | (4 << 0);
+     obj->reg_base->UARTIFLS = (obj->reg_base->UARTIFLS & ~(0x07 << 3)) | (4 << 3);
+     obj->reg_base->UARTLCR_H |= 1 << 4;
+
+    /* Enable for Tx and Rx (TODO: add CTS when we add flow control) */
+    obj->reg_base->UARTCR |= (1 << 8) | (1 << 9);
+
+    /* Now enable it */
+    obj->reg_base->UARTCR |= 1 << 0;
+
+    obj->format_set = false;
+    obj->baud_rate = 0;
+    obj->irq_rx_setting = IRQ_NOT_SET;
+    obj->irq_tx_setting = IRQ_NOT_SET;
+}
+
+/* Release a serial port */
+static void deinit_config(serial_t *obj)
+{
+    pin_function(obj->rx_pin, PIN_FUNCTION_UNCLAIMED);
+    pin_function(obj->tx_pin, PIN_FUNCTION_UNCLAIMED);
+
+    /* Disable UART */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    /* Flush transmit FIFO */
+    obj->reg_base->UARTLCR_H = 0;
+
+    /* Disable everything */
+    obj->reg_base->UARTCR = 0;
+
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            CLKEN_REG_BITCLR = UARTLP_CTRL | UART0_CTRL;
+            LP_UART_CTRL &= ~(0xF << 20); /* Disable all LP interrupts */
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        {
+            CLKEN_REG_BITCLR = UART0_CTRL;
+        }
+        break;
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            CLKEN_REG_BITCLR = UART1_CTRL;
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+
+    obj->config = MAX_NUM_SERIAL_CONFIGS;
+    obj->reg_base = NULL;
+}
+
+/* Set the baud rate for either of the two (non-LP) UARTS */
+static void set_baud(serial_t *obj, uint32_t baud_rate)
+{
+    uint32_t baud_rate_divider_i;
+    uint32_t baud_rate_divider_f;
+    uint32_t remainder;
+    uint32_t core_clock;
+    uint32_t x;
+
+    /* Baud rate divider calculation:
+     *
+     * The integer part is: clock / (16 * baud)
+     *
+     * The fractional part is:  round (decimal_part * 64),
+     * ...where decimal part is, for example, 0.085
+     *
+     * decimal_part is: remainder / (16 * baud),
+     * ...where: remainder = core_clock % (baud * 16),
+     *
+     * So the fractional part becomes:
+     * round (decimal_part * 64) = round (remainder * 64 / (16 * baud)) = round (remainder * 4 / baud)
+     */
+
+    /* Get the mean clock frequency */
+    core_clock = (CLK_FREQ_HIGHTARGET >> 1) + (CLK_FREQ_LOWTARGET >> 1);
+    /* Work out the actual clock frequency */
+    core_clock = (core_clock * CLOCKS_REFERENCE_CLOCK_FREQ) / (((CLK_FREQ_NREFCLKS + 1) & 0xFFFF) * (CLK_GATE_SYS & 0xFF));
+    baud_rate_divider_i = core_clock / (baud_rate << 4);
+    remainder = core_clock % (baud_rate << 4);
+    baud_rate_divider_f = ((remainder << 3) / baud_rate) >> 1;
+    /* Round it */
+    baud_rate_divider_f += ((remainder << 3) / baud_rate) & 1;
+
+    /* Disable UART while writing to control registers */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    obj->reg_base->UARTIBRD = baud_rate_divider_i;
+    obj->reg_base->UARTFBRD = baud_rate_divider_f;
+
+    /* Make IBRD and FBRD update */
+    x = obj->reg_base->UARTLCR_H;
+    obj->reg_base->UARTLCR_H = x;
+
+    /* Now enable the UART again */
+    obj->reg_base->UARTCR |= 1 << 0;
+}
+
+/* Set the NVIC bits */
+static void irq_enable(serial_t *obj)
+{
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            NVIC_EnableIRQ(UART0_IRQn);
+            NVIC_EnableIRQ(LPUART_IRQn);
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        {
+            NVIC_EnableIRQ(UART0_IRQn);
+        }
+        break;
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            NVIC_EnableIRQ(UART1_IRQn);
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+}
+
+/* Unset the NVIC bits */
+static void irq_disable(serial_t *obj)
+{
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            NVIC_DisableIRQ(UART0_IRQn);
+            NVIC_DisableIRQ(LPUART_IRQn);
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        {
+            NVIC_DisableIRQ(UART0_IRQn);
+        }
+        break;
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            NVIC_DisableIRQ(UART1_IRQn);
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+}
+
+/* UART0 IRQ */
+void IRQ7_UART0_Handler()
+{
+    uint32_t id = serial_irq_ids[IRQ_UART_ID_0_AND_LP];
+
+    /* Check Rx and Rx Timeout bit */
+    if (UART0_REG.UARTMIS & ((1 << 4) | (1 << 6))) {
+        if (id != 0) {
+            irq_handler(id, RxIrq);
+            /* Reading the character clears the interrupt,
+             * no way to protect against another arriving
+             * while processing one */
+        }
+    }
+    /* Check Tx bit */
+    if (UART0_REG.UARTMIS & (1 << 5)) {
+        if (id != 0) {
+            irq_handler(id, TxIrq);
+        }
+        /* Not sure what clears the interrupt so clear it explicitly */
+        NVIC_ClearPendingIRQ(UART1_IRQn);
+    }
+}
+
+/* UART1 IRQ */
+void IRQ8_UART1_Handler()
+{
+    uint32_t id = serial_irq_ids[IRQ_UART_ID_1];
+
+    /* Check Rx and Rx Timeout bit */
+    if (UART1_REG.UARTMIS & ((1 << 4) | (1 << 6))) {
+        if (id != 0) {
+            irq_handler(id, RxIrq);
+        }
+        /* Reading the character clears the interrupt,
+         * no way to protect against another arriving
+         * while processing one */
+    }
+    /* Check Tx bit */
+    if (UART1_REG.UARTMIS & (1 << 5)) {
+        if (id != 0) {
+            irq_handler(id, TxIrq);
+        }
+        /* Not sure what clears the interrupt so clear it explicitly */
+        NVIC_ClearPendingIRQ(UART1_IRQn);
+    }
+}
+
+/* LP UART IRQ, receive only */
+void IRQ16_LPUART_Handler()
+{
+    uint32_t id = serial_irq_ids[IRQ_UART_ID_0_AND_LP];
+
+    if (id != 0) {
+        irq_handler(id, RxIrq);
+
+        /* Another character might have arrived while
+         * we are processing the last, so
+         * check status bits 8 to 10 again and pend
+         * interrupt if there's something there */
+        if (((LP_UART_STATUS >> 8) & 0x07) != 0) {
+            NVIC_SetPendingIRQ(LPUART_IRQn);
+        } else {
+            LP_UART_CTRL |= 1 << 27; /* Clear the interrupt */
+        }
+    }
+}
+
+/* ----------------------------------------------------------------
+ * MBED API CALLS: SETUP FUNCTIONS
+ * ----------------------------------------------------------------*/
+
+void serial_init(serial_t *obj, PinName tx, PinName rx)
+{
+    uint32_t clock = CLK_FREQ_DIG_CLKS;
+
+    /* There are two and a half UARTs on the chip. The normal
+     * configuration is to use the LP_UART for Rx and UART0 for
+     * Tx.  This gives maximal power saving in that the chip can
+     * wake up on receipt of data. However, this only works if the
+     * data rate is 9600 because that's the only data rate that
+     * the 32 kHz (i.e. RTC) clock driving the LP UART can support.
+     *
+     * So, if the data rate is 9600, use the LP_UART/UART0
+     * combination, otherwise use UART0 for both Rx and Tx.  However,
+     * we don't know the data rate at this point so assume LP_UART
+     * (as this works at the default baud rate) and we can change
+     * our minds later.
+     *
+     * There is another serial port, UART1, which is normally used
+     * by the modem processor to send out debug.  We only initialise
+     * that here if the Tx pin is UART1_TX. */
+
+    /* Wait for the clock to be stable */
+    while ((clock < CLK_FREQ_LOWTARGET) || (clock > CLK_FREQ_HIGHTARGET)) {
+        clock = CLK_FREQ_DIG_CLKS;
+    }
+
+    if (tx == UART1_TX) {
+        /* Use UART1 for Rx and Tx */
+        obj->config = SERIAL_CONFIG_UART1_RX_UART1_TX;
+    } else {
+        /* Use LP_UART for Rx, UART0 for Tx */
+        obj->config = SERIAL_CONFIG_UARTLP_RX_UART0_TX;
+    }
+
+    obj->rx_pin = rx;
+    obj->tx_pin = tx;
+    init_config(obj);
+
+    /* TODO: set rx pin Pull mode ? */
+
+    /* set default baud rate and format */
+    serial_baud(obj, 9600);
+    serial_format(obj, 8, ParityNone, 1);
+
+    if (tx == UART0_TX) {
+        /* The UART0 pins are the stdio pins */
+        stdio_uart_inited = 1;
+        stdio_uart = *obj;
+    }
+}
+
+void serial_free(serial_t *obj)
+{
+    if (obj->tx_pin == UART0_TX) {
+        stdio_uart_inited = 0;
+    }
+
+    serial_irq_ids[obj->index] = 0;
+
+    /* Release the port HW */
+    deinit_config(obj);
+}
+
+void serial_baud(serial_t *obj, int baudrate)
+{
+    bool switch_port_config = false;
+    bool format_set = obj->format_set;
+    uint8_t stop_bits = obj->format.stop_bits;
+    uint8_t data_bits = obj->format.data_bits;
+    SerialParity parity = (SerialParity) obj->format.parity;
+    irq_setting_t irq_rx_setting = obj->irq_rx_setting;
+    irq_setting_t irq_tx_setting = obj->irq_tx_setting;
+
+    if ((obj->config == SERIAL_CONFIG_UARTLP_RX_UART0_TX) && (baudrate != 9600)) {
+        /* If we were on LP UART but the baud rate is not 9600 then
+         * switch to the standard UART (as the LP UART can't go any higher
+         * because it's clocked from 32 kHz) */
+        deinit_config(obj);
+        obj->config = SERIAL_CONFIG_UART0_RX_UART0_TX;
+        init_config(obj);
+        switch_port_config = true;
+    } else if ((obj->config == SERIAL_CONFIG_UART0_RX_UART0_TX) && (baudrate == 9600)) {
+        /* If we were on UART0 but the baud rate is 9600 then switch to the
+         * LP UART for receive */
+        deinit_config(obj);
+        obj->config = SERIAL_CONFIG_UARTLP_RX_UART0_TX;
+        init_config(obj);
+        switch_port_config = true;
+    }
+
+    /* Disable UART while writing to control registers */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    if (switch_port_config) {
+        /* If the port was switched, switch the port configuration also */
+        if (format_set) {
+            /* This serial port has been previously set up so switch the
+             * settings across to this new configuration */
+            serial_format(obj, data_bits, parity, stop_bits);
+        }
+        if (irq_rx_setting != IRQ_NOT_SET) {
+            /* Do the same for Rx interrupts, if they were set */
+            serial_irq_set(obj, RxIrq, (irq_rx_setting == IRQ_ON));
+        }
+        if (irq_tx_setting != IRQ_NOT_SET) {
+            /* Do the same for Tx interrupts, if they were set */
+            serial_irq_set(obj, TxIrq, (irq_tx_setting == IRQ_ON));
+        }
+    }
+
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            /* Set LP UART to 9600 (numerator 75 (0x4B), denominator 256 (00 == 256)) */
+            LP_UART_CTRL = (LP_UART_CTRL & ~0xFFFF) | 0x004B;
+            set_baud(obj, baudrate);
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            set_baud(obj, baudrate);
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+
+    /* Enable the UART again */
+    obj->reg_base->UARTCR |= 1 << 0;
+
+    obj->baud_rate = baudrate;
+}
+
+void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits)
+{
+    bool lp_also = false;
+
+    MBED_ASSERT(data_bits >= MIN_NUM_UART_DATA_BITS);
+    MBED_ASSERT(data_bits <= MAX_NUM_UART_DATA_BITS);
+    MBED_ASSERT(stop_bits >= NUM_UART_STOP_BITS_1);
+    MBED_ASSERT(stop_bits <= NUM_UART_STOP_BITS_2);
+
+    /* The LP UART is different to UARTs 0 and 1 so deal with it
+     * explicitly when required */
+    if (obj->config == SERIAL_CONFIG_UARTLP_RX_UART0_TX) {
+        lp_also = true;
+    }
+
+    /* Disable UART while writing to control registers */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    /* Set data bits (bits 5 and 6 of the UART0/1 register, bits 18 and 19 of the LP UART register) */
+    obj->reg_base->UARTLCR_H = (obj->reg_base->UARTLCR_H & ~(0x03 << 5)) | (REGISTER_DATA_BITS(data_bits) << 5);
+    if (lp_also) {
+        LP_UART_CTRL = (LP_UART_CTRL & ~(0x03 << 18)) | (REGISTER_DATA_BITS(data_bits) << 18);
+    }
+    obj->format.data_bits = (uint8_t) data_bits;
+
+    /* Set stop bits (bit 7 of the UART0/1 register) (there is no such setting for the LP UART) */
+    if (stop_bits == NUM_UART_STOP_BITS_1) {
+        /* Clear 2-stop-bits bit */
+        obj->reg_base->UARTLCR_H &= ~(1 << 7);
+    } else {
+        /* Set 2-stop-bits bit */
+        obj->reg_base->UARTLCR_H |= 1 << 7;
+    }
+    obj->format.stop_bits = (uint8_t) stop_bits;
+
+    /* Set parity */
+    switch (parity) {
+        case ParityNone:
+        {
+            /* Disable parity */
+            obj->reg_base->UARTLCR_H &= ~0x02;
+            if (lp_also)
+            {
+                LP_UART_CTRL &= ~(1 << 24);
+            }
+        }
+        break;
+        case ParityOdd:
+        {
+            /* Set even bit and enable parity */
+            obj->reg_base->UARTLCR_H = (obj->reg_base->UARTLCR_H | (1 << 3)) | (1 << 2);
+            if (lp_also)
+            {
+                LP_UART_CTRL |= (1 << 24) | (1 << 25);
+            }
+        }
+        break;
+        case ParityEven:
+        {
+            /* Clear even bit and enable parity */
+            obj->reg_base->UARTLCR_H = (obj->reg_base->UARTLCR_H & ~(1 << 3)) | (1 << 2);
+            if (lp_also)
+            {
+                LP_UART_CTRL &= ~(1 << 25);
+                LP_UART_CTRL |= 1 << 24;
+            }
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+
+    /* Enable the UART again */
+    obj->reg_base->UARTCR |= 1 << 0;
+
+    obj->format.parity = (uint8_t) parity;
+    obj->format_set = true;
+}
+
+/* ----------------------------------------------------------------
+ * MBED API CALLS: INTERRUPT FUNCTIONS
+ * ----------------------------------------------------------------*/
+
+void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
+{
+    irq_handler = handler;
+    serial_irq_ids[obj->index] = id;
+}
+
+void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
+{
+    bool lp_also = false;
+
+    if (obj->config == SERIAL_CONFIG_UARTLP_RX_UART0_TX) {
+        lp_also = true;
+    }
+
+    /* Disable UART while writing to control registers */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    if (enable) {
+        switch (irq) {
+            case RxIrq:
+            {
+                /* Bit 4 for Rx and bit 6 for Rx Timeout */
+                obj->reg_base->UARTIMSC |= (1 << 4) | (1 << 6);
+                if (lp_also)
+                {
+                    /* "Word Received" IRQ */
+                    LP_UART_CTRL |= 1 << 23;
+                }
+                obj->irq_rx_setting = IRQ_ON;
+                irq_enable(obj);
+            }
+            break;
+            case TxIrq:
+            {
+                /* Bit 5 */
+                obj->reg_base->UARTIMSC |= 1 << 5;
+                obj->irq_tx_setting = IRQ_ON;
+                irq_enable(obj);
+            }
+            break;
+            default:
+            {
+                MBED_ASSERT(false);
+            }
+            break;
+        }
+    } else {
+        switch (irq) {
+            case RxIrq:
+            {
+                /* Bit 4  for Rx and bit 6 for Rx Timeout */
+                obj->reg_base->UARTIMSC &= ~((1 << 4) | (1 << 6));
+                if (lp_also)
+                {
+                    /* "Word Received" IRQ */
+                    LP_UART_CTRL &= ~(1 << 23);
+                }
+                obj->irq_rx_setting = IRQ_OFF;
+            }
+            break;
+            case TxIrq:
+            {
+                /* Bit 5 */
+                obj->reg_base->UARTIMSC &= ~(1 << 5);
+                obj->irq_tx_setting = IRQ_OFF;
+            }
+            break;
+            default:
+            {
+                MBED_ASSERT(false);
+            }
+            break;
+        }
+
+        if ((obj->irq_rx_setting == IRQ_OFF) && (obj->irq_tx_setting == IRQ_OFF)) {
+            irq_disable(obj);
+        }
+    }
+
+    /* Enable the UART again */
+    obj->reg_base->UARTCR |= 1 << 0;
+}
+
+/* ----------------------------------------------------------------
+ * MBED API CALLS: TRANSMIT AND RECEIVE FUNCTIONS
+ * ----------------------------------------------------------------*/
+
+int serial_getc(serial_t *obj)
+{
+    uint8_t data = 0;
+
+    /* Block until there is data to read */
+    while (!serial_readable(obj)) {}
+
+    /* Read the data */
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            data = (uint8_t) LP_UART_DATA;
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            data = (uint8_t) obj->reg_base->UARTDR;
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+
+    return (int) data;
+}
+
+void serial_putc(serial_t *obj, int c)
+{
+    /* Block until there is room to write */
+    while (!serial_writable(obj)) {}
+
+    /* Write the data */
+    obj->reg_base->UARTDR = (uint8_t) c;
+}
+
+int serial_readable(serial_t *obj)
+{
+    bool readable = false;
+
+    switch (obj->config) {
+        case SERIAL_CONFIG_UARTLP_RX_UART0_TX:
+        {
+            /* Check the status register, bits 8 to 10 indicate
+             * the number of Rx bytes (make sure it's the status
+             * register not the data register as a read from that
+             * register would clear the Rx interrupt) */
+            readable = (((LP_UART_STATUS >> 8) & 0x07) != 0);
+        }
+        break;
+        case SERIAL_CONFIG_UART0_RX_UART0_TX:
+        case SERIAL_CONFIG_UART1_RX_UART1_TX:
+        {
+            /* Check the Rx FIFO Empty bit */
+            readable = ((obj->reg_base->UARTFR & (1 << 4)) != (1 << 4));
+        }
+        break;
+        default:
+        {
+            MBED_ASSERT(false);
+        }
+        break;
+    }
+
+    return (int) readable;
+}
+
+int serial_writable(serial_t *obj)
+{
+    /* Check the "UART TX FIFO full" bit:
+     * only if this is 0 can we transmit  */
+    return (obj->reg_base->UARTFR & (1 << 5)) != (1 << 5);
+}
+
+void serial_break_set(serial_t *obj)
+{
+    /* Disable UART while writing to control registers */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    /* Set bit 1 of the line control register */
+    obj->reg_base->UARTLCR_H |= 1 << 0;
+
+    /* Enable the UART again */
+    obj->reg_base->UARTCR |= 1 << 0;
+}
+
+void serial_break_clear(serial_t *obj)
+{
+    /* Disable UART while writing to control registers */
+    obj->reg_base->UARTCR &= ~(1 << 0);
+
+    /* Clear bit 1 of the line control register */
+    obj->reg_base->UARTLCR_H &= ~(1 << 0);
+
+    /* Enable the UART again */
+    obj->reg_base->UARTCR |= 1 << 0;
+}