Switch fallthrough missing break usbdfu

usbdfu should be updated later...

.gitattributes

@@ -0,0 +1,40 @@
+# Text for humans
+LICENSE text eol=lf
+HACKING text eol=lf
+COPYING text eol=lf
+UsingSWO text eol=lf
+README.* text eol=lf
+
+# Source code
+Makefile text eol=lf
+*.mk text eol=lf
+*.mak text eol=lf
+*.inc text eol=lf
+*.py text eol=lf
+*.sh text eol=lf
+*.c text eol=lf
+*.S text eol=lf
+*.s text eol=lf
+*.h text eol=lf
+*.ld text eol=lf
+*.yml text eol=lf
+*.rules text eol=lf
+
+# Git control files
+.gitattributes eol=lf
+.gitignore eol=lf
+.gitmodules eol=lf
+
+# Windows source code uses CRLF
+*.vcxproj text eol=crlf
+*.props text eol=crlf
+*.bat text eol=crlf
+*.ps1 text eol=crlf
+*.inf text eol=crlf
+
+# Other binary files
+*.png binary
+*.jpg binary
+*.bin binary
+*.elf binary
+*.bin binary

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [esden, dragonmux]
+patreon: 1bitsquared

.github/workflows/build-and-upload.yml

@@ -0,0 +1,36 @@
+name: build and upload
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the main branch
+  push:
+    branches: [ master ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v2
+
+      # Use embedded toolchain
+      - uses: numworks/setup-arm-toolchain@2020-q4
+
+      # Runs a single command using the runners shell
+      - name: Build
+        run: make
+
+      - name: Archive firmware build artifacts as a zip
+        uses: actions/upload-artifact@v2.2.4
+        with:
+          name: blackmagic-firmware.zip
+          path: src/blackmagic*
+          if-no-files-found: error

.github/workflows/build-pr.yml

@@ -0,0 +1,38 @@
+name: build PR
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the main branch
+  pull_request:
+    branches: [ master ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v2
+
+      # Use embedded toolchain
+      - uses: numworks/setup-arm-toolchain@2020-q4
+
+      # Run some of the most common build types
+      - name: Build native fw
+        run: make
+
+      - name: Clean
+        run: make clean
+
+      - name: Install BMP PC hosted dependencies
+        run: sudo apt-get -y install libftdi1-dev libhidapi-dev
+
+      - name: Build PC hosted binary
+        run: make PROBE_HOST=hosted 

.gitignore

@@ -17,4 +17,9 @@ tags
 blackmagic_upgrade
 *.exe
 .DS_Store
+*.elf
+.vscode
 cscope.out
+cscope.files
+.gdb_history
+src/artifacts/

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "libopencm3"]
 	path = libopencm3
-	url = git@github.com:flirc/libopencm3.git
+	url = https://github.com/flirc/libopencm3.git

.travis.yml

@@ -1,12 +1,11 @@
+dist: bionic
 sudo: required
 
 before_install:
   - sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
   - sudo apt-get update -qq
-  - sudo apt-get install -y build-essential libftdi-dev gcc-arm-embedded
-  - sudo pip install intelhex
-
-install: true
+  - pip install --user intelhex
+  - sudo apt-get install -y build-essential libboost-all-dev gcc-arm-embedded libusb-1.0-0-dev libhidapi-dev libftdi1 libftdi1-dev
 
 script:
   - make -C libopencm3 lib

HACKING

@@ -1 +1 @@
-See https://github.com/blacksphere/blackmagic/wiki/Hacking
+See https://github.com/blackmagic-debug/blackmagic/wiki/Hacking

Makefile

@@ -3,16 +3,37 @@ MFLAGS += --no-print-dir
 Q := @
 endif
 
+PC_HOSTED =
+NO_LIBOPENCM3 =
+ifeq ($(PROBE_HOST), hosted)
+	PC_HOSTED = true
+	NO_LIBOPENCM3 = true
+endif
+
 all:
+ifndef NO_LIBOPENCM3
 	$(Q)if [ ! -f libopencm3/Makefile ]; then \
 		echo "Initialising git submodules..." ;\
 		git submodule init ;\
 		git submodule update ;\
 	fi
-	$(Q)$(MAKE) $(MFLAGS) -C libopencm3 lib
+	$(Q)$(MAKE) $(MFLAGS) -C libopencm3 lib/sam/d
+endif
 	$(Q)$(MAKE) $(MFLAGS) -C src
 
-clean:
-	$(Q)$(MAKE) $(MFLAGS) -C libopencm3 $@
+all_platforms:
 	$(Q)$(MAKE) $(MFLAGS) -C src $@
 
+clean:
+ifndef NO_LIBOPENCM3
+	$(Q)$(MAKE) $(MFLAGS) -C libopencm3 $@
+endif
+	$(Q)$(MAKE) $(MFLAGS) -C src $@
+
+clang-tidy:
+	$(Q)scripts/run-clang-tidy.py -s "$(PWD)"
+
+clang-format:
+	$(Q)$(MAKE) $(MFLAGS) -C src $@
+
+.PHONY: clean all_platforms clang-tidy clang-format

UsingRTT.md

@@ -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)

UsingSWO

@@ -0,0 +1,260 @@
+SWO is a datastream that comes out of a single pin when the debug interface
+is in SWD mode. It can be encoded either using NRZ (UART) or RZ (Manchester)
+formats.  The pin is a dedicated one that would be used for TDO when the
+debug interface is in JTAG mode. On the STM32 it's port PB3.
+
+When in NRZ mode the SWO data rate that comes out of the chip _must_ match
+the rate that the debugger expects. By default on BMP the baudrate is
+2.25MBps but that can be changed as an optional parameter to the monitor
+traceswo command, like this;
+
+monitor traceswo 115200
+
+....would set the swo output at the low speed of 115kbps.
+
+We are constrained on maximum input speed by both the capabilities of the
+BMP STM32F103 USART and the ability to get the packets back out over the USB
+link. The UART baudrate is set by b=(72x10^6)/d...with d >= 16 or
+a maximum speed of 4.5Mbps UART1 and 2.25 Mbps on UART2.
+For continious streaming that turns out to be_too_ fast for the USB
+link, so the next available option is the 2.25Mbps that we use. ....
+You can safely use the 4.5Mbps setting if your debug data
+is bursty, or if you're using a different CPU to the STM32F103 as your BMP
+host, but you potentially run the risk of losing packets if you have long
+runs of sending which the usb cannot flush in time (there's a 12K buffer, so
+the it is a pretty long run before it becomes a problem).
+
+Note that the baudrate equation means there are only certain speeds
+available. The highest:
+BRR        USART1(stlink)  USART2(swlink)
+16    	   4.50  Mbps      2.25  Mbps
+17	   4.235 Mbps 	   2.118 Mbps
+18	   4.000 Mbps 	   2.0   Mbps
+19	   3.789 Mbps 	   1.895 Mbps
+20	   3.600 Mbps 	   1.8   Mbps
+...
+24	   3.0   Mbps      1.5   Mbps
+...
+36         2.0   Mbps      1.0   Mbps
+
+...the USART will cope with some timing slip, but it's advisible to stay as
+close to these values as you can. As the speed comes down the spread between
+each valid value so mis-timing is less of an issue. The 'monitor traceswo
+<x>' command will automatically find the closest divisor to the value you
+set for the speed, so be aware the error could be significant.
+
+Depending on what you're using to wake up SWO on the target side, you may
+need code to get it into the correct mode and emitting data. You can do that
+via gdb direct memory accesses, or from program code.
+
+An example for a STM32F103 for the UART (NRZ) data format that we use;
+
+    /* STM32 specific configuration to enable the TRACESWO IO pin */
+    RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;
+    AFIO->MAPR |= (2 << 24); // Disable JTAG to release TRACESWO
+    DBGMCU->CR |= DBGMCU_CR_TRACE_IOEN; // Enable IO trace pins
+
+    TPI->ACPR = 31;  // Output bits at 72000000/(31+1)=2.25MHz.
+    TPI->SPPR = 2;   // Use Async mode (1 for RZ/Manchester)
+    TPI-FFCR  = 0;   // Disable formatter
+
+    /* Configure instrumentation trace macroblock */
+    ITM->LAR = 0xC5ACCE55;
+    ITM->TCR = 1 << ITM_TCR_TraceBusID_Pos | ITM_TCR_SYNCENA_Msk |
+               ITM_TCR_ITMENA_Msk;
+    ITM->TER = 0xFFFFFFFF; // Enable all stimulus ports
+
+Code for the STM32L476 might look like:
+#define BAUDRATE 115200
+    DBGMCU->CR |= DBGMCU_CR_TRACE_IOEN; /* Enable IO pins for Async trace */
+    uint32_t divisor, clk_frequency;
+    clk_frequency = NutGetCpuClock();
+    divisor = clk_frequency / BAUDRATE;
+    divisor--;
+    TPI->CSPSR = 1; /* port size = 1 bit */
+    TPI->ACPR = divisor;
+    TPI->SPPR = 2; /*Use Async mode pin protocol */
+    TPI->FFCR = 0x00; /* Bypass the TPIU formatter and send output directly*/
+
+/* Configure Trace Port Interface Unit */
+    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; // Enable access to registers
+    DWT->CTRL = 0x400003FE; // DWT needs to provide sync for ITM
+    ITM->LAR = 0xC5ACCE55; // Allow access to the Control Register
+    ITM->TPR = 0x0000000F; // Trace access privilege from user level code, please
+    ITM->TCR = 0x0001000D; // ITM_TCR_TraceBusID_Msk | ITM_TCR_DWTENA_Msk | ITM_TCR_SYNCENA_Msk | ITM_TCR_ITMENA_Msk
+    ITM->TER = 1; // Only Enable stimulus port 1
+
+    while(1) {
+        for (uint32_t i = 'A'; i <= 'Z'; i++) {
+            ITM_SendChar(i);
+            NutSleep(1);
+        }
+    }
+
+If you're using RZ mode (e.g. on a genuine BMP) then you will need the trace
+output speed to be quite a lot lower...in the order of 200kHz by means of
+changing the divisor to something like 359.  That's because the STM32F103
+doesn't have a dedicated RZ decoder so it all has to be done in
+software. The advantage of RZ is that the probe can adapt to the speed of
+the target, so you don't have to set the speed on the probe in the monitor
+traceswo command, and it will be tolerant of different speeds.
+
+The SWO data appears on USB Interface 5, Endpoint 5.
+
+SWOListen
+=========
+A program swolisten.c is found in ./scripts which will listen to this
+endpoint, decode the datastream, and output it to a set of unix fifos which
+can then be used as the input to other programs (e.g. cat, or something more
+sophisticated like gnuplot, octave or whatever). This program doesn't care
+if the data originates from a RZ or NRZ port, or at what speed.
+
+Note that swolisten can be used with either BMP firmware, or with a
+conventional TTL serial dongle. See at the bottom of this file for
+information on how to use a dongle.
+
+The command line to build the swolisten tool may look like:
+
+E.g. for Ubuntu
+gcc -I /usr/local/include/libusb-1.0 -L /usr/local/lib swolisten.c -o swolisten -lusb-1.0
+
+E.g. For Opensuse:
+gcc -I /usr/include/libusb-1.0 swolisten.c  swolisten -std=gnu99 -g -Og -lusb-1.0
+
+...you will obviously need to change the paths to your libusb files.
+
+Attach to BMP to your PC:
+Start gdb:                "arm-none-eabi-gdb"
+Choose bmp as target, like:
+                          "target extended /dev/ttyACM0(*)"
+Start SWO output:         "mon traceswo"
+If async SWO is used, give the baudrate your device sends
+out as argument. 2.25 MBaud is the default, for the STM32L476 example above
+the command would be:     "mon traceswo 115200(*)".
+Scan the SWD              "mon swdp_scan"
+Attach to the device: :   "attach 1"
+Start the program:        "r".
+(*) Your milage may vary
+Now start swolisten without further options.
+
+By default the tool will create fifos for the first 32 channels in a
+directory swo (which you will need to create) as follows;
+
+>ls swo/
+chan00 chan02 chan04 chan06 chan08 chan0A chan0C chan0E chan10 chan12 chan14
+chan16 chan18 chan1A chan1C chan1E chan01 chan03 chan05 chan07 chan09 chan0B
+chan0D chan0F chan11 chan13 chan15 chan17 chan19 chan1B chan1D chan1F
+
+>cat swo/channel0
+<<OUTPUT FROM ITM Channel 0>>
+
+With the F103 and L476 examples above, an endless stream of
+"ABCDEFGHIJKLMNOPQRSTUVWXYZ" should be seen. During reset of the target
+device, no output will appear, but with release of reset output restarts.
+
+Information about command line options can be found with the -h option.
+swolisten is specifically designed to be 'hardy' to probe and target
+disconnects and restarts (y'know, like you get in the real world). The
+intention being to give you streams whenever it can get them.  It does _not_
+require gdb to be running. For the time being traceswo is not turned on by
+default in the BMP to avoid possible interactions and making the overall
+thing less reliable so You do need gdb to send the initial 'monitor
+traceswo' to the probe, but beyond that there's no requirement for gdb to be
+present.
+
+Reliability
+===========
+
+A whole chunk of work has gone into making sure the dataflow over the SWO
+link is reliable.  The TL;DR is that the link _is_ reliable. There are
+factors outside of our control (i.e. the USB bus you connect to) that could
+potentially break the reliabilty but there's not too much we can do about
+that since the SWO link is unidirectional (no opportunity for
+re-transmits). The following section provides evidence for the claim that
+the link is good;
+
+A test 'mule' sends data flat out to the link at the maximum data rate of
+2.25Mbps using a loop like the one below;
+
+while (1)
+{
+    for (uint32_t r=0; r<26; r++)
+    {
+        for (uint32_t g=0; g<31; g++)
+        {
+            ITM_SendChar('A'+r);
+        }
+        ITM_SendChar('\n');
+    }
+}
+
+100MB of data (more than 200MB of actual SWO packets, due to the encoding) was sent from the mule to the BMP where the
+output from swolisten chan00 was cat'ted into a file;
+
+>cat swo/chan00 > o
+
+....this process was interrupted once the file had grown to 100MB. The first
+and last lines were removed from it (these represent previously buffered
+data and an incomplete packet at the point where the capture was
+interrupted) and the resulting file analysed for consistency;
+
+> sort o | uniq -c
+
+The output was;
+
+126462 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+126462 BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
+126462 CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+126462 DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
+126461 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
+126461 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+126461 GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+126461 HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
+126461 IIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+126461 JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
+126461 KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
+126461 LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
+126461 MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
+126461 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
+126461 OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
+126461 PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+126461 QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
+126461 RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
+126461 SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
+126461 TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+126461 UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
+126461 VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
+126461 WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
+126461 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+126461 YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
+126461 ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+
+(On inspection, the last line of recorded data was indeed a 'D' line).
+
+Swolisten, using a TTL Serial Dongle
+====================================
+
+The NRZ data that comes out of the SWO is just UART formatted, but in a
+frame.  swolisten has been extended to accomodate TTL Serial Dongles that
+can pick this up.  Success has been had with CP2102 dongles at up to 921600
+baud.
+
+To use this mode just connect SWO to the RX pin of your dongle, and start
+swolisten with parameters representing the speed and port. An example;
+
+>./swolisten -p /dev/cu.SLAB_USBtoUART -v -b swo/ -s 921600
+
+Any individual dongle will only support certain baudrates (Generally
+multiples of 115200) so you may have to experiment to find the best
+supported ones.  For the CP2102 dongle 1.3824Mbps wasn't supported and
+1.8432Mbps returned corrupted data.
+
+Please email dave@marples.net with information about dongles you find work
+well and at what speed.
+
+Further information
+===================
+SWO is a wide field. Read e.g. the blogs around SWD on
+http://shadetail.com/blog/swo-starting-the-steroids/
+An open source program suite for SWO under active development is
+https://github.com/mubes/orbuculum

driver/99-blackmagic.rules

@@ -0,0 +1,8 @@
+# Black Magic Probe
+# there are two connections, one for GDB and one for UART debugging
+# copy this to /etc/udev/rules.d/99-blackmagic.rules
+# and run /usr/sbin/udevadm control --reload-rules
+SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic GDB Server", SYMLINK+="ttyBmpGdb"
+SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic UART Port", SYMLINK+="ttyBmpTarg"
+SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTR{idVendor}=="1d50", ATTR{idProduct}=="6017", MODE="0666"
+SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTR{idVendor}=="1d50", ATTR{idProduct}=="6018", MODE="0666"

driver/blackmagic.inf

@@ -13,17 +13,17 @@
 Signature="$Windows NT$"
 Class=Ports
 ClassGuid={4D36E978-E325-11CE-BFC1-08002BE10318}
-Provider=%BLACKSPHERE%
+Provider=%BLACKMAGIC%
 DriverVer=28/12/2011,0.0.1.1
 
 [Manufacturer]
 %VendorName%=DeviceList, NTamd64
 
 [Strings]
-VendorName = "Black Sphere Technologies"
+VendorName = "Black Magic Debug"
 BLACKMAGICGDB = "Black Magic GDB Server"
 BLACKMAGICUART = "Black Magic UART Port"
-BLACKSPHERE_DISPLAY_NAME = "Black Magic Probe Driver"
+BLACKMAGIC_DISPLAY_NAME = "Black Magic Probe Driver"
 
 [DeviceList]
 %BLACKMAGICGDB%=DriverInstall, USB\VID_1d50&PID_6018&Rev_0100&MI_00
@@ -55,7 +55,7 @@ HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"
 AddService = usbser,0x0002,DriverService.nt
 
 [DriverService.nt]
-DisplayName = %BLACKSPHERE_DISPLAY_NAME%
+DisplayName = %BLACKMAGIC_DISPLAY_NAME%
 ServiceType = 1                  ; SERVICE_KERNEL_DRIVER
 StartType = 3                    ; SERVICE_DEMAND_START
 ErrorControl = 1                 ; SERVICE_ERROR_NORMAL
@@ -80,7 +80,7 @@ HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"
 AddService = usbser,0x0002,DriverService.NTamd64
 
 [DriverService.NTamd64]
-DisplayName = %BLACKSPHERE_DISPLAY_NAME%
+DisplayName = %BLACKMAGIC_DISPLAY_NAME%
 ServiceType = 1                  ; SERVICE_KERNEL_DRIVER
 StartType = 3                    ; SERVICE_DEMAND_START
 ErrorControl = 1                 ; SERVICE_ERROR_NORMAL

driver/blackmagic_upgrade.inf

@@ -4,7 +4,7 @@
 DeviceName = "Black Magic Firmware Upgrade"
 DeviceNameDFU = "Black Magic Probe (Upgrade)"
 DeviceNameTPA = "Black Magic Trace Capture"
-VendorName = "Black Sphere Technologies"
+VendorName = "Black Magic Debug"
 SourceName = "Black Magic Firmware Upgrade Install Disk"
 DeviceID   = "VID_1d50&PID_6018&Rev_0100&MI_04"
 DeviceIDDFU= "VID_1d50&PID_6017&Rev_0100"

libopencm3

@@ -1 +1 @@
-Subproject commit 832eb832fff85d0ecab461310466cf18b2f6006d
+Subproject commit 63573143ef7e1b037d1f0c5baedc5264e12562b8

scripts/bootprog.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # bootprog.py: STM32 SystemMemory Production Programmer -- version 1.1
 # Copyright (C) 2011  Black Sphere Technologies 
@@ -23,107 +23,105 @@ from time import sleep
 
 class stm32_boot:
 	def __init__(self, port, baud=115200):
-		self.serial = serial.Serial(port, baud, 8, 'E', 1, 
+		self.serial = serial.Serial(port, baud, 8, 'E', 1,
 				timeout=1)
 
 		# Turn on target device in SystemMemory boot mode
 		self.serial.setDTR(1)
-		sleep(0.1);
+		sleep(0.1)
 
 		self._sync()
 
 	def _sync(self):
 		# Send sync byte
-		#print "sending sync byte"
-		self.serial.write("\x7F")
+		#print("sending sync byte")
+		self.serial.write(b"\x7f")
 		self._checkack()
 
 	def _sendcmd(self, cmd):
-		if type(cmd) == int:
-			cmd = chr(cmd)
-		cmd += chr(ord(cmd) ^ 0xff)
-		#print "sendcmd:", repr(cmd)
+		cmd = ord(cmd)
+		cmd = bytes((cmd, cmd ^ 0xff))
+		#print("sendcmd:", repr(cmd))
 		self.serial.write(cmd)
 
 	def _send(self, data):
 		csum = 0
-		for c in data: csum ^= ord(c)
-		data = data + chr(csum)
-		#print "sending:", repr(data)
+		for c in data: csum ^= c
+		data = data + bytes((csum,))
+		#print("sending:", repr(data))
 		self.serial.write(data)
 
 	def _checkack(self):
-		ACK = "\x79"
+		ACK = b"\x79"
 		b = self.serial.read(1)
 		if b != ACK: raise Exception("Invalid ack: %r" % b)
-		#print "got ack!"
+		#print("got ack!")
 
 
 
 	def get(self):
-		self._sendcmd("\x00")
+		self._sendcmd(b"\x00")
 		self._checkack()
-		num = ord(self.serial.read(1))
+		num = self.serial.read(1)[0]
 		data = self.serial.read(num+1)
 		self._checkack()
 		return data
 
 	def eraseall(self):
 		# Send erase cmd
-		self._sendcmd("\x43")
+		self._sendcmd(b"\x43")
 		self._checkack()
 		# Global erase
-		self._sendcmd("\xff")
+		self._sendcmd(b"\xff")
 		self._checkack()
 
 	def read(self, addr, len):
 		# Send read cmd
-		self._sendcmd("\x11")
+		self._sendcmd(b"\x11")
 		self._checkack()
 		# Send address
 		self._send(struct.pack(">L", addr))
 		self._checkack()
 		# Send length
-		self._sendcmd(chr(len-1))
+		self._sendcmd(bytes((len-1,)))
 		self._checkack()
 		return self.serial.read(len)
 
 	def write(self, addr, data):
 		# Send write cmd
-		self._sendcmd("\x31")
+		self._sendcmd(b"\x31")
 		self._checkack()
 		# Send address
 		self._send(struct.pack(">L", addr))
 		self._checkack()
 		# Send data
-		self._send(chr(len(data)-1) + data)
+		self._send(bytes((len(data)-1,)) + data)
 		self._checkack()
-	
 
 	def write_protect(self, sectors):
 		# Send WP cmd
-		self._sendcmd("\x63")
+		self._sendcmd(b"\x63")
 		self._checkack()
 		# Send sector list
-		self._send(chr(len(sectors)-1) + "".join(chr(i) for i in sectors))
+		self._send(bytes((len(sectors)-1,)) + bytes(sectors))
 		self._checkack()
 		# Resync after system reset
 		self._sync()
 
 	def write_unprotect(self):
-		self._sendcmd("\x73")
+		self._sendcmd(b"\x73")
 		self._checkack()
 		self._checkack()
 		self._sync()
 
 	def read_protect(self):
-		self._sendcmd("\x82")
+		self._sendcmd(b"\x82")
 		self._checkack()
 		self._checkack()
 		self._sync()
 
 	def read_unprotect(self):
-		self._sendcmd("\x92")
+		self._sendcmd(b"\x92")
 		self._checkack()
 		self._checkack()
 		self._sync()
@@ -133,12 +131,12 @@ if __name__ == "__main__":
 	from sys import stdout, argv, platform
 	from getopt import getopt
 
-	if platform == "linux2":
-		print  "\x1b\x5b\x48\x1b\x5b\x32\x4a" # clear terminal screen
-	print "STM32 SystemMemory Production Programmer -- version 1.1"
-	print "Copyright (C) 2011  Black Sphere Technologies"
-	print "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>"
-	print
+	if platform == "linux":
+		print("\x1b\x5b\x48\x1b\x5b\x32\x4a") # clear terminal screen
+	print("STM32 SystemMemory Production Programmer -- version 1.1")
+	print("Copyright (C) 2011  Black Sphere Technologies")
+	print("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>")
+	print()
 
 	dev = "COM1" if platform == "win32" else "/dev/ttyUSB0"
 	baud = 115200
@@ -152,38 +150,38 @@ if __name__ == "__main__":
 
 		progfile = args[0]
 	except:
-		print "Usage %s [-d <dev>] [-b <baudrate>] [-a <address>] <filename>" % argv[0]
-		print "\t-d : Use target on interface <dev> (default: %s)" % dev
-		print "\t-b : Set device baudrate (default: %d)" % baud
-		print "\t-a : Set programming address (default: 0x%X)" % addr
-		print
+		print("Usage %s [-d <dev>] [-b <baudrate>] [-a <address>] <filename>" % argv[0])
+		print("\t-d : Use target on interface <dev> (default: %s)" % dev)
+		print("\t-b : Set device baudrate (default: %d)" % baud)
+		print("\t-a : Set programming address (default: 0x%X)" % addr)
+		print()
 		exit(-1)
 
 	prog = open(progfile, "rb").read()
 	boot = stm32_boot(dev, baud)
 
 	cmds = boot.get()
-	print "Target bootloader version: %d.%d\n" % (ord(cmds[0]) >> 4, ord(cmds[0]) % 0xf)
+	print("Target bootloader version: %d.%d\n" % (cmds[0] >> 4, cmds[0] % 0xf))
 
-	print "Removing device protection..."
+	print("Removing device protection...")
 	boot.read_unprotect()
 	boot.write_unprotect()
-	print "Erasing target device..."
+	print("Erasing target device...")
 	boot.eraseall()
 	addr = 0x8000000
 	while prog:
-		print ("Programming address 0x%08X..0x%08X...\r" % (addr, addr + min(len(prog), 255))),
-		stdout.flush();
+		print("Programming address 0x%08X..0x%08X...\r" % (addr, addr + min(len(prog), 255)), end=' ')
+		stdout.flush()
 		boot.write(addr, prog[:256])
 		addr += 256
 		prog = prog[256:]
 
 	print
-	print "Enabling device protection..."
+	print("Enabling device protection...")
 	boot.write_protect(range(0,2))
 	#boot.read_protect()
 
-	print "All operations completed."
+	print("All operations completed.")
 	print
 
 

scripts/dfu-convert.py

@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python3
 
 # Written by Antonio Galea - 2010/11/18
 # Distributed under Gnu LGPL 3.0
@@ -16,57 +16,64 @@ def consume(fmt,data,names):
   n = struct.calcsize(fmt)
   return named(struct.unpack(fmt,data[:n]),names),data[n:]
 def cstring(string):
-  return string.split('\0',1)[0]
+  return string.split(b'\0',1)[0]
 def compute_crc(data):
   return 0xFFFFFFFF & -zlib.crc32(data) -1
 
 def parse(file,dump_images=False):
-  print 'File: "%s"' % file
+  print('File: "%s"' % file)
   data = open(file,'rb').read()
   crc = compute_crc(data[:-4])
   prefix, data = consume('<5sBIB',data,'signature version size targets')
-  print '%(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d' % prefix
+  print('%(signature)r v%(version)d, image size: %(size)d, targets: %(targets)d' % prefix)
   for t in range(prefix['targets']):
     tprefix, data  = consume('<6sBI255s2I',data,'signature altsetting named name size elements')
     tprefix['num'] = t
     if tprefix['named']:
       tprefix['name'] = cstring(tprefix['name'])
     else:
-      tprefix['name'] = ''
-    print '%(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d' % tprefix
+      tprefix['name'] = b''
+    print('%(signature)r %(num)d, alt setting: %(altsetting)r, name: %(name)r, size: %(size)d, elements: %(elements)d' % tprefix)
     tsize = tprefix['size']
     target, data = data[:tsize], data[tsize:]
     for e in range(tprefix['elements']):
       eprefix, target = consume('<2I',target,'address size')
       eprefix['num'] = e
-      print '  %(num)d, address: 0x%(address)08x, size: %(size)d' % eprefix
+      print('  %(num)d, address: 0x%(address)08x, size: %(size)d' % eprefix)
       esize = eprefix['size']
       image, target = target[:esize], target[esize:]
       if dump_images:
         out = '%s.target%d.image%d.bin' % (file,t,e)
         open(out,'wb').write(image)
-        print '    DUMPED IMAGE TO "%s"' % out
+        print('    DUMPED IMAGE TO "%s"' % out)
     if len(target):
-      print "target %d: PARSE ERROR" % t
+      print("target %d: PARSE ERROR" % t)
   suffix = named(struct.unpack('<4H3sBI',data[:16]),'device product vendor dfu ufd len crc')
-  print 'usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x' % suffix
+  print('usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)r, %(len)d, 0x%(crc)08x' % suffix)
   if crc != suffix['crc']:
-    print "CRC ERROR: computed crc32 is 0x%08x" % crc
+    print("CRC ERROR: computed crc32 is 0x%08x" % crc)
   data = data[16:]
   if data:
-    print "PARSE ERROR"
+    print("PARSE ERROR")
 
 def build(file,targets,device=DEFAULT_DEVICE):
-  data = ''
+  data = b''
   for t,target in enumerate(targets):
-    tdata = ''
+    tdata = b''
     for image in target:
       tdata += struct.pack('<2I',image['address'],len(image['data']))+image['data']
-    tdata = struct.pack('<6sBI255s2I','Target',0,1,'ST...',len(tdata),len(target)) + tdata
+
+    trgt = b'Target'
+    st = b'ST...'
+    tdata = struct.pack('<6sBI255s2I',trgt,0,1,st,len(tdata),len(target)) + tdata
     data += tdata
-  data  = struct.pack('<5sBIB','DfuSe',1,len(data)+11,len(targets)) + data
+
+  dfu_se = b'DfuSe'
+  ufd = b'UFD'
+  data = struct.pack('<5sBIB',dfu_se,1,len(data)+11,len(targets)) + data
+
   v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
-  data += struct.pack('<4H3sB',0,d,v,0x011a,'UFD',16)
+  data += struct.pack('<4H3sB',0,d,v,0x011a,ufd,16)
   crc   = compute_crc(data)
   data += struct.pack('<I',crc)
   open(file,'wb').write(data)
@@ -96,15 +103,15 @@ if __name__=="__main__":
         try:
           address,binfile = arg.split(':',1)
         except ValueError:
-          print "Address:file couple '%s' invalid." % arg
+          print("Address:file couple '%s' invalid." % arg)
           sys.exit(1)
         try:
           address = int(address,0) & 0xFFFFFFFF
         except ValueError:
-          print "Address %s invalid." % address
+          print("Address %s invalid." % address)
           sys.exit(1)
         if not os.path.isfile(binfile):
-          print "Unreadable file '%s'." % binfile
+          print("Unreadable file '%s'." % binfile)
           sys.exit(1)
         target.append({ 'address': address, 'data': open(binfile,'rb').read() })
     
@@ -116,7 +123,7 @@ if __name__=="__main__":
         try:
           address = address & 0xFFFFFFFF
         except ValueError:
-          print "Address %s invalid." % address
+          print("Address %s invalid." % address)
           sys.exit(1)
         target.append({ 'address': address, 'data': data })
     
@@ -127,13 +134,13 @@ if __name__=="__main__":
     try:
       v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
     except:
-      print "Invalid device '%s'." % device
+      print("Invalid device '%s'." % device)
       sys.exit(1)
     build(outfile,[target],device)
   elif len(args)==1:
     infile = args[0]
     if not os.path.isfile(infile):
-      print "Unreadable file '%s'." % infile
+      print("Unreadable file '%s'." % infile)
       sys.exit(1)
     parse(infile, dump_images=options.dump_images)
   else:

scripts/dfu.py

@@ -1,7 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # dfu.py: Access USB DFU class devices
-# Copyright (C) 2009  Black Sphere Technologies 
+# Copyright (C) 2009  Black Sphere Technologies
 # Written by Gareth McMullin <gareth@blacksphere.co.nz>
 #
 # This program is free software: you can redistribute it and/or modify
@@ -17,12 +17,12 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
- 
+
 import usb
 
 DFU_DETACH_TIMEOUT = 1000
 
-# DFU Requests 
+# DFU Requests
 DFU_DETACH = 0x00
 DFU_DNLOAD = 0x01
 DFU_UPLOAD = 0x02
@@ -62,7 +62,7 @@ DFU_STATUS_ERROR_POR =           0x0d
 DFU_STATUS_ERROR_UNKNOWN =       0x0e
 DFU_STATUS_ERROR_STALLEDPKT =    0x0f
 
-class dfu_status(object):
+class dfu_status:
 	def __init__(self, buf):
 		self.bStatus = buf[0]
 		self.bwPollTimeout = buf[1] + (buf[2]<<8) + (buf[3]<<16)
@@ -70,7 +70,7 @@ class dfu_status(object):
 		self.iString = buf[5]
 
 
-class dfu_device(object):
+class dfu_device:
 	def __init__(self, dev, conf, iface):
 		self.dev = dev
 		self.conf = conf
@@ -84,41 +84,43 @@ class dfu_device(object):
 			self.index = self.iface.interfaceNumber
 		else:	self.index = self.iface
 
+	def release(self):
+		self.handle.releaseInterface()
 	def detach(self, wTimeout=255):
-		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS | 
-			usb.RECIP_INTERFACE, DFU_DETACH, 
+		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
+			usb.RECIP_INTERFACE, DFU_DETACH,
 			None, value=wTimeout, index=self.index)
 
 	def download(self, wBlockNum, data):
 		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
 			usb.RECIP_INTERFACE, DFU_DNLOAD,
-			data, value=wBlockNum, index=self.index) 
+			data, value=wBlockNum, index=self.index)
 
 	def upload(self, wBlockNum, length):
-		return self.handle.controlMsg(usb.ENDPOINT_IN | 
+		return self.handle.controlMsg(usb.ENDPOINT_IN |
 			usb.TYPE_CLASS | usb.RECIP_INTERFACE, DFU_UPLOAD,
-			length, value=wBlockNum, index=self.index) 
+			length, value=wBlockNum, index=self.index)
 
 	def get_status(self):
-		buf = self.handle.controlMsg(usb.ENDPOINT_IN | 
+		buf = self.handle.controlMsg(usb.ENDPOINT_IN |
 			usb.TYPE_CLASS | usb.RECIP_INTERFACE, DFU_GETSTATUS,
-			6, index=self.index) 
+			6, index=self.index)
 		return dfu_status(buf)
-		
+
 	def clear_status(self):
-		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS | 
-			usb.RECIP_INTERFACE, DFU_CLRSTATUS, 
+		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
+			usb.RECIP_INTERFACE, DFU_CLRSTATUS,
 			"", index=0)
 
 	def get_state(self):
-		buf = self.handle.controlMsg(usb.ENDPOINT_IN | 
+		buf = self.handle.controlMsg(usb.ENDPOINT_IN |
 			usb.TYPE_CLASS | usb.RECIP_INTERFACE, DFU_GETSTATE,
-			1, index=self.index) 
+			1, index=self.index)
 		return buf[0]
 
 	def abort(self):
-		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS | 
-			usb.RECIP_INTERFACE, DFU_ABORT, 
+		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
+			usb.RECIP_INTERFACE, DFU_ABORT,
 			None, index=self.index)
 
 
@@ -136,7 +138,7 @@ class dfu_device(object):
 			if status.bState == STATE_DFU_IDLE:
 				return True
 
-			if ((status.bState == STATE_DFU_DOWNLOAD_SYNC) or 
+			if ((status.bState == STATE_DFU_DOWNLOAD_SYNC) or
 			    (status.bState == STATE_DFU_DOWNLOAD_IDLE) or
 			    (status.bState == STATE_DFU_MANIFEST_SYNC) or
 			    (status.bState == STATE_DFU_UPLOAD_IDLE) or
@@ -155,7 +157,7 @@ class dfu_device(object):
 
 			if ((status.bState == STATE_APP_DETACH) or
 			    (status.bState == STATE_DFU_MANIFEST_WAIT_RESET)):
-                		usb.reset(self.handle)
+				usb.reset(self.handle)
 				return False
 
 		raise Exception
@@ -176,16 +178,16 @@ def finddevs():
 if __name__ == "__main__":
 	devs = finddevs()
 	if not devs:
-		print "No devices found!"
+		print("No devices found!")
 		exit(-1)
 
 	for dfu in devs:
 		handle = dfu[0].open()
 		man = handle.getString(dfu[0].iManufacturer, 30)
 		product = handle.getString(dfu[0].iProduct, 30)
-		print "Device %s: ID %04x:%04x %s - %s" % (dfu[0].filename, 
-			dfu[0].idVendor, dfu[0].idProduct, man, product)
-		print "%r, %r" % (dfu[1], dfu[2])
+		print("Device %s: ID %04x:%04x %s - %s" % (dfu[0].filename,
+			dfu[0].idVendor, dfu[0].idProduct, man, product))
+		print("%r, %r" % (dfu[1], dfu[2]))
 
 
 

scripts/gdb.py

@@ -1,9 +1,9 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # gdb.py: Python module for low level GDB protocol implementation
 # Copyright (C) 2009  Black Sphere Technologies
 # Written by Gareth McMullin <gareth@blacksphere.co.nz>
-# 
+#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -24,24 +24,18 @@ import struct
 import time
 
 def hexify(s):
-	"""Convert a binary string into hex representation"""
-	ret = ''
-	for c in s:
-		ret += "%02X" % ord(c)
-	return ret
+	"""Convert a bytes object into hex bytes representation"""
+	return s.hex().encode()
 
 def unhexify(s):
-	"""Convert a hex string into binary representation"""
-	ret = ''
-	for i in range(0, len(s), 2):
-		ret += chr(int(s[i:i+2], 16))
-	return ret
+	"""Convert a hex-encoded bytes into bytes object"""
+	return bytes.fromhex(s.decode())
 
 class FakeSocket:
 	"""Emulate socket functions send and recv on a file object"""
 	def __init__(self, file):
 		self.file = file
-	
+
 	def send(self, data):
 		self.file.write(data)
 
@@ -52,148 +46,186 @@ class Target:
 	def __init__(self, sock):
 		if "send" in dir(sock):
 			self.sock = sock
-		else:	
+		else:
 			self.sock = FakeSocket(sock)
 
+		self.PacketSize=0x100 # default
+
 	def getpacket(self):
 		"""Return the first correctly received packet from GDB target"""
 		while True:
-			while self.sock.recv(1) != '$': pass
+			while self.sock.recv(1) != b'$':
+				pass
+
 			csum = 0
-			packet = ''
+			packet = [] # list-of-small-int
 
 			while True:
-				c = self.sock.recv(1)
-				if c == '#': break
+				c, = self.sock.recv(1)
+				if c == ord('#'):
+					break
 
-				if c == '$':
-					packet = ''
+				if c == ord('$'):
+					packet = []
 					csum = 0
 					continue
 
-				if c == '}':
-					c = self.sock.recv(1)
-					csum += ord(c) + ord('}')
-					packet += chr(ord(c) ^ 0x20)
-					continue	
+				if c == ord('}'):
+					c, = self.sock.recv(1)
+					csum += c + ord('}')
+					packet.append(c ^ 0x20)
+					continue
 
-				packet += c
-				csum += ord(c)
+				packet.append(c)
+				csum += c
 
-			if (csum & 0xFF) == int(self.sock.recv(2),16): break
+			if (csum & 0xFF) == int(self.sock.recv(2),16):
+				break
 
-			self.sock.send('-')
-		
-		self.sock.send('+')
-		return packet
+			self.sock.send(b'-')
 
+		self.sock.send(b'+')
+		return bytes(packet)
 
 	def putpacket(self, packet):
-		"""Send packet to GDB target and wait for acknowledge"""
+		"""Send packet to GDB target and wait for acknowledge
+		packet is bytes or string"""
+
+		if type(packet) == str:
+			packet = packet.encode()
+
 		while True:
-			self.sock.send('$')
-			csum = 0
+			out = []
+
 			for c in packet:
-				if (c == '$') or (c == '#') or (c == '}'):
-					self.sock.send('}')
-					self.sock.send(chr(ord(c) ^ 0x20))
-					csum += (ord(c) ^ 0x20) + ord('}')
+				if (c in b'$#}'):
+					out.append(ord('}'))
+					out.append(c ^ 0x20)
 				else:
-					self.sock.send(c)
-					csum += ord(c)
-			self.sock.send('#')
-			self.sock.send("%02X" % (csum & 0xFF))
-			if self.sock.recv(1) == '+': break
+					out.append(c)
+
+			csum = sum(out)
+			outb = b'$'+bytes(out)+b'#%02X' % (csum & 0xff)
+
+			self.sock.send(outb)
+			if self.sock.recv(1) == b'+':
+				break
 
 	def monitor(self, cmd):
 		"""Send gdb "monitor" command to target"""
+		if type(cmd) == str:
+			cmd = cmd.encode()
+
 		ret = []
-		self.putpacket("qRcmd," + hexify(cmd))
+		self.putpacket(b"qRcmd," + hexify(cmd))
 
 		while True:
 			s = self.getpacket()
-			if s == '': return None
-			if s == 'OK': return ret
-			if s.startswith('O'): ret.append(unhexify(s[1:]))
+
+			if s == b'':
+				return None
+			if s == b'OK':
+				return ret
+			if s.startswith(b'O'):
+				ret.append(unhexify(s[1:]))
 			else:
-				raise Exception('Invalid GDB stub response')
+				raise Exception('Invalid GDB stub response %r'%s.decode())
 
 	def attach(self, pid):
 		"""Attach to target process (gdb "attach" command)"""
-		self.putpacket("vAttach;%08X" % pid)
+		self.putpacket(b"vAttach;%08X" % pid)
 		reply = self.getpacket()
-		if (len(reply) == 0) or (reply[0] == 'E'): 
+		if (reply == b'') or (reply[:1] == b'E'):
 			raise Exception('Failed to attach to remote pid %d' % pid)
 
 	def detach(self):
 		"""Detach from target process (gdb "detach" command)"""
-		self.putpacket("D")
-		if self.getpacket() != 'OK': 
+		self.putpacket(b"D")
+		if self.getpacket() != b'OK':
 			raise Exception("Failed to detach from remote process")
 
 	def reset(self):
 		"""Reset the target system"""
-		self.putpacket("r")
+		self.putpacket(b"r")
 
 	def read_mem(self, addr, length):
 		"""Read length bytes from target at address addr"""
-		self.putpacket("m%08X,%08X" % (addr, length))
-		reply = self.getpacket()
-		if (len(reply) == 0) or (reply[0] == 'E'): 
-			raise Exception('Error reading memory at 0x%08X' % addr)
-		try:
-			data = unhexify(reply)
-		except Excpetion:
-			raise Exception('Invalid response to memory read packet: %r' % reply)
-		return data
-		
+		ret = b''
+		while length:
+			# print("Read")
+			packlen = min(length,self.PacketSize//2)
+			self.putpacket(b"m%08X,%08X" % (addr, packlen))
+			reply = self.getpacket()
+			if (reply == b'') or (reply[:1] == b'E'):
+				raise Exception('Error reading memory at 0x%08X' % addr)
+			try:
+				data = unhexify(reply)
+			except Exception:
+				raise Exception('Invalid response to memory read packet: %r' % reply)
+			ret += data
+			length -= packlen
+			addr += packlen
+
+		return ret
+
 	def write_mem(self, addr, data):
 		"""Write data to target at address addr"""
-		self.putpacket("X%08X,%08X:%s" % (addr, len(data), data))
-		if self.getpacket() != 'OK': 
-			raise Exception('Error writing to memory at 0x%08X' % addr)
+		data = bytes(data)
+
+		while data:
+			d = data[:self.PacketSize-44]
+			data = data[len(d):]
+			#print("Writing %d bytes at 0x%X" % (len(d), addr))
+			pack = b"X%08X,%08X:%s" % (addr, len(d), d)
+			self.putpacket(pack)
+
+			if self.getpacket() != b'OK':
+				raise Exception('Error writing to memory at 0x%08X' % addr)
+			addr += len(d)
 
 	def read_regs(self):
 		"""Read target core registers"""
-		self.putpacket("g")
+		self.putpacket(b"g")
 		reply = self.getpacket()
-		if (len(reply) == 0) or (reply[0] == 'E'): 
-			raise Exception('Error reading memory at 0x%08X' % addr)
+		if (reply == b'') or (reply[:1] == b'E'):
+			raise Exception('Error reading target core registers')
 		try:
 			data = unhexify(reply)
-		except Excpetion:
-			raise Exception('Invalid response to memory read packet: %r' % reply)
-		return struct.unpack("=20L", data)
+		except Exception:
+			raise Exception('Invalid response to registers read packet: %r' % reply)
+		ret = array.array('I',data)
+		return ret
 
 	def write_regs(self, *regs):
 		"""Write target core registers"""
 		data = struct.pack("=%dL" % len(regs), *regs)
-		self.putpacket("G" + hexify(data))
-		if self.getpacket() != 'OK': 
+		self.putpacket(b"G" + hexify(data))
+		if self.getpacket() != b'OK':
 			raise Exception('Error writing to target core registers')
 
 	def memmap_read(self):
 		"""Read the XML memory map from target"""
 		offset = 0
-		ret = ''
+		ret = b''
 		while True:
-			self.putpacket("qXfer:memory-map:read::%08X,%08X" % (offset, 512))
+			self.putpacket(b"qXfer:memory-map:read::%08X,%08X" % (offset, 512))
 			reply = self.getpacket()
-			if (reply[0] == 'm') or (reply[0] == 'l'):
+			if (reply[0] in b'ml'):
 				offset += len(reply) - 1
 				ret += reply[1:]
 			else:
-				raise Exception("Invalid GDB stub response")
+				raise Exception('Invalid GDB stub response %r'%reply)
+
+			if reply[:1] == b'l':
+				return ret
 
-			if reply[0] == 'l': return ret
-			
 	def resume(self):
 		"""Resume target execution"""
-		self.putpacket("c")
+		self.putpacket(b'c')
 
 	def interrupt(self):
 		"""Interrupt target execution"""
-		self.sock.send("\x03")
+		self.sock.send(b'\x03')
 
 	def run_stub(self, stub, address, *args):
 		"""Execute a binary stub at address, passing args in core registers."""
@@ -205,11 +237,19 @@ class Target:
 		regs[15] = address
 		self.write_regs(*regs)
 		self.resume()
-		reply = self.getpacket()
+		reply = None
 		while not reply:
 			reply = self.getpacket()
-		if not reply.startswith("T05"):
-			raise Exception("Invalid stop response: %r" % reply)
+		if not reply.startswith(b"T05"):
+			message = "Invalid stop response: %r" % reply
+			try:
+				message += {'T02':' (SIGINT)',
+							'T05':' (SIGTRAP)',
+							'T0B':' (SIGSEGV)',
+							'T1D':' (SIGLOST)'}[reply]
+			except KeyError:
+				pass
+			raise Exception(message)
 
 	class FlashMemory:
 		def __init__(self, target, offset, length, blocksize):
@@ -217,65 +257,70 @@ class Target:
 			self.offset = offset
 			self.length = length
 			self.blocksize = blocksize
-			self.blocks = list(None for i in range(length / blocksize))
+			self.blocks = list(None for i in range(length // blocksize))
 
 		def prog(self, offset, data):
-			assert ((offset >= self.offset) and 
+			assert type(data)==bytes
+
+			assert ((offset >= self.offset) and
 				(offset + len(data) <= self.offset + self.length))
 
 			while data:
-				index = (offset - self.offset) / self.blocksize
+				index = (offset - self.offset) // self.blocksize
 				bloffset = (offset - self.offset) % self.blocksize
 				bldata = data[:self.blocksize-bloffset]
 				data = data[len(bldata):]; offset += len(bldata)
 				if self.blocks[index] is None: # Initialize a clear block
-					self.blocks[index] = "".join(chr(0xff) for i in range(self.blocksize))
-				self.blocks[index] = (self.blocks[index][:bloffset] + bldata + 
+					self.blocks[index] = bytes(0xff for i in range(self.blocksize))
+				self.blocks[index] = (self.blocks[index][:bloffset] + bldata +
 						self.blocks[index][bloffset+len(bldata):])
 
 		def commit(self, progress_cb=None):
 			totalblocks = 0
 			for b in self.blocks:
-				if b is not None: totalblocks += 1
-				
+				if b is not None:
+					totalblocks += 1
+
 			block = 0
 			for i in range(len(self.blocks)):
 				block += 1
-				if callable(progress_cb):
+				if callable(progress_cb) and totalblocks > 0:
 					progress_cb(block*100/totalblocks)
 
 				# Erase the block
 				data = self.blocks[i]
 				addr = self.offset + self.blocksize * i
-				if data is None: continue
-				#print "Erasing flash at 0x%X" % (self.offset + self.blocksize*i)
-				self.target.putpacket("vFlashErase:%08X,%08X" % 
+				if data is None:
+					continue
+				#print("Erasing flash at 0x%X" % (self.offset + self.blocksize*i))
+				self.target.putpacket(b"vFlashErase:%08X,%08X" %
 					(self.offset + self.blocksize*i, self.blocksize))
-				if self.target.getpacket() != 'OK': 
+				if self.target.getpacket() != b'OK':
 					raise Exception("Failed to erase flash")
 
 				while data:
 					d = data[0:980]
 					data = data[len(d):]
-					#print "Writing %d bytes at 0x%X" % (len(d), addr)
-					self.target.putpacket("vFlashWrite:%08X:%s" % (addr, d))
+					#print("Writing %d bytes at 0x%X" % (len(d), addr))
+					self.target.putpacket(b"vFlashWrite:%08X:%s" % (addr, d))
 					addr += len(d)
-					if self.target.getpacket() != 'OK': 
+					if self.target.getpacket() != b'OK':
 						raise Exception("Failed to write flash")
-					
-				self.target.putpacket("vFlashDone")
-				if self.target.getpacket() != 'OK': 
+
+				self.target.putpacket(b"vFlashDone")
+				if self.target.getpacket() != b'OK':
 					raise Exception("Failed to commit")
-			
-			self.blocks = list(None for i in range(self.length / self.blocksize))
-			
+
+			self.blocks = list(None for i in range(self.length // self.blocksize))
+
 
 	def flash_probe(self):
 		self.mem = []
 		xmldom = parseString(self.memmap_read())
-		
+
 		for memrange in xmldom.getElementsByTagName("memory"):
-			if memrange.getAttribute("type") != "flash": continue
+			if memrange.getAttribute("type") != "flash":
+				continue
 			offset = eval(memrange.getAttribute("start"))
 			length = eval(memrange.getAttribute("length"))
 			for property in memrange.getElementsByTagName("property"):
@@ -291,11 +336,9 @@ class Target:
 
 	def flash_write_prepare(self, address, data):
 		for m in self.mem:
-			if (address >= m.offset) and (address + len(data) < m.offset + m.length):
+			if (address >= m.offset) and (address + len(data) <= m.offset + m.length):
 				m.prog(address, data)
 
 	def flash_commit(self, progress_cb=None):
 		for m in self.mem:
 			m.commit(progress_cb)
-
-

scripts/get_openocd_nrf51_ids.py

@@ -1,60 +1,56 @@
-#!/usr/bin/python
+#!/usr/bin/env python3
 
 """Pulls nRF51 IDs from openocd's nrf51.c in a form suitable for
 pasting into blackmagic's nrf51.c
 
 """
 
-import subprocess,re
+import subprocess
+import re
+import io
 
-cmd = 'git archive --remote=git://git.code.sf.net/p/openocd/code HEAD src/flash/nor/nrf51.c | tar -xO'
+cmd = 'git archive --remote=git://git.code.sf.net/p/openocd/code HEAD src/flash/nor/nrf5.c | tar -xO'
 
 class Spec():
     def __repr__(self):
         return "0x%04X: /* %s %s %s */"%(self.hwid,self.comment, self.variant,self.build_code)
 
-fd = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE).stdout
+proc = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
 
-specdict={}
-specs=[]
-spec=Spec()
-for line in fd.read().split('\n'):
-    m=re.search('/\*(.*)\*/',line)
+specdict = {}
+specs    = []
+spec     = Spec()
+for line in io.TextIOWrapper(proc.stdout, encoding="utf-8"):
+    m = re.search(r'/\*(.*)\*/',line)
     if m:
         lastcomment=m.group(1)
 
-    m=re.search('.hwid.*=\s*(0x[0-9A-F]*),',line)
+    m = re.search(r'NRF51_DEVICE_DEF\((0x[0-9A-F]*),\s*"(.*)",\s*"(.*)",\s*"(.*)",\s*([0-9]*)\s*\),', line)
     if m:
-        spec.hwid=int(m.group(1),base=0)
-    m=re.search('.variant.*=\s*"(.*)",',line)
-    if m:
-        spec.variant=m.group(1)
-    m=re.search('.build_code.*=\s*"(.*)",',line)
-    if m:
-        spec.build_code=m.group(1)
-    m=re.search('.flash_size_kb.*=\s*([0-9]*),',line)
-    if m:
-        spec.flash_size_kb=int(m.group(1),base=0)
-        ram,flash = {'AA':(16,256),
-                     'AB':(16,128),
-                     'AC':(32,256)}[spec.variant[-2:]]
-        assert flash==spec.flash_size_kb
+        spec.hwid          = int(m.group(1), base=0)
+        spec.variant       = m.group(3)
+        spec.build_code    = m.group(4)
+        spec.flash_size_kb = int(m.group(5), base=0)
+        ram, flash = {'AA':(16,256),
+                      'AB':(16,128),
+                      'AC':(32,256)}[spec.variant[-2:]]
+        assert flash == spec.flash_size_kb
         spec.ram_size_kb = ram
-        nicecomment =lastcomment.strip().replace('IC ','').replace('Devices ','').replace('.','')
-        spec.comment=nicecomment
+        nicecomment  = lastcomment.strip().replace('IC ','').replace('Devices ','').replace('.','')
+        spec.comment = nicecomment
 
         specdict.setdefault((ram,flash),[]).append(spec)
         specs.append(spec)
         spec=Spec()
 
-for (ram,flash),specs in specdict.iteritems():
+for (ram,flash),specs in specdict.items():
     specs.sort(key=lambda x:x.hwid)
     for spec in specs:
-        print "\tcase",spec
-    print '\t\tt->driver = "Nordic nRF51";'
-    print '\t\ttarget_add_ram(t, 0x20000000, 0x%X);'%(1024*ram)
-    print '\t\tnrf51_add_flash(t, 0x00000000, 0x%X, NRF51_PAGE_SIZE);'%(1024*flash)
-    print '\t\tnrf51_add_flash(t, NRF51_UICR, 0x100, 0x100);'
-    print '\t\ttarget_add_commands(t, nrf51_cmd_list, "nRF51");'
-    print '\t\treturn true;'
+        print("\tcase",spec)
+    print('\t\tt->driver = "Nordic nRF51";')
+    print('\t\ttarget_add_ram(t, 0x20000000, 0x%X);'%(1024*ram))
+    print('\t\tnrf51_add_flash(t, 0x00000000, 0x%X, NRF51_PAGE_SIZE);'%(1024*flash))
+    print('\t\tnrf51_add_flash(t, NRF51_UICR, 0x100, 0x100);')
+    print('\t\ttarget_add_commands(t, nrf51_cmd_list, "nRF51");')
+    print('\t\treturn true;')
 

scripts/hexprog.py

@@ -1,9 +1,9 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # hexprog.py: Python application to flash a target with an Intel hex file
 # Copyright (C) 2011  Black Sphere Technologies
 # Written by Gareth McMullin <gareth@blacksphere.co.nz>
-# 
+#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -18,7 +18,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import gdb
-import struct
 import time
 
 # Microcode sequence to erase option bytes
@@ -31,15 +30,16 @@ def flash_write_hex(target, hexfile, progress_cb=None):
 	f = open(hexfile)
 	addrhi = 0
 	for line in f:
-		if line[0] != ':': raise Exception("Error in hex file")
+		if line[0] != ':':
+			raise Exception("Error in hex file")
 		reclen = int(line[1:3], 16)
 		addrlo = int(line[3:7], 16)
-		rectype = int(line[7:9], 16);
-		if sum(ord(x) for x in gdb.unhexify(line[1:11+reclen*2])) & 0xff != 0:
-			raise Exception("Checksum error in hex file") 
+		rectype = int(line[7:9], 16)
+		if sum(x for x in bytes.fromhex(line[1:11+reclen*2])) & 0xff != 0:
+			raise Exception("Checksum error in hex file")
 		if rectype == 0: # Data record
 			addr = (addrhi << 16) + addrlo
-			data = gdb.unhexify(line[9:9+reclen*2])
+			data = bytes.fromhex(line[9:9+reclen*2])
 			target.flash_write_prepare(addr, data)
 			pass
 		elif rectype == 4: # High address record
@@ -48,27 +48,27 @@ def flash_write_hex(target, hexfile, progress_cb=None):
 		elif rectype == 5: # Entry record
 			pass
 		elif rectype == 1: # End of file record
-			break 
+			break
 		else:
 			raise Exception("Invalid record in hex file")
 
 	try:
 		target.flash_commit(progress_cb)
 	except:
-		print "Flash write failed! Is device protected?\n"
+		print("Flash write failed! Is device protected?\n")
 		exit(-1)
-	
+
 
 if __name__ == "__main__":
 	from serial import Serial, SerialException
 	from sys import argv, platform, stdout
 	from getopt import getopt
 
-	if platform == "linux2":
-		print ("\x1b\x5b\x48\x1b\x5b\x32\x4a") # clear terminal screen
+	if platform == "linux":
+		print("\x1b\x5b\x48\x1b\x5b\x32\x4a") # clear terminal screen
 	print("Black Magic Probe -- Target Production Programming Tool -- version 1.0")
-	print "Copyright (C) 2011  Black Sphere Technologies"
-	print "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>"
+	print("Copyright (C) 2011  Black Sphere Technologies")
+	print("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>")
 	print("")
 
 	dev = "COM1" if platform == "win32" else "/dev/ttyACM0"
@@ -80,13 +80,20 @@ if __name__ == "__main__":
 	try:
 		opts, args = getopt(argv[1:], "sd:b:t:rR")
 		for opt in opts:
-			if opt[0] == "-s": scan = "swdp_scan"
-			elif opt[0] == "-b": baud = int(opt[1])
-			elif opt[0] == "-d": dev = opt[1]
-			elif opt[0] == "-t": targetno = int(opt[1])
-			elif opt[0] == "-r": unprot = True
-			elif opt[0] == "-R": prot = True
-			else: raise Exception()
+			if opt[0] == "-s":
+				scan = "swdp_scan"
+			elif opt[0] == "-b":
+				baud = int(opt[1])
+			elif opt[0] == "-d":
+				dev = opt[1]
+			elif opt[0] == "-t":
+				targetno = int(opt[1])
+			elif opt[0] == "-r":
+				unprot = True
+			elif opt[0] == "-R":
+				prot = True
+			else:
+				raise Exception()
 
 		hexfile = args[0]
 	except:
@@ -101,39 +108,44 @@ if __name__ == "__main__":
 		exit(-1)
 
 	try:
-		s = Serial(dev, baud, timeout=3)
-		s.setDTR(1)
-		while s.read(1024):
-			pass
+		s = Serial(dev) #, baud, timeout=0.1)
+		#s.setDTR(1)
+		#s.flushInput()
+
+		#while s.read(1024):
+	        #		pass
 
 		target = gdb.Target(s)
-		
-	except SerialException, e:
+
+	except SerialException as e:
 		print("FATAL: Failed to open serial device!\n%s\n" % e[0])
 		exit(-1)
 
 	try:
 		r = target.monitor("version")
-		for s in r: print s,
-	except SerialException, e:
+		for s in r:
+			print(s.decode(), end=' ')
+	except SerialException as e:
 		print("FATAL: Serial communication failure!\n%s\n" % e[0])
 		exit(-1)
-	except: pass
+	#except: pass
 
-	print "Target device scan:"
+	print("Target device scan:")
 	targetlist = None
 	r = target.monitor(scan)
-	for s in r: 
-		print s,
-	print
+	for s in r:
+		print(s.decode(), end=' ')
+	print()
 
 	r = target.monitor("targets")
-	for s in r: 
-		if s.startswith("No. Att Driver"): targetlist = []
+	for s in r:
+		if s.startswith(b"No. Att Driver"):
+			targetlist = []
 		try:
-			if type(targetlist) is list: 
+			if type(targetlist) is list:
 				targetlist.append(int(s[:2]))
-		except: pass
+		except:
+			pass
 
 	#if not targetlist:
 	#	print("FATAL: No usable targets found!\n")
@@ -161,7 +173,7 @@ if __name__ == "__main__":
 		print("FLASH memory -- Offset: 0x%X  BlockSize:0x%X\n" % (m.offset, m.blocksize))
 
 	def progress(percent):
-		print ("Progress: %d%%\r" % percent),
+		print("Progress: %d%%\r" % percent, end=' ')
 		stdout.flush()
 
 	print("Programming target")
@@ -179,4 +191,3 @@ if __name__ == "__main__":
 	target.detach()
 
 	print("\nAll operations complete!\n")
-

scripts/stm32_mem.py

@@ -1,7 +1,8 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # stm32_mem.py: STM32 memory access using USB DFU class
-# Copyright (C) 2011  Black Sphere Technologies 
+# Copyright (C) 2011  Black Sphere Technologies
+# Copyright (C) 2017, 2020  Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
 # Written by Gareth McMullin <gareth@blacksphere.co.nz>
 #
 # This program is free software: you can redistribute it and/or modify
@@ -19,15 +20,15 @@
 
 from time import sleep
 import struct
-from sys import stdout, argv
+import os
+from sys import stdout
 
 import argparse
-import usb
 import dfu
 
-CMD_GETCOMMANDS =            0x00
-CMD_SETADDRESSPOINTER =      0x21
-CMD_ERASE =                  0x41
+CMD_GETCOMMANDS =       0x00
+CMD_SETADDRESSPOINTER = 0x21
+CMD_ERASE =             0x41
 
 def stm32_erase(dev, addr):
 	erase_cmd = struct.pack("<BL", CMD_ERASE, addr)
@@ -39,6 +40,16 @@ def stm32_erase(dev, addr):
 		if status.bState == dfu.STATE_DFU_DOWNLOAD_IDLE:
 			break
 
+def stm32_set_address(dev, addr):
+	set_address_cmd = struct.pack("<BL", CMD_SETADDRESSPOINTER, addr)
+	dev.download(0, set_address_cmd)
+	while True:
+		status = dev.get_status()
+		if status.bState == dfu.STATE_DFU_DOWNLOAD_BUSY:
+			sleep(status.bwPollTimeout / 1000.0)
+		if status.bState == dfu.STATE_DFU_DOWNLOAD_IDLE:
+			break
+
 def stm32_write(dev, data):
 	dev.download(2, data)
 	while True:
@@ -47,9 +58,19 @@ def stm32_write(dev, data):
 			sleep(status.bwPollTimeout / 1000.0)
 		if status.bState == dfu.STATE_DFU_DOWNLOAD_IDLE:
 			break
-	
+
+def stm32_read(dev):
+	data = dev.upload(2, 1024)
+	while True:
+		status = dev.get_status()
+		if status.bState == dfu.STATE_DFU_DOWNLOAD_BUSY:
+			sleep(status.bwPollTimeout / 1000.0)
+		if status.bState == dfu.STATE_DFU_UPLOAD_IDLE:
+			break
+	return data
+
 def stm32_manifest(dev):
-	dev.download(0, "")
+	dev.download(0, b"")
 	while True:
 		try:
 			status = dev.get_status()
@@ -59,72 +80,182 @@ def stm32_manifest(dev):
 		if status.bState == dfu.STATE_DFU_MANIFEST:
 			break
 
+def stm32_scan(args, test):
+	devs = dfu.finddevs()
+	bmp_devs = []
+	bmp = 0
+	if not devs:
+		if test:
+			return
+
+		print("No DFU devices found!")
+		exit(-1)
+
+	for dev in devs:
+		try:
+			dfudev = dfu.dfu_device(*dev)
+		except:
+			# Exceptions are raised when current user doesn't have permissions
+			# for the specified USB device, but the device scan needs to
+			# continue
+			continue
+
+		man = dfudev.handle.getString(dfudev.dev.iManufacturer, 30)
+		if man == b"Black Sphere Technologies":
+			bmp = bmp + 1
+			bmp_devs.append(dev)
+
+	if bmp == 0:
+		if test:
+			return
+
+		print("No compatible device found\n")
+		exit(-1)
+
+	if bmp > 1 and not args.serial_target:
+		if test:
+			return
+
+		print("Found multiple devices:\n")
+		for dev in bmp_devs:
+			dfudev = dfu.dfu_device(*dev)
+			man = dfudev.handle.getString(dfudev.dev.iManufacturer, 30).decode('utf8')
+			product = dfudev.handle.getString(dfudev.dev.iProduct, 96).decode('utf8')
+			serial_no = dfudev.handle.getString(dfudev.dev.iSerialNumber, 30).decode('utf8')
+			print("Device ID:\t %04x:%04x" % (dfudev.dev.idVendor, dfudev.dev.idProduct))
+			print("Manufacturer:\t %s" % man)
+			print("Product:\t %s" % product)
+			print("Serial:\t\t %s\n" % serial_no)
+
+		print("Select device with serial number!")
+		exit(-1)
+
+	for dev in bmp_devs:
+		dfudev = dfu.dfu_device(*dev)
+		man = dfudev.handle.getString(dfudev.dev.iManufacturer, 30).decode('utf8')
+		product = dfudev.handle.getString(dfudev.dev.iProduct, 96).decode('utf8')
+		serial_no = dfudev.handle.getString(dfudev.dev.iSerialNumber, 30).decode('utf8')
+		if args.serial_target:
+			if man == "Black Sphere Technologies" and serial_no == args.serial_target:
+				break
+		else:
+			if man == "Black Sphere Technologies":
+				break
+
+	print("Device ID:\t %04x:%04x" % (dfudev.dev.idVendor, dfudev.dev.idProduct))
+	print("Manufacturer:\t %s" % man)
+	print("Product:\t %s" % product)
+	print("Serial:\t\t %s" % serial_no)
+
+	if args.serial_target and serial_no != args.serial_target:
+		print("Serial number doesn't match %s vs %s!\n" % (serial_no, args.serial_target))
+		exit(-2)
+
+	return dfudev
+
 if __name__ == "__main__":
-	print
-	print "USB Device Firmware Upgrade - Host Utility -- version 1.2"
-	print "Copyright (C) 2011  Black Sphere Technologies"
-	print "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>"
-	print
+	print("-")
+	print("USB Device Firmware Upgrade - Host Utility -- version 1.2")
+	print("Copyright (C) 2011  Black Sphere Technologies")
+	print("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>")
+	print("-")
 
 	parser = argparse.ArgumentParser()
 	parser.add_argument("progfile", help="Binary file to program")
 	parser.add_argument("-s", "--serial_target", help="Match Serial Number")
+	parser.add_argument("-a", "--address", help="Start address for firmware")
+	parser.add_argument("-m", "--manifest", help="Start application, if in DFU mode", action='store_true')
 	args = parser.parse_args()
-	devs = dfu.finddevs()
-	if not devs:
-		print "No devices found!"
-		exit(-1)
-
-	for dev in devs:
-		dfudev = dfu.dfu_device(*dev)
-		man = dfudev.handle.getString(dfudev.dev.iManufacturer, 30)
-		product = dfudev.handle.getString(dfudev.dev.iProduct, 64)
-		serial_no = dfudev.handle.getString(dfudev.dev.iSerialNumber, 30)
-		if args.serial_target:
-			if man == "Black Sphere Technologies" and serial_no ==  args.serial_target: break
-			if man == "STMicroelectronics" and serial_no == args.serial_target: break
-                else:
-			if man == "Black Sphere Technologies": break
-			if man == "STMicroelectronics": break
-
-	print "Device %s: ID %04x:%04x %s - %s\n\tSerial %s" % (
-                dfudev.dev.filename, dfudev.dev.idVendor,
-                dfudev.dev.idProduct, man, product, serial_no)
-
-	if args.serial_target and serial_no !=  args.serial_target:
-                print "Serial number doesn't match!\n"
-                exit(-2)
+	dfudev = stm32_scan(args, False)
 	try:
 		state = dfudev.get_state()
 	except:
-		print "Failed to read device state! Assuming APP_IDLE"
+		if args.manifest: exit(0)
+		print("Failed to read device state! Assuming APP_IDLE")
 		state = dfu.STATE_APP_IDLE
 	if state == dfu.STATE_APP_IDLE:
-		dfudev.detach()
-		print "Run again to upgrade firmware."
+		try:
+			dfudev.detach()
+		except:
+			pass
+		dfudev.release()
+		print("Invoking DFU Device")
+		timeout = 0
+		while True:
+			sleep(1)
+			timeout = timeout + 0.5
+			dfudev = stm32_scan(args, True)
+			if dfudev: break
+			if timeout > 5:
+				print("Error: DFU device did not appear")
+				exit(-1)
+	if args.manifest:
+		stm32_manifest(dfudev)
+		print("Invoking Application Device")
 		exit(0)
-	
 	dfudev.make_idle()
+	file = open(args.progfile, "rb")
+	if (os.path.getsize(args.progfile) > 0x1f800):
+		print("File too large")
+		exit(0)
 
-	bin = open(args.progfile, "rb").read()
+	bin = file.read()
 
-	if "F4" in product:
-		addr = 0x8004000
+	product = dfudev.handle.getString(dfudev.dev.iProduct, 64).decode('utf8')
+	if args.address:
+		start = int(args.address, 0)
 	else:
-		addr = 0x8002000
+		if "F4" in product or "STLINK-V3" in product:
+			start = 0x8004000
+		else:
+			start = 0x8002000
+	addr = start
 	while bin:
-		print ("Programming memory at 0x%08X\r" % addr),
+		print("Programming memory at 0x%08X" % addr, end="\r")
 		stdout.flush()
 		try:
+# STM DFU bootloader erases always.
+# BPM Bootloader only erases once per sector
+# To support the STM DFU bootloader, the interface descriptor must
+# get evaluated and erase called only once per sector!
 			stm32_erase(dfudev, addr)
-                except:
-			print "\nErase Timed out\n"
+		except:
+			print("\nErase Timed out\n")
+			break
+		try:
+			stm32_set_address(dfudev, addr)
+		except:
+			print("\nSet Address Timed out\n")
 			break
 		stm32_write(dfudev, bin[:1024])
-
 		bin = bin[1024:]
 		addr += 1024
-
+	file.seek(0)
+	bin = file.read()
+	len = len(bin)
+	addr = start
+	print("\n-")
+	while bin:
+		try:
+			stm32_set_address(dfudev, addr)
+			data = stm32_read(dfudev)
+		except:
+# Abort silent if bootloader does not support upload
+			break
+		print("Verifying memory at 0x%08X" % addr, end="\r")
+		stdout.flush()
+		if len > 1024:
+			size = 1024
+		else:
+			size = len
+		if bin[:size] != bytearray(data[:size]):
+			print("\nMismatch in block at 0x%08X" % addr)
+			break
+		bin = bin[1024:]
+		addr += 1024
+		len -= 1024
+		if len <= 0:
+			print("\nVerified!")
 	stm32_manifest(dfudev)
 
-	print "\nAll operations complete!\n"
+	print("All operations complete!\n")

scripts/swolisten.c

@@ -0,0 +1,547 @@
+/*
+ * SWO Splitter for Blackmagic Probe and others.
+ * =============================================
+ *
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2017  Dave Marples  <dave@marples.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <stdio.h>
+#include <string.h>
+#include <libusb.h>
+#include <stdint.h>
+#include <limits.h>
+#include <termios.h>
+#include <signal.h>
+
+#define VID       (0x1d50)
+#define PID       (0x6018)
+#define INTERFACE (5)
+#define ENDPOINT  (0x85)
+
+#define TRANSFER_SIZE (64)
+#define NUM_FIFOS     32
+#define MAX_FIFOS     128
+
+#define CHANNELNAME   "chan"
+
+#define BOOL       char
+#define FALSE      (0)
+#define TRUE       (!FALSE)
+
+// Record for options, either defaults or from command line
+struct
+{
+  BOOL verbose;
+  BOOL dump;
+  int nChannels;
+  char *chanPath;
+  char *port;
+  int speed;
+} options = {.nChannels=NUM_FIFOS, .chanPath="", .speed=115200};
+
+// Runtime state
+struct
+{
+  int fifo[MAX_FIFOS];
+} _r;
+
+// ====================================================================================================
+// ====================================================================================================
+// ====================================================================================================
+// Internals
+// ====================================================================================================
+// ====================================================================================================
+// ====================================================================================================
+static BOOL _runFifo(int portNo, int listenHandle, char *fifoName)
+
+{
+  int pid,fifo;
+  int readDataLen, writeDataLen;
+
+  if (mkfifo(fifoName,0666)<0)
+    {
+      return FALSE;
+    }
+
+  pid=fork();
+
+  if (pid==0)
+    {
+      char rxdata[TRANSFER_SIZE];
+      int fifo;
+
+      /* Don't kill this sub-process when any reader or writer evaporates */
+      signal(SIGPIPE, SIG_IGN);
+
+      while (1)
+	{
+	  /* This is the child */
+	  fifo=open(fifoName,O_WRONLY);
+
+	  while (1)
+	    {
+	      readDataLen=read(listenHandle,rxdata,TRANSFER_SIZE);
+	      if (readDataLen<=0)
+		{
+		  exit(0);
+		}
+
+	      writeDataLen=write(fifo,rxdata,readDataLen);
+	      if (writeDataLen<=0)
+		{
+		  break;
+		}
+	    }
+	  close(fifo);
+	}
+    }
+  else if (pid<0)
+    {
+      /* The fork failed */
+      return FALSE;
+    }
+  return TRUE;
+}
+// ====================================================================================================
+static BOOL _makeFifoTasks(void)
+
+/* Create each sub-process that will handle a port */
+
+{
+  char fifoName[PATH_MAX];
+
+  int f[2];
+
+  for (int t=0; t<options.nChannels; t++)
+    {
+      if (pipe(f)<0)
+	  return FALSE;
+      fcntl(f[1],F_SETFL,O_NONBLOCK);
+      _r.fifo[t]=f[1];
+      sprintf(fifoName,"%s%s%02X",options.chanPath,CHANNELNAME,t);
+      if (!_runFifo(t,f[0],fifoName))
+	{
+	  return FALSE;
+	}
+    }
+  return TRUE;
+}
+// ====================================================================================================
+static void _removeFifoTasks(void)
+
+/* Destroy the per-port sub-processes */
+
+{
+  int statloc;
+  int remainingProcesses=0;
+  char fifoName[PATH_MAX];
+
+  for (int t=0; t<options.nChannels; t++)
+    {
+      if (_r.fifo[t]>0)
+	{
+	  close(_r.fifo[t]);
+	  sprintf(fifoName,"%s%s%02X",options.chanPath,CHANNELNAME,t);
+	  unlink(fifoName);
+	  remainingProcesses++;
+	}
+    }
+
+  while (remainingProcesses--)
+    {
+      waitpid(-1,&statloc,0);
+    }
+}
+// ====================================================================================================
+// ====================================================================================================
+// ====================================================================================================
+// Handlers for each message type
+// ====================================================================================================
+// ====================================================================================================
+// ====================================================================================================
+void _handleSWIT(uint8_t addr, uint8_t length, uint8_t *d)
+
+{
+  if (addr<options.nChannels)
+    write(_r.fifo[addr],d,length);
+
+  //  if (addr==0)
+  //  fprintf(stdout,"%c",*d);
+}
+// ====================================================================================================
+void _handleTS(uint8_t length, uint8_t *d)
+
+{
+
+}
+// ====================================================================================================
+// ====================================================================================================
+// ====================================================================================================
+// Protocol pump for decoding messages
+// ====================================================================================================
+// ====================================================================================================
+// ====================================================================================================
+enum _protoState {ITM_IDLE, ITM_SYNCING, ITM_TS, ITM_SWIT};
+
+#ifdef PRINT_TRANSITIONS
+static char *_protoNames[]={"IDLE", "SYNCING","TS","SWIT"};
+#endif
+
+void _protocolPump(uint8_t *c)
+
+{
+  static enum _protoState p;
+  static int targetCount, currentCount, srcAddr;
+  static uint8_t rxPacket[5];
+
+#ifdef PRINT_TRANSITIONS
+  printf("%02x %s --> ",*c,_protoNames[p]);
+#endif
+
+  switch (p)
+    {
+      // -----------------------------------------------------
+    case ITM_IDLE:
+      if (*c==0b01110000)
+	{
+	  /* This is an overflow packet */
+	  if (options.verbose)
+	    fprintf(stderr,"Overflow!\n");
+	  break;
+	}
+      // **********
+      if (*c==0)
+	{
+	  /* This is a sync packet - expect to see 4 more 0's followed by 0x80 */
+	  targetCount=4;
+	  currentCount=0;
+	  p=ITM_SYNCING;
+	  break;
+	}
+      // **********
+      if (!(*c&0x0F))
+	{
+	  currentCount=1;
+	  /* This is a timestamp packet */
+	  rxPacket[0]=*c;
+
+	  if (!(*c&0x80))
+	    {
+	      /* A one byte output */
+	      _handleTS(currentCount,rxPacket);
+	    }
+	  else
+	    {
+	      p=ITM_TS;
+	    }
+	  break;
+	}
+      // **********
+      if ((*c&0x0F) == 0x04)
+	{
+	  /* This is a reserved packet */
+	  break;
+	}
+      // **********
+      if (!(*c&0x04))
+	{
+	  /* This is a SWIT packet */
+	  if ((targetCount=*c&0x03)==3)
+	    targetCount=4;
+	  srcAddr=(*c&0xF8)>>3;
+	  currentCount=0;
+	  p=ITM_SWIT;
+	  break;
+	}
+      // **********
+      if (options.verbose)
+	fprintf(stderr,"Illegal packet start in IDLE state\n");
+      break;
+      // -----------------------------------------------------
+    case ITM_SWIT:
+	  rxPacket[currentCount]=*c;
+	  currentCount++;
+
+	  if (currentCount>=targetCount)
+	    {
+	      p=ITM_IDLE;
+	      _handleSWIT(srcAddr, targetCount, rxPacket);
+	    }
+	  break;
+      // -----------------------------------------------------
+    case ITM_TS:
+      rxPacket[currentCount++]=*c;
+      if (!(*c&0x80))
+	{
+	  /* We are done */
+	  _handleTS(currentCount,rxPacket);
+	}
+      else
+	{
+	  if (currentCount>4)
+	    {
+	      /* Something went badly wrong */
+	      p=ITM_IDLE;
+	    }
+	  break;
+	}
+
+      // -----------------------------------------------------
+    case ITM_SYNCING:
+      if ((*c==0) && (currentCount<targetCount))
+	{
+	  currentCount++;
+	}
+      else
+	{
+	  if (*c==0x80)
+	    {
+	      p=ITM_IDLE;
+	    }
+	  else
+	    {
+	      /* This should really be an UNKNOWN state */
+	      p=ITM_IDLE;
+	    }
+	}
+      break;
+      // -----------------------------------------------------
+    }
+#ifdef PRINT_TRANSITIONS
+  printf("%s\n",_protoNames[p]);
+#endif
+}
+// ====================================================================================================
+void intHandler(int dummy)
+
+{
+  exit(0);
+}
+// ====================================================================================================
+void _printHelp(char *progName)
+
+{
+  printf("Useage: %s <dhnv> <b basedir> <p port> <s speed>\n",progName);
+  printf("        b: <basedir> for channels\n");
+  printf("        h: This help\n");
+  printf("        d: Dump received data without further processing\n");
+  printf("        n: <Number> of channels to populate\n");
+  printf("        p: <serialPort> to use\n");
+  printf("        s: <serialSpeed> to use\n");
+  printf("        v: Verbose mode\n");
+}
+// ====================================================================================================
+int _processOptions(int argc, char *argv[])
+
+{
+  int c;
+  while ((c = getopt (argc, argv, "vdn:b:hp:s:")) != -1)
+    switch (c)
+      {
+      case 'v':
+        options.verbose = 1;
+        break;
+      case 'd':
+        options.dump = 1;
+        break;
+      case 'p':
+	options.port=optarg;
+	break;
+      case 's':
+	options.speed=atoi(optarg);
+	break;
+      case 'h':
+	_printHelp(argv[0]);
+	return FALSE;
+      case 'n':
+	options.nChannels=atoi(optarg);
+	if ((options.nChannels<1) || (options.nChannels>MAX_FIFOS))
+	  {
+	    fprintf(stderr,"Number of channels out of range (1..%d)\n",MAX_FIFOS);
+	    return FALSE;
+	  }
+	break;
+      case 'b':
+        options.chanPath = optarg;
+        break;
+      case '?':
+        if (optopt == 'b')
+          fprintf (stderr, "Option '%c' requires an argument.\n", optopt);
+        else if (!isprint (optopt))
+	    fprintf (stderr,"Unknown option character `\\x%x'.\n", optopt);
+	return FALSE;
+      default:
+        return FALSE;
+      }
+
+  if (options.verbose)
+    {
+      fprintf(stdout,"Verbose: TRUE\nBasePath: %s\n",options.chanPath);
+      if (options.port)
+	{
+	  fprintf(stdout,"Serial Port: %s\nSerial Speed: %d\n",options.port,options.speed);
+	}
+    }
+  return TRUE;
+}
+// ====================================================================================================
+int usbFeeder(void)
+
+{
+
+  unsigned char cbw[TRANSFER_SIZE];
+  libusb_device_handle *handle;
+  libusb_device *dev;
+  int size;
+
+  while (1)
+    {
+      if (libusb_init(NULL) < 0)
+	{
+	  fprintf(stderr,"Failed to initalise USB interface\n");
+	  return (-1);
+	}
+
+      while (!(handle = libusb_open_device_with_vid_pid(NULL, VID, PID)))
+	{
+	  usleep(500000);
+	}
+
+      if (!(dev = libusb_get_device(handle)))
+	continue;
+
+      if (libusb_claim_interface (handle, INTERFACE)<0)
+	continue;
+
+      while (0==libusb_bulk_transfer(handle, ENDPOINT, cbw, TRANSFER_SIZE, &size, 10))
+	{
+	  unsigned char *c=cbw;
+          if (options.dump)
+          {
+              cbw[size] = 0;
+              printf("%s", (char*)cbw);
+          }
+          else
+              while (size--)
+                  _protocolPump(c++);
+	}
+
+      libusb_close(handle);
+    }
+}
+// ====================================================================================================
+int serialFeeder(void)
+
+{
+  int f;
+  unsigned char cbw[TRANSFER_SIZE];
+  ssize_t t;
+  struct termios settings;
+
+  while (1)
+    {
+      while ((f=open(options.port,O_RDONLY))<0)
+	{
+	  if (options.verbose)
+	    {
+	      fprintf(stderr,"Can't open serial port\n");
+	    }
+	  usleep(500000);
+	}
+
+      if (options.verbose)
+	{
+	  fprintf(stderr,"Port opened\n");
+	}
+
+      if (tcgetattr(f, &settings) <0)
+	{
+	  perror("tcgetattr");
+	  return(-3);
+	}
+
+      if (cfsetspeed(&settings, options.speed)<0)
+	{
+	  perror("Setting input speed");
+	  return -3;
+	}
+      settings.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
+      settings.c_cflag &= ~PARENB; /* no parity */
+      settings.c_cflag &= ~CSTOPB; /* 1 stop bit */
+      settings.c_cflag &= ~CSIZE;
+      settings.c_cflag |= CS8 | CLOCAL; /* 8 bits */
+      settings.c_oflag &= ~OPOST; /* raw output */
+
+      if (tcsetattr(f, TCSANOW, &settings)<0)
+	{
+	  fprintf(stderr,"Unsupported baudrate\n");
+	  exit(-3);
+	}
+
+      tcflush(f, TCOFLUSH);
+
+      while ((t=read(f,cbw,TRANSFER_SIZE))>0)
+	{
+	  unsigned char *c=cbw;
+	  while (t--)
+	    _protocolPump(c++);
+	}
+      if (options.verbose)
+	{
+	  fprintf(stderr,"Read failed\n");
+	}
+      close(f);
+    }
+}
+// ====================================================================================================
+int main(int argc, char *argv[])
+
+{
+  if (!_processOptions(argc,argv))
+    {
+      exit(-1);
+    }
+
+  atexit(_removeFifoTasks);
+  /* This ensures the atexit gets called */
+  signal(SIGINT, intHandler);
+  if (!_makeFifoTasks())
+    {
+      fprintf(stderr,"Failed to make channel devices\n");
+      exit(-1);
+    }
+
+  /* Using the exit construct rather than return ensures the atexit gets called */
+  if (!options.port)
+    exit(usbFeeder());
+  else
+    exit(serialFeeder());
+  fprintf(stderr,"Returned\n");
+  exit(0);
+}
+// ====================================================================================================

src/Makefile

@@ -1,6 +1,6 @@
 PROBE_HOST ?= native
 PLATFORM_DIR = platforms/$(PROBE_HOST)
-VPATH += $(PLATFORM_DIR) platforms/common target
+VPATH += $(PLATFORM_DIR) target
 ENABLE_DEBUG ?=
 
 ifneq ($(V), 1)
@@ -8,15 +8,12 @@ MAKEFLAGS += --no-print-dir
 Q := @
 endif
 
-OPT_FLAGS ?= -O2
-
-CFLAGS += -Wall -Wextra -Werror -Wno-char-subscripts\
-	$(OPT_FLAGS) -std=gnu99 -MD \
-	-I. -Iinclude -Iplatforms/common -I$(PLATFORM_DIR)
-LDFLAGS += $(OPT_FLAGS)
+CFLAGS += -Wall -Wextra -Werror -Wno-char-subscripts \
+	-std=gnu99 -MD -I./target \
+	-I. -Iinclude -I$(PLATFORM_DIR)
 
 ifeq ($(ENABLE_DEBUG), 1)
-CFLAGS += -DENABLE_DEBUG -g3 -ggdb
+CFLAGS += -DENABLE_DEBUG
 endif
 
 SRC =			\
@@ -34,35 +31,88 @@ SRC =			\
 	gdb_hostio.c	\
 	gdb_packet.c	\
 	hex_utils.c	\
+	jtag_devs.c	\
 	jtag_scan.c	\
-	jtagtap.c	\
-	jtagtap_generic.c	\
 	lmi.c		\
 	lpc_common.c	\
 	lpc11xx.c	\
+	lpc17xx.c	\
 	lpc15xx.c	\
 	lpc43xx.c	\
+	lpc546xx.c	\
 	kinetis.c	\
 	main.c		\
 	morse.c		\
+	msp432.c	\
 	nrf51.c		\
+	nxpke04.c	\
 	platform.c	\
+	remote.c	\
+	rp.c		\
 	sam3x.c		\
-	sam4l.c	\
+	sam4l.c		\
 	samd.c		\
+	samx5x.c	\
 	stm32f1.c	\
+	ch32f1.c	\
 	stm32f4.c	\
+	stm32h7.c	\
 	stm32l0.c	\
 	stm32l4.c	\
-	swdptap.c	\
-	swdptap_generic.c	\
+	stm32g0.c	\
 	target.c	\
 
+
 include $(PLATFORM_DIR)/Makefile.inc
 
-OBJ = $(SRC:.c=.o)
+OPT_FLAGS ?= -Os
+CFLAGS += $(OPT_FLAGS)
+LDFLAGS += $(OPT_FLAGS)
 
-blackmagic: include/version.h $(OBJ)
+ifndef TARGET
+ifdef PC_HOSTED
+TARGET = blackmagic
+else
+TARGET = blackmagic.elf
+endif
+endif
+
+ifdef NO_OWN_LL
+SRC += jtagtap_generic.c swdptap_generic.c
+endif
+
+ifdef PC_HOSTED
+CFLAGS += -DPC_HOSTED=1
+else
+SRC += swdptap.c jtagtap.c
+CFLAGS += -DPC_HOSTED=0
+VPATH += platforms/common
+CFLAGS += -Iplatforms/common
+endif
+
+ifeq ($(ENABLE_RTT), 1)
+CFLAGS += -DENABLE_RTT
+SRC += rtt.c rtt_if.c
+endif
+
+ifdef RTT_IDENT
+CFLAGS += -DRTT_IDENT=$(RTT_IDENT)
+endif
+
+OBJ = $(patsubst %.S,%.o,$(patsubst %.c,%.o,$(SRC)))
+
+OPTIMIZE := swdptap.o jtagtap.o \
+	    adiv5_jtagdp.o adiv5_swdp.o adiv5.o \
+	    cortexa.o cortexm.o \
+	    gdb_if.o gdb_main.o gdb_hostio.o gdb_packet.o \
+	    jtag_devs.o jtag_scan.o \
+	    crc32.o main.o \
+	    cdcacm.o jeff.o timing.o traceswo.o usbuart.o \
+
+$(OPTIMIZE)::        CFLAGS := $(filter-out -Os, $(CFLAGS))
+$(OPTIMIZE)::        CFLAGS += -O3
+
+$(TARGET): include/version.h $(OBJ)
 	@echo "  LD      $@"
 	$(Q)$(CC) -o $@ $(OBJ) $(LDFLAGS)
 
@@ -70,44 +120,84 @@ blackmagic: include/version.h $(OBJ)
 	@echo "  CC      $<"
 	$(Q)$(CC) $(CFLAGS) -c $< -o $@
 
-%.bin:	%
+%.o:	%.S
+	@echo "  AS      $<"
+	$(Q)$(CC) $(CFLAGS) -c $< -o $@
+
+ifndef PC_HOSTED
+%.bin:	%.elf
 	@echo "  OBJCOPY $@"
 	$(Q)$(OBJCOPY) $(OBJCOPY_FLAGS) -O binary $^ $@
 
-%.hex:	%
+%.hex:	%.elf
 	@echo "  OBJCOPY $@"
 	$(Q)$(OBJCOPY) -O ihex $^ $@
+endif
 
-.PHONY:	clean host_clean all_platforms FORCE
+.PHONY:	clean host_clean all_platforms clang-format FORCE
 
 clean:	host_clean
 	$(Q)echo "  CLEAN"
-	-$(Q)$(RM) -f *.o *.d *~ blackmagic $(HOSTFILES)
-	-$(Q)$(RM) -f platforms/*/*.o platforms/*/*.d mapfile
+	-$(Q)$(RM) *.o *.d *.elf *~ $(TARGET) $(HOSTFILES)
+	-$(Q)$(RM) platforms/*/*.o platforms/*/*.d mapfile include/version.h
 
 all_platforms:
+	$(Q)if [ ! -f ../libopencm3/Makefile ]; then \
+		echo "Initialising git submodules..." ;\
+		git submodule init ;\
+		git submodule update ;\
+	fi
+	$(Q)$(MAKE) $(MFLAGS) -C ../libopencm3 lib/stm32/f1 lib/stm32/f4 lib/lm4f
 	$(Q)set -e ;\
-	mkdir -p artifacts/$(shell git describe --tags --always) ;\
+	mkdir -p artifacts/$(shell git describe --always --dirty --tags) ;\
 	echo "<html><body><ul>" > artifacts/index.html ;\
+	$(MAKE) clean ;\
 	for i in platforms/*/Makefile.inc ; do \
 		export DIRNAME=`dirname $$i` ;\
 		export PROBE_HOST=`basename $$DIRNAME` ;\
 		export CFLAGS=-Werror ;\
 		echo "Building for hardware platform: $$PROBE_HOST" ;\
-		$(MAKE) $(MAKEFLAGS) clean ;\
-		$(MAKE) $(MAKEFLAGS);\
+		$(MAKE);\
+		if [ -f blackmagic ]; then \
+			mv blackmagic artifacts/blackmagic-$$PROBE_HOST ;\
+			echo "<li><a href='blackmagic-$$PROBE_HOST'>$$PROBE_HOST</a></li>"\
+				>> artifacts/index.html ;\
+		fi ;\
 		if [ -f blackmagic.bin ]; then \
 			mv blackmagic.bin artifacts/blackmagic-$$PROBE_HOST.bin ;\
 			echo "<li><a href='blackmagic-$$PROBE_HOST.bin'>$$PROBE_HOST</a></li>"\
 				>> artifacts/index.html ;\
 		fi ;\
+		if [ -f blackmagic_dfu.bin ]; then \
+			mv blackmagic_dfu.bin artifacts/blackmagic_dfu-$$PROBE_HOST.bin ;\
+			echo "<li><a href='blackmagic_dfu-$$PROBE_HOST.bin'>$$PROBE_HOST DFU</a></li>"\
+				>> artifacts/index.html ;\
+		fi ;\
+		$(MAKE) clean ;\
 	done ;\
 	echo "</ul></body></html>" >> artifacts/index.html ;\
-	cp artifacts/*.bin artifacts/$(shell git describe --tags --always)
+	cp artifacts/blackmagic* artifacts/$(shell git describe --always --dirty --tags)
 
+command.c: include/version.h
+
+GIT_VERSION := $(shell git describe --always --dirty --tags)
+VERSION_HEADER := \#define FIRMWARE_VERSION "$(GIT_VERSION)"
 
 include/version.h: FORCE
-	$(Q)echo "  GIT     include/version.h"
-	$(Q)echo "#define FIRMWARE_VERSION \"`git describe --tags --always --dirty`\"" > $@
+	@# If git isn't found then GIT_VERSION will be an empty string.
+ifeq ($(GIT_VERSION),)
+	@echo Git not found, assuming up to date include/version.h
+else
+	@# Note that when we echo the version to the header file, echo writes a final newline
+	@# to the file. This is fine and probably makes the file more human-readable, but
+	@# also means we have to account for that newline in this comparison.
+	$(Q)if [ ! -f $@ ] || [ "$$(cat $@)" != "$$(echo '$(VERSION_HEADER)\n')" ]; then \
+		echo " GEN $@"; \
+		echo '$(VERSION_HEADER)' > $@; \
+	fi
+endif
+
+clang-format:
+	$(Q)clang-format -i *.c */*.c */*/*.c *.h */*.h */*/*.h
 
 -include *.d

src/command.c

@@ -3,6 +3,8 @@
  *
  * Copyright (C) 2011  Black Sphere Technologies Ltd.
  * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ * Copyright (C) 2021 Uwe Bonnes
+ *                            (bon@elektron.ikp.physik.tu-darmstadt.de)
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,39 +29,44 @@
 #include "command.h"
 #include "gdb_packet.h"
 #include "target.h"
+#include "target_internal.h"
 #include "morse.h"
 #include "version.h"
+#include "serialno.h"
+
+#ifdef ENABLE_RTT
+#include "rtt.h"
+#endif
 
 #ifdef PLATFORM_HAS_TRACESWO
 #	include "traceswo.h"
 #endif
 
-typedef bool (*cmd_handler)(target *t, int argc, const char **argv);
-
-struct command_s {
-	const char *cmd;
-	cmd_handler handler;
-
-	const char *help;
-};
-
-static bool cmd_version(void);
-static bool cmd_serial(void);
-static bool cmd_help(target *t);
+static bool cmd_version(target *t, int argc, char **argv);
+#ifdef PLATFORM_HAS_PRINTSERIAL
+static bool cmd_serial(target *t, int argc, char **argv);
+#endif
+static bool cmd_help(target *t, int argc, char **argv);
 
 static bool cmd_jtag_scan(target *t, int argc, char **argv);
-static bool cmd_swdp_scan(void);
-static bool cmd_targets(void);
-static bool cmd_morse(void);
+static bool cmd_swdp_scan(target *t, int argc, char **argv);
+static bool cmd_frequency(target *t, int argc, char **argv);
+static bool cmd_targets(target *t, int argc, char **argv);
+static bool cmd_morse(target *t, int argc, char **argv);
+static bool cmd_halt_timeout(target *t, int argc, const char **argv);
 static bool cmd_connect_srst(target *t, int argc, const char **argv);
-static bool cmd_hard_srst(void);
+static bool cmd_hard_srst(target *t, int argc, const char **argv);
 #ifdef PLATFORM_HAS_POWER_SWITCH
 static bool cmd_target_power(target *t, int argc, const char **argv);
 #endif
 #ifdef PLATFORM_HAS_TRACESWO
-static bool cmd_traceswo(void);
+static bool cmd_traceswo(target *t, int argc, const char **argv);
 #endif
-#ifdef PLATFORM_HAS_DEBUG
+static bool cmd_heapinfo(target *t, int argc, const char **argv);
+#ifdef ENABLE_RTT
+static bool cmd_rtt(target *t, int argc, const char **argv);
+#endif
+#if defined(PLATFORM_HAS_DEBUG) && (PC_HOSTED == 0)
 static bool cmd_debug_bmp(target *t, int argc, const char **argv);
 #endif
 #ifdef PLATFORM_HAS_UART_WHEN_SWDP
@@ -78,17 +85,27 @@ const struct command_s cmd_list[] = {
 	{"help", (cmd_handler)cmd_help, "Display help for monitor commands"},
 	{"jtag_scan", (cmd_handler)cmd_jtag_scan, "Scan JTAG chain for devices" },
 	{"swdp_scan", (cmd_handler)cmd_swdp_scan, "Scan SW-DP for devices" },
+	{"frequency", (cmd_handler)cmd_frequency, "set minimum high and low times" },
 	{"targets", (cmd_handler)cmd_targets, "Display list of available targets" },
 	{"morse", (cmd_handler)cmd_morse, "Display morse error message" },
+	{"halt_timeout", (cmd_handler)cmd_halt_timeout, "Timeout (ms) to wait until Cortex-M is halted: (Default 2000)" },
 	{"connect_srst", (cmd_handler)cmd_connect_srst, "Configure connect under SRST: (enable|disable)" },
 	{"hard_srst", (cmd_handler)cmd_hard_srst, "Force a pulse on the hard SRST line - disconnects target" },
 #ifdef PLATFORM_HAS_POWER_SWITCH
 	{"tpwr", (cmd_handler)cmd_target_power, "Supplies power to the target: (enable|disable)"},
 #endif
-#ifdef PLATFORM_HAS_TRACESWO
-	{"traceswo", (cmd_handler)cmd_traceswo, "Start trace capture" },
+#ifdef ENABLE_RTT
+	{"rtt", (cmd_handler)cmd_rtt, "enable|disable|status|channel 0..15|ident (str)|cblock|poll maxms minms maxerr" },
 #endif
-#ifdef PLATFORM_HAS_DEBUG
+#ifdef PLATFORM_HAS_TRACESWO
+#if defined TRACESWO_PROTOCOL && TRACESWO_PROTOCOL == 2
+	{"traceswo", (cmd_handler)cmd_traceswo, "Start trace capture, NRZ mode: (baudrate) (decode channel ...)" },
+#else
+	{"traceswo", (cmd_handler)cmd_traceswo, "Start trace capture, Manchester mode: (decode channel ...)" },
+#endif
+#endif
+	{"heapinfo", (cmd_handler)cmd_heapinfo, "Set semihosting heapinfo" },
+#if defined(PLATFORM_HAS_DEBUG) && (PC_HOSTED == 0)
 	{"debug_bmp", (cmd_handler)cmd_debug_bmp, "Output BMP \"debug\" strings to the second vcom: (enable|disable)"},
 #endif
 #ifdef PLATFORM_HAS_UART_WHEN_SWDP
@@ -101,16 +118,18 @@ const struct command_s cmd_list[] = {
 	{NULL, NULL, NULL}
 };
 
-static bool connect_assert_srst;
-#ifdef PLATFORM_HAS_DEBUG
+bool connect_assert_srst;
+#if defined(PLATFORM_HAS_DEBUG) && (PC_HOSTED == 0)
 bool debug_bmp;
 #endif
+unsigned cortexm_wait_timeout = 2000; /* Timeout to wait for Cortex to react on halt command. */
 
 int command_process(target *t, char *cmd)
 {
 	const struct command_s *c;
-	int argc = 0;
+	int argc = 1;
 	const char **argv;
+	const char *part;
 
 	/* Initial estimate for argc */
 	for(char *s = cmd; *s; s++)
@@ -119,8 +138,9 @@ int command_process(target *t, char *cmd)
 	argv = alloca(sizeof(const char *) * argc);
 
 	/* Tokenize cmd to find argv */
-	for(argc = 0, argv[argc] = strtok(cmd, " \t");
-		argv[argc]; argv[++argc] = strtok(NULL, " \t"));
+	argc = 0;
+	for (part = strtok(cmd, " \t"); part; part = strtok(NULL, " \t"))
+		argv[argc++] = part;
 
 	/* Look for match and call handler */
 	for(c = cmd_list; c->cmd; c++) {
@@ -137,24 +157,39 @@ int command_process(target *t, char *cmd)
 	return target_command(t, argc, argv);
 }
 
-bool cmd_version(void)
+#define BOARD_IDENT "Black Magic Probe" PLATFORM_IDENT FIRMWARE_VERSION
+
+bool cmd_version(target *t, int argc, char **argv)
 {
-	gdb_outf("Black Magic Probe (Firmware " FIRMWARE_VERSION ") (Hardware Version %d)\n", platform_hwversion());
-	gdb_out("Copyright (C) 2015  Black Sphere Technologies Ltd.\n");
+	(void)t;
+	(void)argc;
+	(void)argv;
+#if PC_HOSTED == 1
+	char ident[256];
+	gdb_ident(ident, sizeof(ident));
+	DEBUG_WARN("%s\n", ident);
+#else
+	gdb_out(BOARD_IDENT);
+	gdb_outf(", Hardware Version %d\n", platform_hwversion());
+	gdb_out("Copyright (C) 2022 Black Magic Debug Project\n");
 	gdb_out("License GPLv3+: GNU GPL version 3 or later "
 		"<http://gnu.org/licenses/gpl.html>\n\n");
+#endif
 
 	return true;
 }
 
-bool cmd_help(target *t)
+bool cmd_help(target *t, int argc, char **argv)
 {
+	(void)argc;
+	(void)argv;
 	const struct command_s *c;
 
-	gdb_out("General commands:\n");
-	for(c = cmd_list; c->cmd; c++)
-		gdb_outf("\t%s -- %s\n", c->cmd, c->help);
-
+	if (!t || t->tc->destroy_callback) {
+		gdb_out("General commands:\n");
+		for(c = cmd_list; c->cmd; c++)
+			gdb_outf("\t%s -- %s\n", c->cmd, c->help);
+	}
 	if (!t)
 		return -1;
 
@@ -168,7 +203,8 @@ static bool cmd_jtag_scan(target *t, int argc, char **argv)
 	(void)t;
 	uint8_t irlens[argc];
 
-	gdb_outf("Target voltage: %s\n", platform_target_voltage());
+	if (platform_target_voltage())
+		gdb_outf("Target voltage: %s\n", platform_target_voltage());
 
 	if (argc > 1) {
 		/* Accept a list of IR lengths on command line */
@@ -183,7 +219,11 @@ static bool cmd_jtag_scan(target *t, int argc, char **argv)
 	int devs = -1;
 	volatile struct exception e;
 	TRY_CATCH (e, EXCEPTION_ALL) {
+#if PC_HOSTED == 1
+		devs = platform_jtag_scan(argc > 1 ? irlens : NULL);
+#else
 		devs = jtag_scan(argc > 1 ? irlens : NULL);
+#endif
 	}
 	switch (e.type) {
 	case EXCEPTION_TIMEOUT:
@@ -199,14 +239,19 @@ static bool cmd_jtag_scan(target *t, int argc, char **argv)
 		gdb_out("JTAG device scan failed!\n");
 		return false;
 	}
-	cmd_targets();
+	cmd_targets(NULL, 0, NULL);
 	morse(NULL, false);
 	return true;
 }
 
-bool cmd_swdp_scan(void)
+bool cmd_swdp_scan(target *t, int argc, char **argv)
 {
-	gdb_outf("Target voltage: %s\n", platform_target_voltage());
+	(void)t;
+	volatile uint32_t targetid = 0;
+	if (argc > 1)
+		targetid  = strtol(argv[1], NULL, 0);
+	if (platform_target_voltage())
+		gdb_outf("Target voltage: %s\n", platform_target_voltage());
 
 	if(connect_assert_srst)
 		platform_srst_set_val(true); /* will be deasserted after attach */
@@ -214,8 +259,12 @@ bool cmd_swdp_scan(void)
 	int devs = -1;
 	volatile struct exception e;
 	TRY_CATCH (e, EXCEPTION_ALL) {
-		devs = adiv5_swdp_scan();
-	}
+#if PC_HOSTED == 1
+		devs = platform_adiv5_swdp_scan(targetid);
+#else
+		devs = adiv5_swdp_scan(targetid);
+#endif
+		}
 	switch (e.type) {
 	case EXCEPTION_TIMEOUT:
 		gdb_outf("Timeout during scan. Is target stuck in WFI?\n");
@@ -231,20 +280,59 @@ bool cmd_swdp_scan(void)
 		return false;
 	}
 
-	cmd_targets();
+	cmd_targets(NULL, 0, NULL);
 	morse(NULL, false);
 	return true;
 
 }
 
+bool cmd_frequency(target *t, int argc, char **argv)
+{
+	(void)t;
+	if (argc == 2) {
+		char *p;
+		uint32_t frequency = strtol(argv[1], &p, 10);
+		switch(*p) {
+		case 'k':
+			frequency *= 1000;
+			break;
+		case 'M':
+			frequency *= 1000*1000;
+			break;
+		}
+		platform_max_frequency_set(frequency);
+	}
+	uint32_t freq = platform_max_frequency_get();
+	if (freq == FREQ_FIXED)
+		gdb_outf("SWJ freq fixed\n");
+	else
+		gdb_outf("Max SWJ freq %08" PRIx32 "\n", freq);
+	return true;
+
+}
+
 static void display_target(int i, target *t, void *context)
 {
 	(void)context;
-	gdb_outf("%2d   %c  %s\n", i, target_attached(t)?'*':' ', target_driver_name(t));
+	if (!strcmp(target_driver_name(t), "ARM Cortex-M")) {
+		gdb_outf("***%2d%sUnknown %s Designer %3x Partno %3x %s\n",
+				 i, target_attached(t)?" * ":" ",
+				 target_driver_name(t),
+				 target_designer(t),
+				 target_idcode(t),
+				 (target_core_name(t)) ? target_core_name(t): "");
+	} else {
+		gdb_outf("%2d   %c  %s %s\n", i, target_attached(t)?'*':' ',
+				 target_driver_name(t),
+				 (target_core_name(t)) ? target_core_name(t): "");
+	}
 }
 
-bool cmd_targets(void)
+bool cmd_targets(target *t, int argc, char **argv)
 {
+	(void)t;
+	(void)argc;
+	(void)argv;
 	gdb_out("Available Targets:\n");
 	gdb_out("No. Att Driver\n");
 	if (!target_foreach(display_target, NULL)) {
@@ -255,26 +343,70 @@ bool cmd_targets(void)
 	return true;
 }
 
-bool cmd_morse(void)
+bool cmd_morse(target *t, int argc, char **argv)
 {
-	if(morse_msg)
+	(void)t;
+	(void)argc;
+	(void)argv;
+	if(morse_msg) {
 		gdb_outf("%s\n", morse_msg);
+		DEBUG_WARN("%s\n", morse_msg);
+	}
 	return true;
 }
 
+bool parse_enable_or_disable(const char *s, bool *out) {
+	if (strlen(s) == 0) {
+		gdb_outf("'enable' or 'disable' argument must be provided\n");
+		return false;
+	} else if (!strncmp(s, "enable", strlen(s))) {
+		*out = true;
+		return true;
+	} else if (!strncmp(s, "disable", strlen(s))) {
+		*out = false;
+		return true;
+	} else {
+		gdb_outf("Argument '%s' not recognized as 'enable' or 'disable'\n", s);
+		return false;
+	}
+}
+
 static bool cmd_connect_srst(target *t, int argc, const char **argv)
 {
 	(void)t;
-	if (argc == 1)
+	bool print_status = false;
+	if (argc == 1) {
+		print_status = true;
+	} else if (argc == 2) {
+		if (parse_enable_or_disable(argv[1], &connect_assert_srst)) {
+			print_status = true;
+		}
+	} else {
+		gdb_outf("Unrecognized command format\n");
+	}
+
+	if (print_status) {
 		gdb_outf("Assert SRST during connect: %s\n",
 			 connect_assert_srst ? "enabled" : "disabled");
-	else
-		connect_assert_srst = !strcmp(argv[1], "enable");
+	}
 	return true;
 }
 
-static bool cmd_hard_srst(void)
+static bool cmd_halt_timeout(target *t, int argc, const char **argv)
 {
+	(void)t;
+	if (argc > 1)
+		cortexm_wait_timeout = atol(argv[1]);
+	gdb_outf("Cortex-M timeout to wait for device haltes: %d\n",
+				 cortexm_wait_timeout);
+	return true;
+}
+
+static bool cmd_hard_srst(target *t, int argc, const char **argv)
+{
+	(void)t;
+	(void)argc;
+	(void)argv;
 	target_list_free();
 	platform_srst_set_val(true);
 	platform_srst_set_val(false);
@@ -285,34 +417,179 @@ static bool cmd_hard_srst(void)
 static bool cmd_target_power(target *t, int argc, const char **argv)
 {
 	(void)t;
-	if (argc == 1)
+	if (argc == 1) {
 		gdb_outf("Target Power: %s\n",
 			 platform_target_get_power() ? "enabled" : "disabled");
-	else
-		platform_target_set_power(!strncmp(argv[1], "enable", strlen(argv[1])));
+	} else if (argc == 2) {
+		bool want_enable = false;
+		if (parse_enable_or_disable(argv[1], &want_enable)) {
+			if (want_enable
+				&& !platform_target_get_power()
+				&& platform_target_voltage_sense() > POWER_CONFLICT_THRESHOLD) {
+				/* want to enable target power, but VREF > 0.5V sensed -> cancel */
+				gdb_outf("Target already powered (%s)\n", platform_target_voltage());
+			} else {
+				platform_target_set_power(want_enable);
+				gdb_outf("%s target power\n", want_enable ? "Enabling" : "Disabling");
+			}
+		}
+	} else {
+		gdb_outf("Unrecognized command format\n");
+	}
+	return true;
+}
+#endif
+
+#ifdef ENABLE_RTT
+static const char *on_or_off(const bool value)
+{
+	return value ? "on" : "off";
+}
+
+static bool cmd_rtt(target *t, int argc, const char **argv)
+{
+	(void)t;
+	const size_t command_len = strlen(argv[1]);
+	if (argc == 1 || (argc == 2 && !strncmp(argv[1], "enabled", command_len))) {
+		rtt_enabled = true;
+		rtt_found = false;
+	} else if ((argc == 2) && !strncmp(argv[1], "disabled", command_len)) {
+		rtt_enabled = false;
+		rtt_found = false;
+	} else if ((argc == 2) && !strncmp(argv[1], "status", command_len)) {
+		gdb_outf("rtt: %s found: %s ident: \"%s\"", on_or_off(rtt_enabled), rtt_found ? "yes" : "no",
+			rtt_ident[0] == '\0' ? "off" : rtt_ident);
+		gdb_outf(" halt: %s", on_or_off(target_no_background_memory_access(t)));
+		gdb_out(" channels: ");
+		if (rtt_auto_channel)
+			gdb_out("auto ");
+		for (size_t i = 0; i < MAX_RTT_CHAN; i++) {
+			if (rtt_channel[i].is_enabled)
+				gdb_outf("%d ", i);
+		}
+		gdb_outf(
+			"\nmax poll ms: %u min poll ms: %u max errs: %u\n", rtt_max_poll_ms, rtt_min_poll_ms, rtt_max_poll_errs);
+	} else if (argc >= 2 && !strncmp(argv[1], "channel", command_len)) {
+		/* mon rtt channel switches to auto rtt channel selection
+		   mon rtt channel number... selects channels given */
+		for (size_t i = 0; i < MAX_RTT_CHAN; i++)
+			rtt_channel[i].is_enabled = false;
+
+		if (argc == 2)
+			rtt_auto_channel = true;
+		else {
+			rtt_auto_channel = false;
+			for (size_t i = 2; i < (size_t)argc; ++i) {
+				const uint32_t channel = strtoul(argv[i], NULL, 0);
+				if (channel < MAX_RTT_CHAN)
+					rtt_channel[channel].is_enabled = true;
+			}
+		}
+	} else if (argc == 2 && !strncmp(argv[1], "ident", command_len))
+		rtt_ident[0] = '\0';
+	else if (argc == 2 && !strncmp(argv[1], "poll", command_len))
+		gdb_outf("%u %u %u\n", rtt_max_poll_ms, rtt_min_poll_ms, rtt_max_poll_errs);
+	else if (argc == 2 && !strncmp(argv[1], "cblock", command_len)) {
+		gdb_outf("cbaddr: 0x%x\n", rtt_cbaddr);
+		gdb_out("ch ena cfg i/o buf@        size head@      tail@      flg\n");
+		for (size_t i = 0; i < MAX_RTT_CHAN; ++i) {
+			gdb_outf("%2zu   %c   %c %s 0x%08x %5d 0x%08x 0x%08x   %d\n", i, rtt_channel[i].is_enabled ? 'y' : 'n',
+				rtt_channel[i].is_configured ? 'y' : 'n', rtt_channel[i].is_output ? "out" : "in ",
+				rtt_channel[i].buf_addr, rtt_channel[i].buf_size, rtt_channel[i].head_addr, rtt_channel[i].tail_addr,
+				rtt_channel[i].flag);
+		}
+	} else if (argc == 3 && !strncmp(argv[1], "ident", command_len)) {
+		strncpy(rtt_ident, argv[2], sizeof(rtt_ident));
+		rtt_ident[sizeof(rtt_ident) - 1] = '\0';
+		for (size_t i = 0; i < sizeof(rtt_ident); i++) {
+			if (rtt_ident[i] == '_')
+				rtt_ident[i] = ' ';
+		}
+	} else if (argc == 5 && !strncmp(argv[1], "poll", command_len)) {
+		/* set polling params */
+		rtt_max_poll_ms = strtoul(argv[2], NULL, 0);
+		rtt_min_poll_ms = strtoul(argv[3], NULL, 0);
+		rtt_max_poll_errs = strtoul(argv[4], NULL, 0);
+	} else
+		gdb_out("what?\n");
 	return true;
 }
 #endif
 
 #ifdef PLATFORM_HAS_TRACESWO
-static bool cmd_traceswo(void)
+static bool cmd_traceswo(target *t, int argc, const char **argv)
 {
-	extern char serial_no[9];
-	traceswo_init();
+	char serial_no[DFU_SERIAL_LENGTH];
+	(void)t;
+#if TRACESWO_PROTOCOL == 2
+	uint32_t baudrate = SWO_DEFAULT_BAUD;
+#endif
+	uint32_t swo_channelmask = 0; /* swo decoding off */
+	uint8_t decode_arg = 1;
+#if TRACESWO_PROTOCOL == 2
+	/* argument: optional baud rate for async mode */
+	if ((argc > 1) && (*argv[1] >= '0') && (*argv[1] <= '9')) {
+		baudrate = atoi(argv[1]);
+		if (baudrate == 0) baudrate = SWO_DEFAULT_BAUD;
+		decode_arg = 2;
+	}
+#endif
+	/* argument: 'decode' literal */
+	if((argc > decode_arg) &&  !strncmp(argv[decode_arg], "decode", strlen(argv[decode_arg]))) {
+		swo_channelmask = 0xFFFFFFFF; /* decoding all channels */
+		/* arguments: channels to decode */
+		if (argc > decode_arg + 1) {
+			swo_channelmask = 0x0;
+			for (int i = decode_arg+1; i < argc; i++) { /* create bitmask of channels to decode */
+				int channel = atoi(argv[i]);
+				if ((channel >= 0) && (channel <= 31))
+					swo_channelmask |= (uint32_t)0x1 << channel;
+			}
+		}
+	}
+#if defined(PLATFORM_HAS_DEBUG) && (PC_HOSTED == 0) && defined(ENABLE_DEBUG)
+	if (debug_bmp) {
+#if TRACESWO_PROTOCOL == 2
+		gdb_outf("baudrate: %lu ", baudrate);
+#endif
+		gdb_outf("channel mask: ");
+		for (int8_t i=31;i>=0;i--) {
+			uint8_t bit = (swo_channelmask >> i) & 0x1;
+			gdb_outf("%u", bit);
+		}
+		gdb_outf("\n");
+	}
+#endif
+#if TRACESWO_PROTOCOL == 2
+	traceswo_init(baudrate, swo_channelmask);
+#else
+	traceswo_init(swo_channelmask);
+#endif
+	serial_no_read(serial_no);
 	gdb_outf("%s:%02X:%02X\n", serial_no, 5, 0x85);
 	return true;
 }
 #endif
 
-#ifdef PLATFORM_HAS_DEBUG
+#if defined(PLATFORM_HAS_DEBUG) && (PC_HOSTED == 0)
 static bool cmd_debug_bmp(target *t, int argc, const char **argv)
 {
 	(void)t;
-	if (argc > 1) {
-		debug_bmp = !strcmp(argv[1], "enable");
+	bool print_status = false;
+	if (argc == 1) {
+		print_status = true;
+	} else if (argc == 2) {
+		if (parse_enable_or_disable(argv[1], &debug_bmp)) {
+			print_status = true;
+		}
+	} else {
+		gdb_outf("Unrecognized command format\n");
+	}
+
+	if (print_status) {
+		gdb_outf("Debug mode is %s\n",
+			 debug_bmp ? "enabled" : "disabled");
 	}
-	gdb_outf("Debug mode is %s\n",
-		 debug_bmp ? "enabled" : "disabled");
 	return true;
 }
 #endif
@@ -365,9 +642,28 @@ static bool cmd_enter_bootldr(target *t, int argc, const char **argv)
 #endif
 
 #ifdef PLATFORM_HAS_PRINTSERIAL
-bool cmd_serial(void)
+bool cmd_serial(target *t, int argc, char **argv)
 {
+	(void) t;
+	(void) argc;
+	(void) argv;
+
 	print_serial();
 	return true;
 }
 #endif
+
+static bool cmd_heapinfo(target *t, int argc, const char **argv)
+{
+	if (t == NULL) gdb_out("not attached\n");
+	else if (argc == 5) {
+		target_addr heap_base = strtoul(argv[1], NULL, 16);
+		target_addr heap_limit = strtoul(argv[2], NULL, 16);
+		target_addr stack_base = strtoul(argv[3], NULL, 16);
+		target_addr stack_limit = strtoul(argv[4], NULL, 16);
+		gdb_outf("heapinfo heap_base: %p heap_limit: %p stack_base: %p stack_limit: %p\n",
+			heap_base, heap_limit, stack_base, stack_limit);
+		target_set_heapinfo(t, heap_base, heap_limit, stack_base, stack_limit);
+	} else gdb_outf("heapinfo heap_base heap_limit stack_base stack_limit\n");
+	return true;
+}

src/crc32.c

@@ -20,8 +20,12 @@
 
 #include "general.h"
 #include "target.h"
+#include "gdb_if.h"
 
-#if !defined(STM32F1) && !defined(STM32F4)
+#if !defined(STM32F0) && !defined(STM32F1) && !defined(STM32F2) && \
+	!defined(STM32F3) && !defined(STM32F4) && !defined(STM32F7) && \
+	!defined(STM32L0) && !defined(STM32L1) && !defined(STM32F4) && \
+	!defined(STM32G0) && !defined(STM32G4)
 static const uint32_t crc32_table[] = {
 	0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9,
 	0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005,
@@ -94,14 +98,33 @@ static uint32_t crc32_calc(uint32_t crc, uint8_t data)
 	return (crc << 8) ^ crc32_table[((crc >> 24) ^ data) & 255];
 }
 
-uint32_t generic_crc32(target *t, uint32_t base, size_t len)
+int generic_crc32(target *t, uint32_t *crc_res, uint32_t base, size_t len)
 {
 	uint32_t crc = -1;
+#if PC_HOSTED == 1
+	/* Reading a 2 MByte on a H743 takes about 80 s@128, 28s @ 1k,
+	 * 22 s @ 4k and 21 s @ 64k
+	 */
+	uint8_t bytes[0x1000];
+#else
 	uint8_t bytes[128];
-
+#endif
+#if defined(ENABLE_DEBUG)
+	uint32_t start_time = platform_time_ms();
+#endif
+	uint32_t last_time = platform_time_ms();
 	while (len) {
+		uint32_t actual_time = platform_time_ms();
+		if ( actual_time > last_time + 1000) {
+			last_time = actual_time;
+			gdb_if_putchar(0, true);
+		}
 		size_t read_len = MIN(sizeof(bytes), len);
-		target_mem_read(t, bytes, base, read_len);
+		if (target_mem_read(t, bytes, base, read_len)) {
+			DEBUG_WARN("generic_crc32 error around address 0x%08" PRIx32 "\n",
+					   base);
+			return -1;
+		}
 
 		for (unsigned i = 0; i < read_len; i++)
 			crc = crc32_calc(crc, bytes[i]);
@@ -109,20 +132,32 @@ uint32_t generic_crc32(target *t, uint32_t base, size_t len)
 		base += read_len;
 		len -= read_len;
 	}
-	return crc;
+	DEBUG_WARN("%" PRIu32 " ms\n", platform_time_ms() - start_time);
+	*crc_res = crc;
+	return 0;
 }
 #else
 #include <libopencm3/stm32/crc.h>
-uint32_t generic_crc32(target *t, uint32_t base, size_t len)
+int generic_crc32(target *t, uint32_t *crc_res, uint32_t base, size_t len)
 {
 	uint8_t bytes[128];
 	uint32_t crc;
 
 	CRC_CR |= CRC_CR_RESET;
 
+	uint32_t last_time = platform_time_ms();
 	while (len > 3) {
+		uint32_t actual_time = platform_time_ms();
+		if ( actual_time > last_time + 1000) {
+			last_time = actual_time;
+			gdb_if_putchar(0, true);
+		}
 		size_t read_len = MIN(sizeof(bytes), len) & ~3;
-		target_mem_read(t, bytes, base, read_len);
+		if (target_mem_read(t, bytes, base, read_len)) {
+			DEBUG_WARN("generic_crc32 error around address 0x%08" PRIx32 "\n",
+					   base);
+			return -1;
+		}
 
 		for (unsigned i = 0; i < read_len; i += 4)
 			CRC_DR = __builtin_bswap32(*(uint32_t*)(bytes+i));
@@ -133,7 +168,11 @@ uint32_t generic_crc32(target *t, uint32_t base, size_t len)
 
 	crc = CRC_DR;
 
-	target_mem_read(t, bytes, base, len);
+	if (target_mem_read(t, bytes, base, len)) {
+		DEBUG_WARN("generic_crc32 error around address 0x%08" PRIx32 "\n",
+				   base);
+		return -1;
+	}
 	uint8_t *data = bytes;
 	while (len--) {
 		crc ^= *data++ << 24;
@@ -144,7 +183,8 @@ uint32_t generic_crc32(target *t, uint32_t base, size_t len)
 				crc <<= 1;
 		}
 	}
-	return crc;
+	*crc_res = crc;
+	return 0;
 }
 #endif
 

src/exception.c

@@ -26,7 +26,6 @@ struct exception *innermost_exception;
 void raise_exception(uint32_t type, const char *msg)
 {
 	struct exception *e;
-	DEBUG("Exception: %s\n", msg);
 	for (e = innermost_exception; e; e = e->outer) {
 		if (e->mask & type) {
 			e->type = type;
@@ -35,6 +34,7 @@ void raise_exception(uint32_t type, const char *msg)
 			longjmp(e->jmpbuf, type);
 		}
 	}
+	DEBUG_WARN("Unhandled exception: %s\n", msg);
 	abort();
 }
 

src/gdb_hostio.c

@@ -130,4 +130,3 @@ int hostio_system(struct target_controller *tc,
 	gdb_putpacket_f("Fsystem,%08X/%X", cmd, cmd_len);
 	return gdb_main_loop(tc, true);
 }
-

src/gdb_main.c

@@ -25,6 +25,7 @@
  */
 
 #include "general.h"
+#include "ctype.h"
 #include "hex_utils.h"
 #include "gdb_if.h"
 #include "gdb_packet.h"
@@ -34,6 +35,9 @@
 #include "command.h"
 #include "crc32.h"
 #include "morse.h"
+#ifdef ENABLE_RTT
+#include "rtt.h"
+#endif
 
 enum gdb_signal {
 	GDB_SIGINT = 2,
@@ -42,25 +46,37 @@ enum gdb_signal {
 	GDB_SIGLOST = 29,
 };
 
-#define BUF_SIZE	1024
+#define BUF_SIZE	1024U
 
 #define ERROR_IF_NO_TARGET()	\
 	if(!cur_target) { gdb_putpacketz("EFF"); break; }
 
-static char pbuf[BUF_SIZE+1];
+typedef struct
+{
+	const char *cmd_prefix;
+	void (*func)(const char *packet, size_t len);
+} cmd_executer;
+
+static char pbuf[BUF_SIZE + 1U];
 
 static target *cur_target;
 static target *last_target;
+static bool gdb_needs_detach_notify = false;
 
-static void handle_q_packet(char *packet, int len);
-static void handle_v_packet(char *packet, int len);
-static void handle_z_packet(char *packet, int len);
+static void handle_q_packet(char *packet, size_t len);
+static void handle_v_packet(char *packet, size_t len);
+static void handle_z_packet(char *packet, size_t len);
+static void handle_kill_target(void);
 
 static void gdb_target_destroy_callback(struct target_controller *tc, target *t)
 {
 	(void)tc;
-	if (cur_target == t)
+	if (cur_target == t) {
+		gdb_put_notificationz("%Stop:W00");
+		gdb_out("You are now detached from the previous target.\n");
 		cur_target = NULL;
+		gdb_needs_detach_notify = true;
+	}
 
 	if (last_target == t)
 		last_target = NULL;
@@ -93,24 +109,22 @@ static struct target_controller gdb_controller = {
 
 int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 {
-	int size;
 	bool single_step = false;
 
 	/* GDB protocol main loop */
-	while(1) {
+	while (1) {
 		SET_IDLE_STATE(1);
-		size = gdb_getpacket(pbuf, BUF_SIZE);
+		size_t size = gdb_getpacket(pbuf, BUF_SIZE);
 		SET_IDLE_STATE(0);
-		switch(pbuf[0]) {
+		switch (pbuf[0]) {
 		/* Implementation of these is mandatory! */
 		case 'g': { /* 'g': Read general registers */
 			ERROR_IF_NO_TARGET();
-			uint8_t arm_regs[target_regs_size(cur_target)];
-			target_regs_read(cur_target, arm_regs);
-			gdb_putpacket(hexify(pbuf, arm_regs, sizeof(arm_regs)),
-			              sizeof(arm_regs) * 2);
+			uint8_t gp_regs[target_regs_size(cur_target)];
+			target_regs_read(cur_target, gp_regs);
+			gdb_putpacket(hexify(pbuf, gp_regs, sizeof(gp_regs)), sizeof(gp_regs) * 2U);
 			break;
-			}
+		}
 		case 'm': {	/* 'm addr,len': Read len bytes from addr */
 			uint32_t addr, len;
 			ERROR_IF_NO_TARGET();
@@ -119,24 +133,26 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 				gdb_putpacketz("E02");
 				break;
 			}
-			DEBUG("m packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
+			DEBUG_GDB("m packet: addr = %" PRIx32 ", len = %" PRIx32 "\n",
+					  addr, len);
 			uint8_t mem[len];
 			if (target_mem_read(cur_target, mem, addr, len))
 				gdb_putpacketz("E01");
 			else
-				gdb_putpacket(hexify(pbuf, mem, len), len*2);
+				gdb_putpacket(hexify(pbuf, mem, len), len * 2U);
 			break;
-			}
+		}
 		case 'G': {	/* 'G XX': Write general registers */
 			ERROR_IF_NO_TARGET();
-			uint8_t arm_regs[target_regs_size(cur_target)];
-			unhexify(arm_regs, &pbuf[1], sizeof(arm_regs));
-			target_regs_write(cur_target, arm_regs);
+			uint8_t gp_regs[target_regs_size(cur_target)];
+			unhexify(gp_regs, &pbuf[1], sizeof(gp_regs));
+			target_regs_write(cur_target, gp_regs);
 			gdb_putpacketz("OK");
 			break;
-			}
+		}
 		case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
-			uint32_t addr, len;
+			uint32_t addr = 0;
+			uint32_t len = 0;
 			int hex;
 			ERROR_IF_NO_TARGET();
 			sscanf(pbuf, "M%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &hex);
@@ -144,7 +160,8 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 				gdb_putpacketz("E02");
 				break;
 			}
-			DEBUG("M packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
+			DEBUG_GDB("M packet: addr = %" PRIx32 ", len = %" PRIx32 "\n",
+					  addr, len);
 			uint8_t mem[len];
 			unhexify(mem, pbuf + hex, len);
 			if (target_mem_write(cur_target, addr, mem, len))
@@ -152,12 +169,25 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 			else
 				gdb_putpacketz("OK");
 			break;
-			}
+		}
+		/* '[m|M|g|G|c][thread-id]' : Set the thread ID for the given subsequent operation
+		 * (we don't actually care which as we only care about the TID for whether to send OK or an error)
+		 */
+		case 'H': {
+			char operation = 0;
+			uint32_t thread_id = 0;
+			sscanf(pbuf, "H%c%" SCNx32, &operation, &thread_id);
+			if (thread_id <= 1)
+				gdb_putpacketz("OK");
+			else
+				gdb_putpacketz("E01");
+			break;
+		}
 		case 's':	/* 's [addr]': Single step [start at addr] */
 			single_step = true;
-			// Fall through to resume target
+			/* fall through */
 		case 'c':	/* 'c [addr]': Continue [at addr] */
-			if(!cur_target) {
+			if (!cur_target) {
 				gdb_putpacketz("X1D");
 				break;
 			}
@@ -165,14 +195,14 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 			target_halt_resume(cur_target, single_step);
 			SET_RUN_STATE(1);
 			single_step = false;
-			// Fall through to wait for target halt
+			/* fall through */
 		case '?': {	/* '?': Request reason for target halt */
 			/* This packet isn't documented as being mandatory,
 			 * but GDB doesn't work without it. */
 			target_addr watch;
 			enum target_halt_reason reason;
 
-			if(!cur_target) {
+			if (!cur_target) {
 				/* Report "target exited" if no target */
 				gdb_putpacketz("W00");
 				break;
@@ -180,10 +210,13 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 
 			/* Wait for target halt */
 			while(!(reason = target_halt_poll(cur_target, &watch))) {
-				unsigned char c = gdb_if_getchar_to(0);
-				if((c == '\x03') || (c == '\x04')) {
+				char c = (char)gdb_if_getchar_to(0);
+				if(c == '\x03' || c == '\x04') {
 					target_halt_request(cur_target);
 				}
+				#ifdef ENABLE_RTT
+				if (rtt_enabled) poll_rtt(cur_target);
+				#endif
 			}
 			SET_RUN_STATE(0);
 
@@ -206,17 +239,45 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 				gdb_putpacket_f("T%02X", GDB_SIGTRAP);
 			}
 			break;
-			}
+		}
+
+		/* Optional GDB packet support */
+		case 'p': { /* Read single register */
+			ERROR_IF_NO_TARGET();
+			uint32_t reg;
+			sscanf(pbuf, "p%" SCNx32, &reg);
+			uint8_t val[8];
+			size_t s = target_reg_read(cur_target, reg, val, sizeof(val));
+			if (s > 0)
+				gdb_putpacket(hexify(pbuf, val, s), s * 2);
+			else
+				gdb_putpacketz("EFF");
+			break;
+		}
+		case 'P': { /* Write single register */
+			ERROR_IF_NO_TARGET();
+			uint32_t reg;
+			int n;
+			sscanf(pbuf, "P%" SCNx32 "=%n", &reg, &n);
+			// TODO: FIXME, VLAs considered harmful.
+			uint8_t val[strlen(&pbuf[n]) / 2];
+			unhexify(val, pbuf + n, sizeof(val));
+			if (target_reg_write(cur_target, reg, val, sizeof(val)) > 0)
+				gdb_putpacketz("OK");
+			else
+				gdb_putpacketz("EFF");
+			break;
+		}
+
 		case 'F':	/* Semihosting call finished */
-			if (in_syscall) {
+			if (in_syscall)
 				return hostio_reply(tc, pbuf, size);
-			} else {
-				DEBUG("*** F packet when not in syscall! '%s'\n", pbuf);
+			else {
+				DEBUG_GDB("*** F packet when not in syscall! '%s'\n", pbuf);
 				gdb_putpacketz("");
 			}
 			break;
 
-		/* Optional GDB packet support */
 		case '!':	/* Enable Extended GDB Protocol. */
 			/* This doesn't do anything, we support the extended
 			 * protocol anyway, but GDB will never send us a 'R'
@@ -227,20 +288,17 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 
 		case 0x04:
 		case 'D':	/* GDB 'detach' command. */
-			if(cur_target)
+			if(cur_target) {
+				SET_RUN_STATE(1);
 				target_detach(cur_target);
+			}
 			last_target = cur_target;
 			cur_target = NULL;
 			gdb_putpacketz("OK");
 			break;
 
 		case 'k':	/* Kill the target */
-			if(cur_target) {
-				target_reset(cur_target);
-				target_detach(cur_target);
-				last_target = cur_target;
-				cur_target = NULL;
-			}
+			handle_kill_target();
 			break;
 
 		case 'r':	/* Reset the target system */
@@ -250,6 +308,8 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 			else if(last_target) {
 				cur_target = target_attach(last_target,
 						           &gdb_controller);
+				if(cur_target)
+					morse(NULL, false);
 				target_reset(cur_target);
 			}
 			break;
@@ -263,19 +323,20 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 				gdb_putpacketz("E02");
 				break;
 			}
-			DEBUG("X packet: addr = %" PRIx32 ", len = %" PRIx32 "\n", addr, len);
-			if (target_mem_write(cur_target, addr, pbuf+bin, len))
+			DEBUG_GDB("X packet: addr = %" PRIx32 ", len = %" PRIx32 "\n",
+					  addr, len);
+			if (target_mem_write(cur_target, addr, pbuf + bin, len))
 				gdb_putpacketz("E01");
 			else
 				gdb_putpacketz("OK");
 			break;
-			}
+		}
 
 		case 'q':	/* General query packet */
 			handle_q_packet(pbuf, size);
 			break;
 
-		case 'v':	/* General query packet */
+		case 'v':	/* Verbose command packet */
 			handle_v_packet(pbuf, size);
 			break;
 
@@ -287,199 +348,344 @@ int gdb_main_loop(struct target_controller *tc, bool in_syscall)
 			break;
 
 		default: 	/* Packet not implemented */
-			DEBUG("*** Unsupported packet: %s\n", pbuf);
+			DEBUG_GDB("*** Unsupported packet: %s\n", pbuf);
 			gdb_putpacketz("");
 		}
 	}
 }
 
-static void
-handle_q_string_reply(const char *str, const char *param)
+static bool exec_command(char *packet, const size_t length, const cmd_executer *exec)
 {
-	unsigned long addr, len;
+	while (exec->cmd_prefix) {
+		const size_t prefix_length = strlen(exec->cmd_prefix);
+		if (!strncmp(packet, exec->cmd_prefix, prefix_length)) {
+			exec->func(packet + prefix_length, length - prefix_length);
+			return true;
+		}
+		++exec;
+	}
+	return false;
+}
 
-	if (sscanf(param, "%08lx,%08lx", &addr, &len) != 2) {
+static void exec_q_rcmd(const char *packet, const size_t length)
+{
+	/* calculate size and allocate buffer for command */
+	const size_t datalen = length / 2U;
+	char *data = alloca(datalen + 1);
+	/* dehexify command */
+	unhexify(data, packet, datalen);
+	data[datalen] = 0;	/* add terminating null */
+
+	const int c = command_process(cur_target, data);
+	if (c < 0)
+		gdb_putpacketz("");
+	else if (c == 0)
+		gdb_putpacketz("OK");
+	else
+		gdb_putpacket(hexify(pbuf, "Failed\n", strlen("Failed\n")),
+				2 * strlen("Failed\n"));
+}
+
+static void handle_q_string_reply(const char *reply, const char *param)
+{
+	const size_t reply_length = strlen(reply);
+	uint32_t addr = 0;
+	uint32_t len = 0;
+
+	if (sscanf(param, "%08" PRIx32 ",%08" PRIx32, &addr, &len) != 2) {
 		gdb_putpacketz("E01");
 		return;
 	}
-	if (addr < strlen (str)) {
-		char reply[len+2];
-		reply[0] = 'm';
-		strncpy (reply + 1, &str[addr], len);
-		if(len > strlen(&str[addr]))
-			len = strlen(&str[addr]);
-		gdb_putpacket(reply, len + 1);
-	} else if (addr == strlen (str)) {
-		gdb_putpacketz("l");
-	} else
+	if (addr > reply_length) {
 		gdb_putpacketz("E01");
+		return;
+	}
+	if (addr == reply_length) {
+		gdb_putpacketz("l");
+		return;
+	}
+	size_t output_len = reply_length - addr;
+	if (output_len > len)
+		output_len = len;
+	gdb_putpacket2("m", 1U, reply + addr, output_len);
 }
 
-static void
-handle_q_packet(char *packet, int len)
+static void exec_q_supported(const char *packet, const size_t length)
 {
-	uint32_t addr, alen;
+	(void)packet;
+	(void)length;
+	gdb_putpacket_f("PacketSize=%X;qXfer:memory-map:read+;qXfer:features:read+", BUF_SIZE);
+}
 
-	if(!strncmp(packet, "qRcmd,", 6)) {
-		char *data;
-		int datalen;
+static void exec_q_memory_map(const char *packet, const size_t length)
+{
+	(void)packet;
+	(void)length;
+	/* Read target XML memory map */
+	if ((!cur_target) && last_target) {
+		/* Attach to last target if detached. */
+		cur_target = target_attach(last_target,
+				   &gdb_controller);
+	}
+	if (!cur_target) {
+		gdb_putpacketz("E01");
+		return;
+	}
+	char buf[1024];
+	target_mem_map(cur_target, buf, sizeof(buf)); /* Fixme: Check size!*/
+	handle_q_string_reply(buf, packet);
+}
 
-		/* calculate size and allocate buffer for command */
-		datalen = (len - 6) / 2;
-		data = alloca(datalen+1);
-		/* dehexify command */
-		unhexify(data, packet+6, datalen);
-		data[datalen] = 0;	/* add terminating null */
+static void exec_q_feature_read(const char *packet, const size_t length)
+{
+	(void)length;
+	/* Read target description */
+	if ((!cur_target) && last_target) {
+	  /* Attach to last target if detached. */
+	  cur_target = target_attach(last_target, &gdb_controller);
+	}
+	if (!cur_target) {
+	  gdb_putpacketz("E01");
+	  return;
+	}
+	handle_q_string_reply(target_tdesc(cur_target), packet);
+}
 
-		int c = command_process(cur_target, data);
-		if(c < 0)
-			gdb_putpacketz("");
-		else if(c == 0)
-			gdb_putpacketz("OK");
+static void exec_q_crc(const char *packet, const size_t length)
+{
+	(void)length;
+	uint32_t addr;
+	uint32_t addr_length;
+	if (sscanf(packet, "%" PRIx32 ",%" PRIx32, &addr, &addr_length) == 2) {
+		if (!cur_target) {
+			gdb_putpacketz("E01");
+			return;
+		}
+		uint32_t crc;
+		if (generic_crc32(cur_target, &crc, addr, addr_length))
+			gdb_putpacketz("E03");
 		else
-			gdb_putpacketz("E");
-
-	} else if (!strncmp (packet, "qSupported", 10)) {
-		/* Query supported protocol features */
-		gdb_putpacket_f("PacketSize=%X;qXfer:memory-map:read+;qXfer:features:read+", BUF_SIZE);
-
-	} else if (strncmp (packet, "qXfer:memory-map:read::", 23) == 0) {
-		/* Read target XML memory map */
-		if((!cur_target) && last_target) {
-			/* Attach to last target if detached. */
-			cur_target = target_attach(last_target,
-						   &gdb_controller);
-		}
-		if (!cur_target) {
-			gdb_putpacketz("E01");
-			return;
-		}
-		handle_q_string_reply(target_mem_map(cur_target), packet + 23);
-
-	} else if (strncmp (packet, "qXfer:features:read:target.xml:", 31) == 0) {
-		/* Read target description */
-		if((!cur_target) && last_target) {
-			/* Attach to last target if detached. */
-			cur_target = target_attach(last_target,
-						   &gdb_controller);
-		}
-		if (!cur_target) {
-			gdb_putpacketz("E01");
-			return;
-		}
-		handle_q_string_reply(target_tdesc(cur_target), packet + 31);
-	} else if (sscanf(packet, "qCRC:%" PRIx32 ",%" PRIx32, &addr, &alen) == 2) {
-		if(!cur_target) {
-			gdb_putpacketz("E01");
-			return;
-		}
-		gdb_putpacket_f("C%lx", generic_crc32(cur_target, addr, alen));
-
-	} else {
-		DEBUG("*** Unsupported packet: %s\n", packet);
-		gdb_putpacket("", 0);
+			gdb_putpacket_f("C%lx", crc);
 	}
 }
 
-static void
-handle_v_packet(char *packet, int plen)
+/*
+ * qC queries are for the current thread. We don't support threads but GDB 11 and 12 require this,
+ * so we always answer that the current thread is thread 1.
+ */
+static void exec_q_c(const char *packet, const size_t length)
 {
-	unsigned long addr, len;
+	(void)packet;
+	(void)length;
+	gdb_putpacketz("QC1");
+}
+
+/*
+ * qfThreadInfo queries are required in GDB 11 and 12 as these GDBs require the server to support
+ * threading even when there's only the possiblity for one thread to exist. In this instance,
+ * we have to tell GDB that there is a single active thread so it doesn't think the "thread" died.
+ * qsThreadInfo will always follow qfThreadInfo when we reply as we have to specify 'l' at the
+ * end to terminate the list.. GDB doesn't like this not happening.
+ */
+static void exec_q_thread_info(const char *packet, const size_t length)
+{
+	(void)length;
+	if (packet[-11] == 'f')
+		gdb_putpacketz("m1");
+	else
+		gdb_putpacketz("l");
+}
+
+static const cmd_executer q_commands[]=
+{
+	{"qRcmd,",                         exec_q_rcmd},
+	{"qSupported",                     exec_q_supported},
+	{"qXfer:memory-map:read::",        exec_q_memory_map},
+	{"qXfer:features:read:target.xml:",exec_q_feature_read},
+	{"qCRC:",                          exec_q_crc},
+	{"qC",                             exec_q_c},
+	{"qfThreadInfo",                   exec_q_thread_info},
+	{"qsThreadInfo",                   exec_q_thread_info},
+	{NULL, NULL},
+};
+
+static void handle_kill_target(void)
+{
+	if (cur_target) {
+		target_reset(cur_target);
+		target_detach(cur_target);
+		last_target = cur_target;
+		cur_target = NULL;
+	}
+}
+
+static void handle_q_packet(char *packet, const size_t length)
+{
+	if (exec_command(packet, length, q_commands))
+		return;
+	DEBUG_GDB("*** Unsupported packet: %s\n", packet);
+	gdb_putpacket("", 0);
+}
+
+static void handle_v_packet(char *packet, const size_t plen)
+{
+	uint32_t addr = 0;
+	uint32_t len = 0;
 	int bin;
 	static uint8_t flash_mode = 0;
 
-	if (sscanf(packet, "vAttach;%08lx", &addr) == 1) {
+	if (sscanf(packet, "vAttach;%08" PRIx32, &addr) == 1) {
 		/* Attach to remote target processor */
 		cur_target = target_attach_n(addr, &gdb_controller);
-		if(cur_target)
-			gdb_putpacketz("T05");
-		else
+		if(cur_target) {
+			morse(NULL, false);
+			/*
+			 * We don't actually support threads, but GDB 11 and 12 can't work without
+			 * us saying we attached to thread 1.. see the following for the low-down of this:
+			 * https://sourceware.org/bugzilla/show_bug.cgi?id=28405
+			 * https://sourceware.org/bugzilla/show_bug.cgi?id=28874
+			 * https://sourceware.org/pipermail/gdb-patches/2021-December/184171.html
+			 * https://sourceware.org/pipermail/gdb-patches/2022-April/188058.html
+			 * https://sourceware.org/pipermail/gdb-patches/2022-July/190869.html
+			 */
+			gdb_putpacketz("T05thread:1;");
+		} else
 			gdb_putpacketz("E01");
 
-	} else if (!strcmp(packet, "vRun;")) {
+	} else if (!strncmp(packet, "vKill;", 6)) {
+		/* Kill the target - we don't actually care about the PID that follows "vKill;" */
+		handle_kill_target();
+		gdb_putpacketz("OK");
+
+	} else if (!strncmp(packet, "vRun", 4)) {
+		/* Parse command line for get_cmdline semihosting call */
+		char cmdline[83];
+		char *pcmdline = cmdline;
+		char *tok = packet + 4;
+		if (*tok == ';')
+			++tok;
+		cmdline[0] = '\0';
+		while(*tok != '\0') {
+			if (strlen(cmdline) + 3 >= sizeof(cmdline))
+				break;
+			if (*tok == ';') {
+				*pcmdline++ = ' ';
+				pcmdline[0] = '\0';
+				tok++;
+				continue;
+			}
+			if (isxdigit(tok[0]) && isxdigit(tok[1])) {
+				unhexify(pcmdline, tok, 2);
+				if ((*pcmdline == ' ') || (*pcmdline == '\\')) {
+					pcmdline[1] = *pcmdline;
+					*pcmdline++ = '\\';
+				}
+				pcmdline++;
+				tok += 2;
+				pcmdline[0] = '\0';
+				continue;
+			}
+			break;
+		}
+		#ifdef ENABLE_RTT
+		/* force searching rtt control block */
+		rtt_found = false;
+		#endif
 		/* Run target program. For us (embedded) this means reset. */
-		if(cur_target) {
+		if (cur_target) {
+			target_set_cmdline(cur_target, cmdline);
 			target_reset(cur_target);
 			gdb_putpacketz("T05");
-		} else if(last_target) {
+		} else if (last_target) {
 			cur_target = target_attach(last_target,
 						   &gdb_controller);
 
-                        /* If we were able to attach to the target again */
-                        if (cur_target) {
-                        	target_reset(cur_target);
-                        	gdb_putpacketz("T05");
-                        } else	gdb_putpacketz("E01");
+			/* If we were able to attach to the target again */
+			if (cur_target) {
+				target_set_cmdline(cur_target, cmdline);
+				target_reset(cur_target);
+				morse(NULL, false);
+				gdb_putpacketz("T05");
+			} else
+				gdb_putpacketz("E01");
 
-		} else	gdb_putpacketz("E01");
+		} else
+			gdb_putpacketz("E01");
 
-	} else if (sscanf(packet, "vFlashErase:%08lx,%08lx", &addr, &len) == 2) {
+	} else if (sscanf(packet, "vFlashErase:%08" PRIx32 ",%08" PRIx32, &addr, &len) == 2) {
 		/* Erase Flash Memory */
-		DEBUG("Flash Erase %08lX %08lX\n", addr, len);
-		if(!cur_target) { gdb_putpacketz("EFF"); return; }
+		DEBUG_GDB("Flash Erase %08" PRIX32 " %08" PRIX32 "\n", addr, len);
+		if (!cur_target) {
+			gdb_putpacketz("EFF");
+			return;
+		}
 
-		if(!flash_mode) {
+		if (!flash_mode) {
 			/* Reset target if first flash command! */
 			/* This saves us if we're interrupted in IRQ context */
 			target_reset(cur_target);
 			flash_mode = 1;
 		}
-		if(target_flash_erase(cur_target, addr, len) == 0)
+		if (target_flash_erase(cur_target, addr, len) == 0)
 			gdb_putpacketz("OK");
-		else
+		else {
+			flash_mode = 0;
 			gdb_putpacketz("EFF");
+		}
 
-	} else if (sscanf(packet, "vFlashWrite:%08lx:%n", &addr, &bin) == 1) {
+	} else if (sscanf(packet, "vFlashWrite:%08" PRIx32 ":%n", &addr, &bin) == 1) {
 		/* Write Flash Memory */
-		len = plen - bin;
-		DEBUG("Flash Write %08lX %08lX\n", addr, len);
-		if(cur_target && target_flash_write(cur_target, addr, (void*)packet + bin, len) == 0)
+		const uint32_t count = plen - bin;
+		DEBUG_GDB("Flash Write %08" PRIX32 " %08" PRIX32 "\n", addr, count);
+		if (cur_target && target_flash_write(cur_target, addr, (void*)packet + bin, count) == 0)
 			gdb_putpacketz("OK");
-		else
+		else {
+			flash_mode = 0;
 			gdb_putpacketz("EFF");
+		}
 
 	} else if (!strcmp(packet, "vFlashDone")) {
 		/* Commit flash operations. */
 		gdb_putpacketz(target_flash_done(cur_target) ? "EFF" : "OK");
 		flash_mode = 0;
 
+	} else if (!strcmp(packet, "vStopped")) {
+		if (gdb_needs_detach_notify) {
+			gdb_putpacketz("W00");
+			gdb_needs_detach_notify = false;
+		} else
+			gdb_putpacketz("OK");
+
 	} else {
-		DEBUG("*** Unsupported packet: %s\n", packet);
+		DEBUG_GDB("*** Unsupported packet: %s\n", packet);
 		gdb_putpacket("", 0);
 	}
 }
 
-static void
-handle_z_packet(char *packet, int plen)
+static void handle_z_packet(char *packet, const size_t plen)
 {
 	(void)plen;
 
-	uint8_t set = (packet[0] == 'Z') ? 1 : 0;
-	int type, len;
+	uint32_t type;
+	uint32_t len;
 	uint32_t addr;
-	int ret;
+	sscanf(packet, "%*[zZ]%" PRIu32 ",%08" PRIx32 ",%" PRIu32, &type, &addr, &len);
 
-	/* I have no idea why this doesn't work. Seems to work
-	 * with real sscanf() though... */
-	//sscanf(packet, "%*[zZ]%hhd,%08lX,%hhd", &type, &addr, &len);
-	type = packet[1] - '0';
-	sscanf(packet + 2, ",%" PRIx32 ",%d", &addr, &len);
-	if(set)
+	int ret = 0;
+	if (packet[0] == 'Z')
 		ret = target_breakwatch_set(cur_target, type, addr, len);
 	else
 		ret = target_breakwatch_clear(cur_target, type, addr, len);
 
-	if (ret < 0) {
+	if (ret < 0)
 		gdb_putpacketz("E01");
-	} else if (ret > 0) {
+	else if (ret > 0)
 		gdb_putpacketz("");
-	} else {
+	else
 		gdb_putpacketz("OK");
-	}
 }
 
 void gdb_main(void)
 {
 	gdb_main_loop(&gdb_controller, false);
 }
-

src/gdb_packet.c

@@ -26,107 +26,200 @@
 #include "gdb_if.h"
 #include "gdb_packet.h"
 #include "hex_utils.h"
+#include "remote.h"
 
 #include <stdarg.h>
 
-int gdb_getpacket(char *packet, int size)
+size_t gdb_getpacket(char *packet, size_t size)
 {
-	unsigned char c;
 	unsigned char csum;
 	char recv_csum[3];
-	int i;
+	size_t offset = 0;
 
-	while(1) {
-		/* Wait for packet start */
-		while((packet[0] = gdb_if_getchar()) != '$')
-			if(packet[0] == 0x04) return 1;
+	while (1) {
+	    /* Wait for packet start */
+		do {
+			/* Spin waiting for a start of packet character - either a gdb
+             * start ('$') or a BMP remote packet start ('!').
+			 */
+			do {
+				/* Smells like bad code */
+				packet[0] = (char)gdb_if_getchar();
+				if (packet[0] == 0x04)
+					return 1;
+			} while ((packet[0] != '$') && (packet[0] != REMOTE_SOM));
+#if PC_HOSTED == 0
+			if (packet[0] == REMOTE_SOM) {
+				/* This is probably a remote control packet
+				 * - get and handle it */
+				offset = 0;
+				bool gettingRemotePacket = true;
+				while (gettingRemotePacket) {
+					/* Smells like bad code */
+					const char c = (char)gdb_if_getchar();
+					switch (c) {
+					case REMOTE_SOM: /* Oh dear, packet restarts */
+						offset = 0;
+						break;
 
-		i = 0; csum = 0;
+					case REMOTE_EOM: /* Complete packet for processing */
+						packet[offset] = 0;
+						remotePacketProcess(offset, packet);
+						gettingRemotePacket = false;
+						break;
+
+					case '$': /* A 'real' gdb packet, best stop squatting now */
+						packet[0] = '$';
+						gettingRemotePacket = false;
+						break;
+
+					default:
+						if (offset < size) {
+							packet[offset++] = c;
+						} else {
+							/* Who knows what is going on...return to normality */
+							gettingRemotePacket = false;
+						}
+						break;
+					}
+				}
+				/* Reset the packet buffer start character to zero, because function
+				 * 'remotePacketProcess()' above overwrites this buffer, and
+				 * an arbitrary character may have been placed there. If this is a '$'
+				 * character, this will cause this loop to be terminated, which is wrong.
+				 */
+				packet[0] = 0;
+			}
+#endif
+	    } while (packet[0] != '$');
+
+		offset = 0;
+		csum = 0;
+		char c;
 		/* Capture packet data into buffer */
-		while((c = gdb_if_getchar()) != '#') {
+		while ((c = (char)gdb_if_getchar()) != '#') {
 
-			if(i == size) break; /* Oh shit */
+			/* If we run out of buffer space, exit early */
+			if (offset == size)
+				break;
 
-			if(c == '$') { /* Restart capture */
-				i = 0;
+			if (c == '$') { /* Restart capture */
+				offset = 0;
 				csum = 0;
 				continue;
 			}
-			if(c == '}') { /* escaped char */
+			if (c == '}') { /* escaped char */
 				c = gdb_if_getchar();
 				csum += c + '}';
-				packet[i++] = c ^ 0x20;
+				packet[offset++] = c ^ 0x20;
 				continue;
 			}
 			csum += c;
-			packet[i++] = c;
+			packet[offset++] = c;
 		}
-		recv_csum[0] = gdb_if_getchar();
-		recv_csum[1] = gdb_if_getchar();
+		recv_csum[0] = (char)gdb_if_getchar();
+		recv_csum[1] = (char)gdb_if_getchar();
 		recv_csum[2] = 0;
 
 		/* return packet if checksum matches */
-		if(csum == strtol(recv_csum, NULL, 16)) break;
+		if (csum == strtol(recv_csum, NULL, 16))
+			break;
 
 		/* get here if checksum fails */
 		gdb_if_putchar('-', 1); /* send nack */
 	}
 	gdb_if_putchar('+', 1); /* send ack */
-	packet[i] = 0;
+	packet[offset] = 0;
 
-#ifdef DEBUG_GDBPACKET
-	DEBUG("%s : ", __func__);
-	for(int j = 0; j < i; j++) {
-		c = packet[j];
-		if ((c >= 32) && (c < 127))
-			DEBUG("%c", c);
+#if PC_HOSTED == 1
+	DEBUG_GDB_WIRE("%s : ", __func__);
+	for (size_t j = 0; j < offset; j++) {
+		const char c = packet[j];
+		if (c >= ' ' && c < 0x7F)
+			DEBUG_GDB_WIRE("%c", c);
 		else
-			DEBUG("\\x%02X", c);
+			DEBUG_GDB_WIRE("\\x%02X", c);
 	}
-	DEBUG("\n");
+	DEBUG_GDB_WIRE("\n");
 #endif
-	return i;
+	return offset;
 }
 
-void gdb_putpacket(const char *packet, int size)
+static void gdb_next_char(char c, unsigned char *csum)
+{
+#if PC_HOSTED == 1
+	if ((c >= 32) && (c < 127))
+		DEBUG_GDB_WIRE("%c", c);
+	else
+		DEBUG_GDB_WIRE("\\x%02X", c);
+#endif
+	if ((c == '$') || (c == '#') || (c == '}') || (c == '*')) {
+		gdb_if_putchar('}', 0);
+		gdb_if_putchar(c ^ 0x20, 0);
+		*csum += '}' + (c ^ 0x20);
+	}
+	else {
+		gdb_if_putchar(c, 0);
+		*csum += c;
+	}
+}
+
+void gdb_putpacket2(const char *packet1, size_t size1, const char *packet2, size_t size2)
 {
-	int i;
-	unsigned char csum;
-	unsigned char c;
 	char xmit_csum[3];
-	int tries = 0;
+	size_t tries = 0;
 
 	do {
-#ifdef DEBUG_GDBPACKET
-		DEBUG("%s : ", __func__);
-#endif
-		csum = 0;
+		DEBUG_GDB_WIRE("%s: ", __func__);
+		unsigned char csum = 0;
 		gdb_if_putchar('$', 0);
-		for(i = 0; i < size; i++) {
-			c = packet[i];
-#ifdef DEBUG_GDBPACKET
-			if ((c >= 32) && (c < 127))
-				DEBUG("%c", c);
-			else
-				DEBUG("\\x%02X", c);
-#endif
-			if((c == '$') || (c == '#') || (c == '}')) {
-				gdb_if_putchar('}', 0);
-				gdb_if_putchar(c ^ 0x20, 0);
-				csum += '}' + (c ^ 0x20);
-			} else {
-				gdb_if_putchar(c, 0);
-				csum += c;
-			}
-		}
+
+		for (size_t i = 0; i < size1; ++i)
+			gdb_next_char(packet1[i], &csum);
+		for (size_t i = 0; i < size2; ++i)
+			gdb_next_char(packet2[i], &csum);
+
 		gdb_if_putchar('#', 0);
-		sprintf(xmit_csum, "%02X", csum);
+		snprintf(xmit_csum, sizeof(xmit_csum), "%02X", csum);
 		gdb_if_putchar(xmit_csum[0], 0);
 		gdb_if_putchar(xmit_csum[1], 1);
-#ifdef DEBUG_GDBPACKET
-		DEBUG("\n");
-#endif
-	} while((gdb_if_getchar_to(2000) != '+') && (tries++ < 3));
+		DEBUG_GDB_WIRE("\n");
+	} while (gdb_if_getchar_to(2000) != '+' && tries++ < 3);
+}
+
+void gdb_putpacket(const char *packet, size_t size)
+{
+	char xmit_csum[3];
+	size_t tries = 0;
+
+	do {
+		DEBUG_GDB_WIRE("%s: ", __func__);
+		unsigned char csum = 0;
+		gdb_if_putchar('$', 0);
+		for (size_t i = 0; i < size; ++i)
+			gdb_next_char(packet[i], &csum);
+		gdb_if_putchar('#', 0);
+		snprintf(xmit_csum, sizeof(xmit_csum), "%02X", csum);
+		gdb_if_putchar(xmit_csum[0], 0);
+		gdb_if_putchar(xmit_csum[1], 1);
+		DEBUG_GDB_WIRE("\n");
+	} while (gdb_if_getchar_to(2000) != '+' && tries++ < 3);
+}
+
+void gdb_put_notification(const char *const packet, const size_t size)
+{
+	char xmit_csum[3];
+
+	DEBUG_GDB_WIRE("%s: ", __func__);
+	uint8_t csum = 0;
+	gdb_if_putchar('%', 0);
+	for (size_t i = 0; i < size; ++i)
+		gdb_next_char(packet[i], &csum);
+	gdb_if_putchar('#', 0);
+	snprintf(xmit_csum, sizeof(xmit_csum), "%02X", csum);
+	gdb_if_putchar(xmit_csum[0], 0);
+	gdb_if_putchar(xmit_csum[1], 1);
+	DEBUG_GDB_WIRE("\n");
 }
 
 void gdb_putpacket_f(const char *fmt, ...)
@@ -144,13 +237,13 @@ void gdb_putpacket_f(const char *fmt, ...)
 
 void gdb_out(const char *buf)
 {
-	char *hexdata;
-	int i;
-
-	hexdata = alloca((i = strlen(buf)*2 + 1) + 1);
-	hexdata[0] = 'O';
-	hexify(hexdata+1, buf, strlen(buf));
-	gdb_putpacket(hexdata, i);
+	int l = strlen(buf);
+	char *hexdata = calloc(1, 2 * l + 1);
+	if (!hexdata)
+		return;
+	hexify(hexdata, buf, l);
+	gdb_putpacket2("O", 1, hexdata, 2 * l);
+	free(hexdata);
 }
 
 void gdb_voutf(const char *fmt, va_list ap)

src/hex_utils.c

@@ -26,16 +26,16 @@
 
 static const char hexdigits[] = "0123456789abcdef";
 
-char * hexify(char *hex, const void *buf, size_t size)
+char *hexify(char *hex, const void *buf, const size_t size)
 {
-	char *tmp = hex;
-	const uint8_t *b = buf;
+	char *dst = hex;
+	const uint8_t *const src = buf;
 
-	while (size--) {
-		*tmp++ = hexdigits[*b >> 4];
-		*tmp++ = hexdigits[*b++ & 0xF];
+	for (size_t idx = 0; idx < size; ++idx) {
+		*dst++ = hexdigits[src[idx] >> 4];
+		*dst++ = hexdigits[src[idx] & 0xF];
 	}
-	*tmp++ = 0;
+	*dst++ = 0;
 
 	return hex;
 }
@@ -43,20 +43,18 @@ char * hexify(char *hex, const void *buf, size_t size)
 static uint8_t unhex_digit(char hex)
 {
 	uint8_t tmp = hex - '0';
-	if(tmp > 9)
+	if (tmp > 9)
 		tmp -= 'A' - '0' - 10;
-	if(tmp > 16)
+	if (tmp > 16)
 		tmp -= 'a' - 'A';
 	return tmp;
 }
 
-char * unhexify(void *buf, const char *hex, size_t size)
+char *unhexify(void *buf, const char *hex, const size_t size)
 {
-	uint8_t *b = buf;
-	while (size--) {
-		*b = unhex_digit(*hex++) << 4;
-		*b++ |= unhex_digit(*hex++);
+	uint8_t *const dst = buf;
+	for (size_t idx = 0; idx < size; ++idx, hex += 2) {
+		dst[idx] = (unhex_digit(hex[0]) << 4) | unhex_digit(hex[1]);
 	}
 	return buf;
 }
-

src/include/command.h

@@ -21,9 +21,19 @@
 #ifndef __COMMAND_H
 #define __COMMAND_H
 
+#include <stdbool.h>
+
 #include "target.h"
 
 int command_process(target *t, char *cmd);
 
+/*
+ * Attempts to parse a string as either being "enable" or "disable".
+ * If the parse is successful, returns true and sets the out param to
+ * indicate what was parsed. If not successful, emits a warning to the
+ * gdb port, returns false and leaves out untouched.
+ */
+bool parse_enable_or_disable(const char *s, bool *out);
+
 #endif
 

src/include/crc32.h

@@ -21,6 +21,6 @@
 #ifndef __CRC32_H
 #define __CRC32_H
 
-uint32_t generic_crc32(target *t, uint32_t base, int len);
+int generic_crc32(target *t, uint32_t *crc, uint32_t base, int len);
 
 #endif

src/include/gdb_if.h

@@ -21,7 +21,7 @@
 #ifndef __GDB_IF_H
 #define __GDB_IF_H
 
-#if !defined(LIBFTDI)
+#if PC_HOSTED == 0
 #include <libopencm3/usb/usbd.h>
 void gdb_usb_out_cb(usbd_device *dev, uint8_t ep);
 #endif
@@ -29,6 +29,8 @@ void gdb_usb_out_cb(usbd_device *dev, uint8_t ep);
 int gdb_if_init(void);
 unsigned char gdb_if_getchar(void);
 unsigned char gdb_if_getchar_to(int timeout);
+
+/* sending gdb_if_putchar(0, true) seems to work as keep alive */
 void gdb_if_putchar(unsigned char c, int flush);
 
 #endif

src/include/gdb_packet.h

@@ -21,17 +21,19 @@
 #ifndef __GDB_PACKET_H
 #define __GDB_PACKET_H
 
+#include <stddef.h>
 #include <stdarg.h>
 
-int gdb_getpacket(char *packet, int size);
-void gdb_putpacket(const char *packet, int size);
+size_t gdb_getpacket(char *packet, size_t size);
+void gdb_putpacket(const char *packet, size_t size);
+void gdb_putpacket2(const char *packet1, size_t size1, const char *packet2, size_t size2);
 #define gdb_putpacketz(packet) gdb_putpacket((packet), strlen(packet))
 void gdb_putpacket_f(const char *packet, ...);
+void gdb_put_notification(const char *packet, size_t size);
+#define gdb_put_notificationz(packet) gdb_put_notification((packet), strlen(packet))
 
 void gdb_out(const char *buf);
 void gdb_voutf(const char *fmt, va_list);
 void gdb_outf(const char *fmt, ...);
 
 #endif
-
-

src/include/general.h

@@ -21,7 +21,12 @@
 #ifndef __GENERAL_H
 #define __GENERAL_H
 
-#define _GNU_SOURCE
+#if !defined(_GNU_SOURCE)
+# define _GNU_SOURCE
+#endif
+#if !defined(__USE_MINGW_ANSI_STDIO)
+# define __USE_MINGW_ANSI_STDIO 1
+#endif
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -29,18 +34,141 @@
 #include <stdio.h>
 #include <stddef.h>
 #include <inttypes.h>
+#include <sys/types.h>
 
 #include "platform.h"
 #include "platform_support.h"
 
-#ifndef DEBUG
-#include <stdio.h>
-#define DEBUG	printf
+extern uint32_t delay_cnt;
+
+enum BMP_DEBUG {
+	BMP_DEBUG_NONE   =  0,
+	BMP_DEBUG_INFO   =  1,
+	BMP_DEBUG_GDB    =  2,
+	BMP_DEBUG_TARGET =  4,
+	BMP_DEBUG_PROBE =  8,
+	BMP_DEBUG_WIRE   = 0x10,
+	BMP_DEBUG_MAX    = 0x20,
+	BMP_DEBUG_STDOUT = 0x8000,
+};
+
+#define FREQ_FIXED 0xffffffff
+
+#if PC_HOSTED == 0
+/* For BMP debug output on a firmware BMP platform, using
+ * BMP PC-Hosted is the preferred way. Printing DEBUG_WARN
+ * and DEBUG_INFO is kept for comptibiluty.
+ */
+# if !defined(PLATFORM_PRINTF)
+#  define PLATFORM_PRINTF printf
+# endif
+# if defined(ENABLE_DEBUG)
+#  define DEBUG_WARN PLATFORM_PRINTF
+#  define DEBUG_INFO PLATFORM_PRINTF
+# else
+#  define DEBUG_WARN(...) do {} while(0)
+#  define DEBUG_INFO(...) do {} while(0)
+# endif
+# define DEBUG_GDB(...) do {} while(0)
+# define DEBUG_TARGET(...) do {} while(0)
+# define DEBUG_PROBE(...) do {} while(0)
+# define DEBUG_WIRE(...) do {} while(0)
+# define DEBUG_GDB_WIRE(...) do {} while(0)
+#else
+# include <stdarg.h>
+extern int cl_debuglevel;
+
+static inline void DEBUG_WARN(const char *format, ...)
+{
+	va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
+
+static inline void DEBUG_INFO(const char *format, ...)
+{
+	if (~cl_debuglevel & BMP_DEBUG_INFO)
+		return;
+	va_list ap;
+    va_start(ap, format);
+	if (cl_debuglevel & BMP_DEBUG_STDOUT)
+		vfprintf(stdout, format, ap);
+	else
+		vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
+
+static inline void DEBUG_GDB(const char *format, ...)
+{
+	if (~cl_debuglevel & BMP_DEBUG_GDB)
+		return;
+	va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
+
+static inline void DEBUG_GDB_WIRE(const char *format, ...)
+{
+	if ((cl_debuglevel & (BMP_DEBUG_GDB | BMP_DEBUG_WIRE)) !=
+		(BMP_DEBUG_GDB | BMP_DEBUG_WIRE))
+		return;
+	va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
+
+static inline void DEBUG_TARGET(const char *format, ...)
+{
+	if (~cl_debuglevel & BMP_DEBUG_TARGET)
+		return;
+	va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
+
+static inline void DEBUG_PROBE(const char *format, ...)
+{
+	if (~cl_debuglevel & BMP_DEBUG_PROBE)
+		return;
+	va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
+
+static inline void DEBUG_WIRE(const char *format, ...)
+{
+	if (~cl_debuglevel & BMP_DEBUG_WIRE)
+		return;
+	va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+	return;
+}
 #endif
 
 #define ALIGN(x, n) (((x) + (n) - 1) & ~((n) - 1))
 #undef MIN
 #define MIN(x, y)  (((x) < (y)) ? (x) : (y))
+#undef MAX
+#define MAX(x, y)  (((x) > (y)) ? (x) : (y))
+
+#if !defined(SYSTICKHZ)
+# define SYSTICKHZ 100
+#endif
+#define SYSTICKMS (1000 / SYSTICKHZ)
+#define MORSECNT ((SYSTICKHZ / 10) - 1)
 
 #endif
 

src/include/jtagtap.h

@@ -21,13 +21,12 @@
 #ifndef __JTAGTAP_H
 #define __JTAGTAP_H
 
+typedef struct jtag_proc_s {
 /* Note: Signal names are as for the device under test. */
 
-int jtagtap_init(void);
+	void (*jtagtap_reset)(void);
 
-void jtagtap_reset(void);
-
-uint8_t jtagtap_next(const uint8_t TMS, const uint8_t TDI);
+	uint8_t (*jtagtap_next)(const uint8_t TMS, const uint8_t TDI);
 /* tap_next executes one state transision in the JTAG TAP state machine:
  * - Ensure TCK is low
  * - Assert the values of TMS and TDI
@@ -36,30 +35,39 @@ uint8_t jtagtap_next(const uint8_t TMS, const uint8_t TDI);
  * - Release TCK.
  */
 
-void jtagtap_tms_seq(uint32_t MS, int ticks);
-void jtagtap_tdi_tdo_seq(uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks);
-void jtagtap_tdi_seq(const uint8_t final_tms, const uint8_t *DI, int ticks);
+	void (*jtagtap_tms_seq)(uint32_t MS, int ticks);
+	void (*jtagtap_tdi_tdo_seq)
+	(uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks);
 /* Shift out a sequence on MS and DI, capture data to DO.
  * - This is not endian safe: First byte will always be first shifted out.
  * - DO may be NULL to ignore captured data.
  * - DO may be point to the same address as DI.
  */
+	void (*jtagtap_tdi_seq)
+	(const uint8_t final_tms, const uint8_t *DI, int ticks);
+} jtag_proc_t;
+extern jtag_proc_t jtag_proc;
 
 /* generic soft reset: 1, 1, 1, 1, 1, 0 */
 #define jtagtap_soft_reset()	\
-	jtagtap_tms_seq(0x1F, 6)
+	jtag_proc.jtagtap_tms_seq(0x1F, 6)
 
 /* Goto Shift-IR: 1, 1, 0, 0 */
 #define jtagtap_shift_ir()		\
-	jtagtap_tms_seq(0x03, 4)
+	jtag_proc.jtagtap_tms_seq(0x03, 4)
 
 /* Goto Shift-DR: 1, 0, 0 */
 #define jtagtap_shift_dr()		\
-	jtagtap_tms_seq(0x01, 3)
+	jtag_proc.jtagtap_tms_seq(0x01, 3)
 
 /* Goto Run-test/Idle: 1, 1, 0 */
 #define jtagtap_return_idle()	\
-	jtagtap_tms_seq(0x01, 2)
+	jtag_proc.jtagtap_tms_seq(0x01, 2)
 
+# if PC_HOSTED == 1
+int platform_jtagtap_init(void);
+# else
+int jtagtap_init(void);
+# endif
 #endif
 

src/include/platform_support.h

@@ -24,7 +24,9 @@
 #	error "Include 'general.h' instead"
 #endif
 
-#if defined(LIBFTDI)
+#include "target.h"
+
+#if PC_HOSTED == 1
 void platform_init(int argc, char **argv);
 #else
 void platform_init(void);
@@ -35,6 +37,9 @@ void platform_timeout_set(platform_timeout *t, uint32_t ms);
 bool platform_timeout_is_expired(platform_timeout *t);
 void platform_delay(uint32_t ms);
 
+#define POWER_CONFLICT_THRESHOLD	5 /* in 0.1V, so 5 stands for 0.5V */
+extern bool connect_assert_srst;
+uint32_t platform_target_voltage_sense(void);
 const char *platform_target_voltage(void);
 int platform_hwversion(void);
 void platform_srst_set_val(bool assert);
@@ -42,6 +47,8 @@ bool platform_srst_get_val(void);
 bool platform_target_get_power(void);
 void platform_target_set_power(bool power);
 void platform_request_boot(void);
+void platform_max_frequency_set(uint32_t frequency);
+uint32_t platform_max_frequency_get(void);
 
 #endif
 

src/include/rtt.h

@@ -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

src/include/rtt_if.h

@@ -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

src/include/serialno.h

@@ -20,7 +20,7 @@
 #ifndef __SERIALNO_H
 #define __SERIALNO_H
 
-char *serialno_read(char *s);
+char *serial_no_read(char *s);
 
 #endif
 

src/include/target.h

@@ -26,15 +26,22 @@
 #define __TARGET_H
 
 #include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/types.h>
 
 typedef struct target_s target;
 typedef uint32_t target_addr;
 struct target_controller;
 
-int adiv5_swdp_scan(void);
+#if PC_HOSTED == 1
+int platform_adiv5_swdp_scan(uint32_t targetid);
+int platform_jtag_scan(const uint8_t *lrlens);
+#endif
+int adiv5_swdp_scan(uint32_t targetid);
 int jtag_scan(const uint8_t *lrlens);
 
-bool target_foreach(void (*cb)(int i, target *t, void *context), void *context);
+int target_foreach(void (*cb)(int i, target *t, void *context), void *context);
 void target_list_free(void);
 
 /* Attach/detach functions */
@@ -43,9 +50,12 @@ target *target_attach_n(int n, struct target_controller *);
 void target_detach(target *t);
 bool target_attached(target *t);
 const char *target_driver_name(target *t);
+const char *target_core_name(target *t);
+unsigned int target_designer(target *t);
+unsigned int target_idcode(target *t);
 
 /* Memory access functions */
-const char *target_mem_map(target *t);
+bool target_mem_map(target *t, char *buf, size_t len);
 int target_mem_read(target *t, void *dest, target_addr src, size_t len);
 int target_mem_write(target *t, target_addr dest, const void *src, size_t len);
 /* Flash memory access functions */
@@ -58,6 +68,8 @@ size_t target_regs_size(target *t);
 const char *target_tdesc(target *t);
 void target_regs_read(target *t, void *data);
 void target_regs_write(target *t, const void *data);
+ssize_t target_reg_read(target *t, int reg, void *data, size_t max);
+ssize_t target_reg_write(target *t, int reg, const void *data, size_t size);
 
 /* Halt/resume functions */
 enum target_halt_reason {
@@ -74,6 +86,9 @@ void target_reset(target *t);
 void target_halt_request(target *t);
 enum target_halt_reason target_halt_poll(target *t, target_addr *watch);
 void target_halt_resume(target *t, bool step);
+void target_set_cmdline(target *t, char *cmdline);
+void target_set_heapinfo(target *t, target_addr heap_base, target_addr heap_limit,
+	target_addr stack_base, target_addr stack_limit);
 
 /* Break-/watchpoint functions */
 enum target_breakwatch {
@@ -90,11 +105,12 @@ int target_breakwatch_clear(target *t, enum target_breakwatch, target_addr, size
 void target_command_help(target *t);
 int target_command(target *t, int argc, const char *argv[]);
 
-
+/* keep target_errno in sync with errno values in gdb/include/gdb/fileio.h */
 enum target_errno {
 	TARGET_EPERM = 1,
 	TARGET_ENOENT = 2,
 	TARGET_EINTR = 4,
+	TARGET_EIO = 5,
 	TARGET_EBADF = 9,
 	TARGET_EACCES = 13,
 	TARGET_EFAULT = 14,
@@ -104,13 +120,15 @@ enum target_errno {
 	TARGET_ENOTDIR = 20,
 	TARGET_EISDIR = 21,
 	TARGET_EINVAL = 22,
-	TARGET_EMFILE = 24,
 	TARGET_ENFILE = 23,
+	TARGET_EMFILE = 24,
 	TARGET_EFBIG = 27,
 	TARGET_ENOSPC = 28,
 	TARGET_ESPIPE = 29,
 	TARGET_EROFS = 30,
-	TARGET_ENAMETOOLONG = 36,
+	TARGET_ENOSYS = 88,
+	TARGET_ENAMETOOLONG = 91,
+	TARGET_EUNKNOWN = 9999,
 };
 
 enum target_open_flags {

src/include/timing.h

@@ -24,7 +24,7 @@ struct platform_timeout {
 	uint32_t time;
 };
 
+extern int32_t swj_delay_cnt;
 uint32_t platform_time_ms(void);
 
 #endif /* __TIMING_H */
-

src/main.c

@@ -33,7 +33,7 @@
 int
 main(int argc, char **argv)
 {
-#if defined(LIBFTDI)
+#if PC_HOSTED == 1
 	platform_init(argc, argv);
 #else
 	(void) argc;

src/morse.c

@@ -59,8 +59,14 @@ static char morse_repeat;
 
 void morse(const char *msg, char repeat)
 {
+#if PC_HOSTED == 1
+	if (msg)
+		DEBUG_WARN("%s\n", msg);
+	(void) repeat;
+#else
 	morse_msg = morse_ptr = msg;
 	morse_repeat = repeat;
+#endif
 }
 
 bool morse_update(void)

src/platforms/Readme.md

@@ -0,0 +1,23 @@
+# Platforms and platform support files
+
+This directory contains the implementation of platforms and support file
+used by (multiple) platforms.
+
+## Implementation directories
+
+native : Firmware for original Black Magic Probe<br>
+stlink : Firmware for STLINK-V2 and V21<br>
+swlink :  Firmware for STLINK-V1 and Bluepill<br>
+hydrabus :  Firmware https://hydrabus.com/ <br>
+f4discovery    : Firmware for STM32F407DISCO<br>
+launchpad-icdi :<br>
+tm4c: <br>
+hosted: PC-hosted BMP running as PC application talking to firmware BMPs,
+        STLINK-V2/21/3, FTDI MPSSE probes, CMSIS-DAP and JLINK
+
+
+## Support directories
+
+common: libopencm3 based support for firmware BMPs<br>
+stm32:  STM32 specific libopencm3 based support  for firmware BMPs<br>
+pc: Support for PC-hosted BMPs.<br>

src/platforms/common/cdcacm.c

@@ -24,6 +24,18 @@
  * field firmware upgrade.
  *
  * The device's unique id is used as the USB serial number string.
+ *
+ * Endpoint Usage
+ *
+ *     0 Control Endpoint
+ * IN  1 GDB CDC DATA
+ * OUT 1 GDB CDC DATA
+ * IN  2 GDB CDC CTR
+ * IN  3 UART CDC DATA
+ * OUT 3 UART CDC DATA
+ * OUT 4 UART CDC CTRL
+ * In  5 Trace Capture
+ *
  */
 
 #include "general.h"
@@ -34,15 +46,23 @@
 #endif
 #include "usbuart.h"
 #include "serialno.h"
+#include "version.h"
 
 #include <libopencm3/cm3/nvic.h>
 #include <libopencm3/usb/usbd.h>
 #include <libopencm3/usb/cdc.h>
 #include <libopencm3/cm3/scb.h>
 #include <libopencm3/usb/dfu.h>
-#include <stdlib.h>
 
-#define DFU_IF_NO 4
+#define GDB_IF_NO   0
+#define UART_IF_NO  2
+#define DFU_IF_NO   4
+#if defined(PLATFORM_HAS_TRACESWO)
+# define TRACE_IF_NO 5
+# define TOTAL_INTERFACES  6
+#else
+# define TOTAL_INTERFACES  5
+#endif
 
 usbd_device * usbdev;
 
@@ -51,14 +71,18 @@ static int cdcacm_gdb_dtr = 1;
 
 static void cdcacm_set_modem_state(usbd_device *dev, int iface, bool dsr, bool dcd);
 
-static const struct usb_device_descriptor dev = {
+static const struct usb_device_descriptor dev_desc = {
 	.bLength = USB_DT_DEVICE_SIZE,
 	.bDescriptorType = USB_DT_DEVICE,
 	.bcdUSB = 0x0200,
 	.bDeviceClass = 0xEF,		/* Miscellaneous Device */
 	.bDeviceSubClass = 2,		/* Common Class */
 	.bDeviceProtocol = 1,		/* Interface Association */
-	.bMaxPacketSize0 = 64,
+#if defined(SAMD21E17) || defined(LM4F)
+	.bMaxPacketSize0 = 64,		/*Fixed for icdi*/
+#else
+	.bMaxPacketSize0 = 32,
+#endif
 	.idVendor = 0x1D50,
 	.idProduct = 0x6018,
 	.bcdDevice = 0x0100,
@@ -74,7 +98,7 @@ static const struct usb_device_descriptor dev = {
 static const struct usb_endpoint_descriptor gdb_comm_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x82,
+	.bEndpointAddress =  (CDCACM_GDB_ENDPOINT + 1) | USB_REQ_TYPE_IN,
 	.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
 	.wMaxPacketSize = 16,
 	.bInterval = 255,
@@ -83,14 +107,14 @@ static const struct usb_endpoint_descriptor gdb_comm_endp[] = {{
 static const struct usb_endpoint_descriptor gdb_data_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x01,
+	.bEndpointAddress = CDCACM_GDB_ENDPOINT,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
 	.wMaxPacketSize = CDCACM_PACKET_SIZE,
 	.bInterval = 1,
 }, {
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x81,
+	.bEndpointAddress = CDCACM_GDB_ENDPOINT | USB_REQ_TYPE_IN,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
 	.wMaxPacketSize = CDCACM_PACKET_SIZE,
 	.bInterval = 1,
@@ -114,7 +138,7 @@ static const struct {
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
 		.bmCapabilities = 0,
-		.bDataInterface = 1,
+		.bDataInterface = GDB_IF_NO + 1,
 	},
 	.acm = {
 		.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
@@ -126,8 +150,8 @@ static const struct {
 		.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_UNION,
-		.bControlInterface = 0,
-		.bSubordinateInterface0 = 1,
+		.bControlInterface = GDB_IF_NO,
+		.bSubordinateInterface0 = GDB_IF_NO + 1,
 	 }
 };
 
@@ -139,7 +163,7 @@ static const struct usb_interface_descriptor gdb_comm_iface[] = {{
 	.bNumEndpoints = 1,
 	.bInterfaceClass = USB_CLASS_CDC,
 	.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
-	.bInterfaceProtocol = USB_CDC_PROTOCOL_AT,
+	.bInterfaceProtocol = USB_CDC_PROTOCOL_NONE,
 	.iInterface = 4,
 
 	.endpoint = gdb_comm_endp,
@@ -151,7 +175,7 @@ static const struct usb_interface_descriptor gdb_comm_iface[] = {{
 static const struct usb_interface_descriptor gdb_data_iface[] = {{
 	.bLength = USB_DT_INTERFACE_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE,
-	.bInterfaceNumber = 1,
+	.bInterfaceNumber = GDB_IF_NO + 1,
 	.bAlternateSetting = 0,
 	.bNumEndpoints = 2,
 	.bInterfaceClass = USB_CLASS_DATA,
@@ -165,19 +189,19 @@ static const struct usb_interface_descriptor gdb_data_iface[] = {{
 static const struct usb_iface_assoc_descriptor gdb_assoc = {
 	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
-	.bFirstInterface = 0,
+	.bFirstInterface = GDB_IF_NO,
 	.bInterfaceCount = 2,
 	.bFunctionClass = USB_CLASS_CDC,
 	.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
-	.bFunctionProtocol = USB_CDC_PROTOCOL_AT,
-	.iFunction = 0,
+	.bFunctionProtocol = USB_CDC_PROTOCOL_NONE,
+	.iFunction = 4,
 };
 
 /* Serial ACM interface */
 static const struct usb_endpoint_descriptor uart_comm_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x84,
+	.bEndpointAddress = (CDCACM_UART_ENDPOINT + 1) | USB_REQ_TYPE_IN,
 	.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
 	.wMaxPacketSize = 16,
 	.bInterval = 255,
@@ -186,14 +210,14 @@ static const struct usb_endpoint_descriptor uart_comm_endp[] = {{
 static const struct usb_endpoint_descriptor uart_data_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x03,
+	.bEndpointAddress = CDCACM_UART_ENDPOINT,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
-	.wMaxPacketSize = CDCACM_PACKET_SIZE,
+	.wMaxPacketSize = CDCACM_PACKET_SIZE / 2,
 	.bInterval = 1,
 }, {
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x83,
+	.bEndpointAddress = CDCACM_UART_ENDPOINT | USB_REQ_TYPE_IN,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
 	.wMaxPacketSize = CDCACM_PACKET_SIZE,
 	.bInterval = 1,
@@ -217,7 +241,7 @@ static const struct {
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
 		.bmCapabilities = 0,
-		.bDataInterface = 3,
+		.bDataInterface = UART_IF_NO + 1,
 	},
 	.acm = {
 		.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
@@ -229,20 +253,20 @@ static const struct {
 		.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
 		.bDescriptorType = CS_INTERFACE,
 		.bDescriptorSubtype = USB_CDC_TYPE_UNION,
-		.bControlInterface = 2,
-		.bSubordinateInterface0 = 3,
+		.bControlInterface = UART_IF_NO,
+		.bSubordinateInterface0 = UART_IF_NO + 1,
 	 }
 };
 
 static const struct usb_interface_descriptor uart_comm_iface[] = {{
 	.bLength = USB_DT_INTERFACE_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE,
-	.bInterfaceNumber = 2,
+	.bInterfaceNumber = UART_IF_NO,
 	.bAlternateSetting = 0,
 	.bNumEndpoints = 1,
 	.bInterfaceClass = USB_CLASS_CDC,
 	.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
-	.bInterfaceProtocol = USB_CDC_PROTOCOL_AT,
+	.bInterfaceProtocol = USB_CDC_PROTOCOL_NONE,
 	.iInterface = 5,
 
 	.endpoint = uart_comm_endp,
@@ -254,7 +278,7 @@ static const struct usb_interface_descriptor uart_comm_iface[] = {{
 static const struct usb_interface_descriptor uart_data_iface[] = {{
 	.bLength = USB_DT_INTERFACE_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE,
-	.bInterfaceNumber = 3,
+	.bInterfaceNumber = UART_IF_NO + 1,
 	.bAlternateSetting = 0,
 	.bNumEndpoints = 2,
 	.bInterfaceClass = USB_CLASS_DATA,
@@ -268,12 +292,12 @@ static const struct usb_interface_descriptor uart_data_iface[] = {{
 static const struct usb_iface_assoc_descriptor uart_assoc = {
 	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
-	.bFirstInterface = 2,
+	.bFirstInterface = UART_IF_NO,
 	.bInterfaceCount = 2,
 	.bFunctionClass = USB_CLASS_CDC,
 	.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
-	.bFunctionProtocol = USB_CDC_PROTOCOL_AT,
-	.iFunction = 0,
+	.bFunctionProtocol = USB_CDC_PROTOCOL_NONE,
+	.iFunction = 5,
 };
 
 const struct usb_dfu_descriptor dfu_function = {
@@ -303,7 +327,7 @@ const struct usb_interface_descriptor dfu_iface = {
 static const struct usb_iface_assoc_descriptor dfu_assoc = {
 	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
-	.bFirstInterface = 4,
+	.bFirstInterface = DFU_IF_NO,
 	.bInterfaceCount = 1,
 	.bFunctionClass = 0xFE,
 	.bFunctionSubClass = 1,
@@ -315,7 +339,7 @@ static const struct usb_iface_assoc_descriptor dfu_assoc = {
 static const struct usb_endpoint_descriptor trace_endp[] = {{
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
-	.bEndpointAddress = 0x85,
+	.bEndpointAddress = TRACE_ENDPOINT | USB_REQ_TYPE_IN,
 	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
 	.wMaxPacketSize = 64,
 	.bInterval = 0,
@@ -324,7 +348,7 @@ static const struct usb_endpoint_descriptor trace_endp[] = {{
 const struct usb_interface_descriptor trace_iface = {
 	.bLength = USB_DT_INTERFACE_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE,
-	.bInterfaceNumber = 5,
+	.bInterfaceNumber = TRACE_IF_NO,
 	.bAlternateSetting = 0,
 	.bNumEndpoints = 1,
 	.bInterfaceClass = 0xFF,
@@ -338,7 +362,7 @@ const struct usb_interface_descriptor trace_iface = {
 static const struct usb_iface_assoc_descriptor trace_assoc = {
 	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
 	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
-	.bFirstInterface = 5,
+	.bFirstInterface = TRACE_IF_NO,
 	.bInterfaceCount = 1,
 	.bFunctionClass = 0xFF,
 	.bFunctionSubClass = 0xFF,
@@ -377,11 +401,7 @@ static const struct usb_config_descriptor config = {
 	.bLength = USB_DT_CONFIGURATION_SIZE,
 	.bDescriptorType = USB_DT_CONFIGURATION,
 	.wTotalLength = 0,
-#if defined(PLATFORM_HAS_TRACESWO)
-	.bNumInterfaces = 6,
-#else
-	.bNumInterfaces = 5,
-#endif
+	.bNumInterfaces = TOTAL_INTERFACES,
 	.bConfigurationValue = 1,
 	.iConfiguration = 0,
 	.bmAttributes = 0x80,
@@ -389,16 +409,17 @@ static const struct usb_config_descriptor config = {
 
 	.interface = ifaces,
 };
+static char serial_no[DFU_SERIAL_LENGTH];
 
-char serial_no[9];
+#define BOARD_IDENT "Black Magic Probe " PLATFORM_IDENT FIRMWARE_VERSION
 
 static const char *usb_strings[] = {
-	"Black Sphere Technologies",
+	"Black Magic Debug",
 	BOARD_IDENT,
 	serial_no,
 	"Black Magic GDB Server",
 	"Black Magic UART Port",
-	DFU_IDENT,
+	"Black Magic DFU",
 #if defined(PLATFORM_HAS_TRACESWO)
 	"Black Magic Trace Capture",
 #endif
@@ -419,7 +440,7 @@ static void dfu_detach_complete(usbd_device *dev, struct usb_setup_data *req)
 #endif
 }
 
-static int cdcacm_control_request(usbd_device *dev,
+static enum usbd_request_return_codes  cdcacm_control_request(usbd_device *dev,
 		struct usb_setup_data *req, uint8_t **buf, uint16_t *len,
 		void (**complete)(usbd_device *dev, struct usb_setup_data *req))
 {
@@ -432,23 +453,24 @@ static int cdcacm_control_request(usbd_device *dev,
 	case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
 		cdcacm_set_modem_state(dev, req->wIndex, true, true);
 		/* Ignore if not for GDB interface */
-		if(req->wIndex != 0)
-			return 1;
+		if(req->wIndex != GDB_IF_NO)
+			return USBD_REQ_HANDLED;
 
 		cdcacm_gdb_dtr = req->wValue & 1;
 
-		return 1;
+		return USBD_REQ_HANDLED;
 	case USB_CDC_REQ_SET_LINE_CODING:
 		if(*len < sizeof(struct usb_cdc_line_coding))
-			return 0;
+			return USBD_REQ_NOTSUPP;
 
 		switch(req->wIndex) {
-		case 2:
+		case UART_IF_NO:
 			usbuart_set_line_coding((struct usb_cdc_line_coding*)*buf);
-		case 0:
-			return 1; /* Ignore on GDB Port */
+			return USBD_REQ_HANDLED;
+		case GDB_IF_NO:
+			return USBD_REQ_HANDLED; /* Ignore on GDB Port */
 		default:
-			return 0;
+			return USBD_REQ_NOTSUPP;
 		}
 	case DFU_GETSTATUS:
 		if(req->wIndex == DFU_IF_NO) {
@@ -460,16 +482,17 @@ static int cdcacm_control_request(usbd_device *dev,
 			(*buf)[5] = 0;	/* iString not used here */
 			*len = 6;
 
-			return 1;
+			return USBD_REQ_HANDLED;
 		}
+		return USBD_REQ_NOTSUPP;
 	case DFU_DETACH:
 		if(req->wIndex == DFU_IF_NO) {
 			*complete = dfu_detach_complete;
-			return 1;
+			return USBD_REQ_HANDLED;
 		}
-		return 0;
+		return USBD_REQ_NOTSUPP;
 	}
-	return 0;
+	return USBD_REQ_NOTSUPP;
 }
 
 int cdcacm_get_config(void)
@@ -494,6 +517,7 @@ static void cdcacm_set_modem_state(usbd_device *dev, int iface, bool dsr, bool d
 	notif->wLength = 2;
 	buf[8] = (dsr ? 2 : 0) | (dcd ? 1 : 0);
 	buf[9] = 0;
+	/* FIXME: Remove magic numbers */
 	usbd_ep_write_packet(dev, 0x82 + iface, buf, 10);
 }
 
@@ -503,26 +527,29 @@ static void cdcacm_set_config(usbd_device *dev, uint16_t wValue)
 
 	/* GDB interface */
 #if defined(STM32F4) || defined(LM4F) || defined(SAMD)
-	usbd_ep_setup(dev, 0x01, USB_ENDPOINT_ATTR_BULK,
+	usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT, USB_ENDPOINT_ATTR_BULK,
 	              CDCACM_PACKET_SIZE, gdb_usb_out_cb);
 #else
-	usbd_ep_setup(dev, 0x01, USB_ENDPOINT_ATTR_BULK,
+	usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT, USB_ENDPOINT_ATTR_BULK,
 	              CDCACM_PACKET_SIZE, NULL);
 #endif
-	usbd_ep_setup(dev, 0x81, USB_ENDPOINT_ATTR_BULK,
-	              CDCACM_PACKET_SIZE, NULL);
-	usbd_ep_setup(dev, 0x82, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
+	usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT | USB_REQ_TYPE_IN,
+				  USB_ENDPOINT_ATTR_BULK, CDCACM_PACKET_SIZE, NULL);
+	usbd_ep_setup(dev, (CDCACM_GDB_ENDPOINT + 1) | USB_REQ_TYPE_IN,
+				  USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
 
 	/* Serial interface */
-	usbd_ep_setup(dev, 0x03, USB_ENDPOINT_ATTR_BULK,
-	              CDCACM_PACKET_SIZE, usbuart_usb_out_cb);
-	usbd_ep_setup(dev, 0x83, USB_ENDPOINT_ATTR_BULK,
+	usbd_ep_setup(dev, CDCACM_UART_ENDPOINT, USB_ENDPOINT_ATTR_BULK,
+	              CDCACM_PACKET_SIZE / 2, usbuart_usb_out_cb);
+	usbd_ep_setup(dev, CDCACM_UART_ENDPOINT | USB_REQ_TYPE_IN,
+				  USB_ENDPOINT_ATTR_BULK,
 	              CDCACM_PACKET_SIZE, usbuart_usb_in_cb);
-	usbd_ep_setup(dev, 0x84, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
+	usbd_ep_setup(dev, (CDCACM_UART_ENDPOINT + 1) | USB_REQ_TYPE_IN,
+				  USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
 
 #if defined(PLATFORM_HAS_TRACESWO)
 	/* Trace interface */
-	usbd_ep_setup(dev, 0x85, USB_ENDPOINT_ATTR_BULK,
+	usbd_ep_setup(dev, TRACE_ENDPOINT | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_BULK,
 					64, trace_buf_drain);
 #endif
 
@@ -534,8 +561,8 @@ static void cdcacm_set_config(usbd_device *dev, uint16_t wValue)
 	/* Notify the host that DCD is asserted.
 	 * Allows the use of /dev/tty* devices on *BSD/MacOS
 	 */
-	cdcacm_set_modem_state(dev, 0, true, true);
-	cdcacm_set_modem_state(dev, 2, true, true);
+	cdcacm_set_modem_state(dev, GDB_IF_NO, true, true);
+	cdcacm_set_modem_state(dev, UART_IF_NO, true, true);
 }
 
 /* We need a special large control buffer for this device: */
@@ -545,9 +572,9 @@ void cdcacm_init(void)
 {
 	void exti15_10_isr(void);
 
-	serialno_read(serial_no);
+	serial_no_read(serial_no);
 
-	usbdev = usbd_init(&USB_DRIVER, &dev, &config, usb_strings,
+	usbdev = usbd_init(&USB_DRIVER, &dev_desc, &config, usb_strings,
 			    sizeof(usb_strings)/sizeof(char *),
 			    usbd_control_buffer, sizeof(usbd_control_buffer));
 
@@ -562,4 +589,3 @@ void USB_ISR(void)
 {
 	usbd_poll(usbdev);
 }
-

src/platforms/common/cdcacm.h

@@ -34,6 +34,7 @@
 
 #define CDCACM_GDB_ENDPOINT	1
 #define CDCACM_UART_ENDPOINT	3
+#define TRACE_ENDPOINT			5
 
 extern usbd_device *usbdev;
 

src/platforms/common/jtagtap.c

@@ -0,0 +1,199 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* This file implements the low-level JTAG TAP interface.  */
+
+#include <stdio.h>
+
+#include "general.h"
+#include "jtagtap.h"
+#include "gdb_packet.h"
+
+jtag_proc_t jtag_proc;
+
+static void jtagtap_reset(void);
+static void jtagtap_tms_seq(uint32_t MS, int ticks);
+static void jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks);
+static void jtagtap_tdi_seq(
+	const uint8_t final_tms, const uint8_t *DI, int ticks);
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI);
+
+int jtagtap_init()
+{
+	TMS_SET_MODE();
+
+	jtag_proc.jtagtap_reset = jtagtap_reset;
+	jtag_proc.jtagtap_next =jtagtap_next;
+	jtag_proc.jtagtap_tms_seq = jtagtap_tms_seq;
+	jtag_proc.jtagtap_tdi_tdo_seq = jtagtap_tdi_tdo_seq;
+	jtag_proc.jtagtap_tdi_seq = jtagtap_tdi_seq;
+
+	/* Go to JTAG mode for SWJ-DP */
+	for(int i = 0; i <= 50; i++) jtagtap_next(1, 0); /* Reset SW-DP */
+	jtagtap_tms_seq(0xE73C, 16);		/* SWD to JTAG sequence */
+	jtagtap_soft_reset();
+
+	return 0;
+}
+
+static void jtagtap_reset(void)
+{
+#ifdef TRST_PORT
+	if (platform_hwversion() == 0) {
+		volatile int i;
+		gpio_clear(TRST_PORT, TRST_PIN);
+		for(i = 0; i < 10000; i++) asm("nop");
+		gpio_set(TRST_PORT, TRST_PIN);
+	}
+#endif
+	jtagtap_soft_reset();
+}
+
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI)
+{
+	uint16_t ret;
+	register volatile int32_t cnt;
+
+	gpio_set_val(TMS_PORT, TMS_PIN, dTMS);
+	gpio_set_val(TDI_PORT, TDI_PIN, dTDI);
+	gpio_set(TCK_PORT, TCK_PIN);
+	for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+	ret = gpio_get(TDO_PORT, TDO_PIN);
+	gpio_clear(TCK_PORT, TCK_PIN);
+	for(cnt = swd_delay_cnt - 2; cnt > 0; cnt--);
+
+	//DEBUG("jtagtap_next(TMS = %d, TDI = %d) = %d\n", dTMS, dTDI, ret);
+
+	return ret != 0;
+}
+
+static void jtagtap_tms_seq(uint32_t MS, int ticks)
+{
+	gpio_set_val(TDI_PORT, TDI_PIN, 1);
+	int data = MS & 1;
+	register volatile int32_t cnt;
+	if (swd_delay_cnt) {
+		while(ticks) {
+			gpio_set_val(TMS_PORT, TMS_PIN, data);
+			gpio_set(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+			MS >>= 1;
+			data = MS & 1;
+			ticks--;
+			gpio_clear(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+		}
+	} else {
+		while(ticks) {
+			gpio_set_val(TMS_PORT, TMS_PIN, data);
+			gpio_set(TCK_PORT, TCK_PIN);
+			MS >>= 1;
+			data = MS & 1;
+			ticks--;
+			gpio_clear(TCK_PORT, TCK_PIN);
+		}
+	}
+}
+
+static void jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks)
+{
+	uint8_t index = 1;
+	gpio_set_val(TMS_PORT, TMS_PIN, 0);
+	uint8_t res = 0;
+	register volatile int32_t cnt;
+	if (swd_delay_cnt) {
+		while(ticks > 1) {
+			gpio_set_val(TDI_PORT, TDI_PIN, *DI & index);
+			gpio_set(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+			if (gpio_get(TDO_PORT, TDO_PIN)) {
+				res |= index;
+			}
+			if(!(index <<= 1)) {
+				*DO = res;
+				res = 0;
+				index = 1;
+				DI++; DO++;
+			}
+			ticks--;
+			gpio_clear(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+		}
+	} else {
+		while(ticks > 1) {
+			gpio_set_val(TDI_PORT, TDI_PIN, *DI & index);
+			gpio_set(TCK_PORT, TCK_PIN);
+			if (gpio_get(TDO_PORT, TDO_PIN)) {
+				res |= index;
+			}
+			if(!(index <<= 1)) {
+				*DO = res;
+				res = 0;
+				index = 1;
+				DI++; DO++;
+			}
+			ticks--;
+			gpio_clear(TCK_PORT, TCK_PIN);
+		}
+	}
+	gpio_set_val(TMS_PORT, TMS_PIN, final_tms);
+	gpio_set_val(TDI_PORT, TDI_PIN, *DI & index);
+	gpio_set(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+	if (gpio_get(TDO_PORT, TDO_PIN)) {
+		res |= index;
+	}
+	*DO = res;
+	gpio_clear(TCK_PORT, TCK_PIN);
+	for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+}
+
+static void jtagtap_tdi_seq(const uint8_t final_tms, const uint8_t *DI, int ticks)
+{
+	uint8_t index = 1;
+	register volatile int32_t cnt;
+	if (swd_delay_cnt) {
+		while(ticks--) {
+			gpio_set_val(TMS_PORT, TMS_PIN, ticks? 0 : final_tms);
+			gpio_set_val(TDI_PORT, TDI_PIN, *DI & index);
+			gpio_set(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+			if(!(index <<= 1)) {
+				index = 1;
+				DI++;
+			}
+			gpio_clear(TCK_PORT, TCK_PIN);
+			for(cnt = swd_delay_cnt -2 ; cnt > 0; cnt--);
+		}
+	} else {
+		while(ticks--) {
+			gpio_set_val(TMS_PORT, TMS_PIN, ticks? 0 : final_tms);
+			gpio_set_val(TDI_PORT, TDI_PIN, *DI & index);
+			gpio_set(TCK_PORT, TCK_PIN);
+			if(!(index <<= 1)) {
+				index = 1;
+				DI++;
+			}
+			gpio_clear(TCK_PORT, TCK_PIN);
+		}
+	}
+}

src/platforms/common/swdptap.c

@@ -18,9 +18,198 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* This file implements the low-level SW-DP interface. */
+/* This file implements the SW-DP interface. */
 
 #include "general.h"
-#include "swdptap.h"
+#include "timing.h"
+#include "adiv5.h"
 
-/* Optimized this by moving directly inline */
+enum {
+	SWDIO_STATUS_FLOAT = 0,
+	SWDIO_STATUS_DRIVE
+};
+static void swdptap_turnaround(int dir) __attribute__ ((optimize(3)));
+static uint32_t swdptap_seq_in(int ticks) __attribute__ ((optimize(3)));
+static bool swdptap_seq_in_parity(uint32_t *ret, int ticks)
+	__attribute__ ((optimize(3)));
+static void swdptap_seq_out(uint32_t MS, int ticks)
+	__attribute__ ((optimize(3)));
+static void swdptap_seq_out_parity(uint32_t MS, int ticks)
+	__attribute__ ((optimize(3)));
+
+static void swdptap_turnaround(int dir)
+{
+	static int olddir = SWDIO_STATUS_FLOAT;
+	register volatile int32_t cnt;
+
+	/* Don't turnaround if direction not changing */
+	if(dir == olddir) return;
+	olddir = dir;
+
+#ifdef DEBUG_SWD_BITS
+	DEBUG("%s", dir ? "\n-> ":"\n<- ");
+#endif
+
+	if(dir == SWDIO_STATUS_FLOAT)
+		SWDIO_MODE_FLOAT();
+	gpio_set(SWCLK_PORT, SWCLK_PIN);
+	for(cnt = swd_delay_cnt; --cnt > 0;);
+	gpio_clear(SWCLK_PORT, SWCLK_PIN);
+	for(cnt = swd_delay_cnt; --cnt > 0;);
+	if(dir == SWDIO_STATUS_DRIVE)
+		SWDIO_MODE_DRIVE();
+}
+
+static uint32_t swdptap_seq_in(int ticks)
+{
+	uint32_t index = 1;
+	uint32_t ret = 0;
+	int len = ticks;
+	register volatile int32_t cnt;
+
+	swdptap_turnaround(SWDIO_STATUS_FLOAT);
+	if (swd_delay_cnt) {
+		while (len--) {
+			int res;
+			res = gpio_get(SWDIO_PORT, SWDIO_PIN);
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+			ret |= (res) ? index : 0;
+			index <<= 1;
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+		}
+	} else {
+		volatile int res;
+		while (len--) {
+			res = gpio_get(SWDIO_PORT, SWDIO_PIN);
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			ret |= (res) ? index : 0;
+			index <<= 1;
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+		}
+	}
+#ifdef DEBUG_SWD_BITS
+	for (int i = 0; i < len; i++)
+		DEBUG("%d", (ret & (1 << i)) ? 1 : 0);
+#endif
+	return ret;
+}
+
+static bool swdptap_seq_in_parity(uint32_t *ret, int ticks)
+{
+	uint32_t index = 1;
+	uint32_t res = 0;
+	bool bit;
+	int len = ticks;
+	register volatile int32_t cnt;
+
+	swdptap_turnaround(SWDIO_STATUS_FLOAT);
+	if (swd_delay_cnt) {
+		while (len--) {
+			bit = gpio_get(SWDIO_PORT, SWDIO_PIN);
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+			res |= (bit) ? index : 0;
+			index <<= 1;
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+		}
+	} else {
+		while (len--) {
+			bit = gpio_get(SWDIO_PORT, SWDIO_PIN);
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			res |= (bit) ? index : 0;
+			index <<= 1;
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+		}
+	}
+	int parity = __builtin_popcount(res);
+	bit = gpio_get(SWDIO_PORT, SWDIO_PIN);
+	gpio_set(SWCLK_PORT, SWCLK_PIN);
+	for(cnt = swd_delay_cnt; --cnt > 0;);
+	parity += (bit) ? 1 : 0;
+	gpio_clear(SWCLK_PORT, SWCLK_PIN);
+	for(cnt = swd_delay_cnt; --cnt > 0;);
+#ifdef DEBUG_SWD_BITS
+	for (int i = 0; i < len; i++)
+		DEBUG("%d", (res & (1 << i)) ? 1 : 0);
+#endif
+	*ret = res;
+	/* Terminate the read cycle now */
+	swdptap_turnaround(SWDIO_STATUS_DRIVE);
+	return (parity & 1);
+}
+
+static void swdptap_seq_out(uint32_t MS, int ticks)
+{
+#ifdef DEBUG_SWD_BITS
+	for (int i = 0; i < ticks; i++)
+		DEBUG("%d", (MS & (1 << i)) ? 1 : 0);
+#endif
+	register volatile int32_t cnt;
+	swdptap_turnaround(SWDIO_STATUS_DRIVE);
+	gpio_set_val(SWDIO_PORT, SWDIO_PIN, MS & 1);
+	if (swd_delay_cnt) {
+		while (ticks--) {
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+			MS >>= 1;
+			gpio_set_val(SWDIO_PORT, SWDIO_PIN, MS & 1);
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+		}
+	} else {
+		while (ticks--) {
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			MS >>= 1;
+			gpio_set_val(SWDIO_PORT, SWDIO_PIN, MS & 1);
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+		}
+	}
+}
+
+static void swdptap_seq_out_parity(uint32_t MS, int ticks)
+{
+	int parity = __builtin_popcount(MS);
+#ifdef DEBUG_SWD_BITS
+	for (int i = 0; i < ticks; i++)
+		DEBUG("%d", (MS & (1 << i)) ? 1 : 0);
+#endif
+	register volatile int32_t cnt;
+	swdptap_turnaround(SWDIO_STATUS_DRIVE);
+	gpio_set_val(SWDIO_PORT, SWDIO_PIN, MS & 1);
+	MS >>= 1;
+	if (swd_delay_cnt) {
+		while (ticks--) {
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+			gpio_set_val(SWDIO_PORT, SWDIO_PIN, MS & 1);
+			MS >>= 1;
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+			for(cnt = swd_delay_cnt; --cnt > 0;);
+		}
+	} else {
+		while (ticks--) {
+			gpio_set(SWCLK_PORT, SWCLK_PIN);
+			gpio_set_val(SWDIO_PORT, SWDIO_PIN, MS & 1);
+			MS >>= 1;
+			gpio_clear(SWCLK_PORT, SWCLK_PIN);
+		}
+	}
+	gpio_set_val(SWDIO_PORT, SWDIO_PIN, parity & 1);
+	gpio_set(SWCLK_PORT, SWCLK_PIN);
+	for(cnt = swd_delay_cnt; --cnt > 0;);
+	gpio_clear(SWCLK_PORT, SWCLK_PIN);
+	for(cnt = swd_delay_cnt; --cnt > 0;);
+}
+
+int swdptap_init(ADIv5_DP_t *dp)
+{
+	dp->seq_in  = swdptap_seq_in;
+	dp->seq_in_parity  = swdptap_seq_in_parity;
+	dp->seq_out = swdptap_seq_out;
+	dp->seq_out_parity  = swdptap_seq_out_parity;
+
+	return 0;
+}

src/platforms/common/traceswo.h

@@ -22,7 +22,21 @@
 
 #include <libopencm3/usb/usbd.h>
 
-void traceswo_init(void);
+#if defined TRACESWO_PROTOCOL && TRACESWO_PROTOCOL == 2
+/* Default line rate, used as default for a request without baudrate */
+#define SWO_DEFAULT_BAUD (2250000)
+void traceswo_init(uint32_t baudrate, uint32_t swo_chan_bitmask);
+#else
+void traceswo_init(uint32_t swo_chan_bitmask);
+#endif
+
 void trace_buf_drain(usbd_device *dev, uint8_t ep);
 
+/* set bitmask of swo channels to be decoded */
+void traceswo_setmask(uint32_t mask);
+
+/* print decoded swo packet on usb serial */
+uint16_t traceswo_decode(usbd_device *usbd_dev, uint8_t addr,
+				const void *buf, uint16_t len);
+
 #endif

src/platforms/f4discovery/Makefile.inc

@@ -1,28 +1,57 @@
 CROSS_COMPILE ?= arm-none-eabi-
+BMP_BOOTLOADER ?=
 CC = $(CROSS_COMPILE)gcc
 OBJCOPY = $(CROSS_COMPILE)objcopy
 
 CFLAGS += -Istm32/include -mcpu=cortex-m4 -mthumb \
 	-mfloat-abi=hard -mfpu=fpv4-sp-d16 \
-	-DSTM32F4 -DF4DISCOVERY -I../libopencm3/include \
+	-DSTM32F4 -I../libopencm3/include \
 	-Iplatforms/stm32
 
-LDFLAGS = -lopencm3_stm32f4 -Wl,--defsym,_stack=0x20006000 \
-	-Wl,-T,platforms/stm32/f4discovery.ld -nostartfiles -lc -lnosys \
+ifeq ($(BLACKPILL), 1)
+LINKER_SCRIPT=platforms/stm32/blackpillv2.ld
+CFLAGS += -DBLACKPILL=1
+else
+LINKER_SCRIPT=platforms/stm32/f4discovery.ld
+endif
+
+LDFLAGS_BOOT = -lopencm3_stm32f4 \
+	-Wl,-T,$(LINKER_SCRIPT) -nostartfiles -lc -lnosys \
 	-Wl,-Map=mapfile -mthumb -mcpu=cortex-m4 -Wl,-gc-sections \
 	-mfloat-abi=hard -mfpu=fpv4-sp-d16 \
 	-L../libopencm3/lib
 
+ifeq ($(BMP_BOOTLOADER), 1)
+$(info  Load address 0x08004000 for BMPBootloader)
+LDFLAGS = $(LDFLAGS_BOOT) -Wl,-Ttext=0x8004000
+CFLAGS += -DDFU_SERIAL_LENGTH=9
+else
+LDFLAGS += $(LDFLAGS_BOOT)
+CFLAGS += -DDFU_SERIAL_LENGTH=13
+endif
+
 VPATH += platforms/stm32
 
 SRC += 	cdcacm.c	\
+	traceswodecode.c	\
 	traceswo.c	\
 	usbuart.c	\
 	serialno.c	\
 	timing.c	\
 	timing_stm32.c	\
 
+ifneq ($(BMP_BOOTLOADER), 1)
 all:	blackmagic.bin
+else
+all:	blackmagic.bin  blackmagic_dfu.bin blackmagic_dfu.hex
+blackmagic_dfu: usbdfu.o dfucore.o dfu_f4.o serialno.o
+	$(CC) $^ -o $@ $(LDFLAGS_BOOT)
 
+blackmagic_dfu.bin:    blackmagic_dfu
+	$(OBJCOPY) -O binary $^ $@
+
+blackmagic_dfu.hex:    blackmagic_dfu
+	$(OBJCOPY) -O ihex $^ $@
+endif
 host_clean:
 	-$(Q)$(RM) blackmagic.bin

src/platforms/f4discovery/Readme

@@ -1,28 +0,0 @@
-System vs BMP Bootloader
-========================
-For the BMP bootloader, flashing qas not reliable. So we use the system
-bootloder unconditional.
-
-Connections:
-====================
-
-PA0: User button to force system bootloader entry with reset
-PA2/PA3 eventual connected to the STLINK/ STM32F103C8
-
-PC2: TDI
-PC4: TMS/SWDIO
-PC5: TCK/SWCLK
-PC6: TDO/TRACESWO
-
-PC1: TRST
-PC8: SRST
-
-Blue Led: Indicator that system bootloader is entered via BMP
-
-Bootstrapping the F4Discovery on-board ST-Link
-==============================================
-http://embdev.net/articles/STM_Discovery_as_Black_Magic_Probe has some hints
-how to modify the F4Discovery on-board ST-Link.  If you try to do so and hit
-a problem that stands some test like that you load the right firmware to the
-right device via the right BMP probe, explain, report and ask on the
-blackmagic mailing list http://sourceforge.net/mail/?group_id=407419.

src/platforms/f4discovery/Readme.md

@@ -0,0 +1,65 @@
+# Firmware BMP for STM32F407 DISCO boards
+
+Kept for historical reasons to load BMP bootloader to the STM32F103 of the onboard STLINK or external STLINKs. As stlink-tool now allows to load BMP firmware via the original STLINK bootloader is no longer really needed.
+
+## Connections:
+
+PC2: TDI<br>
+PC4: TMS/SWDIO<br>
+PC5: TCK/SWCLK<br>
+PC6: TDO/TRACESWO<br>
+
+PC1: TRST<br>
+PC8: SRST<br>
+
+# Alternate build for stm32f401 stm32f411 MiniF4 aka BlackPillV2 boards.
+
+https://github.com/WeActTC/MiniSTM32F4x1
+
+## Connections:
+
+* JTAG/SWD
+   * PA1: TDI
+   * PA13: TMS/SWDIO
+   * PA14: TCK/SWCLK
+   * PB3: TDO/TRACESWO
+   * PB5: TRST
+   * PB4: SRST
+
+* USB USART
+   * PB6: USART1 TX (usbuart_xxx)
+   * PB7: USART1 RX (usbuart_xxx)
+
+* +3V3.
+   * PB8 - turn on IRLML5103 transistor
+
+How to Build
+========================================
+```
+cd blackmagic
+make clean
+make PROBE_HOST=f4discovery BLACKPILL=1
+```
+
+How to Flash with dfu
+========================================
+* After build:
+ * 1) `apt install dfu-util`
+ * 2) Force the F4 into system bootloader mode by jumpering "BOOT0" to "3V3" and "PB2/BOOT1" to "GND" and reset (RESET button). System bootloader should appear.
+ * 3) `dfu-util -a 0 --dfuse-address 0x08000000 -D blackmagic.bin`
+
+To exit from dfu mode press a "key" and "reset", release reset. BMP firmware should appear
+
+
+10 pin male from pins
+========================================
+
+| PB3/TDO  | PB7/RX      | PB6/TX     | X          | PA1/TDI |
+| -------- | ----------- | ---------- | ---------- | ------- |
+| PB4/SRST | +3V3/PB8 SW | PA13/SWDIO | PA14/SWCLK | GND     |
+
+SWJ frequency setting
+====================================
+https://github.com/blackmagic-debug/blackmagic/pull/783#issue-529197718
+
+`mon freq 900k` helps at most

src/platforms/f4discovery/platform.c

@@ -27,54 +27,108 @@
 #include "usbuart.h"
 #include "morse.h"
 
-#include <libopencm3/stm32/f4/rcc.h>
+#include <libopencm3/stm32/rcc.h>
 #include <libopencm3/cm3/scb.h>
 #include <libopencm3/cm3/nvic.h>
 #include <libopencm3/stm32/exti.h>
 #include <libopencm3/stm32/usart.h>
 #include <libopencm3/stm32/syscfg.h>
 #include <libopencm3/usb/usbd.h>
+#include <libopencm3/cm3/systick.h>
+#include <libopencm3/cm3/cortex.h>
+
+#ifdef BLACKPILL
+#include <libopencm3/usb/dwc/otg_fs.h>
+#endif
+
 
 jmp_buf fatal_error_jmpbuf;
+extern char _ebss[];
 
 void platform_init(void)
 {
+	volatile uint32_t *magic = (uint32_t *)_ebss;
+	/* Enable GPIO peripherals */
+	rcc_periph_clock_enable(RCC_GPIOA);
+	rcc_periph_clock_enable(RCC_GPIOC);
+#ifdef BLACKPILL
+	rcc_periph_clock_enable(RCC_GPIOB);
+#else
+	rcc_periph_clock_enable(RCC_GPIOD);
+#endif
 	/* Check the USER button*/
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
-	if(gpio_get(GPIOA, GPIO0)) {
-		platform_request_boot();
+	if (gpio_get(GPIOA, GPIO0) ||
+		((magic[0] == BOOTMAGIC0) && (magic[1] == BOOTMAGIC1)))
+	{
+		magic[0] = 0;
+		magic[1] = 0;
+		/* Assert blue LED as indicator we are in the bootloader */
+		gpio_mode_setup(LED_PORT, GPIO_MODE_OUTPUT,
+						GPIO_PUPD_NONE, LED_BOOTLOADER);
+		gpio_set(LED_PORT, LED_BOOTLOADER);
+		/* Jump to the built in bootloader by mapping System flash.
+		   As we just come out of reset, no other deinit is needed!*/
+		rcc_periph_clock_enable(RCC_SYSCFG);
+		SYSCFG_MEMRM &= ~3;
+		SYSCFG_MEMRM |= 1;
 		scb_reset_core();
 	}
-
-	rcc_clock_setup_hse_3v3(&hse_8mhz_3v3[CLOCK_3V3_48MHZ]);
+#ifdef BLACKPILL
+	rcc_clock_setup_pll(&rcc_hse_25mhz_3v3[RCC_CLOCK_3V3_84MHZ]);
+#else
+	rcc_clock_setup_pll(&rcc_hse_8mhz_3v3[RCC_CLOCK_3V3_168MHZ]);
+#endif
 
 	/* Enable peripherals */
-	rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPCEN);
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPDEN);
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_CRCEN);
+	rcc_periph_clock_enable(RCC_OTGFS);
+	rcc_periph_clock_enable(RCC_CRC);
 
 	/* Set up USB Pins and alternate function*/
-	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11 | GPIO12);
-	gpio_set_af(GPIOA, GPIO_AF10, GPIO11 | GPIO12);
+	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9 | GPIO11 | GPIO12);
+	gpio_set_af(GPIOA, GPIO_AF10, GPIO9 | GPIO10 | GPIO11 | GPIO12);
 
-	GPIOC_OSPEEDR &=~0xF30;
+#ifdef BLACKPILL
+	GPIOA_OSPEEDR &= 0x3C00000C;
+	GPIOA_OSPEEDR |= 0x28000008;
+#else
+	GPIOC_OSPEEDR &= ~0xF30;
 	GPIOC_OSPEEDR |= 0xA20;
-	gpio_mode_setup(JTAG_PORT, GPIO_MODE_OUTPUT,
-			GPIO_PUPD_NONE,
-			TMS_PIN | TCK_PIN | TDI_PIN);
+#endif
 
+	gpio_mode_setup(JTAG_PORT, GPIO_MODE_OUTPUT,
+					GPIO_PUPD_NONE,
+					TCK_PIN | TDI_PIN);
+	gpio_mode_setup(JTAG_PORT, GPIO_MODE_INPUT,
+					GPIO_PUPD_NONE, TMS_PIN);
+	gpio_set_output_options(JTAG_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ,
+							TCK_PIN | TDI_PIN | TMS_PIN);
 	gpio_mode_setup(TDO_PORT, GPIO_MODE_INPUT,
-			GPIO_PUPD_NONE,
-			TDO_PIN);
+					GPIO_PUPD_NONE,
+					TDO_PIN);
+	gpio_set_output_options(TDO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ,
+							TDO_PIN | TMS_PIN);
 
 	gpio_mode_setup(LED_PORT, GPIO_MODE_OUTPUT,
-			GPIO_PUPD_NONE,
-			LED_UART | LED_IDLE_RUN | LED_ERROR | LED_BOOTLOADER);
+					GPIO_PUPD_NONE,
+					LED_IDLE_RUN | LED_ERROR | LED_BOOTLOADER);
+
+	gpio_mode_setup(LED_PORT_UART, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_UART);
+
+#ifdef PLATFORM_HAS_POWER_SWITCH
+	gpio_set(PWR_BR_PORT, PWR_BR_PIN);
+	gpio_mode_setup(PWR_BR_PORT, GPIO_MODE_OUTPUT,
+					GPIO_PUPD_NONE,
+					PWR_BR_PIN);
+#endif
 
 	platform_timing_init();
 	usbuart_init();
 	cdcacm_init();
+#ifdef BLACKPILL
+	// https://github.com/libopencm3/libopencm3/pull/1256#issuecomment-779424001
+	OTG_FS_GCCFG |= OTG_GCCFG_NOVBUSSENS | OTG_GCCFG_PWRDWN;
+	OTG_FS_GCCFG &= ~(OTG_GCCFG_VBUSBSEN | OTG_GCCFG_VBUSASEN);
+#endif
 }
 
 void platform_srst_set_val(bool assert) { (void)assert; }
@@ -82,23 +136,25 @@ bool platform_srst_get_val(void) { return false; }
 
 const char *platform_target_voltage(void)
 {
-	return "ABSENT!";
+	return NULL;
 }
 
 void platform_request_boot(void)
 {
-	/* Disconnect USB cable */
-	usbd_disconnect(usbdev, 1);
-	nvic_disable_irq(USB_IRQ);
-
-	/* Assert blue LED as indicator we are in the bootloader */
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPDEN);
-	gpio_mode_setup(LED_PORT, GPIO_MODE_OUTPUT,
-		GPIO_PUPD_NONE, LED_BOOTLOADER);
-	gpio_set(LED_PORT, LED_BOOTLOADER);
-
-	/* Jump to the built in bootloader by mapping System flash */
-	rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_SYSCFGEN);
-	SYSCFG_MEMRM &= ~3;
-	SYSCFG_MEMRM |=  1;
+	uint32_t *magic = (uint32_t *)&_ebss;
+	magic[0] = BOOTMAGIC0;
+	magic[1] = BOOTMAGIC1;
+	scb_reset_system();
 }
+
+#ifdef PLATFORM_HAS_POWER_SWITCH
+bool platform_target_get_power(void)
+{
+	return !gpio_get(PWR_BR_PORT, PWR_BR_PIN);
+}
+
+void platform_target_set_power(bool power)
+{
+	gpio_set_val(PWR_BR_PORT, PWR_BR_PIN, !power);
+}
+#endif

src/platforms/f4discovery/platform.h

@@ -27,15 +27,80 @@
 #include "gpio.h"
 #include "timing.h"
 #include "timing_stm32.h"
-#include "version.h"
 
 #include <setjmp.h>
 
 #define PLATFORM_HAS_TRACESWO
-#define BOARD_IDENT       "Black Magic Probe (F4Discovery), (Firmware " FIRMWARE_VERSION ")"
-#define BOARD_IDENT_DFU   "Black Magic (Upgrade) for F4Discovery, (Firmware " FIRMWARE_VERSION ")"
-#define DFU_IDENT         "Black Magic Firmware Upgrade (F4Discovery"
-#define DFU_IFACE_STRING  "@Internal Flash   /0x08000000/1*016Ka,3*016Kg,1*064Kg,7*128Kg"
+#ifdef BLACKPILL
+#define PLATFORM_IDENT "(F4Discovery/BlackPillV2) "
+/* Important pin mappings for STM32 implementation:
+        * JTAG/SWD
+                * PA1: TDI<br>
+                * PA13: TMS/SWDIO<br>
+                * PA14: TCK/SWCLK<br>
+                * PB3: TDO/TRACESWO<br>
+                * PB5: TRST<br>
+                * PB4: SRST<br>
+        * USB USART
+                * PB6: USART1 TX
+                * PB7: USART1 RX
+        * +3V3
+                * PB8 - turn on IRLML5103 transistor
+        * Force DFU mode button: PA0
+ */
+
+/* Hardware definitions... */
+#define JTAG_PORT GPIOA
+#define TDI_PORT JTAG_PORT
+#define TMS_PORT JTAG_PORT
+#define TCK_PORT JTAG_PORT
+#define TDO_PORT GPIOB
+#define TDI_PIN GPIO1
+#define TMS_PIN GPIO13
+#define TCK_PIN GPIO14
+#define TDO_PIN GPIO3
+
+#define SWDIO_PORT JTAG_PORT
+#define SWCLK_PORT JTAG_PORT
+#define SWDIO_PIN TMS_PIN
+#define SWCLK_PIN TCK_PIN
+
+#define TRST_PORT GPIOB
+#define TRST_PIN GPIO5
+#define SRST_PORT GPIOB
+#define SRST_PIN GPIO4
+
+#define PWR_BR_PORT GPIOB
+#define PWR_BR_PIN GPIO8
+
+#define LED_PORT GPIOC
+#define LED_PORT_UART GPIOA
+#define LED_UART GPIO1
+#define LED_IDLE_RUN GPIO15
+#define LED_ERROR GPIO14
+#define LED_BOOTLOADER GPIO13
+
+#define USBUSART USART1
+#define USBUSART_CR1 USART1_CR1
+#define USBUSART_DR USART1_DR
+#define USBUSART_IRQ NVIC_USART1_IRQ
+#define USBUSART_CLK RCC_USART1
+#define USBUSART_PORT GPIOB
+#define USBUSART_TX_PIN GPIO6
+#define USBUSART_RX_PIN GPIO7
+#define USBUSART_ISR(x) usart1_isr(x)
+#define USBUSART_DMA_BUS DMA2
+#define USBUSART_DMA_CLK RCC_DMA2
+#define USBUSART_DMA_TX_CHAN DMA_STREAM7
+#define USBUSART_DMA_TX_IRQ NVIC_DMA2_STREAM7_IRQ
+#define USBUSART_DMA_TX_ISR(x) dma2_stream7_isr(x)
+#define USBUSART_DMA_RX_CHAN DMA_STREAM5
+#define USBUSART_DMA_RX_IRQ NVIC_DMA2_STREAM5_IRQ
+#define USBUSART_DMA_RX_ISR(x) dma2_stream5_isr(x)
+/* For STM32F4 DMA trigger source must be specified */
+#define USBUSART_DMA_TRG DMA_SxCR_CHSEL_4
+#else
+#define PLATFORM_IDENT "(F4Discovery) "
 
 /* Important pin mappings for STM32 implementation:
  *
@@ -44,7 +109,6 @@
  * LED2 = 	PD12	(Red LED    : Error)
  * LED3 = 	PD15	(Blue LED   : Bootloader active)
  *
- * TPWR = 	XXX (input) -- analogue on mini design ADC1, ch8
  * nTRST = 	PC1
  * SRST_OUT =   PC8
  * TDI = 	PC2
@@ -53,10 +117,7 @@
  * TDO = 	PC6 (input for TRACESWO
  * nSRST =
  *
- * USB cable pull-up: PA8
- * USB VBUS detect:  PB13 -- New on mini design.
- *                           Enable pull up for compatibility.
- * Force DFU mode button: PB12
+ * Force DFU mode button: PA0
  */
 
 /* Hardware definitions... */
@@ -87,6 +148,30 @@
 #define LED_ERROR	GPIO14
 #define LED_BOOTLOADER	GPIO15
 
+#define USBUSART USART3
+#define USBUSART_CR1 USART3_CR1
+#define USBUSART_DR USART3_DR
+#define USBUSART_IRQ NVIC_USART3_IRQ
+#define USBUSART_CLK RCC_USART3
+#define USBUSART_PORT GPIOD
+#define USBUSART_TX_PIN GPIO8
+#define USBUSART_RX_PIN GPIO9
+#define USBUSART_ISR(x) usart3_isr(x)
+#define USBUSART_DMA_BUS DMA1
+#define USBUSART_DMA_CLK RCC_DMA1
+#define USBUSART_DMA_TX_CHAN DMA_STREAM3
+#define USBUSART_DMA_TX_IRQ NVIC_DMA1_STREAM3_IRQ
+#define USBUSART_DMA_TX_ISR(x) dma1_stream3_isr(x)
+#define USBUSART_DMA_RX_CHAN DMA_STREAM1
+#define USBUSART_DMA_RX_IRQ NVIC_DMA1_STREAM1_IRQ
+#define USBUSART_DMA_RX_ISR(x) dma1_stream1_isr(x)
+/* For STM32F4 DMA trigger source must be specified */
+#define USBUSART_DMA_TRG DMA_SxCR_CHSEL_4
+#endif
+
+#define BOOTMAGIC0 0xb007da7a
+#define BOOTMAGIC1 0xbaadfeed
+
 #define TMS_SET_MODE() \
 	gpio_mode_setup(TMS_PORT, GPIO_MODE_OUTPUT, \
 	                GPIO_PUPD_NONE, TMS_PIN);
@@ -97,49 +182,35 @@
 #define SWDIO_MODE_DRIVE() \
 	gpio_mode_setup(SWDIO_PORT, GPIO_MODE_OUTPUT, \
 	                GPIO_PUPD_NONE, SWDIO_PIN);
-
+#define UART_PIN_SETUP() do { \
+	gpio_mode_setup(USBUSART_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, \
+	                USBUSART_TX_PIN); \
+	gpio_set_output_options(USBUSART_PORT, GPIO_OTYPE_PP, \
+					GPIO_OSPEED_100MHZ, USBUSART_TX_PIN); \
+	gpio_set_af(USBUSART_PORT, GPIO_AF7, USBUSART_TX_PIN); \
+	gpio_mode_setup(USBUSART_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, \
+	                USBUSART_RX_PIN); \
+	gpio_set_output_options(USBUSART_PORT, GPIO_OTYPE_OD, \
+					GPIO_OSPEED_100MHZ, USBUSART_RX_PIN); \
+	gpio_set_af(USBUSART_PORT, GPIO_AF7, USBUSART_RX_PIN); \
+} while(0)
 
 #define USB_DRIVER      stm32f107_usb_driver
 #define USB_IRQ         NVIC_OTG_FS_IRQ
-#define USB_ISR         otg_fs_isr
+#define USB_ISR(x)      otg_fs_isr(x)
 /* Interrupt priorities.  Low numbers are high priority.
- * For now USART1 preempts USB which may spin while buffer is drained.
  * TIM3 is used for traceswo capture and must be highest priority.
  */
-#define IRQ_PRI_USB		(2 << 4)
-#define IRQ_PRI_USBUSART	(1 << 4)
-#define IRQ_PRI_USBUSART_TIM	(3 << 4)
+#define IRQ_PRI_USB		(1 << 4)
+#define IRQ_PRI_USBUSART	(2 << 4)
+#define IRQ_PRI_USBUSART_DMA 	(2 << 4)
 #define IRQ_PRI_TRACE		(0 << 4)
 
-#define USBUSART USART3
-#define USBUSART_CR1 USART3_CR1
-#define USBUSART_IRQ NVIC_USART3_IRQ
-#define USBUSART_CLK RCC_USART3
-#define USBUSART_TX_PORT GPIOD
-#define USBUSART_TX_PIN  GPIO8
-#define USBUSART_RX_PORT GPIOD
-#define USBUSART_RX_PIN  GPIO9
-#define USBUSART_ISR usart3_isr
-#define USBUSART_TIM TIM4
-#define USBUSART_TIM_CLK_EN() rcc_periph_clock_enable(RCC_TIM4)
-#define USBUSART_TIM_IRQ NVIC_TIM4_IRQ
-#define USBUSART_TIM_ISR tim4_isr
-
-#define UART_PIN_SETUP() do { \
-	gpio_mode_setup(USBUSART_TX_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, \
-	                USBUSART_TX_PIN); \
-	gpio_mode_setup(USBUSART_RX_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, \
-	                USBUSART_RX_PIN); \
-	gpio_set_af(USBUSART_TX_PORT, GPIO_AF7, USBUSART_TX_PIN); \
-	gpio_set_af(USBUSART_RX_PORT, GPIO_AF7, USBUSART_RX_PIN); \
-    } while(0)
 
 #define TRACE_TIM TIM3
 #define TRACE_TIM_CLK_EN() rcc_periph_clock_enable(RCC_TIM3)
 #define TRACE_IRQ   NVIC_TIM3_IRQ
-#define TRACE_ISR   tim3_isr
-
-#define DEBUG(...)
+#define TRACE_ISR(x) tim3_isr(x)
 
 #define gpio_set_val(port, pin, val) do {	\
 	if(val)					\
@@ -157,11 +228,37 @@ static inline int platform_hwversion(void)
 	return 0;
 }
 
-/* Use newlib provided integer only stdio functions */
-#define sscanf siscanf
-#define sprintf siprintf
-#define vasprintf vasiprintf
-#define snprintf sniprintf
+/*
+ * Use newlib provided integer only stdio functions
+ */
 
+/* sscanf */
+#ifdef sscanf
+#undef sscanf
+#define sscanf siscanf
+#else
+#define sscanf siscanf
+#endif
+/* sprintf */
+#ifdef sprintf
+#undef sprintf
+#define sprintf siprintf
+#else
+#define sprintf siprintf
+#endif
+/* vasprintf */
+#ifdef vasprintf
+#undef vasprintf
+#define vasprintf vasiprintf
+#else
+#define vasprintf vasiprintf
+#endif
+/* snprintf */
+#ifdef snprintf
+#undef snprintf
+#define snprintf sniprintf
+#else
+#define snprintf sniprintf
 #endif
 
+#endif

src/platforms/f4discovery/usbdfu.c

@@ -17,59 +17,57 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "general.h"
-#include "usbdfu.h"
-
+#include <string.h>
 #include <libopencm3/cm3/systick.h>
 #include <libopencm3/stm32/rcc.h>
 #include <libopencm3/stm32/gpio.h>
 #include <libopencm3/cm3/scb.h>
 
+#include "usbdfu.h"
+#include "general.h"
+#include "platform.h"
+
+uint32_t app_address = 0x08004000;
+extern char _ebss[];
+
 void dfu_detach(void)
 {
-	/* USB device must detach, we just reset... */
 	scb_reset_system();
 }
 
 int main(void)
 {
-	/* Check the force bootloader pin*/
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
-	if(!gpio_get(GPIOA, GPIO0))
+	volatile uint32_t *magic = (uint32_t *)_ebss;
+	rcc_periph_clock_enable(RCC_GPIOA);
+	if (gpio_get(GPIOA, GPIO0) ||
+	   ((magic[0] == BOOTMAGIC0) && (magic[1] == BOOTMAGIC1))) {
+		magic[0] = 0;
+		magic[1] = 0;
+	} else {
 		dfu_jump_app_if_valid();
+	}
+	rcc_clock_setup_pll(&rcc_hse_8mhz_3v3[RCC_CLOCK_3V3_168MHZ]);
 
-	dfu_protect_enable();
+	/* Assert blue LED as indicator we are in the bootloader */
+	rcc_periph_clock_enable(RCC_GPIOD);
+	gpio_mode_setup(LED_PORT, GPIO_MODE_OUTPUT,
+					GPIO_PUPD_NONE, LED_BOOTLOADER);
+	gpio_set(LED_PORT, LED_BOOTLOADER);
 
-	/* Set up clock*/
-	rcc_clock_setup_hse_3v3(&hse_8mhz_3v3[CLOCK_3V3_168MHZ]);
-	systick_set_clocksource(STK_CSR_CLKSOURCE_AHB_DIV8);
-	systick_set_reload(2100000);
-
-	systick_interrupt_enable();
-	systick_counter_enable();
-
-	/* Handle LEDs */
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPDEN);
-	gpio_clear(GPIOD, GPIO12 | GPIO13 | GPIO14 |GPIO15);
-	gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE,
-			GPIO12 | GPIO13 | GPIO14 |GPIO15);
-
-	/* Set up USB*/
-	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
-	rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
+	/* Enable peripherals */
+	rcc_periph_clock_enable(RCC_OTGFS);
 
 	/* Set up USB Pins and alternate function*/
-	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE,
-                        GPIO10 | GPIO11 | GPIO12);
-	gpio_set_af(GPIOA, GPIO_AF10, GPIO10 | GPIO11 | GPIO12);
-	dfu_init(&stm32f107_usb_driver);
+	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11 | GPIO12);
+	gpio_set_af(GPIOA, GPIO_AF10, GPIO11 | GPIO12);
 
+ 	dfu_protect(false);
+	dfu_init(&USB_DRIVER);
 	dfu_main();
+
 }
 
-
-void sys_tick_handler(void)
+void dfu_event(void)
 {
-	gpio_toggle(GPIOD, GPIO12);  /* Green LED on/off */
 }
 

src/platforms/hosted/Makefile.inc

@@ -0,0 +1,85 @@
+CC ?= gcc
+SYS = $(shell $(CC) -dumpmachine)
+CFLAGS += -DENABLE_DEBUG -DPLATFORM_HAS_DEBUG
+CFLAGS +=-I ./target -I./platforms/pc
+
+# Define HOSTED_BMP_ONLY to '0' in order to build the hosted blackmagic
+# executable with support for other probes beside BMP. Default HOSTED_BMP_ONLY
+# == 1 on Windows makes linking against the libftdi and libusb libraries
+# unnecessary.
+# This can be useful to minimize external dependencies, and make building on
+# windows systems easier and is default now.
+ifneq (, $(findstring linux, $(SYS)))
+HOSTED_BMP_ONLY ?= 0
+else
+HOSTED_BMP_ONLY ?= 1
+endif
+CFLAGS  +=  -DHOSTED_BMP_ONLY=$(HOSTED_BMP_ONLY)
+
+ifneq (, $(findstring linux, $(SYS)))
+SRC += serial_unix.c
+HIDAPILIB = hidapi-hidraw
+ifeq ($(ASAN), 1)
+CFLAGS += -fsanitize=address  -Wno-format-truncation
+LDFLAGS += -lasan
+endif
+else ifneq (, $(findstring mingw, $(SYS)))
+# Build for windows versions Vista, and above, where the
+# 'SetupDiGetDevicePropertyW()' function is available
+CFLAGS += -D_WIN32_WINNT=0x600
+SRC += 	 serial_win.c
+LDFLAGS += -lws2_32
+LDFLAGS += -lsetupapi
+else ifneq (, $(findstring cygwin, $(SYS)))
+# Build for windows versions Vista, and above, where the
+# 'SetupDiGetDevicePropertyW()' function is available
+CFLAGS += -D_WIN32_WINNT=0x600
+SRC += 	 serial_win.c
+LDFLAGS += -lws2_32
+LDFLAGS += -lsetupapi
+#https://github.com/dmlc/xgboost/issues/1945 indicates macosx as indicator
+else ifneq (filter, macosx darwin, $(SYS))
+SRC += serial_unix.c
+LDFLAGS += -lhidapi
+LDFLAGS += -framework CoreFoundation
+CFLAGS += -Ihidapi/hidapi
+HIDAPILIB = hidapi
+endif
+
+ifneq ($(HOSTED_BMP_ONLY), 1)
+ $(shell pkg-config --exists libftdi1)
+ ifneq ($(.SHELLSTATUS), 0)
+  $(error Please install libftdi1 dependency or set HOSTED_BMP_ONLY to 1)
+ endif
+ LDFLAGS += -lusb-1.0
+ CFLAGS += $(shell pkg-config --cflags libftdi1)
+ LDFLAGS += $(shell pkg-config --libs libftdi1)
+ CFLAGS += -Wno-missing-field-initializers
+endif
+
+ifneq ($(HOSTED_BMP_ONLY), 1)
+ CFLAGS  +=  -DCMSIS_DAP
+ SRC += cmsis_dap.c dap.c
+ ifneq (, $(findstring mingw, $(SYS)))
+  SRC += hid.c
+ else
+  $(shell pkg-config --exists $(HIDAPILIB))
+  ifneq ($(.SHELLSTATUS), 0)
+   $(error Please install $(HIDAPILIB) dependency or set HOSTED_BMP_ONLY to 1)
+  endif
+  CFLAGS += $(shell pkg-config --cflags $(HIDAPILIB))
+  LDFLAGS += $(shell pkg-config --libs $(HIDAPILIB))
+ endif
+endif
+
+VPATH += platforms/pc
+SRC += timing.c cl_utils.c utils.c
+SRC += bmp_remote.c remote_swdptap.c remote_jtagtap.c
+ifneq ($(HOSTED_BMP_ONLY), 1)
+SRC += bmp_libusb.c stlinkv2.c
+SRC += ftdi_bmp.c libftdi_swdptap.c libftdi_jtagtap.c
+SRC += jlink.c jlink_adiv5_swdp.c jlink_jtagtap.c
+else
+SRC += bmp_serial.c
+endif
+PC_HOSTED = 1

src/platforms/hosted/Readme.md

@@ -0,0 +1,177 @@
+# PC-Hosted BMP
+Compile in src with "make PROBE_HOST=hosted". This needs minimal external
+support.  "make PROBE_HOST=hosted HOSTED_BMP_ONLY=0" will compile support for FTDI,
+STLink, CMSIS-DAP and JLINK probes, but requires external libraries.
+
+## Description
+PC-hosted BMP run on the PC and compiles as "blackmagic". When started,
+it either presents a list of available probes or starts the BMP process
+if either only one probe is attached to the PC or enough information is
+given on the command line to select one of several probes.
+
+When started without any other argument beside the probe selection, a
+GDB server is started on port 2000 and up. Connect to the server as you would
+connect to the BMP with the CDCACM GDB serial server. GDB functionality
+is the same, monitor option may vary.
+
+More arguments allow to
+### Print information on the connected target
+```
+blackmagic -t
+```
+### Directly flash a binary file at lowest flash address
+```
+blackmagic <file.bin>
+```
+or with the -S argument at some other address
+```
+blackmagic -S 0x08002000 <file.bin>
+```
+
+### Read flash to binary file
+```
+blackmagic -r <file>.bin
+```
+### Verify flash against binary file
+```
+blackmagic -V <file>.bin
+```
+### Show more options
+```
+blackmagic -h
+```
+### Show available monitor commands
+```
+blackmagic -M help
+```
+### Show available monitor commands on second target
+```
+blackmagic -n 2 -M help
+```
+### Monitor commands with multiple arguments, e.g.Stm32F1:
+```
+blackmagic -M "option help"
+```
+## Used shared libraries:
+### libusb
+### libftdi, for FTDI support
+
+## Other used libraries:
+### hidapi-libusb, for CMSIS-DAP support
+
+## Compiling on windows
+
+You can crosscompile blackmagic for windows with mingw or on windows
+with cygwin. For suppport of other probes beside BMP, headers for libftdi1 and
+libusb-1.0 are needed. For running, libftdi1.dll and libusb-1.0.dll are needed
+and the executable must be able to find them. Mingw on cygwin does not provide
+a libftdi package yet.
+
+PC-hosted BMP for windows can also be built with [MSYS2](https://www.msys2.org/),
+in windows. Make sure to use the `mingw64` shell from msys2, otherwise,
+you may get compilation errors. You will need to install the libusb
+and libftdi libraries, and have the correct mingw compiler.
+You can use these commands to install dependencies, and build PC-hosted BMP
+from a mingw64 shell, from within the `src` directory:
+```
+pacman -S mingw-w64-x86_64-libusb --needed
+pacman -S mingw-w64-x86_64-libftdi --needed
+pacman -S mingw-w64-x86_64-gcc --needed
+PROBE_HOST=hosted make
+```
+
+For suppport of other probes beside BMP, libusb access is needed. To prepare
+libusb access to the ftdi/stlink/jlink/cmsis-dap devices, run zadig
+https://zadig.akeo.ie/. Choose WinUSB(libusb-1.0).
+
+Running cygwin/blackmagic in a cygwin console, the program does not react
+on ^C. In another console, run "ps ax" to find the WINPID of the process
+and then "taskkill /F ?PID (WINPID)".
+
+## Supported debuggers
+REMOTE_BMP is a "normal" BMP usb connected
+
+|   Debugger   | Speed | Remarks
+| ------------ | ----- | ------
+| REMOTE_BMP   |  +++  | Requires recent firmware for decent speed
+Probes below only when compiled with HOSTED_BMP_ONLY=0
+| ST-Link V3   | ++++  | Requires recent firmware, Only STM32 devices supported!
+| ST-Link V2   |  +++  | Requires recent firmware, No CDCACM uart! Cortex only!
+| ST-Link V2/1 |  +++  | Requires recent firmware, Cortex only!
+| CMSIS-DAP    |  +++  | Speed varies with MCU implementing CMSIS-DAP
+| FTDI MPSSE   |   ++  | Requires a device descrition
+| JLINK        |    -  | Usefull to add BMP support for MCUs with built-in JLINK
+
+## Device matching
+As other USB dongles already connected to the host PC may use FTDI chips,
+cable descriptions must be provided to match with the dongle.
+To match the dongle, at least USB VID/PID  that must match.
+If a description is given, the USB device must provide that string. If a
+serial number string is given on the command line, that number must match
+with serial number in the USB descriptor of the device.
+
+## FTDI connection possibilities:
+
+| Direct Connection     |
+| ----------------------|
+| MPSSE_SK --> JTAG_TCK |
+| MPSSE_DO --> JTAG_TDI |
+| MPSSE_DI <-- JTAG_TDO |
+| MPSSE_CS <-> JTAG_TMS |
+
+\+ JTAG and bitbanging SWD is possible<br>
+\- No level translation, no buffering, no isolation<br>
+Example: [Flossjtag](https://randomprojects.org/wiki/Floss-JTAG).
+
+| Resistor SWD           |
+|------------------------|
+| MPSSE_SK ---> JTAG_TCK |
+| MPSSE_DO -R-> JTAG_TMS |
+| MPSSE_DI <--- JTAG_TMS |
+
+BMP would allow direct MPSSE_DO ->JTAG_TMS connections as BMP tristates DO
+when reading. Resistor defeats contentions anyways. R is typical choosen
+in the range of 470R
+
+\+ MPSSE SWD possible<br>
+\- No Jtag, no level translation, no buffering, no isolation<br>
+
+|Direct buffered Connection|
+|--------------------------|
+| MPSSE_SK -B-> JTAG_TCK   |
+| MPSSE_DO -B-> JTAG_TDI   |
+| MPSSE_DI <-B- JTAG_TDO   |
+| MPSSE_CS -B-> JTAG_TMS   |
+
+\+ Only Jtag, buffered, possible level translation and isolation<br>
+\- No SWD<br>
+Example: [Turtelizer]http://www.ethernut.de/en/hardware/turtelizer/index.html)
+[schematics](http://www.ethernut.de/pdf/turtelizer20c-schematic.pdf)
+
+The 'r' command line arguments allows to specify an external SWD
+resistor connection added to some existing cable. Jtag is not possible
+together with the 'r' argument.
+
+### Many variants possible
+As the FTDI has more pins, these pins may be used to control
+enables of buffers and multiplexer selection in many variants.
+
+### FTDI SWD speed
+SWD read needs two USB round trip, one for the acknowledge and one
+round-trip after the data phase, while JTAG only needs one round-trip.
+For that, SWD read speed is about half the JTAG read speed.
+
+### Reset, Target voltage readback etc
+The additional pins may also control Reset functionality, provide
+information if target voltage is applied. etc.
+
+### Cable descriptions
+Please help to verify the cable description and give feedback on the
+cables already listed and propose other cable. A link to the schematics
+is welcome.
+
+## Feedback
+### Issues and Pull request on https://github.com/blackmagic-debug/blackmagic/
+### Discussions on Discord.
+You can find the Discord link here: https://1bitsquared.com/pages/chat
+### Blackmagic mailing list http://sourceforge.net/mail/?group_id=407419

src/platforms/hosted/bmp_hosted.h

@@ -0,0 +1,52 @@
+#if !defined(__BMP_LIBUSB_H)
+#define      __BMP_LIBUSB_H
+
+#include "cl_utils.h"
+
+#if HOSTED_BMP_ONLY != 1
+# include <libusb-1.0/libusb.h>
+struct trans_ctx {
+#define TRANS_FLAGS_IS_DONE (1 << 0)
+#define TRANS_FLAGS_HAS_ERROR (1 << 1)
+    volatile unsigned long flags;
+};
+
+typedef struct usb_link_s {
+	libusb_context        *ul_libusb_ctx;
+	libusb_device_handle  *ul_libusb_device_handle;
+	unsigned char         ep_tx;
+	unsigned char         ep_rx;
+	struct libusb_transfer* req_trans;
+	struct libusb_transfer* rep_trans;
+	void                  *priv;
+} usb_link_t;
+
+int send_recv(usb_link_t *link, uint8_t *txbuf, size_t txsize,
+			  uint8_t *rxbuf, size_t rxsize);
+#endif
+typedef struct bmp_info_s {
+	bmp_type_t bmp_type;
+	char dev;
+	char serial[64];
+	char manufacturer[512];
+	char product[256];
+	char version[256];
+	bool is_jtag;
+#if HOSTED_BMP_ONLY != 1
+	libusb_context *libusb_ctx;
+	struct ftdi_context *ftdic;
+	usb_link_t *usb_link;
+	unsigned int vid;
+	unsigned int pid;
+	uint8_t interface_num;
+	uint8_t in_ep;
+	uint8_t out_ep;
+#endif
+} bmp_info_t;
+
+extern bmp_info_t info;
+void bmp_ident(bmp_info_t *info);
+int find_debuggers(BMP_CL_OPTIONS_t *cl_opts,bmp_info_t *info);
+void libusb_exit_function(bmp_info_t *info);
+
+#endif

src/platforms/hosted/bmp_libusb.c

@@ -0,0 +1,473 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright(C) 2020 - 2022 Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Find all known usb connected debuggers */
+#include "general.h"
+#include "libusb-1.0/libusb.h"
+#include "cl_utils.h"
+#include "ftdi_bmp.h"
+#include "version.h"
+
+#define NO_SERIAL_NUMBER "<no serial number>"
+
+void bmp_ident(bmp_info_t *info)
+{
+	DEBUG_INFO("BMP hosted %s\n for ST-Link V2/3, CMSIS_DAP, JLINK and "
+			   "LIBFTDI/MPSSE\n", FIRMWARE_VERSION);
+	if (info && info->vid && info->pid)
+		DEBUG_INFO("Using %04x:%04x %s %s\n %s\n", info->vid, info->pid,
+				   (info->serial[0]) ? info->serial : NO_SERIAL_NUMBER,
+				   info->manufacturer,
+				   info->product);
+}
+
+void libusb_exit_function(bmp_info_t *info)
+{
+	if (!info->usb_link)
+		return;
+	libusb_free_transfer(info->usb_link->req_trans);
+	libusb_free_transfer(info->usb_link->rep_trans);
+	if (info->usb_link->ul_libusb_device_handle) {
+		libusb_release_interface (
+			info->usb_link->ul_libusb_device_handle, 0);
+		libusb_close(info->usb_link->ul_libusb_device_handle);
+	}
+}
+
+static bmp_type_t find_cmsis_dap_interface(libusb_device *dev,bmp_info_t *info) {
+	bmp_type_t type = BMP_TYPE_NONE;
+
+	struct libusb_config_descriptor *conf;
+	char interface_string[128];
+
+	int res = libusb_get_active_config_descriptor(dev, &conf);
+	if (res < 0) {
+		DEBUG_WARN( "WARN: libusb_get_active_config_descriptor() failed: %s",
+				libusb_strerror(res));
+		return type;
+	}
+
+	libusb_device_handle *handle;
+	res = libusb_open(dev, &handle);
+	if (res != LIBUSB_SUCCESS) {
+		DEBUG_INFO("INFO: libusb_open() failed: %s\n",
+					libusb_strerror(res));
+		libusb_free_config_descriptor(conf);
+		return type;
+	}
+
+	for (int i = 0; i < conf->bNumInterfaces; i++) {
+		const struct libusb_interface_descriptor *interface = &conf->interface[i].altsetting[0];
+
+		if (!interface->iInterface) {
+			continue;
+		}
+
+		res = libusb_get_string_descriptor_ascii(
+			handle, interface->iInterface, (uint8_t*)interface_string,
+			sizeof(interface_string));
+		if (res < 0) {
+			DEBUG_WARN( "WARN: libusb_get_string_descriptor_ascii() failed: %s\n",
+					libusb_strerror(res));
+			continue;
+		}
+
+		if (!strstr(interface_string, "CMSIS")) {
+			continue;
+		}
+		type = BMP_TYPE_CMSIS_DAP;
+
+		if (interface->bInterfaceClass == 0xff && interface->bNumEndpoints == 2) {
+			info->interface_num = interface->bInterfaceNumber;
+
+			for (int j = 0; j < interface->bNumEndpoints; j++) {
+				uint8_t n = interface->endpoint[j].bEndpointAddress;
+
+				if (n & 0x80) {
+					info->in_ep = n;
+				} else {
+					info->out_ep = n;
+				}
+			}
+
+			/* V2 is preferred, return early. */
+			break;
+		}
+	}
+	libusb_free_config_descriptor(conf);
+	return type;
+}
+
+int find_debuggers(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info)
+{
+	libusb_device **devs;
+	int res = libusb_init(&info->libusb_ctx);
+	if (res) {
+		DEBUG_WARN( "Fatal: Failed to get USB context: %s\n",
+				libusb_strerror(res));
+		exit(-1);
+	}
+	if (cl_opts->opt_cable) {
+		if (!strcmp(cl_opts->opt_cable, "list") ||
+			!strcmp(cl_opts->opt_cable, "l")) {
+			cable_desc_t *cable = cable_desc;
+			DEBUG_WARN("Available cables:\n");
+			for (; cable->name; ++cable) {
+				DEBUG_WARN("\t%s\n", cable->name);
+			}
+			exit(0);
+		}
+		info->bmp_type = BMP_TYPE_LIBFTDI;
+	}
+	int n_devs = libusb_get_device_list(info->libusb_ctx, &devs);
+    if (n_devs < 0) {
+        DEBUG_WARN( "WARN:libusb_get_device_list() failed");
+		return -1;
+	}
+	bool report = false;
+	int found_debuggers;
+	struct libusb_device_descriptor desc;
+	char serial[64];
+	char manufacturer[128];
+	char product[128];
+	bool access_problems = false;
+	char *active_cable = NULL;
+	bool ftdi_unknown = false;
+rescan:
+	found_debuggers = 0;
+	serial[0] = 0;
+	manufacturer[0] = 0;
+	product[0] = 0;
+	access_problems = false;
+	active_cable = NULL;
+	ftdi_unknown = false;
+	for (size_t i = 0; devs[i]; ++i) {
+		bmp_type_t type = BMP_TYPE_NONE;
+		libusb_device *dev = devs[i];
+		int res = libusb_get_device_descriptor(dev, &desc);
+		if (res < 0) {
+            DEBUG_WARN( "WARN: libusb_get_device_descriptor() failed: %s",
+					libusb_strerror(res));
+			libusb_free_device_list(devs, 1);
+			continue;
+		}
+		/* Exclude hubs from testing. Probably more classes could be excluded here!*/
+		switch (desc.bDeviceClass) {
+		case LIBUSB_CLASS_HUB:
+		case LIBUSB_CLASS_WIRELESS:
+			continue;
+		}
+		libusb_device_handle *handle = NULL;
+		res = libusb_open(dev, &handle);
+		if (res != LIBUSB_SUCCESS) {
+			if (!access_problems) {
+				DEBUG_INFO("INFO: Open USB %04x:%04x class %2x failed\n",
+						   desc.idVendor, desc.idProduct, desc.bDeviceClass);
+				access_problems = true;
+			}
+			continue;
+		}
+		/* If the device even has a serial number string, fetch it */
+		if (desc.iSerialNumber) {
+			res = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber,
+				(uint8_t *)serial, sizeof(serial));
+			/* If the call fails and it's not because the device gave us STALL, continue to the next one */
+			if (res < 0 && res != LIBUSB_ERROR_PIPE) {
+				libusb_close(handle);
+				continue;
+			}
+			/* Device has no serial and that's ok. */
+			else if (res <= 0)
+				serial[0] = '\0';
+		}
+		else
+			serial[0] = '\0';
+		if (cl_opts->opt_serial && !strstr(serial, cl_opts->opt_serial)) {
+			libusb_close(handle);
+			continue;
+		}
+		/* Attempt to get the manufacturer string */
+		if (desc.iManufacturer) {
+			res = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer,
+				(uint8_t *)manufacturer, sizeof(manufacturer));
+			/* If the call fails and it's not because the device gave us STALL, continue to the next one */
+			if (res < 0 && res != LIBUSB_ERROR_PIPE) {
+				DEBUG_WARN("WARN: libusb_get_string_descriptor_ascii() call to fetch manufacturer string failed: %s\n",
+					libusb_strerror(res));
+				libusb_close(handle);
+				continue;
+			}
+			/* Device has no manufacturer string and that's ok. */
+			else if (res <= 0)
+				manufacturer[0] = '\0';
+		}
+		else
+			manufacturer[0] = '\0';
+		/* Attempt to get the product string */
+		if (desc.iProduct) {
+			res = libusb_get_string_descriptor_ascii(handle, desc.iProduct,
+				(uint8_t *)product, sizeof(product));
+			/* If the call fails and it's not because the device gave us STALL, continue to the next one */
+			if (res < 0 && res != LIBUSB_ERROR_PIPE) {
+				DEBUG_WARN("WARN: libusb_get_string_descriptor_ascii() call to fetch product string failed: %s\n",
+					libusb_strerror(res));
+				libusb_close(handle);
+				continue;
+			}
+			/* Device has no product string and that's ok. */
+			else if (res <= 0)
+				product[0] = '\0';
+		}
+		else
+			product[0] = '\0';
+		libusb_close(handle);
+		if (cl_opts->opt_ident_string) {
+			char *match_manu = NULL;
+			char *match_product = NULL;
+			match_manu = strstr(manufacturer, cl_opts->opt_ident_string);
+			match_product = strstr(product, cl_opts->opt_ident_string);
+			if (!match_manu && !match_product)
+				continue;
+		}
+		/* Either serial and/or ident_string match or are not given.
+		 * Check type.*/
+		if (desc.idVendor == VENDOR_ID_BMP) {
+			if (desc.idProduct == PRODUCT_ID_BMP)
+				type = BMP_TYPE_BMP;
+			else {
+				if (desc.idProduct == PRODUCT_ID_BMP_BL)
+					DEBUG_WARN("BMP in bootloader mode found. Restart or reflash!\n");
+				continue;
+			}
+		} else if (type == BMP_TYPE_NONE &&
+				   (type = find_cmsis_dap_interface(dev, info)) != BMP_TYPE_NONE) {
+			/* find_cmsis_dap_interface has set valid type*/
+		} else if (strstr(manufacturer, "CMSIS") || strstr(product, "CMSIS"))
+			type = BMP_TYPE_CMSIS_DAP;
+		else if (desc.idVendor ==  VENDOR_ID_STLINK) {
+			if (desc.idProduct == PRODUCT_ID_STLINKV2 ||
+				desc.idProduct == PRODUCT_ID_STLINKV21 ||
+				desc.idProduct == PRODUCT_ID_STLINKV21_MSD ||
+				desc.idProduct == PRODUCT_ID_STLINKV3_NO_MSD ||
+				desc.idProduct == PRODUCT_ID_STLINKV3_BL ||
+				desc.idProduct == PRODUCT_ID_STLINKV3 ||
+				desc.idProduct == PRODUCT_ID_STLINKV3E)
+				type = BMP_TYPE_STLINKV2;
+			else {
+				if (desc.idProduct == PRODUCT_ID_STLINKV1)
+					DEBUG_WARN( "INFO: STLINKV1 not supported\n");
+				continue;
+			}
+		} else if (desc.idVendor ==  VENDOR_ID_SEGGER)
+			type = BMP_TYPE_JLINK;
+		else {
+			cable_desc_t *cable = cable_desc;
+			for (; cable->name; ++cable) {
+				bool found = false;
+				if (cable->vendor != desc.idVendor || cable->product != desc.idProduct)
+					continue; /* VID/PID do not match*/
+				if (cl_opts->opt_cable) {
+					if (strncmp(cable->name, cl_opts->opt_cable, strlen(cable->name)))
+						continue; /* cable names do not match*/
+					else
+						found = true;
+				}
+				if (cable->description) {
+					if (strncmp(cable->description, product, strlen(cable->description)))
+						continue; /* discriptions do not match*/
+					else
+						found = true;
+				} else { /* VID/PID fits, but no cl_opts->opt_cable and no description*/
+					if (cable->vendor == 0x0403 && /* FTDI*/
+						(cable->product == 0x6010 || /* FT2232C/D/H*/
+						 cable->product == 0x6011 || /* FT4232H Quad HS USB-UART/FIFO IC */
+						 cable->product == 0x6014)) {  /* FT232H Single HS USB-UART/FIFO IC */
+						ftdi_unknown = true;
+						continue; /* Cable name is needed */
+					}
+				}
+				if (found) {
+					active_cable = cable->name;
+					type = BMP_TYPE_LIBFTDI;
+					break;
+				}
+			}
+			if (!cable->name)
+				continue;
+		}
+		if (report) {
+			DEBUG_WARN("%2d: %s, %s, %s\n", found_debuggers + 1,
+				serial[0] ? serial :  NO_SERIAL_NUMBER,
+				manufacturer,product);
+		}
+		info->vid = desc.idVendor;
+		info->pid = desc.idProduct;
+		info->bmp_type = type;
+		strncpy(info->serial, serial, sizeof(info->serial));
+		strncpy(info->product, product, sizeof(info->product));
+		strncpy(info->manufacturer, manufacturer, sizeof(info->manufacturer));
+		if (cl_opts->opt_position &&
+			cl_opts->opt_position == found_debuggers + 1) {
+			found_debuggers = 1;
+			break;
+		} else
+			++found_debuggers;
+	}
+	if (found_debuggers == 0 && ftdi_unknown)
+		DEBUG_WARN("Generic FTDI MPSSE VID/PID found. Please specify exact type with \"-c <cable>\" !\n");
+	if (found_debuggers == 1 && !cl_opts->opt_cable && info->bmp_type == BMP_TYPE_LIBFTDI)
+		cl_opts->opt_cable = active_cable;
+	if (!found_debuggers && cl_opts->opt_list_only)
+		DEBUG_WARN("No usable debugger found\n");
+	if (found_debuggers > 1 ||
+		(found_debuggers == 1 && cl_opts->opt_list_only)) {
+		if (!report) {
+			if (found_debuggers > 1)
+				DEBUG_WARN("%d debuggers found!\nSelect with -P <pos> "
+						   "or -s <(partial)serial no.>\n",
+						   found_debuggers);
+			report = true;
+			goto rescan;
+		} else {
+			if (found_debuggers > 0)
+				access_problems = false;
+			found_debuggers = 0;
+		}
+	}
+	if (!found_debuggers && access_problems)
+		DEBUG_WARN(
+			"No debugger found. Please check access rights to USB devices!\n");
+	libusb_free_device_list(devs, 1);
+	return found_debuggers == 1 ? 0 : -1;
+}
+
+static void LIBUSB_CALL on_trans_done(struct libusb_transfer *trans)
+{
+    struct trans_ctx * const ctx = trans->user_data;
+
+    if (trans->status != LIBUSB_TRANSFER_COMPLETED)
+    {
+		DEBUG_WARN("on_trans_done: ");
+        if (trans->status == LIBUSB_TRANSFER_TIMED_OUT)
+            DEBUG_WARN(" Timeout\n");
+        else if (trans->status == LIBUSB_TRANSFER_CANCELLED)
+            DEBUG_WARN(" cancelled\n");
+        else if (trans->status == LIBUSB_TRANSFER_NO_DEVICE)
+            DEBUG_WARN(" no device\n");
+        else
+            DEBUG_WARN(" unknown\n");
+        ctx->flags |= TRANS_FLAGS_HAS_ERROR;
+    }
+    ctx->flags |= TRANS_FLAGS_IS_DONE;
+}
+
+static int submit_wait(usb_link_t *link, struct libusb_transfer *trans) {
+	struct trans_ctx trans_ctx;
+	enum libusb_error error;
+
+	trans_ctx.flags = 0;
+
+	/* brief intrusion inside the libusb interface */
+	trans->callback = on_trans_done;
+	trans->user_data = &trans_ctx;
+
+	if ((error = libusb_submit_transfer(trans))) {
+		DEBUG_WARN("libusb_submit_transfer(%d): %s\n", error,
+			  libusb_strerror(error));
+		exit(-1);
+	}
+
+	uint32_t start_time = platform_time_ms();
+	while (trans_ctx.flags == 0) {
+		struct timeval timeout;
+		timeout.tv_sec = 1;
+		timeout.tv_usec = 0;
+		if (libusb_handle_events_timeout(link->ul_libusb_ctx, &timeout)) {
+			DEBUG_WARN("libusb_handle_events()\n");
+			return -1;
+		}
+		uint32_t now = platform_time_ms();
+		if (now - start_time > 1000) {
+			libusb_cancel_transfer(trans);
+			DEBUG_WARN("libusb_handle_events() timeout\n");
+			return -1;
+		}
+	}
+	if (trans_ctx.flags & TRANS_FLAGS_HAS_ERROR) {
+		DEBUG_WARN("libusb_handle_events() | has_error\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/* One USB transaction */
+int send_recv(usb_link_t *link,
+					 uint8_t *txbuf, size_t txsize,
+					 uint8_t *rxbuf, size_t rxsize)
+{
+	int res = 0;
+	if (txsize) {
+		libusb_fill_bulk_transfer(link->req_trans,
+								  link->ul_libusb_device_handle,
+								  link->ep_tx | LIBUSB_ENDPOINT_OUT,
+								  txbuf, txsize,
+								  NULL, NULL, 0);
+		size_t i = 0;
+		DEBUG_WIRE(" Send (%3zu): ", txsize);
+		for (; i < txsize; ++i) {
+			DEBUG_WIRE("%02x", txbuf[i]);
+			if ((i & 7U) == 7U)
+				DEBUG_WIRE(".");
+			if ((i & 31U) == 31U)
+				DEBUG_WIRE("\n             ");
+		}
+		if (!(i & 31U))
+			DEBUG_WIRE("\n");
+		if (submit_wait(link, link->req_trans)) {
+			libusb_clear_halt(link->ul_libusb_device_handle, link->ep_tx);
+			return -1;
+		}
+	}
+	/* send_only */
+	if (rxsize != 0) {
+		/* read the response */
+		libusb_fill_bulk_transfer(link->rep_trans, link->ul_libusb_device_handle,
+								  link->ep_rx | LIBUSB_ENDPOINT_IN,
+								  rxbuf, rxsize, NULL, NULL, 0);
+
+		if (submit_wait(link, link->rep_trans)) {
+			DEBUG_WARN("clear 1\n");
+			libusb_clear_halt(link->ul_libusb_device_handle, link->ep_rx);
+			return -1;
+		}
+		res = link->rep_trans->actual_length;
+		if (res > 0) {
+			const size_t rxlen = (size_t)res;
+			DEBUG_WIRE(" Rec (%zu/%zu)", rxsize, rxlen);
+			for (size_t i = 0; i < rxlen && i < 32 ; ++i) {
+				if (i && ((i & 7U) == 0U))
+					DEBUG_WIRE(".");
+				DEBUG_WIRE("%02x", rxbuf[i]);
+			}
+		}
+	}
+	DEBUG_WIRE("\n");
+	return res;
+}

src/platforms/hosted/bmp_remote.c

@@ -0,0 +1,404 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ * Additions by Dave Marples <dave@marples.net>
+ * Modifications (C) 2020 Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "general.h"
+#include "gdb_if.h"
+#include "version.h"
+#include "remote.h"
+#include "target.h"
+#include "bmp_remote.h"
+#include "cl_utils.h"
+#include "hex_utils.h"
+
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#include "adiv5.h"
+
+int remote_init(void)
+{
+	char construct[REMOTE_MAX_MSG_SIZE];
+	int c = snprintf(construct, REMOTE_MAX_MSG_SIZE, "%s", REMOTE_START_STR);
+	platform_buffer_write((uint8_t *)construct, c);
+	c = platform_buffer_read((uint8_t *)construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((c < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("Remote Start failed, error %s\n",
+				c ? (char *)&(construct[1]) : "unknown");
+      return -1;
+    }
+	DEBUG_PROBE("Remote is %s\n", &construct[1]);
+	return 0;
+}
+
+bool remote_target_get_power(void)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s=snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, "%s",
+			   REMOTE_PWR_GET_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+      DEBUG_WARN(" platform_target_get_power failed, error %s\n",
+				 s ? (char *)&(construct[1]) : "unknown");
+      exit (-1);
+    }
+
+	return (construct[1] == '1');
+}
+
+bool remote_target_set_power(bool power)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,REMOTE_PWR_SET_STR,
+				 power ? '1' : '0');
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("platform_target_set_power failed, error %s\n",
+				s ? (char *)&(construct[1]) : "unknown");
+		return false;
+    }
+	return true;
+}
+
+void remote_srst_set_val(bool assert)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, REMOTE_SRST_SET_STR,
+				 assert ? '1' : '0');
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("platform_srst_set_val failed, error %s\n",
+				   s ? (char *)&(construct[1]) : "unknown");
+      exit(-1);
+    }
+}
+
+bool remote_srst_get_val(void)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,"%s",
+				 REMOTE_SRST_GET_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("platform_srst_set_val failed, error %s\n",
+				   s ? (char *)&(construct[1]) : "unknown");
+      exit(-1);
+    }
+	return (construct[1] == '1');
+}
+
+void remote_max_frequency_set(uint32_t freq)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, REMOTE_FREQ_SET_STR,
+				 freq);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("Update Firmware to allow to set max SWJ frequency\n");
+    }
+}
+
+uint32_t remote_max_frequency_get(void)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,"%s",
+				 REMOTE_FREQ_GET_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR))
+		return FREQ_FIXED;
+
+	uint32_t freq[1];
+	unhexify(freq, (const char*)&construct[1], 4);
+	return freq[0];
+}
+
+const char *remote_target_voltage(void)
+{
+	static uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE," %s",
+				 REMOTE_VOLTAGE_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+      DEBUG_WARN("platform_target_voltage failed, error %s\n",
+			  s ? (char *)&(construct[1]) : "unknown");
+      exit(- 1);
+    }
+	return (char *)&construct[1];
+}
+
+static uint32_t remote_adiv5_dp_read(ADIv5_DP_t *dp, uint16_t addr)
+{
+	(void)dp;
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, REMOTE_DP_READ_STR,
+					 dp->dp_jd_index, addr);
+	platform_buffer_write(construct, s);
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("%s error %d\n", __func__, s);
+	}
+    uint32_t dest[1];
+	unhexify(dest, (const char*)&construct[1], 4);
+	DEBUG_PROBE("dp_read addr %04x: %08" PRIx32 "\n", dest[0]);
+	return dest[0];
+}
+
+static uint32_t remote_adiv5_low_access(
+	ADIv5_DP_t *dp, uint8_t RnW, uint16_t addr, uint32_t value)
+{
+	(void)dp;
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,
+					 REMOTE_LOW_ACCESS_STR, dp->dp_jd_index, RnW, addr, value);
+	platform_buffer_write(construct, s);
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("%s error %d\n", __func__, s);
+	}
+    uint32_t dest[1];
+	unhexify(dest, (const char*)&construct[1], 4);
+	return dest[0];
+}
+
+static uint32_t remote_adiv5_ap_read(ADIv5_AP_t *ap, uint16_t addr)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,REMOTE_AP_READ_STR,
+					 ap->dp->dp_jd_index, ap->apsel, addr);
+	platform_buffer_write(construct, s);
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("%s error %d\n", __func__, s);
+	}
+    uint32_t dest[1];
+	unhexify(dest, (const char*)&construct[1], 4);
+	return dest[0];
+}
+
+static void remote_adiv5_ap_write(ADIv5_AP_t *ap, uint16_t addr, uint32_t value)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,REMOTE_AP_WRITE_STR,
+					ap->dp->dp_jd_index,  ap->apsel, addr, value);
+	platform_buffer_write(construct, s);
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("%s error %d\n", __func__, s);
+	}
+	return;
+}
+
+#if 0
+static void remote_mem_read(
+	ADIv5_AP_t *ap, void *dest, uint32_t src, size_t len)
+{
+	(void)ap;
+	if (len == 0)
+		return;
+	DEBUG_WIRE("memread @ %" PRIx32 " len %ld, start: \n",
+			   src, len);
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+	int batchsize = (REMOTE_MAX_MSG_SIZE - 32) / 2;
+	while(len) {
+		int count = len;
+		if (count > batchsize)
+			count = batchsize;
+		s = snprintf(construct, REMOTE_MAX_MSG_SIZE,
+					 REMOTE_MEM_READ_STR, src, count);
+		platform_buffer_write(construct, s);
+
+		s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+		if ((s > 0) && (construct[0] == REMOTE_RESP_OK)) {
+			unhexify(dest, (const char*)&construct[1], count);
+			src += count;
+			dest += count;
+			len -= count;
+
+			continue;
+		} else {
+			if(construct[0] == REMOTE_RESP_ERR) {
+				ap->dp->fault = 1;
+				DEBUG_WARN("%s returned REMOTE_RESP_ERR at addr: 0x%08x\n",
+					   __func__, src);
+				break;
+			} else {
+				DEBUG_WARN("%s error %d\n", __func__, s);
+				break;
+			}
+		}
+	}
+}
+#endif
+
+static void remote_ap_mem_read(
+	ADIv5_AP_t *ap, void *dest, uint32_t src, size_t len)
+{
+	(void)ap;
+	if (len == 0)
+		return;
+	char construct[REMOTE_MAX_MSG_SIZE];
+	int batchsize = (REMOTE_MAX_MSG_SIZE - 0x20) / 2;
+	while(len) {
+		int s;
+		int count = len;
+		if (count > batchsize)
+			count = batchsize;
+		s = snprintf(construct, REMOTE_MAX_MSG_SIZE,
+					 REMOTE_AP_MEM_READ_STR, ap->dp->dp_jd_index, ap->apsel, ap->csw, src, count);
+		platform_buffer_write((uint8_t*)construct, s);
+		s = platform_buffer_read((uint8_t*)construct, REMOTE_MAX_MSG_SIZE);
+		if ((s > 0) && (construct[0] == REMOTE_RESP_OK)) {
+			unhexify(dest, (const char*)&construct[1], count);
+			src  += count;
+			dest += count;
+			len  -= count;
+			continue;
+		} else {
+			if(construct[0] == REMOTE_RESP_ERR) {
+				ap->dp->fault = 1;
+				DEBUG_WARN("%s returned REMOTE_RESP_ERR at apsel %d, "
+					   "addr: 0x%08" PRIx32 "\n", __func__, ap->apsel, src);
+				break;
+			} else {
+				DEBUG_WARN("%s error %d around 0x%08" PRIx32 "\n",
+					   __func__, s, src);
+				break;
+			}
+		}
+	}
+}
+
+static void remote_ap_mem_write_sized(
+	ADIv5_AP_t *ap, uint32_t dest, const void *src, size_t len,
+	enum align align)
+{
+	(void)ap;
+	if (len == 0)
+		return;
+	char construct[REMOTE_MAX_MSG_SIZE];
+	/* (5 * 1 (char)) + (2 * 2 (bytes)) + (3 * 8 (words)) */
+	int batchsize = (REMOTE_MAX_MSG_SIZE - 0x30) / 2;
+	while (len) {
+		int count = len;
+		if (count > batchsize)
+			count = batchsize;
+		int s = snprintf(construct, REMOTE_MAX_MSG_SIZE,
+						 REMOTE_AP_MEM_WRITE_SIZED_STR,
+						 ap->dp->dp_jd_index, ap->apsel, ap->csw, align, dest, count);
+		char *p = construct + s;
+		hexify(p, src, count);
+		p += 2 * count;
+		src  += count;
+		dest += count;
+		len  -= count;
+		*p++ = REMOTE_EOM;
+		*p   = 0;
+		platform_buffer_write((uint8_t*)construct, p - construct);
+
+		s = platform_buffer_read((uint8_t*)construct, REMOTE_MAX_MSG_SIZE);
+		if ((s > 0) && (construct[0] == REMOTE_RESP_OK))
+			continue;
+		if ((s > 0) && (construct[0] == REMOTE_RESP_ERR)) {
+			ap->dp->fault = 1;
+			DEBUG_WARN("%s returned REMOTE_RESP_ERR at apsel %d, "
+				   "addr: 0x%08x\n", __func__, ap->apsel, dest);
+		} else {
+			DEBUG_WARN("%s error %d around address 0x%08" PRIx32 "\n",
+				   __func__, s, dest);
+			break;
+		}
+	}
+}
+
+void remote_adiv5_dp_defaults(ADIv5_DP_t *dp)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, "%s",
+					 REMOTE_HL_CHECK_STR);
+	platform_buffer_write(construct, s);
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR) ||
+		((construct[1] - '0') <  REMOTE_HL_VERSION)) {
+		DEBUG_WARN(
+			"Please update BMP firmware for substantial speed increase!\n");
+		return;
+	}
+	dp->low_access = remote_adiv5_low_access;
+	dp->dp_read    = remote_adiv5_dp_read;
+	dp->ap_write   = remote_adiv5_ap_write;
+	dp->ap_read    = remote_adiv5_ap_read;
+	dp->mem_read   = remote_ap_mem_read;
+	dp->mem_write_sized = remote_ap_mem_write_sized;
+}
+
+void remote_add_jtag_dev(int i, const jtag_dev_t *jtag_dev)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,
+					 REMOTE_JTAG_ADD_DEV_STR,
+					 i,
+					 jtag_dev->dr_prescan,
+					 jtag_dev->dr_postscan,
+					 jtag_dev->ir_len,
+					 jtag_dev->ir_prescan,
+					 jtag_dev->ir_postscan,
+					 jtag_dev->current_ir);
+	platform_buffer_write(construct, s);
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	/* No check for error here. Done in remote_adiv5_dp_defaults!*/
+}

src/platforms/hosted/bmp_remote.h

@@ -0,0 +1,45 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2020 Uwe Bonnes
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.	 If not, see <http://www.gnu.org/licenses/>.
+ */
+#if !defined(__BMP_REMOTE_H_)
+#define      __BMP_REMOTE_H_
+#include "jtagtap.h"
+#include "adiv5.h"
+#include "target.h"
+#include "target_internal.h"
+
+#define REMOTE_MAX_MSG_SIZE (1024)
+
+int platform_buffer_write(const uint8_t *data, int size);
+int platform_buffer_read(uint8_t *data, int size);
+
+int remote_init(void);
+int remote_swdptap_init(ADIv5_DP_t *dp);
+int remote_jtagtap_init(jtag_proc_t *jtag_proc);
+bool remote_target_get_power(void);
+const char *remote_target_voltage(void);
+bool remote_target_set_power(bool power);
+void remote_srst_set_val(bool assert);
+bool remote_srst_get_val(void);
+void remote_max_frequency_set(uint32_t freq);
+uint32_t remote_max_frequency_get(void);
+const char *platform_target_voltage(void);
+void remote_adiv5_dp_defaults(ADIv5_DP_t *dp);
+void remote_add_jtag_dev(int i, const jtag_dev_t *jtag_dev);
+#define __BMP_REMOTE_H_
+#endif

src/platforms/hosted/bmp_serial.c

@@ -0,0 +1,296 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2020 Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Find all known serial connected debuggers */
+
+#include "general.h"
+#include <dirent.h>
+#include <errno.h>
+#include "bmp_hosted.h"
+#include "version.h"
+
+void bmp_ident(bmp_info_t *info)
+{
+	if (!info)
+		return;
+	DEBUG_INFO("BMP hosted (BMP Only) %s\n", FIRMWARE_VERSION);
+	DEBUG_INFO("Using:\n %s %s %s\n", info->manufacturer, info->version, info->serial);
+}
+
+void libusb_exit_function(bmp_info_t *info) {(void)info;};
+
+
+#ifdef __APPLE__
+int find_debuggers(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info)
+{
+	DEBUG_WARN("Please implement find_debuggers for MACOS!\n");
+	(void)cl_opts;
+	(void)info;
+	return -1;
+}
+#elif defined(__WIN32__) || defined(__CYGWIN__)
+
+
+/* This source has been used as an example:
+ * https://stackoverflow.com/questions/3438366/setupdigetdeviceproperty-usage-example */
+
+#include <windows.h>
+#include <setupapi.h>
+#include <cfgmgr32.h>   // for MAX_DEVICE_ID_LEN, CM_Get_Parent and CM_Get_Device_ID
+#include <tchar.h>
+#include <stdio.h>
+
+/* include DEVPKEY_Device_BusReportedDeviceDesc from WinDDK\7600.16385.1\inc\api\devpropdef.h */
+#ifdef DEFINE_DEVPROPKEY
+#undef DEFINE_DEVPROPKEY
+#endif
+#define DEFINE_DEVPROPKEY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8, pid) const DEVPROPKEY DECLSPEC_SELECTANY name = { { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }, pid }
+
+/* include DEVPKEY_Device_BusReportedDeviceDesc from WinDDK\7600.16385.1\inc\api\devpkey.h */
+DEFINE_DEVPROPKEY(DEVPKEY_Device_BusReportedDeviceDesc,  0x540b947e, 0x8b40, 0x45bc, 0xa8, 0xa2, 0x6a, 0x0b, 0x89, 0x4c, 0xbd, 0xa2, 4);     // DEVPROP_TYPE_STRING
+
+/* List all USB devices with some additional information.
+ * Unfortunately, this code is quite ugly. */
+int find_debuggers(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info)
+{
+	unsigned i;
+	DWORD dwSize;
+	DEVPROPTYPE ulPropertyType;
+	CONFIGRET status;
+	HDEVINFO hDevInfo;
+	SP_DEVINFO_DATA DeviceInfoData;
+	TCHAR szDeviceInstanceID [MAX_DEVICE_ID_LEN];
+	WCHAR busReportedDeviceSesc[4096];
+	int probes_found = 0;
+	bool is_printing_probes_info = cl_opts->opt_list_only != 0;
+
+	info->bmp_type = BMP_TYPE_BMP;
+
+	hDevInfo = SetupDiGetClassDevs (0, "USB", NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT);
+	if (hDevInfo == INVALID_HANDLE_VALUE)
+		return -1;
+print_probes_info:
+	for (i = 0; ; i++)  {
+		char serial_number[sizeof info->serial];
+		DeviceInfoData.cbSize = sizeof (DeviceInfoData);
+		if (!SetupDiEnumDeviceInfo(hDevInfo, i, &DeviceInfoData))
+			break;
+
+		status = CM_Get_Device_ID(DeviceInfoData.DevInst, szDeviceInstanceID , MAX_PATH, 0);
+		if (status != CR_SUCCESS)
+			continue;
+
+		if (!sscanf(szDeviceInstanceID, "USB\\VID_1D50&PID_6018\\%s", serial_number))
+			continue;
+
+		if (SetupDiGetDevicePropertyW (hDevInfo, &DeviceInfoData, &DEVPKEY_Device_BusReportedDeviceDesc,
+		       &ulPropertyType, (BYTE*)busReportedDeviceSesc, sizeof busReportedDeviceSesc, &dwSize, 0))
+		{
+			probes_found ++;
+			if (is_printing_probes_info)
+			{
+				DEBUG_WARN("%2d: %s, %ls\n", probes_found,
+					   serial_number, busReportedDeviceSesc);
+			}
+			else
+			{
+				bool probe_identified = true;
+				if ((cl_opts->opt_serial && strstr(serial_number, cl_opts->opt_serial)) ||
+					(cl_opts->opt_position && cl_opts->opt_position == probes_found) ||
+					/* Special case for the very first probe found. */
+					(probe_identified = false, probes_found == 1)) {
+
+					strncpy(info->serial, serial_number, sizeof info->serial);
+					strncpy(info->manufacturer, "BMP", sizeof info->manufacturer);
+					snprintf(info->product, sizeof info->product, "%ls", busReportedDeviceSesc);
+					/* Don't bother to parse the version string. It is a part of the
+					 * product description string. It seems that at the moment it
+					 * is only being used to print a version string in response
+					 * to the 'monitor version' command, so it doesn't really matter
+					 * if the version string is printed as a part of the product string,
+					 * or as a separate string, the result is pretty much the same. */
+					info->version[0] = 0;
+					if (probe_identified)
+						return 0;
+				}
+			}
+		}
+	}
+	if (is_printing_probes_info)
+		return 1;
+	if (probes_found == 1)
+		/* Exactly one probe found. Its information has already been filled
+		 * in the detection loop, so use this probe. */
+		return 0;
+	if (probes_found < 1) {
+		DEBUG_WARN("No BMP probe found\n");
+		return -1;
+	}
+	/* Otherwise, if this line is reached, then more than one probe has been found,
+	 * and no probe was identified as selected by the user.
+	 * Restart the identification loop, this time printing the probe information,
+	 * and then return. */
+	DEBUG_WARN("%d debuggers found!\nSelect with -P <pos>, or "
+		   "-s <(partial)serial no.>\n",
+		   probes_found);
+	probes_found = 0;
+	is_printing_probes_info = true;
+	goto print_probes_info;
+}
+
+#else
+/* Old ID: Black_Sphere_Technologies_Black_Magic_Probe_BFE4D6EC-if00
+ * Recent: Black_Sphere_Technologies_Black_Magic_Probe_v1.7.1-212-g212292ab_7BAE7AB8-if00
+ * usb-Black_Sphere_Technologies_Black_Magic_Probe__SWLINK__v1.7.1-155-gf55ad67b-dirty_DECB8811-if00
+ */
+#define BMP_IDSTRING_BLACKSPHERE "usb-Black_Sphere_Technologies_Black_Magic_Probe"
+#define BMP_IDSTRING_BLACKMAGIC "usb-Black_Magic_Debug_Black_Magic_Probe"
+#define BMP_IDSTRING_1BITSQUARED "usb-1BitSquared_Black_Magic_Probe"
+#define DEVICE_BY_ID "/dev/serial/by-id/"
+
+/*
+ * Extract type, version and serial from /dev/serial/by_id
+ * Return 0 on success
+ *
+ * Old versions have different strings. Try to cope!
+ */
+static int scan_linux_id(char *name, char *type, char *version, char  *serial)
+{
+	name += strlen(BMP_IDSTRING_BLACKSPHERE) + 1;
+	while (*name == '_')
+		name++;
+	if (!*name) {
+		DEBUG_WARN("Unexpected end\n");
+		return -1;
+	}
+	char *p = name;
+	char *delims[4] = {0,0,0,0};
+	int underscores = 0;
+	while (*p) {
+		if (*p == '_') {
+			while (p[1] == '_')
+				p++; /* remove multiple underscores */
+			if (underscores > 2)
+				return -1;
+			delims[underscores] = p;
+			underscores ++;
+		}
+		p++;
+	}
+	if (underscores == 0) { /* Old BMP native */
+		int res;
+		res = sscanf(name, "%8s-if00", serial);
+		if (res != 1)
+			return -1;
+		strcpy(type, "Native");
+		strcpy(version, "Unknown");
+	} else if (underscores == 2) {
+		strncpy(type, name, delims[0] - name - 1);
+		strncpy(version, delims[0] + 1, delims[1] - delims[0] - 1);
+		int res = sscanf(delims[1] + 1, "%8s-if00", serial);
+		if (!res)
+			return -1;
+	} else {
+		int res = sscanf(delims[0] + 1, "%8s-if00", serial);
+		if (!res)
+			return -1;
+		if (name[0] == 'v') {
+			strcpy(type, "Unknown");
+			strncpy(version, name, delims[0] - name - 1);
+		} else {
+			strncpy(type, name, delims[0] - name);
+			strcpy(type, "Unknown");
+		}
+	}
+	return 0;
+}
+
+int find_debuggers(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info)
+{
+	if (cl_opts->opt_device)
+		return 1;
+	info->bmp_type = BMP_TYPE_BMP;
+	DIR *dir = opendir(DEVICE_BY_ID);
+	if (!dir) /* No serial device connected!*/
+		return 0;
+	int found_bmps = 0;
+	struct dirent *dp;
+	int i = 0;
+	while ((dp = readdir(dir)) != NULL) {
+		if ((strstr(dp->d_name, BMP_IDSTRING_BLACKMAGIC) ||
+		     strstr(dp->d_name, BMP_IDSTRING_BLACKSPHERE) ||
+		     strstr(dp->d_name, BMP_IDSTRING_1BITSQUARED)) &&
+			(strstr(dp->d_name, "-if00"))) {
+			i++;
+			char type[256], version[256], serial[256];
+			if (scan_linux_id(dp->d_name, type, version, serial)) {
+				DEBUG_WARN("Unexpected device name found \"%s\"\n",
+						   dp->d_name);
+			}
+			if ((cl_opts->opt_serial && strstr(serial, cl_opts->opt_serial)) ||
+				(cl_opts->opt_position && cl_opts->opt_position == i)) {
+				/* With serial number given and partial match, we are done!*/
+				strncpy(info->serial, serial, sizeof(info->serial));
+				int res = snprintf(info->manufacturer, sizeof(info->manufacturer), "Black Magic Probe (%s)", type);
+				if (res)
+					DEBUG_WARN("Overflow\n");
+				strncpy(info->version, version, sizeof(info->version));
+				found_bmps = 1;
+				break;
+			} else {
+				found_bmps++;
+			}
+		}
+	}
+	closedir(dir);
+	if (found_bmps < 1) {
+		DEBUG_WARN("No BMP probe found\n");
+		return -1;
+	} else if ((found_bmps > 1) || cl_opts->opt_list_only) {
+		DEBUG_WARN("Available Probes:\n");
+	}
+	dir = opendir(DEVICE_BY_ID);
+	i = 0;
+	while ((dp = readdir(dir)) != NULL) {
+		if ((strstr(dp->d_name, BMP_IDSTRING_BLACKMAGIC) ||
+		     strstr(dp->d_name, BMP_IDSTRING_BLACKSPHERE) ||
+		     strstr(dp->d_name, BMP_IDSTRING_1BITSQUARED)) &&
+			(strstr(dp->d_name, "-if00"))) {
+			i++;
+			char type[256], version[256], serial[256];
+			if (scan_linux_id(dp->d_name, type, version, serial)) {
+				DEBUG_WARN("Unexpected device name found \"%s\"\n",
+						   dp->d_name);
+			} else if ((found_bmps == 1) && (!cl_opts->opt_list_only)) {
+				strncpy(info->serial, serial, sizeof(info->serial));
+				found_bmps = 1;
+				strncpy(info->serial, serial, sizeof(info->serial));
+				snprintf(info->manufacturer, sizeof(info->manufacturer), "Black Magic Probe (%s)", type);
+				strncpy(info->version, version, sizeof(info->version));
+				break;
+			} else if (found_bmps > 0) {
+				DEBUG_WARN("%2d: %s, Black Magic Debug, Black Magic "
+						   "Probe (%s), %s\n", i, serial, type, version);
+			}
+		}
+	}
+	closedir(dir);
+	return (found_bmps == 1 && !cl_opts->opt_list_only) ? 0 : 1;
+}
+#endif

src/platforms/hosted/cmsis_dap.c

@@ -0,0 +1,470 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2019-2021 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.	 If not, see <http://www.gnu.org/licenses/>.
+ */
+/* Modified from edbg.c
+ *   Links between bmp and edbg
+ *
+ * https://arm-software.github.io/CMSIS_5/DAP/html/index.html
+*/
+
+#include "general.h"
+#include "gdb_if.h"
+#include "adiv5.h"
+
+#include <assert.h>
+#include <unistd.h>
+#include <signal.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include <hidapi.h>
+#include <wchar.h>
+
+#include "bmp_hosted.h"
+#include "dap.h"
+#include "cmsis_dap.h"
+
+#include "cl_utils.h"
+#include "target.h"
+#include "target_internal.h"
+
+uint8_t dap_caps;
+uint8_t mode;
+
+typedef enum cmsis_type_s {
+	CMSIS_TYPE_NONE = 0,
+	CMSIS_TYPE_HID,
+	CMSIS_TYPE_BULK
+} cmsis_type_t;
+/*- Variables ---------------------------------------------------------------*/
+static cmsis_type_t type;
+static libusb_device_handle *usb_handle = NULL;
+static uint8_t in_ep;
+static uint8_t out_ep;
+static hid_device *handle = NULL;
+static uint8_t buffer[1024 + 1];
+static int report_size = 64 + 1; // TODO: read actual report size
+static bool has_swd_sequence = false;
+
+/* LPC845 Breakout Board Rev. 0 report invalid response with > 65 bytes */
+int dap_init(bmp_info_t *info)
+{
+	type = (info->in_ep && info->out_ep) ? CMSIS_TYPE_BULK : CMSIS_TYPE_HID;
+	int size;
+
+	if (type == CMSIS_TYPE_HID) {
+		DEBUG_INFO("Using hid transfer\n");
+		if (hid_init())
+			return -1;
+		size = strlen(info->serial);
+		wchar_t serial[64] = {0}, *wc = serial;
+		for (int i = 0; i < size; i++)
+			*wc++ = info->serial[i];
+		*wc = 0;
+		/* Blacklist devices that do not work with 513 byte report length
+		* FIXME: Find a solution to decipher from the device.
+		*/
+		if ((info->vid == 0x1fc9) && (info->pid == 0x0132)) {
+			DEBUG_WARN("Blacklist\n");
+			report_size = 64 + 1;
+		}
+		handle = hid_open(info->vid, info->pid,  (serial[0]) ? serial : NULL);
+		if (!handle) {
+			DEBUG_WARN("hid_open failed\n");
+			return -1;
+		}
+	} else if (type == CMSIS_TYPE_BULK) {
+		DEBUG_INFO("Using bulk transfer\n");
+		usb_handle = libusb_open_device_with_vid_pid(info->libusb_ctx, info->vid, info->pid);
+		if (!usb_handle) {
+			DEBUG_WARN("WARN: libusb_open_device_with_vid_pid() failed\n");
+			return -1;
+		}
+		if (libusb_claim_interface(usb_handle, info->interface_num) < 0) {
+			DEBUG_WARN("WARN: libusb_claim_interface() failed\n");
+			return -1;
+		}
+		in_ep = info->in_ep;
+		out_ep = info->out_ep;
+	}
+	dap_disconnect();
+	size = dap_info(DAP_INFO_FW_VER, buffer, sizeof(buffer));
+	if (size) {
+		DEBUG_INFO("Ver %s, ", buffer);
+		int major = -1, minor = -1, sub = -1;
+		if (sscanf((const char *)buffer, "%d.%d.%d",
+				   &major, &minor, &sub)) {
+			if (sub == -1) {
+				if (minor >= 10) {
+					minor /= 10;
+					sub = 0;
+				}
+			}
+			has_swd_sequence = ((major > 1 ) || ((major > 0 ) && (minor > 1)));
+		}
+	}
+	size = dap_info(DAP_INFO_CAPABILITIES, buffer, sizeof(buffer));
+	dap_caps = buffer[0];
+	DEBUG_INFO("Cap (0x%2x): %s%s%s", dap_caps,
+		   (dap_caps & 1)? "SWD" : "",
+		   ((dap_caps & 3) == 3) ? "/" : "",
+		   (dap_caps & 2)? "JTAG" : "");
+	if (dap_caps & 4)
+		DEBUG_INFO(", SWO_UART");
+	if (dap_caps & 8)
+		DEBUG_INFO(", SWO_MANCHESTER");
+	if (dap_caps & 0x10)
+		DEBUG_INFO(", Atomic Cmds");
+	if (has_swd_sequence)
+		DEBUG_INFO(", DAP_SWD_Sequence");
+	DEBUG_INFO("\n");
+	return 0;
+}
+
+void dap_srst_set_val(bool assert)
+{
+	dap_reset_pin(!assert);
+}
+
+static void dap_dp_abort(ADIv5_DP_t *dp, uint32_t abort)
+{
+	/* DP Write to Reg 0.*/
+	dap_write_reg(dp, ADIV5_DP_ABORT, abort);
+}
+
+static uint32_t dap_dp_error(ADIv5_DP_t *dp)
+{
+	/* Not used for SWD debugging, so no TARGETID switch needed!*/
+	uint32_t ctrlstat = dap_read_reg(dp, ADIV5_DP_CTRLSTAT);
+	uint32_t err = ctrlstat &
+		(ADIV5_DP_CTRLSTAT_STICKYORUN | ADIV5_DP_CTRLSTAT_STICKYCMP |
+		ADIV5_DP_CTRLSTAT_STICKYERR | ADIV5_DP_CTRLSTAT_WDATAERR);
+	uint32_t clr = 0;
+	if(err & ADIV5_DP_CTRLSTAT_STICKYORUN)
+		clr |= ADIV5_DP_ABORT_ORUNERRCLR;
+	if(err & ADIV5_DP_CTRLSTAT_STICKYCMP)
+		clr |= ADIV5_DP_ABORT_STKCMPCLR;
+	if(err & ADIV5_DP_CTRLSTAT_STICKYERR)
+		clr |= ADIV5_DP_ABORT_STKERRCLR;
+	if(err & ADIV5_DP_CTRLSTAT_WDATAERR)
+		clr |= ADIV5_DP_ABORT_WDERRCLR;
+	dap_write_reg(dp, ADIV5_DP_ABORT, clr);
+	dp->fault = 0;
+	return err;
+}
+
+static uint32_t dap_dp_low_access(struct ADIv5_DP_s *dp, uint8_t RnW,
+                               uint16_t addr, uint32_t value)
+{
+	bool APnDP = addr & ADIV5_APnDP;
+	uint32_t res = 0;
+	uint8_t reg = (addr & 0xc) | ((APnDP)? 1 : 0);
+	if (RnW) {
+		res = dap_read_reg(dp, reg);
+	}
+	else {
+		dap_write_reg(dp, reg, value);
+	}
+	return res;
+}
+
+static uint32_t dap_dp_read_reg(ADIv5_DP_t *dp, uint16_t addr)
+{
+	uint32_t res = dap_dp_low_access(dp, ADIV5_LOW_READ, addr, 0);
+	DEBUG_PROBE("dp_read %04x %08" PRIx32 "\n", addr, res);
+	return res;
+}
+
+void dap_exit_function(void)
+{
+	if (type == CMSIS_TYPE_HID) {
+		if (handle) {
+			dap_disconnect();
+			hid_close(handle);
+		}
+	} else if (type == CMSIS_TYPE_BULK) {
+		if (usb_handle) {
+			dap_disconnect();
+			libusb_close(usb_handle);
+		}
+	}
+}
+
+int dbg_get_report_size(void)
+{
+	return report_size;
+}
+
+int dbg_dap_cmd(uint8_t *data, int size, int rsize)
+
+{
+	char cmd = data[0];
+	int res = -1;
+
+	memset(buffer, 0xff, report_size + 1);
+
+	buffer[0] = 0x00; // Report ID??
+	memcpy(&buffer[1], data, rsize);
+
+	DEBUG_WIRE("cmd :   ");
+	for(int i = 0; (i < 32) && (i < rsize + 1); i++)
+		DEBUG_WIRE("%02x.",	buffer[i]);
+	DEBUG_WIRE("\n");
+	if (type == CMSIS_TYPE_HID) {
+		res = hid_write(handle, buffer, 65);
+		if (res < 0) {
+			DEBUG_WARN( "Error: %ls\n", hid_error(handle));
+			exit(-1);
+		}
+		res = hid_read_timeout(handle, buffer, 65, 1000);
+		if (res < 0) {
+			DEBUG_WARN( "debugger read(): %ls\n", hid_error(handle));
+			exit(-1);
+		} else if (res == 0) {
+			DEBUG_WARN( "timeout\n");
+			exit(-1);
+		}
+	} else if (type == CMSIS_TYPE_BULK) {
+		int transferred = 0;
+
+		res = libusb_bulk_transfer(usb_handle, out_ep, data, rsize, &transferred, 500);
+		if (res < 0) {
+			DEBUG_WARN("OUT error: %d\n", res);
+			return res;
+		}
+		res = libusb_bulk_transfer(usb_handle, in_ep, buffer, report_size, &transferred, 500);
+		if (res < 0) {
+			DEBUG_WARN("IN error: %d\n", res);
+			return res;
+		}
+		res = transferred;
+	}
+	DEBUG_WIRE("cmd res:");
+	for(int i = 0; (i < 16) && (i < size + 1); i++)
+		DEBUG_WIRE("%02x.",	buffer[i]);
+	DEBUG_WIRE("\n");
+	if (buffer[0] != cmd) {
+		DEBUG_WARN("cmd %02x not implemented\n", cmd);
+		buffer[1] = 0xff /*DAP_ERROR*/;
+	}
+	if (size)
+		memcpy(data, &buffer[1], (size < res) ? size : res);
+	return res;
+}
+#define ALIGNOF(x) (((x) & 3) == 0 ? ALIGN_WORD :					\
+                    (((x) & 1) == 0 ? ALIGN_HALFWORD : ALIGN_BYTE))
+
+static void dap_mem_read(ADIv5_AP_t *ap, void *dest, uint32_t src, size_t len)
+{
+	if (len == 0)
+		return;
+	enum align align = MIN(ALIGNOF(src), ALIGNOF(len));
+	DEBUG_WIRE("memread @ %" PRIx32 " len %ld, align %d , start: \n",
+		   src, len, align);
+	if (((unsigned)(1 << align)) == len)
+		return dap_read_single(ap, dest, src, align);
+	/* One word transfer for every byte/halfword/word
+	 * Total number of bytes in transfer*/
+	unsigned int max_size = ((dbg_get_report_size() - 6) >> (2 - align)) & ~3;
+	while (len) {
+		dap_ap_mem_access_setup(ap, src, align);
+		/* Calculate length until next access setup is needed */
+		unsigned int blocksize = (src | 0x3ff) - src + 1;
+		if (blocksize > len)
+			blocksize = len;
+		while (blocksize) {
+			unsigned int transfersize = blocksize;
+			if (transfersize > max_size)
+				transfersize = max_size;
+			unsigned int res = dap_read_block(ap, dest, src, transfersize,
+											  align);
+			if (res) {
+			    DEBUG_WIRE("mem_read failed %02x\n", res);
+				ap->dp->fault = 1;
+				return;
+			}
+			blocksize -= transfersize;
+			len       -= transfersize;
+			dest      += transfersize;
+			src       += transfersize;
+		}
+	}
+    DEBUG_WIRE("memread res last data %08" PRIx32 "\n", ((uint32_t*)dest)[-1]);
+}
+
+static void dap_mem_write_sized(
+	ADIv5_AP_t *ap, uint32_t dest, const void *src,
+							size_t len, enum align align)
+{
+	if (len == 0)
+		return;
+	DEBUG_WIRE("memwrite @ %" PRIx32 " len %ld, align %d , %08x start: \n",
+		dest, len, align, *(uint32_t *)src);
+	if (((unsigned)(1 << align)) == len)
+		return dap_write_single(ap, dest, src, align);
+	unsigned int max_size = ((dbg_get_report_size() - 6) >> (2 - align) & ~3);
+	while (len) {
+		dap_ap_mem_access_setup(ap, dest, align);
+		unsigned int blocksize = (dest | 0x3ff) - dest + 1;
+		if (blocksize > len)
+			blocksize = len;
+		while (blocksize) {
+			unsigned int transfersize = blocksize;
+			if (transfersize > max_size)
+				transfersize = max_size;
+			unsigned int res = dap_write_block(ap, dest, src, transfersize,
+											   align);
+			if (res) {
+				DEBUG_WARN("mem_write failed %02x\n", res);
+				ap->dp->fault = 1;
+				return;
+			}
+			blocksize -= transfersize;
+			len       -= transfersize;
+			dest      += transfersize;
+			src       += transfersize;
+		}
+	}
+	DEBUG_WIRE("memwrite done\n");
+}
+
+void dap_adiv5_dp_defaults(ADIv5_DP_t *dp)
+{
+	if ((mode == DAP_CAP_JTAG) && dap_jtag_configure())
+		return;
+	dp->ap_read  = dap_ap_read;
+	dp->ap_write = dap_ap_write;
+	dp->mem_read = dap_mem_read;
+	dp->mem_write_sized =  dap_mem_write_sized;
+}
+
+static void cmsis_dap_jtagtap_reset(void)
+{
+	jtagtap_soft_reset();
+	/* Is there a way to know if TRST is available?*/
+}
+
+static void cmsis_dap_jtagtap_tms_seq(uint32_t MS, int ticks)
+{
+	uint8_t TMS[4] = {MS & 0xff, (MS >> 8) & 0xff, (MS >> 16) & 0xff,
+					  (MS >> 24) & 0xff};
+	dap_jtagtap_tdi_tdo_seq(NULL, false, TMS, NULL, ticks);
+	DEBUG_PROBE("tms_seq DI %08x %d\n", MS, ticks);
+}
+
+static void cmsis_dap_jtagtap_tdi_tdo_seq(uint8_t *DO, const uint8_t final_tms,
+										  const uint8_t *DI, int ticks)
+{
+	dap_jtagtap_tdi_tdo_seq(DO, (final_tms), NULL, DI, ticks);
+	DEBUG_PROBE("jtagtap_tdi_tdo_seq %d, %02x-> %02x\n", ticks, DI[0], (DO)? DO[0] : 0);
+}
+
+static void  cmsis_dap_jtagtap_tdi_seq(const uint8_t final_tms,
+									   const uint8_t *DI, int ticks)
+{
+	dap_jtagtap_tdi_tdo_seq(NULL, (final_tms), NULL, DI, ticks);
+	DEBUG_PROBE("jtagtap_tdi_seq %d, %02x\n", ticks, DI[0]);
+}
+
+static uint8_t cmsis_dap_jtagtap_next(uint8_t dTMS, uint8_t dTDI)
+{
+	uint8_t tdo[1];
+	dap_jtagtap_tdi_tdo_seq(tdo, false, &dTMS, &dTDI, 1);
+	DEBUG_PROBE("next tms %02x tdi %02x tdo %02x\n", dTMS, dTDI, tdo[0]);
+	return (tdo[0] & 1);
+}
+
+int cmsis_dap_jtagtap_init(jtag_proc_t *jtag_proc)
+{
+	DEBUG_PROBE("jtap_init\n");
+	if (!(dap_caps & DAP_CAP_JTAG))
+		return -1;
+	mode =  DAP_CAP_JTAG;
+	dap_disconnect();
+	dap_connect(true);
+	dap_reset_link(true);
+	jtag_proc->jtagtap_reset       = cmsis_dap_jtagtap_reset;
+	jtag_proc->jtagtap_next        = cmsis_dap_jtagtap_next;
+	jtag_proc->jtagtap_tms_seq     = cmsis_dap_jtagtap_tms_seq;
+	jtag_proc->jtagtap_tdi_tdo_seq = cmsis_dap_jtagtap_tdi_tdo_seq;
+	jtag_proc->jtagtap_tdi_seq     = cmsis_dap_jtagtap_tdi_seq;
+	return 0;
+}
+
+int dap_jtag_dp_init(ADIv5_DP_t *dp)
+{
+	dp->dp_read = dap_dp_read_reg;
+	dp->error = dap_dp_error;
+	dp->low_access = dap_dp_low_access;
+	dp->abort = dap_dp_abort;
+
+	return true;
+}
+
+#define SWD_SEQUENCE_IN 0x80
+#define DAP_SWD_SEQUENCE 0x1d
+static bool dap_dp_low_write(ADIv5_DP_t *dp, uint16_t addr, const uint32_t data)
+{
+	DEBUG_PROBE("dap_dp_low_write %08" PRIx32 "\n", data);
+	(void)dp;
+	unsigned int paket_request = make_packet_request(ADIV5_LOW_WRITE, addr);
+	uint8_t buf[32] = {
+		DAP_SWD_SEQUENCE,
+		5,
+		8,
+		paket_request,
+		4 + SWD_SEQUENCE_IN,  /* one turn-around + read 3 bit ACK */
+		1,                    /* one bit turn around to drive SWDIO */
+		0,
+		32,                   /* write 32 bit data */
+		(data >>  0) & 0xff,
+		(data >>  8) & 0xff,
+		(data >> 16) & 0xff,
+		(data >> 24) & 0xff,
+		1,                    /* write parity biT */
+		__builtin_parity(data)
+	};
+	dbg_dap_cmd(buf, sizeof(buf), 14);
+	if (buf[0])
+		DEBUG_WARN("dap_dp_low_write failed\n");
+	uint32_t ack = (buf[1] >> 1) & 7;
+	return (ack != SWDP_ACK_OK);
+}
+
+int dap_swdptap_init(ADIv5_DP_t *dp)
+{
+	if (!(dap_caps & DAP_CAP_SWD))
+		return 1;
+	mode =  DAP_CAP_SWD;
+	dap_transfer_configure(2, 128, 128);
+	dap_swd_configure(0);
+	dap_connect(false);
+	dap_led(0, 1);
+	dap_reset_link(false);
+	if ((has_swd_sequence)  && dap_sequence_test()) {
+		/* DAP_SWD_SEQUENCE does not do auto turnaround, use own!*/
+		dp->dp_low_write = dap_dp_low_write;
+	} else {
+		dp->dp_low_write = NULL;
+	}
+	dp->seq_out = dap_swdptap_seq_out;
+	dp->dp_read = dap_dp_read_reg;
+	/* For error() use the TARGETID switching firmware_swdp_error */
+	dp->low_access = dap_dp_low_access;
+	dp->abort = dap_dp_abort;
+	return 0;
+}

src/platforms/hosted/cmsis_dap.h

@@ -0,0 +1,56 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2019 - 2021 Uwe Bonnes(bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.	 If not, see <http://www.gnu.org/licenses/>.
+ */
+#if !defined(__CMSIS_DAP_H_)
+#define __CMSIS_DAP_H_
+
+#include "adiv5.h"
+#include "cl_utils.h"
+
+#if defined(CMSIS_DAP)
+int dap_init(bmp_info_t *info);
+void dap_exit_function(void);
+void dap_adiv5_dp_defaults(ADIv5_DP_t *dp);
+int cmsis_dap_jtagtap_init(jtag_proc_t *jtag_proc);
+int dap_swdptap_init(ADIv5_DP_t *dp);
+int dap_jtag_dp_init(ADIv5_DP_t *dp);
+uint32_t dap_swj_clock(uint32_t clock);
+void dap_swd_configure(uint8_t cfg);
+void dap_srst_set_val(bool assert);
+#else
+int dap_init(bmp_info_t *info)
+{
+	DEBUG_WARN("FATAL: Missing hidapi-libusb\n");
+	(void)info;
+	return -1;
+}
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-parameter"
+uint32_t dap_swj_clock(uint32_t clock) {return 0;}
+void dap_exit_function(void) {};
+void dap_adiv5_dp_defaults(ADIv5_DP_t *dp) {};
+int cmsis_dap_jtagtap_init(jtag_proc_t *jtag_proc) {return -1;}
+int dap_swdptap_init(ADIv5_DP_t *dp) {return -1;}
+int dap_jtag_dp_init(ADIv5_DP_t *dp) {return -1;}
+void dap_swd_configure(uint8_t cfg) {};
+void dap_srst_set_val(bool assert) {};
+# pragma GCC diagnostic pop
+
+#endif
+
+#endif

src/platforms/hosted/dap.c

@@ -0,0 +1,849 @@
+/*
+ * Copyright (c) 2013-2015, Alex Taradov <alex@taradov.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Modified for Blackmagic Probe
+ * Copyright (c) 2020-21 Uwe Bonnes bon@elektron.ikp.physik.tu-darmstadt.de
+ */
+
+/*- Includes ----------------------------------------------------------------*/
+#include <general.h>
+#include "exception.h"
+#include "dap.h"
+#include "jtag_scan.h"
+
+/*- Definitions -------------------------------------------------------------*/
+enum
+{
+	ID_DAP_INFO               = 0x00,
+	ID_DAP_LED                = 0x01,
+	ID_DAP_CONNECT            = 0x02,
+	ID_DAP_DISCONNECT         = 0x03,
+	ID_DAP_TRANSFER_CONFIGURE = 0x04,
+	ID_DAP_TRANSFER           = 0x05,
+	ID_DAP_TRANSFER_BLOCK     = 0x06,
+	ID_DAP_TRANSFER_ABORT     = 0x07,
+	ID_DAP_WRITE_ABORT        = 0x08,
+	ID_DAP_DELAY              = 0x09,
+	ID_DAP_RESET_TARGET       = 0x0a,
+	ID_DAP_SWJ_PINS           = 0x10,
+	ID_DAP_SWJ_CLOCK          = 0x11,
+	ID_DAP_SWJ_SEQUENCE       = 0x12,
+	ID_DAP_SWD_CONFIGURE      = 0x13,
+	ID_DAP_JTAG_SEQUENCE      = 0x14,
+	ID_DAP_JTAG_CONFIGURE     = 0x15,
+	ID_DAP_JTAG_IDCODE        = 0x16,
+	ID_DAP_SWD_SEQUENCE       = 0x1D,
+};
+
+enum
+{
+	DAP_TRANSFER_APnDP        = 1 << 0,
+	DAP_TRANSFER_RnW          = 1 << 1,
+	DAP_TRANSFER_A2           = 1 << 2,
+	DAP_TRANSFER_A3           = 1 << 3,
+	DAP_TRANSFER_MATCH_VALUE  = 1 << 4,
+	DAP_TRANSFER_MATCH_MASK   = 1 << 5,
+};
+
+enum
+{
+	DAP_TRANSFER_INVALID      = 0,
+	DAP_TRANSFER_OK           = 1 << 0,
+	DAP_TRANSFER_WAIT         = 1 << 1,
+	DAP_TRANSFER_FAULT        = 1 << 2,
+	DAP_TRANSFER_ERROR        = 1 << 3,
+	DAP_TRANSFER_MISMATCH     = 1 << 4,
+	DAP_TRANSFER_NO_TARGET    = 7,
+};
+
+enum
+{
+	DAP_SWJ_SWCLK_TCK = 1 << 0,
+	DAP_SWJ_SWDIO_TMS = 1 << 1,
+	DAP_SWJ_TDI       = 1 << 2,
+	DAP_SWJ_TDO       = 1 << 3,
+	DAP_SWJ_nTRST     = 1 << 5,
+	DAP_SWJ_nRESET    = 1 << 7,
+};
+
+enum
+{
+	DAP_OK    = 0x00,
+	DAP_ERROR = 0xff,
+};
+
+enum
+{
+	DAP_JTAG_TMS         = 1 << 6,
+	DAP_JTAG_TDO_CAPTURE = 1 << 7,
+};
+
+enum
+{
+	SWD_DP_R_IDCODE    = 0x00,
+	SWD_DP_W_ABORT     = 0x00,
+	SWD_DP_R_CTRL_STAT = 0x04,
+	SWD_DP_W_CTRL_STAT = 0x04, // When CTRLSEL == 0
+	SWD_DP_W_WCR       = 0x04, // When CTRLSEL == 1
+	SWD_DP_R_RESEND    = 0x08,
+	SWD_DP_W_SELECT    = 0x08,
+	SWD_DP_R_RDBUFF    = 0x0c,
+};
+
+enum
+{
+	SWD_AP_CSW  = 0x00 | DAP_TRANSFER_APnDP,
+	SWD_AP_TAR  = 0x04 | DAP_TRANSFER_APnDP,
+	SWD_AP_DRW  = 0x0c | DAP_TRANSFER_APnDP,
+
+	SWD_AP_DB0  = 0x00 | DAP_TRANSFER_APnDP, // 0x10
+	SWD_AP_DB1  = 0x04 | DAP_TRANSFER_APnDP, // 0x14
+	SWD_AP_DB2  = 0x08 | DAP_TRANSFER_APnDP, // 0x18
+	SWD_AP_DB3  = 0x0c | DAP_TRANSFER_APnDP, // 0x1c
+
+	SWD_AP_CFG  = 0x04 | DAP_TRANSFER_APnDP, // 0xf4
+	SWD_AP_BASE = 0x08 | DAP_TRANSFER_APnDP, // 0xf8
+	SWD_AP_IDR  = 0x0c | DAP_TRANSFER_APnDP, // 0xfc
+};
+
+#define DP_ABORT_DAPABORT      (1 << 0)
+#define DP_ABORT_STKCMPCLR     (1 << 1)
+#define DP_ABORT_STKERRCLR     (1 << 2)
+#define DP_ABORT_WDERRCLR      (1 << 3)
+#define DP_ABORT_ORUNERRCLR    (1 << 4)
+
+#define DP_CST_ORUNDETECT      (1 << 0)
+#define DP_CST_STICKYORUN      (1 << 1)
+#define DP_CST_TRNMODE_NORMAL  (0 << 2)
+#define DP_CST_TRNMODE_VERIFY  (1 << 2)
+#define DP_CST_TRNMODE_COMPARE (2 << 2)
+#define DP_CST_STICKYCMP       (1 << 4)
+#define DP_CST_STICKYERR       (1 << 5)
+#define DP_CST_READOK          (1 << 6)
+#define DP_CST_WDATAERR        (1 << 7)
+#define DP_CST_MASKLANE(x)     ((x) << 8)
+#define DP_CST_TRNCNT(x)       ((x) << 12)
+#define DP_CST_CDBGRSTREQ      (1 << 26)
+#define DP_CST_CDBGRSTACK      (1 << 27)
+#define DP_CST_CDBGPWRUPREQ    (1 << 28)
+#define DP_CST_CDBGPWRUPACK    (1 << 29)
+#define DP_CST_CSYSPWRUPREQ    (1 << 30)
+#define DP_CST_CSYSPWRUPACK    (1 << 31)
+
+#define DP_SELECT_CTRLSEL      (1 << 0)
+#define DP_SELECT_APBANKSEL(x) ((x) << 4)
+#define DP_SELECT_APSEL(x)     ((x) << 24)
+
+#define AP_CSW_SIZE_BYTE       (0 << 0)
+#define AP_CSW_SIZE_HALF       (1 << 0)
+#define AP_CSW_SIZE_WORD       (2 << 0)
+#define AP_CSW_ADDRINC_OFF     (0 << 4)
+#define AP_CSW_ADDRINC_SINGLE  (1 << 4)
+#define AP_CSW_ADDRINC_PACKED  (2 << 4)
+#define AP_CSW_DEVICEEN        (1 << 6)
+#define AP_CSW_TRINPROG        (1 << 7)
+#define AP_CSW_SPIDEN          (1 << 23)
+#define AP_CSW_PROT(x)         ((x) << 24)
+#define AP_CSW_DBGSWENABLE     (1 << 31)
+
+/*- Implementations ---------------------------------------------------------*/
+
+//-----------------------------------------------------------------------------
+void dap_led(int index, int state)
+{
+	uint8_t buf[3];
+
+	buf[0] = ID_DAP_LED;
+	buf[1] = index;
+	buf[2] = state;
+	dbg_dap_cmd(buf, sizeof(buf), 3);
+}
+
+//-----------------------------------------------------------------------------
+void dap_connect(bool jtag)
+{
+	uint8_t buf[2];
+
+	buf[0] = ID_DAP_CONNECT;
+	buf[1] = (jtag) ? DAP_CAP_JTAG : DAP_CAP_SWD;
+	dbg_dap_cmd(buf, sizeof(buf), 2);
+
+}
+
+//-----------------------------------------------------------------------------
+void dap_disconnect(void)
+{
+	uint8_t buf[65];
+
+	buf[0] = ID_DAP_DISCONNECT;
+	dbg_dap_cmd(buf, sizeof(buf), 1);
+}
+
+static uint32_t swj_clock;
+/* Set/Get JTAG/SWD clock frequency
+ *
+ * With clock == 0, return last set value.
+ */
+uint32_t dap_swj_clock(uint32_t clock)
+{
+	if (clock == 0)
+		return swj_clock;
+	uint8_t buf[5];
+	buf[0] = ID_DAP_SWJ_CLOCK;
+	buf[1] = clock & 0xff;
+	buf[2] = (clock >> 8) & 0xff;
+	buf[3] = (clock >> 16) & 0xff;
+	buf[4] = (clock >> 24) & 0xff;
+	dbg_dap_cmd(buf, sizeof(buf), 5);
+	if (buf[0])
+		DEBUG_WARN("dap_swj_clock failed\n");
+	else
+		swj_clock = clock;
+	return swj_clock;
+}
+
+//-----------------------------------------------------------------------------
+void dap_transfer_configure(uint8_t idle, uint16_t count, uint16_t retry)
+{
+	uint8_t buf[6];
+
+	buf[0] = ID_DAP_TRANSFER_CONFIGURE;
+	buf[1] = idle;
+	buf[2] = count & 0xff;
+	buf[3] = (count >> 8) & 0xff;
+	buf[4] = retry & 0xff;
+	buf[5] = (retry >> 8) & 0xff;
+	dbg_dap_cmd(buf, sizeof(buf), 6);
+}
+
+//-----------------------------------------------------------------------------
+void dap_swd_configure(uint8_t cfg)
+{
+	uint8_t buf[2];
+
+	buf[0] = ID_DAP_SWD_CONFIGURE;
+	buf[1] = cfg;
+	dbg_dap_cmd(buf, sizeof(buf), 2);
+}
+
+//-----------------------------------------------------------------------------
+int dap_info(int info, uint8_t *data, int size)
+{
+	uint8_t buf[256];
+	int rsize;
+
+	buf[0] = ID_DAP_INFO;
+	buf[1] = info;
+	dbg_dap_cmd(buf, sizeof(buf), 2);
+
+	rsize = (size < buf[0]) ? size : buf[0];
+	memcpy(data, &buf[1], rsize);
+
+	if (rsize < size)
+		data[rsize] = 0;
+
+	return rsize;
+}
+
+void dap_reset_pin(int state)
+{
+	uint8_t buf[7];
+
+	buf[0] = ID_DAP_SWJ_PINS;
+	buf[1] = state ? DAP_SWJ_nRESET : 0; // Value
+	buf[2] = DAP_SWJ_nRESET; // Select
+	buf[3] = 0; // Wait
+	buf[4] = 0; // Wait
+	buf[5] = 0; // Wait
+	buf[6] = 0; // Wait
+	dbg_dap_cmd(buf, sizeof(buf), 7);
+}
+
+void dap_trst_reset(void)
+{
+	uint8_t buf[7];
+
+	buf[0] = ID_DAP_SWJ_PINS;
+	buf[1] = DAP_SWJ_nTRST;
+	buf[2] = 0;
+	buf[3] = 0;
+	buf[4] = 4; /* ~ 1 ms*/
+	buf[5] = 0;
+	buf[6] = 0;
+	dbg_dap_cmd(buf, sizeof(buf), 7);
+
+	buf[0] = ID_DAP_SWJ_PINS;
+	buf[1] = DAP_SWJ_nTRST;
+	buf[2] = DAP_SWJ_nTRST;
+	dbg_dap_cmd(buf, sizeof(buf), 7);
+}
+
+static void dap_line_reset(void)
+{
+	uint8_t buf[] = {
+		ID_DAP_SWJ_SEQUENCE,
+		64,
+		0xff,
+		0xff,
+		0xff,
+		0xff,
+		0xff,
+		0xff,
+		0xff,
+		0
+	};
+	dbg_dap_cmd(buf, sizeof(buf), 10);
+	if (buf[0])
+		DEBUG_WARN("line reset failed\n");
+}
+
+static uint32_t wait_word(uint8_t *buf, int size, int len, uint8_t *dp_fault)
+{
+	uint8_t cmd_copy[len];
+	memcpy(cmd_copy, buf, len);
+	do {
+		memcpy(buf, cmd_copy, len);
+		dbg_dap_cmd(buf, size, len);
+		if (buf[1] < DAP_TRANSFER_WAIT)
+			break;
+	} while (buf[1] == DAP_TRANSFER_WAIT);
+
+	if(buf[1] == SWDP_ACK_FAULT) {
+		*dp_fault = 1;
+		return 0;
+	}
+
+	if(buf[1] != SWDP_ACK_OK)
+		raise_exception(EXCEPTION_ERROR, "SWDP invalid ACK");
+	uint32_t res =
+		((uint32_t)buf[5] << 24) | ((uint32_t)buf[4] << 16) |
+		((uint32_t)buf[3] << 8) | (uint32_t)buf[2];
+	return res;
+}
+
+//-----------------------------------------------------------------------------
+uint32_t dap_read_reg(ADIv5_DP_t *dp, uint8_t reg)
+{
+	uint8_t buf[8];
+	uint8_t dap_index = 0;
+	dap_index = dp->dp_jd_index;
+	buf[0] = ID_DAP_TRANSFER;
+	buf[1] = dap_index;
+	buf[2] = 0x01; // Request size
+	buf[3] = reg | DAP_TRANSFER_RnW;
+	uint32_t res = wait_word(buf, 8, 4, &dp->fault);
+	DEBUG_WIRE("\tdap_read_reg %02x %08x\n", reg, res);
+	return res;
+}
+
+//-----------------------------------------------------------------------------
+void dap_write_reg(ADIv5_DP_t *dp, uint8_t reg, uint32_t data)
+{
+	uint8_t buf[8];
+	DEBUG_PROBE("\tdap_write_reg %02x %08x\n", reg, data);
+
+	buf[0] = ID_DAP_TRANSFER;
+	uint8_t dap_index = 0;
+	dap_index = dp->dp_jd_index;
+	buf[1] = dap_index;
+	buf[2] = 0x01; // Request size
+	buf[3] = reg & ~DAP_TRANSFER_RnW;;
+	buf[4] = data & 0xff;
+	buf[5] = (data >> 8) & 0xff;
+	buf[6] = (data >> 16) & 0xff;
+	buf[7] = (data >> 24) & 0xff;
+	uint8_t cmd_copy[8];
+	memcpy(cmd_copy, buf, 8);
+	do {
+		memcpy(buf, cmd_copy, 8);
+		dbg_dap_cmd(buf, sizeof(buf), 8);
+		if (buf[1] < DAP_TRANSFER_WAIT)
+			break;
+	} while (buf[1] == DAP_TRANSFER_WAIT);
+
+	if (buf[1] > DAP_TRANSFER_WAIT) {
+		DEBUG_WARN("dap_write_reg %02x data %08x:fault\n", reg, data);
+		dp->fault = 1;
+	}
+	if (buf[1] == DAP_TRANSFER_ERROR) {
+		DEBUG_WARN("dap_write_reg %02x data %08x: protocoll error\n",
+					reg, data);
+		dap_line_reset();
+	}
+}
+
+unsigned int dap_read_block(ADIv5_AP_t *ap, void *dest, uint32_t src,
+							size_t len, enum align align)
+{
+	uint8_t buf[1024];
+	unsigned int sz = len >> align;
+	uint8_t dap_index = 0;
+	dap_index = ap->dp->dp_jd_index;
+    buf[0] = ID_DAP_TRANSFER_BLOCK;
+    buf[1] = dap_index;
+    buf[2] =  sz & 0xff;
+    buf[3] = (sz >> 8) & 0xff;
+    buf[4] = SWD_AP_DRW | DAP_TRANSFER_RnW;
+    dbg_dap_cmd(buf, 1023, 5);
+	unsigned int transferred = buf[0] + (buf[1] << 8);
+	if (buf[2] >= DAP_TRANSFER_FAULT) {
+		DEBUG_WARN("dap_read_block @ %08" PRIx32 " fault -> line reset\n", src);
+		dap_line_reset();
+	}
+	if (sz != transferred) {
+		return 1;
+	} else if (align > ALIGN_HALFWORD) {
+		memcpy(dest, &buf[3], len);
+	} else {
+		uint32_t *p = (uint32_t *)&buf[3];
+		while(sz) {
+			dest = extract(dest, src, *p, align);
+			p++;
+			src  += (1 << align);
+			sz--;
+		}
+	}
+	return (buf[2] > DAP_TRANSFER_WAIT) ? 1 : 0;
+}
+
+unsigned int dap_write_block(ADIv5_AP_t *ap, uint32_t dest, const void *src,
+							 size_t len, enum align align)
+{
+	uint8_t buf[1024];
+	unsigned int sz = len >> align;
+	uint8_t dap_index = 0;
+	dap_index = ap->dp->dp_jd_index;
+    buf[0] = ID_DAP_TRANSFER_BLOCK;
+    buf[1] = dap_index;
+    buf[2] =  sz & 0xff;
+    buf[3] = (sz >> 8) & 0xff;
+    buf[4] = SWD_AP_DRW;
+	if (align > ALIGN_HALFWORD) {
+		memcpy(&buf[5], src, len);
+	} else {
+		unsigned int size = len;
+		uint32_t *p = (uint32_t *)&buf[5];
+		while (size) {
+			uint32_t tmp = 0;
+			/* Pack data into correct data lane */
+			if (align == ALIGN_BYTE) {
+				tmp = ((uint32_t)*(uint8_t  *)src) << ((dest & 3) << 3);
+			} else {
+				tmp = ((uint32_t)*(uint16_t *)src) << ((dest & 2) << 3);
+			}
+			src = src + (1 << align);
+			dest += (1 << align);
+			size--;
+			*p++ = tmp;
+		}
+	}
+	dbg_dap_cmd(buf, 1023, 5 + (sz << 2));
+	if (buf[2] > DAP_TRANSFER_FAULT) {
+		dap_line_reset();
+	}
+	return (buf[2] > DAP_TRANSFER_WAIT) ? 1 : 0;
+}
+
+//-----------------------------------------------------------------------------
+void dap_reset_link(bool jtag)
+{
+	uint8_t buf[128], *p = buf;
+
+	//-------------
+	*p++ = ID_DAP_SWJ_SEQUENCE;
+	p++;
+	*p++ = 0xff;
+	*p++ = 0xff;
+	*p++ = 0xff;
+	*p++ = 0xff;
+	*p++ = 0xff;
+	*p++ = 0xff;
+	*p++ = 0xff;
+	if (jtag) {
+		*p++ = 0x3c;
+		*p++ = 0xe7;
+		*p++ = 0x1f;
+		buf[1] = ((p - &buf[2]) * 8) - 2;
+	} else {
+		*p++ = 0x9e;
+		*p++ = 0xe7;
+		*p++ = 0xff;
+		*p++ = 0xff;
+		*p++ = 0xff;
+		*p++ = 0xff;
+		*p++ = 0xff;
+		*p++ = 0xff;
+		*p++ = 0xff;
+		*p++ = 0x00;
+		buf[1] = (p - &buf[2]) * 8;
+	}
+	dbg_dap_cmd(buf, sizeof(buf), p - buf);
+
+	if (!jtag) {
+		//-------------
+		buf[0] = ID_DAP_TRANSFER;
+		buf[1] = 0; // DAP index
+		buf[2] = 1; // Request size
+		buf[3] = SWD_DP_R_IDCODE | DAP_TRANSFER_RnW;
+		dbg_dap_cmd(buf, sizeof(buf), 4);
+	}
+}
+
+//-----------------------------------------------------------------------------
+uint32_t dap_read_idcode(ADIv5_DP_t *dp)
+{
+	return dap_read_reg(dp, SWD_DP_R_IDCODE);
+}
+
+static uint8_t *mem_access_setup(ADIv5_AP_t *ap, uint8_t *p,
+								 uint32_t addr, enum align align)
+{
+	uint32_t csw = ap->csw | ADIV5_AP_CSW_ADDRINC_SINGLE;
+	switch (align) {
+	case ALIGN_BYTE:
+		csw |= ADIV5_AP_CSW_SIZE_BYTE;
+		break;
+	case ALIGN_HALFWORD:
+		csw |= ADIV5_AP_CSW_SIZE_HALFWORD;
+		break;
+	case ALIGN_DWORD:
+	case ALIGN_WORD:
+		csw |= ADIV5_AP_CSW_SIZE_WORD;
+		break;
+	}
+	uint8_t dap_index = 0;
+	dap_index = ap->dp->dp_jd_index;
+	*p++ = ID_DAP_TRANSFER;
+	*p++ = dap_index;
+	*p++ = 3; /* Nr transfers */
+	*p++ = SWD_DP_W_SELECT;
+	*p++ = ADIV5_AP_CSW & 0xF0;
+	*p++ = 0;
+	*p++ = 0;
+	*p++ = ap->apsel & 0xff;
+	*p++ = SWD_AP_CSW;
+	*p++ = (csw >>  0) & 0xff;
+	*p++ = (csw >>  8) & 0xff;
+	*p++ = (csw >> 16) & 0xff;
+	*p++ = (csw >> 24) & 0xff;
+	*p++ = SWD_AP_TAR ;
+	*p++ = (addr >>  0) & 0xff;
+	*p++ = (addr >>  8) & 0xff;
+	*p++ = (addr >> 16) & 0xff;
+	*p++ = (addr >> 24) & 0xff;
+	return p;
+}
+
+void dap_ap_mem_access_setup(ADIv5_AP_t *ap, uint32_t addr, enum align align)
+{
+	uint8_t buf[63];
+	uint8_t *p = mem_access_setup(ap, buf, addr, align);
+	dbg_dap_cmd(buf, sizeof(buf), p - buf);
+}
+
+uint32_t dap_ap_read(ADIv5_AP_t *ap, uint16_t addr)
+{
+	DEBUG_PROBE("dap_ap_read_start addr %x\n", addr);
+	uint8_t buf[63], *p = buf;
+	buf[0] = ID_DAP_TRANSFER;
+	uint8_t dap_index = 0;
+	dap_index = ap->dp->dp_jd_index;
+	*p++ = ID_DAP_TRANSFER;
+	*p++ = dap_index;
+	*p++ = 2; /* Nr transfers */
+	*p++ = SWD_DP_W_SELECT;
+	*p++ = (addr & 0xF0);
+	*p++ = 0;
+	*p++ = 0;
+	*p++ = ap->apsel & 0xff;
+	*p++ = (addr & 0x0c) | DAP_TRANSFER_RnW  |
+		((addr & 0x100) ?  DAP_TRANSFER_APnDP : 0);
+	uint32_t res = wait_word(buf, 63, p - buf, &ap->dp->fault);
+	if ((buf[0] != 2) || (buf[1] != 1)) {
+		DEBUG_WARN("dap_ap_read error %x\n", buf[1]);
+	}
+	return res;
+}
+
+void dap_ap_write(ADIv5_AP_t *ap, uint16_t addr, uint32_t value)
+{
+	DEBUG_PROBE("dap_ap_write addr %04x value %08x\n", addr, value);
+	uint8_t buf[63], *p = buf;
+	uint8_t dap_index = 0;
+	dap_index = ap->dp->dp_jd_index;
+	*p++ = ID_DAP_TRANSFER;
+	*p++ = dap_index;
+	*p++ = 2; /* Nr transfers */
+	*p++ = SWD_DP_W_SELECT;
+	*p++ = (addr & 0xF0);
+	*p++ = 0;
+	*p++ = 0;
+	*p++ = ap->apsel & 0xff;
+	*p++ = (addr & 0x0c) | ((addr & 0x100) ?  DAP_TRANSFER_APnDP : 0);
+	*p++ = (value >>  0) & 0xff;
+	*p++ = (value >>  8) & 0xff;
+	*p++ = (value >> 16) & 0xff;
+	*p++ = (value >> 24) & 0xff;
+	dbg_dap_cmd(buf, sizeof(buf), p - buf);
+	if ((buf[0] != 2) || (buf[1] != 1)) {
+		DEBUG_WARN("dap_ap_write error %x\n", buf[1]);
+	}
+}
+
+void dap_read_single(ADIv5_AP_t *ap, void *dest, uint32_t src, enum align align)
+{
+	uint8_t buf[63];
+	uint8_t *p = mem_access_setup(ap, buf, src, align);
+	*p++ = SWD_AP_DRW | DAP_TRANSFER_RnW;
+	*p++ = SWD_DP_R_RDBUFF | DAP_TRANSFER_RnW;
+	buf[2] = 5;
+	uint32_t tmp = wait_word(buf, 63, p - buf, &ap->dp->fault);
+	dest = extract(dest, src, tmp, align);
+}
+
+void dap_write_single(ADIv5_AP_t *ap, uint32_t dest, const void *src,
+					  enum align align)
+{
+	uint8_t buf[63];
+	uint8_t *p = mem_access_setup(ap, buf, dest, align);
+	*p++ = SWD_AP_DRW;
+	uint32_t tmp = 0;
+	/* Pack data into correct data lane */
+	switch (align) {
+	case ALIGN_BYTE:
+		tmp = ((uint32_t)*(uint8_t *)src) << ((dest & 3) << 3);
+		break;
+	case ALIGN_HALFWORD:
+		tmp = ((uint32_t)*(uint16_t *)src) << ((dest & 2) << 3);
+		break;
+	case ALIGN_DWORD:
+	case ALIGN_WORD:
+		tmp = *(uint32_t *)src;
+		break;
+	}
+	*p++ = (tmp >>  0) & 0xff;
+	*p++ = (tmp >>  8) & 0xff;
+	*p++ = (tmp >> 16) & 0xff;
+	*p++ = (tmp >> 24) & 0xff;
+	buf[2] = 4;
+	dbg_dap_cmd(buf, sizeof(buf), p - buf);
+}
+
+void dap_jtagtap_tdi_tdo_seq(uint8_t *DO, bool final_tms, const uint8_t *TMS,
+							 const uint8_t *DI, int ticks)
+{
+	DEBUG_PROBE("dap_jtagtap_tdi_tdo_seq %s %d ticks\n",
+				(final_tms) ? "final" : "", ticks);
+	uint8_t buf[64];
+	const uint8_t *din = DI;
+	uint8_t *dout = DO;
+	if (!TMS) {
+		int last_byte = last_byte = (ticks - 1) >> 3;
+		int last_bit = (ticks - 1) & 7;
+		if (final_tms)
+			ticks --;
+		while (ticks) {
+			int transfers = ticks;
+			if (transfers > 64)
+				transfers = 64;
+			uint8_t *p = buf;
+			*p++ = ID_DAP_JTAG_SEQUENCE;
+			*p++ = 1;
+			*p++ = ((transfers == 64) ? 0 : transfers) |
+				((DO) ? DAP_JTAG_TDO_CAPTURE : 0);
+			int n_di_bytes = (transfers + 7) >> 3;
+			if (din) {
+				p = memcpy(p, din, n_di_bytes);
+				din += n_di_bytes;
+			} else {
+				p = memset(p, 0xff, n_di_bytes);
+			}
+			p += n_di_bytes;
+			dbg_dap_cmd(buf, sizeof(buf), p - buf);
+			if (buf[0] != DAP_OK)
+				DEBUG_WARN("dap_jtagtap_tdi_tdo_seq failed %02x\n", buf[0]);
+			if (dout) {
+				memcpy(dout, &buf[1], (transfers + 7) >> 3);
+				dout += (transfers + 7) >> 3;
+			}
+			ticks -= transfers;
+		}
+		if (final_tms) {
+			uint8_t *p = buf;
+			*p++ = ID_DAP_JTAG_SEQUENCE;
+			*p++ = 1;
+			*p++ = 1 | ((dout) ? DAP_JTAG_TDO_CAPTURE : 0) | DAP_JTAG_TMS;
+			if (din) {
+				*p++ = ((DI[last_byte] & (1 << last_bit)) ? 1 : 0);
+			} else {
+				*p++ = 0;
+			}
+			dbg_dap_cmd(buf, sizeof(buf), p - buf);
+			if (buf[0] == DAP_ERROR)
+				DEBUG_WARN("dap_jtagtap_tdi_tdo_seq failed %02x\n", buf[0]);
+			if (dout) {
+				if (buf[1] & 1)
+					DO[last_byte] |= (1 << last_bit);
+				else
+					DO[last_byte] &= ~(1 << last_bit);
+			}
+		}
+	} else {
+		while(ticks) {
+			uint8_t *p = buf;
+			int transfers = ticks;
+			if (transfers > 64)
+				transfers = 64;
+			p = buf;
+			*p++ = ID_DAP_JTAG_SEQUENCE;
+			*p++ = transfers;
+			for (int i = 0; i < transfers; i++) {
+				*p++ = 1 | ((DO) ? DAP_JTAG_TDO_CAPTURE : 0) |
+					((TMS[i >> 3] & (1 << (i & 7))) ? DAP_JTAG_TMS : 0);
+				if (DI)
+					*p++ = (DI[i >> 3] & (1 << (i & 7))) ? 1 : 0;
+				else
+					*p++ = 1;
+			}
+			dbg_dap_cmd(buf, sizeof(buf), p - buf);
+			if (buf[0] == DAP_ERROR)
+				DEBUG_WARN("dap_jtagtap_tdi_tdo_seq failed %02x\n", buf[0]);
+			if (DO) {
+				for (int i = 0; i < transfers; i++) {
+					if (buf[i + 1])
+						DO[i >> 3] |= (1 << (i & 7));
+					else
+						DO[i >> 3] &= ~(1 << (i & 7));
+				}
+			}
+			ticks -= transfers;
+		}
+	}
+}
+
+int dap_jtag_configure(void)
+{
+	uint8_t buf[64], *p = &buf[2];
+	int i = 0;
+	for (; i < jtag_dev_count; i++) {
+		struct jtag_dev_s *jtag_dev = &jtag_devs[i];
+		*p++ = jtag_dev->ir_len;
+		DEBUG_PROBE("irlen %d\n", jtag_dev->ir_len);
+	}
+	if ((!i || i >= JTAG_MAX_DEVS))
+		return -1;
+	buf[0] = 0x15;
+	buf[1] = i;
+	dbg_dap_cmd(buf, sizeof(buf), p - buf);
+	if (buf[0] != DAP_OK)
+		DEBUG_WARN("dap_jtag_configure Failed %02x\n", buf[0]);
+	return 0;
+}
+
+void dap_swdptap_seq_out(uint32_t MS, int ticks)
+{
+	uint8_t buf[64] = {
+		ID_DAP_SWJ_SEQUENCE,
+		ticks,
+		(MS >>  0) & 0xff,
+		(MS >>  8) & 0xff,
+		(MS >> 16) & 0xff,
+		(MS >> 24) & 0xff
+	};
+	dbg_dap_cmd(buf, 64, 2 + ((ticks +7) >> 3));
+	if (buf[0])
+		DEBUG_WARN("dap_swdptap_seq_out error\n");
+}
+
+void dap_swdptap_seq_out_parity(uint32_t MS, int ticks)
+{
+	uint8_t buf[] = {
+		ID_DAP_SWJ_SEQUENCE,
+		ticks + 1,
+		(MS >>  0) & 0xff,
+		(MS >>  8) & 0xff,
+		(MS >> 16) & 0xff,
+		(MS >> 24) & 0xff,
+		__builtin_parity(MS) & 1
+	};
+	dbg_dap_cmd(buf, 1, sizeof(buf));
+	if (buf[0])
+		DEBUG_WARN("dap_swdptap_seq_out error\n");
+}
+
+bool dap_sequence_test(void)
+{
+	uint8_t buf[4] = {
+		ID_DAP_SWD_SEQUENCE,
+		0x1,
+		0x81, /* Read one bit */
+		0     /* one idle cycle */
+	};
+	dbg_dap_cmd(buf, sizeof(buf), 3);
+	return (buf[0] == DAP_OK);
+}
+
+#define SWD_SEQUENCE_IN 0x80
+uint32_t dap_swdptap_seq_in(int ticks)
+{
+	uint8_t buf[5] = {
+		ID_DAP_SWD_SEQUENCE,
+		1,
+		ticks + SWD_SEQUENCE_IN
+	};
+	dbg_dap_cmd(buf, 2 + ((ticks + 7) >> 3), 3);
+	uint32_t res = 0;
+	int len = (ticks + 7) >> 3;
+	while (len--) {
+		res <<= 8;
+		res += buf[len + 1];
+	}
+	return res;
+}
+
+bool dap_swdptap_seq_in_parity(uint32_t *ret, int ticks)
+{
+	(void)ticks;
+	uint8_t buf[8] = {
+		ID_DAP_SWD_SEQUENCE,
+		1,
+		33 + SWD_SEQUENCE_IN,
+	};
+	dbg_dap_cmd(buf, 7, 4);
+	uint32_t res = 0;
+	int len = 4;
+	while (len--) {
+		res <<= 8;
+		res += buf[len + 1];
+	}
+	*ret = res;
+	unsigned int parity = __builtin_parity(res) & 1;
+	parity ^= (buf[5] % 1);
+	DEBUG_WARN("Res %08" PRIx32" %d\n", *ret, parity & 1);
+	return (!(parity & 1));
+}

src/platforms/hosted/dap.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2013-2015, Alex Taradov <alex@taradov.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _DAP_H_
+#define _DAP_H_
+
+/*- Includes ----------------------------------------------------------------*/
+#include <stdint.h>
+#include <stdbool.h>
+#include "adiv5.h"
+
+/*- Definitions -------------------------------------------------------------*/
+enum
+{
+  DAP_INFO_VENDOR        = 0x01,
+  DAP_INFO_PRODUCT       = 0x02,
+  DAP_INFO_SER_NUM       = 0x03,
+  DAP_INFO_FW_VER        = 0x04,
+  DAP_INFO_DEVICE_VENDOR = 0x05,
+  DAP_INFO_DEVICE_NAME   = 0x06,
+  DAP_INFO_CAPABILITIES  = 0xf0,
+  DAP_INFO_TDT           = 0xf1,
+  DAP_INFO_SWO_BUF_SIZE  = 0xfd,
+  DAP_INFO_PACKET_COUNT  = 0xfe,
+  DAP_INFO_PACKET_SIZE   = 0xff,
+};
+
+enum
+{
+  DAP_CAP_SWD            = (1 << 0),
+  DAP_CAP_JTAG           = (1 << 1),
+  DAP_CAP_SWO_UART       = (1 << 2),
+  DAP_CAP_SWO_MANCHESTER = (1 << 3),
+  DAP_CAP_ATOMIC_CMD     = (1 << 4),
+  DAP_CAP_TDT            = (1 << 5),
+  DAP_CAP_SWO_STREAMING  = (1 << 6),
+};
+
+/*- Prototypes --------------------------------------------------------------*/
+void dap_led(int index, int state);
+void dap_connect(bool jtag);
+void dap_disconnect(void);
+void dap_transfer_configure(uint8_t idle, uint16_t count, uint16_t retry);
+void dap_swd_configure(uint8_t cfg);
+int dap_info(int info, uint8_t *data, int size);
+void dap_reset_target(void);
+void dap_srst_set_val(bool assert);
+void dap_trst_reset(void);
+void dap_reset_target_hw(int state);
+void dap_reset_pin(int state);
+uint32_t dap_read_reg(ADIv5_DP_t *dp, uint8_t reg);
+void dap_write_reg(ADIv5_DP_t *dp, uint8_t reg, uint32_t data);
+void dap_reset_link(bool jtag);
+uint32_t dap_read_idcode(ADIv5_DP_t *dp);
+unsigned int dap_read_block(ADIv5_AP_t *ap, void *dest, uint32_t src,
+							size_t len,	enum align align);
+unsigned int dap_write_block(ADIv5_AP_t *ap, uint32_t dest, const void *src,
+							 size_t len, enum align align);
+void dap_ap_mem_access_setup(ADIv5_AP_t *ap, uint32_t addr, enum align align);
+uint32_t dap_ap_read(ADIv5_AP_t *ap, uint16_t addr);
+void dap_ap_write(ADIv5_AP_t *ap, uint16_t addr, uint32_t value);
+void dap_read_single(ADIv5_AP_t *ap, void *dest, uint32_t src, enum align align);
+void dap_write_single(ADIv5_AP_t *ap, uint32_t dest, const void *src,
+					  enum align align);
+int dbg_dap_cmd(uint8_t *data, int size, int rsize);
+void dap_jtagtap_tdi_tdo_seq(uint8_t *DO, bool final_tms, const uint8_t *TMS,
+							 const uint8_t *DI, int ticks);
+int dap_jtag_configure(void);
+void dap_swdptap_seq_out(uint32_t MS, int ticks);
+void dap_swdptap_seq_out_parity(uint32_t MS, int ticks);
+bool dap_sequence_test(void);
+#endif // _DAP_H_

src/platforms/hosted/ftdi_bmp.c

@@ -0,0 +1,661 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Copyright (C) 2018  Uwe Bonnes(bon@elektron.ikp.physik.tu-darmstadt.de)
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "general.h"
+#include "gdb_if.h"
+#include "target.h"
+
+#include <assert.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+#include "ftdi_bmp.h"
+#include <ftdi.h>
+
+struct ftdi_context *ftdic;
+
+#define BUF_SIZE 4096
+static uint8_t outbuf[BUF_SIZE];
+static uint16_t bufptr = 0;
+
+cable_desc_t *active_cable;
+data_desc_t active_state;
+
+cable_desc_t cable_desc[] = {
+	{
+		/* Direct connection from FTDI to Jtag/Swd.
+		 Pin 6 direct connected to RST.*/
+		.vendor = 0x0403,
+		.product = 0x6014,
+		.interface = INTERFACE_A,
+		// No explicit reset
+		.bb_swdio_in_port_cmd = GET_BITS_LOW,
+		.bb_swdio_in_pin = MPSSE_CS,
+		.description = "UM232H",
+		.name = "um232h"
+	},
+	{
+		/* Direct connection from FTDI to Jtag/Swd.
+		 Pin 6 direct connected to RST.*/
+		.vendor = 0x0403,
+		.product = 0x6010,
+		.interface = INTERFACE_A,
+		.init.data_low = PIN6, /* PULL nRST high*/
+		.bb_swdio_in_port_cmd = GET_BITS_LOW,
+		.bb_swdio_in_pin = MPSSE_CS,
+		.assert_srst.data_low   = ~PIN6,
+		.assert_srst.ddr_low    =  PIN6,
+		.deassert_srst.data_low =  PIN6,
+		.deassert_srst.ddr_low  = ~PIN6,
+		.description = "FLOSS-JTAG",
+		.name = "flossjtag"
+	},
+	{
+		/* MPSSE_SK (DB0) ----------- SWDCK/JTCK
+		 * MPSSE-DO (DB1) -- 470 R -- SWDIO/JTMS
+		 * MPSSE-DI (DB2) ----------- SWDIO/JTMS
+		 * DO is tristated with SWD read, so
+		 * resistor is not necessary, but protects
+		 * from contentions in case of errors.
+		 * JTAG not possible
+		 * PIN6     (DB6) ----------- NRST */
+		.vendor  = 0x0403,
+		.product = 0x6010,/*FT2232H*/
+		.interface = INTERFACE_B,
+		.init.data_low = PIN4, /* Pull up pin 4 */
+		.init.ddr_low  = PIN4, /* Pull up pin 4 */
+		.mpsse_swd_read.set_data_low  = MPSSE_DO,
+		.mpsse_swd_write.set_data_low = MPSSE_DO,
+		.assert_srst.data_low   = ~PIN6,
+		.assert_srst.ddr_low    =  PIN6,
+		.deassert_srst.data_low =  PIN6,
+		.deassert_srst.ddr_low  = ~PIN6,
+		.target_voltage_cmd  = GET_BITS_LOW,
+		.target_voltage_pin  = PIN4, /* Always read as target voltage present.*/
+		.description = "USBMATE",
+		.name = "usbmate"
+	},
+	{
+		/* MPSSE_SK (DB0) ----------- SWDCK/JTCK
+		 * MPSSE-DO (DB1) -- 470 R -- SWDIO/JTMS
+		 * MPSSE-DI (DB2) ----------- SWDIO/JTMS
+		 * DO is tristated with SWD read, so
+		 * resistor is not necessary, but protects
+		 * from contentions in case of errors.
+		 * JTAG not possible.*/
+		.vendor  = 0x0403,
+		.product = 0x6014,/*FT232H*/
+		.interface = INTERFACE_A,
+		.mpsse_swd_read.set_data_low  = MPSSE_DO,
+		.mpsse_swd_write.set_data_low = MPSSE_DO,
+		.name = "ft232h_resistor_swd"
+	},
+	{
+		/* Buffered connection from FTDI to Jtag/Swd.
+		 * TCK and TMS not independant switchable!
+		 * SWD not possible.
+		 * PIN4 low enables buffers
+		 * PIN5 Low indicates VRef applied
+		 * PIN6 reads back SRST
+		 * CBUS PIN1 Sets SRST
+		 * CBUS PIN2 low drives SRST
+		 */
+		.vendor = 0x0403,
+		.product = 0x6010,
+		.interface = INTERFACE_A,
+		.init.ddr_low = PIN4,
+		.init.data_high = PIN4 | PIN3 | PIN2,
+		.init.ddr_high = PIN4 | PIN3 | PIN2 | PIN1 | PIN0,
+		.assert_srst.data_high   = ~PIN3,
+		.deassert_srst.data_high =  PIN3,
+		.srst_get_port_cmd = GET_BITS_LOW,
+		.srst_get_pin = PIN6,
+		.description = "FTDIJTAG",
+		.name = "ftdijtag"
+	},
+	{
+/* UART/SWO on Interface A
+ * JTAG and control on INTERFACE_B
+ * Bit 5 high selects SWD-WRITE (TMS routed to MPSSE_DI)
+ * Bit 6 high selects JTAG vs SWD (TMS routed to MPSSE_CS)
+ * BCBUS 1 (Output) N_SRST
+ * BCBUS 2 (Input/ Internal Pull Up) V_ISO available
+ *
+ * For bitbanged SWD, set Bit 5 low and select SWD read with
+ * Bit 6 low. Read Connector TMS as MPSSE_DI.
+ *
+ * TDO is routed to Interface 0 RXD as SWO or with Uart
+ * Connector pin 10 pulled to ground will connect Interface 0 RXD
+ * to UART connector RXD
+ */
+		.vendor = 0x0403,
+		.product = 0x6010,
+		.interface = INTERFACE_B,
+		.init.data_low = PIN6 | PIN5,
+		.init.ddr_low  = PIN6 | PIN5,
+		.init.data_high = PIN1 | PIN2,
+		.assert_srst.data_high     = ~PIN1,
+		.assert_srst.ddr_high      =  PIN1,
+		.deassert_srst.data_high   =  PIN1,
+		.deassert_srst.ddr_high    = ~PIN1,
+		.mpsse_swd_read.clr_data_low  = PIN5 | PIN6,
+		.mpsse_swd_write.set_data_low = PIN5,
+		.mpsse_swd_write.clr_data_low = PIN6,
+		.jtag.set_data_low            = PIN6,
+		.target_voltage_cmd  = GET_BITS_HIGH,
+		.target_voltage_pin  = ~PIN2,
+		.name = "ftdiswd",
+		.description = "FTDISWD"
+	},
+	{
+		.vendor = 0x15b1,
+		.product = 0x0003,
+		.interface = INTERFACE_A,
+		.init.ddr_low  = PIN5,
+		.name = "olimex"
+	},
+	{
+		/* Buffered connection from FTDI to Jtag/Swd.
+		 * TCK and TMS not independant switchable!
+		 * => SWD not possible.
+		 * DBUS PIN4 / JTAGOE low enables buffers
+		 * DBUS PIN5 / TRST high drives nTRST low OC
+		 * DBUS PIN6 / RST high drives nSRST low OC
+		 * CBUS PIN0 reads back SRST
+		 */
+		.vendor = 0x0403,
+		.product = 0xbdc8,
+		.interface = INTERFACE_A,
+		/* Drive low to activate JTAGOE and deassert TRST/RST.*/
+		.init.data_low  = 0,
+		.init.ddr_low  = PIN6 | PIN5 | PIN4,
+		.init.ddr_high = PIN2, /* ONE LED */
+		.assert_srst.data_low = PIN6,
+		.deassert_srst.data_low = ~PIN6,
+		.srst_get_port_cmd = GET_BITS_HIGH,
+		.srst_get_pin = PIN0,
+		.name = "turtelizer",
+		.description = "Turtelizer JTAG/RS232 Adapter"
+	},
+	{
+		/* https://reference.digilentinc.com/jtag_hs1/jtag_hs1
+		 * No schmeatics available.
+		 * Buffered from FTDI to Jtag/Swd announced
+		 * Independant switch for TMS not known
+		 * => SWD not possible. */
+		.vendor = 0x0403,
+		.product = 0xbdc8,
+		.interface = INTERFACE_A,
+		.name = "jtaghs1"
+	},
+	{
+		/* Direct connection from FTDI to Jtag/Swd assumed.*/
+		.vendor = 0x0403,
+		.product = 0xbdc8,
+		.interface = INTERFACE_A,
+		.init.data_low = MPSSE_CS | MPSSE_DO | MPSSE_DI,
+		.init.ddr_low  = MPSSE_CS | MPSSE_DO | MPSSE_SK,
+		.bb_swdio_in_port_cmd = GET_BITS_LOW,
+		.bb_swdio_in_pin = MPSSE_CS,
+		.name = "ftdi"
+	},
+	{
+		/* Product name not unique! Assume SWD not possible.*/
+		.vendor = 0x0403,
+		.product = 0x6014,
+		.interface = INTERFACE_A,
+		.init.data_low = PIN7,
+		.init.ddr_low = PIN7,
+		.init.data_high = PIN5,
+		.init.ddr_high = PIN5 | PIN4 | PIN3 | PIN2 | PIN1 | PIN0,
+		.name = "digilent"
+	},
+	{
+		/* Direct connection from FTDI to Jtag/Swd assumed.*/
+		.vendor = 0x0403,
+		.product = 0x6014,
+		.interface = INTERFACE_A,
+		.init.data_low = MPSSE_CS | MPSSE_DO | MPSSE_DI,
+		.init.ddr_low  = MPSSE_CS | MPSSE_DO | MPSSE_SK,
+		.bb_swdio_in_port_cmd = GET_BITS_LOW,
+		.bb_swdio_in_pin = MPSSE_CS,
+		.name = "ft232h"
+	},
+	{
+		/* Direct connection from FTDI to Jtag/Swd assumed.*/
+		.vendor = 0x0403,
+		.product = 0x6011,
+		.interface = INTERFACE_A,
+		.bb_swdio_in_port_cmd = GET_BITS_LOW,
+		.bb_swdio_in_pin = MPSSE_CS,
+		.name = "ft4232h"
+	},
+	{
+		/* http://www.olimex.com/dev/pdf/ARM-USB-OCD.pdf.
+		 * DBUS 4 global enables JTAG Buffer.
+		 * => TCK and TMS not independant switchable!
+		 * => SWD not possible. */
+		.vendor = 0x15ba,
+		.product = 0x002b,
+		.interface = INTERFACE_A,
+		.init.ddr_low = PIN4,
+		.init.data_high = PIN3 | PIN1 | PIN0,
+		.init.ddr_high =  PIN4 | PIN3 | PIN1 | PIN0,
+		.name = "arm-usb-ocd-h"
+	},
+	{
+	}
+};
+
+int ftdi_bmp_init(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info)
+{
+	int err;
+	cable_desc_t *cable = &cable_desc[0];
+	for(;  cable->name; cable++) {
+		if (strncmp(cable->name, cl_opts->opt_cable, strlen(cable->name)) == 0)
+		 break;
+	}
+
+	if (!cable->name ) {
+		DEBUG_WARN( "No cable matching found for %s\n", cl_opts->opt_cable);
+		return -1;
+	}
+
+	active_cable = cable;
+	memcpy(&active_state, &active_cable->init, sizeof(data_desc_t));
+	/* If swd_(read|write) is not given for the selected cable and
+	   the 'e' command line argument is give, assume resistor SWD
+	   connection.*/
+	if (cl_opts->external_resistor_swd &&
+		(active_cable->mpsse_swd_read.set_data_low  == 0) &&
+		(active_cable->mpsse_swd_read.clr_data_low  == 0) &&
+		(active_cable->mpsse_swd_read.set_data_high == 0) &&
+		(active_cable->mpsse_swd_read.clr_data_high == 0) &&
+		(active_cable->mpsse_swd_write.set_data_low  == 0) &&
+		(active_cable->mpsse_swd_write.clr_data_low  == 0) &&
+		(active_cable->mpsse_swd_write.set_data_high == 0) &&
+		(active_cable->mpsse_swd_write.clr_data_high == 0)) {
+			DEBUG_INFO("Using external resistor SWD\n");
+			active_cable->mpsse_swd_read.set_data_low = MPSSE_DO;
+			active_cable->mpsse_swd_write.set_data_low = MPSSE_DO;
+	} else if (!libftdi_swd_possible(NULL, NULL) &&
+			   !cl_opts->opt_usejtag) {
+		DEBUG_WARN("SWD with cable not possible, trying JTAG\n");
+		cl_opts->opt_usejtag = true;
+	}
+	if(ftdic) {
+		ftdi_usb_close(ftdic);
+		ftdi_free(ftdic);
+		ftdic = NULL;
+	}
+	if((ftdic = ftdi_new()) == NULL) {
+		DEBUG_WARN( "ftdi_new: %s\n",
+			ftdi_get_error_string(ftdic));
+		abort();
+	}
+	info->ftdic = ftdic;
+	if((err = ftdi_set_interface(ftdic, active_cable->interface)) != 0) {
+		DEBUG_WARN( "ftdi_set_interface: %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_1;
+	}
+	if((err = ftdi_usb_open_desc(
+		ftdic, active_cable->vendor, active_cable->product,
+		active_cable->description, cl_opts->opt_serial)) != 0) {
+		DEBUG_WARN( "unable to open ftdi device: %d (%s)\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_1;
+	}
+
+	if((err = ftdi_set_latency_timer(ftdic, 1)) != 0) {
+		DEBUG_WARN( "ftdi_set_latency_timer: %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_2;
+	}
+	if((err = ftdi_set_baudrate(ftdic, 1000000)) != 0) {
+		DEBUG_WARN( "ftdi_set_baudrate: %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_2;
+	}
+	if((err = ftdi_write_data_set_chunksize(ftdic, BUF_SIZE)) != 0) {
+		DEBUG_WARN( "ftdi_write_data_set_chunksize: %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_2;
+	}
+	assert(ftdic != NULL);
+#ifdef _Ftdi_Pragma
+	err = ftdi_tcioflush(ftdic);
+#else
+	 err = ftdi_usb_purge_buffers(ftdic);
+#endif
+	if (err != 0) {
+		DEBUG_WARN("ftdi_tcioflush(ftdi_usb_purge_buffer): %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_2;
+	}
+	/* Reset MPSSE controller. */
+	err = ftdi_set_bitmode(ftdic, 0,  BITMODE_RESET);
+	if (err != 0) {
+		DEBUG_WARN("ftdi_set_bitmode: %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_2;
+	}
+	/* Enable MPSSE controller. Pin directions are set later.*/
+	err = ftdi_set_bitmode(ftdic, 0, BITMODE_MPSSE);
+	if (err != 0) {
+		DEBUG_WARN("ftdi_set_bitmode: %d: %s\n",
+			err, ftdi_get_error_string(ftdic));
+		goto error_2;
+	}
+	uint8_t ftdi_init[16];
+	/* Test for pending garbage.*/
+	int garbage =  ftdi_read_data(ftdic, ftdi_init, sizeof(ftdi_init));
+	if (garbage > 0) {
+		DEBUG_WARN("FTDI init garbage at start:");
+		for (int i = 0; i < garbage; i++)
+			DEBUG_WARN(" %02x", ftdi_init[i]);
+		DEBUG_WARN("\n");
+	}
+	int index = 0;
+	ftdi_init[index++]= LOOPBACK_END; /* FT2232D gets upset otherwise*/
+	switch(ftdic->type) {
+	case TYPE_2232H:
+	case TYPE_4232H:
+	case TYPE_232H:
+		ftdi_init[index++] = DIS_DIV_5;
+		break;
+	case TYPE_2232C:
+		break;
+	default:
+		DEBUG_WARN("FTDI Chip has no MPSSE\n");
+		goto error_2;
+	}
+	ftdi_init[index++]= TCK_DIVISOR;
+	/* Use CLK/2 for about 50 % SWDCLK duty cycle on FT2232c.*/
+	ftdi_init[index++]= 1;
+	ftdi_init[index++]= 0;
+	ftdi_init[index++]= SET_BITS_LOW;
+	ftdi_init[index++]= active_state.data_low;
+	ftdi_init[index++]= active_state.ddr_low;
+	ftdi_init[index++]= SET_BITS_HIGH;
+	ftdi_init[index++]= active_state.data_high;
+	ftdi_init[index++]= active_state.ddr_high;
+	libftdi_buffer_write(ftdi_init, index);
+	libftdi_buffer_flush();
+	garbage =  ftdi_read_data(ftdic, ftdi_init, sizeof(ftdi_init));
+	if (garbage > 0) {
+		DEBUG_WARN("FTDI init garbage at end:");
+		for (int i = 0; i < garbage; i++)
+			DEBUG_WARN(" %02x", ftdi_init[i]);
+		DEBUG_WARN("\n");
+	}	return 0;
+
+  error_2:
+	ftdi_usb_close(ftdic);
+  error_1:
+	ftdi_free(ftdic);
+	return -1;
+}
+
+static void libftdi_set_data(data_desc_t* data)
+{
+	uint8_t cmd[6];
+	int index = 0;
+	if ((data->data_low) || (data->ddr_low)) {
+		if (data->data_low > 0)
+			active_state.data_low |= (data->data_low & 0xff);
+		else if (data->data_low < 0)
+			active_state.data_low &= (data->data_low & 0xff);
+		if (data->ddr_low > 0)
+			active_state.ddr_low  |= (data->ddr_low  & 0xff);
+		else if (data->ddr_low < 0)
+			active_state.ddr_low  &= (data->ddr_low  & 0xff);
+		cmd[index++] = SET_BITS_LOW;
+		cmd[index++] = active_state.data_low;
+		cmd[index++] = active_state.ddr_low;
+	}
+	if ((data->data_high) || (data->ddr_high)) {
+		if (data->data_high > 0)
+			active_state.data_high |= (data->data_high & 0xff);
+		else if (data->data_high < 0)
+			active_state.data_high &= (data->data_high & 0xff);
+		if (data->ddr_high > 0)
+			active_state.ddr_high  |= (data->ddr_high  & 0xff);
+		else if (data->ddr_high < 0)
+			active_state.ddr_high  &= (data->ddr_high  & 0xff);
+		cmd[index++] = SET_BITS_HIGH;
+		cmd[index++] = active_state.data_high;
+		cmd[index++] = active_state.ddr_high;
+	}
+	if (index) {
+		libftdi_buffer_write(cmd, index);
+		libftdi_buffer_flush();
+	}
+}
+
+void libftdi_srst_set_val(bool assert)
+{
+	if (assert)
+		libftdi_set_data(&active_cable->assert_srst);
+	else
+		libftdi_set_data(&active_cable->deassert_srst);
+}
+
+bool libftdi_srst_get_val(void)
+{
+	uint8_t cmd[1] = {0};
+	uint8_t pin = 0;
+	if (active_cable->srst_get_port_cmd && active_cable->srst_get_pin) {
+		cmd[0]= active_cable->srst_get_port_cmd;
+		pin   =  active_cable->srst_get_pin;
+	} else if (active_cable->assert_srst.data_low &&
+			   active_cable->assert_srst.ddr_low) {
+		cmd[0]= GET_BITS_LOW;
+		pin   = active_cable->assert_srst.data_low;
+	} else if (active_cable->assert_srst.data_high &&
+			   active_cable->assert_srst.ddr_high) {
+		cmd[0]= GET_BITS_HIGH;
+		pin   = active_cable->assert_srst.data_high;
+	}else {
+		return false;
+	}
+	libftdi_buffer_write(cmd, 1);
+	uint8_t data[1];
+	libftdi_buffer_read(data, 1);
+	bool res = false;
+	if (((pin < 0x7f) || (pin == PIN7)))
+		res = data[0] & pin;
+	else
+		res = !(data[0] & ~pin);
+	return res;
+}
+
+void libftdi_buffer_flush(void)
+{
+	if (!bufptr)
+		return;
+	DEBUG_WIRE("Flush %d\n", bufptr);
+#if defined(USE_USB_VERSION_BIT)
+static struct ftdi_transfer_control *tc_write = NULL;
+    if (tc_write)
+		ftdi_transfer_data_done(tc_write);
+	tc_write = ftdi_write_data_submit(ftdic, outbuf, bufptr);
+#else
+	assert(ftdi_write_data(ftdic, outbuf, bufptr) == bufptr);
+	DEBUG_WIRE("FT2232 libftdi_buffer flush: %d bytes\n", bufptr);
+#endif
+	bufptr = 0;
+}
+
+int libftdi_buffer_write(const uint8_t *data, int size)
+{
+	if((bufptr + size) / BUF_SIZE > 0) libftdi_buffer_flush();
+	DEBUG_WIRE("Write %d bytes:", size);
+	for (int i = 0; i < size; i++) {
+		DEBUG_WIRE(" %02x", data[i]);
+		if (i && ((i & 0xf) == 0xf))
+			DEBUG_WIRE("\n\t");
+	}
+	DEBUG_WIRE("\n");
+	memcpy(outbuf + bufptr, data, size);
+	bufptr += size;
+	return size;
+}
+
+int libftdi_buffer_read(uint8_t *data, int size)
+{
+#if defined(USE_USB_VERSION_BIT)
+	struct ftdi_transfer_control *tc;
+	outbuf[bufptr++] = SEND_IMMEDIATE;
+	libftdi_buffer_flush();
+	tc = ftdi_read_data_submit(ftdic, data, size);
+	ftdi_transfer_data_done(tc);
+#else
+	int index = 0;
+	const uint8_t cmd[1] = {SEND_IMMEDIATE};
+	libftdi_buffer_write(cmd, 1);
+	libftdi_buffer_flush();
+	while((index += ftdi_read_data(ftdic, data + index, size-index)) != size);
+#endif
+	DEBUG_WIRE("Read  %d bytes:", size);
+	for (int i = 0; i < size; i++) {
+		DEBUG_WIRE(" %02x", data[i]);
+		if (i && ((i & 0xf) == 0xf))
+			DEBUG_WIRE("\n\t");
+	}
+	DEBUG_WIRE("\n");
+	return size;
+}
+
+void libftdi_jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks)
+{
+	int rsize, rticks;
+
+	if(!ticks) return;
+	if (!DI && !DO) return;
+
+	DEBUG_WIRE("libftdi_jtagtap_tdi_tdo_seq %s ticks: %d\n",
+			   (DI && DO) ? "read/write" : ((DI) ? "write" : "read"), ticks);
+	if(final_tms) ticks--;
+	rticks = ticks & 7;
+	ticks >>= 3;
+	uint8_t data[8];
+	uint8_t cmd =  ((DO)? MPSSE_DO_READ : 0) |
+		((DI)? (MPSSE_DO_WRITE | MPSSE_WRITE_NEG) : 0) | MPSSE_LSB;
+	rsize = ticks;
+	if(ticks) {
+		data[0] = cmd;
+		data[1] = ticks - 1;
+		data[2] = 0;
+		libftdi_buffer_write(data, 3);
+		if (DI)
+			libftdi_buffer_write(DI, ticks);
+	}
+	int index = 0;
+	if(rticks) {
+		rsize++;
+		data[index++] = cmd | MPSSE_BITMODE;
+		data[index++] = rticks - 1;
+		if (DI)
+			data[index++] = DI[ticks];
+	}
+	if(final_tms) {
+		rsize++;
+		data[index++] = MPSSE_WRITE_TMS | ((DO)? MPSSE_DO_READ : 0) |
+			MPSSE_LSB | MPSSE_BITMODE | MPSSE_WRITE_NEG;
+		data[index++] = 0;
+		if (DI)
+			data[index++] = (DI[ticks] & (1 << rticks)) ? 0x81 : 0x01;
+	}
+	if (index)
+		libftdi_buffer_write(data, index);
+	if (DO) {
+		int index = 0;
+		uint8_t *tmp = alloca(rsize);
+		libftdi_buffer_read(tmp, rsize);
+		if(final_tms) rsize--;
+
+		while(rsize--) {
+			*DO++ = tmp[index++];
+		}
+		if (rticks == 0)
+			*DO++ = 0;
+		if(final_tms) {
+			rticks++;
+			*(--DO) >>= 1;
+			*DO |= tmp[index] & 0x80;
+		} else DO--;
+		if(rticks) {
+			*DO >>= (8-rticks);
+		}
+	}
+}
+
+const char *libftdi_target_voltage(void)
+{
+	uint8_t pin = active_cable->target_voltage_pin;
+	if (active_cable->target_voltage_cmd && pin) {
+		libftdi_buffer_write(&active_cable->target_voltage_cmd, 1);
+		uint8_t data[1];
+		libftdi_buffer_read(data, 1);
+		bool res = false;
+		if (((pin < 0x7f) || (pin == PIN7)))
+			res = data[0] & pin;
+		else
+			res = !(data[0] & ~pin);
+		if (res)
+			return "Present";
+		else
+			return "Absent";
+	}
+	return NULL;
+}
+
+static uint16_t divisor;
+void libftdi_max_frequency_set(uint32_t freq)
+{
+	uint32_t clock;
+	if (ftdic->type == TYPE_2232C)
+		clock = 12 * 1000 * 1000;
+	else
+		/* Undivided clock set during startup*/
+		clock = 60 * 1000 * 1000;
+	uint32_t div = (clock  + 2 * freq - 1)/ freq;
+	if ((div < 4) && (ftdic->type = TYPE_2232C))
+		div = 4; /* Avoid bad unsymetrict FT2232C clock at 6 MHz*/
+	divisor = div / 2 - 1;
+	uint8_t buf[3];
+	buf[0] = TCK_DIVISOR;
+	buf[1] = divisor & 0xff;
+	buf[2] = (divisor >> 8) & 0xff;
+	libftdi_buffer_write(buf, 3);
+}
+
+uint32_t libftdi_max_frequency_get(void)
+{
+	uint32_t clock;
+	if (ftdic->type == TYPE_2232C)
+		clock = 12 * 1000 * 1000;
+	else
+		/* Undivided clock set during startup*/
+		clock = 60 * 1000 * 1000;
+	return clock/ ( 2 *(divisor + 1));
+}

src/platforms/hosted/ftdi_bmp.h

@@ -0,0 +1,155 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ * Copyright (C) 2018  Uwe Bonnes (non@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __FTDI_BMP_H
+#define __FTDI_BMP_H
+
+#include "cl_utils.h"
+#include "jtagtap.h"
+
+#include "bmp_hosted.h"
+
+typedef struct data_desc_s {
+	int16_t data_low;
+	int16_t ddr_low;
+	int16_t data_high;
+	int16_t ddr_high;
+}data_desc_t;
+
+typedef struct pin_settings_s {
+	uint8_t set_data_low;
+	uint8_t clr_data_low;
+	uint8_t set_data_high;
+	uint8_t clr_data_high;
+}pin_settings_t;
+
+typedef struct cable_desc_s {
+	int vendor;
+	int product;
+	int interface;
+	/* Initial (C|D)(Bus|Ddr) values for additional pins.
+	 * MPSSE_CS|DI|DO|SK are initialized accordig to mode.*/
+	data_desc_t init;
+	/* MPSSE command to read TMS/SWDIO in bitbanging SWD.
+	 * In many cases this is the TMS port, so then use "GET_PIN_LOW".*/
+	uint8_t bb_swdio_in_port_cmd;
+	/* bus bit to read TMS/SWDIO in bitbanging SWD.
+	 * In many cases this is the TMS port, so then use "MPSSE_CS".*/
+	uint8_t bb_swdio_in_pin;
+	/* Bus data to allow bitbanging switched SWD read.
+	 * TMS is routed to bb_swdio_in_port/pin.*/
+	pin_settings_t bb_swd_read;
+	/* Bus data to allow bitbanging switched SWD write.
+	 * TMS is routed to MPSSE_CS.*/
+	pin_settings_t bb_swd_write;
+	/* dbus_data, dbus_ddr, cbus_data, cbus_ddr value to assert SRST.
+	 *	E.g. with CBUS Pin 1 low,
+	 *	give data_high = ~PIN1, ddr_high = PIN1 */
+	data_desc_t assert_srst;
+	/*  Bus_data, dbus_ddr, cbus_data, cbus_ddr value to release SRST.
+	 *	E.g. with CBUS Pin 1 floating with internal pull up,
+	 *	give data_high = PIN1, ddr_high = ~PIN1 */
+	data_desc_t deassert_srst;
+	/* Command to read back SRST. If 0, port from assert_srst is used*/
+	uint8_t srst_get_port_cmd;
+	/* PIN to read back as SRST. if 0 port from assert_srst is ised.
+	*  Use PINX if active high, use Complement (~PINX) if active low*/
+	uint8_t srst_get_pin;
+	/* Bbus data for pure MPSSE SWD read.
+	 * Use together with swd_write if by some bits on DBUS,
+	 * SWDIO can be routed to TDI and TDO.
+	 * If both mpsse_swd_read|write and
+	 * bitbang_swd_dbus_read_data/bitbang_tms_in_port_cmd/bitbang_tms_in_pin
+	 * are provided, pure MPSSE SWD is choosen.
+	 * If neither a complete set of swd_read|write or
+	 * bitbang_swd_dbus_read_data/bitbang_tms_in_port_cmd/bitbang_tms_in_pin
+	 * are provided, SWD can not be done.
+	 * swd_read.set_data_low ==  swd_write.set_data_low == MPSSE_DO
+	 * indicated resistor SWD and inhibits Jtag.*/
+	pin_settings_t mpsse_swd_read;
+	/* dbus data for pure MPSSE SWD write.*/
+	pin_settings_t mpsse_swd_write;
+	/* dbus data for jtag.*/
+	pin_settings_t jtag;
+	/* Command to read port to check target voltage.*/
+	uint8_t target_voltage_cmd;
+	/* Pin to check target voltage.*/
+	uint8_t target_voltage_pin;
+	/* USB readable description of the device.*/
+	char *description;
+	/* Command line argument to -c option to select this device.*/
+	char * name;
+}cable_desc_t;
+
+#if HOSTED_BMP_ONLY == 1
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-parameter"
+int ftdi_bmp_init(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info) {return -1;};
+int libftdi_swdptap_init(ADIv5_DP_t *dp) {return -1;};
+int libftdi_jtagtap_init(jtag_proc_t *jtag_proc) {return 0;};
+void libftdi_buffer_flush(void) {};
+int libftdi_buffer_write(const uint8_t *data, int size) {return size;};
+int libftdi_buffer_read(uint8_t *data, int size) {return size;};
+const char *libftdi_target_voltage(void) {return "ERROR";};
+void libftdi_jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks) {};
+bool  libftdi_swd_possible(bool *do_mpsse, bool *direct_bb_swd) {return false;};
+void libftdi_max_frequency_set(uint32_t freq) {};
+uint32_t libftdi_max_frequency_get(void) {return 0;};
+void libftdi_srst_set_val(bool assert){};
+bool libftdi_srst_get_val(void) { return false;};
+# pragma GCC diagnostic pop
+#else
+#include <ftdi.h>
+extern cable_desc_t cable_desc[];
+extern cable_desc_t *active_cable;
+extern struct ftdi_context *ftdic;
+extern data_desc_t active_state;
+
+int ftdi_bmp_init(BMP_CL_OPTIONS_t *cl_opts, bmp_info_t *info);
+int libftdi_swdptap_init(ADIv5_DP_t *dp);
+int libftdi_jtagtap_init(jtag_proc_t *jtag_proc);
+void libftdi_buffer_flush(void);
+int libftdi_buffer_write(const uint8_t *data, int size);
+int libftdi_buffer_read(uint8_t *data, int size);
+const char *libftdi_target_voltage(void);
+void libftdi_jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks);
+bool  libftdi_swd_possible(bool *do_mpsse, bool *direct_bb_swd);
+void libftdi_max_frequency_set(uint32_t freq);
+uint32_t libftdi_max_frequency_get(void);
+void libftdi_srst_set_val(bool assert);
+bool libftdi_srst_get_val(void);
+#endif
+
+#define MPSSE_SK 1
+#define PIN0     1
+#define MPSSE_DO 2
+#define PIN1     2
+#define MPSSE_DI 4
+#define PIN2     4
+#define MPSSE_CS 8
+#define PIN3     8
+#define PIN4     0x10
+#define PIN5     0x20
+#define PIN6     0x40
+#define PIN7     0x80
+#endif

src/platforms/hosted/jlink.c

@@ -0,0 +1,271 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2020 Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.	 If not, see <http://www.gnu.org/licenses/>.
+ */
+/* Base on code from git://repo.or.cz/libjaylink.git
+ * and https://github.com/afaerber/jlink.git*/
+
+#include "general.h"
+#include "gdb_if.h"
+#include "adiv5.h"
+#include "exception.h"
+
+#include <assert.h>
+#include <unistd.h>
+#include <signal.h>
+#include <ctype.h>
+#include <sys/time.h>
+
+#include "cl_utils.h"
+#include "jlink.h"
+
+#define USB_PID_SEGGER       0x1366
+
+/* Only two devices PIDS tested so long */
+#define USB_VID_SEGGER_0101  0x0101
+#define USB_VID_SEGGER_0105  0x0105
+#define USB_VID_SEGGER_1020  0x1020
+
+static uint32_t emu_caps;
+static uint32_t emu_speed_kHz;
+static uint16_t emu_min_divisor;
+static uint16_t emu_current_divisor;
+
+static void jlink_print_caps(bmp_info_t *info)
+{
+	uint8_t cmd[1] = {CMD_GET_CAPS};
+	uint8_t res[4];
+	send_recv(info->usb_link, cmd, 1, res, sizeof(res));
+	emu_caps = res[0] | (res[1] << 8) | (res[2] << 16) | (res[3] << 24);
+	DEBUG_INFO("Caps %" PRIx32 "\n", emu_caps);
+	if (emu_caps & JLINK_CAP_GET_HW_VERSION) {
+		uint8_t cmd[1] = {CMD_GET_HW_VERSION};
+		send_recv(info->usb_link, cmd, 1, NULL, 0);
+		send_recv(info->usb_link, NULL, 0, res, sizeof(res));
+		DEBUG_INFO("HW: Type %d, Major %d, Minor %d, Rev %d\n",
+			   res[3], res[2], res[1], res[0]);
+	}
+}
+static void jlink_print_speed(bmp_info_t *info)
+{
+	uint8_t cmd[1] = {CMD_GET_SPEEDS};
+	uint8_t res[6];
+	send_recv(info->usb_link, cmd, 1, res, sizeof(res));
+	emu_speed_kHz = (res[0] | (res[1] << 8) | (res[2] << 16) | (res[3] << 24)) /
+					 1000;
+	emu_min_divisor = res[4] | (res[5] << 8);
+	DEBUG_INFO("Emulator speed %d kHz, Mindiv %d%s\n", emu_speed_kHz,
+			   emu_min_divisor,
+			   (emu_caps & JLINK_CAP_GET_SPEEDS) ? "" : ", fixed");
+}
+
+static void jlink_print_version(bmp_info_t *info)
+{
+	uint8_t cmd[1] = {CMD_GET_VERSION};
+	uint8_t len_str[2];
+	send_recv(info->usb_link, cmd, 1, len_str, sizeof(len_str));
+	uint8_t version[0x70];
+	send_recv(info->usb_link, NULL, 0, version, sizeof(version));
+	DEBUG_INFO("%s\n", version );
+}
+
+static void jlink_print_interfaces(bmp_info_t *info)
+{
+	uint8_t cmd[2] = {CMD_GET_SELECT_IF, JLINK_IF_GET_ACTIVE};
+	uint8_t res[4];
+	send_recv(info->usb_link, cmd, 2, res, sizeof(res));
+	cmd[1] = JLINK_IF_GET_AVAILABLE;
+	uint8_t res1[4];
+	send_recv(info->usb_link, cmd, 2, res1, sizeof(res1));
+	DEBUG_INFO("%s active", (res[0] == SELECT_IF_SWD) ? "SWD":
+		   (res[0] == SELECT_IF_JTAG) ? "JTAG" : "NONE");
+	uint8_t other_interface = res1[0] - (res[0] + 1);
+	if (other_interface)
+		DEBUG_INFO(", %s available\n",
+			   (other_interface == JLINK_IF_SWD) ? "SWD": "JTAG");
+	else
+		DEBUG_INFO(", %s not available\n",
+			   ((res[0] + 1) == JLINK_IF_SWD) ? "JTAG": "SWD");
+}
+
+static void jlink_info(bmp_info_t *info)
+{
+	jlink_print_version(info);
+	jlink_print_caps(info);
+	jlink_print_speed(info);
+	jlink_print_interfaces(info);
+}
+
+/* On success endpoints are set and return 0, !0 else */
+static int initialize_handle(bmp_info_t *info, libusb_device *dev)
+{
+	struct libusb_config_descriptor *config;
+	int ret =  libusb_get_active_config_descriptor(dev, &config);
+	if (ret != LIBUSB_SUCCESS) {
+		DEBUG_WARN( "Failed to get configuration descriptor: %s.",
+				libusb_error_name(ret));
+		return -1;
+	}
+	const struct libusb_interface *interface;
+	bool found_interface = false;
+	const struct libusb_interface_descriptor *desc;
+	for (int i = 0; i < config->bNumInterfaces; i++) {
+		interface = &config->interface[i];
+		desc = &interface->altsetting[0];
+		if (desc->bInterfaceClass != LIBUSB_CLASS_VENDOR_SPEC)
+			continue;
+		if (desc->bInterfaceSubClass != LIBUSB_CLASS_VENDOR_SPEC)
+			continue;
+		if (desc->bNumEndpoints < 2)
+			continue;
+		found_interface = true;
+		if (libusb_claim_interface (
+				info->usb_link->ul_libusb_device_handle, i)) {
+			DEBUG_WARN( " Can not claim handle\n");
+			found_interface = false;
+		}
+		break;
+	}
+	if (!found_interface) {
+		DEBUG_WARN( "No suitable interface found.");
+		libusb_free_config_descriptor(config);
+		return -1;
+	}
+	for (int i = 0; i < desc->bNumEndpoints; i++) {
+		const struct libusb_endpoint_descriptor *epdesc = &desc->endpoint[i];
+		if (epdesc->bEndpointAddress & LIBUSB_ENDPOINT_IN) {
+			info->usb_link->ep_rx = epdesc->bEndpointAddress;
+		} else {
+			info->usb_link->ep_tx = epdesc->bEndpointAddress;
+		}
+	}
+	libusb_free_config_descriptor(config);
+	return 0;
+}
+/* Return 0 if single J-Link device connected or
+ * serial given matches one of several J-Link devices.
+ */
+int jlink_init(bmp_info_t *info)
+{
+	usb_link_t *jl = calloc(1, sizeof(usb_link_t));
+	if (!jl)
+		return -1;
+	info->usb_link = jl;
+	jl->ul_libusb_ctx = info->libusb_ctx;
+	int ret = -1;
+	libusb_device **devs;
+    if (libusb_get_device_list(info->libusb_ctx, &devs) < 0) {
+        DEBUG_WARN( "libusb_get_device_list() failed");
+		return ret;
+	}
+	int i = 0;
+	for (;  devs[i]; i++) {
+		libusb_device *dev =  devs[i];
+		struct libusb_device_descriptor desc;
+		if (libusb_get_device_descriptor(dev, &desc) < 0) {
+            DEBUG_WARN( "libusb_get_device_descriptor() failed");
+			goto error;;
+		}
+		if (desc.idVendor !=  USB_PID_SEGGER)
+			continue;
+		if ((desc.idProduct != USB_VID_SEGGER_0101) &&
+			(desc.idProduct != USB_VID_SEGGER_0105) &&
+			(desc.idProduct != USB_VID_SEGGER_1020))
+			continue;
+		int res = libusb_open(dev, &jl->ul_libusb_device_handle);
+		if (res != LIBUSB_SUCCESS)
+			continue;
+		char buf[32];
+		res = libusb_get_string_descriptor_ascii(jl->ul_libusb_device_handle,
+			desc.iSerialNumber, (uint8_t*) buf, sizeof(buf));
+		if ((res <= 0) || (!strstr(buf, info->serial))) {
+			libusb_close(jl->ul_libusb_device_handle);
+			continue;
+		}
+		break;
+	}
+	if (!devs[i])
+		goto error;
+	if (initialize_handle(info, devs[i]))
+		goto error;
+	jl->req_trans = libusb_alloc_transfer(0);
+	jl->rep_trans = libusb_alloc_transfer(0);
+	if (!jl->req_trans || !jl->rep_trans ||
+		!jl->ep_tx || !jl->ep_rx) {
+		DEBUG_WARN("Device setup failed\n");
+		goto error;
+	}
+	libusb_free_device_list(devs, 1);
+	jlink_info(info);
+	return 0;
+  error:
+	libusb_free_device_list(devs, 1);
+	return -1;
+
+}
+
+const char *jlink_target_voltage(bmp_info_t *info)
+{
+        uint8_t cmd[1] = {CMD_GET_HW_STATUS};
+		uint8_t res[8];
+        send_recv(info->usb_link, cmd, 1, res, sizeof(res));
+        uint16_t mVolt = res[0] | (res[1] << 8);
+        static char ret[7];
+        sprintf(ret, "%2d.%03d", mVolt / 1000, mVolt % 1000);
+        return ret;
+}
+
+static bool srst_status = false;
+void jlink_srst_set_val(bmp_info_t *info, bool assert)
+{
+        uint8_t cmd[1];
+        cmd[0]= (assert)? CMD_HW_RESET0: CMD_HW_RESET1;
+        send_recv(info->usb_link, cmd, 1, NULL, 0);
+        platform_delay(2);
+        srst_status = assert;
+}
+
+bool jlink_srst_get_val(bmp_info_t *info) {
+        uint8_t cmd[1] = {CMD_GET_HW_STATUS};
+        uint8_t res[8];
+        send_recv(info->usb_link, cmd, 1, res, sizeof(res));
+        return !(res[6]);
+}
+
+void jlink_max_frequency_set(bmp_info_t *info, uint32_t freq)
+{
+	if (!(emu_caps &  JLINK_CAP_GET_SPEEDS))
+		return;
+	if (!info->is_jtag)
+		return;
+	uint16_t freq_kHz = freq /1000;
+	uint16_t divisor = (emu_speed_kHz + freq_kHz - 1) / freq_kHz;
+	if (divisor < emu_min_divisor)
+		divisor = emu_min_divisor;
+	emu_current_divisor = divisor;
+	uint16_t speed_kHz = emu_speed_kHz / divisor;
+	uint8_t cmd[3] = {CMD_SET_SPEED, speed_kHz & 0xff, speed_kHz >> 8};
+	DEBUG_WARN("Set Speed %d\n", speed_kHz);
+	send_recv(info->usb_link, cmd, 3, NULL, 0);
+}
+
+uint32_t jlink_max_frequency_get(bmp_info_t *info)
+{
+	if ((emu_caps & JLINK_CAP_GET_SPEEDS) && (info->is_jtag))
+		return (emu_speed_kHz * 1000L)/ emu_current_divisor;
+	return FREQ_FIXED;
+}

src/platforms/hosted/jlink.h

@@ -0,0 +1,108 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2019 Uwe Bonnes
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.	 If not, see <http://www.gnu.org/licenses/>.
+ */
+#if !defined(__JLINK_H_)
+#define __JLINK_H_
+
+#include "bmp_hosted.h"
+#include "jtagtap.h"
+
+/** @cond PRIVATE */
+#define CMD_GET_VERSION         0x01
+#define CMD_SET_SPEED           0x05
+#define CMD_GET_HW_STATUS       0x07
+#define CMD_GET_SPEEDS          0xc0
+#define CMD_GET_SELECT_IF       0xc7
+#define CMD_HW_JTAG3            0xcf
+#define CMD_HW_RESET0           0xdc
+#define CMD_HW_RESET1           0xdd
+#define CMD_GET_CAPS            0xe8
+#define CMD_GET_EXT_CAPS        0xed
+#define CMD_GET_HW_VERSION      0xf0
+
+#define JLINK_IF_GET_ACTIVE    0xfe
+#define JLINK_IF_GET_AVAILABLE 0xff
+
+#define JLINK_CAP_GET_SPEEDS     (1 <<  9)
+#define JLINK_CAP_GET_HW_VERSION (1 <<  1)
+#define JLINK_IF_JTAG             1
+#define JLINK_IF_SWD              2
+
+#define SELECT_IF_JTAG            0
+#define SELECT_IF_SWD             1
+
+#if HOSTED_BMP_ONLY == 1
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-parameter"
+int jlink_init(bmp_info_t *info) {return -1;};
+int jlink_swdp_scan(bmp_info_t *info) {return 0;};
+int jlink_jtagtap_init(bmp_info_t *info, jtag_proc_t *jtag_proc) {return 0;};
+const char *jlink_target_voltage(bmp_info_t *info) {return "ERROR";};
+void jlink_srst_set_val(bmp_info_t *info, bool assert) {};
+bool jlink_srst_get_val(bmp_info_t *info) {return true;};
+void jlink_max_frequency_set(bmp_info_t *info, uint32_t freq) {};
+uint32_t jlink_max_frequency_get(bmp_info_t *info) {return 0;};
+# pragma GCC diagnostic pop
+#else
+/** Device capabilities. (from openocd*/
+enum jaylink_device_capability {
+        /** Device supports retrieval of the hardware version. */
+        JAYLINK_DEV_CAP_GET_HW_VERSION = 1,
+        /** Device supports adaptive clocking. */
+        JAYLINK_DEV_CAP_ADAPTIVE_CLOCKING = 3,
+        /** Device supports reading configuration data. */
+        JAYLINK_DEV_CAP_READ_CONFIG = 4,
+        /** Device supports writing configuration data. */
+        JAYLINK_DEV_CAP_WRITE_CONFIG = 5,
+        /** Device supports retrieval of target interface speeds. */
+        JAYLINK_DEV_CAP_GET_SPEEDS = 9,
+        /** Device supports retrieval of free memory size. */
+        JAYLINK_DEV_CAP_GET_FREE_MEMORY = 11,
+        /** Device supports retrieval of hardware information. */
+        JAYLINK_DEV_CAP_GET_HW_INFO = 12,
+        /** Device supports the setting of the target power supply. */
+        JAYLINK_DEV_CAP_SET_TARGET_POWER = 13,
+        /** Device supports target interface selection. */
+        JAYLINK_DEV_CAP_SELECT_TIF = 17,
+        /** Device supports retrieval of counter values. */
+        JAYLINK_DEV_CAP_GET_COUNTERS = 19,
+        /** Device supports capturing of SWO trace data. */
+        JAYLINK_DEV_CAP_SWO = 23,
+        /** Device supports file I/O operations. */
+        JAYLINK_DEV_CAP_FILE_IO = 26,
+        /** Device supports registration of connections. */
+        JAYLINK_DEV_CAP_REGISTER = 27,
+        /** Device supports retrieval of extended capabilities. */
+        JAYLINK_DEV_CAP_GET_EXT_CAPS = 31,
+        /** Device supports EMUCOM. */
+        JAYLINK_DEV_CAP_EMUCOM = 33,
+        /** Device supports ethernet connectivity. */
+        JAYLINK_DEV_CAP_ETHERNET = 38
+};
+
+
+int jlink_init(bmp_info_t *info);
+int jlink_swdp_scan(bmp_info_t *info);
+int jlink_jtagtap_init(bmp_info_t *info, jtag_proc_t *jtag_proc);
+const char *jlink_target_voltage(bmp_info_t *info);
+void jlink_srst_set_val(bmp_info_t *info, bool assert);
+bool jlink_srst_get_val(bmp_info_t *info);
+void jlink_max_frequency_set(bmp_info_t *info, uint32_t freq);
+uint32_t jlink_max_frequency_get(bmp_info_t *info);
+#endif
+#endif

src/platforms/hosted/jlink_adiv5_swdp.c

@@ -0,0 +1,327 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ * Copyright (C) 2019 - 2021 Uwe Bonnes
+ *                           (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* This file implements the SW-DP specific functions of the
+ * ARM Debug Interface v5 Architecure Specification, ARM doc IHI0031A.
+ */
+
+#include "general.h"
+#include "exception.h"
+#include "target.h"
+#include "target_internal.h"
+#include "adiv5.h"
+#include "jlink.h"
+#include "cl_utils.h"
+
+#define SWDP_ACK_OK    0x01
+#define SWDP_ACK_WAIT  0x02
+#define SWDP_ACK_FAULT 0x04
+
+static uint32_t jlink_adiv5_swdp_read(ADIv5_DP_t *dp, uint16_t addr);
+
+static uint32_t jlink_adiv5_swdp_error(ADIv5_DP_t *dp);
+
+static uint32_t jlink_adiv5_swdp_low_access(ADIv5_DP_t *dp, uint8_t RnW,
+				      uint16_t addr, uint32_t value);
+
+static void jlink_adiv5_swdp_abort(ADIv5_DP_t *dp, uint32_t abort);
+
+enum {
+	SWDIO_WRITE = 0,
+	SWDIO_READ
+};
+
+/* Write at least 50 bits high, two bits low and read DP_IDR and put
+*  idle cyccles at the end*/
+static int line_reset(bmp_info_t *info)
+{
+        uint8_t cmd[44];
+        cmd[0]  = CMD_HW_JTAG3;
+        cmd[1]  = 0;
+        /* write 19 Bytes.*/
+        cmd[2]  = 19 * 8;
+        cmd[3]  = 0;
+        uint8_t *direction = cmd + 4;
+        direction[0]  = 0;
+        direction[1]  = 0;
+        direction[2]  = 0;
+        direction[3]  = 0;
+        direction[4]  = 0;
+        direction[5]  = 0xff;
+        direction[6]  = 0xff;
+        direction[7]  = 0xff;
+        direction[8]  = 0xff;
+        direction[9]  = 0xff;
+        direction[10] = 0xff;
+        direction[11] = 0xff;
+        direction[12] = 0xff;
+        direction[13] = 0xff;
+        direction[14] = 0x0;
+        direction[15] = 0x0;
+        direction[16] = 0x0;
+        direction[17] = 0x0;
+        direction[18] = 0xe0;
+        uint8_t *data = direction + 19;
+        data[5] =  0xff;
+        data[6] =  0xff;
+        data[7] =  0xff;
+        data[8] =  0xff;
+        data[9] =  0xff;
+        data[10] = 0xff;
+        data[11] = 0xff;
+        data[12] = 0;
+        data[13] = 0xa5;
+        data[18] = 0;
+
+        uint8_t res[19];
+        send_recv(info->usb_link, cmd, 42, res, 19);
+        send_recv(info->usb_link, NULL, 0, res,  1);
+
+        if (res[0] != 0) {
+                DEBUG_WARN( "Line reset failed\n");
+                return -1;
+        }
+        return 0;
+}
+
+static int jlink_swdptap_init(bmp_info_t *info)
+{
+	uint8_t cmd[2] = {CMD_GET_SELECT_IF, JLINK_IF_GET_AVAILABLE};
+	uint8_t res[4];
+	send_recv(info->usb_link, cmd, 2, res, sizeof(res));
+	if (!(res[0] & JLINK_IF_SWD))
+		return -1;
+	cmd[1] = SELECT_IF_SWD;
+	send_recv(info->usb_link, cmd, 2, res, sizeof(res));
+	platform_delay(10);
+	/* SWD speed is fixed. Do not set it here*/
+	return 0;
+}
+
+int jlink_swdp_scan(bmp_info_t *info)
+{
+	jlink_swdptap_init(info);
+	target_list_free();
+	uint8_t cmd[44];
+	cmd[0]  = CMD_HW_JTAG3;
+	cmd[1]  = 0;
+	/* write 18 Bytes.*/
+	cmd[2]  = 17 * 8;
+	cmd[3]  = 0;
+	uint8_t *direction = cmd + 4;
+	direction[0]  = 0xff;
+	direction[1]  = 0xff;
+	direction[2]  = 0xff;
+	direction[3]  = 0xff;
+	direction[4]  = 0xff;
+	direction[5]  = 0xff;
+	direction[6]  = 0xff;
+	direction[7]  = 0xff;
+	direction[8]  = 0xff;
+	direction[9]  = 0xff;
+	direction[10] = 0xff;
+	direction[11] = 0xff;
+	direction[12] = 0xff;
+	direction[13] = 0xff;
+	direction[14] = 0xff;
+	direction[15] = 0xff;
+	direction[16] = 0xff;
+	uint8_t *data = direction + 17;
+	data[0] = 0xff;
+	data[1] = 0xff;
+	data[2] = 0xff;
+	data[3] = 0xff;
+	data[4] = 0xff;
+	data[5] = 0xff;
+	data[6] = 0xff;
+	data[7] = 0x9e;
+	data[8] = 0xe7;
+	data[9] = 0xff;
+	data[10] = 0xff;
+	data[11] = 0xff;
+	data[12] = 0xff;
+	data[13] = 0xff;
+	data[14] = 0xff;
+	data[15] = 0;
+	data[16] = 0;
+
+	uint8_t res[18];
+	send_recv(info->usb_link, cmd, 38, res, 17);
+	send_recv(info->usb_link, NULL, 0, res,  1);
+
+	if (res[0] != 0) {
+		DEBUG_WARN( "Line reset failed\n");
+		return 0;
+	}
+	ADIv5_DP_t *dp = (void*)calloc(1, sizeof(*dp));
+	if (!dp) /* calloc failed: heap exhaustion */
+		return 0;
+	volatile struct exception e;
+	TRY_CATCH (e, EXCEPTION_ALL) {
+		dp->idcode = jlink_adiv5_swdp_low_access(dp, 1, ADIV5_DP_IDCODE, 0);
+	}
+	if (e.type) {
+		DEBUG_WARN("DP not responding for IDCODE! Reset stuck low?\n");
+		free(dp);
+		return 0;
+	}
+	dp->dp_read = jlink_adiv5_swdp_read;
+	dp->error = jlink_adiv5_swdp_error;
+	dp->low_access = jlink_adiv5_swdp_low_access;
+	dp->abort = jlink_adiv5_swdp_abort;
+
+	jlink_adiv5_swdp_error(dp);
+	adiv5_dp_init(dp);
+	return target_list?1:0;
+}
+
+static uint32_t jlink_adiv5_swdp_read(ADIv5_DP_t *dp, uint16_t addr)
+{
+	if (addr & ADIV5_APnDP) {
+		adiv5_dp_low_access(dp, ADIV5_LOW_READ, addr, 0);
+		return adiv5_dp_low_access(dp, ADIV5_LOW_READ,
+		                           ADIV5_DP_RDBUFF, 0);
+	} else {
+		return jlink_adiv5_swdp_low_access(dp, ADIV5_LOW_READ, addr, 0);
+	}
+}
+
+static uint32_t jlink_adiv5_swdp_error(ADIv5_DP_t *dp)
+{
+	uint32_t err, clr = 0;
+	err = jlink_adiv5_swdp_read(dp, ADIV5_DP_CTRLSTAT) &
+		(ADIV5_DP_CTRLSTAT_STICKYORUN | ADIV5_DP_CTRLSTAT_STICKYCMP |
+		ADIV5_DP_CTRLSTAT_STICKYERR | ADIV5_DP_CTRLSTAT_WDATAERR);
+
+	if(err & ADIV5_DP_CTRLSTAT_STICKYORUN)
+		clr |= ADIV5_DP_ABORT_ORUNERRCLR;
+	if(err & ADIV5_DP_CTRLSTAT_STICKYCMP)
+		clr |= ADIV5_DP_ABORT_STKCMPCLR;
+	if(err & ADIV5_DP_CTRLSTAT_STICKYERR)
+		clr |= ADIV5_DP_ABORT_STKERRCLR;
+	if(err & ADIV5_DP_CTRLSTAT_WDATAERR)
+		clr |= ADIV5_DP_ABORT_WDERRCLR;
+	if (clr)
+		adiv5_dp_write(dp, ADIV5_DP_ABORT, clr);
+	if (dp->fault)
+		err |= 0x8000;
+	dp->fault = 0;
+
+	return err;
+}
+
+static uint32_t jlink_adiv5_swdp_low_access(ADIv5_DP_t *dp, uint8_t RnW,
+				      uint16_t addr, uint32_t value)
+{
+	bool APnDP = addr & ADIV5_APnDP;
+	uint8_t addr8 = addr & 0xff;
+	uint8_t request = 0x81;
+	uint32_t response = 0;
+	uint8_t ack;
+	platform_timeout timeout;
+
+	if(APnDP && dp->fault) return 0;
+
+	if(APnDP) request ^= 0x22;
+	if(RnW)   request ^= 0x24;
+
+	addr8 &= 0xC;
+	request |= (addr8 << 1) & 0x18;
+	if((addr8 == 4) || (addr8 == 8))
+		request ^= 0x20;
+	uint8_t cmd[16];
+	uint8_t res[8];
+	cmd[0] = CMD_HW_JTAG3;
+	cmd[1] = 0;
+	/* It seems, JLINK samples read data at end of previous clock.
+	 * So target data read must start at the 12'th clock, while
+	 * write starts as expected at the 14'th clock (8 cmd, 3 response,
+	 * 2 turn around.
+	 */
+	cmd[2] = (RnW) ? 11 : 13;
+	cmd[3] = 0;
+	cmd[4] = 0xff; /* 8 bits command OUT */
+	cmd[5] = 0xf0; /* one IN bit to turn around to read, read 2
+					  (read) or 3 (write) IN bits for response and
+					  and one OUT bit to turn around to write on write*/
+	cmd[6] = request;
+	cmd[7] = 0x00;
+	platform_timeout_set(&timeout, 2000);
+	do {
+		send_recv(info.usb_link, cmd,  8, res, 2);
+		send_recv(info.usb_link, NULL, 0, res + 2 , 1);
+		if (res[2] != 0)
+			raise_exception(EXCEPTION_ERROR, "Low access setup failed");
+		ack = res[1] & 7;
+	} while (ack == SWDP_ACK_WAIT && !platform_timeout_is_expired(&timeout));
+	if (ack == SWDP_ACK_WAIT)
+		raise_exception(EXCEPTION_TIMEOUT, "SWDP ACK timeout");
+
+	if(ack == SWDP_ACK_FAULT) {
+		if (cl_debuglevel & BMP_DEBUG_TARGET)
+			DEBUG_WARN( "Fault\n");
+		dp->fault = 1;
+		return 0;
+	}
+
+	if(ack != SWDP_ACK_OK) {
+		if (cl_debuglevel & BMP_DEBUG_TARGET)
+			DEBUG_WARN( "Protocol %d\n", ack);
+		line_reset(&info);
+		return 0;
+	}
+	/* Always append 8 idle cycle (SWDIO = 0)!*/
+	if(RnW) {
+		memset(cmd + 4, 0, 10);
+		cmd[2] = 33 + 2; /* 2 idle cycles */
+		cmd[8] = 0xfe;
+		send_recv(info.usb_link, cmd, 14, res, 5);
+		send_recv(info.usb_link, NULL, 0, res + 5, 1);
+		if (res[5] != 0)
+			raise_exception(EXCEPTION_ERROR, "Low access read failed");
+		response = res[0] | res[1] << 8 | res[2] << 16 | res[3] << 24;
+		int parity = res[4] & 1;
+		int bit_count  = __builtin_popcount (response) + parity;
+		if (bit_count & 1)	/* Give up on parity error */
+			raise_exception(EXCEPTION_ERROR, "SWDP Parity error");
+	} else {
+		cmd[2] = 33 + 8; /* 8 idle cycle  to move data through SW-DP */
+		memset(cmd + 4, 0xff, 6);
+		cmd[10] = ((value >>  0) & 0xff);
+		cmd[11] = ((value >>  8) & 0xff);
+		cmd[12] = ((value >> 16) & 0xff);
+		cmd[13] = ((value >> 24) & 0xff);
+		int bit_count  = __builtin_popcount(value);
+		cmd[14] = bit_count & 1;
+		cmd[15] = 0;
+		send_recv(info.usb_link, cmd, 16, res, 6);
+		send_recv(info.usb_link, NULL, 0, res, 1);
+		if (res[0] != 0)
+			raise_exception(EXCEPTION_ERROR, "Low access write failed");
+	}
+	return response;
+}
+
+static void jlink_adiv5_swdp_abort(ADIv5_DP_t *dp, uint32_t abort)
+{
+	adiv5_dp_write(dp, ADIV5_DP_ABORT, abort);
+}

src/platforms/hosted/jlink_jtagtap.c

@@ -0,0 +1,182 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2020 Uwe Bonnes bon@elektron.ikp.physik.tu-darmstadt.de
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Low level JTAG implementation using jlink.
+ *
+ */
+
+#include "general.h"
+#include <unistd.h>
+#include <assert.h>
+
+#include "exception.h"
+
+#include "jlink.h"
+#include "cl_utils.h"
+
+static void jtagtap_reset(void)
+{
+	jtagtap_soft_reset();
+}
+
+static void jtagtap_tms_seq(uint32_t MS, int ticks)
+{
+	DEBUG_PROBE("jtagtap_tms_seq 0x%08" PRIx32 ", ticks %d\n", MS, ticks);
+	int len = (ticks + 7) / 8;
+	uint8_t cmd[12];
+	cmd[0] = CMD_HW_JTAG3;
+	cmd[1] = 0;
+	cmd[2] = ticks;
+	cmd[3] = 0;
+	uint8_t *tms = cmd + 4;
+	for (int i = 0; i < len; i++) {
+		*tms = MS & 0xff;
+		*(tms + len) = *tms;
+		tms++;
+		MS >>= 8;
+	}
+	uint8_t res[4];
+	send_recv(info.usb_link, cmd, 4 + 2 * len, res, len);
+	send_recv(info.usb_link, NULL, 0, res, 1);
+	if (res[0] != 0)
+		raise_exception(EXCEPTION_ERROR, "tagtap_tms_seq failed");
+}
+
+static void jtagtap_tdi_tdo_seq(uint8_t *DO, const uint8_t final_tms,
+						 const uint8_t *DI, int ticks)
+{
+	if (!ticks)
+		return;
+	int len = (ticks + 7) / 8;
+	if (cl_debuglevel & BMP_DEBUG_PROBE) {
+		DEBUG_PROBE("jtagtap_tdi_tdo %s, ticks %d, DI: ",
+			   (final_tms) ? "Final TMS" : "", ticks);
+		for (int i = 0; i < len; i++) {
+			DEBUG_PROBE("%02x", DI[i]);
+		}
+		DEBUG_PROBE("\n");
+	}
+	uint8_t *cmd = alloca(4 + 2 * len);
+	cmd[0] = CMD_HW_JTAG3;
+	cmd[1] = 0;
+	cmd[2] = ticks;
+	cmd[3] = 0;
+	uint8_t *tms = cmd + 4;
+	for (int i = 0; i < len; i++)
+		*tms++ = 0;
+	if (final_tms)
+		cmd[4 + (ticks - 1) / 8] |= (1 << ((ticks - 1) % 8));
+	uint8_t *tdi = tms;
+	if (DI)
+		for (int i = 0; i < len; i++)
+			*tdi++ = DI[i];
+	if (DO)
+		send_recv(info.usb_link, cmd, 4 + 2 * len, DO, len);
+	else
+		send_recv(info.usb_link, cmd, 4 + 2 * len, cmd, len);
+	uint8_t res[1];
+	send_recv(info.usb_link, NULL, 0, res, 1);
+	if (res[0] != 0)
+		raise_exception(EXCEPTION_ERROR, "jtagtap_tdi_tdi failed");
+}
+
+static void jtagtap_tdi_seq(const uint8_t final_tms, const uint8_t *DI,
+							int ticks)
+{
+	if (cl_debuglevel & BMP_DEBUG_PROBE) {
+		DEBUG_PROBE("jtagtap_tdi_seq %s:", (final_tms)? "final_tms" : "");
+		const uint8_t *p = DI;
+		unsigned int i = (ticks & 7) & ~7 ;
+		if (i > 16)
+			i = 16;
+		while (i--)
+			DEBUG_PROBE(" %02x", *p++);
+		if (ticks > (16 * 8))
+			DEBUG_PROBE(" ...");
+		DEBUG_PROBE("\n");
+	}
+	return jtagtap_tdi_tdo_seq(NULL,  final_tms, DI, ticks);
+}
+
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI)
+{
+	DEBUG_PROBE("jtagtap_next TMS 0x%02x, TDI %02x\n", dTMS, dTDI);
+	uint8_t cmd[6];
+	cmd[0] = CMD_HW_JTAG3;
+	cmd[1] = 0;
+	cmd[2] = 1;
+	cmd[3] = 0;
+	cmd[4] = (dTMS) ? 0xff : 0;
+	cmd[5] = (dTDI) ? 0xff : 0;
+	uint8_t ret[1];
+	send_recv(info.usb_link, cmd, 6, ret, 1);
+	uint8_t res[1];
+	send_recv(info.usb_link, NULL, 0, res, 1);
+	if (res[0] != 0)
+		raise_exception(EXCEPTION_ERROR, "jtagtap_next failed");
+	return (ret[0] & 1);
+}
+
+int jlink_jtagtap_init(bmp_info_t *info, jtag_proc_t *jtag_proc)
+{
+	DEBUG_PROBE("jtap_init\n");
+	uint8_t cmd_switch[2] = {CMD_GET_SELECT_IF, JLINK_IF_GET_AVAILABLE};
+	uint8_t res[4];
+	send_recv(info->usb_link, cmd_switch, 2, res, sizeof(res));
+	if (!(res[0] & JLINK_IF_JTAG)) {
+		DEBUG_WARN("JTAG not available\n");
+		return -1;
+	}
+	cmd_switch[1] = SELECT_IF_JTAG;
+	send_recv(info->usb_link, cmd_switch, 2, res, sizeof(res));
+	platform_delay(10);
+	/* Set speed 256 kHz*/
+	unsigned int speed = 2000;
+	uint8_t jtag_speed[3] = {5, speed & 0xff, speed >> 8};
+	send_recv(info->usb_link, jtag_speed, 3, NULL, 0);
+	uint8_t cmd[44];
+	cmd[0]  = CMD_HW_JTAG3;
+	cmd[1]  = 0;
+	/* write 8 Bytes.*/
+	cmd[2]  = 9 * 8;
+	cmd[3]  = 0;
+	uint8_t *tms = cmd + 4;
+	tms[0]  = 0xff;
+	tms[1]  = 0xff;
+	tms[2]  = 0xff;
+	tms[3]  = 0xff;
+	tms[4]  = 0xff;
+	tms[5]  = 0xff;
+	tms[6]  = 0xff;
+	tms[7]  = 0x3c;
+	tms[8]  = 0xe7;
+	send_recv(info->usb_link, cmd, 4 + 2 * 9, cmd, 9);
+	send_recv(info->usb_link, NULL, 0, res,  1);
+
+	if (res[0] != 0) {
+		DEBUG_WARN("Switch to JTAG failed\n");
+		return 0;
+	}
+	jtag_proc->jtagtap_reset = jtagtap_reset;
+	jtag_proc->jtagtap_next =jtagtap_next;
+	jtag_proc->jtagtap_tms_seq = jtagtap_tms_seq;
+	jtag_proc->jtagtap_tdi_tdo_seq = jtagtap_tdi_tdo_seq;
+	jtag_proc->jtagtap_tdi_seq = jtagtap_tdi_seq;
+	return 0;
+}

src/platforms/hosted/libftdi_jtagtap.c

@@ -0,0 +1,129 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2008  Black Sphere Technologies Ltd.
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Low level JTAG implementation using FT2232 with libftdi.
+ *
+ */
+
+#include "general.h"
+#include <unistd.h>
+#include <assert.h>
+#include <ftdi.h>
+#include "ftdi_bmp.h"
+
+
+extern cable_desc_t *active_cable;
+extern struct ftdi_context *ftdic;
+
+static void jtagtap_reset(void);
+static void jtagtap_tms_seq(uint32_t MS, int ticks);
+static void jtagtap_tdi_seq(
+	const uint8_t final_tms, const uint8_t *DI, int ticks);
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI);
+
+int libftdi_jtagtap_init(jtag_proc_t *jtag_proc)
+{
+	if ((active_cable->mpsse_swd_read.set_data_low == MPSSE_DO) &&
+		(active_cable->mpsse_swd_write.set_data_low == MPSSE_DO)) {
+		printf("Jtag not possible with resistor SWD!\n");
+			return -1;
+	}
+	jtag_proc->jtagtap_reset = jtagtap_reset;
+	jtag_proc->jtagtap_next =jtagtap_next;
+	jtag_proc->jtagtap_tms_seq = jtagtap_tms_seq;
+	jtag_proc->jtagtap_tdi_tdo_seq = libftdi_jtagtap_tdi_tdo_seq;
+	jtag_proc->jtagtap_tdi_seq = jtagtap_tdi_seq;
+
+	active_state.data_low  |=   active_cable->jtag.set_data_low |
+		MPSSE_CS | MPSSE_DI | MPSSE_DO;
+	active_state.data_low  &= ~(active_cable->jtag.clr_data_low | MPSSE_SK);
+	active_state.ddr_low   |=   MPSSE_CS | MPSSE_DO | MPSSE_SK;
+	active_state.ddr_low   &= ~(MPSSE_DI);
+	active_state.data_high |=   active_cable->jtag.set_data_high;
+	active_state.data_high &= ~(active_cable->jtag.clr_data_high);
+	uint8_t gab[16];
+	int garbage =  ftdi_read_data(ftdic, gab, sizeof(gab));
+	if (garbage > 0) {
+		DEBUG_WARN("FTDI JTAG init got garbage:");
+		for (int i = 0; i < garbage; i++)
+			DEBUG_WARN(" %02x", gab[i]);
+		DEBUG_WARN("\n");
+	}
+	uint8_t cmd_write[16] = {
+		SET_BITS_LOW,  active_state.data_low,
+		active_state.ddr_low,
+		SET_BITS_HIGH, active_state.data_high, active_state.ddr_high};
+	libftdi_buffer_write(cmd_write, 6);
+	libftdi_buffer_flush();
+	/* Write out start condition and pull garbage from read buffer.
+	 * FT2232D otherwise misbehaves on runs follwoing the first run.*/
+	garbage =  ftdi_read_data(ftdic, cmd_write, sizeof(cmd_write));
+	if (garbage > 0) {
+		DEBUG_WARN("FTDI JTAG end init got garbage:");
+		for (int i = 0; i < garbage; i++)
+			DEBUG_WARN(" %02x", cmd_write[i]);
+		DEBUG_WARN("\n");
+	}
+	/* Go to JTAG mode for SWJ-DP */
+	for (int i = 0; i <= 50; i++)
+		jtag_proc->jtagtap_next(1, 0);          /* Reset SW-DP */
+	jtag_proc->jtagtap_tms_seq(0xE73C, 16);		/* SWD to JTAG sequence */
+	jtag_proc->jtagtap_tms_seq(0x1F, 6);
+
+	return 0;
+}
+
+static void jtagtap_reset(void)
+{
+	jtagtap_soft_reset();
+}
+
+static void jtagtap_tms_seq(uint32_t MS, int ticks)
+{
+	uint8_t tmp[3] = {
+		MPSSE_WRITE_TMS | MPSSE_LSB | MPSSE_BITMODE | MPSSE_WRITE_NEG, 0, 0};
+	while(ticks >= 0) {
+		tmp[1] = ticks<7?ticks-1:6;
+		tmp[2] = 0x80 | (MS & 0x7F);
+
+		libftdi_buffer_write(tmp, 3);
+		MS >>= 7; ticks -= 7;
+	}
+}
+
+static void jtagtap_tdi_seq(
+	const uint8_t final_tms, const uint8_t *DI, int ticks)
+{
+	return libftdi_jtagtap_tdi_tdo_seq(NULL,  final_tms, DI, ticks);
+}
+
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI)
+{
+	uint8_t ret;
+	uint8_t tmp[3] = {MPSSE_WRITE_TMS | MPSSE_DO_READ | MPSSE_LSB |
+					  MPSSE_BITMODE | MPSSE_WRITE_NEG, 0, 0};
+	tmp[2] = (dTDI?0x80:0) | (dTMS?0x01:0);
+	libftdi_buffer_write(tmp, 3);
+	libftdi_buffer_read(&ret, 1);
+
+	ret &= 0x80;
+
+	return ret;
+}

src/platforms/hosted/libftdi_swdptap.c

@@ -0,0 +1,413 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright(C) 2018 - 2021 Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* MPSSE bit-banging SW-DP interface over FTDI with loop unrolled.
+ * Speed is sensible.
+ */
+
+#include "general.h"
+#include <assert.h>
+
+#include <ftdi.h>
+#include "ftdi_bmp.h"
+
+enum  swdio_status{
+	SWDIO_STATUS_DRIVE = 0,
+	SWDIO_STATUS_FLOAT,
+};
+
+static enum swdio_status olddir;
+static bool do_mpsse;
+static bool direct_bb_swd;
+
+#define MPSSE_MASK (MPSSE_DO | MPSSE_DI | MPSSE_CS)
+#define MPSSE_TD_MASK (MPSSE_DO | MPSSE_DI)
+#define MPSSE_TMS_SHIFT (MPSSE_WRITE_TMS | MPSSE_LSB |\
+						 MPSSE_BITMODE | MPSSE_WRITE_NEG)
+#define MPSSE_TDO_SHIFT (MPSSE_DO_WRITE | MPSSE_LSB |\
+						 MPSSE_BITMODE | MPSSE_WRITE_NEG)
+static void swdptap_turnaround(enum swdio_status dir)
+{
+	if (dir == olddir)
+		return;
+	olddir = dir;
+	DEBUG_PROBE("Turnaround %s\n", (dir == SWDIO_STATUS_FLOAT) ? "float": "drive");
+	if (do_mpsse) {
+		if (dir == SWDIO_STATUS_FLOAT)	/* SWDIO goes to input */ {
+			active_state.data_low |=  active_cable->mpsse_swd_read.set_data_low | MPSSE_DO;
+			active_state.data_low &= ~active_cable->mpsse_swd_read.clr_data_low;
+			active_state.ddr_low &= ~MPSSE_DO;
+			active_state.data_high |=  active_cable->mpsse_swd_read.set_data_high;
+			active_state.data_high &= ~active_cable->mpsse_swd_read.clr_data_high;
+			uint8_t cmd_read[6] = {
+				SET_BITS_LOW,  active_state.data_low,
+				active_state.ddr_low,
+				SET_BITS_HIGH, active_state.data_high, active_state.ddr_high};
+			libftdi_buffer_write(cmd_read, 6);
+		}
+		uint8_t cmd[] = {MPSSE_TDO_SHIFT, 0, 0}; /* One clock cycle */
+		libftdi_buffer_write(cmd, sizeof(cmd));
+		if (dir == SWDIO_STATUS_DRIVE)  /* SWDIO goes to output */ {
+			active_state.data_low |=  active_cable->mpsse_swd_write.set_data_low | MPSSE_DO;
+			active_state.data_low &= ~active_cable->mpsse_swd_write.clr_data_low;
+			active_state.ddr_low |= MPSSE_DO;
+			active_state.data_high |=  active_cable->mpsse_swd_write.set_data_high;
+			active_state.data_high &= ~active_cable->mpsse_swd_write.clr_data_high;
+			uint8_t cmd_write[6] = {
+				SET_BITS_LOW,  active_state.data_low,
+				active_state.ddr_low,
+				SET_BITS_HIGH, active_state.data_high, active_state.ddr_high};
+			libftdi_buffer_write(cmd_write, 6);
+		}
+	} else {
+		uint8_t cmd[9];
+		int index = 0;
+
+		if(dir == SWDIO_STATUS_FLOAT)	  { /* SWDIO goes to input */
+			if (direct_bb_swd) {
+				active_state.data_low |=  MPSSE_CS;
+				active_state.ddr_low  &= ~MPSSE_CS;
+			} else {
+				active_state.data_low  |=  active_cable->bb_swd_read.set_data_low;
+				active_state.data_low  &= ~active_cable->bb_swd_read.clr_data_low;
+				active_state.data_high |=  active_cable->bb_swd_read.set_data_high;
+				active_state.data_high &= ~active_cable->bb_swd_read.clr_data_high;
+			}
+			cmd[index++] = SET_BITS_LOW;
+			cmd[index++] = active_state.data_low;
+			cmd[index++] = active_state.ddr_low;
+			cmd[index++] = SET_BITS_HIGH;
+			cmd[index++] = active_state.data_high;
+			cmd[index++] = active_state.ddr_high;
+		}
+		/* One clock cycle */
+		cmd[index++] = MPSSE_TMS_SHIFT;
+		cmd[index++] = 0;
+		cmd[index++] = 0;
+		if (dir == SWDIO_STATUS_DRIVE) {
+			if (direct_bb_swd) {
+				active_state.data_low |=  MPSSE_CS;
+				active_state.ddr_low  |=  MPSSE_CS;
+			} else {
+				active_state.data_low  |=  active_cable->bb_swd_write.set_data_low;
+				active_state.data_low  &= ~active_cable->bb_swd_write.clr_data_low;
+				active_state.data_high |=  active_cable->bb_swd_write.set_data_high;
+				active_state.data_high &= ~active_cable->bb_swd_write.clr_data_high;
+			}
+			cmd[index++] = SET_BITS_LOW;
+			cmd[index++] = active_state.data_low;
+			cmd[index++] = active_state.ddr_low;
+			cmd[index++] = SET_BITS_HIGH;
+			cmd[index++] = active_state.data_high;
+			cmd[index++] = active_state.ddr_high;
+		}
+		libftdi_buffer_write(cmd, index);
+	}
+}
+
+static bool swdptap_seq_in_parity(uint32_t *res, int ticks);
+static uint32_t swdptap_seq_in(int ticks);
+static void swdptap_seq_out(uint32_t MS, int ticks);
+static void swdptap_seq_out_parity(uint32_t MS, int ticks);
+
+bool libftdi_swd_possible(bool *do_mpsse, bool *direct_bb_swd)
+{
+	bool swd_read =
+		active_cable->mpsse_swd_read.set_data_low ||
+		active_cable->mpsse_swd_read.clr_data_low ||
+		active_cable->mpsse_swd_read.set_data_high ||
+		active_cable->mpsse_swd_read.clr_data_high;
+	bool swd_write =
+		active_cable->mpsse_swd_write.set_data_low ||
+		active_cable->mpsse_swd_write.clr_data_low ||
+		active_cable->mpsse_swd_write.set_data_high ||
+		active_cable->mpsse_swd_write.clr_data_high;
+	bool mpsse = swd_read && swd_write;
+	if (do_mpsse)
+		*do_mpsse = mpsse;
+	if (!mpsse) {
+		bool bb_swd_read =
+			active_cable->bb_swd_read.set_data_low ||
+			active_cable->bb_swd_read.clr_data_low ||
+			active_cable->bb_swd_read.set_data_high ||
+			active_cable->bb_swd_read.clr_data_high;
+		bool bb_swd_write =
+			active_cable->bb_swd_write.set_data_low ||
+			active_cable->bb_swd_write.clr_data_low ||
+			active_cable->bb_swd_write.set_data_high ||
+			active_cable->bb_swd_write.clr_data_high;
+		bool bb_direct_possible =
+			active_cable->bb_swdio_in_port_cmd == GET_BITS_LOW &&
+			active_cable->bb_swdio_in_pin == MPSSE_CS;
+		if (!bb_swd_read && !bb_swd_write) {
+			if (!bb_direct_possible)
+				return false;
+		}
+		if (direct_bb_swd)
+			*direct_bb_swd = true;
+	}
+	return true;
+}
+
+int libftdi_swdptap_init(ADIv5_DP_t *dp)
+{
+	if (!libftdi_swd_possible(&do_mpsse, &direct_bb_swd)) {
+		DEBUG_WARN("SWD not possible or missing item in cable description.\n");
+		return -1;
+	}
+	active_state.data_low |=   MPSSE_CS | MPSSE_DI | MPSSE_DO;
+	active_state.data_low &=   MPSSE_SK;
+	active_state.ddr_low  |=   MPSSE_SK;
+	active_state.ddr_low  &= ~(MPSSE_CS | MPSSE_DI | MPSSE_DO);
+	if (do_mpsse) {
+		DEBUG_INFO("Using genuine MPSSE for SWD.\n");
+		active_state.data_low  |=   active_cable->mpsse_swd_read.set_data_low;
+		active_state.data_low  &= ~(active_cable->mpsse_swd_read.clr_data_low);
+		active_state.data_high |=   active_cable->mpsse_swd_read.set_data_high;
+		active_state.data_high &= ~(active_cable->mpsse_swd_read.clr_data_high);
+	} else if (direct_bb_swd) {
+		DEBUG_INFO("Using direct bitbang with SWDIO %cBUS%d.\n",
+				   (active_cable->bb_swdio_in_port_cmd == GET_BITS_LOW) ? 'C' : 'D',
+				   __builtin_ctz(active_cable->bb_swdio_in_pin));
+	} else {
+		DEBUG_INFO("Using switched bitbang for SWD.\n");
+		active_state.data_low  |=   active_cable->bb_swd_read.set_data_low;
+		active_state.data_low  &= ~(active_cable->bb_swd_read.clr_data_low);
+		active_state.data_high |=   active_cable->bb_swd_read.set_data_high;
+		active_state.data_high &= ~(active_cable->bb_swd_read.clr_data_high);
+		active_state.ddr_low  |=  MPSSE_CS;
+		if (active_cable->bb_swdio_in_port_cmd == GET_BITS_LOW)
+			active_state.ddr_low  &= ~active_cable->bb_swdio_in_pin;
+		else if (active_cable->bb_swdio_in_port_cmd == GET_BITS_HIGH)
+			active_state.ddr_high &= ~active_cable->bb_swdio_in_pin;
+	}
+	uint8_t cmd_write[6] = {
+		SET_BITS_LOW,  active_state.data_low,
+		active_state.ddr_low,
+		SET_BITS_HIGH, active_state.data_high, active_state.ddr_high};
+	libftdi_buffer_write(cmd_write, 6);
+	libftdi_buffer_flush();
+	olddir = SWDIO_STATUS_FLOAT;
+
+	dp->seq_in  = swdptap_seq_in;
+	dp->seq_in_parity  = swdptap_seq_in_parity;
+	dp->seq_out = swdptap_seq_out;
+	dp->seq_out_parity  = swdptap_seq_out_parity;
+	dp->dp_read = firmware_swdp_read;
+	dp->error = firmware_swdp_error;
+	dp->low_access = firmware_swdp_low_access;
+	dp->abort = firmware_swdp_abort;
+	return 0;
+}
+
+bool swdptap_bit_in(void)
+{
+	swdptap_turnaround(SWDIO_STATUS_FLOAT);
+	uint8_t cmd[4];
+	int index = 0;
+	bool result = false;
+
+	if (do_mpsse) {
+		uint8_t cmd[2] = {MPSSE_DO_READ | MPSSE_LSB | MPSSE_BITMODE, 0};
+		libftdi_buffer_write(cmd, sizeof(cmd));
+		uint8_t data[1];
+		libftdi_buffer_read(data, sizeof(data));
+		result = (data[0] & 0x80);
+	} else {
+		cmd[index++] = active_cable->bb_swdio_in_port_cmd;
+		cmd[index++] = MPSSE_TMS_SHIFT;
+		cmd[index++] = 0;
+		cmd[index++] = 0;
+		libftdi_buffer_write(cmd, index);
+		uint8_t data[1];
+		libftdi_buffer_read(data, sizeof(data));
+		result = (data[0] &= active_cable->bb_swdio_in_pin);
+	}
+	return result;
+}
+
+void swdptap_bit_out(bool val)
+{
+	swdptap_turnaround(SWDIO_STATUS_DRIVE);
+	if (do_mpsse) {
+		uint8_t cmd[3] = {MPSSE_TDO_SHIFT, 0, (val)? 1:0};
+		libftdi_buffer_write(cmd, sizeof(cmd));
+	} else {
+		uint8_t cmd[3];
+		cmd[0] = MPSSE_TMS_SHIFT;
+		cmd[1] = 0;
+		cmd[2] = (val)? 1 : 0;
+		libftdi_buffer_write(cmd, sizeof(cmd));
+	}
+}
+
+bool swdptap_seq_in_parity(uint32_t *res, int ticks)
+{
+	assert(ticks == 32);
+	swdptap_turnaround(SWDIO_STATUS_FLOAT);
+	unsigned int parity = 0;
+	unsigned int result = 0;
+	if (do_mpsse) {
+		uint8_t DO[5];
+		libftdi_jtagtap_tdi_tdo_seq(DO, 0, NULL, ticks + 1);
+		result = DO[0] + (DO[1] << 8) + (DO[2] << 16) + (DO[3] << 24);
+		parity =  __builtin_parity(result & ((1LL << ticks) - 1)) & 1;
+		parity ^= DO[4] & 1;
+	} else {
+		int index = ticks + 1;
+		uint8_t cmd[4];
+
+		cmd[0] = active_cable->bb_swdio_in_port_cmd;
+		cmd[1] = MPSSE_TMS_SHIFT;
+		cmd[2] = 0;
+		cmd[3] = 0;
+		while (index--) {
+			libftdi_buffer_write(cmd, sizeof(cmd));
+		}
+		uint8_t data[33];
+		libftdi_buffer_read(data, ticks + 1);
+		if (data[ticks] & active_cable->bb_swdio_in_pin)
+			parity ^= 1;
+		index = ticks;
+		while (index--) {
+			if (data[index] & active_cable->bb_swdio_in_pin) {
+				parity ^= 1;
+				result |= (1 << index);
+			}
+		}
+	}
+	*res = result;
+	return parity;
+}
+
+static uint32_t swdptap_seq_in(int ticks)
+{
+	if (!ticks)
+		return 0;
+	uint32_t result = 0;
+	swdptap_turnaround(SWDIO_STATUS_FLOAT);
+	if (do_mpsse) {
+		uint8_t DO[4];
+		libftdi_jtagtap_tdi_tdo_seq(DO, 0, NULL, ticks);
+		int bytes = ticks >> 3;
+		if (ticks & 7)
+			bytes++;
+		for (int i = 0; i < bytes; i++) {
+			result |= DO[i] << (8 * i);
+		}
+	} else {
+		int index = ticks;
+		uint8_t cmd[4];
+
+		cmd[0] = active_cable->bb_swdio_in_port_cmd;
+		cmd[1] = MPSSE_TMS_SHIFT;
+		cmd[2] = 0;
+		cmd[3] = 0;
+
+		while (index--) {
+			libftdi_buffer_write(cmd, sizeof(cmd));
+		}
+		uint8_t data[32];
+		libftdi_buffer_read(data, ticks);
+		index = ticks;
+		while (index--) {
+			if (data[index] & active_cable->bb_swdio_in_pin)
+				result |= (1 << index);
+		}
+	}
+	return result;
+}
+
+static void swdptap_seq_out(uint32_t MS, int ticks)
+{
+	if (!ticks)
+		return;
+	swdptap_turnaround(SWDIO_STATUS_DRIVE);
+	if (do_mpsse) {
+		uint8_t DI[4];
+		DI[0] = (MS >>  0) & 0xff;
+		DI[1] = (MS >>  8) & 0xff;
+		DI[2] = (MS >> 16) & 0xff;
+		DI[3] = (MS >> 24) & 0xff;
+		libftdi_jtagtap_tdi_tdo_seq(NULL, 0, DI, ticks);
+	} else {
+		uint8_t cmd[16];
+		unsigned int index = 0;
+		while (ticks) {
+			cmd[index++] = MPSSE_TMS_SHIFT;
+			if (ticks >= 7) {
+				cmd[index++] = 6;
+				cmd[index++] = MS & 0x7f;
+				MS >>= 7;
+				ticks -= 7;
+			} else {
+				cmd[index++] = ticks - 1;
+				cmd[index++] = MS & 0x7f;
+				ticks = 0;
+			}
+		}
+		libftdi_buffer_write(cmd, index);
+	}
+}
+
+/* ARM Debug Interface Architecture Specification ADIv5.0 to ADIv5.2
+ * tells to clock the data through SW-DP to either :
+ * - immediate start a new transaction
+ * - continue to drive idle cycles
+ * - or clock at least 8 idle cycles
+ *
+ * Implement last option to favour correctness over
+ *   slight speed decrease
+ */
+static void swdptap_seq_out_parity(uint32_t MS, int ticks)
+{
+	(void) ticks;
+	int parity = __builtin_parity(MS) & 1;
+	unsigned int index = 0;
+	swdptap_turnaround(SWDIO_STATUS_DRIVE);
+	if (do_mpsse) {
+		uint8_t DI[8];
+		DI[0] = (MS >>  0) & 0xff;
+		DI[1] = (MS >>  8) & 0xff;
+		DI[2] = (MS >> 16) & 0xff;
+		DI[3] = (MS >> 24) & 0xff;
+		DI[4] = parity;
+		DI[5] = 0;
+		libftdi_jtagtap_tdi_tdo_seq(NULL, 0, DI, 32 + 1 + 8);
+	} else {
+		uint8_t cmd[32];
+		int steps = ticks;
+		while (steps) {
+			cmd[index++] = MPSSE_TMS_SHIFT;
+			cmd[index++] = 6;
+			if (steps >= 7) {
+				cmd[index++] = MS & 0x7f;
+				MS >>= 7;
+				steps -= 7;
+			} else {
+				cmd[index++] = (MS & 0x7f) | (parity << 4);
+				steps = 0;
+			}
+		}
+		cmd[index++] = MPSSE_TMS_SHIFT;
+		cmd[index++] = 4;
+		cmd[index++] = 0;
+		libftdi_buffer_write(cmd, index);
+	}
+}

src/platforms/hosted/platform.c

@@ -0,0 +1,556 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2020- 2021 Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Handle different BMP pc-hosted platforms/
+ */
+
+#include "general.h"
+#include "jtagtap.h"
+#include "target.h"
+#include "target_internal.h"
+#include "adiv5.h"
+#include "timing.h"
+#include "cl_utils.h"
+#include "gdb_if.h"
+#include <signal.h>
+
+#ifdef ENABLE_RTT
+#include "rtt_if.h"
+#endif
+
+#include "bmp_remote.h"
+#include "bmp_hosted.h"
+#include "stlinkv2.h"
+#include "ftdi_bmp.h"
+#include "jlink.h"
+#include "cmsis_dap.h"
+#include "cl_utils.h"
+
+bmp_info_t info;
+
+jtag_proc_t jtag_proc;
+
+void gdb_ident(char *p, int count)
+{
+	snprintf(p, count, "%s (%s), %s", info.manufacturer, info.product,
+			 info.version);
+}
+
+static void exit_function(void)
+{
+	libusb_exit_function(&info);
+	switch (info.bmp_type) {
+	case BMP_TYPE_CMSIS_DAP:
+		dap_exit_function();
+		break;
+	default:
+		break;
+	}
+	#ifdef ENABLE_RTT
+	rtt_if_exit();
+	#endif
+	fflush(stdout);
+}
+
+/* SIGTERM handler. */
+static void sigterm_handler(int sig)
+{
+	(void)sig;
+	exit(0);
+}
+
+static	BMP_CL_OPTIONS_t cl_opts;
+
+void platform_init(int argc, char **argv)
+{
+	cl_init(&cl_opts, argc, argv);
+	atexit(exit_function);
+	signal(SIGTERM, sigterm_handler);
+	signal(SIGINT, sigterm_handler);
+	if (cl_opts.opt_device)
+		info.bmp_type = BMP_TYPE_BMP;
+	else if (find_debuggers(&cl_opts, &info))
+		exit(-1);
+	bmp_ident(&info);
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		if (serial_open(&cl_opts, info.serial))
+			exit(-1);
+		remote_init();
+		break;
+	case BMP_TYPE_STLINKV2:
+		if (stlink_init(&info))
+			exit(-1);
+		break;
+	case BMP_TYPE_CMSIS_DAP:
+		if (dap_init(&info))
+			exit(-1);
+		break;
+	case BMP_TYPE_LIBFTDI:
+		if (ftdi_bmp_init(&cl_opts, &info))
+			exit(-1);
+		break;
+	case BMP_TYPE_JLINK:
+		if (jlink_init(&info))
+			exit(-1);
+		break;
+	default:
+		exit(-1);
+	}
+	if (cl_opts.opt_mode != BMP_MODE_DEBUG)
+		exit(cl_execute(&cl_opts));
+	else {
+		gdb_if_init();
+		#ifdef ENABLE_RTT
+		rtt_if_init();
+		#endif
+		return;
+	}
+}
+
+int platform_adiv5_swdp_scan(uint32_t targetid)
+{
+	info.is_jtag = false;
+	platform_max_frequency_set(cl_opts.opt_max_swj_frequency);
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+	case BMP_TYPE_LIBFTDI:
+	case BMP_TYPE_CMSIS_DAP:
+		return adiv5_swdp_scan(targetid);
+		break;
+	case BMP_TYPE_STLINKV2:
+	{
+		target_list_free();
+		ADIv5_DP_t *dp = (void*)calloc(1, sizeof(*dp));
+		if (stlink_enter_debug_swd(&info, dp)) {
+			free(dp);
+		} else {
+			adiv5_dp_init(dp);
+			if (target_list)
+				return 1;
+		}
+		break;
+	}
+	case BMP_TYPE_JLINK:
+		return jlink_swdp_scan(&info);
+	default:
+		return 0;
+	}
+	return 0;
+}
+
+int swdptap_init(ADIv5_DP_t *dp)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		return remote_swdptap_init(dp);
+	case BMP_TYPE_CMSIS_DAP:
+		return dap_swdptap_init(dp);
+	case BMP_TYPE_STLINKV2:
+	case BMP_TYPE_JLINK:
+		return 0;
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_swdptap_init(dp);
+	default:
+		return -1;
+	}
+	return -1;
+}
+
+void platform_add_jtag_dev(int i, const jtag_dev_t *jtag_dev)
+{
+	if (info.bmp_type == BMP_TYPE_BMP)
+		remote_add_jtag_dev(i, jtag_dev);
+}
+
+int platform_jtag_scan(const uint8_t *lrlens)
+{
+	info.is_jtag = true;
+	platform_max_frequency_set(cl_opts.opt_max_swj_frequency);
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+	case BMP_TYPE_LIBFTDI:
+	case BMP_TYPE_JLINK:
+	case BMP_TYPE_CMSIS_DAP:
+		return jtag_scan(lrlens);
+	case BMP_TYPE_STLINKV2:
+		return jtag_scan_stlinkv2(&info, lrlens);
+	default:
+		return -1;
+	}
+	return -1;
+}
+
+int platform_jtagtap_init(void)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		return remote_jtagtap_init(&jtag_proc);
+	case BMP_TYPE_STLINKV2:
+		return 0;
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_jtagtap_init(&jtag_proc);
+	case BMP_TYPE_JLINK:
+		return jlink_jtagtap_init(&info, &jtag_proc);
+	case BMP_TYPE_CMSIS_DAP:
+		return cmsis_dap_jtagtap_init(&jtag_proc);
+	default:
+		return -1;
+	}
+	return -1;
+}
+
+void platform_adiv5_dp_defaults(ADIv5_DP_t *dp)
+{
+	dp->dp_bmp_type = info.bmp_type;
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		if (cl_opts.opt_no_hl) {
+			DEBUG_WARN("Not using HL commands\n");
+			return;
+		}
+		return remote_adiv5_dp_defaults(dp);
+	case BMP_TYPE_STLINKV2:
+		return stlink_adiv5_dp_defaults(dp);
+	case BMP_TYPE_CMSIS_DAP:
+		return dap_adiv5_dp_defaults(dp);
+	default:
+		break;
+	}
+}
+
+int platform_jtag_dp_init(ADIv5_DP_t *dp)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+	case BMP_TYPE_LIBFTDI:
+	case BMP_TYPE_JLINK:
+		return 0;
+	case BMP_TYPE_STLINKV2:
+		return stlink_jtag_dp_init(dp);
+	case BMP_TYPE_CMSIS_DAP:
+		return dap_jtag_dp_init(dp);
+	default:
+		return 0;
+	}
+	return 0;
+}
+
+char *platform_ident(void)
+{
+	switch (info.bmp_type) {
+	  case BMP_TYPE_NONE:
+		return "NONE";
+	  case BMP_TYPE_BMP:
+		return "BMP";
+	  case BMP_TYPE_STLINKV2:
+		return "STLINKV2";
+	  case BMP_TYPE_LIBFTDI:
+		return "LIBFTDI";
+	  case BMP_TYPE_CMSIS_DAP:
+		return "CMSIS_DAP";
+	  case BMP_TYPE_JLINK:
+		return "JLINK";
+	}
+	return NULL;
+}
+
+const char *platform_target_voltage(void)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		return remote_target_voltage();
+	case BMP_TYPE_STLINKV2:
+		return stlink_target_voltage(&info);
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_target_voltage();
+	case BMP_TYPE_JLINK:
+		return jlink_target_voltage(&info);
+	default:
+		break;
+	}
+	return NULL;
+}
+
+void platform_srst_set_val(bool assert)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_STLINKV2:
+		return stlink_srst_set_val(&info, assert);
+	case BMP_TYPE_BMP:
+		return remote_srst_set_val(assert);
+	case BMP_TYPE_JLINK:
+		return jlink_srst_set_val(&info, assert);
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_srst_set_val(assert);
+	case BMP_TYPE_CMSIS_DAP:
+		return dap_srst_set_val(assert);
+	default:
+		break;
+	}
+}
+
+bool platform_srst_get_val(void)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		return remote_srst_get_val();
+	case BMP_TYPE_STLINKV2:
+		return stlink_srst_get_val();
+	case BMP_TYPE_JLINK:
+		return jlink_srst_get_val(&info);
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_srst_get_val();
+	default:
+		break;
+	}
+	return false;
+}
+
+void platform_max_frequency_set(uint32_t freq)
+{
+	if (!freq)
+		return;
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		remote_max_frequency_set(freq);
+		break;
+	case BMP_TYPE_CMSIS_DAP:
+		dap_swj_clock(freq);
+		break;
+	case BMP_TYPE_LIBFTDI:
+		libftdi_max_frequency_set(freq);
+		break;
+	case BMP_TYPE_STLINKV2:
+		stlink_max_frequency_set(&info, freq);
+		break;
+	case BMP_TYPE_JLINK:
+		jlink_max_frequency_set(&info, freq);
+		break;
+	default:
+		DEBUG_WARN("Setting max SWJ frequency not yet implemented\n");
+		break;
+	}
+	uint32_t max_freq = platform_max_frequency_get();
+	if (max_freq == FREQ_FIXED)
+		DEBUG_INFO("Device has fixed frequency for %s\n",
+				   (info.is_jtag) ? "JTAG" : "SWD" );
+	else
+		DEBUG_INFO("Speed set to %7.4f MHz for %s\n",
+				   platform_max_frequency_get() / 1000000.0,
+				   (info.is_jtag) ? "JTAG" : "SWD" );
+}
+
+uint32_t platform_max_frequency_get(void)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		return remote_max_frequency_get();
+	case BMP_TYPE_CMSIS_DAP:
+		return dap_swj_clock(0);
+		break;
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_max_frequency_get();
+	case BMP_TYPE_STLINKV2:
+		return stlink_max_frequency_get(&info);
+	case BMP_TYPE_JLINK:
+		return jlink_max_frequency_get(&info);
+	default:
+		DEBUG_WARN("Reading max SWJ frequency not yet implemented\n");
+		break;
+	}
+	return false;
+}
+
+void platform_target_set_power(bool power)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_BMP:
+		if (remote_target_set_power(power))
+			DEBUG_INFO("Powering up device!\n");
+		else
+			DEBUG_WARN("Powering up device unimplemented or failed\n");
+	   break;
+	default:
+		break;
+	}
+}
+
+void platform_buffer_flush(void)
+{
+	switch (info.bmp_type) {
+	case BMP_TYPE_LIBFTDI:
+		return libftdi_buffer_flush();
+	default:
+		break;
+	}
+}
+
+static void ap_decode_access(uint16_t addr, uint8_t RnW)
+{
+	if (RnW)
+		fprintf(stderr, "Read  ");
+	else
+		fprintf(stderr, "Write ");
+	if (addr < 0x100) {
+		switch(addr) {
+		case 0x00:
+			if (RnW)
+				fprintf(stderr, "DP_DPIDR :");
+			else
+				fprintf(stderr, "DP_ABORT :");
+			break;
+		case 0x04: fprintf(stderr, "CTRL/STAT:");
+			break;
+		case 0x08:
+			if (RnW)
+				fprintf(stderr, "RESEND   :");
+			else
+				fprintf(stderr, "DP_SELECT:");
+			break;
+		case 0x0c: fprintf(stderr, "DP_RDBUFF:");
+			break;
+		default: fprintf(stderr, "Unknown %02x   :", addr);
+		}
+	} else {
+		fprintf(stderr, "AP 0x%02x ", addr >> 8);
+		switch (addr & 0xff) {
+		case 0x00: fprintf(stderr, "CSW   :");
+			break;
+		case 0x04: fprintf(stderr, "TAR   :");
+			break;
+		case 0x0c: fprintf(stderr, "DRW   :");
+			break;
+		case 0x10: fprintf(stderr, "DB0   :");
+			break;
+		case 0x14: fprintf(stderr, "DB1   :");
+			break;
+		case 0x18: fprintf(stderr, "DB2   :");
+			break;
+		case 0x1c: fprintf(stderr, "DB3   :");
+			break;
+		case 0xf8: fprintf(stderr, "BASE  :");
+			break;
+		case 0xf4: fprintf(stderr, "CFG   :");
+			break;
+		case 0xfc: fprintf(stderr, "IDR   :");
+			break;
+		default:   fprintf(stderr, "RSVD%02x:", addr & 0xff);
+		}
+	}
+}
+
+void adiv5_dp_write(ADIv5_DP_t *dp, uint16_t addr, uint32_t value)
+{
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		ap_decode_access(addr, ADIV5_LOW_WRITE);
+		fprintf(stderr, " 0x%08" PRIx32 "\n", value);
+	}
+	dp->low_access(dp, ADIV5_LOW_WRITE, addr, value);
+}
+
+uint32_t adiv5_dp_read(ADIv5_DP_t *dp, uint16_t addr)
+{
+	uint32_t ret = dp->dp_read(dp, addr);
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		ap_decode_access(addr, ADIV5_LOW_READ);
+		fprintf(stderr, " 0x%08" PRIx32 "\n", ret);
+	}
+	return ret;
+}
+
+uint32_t adiv5_dp_error(ADIv5_DP_t *dp)
+{
+	uint32_t ret = dp->error(dp);
+	DEBUG_TARGET( "DP Error 0x%08" PRIx32 "\n", ret);
+	return ret;
+}
+
+uint32_t adiv5_dp_low_access(struct ADIv5_DP_s *dp, uint8_t RnW,
+							 uint16_t addr, uint32_t value)
+{
+	uint32_t ret = dp->low_access(dp, RnW, addr, value);
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		ap_decode_access(addr, RnW);
+		fprintf(stderr, " 0x%08" PRIx32 "\n", (RnW)? ret : value);
+	}
+	return ret;
+}
+
+uint32_t adiv5_ap_read(ADIv5_AP_t *ap, uint16_t addr)
+{
+	uint32_t ret = ap->dp->ap_read(ap, addr);
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		ap_decode_access(addr, ADIV5_LOW_READ);
+		fprintf(stderr, " 0x%08" PRIx32 "\n", ret);
+	}
+	return ret;
+}
+
+void adiv5_ap_write(ADIv5_AP_t *ap, uint16_t addr, uint32_t value)
+{
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		ap_decode_access(addr, ADIV5_LOW_WRITE);
+		fprintf(stderr, " 0x%08" PRIx32 "\n", value);
+	}
+	return ap->dp->ap_write(ap, addr, value);
+}
+
+void adiv5_mem_read(ADIv5_AP_t *ap, void *dest, uint32_t src, size_t len)
+{
+	ap->dp->mem_read(ap, dest, src, len);
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		fprintf(stderr, "ap_memread @ %" PRIx32 " len %" PRIx32 ":",
+				src, (uint32_t)len);
+		uint8_t *p = (uint8_t *) dest;
+		unsigned int i = len;
+		if (i > 16)
+			i = 16;
+		while (i--)
+			fprintf(stderr, " %02x", *p++);
+		if (len > 16)
+			fprintf(stderr, " ...");
+		fprintf(stderr, "\n");
+	}
+	return;
+}
+void adiv5_mem_write_sized(	ADIv5_AP_t *ap, uint32_t dest, const void *src,
+							size_t len, enum align align)
+{
+	if (cl_debuglevel & BMP_DEBUG_TARGET) {
+		fprintf(stderr, "ap_mem_write_sized @ %" PRIx32 " len %" PRIx32
+				", align %d:", dest, (uint32_t)len, 1 << align);
+		uint8_t *p = (uint8_t *) src;
+		unsigned int i = len;
+		if (i > 16)
+			i = 16;
+		while (i--)
+			fprintf(stderr, " %02x", *p++);
+		if (len > 16)
+			fprintf(stderr, " ...");
+		fprintf(stderr, "\n");
+	}
+	return ap->dp->mem_write_sized(ap, dest, src, len, align);
+}
+
+void adiv5_dp_abort(struct ADIv5_DP_s *dp, uint32_t abort)
+{
+	DEBUG_TARGET("Abort: %08" PRIx32 "\n", abort);
+	return dp->abort(dp, abort);
+}

src/platforms/hosted/platform.h

@@ -0,0 +1,43 @@
+#ifndef __PLATFORM_H
+#define __PLATFORM_H
+
+#include "timing.h"
+
+char *platform_ident(void);
+void platform_buffer_flush(void);
+
+#define PLATFORM_IDENT     "(PC-Hosted) "
+#define SET_IDLE_STATE(x)
+#define SET_RUN_STATE(x)
+
+#define SYSTICKHZ 1000
+
+#define VENDOR_ID_BMP            0x1d50
+#define PRODUCT_ID_BMP_BL        0x6017
+#define PRODUCT_ID_BMP           0x6018
+
+#define VENDOR_ID_STLINK		 0x0483
+#define PRODUCT_ID_STLINK_MASK	 0xffe0
+#define PRODUCT_ID_STLINK_GROUP  0x3740
+#define PRODUCT_ID_STLINKV1		 0x3744
+#define PRODUCT_ID_STLINKV2		 0x3748
+#define PRODUCT_ID_STLINKV21	 0x374b
+#define PRODUCT_ID_STLINKV21_MSD 0x3752
+#define PRODUCT_ID_STLINKV3_NO_MSD 0x3754
+#define PRODUCT_ID_STLINKV3_BL	 0x374d
+#define PRODUCT_ID_STLINKV3		 0x374f
+#define PRODUCT_ID_STLINKV3E	 0x374e
+
+#define VENDOR_ID_SEGGER         0x1366
+
+typedef enum bmp_type_s {
+	BMP_TYPE_NONE = 0,
+	BMP_TYPE_BMP,
+	BMP_TYPE_STLINKV2,
+	BMP_TYPE_LIBFTDI,
+	BMP_TYPE_CMSIS_DAP,
+	BMP_TYPE_JLINK
+} bmp_type_t;
+
+void gdb_ident(char *p, int count);
+#endif

src/platforms/hosted/remote_jtagtap.c

@@ -0,0 +1,187 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2008  Black Sphere Technologies Ltd.
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ * Modified by Dave Marples <dave@marples.net>
+ * Modified (c) 2020 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Low level JTAG implementation using FT2232 with libftdi.
+ *
+ * Issues:
+ * Should share interface with swdptap.c or at least clean up...
+ */
+
+#include "general.h"
+#include <unistd.h>
+
+#include <assert.h>
+
+#include "remote.h"
+#include "jtagtap.h"
+#include "bmp_remote.h"
+
+static void jtagtap_reset(void);
+static void jtagtap_tms_seq(uint32_t MS, int ticks);
+static void jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks);
+static void jtagtap_tdi_seq(
+	const uint8_t final_tms, const uint8_t *DI, int ticks);
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI);
+
+int remote_jtagtap_init(jtag_proc_t *jtag_proc)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, "%s",
+				 REMOTE_JTAG_INIT_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((!s) || (construct[0] == REMOTE_RESP_ERR)) {
+      DEBUG_WARN("jtagtap_init failed, error %s\n",
+			  s ? (char *)&(construct[1]) : "unknown");
+      exit(-1);
+    }
+
+	jtag_proc->jtagtap_reset = jtagtap_reset;
+	jtag_proc->jtagtap_next =jtagtap_next;
+	jtag_proc->jtagtap_tms_seq = jtagtap_tms_seq;
+	jtag_proc->jtagtap_tdi_tdo_seq = jtagtap_tdi_tdo_seq;
+	jtag_proc->jtagtap_tdi_seq = jtagtap_tdi_seq;
+
+	return 0;
+}
+
+/* See remote.c/.h for protocol information */
+
+static void jtagtap_reset(void)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, "%s",
+				 REMOTE_JTAG_RESET_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((!s) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("jtagtap_reset failed, error %s\n",
+				s ? (char *)&(construct[1]) : "unknown");
+		exit(-1);
+    }
+}
+
+static void jtagtap_tms_seq(uint32_t MS, int ticks)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,
+				 REMOTE_JTAG_TMS_STR, ticks, MS);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((!s) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("jtagtap_tms_seq failed, error %s\n",
+				s ? (char *)&(construct[1]) : "unknown");
+		exit(-1);
+    }
+}
+
+/* At least up to v1.7.1-233, remote handles only up to 32 ticks in one
+ * call. Break up large calls.
+ *
+ * FIXME: Provide and test faster call and keep fallback
+ * for old firmware
+ */
+static void jtagtap_tdi_tdo_seq(
+	uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	if(!ticks || (!DI && !DO))
+		return;
+	while (ticks) {
+		int chunk;
+		if (ticks < 65)
+			chunk = ticks;
+		else {
+			chunk = 64;
+		}
+		ticks -= chunk;
+		uint64_t di = 0;
+		int bytes = (chunk + 7) >> 3;
+		int i = 0;
+		if (DI) {
+			for (; i < bytes; i++) {
+				di |= *DI << (i * 8);
+				DI++;
+			}
+		}
+		/* PRIx64 differs with system. Use it explicit in the format string*/
+		s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE,
+					 "!J%c%02x%" PRIx64 "%c",
+					 (!ticks && final_tms) ?
+					 REMOTE_TDITDO_TMS : REMOTE_TDITDO_NOTMS,
+					 chunk, di, REMOTE_EOM);
+		platform_buffer_write(construct,s);
+
+		s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+		if ((!s) || (construct[0] == REMOTE_RESP_ERR)) {
+			DEBUG_WARN("jtagtap_tms_seq failed, error %s\n",
+					   s ? (char *)&(construct[1]) : "unknown");
+			exit(-1);
+		}
+		if (DO) {
+			uint64_t res = remotehston(-1, (char *)&construct[1]);
+			for (i = bytes; i > 0; i--) {
+				*DO++ = res & 0xff;
+				res >>= 8;
+			}
+		}
+	}
+}
+
+static void jtagtap_tdi_seq(
+	const uint8_t final_tms, const uint8_t *DI, int ticks)
+{
+	return jtagtap_tdi_tdo_seq(NULL,  final_tms, DI, ticks);
+}
+
+
+static uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = snprintf((char *)construct, REMOTE_MAX_MSG_SIZE, REMOTE_JTAG_NEXT,
+				 dTMS ? '1' : '0', dTDI ? '1' : '0');
+
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((!s) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("jtagtap_next failed, error %s\n",
+				s ? (char *)&(construct[1]) : "unknown");
+		exit(-1);
+    }
+
+	return remotehston(-1, (char *)&construct[1]);
+}

src/platforms/hosted/remote_swdptap.c

@@ -0,0 +1,139 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Written by Gareth McMullin <gareth@blacksphere.co.nz>
+ * Modified by Dave Marples <dave@marples.net>
+ * Modified 2020 - 2021 by Uwe Bonnes (bon@elektron.ikp.physik.tu-darmstadt.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* MPSSE bit-banging SW-DP interface over FTDI with loop unrolled.
+ * Speed is sensible.
+ */
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "general.h"
+#include "remote.h"
+#include "bmp_remote.h"
+
+static bool swdptap_seq_in_parity(uint32_t *res, int ticks);
+static uint32_t swdptap_seq_in(int ticks);
+static void swdptap_seq_out(uint32_t MS, int ticks);
+static void swdptap_seq_out_parity(uint32_t MS, int ticks);
+
+int remote_swdptap_init(ADIv5_DP_t *dp)
+{
+	DEBUG_WIRE("remote_swdptap_init\n");
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+	s = sprintf((char *)construct,"%s", REMOTE_SWDP_INIT_STR);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((!s) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("swdptap_init failed, error %s\n",
+				s ? (char *)&(construct[1]) : "unknown");
+		exit(-1);
+    }
+
+	dp->seq_in  = swdptap_seq_in;
+	dp->seq_in_parity  = swdptap_seq_in_parity;
+	dp->seq_out = swdptap_seq_out;
+	dp->seq_out_parity  = swdptap_seq_out_parity;
+	dp->dp_read = firmware_swdp_read;
+	dp->error = firmware_swdp_error;
+	dp->low_access = firmware_swdp_low_access;
+	dp->abort = firmware_swdp_abort;
+  return 0;
+}
+
+static bool swdptap_seq_in_parity(uint32_t *res, int ticks)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = sprintf((char *)construct, REMOTE_SWDP_IN_PAR_STR, ticks);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s<2) || (construct[0] == REMOTE_RESP_ERR)) {
+		DEBUG_WARN("swdptap_seq_in_parity failed, error %s\n",
+				s ? (char *)&(construct[1]) : "short response");
+		exit(-1);
+	}
+
+	*res=remotehston(-1, (char *)&construct[1]);
+	DEBUG_PROBE("swdptap_seq_in_parity  %2d ticks: %08" PRIx32 " %s\n",
+				 ticks, *res, (construct[0] != REMOTE_RESP_OK) ? "ERR" : "OK");
+	return (construct[0] != REMOTE_RESP_OK);
+}
+
+static uint32_t swdptap_seq_in(int ticks)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	s = sprintf((char *)construct, REMOTE_SWDP_IN_STR, ticks);
+	platform_buffer_write(construct,s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s<2) || (construct[0] == REMOTE_RESP_ERR)) {
+      DEBUG_WARN("swdptap_seq_in failed, error %s\n",
+			  s ? (char *)&(construct[1]) : "short response");
+      exit(-1);
+    }
+	uint32_t res = remotehston(-1,(char *)&construct[1]);
+	DEBUG_PROBE("swdptap_seq_in         %2d ticks: %08" PRIx32 "\n",
+				 ticks, res);
+	return res;
+}
+
+static void swdptap_seq_out(uint32_t MS, int ticks)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	DEBUG_PROBE("swdptap_seq_out        %2d ticks: %08" PRIx32 "\n",
+				 ticks, MS);
+	s = sprintf((char *)construct,REMOTE_SWDP_OUT_STR, ticks, MS);
+	platform_buffer_write(construct, s);
+
+	s=platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[0] == REMOTE_RESP_ERR)) {
+      DEBUG_WARN("swdptap_seq_out failed, error %s\n",
+			  s ? (char *)&(construct[1]) : "short response");
+      exit(-1);
+    }
+}
+
+static void swdptap_seq_out_parity(uint32_t MS, int ticks)
+{
+	uint8_t construct[REMOTE_MAX_MSG_SIZE];
+	int s;
+
+	DEBUG_PROBE("swdptap_seq_out_parity %2d ticks: %08" PRIx32 "\n",
+				 ticks, MS);
+	s = sprintf((char *)construct, REMOTE_SWDP_OUT_PAR_STR, ticks, MS);
+	platform_buffer_write(construct, s);
+
+	s = platform_buffer_read(construct, REMOTE_MAX_MSG_SIZE);
+	if ((s < 1) || (construct[1] == REMOTE_RESP_ERR)){
+      DEBUG_WARN("swdptap_seq_out_parity failed, error %s\n",
+			  s ? (char *)&(construct[2]) : "short response");
+      exit(-1);
+    }
+}

src/platforms/hosted/rtt_if.c

@@ -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

src/platforms/hosted/stlinkv2.h

@@ -0,0 +1,57 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2019 Uwe Bonnes
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.	 If not, see <http://www.gnu.org/licenses/>.
+ */
+#if !defined(__STLINKV2_H_)
+
+#define STLINK_ERROR_FAIL -1
+#define STLINK_ERROR_OK 0
+#define STLINK_ERROR_WAIT 1
+
+#define STLINK_DEBUG_PORT_ACCESS            0xffff
+
+#if HOSTED_BMP_ONLY == 1
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-parameter"
+int stlink_init(bmp_info_t *info) {return -1;};
+int stlink_hwversion(void) {return -1;};
+const char *stlink_target_voltage(bmp_info_t *info) {return "ERROR";};
+void stlink_srst_set_val(bmp_info_t *info, bool assert) {};
+bool stlink_srst_get_val(void) {return true;};
+int stlink_enter_debug_swd(bmp_info_t *info, ADIv5_DP_t *dp) {return -1;};
+void stlink_adiv5_dp_defaults(ADIv5_DP_t *dp) {};
+int stlink_jtag_dp_init(ADIv5_DP_t *dp) {return false;};
+int jtag_scan_stlinkv2(bmp_info_t *info, const uint8_t *irlens) {return 0;};
+void stlink_exit_function(bmp_info_t *info) {};
+void stlink_max_frequency_set(bmp_info_t *info, uint32_t freq) {};
+uint32_t stlink_max_frequency_get(bmp_info_t *info) {return 0;};
+# pragma GCC diagnostic pop
+#else
+int stlink_init(bmp_info_t *info);
+int stlink_hwversion(void);
+const char *stlink_target_voltage(bmp_info_t *info);
+void stlink_srst_set_val(bmp_info_t *info, bool assert);
+bool stlink_srst_get_val(void);
+int stlink_enter_debug_swd(bmp_info_t *info, ADIv5_DP_t *dp);
+void stlink_adiv5_dp_defaults(ADIv5_DP_t *dp);
+int stlink_jtag_dp_init(ADIv5_DP_t *dp);
+int jtag_scan_stlinkv2(bmp_info_t *info, const uint8_t *irlens);
+void stlink_exit_function(bmp_info_t *info);
+void stlink_max_frequency_set(bmp_info_t *info, uint32_t freq);
+uint32_t stlink_max_frequency_get(bmp_info_t *info);
+#endif
+#endif

src/platforms/hydrabus/Makefile.inc

@@ -4,10 +4,10 @@ OBJCOPY = $(CROSS_COMPILE)objcopy
 
 CFLAGS += -Istm32/include -mcpu=cortex-m4 -mthumb \
 	-mfloat-abi=hard -mfpu=fpv4-sp-d16 \
-	-DSTM32F4 -DHYDRABUS -I../libopencm3/include \
-	-Iplatforms/stm32
+	-DSTM32F4 -I../libopencm3/include \
+	-Iplatforms/stm32 -DDFU_SERIAL_LENGTH=9
 
-LDFLAGS = -lopencm3_stm32f4 -Wl,--defsym,_stack=0x20006000 \
+LDFLAGS = -lopencm3_stm32f4 \
 	-Wl,-T,platforms/stm32/f4discovery.ld -nostartfiles -lc -lnosys \
 	-Wl,-Map=mapfile -mthumb -mcpu=cortex-m4 -Wl,-gc-sections \
 	-mfloat-abi=hard -mfpu=fpv4-sp-d16 \
@@ -16,17 +16,18 @@ LDFLAGS = -lopencm3_stm32f4 -Wl,--defsym,_stack=0x20006000 \
 VPATH += platforms/stm32
 
 SRC += 	cdcacm.c	\
+	traceswodecode.c	\
 	traceswo.c	\
 	usbuart.c	\
 	serialno.c	\
 	timing.c	\
 	timing_stm32.c	\
 
-all: blackmagic.bin blackmagic.hex blackmagic.dfu
+all: blackmagic.bin blackmagic.hex
 
 blackmagic.dfu: blackmagic.hex
 	@echo Creating $@
-	@python ../scripts/dfu-convert.py -i $< $@
+	@python3 ../scripts/dfu-convert.py -i $< $@
 
 host_clean:
 	-$(Q)$(RM) blackmagic.bin blackmagic.hex blackmagic.dfu

src/platforms/hydrabus/Readme.md

@@ -27,7 +27,7 @@ make PROBE_HOST=hydrabus
 How to Flash the firmware with Windows
 ========================================
 * After build:
- * 1) Download files from https://github.com/bvernoux/hydrafw/tree/master/update_fw_dfu_usb_hydrafw
+ * 1) Download files from https://github.com/hydrabus/hydrafw/tree/master/utils/windows_dfu_util
  * 2) Force the F4 into system bootloader mode by jumpering "BOOT0" to "3V3" and "PB2/BOOT1" to "GND" and reset (RESET button). System bootloader should appear.
  * 3) Run the command `DfuSeCommand.exe -c --de 0 -d --fn .\src\blackmagic.dfu`
 

src/platforms/hydrabus/platform.c

@@ -27,7 +27,7 @@
 #include "usbuart.h"
 #include "morse.h"
 
-#include <libopencm3/stm32/f4/rcc.h>
+#include <libopencm3/stm32/rcc.h>
 #include <libopencm3/cm3/scb.h>
 #include <libopencm3/cm3/nvic.h>
 #include <libopencm3/stm32/exti.h>
@@ -46,7 +46,7 @@ void platform_init(void)
 		scb_reset_core();
 	}
 
-	rcc_clock_setup_hse_3v3(&hse_8mhz_3v3[CLOCK_3V3_48MHZ]);
+	rcc_clock_setup_pll(&rcc_hse_8mhz_3v3[RCC_CLOCK_3V3_168MHZ]);
 
 	/* Enable peripherals */
 	rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
@@ -63,7 +63,9 @@ void platform_init(void)
 	GPIOC_OSPEEDR |= 0xA20;
 	gpio_mode_setup(JTAG_PORT, GPIO_MODE_OUTPUT,
 			GPIO_PUPD_NONE,
-			TMS_PIN | TCK_PIN | TDI_PIN);
+			TCK_PIN | TDI_PIN);
+	gpio_mode_setup(JTAG_PORT, GPIO_MODE_INPUT,
+			GPIO_PUPD_NONE, TMS_PIN);
 
 	gpio_mode_setup(TDO_PORT, GPIO_MODE_INPUT,
 			GPIO_PUPD_NONE,
@@ -83,7 +85,7 @@ bool platform_srst_get_val(void) { return false; }
 
 const char *platform_target_voltage(void)
 {
-	return "ABSENT!";
+	return NULL;
 }
 
 void platform_request_boot(void)
@@ -103,4 +105,3 @@ void platform_request_boot(void)
 	SYSCFG_MEMRM &= ~3;
 	SYSCFG_MEMRM |=  1;
 }
-

src/platforms/hydrabus/platform.h

@@ -28,15 +28,11 @@
 #include "gpio.h"
 #include "timing.h"
 #include "timing_stm32.h"
-#include "version.h"
 
 #include <setjmp.h>
 
 #define PLATFORM_HAS_TRACESWO
-#define BOARD_IDENT       "Black Magic Probe (HydraBus), (Firmware " FIRMWARE_VERSION ")"
-#define BOARD_IDENT_DFU   "Black Magic (Upgrade) for HydraBus, (Firmware " FIRMWARE_VERSION ")"
-#define DFU_IDENT         "Black Magic Firmware Upgrade (HydraBus)"
-#define DFU_IFACE_STRING  "@Internal Flash   /0x08000000/1*016Ka,3*016Kg,1*064Kg,7*128Kg"
+#define PLATFORM_IDENT        " (HydraBus))"
 
 /* Important pin mappings for STM32 implementation:
  *
@@ -94,49 +90,54 @@
 #define SWDIO_MODE_DRIVE() \
 	gpio_mode_setup(SWDIO_PORT, GPIO_MODE_OUTPUT, \
 	                GPIO_PUPD_NONE, SWDIO_PIN);
-
+#define UART_PIN_SETUP() do { \
+	gpio_mode_setup(USBUSART_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, \
+	                USBUSART_TX_PIN); \
+	gpio_set_output_options(USBUSART_PORT, GPIO_OTYPE_PP, \
+					GPIO_OSPEED_100MHZ, USBUSART_TX_PIN); \
+	gpio_set_af(USBUSART_PORT, GPIO_AF7, USBUSART_TX_PIN); \
+	gpio_mode_setup(USBUSART_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, \
+	                USBUSART_RX_PIN); \
+	gpio_set_output_options(USBUSART_PORT, GPIO_OTYPE_OD, \
+					GPIO_OSPEED_100MHZ, USBUSART_RX_PIN); \
+	gpio_set_af(USBUSART_PORT, GPIO_AF7, USBUSART_RX_PIN); \
+} while(0)
 
 #define USB_DRIVER      stm32f107_usb_driver
 #define USB_IRQ         NVIC_OTG_FS_IRQ
-#define USB_ISR         otg_fs_isr
+#define USB_ISR(x)      otg_fs_isr(x)
 /* Interrupt priorities.  Low numbers are high priority.
- * For now USART1 preempts USB which may spin while buffer is drained.
  * TIM3 is used for traceswo capture and must be highest priority.
  */
-#define IRQ_PRI_USB		(2 << 4)
-#define IRQ_PRI_USBUSART	(1 << 4)
-#define IRQ_PRI_USBUSART_TIM	(3 << 4)
+#define IRQ_PRI_USB		(1 << 4)
+#define IRQ_PRI_USBUSART	(2 << 4)
+#define IRQ_PRI_USBUSART_DMA 	(2 << 4)
 #define IRQ_PRI_TRACE		(0 << 4)
 
 #define USBUSART USART1
 #define USBUSART_CR1 USART1_CR1
+#define USBUSART_DR USART1_DR
 #define USBUSART_IRQ NVIC_USART1_IRQ
 #define USBUSART_CLK RCC_USART1
-#define USBUSART_TX_PORT GPIOA
-#define USBUSART_TX_PIN  GPIO9
-#define USBUSART_RX_PORT GPIOA
-#define USBUSART_RX_PIN  GPIO10
-#define USBUSART_ISR usart1_isr
-#define USBUSART_TIM TIM4
-#define USBUSART_TIM_CLK_EN() rcc_periph_clock_enable(RCC_TIM4)
-#define USBUSART_TIM_IRQ NVIC_TIM4_IRQ
-#define USBUSART_TIM_ISR tim4_isr
-
-#define UART_PIN_SETUP() do { \
-	gpio_mode_setup(USBUSART_TX_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, \
-	                USBUSART_TX_PIN); \
-	gpio_mode_setup(USBUSART_RX_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, \
-	                USBUSART_RX_PIN); \
-	gpio_set_af(USBUSART_TX_PORT, GPIO_AF7, USBUSART_TX_PIN); \
-	gpio_set_af(USBUSART_RX_PORT, GPIO_AF7, USBUSART_RX_PIN); \
-    } while(0)
+#define USBUSART_PORT GPIOA
+#define USBUSART_TX_PIN GPIO9
+#define USBUSART_RX_PIN GPIO10
+#define USBUSART_ISR(x) usart1_isr(x)
+#define USBUSART_DMA_BUS DMA2
+#define USBUSART_DMA_CLK RCC_DMA2
+#define USBUSART_DMA_TX_CHAN DMA_STREAM7
+#define USBUSART_DMA_TX_IRQ NVIC_DMA2_STREAM7_IRQ
+#define USBUSART_DMA_TX_ISR(x) dma2_stream7_isr(x)
+#define USBUSART_DMA_RX_CHAN DMA_STREAM5
+#define USBUSART_DMA_RX_IRQ NVIC_DMA2_STREAM5_IRQ
+#define USBUSART_DMA_RX_ISR(x) dma2_stream5_isr(x)
+/* For STM32F4 DMA trigger source must be specified */
+#define USBUSART_DMA_TRG DMA_SxCR_CHSEL_4
 
 #define TRACE_TIM TIM3
 #define TRACE_TIM_CLK_EN() rcc_periph_clock_enable(RCC_TIM3)
 #define TRACE_IRQ   NVIC_TIM3_IRQ
-#define TRACE_ISR   tim3_isr
-
-#define DEBUG(...)
+#define TRACE_ISR(x) tim3_isr(x)
 
 #define gpio_set_val(port, pin, val) do {	\
 	if(val)					\
@@ -154,11 +155,37 @@ static inline int platform_hwversion(void)
 	return 0;
 }
 
-/* Use newlib provided integer only stdio functions */
-#define sscanf siscanf
-#define sprintf siprintf
-#define vasprintf vasiprintf
-#define snprintf sniprintf
+/*
+ * Use newlib provided integer only stdio functions
+ */
 
+/* sscanf */
+#ifdef sscanf
+#undef sscanf
+#define sscanf siscanf
+#else
+#define sscanf siscanf
+#endif
+/* sprintf */
+#ifdef sprintf
+#undef sprintf
+#define sprintf siprintf
+#else
+#define sprintf siprintf
+#endif
+/* vasprintf */
+#ifdef vasprintf
+#undef vasprintf
+#define vasprintf vasiprintf
+#else
+#define vasprintf vasiprintf
+#endif
+/* snprintf */
+#ifdef snprintf
+#undef snprintf
+#define snprintf sniprintf
+#else
+#define snprintf sniprintf
 #endif
 
+#endif

src/platforms/jeff/Makefile.inc

@@ -2,6 +2,8 @@ CROSS_COMPILE ?= arm-none-eabi-
 CC = $(CROSS_COMPILE)gcc
 OBJCOPY = $(CROSS_COMPILE)objcopy
 
+OPT_FLAGS := -Os
+
 ifeq ($(ENABLE_DEBUG), 1)
 CFLAGS += -DDEBUG_ME
 CFLAGS += -DENABLE_DEBUG
@@ -15,7 +17,11 @@ ifeq ($(CONSOLE_NO_AUTO_CRLF), 1)
 CFLAGS += -DCONSOLE_NO_AUTO_CRLF
 endif
 
-CFLAGS += -mthumb -mcpu=cortex-m0plus \
+ifeq ($(ENABLE_DEBUG), 1)
+CFLAGS += -g3 -ggdb
+endif
+
+CFLAGS += -mthumb -mcpu=cortex-m0plus -DDFU_SERIAL_LENGTH=9 \
 	-DSAMD -DSAMD21E17 -DBLACKMAGIC -I../libopencm3/include \
 	-Iplatforms/samd -msoft-float -ffunction-sections -fdata-sections -MD
 
@@ -27,7 +33,7 @@ LDFLAGS = -mthumb -mcpu=cortex-m0plus -msoft-float -nostartfiles -lc \
 ifeq ($(ENABLE_DEBUG), 1)
 LDFLAGS += --specs=rdimon.specs
 else
-LDFLAGS += --specs=nosys.specs
+LDFLAGS += --specs=nano.specs
 endif
 
 VPATH += platforms/samd
@@ -42,7 +48,7 @@ all:	blackmagic_full.bin blackmagic.bin blackmagic_dfu.bin blackmagic_dfu.hex
 blackmagic_dfu.bin : OBJCOPY_FLAGS := --pad-to 0x00002000 --gap-fill 0xFF -j .text -j .data
 blackmagic_dfu.bin : LINKER_SCRIPT := "platforms/samd/samd_boot.ld"
 
-blackmagic_dfu: usbdfu.o
+blackmagic_dfu.elf: usbdfu.o
 	@echo "  LD      $@"
 	$(Q)$(CC) $^ -o $@ $(LDFLAGS)
 

src/platforms/jeff/platform.c

@@ -236,6 +236,16 @@ void platform_delay(uint32_t ms)
 	while (!platform_timeout_is_expired(&timeout));
 }
 
+uint32_t platform_target_voltage_sense(void)
+{
+	uint32_t val;
+	adc_start();
+
+	while (!(1&(ADC->intflag)));
+	val = ((485*adc_result())>>12); /* 330 without divider, 485 with it */
+	return val;
+}
+
 const char *platform_target_voltage(void)
 {
 	uint32_t voltage;
@@ -243,8 +253,7 @@ const char *platform_target_voltage(void)
 
 	adc_start();
 
-	while (!(1&(ADC->intflag)));
-	voltage = ((485*adc_result())>>12); /* 330 without divider, 485 with it */
+	voltage = platform_target_voltage_sense();
 
 	out[0] = '0' + (char)(voltage/100);
 	out[2] = '0' + (char)((voltage/10) % 10);
@@ -252,7 +261,7 @@ const char *platform_target_voltage(void)
 	return out;
 }
 
-char *serialno_read(char *s)
+char *serial_no_read(char *s)
 {
 #ifdef CUSTOM_SER
 	s[0] = 'J';
@@ -262,11 +271,12 @@ char *serialno_read(char *s)
 	return s;
 #else
         int i;
+
 	volatile uint32_t unique_id = *(volatile uint32_t *)0x0080A00C +
 		*(volatile uint32_t *)0x0080A040 +
 		*(volatile uint32_t *)0x0080A044 +
 		*(volatile uint32_t *)0x0080A048;
-
+	
         /* Fetch serial number from chip's unique ID */
         for(i = 0; i < 8; i++) {
                 s[7-i] = ((unique_id >> (4*i)) & 0xF) + '0';
@@ -322,3 +332,15 @@ void tc3_isr(void)
 	if (tc_interrupt_flag(3) & 16)
 		scb_reset_system();
 }
+
+uint32_t swd_delay_cnt = 0;
+
+void platform_max_frequency_set(uint32_t freq)
+{
+	(void)freq;
+}
+
+uint32_t platform_max_frequency_get(void)
+{
+	return 0;
+}

src/platforms/jeff/platform.h

@@ -36,16 +36,18 @@
 #define PLATFORM_HAS_BOOTLOADER
 #define PLATFORM_HAS_PRINTSERIAL
 
-#define BOARD_IDENT             "Black Magic Probe (SAMD), (Firmware " FIRMWARE_VERSION ")"
+//#define BOARD_IDENT             "Black Magic Probe (SAMD), (Firmware " FIRMWARE_VERSION ")"
 #define BOARD_IDENT_DFU		"Black Magic (Upgrade) for Launchpad, (Firmware " FIRMWARE_VERSION ")"
-#define DFU_IDENT               "Black Magic Firmware Upgrade (SAMD)"
+//#define DFU_IDENT               "Black Magic Firmware Upgrade (SAMD)"
 #define DFU_IFACE_STRING	"hid"
 
 #define BOARD_IDENT_UPD       "Black Magic (DFU Upgrade), SAMD21, (Firmware " FIRMWARE_VERSION ")"
 #define UPD_IFACE_STRING       "@Internal Flash   /0x00000000/1*008Ka,15*8Kg"
 
+#define PLATFORM_IDENT          " "
 
 extern uint8_t running_status;
+extern uint32_t swd_delay_cnt;
 
 #ifdef DEBUG_ME
 

src/platforms/jeff/usbdfu.c

@@ -143,10 +143,8 @@ static const char *usb_strings[] = {
 	//"@Internal Flash   /0x00000000/1*0016Ka,15*0016Kg",
 };
 
-static uint8_t usbdfu_getstatus(usbd_device *usbd_dev, uint32_t *bwPollTimeout)
+static uint8_t usbdfu_getstatus(uint32_t *bwPollTimeout)
 {
-	(void)usbd_dev;
-
 	switch (usbdfu_state) {
 	case STATE_DFU_DNLOAD_SYNC:
 		usbdfu_state = STATE_DFU_DNBUSY;
@@ -177,11 +175,13 @@ static void usbdfu_getstatus_complete(usbd_device *usbd_dev, struct usb_setup_da
 					uint32_t *dat = (uint32_t *)(prog.buf + 1);
 					nvmctrl_erase_row(*dat); //flash_erase_page(*dat);
 				}
+				break;
 			case CMD_SETADDR:
 				{
 					uint32_t *dat = (uint32_t *)(prog.buf + 1);
 					prog.addr = *dat;
 				}
+				break;
 			}
 		} else {
 			//uint32_t baseaddr = prog.addr + ((prog.blocknum - 2) *
@@ -225,9 +225,12 @@ static void usbdfu_getstatus_complete(usbd_device *usbd_dev, struct usb_setup_da
 	}
 }
 
-static int usbdfu_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, uint8_t **buf,
-		uint16_t *len, void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req))
+static enum usbd_request_return_codes usbdfu_control_request(usbd_device *dev,
+		struct usb_setup_data *req, uint8_t **buf, uint16_t *len,
+		void (**complete)(usbd_device *dev, struct usb_setup_data *req))
 {
+	(void)dev;
+
 	if ((req->bmRequestType & 0x7F) != 0x21)
 		return 0; /* Only accept class request. */
 
@@ -258,7 +261,7 @@ static int usbdfu_control_request(usbd_device *usbd_dev, struct usb_setup_data *
 		return 0;
 	case DFU_GETSTATUS: {
 		uint32_t bwPollTimeout = 0; /* 24-bit integer in DFU class spec */
-		(*buf)[0] = usbdfu_getstatus(usbd_dev, &bwPollTimeout);
+		(*buf)[0] = usbdfu_getstatus(&bwPollTimeout);
 		(*buf)[1] = bwPollTimeout & 0xFF;
 		(*buf)[2] = (bwPollTimeout >> 8) & 0xFF;
 		(*buf)[3] = (bwPollTimeout >> 16) & 0xFF;

src/platforms/launchpad-icdi/Makefile.inc

@@ -1,11 +1,13 @@
 CROSS_COMPILE ?= arm-none-eabi-
+SERIAL_NO ?= 1
 CC = $(CROSS_COMPILE)gcc
 OBJCOPY = $(CROSS_COMPILE)objcopy
 
 INCLUDES = -I../libopencm3/include
 
 CPU_FLAGS = -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=hard
-CFLAGS += $(INCLUDES) $(CPU_FLAGS) -DTARGET_IS_BLIZZARD_RB1 -DLM4F -DPART_TM4C123GH6PM
+CFLAGS += $(INCLUDES) $(CPU_FLAGS) -DSERIAL_NO=$(SERIAL_NO) -DTARGET_IS_BLIZZARD_RB1 -DLM4F -DPART_TM4C123GH6PM
+CFLAGS += -DDFU_SERIAL_LENGTH=9
 
 LINKER_SCRIPT="platforms/tm4c/tm4c.ld"
 LDFLAGS = -nostartfiles -lc $(CPU_FLAGS) -nodefaultlibs -T$(LINKER_SCRIPT) -Wl,--gc-sections \

src/platforms/launchpad-icdi/platform.c

@@ -25,9 +25,6 @@
 #include <libopencm3/cm3/systick.h>
 #include <libopencm3/lm4f/usb.h>
 
-#define SYSTICKHZ	100
-#define SYSTICKMS	(1000 / SYSTICKHZ)
-
 #define PLL_DIV_80MHZ	5
 #define PLL_DIV_25MHZ	16
 
@@ -37,6 +34,8 @@ volatile platform_timeout * volatile head_timeout;
 uint8_t running_status;
 static volatile uint32_t time_ms;
 
+uint32_t swd_delay_cnt = 0;
+
 void sys_tick_handler(void)
 {
 	trace_tick();
@@ -62,7 +61,7 @@ platform_init(void)
 
 	gpio_enable_ahb_aperture();
 
-	gpio_mode_setup(TMS_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, TMS_PIN);
+	gpio_mode_setup(TMS_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, TMS_PIN);
 	gpio_mode_setup(TCK_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, TCK_PIN);
 	gpio_mode_setup(TDI_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, TDI_PIN);
 	gpio_mode_setup(TDO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, TDO_PIN);
@@ -115,23 +114,23 @@ void platform_delay(uint32_t ms)
 
 const char *platform_target_voltage(void)
 {
-	return "not supported";
+	return NULL;
 }
 
-char *serialno_read(char *s)
+char *serial_no_read(char *s)
 {
 	/* FIXME: Store a unique serial number somewhere and retreive here */
-	uint32_t unique_id = 1;
+	uint32_t unique_id = SERIAL_NO;
         int i;
 
         /* Fetch serial number from chip's unique ID */
         for(i = 0; i < 8; i++) {
                 s[7-i] = ((unique_id >> (4*i)) & 0xF) + '0';
         }
-        for(i = 0; i < 8; i++)
+        for(i = 0; i < DFU_SERIAL_LENGTH - 1; i++)
                 if(s[i] > '9')
                         s[i] += 'A' - '9' - 1;
-	s[8] = 0;
+	s[DFU_SERIAL_LENGTH - 1] = 0;
 
 	return s;
 }
@@ -140,3 +139,12 @@ void platform_request_boot(void)
 {
 }
 
+void platform_max_frequency_set(uint32_t freq)
+{
+	(void)freq;
+}
+
+uint32_t platform_max_frequency_get(void)
+{
+	return 0;
+}

src/platforms/launchpad-icdi/platform.h

@@ -21,14 +21,11 @@
 #include <libopencm3/usb/usbd.h>
 
 #include "timing.h"
-#include "version.h"
 
-#define BOARD_IDENT             "Black Magic Probe (Launchpad ICDI), (Firmware " FIRMWARE_VERSION ")"
-#define BOARD_IDENT_DFU		"Black Magic (Upgrade) for Launchpad, (Firmware " FIRMWARE_VERSION ")"
-#define DFU_IDENT               "Black Magic Firmware Upgrade (Launchpad)"
-#define DFU_IFACE_STRING	"lolwut"
+#define PLATFORM_IDENT      "(Launchpad ICDI) "
 
 extern uint8_t running_status;
+extern uint32_t swd_delay_cnt;
 
 #define TMS_PORT	GPIOA_BASE
 #define TMS_PIN		GPIO3
@@ -68,7 +65,7 @@ extern uint8_t running_status;
 	gpio_set_output_config(SWDIO_PORT, GPIO_OTYPE_PP, GPIO_DRIVE_2MA, SWDIO_PIN);		\
 }
 
-extern usbd_driver lm4f_usb_driver;
+extern const usbd_driver lm4f_usb_driver;
 #define USB_DRIVER	lm4f_usb_driver
 #define USB_IRQ		NVIC_USB0_IRQ
 #define USB_ISR		usb0_isr
@@ -98,8 +95,6 @@ extern usbd_driver lm4f_usb_driver;
 #define vasprintf vasiprintf
 #define snprintf sniprintf
 
-#define DEBUG(...)
-
 #define SET_RUN_STATE(state)	{running_status = (state);}
 #define SET_IDLE_STATE(state)	{}
 #define SET_ERROR_STATE(state)	SET_IDLE_STATE(state)

src/platforms/libftdi/Makefile.inc

@@ -1,4 +0,0 @@
-CFLAGS += -DLIBFTDI
-LDFLAGS += -lftdi -lusb
-
-SRC += 	timing.c	\

src/platforms/libftdi/gdb_if.c

@@ -1,123 +0,0 @@
-/*
- * This file is part of the Black Magic Debug project.
- *
- * Copyright (C) 2011  Black Sphere Technologies Ltd.
- * Written by Gareth McMullin <gareth@blacksphere.co.nz>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/* This file implements a transparent channel over which the GDB Remote
- * Serial Debugging protocol is implemented.  This implementation for Linux
- * uses a TCP server on port 2000.
- */
-#include <stdio.h>
-
-#ifndef WIN32
-#   include <sys/socket.h>
-#   include <netinet/in.h>
-#   include <netinet/tcp.h>
-#   include <sys/select.h>
-#else
-#   include <winsock2.h>
-#   include <windows.h>
-#   include <ws2tcpip.h>
-#endif
-
-#include <assert.h>
-
-#include "general.h"
-#include "gdb_if.h"
-
-static int gdb_if_serv, gdb_if_conn;
-
-int gdb_if_init(void)
-{
-#ifdef WIN32
-	WSADATA wsaData;
-	WSAStartup(MAKEWORD(2, 2), &wsaData);
-#endif
-	struct sockaddr_in addr;
-	int opt;
-
-	addr.sin_family = AF_INET;
-	addr.sin_port = htons(2000);
-	addr.sin_addr.s_addr = htonl(INADDR_ANY);
-
-	assert((gdb_if_serv = socket(PF_INET, SOCK_STREAM, 0)) != -1);
-	opt = 1;
-	assert(setsockopt(gdb_if_serv, SOL_SOCKET, SO_REUSEADDR, (void*)&opt, sizeof(opt)) != -1);
-	assert(setsockopt(gdb_if_serv, IPPROTO_TCP, TCP_NODELAY, (void*)&opt, sizeof(opt)) != -1);
-
-	assert(bind(gdb_if_serv, (void*)&addr, sizeof(addr)) != -1);
-	assert(listen(gdb_if_serv, 1) != -1);
-
-	DEBUG("Listening on TCP:2000\n");
-
-	return 0;
-}
-
-
-unsigned char gdb_if_getchar(void)
-{
-	unsigned char ret;
-	int i = 0;
-
-	while(i <= 0) {
-		if(gdb_if_conn <= 0) {
-			gdb_if_conn = accept(gdb_if_serv, NULL, NULL);
-			DEBUG("Got connection\n");
-		}
-		i = recv(gdb_if_conn, (void*)&ret, 1, 0);
-		if(i <= 0) {
-			gdb_if_conn = -1;
-			DEBUG("Dropped broken connection\n");
-			/* Return '+' in case we were waiting for an ACK */
-			return '+';
-		}
-	}
-	return ret;
-}
-
-unsigned char gdb_if_getchar_to(int timeout)
-{
-	fd_set fds;
-	struct timeval tv;
-
-	if(gdb_if_conn == -1) return -1;
-
-	tv.tv_sec = timeout / 1000;
-	tv.tv_usec = (timeout % 1000) * 1000;
-
-	FD_ZERO(&fds);
-	FD_SET(gdb_if_conn, &fds);
-
-	if(select(gdb_if_conn+1, &fds, NULL, NULL, &tv) > 0)
-		return gdb_if_getchar();
-
-	return -1;
-}
-
-void gdb_if_putchar(unsigned char c, int flush)
-{
-	static uint8_t buf[2048];
-	static int bufsize = 0;
-	if (gdb_if_conn > 0) {
-		buf[bufsize++] = c;
-		if (flush || (bufsize == sizeof(buf))) {
-			send(gdb_if_conn, buf, bufsize, 0);
-			bufsize = 0;
-		}
-	}
-}

src/platforms/libftdi/jtagtap.c

@@ -1,204 +0,0 @@
-/*
- * This file is part of the Black Magic Debug project.
- *
- * Copyright (C) 2008  Black Sphere Technologies Ltd.
- * Written by Gareth McMullin <gareth@blacksphere.co.nz>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/* Low level JTAG implementation using FT2232 with libftdi.
- *
- * Issues:
- * This code is old, rotten and unsupported.
- * Magic numbers everywhere.
- * Should share interface with swdptap.c or at least clean up...
- */
-
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-
-#include <assert.h>
-
-#include <ftdi.h>
-
-#include "general.h"
-
-#define PROVIDE_GENERIC_TAP_SEQ
-//#define PROVIDE_GENERIC_TAP_TMS_SEQ
-//#define PROVIDE_GENERIC_TAP_TDI_TDO_SEQ
-//#define PROVIDE_GENERIC_TAP_TDI_SEQ
-#include "jtagtap.h"
-
-#define ALL_ZERO 0xA0
-#define TCK 	0x01
-#define TDI 	0x02
-#define TDO 	0x04
-#define TMS 	0x08
-#define nSRST 	0x20
-
-int jtagtap_init(void)
-{
-	assert(ftdic != NULL);
-
-	/* Go to JTAG mode for SWJ-DP */
-	for (int i = 0; i <= 50; i++)
-		jtagtap_next(1, 0);		/* Reset SW-DP */
-	jtagtap_tms_seq(0xE73C, 16);		/* SWD to JTAG sequence */
-	jtagtap_soft_reset();
-
-	return 0;
-}
-
-void jtagtap_reset(void)
-{
-	jtagtap_soft_reset();
-}
-
-#ifndef PROVIDE_GENERIC_TAP_TMS_SEQ
-void
-jtagtap_tms_seq(uint32_t MS, int ticks)
-{
-	uint8_t tmp[3] = "\x4B";
-	while(ticks >= 0) {
-		//jtagtap_next(MS & 1, 1);
-		tmp[1] = ticks<7?ticks-1:6;
-		tmp[2] = 0x80 | (MS & 0x7F);
-
-//		assert(ftdi_write_data(ftdic, tmp, 3) == 3);
-		platform_buffer_write(tmp, 3);
-		MS >>= 7; ticks -= 7;
-	}
-}
-#endif
-
-#ifndef PROVIDE_GENERIC_TAP_TDI_SEQ
-void
-jtagtap_tdi_seq(const uint8_t final_tms, const uint8_t *DI, int ticks)
-{
-	uint8_t *tmp;
-	int index = 0;
-	int rticks;
-
-	if(!ticks) return;
-
-	if(final_tms) ticks--;
-	rticks = ticks & 7;
-	ticks >>= 3;
-	tmp = alloca(ticks + 9);
-
-	if(ticks) {
-		tmp[index++] = 0x19;
-		tmp[index++] = ticks - 1;
-		tmp[index++] = 0;
-		while(ticks--) tmp[index++] = *DI++;
-	}
-
-	if(rticks) {
-		tmp[index++] = 0x1B;
-		tmp[index++] = rticks - 1;
-		tmp[index++] = *DI;
-	}
-
-	if(final_tms) {
-		tmp[index++] = 0x4B;
-		tmp[index++] = 0;
-		tmp[index++] = (*DI)>>rticks?0x81:0x01;
-	}
-//	assert(ftdi_write_data(ftdic, tmp, index) == index);
-	platform_buffer_write(tmp, index);
-}
-#endif
-
-#ifndef PROVIDE_GENERIC_TAP_TDI_TDO_SEQ
-void
-jtagtap_tdi_tdo_seq(uint8_t *DO, const uint8_t final_tms, const uint8_t *DI, int ticks)
-{
-	uint8_t *tmp;
-	int index = 0, rsize;
-	int rticks;
-
-	if(!ticks) return;
-
-//	printf("ticks: %d\n", ticks);
-	if(final_tms) ticks--;
-	rticks = ticks & 7;
-	ticks >>= 3;
-	tmp = alloca(ticks + 9);
-	rsize = ticks;
-	if(ticks) {
-		tmp[index++] = 0x39;
-		tmp[index++] = ticks - 1;
-		tmp[index++] = 0;
-		while(ticks--) tmp[index++] = *DI++;
-	}
-
-	if(rticks) {
-		rsize++;
-		tmp[index++] = 0x3B;
-		tmp[index++] = rticks - 1;
-		tmp[index++] = *DI;
-	}
-
-	if(final_tms) {
-		rsize++;
-		tmp[index++] = 0x6B;
-		tmp[index++] = 0;
-		tmp[index++] = (*DI)>>rticks?0x81:0x01;
-	}
-//	assert(ftdi_write_data(ftdic, tmp, index) == index);
-	platform_buffer_write(tmp, index);
-//	index = 0;
-//	while((index += ftdi_read_data(ftdic, tmp + index, rsize-index)) != rsize);
-	platform_buffer_read(tmp, rsize);
-	/*for(index = 0; index < rsize; index++)
-		printf("%02X ", tmp[index]);
-	printf("\n");*/
-	index = 0;
-	if(final_tms) rsize--;
-
-	while(rsize--) {
-		/*if(rsize) printf("%02X ", tmp[index]);*/
-		*DO++ = tmp[index++];
-	}
-	if(final_tms) {
-		rticks++;
-		*(--DO) >>= 1;
-		*DO |= tmp[index] & 0x80;
-	} else DO--;
-	if(rticks) {
-		*DO >>= (8-rticks);
-	}
-	/*printf("%02X\n", *DO);*/
-}
-#endif
-
-uint8_t jtagtap_next(uint8_t dTMS, uint8_t dTDI)
-{
-	uint8_t ret;
-	uint8_t tmp[3] = "\x6B\x00\x00";
-	tmp[2] = (dTDI?0x80:0) | (dTMS?0x01:0);
-//	assert(ftdi_write_data(ftdic, tmp, 3) == 3);
-//	while(ftdi_read_data(ftdic, &ret, 1) != 1);
-	platform_buffer_write(tmp, 3);
-	platform_buffer_read(&ret, 1);
-
-	ret &= 0x80;
-
-//	DEBUG("jtagtap_next(TMS = %d, TDI = %d) = %02X\n", dTMS, dTDI, ret);
-
-	return ret;
-}
-

src/platforms/libftdi/platform.c

@@ -1,293 +0,0 @@
-/*
- * This file is part of the Black Magic Debug project.
- *
- * Copyright (C) 2011  Black Sphere Technologies Ltd.
- * Written by Gareth McMullin <gareth@blacksphere.co.nz>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#include "general.h"
-#include "gdb_if.h"
-#include "version.h"
-
-#include <assert.h>
-#include <unistd.h>
-#include <sys/time.h>
-
-struct ftdi_context *ftdic;
-
-#define BUF_SIZE 4096
-static uint8_t outbuf[BUF_SIZE];
-static uint16_t bufptr = 0;
-
-static struct cable_desc_s {
-	int vendor;
-	int product;
-	int interface;
-	uint8_t dbus_data;
-	uint8_t dbus_ddr;
-	uint8_t cbus_data;
-	uint8_t cbus_ddr;
-	char *description;
-	char * name;
-} cable_desc[] = {
-	{
-		.vendor = 0x0403,
-		.product = 0x6010,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x1B,
-		.description = "FLOSS-JTAG",
-		.name = "flossjtag"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0x6010,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x1B,
-		.description = "FTDIJTAG",
-		.name = "ftdijtag"
-	},
-	{
-		.vendor = 0x15b1,
-		.product = 0x0003,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x1B,
-		.name = "olimex"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0xbdc8,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x1B,
-		.name = "turtelizer"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0xbdc8,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x1B,
-		.name = "jtaghs1"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0xbdc8,
-		.interface = INTERFACE_A,
-		.dbus_data = 0xA8,
-		.dbus_ddr  = 0xAB,
-		.name = "ftdi"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0x6014,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x88,
-		.dbus_ddr  = 0x8B,
-		.cbus_data = 0x20,
-		.cbus_ddr  = 0x3f,
-		.name = "digilent"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0x6014,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x0B,
-		.name = "ft232h"
-	},
-	{
-		.vendor = 0x0403,
-		.product = 0x6011,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x0B,
-		.name = "ft4232h"
-	},
-	{
-		.vendor = 0x15ba,
-		.product = 0x002b,
-		.interface = INTERFACE_A,
-		.dbus_data = 0x08,
-		.dbus_ddr  = 0x1B,
-		.cbus_data = 0x00,
-		.cbus_ddr  = 0x08,
-		.name = "arm-usb-ocd-h"
-	},
-};
-
-void platform_init(int argc, char **argv)
-{
-	int err;
-	int c;
-	unsigned index = 0;
-	char *serial = NULL;
-	char * cablename =  "ftdi";
-	uint8_t ftdi_init[9] = {TCK_DIVISOR, 0x01, 0x00, SET_BITS_LOW, 0,0,
-				SET_BITS_HIGH, 0,0};
-
-	while((c = getopt(argc, argv, "c:s:")) != -1) {
-		switch(c) {
-		case 'c':
-			cablename =  optarg;
-			break;
-		case 's':
-			serial = optarg;
-			break;
-		}
-	}
-
-	for(index = 0; index < sizeof(cable_desc)/sizeof(cable_desc[0]);
-		index++)
-		 if (strcmp(cable_desc[index].name, cablename) == 0)
-		 break;
-
-	if (index == sizeof(cable_desc)/sizeof(cable_desc[0])){
-		fprintf(stderr, "No cable matching %s found\n",cablename);
-		exit(-1);
-	}
-
-	if (cable_desc[index].dbus_data)
-		ftdi_init[4]= cable_desc[index].dbus_data;
-	if (cable_desc[index].dbus_ddr)
-		ftdi_init[5]= cable_desc[index].dbus_ddr;
-	if (cable_desc[index].cbus_data)
-		ftdi_init[7]= cable_desc[index].cbus_data;
-	if(cable_desc[index].cbus_ddr)
-		ftdi_init[8]= cable_desc[index].cbus_ddr;
-
-	printf("\nBlack Magic Probe (" FIRMWARE_VERSION ")\n");
-	printf("Copyright (C) 2015  Black Sphere Technologies Ltd.\n");
-	printf("License GPLv3+: GNU GPL version 3 or later "
-	       "<http://gnu.org/licenses/gpl.html>\n\n");
-
-	if(ftdic) {
-		ftdi_usb_close(ftdic);
-		ftdi_free(ftdic);
-		ftdic = NULL;
-	}
-	if((ftdic = ftdi_new()) == NULL) {
-		fprintf(stderr, "ftdi_new: %s\n",
-			ftdi_get_error_string(ftdic));
-		abort();
-	}
-	if((err = ftdi_set_interface(ftdic, cable_desc[index].interface)) != 0) {
-		fprintf(stderr, "ftdi_set_interface: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-	if((err = ftdi_usb_open_desc(
-		ftdic, cable_desc[index].vendor, cable_desc[index].product,
-		cable_desc[index].description, serial)) != 0) {
-		fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-
-	if((err = ftdi_set_latency_timer(ftdic, 1)) != 0) {
-		fprintf(stderr, "ftdi_set_latency_timer: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-	if((err = ftdi_set_baudrate(ftdic, 1000000)) != 0) {
-		fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-	if((err = ftdi_usb_purge_buffers(ftdic)) != 0) {
-		fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-	if((err = ftdi_write_data_set_chunksize(ftdic, BUF_SIZE)) != 0) {
-		fprintf(stderr, "ftdi_write_data_set_chunksize: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-
-	if((err = ftdi_set_bitmode(ftdic, 0xAB, BITMODE_MPSSE)) != 0) {
-		fprintf(stderr, "ftdi_set_bitmode: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-
-	assert(ftdi_write_data(ftdic, ftdi_init, 9) == 9);
-	assert(gdb_if_init() == 0);
-}
-
-void platform_srst_set_val(bool assert)
-{
-	(void)assert;
-	platform_buffer_flush();
-}
-
-bool platform_srst_get_val(void) { return false; }
-
-void platform_buffer_flush(void)
-{
-	assert(ftdi_write_data(ftdic, outbuf, bufptr) == bufptr);
-//	printf("FT2232 platform_buffer flush: %d bytes\n", bufptr);
-	bufptr = 0;
-}
-
-int platform_buffer_write(const uint8_t *data, int size)
-{
-	if((bufptr + size) / BUF_SIZE > 0) platform_buffer_flush();
-	memcpy(outbuf + bufptr, data, size);
-	bufptr += size;
-	return size;
-}
-
-int platform_buffer_read(uint8_t *data, int size)
-{
-	int index = 0;
-	platform_buffer_flush();
-	while((index += ftdi_read_data(ftdic, data + index, size-index)) != size);
-	return size;
-}
-
-#ifdef WIN32
-#warning "This vasprintf() is dubious!"
-int vasprintf(char **strp, const char *fmt, va_list ap)
-{
-	int size = 128, ret = 0;
-
-	*strp = malloc(size);
-	while(*strp && ((ret = vsnprintf(*strp, size, fmt, ap)) == size))
-		*strp = realloc(*strp, size <<= 1);
-
-	return ret;
-}
-#endif
-
-const char *platform_target_voltage(void)
-{
-	return "not supported";
-}
-
-void platform_delay(uint32_t ms)
-{
-	usleep(ms * 1000);
-}
-
-uint32_t platform_time_ms(void)
-{
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
-}
-

src/platforms/libftdi/swdptap.c

@@ -1,95 +0,0 @@
-/*
- * This file is part of the Black Magic Debug project.
- *
- * Copyright (C) 2011  Black Sphere Technologies Ltd.
- * Written by Gareth McMullin <gareth@blacksphere.co.nz>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/* Quick hack for bit-banging SW-DP interface over FT2232.
- * Intended as proof of concept, not for production.
- */
-
-#include <stdio.h>
-#include <assert.h>
-#include <ftdi.h>
-
-#include "general.h"
-#include "swdptap.h"
-
-static uint8_t olddir = 0;
-
-int swdptap_init(void)
-{
-	int err;
-
-	assert(ftdic != NULL);
-
-	if((err = ftdi_set_bitmode(ftdic, 0xAB, BITMODE_BITBANG)) != 0) {
-		fprintf(stderr, "ftdi_set_bitmode: %d: %s\n",
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-
-	assert(ftdi_write_data(ftdic, (void*)"\xAB\xA8", 2) == 2);
-	olddir = 0;
-
-	return 0;
-}
-
-static void swdptap_turnaround(uint8_t dir)
-{
-	platform_buffer_flush();
-
-	if (dir == olddir)
-		return;
-	olddir = dir;
-
-	if(dir)	/* SWDIO goes to input */
-		assert(ftdi_set_bitmode(ftdic, 0xA3, BITMODE_BITBANG) == 0);
-
-	/* One clock cycle */
-	ftdi_write_data(ftdic, (void *)"\xAB\xA8", 2);
-
-	if(!dir) /* SWDIO goes to output */
-		assert(ftdi_set_bitmode(ftdic, 0xAB, BITMODE_BITBANG) == 0);
-}
-
-bool swdptap_bit_in(void)
-{
-	uint8_t ret;
-
-	swdptap_turnaround(1);
-
-	ftdi_read_pins(ftdic, &ret);
-	ret &= 0x08;
-	ftdi_write_data(ftdic, (void *)"\xA1\xA0", 2);
-
-	return ret;
-}
-
-void swdptap_bit_out(bool val)
-{
-	uint8_t buf[3] = "\xA0\xA1\xA0";
-
-	swdptap_turnaround(0);
-
-	if (val) {
-		for(int i = 0; i < 3; i++)
-			buf[i] |= 0x08;
-	}
-	platform_buffer_write(buf, 3);
-}
-

src/platforms/native/Makefile.inc

@@ -4,9 +4,9 @@ OBJCOPY = $(CROSS_COMPILE)objcopy
 
 CFLAGS += -Istm32/include -mcpu=cortex-m3 -mthumb \
 	-DSTM32F1 -DBLACKMAGIC -I../libopencm3/include \
-	-Iplatforms/stm32
+	-Iplatforms/stm32 -DDFU_SERIAL_LENGTH=9
 
-LDFLAGS_BOOT := $(LDFLAGS) -lopencm3_stm32f1 -Wl,--defsym,_stack=0x20005000 \
+LDFLAGS_BOOT := $(LDFLAGS) --specs=nano.specs -lopencm3_stm32f1 \
 	-Wl,-T,platforms/stm32/blackmagic.ld -nostartfiles -lc \
 	-Wl,-Map=mapfile -mthumb -mcpu=cortex-m3 -Wl,-gc-sections \
 	-L../libopencm3/lib
@@ -21,6 +21,7 @@ endif
 VPATH += platforms/stm32
 
 SRC += 	cdcacm.c	\
+	traceswodecode.c	\
 	traceswo.c	\
 	usbuart.c	\
 	serialno.c	\
@@ -29,10 +30,9 @@ SRC += 	cdcacm.c	\
 
 all:	blackmagic.bin blackmagic_dfu.bin blackmagic_dfu.hex
 
-blackmagic_dfu: usbdfu.o dfucore.o dfu_f1.o
+blackmagic_dfu.elf: usbdfu.o dfucore.o dfu_f1.o serialno.o
 	@echo "  LD      $@"
 	$(Q)$(CC) $^ -o $@ $(LDFLAGS_BOOT)
 
 host_clean:
-	-$(Q)$(RM) -f blackmagic.bin blackmagic_dfu blackmagic_dfu.bin blackmagic_dfu.hex
-
+	-$(Q)$(RM) blackmagic.bin blackmagic_dfu blackmagic_dfu.bin blackmagic_dfu.hex