/**
 * 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 <stdlib.h>
#include "os/mynewt.h"
#include "hal/hal_uart.h"
#include "bsp/bsp.h"
#include "mcu/mips_hal.h"
#include "mcu/pps.h"

#include <xc.h>

#define UxMODE(U)           (base_address[U][0x0 / 0x4])
#define UxMODESET(U)        (base_address[U][0x8 / 0x4])
#define UxSTA(U)            (base_address[U][0x10 / 0x4])
#define UxTXREG(U)          (base_address[U][0x20 / 0x4])
#define UxRXREG(U)          (base_address[U][0x30 / 0x4])
#define UxBRG(U)            (base_address[U][0x40 / 0x4])

static volatile uint32_t* base_address[UART_CNT] = {
    (volatile uint32_t *)_UART1_BASE_ADDRESS,
    (volatile uint32_t *)_UART2_BASE_ADDRESS,
    (volatile uint32_t *)_UART3_BASE_ADDRESS,
    (volatile uint32_t *)_UART4_BASE_ADDRESS,
    (volatile uint32_t *)_UART5_BASE_ADDRESS,
    (volatile uint32_t *)_UART6_BASE_ADDRESS
};

struct hal_uart {
    volatile uint8_t u_rx_stall:1;
    volatile uint8_t u_rx_data;
    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;
    const struct mips_uart_cfg *u_pins;
};
static struct hal_uart uarts[UART_CNT];

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)
{
    uarts[port].u_rx_func = rx_func;
    uarts[port].u_tx_func = tx_func;
    uarts[port].u_tx_done = tx_done;
    uarts[port].u_func_arg = arg;
    return 0;
}

static void
uart_disable_tx_int(int port)
{
    switch (port) {
    case 0:
        IEC3CLR = _IEC3_U1TXIE_MASK;
        break;
    case 1:
        IEC4CLR = _IEC4_U2TXIE_MASK;
        break;
    case 2:
        IEC4CLR = _IEC4_U3TXIE_MASK;
        break;
    case 3:
        IEC5CLR = _IEC5_U4TXIE_MASK;
        break;
    case 4:
        IEC5CLR = _IEC5_U5TXIE_MASK;
        break;
    case 5:
        IEC5CLR = _IEC5_U6TXIE_MASK;
        break;
    }
}

static void
uart_enable_tx_int(int port)
{
    switch (port) {
    case 0:
        IEC3SET = _IEC3_U1TXIE_MASK;
        break;
    case 1:
        IEC4SET = _IEC4_U2TXIE_MASK;
        break;
    case 2:
        IEC4SET = _IEC4_U3TXIE_MASK;
        break;
    case 3:
        IEC5SET = _IEC5_U4TXIE_MASK;
        break;
    case 4:
        IEC5SET = _IEC5_U5TXIE_MASK;
        break;
    case 5:
        IEC5SET = _IEC5_U6TXIE_MASK;
        break;
    }
}

static void
uart_disable_rx_int(int port)
{
    switch (port) {
    case 0:
        IEC3CLR = _IEC3_U1RXIE_MASK;
        break;
    case 1:
        IEC4CLR = _IEC4_U2RXIE_MASK;
        break;
    case 2:
        IEC4CLR = _IEC4_U3RXIE_MASK;
        break;
    case 3:
        IEC5CLR = _IEC5_U4RXIE_MASK;
        break;
    case 4:
        IEC5CLR = _IEC5_U5RXIE_MASK;
        break;
    case 5:
        IEC5CLR = _IEC5_U6RXIE_MASK;
        break;
    }
}

static void
uart_enable_rx_int(int port)
{
    switch (port) {
    case 0:
        IEC3SET = _IEC3_U1RXIE_MASK;
        break;
    case 1:
        IEC4SET = _IEC4_U2RXIE_MASK;
        break;
    case 2:
        IEC4SET = _IEC4_U3RXIE_MASK;
        break;
    case 3:
        IEC5SET = _IEC5_U4RXIE_MASK;
        break;
    case 4:
        IEC5SET = _IEC5_U5RXIE_MASK;
        break;
    case 5:
        IEC5SET = _IEC5_U6RXIE_MASK;
        break;
    }
}

static void
uart_receive_ready(int port)
{
    uarts[port].u_rx_data = UxRXREG(port);

    int c = uarts[port].u_rx_func(uarts[port].u_func_arg,
                                    uarts[port].u_rx_data);
    if (c < 0) {
        uart_disable_rx_int(port);
        uarts[port].u_rx_stall = 1;
    }
}

static void
uart_transmit_ready(int port)
{
    int c;

    while(!(UxSTA(port) & _U1STA_UTXBF_MASK)) {
        c = uarts[port].u_tx_func(uarts[port].u_func_arg);
        if (c < 0) {
            uart_disable_tx_int(port);

            /* call tx done cb */
            if (uarts[port].u_tx_done) {
                uarts[port].u_tx_done(uarts[port].u_func_arg);
            }
            break;
        }

        UxTXREG(port) = (uint32_t)c & 0xff;
    }
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART1_RX_VECTOR))) uart_1_rx_isr(void)
{
    uart_receive_ready(0);
    IFS3CLR = _IFS3_U1RXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART1_TX_VECTOR))) uart_1_tx_isr(void)
{
    uart_transmit_ready(0);
    IFS3CLR = _IFS3_U1TXIF_MASK;
}


