jtag-console.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228
  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. #include <common.h>
  9. #include <malloc.h>
  10. #include <stdio_dev.h>
  11. #include <asm/blackfin.h>
  12. #ifdef DEBUG
  13. # define dprintf(...) serial_printf(__VA_ARGS__)
  14. #else
  15. # define dprintf(...) do { if (0) printf(__VA_ARGS__); } while (0)
  16. #endif
  17. static inline void dprintf_decode(const char *s, uint32_t len)
  18. {
  19. uint32_t i;
  20. for (i = 0; i < len; ++i)
  21. if (s[i] < 0x20 || s[i] >= 0x7f)
  22. dprintf("\\%o", s[i]);
  23. else
  24. dprintf("%c", s[i]);
  25. }
  26. static inline uint32_t bfin_write_emudat(uint32_t emudat)
  27. {
  28. __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
  29. return emudat;
  30. }
  31. static inline uint32_t bfin_read_emudat(void)
  32. {
  33. uint32_t emudat;
  34. __asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
  35. return emudat;
  36. }
  37. #ifndef CONFIG_JTAG_CONSOLE_TIMEOUT
  38. # define CONFIG_JTAG_CONSOLE_TIMEOUT 500
  39. #endif
  40. /* The Blackfin tends to be much much faster than the JTAG hardware. */
  41. static bool jtag_write_emudat(uint32_t emudat)
  42. {
  43. static bool overflowed = false;
  44. ulong timeout = get_timer(0);
  45. while (bfin_read_DBGSTAT() & 0x1) {
  46. if (overflowed)
  47. return overflowed;
  48. if (get_timer(timeout) > CONFIG_JTAG_CONSOLE_TIMEOUT)
  49. overflowed = true;
  50. }
  51. overflowed = false;
  52. bfin_write_emudat(emudat);
  53. return overflowed;
  54. }
  55. /* Transmit a buffer. The format is:
  56. * [32bit length][actual data]
  57. */
  58. static void jtag_send(const char *raw_str, uint32_t len)
  59. {
  60. const char *cooked_str;
  61. uint32_t i, ex;
  62. if (len == 0)
  63. return;
  64. /* Ugh, need to output \r after \n */
  65. ex = 0;
  66. for (i = 0; i < len; ++i)
  67. if (raw_str[i] == '\n')
  68. ++ex;
  69. if (ex) {
  70. char *c = malloc(len + ex);
  71. cooked_str = c;
  72. for (i = 0; i < len; ++i) {
  73. *c++ = raw_str[i];
  74. if (raw_str[i] == '\n')
  75. *c++ = '\r';
  76. }
  77. len += ex;
  78. } else
  79. cooked_str = raw_str;
  80. dprintf("%s(\"", __func__);
  81. dprintf_decode(cooked_str, len);
  82. dprintf("\", %i)\n", len);
  83. /* First send the length */
  84. if (jtag_write_emudat(len))
  85. goto done;
  86. /* Then send the data */
  87. for (i = 0; i < len; i += 4) {
  88. uint32_t emudat =
  89. (cooked_str[i + 0] << 0) |
  90. (cooked_str[i + 1] << 8) |
  91. (cooked_str[i + 2] << 16) |
  92. (cooked_str[i + 3] << 24);
  93. if (jtag_write_emudat(emudat)) {
  94. bfin_write_emudat(0);
  95. goto done;
  96. }
  97. }
  98. done:
  99. if (cooked_str != raw_str)
  100. free((char *)cooked_str);
  101. }
  102. static void jtag_putc(struct stdio_dev *dev, const char c)
  103. {
  104. jtag_send(&c, 1);
  105. }
  106. static void jtag_puts(struct stdio_dev *dev, const char *s)
  107. {
  108. jtag_send(s, strlen(s));
  109. }
  110. static size_t inbound_len, leftovers_len;
  111. /* Lower layers want to know when jtag has data */
  112. static int jtag_tstc_dbg(void)
  113. {
  114. int ret = (bfin_read_DBGSTAT() & 0x2);
  115. if (ret)
  116. dprintf("%s: ret:%i\n", __func__, ret);
  117. return ret;
  118. }
  119. /* Higher layers want to know when any data is available */
  120. static int jtag_tstc(struct stdio_dev *dev)
  121. {
  122. return jtag_tstc_dbg() || leftovers_len;
  123. }
  124. /* Receive a buffer. The format is:
  125. * [32bit length][actual data]
  126. */
  127. static uint32_t leftovers;
  128. static int jtag_getc(struct stdio_dev *dev)
  129. {
  130. int ret;
  131. uint32_t emudat;
  132. dprintf("%s: inlen:%zu leftlen:%zu left:%x\n", __func__,
  133. inbound_len, leftovers_len, leftovers);
  134. /* see if any data is left over */
  135. if (leftovers_len) {
  136. --leftovers_len;
  137. ret = leftovers & 0xff;
  138. leftovers >>= 8;
  139. return ret;
  140. }
  141. /* wait for new data ! */
  142. while (!jtag_tstc_dbg())
  143. continue;
  144. emudat = bfin_read_emudat();
  145. if (inbound_len == 0) {
  146. /* grab the length */
  147. inbound_len = emudat;
  148. } else {
  149. /* store the bytes */
  150. leftovers_len = min((size_t)4, inbound_len);
  151. inbound_len -= leftovers_len;
  152. leftovers = emudat;
  153. }
  154. return jtag_getc(dev);
  155. }
  156. int drv_jtag_console_init(void)
  157. {
  158. struct stdio_dev dev;
  159. int ret;
  160. memset(&dev, 0x00, sizeof(dev));
  161. strcpy(dev.name, "jtag");
  162. dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
  163. dev.putc = jtag_putc;
  164. dev.puts = jtag_puts;
  165. dev.tstc = jtag_tstc;
  166. dev.getc = jtag_getc;
  167. ret = stdio_register(&dev);
  168. return (ret == 0 ? 1 : ret);
  169. }
  170. #ifdef CONFIG_UART_CONSOLE_IS_JTAG
  171. #include <serial.h>
  172. /* Since the JTAG is always available (at power on), allow it to fake a UART */
  173. void jtag_serial_setbrg(void)
  174. {
  175. }
  176. int jtag_serial_init(void)
  177. {
  178. return 0;
  179. }
  180. static struct serial_device serial_jtag_drv = {
  181. .name = "jtag",
  182. .start = jtag_serial_init,
  183. .stop = NULL,
  184. .setbrg = jtag_serial_setbrg,
  185. .putc = jtag_putc,
  186. .puts = jtag_puts,
  187. .tstc = jtag_tstc,
  188. .getc = jtag_getc,
  189. };
  190. void bfin_jtag_initialize(void)
  191. {
  192. serial_register(&serial_jtag_drv);
  193. }
  194. struct serial_device *default_serial_console(void)
  195. {
  196. return &serial_jtag_drv;
  197. }
  198. #endif