mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-17 23:48:52 +09:00
![Simon Glass](/assets/img/avatar_default.png)
At present stdio device functions do not get any clue as to which stdio device is being acted on. Some implementations go to great lengths to work around this, such as defining a whole separate set of functions for each possible device. For driver model we need to associate a stdio_dev with a device. It doesn't seem possible to continue with this work-around approach. Instead, add a stdio_dev pointer to each of the stdio member functions. Note: The serial drivers have the same problem, but it is not strictly necessary to fix that to get driver model running. Also, if we convert serial over to driver model the problem will go away. Code size increases by 244 bytes for Thumb2 and 428 for PowerPC. 22: stdio: Pass device pointer to stdio methods arm: (for 2/2 boards) all +244.0 bss -4.0 text +248.0 powerpc: (for 1/1 boards) all +428.0 text +428.0 Signed-off-by: Simon Glass <sjg@chromium.org> Acked-by: Marek Vasut <marex@denx.de> Reviewed-by: Marek Vasut <marex@denx.de>
229 lines
4.5 KiB
C
229 lines
4.5 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(struct stdio_dev *dev, const char c)
|
|
{
|
|
jtag_send(&c, 1);
|
|
}
|
|
static void jtag_puts(struct stdio_dev *dev, 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(struct stdio_dev *dev)
|
|
{
|
|
return jtag_tstc_dbg() || leftovers_len;
|
|
}
|
|
|
|
/* Receive a buffer. The format is:
|
|
* [32bit length][actual data]
|
|
*/
|
|
static uint32_t leftovers;
|
|
static int jtag_getc(struct stdio_dev *dev)
|
|
{
|
|
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(dev);
|
|
}
|
|
|
|
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
|