void
__attribute__((interrupt(IPL1AUTO), vector(_UART2_RX_VECTOR))) uart_2_rx_isr(void)
{
    uart_receive_ready(1);
    IFS4CLR = _IFS4_U2RXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART2_TX_VECTOR))) uart_2_tx_isr(void)
{
    uart_transmit_ready(1);
    IFS4CLR = _IFS4_U2TXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART3_RX_VECTOR))) uart_3_rx_isr(void)
{
    uart_receive_ready(2);
    IFS4CLR = _IFS4_U3RXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART3_TX_VECTOR))) uart_3_tx_isr(void)
{
    uart_transmit_ready(2);
    IFS4CLR = _IFS4_U3TXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART4_RX_VECTOR))) uart_4_rx_isr(void)
{
    uart_receive_ready(3);
    IFS5CLR = _IFS5_U4RXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART4_TX_VECTOR))) uart_4_tx_isr(void)
{
    uart_transmit_ready(3);
    IFS5CLR = _IFS5_U4TXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART5_RX_VECTOR))) uart_5_rx_isr(void)
{
    uart_receive_ready(4);
    IFS5CLR = _IFS5_U5RXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART5_TX_VECTOR))) uart_5_tx_isr(void)
{
    uart_transmit_ready(4);
    IFS5CLR = _IFS5_U5TXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART6_RX_VECTOR))) uart_6_rx_isr(void)
{
    uart_receive_ready(5);
    IFS5CLR = _IFS5_U6RXIF_MASK;
}

void
__attribute__((interrupt(IPL1AUTO), vector(_UART6_TX_VECTOR))) uart_6_tx_isr(void)
{
    uart_transmit_ready(5);
    IFS5CLR = _IFS5_U6TXIF_MASK;
}

void
hal_uart_start_rx(int port)
{
    if (uarts[port].u_rx_stall) {
        /* recover saved data */
        uint32_t sr;
        __HAL_DISABLE_INTERRUPTS(sr);
        int c = uarts[port].u_rx_func(uarts[port].u_func_arg,
                                        uarts[port].u_rx_data);
        if (c >= 0) {
            uarts[port].u_rx_stall = 0;
            /* enable RX interrupt */
            uart_enable_rx_int(port);
        }
        __HAL_ENABLE_INTERRUPTS(sr);
    }
}

void
hal_uart_start_tx(int port)
{
    uart_enable_tx_int(port);
}

void
hal_uart_blocking_tx(int port, uint8_t data)
{
    /* wait for transmit holding register to be empty */
    while(!(UxSTA(port) & _U1STA_TRMT_MASK)) {
    }

    UxTXREG(port) = data;
}

