AVR Freaks

The approach you outline has worked for me. Maybe you need to show the code. Anyway here is an example reading line by line and it keeps up when sending a text file from a PC terminal program at 115200 baud. For testing I put a break point at the 

            n_lines = 0;

i.e., when 100 lines are read.

/Lars

#include <asf.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>

bool get_line(char* buffer, size_t buf_size, size_t timeout_ms);
void usart_read_callback(struct usart_module *const usart_module);
void configure_usart(void);
void configure_usart_callbacks(void);

struct usart_module usart_instance;
char line_buffer[120];
char done_buffer[120];
char rx_buffer;
volatile bool line_buffered = false;

void usart_read_callback(struct usart_module *const usart_module)
{
    static size_t line_idx = 0;
    if (line_idx > 0 || !isspace(rx_buffer)) {
        if (rx_buffer == '\r' || rx_buffer == '\n') {
            memcpy(done_buffer, line_buffer, line_idx);
            done_buffer[line_idx] = '\0';
            line_buffered = true;
            line_idx = 0;
        }
        else if (line_idx < sizeof(line_buffer) - 1) {
            line_buffer[line_idx++] = rx_buffer;
        }
    }
    usart_read_buffer_job(&usart_instance, (uint8_t*)&rx_buffer, 1);
}

bool get_line(char* buffer, size_t buf_size, size_t timeout_ms)
{
    while(!line_buffered) {
        if (timeout_ms == 0) {
            return false;
        }
        delay_ms(1);
        timeout_ms--;
    }	
    line_buffered = false;
    strncpy(buffer, done_buffer, buf_size);
    return true;
}

void configure_usart(void)
{
    struct usart_config config_usart;
    usart_get_config_defaults(&config_usart);

    config_usart.baudrate    = 115200;
    config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
    config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
    config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
    config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
    config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
    while (usart_init(&usart_instance, EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {
    }
    usart_enable(&usart_instance);
}

void configure_usart_callbacks(void)
{
    usart_register_callback(&usart_instance,
            usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);
    usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
}

char test_lines[100][80];
int main(void)
{
    system_init();
    delay_init();
    
    configure_usart();
    configure_usart_callbacks();
    system_interrupt_enable_global();
    usart_read_buffer_job(&usart_instance, (uint8_t*)&rx_buffer, 1);

    size_t n_lines = 0;
    while (true) {
        if (n_lines < 100) {
            if (get_line(test_lines[n_lines], sizeof(test_lines[n_lines]), 0)) {
                n_lines++;
            }
        }
        else {
            n_lines = 0;
        }
    }
}