arch/blackfin/cpu/jtag-console.c

   1 /*
   2  * jtag-console.c - console driver over Blackfin JTAG
   3  *
   4  * Copyright (c) 2008-2010 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  */
   8
   9 #include <common.h>
  10 #include <stdio_dev.h>
  11 #include <asm/blackfin.h>
  12
  13 static inline uint32_t bfin_write_emudat(uint32_t emudat)
  14 {
  15         __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
  16         return emudat;
  17 }
  18
  19 static inline uint32_t bfin_read_emudat(void)
  20 {
  21         uint32_t emudat;
  22         __asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
  23         return emudat;
  24 }
  25
  26 #ifndef CONFIG_JTAG_CONSOLE_TIMEOUT
  27 # define CONFIG_JTAG_CONSOLE_TIMEOUT 500
  28 #endif
  29
  30 /* The Blackfin tends to be much much faster than the JTAG hardware. */
  31 static bool jtag_write_emudat(uint32_t emudat)
  32 {
  33         static bool overflowed = false;
  34         ulong timeout = get_timer(0) + CONFIG_JTAG_CONSOLE_TIMEOUT;
  35         while (bfin_read_DBGSTAT() & 0x1) {
  36                 if (overflowed)
  37                         return overflowed;
  38                 if (timeout < get_timer(0))
  39                         overflowed = true;
  40         }
  41         overflowed = false;
  42         bfin_write_emudat(emudat);
  43         return overflowed;
  44 }
  45 /* Transmit a buffer.  The format is:
  46  * [32bit length][actual data]
  47  */
  48 static void jtag_send(const char *c, uint32_t len)
  49 {
  50         uint32_t i;
  51
  52         if (len == 0)
  53                 return;
  54
  55         /* First send the length */
  56         if (jtag_write_emudat(len))
  57                 return;
  58
  59         /* Then send the data */
  60         for (i = 0; i < len; i += 4) {
  61                 uint32_t emudat =
  62                         (c[i + 0] <<  0) |
  63                         (c[i + 1] <<  8) |
  64                         (c[i + 2] << 16) |
  65                         (c[i + 3] << 24);
  66                 if (jtag_write_emudat(emudat)) {
  67                         bfin_write_emudat(0);
  68                         return;
  69                 }
  70         }
  71 }
  72 static void jtag_putc(const char c)
  73 {
  74         jtag_send(&c, 1);
  75 }
  76 static void jtag_puts(const char *s)
  77 {
  78         jtag_send(s, strlen(s));
  79 }
  80
  81 static size_t inbound_len, leftovers_len;
  82
  83 /* Lower layers want to know when jtag has data */
  84 static int jtag_tstc_dbg(void)
  85 {
  86         return (bfin_read_DBGSTAT() & 0x2);
  87 }
  88
  89 /* Higher layers want to know when any data is available */
  90 static int jtag_tstc(void)
  91 {
  92         return jtag_tstc_dbg() || leftovers_len;
  93 }
  94
  95 /* Receive a buffer.  The format is:
  96  * [32bit length][actual data]
  97  */
  98 static uint32_t leftovers;
  99 static int jtag_getc(void)
 100 {
 101         int ret;
 102         uint32_t emudat;
 103
 104         /* see if any data is left over */
 105         if (leftovers_len) {
 106                 --leftovers_len;
 107                 ret = leftovers & 0xff;
 108                 leftovers >>= 8;
 109                 return ret;
 110         }
 111
 112         /* wait for new data ! */
 113         while (!jtag_tstc_dbg())
 114                 continue;
 115         emudat = bfin_read_emudat();
 116
 117         if (inbound_len == 0) {
 118                 /* grab the length */
 119                 inbound_len = emudat;
 120         } else {
 121                 /* store the bytes */
 122                 leftovers_len = min(4, inbound_len);
 123                 inbound_len -= leftovers_len;
 124                 leftovers = emudat;
 125         }
 126
 127         return jtag_getc();
 128 }
 129
 130 int drv_jtag_console_init(void)
 131 {
 132         struct stdio_dev dev;
 133         int ret;
 134
 135         memset(&dev, 0x00, sizeof(dev));
 136         strcpy(dev.name, "jtag");
 137         dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 138         dev.putc = jtag_putc;
 139         dev.puts = jtag_puts;
 140         dev.tstc = jtag_tstc;
 141         dev.getc = jtag_getc;
 142
 143         ret = stdio_register(&dev);
 144         return (ret == 0 ? 1 : ret);
 145 }
 146
 147 #ifdef CONFIG_UART_CONSOLE_IS_JTAG
 148 /* Since the JTAG is always available (at power on), allow it to fake a UART */
 149 void serial_set_baud(uint32_t baud) {}
 150 void serial_setbrg(void)            {}
 151 int serial_init(void)               { return 0; }
 152 void serial_putc(const char c)      __attribute__((alias("jtag_putc")));
 153 void serial_puts(const char *s)     __attribute__((alias("jtag_puts")));
 154 int serial_tstc(void)               __attribute__((alias("jtag_tstc")));
 155 int serial_getc(void)               __attribute__((alias("jtag_getc")));
 156 #endif