/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

#include <assert.h>

#include "os/mynewt.h"
#include "hal/hal_uart.h"
#include "mcu/cmsis_nvic.h"
#include "bsp/bsp.h"

#include "nrf.h"
#include "mcu/nrf52_hal.h"


#define UARTE_INT_ENDTX		UARTE_INTEN_ENDTX_Msk
#define UARTE_INT_ENDRX		UARTE_INTEN_ENDRX_Msk
#define UARTE_CONFIG_PARITY	UARTE_CONFIG_PARITY_Msk
#define UARTE_CONFIG_HWFC	UARTE_CONFIG_HWFC_Msk
#define UARTE_ENABLE		UARTE_ENABLE_ENABLE_Enabled
#define UARTE_DISABLE       UARTE_ENABLE_ENABLE_Disabled

/*
 * Only one UART on NRF 52832.
 */
struct hal_uart {
    uint8_t u_open:1;
    uint8_t u_rx_stall:1;
    uint8_t u_tx_started:1;
    uint8_t u_rx_buf;
    uint8_t u_tx_buf[8];
    hal_uart_rx_char u_rx_func;
    hal_uart_tx_char u_tx_func;
    hal_uart_tx_done u_tx_done;
    void *u_func_arg;
};

#if defined(NRF52840_XXAA)
static struct hal_uart uart0;
static struct hal_uart uart1;
#else
static struct hal_uart uart0;
#endif

int
hal_uart_init_cbs(int port, hal_uart_tx_char tx_func, hal_uart_tx_done tx_done,
  hal_uart_rx_char rx_func, void *arg)
{
    struct hal_uart *u;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        u = &uart0;
    } else if (port == 1) {
        u = &uart1;
    } else {
        return -1;
    }
#else
    if (port != 0) {
        return -1;
    }
    u = &uart0;
#endif

    if (u->u_open) {
        return -1;
    }
    u->u_rx_func = rx_func;
    u->u_tx_func = tx_func;
    u->u_tx_done = tx_done;
    u->u_func_arg = arg;
    return 0;
}

static int
hal_uart_tx_fill_buf(struct hal_uart *u)
{
    int data;
    int i;

    for (i = 0; i < sizeof(u->u_tx_buf); i++) {
        data = u->u_tx_func(u->u_func_arg);
        if (data < 0) {
            break;
        }
        u->u_tx_buf[i] = data;
    }
    return i;
}

void
hal_uart_start_tx(int port)
{
    NRF_UARTE_Type *nrf_uart;
    struct hal_uart *u;
    int sr;
    int rc;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        nrf_uart = NRF_UARTE0;
        u = &uart0;
    } else if (port == 1) {
        nrf_uart = NRF_UARTE1;
        u = &uart1;
    } else {
        return;
    }
#else
    if (port != 0) {
        return;
    }
    nrf_uart = NRF_UARTE0;
    u = &uart0;
#endif

    __HAL_DISABLE_INTERRUPTS(sr);
    if (u->u_tx_started == 0) {
        rc = hal_uart_tx_fill_buf(u);
        if (rc > 0) {
            nrf_uart->INTENSET = UARTE_INT_ENDTX;
            nrf_uart->TXD.PTR = (uint32_t)&u->u_tx_buf;
            nrf_uart->TXD.MAXCNT = rc;
            nrf_uart->TASKS_STARTTX = 1;
            u->u_tx_started = 1;
        }
    }
    __HAL_ENABLE_INTERRUPTS(sr);
}

void
hal_uart_start_rx(int port)
{
    NRF_UARTE_Type *nrf_uart;
    struct hal_uart *u;
    int sr;
    int rc;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        nrf_uart = NRF_UARTE0;
        u = &uart0;
    } else if (port == 1) {
        nrf_uart = NRF_UARTE1;
        u = &uart1;
    } else {
        return;
    }
#else
    if (port != 0) {
        return;
    }
    nrf_uart = NRF_UARTE0;
    u = &uart0;
#endif

    if (u->u_rx_stall) {
        __HAL_DISABLE_INTERRUPTS(sr);
        rc = u->u_rx_func(u->u_func_arg, u->u_rx_buf);
        if (rc == 0) {
            u->u_rx_stall = 0;
            nrf_uart->TASKS_STARTRX = 1;
        }

        __HAL_ENABLE_INTERRUPTS(sr);
    }
}