int
hal_uart_init(int port, void *arg)
{
    if (port >= UART_CNT) {
        return -1;
    }

    uarts[port].u_pins = arg;

    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)
{
    uint32_t peripheral_clk = MYNEWT_VAL(CLOCK_FREQ) / 2;

    // check input
    if ((databits < 8) || (databits > 9) || (stopbits < 1) || (stopbits > 2)) {
        return -1;
    }

    /* XXX: flow control currently unsupported */
    (void) flow_ctl;
    uarts[port].u_rx_stall = 0;

    uint16_t mode = _U1MODE_BRGH_MASK | (stopbits >> 1);
    switch (parity) {
    case HAL_UART_PARITY_NONE:
        if (databits == 9) {
            mode |= _U1MODE_PDSEL_MASK;
        }
        break;
    case HAL_UART_PARITY_ODD:
        if (databits == 9) { // PIC does not do 9 bit data + parity.
            return -1;
        }
        mode |= _U1MODE_PDSEL1_MASK;
        break;
    case HAL_UART_PARITY_EVEN:
        if (databits == 9) {
           return -1;
        }
        mode |= _U1MODE_PDSEL0_MASK;
        break;
    default:
        return -1;
    }

    /* Configure TX/RX pins */
    if (uarts[port].u_pins) {
        int ret = 0;
        switch(port) {
        case 0:
            ret += pps_configure_output(uarts[port].u_pins->tx, U1TX_OUT_FUNC);
            ret += pps_configure_input(uarts[port].u_pins->rx, U1RX_IN_FUNC);
            break;
        case 1:
            ret += pps_configure_output(uarts[port].u_pins->tx, U2TX_OUT_FUNC);
            ret += pps_configure_input(uarts[port].u_pins->rx, U2RX_IN_FUNC);
            break;
        case 2:
            ret += pps_configure_output(uarts[port].u_pins->tx, U3TX_OUT_FUNC);
            ret += pps_configure_input(uarts[port].u_pins->rx, U3RX_IN_FUNC);
            break;
        case 3:
            ret += pps_configure_output(uarts[port].u_pins->tx, U4TX_OUT_FUNC);
            ret += pps_configure_input(uarts[port].u_pins->rx, U4RX_IN_FUNC);
            break;
        case 4:
            ret += pps_configure_output(uarts[port].u_pins->tx, U5TX_OUT_FUNC);
            ret += pps_configure_input(uarts[port].u_pins->rx, U5RX_IN_FUNC);
            break;
        case 5:
            ret += pps_configure_output(uarts[port].u_pins->tx, U6TX_OUT_FUNC);
            ret += pps_configure_input(uarts[port].u_pins->rx, U6RX_IN_FUNC);
            break;
        default:
            return -1;
        }
        if (ret) {
            return -1;
        }
    }

    uint16_t divisor = peripheral_clk / (4 * baudrate) - 1;

    /* disable */
    UxMODE(port) = 0;
    __asm__("nop");
    UxBRG(port) = divisor;
    UxMODE(port) = mode;
    UxSTA(port) = _U1STA_URXEN_MASK | _U1STA_UTXEN_MASK;

    switch (port) {
    case 0:
        /* clear RX interrupt flag */
        IFS3CLR = _IFS3_U1RXIF_MASK;

        /* enable RX interrupt */
        IEC3SET = _IEC3_U1RXIE_MASK;

        /* set rx interrupt priority */
        IPC28CLR = _IPC28_U1RXIP_MASK;
        IPC28SET = (1 << _IPC28_U1RXIP_POSITION); // priority 1
        /* set rx interrupt subpriority */
        IPC28CLR = _IPC28_U1RXIS_MASK;
        IPC28SET = (0 << _IPC28_U1RXIS_POSITION); // subpriority 0

        /* set tx interrupt priority */
        IPC28CLR = _IPC28_U1TXIP_MASK;
        IPC28SET = (1 << _IPC28_U1TXIP_POSITION); // priority 1
        /* set tx interrupt subpriority */
        IPC28CLR = _IPC28_U1TXIS_MASK;
        IPC28SET = (0 << _IPC28_U1TXIS_POSITION); // subpriority 0
        break;
    case 1:
        /* clear RX interrupt flag */
        IFS4CLR = _IFS4_U2RXIF_MASK;

        /* enable RX interrupt */
        IEC4SET = _IEC4_U2RXIE_MASK;

        /* set rx interrupt priority */
        IPC36CLR = _IPC36_U2RXIP_MASK;
        IPC36SET = (1 << _IPC36_U2RXIP_POSITION); // priority 1
        /* set rx interrupt subpriority */
        IPC36CLR = _IPC36_U2RXIS_MASK;
        IPC36SET = (0 << _IPC36_U2RXIS_POSITION); // subpriority 0

        /* set tx interrupt priority */
        IPC36CLR = _IPC36_U2TXIP_MASK;
        IPC36SET = (1 << _IPC36_U2TXIP_POSITION); // priority 1
        /* set tx interrupt subpriority */
        IPC36CLR = _IPC36_U2TXIS_MASK;
        IPC36SET = (0 << _IPC36_U2TXIS_POSITION); // subpriority 0
        break;
    case 2:
        /* clear RX interrupt flag */
        IFS4CLR = _IFS4_U3RXIF_MASK;

        /* enable RX interrupt */
        IEC4SET = _IEC4_U3RXIE_MASK;

        /* set rx interrupt priority */
        IPC39CLR = _IPC39_U3RXIP_MASK;
        IPC39SET = (1 << _IPC39_U3RXIP_POSITION); // priority 1
        /* set rx interrupt subpriority */
        IPC39CLR = _IPC39_U3RXIS_MASK;
        IPC39SET = (0 << _IPC39_U3RXIS_POSITION); // subpriority 0

        /* set tx interrupt priority */
        IPC39CLR = _IPC39_U3TXIP_MASK;
        IPC39SET = (1 << _IPC39_U3TXIP_POSITION); // priority 1
        /* set tx interrupt subpriority */
        IPC39CLR = _IPC39_U3TXIS_MASK;
        IPC39SET = (0 << _IPC39_U3TXIS_POSITION); // subpriority 0
        break;
    case 3:
        /* clear RX interrupt flag */
        IFS5CLR = _IFS5_U4RXIF_MASK;

        /* enable RX interrupt */
        IEC5SET = _IEC5_U4RXIE_MASK;

        /* set rx interrupt priority */
        IPC42CLR = _IPC42_U4RXIP_MASK;
        IPC42SET = (1 << _IPC42_U4RXIP_POSITION); // priority 1
        /* set rx interrupt subpriority */
        IPC42CLR = _IPC42_U4RXIS_MASK;
        IPC42SET = (0 << _IPC42_U4RXIS_POSITION); // subpriority 0

        /* set tx interrupt priority */
        IPC43CLR = _IPC43_U4TXIP_MASK;
        IPC43SET = (1 << _IPC43_U4TXIP_POSITION); // priority 1
        /* set tx interrupt subpriority */
        IPC43CLR = _IPC43_U4TXIS_MASK;
        IPC43SET = (0 << _IPC43_U4TXIS_POSITION); // subpriority 0
        break;
    case 4:
        /* clear RX interrupt flag */
        IFS5CLR = _IFS5_U5RXIF_MASK;

        /* enable RX interrupt */
        IEC5SET = _IEC5_U5RXIE_MASK;

        /* set rx interrupt priority */
        IPC45CLR = _IPC45_U5RXIP_MASK;
        IPC45SET = (1 << _IPC45_U5RXIP_POSITION); // priority 1
        /* set rx interrupt subpriority */
        IPC45CLR = _IPC45_U5RXIS_MASK;
        IPC45SET = (0 << _IPC45_U5RXIS_POSITION); // subpriority 0

        /* set tx interrupt priority */
        IPC45CLR = _IPC45_U5TXIP_MASK;
        IPC45SET = (1 << _IPC45_U5TXIP_POSITION); // priority 1
        /* set tx interrupt subpriority */
        IPC45CLR = _IPC45_U5TXIS_MASK;
        IPC45SET = (0 << _IPC45_U5TXIS_POSITION); // subpriority 0
        break;
    case 5:
        /* clear RX interrupt flag */
        IFS5CLR = _IFS5_U6RXIF_MASK;

        /* enable RX interrupt */
        IEC5SET = _IEC5_U6RXIE_MASK;

        /* set rx interrupt priority */
        IPC47CLR = _IPC47_U6RXIP_MASK;
        IPC47SET = (1 << _IPC47_U6RXIP_POSITION); // priority 1
        /* set rx interrupt subpriority */
        IPC47CLR = _IPC47_U6RXIS_MASK;
        IPC47SET = (0 << _IPC47_U6RXIS_POSITION); // subpriority 0

        /* set tx interrupt priority */
        IPC47CLR = _IPC47_U6TXIP_MASK;
        IPC47SET = (1 << _IPC47_U6TXIP_POSITION); // priority 1
        /* set tx interrupt subpriority */
        IPC47CLR = _IPC47_U6TXIS_MASK;
        IPC47SET = (0 << _IPC47_U6TXIS_POSITION); // subpriority 0
        break;
    }

    UxMODESET(port) = _U1MODE_ON_MASK;

    return 0;
}

int
hal_uart_close(int port)
{
    if (port >= UART_CNT) {
        return -1;
    }

    UxMODE(port) = 0;
    uart_disable_rx_int(port);

    return 0;
}