Koen De Vleeschauwer
3 years ago
committed by
Rachel Mant
Rachel Mant
13 changed files with 1198 additions and 1 deletions
@ -0,0 +1,271 @@ |
|||||
|
# Using RTT |
||||
|
|
||||
|
When debugging arm processors, there are three ways for the target to print debug messages on the host: Semihosting, Serial Wire Output SWO, and Real-Time Transfer RTT. |
||||
|
|
||||
|
[Black Magic Probe](https://github.com/blacksphere/blackmagic) (BMP) is an open source debugger probe that already implements Semihosting and Single Wire Output. This patch adds Real-Time Transfer RTT output to usb serial port. |
||||
|
|
||||
|
- RTT is implemented, not as a user program, but as a serial port device. To read RTT output, use a terminal emulator and connect to the serial port. |
||||
|
|
||||
|
- A novel way to detect RTT automatically, fast and convenient. |
||||
|
|
||||
|
## Use |
||||
|
This example uses linux as operating system. For Windows and MacOS see the *Operating Systems* section. |
||||
|
|
||||
|
In one window open a terminal emulator (minicom, putty) and connect to the usb uart: |
||||
|
``` |
||||
|
$ minicom -c on -D /dev/ttyBmpTarg |
||||
|
``` |
||||
|
|
||||
|
In another window open a debugger: |
||||
|
``` |
||||
|
$ gdb |
||||
|
(gdb) target extended-remote /dev/ttyBmpGdb |
||||
|
(gdb) monitor swdp_scan |
||||
|
(gdb) attach 1 |
||||
|
(gdb) monitor rtt |
||||
|
(gdb) run |
||||
|
^C |
||||
|
(gdb) monitor rtt status |
||||
|
rtt: on found: yes ident: off halt: off channels: auto 0 1 3 |
||||
|
max poll ms: 256 min poll ms: 8 max errs: 10 |
||||
|
``` |
||||
|
|
||||
|
The terminal emulator displays RTT output from the target, |
||||
|
and characters typed in the terminal emulator are sent via RTT to the target. |
||||
|
|
||||
|
|
||||
|
## gdb commands |
||||
|
|
||||
|
The following new gdb commands are available: |
||||
|
|
||||
|
- ``monitor rtt`` |
||||
|
|
||||
|
switch rtt on |
||||
|
|
||||
|
- ``monitor rtt enable`` |
||||
|
|
||||
|
switch rtt on |
||||
|
|
||||
|
- ``monitor rtt disable`` |
||||
|
|
||||
|
switch rtt off |
||||
|
|
||||
|
- ``monitor rtt poll `` max_poll_ms min_poll_ms max_errs |
||||
|
|
||||
|
sets maximum time between polls, minimum time between polls, and the maximum number of errors before RTT disconnects from the target. Times in milliseconds. It is best if max_poll_ms/min_poll_ms is a power of two. As an example, if you wish to check for RTT output between once per second to eight times per second: ``monitor rtt poll 1000 125 10``. |
||||
|
|
||||
|
- ``monitor rtt status`` |
||||
|
|
||||
|
show status. |
||||
|
|
||||
|
rtt|found|state |
||||
|
---|---|--- |
||||
|
rtt: off|found: no|rtt inactive |
||||
|
rtt: on|found: no|searching for rtt control block |
||||
|
rtt: on|found: yes|rtt active |
||||
|
rtt: off|found: yes|corrupt rtt control block, or target memory access error |
||||
|
|
||||
|
A status of `rtt: on found: no` indicates bmp is still searching for the rtt control block in target ram, but has not found anything yet. A status of `rtt: on found: yes` indicates the control block has been found and rtt is active. |
||||
|
|
||||
|
- ``monitor rtt channel`` |
||||
|
|
||||
|
enables the first two output channels, and the first input channel. (default) |
||||
|
|
||||
|
- ``monitor rtt channel number...`` |
||||
|
|
||||
|
enables the given RTT channel numbers. Channels are numbers from 0 to 15, inclusive. Eg. ``monitor rtt channel 0 1 4`` to enable channels 0, 1, and 4. |
||||
|
|
||||
|
- ``monitor rtt ident string`` |
||||
|
|
||||
|
sets RTT ident to *string*. If *string* contains a space, replace the space with an underscore _. Setting ident string is optional, RTT works fine without. |
||||
|
|
||||
|
- ``monitor rtt ident`` |
||||
|
|
||||
|
clears ident string. (default) |
||||
|
|
||||
|
- ``monitor rtt cblock`` |
||||
|
|
||||
|
shows rtt control block data, and which channels are enabled. This is an example control block: |
||||
|
|
||||
|
``` |
||||
|
(gdb) mon rtt cb |
||||
|
cbaddr: 0x200000a0 |
||||
|
ch ena cfg i/o buf@ size head@ tail@ flg |
||||
|
0 y y out 0x20000148 1024 0x200000c4 0x200000c8 2 |
||||
|
1 y n out 0x00000000 0 0x200000dc 0x200000e0 0 |
||||
|
2 n n out 0x00000000 0 0x200000f4 0x200000f8 0 |
||||
|
3 y y in 0x20000548 16 0x2000010c 0x20000110 0 |
||||
|
4 n n in 0x00000000 0 0x20000124 0x20000128 0 |
||||
|
5 n n in 0x00000000 0 0x2000013c 0x20000140 0 |
||||
|
6 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
7 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
8 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
9 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
10 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
11 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
12 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
13 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
14 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
15 n n in 0x00000000 0 0x00000000 0x00000000 0 |
||||
|
``` |
||||
|
|
||||
|
Channels are listed, one channel per line. The columns are: channel, enabled, configured, input/output, buffer address, buffer size, address of head pointer, address of tail pointer, flag. Each channel is a circular buffer with head and tail pointer. |
||||
|
|
||||
|
Note the columns `ena` for enabled, `cfg` for configured. |
||||
|
|
||||
|
Configured channels have a non-zero buffer address and non-zero size. Configured channels are marked yes `y` in the column `cfg` . What channels are configured depends upon target software. |
||||
|
|
||||
|
Channels the user wants to see are marked yes `y` in the column enabled `ena`. The user can change which channels are shown with the `monitor rtt channel` command. |
||||
|
|
||||
|
Output channels are displayed, and Input channels receive keyboard input, if they are marked yes in both *enabled* and *configured*. |
||||
|
|
||||
|
The control block is cached for speed. In an interrupted program, `monitor rtt` will force a reload of the control block when the program continues. |
||||
|
|
||||
|
## Identifier string |
||||
|
It is possible to set an RTT identifier string. |
||||
|
As an example, if the RTT identifier is "IDENT STR": |
||||
|
``` |
||||
|
$ gdb |
||||
|
(gdb) target extended-remote /dev/ttyBmpGdb |
||||
|
(gdb) monitor swdp_scan |
||||
|
(gdb) attach 1 |
||||
|
(gdb) monitor rtt ident IDENT_STR |
||||
|
(gdb) monitor rtt |
||||
|
(gdb) run |
||||
|
^C |
||||
|
(gdb) monitor rtt status |
||||
|
rtt: on found: yes ident: "IDENT STR" halt: off channels: auto 0 1 3 |
||||
|
max poll ms: 256 min poll ms: 8 max errs: 10 |
||||
|
``` |
||||
|
Note replacing space with underscore _ in *monitor rtt ident*. |
||||
|
|
||||
|
Setting an identifier string is optional. RTT gives the same output at the same speed, with or without specifying identifier string. |
||||
|
|
||||
|
## Operating systems |
||||
|
|
||||
|
[Configuration](https://github.com/blacksphere/blackmagic/wiki/Getting-Started) instructions for windows, linux and macos. |
||||
|
|
||||
|
### Windows |
||||
|
|
||||
|
After configuration, Black Magic Probe shows up in Windows as two _USB Serial (CDC)_ ports. |
||||
|
|
||||
|
Connect arm-none-eabi-gdb, the gnu debugger for arm processors, to the lower numbered of the two COM ports. Connect an ansi terminal emulator to the higher numbered of the two COM ports. |
||||
|
|
||||
|
Sample gdb session: |
||||
|
``` |
||||
|
(gdb) target extended-remote COM3 |
||||
|
(gdb) monitor swdp_scan |
||||
|
(gdb) attach 1 |
||||
|
(gdb) monitor rtt |
||||
|
(gdb) run |
||||
|
``` |
||||
|
|
||||
|
For COM port COM10 and higher, add the prefix `\\.\`, e.g. |
||||
|
``` |
||||
|
target extended-remote \\.\COM10 |
||||
|
``` |
||||
|
|
||||
|
Target RTT output will appear in the terminal, and what you type in the terminal will be sent to the RTT input of the target. |
||||
|
|
||||
|
### linux |
||||
|
On linux, install [udev rules](https://github.com/blacksphere/blackmagic/blob/master/driver/99-blackmagic.rules). Disconnect and re-connect the BMP. Check the device shows up in /dev/ : |
||||
|
``` |
||||
|
$ ls -l /dev/ttyBmp* |
||||
|
lrwxrwxrwx 1 root root 7 Dec 13 07:29 /dev/ttyBmpGdb -> ttyACM0 |
||||
|
lrwxrwxrwx 1 root root 7 Dec 13 07:29 /dev/ttyBmpTarg -> ttyACM2 |
||||
|
``` |
||||
|
Connect terminal emulator to /dev/ttyBmpTarg and gdb to /dev/ttyBmpGdb . |
||||
|
|
||||
|
In one window: |
||||
|
``` |
||||
|
minicom -c on -D /dev/ttyBmpTarg |
||||
|
``` |
||||
|
In another window : |
||||
|
``` |
||||
|
gdb |
||||
|
(gdb) target extended-remote /dev/ttyBmpGdb |
||||
|
(gdb) monitor swdp_scan |
||||
|
(gdb) attach 1 |
||||
|
(gdb) monitor rtt |
||||
|
(gdb) run |
||||
|
``` |
||||
|
|
||||
|
### MacOS |
||||
|
|
||||
|
On MacOS the tty devices have different names than on linux. On connecting blackmagic to the computer 4 devices are created, 2 'tty' and 2 'cu' devices. Gdb connects to the first cu device (e.g.: `target extended-remote /dev/cu.usbmodemDDCEC9EC1`), while RTT is connected to the second tty device (`minicom -c on -D /dev/tty.usbmodemDDCEC9EC3`). In full: |
||||
|
|
||||
|
In one Terminal window, connect a terminal emulator to /dev/tty.usbmodemDDCEC9EC3 : |
||||
|
|
||||
|
``` |
||||
|
minicom -c on -D /dev/tty.usbmodemDDCEC9EC3 |
||||
|
``` |
||||
|
In another Terminal window, connect gdb to /dev/cu.usbmodemDDCEC9EC1 : |
||||
|
``` |
||||
|
gdb |
||||
|
(gdb) target extended-remote /dev/cu.usbmodemDDCEC9EC1 |
||||
|
(gdb) monitor swdp_scan |
||||
|
(gdb) attach 1 |
||||
|
(gdb) monitor rtt |
||||
|
(gdb) run |
||||
|
``` |
||||
|
RTT input/output is in the window running _minicom_. |
||||
|
|
||||
|
## Notes |
||||
|
|
||||
|
- Design goal was smallest, simplest implementation that has good practical use. |
||||
|
|
||||
|
- RTT code size is 3.5 kbyte - the whole debugger 110 kbyte. |
||||
|
|
||||
|
- Because RTT is implemented as a serial port device, there is no need to write and maintain software for different host operating systems. A serial port works everywhere - linux, windows and mac. You can even use an Android mobile phone as RTT terminal. |
||||
|
|
||||
|
- Because polling occurs between debugger probe and target, the load on the host is small. There is no constant usb traffic, there are no real-time requirements on the host. |
||||
|
|
||||
|
- RTT polling frequency is adaptive and goes up and down with RTT activity. Use *monitor rtt poll* to balance response speed and target load for your use. |
||||
|
|
||||
|
- Detects RTT automatically, very convenient. |
||||
|
|
||||
|
- When using RTT as a terminal, sending data from host to target, you may need to change local echo, carriage return and/or line feed settings in your terminal emulator. |
||||
|
|
||||
|
- Architectures such as risc-v may not allow the debugger access to target memory while the target is running. As a workaround, on these architectures RTT briefly halts the target during polling. If the target is halted during polling, `monitor rtt status` shows `halt: on`. |
||||
|
|
||||
|
- Measured RTT speed. |
||||
|
|
||||
|
| debugger | char/s | |
||||
|
| ------------------------- | ------ | |
||||
|
| bmp stm32f723 stlinkv3 | 49811 | |
||||
|
| bmp stm32f411 black pill | 50073 | |
||||
|
| bmp stm32f103 blue pill | 50142 | |
||||
|
|
||||
|
This is the speed at which characters can be sent from target to debugger probe, in reasonable circumstances. Test target is an stm32f103 blue pill running an [Arduino sketch](https://github.com/koendv/Arduino-RTTStream/blob/main/examples/SpeedTest/SpeedTest.ino). Default *monitor rtt poll* settings on debugger. Default RTT buffer size in target and debugger. Overhead for printf() calls included. |
||||
|
|
||||
|
## Compiling firmware |
||||
|
To compile with RTT support, add *ENABLE_RTT=1*. |
||||
|
|
||||
|
Eg. for STM32F103 blue pill: |
||||
|
``` |
||||
|
make clean |
||||
|
make PROBE_HOST=stlink ENABLE_RTT=1 |
||||
|
``` |
||||
|
or for the STM32F411 *[Black Pill](https://www.aliexpress.com/item/1005001456186625.html)*: |
||||
|
``` |
||||
|
make clean |
||||
|
make PROBE_HOST=f4discovery BLACKPILL=1 ENABLE_RTT=1 |
||||
|
``` |
||||
|
Setting an ident string is optional. But if you wish, you can set the default RTT ident at compile time. |
||||
|
For STM32F103 *Blue Pill*: |
||||
|
``` |
||||
|
make clean |
||||
|
make PROBE_HOST=stlink ENABLE_RTT=1 "RTT_IDENT=IDENT\ STR" |
||||
|
``` |
||||
|
or for STM32F411 *Black Pill*: |
||||
|
``` |
||||
|
make clean |
||||
|
make PROBE_HOST=f4discovery BLACKPILL=1 ENABLE_RTT=1 "RTT_IDENT=IDENT\ STR" |
||||
|
``` |
||||
|
Note the backslash \\ before the space. |
||||
|
|
||||
|
## Links |
||||
|
- [OpenOCD](https://openocd.org/doc/html/General-Commands.html#Real-Time-Transfer-_0028RTT_0029) |
||||
|
- [probe-rs](https://probe.rs/) and [rtt-target](https://github.com/mvirkkunen/rtt-target) for the _rust_ programming language. |
||||
|
- [RTT Stream](https://github.com/koendv/Arduino-RTTStream) for Arduino on arm processors |
||||
|
- [\[WIP\] RTT support - PR from katyo](https://github.com/blacksphere/blackmagic/pull/833) |
||||
@ -0,0 +1,34 @@ |
|||||
|
#ifndef RTT_H |
||||
|
#define RTT_H |
||||
|
#include <target.h> |
||||
|
|
||||
|
#define MAX_RTT_CHAN 16 |
||||
|
|
||||
|
extern char rtt_ident[16]; // string
|
||||
|
extern bool rtt_enabled; // rtt on/off
|
||||
|
extern bool rtt_found; // control block found
|
||||
|
extern uint32_t rtt_cbaddr; // control block address
|
||||
|
extern uint32_t rtt_min_poll_ms; // min time between polls (ms)
|
||||
|
extern uint32_t rtt_max_poll_ms; // max time between polls (ms)
|
||||
|
extern uint32_t rtt_max_poll_errs; // max number of errors before disconnect
|
||||
|
extern bool rtt_auto_channel; // manual or auto channel selection
|
||||
|
extern bool rtt_flag_skip; // skip if host-to-target fifo full
|
||||
|
extern bool rtt_flag_block; // block if host-to-target fifo full
|
||||
|
|
||||
|
struct rtt_channel_struct { |
||||
|
bool is_enabled; // does user want to see this channel?
|
||||
|
bool is_configured; // is channel configured in control block?
|
||||
|
bool is_output; |
||||
|
uint32_t buf_addr; |
||||
|
uint32_t buf_size; |
||||
|
uint32_t head_addr; |
||||
|
uint32_t tail_addr; |
||||
|
uint32_t flag; |
||||
|
}; |
||||
|
|
||||
|
extern struct rtt_channel_struct rtt_channel[MAX_RTT_CHAN]; |
||||
|
|
||||
|
// true if target memory access does not work when target running
|
||||
|
extern bool target_no_background_memory_access(target *cur_target); |
||||
|
extern void poll_rtt(target *cur_target); |
||||
|
#endif |
||||
@ -0,0 +1,36 @@ |
|||||
|
#ifndef RTT_IF_H |
||||
|
#define RTT_IF_H |
||||
|
/* rtt i/o to terminal */ |
||||
|
|
||||
|
/* default buffer sizes, 8 bytes added to up buffer for alignment and padding */ |
||||
|
/* override RTT_UP_BUF_SIZE and RTT_DOWN_BUF_SIZE in platform.h if needed */ |
||||
|
|
||||
|
#if !defined(RTT_UP_BUF_SIZE) || !defined(RTT_DOWN_BUF_SIZE) |
||||
|
#if (PC_HOSTED == 1) |
||||
|
#define RTT_UP_BUF_SIZE (4096 + 8) |
||||
|
#define RTT_DOWN_BUF_SIZE (512) |
||||
|
#elif defined(STM32F7) |
||||
|
#define RTT_UP_BUF_SIZE (4096 + 8) |
||||
|
#define RTT_DOWN_BUF_SIZE (2048) |
||||
|
#elif defined(STM32F4) |
||||
|
#define RTT_UP_BUF_SIZE (2048 + 8) |
||||
|
#define RTT_DOWN_BUF_SIZE (256) |
||||
|
#else /* stm32f103 */ |
||||
|
#define RTT_UP_BUF_SIZE (1024 + 8) |
||||
|
#define RTT_DOWN_BUF_SIZE (256) |
||||
|
#endif |
||||
|
#endif |
||||
|
|
||||
|
/* hosted initialisation */ |
||||
|
extern int rtt_if_init(void); |
||||
|
/* hosted teardown */ |
||||
|
extern int rtt_if_exit(void); |
||||
|
|
||||
|
/* target to host: write len bytes from the buffer starting at buf. return number bytes written */ |
||||
|
extern uint32_t rtt_write(const char *buf, uint32_t len); |
||||
|
/* host to target: read one character, non-blocking. return character, -1 if no character */ |
||||
|
extern int32_t rtt_getchar(); |
||||
|
/* host to target: true if no characters available for reading */ |
||||
|
extern bool rtt_nodata(); |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,127 @@ |
|||||
|
/*
|
||||
|
* This file is part of the Black Magic Debug project. |
||||
|
* |
||||
|
* MIT License |
||||
|
* |
||||
|
* Copyright (c) 2021 Koen De Vleeschauwer |
||||
|
* |
||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||
|
* in the Software without restriction, including without limitation the rights |
||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||
|
* furnished to do so, subject to the following conditions: |
||||
|
* |
||||
|
* The above copyright notice and this permission notice shall be included in all |
||||
|
* copies or substantial portions of the Software. |
||||
|
* |
||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
|
* SOFTWARE. |
||||
|
*/ |
||||
|
|
||||
|
#include <general.h> |
||||
|
#include <unistd.h> |
||||
|
#include <fcntl.h> |
||||
|
#include <rtt_if.h> |
||||
|
|
||||
|
/* maybe rewrite this as tcp server */ |
||||
|
|
||||
|
#ifndef WIN32 |
||||
|
#include <termios.h> |
||||
|
|
||||
|
/* linux */ |
||||
|
static struct termios saved_ttystate; |
||||
|
static bool tty_saved = false; |
||||
|
|
||||
|
/* set up and tear down */ |
||||
|
|
||||
|
int rtt_if_init() |
||||
|
{ |
||||
|
struct termios ttystate; |
||||
|
tcgetattr(STDIN_FILENO, &saved_ttystate); |
||||
|
tty_saved = true; |
||||
|
tcgetattr(STDIN_FILENO, &ttystate); |
||||
|
ttystate.c_lflag &= ~ICANON; |
||||
|
ttystate.c_lflag &= ~ECHO; |
||||
|
ttystate.c_cc[VMIN] = 1; |
||||
|
tcsetattr(STDIN_FILENO, TCSANOW, &ttystate); |
||||
|
int flags = fcntl(0, F_GETFL, 0); |
||||
|
fcntl(0, F_SETFL, flags | O_NONBLOCK); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
int rtt_if_exit() |
||||
|
{ |
||||
|
if (tty_saved) |
||||
|
tcsetattr(STDIN_FILENO, TCSANOW, &saved_ttystate); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
/* write buffer to terminal */ |
||||
|
|
||||
|
uint32_t rtt_write(const char *buf, uint32_t len) |
||||
|
{ |
||||
|
write(1, buf, len); |
||||
|
return len; |
||||
|
} |
||||
|
|
||||
|
/* read character from terminal */ |
||||
|
|
||||
|
int32_t rtt_getchar() |
||||
|
{ |
||||
|
char ch; |
||||
|
int len; |
||||
|
len = read(0, &ch, 1); |
||||
|
if (len == 1) return ch; |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
/* true if no characters available */ |
||||
|
|
||||
|
bool rtt_nodata() |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
#else |
||||
|
|
||||
|
/* windows, output only */ |
||||
|
|
||||
|
int rtt_if_init() |
||||
|
{ |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
int rtt_if_exit() |
||||
|
{ |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
/* write buffer to terminal */ |
||||
|
|
||||
|
uint32_t rtt_write(const char *buf, uint32_t len) |
||||
|
{ |
||||
|
write(1, buf, len); |
||||
|
return len; |
||||
|
} |
||||
|
|
||||
|
/* read character from terminal */ |
||||
|
|
||||
|
int32_t rtt_getchar() |
||||
|
{ |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
/* true if no characters available */ |
||||
|
|
||||
|
bool rtt_nodata() |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,136 @@ |
|||||
|
/*
|
||||
|
* This file is part of the Black Magic Debug project. |
||||
|
* |
||||
|
* MIT License |
||||
|
* |
||||
|
* Copyright (c) 2021 Koen De Vleeschauwer |
||||
|
* |
||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||
|
* in the Software without restriction, including without limitation the rights |
||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||
|
* furnished to do so, subject to the following conditions: |
||||
|
* |
||||
|
* The above copyright notice and this permission notice shall be included in all |
||||
|
* copies or substantial portions of the Software. |
||||
|
* |
||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
|
* SOFTWARE. |
||||
|
*/ |
||||
|
|
||||
|
#include "general.h" |
||||
|
#include "platform.h" |
||||
|
#include <assert.h> |
||||
|
#include "cdcacm.h" |
||||
|
#include "rtt.h" |
||||
|
#include "rtt_if.h" |
||||
|
|
||||
|
/*********************************************************************
|
||||
|
* |
||||
|
* rtt terminal i/o |
||||
|
* |
||||
|
********************************************************************** |
||||
|
*/ |
||||
|
|
||||
|
/* usb uart receive buffer */ |
||||
|
static char recv_buf[RTT_DOWN_BUF_SIZE]; |
||||
|
static uint32_t recv_head = 0; |
||||
|
static uint32_t recv_tail = 0; |
||||
|
|
||||
|
/* data from host to target: number of free bytes in usb receive buffer */ |
||||
|
inline static uint32_t recv_bytes_free() |
||||
|
{ |
||||
|
uint32_t bytes_free; |
||||
|
if (recv_tail <= recv_head) bytes_free = sizeof(recv_buf) - recv_head + recv_tail - 1; |
||||
|
else bytes_free = recv_tail - recv_head - 1; |
||||
|
return bytes_free; |
||||
|
} |
||||
|
|
||||
|
/* data from host to target: true if not enough free buffer space and we need to close flow control */ |
||||
|
inline static bool recv_set_nak() |
||||
|
{ |
||||
|
assert(sizeof(recv_buf) > 2 * CDCACM_PACKET_SIZE); |
||||
|
bool nak = recv_bytes_free() < 2 * CDCACM_PACKET_SIZE; |
||||
|
return nak; |
||||
|
} |
||||
|
|
||||
|
/* usbuart_usb_out_cb is called when usb uart has received new data for target.
|
||||
|
this routine has to be fast */ |
||||
|
|
||||
|
void usbuart_usb_out_cb(usbd_device *dev, uint8_t ep) |
||||
|
{ |
||||
|
(void)dev; |
||||
|
(void)ep; |
||||
|
char usb_buf[CDCACM_PACKET_SIZE]; |
||||
|
|
||||
|
/* close flow control while processing packet */ |
||||
|
usbd_ep_nak_set(usbdev, CDCACM_UART_ENDPOINT, 1); |
||||
|
|
||||
|
const uint16_t len = usbd_ep_read_packet(usbdev, CDCACM_UART_ENDPOINT, usb_buf, CDCACM_PACKET_SIZE); |
||||
|
|
||||
|
/* skip flag: drop packet if not enough free buffer space */ |
||||
|
if (rtt_flag_skip && (len > recv_bytes_free())) { |
||||
|
usbd_ep_nak_set(usbdev, CDCACM_UART_ENDPOINT, 0); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
/* copy data to recv_buf */ |
||||
|
for (int i = 0; i < len; i++) { |
||||
|
uint32_t next_recv_head = (recv_head + 1) % sizeof(recv_buf); |
||||
|
if (next_recv_head == recv_tail) |
||||
|
break; /* overflow */ |
||||
|
recv_buf[recv_head] = usb_buf[i]; |
||||
|
recv_head = next_recv_head; |
||||
|
} |
||||
|
|
||||
|
/* block flag: flow control closed if not enough free buffer space */ |
||||
|
if (!(rtt_flag_block && recv_set_nak())) |
||||
|
usbd_ep_nak_set(usbdev, CDCACM_UART_ENDPOINT, 0); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
/* rtt host to target: read one character */ |
||||
|
int32_t rtt_getchar() |
||||
|
{ |
||||
|
int retval; |
||||
|
|
||||
|
if (recv_head == recv_tail) |
||||
|
return -1; |
||||
|
retval = recv_buf[recv_tail]; |
||||
|
recv_tail = (recv_tail + 1) % sizeof(recv_buf); |
||||
|
|
||||
|
/* open flow control if enough free buffer space */ |
||||
|
if (!recv_set_nak()) |
||||
|
usbd_ep_nak_set(usbdev, CDCACM_UART_ENDPOINT, 0); |
||||
|
|
||||
|
return retval; |
||||
|
} |
||||
|
|
||||
|
/* rtt host to target: true if no characters available for reading */ |
||||
|
bool rtt_nodata() |
||||
|
{ |
||||
|
return recv_head == recv_tail; |
||||
|
} |
||||
|
|
||||
|
/* rtt target to host: write string */ |
||||
|
uint32_t rtt_write(const char *buf, uint32_t len) |
||||
|
{ |
||||
|
if ((len != 0) && usbdev && cdcacm_get_config() && cdcacm_get_dtr()) { |
||||
|
for (uint32_t p = 0; p < len; p += CDCACM_PACKET_SIZE) { |
||||
|
uint32_t plen = MIN(CDCACM_PACKET_SIZE, len - p); |
||||
|
while(usbd_ep_write_packet(usbdev, CDCACM_UART_ENDPOINT, buf + p, plen) <= 0); |
||||
|
} |
||||
|
/* flush 64-byte packet on full-speed */ |
||||
|
if ((CDCACM_PACKET_SIZE == 64) && ((len % CDCACM_PACKET_SIZE) == 0)) |
||||
|
while(usbd_ep_write_packet(usbdev, CDCACM_UART_ENDPOINT, NULL, 0) <= 0); |
||||
|
} |
||||
|
return len; |
||||
|
} |
||||
|
// not truncated
|
||||
@ -0,0 +1,463 @@ |
|||||
|
|
||||
|
/*
|
||||
|
* This file is part of the Black Magic Debug project. |
||||
|
* |
||||
|
* MIT License |
||||
|
* |
||||
|
* Copyright (c) 2021 Koen De Vleeschauwer |
||||
|
* |
||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||
|
* in the Software without restriction, including without limitation the rights |
||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||
|
* furnished to do so, subject to the following conditions: |
||||
|
* |
||||
|
* The above copyright notice and this permission notice shall be included in all |
||||
|
* copies or substantial portions of the Software. |
||||
|
* |
||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
|
* SOFTWARE. |
||||
|
*/ |
||||
|
|
||||
|
#include "general.h" |
||||
|
#include "platform.h" |
||||
|
#include "gdb_packet.h" |
||||
|
#include "target.h" |
||||
|
#include "target/target_internal.h" |
||||
|
#include "rtt.h" |
||||
|
#include "rtt_if.h" |
||||
|
|
||||
|
bool rtt_enabled = false; |
||||
|
bool rtt_found = false; |
||||
|
static bool rtt_halt = false; // true if rtt needs to halt target to access memory
|
||||
|
uint32_t rtt_cbaddr = 0; |
||||
|
bool rtt_auto_channel = true; |
||||
|
struct rtt_channel_struct rtt_channel[MAX_RTT_CHAN]; |
||||
|
|
||||
|
uint32_t rtt_min_poll_ms = 8; /* 8 ms */ |
||||
|
uint32_t rtt_max_poll_ms = 256; /* 0.256 s */ |
||||
|
uint32_t rtt_max_poll_errs = 10; |
||||
|
static uint32_t poll_ms; |
||||
|
static uint32_t poll_errs; |
||||
|
static uint32_t last_poll_ms; |
||||
|
/* flags for data from host to target */ |
||||
|
bool rtt_flag_skip = false; |
||||
|
bool rtt_flag_block = false; |
||||
|
|
||||
|
typedef enum rtt_retval { |
||||
|
RTT_OK, |
||||
|
RTT_IDLE, |
||||
|
RTT_ERR |
||||
|
} rtt_retval; |
||||
|
|
||||
|
#ifdef RTT_IDENT |
||||
|
#define Q(x) #x |
||||
|
#define QUOTE(x) Q(x) |
||||
|
char rtt_ident[16] = QUOTE(RTT_IDENT); |
||||
|
#else |
||||
|
char rtt_ident[16] = {0}; |
||||
|
#endif |
||||
|
|
||||
|
/* usb uart transmit buffer */ |
||||
|
static char xmit_buf[RTT_UP_BUF_SIZE]; |
||||
|
|
||||
|
/*********************************************************************
|
||||
|
* |
||||
|
* rtt control block |
||||
|
* |
||||
|
********************************************************************** |
||||
|
*/ |
||||
|
|
||||
|
uint32_t fastsrch(target *cur_target) |
||||
|
{ |
||||
|
const uint32_t m = 16; |
||||
|
const uint64_t q = 0x797a9691; /* prime */ |
||||
|
const uint64_t rm = 0x73b07d01; |
||||
|
const uint64_t p = 0x444110cd; |
||||
|
const uint32_t stride = 128; |
||||
|
uint64_t t = 0; |
||||
|
uint8_t srch_buf[m+stride]; |
||||
|
|
||||
|
for (struct target_ram *r = cur_target->ram; r; r = r->next) { |
||||
|
uint32_t ram_start = r->start; |
||||
|
uint32_t ram_end = r->start + r->length; |
||||
|
|
||||
|
t = 0; |
||||
|
memset(srch_buf, 0, sizeof(srch_buf)); |
||||
|
|
||||
|
for (uint32_t addr = ram_start; addr < ram_end; addr += stride) { |
||||
|
uint32_t buf_siz = MIN(stride, ram_end - addr); |
||||
|
memcpy(srch_buf, srch_buf + stride, m); |
||||
|
if (target_mem_read(cur_target, srch_buf + m, addr, buf_siz)) { |
||||
|
gdb_outf("rtt: read fail at 0x%x\r\n", addr); |
||||
|
return 0; |
||||
|
} |
||||
|
for (uint32_t i = 0; i < buf_siz; i++) { |
||||
|
t = (t + q - rm * srch_buf[i] % q) % q; |
||||
|
t = ((t << 8) + srch_buf[i + m]) % q; |
||||
|
if (p == t) { |
||||
|
uint32_t offset = i - m + 1; |
||||
|
return addr + offset; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
/* no match */ |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
uint32_t memsrch(target *cur_target) |
||||
|
{ |
||||
|
char *srch_str = rtt_ident; |
||||
|
uint32_t srch_str_len = strlen(srch_str); |
||||
|
uint8_t srch_buf[128]; |
||||
|
|
||||
|
if ((srch_str_len == 0) || (srch_str_len > sizeof(srch_buf) / 2)) |
||||
|
return 0; |
||||
|
|
||||
|
if (rtt_cbaddr && !target_mem_read(cur_target, srch_buf, rtt_cbaddr, srch_str_len) |
||||
|
&& (strncmp((const char *)(srch_buf), srch_str, srch_str_len) == 0)) { |
||||
|
/* still at same place */ |
||||
|
return rtt_cbaddr; |
||||
|
} |
||||
|
|
||||
|
for (struct target_ram *r = cur_target->ram; r; r = r->next) { |
||||
|
uint32_t ram_end = r->start + r->length; |
||||
|
for (uint32_t addr = r->start; addr < ram_end; addr += sizeof(srch_buf) - srch_str_len - 1) { |
||||
|
uint32_t buf_siz = MIN(ram_end - addr, sizeof(srch_buf)); |
||||
|
if (target_mem_read(cur_target, srch_buf, addr, buf_siz)) { |
||||
|
gdb_outf("rtt: read fail at 0x%x\r\n", addr); |
||||
|
continue; |
||||
|
} |
||||
|
for (uint32_t offset = 0; offset + srch_str_len + 1 < buf_siz; offset++) { |
||||
|
if (strncmp((const char *)(srch_buf + offset), srch_str, srch_str_len) == 0) { |
||||
|
uint32_t cb_addr = addr + offset; |
||||
|
return cb_addr; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
static void find_rtt(target *cur_target) |
||||
|
{ |
||||
|
rtt_found = false; |
||||
|
poll_ms = rtt_max_poll_ms; |
||||
|
poll_errs = 0; |
||||
|
last_poll_ms = 0; |
||||
|
|
||||
|
if (!cur_target || !rtt_enabled) |
||||
|
return; |
||||
|
|
||||
|
if (rtt_ident[0] == 0) rtt_cbaddr = fastsrch(cur_target); |
||||
|
else rtt_cbaddr = memsrch(cur_target); |
||||
|
DEBUG_INFO("rtt: match at 0x%" PRIx32 "\r\n", rtt_cbaddr); |
||||
|
|
||||
|
if (rtt_cbaddr) { |
||||
|
uint32_t num_buf[2]; |
||||
|
int32_t num_up_buf; |
||||
|
int32_t num_down_buf; |
||||
|
if (target_mem_read(cur_target, num_buf, rtt_cbaddr + 16, sizeof(num_buf))) |
||||
|
return; |
||||
|
num_up_buf = num_buf[0]; |
||||
|
num_down_buf = num_buf[1]; |
||||
|
|
||||
|
if ((num_up_buf > 255) || (num_down_buf > 255)) { |
||||
|
gdb_out("rtt: bad cblock\r\n"); |
||||
|
rtt_enabled = false; |
||||
|
return; |
||||
|
} else if ((num_up_buf == 0) && (num_down_buf == 0)) |
||||
|
gdb_out("rtt: empty cblock\r\n"); |
||||
|
|
||||
|
for (int32_t i = 0; i < MAX_RTT_CHAN; i++) { |
||||
|
uint32_t buf_desc[6]; |
||||
|
|
||||
|
rtt_channel[i].is_configured = false; |
||||
|
rtt_channel[i].is_output = false; |
||||
|
rtt_channel[i].buf_addr = 0; |
||||
|
rtt_channel[i].buf_size = 0; |
||||
|
rtt_channel[i].head_addr = 0; |
||||
|
rtt_channel[i].tail_addr = 0; |
||||
|
rtt_channel[i].flag = 0; |
||||
|
|
||||
|
if (i >= num_up_buf + num_down_buf) continue; |
||||
|
if (target_mem_read(cur_target, buf_desc, rtt_cbaddr + 24 + i * 24, sizeof(buf_desc))) |
||||
|
return; |
||||
|
rtt_channel[i].is_output = i < num_up_buf; |
||||
|
rtt_channel[i].buf_addr = buf_desc[1]; |
||||
|
rtt_channel[i].buf_size = buf_desc[2]; |
||||
|
rtt_channel[i].head_addr = rtt_cbaddr + 24 + i * 24 + 12; |
||||
|
rtt_channel[i].tail_addr = rtt_cbaddr + 24 + i * 24 + 16; |
||||
|
rtt_channel[i].flag = buf_desc[5]; |
||||
|
rtt_channel[i].is_configured = (rtt_channel[i].buf_addr != 0) && (rtt_channel[i].buf_size != 0); |
||||
|
} |
||||
|
|
||||
|
/* auto channel: enable output channels 0 and 1 and first input channel */ |
||||
|
if (rtt_auto_channel) { |
||||
|
for (uint32_t i = 0; i < MAX_RTT_CHAN; i++) |
||||
|
rtt_channel[i].is_enabled = false; |
||||
|
rtt_channel[0].is_enabled = num_up_buf > 0; |
||||
|
rtt_channel[1].is_enabled = num_up_buf > 1; |
||||
|
if ((num_up_buf < MAX_RTT_CHAN) && (num_down_buf > 0)) |
||||
|
rtt_channel[num_up_buf].is_enabled = true; |
||||
|
} |
||||
|
|
||||
|
/* get flags for data from host to target */ |
||||
|
rtt_flag_skip = false; |
||||
|
rtt_flag_block = false; |
||||
|
for (uint32_t i = 0; i < MAX_RTT_CHAN; i++) |
||||
|
if (rtt_channel[i].is_enabled && rtt_channel[i].is_configured && !rtt_channel[i].is_output) { |
||||
|
rtt_flag_skip = rtt_channel[i].flag == 0; |
||||
|
rtt_flag_block = rtt_channel[i].flag == 2; |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
rtt_found = true; |
||||
|
DEBUG_INFO("rtt found\n"); |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
/*********************************************************************
|
||||
|
* |
||||
|
* rtt from host to target |
||||
|
* |
||||
|
********************************************************************** |
||||
|
*/ |
||||
|
|
||||
|
/* poll if host has new data for target */ |
||||
|
static rtt_retval read_rtt(target *cur_target, uint32_t i) |
||||
|
{ |
||||
|
uint32_t head_tail[2]; |
||||
|
uint32_t buf_head; |
||||
|
uint32_t buf_tail; |
||||
|
uint32_t next_head; |
||||
|
int ch; |
||||
|
|
||||
|
/* copy data from recv_buf to target rtt 'down' buffer */ |
||||
|
if (rtt_nodata()) |
||||
|
return RTT_IDLE; |
||||
|
|
||||
|
if ((cur_target == NULL) || rtt_channel[i].is_output || (rtt_channel[i].buf_addr == 0) || (rtt_channel[i].buf_size == 0)) |
||||
|
return RTT_IDLE; |
||||
|
|
||||
|
/* read down buffer head and tail from target */ |
||||
|
if (target_mem_read(cur_target, head_tail, rtt_channel[i].head_addr, sizeof(head_tail))) { |
||||
|
return RTT_ERR; |
||||
|
} |
||||
|
|
||||
|
buf_head = head_tail[0]; |
||||
|
buf_tail = head_tail[1]; |
||||
|
|
||||
|
if ((buf_head >= rtt_channel[i].buf_size) || (buf_tail >= rtt_channel[i].buf_size)) { |
||||
|
return RTT_ERR; |
||||
|
} |
||||
|
|
||||
|
/* write recv_buf to target rtt 'down' buf */ |
||||
|
while (((next_head = ((buf_head + 1) % rtt_channel[i].buf_size)) != buf_tail) && ((ch = rtt_getchar()) != -1)) { |
||||
|
if (target_mem_write(cur_target, rtt_channel[i].buf_addr + buf_head, &ch, 1)) { |
||||
|
return RTT_ERR; |
||||
|
} |
||||
|
|
||||
|
/* advance pointers */ |
||||
|
buf_head = next_head; |
||||
|
} |
||||
|
|
||||
|
/* update head of target 'down' buffer */ |
||||
|
if (target_mem_write(cur_target, rtt_channel[i].head_addr, &buf_head, sizeof(buf_head))) { |
||||
|
return RTT_ERR; |
||||
|
} |
||||
|
|
||||
|
return RTT_OK; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
/*********************************************************************
|
||||
|
* |
||||
|
* rtt from target to host |
||||
|
* |
||||
|
********************************************************************** |
||||
|
*/ |
||||
|
|
||||
|
/* target_mem_read, word aligned for speed.
|
||||
|
note: dest has to be len + 8 bytes, to allow for alignment and padding. |
||||
|
*/ |
||||
|
int target_aligned_mem_read(target *t, void *dest, target_addr src, size_t len) |
||||
|
{ |
||||
|
uint32_t src0 = src; |
||||
|
uint32_t len0 = len; |
||||
|
uint32_t offset = src & 0x3; |
||||
|
src0 -= offset; |
||||
|
len0 += offset; |
||||
|
if ((len0 & 0x3) != 0) len0 = (len0 + 4) & ~0x3; |
||||
|
|
||||
|
if ((src0 == src) && (len0 == len)) |
||||
|
return target_mem_read(t, dest, src, len); |
||||
|
else { |
||||
|
uint32_t retval = target_mem_read(t, dest, src0, len0); |
||||
|
memmove(dest, dest + offset, len); |
||||
|
return retval; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/* poll if target has new data for host */ |
||||
|
static rtt_retval print_rtt(target *cur_target, uint32_t i) |
||||
|
{ |
||||
|
uint32_t head; |
||||
|
uint32_t tail; |
||||
|
|
||||
|
if (!cur_target || !rtt_channel[i].is_output || (rtt_channel[i].buf_addr == 0) || (rtt_channel[i].head_addr == 0)) |
||||
|
return RTT_IDLE; |
||||
|
|
||||
|
uint32_t head_tail[2]; |
||||
|
if (target_mem_read(cur_target, head_tail, rtt_channel[i].head_addr, sizeof(head_tail))) { |
||||
|
return RTT_ERR; |
||||
|
} |
||||
|
head = head_tail[0]; |
||||
|
tail = head_tail[1]; |
||||
|
|
||||
|
if ((head >= rtt_channel[i].buf_size) || (tail >= rtt_channel[i].buf_size)) { |
||||
|
return RTT_ERR; |
||||
|
} |
||||
|
|
||||
|
if (head == tail) |
||||
|
return RTT_IDLE; |
||||
|
|
||||
|
uint32_t bytes_free = sizeof(xmit_buf) - 8; /* need 8 bytes for alignment and padding */ |
||||
|
uint32_t bytes_read = 0; |
||||
|
|
||||
|
if (tail > head) { |
||||
|
uint32_t len = rtt_channel[i].buf_size - tail; |
||||
|
if (len > bytes_free) |
||||
|
len = bytes_free; |
||||
|
if (target_aligned_mem_read(cur_target, xmit_buf + bytes_read, rtt_channel[i].buf_addr + tail, len)) |
||||
|
return RTT_ERR; |
||||
|
bytes_free -= len; |
||||
|
bytes_read += len; |
||||
|
tail = (tail + len) % rtt_channel[i].buf_size; |
||||
|
} |
||||
|
|
||||
|
if ((head > tail) && (bytes_free > 0)) { |
||||
|
uint32_t len = head - tail; |
||||
|
if (len > bytes_free) |
||||
|
len = bytes_free; |
||||
|
if (target_aligned_mem_read(cur_target, xmit_buf + bytes_read, rtt_channel[i].buf_addr + tail, len)) |
||||
|
return RTT_ERR; |
||||
|
bytes_read += len; |
||||
|
tail = (tail + len) % rtt_channel[i].buf_size; |
||||
|
} |
||||
|
|
||||
|
/* update tail on target */ |
||||
|
if (target_mem_write(cur_target, rtt_channel[i].tail_addr, &tail, sizeof(tail))) |
||||
|
return RTT_ERR; |
||||
|
|
||||
|
/* write buffer to usb */ |
||||
|
rtt_write(xmit_buf, bytes_read); |
||||
|
|
||||
|
return RTT_OK; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
/*********************************************************************
|
||||
|
* |
||||
|
* target background memory access |
||||
|
* |
||||
|
********************************************************************** |
||||
|
*/ |
||||
|
|
||||
|
/* target_no_background_memory_access() is true if the target needs to be halted during jtag memory access
|
||||
|
target_no_background_memory_access() is false if the target allows jtag memory access while running */ |
||||
|
|
||||
|
bool target_no_background_memory_access(target *cur_target) |
||||
|
{ |
||||
|
/* if error message is 'rtt: read fail at' add target to expression below.
|
||||
|
As a first approximation, assume all arm processors allow memory access while running, and no riscv does. */ |
||||
|
bool riscv_core = cur_target && target_core_name(cur_target) && strstr(target_core_name(cur_target), "RVDBG"); |
||||
|
return riscv_core; |
||||
|
} |
||||
|
|
||||
|
/*********************************************************************
|
||||
|
* |
||||
|
* rtt top level |
||||
|
* |
||||
|
********************************************************************** |
||||
|
*/ |
||||
|
|
||||
|
void poll_rtt(target *cur_target) |
||||
|
{ |
||||
|
/* rtt off */ |
||||
|
if (!cur_target || !rtt_enabled) { |
||||
|
return; |
||||
|
} |
||||
|
/* target present and rtt enabled */ |
||||
|
uint32_t now = platform_time_ms(); |
||||
|
bool rtt_err = false; |
||||
|
bool rtt_busy = false; |
||||
|
|
||||
|
if ((last_poll_ms + poll_ms <= now) || (now < last_poll_ms)) { |
||||
|
target_addr watch; |
||||
|
enum target_halt_reason reason; |
||||
|
bool resume_target = false; |
||||
|
if (!rtt_found) { |
||||
|
/* check if target needs to be halted during memory access */ |
||||
|
rtt_halt = target_no_background_memory_access(cur_target); |
||||
|
} |
||||
|
if (rtt_halt && (target_halt_poll(cur_target, &watch) == TARGET_HALT_RUNNING)) { |
||||
|
/* briefly halt target during target memory access */ |
||||
|
target_halt_request(cur_target); |
||||
|
while((reason = target_halt_poll(cur_target, &watch)) == TARGET_HALT_RUNNING); |
||||
|
resume_target = reason == TARGET_HALT_REQUEST; |
||||
|
} |
||||
|
if (!rtt_found) { |
||||
|
/* find rtt control block in target memory */ |
||||
|
find_rtt(cur_target); |
||||
|
} |
||||
|
/* do rtt i/o if control block found */ |
||||
|
if (rtt_found) { |
||||
|
for (uint32_t i = 0; i < MAX_RTT_CHAN; i++) { |
||||
|
rtt_retval v; |
||||
|
if (rtt_channel[i].is_enabled && rtt_channel[i].is_configured) { |
||||
|
if (rtt_channel[i].is_output) |
||||
|
v = print_rtt(cur_target, i); |
||||
|
else |
||||
|
v = read_rtt(cur_target, i); |
||||
|
if (v == RTT_OK) rtt_busy = true; |
||||
|
else if (v == RTT_ERR) rtt_err = true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
/* continue target if halted */ |
||||
|
if (resume_target) { |
||||
|
target_halt_resume(cur_target, false); |
||||
|
} |
||||
|
|
||||
|
/* update last poll time */ |
||||
|
last_poll_ms = now; |
||||
|
|
||||
|
/* rtt polling frequency goes up and down with rtt activity */ |
||||
|
if (rtt_busy && !rtt_err) |
||||
|
poll_ms /= 2; |
||||
|
else poll_ms *= 2; |
||||
|
if (poll_ms > rtt_max_poll_ms) poll_ms = rtt_max_poll_ms; |
||||
|
else if (poll_ms < rtt_min_poll_ms) poll_ms = rtt_min_poll_ms; |
||||
|
|
||||
|
if (rtt_err) { |
||||
|
gdb_out("rtt: err\r\n"); |
||||
|
poll_errs++; |
||||
|
if ((rtt_max_poll_errs != 0) && (poll_errs > rtt_max_poll_errs)) { |
||||
|
gdb_out("\r\nrtt lost\r\n"); |
||||
|
rtt_enabled = false; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// not truncated
|
||||
Loading…
Reference in new issue