DBGU.c //fifo

#include <string.h>
#include <stdbool.h>

#include "at91sam9263.h"
#include "DBGU.h"

struct FIFO fifo;

int DBGU_init(void) {
    AT91C_BASE_DBGU->DBGU_IDR = 0xFFFFFFFF; /* deactivate all DBGU interrupts */
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_RSTRX | AT91C_US_RXDIS; /* reset and turn off receiver */
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_RSTTX | AT91C_US_TXDIS; /* reset and turn off transmitter */
    AT91C_BASE_PIOC->PIO_ASR = AT91C_PC31_DTXD /* TxD */ | AT91C_PC30_DRXD; /* RxD */
    AT91C_BASE_PIOC->PIO_PDR = AT91C_PC31_DTXD /* TxD */ | AT91C_PC30_DRXD; /* RxD */
    AT91C_BASE_DBGU->DBGU_BRGR = PROCESSOR_CLOCK / (115200 * 16); /* throughput configuration */
    AT91C_BASE_DBGU->DBGU_MR = AT91C_US_CHMODE_NORMAL | AT91C_US_PAR_NONE; /* configure operation mode */
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_RXEN; // enable receiver
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_TXEN; // enable transmitter
    FIFO_Init(&fifo);
    return 0;
}

int dbgu_print_ascii() {

    char buffer;
    int counter = 0;

    while (FIFO_Get(&fifo, &buffer) == 1) {
        while (!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY)){} // wait intil Tx buffer busy – check TXRDY flag

        echo(&buffer);

        AT91C_BASE_DBGU->DBGU_THR = buffer; // write a single char to Transmitter Holding Register
        ++counter;
    }

    newLine();

    return counter;
}

int dbgu_read_ascii() {
    int counter = 0;

    while(1) {
        while (!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_RXRDY)){}; // wait until data available

        char buffer = AT91C_BASE_DBGU->DBGU_RHR & 0xFF; // read data from Receiver Holding Register

        if (buffer == RETURN)
            break;

        if (is_FIFO_full(&fifo)) {
            dbgu_print_warning("Overflow");
        } else {
            FIFO_Put(&fifo, buffer);
        }

        ++counter;
    }

    return counter;
}

void dbgu_print_warning(char *message) {

    newLine();

    int i;
    for (i = 0; i < strlen(message); ++i) {
        while (!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY)){}
        AT91C_BASE_DBGU->DBGU_THR = message[i];
    }

    newLine();

}

void newLine() {
    while (!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY)){}
    AT91C_BASE_DBGU->DBGU_THR = '\n';
    while (!(AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY)){}
    AT91C_BASE_DBGU->DBGU_THR = '\r';
}

void FIFO_Init (struct FIFO *fifo){
    fifo->head = 0;
    fifo->tail = 0;
}

bool is_FIFO_full(struct FIFO *fifo) {
    return ((fifo->tail-fifo->head)==1 || (fifo->head-fifo->tail)==BUFFERSIZE);
}

int FIFO_Put (struct FIFO *fifo, char Data){
    if (is_FIFO_full(fifo)) {
        return -1; /* FIFO overflow */
    };

    fifo->buffer[fifo->head] = Data;
    fifo->head = (fifo->head + 1) & BUFFERSIZE;
    return 1; /* Put 1 byte successfully */
}

int FIFO_Get (struct FIFO *fifo, char *Data){
    if (fifo->head!=fifo->tail){
        *Data = fifo->buffer[fifo->tail];
        fifo->tail = (fifo->tail + 1) & BUFFERSIZE;
        return 1; /* Get 1 byte successfully */
    }
    else return -1; /* No data in FIFO */
}

void echo(char *string) {
    int i;

    for(i = 0; i < strlen(string); i++) {
        if (string[i] >= 'a' && string[i] <= 'z') {
            charToUpper(&string[i]);
        }
        else if (string[i] >= 'A' && string[i] <= 'Z') {
            charToLower(&string[i]);
        }
    }
}

void charToUpper(char *sign) {
    *sign -= 32;
}

void charToLower(char *sign) {
    *sign += 32;
}