debug-uart.c

/* vi: set noai ts=2 sw=2 expandtab: */

#include <debug-uart.h>
#include <string.h>
#include <core/pm.h>
#include <lib/assert.h>
#include <app_util_platform.h>
#include <dev/uart.h>

#ifndef DBG_XMIT_BUFFER_LEN
#define DBG_XMIT_BUFFER_LEN 1024
#endif

struct dbg_uart_state_t {
  const struct uart_t *uart;
  uint8_t *volatile xmit_buffer_head;
  uint8_t *volatile xmit_buffer_tail;
  uint8_t dma_size;
  uint8_t write_overrun;
  uint8_t xmit_buffer[DBG_XMIT_BUFFER_LEN];
};

struct dbg_uart_state_t dbg_uart_state;
#define XMIT_BUFFER_END(s) (&(s)->xmit_buffer[DBG_XMIT_BUFFER_LEN])

static void dbg_uart_event_hander(const struct uart_t *uart, void *data);

void dbg_setup()
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  s->xmit_buffer_head = s->xmit_buffer;
  s->xmit_buffer_tail = s->xmit_buffer;
}

static uint8_t
update_dma(void)
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  unsigned bytes;

  if (s->xmit_buffer_tail == s->xmit_buffer_head)
    return 0;

  if (s->xmit_buffer_head < s->xmit_buffer_tail)
    bytes = s->xmit_buffer_tail - s->xmit_buffer_head;
  else
    bytes = XMIT_BUFFER_END(s) - s->xmit_buffer_head;

  /* Activate DMA channel for TX */
  if (bytes) {
    if (bytes > 255)
      bytes = 255;
    UartStartBasicTx(s->uart, s->xmit_buffer_head, bytes, dbg_uart_event_hander, NULL);
  }

  return bytes;
}

static void dbg_uart_event_hander(const struct uart_t *uart, void *data)
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  CRITICAL_REGION_ENTER();
  s->xmit_buffer_head += s->dma_size;
  if (s->xmit_buffer_head == XMIT_BUFFER_END(s))
    s->xmit_buffer_head = s->xmit_buffer;
  dbg_uart_state.dma_size = update_dma();
  CRITICAL_REGION_EXIT();
}

unsigned int
dbg_send_bytes(const uint8_t *seq, unsigned int len)
{
  /* Since each of the pointers should be read atomically
     there's no need to disable interrupts */
  struct dbg_uart_state_t *s = &dbg_uart_state;
  uint8_t *head = s->xmit_buffer_head;
  uint8_t *tail = s->xmit_buffer_tail;

  if (tail >= head) {
    /* Free space wraps */
    unsigned int xfer_len = XMIT_BUFFER_END(s) - tail;
    unsigned int free = DBG_XMIT_BUFFER_LEN - (tail - head) - 1;

    if (len > free)
      len = free;
    if (xfer_len < len) {
      memcpy(tail, seq, xfer_len);
      seq += xfer_len;
      xfer_len = len - xfer_len;
      memcpy(s->xmit_buffer, seq, xfer_len);
      tail = s->xmit_buffer + xfer_len;
    } else {
      memcpy(tail, seq, len);
      tail += len;
      if (tail == XMIT_BUFFER_END(s))
        tail = s->xmit_buffer;
    }
  } else {
    /* Free space continuous */
    unsigned int free = (head - tail) - 1;
    if (len > free)
      len = free;
    memcpy(tail, seq, len);
    tail += len;
  }

  if (s->uart) {
    /* Start DMA */
    CRITICAL_REGION_ENTER();
    s->xmit_buffer_tail = tail;
    if (!dbg_uart_state.dma_size)
      dbg_uart_state.dma_size = update_dma();
    CRITICAL_REGION_EXIT();
  }

  return len;
}

void
dbg_putchar(const char ch)
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  if (s->write_overrun) {
    if (dbg_send_bytes((const uint8_t*)"^", 1) != 1)
      return;
  }
  s->write_overrun = 0;
  if (dbg_send_bytes((const uint8_t*)&ch, 1) != 1) {
    s->write_overrun = 1;
  }
}

void
dbg_blocking_putchar(const char ch)
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  if (s->write_overrun) {
    while (dbg_send_bytes((const uint8_t*)"^", 1) != 1)
      pm_relax();
  }
  s->write_overrun = 0;
  while (dbg_send_bytes((const uint8_t*)&ch, 1) != 1)
    pm_relax();
}

void
dbg_drain()
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  while(s->xmit_buffer_tail != s->xmit_buffer_head)
    pm_relax();
}

void
dbg_panic(void)
{
}

void
dbg_uart_set_uart(const struct uart_t *uart)
{
  struct dbg_uart_state_t *s = &dbg_uart_state;
  s->uart = uart;
}