LCOM1920-T5G03

#ifndef TEST7_H_INCLUDED

#define TEST7_H_INCLUDED

#include "uart.h"

#endif //TEST7_H_INCLUDED

#define COM1_ADDR           0x3F8

#define COM2_ADDR           0x2F8

#define COM1_IRQ            4

#define COM2_IRQ            3

#define COM1_VECTOR         0x0C

#define COM2_VECTOR         0x0B

typedef enum {

    uart_parity_none = 0x0,

    uart_parity_odd  = 0x1,

    uart_parity_even = 0x3,

    uart_parity_par1 = 0x5,

    uart_parity_par0 = 0x7

} uart_parity;

    uart_parity parity              ;

int uart_get_char_poll   (int base_addr, uint8_t *p);

int uart_send_char_poll  (int base_addr, uint8_t  c);

int uart_send_memory_poll(int base_addr, void *str, size_t n);

        long parity = 0;

        unsigned char tx = 1;

        char *strings[] = {"Hello", "world"}; (void)strings;

        //if((r = ser_test_conf(COM1_ADDR))) return r;

        //if((r = ser_test_set(COM1_ADDR, bits, stop, parity, rate))) return r;

        printf("DONE\n");

		uint8_t c;

		if((ret = uart_get_char_poll(base_addr, &c))) return ret;

		while((char)c != '.'){

			printf("%c", (char)c);

			if((ret = uart_get_char_poll(base_addr, &c))) return ret;

		printf("%c\n", (char)c);

			size_t sz = strlen(strings[i]);

			if((ret = uart_send_memory_poll(base_addr, strings[i], sz))) return ret;

			if(i+1 != stringc) if((ret = uart_send_memory_poll(base_addr, " ", 1))) return ret;

		if((ret = uart_send_memory_poll(base_addr, ".", 1))) return ret;

#define UART_BITRATE                            115200

#define UART_WAIT                               20 //microseconds

#define UART_RBR                                0

#define UART_THR                                0

#define UART_IER                                1

#define UART_IIR                                2

#define UART_FCR                                2

#define UART_LCR                                3

#define UART_MCR                                4

#define UART_LSR                                5

#define UART_MSR                                6

#define UART_SR                                 7

#define UART_DLL                                0

#define UART_DLM                                1

/// LCR

#define UART_BITS_PER_CHAR_POS                  0

#define UART_STOP_BITS_POS                      2

#define UART_PARITY_POS                         3

#define UART_BREAK_CONTROL_POS                  6

#define UART_DLAB_POS                           7

#define UART_BITS_PER_CHAR                      (BIT(0) | BIT(1))

#define UART_STOP_BITS                          (BIT(2))

#define UART_PARITY                             (BIT(3) | BIT(4) | BIT(5))

#define UART_BREAK_CONTROL                      (BIT(6))

#define UART_DLAB                               (BIT(7))

#define UART_GET_BITS_PER_CHAR(n)               (((n)&UART_BITS_PER_CHAR) + 5)

#define UART_GET_STOP_BITS(n)                   (((n)&UART_STOP_BITS)? 2 : 1)

#define UART_GET_PARITY(n)                      (((n)&UART_PARITY       )>>UART_PARITY_POS       )

#define UART_GET_BREAK_CONTROL(n)               (((n)&UART_BREAK_CONTROL)>>UART_BREAK_CONTROL_POS)

#define UART_GET_DLAB(n)                        (((n)&UART_DLAB         )>>UART_DLAB_POS         )

#define UART_GET_DIV_LATCH(m,l)                 ((m)<<8 | (l))

#define UART_GET_DLL(n)                         ((n)&0xFF)

#define UART_GET_DLM(n)                         (((n)>>8)&0xFF)

/// IER

#define UART_INT_EN_RECEIVED_DATA_POS           0

#define UART_INT_EN_TRANSMITTER_EMPTY_POS       1

#define UART_INT_EN_RECEIVER_LINE_STAT_POS      2

#define UART_INT_EN_MODEM_STAT_POS              3

#define UART_INT_EN_RECEIVED_DATA               (BIT(0))

#define UART_INT_EN_TRANSMITTER_EMPTY           (BIT(1))

#define UART_INT_EN_RECEIVER_LINE_STAT          (BIT(2))

#define UART_INT_EN_MODEM_STAT                  (BIT(3))

#define UART_INT_EN_GET_RECEIVED_DATA(n)        (((n)&UART_INT_EN_RECEIVED_DATA     )>>UART_INT_EN_RECEIVED_DATA_POS     )

#define UART_INT_EN_GET_TRANSMITTER_EMPTY(n)    (((n)&UART_INT_EN_TRANSMITTER_EMPTY )>>UART_INT_EN_TRANSMITTER_EMPTY_POS )

#define UART_INT_EN_GET_RECEIVER_LINE_STAT(n)   (((n)&UART_INT_EN_RECEIVER_LINE_STAT)>>UART_INT_EN_RECEIVER_LINE_STAT_POS)

#define UART_INT_EN_GET_MODEM_STAT(n)           (((n)&UART_INT_EN_MODEM_STAT        )>>UART_INT_EN_MODEM_STAT_POS        )

/// LSR

#define UART_RECEIVER_READY_POS                 0

#define UART_TRANSMITTER_EMPTY_POS              5

#define UART_RECEIVER_READY                     (BIT(0))

#define UART_TRANSMITTER_EMPTY                  (BIT(5))

#define UART_GET_RECEIVER_READY(n)              (((n)&UART_RECEIVER_READY           )>>UART_RECEIVER_READY_POS           )

#define UART_GET_TRANSMITTER_EMPTY(n)           (((n)&UART_TRANSMITTER_EMPTY        )>>UART_TRANSMITTER_EMPTY_POS        )

    config->parity                 = UART_GET_PARITY            (config->lcr); if((config->parity & BIT(0)) == 0) config->parity = uart_parity_none;

    config->received_data_int      = UART_INT_EN_GET_RECEIVED_DATA     (config->ier);

    config->transmitter_empty_int  = UART_INT_EN_GET_TRANSMITTER_EMPTY (config->ier);

    config->receiver_line_stat_int = UART_INT_EN_GET_RECEIVER_LINE_STAT(config->ier);

    config->modem_stat_int         = UART_INT_EN_GET_MODEM_STAT        (config->ier);

    printf("%s configuration:\n", (config.base_addr == COM1_ADDR ? "COM1" : "COM2"));

    printf("\tLCR = 0x%X: %d bits per char\t %d stop bits\t", config.lcr, config.bits_per_char, config.stop_bits);

    if((config.parity&BIT(0)) == 0) printf("NO parity\n");

        case uart_parity_odd : printf("ODD parity\n"     ); break;

        case uart_parity_even: printf("EVEN parity\n"    ); break;

    printf("\tDLM = 0x%02X DLL=0x%02X: bitrate = %d bps\n", config.dlm, config.dll, UART_BITRATE/config.divisor_latch);

    printf("\tIER = 0x%02X: Rx interrupts: %s\tTx interrupts: %s\n", config.ier,

        (config.received_data_int     ? "ENABLED":"DISABLED"),

        (config.transmitter_empty_int ? "ENABLED":"DISABLED"));

    if((ret = uart_disable_divisor_latch(base_addr))) return ret;

/// PRIVATE

int uart_get_lsr(int base_addr, uint8_t *p){

    return util_sys_inb(base_addr+UART_LSR, p);

}

/**

 * @brief Get char from RBR.

 */

int uart_get_char(int base_addr, uint8_t *p){

    int ret;

    if((ret = uart_disable_divisor_latch(base_addr))) return ret;

    return util_sys_inb(base_addr+UART_RBR, p);

}

int uart_send_char(int base_addr, uint8_t c){

    int ret;

    if((ret = uart_disable_divisor_latch(base_addr))) return ret;

    if(sys_outb(base_addr, c)) return WRITE_ERROR;

    return SUCCESS;

}

int uart_receiver_ready(int base_addr){

    uint8_t lsr;

    if(uart_get_lsr(base_addr, &lsr)) return false;

    return UART_GET_RECEIVER_READY(lsr);

}

int uart_transmitter_empty(int base_addr){

    uint8_t lsr;

    if(uart_get_lsr(base_addr, &lsr)) return false;

    return UART_GET_TRANSMITTER_EMPTY(lsr);

}

///PUBLIC

int uart_get_char_poll(int base_addr, uint8_t *p){

    int ret;

    while(!uart_receiver_ready(base_addr)){}

    if((ret = uart_get_char(base_addr, p))) return ret;

    return SUCCESS;

}

int uart_send_char_poll(int base_addr, uint8_t  c){

    int ret;

    while(!uart_transmitter_empty(base_addr)){}

    if((ret = uart_send_char(base_addr, c))) return ret;

    return SUCCESS;

}

int uart_send_memory_poll(int base_addr, void *str, size_t n){

    int ret;

    uint8_t *p = str;

    for(size_t i = 0; i < n; ++i, ++p){

        if((ret = uart_send_char_poll(base_addr, *p))) return ret;

    }

    return SUCCESS;

}

# Serial port protocol

Transmission/reception is processed at 38400 bps, with chars of 8 bits and even parity.

## Transmission

Transmission is performed on request by the program. It is done in a synchronous fashion. When starting a transmission, reception interrupt notifications are suspended. On ending, reception interrupt notifications are re-activated.

### Transmission of a char

1. 1 polls the readiness of THR in intervals of 50 microseconds, one at the beginning and up to 10 retries (up to 11 polling operations, and 500 microseconds). If after all the retries 1 has not yet sent the char, transmission is aborted.

2. If the char is transmitted, 1 expects 2 to answer the same char for confirmation. 1 polls the fullness of RBR in intervals of 50 microseconds, one at the beginning and up to 10 retries. If after all the retries 1 has not yet received the answer, transmission is aborted.

3. If 1 gets the answer, it compares it with the char it sent. If they are different, go back to step 2.

4. If they are equal, 1 sends OK symbol 0xFF using only step 1., and char transmission is complete.

### Transmission of a string

If the string has more than 1024 chars, transmission is not even started.

1. For each char in the string, transmit them, plus a start symbol 0x80 and an end symbol 0xEF. If transmission fails for a given char, transmission of the string fails, and none of the following chars in the same transmission request are transmitted.

2. If all symbols are transmitted correctly, transmission is successfully terminated.

## Reception

Reception is made through interrupts. On a reception interrupt, 2 must handle the interrupt. On a reception interrupt, reception interrupt notifications are suspended, and on ending a reception notifications are re-activated.

### Reception of a char

1. Upon getting a reception interrupt, 2 grabs the char, and then polls the readiness of the THR in intervals of 50 microseconds, one at the beginning and up to 10 retries. If after 10 retries 2 has not sent the char, transmission is aborted.

2. If transmission is successful, 2 expects 1 to answer the OK symbol 0xFF, using only step 1. to get the OK. If the received symbol has less or equal to 4 bits set to 1, transmission is aborted.

3. If the received OK has at least 4 bits set to 1 then it is accepted.

### Reception of a string

1. 2 expects the first char to be the start char. If it is not, transmission is aborted.

2. If the first char is correct, all chars are received. If one of the char receptions fails (timeout), reception fails. If after receiving 1024 chars the end symbol is not received, transmission is aborted.

3. If all receptions are successful and the end symbol is received, transmission is successful.