source: rc_os_nios2/atk2-sc1_1.3.2/obj/nios2_dev_rc/comuart.c@ 128

#include "Os.h"
#include "t_stdlib.h"
#include "prc_sil.h"
#include "comuart.h"

/*
 *  ƒŒƒWƒXƒ^ƒIƒtƒZƒbƒg
 */
#define UART_RXDATA_OFFSET      UINT_C(0x00)
#define UART_TXDATA_OFFSET      UINT_C(0x04)
#define UART_STATUS_OFFSET      UINT_C(0x08)
#define UART_CONTROL_OFFSET     UINT_C(0x0c)
#define UART_DIVISOR_OFFSET     UINT_C(0x10)

/*
 *  ƒŒƒWƒXƒ^ƒrƒbƒg’è‹`
 */
#define UART_STATUS_TRDY        UINT_C(0x0040)
#define UART_STATUS_RRDY        UINT_C(0x0080)

#define UART_CONTROL_ITRDY      UINT_C(0x0040)
#define UART_CONTROL_IRRDY      UINT_C(0x0080)

/*
 *  UART
 */
#define RxBUFF_SIZE 256
#define TxBUFF_SIZE 256

static uint8 s_rxbuff[RxBUFF_SIZE];
static uint8 s_txbuff[TxBUFF_SIZE];

static int s_rxbuff_tail;
static int s_rxbuff_head;
static int s_rxbuff_cnt;
static int s_txbuff_tail;
static int s_txbuff_head;
static int s_txbuff_cnt;

static boolean s_do_tx;


static void
ena_rx_int(void){
        sil_wrw_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET),
                                sil_rew_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET))
                                | UART_CONTROL_IRRDY);
}

static void
dis_rx_int(void){
        sil_wrw_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET),
                                sil_rew_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET))
                                & ~UART_CONTROL_IRRDY);
}

static void
ena_tx_int(void){
        sil_wrw_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET),
                                sil_rew_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET))
                                | UART_CONTROL_ITRDY);
}

static void
dis_tx_int(void){
        sil_wrw_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET),
                                sil_rew_iop((void *) (COMUART_BASE + UART_CONTROL_OFFSET))
                                & ~UART_CONTROL_ITRDY);
}

static void
comuart_putc(unsigned char c){
        sil_wrw_iop((void *) (COMUART_BASE + UART_TXDATA_OFFSET), (uint32) c);
}

static unsigned char
comuart_getc(void){
        return((uint8) sil_rew_iop((void *) (COMUART_BASE + UART_RXDATA_OFFSET)));
}

static boolean
comuart_getready(void)
{
        return((sil_rew_iop((void *) (COMUART_BASE + UART_STATUS_OFFSET)) & UART_STATUS_RRDY) != 0U);
}

static boolean
comuart_putready(void)
{
        return((sil_rew_iop((void *) (COMUART_BASE + UART_STATUS_OFFSET)) & UART_STATUS_TRDY) != 0U);
}

void
comuart_pputc(unsigned char c){
        while(!(comuart_putready())){}
        comuart_putc(c);
}

/*
 * ‰Šú‰»
 */
void
comuart_init(void)
{
        /*
         *  ŽóMŠ„ž‚Ý‹–‰Â
         */
        ena_rx_int();
}


/*
 * ŽóM‚µ‚½ƒf[ƒ^’· 
 */
int
comuart_get_rxcnt(void)
{
        return s_rxbuff_cnt;
}

/*
 *  ŽóM 
 */
boolean
comuart_receive(unsigned char *data, int len)
{
        boolean result = TRUE;
        int loop;

        SuspendOSInterrupts();
        if (s_rxbuff_cnt < len) {
                result = FALSE;
        }else {
                for(loop = 0; loop < len; loop++) {
                        *data++ = s_rxbuff[s_rxbuff_head++];
                        s_rxbuff_head = s_rxbuff_head % RxBUFF_SIZE;
                        s_rxbuff_cnt--;
                }
        }
        ResumeOSInterrupts();

        return result;
}

/*
 *  ‘—M
 */
boolean
comuart_send(const unsigned char *data, int len)
{
        int loop;
        char c;

        /* ‹ó‚«‚ª–³‚¯‚ê‚΃Gƒ‰[ */
        if (s_txbuff_cnt + len > TxBUFF_SIZE) {
                return FALSE;
        }

        /* ƒŠƒ“ƒOƒoƒbƒtƒ@‚ɃRƒs[ */
        for(loop = 0; loop < len; loop++){
                s_txbuff[s_txbuff_tail++] = *data++;
                s_txbuff_tail = s_txbuff_tail % TxBUFF_SIZE;
                s_txbuff_cnt++;
        }

        if (!(s_do_tx)) {
                SuspendOSInterrupts();
                /* ƒŠƒ“ƒOƒoƒbƒtƒ@‚©‚çŽæ‚èo‚µ‘—M */
                c = s_txbuff[s_txbuff_head++];
                s_txbuff_head = s_txbuff_head % TxBUFF_SIZE;
                s_txbuff_cnt--;
                s_do_tx = TRUE;
                comuart_putc(c);
                ResumeOSInterrupts();

                /* ŽóMŠ„ž‚Ý‹–‰Â */
                if(s_txbuff_cnt > 0){
                  ena_tx_int();
                }
        }

        return TRUE;
}

/*
 *  UART2Š„ž‚݃nƒ“ƒhƒ‰
 */
#define TASK_NONE  0xFFFFFFFF
static TaskType COMUartWaitTask = TASK_NONE;

/*
 *  Š„ž‚݃nƒ“ƒhƒ‰
 */
ISR(COMUART_Interrupt)
{
        char c;

        if (comuart_putready() != FALSE) {
                /* ‘—Mˆ— */
                if (s_txbuff_cnt == 0) {
                        /* ƒoƒbƒtƒ@‚ª‹ó */
                        s_do_tx = FALSE;
                        dis_tx_int();
                }
                else {
                        /* ƒoƒbƒtƒ@‚©‚çƒf[ƒ^‚ðŽæ‚èo‚µo—Í */
                        c = s_txbuff[s_txbuff_head++];
                        s_txbuff_head = s_txbuff_head % TxBUFF_SIZE;
                        s_txbuff_cnt--;
                        comuart_putc(c);
                        s_do_tx = TRUE;
                }
        }

        if (comuart_getready() != FALSE) {
                /* ŽóMˆ— */
                c = comuart_getc();

                if (s_rxbuff_cnt < RxBUFF_SIZE) {
                        s_rxbuff[s_rxbuff_tail++] = c;
                        s_rxbuff_tail = s_rxbuff_tail % RxBUFF_SIZE;
                        s_rxbuff_cnt++;
                }
                else {
                        com_error();
                }
                
                if (COMUartWaitTask != TASK_NONE) {
                        SetEvent(COMUartWaitTask, COMUartEvt);
                }
        }
}

/*
 *  UARTE2‚̃Cƒxƒ“ƒg‘Ò‚¿
 */
void
WaitCOMUartEvent(void) {

        TaskType task_id;
        GetTaskID(&task_id);

        COMUartWaitTask = task_id;
        if(comuart_get_rxcnt() == 0) {
                WaitEvent(COMUartEvt);
                ClearEvent(COMUartEvt);
        }
        COMUartWaitTask = TASK_NONE;
}