DBGU.c //inter

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

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

unsigned int overrun_error_counter = 0;
unsigned int framing_error_counter = 0;
unsigned int parity_error_counter = 0;
unsigned int other_dgbu_interrupt_counter = 0;
unsigned int other_interrupt_counter = 0;
struct FIFO fifo;

int DBGU_init(void) {
    AT91C_BASE_DBGU->DBGU_IDR = 0xFFFFFFFF;
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_RSTRX | AT91C_US_RXDIS;
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_RSTTX | AT91C_US_TXDIS;
    AT91C_BASE_PIOC->PIO_ASR = AT91C_PC31_DTXD | AT91C_PC30_DRXD;
    AT91C_BASE_PIOC->PIO_PDR = AT91C_PC31_DTXD | AT91C_PC30_DRXD;
    AT91C_BASE_DBGU->DBGU_BRGR = PROCESSOR_CLOCK / (THROUGHPUT * 16);
    AT91C_BASE_DBGU->DBGU_MR = AT91C_US_CHMODE_NORMAL | AT91C_US_PAR_NONE;
    DBGU_interrupt_init();
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_RXEN;
    AT91C_BASE_DBGU->DBGU_CR = AT91C_US_TXEN;
    FIFO_Init(&fifo);
    return 0;
}

void DBGU_interrupt_init() {
    AT91C_BASE_AIC->AIC_IDCR = 1 << AT91C_ID_SYS;
    AT91C_BASE_AIC->AIC_SVR[AT91C_ID_SYS] = (unsigned int) interruptHandler;
    AT91C_BASE_AIC->AIC_SMR[AT91C_ID_SYS] = (AT91C_AIC_SRCTYPE & AT91C_AIC_SRCTYPE_INT_EDGE_TRIGGERED) | (AT91C_AIC_SRCTYPE & AT91C_AIC_SRCTYPE_EXT_POSITIVE_EDGE) | (AT91C_AIC_PRIOR & AT91C_AIC_PRIOR_HIGHEST);
    AT91C_BASE_AIC->AIC_ICCR = 1 << AT91C_ID_SYS;
    AT91C_BASE_AIC->AIC_IECR = 1 << AT91C_ID_SYS;
    AT91C_BASE_DBGU->DBGU_IER = AT91C_US_OVRE | AT91C_US_FRAME | AT91C_US_PARE | AT91C_US_RXRDY;
}

void interruptHandler() {

    if (AT91C_BASE_DBGU->DBGU_CSR & AT91C_BASE_DBGU->DBGU_IMR) {

        if ((AT91C_BASE_DBGU->DBGU_IMR & AT91C_US_TXRDY) && (AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY)) {
            dbgu_print_string();
        }
        else if ((AT91C_BASE_DBGU->DBGU_IMR & AT91C_US_RXRDY) && (AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_RXRDY)) {
            dbgu_read_ascii();
        }
        else if ((AT91C_BASE_DBGU->DBGU_IMR & AT91C_US_OVRE) && (AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_OVRE)) {
            overrun_error_counter += 1;
        }
        else if ((AT91C_BASE_DBGU->DBGU_IMR & AT91C_US_FRAME) && (AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_FRAME)) {
            framing_error_counter += 1;
        }
        else if ((AT91C_BASE_DBGU->DBGU_IMR & AT91C_US_PARE) && (AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_PARE)) {
            parity_error_counter += 1;
        }
        else {
            other_dgbu_interrupt_counter += 1;
        }
    }
    else {
        other_interrupt_counter += 1;
    }
}

void dbgu_print_string() {
    char buffer;

    if (FIFO_Get(&fifo, &buffer) == SUCCESS) {
        AT91C_BASE_DBGU->DBGU_THR = buffer;
    }
    else {
         newLine();
         AT91C_BASE_DBGU->DBGU_IDR = AT91C_US_TXRDY;
    }

}

void dbgu_read_ascii() {

    char buffer = AT91C_BASE_DBGU->DBGU_RHR & 0xFF;

    if (buffer == KEY_RETURN) {
        AT91C_BASE_DBGU->DBGU_IER = AT91C_US_TXRDY;
    }
    else {
        if (is_FIFO_full(&fifo)) {
            dbgu_print_warning("Overflow");
        }
        else {
            FIFO_Put(&fifo, buffer);
        }
    }
}

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 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 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 FAIL;
    };

    fifo->buffer[fifo->head] = Data;
    fifo->head = (fifo->head + 1) & BUFFERSIZE;
    return SUCCESS;
}

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 SUCCESS;
    }
    else return FAIL;
}

void invertCase(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;
}