/* KallistiOS ##version##

   sio.c

   Copyright (C)2004 Dan Potter

*/

#include <dc/scif.h>

#include <kos/thread.h>

#include <lwip/lwip.h>

#include "lwip/sio.h"

/*

  This implements the serial I/O interface for lwIP to use PPP for serial

  connections. This hooks straight to dbgio right now but could easily

  be swapped over to use the modem stuff.

 */

static volatile int sio_abort = ;

sio_fd_t sio_open(u8_t foo) {

    int i;

    sio_abort = ;

    // Clear out anything in the buffer already

    i = ;

    while (scif_read() != -)

        i++;

    if (i)

        printf("sio: cleared %d initial chars\n", i);

    return NULL;

}

void sio_send(u8_t ch, sio_fd_t foo) {

    scif_write(ch);

    scif_flush();

}

u8_t sio_recv(sio_fd_t foo) {

    int ch;

    do {

        ch = scif_read();

        if (ch == -)

            thd_sleep();

    } while (ch == - && !sio_abort);

    sio_abort = ;

    return ch;

}

// I *think* this is right, but sio_* seems to be totally

// undocumented like so many things in lwIP.

u32_t sio_read(sio_fd_t foo, u8_t *outbuf, u32_t bufmax) {

    int i, ch;

    for (i=; i<bufmax && !sio_abort; i++) {

        ch = scif_read();

        if (ch == -) {

            if (i == ) {

                thd_sleep();

                i--;

                continue;

            } else

                break;

        }

        outbuf[i] = ch;

    }

    sio_abort = ;

    return i;

}

// Ditto on the comment for sio_read.

u32_t sio_write(sio_fd_t foo, u8_t *buf, u32_t buflen) {

    int i;

    for (i=; i<buflen && !sio_abort; i++)

        scif_write(buf[i]);

    scif_flush();

    sio_abort = ;

    return buflen;

}

void sio_read_abort(sio_fd_t foo) {

    sio_abort = ;

    printf("sio_read_abort called\n");

    while (sio_abort)

        thd_sleep();

}

/**

 * Reads from the serial device.

 *

 * @param fd serial device handle

 * @param data pointer to data buffer for receiving

 * @param len maximum length (in bytes) of data to receive

 * @return number of bytes actually received - may be 0 if aborted by sio_read_abort

 *

 * @note This function will block until data can be received. The blocking

 * can be cancelled by calling sio_read_abort().

 */

u32_t sio_read(sio_fd_t fd, u8_t *data, u32_t len)

{

    if(len >= )

    {

        if(fd.UartNo == )

        {

            while(USART_GetITStatus(USART1, USART_IT_RXNE) == RESET) {Delay();}

            {

                *data =(u8)USART_ReceiveData(USART1);

                return ;

            }

        }

        else if(fd.UartNo == )

        {

            while(USART_GetITStatus(USART3, USART_IT_RXNE) == RESET)

            {

                *data =(u8)USART_ReceiveData(USART3);

                return ;

            }

        }

        else if(fd.UartNo == )

        {

            while(USART_GetITStatus(UART5, USART_IT_RXNE) == RESET)

            {

                *data =(u8)USART_ReceiveData(UART5);

                return ;

            }

        }

        else if(fd.UartNo == )

        {

            while(USART_GetITStatus(USART6, USART_IT_RXNE) == RESET)

            {

                *data =(u8)USART_ReceiveData(USART6);

                return ;

            }

        }

    }

    return ;

}

#if SLIP_USE_RX_THREAD

/**

 * The SLIP input thread.

 *

 * Feed the IP layer with incoming packets

 *

 * @param nf the lwip network interface structure for this slipif

 */

static void

slipif_loop_thread(void *nf)

{

  u8_t c;

  struct netif *netif = (struct netif *)nf;

  struct slipif_priv *priv = (struct slipif_priv *)netif->state;

  while () {

    if (sio_tryread(priv->sd, &c, ) > ) {

      slipif_rxbyte_input(netif, c);

    }

  }

}

#endif /* SLIP_USE_RX_THREAD */

/**

  * @brief  Inserts a delay time.

  * @param  nCount: number of Ticks to delay.

  * @retval None

  */

void Delay(uint32_t nCount)

{

  vTaskDelay(nCount);

}