void
hal_uart_blocking_tx(int port, uint8_t data)
{
    struct hal_uart *u;
    NRF_UARTE_Type *nrf_uart;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        nrf_uart = NRF_UARTE0;
        u = &uart0;
    } else if (port == 1) {
        nrf_uart = NRF_UARTE1;
        u = &uart1;
    } else {
        return;
    }
#else
    if (port != 0) {
        return;
    }
    nrf_uart = NRF_UARTE0;
    u = &uart0;
#endif

    if (!u->u_open) {
        return;
    }

    /* If we have started, wait until the current uart dma buffer is done */
    if (u->u_tx_started) {
        while (nrf_uart->EVENTS_ENDTX == 0) {
            /* Wait here until the dma is finished */
        }
    }

    nrf_uart->EVENTS_ENDTX = 0;
    nrf_uart->TXD.PTR = (uint32_t)&data;
    nrf_uart->TXD.MAXCNT = 1;
    nrf_uart->TASKS_STARTTX = 1;

    while (nrf_uart->EVENTS_ENDTX == 0) {
        /* Wait till done */
    }

    /* Stop the uart */
    nrf_uart->TASKS_STOPTX = 1;
}

static void
uart_irq_handler(NRF_UARTE_Type *nrf_uart, struct hal_uart *u)
{
    int rc;

    os_trace_isr_enter();

    if (nrf_uart->EVENTS_ENDTX) {
        nrf_uart->EVENTS_ENDTX = 0;
        rc = hal_uart_tx_fill_buf(u);
        if (rc > 0) {
            nrf_uart->TXD.PTR = (uint32_t)&u->u_tx_buf;
            nrf_uart->TXD.MAXCNT = rc;
            nrf_uart->TASKS_STARTTX = 1;
        } else {
            if (u->u_tx_done) {
                u->u_tx_done(u->u_func_arg);
            }
            nrf_uart->INTENCLR = UARTE_INT_ENDTX;
            nrf_uart->TASKS_STOPTX = 1;
            u->u_tx_started = 0;
        }
    }
    if (nrf_uart->EVENTS_ENDRX) {
        nrf_uart->EVENTS_ENDRX = 0;
        rc = u->u_rx_func(u->u_func_arg, u->u_rx_buf);
        if (rc < 0) {
            u->u_rx_stall = 1;
        } else {
            nrf_uart->TASKS_STARTRX = 1;
        }
    }
    os_trace_isr_exit();
}

static void
uart0_irq_handler(void)
{
    uart_irq_handler(NRF_UARTE0, &uart0);
}

#if defined(NRF52840_XXAA)
static void
uart1_irq_handler(void)
{
    uart_irq_handler(NRF_UARTE1, &uart1);
}
#endif

static uint32_t
hal_uart_baudrate(int baudrate)
{
    switch (baudrate) {
    case 1200:
        return UARTE_BAUDRATE_BAUDRATE_Baud1200;
    case 2400:
        return UARTE_BAUDRATE_BAUDRATE_Baud2400;
    case 4800:
        return UARTE_BAUDRATE_BAUDRATE_Baud4800;
    case 9600:
        return UARTE_BAUDRATE_BAUDRATE_Baud9600;
    case 19200:
        return UARTE_BAUDRATE_BAUDRATE_Baud19200;
    case 38400:
        return UARTE_BAUDRATE_BAUDRATE_Baud38400;
    case 57600:
        return UARTE_BAUDRATE_BAUDRATE_Baud57600;
    case 76800:
        return UARTE_BAUDRATE_BAUDRATE_Baud76800;
    case 115200:
        return UARTE_BAUDRATE_BAUDRATE_Baud115200;
    case 230400:
        return UARTE_BAUDRATE_BAUDRATE_Baud230400;
    case 460800:
        return UARTE_BAUDRATE_BAUDRATE_Baud460800;
    case 921600:
        return UARTE_BAUDRATE_BAUDRATE_Baud921600;
    case 1000000:
        return UARTE_BAUDRATE_BAUDRATE_Baud1M;
    default:
        return 0;
    }
}

int
hal_uart_init(int port, void *arg)
{
    struct nrf52_uart_cfg *cfg;
    NRF_UARTE_Type *nrf_uart;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        nrf_uart = NRF_UARTE0;
        NVIC_SetVector(UARTE0_UART0_IRQn, (uint32_t)uart0_irq_handler);
    } else if (port == 1) {
        nrf_uart = NRF_UARTE1;
        NVIC_SetVector(UARTE1_IRQn, (uint32_t)uart1_irq_handler);
    } else {
        return -1;
    }
