mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-18 16:08:53 +09:00
![Marek Vasut](/assets/img/avatar_default.png)
Rework the emulation of serial console via JTAG from simple ad-hoc implementation of serial port routines to CONFIG_SERIAL_MULTI and enable CONFIG_SERIAL_MULTI unconditionally for blackfin. In order for the JTAG serial console to take precedence over all other serial ports available in system, implement override for default_serial_console call returning this JTAG serial console. This brings in a bit of a growth of size, but eventually will allow us to unconditionally enable CONFIG_SERIAL_MULTI throughout the whole U-Boot and maintain only one serial subsystem. Signed-off-by: Marek Vasut <marex@denx.de> Cc: Marek Vasut <marek.vasut@gmail.com> Cc: Tom Rini <trini@ti.com> Cc: Mike Frysinger <vapier@gentoo.org>
229 lines
4.4 KiB
C
229 lines
4.4 KiB
C
/*
|
|
* jtag-console.c - console driver over Blackfin JTAG
|
|
*
|
|
* Copyright (c) 2008-2010 Analog Devices Inc.
|
|
*
|
|
* Licensed under the GPL-2 or later.
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <malloc.h>
|
|
#include <stdio_dev.h>
|
|
#include <asm/blackfin.h>
|
|
|
|
#ifdef DEBUG
|
|
# define dprintf(...) serial_printf(__VA_ARGS__)
|
|
#else
|
|
# define dprintf(...) do { if (0) printf(__VA_ARGS__); } while (0)
|
|
#endif
|
|
|
|
static inline void dprintf_decode(const char *s, uint32_t len)
|
|
{
|
|
uint32_t i;
|
|
for (i = 0; i < len; ++i)
|
|
if (s[i] < 0x20 || s[i] >= 0x7f)
|
|
dprintf("\\%o", s[i]);
|
|
else
|
|
dprintf("%c", s[i]);
|
|
}
|
|
|
|
static inline uint32_t bfin_write_emudat(uint32_t emudat)
|
|
{
|
|
__asm__ __volatile__("emudat = %0;" : : "d"(emudat));
|
|
return emudat;
|
|
}
|
|
|
|
static inline uint32_t bfin_read_emudat(void)
|
|
{
|
|
uint32_t emudat;
|
|
__asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
|
|
return emudat;
|
|
}
|
|
|
|
#ifndef CONFIG_JTAG_CONSOLE_TIMEOUT
|
|
# define CONFIG_JTAG_CONSOLE_TIMEOUT 500
|
|
#endif
|
|
|
|
/* The Blackfin tends to be much much faster than the JTAG hardware. */
|
|
static bool jtag_write_emudat(uint32_t emudat)
|
|
{
|
|
static bool overflowed = false;
|
|
ulong timeout = get_timer(0);
|
|
while (bfin_read_DBGSTAT() & 0x1) {
|
|
if (overflowed)
|
|
return overflowed;
|
|
if (get_timer(timeout) > CONFIG_JTAG_CONSOLE_TIMEOUT)
|
|
overflowed = true;
|
|
}
|
|
overflowed = false;
|
|
bfin_write_emudat(emudat);
|
|
return overflowed;
|
|
}
|
|
/* Transmit a buffer. The format is:
|
|
* [32bit length][actual data]
|
|
*/
|
|
static void jtag_send(const char *raw_str, uint32_t len)
|
|
{
|
|
const char *cooked_str;
|
|
uint32_t i, ex;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
/* Ugh, need to output \r after \n */
|
|
ex = 0;
|
|
for (i = 0; i < len; ++i)
|
|
if (raw_str[i] == '\n')
|
|
++ex;
|
|
if (ex) {
|
|
char *c = malloc(len + ex);
|
|
cooked_str = c;
|
|
for (i = 0; i < len; ++i) {
|
|
*c++ = raw_str[i];
|
|
if (raw_str[i] == '\n')
|
|
*c++ = '\r';
|
|
}
|
|
len += ex;
|
|
} else
|
|
cooked_str = raw_str;
|
|
|
|
dprintf("%s(\"", __func__);
|
|
dprintf_decode(cooked_str, len);
|
|
dprintf("\", %i)\n", len);
|
|
|
|
/* First send the length */
|
|
if (jtag_write_emudat(len))
|
|
goto done;
|
|
|
|
/* Then send the data */
|
|
for (i = 0; i < len; i += 4) {
|
|
uint32_t emudat =
|
|
(cooked_str[i + 0] << 0) |
|
|
(cooked_str[i + 1] << 8) |
|
|
(cooked_str[i + 2] << 16) |
|
|
(cooked_str[i + 3] << 24);
|
|
if (jtag_write_emudat(emudat)) {
|
|
bfin_write_emudat(0);
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (cooked_str != raw_str)
|
|
free((char *)cooked_str);
|
|
}
|
|
static void jtag_putc(const char c)
|
|
{
|
|
jtag_send(&c, 1);
|
|
}
|
|
static void jtag_puts(const char *s)
|
|
{
|
|
jtag_send(s, strlen(s));
|
|
}
|
|
|
|
static size_t inbound_len, leftovers_len;
|
|
|
|
/* Lower layers want to know when jtag has data */
|
|
static int jtag_tstc_dbg(void)
|
|
{
|
|
int ret = (bfin_read_DBGSTAT() & 0x2);
|
|
if (ret)
|
|
dprintf("%s: ret:%i\n", __func__, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Higher layers want to know when any data is available */
|
|
static int jtag_tstc(void)
|
|
{
|
|
return jtag_tstc_dbg() || leftovers_len;
|
|
}
|
|
|
|
/* Receive a buffer. The format is:
|
|
* [32bit length][actual data]
|
|
*/
|
|
static uint32_t leftovers;
|
|
static int jtag_getc(void)
|
|
{
|
|
int ret;
|
|
uint32_t emudat;
|
|
|
|
dprintf("%s: inlen:%zu leftlen:%zu left:%x\n", __func__,
|
|
inbound_len, leftovers_len, leftovers);
|
|
|
|
/* see if any data is left over */
|
|
if (leftovers_len) {
|
|
--leftovers_len;
|
|
ret = leftovers & 0xff;
|
|
leftovers >>= 8;
|
|
return ret;
|
|
}
|
|
|
|
/* wait for new data ! */
|
|
while (!jtag_tstc_dbg())
|
|
continue;
|
|
emudat = bfin_read_emudat();
|
|
|
|
if (inbound_len == 0) {
|
|
/* grab the length */
|
|
inbound_len = emudat;
|
|
} else {
|
|
/* store the bytes */
|
|
leftovers_len = min(4, inbound_len);
|
|
inbound_len -= leftovers_len;
|
|
leftovers = emudat;
|
|
}
|
|
|
|
return jtag_getc();
|
|
}
|
|
|
|
int drv_jtag_console_init(void)
|
|
{
|
|
struct stdio_dev dev;
|
|
int ret;
|
|
|
|
memset(&dev, 0x00, sizeof(dev));
|
|
strcpy(dev.name, "jtag");
|
|
dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
|
|
dev.putc = jtag_putc;
|
|
dev.puts = jtag_puts;
|
|
dev.tstc = jtag_tstc;
|
|
dev.getc = jtag_getc;
|
|
|
|
ret = stdio_register(&dev);
|
|
return (ret == 0 ? 1 : ret);
|
|
}
|
|
|
|
#ifdef CONFIG_UART_CONSOLE_IS_JTAG
|
|
#include <serial.h>
|
|
/* Since the JTAG is always available (at power on), allow it to fake a UART */
|
|
void jtag_serial_setbrg(void)
|
|
{
|
|
}
|
|
|
|
int jtag_serial_init(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static struct serial_device serial_jtag_drv = {
|
|
.name = "jtag",
|
|
.start = jtag_serial_init,
|
|
.stop = NULL,
|
|
.setbrg = jtag_serial_setbrg,
|
|
.putc = jtag_putc,
|
|
.puts = jtag_puts,
|
|
.tstc = jtag_tstc,
|
|
.getc = jtag_getc,
|
|
};
|
|
|
|
void bfin_jtag_initialize(void)
|
|
{
|
|
serial_register(&serial_jtag_drv);
|
|
}
|
|
|
|
struct serial_device *default_serial_console(void)
|
|
{
|
|
return &serial_jtag_drv;
|
|
}
|
|
#endif
|