#else
    if (port != 0) {
        return -1;
    }
    nrf_uart = NRF_UARTE0;
    NVIC_SetVector(UARTE0_UART0_IRQn, (uint32_t)uart0_irq_handler);
#endif

    cfg = (struct nrf52_uart_cfg *)arg;

    nrf_uart->PSEL.TXD = cfg->suc_pin_tx;
    nrf_uart->PSEL.RXD = cfg->suc_pin_rx;
    nrf_uart->PSEL.RTS = cfg->suc_pin_rts;
    nrf_uart->PSEL.CTS = cfg->suc_pin_cts;

    return 0;
}

int
hal_uart_config(int port, int32_t baudrate, uint8_t databits, uint8_t stopbits,
  enum hal_uart_parity parity, enum hal_uart_flow_ctl flow_ctl)
{
    struct hal_uart *u;
    uint32_t cfg_reg = 0;
    uint32_t baud_reg;
    NRF_UARTE_Type *nrf_uart;
    IRQn_Type irqnum;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        nrf_uart = NRF_UARTE0;
        irqnum = UARTE0_UART0_IRQn;
        u = &uart0;
    } else if (port == 1) {
        nrf_uart = NRF_UARTE1;
        irqnum = UARTE1_IRQn;
        u = &uart1;
    } else {
        return -1;
    }
#else
    if (port != 0) {
        return -1;
    }
    nrf_uart = NRF_UARTE0;
    irqnum = UARTE0_UART0_IRQn;
    u = &uart0;
#endif

    if (u->u_open) {
        return -1;
    }

    /*
     * pin config
     * UART config
     * nvic config
     * enable uart
     */
    if (databits != 8) {
        return -1;
    }
    if (stopbits != 1) {
        return -1;
    }

    switch (parity) {
    case HAL_UART_PARITY_NONE:
        break;
    case HAL_UART_PARITY_ODD:
        return -1;
    case HAL_UART_PARITY_EVEN:
        cfg_reg |= UARTE_CONFIG_PARITY;
        break;
    }

    switch (flow_ctl) {
    case HAL_UART_FLOW_CTL_NONE:
        break;
    case HAL_UART_FLOW_CTL_RTS_CTS:
        cfg_reg |= UARTE_CONFIG_HWFC;
        if (nrf_uart->PSEL.RTS == 0xffffffff ||
          nrf_uart->PSEL.CTS == 0xffffffff) {
            /*
             * Can't turn on HW flow control if pins to do that are not
             * defined.
             */
            assert(0);
            return -1;
        }
        break;
    }
    baud_reg = hal_uart_baudrate(baudrate);
    if (baud_reg == 0) {
        return -1;
    }
    nrf_uart->ENABLE = 0;
    nrf_uart->INTENCLR = 0xffffffff;
    nrf_uart->BAUDRATE = baud_reg;
    nrf_uart->CONFIG = cfg_reg;

    NVIC_EnableIRQ(irqnum);

    nrf_uart->ENABLE = UARTE_ENABLE;

    nrf_uart->INTENSET = UARTE_INT_ENDRX;
    nrf_uart->RXD.PTR = (uint32_t)&u->u_rx_buf;
    nrf_uart->RXD.MAXCNT = sizeof(u->u_rx_buf);
    nrf_uart->TASKS_STARTRX = 1;

    u->u_rx_stall = 0;
    u->u_tx_started = 0;
    u->u_open = 1;

    return 0;
}

int
hal_uart_close(int port)
{
    struct hal_uart *u;
    NRF_UARTE_Type *nrf_uart;

#if defined(NRF52840_XXAA)
    if (port == 0) {
        nrf_uart = NRF_UARTE0;
        u = &uart0;
    } else if (port == 1) {
        nrf_uart = NRF_UARTE1;
        u = &uart1;
    } else {
        return -1;
    }
#else
    if (port != 0) {
        return -1;
    }
    nrf_uart = NRF_UARTE0;
    u = &uart0;
#endif

    u->u_open = 0;
    nrf_uart->ENABLE = 0;
    nrf_uart->INTENCLR = 0xffffffff;
    return 0;
}