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

@@ -0,0 +1,25 @@
+src/include/version.h
+blackmagic
+*.bin
+*.hex
+blackmagic_dfu
+dfu_upgrade
+mapfile
+*.o
+*.d
+.*.swp
+*~
+*.pyc
+tags
+.gdbinit
+*.s#*
+*.b#*
+blackmagic_upgrade
+*.exe
+.DS_Store
+*.elf
+.vscode
+cscope.out
+cscope.files
+.gdb_history
+src/artifacts/

.gitmodules

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

.travis.yml

@@ -0,0 +1,27 @@
+dist: bionic
+sudo: required
+
+before_install:
+  - sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
+  - sudo apt-get update -qq
+  - 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
+  - make -C src all_platforms
+
+deploy:
+  provider: s3
+  access_key_id: AKIAIDXRMRPEG5OCN5AQ
+  secret_access_key:
+    secure: AKGtHD71s7FEfmzSWkrEgW8DT3exDzKPROn4hI4kwuMcI6gYoOHqloEhzqZVi9ok8ynEkGfzzaAAcPYCNjlxOu2zmMJFgCiGegIUacrpJuzo9eknqW281pEpIlSXonrlttW9Hm0gJhl3yLKdMQYKoXvCfR7HgUkcN7QSAZxLgv297u/azMLq2z6rZdTCgZYpD2EIB3BlqChZkoepyczBYEtGOj0tMW4WF79qufIfVnUnQqWr8Lef2tQ9X9MEn7LIsHbBgGJ08TGb2yIiPTF+NyE+2ev3KmVmBdzDLdfAAV3koPtiTsTBdcstNAT51vvPsQhuIXB7gIr91xhquCel84DV285aZn2wOwgQ0KHhbFLVFXb2wv+r1saF1b4/rJTiobavDbIXIDVm/UfAs41AyM/zoclTeixAgyA8BpuhDEP+2dDYk3rehZ1Uhbaf8U9OKyQ6kYg1aFOQU5jYFjIbJmgSTlkJwntk9w3EX7lI8LSInNgdPhM8Ak6IjTCKg8NSKvtDH27X++UNVn1r2vX0eMjcusUNSPktjvilWIFMIvPw8bO2yLgj6bLDQ73WsEUC0LiiqL45r3A5KOMkMO8z1xp0TOz2f3Pxdyr1l2gXC0n/hxutoue7HaaPE2zA08giYdSCwZBxSedcoxxKA8V+E4vwfm0D/sWZS+U7vXm15LE=
+  bucket: builds.blacksphere.co.nz
+  region: us-west-2
+  local-dir: src/artifacts
+  upload-dir: blackmagic
+  acl: public_read
+  skip_cleanup: true
+  on:
+    repo: blacksphere/blackmagic
+    branch: master

HACKING

@@ -1,58 +1 @@
-========================================
+See https://github.com/blackmagic-debug/blackmagic/wiki/Hacking
-The Black Magic Debug Project -- HACKING
-========================================
-
-The Black Magic Probe consists of both hardware and firmware components.
-The hardware design resides in the 'hardware' directory and the firmware
-resides in the 'src' directory.
-
-
-Compiling for the native hardware
----------------------------------
-To build the firmware for the standard hardware platform run 'make' in the
-src directory.  You will require a GCC cross compiler for ARM Cortex-M3 
-targets.  You will also need to have the libopenstm32 library installed.
-The default makefile assumes the target is arm-cortexm3-eabi, but 
-you can override this on the command line:
-
-make CROSS_COMPILE=arm-none-eabi-
-
-This will result in binary files:
-blackmagic - ELF binary of the Black Magic debug probe.
-blackmagic.bin - Flat binary of the Black Magic debug probe, load at 0x8002000.
-blackmagic_dfu - ELF binary of the Black Magic DFU bootloader.
-blackmagic_dfu.bin - Flat binary of the DFU bootloader, load at 0x8000000.
-
-If you already have a JTAG/SWD debug probe that can be used to load these
-binaries to your target hardware.  If not the SystemMemory bootloader can
-be used to load the DFU bootloader:
-../scripts/bootprog.py blackmagic_dfu.bin
-
-This requires an appropriate cable to connect the PC serial port to the probe.
-See the schematic for more information.
-
-Once the DFU bootloader is loaded, the Black Magic application can be loaded
-over USB:
-(First connect the probe and observe the flashing red led)
-../scripts/stm32_mem.py blackmagic.bin
-
-The device should reset and re-enumerate as a CDC-ACM device implementing
-the GDB protocol.
-
-
-Compiling as a Linux application using FT2232 hardware
-------------------------------------------------------
-The Black Magic application can also be compiled as a native Linux application
-which will use an FT2232 device to implement the physical JTAG interface.
-This is not the intended mode of operation, but is useful for debugging,
-experimentation, and if you don't have the actual hardware.
-
-First, get the VID/PID for your FT2232 device using 'lsusb'.  Edit the file
-'src/linux/platform.h' and change the VID/PID to match your hardware. 
-Compile the application with the command:
-
-make HOST=linux
-
-Running the application 'blackmagic' will start a GDB server on TCP port 2000.
-
-

Makefile

@@ -0,0 +1,39 @@
+ifneq ($(V), 1)
+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/sam/d
+endif
+	$(Q)$(MAKE) $(MFLAGS) -C src
+
+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

README

@@ -1,47 +0,0 @@
-=======================================
-The Black Magic Debug Project -- README
-=======================================
-
-The Black Magic Debug Probe is gadget providing an in-application
-debug capability for ARM Cortex-M3 microcontrollers.  It interfaces
-with the GDB, the GNU source level debugger over the USB bus, and
-communicates with the target microcontroller over either a JTAG or
-Serial Wire debug port.
-
-Currently supported microcontrollers:
-
- - ST STM32 Family
- - TI/LMI Stellaris Family
-
-
-Getting started
-===============
-The Black Magic Probe is available as a built-up product form Black
-Sphere Technologies.  Contact <sales@blacksphere.co.nz> should
-you wish to order one.  If you would like to work on the project see
-the file HACKING for developer's info.
-
-When connected via USB, the Black Magic probe will enumerate as a CDC-ACM
-device which the OS should present as a tty device or serial port.  The
-GDB remote debugging protocol is implemented over this virtual character
-stream.  To connect your ARM GDB to the target device use the following
-commands:
-
-(gdb) target extended-remote /dev/ttyACM0
-(gdb) mon jtag_scan
-(gdb) attach 1
-
-The command 'mon swdp_scan' may be used to use the Serial-Wire Debug Protocol
-instead of JTAG to connect to the target.
-
-Once attached, all the standard GDB commands may be used to start and control
-the execution of the embedded application.
-
-
-Project layout
-==============
-flashstub/ - Source code for flash programming stubs in target drivers.
-hardware/ - Schematic and PCB layout for the Black Magic Probe
-scripts/ - Python scripts useful for programming devices.
-src/ - Firmware source code for the Black Magic debug probe.
-

README.md

@@ -0,0 +1,54 @@
+Jeff Probe
+==========
+
+This is a fork of the [original Black Magic Probe](https://github.com/blacksphere/blackmagic).
+
+The original is arguably better, faster and wider supported. However, this 
+project was a way to offer an affordable version and I'll rely on community
+support and pull requests.
+
+One urguably better funncton is the ability to do DEBUG and Serial communication
+over a single JTAG cable when paired with a device that uses single wire JTAG.
+
+Normally, the serial header can be used on a target for the serial port, and
+shows up as the second serial device on the system, however, we can dynamically
+change the pins to use the ones on the JTAG cable with the following command:
+
+``` bash
+ $ mon convert_tdio enable
+```
+
+Compilation
+---
+
+Newer toolchains can cause issues. I usually work 4_9-2014q4-20141203 found [here.](https://launchpad.net/gcc-arm-embedded/4.9/4.9-2014-q4-major/+download/gcc-arm-none-eabi-4_9-2014q4-20141203-mac.tar.bz2)
+
+the versionfollowing version
+
+```bash
+ $ make clean
+ $ make PROBE_HOST=jeff CUSTOM_SER=1
+ $ dfu-util --device ,1d50:6017 -s 0x00002000:leave -D src/blackmagic.bin 
+```
+
+CUSTOM OPTIONS
+---
+
+On mac, our device shows up with a serial number /dev/tty.cuJEFF123HDC 
+
+This can be annoy if we want to autocnnect with a gith script. We can override
+the use of a serial number by doing a custom compliation such that our device
+shows up with the following: /dev/cu.usbmodemJEFF1 and /dev/cu.usbmodemJEFF3
+
+```bash
+ $ make PROBE_HOST=jeff CUSTOM_SER=1
+```
+
+More
+---
+
+More helpful information can be found on the black magic probe [readme](https://github.com/blacksphere/blackmagic/blob/master/README.md#black-magic-probe), which is relevant.
+
+See online documentation at https://github.com/blacksphere/blackmagic/wiki
+
+Binaries from the latest automated build can be found on the release page.

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

@@ -0,0 +1,89 @@
+; Windows USB CDC ACM driver setup file.
+
+; Copyright (C) 2004 Al Borchers (alborchers@steinerpoint.com)
+; Taken from Linux documentation, modified for Black Magic debug probe
+; by Gareth McMullin <gareth@blacksphere.co.nz>
+
+; This provides the driver information for the GDB and UART interfaces to
+; be presented as virtual serial ports in Windows.
+
+; Common to Windows 32- and 64-bit systems
+
+[Version]
+Signature="$Windows NT$"
+Class=Ports
+ClassGuid={4D36E978-E325-11CE-BFC1-08002BE10318}
+Provider=%BLACKMAGIC%
+DriverVer=28/12/2011,0.0.1.1
+
+[Manufacturer]
+%VendorName%=DeviceList, NTamd64
+
+[Strings]
+VendorName = "Black Magic Debug"
+BLACKMAGICGDB = "Black Magic GDB Server"
+BLACKMAGICUART = "Black Magic UART Port"
+BLACKMAGIC_DISPLAY_NAME = "Black Magic Probe Driver"
+
+[DeviceList]
+%BLACKMAGICGDB%=DriverInstall, USB\VID_1d50&PID_6018&Rev_0100&MI_00
+%BLACKMAGICUART%=DriverInstall, USB\VID_1d50&PID_6018&Rev_0100&MI_02
+
+[DeviceList.NTamd64]
+%BLACKMAGICGDB%=DriverInstall, USB\VID_1d50&PID_6018&Rev_0100&MI_00
+%BLACKMAGICUART%=DriverInstall, USB\VID_1d50&PID_6018&Rev_0100&MI_02
+
+[DestinationDirs]
+DefaultDestDir=10,System32\Drivers
+
+; Windows 32-bit sections
+;~~~~~~~~~~~~~~~~~~~~~~~~~
+
+[DriverInstall.nt]
+CopyFiles=DriverCopyFiles.nt
+AddReg=DriverInstall.nt.AddReg
+
+[DriverCopyFiles.nt]
+usbser.sys,,,0x20
+
+[DriverInstall.nt.AddReg]
+HKR,,DevLoader,,*ntkern
+HKR,,NTMPDriver,,usbser.sys
+HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"
+
+[DriverInstall.nt.Services]
+AddService = usbser,0x0002,DriverService.nt
+
+[DriverService.nt]
+DisplayName = %BLACKMAGIC_DISPLAY_NAME%
+ServiceType = 1                  ; SERVICE_KERNEL_DRIVER
+StartType = 3                    ; SERVICE_DEMAND_START
+ErrorControl = 1                 ; SERVICE_ERROR_NORMAL
+ServiceBinary = %10%\System32\Drivers\usbser.sys
+LoadOrderGroup = Base
+
+; Windows 64-bit sections
+;~~~~~~~~~~~~~~~~~~~~~~~~~
+[DriverInstall.NTamd64]
+CopyFiles=DriverCopyFiles.NTamd64
+AddReg=DriverInstall.NTamd64.AddReg
+
+[DriverCopyFiles.NTamd64]
+usbser.sys,,,0x20
+
+[DriverInstall.NTamd64.AddReg]
+HKR,,DevLoader,,*ntkern
+HKR,,NTMPDriver,,usbser.sys
+HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"
+
+[DriverInstall.NTamd64.Services]
+AddService = usbser,0x0002,DriverService.NTamd64
+
+[DriverService.NTamd64]
+DisplayName = %BLACKMAGIC_DISPLAY_NAME%
+ServiceType = 1                  ; SERVICE_KERNEL_DRIVER
+StartType = 3                    ; SERVICE_DEMAND_START
+ErrorControl = 1                 ; SERVICE_ERROR_NORMAL
+ServiceBinary = %10%\System32\Drivers\usbser.sys
+LoadOrderGroup = Base
+

driver/blackmagic_upgrade.inf

@@ -0,0 +1,161 @@
+; blackmagic_upgrade.inf
+; Copyright (c) 2010 libusb-win32 (GNU LGPL)
+[Strings]
+DeviceName = "Black Magic Firmware Upgrade"
+DeviceNameDFU = "Black Magic Probe (Upgrade)"
+DeviceNameTPA = "Black Magic Trace Capture"
+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"
+DeviceIDTPA= "VID_1d50&PID_6018&Rev_0100&MI_05"
+DeviceIDDFUold= "VID_0483&PID_df11&Rev_0200"
+
+[Version]
+Signature   = "$Windows NT$"
+Class       = "libusb-win32 devices"
+ClassGuid   = {EB781AAF-9C70-4523-A5DF-642A87ECA567}
+Provider    = "libusb-win32"
+CatalogFile = blackmagic_upgrade.cat
+DriverVer   = 01/18/2012, 1.2.6.0
+
+[ClassInstall32]
+Addreg = libusb_class_install_add_reg
+
+[libusb_class_install_add_reg]
+HKR,,,0,"libusb-win32 devices"
+HKR,,Icon,,-20
+
+[Manufacturer]
+%VendorName% = Devices, NT, NTAMD64, NTIA64
+
+;--------------------------------------------------------------------------
+; libusb-win32 files
+;--------------------------------------------------------------------------
+
+[SourceDisksNames]
+1 = %SourceName%
+
+[SourceDisksFiles.x86]
+libusb0.sys     = 1,x86
+libusb0_x86.dll = 1,x86
+
+[SourceDisksFiles.amd64]
+libusb0.sys     = 1,amd64
+libusb0.dll     = 1,amd64
+libusb0_x86.dll = 1,x86
+
+[SourceDisksFiles.ia64]
+libusb0.sys     = 1,ia64
+libusb0.dll     = 1,ia64
+libusb0_x86.dll = 1,x86
+
+[DestinationDirs]
+libusb_files_sys       = 10,system32\drivers
+libusb_files_dll       = 10,system32
+libusb_files_dll_wow64 = 10,syswow64
+libusb_files_dll_x86   = 10,system32
+
+[libusb_files_sys]
+libusb0.sys
+
+[libusb_files_dll]
+libusb0.dll
+
+[libusb_files_dll_x86]
+libusb0.dll, libusb0_x86.dll
+
+[libusb_files_dll_wow64]
+libusb0.dll, libusb0_x86.dll
+
+;--------------------------------------------------------------------------
+; libusb-win32 device driver
+;--------------------------------------------------------------------------
+
+[LIBUSB_WIN32_DEV.NT]
+CopyFiles = libusb_files_sys, libusb_files_dll_x86
+
+[LIBUSB_WIN32_DEV.NTAMD64]
+CopyFiles = libusb_files_sys, libusb_files_dll, libusb_files_dll_wow64
+
+[LIBUSB_WIN32_DEV.NTIA64]
+CopyFiles = libusb_files_sys, libusb_files_dll, libusb_files_dll_wow64
+
+[LIBUSB_WIN32_DEV.NT.HW]
+DelReg = libusb_del_reg_hw
+AddReg = libusb_add_reg_hw
+
+[LIBUSB_WIN32_DEV.NTAMD64.HW]
+DelReg = libusb_del_reg_hw
+AddReg = libusb_add_reg_hw
+
+[LIBUSB_WIN32_DEV.NTIA64.HW]
+DelReg = libusb_del_reg_hw
+AddReg = libusb_add_reg_hw
+
+[LIBUSB_WIN32_DEV.NT.Services]
+AddService = libusb0, 0x00000002, libusb_add_service
+
+[LIBUSB_WIN32_DEV.NTAMD64.Services]
+AddService = libusb0, 0x00000002, libusb_add_service
+
+[LIBUSB_WIN32_DEV.NTIA64.Services]
+AddService = libusb0, 0x00000002, libusb_add_service
+
+; Older versions of this .inf file installed filter drivers. They are not
+; needed any more and must be removed
+[libusb_del_reg_hw]
+HKR,,LowerFilters
+HKR,,UpperFilters
+
+; libusb-win32 device properties
+[libusb_add_reg_hw]
+HKR,,SurpriseRemovalOK,0x00010001,1
+
+; (Optional) the usb configuration value to select when this device
+; is started.  If this key does not exist the first config is selected.
+;HKR,,InitialConfigValue,0x00010001,<your config value>
+
+;--------------------------------------------------------------------------
+; libusb-win32 service
+;--------------------------------------------------------------------------
+
+[libusb_add_service]
+DisplayName   = "libusb-win32 - Kernel Driver 01/18/2012 1.2.6.0"
+ServiceType   = 1
+StartType     = 3
+ErrorControl  = 0
+ServiceBinary = %12%\libusb0.sys
+
+;--------------------------------------------------------------------------
+; libusb-win32 devices
+;--------------------------------------------------------------------------
+
+; Hardware IDs in a 'Devices' section can be installed by libusb-win32
+; using usb_install_driver_np(), usb_install_driver_np_rundll(), or the
+; inf-wizard utility.
+;
+[Devices]
+%DeviceName% = LIBUSB_WIN32_DEV, USB\%DeviceID%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV, USB\%DeviceIDDFU%
+%DeviceNameTPA% = LIBUSB_WIN32_DEV, USB\%DeviceIDTPA%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV, USB\%DeviceIDDFUold%
+
+[Devices.NT]
+%DeviceName% = LIBUSB_WIN32_DEV.NT, USB\%DeviceID%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV.NT, USB\%DeviceIDDFU%
+%DeviceNameTPA% = LIBUSB_WIN32_DEV.NT, USB\%DeviceIDTPA%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV.NT, USB\%DeviceIDDFUold%
+
+[Devices.NTAMD64]
+%DeviceName% = LIBUSB_WIN32_DEV.NTAMD64, USB\%DeviceID%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV.NTAMD64, USB\%DeviceIDDFU%
+%DeviceNameTPA% = LIBUSB_WIN32_DEV.NTAMD64, USB\%DeviceIDTPA%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV.NTAMD64, USB\%DeviceIDDFUold%
+
+[Devices.NTIA64]
+%DeviceName% = LIBUSB_WIN32_DEV.NTIA64, USB\%DeviceID%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV.NTIA64, USB\%DeviceIDDFU%
+%DeviceNameTPA% = LIBUSB_WIN32_DEV.NTIA64, USB\%DeviceIDTPA%
+%DeviceNameDFU% = LIBUSB_WIN32_DEV.NTIA64, USB\%DeviceIDDFUold%
+

flashstub/README

@@ -1,5 +0,0 @@
-These are the assembler routines for executing a flash write
-on the supported targets.  They are kept here for reference, but
-are not used, as the compiled binary code is included in the 
-target drivers.
-

flashstub/lmi.s

@@ -1,42 +0,0 @@
-
-_start:
-	ldr r0, _flashbase
-	ldr r1, _addr
-	mov r2, pc
-	add r2, #(_data - . - 2)
-	ldr r3, _size
-	ldr r5, _flash_write_cmd
-_next:
-	cbz r3, _done
-	@ Write address to FMA
-	str r1, [r0]
-	@ Write data to FMD
-	ldr r4, [r2]
-	str r4, [r0, #4]
-	@ Write WRITE bit to FMC
-	str r5, [r0, #8]
-_wait:	@ Wait for WRITE bit to clear
-	ldr r4, [r0, #8]
-	mov r6, #1
-	tst r4, r6
-	bne _wait
-
-	sub r3, #1
-	add r1, #4
-	add r2, #4
-	b _next
-_done:
-	bkpt
-
-@.align 4
-.org 0x28
-_flashbase:
-	.word 0x400FD000
-_flash_write_cmd:
-	.word 0xA4420001
-_addr:
-	.word 0
-_size:
-	.word 4
-_data:
-	.string "Hello World!\n\0\0\0"

flashstub/stm32.s

@@ -1,42 +0,0 @@
-.global _start
-
-_start:
-	ldr r0, _flashbase
-	ldr r1, _addr
-	mov r2, pc
-	add r2, #(_data - . - 2)
-	ldr r3, _size
-	mov r5, #1
-_next:
-	cbz r3, _done
-	@ Write PG command to FLASH_CR
-	str r5, [r0, #0x10]
-	@ Write data to flash (half-word)
-	ldrh r4, [r2]
-	strh r4, [r1]
-
-_wait:	@ Wait for BSY bit to clear
-	ldr r4, [r0, #0x0C]
-	mov r6, #1
-	tst r4, r6
-	bne _wait
-
-	sub r3, #2
-	add r1, #2
-	add r2, #2
-	b _next
-_done:
-	bkpt
-
-@.align 4
-.org 0x28
-_flashbase:
-	.word 0x40022000
-_addr:
-	.word 0
-_size:
-	.word 12
-_data:
-	.word 0xAAAAAAAA
-	.word 0xBBBBBBBB
-	.word 0xCCCCCCCC

libopencm3

@@ -0,0 +1 @@
+Subproject commit 63573143ef7e1b037d1f0c5baedc5264e12562b8

scripts/bootprog.py

@@ -1,4 +1,4 @@
-#!/usr/bin/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"
+		#print("sending sync byte")
-		self.serial.write("\x7F")
+		self.serial.write(b"\x7f")
 		self._checkack()
 
 	def _sendcmd(self, cmd):
-		if type(cmd) == int:
+		cmd = ord(cmd)
-			cmd = chr(cmd)
+		cmd = bytes((cmd, cmd ^ 0xff))
-		cmd += chr(ord(cmd) ^ 0xff)
+		#print("sendcmd:", repr(cmd))
-		#print "sendcmd:", repr(cmd)
 		self.serial.write(cmd)
 
 	def _send(self, data):
 		csum = 0
-		for c in data: csum ^= ord(c)
+		for c in data: csum ^= c
-		data = data + chr(csum)
+		data = data + bytes((csum,))
-		#print "sending:", repr(data)
+		#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":
+	if platform == "linux":
-		print  "\x1b\x5b\x48\x1b\x5b\x32\x4a" # clear terminal screen
+		print("\x1b\x5b\x48\x1b\x5b\x32\x4a") # clear terminal screen
-	print "STM32 SystemMemory Production Programmer -- version 1.1"
+	print("STM32 SystemMemory Production Programmer -- version 1.1")
-	print "Copyright (C) 2011  Black Sphere Technologies"
+	print("Copyright (C) 2011  Black Sphere Technologies")
-	print "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>"
+	print("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>")
-	print
+	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("Usage %s [-d <dev>] [-b <baudrate>] [-a <address>] <filename>" % argv[0])
-		print "\t-d : Use target on interface <dev> (default: %s)" % dev
+		print("\t-d : Use target on interface <dev> (default: %s)" % dev)
-		print "\t-b : Set device baudrate (default: %d)" % baud
+		print("\t-b : Set device baudrate (default: %d)" % baud)
-		print "\t-a : Set programming address (default: 0x%X)" % addr
+		print("\t-a : Set programming address (default: 0x%X)" % addr)
-		print
+		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))),
+		print("Programming address 0x%08X..0x%08X...\r" % (addr, addr + min(len(prog), 255)), end=' ')
-		stdout.flush();
+		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

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+
+# Written by Antonio Galea - 2010/11/18
+# Distributed under Gnu LGPL 3.0
+# see http://www.gnu.org/licenses/lgpl-3.0.txt
+
+import sys,struct,zlib,os
+from optparse import OptionParser
+from intelhex import IntelHex
+
+DEFAULT_DEVICE="0x0483:0xdf11"
+
+def named(tuple,names):
+  return dict(zip(names.split(),tuple))
+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(b'\0',1)[0]
+def compute_crc(data):
+  return 0xFFFFFFFF & -zlib.crc32(data) -1
+
+def parse(file,dump_images=False):
+  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)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'] = 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)
+      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)
+    if len(target):
+      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)r, %(len)d, 0x%(crc)08x' % suffix)
+  if crc != suffix['crc']:
+    print("CRC ERROR: computed crc32 is 0x%08x" % crc)
+  data = data[16:]
+  if data:
+    print("PARSE ERROR")
+
+def build(file,targets,device=DEFAULT_DEVICE):
+  data = b''
+  for t,target in enumerate(targets):
+    tdata = b''
+    for image in target:
+      tdata += struct.pack('<2I',image['address'],len(image['data']))+image['data']
+
+    trgt = b'Target'
+    st = b'ST...'
+    tdata = struct.pack('<6sBI255s2I',trgt,0,1,st,len(tdata),len(target)) + tdata
+    data += tdata
+
+  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)
+  crc   = compute_crc(data)
+  data += struct.pack('<I',crc)
+  open(file,'wb').write(data)
+
+if __name__=="__main__":
+  usage = """
+%prog [-d|--dump] infile.dfu
+%prog {-b|--build} address:file.bin [-b address:file.bin ...] [{-D|--device}=vendor:device] outfile.dfu
+%prog {-i|--ihex} file.hex [-i file.hex ...] [{-D|--device}=vendor:device] outfile.dfu"""
+
+  parser = OptionParser(usage=usage)
+  parser.add_option("-b", "--build", action="append", dest="binfiles",
+    help="build a DFU file from given BINFILES", metavar="BINFILES")
+  parser.add_option("-i", "--ihex", action="append", dest="hexfiles",
+    help="build a DFU file from given HEXFILES", metavar="HEXFILES")
+  parser.add_option("-D", "--device", action="store", dest="device",
+    help="build for DEVICE, defaults to %s" % DEFAULT_DEVICE, metavar="DEVICE")
+  parser.add_option("-d", "--dump", action="store_true", dest="dump_images",
+    default=False, help="dump contained images to current directory")
+  (options, args) = parser.parse_args()
+
+  if (options.binfiles or options.hexfiles) and len(args)==1:
+    target = []
+    
+    if options.binfiles:
+      for arg in options.binfiles:
+        try:
+          address,binfile = arg.split(':',1)
+        except ValueError:
+          print("Address:file couple '%s' invalid." % arg)
+          sys.exit(1)
+        try:
+          address = int(address,0) & 0xFFFFFFFF
+        except ValueError:
+          print("Address %s invalid." % address)
+          sys.exit(1)
+        if not os.path.isfile(binfile):
+          print("Unreadable file '%s'." % binfile)
+          sys.exit(1)
+        target.append({ 'address': address, 'data': open(binfile,'rb').read() })
+    
+    if options.hexfiles:
+      for hex in options.hexfiles:
+        ih = IntelHex(hex)
+        address = ih.minaddr()
+        data = ih.tobinstr()
+        try:
+          address = address & 0xFFFFFFFF
+        except ValueError:
+          print("Address %s invalid." % address)
+          sys.exit(1)
+        target.append({ 'address': address, 'data': data })
+    
+    outfile = args[0]
+    device = DEFAULT_DEVICE
+    if options.device:
+      device=options.device
+    try:
+      v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
+    except:
+      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)
+      sys.exit(1)
+    parse(infile, dump_images=options.dump_images)
+  else:
+    parser.print_help()
+    sys.exit(1)
+

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 | 
+		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
-			usb.RECIP_INTERFACE, DFU_DETACH, 
+			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 | 
+		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
-			usb.RECIP_INTERFACE, DFU_CLRSTATUS, 
+			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 | 
+		self.handle.controlMsg(usb.ENDPOINT_OUT | usb.TYPE_CLASS |
-			usb.RECIP_INTERFACE, DFU_ABORT, 
+			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, 
+		print("Device %s: ID %04x:%04x %s - %s" % (dfu[0].filename,
-			dfu[0].idVendor, dfu[0].idProduct, man, product)
+			dfu[0].idVendor, dfu[0].idProduct, man, product))
-		print "%r, %r" % (dfu[1], dfu[2])
+		print("%r, %r" % (dfu[1], dfu[2]))
 
 
 

scripts/gdb.py

@@ -1,9 +1,9 @@
-#!/usr/bin/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"""
+	"""Convert a bytes object into hex bytes representation"""
-	ret = ''
+	return s.hex().encode()
-	for c in s:
-		ret += "%02X" % ord(c)
-	return ret
 
 def unhexify(s):
-	"""Convert a hex string into binary representation"""
+	"""Convert a hex-encoded bytes into bytes object"""
-	ret = ''
+	return bytes.fromhex(s.decode())
-	for i in range(0, len(s), 2):
-		ret += chr(int(s[i:i+2], 16))
-	return ret
 
 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)
+				c, = self.sock.recv(1)
-				if c == '#': break
+				if c == ord('#'):
+					break
 
-				if c == '$':
+				if c == ord('$'):
-					packet = ''
+					packet = []
 					csum = 0
 					continue
 
-				if c == '}':
+				if c == ord('}'):
-					c = self.sock.recv(1)
+					c, = self.sock.recv(1)
-					csum += ord(c) + ord('}')
+					csum += c + ord('}')
-					packet += chr(ord(c) ^ 0x20)
+					packet.append(c ^ 0x20)
-					continue	
+					continue
 
-				packet += c
+				packet.append(c)
-				csum += ord(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(b'-')
-		
-		self.sock.send('+')
-		return packet
 
+		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('$')
+			out = []
-			csum = 0
+
 			for c in packet:
-				if (c == '$') or (c == '#') or (c == '}'):
+				if (c in b'$#}'):
-					self.sock.send('}')
+					out.append(ord('}'))
-					self.sock.send(chr(ord(c) ^ 0x20))
+					out.append(c ^ 0x20)
-					csum += (ord(c) ^ 0x20) + ord('}')
 				else:
-					self.sock.send(c)
+					out.append(c)
-					csum += ord(c)
+
-			self.sock.send('#')
+			csum = sum(out)
-			self.sock.send("%02X" % (csum & 0xFF))
+			outb = b'$'+bytes(out)+b'#%02X' % (csum & 0xff)
-			if self.sock.recv(1) == '+': break
+
+			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 == b'':
-			if s.startswith('O'): ret.append(unhexify(s[1:]))
+				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")
+		self.putpacket(b"D")
-		if self.getpacket() != 'OK': 
+		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))
+		ret = b''
-		reply = self.getpacket()
+		while length:
-		if (len(reply) == 0) or (reply[0] == 'E'): 
+			# print("Read")
-			raise Exception('Error reading memory at 0x%08X' % addr)
+			packlen = min(length,self.PacketSize//2)
-		try:
+			self.putpacket(b"m%08X,%08X" % (addr, packlen))
-			data = unhexify(reply)
+			reply = self.getpacket()
-		except Excpetion:
+			if (reply == b'') or (reply[:1] == b'E'):
-			raise Exception('Invalid response to memory read packet: %r' % reply)
+				raise Exception('Error reading memory at 0x%08X' % addr)
-		return data
+			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))
+		data = bytes(data)
-		if self.getpacket() != 'OK': 
+
-			raise Exception('Error writing to memory at 0x%08X' % addr)
+		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'): 
+		if (reply == b'') or (reply[:1] == b'E'):
-			raise Exception('Error reading memory at 0x%08X' % addr)
+			raise Exception('Error reading target core registers')
 		try:
 			data = unhexify(reply)
-		except Excpetion:
+		except Exception:
-			raise Exception('Invalid response to memory read packet: %r' % reply)
+			raise Exception('Invalid response to registers read packet: %r' % reply)
-		return struct.unpack("=16L", data)
+		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))
+		self.putpacket(b"G" + hexify(data))
-		if self.getpacket() != 'OK': 
+		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"):
+		if not reply.startswith(b"T05"):
-			raise Exception("Invalid stop response: %r" % reply)
+			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] = bytes(0xff for i in range(self.blocksize))
-				self.blocks[index] = (self.blocks[index][:bloffset] + bldata + 
+				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
+				if data is None:
-				#print "Erasing flash at 0x%X" % (self.offset + self.blocksize*i)
+					continue
-				self.target.putpacket("vFlashErase:%08X,%08X" % 
+				#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)
+					#print("Writing %d bytes at 0x%X" % (len(d), addr))
-					self.target.putpacket("vFlashWrite:%08X:%s" % (addr, d))
+					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")
+				self.target.putpacket(b"vFlashDone")
-				if self.target.getpacket() != 'OK': 
+				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

@@ -0,0 +1,56 @@
+#!/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
+import re
+import io
+
+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)
+
+proc = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
+
+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(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)
+        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
+
+        specdict.setdefault((ram,flash),[]).append(spec)
+        specs.append(spec)
+        spec=Spec()
+
+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;')
+

scripts/hexprog.py

@@ -1,9 +1,9 @@
-#!/usr/bin/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);
+		rectype = int(line[7:9], 16)
-		if sum(ord(x) for x in gdb.unhexify(line[1:11+reclen*2])) & 0xff != 0:
+		if sum(x for x in bytes.fromhex(line[1:11+reclen*2])) & 0xff != 0:
-			raise Exception("Checksum error in hex file") 
+			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":
+	if platform == "linux":
-		print ("\x1b\x5b\x48\x1b\x5b\x32\x4a") # clear terminal screen
+		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("Copyright (C) 2011  Black Sphere Technologies")
-	print "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>"
+	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"
+			if opt[0] == "-s":
-			elif opt[0] == "-b": baud = int(opt[1])
+				scan = "swdp_scan"
-			elif opt[0] == "-d": dev = opt[1]
+			elif opt[0] == "-b":
-			elif opt[0] == "-t": targetno = int(opt[1])
+				baud = int(opt[1])
-			elif opt[0] == "-r": unprot = True
+			elif opt[0] == "-d":
-			elif opt[0] == "-R": prot = True
+				dev = opt[1]
-			else: raise Exception()
+			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 = Serial(dev) #, baud, timeout=0.1)
-		s.setDTR(1)
+		#s.setDTR(1)
-		while s.read(1024):
+		#s.flushInput()
-			pass
+
+		#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,
+		for s in r:
-	except SerialException, e:
+			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: 
+	for s in r:
-		print s,
+		print(s.decode(), end=' ')
-	print
+	print()
 
 	r = target.monitor("targets")
-	for s in r: 
+	for s in r:
-		if s.startswith("No. Att Driver"): targetlist = []
+		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/setlocalversion

@@ -1,82 +0,0 @@
-#!/bin/sh
-#
-# This scripts adds local version information from the version
-# control systems git, mercurial (hg) and subversion (svn).
-#
-# If something goes wrong, send a mail the kernel build mailinglist
-# (see MAINTAINERS) and CC Nico Schottelius
-# <nico-linuxsetlocalversion -at- schottelius.org>.
-#
-#
-
-usage() {
-	echo "Usage: $0 [srctree]" >&2
-	exit 1
-}
-
-cd "${1:-.}" || usage
-
-# Check for git and a git repo.
-if head=`git rev-parse --verify --short HEAD 2>/dev/null`; then
-
-	# If we are at a tagged commit (like "v2.6.30-rc6"), we ignore it,
-	# because this version is defined in the top level Makefile.
-	if [ -z "`git describe --exact-match 2>/dev/null`" ]; then
-
-		# If we are past a tagged commit (like "v2.6.30-rc5-302-g72357d5"),
-		# we pretty print it.
-		if atag="`git describe 2>/dev/null`"; then
-			echo "$atag" | awk -F- '{printf("-%05d-%s", $(NF-1),$(NF))}'
-
-		# If we don't have a tag at all we print -g{commitish}.
-		else
-			printf '%s%s' -g $head
-		fi
-	fi
-
-	# Is this git on svn?
-	if git config --get svn-remote.svn.url >/dev/null; then
-	        printf -- '-svn%s' "`git svn find-rev $head`"
-	fi
-
-	# Update index only on r/w media
-	[ -w . ] && git update-index --refresh --unmerged > /dev/null
-
-	# Check for uncommitted changes
-	if git diff-index --name-only HEAD | grep -v "^scripts/package" \
-	    | read dummy; then
-		printf '%s' -dirty
-	fi
-
-	# All done with git
-	exit
-fi
-
-# Check for mercurial and a mercurial repo.
-if hgid=`hg id 2>/dev/null`; then
-	tag=`printf '%s' "$hgid" | cut -d' ' -f2`
-
-	# Do we have an untagged version?
-	if [ -z "$tag" -o "$tag" = tip ]; then
-		id=`printf '%s' "$hgid" | sed 's/[+ ].*//'`
-		printf '%s%s' -hg "$id"
-	fi
-
-	# Are there uncommitted changes?
-	# These are represented by + after the changeset id.
-	case "$hgid" in
-		*+|*+\ *) printf '%s' -dirty ;;
-	esac
-
-	# All done with mercurial
-	exit
-fi
-
-# Check for svn and a svn repo.
-if rev=`svn info 2>/dev/null | grep '^Last Changed Rev'`; then
-	rev=`echo $rev | awk '{print $NF}'`
-	printf -- '-svn%s' "$rev"
-
-	# All done with svn
-	exit
-fi

scripts/stm32_mem.py

@@ -1,7 +1,8 @@
-#!/usr/bin/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,14 +20,15 @@
 
 from time import sleep
 import struct
-from sys import stdout, argv
+import os
+from sys import stdout
 
-import usb
+import argparse
 import dfu
 
-CMD_GETCOMMANDS =            0x00
+CMD_GETCOMMANDS =       0x00
-CMD_SETADDRESSPOINTER =      0x21
+CMD_SETADDRESSPOINTER = 0x21
-CMD_ERASE =                  0x41
+CMD_ERASE =             0x41
 
 def stm32_erase(dev, addr):
 	erase_cmd = struct.pack("<BL", CMD_ERASE, addr)
@@ -38,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:
@@ -46,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()
@@ -58,52 +80,182 @@ def stm32_manifest(dev):
 		if status.bState == dfu.STATE_DFU_MANIFEST:
 			break
 
-if __name__ == "__main__":
+def stm32_scan(args, test):
-	print
-	print "USB Device Firmware Upgrade - Host Utility -- 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
-
 	devs = dfu.finddevs()
+	bmp_devs = []
+	bmp = 0
 	if not devs:
-		print "No devices found!"
+		if test:
+			return
+
+		print("No DFU devices found!")
 		exit(-1)
 
 	for dev in devs:
-		dfudev = dfu.dfu_device(*dev)
+		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)
-		product = dfudev.handle.getString(dfudev.dev.iProduct, 30)
+		if man == b"Black Sphere Technologies":
-		if man == "Black Sphere Technologies": break
+			bmp = bmp + 1
-		if man == "STMicroelectronics": break
+			bmp_devs.append(dev)
 
-	print "Device %s: ID %04x:%04x %s - %s" % (dfudev.dev.filename, 
+	if bmp == 0:
-		dfudev.dev.idVendor, dfudev.dev.idProduct, man, product)
+		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("-")
+
+	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()
+	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()
+		try:
-		print "Run again to upgrade firmware."
+			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(argv[1], "rb").read()
+	bin = file.read()
 
-	addr = 0x8002000
+	product = dfudev.handle.getString(dfudev.dev.iProduct, 64).decode('utf8')
+	if args.address:
+		start = int(args.address, 0)
+	else:
+		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()
-		stm32_erase(dfudev, addr)
+		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")
+			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,44 +1,203 @@
-ifndef PROBE_HOST
+PROBE_HOST ?= native
-PROBE_HOST = stm32
+PLATFORM_DIR = platforms/$(PROBE_HOST)
+VPATH += $(PLATFORM_DIR) target
+ENABLE_DEBUG ?=
+
+ifneq ($(V), 1)
+MAKEFLAGS += --no-print-dir
+Q := @
 endif
 
-VPATH += $(PROBE_HOST)
+CFLAGS += -Wall -Wextra -Werror -Wno-char-subscripts \
+	-std=gnu99 -MD -I./target \
+	-I. -Iinclude -I$(PLATFORM_DIR)
 
-BUILDDATE := `date +"%Y%m%d"`
+ifeq ($(ENABLE_DEBUG), 1)
+CFLAGS += -DENABLE_DEBUG
+endif
 
-CFLAGS += -Wall -Wextra -Wno-pointer-sign -Wno-char-subscripts\
+SRC =			\
-	-O0 -std=gnu99 -g3 -DBUILDDATE=\"$(BUILDDATE)\"\
-	-I. -Iinclude -I$(PROBE_HOST) \
-	-DVERSION_SUFFIX=\"`../scripts/setlocalversion`\"
-
-SRC = 	gdb_if.c	\
-	gdb_packet.c	\
-	gdb_main.c	\
-	hex_utils.c	\
-	jtagtap.c	\
-	swdptap.c	\
 	adiv5.c		\
-	adiv5_swdp.c	\
-	cortexm3.c	\
-	stm32_tgt.c	\
-	main.c		\
-	platform.c	\
-	command.c	\
-	jtag_scan.c	\
 	adiv5_jtagdp.c	\
+	adiv5_swdp.c	\
+	command.c	\
+	cortexa.c	\
+	cortexm.c	\
+	crc32.c		\
+	efm32.c		\
+	exception.c	\
+	gdb_if.c	\
+	gdb_main.c	\
+	gdb_hostio.c	\
+	gdb_packet.c	\
+	hex_utils.c	\
+	jtag_devs.c	\
+	jtag_scan.c	\
 	lmi.c		\
-	arm7tdmi.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		\
+	samd.c		\
+	samx5x.c	\
+	stm32f1.c	\
+	ch32f1.c	\
 	stm32f4.c	\
+	stm32h7.c	\
+	stm32l0.c	\
+	stm32l4.c	\
+	stm32g0.c	\
+	target.c	\
 
-include $(PROBE_HOST)/Makefile.inc
 
-OBJ = $(SRC:.c=.o)
+include $(PLATFORM_DIR)/Makefile.inc
 
-blackmagic: $(OBJ)
+OPT_FLAGS ?= -Os
-	$(CC) -o $@ $^ $(LDFLAGS)
+CFLAGS += $(OPT_FLAGS)
+LDFLAGS += $(OPT_FLAGS)
 
-.PHONY:	clean host_clean
+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)
+
+%.o:	%.c
+	@echo "  CC      $<"
+	$(Q)$(CC) $(CFLAGS) -c $< -o $@
+
+%.o:	%.S
+	@echo "  AS      $<"
+	$(Q)$(CC) $(CFLAGS) -c $< -o $@
+
+ifndef PC_HOSTED
+%.bin:	%.elf
+	@echo "  OBJCOPY $@"
+	$(Q)$(OBJCOPY) $(OBJCOPY_FLAGS) -O binary $^ $@
+
+%.hex:	%.elf
+	@echo "  OBJCOPY $@"
+	$(Q)$(OBJCOPY) -O ihex $^ $@
+endif
+
+.PHONY:	clean host_clean all_platforms clang-format FORCE
 
 clean:	host_clean
-	$(RM) *.o *~ blackmagic $(HOSTFILES)
+	$(Q)echo "  CLEAN"
+	-$(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 --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);\
+		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/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
+	@# 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/adiv5.c

@@ -1,288 +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 the transport generic functions of the 
- * ARM Debug Interface v5 Architecure Specification, ARM doc IHI0031A.
- *
- * Issues:
- * Currently doesn't use ROM table for introspection, just assumes
- * the device is Cortex-M3.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "general.h"
-#include "jtag_scan.h"
-#include "gdb_packet.h"
-#include "adiv5.h"
-
-#include "target.h"
-
-#include "cortexm3.h"
-
-#ifndef DO_RESET_SEQ
-#define DO_RESET_SEQ 0
-#endif
-
-/* This belongs elsewhere... */
-target *target_list = NULL;
-target *cur_target = NULL;
-target *last_target = NULL;
-
-static const char adiv5_driver_str[] = "ARM ADIv5 MEM-AP";
-
-ADIv5_DP_t *adiv5_dp_list;
-ADIv5_AP_t adiv5_aps[5];
-int adiv5_ap_count;
-
-static int ap_check_error(struct target_s *target);
-
-static int ap_mem_read_words(struct target_s *target, uint32_t *dest, uint32_t src, int len);
-static int ap_mem_write_words(struct target_s *target, uint32_t dest, const uint32_t *src, int len);
-static int ap_mem_read_bytes(struct target_s *target, uint8_t *dest, uint32_t src, int len);
-static int ap_mem_write_bytes(struct target_s *target, uint32_t dest, const uint8_t *src, int len);
-
-void adiv5_free_all(void)
-{
-	ADIv5_DP_t *dp;
-
-	while(adiv5_dp_list) {
-		dp = adiv5_dp_list->next;
-		free(adiv5_dp_list);
-		adiv5_dp_list = dp;
-	}
-
-	adiv5_ap_count = 0;
-}
-
-
-void adiv5_dp_init(ADIv5_DP_t *dp)
-{
-	uint32_t ctrlstat;
-
-	dp->next = adiv5_dp_list;
-	adiv5_dp_list = dp;
-
-	ctrlstat = adiv5_dp_read(dp, ADIV5_DP_CTRLSTAT);
-
-	/* Write request for system and debug power up */
-	adiv5_dp_write(dp, ADIV5_DP_CTRLSTAT, 
-			ctrlstat |= ADIV5_DP_CTRLSTAT_CSYSPWRUPREQ | 
-				ADIV5_DP_CTRLSTAT_CDBGPWRUPREQ);
-	/* Wait for acknowledge */
-	while(((ctrlstat = adiv5_dp_read(dp, ADIV5_DP_CTRLSTAT)) & 
-		(ADIV5_DP_CTRLSTAT_CSYSPWRUPACK | ADIV5_DP_CTRLSTAT_CDBGPWRUPACK)) != 
-		(ADIV5_DP_CTRLSTAT_CSYSPWRUPACK | ADIV5_DP_CTRLSTAT_CDBGPWRUPACK));
-
-	if(DO_RESET_SEQ) {
-		/* This AP reset logic is described in ADIv5, but fails to work 
-		 * correctly on STM32.  CDBGRSTACK is never asserted, and we 
-		 * just wait forever. 
-		 */
-
-		/* Write request for debug reset */
-		adiv5_dp_write(dp, ADIV5_DP_CTRLSTAT, 
-				ctrlstat |= ADIV5_DP_CTRLSTAT_CDBGRSTREQ);
-		/* Wait for acknowledge */
-		while(!((ctrlstat = adiv5_dp_read(dp, ADIV5_DP_CTRLSTAT)) & 
-				ADIV5_DP_CTRLSTAT_CDBGRSTACK));
-
-		/* Write request for debug reset release */
-		adiv5_dp_write(dp, ADIV5_DP_CTRLSTAT, 
-				ctrlstat &= ~ADIV5_DP_CTRLSTAT_CDBGRSTREQ);
-		/* Wait for acknowledge */
-		while(adiv5_dp_read(dp, ADIV5_DP_CTRLSTAT) & 
-				ADIV5_DP_CTRLSTAT_CDBGRSTACK);
-	}
-
-	/* Probe for APs on this DP */
-	for(int i = 0; i < 256; i++) {
-		ADIv5_AP_t *ap = &adiv5_aps[adiv5_ap_count];
-		target *t;
-
-		/* Assume valid and try to read IDR */
-		ap->dp = dp;
-		ap->apsel = i;
-		ap->idr = adiv5_ap_read(ap, ADIV5_AP_IDR);
-
-		if(!ap->idr) /* IDR Invalid - Should we not continue here? */
-			break;
-
-		/* We have a valid AP, adding to list */
-		ap->cfg = adiv5_ap_read(ap, ADIV5_AP_CFG);
-		ap->base = adiv5_ap_read(ap, ADIV5_AP_BASE);
-		/* Should probe further here... */
-
-		/* Prepend to target list... */
-		t = (void*)calloc(1, sizeof(struct target_ap_s));
-		t->next = target_list;
-		target_list = t;
-		((struct target_ap_s *)t)->ap = ap;
-
-		t->driver = adiv5_driver_str;
-		t->check_error = ap_check_error;
-
-		t->mem_read_words = ap_mem_read_words;
-		t->mem_write_words = ap_mem_write_words;
-		t->mem_read_bytes = ap_mem_read_bytes;
-		t->mem_write_bytes = ap_mem_write_bytes;
-
-		/* The rest sould only be added after checking ROM table */
-		cm3_probe(t);
-
-		adiv5_ap_count++;
-	}
-}
-
-void adiv5_dp_write_ap(ADIv5_DP_t *dp, uint8_t addr, uint32_t value)
-{
-	adiv5_dp_low_access(dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, addr, value);
-}
-
-uint32_t adiv5_dp_read_ap(ADIv5_DP_t *dp, uint8_t addr)
-{
-	uint32_t ret;
-
-	adiv5_dp_low_access(dp, ADIV5_LOW_AP, ADIV5_LOW_READ, addr, 0);
-	ret = adiv5_dp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_READ, 
-				ADIV5_DP_RDBUFF, 0);
-
-	return ret;
-}
-
-
-static int 
-ap_check_error(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-	return adiv5_dp_error(t->ap->dp);
-}
-
-static int 
-ap_mem_read_words(struct target_s *target, uint32_t *dest, uint32_t src, int len)
-{
-	struct target_ap_s *t = (void *)target;
-
-	len >>= 2;
-
-	adiv5_ap_write(t->ap, ADIV5_AP_CSW, 0xA2000052);
-	adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, 
-					ADIV5_AP_TAR, src);
-	adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_READ, 
-					ADIV5_AP_DRW, 0);
-	while(--len) 
-		*dest++ = adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, 
-					ADIV5_LOW_READ, ADIV5_AP_DRW, 0);
-	
-	*dest++ = adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_DP, ADIV5_LOW_READ, 
-					ADIV5_DP_RDBUFF, 0);
-
-	return 0;
-}
-
-static int 
-ap_mem_read_bytes(struct target_s *target, uint8_t *dest, uint32_t src, int len)
-{
-	struct target_ap_s *t = (void *)target;
-	uint32_t tmp = src;
-
-	adiv5_ap_write(t->ap, ADIV5_AP_CSW, 0xA2000050);
-	adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, 
-					ADIV5_AP_TAR, src);
-	adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_READ, 
-					ADIV5_AP_DRW, 0);
-	while(--len) {
-		tmp = adiv5_dp_low_access(t->ap->dp, 1, 1, ADIV5_AP_DRW, 0);
-		*dest++ = (tmp >> ((src++ & 0x3) << 3) & 0xFF);
-	}
-	tmp = adiv5_dp_low_access(t->ap->dp, 0, 1, ADIV5_DP_RDBUFF, 0);
-	*dest++ = (tmp >> ((src++ & 0x3) << 3) & 0xFF);
-
-	return 0;
-}
-
-
-static int 
-ap_mem_write_words(struct target_s *target, uint32_t dest, const uint32_t *src, int len)
-{
-	struct target_ap_s *t = (void *)target;
-
-	len >>= 2;
-
-	adiv5_ap_write(t->ap, ADIV5_AP_CSW, 0xA2000052);
-	adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, 
-					ADIV5_AP_TAR, dest);
-	while(len--) 
-		adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, 
-					ADIV5_AP_DRW, *src++);
-	
-	return 0;
-}
-
-static int 
-ap_mem_write_bytes(struct target_s *target, uint32_t dest, const uint8_t *src, int len)
-{
-	struct target_ap_s *t = (void *)target;
-	uint32_t tmp;
-
-	adiv5_ap_write(t->ap, ADIV5_AP_CSW, 0xA2000050);
-	adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, 
-					ADIV5_AP_TAR, dest);
-	while(len--) {
-		tmp = (uint32_t)*src++ << ((dest++ & 3) << 3);
-		adiv5_dp_low_access(t->ap->dp, ADIV5_LOW_AP, ADIV5_LOW_WRITE, 
-					ADIV5_AP_DRW, tmp);
-	}
-	return 0;
-}
-
-
-
-uint32_t adiv5_ap_mem_read(ADIv5_AP_t *ap, uint32_t addr)
-{
-	adiv5_ap_write(ap, ADIV5_AP_CSW, 0xA2000052);
-	adiv5_ap_write(ap, ADIV5_AP_TAR, addr);
-	return adiv5_ap_read(ap, ADIV5_AP_DRW);
-}
-
-void adiv5_ap_mem_write(ADIv5_AP_t *ap, uint32_t addr, uint32_t value)
-{
-	adiv5_ap_write(ap, ADIV5_AP_CSW, 0xA2000052);
-	adiv5_ap_write(ap, ADIV5_AP_TAR, addr);
-	adiv5_ap_write(ap, ADIV5_AP_DRW, value);
-}
-
-void adiv5_ap_write(ADIv5_AP_t *ap, uint8_t addr, uint32_t value)
-{
-	adiv5_dp_write(ap->dp, ADIV5_DP_SELECT, 
-			((uint32_t)ap->apsel << 24)|(addr & 0xF0));
-	adiv5_dp_write_ap(ap->dp, addr, value);
-}
-
-uint32_t adiv5_ap_read(ADIv5_AP_t *ap, uint8_t addr)
-{
-	uint32_t ret;
-	adiv5_dp_write(ap->dp, ADIV5_DP_SELECT, 
-			((uint32_t)ap->apsel << 24)|(addr & 0xF0));
-	ret = adiv5_dp_read_ap(ap->dp, addr);
-	return ret;
-}
-

src/adiv5_jtagdp.c

@@ -1,107 +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 the JTAG-DP specific functions of the 
- * ARM Debug Interface v5 Architecure Specification, ARM doc IHI0031A.
- */
-
-#include "general.h"
-#include "platform.h"
-#include "adiv5.h"
-#include "jtag_scan.h"
-#include "jtagtap.h"
-
-#include <stdlib.h>
-
-#define JTAGDP_ACK_OK	0x02
-#define JTAGDP_ACK_WAIT	0x01
-
-/* 35-bit registers that control the ADIv5 DP */
-#define IR_ABORT	0x8
-#define IR_DPACC	0xA
-#define IR_APACC	0xB
-
-static void adiv5_jtagdp_write(ADIv5_DP_t *dp, uint8_t addr, uint32_t value);
-static uint32_t adiv5_jtagdp_read(ADIv5_DP_t *dp, uint8_t addr);
-
-static uint32_t adiv5_jtagdp_error(ADIv5_DP_t *dp);
-
-static uint32_t adiv5_jtagdp_low_access(ADIv5_DP_t *dp, uint8_t APnDP, uint8_t RnW, 
-					uint8_t addr, uint32_t value);
-
-
-void adiv5_jtag_dp_handler(jtag_dev_t *dev)
-{
-	ADIv5_DP_t *dp = (void*)calloc(1, sizeof(ADIv5_DP_t));
-
-	dp->dev = dev;
-	dp->idcode = dev->idcode;
-
-	dp->dp_write = adiv5_jtagdp_write;
-	dp->dp_read = adiv5_jtagdp_read;
-	dp->error = adiv5_jtagdp_error;
-	dp->low_access = adiv5_jtagdp_low_access;
-
-	adiv5_dp_init(dp);
-}
-
-static void adiv5_jtagdp_write(ADIv5_DP_t *dp, uint8_t addr, uint32_t value)
-{
-	adiv5_jtagdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_WRITE, addr, value);
-}
-
-static uint32_t adiv5_jtagdp_read(ADIv5_DP_t *dp, uint8_t addr)
-{
-	adiv5_jtagdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_READ, addr, 0);
-	return adiv5_jtagdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_READ, 
-					ADIV5_DP_RDBUFF, 0);
-}
-
-static uint32_t adiv5_jtagdp_error(ADIv5_DP_t *dp)
-{
-	adiv5_jtagdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_READ, 
-				ADIV5_DP_CTRLSTAT, 0);
-	return adiv5_jtagdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_WRITE, 
-				ADIV5_DP_CTRLSTAT, 0xF0000032) & 0x32;
-}
-
-static uint32_t adiv5_jtagdp_low_access(ADIv5_DP_t *dp, uint8_t APnDP, uint8_t RnW, 
-					uint8_t addr, uint32_t value)
-{
-	uint64_t request, response;
-	uint8_t ack;
-
-	request = ((uint64_t)value << 3) | ((addr >> 1) & 0x06) | (RnW?1:0);
-
-	jtag_dev_write_ir(dp->dev, APnDP?IR_APACC:IR_DPACC);
-
-	do {
-		jtag_dev_shift_dr(dp->dev, (uint8_t*)&response, (uint8_t*)&request, 35);
-		ack = response & 0x07;
-	} while(ack == JTAGDP_ACK_WAIT);
-
-	if((ack != JTAGDP_ACK_OK)) {
-		/* Fatal error if invalid ACK response */
-		PLATFORM_FATAL_ERROR(1);
-	}
-
-	return (uint32_t)(response >> 3);
-}
-

src/adiv5_swdp.c

@@ -1,160 +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 the SW-DP specific functions of the 
- * ARM Debug Interface v5 Architecure Specification, ARM doc IHI0031A.
- */
-
-#include "general.h"
-#include "platform.h"
-#include "adiv5.h"
-
-#include "swdptap.h"
-
-#include "command.h"
-
-#include <stdlib.h>
-
-#define SWDP_ACK_OK    0x01
-#define SWDP_ACK_WAIT  0x02
-#define SWDP_ACK_FAULT 0x04
-
-static void adiv5_swdp_write(ADIv5_DP_t *dp, uint8_t addr, uint32_t value);
-static uint32_t adiv5_swdp_read(ADIv5_DP_t *dp, uint8_t addr);
-
-static uint32_t adiv5_swdp_error(ADIv5_DP_t *dp);
-
-static uint32_t adiv5_swdp_low_access(ADIv5_DP_t *dp, uint8_t APnDP, uint8_t RnW, 
-				      uint8_t addr, uint32_t value);
-
-
-int adiv5_swdp_scan(void)
-{
-	ADIv5_DP_t *dp;
-	uint8_t ack;
-
-	TARGET_LIST_FREE();
-#warning "These should be elsewhere!"
-	adiv5_free_all();
-
-	dp = (void*)calloc(1, sizeof(ADIv5_DP_t));
-
-	swdptap_init();
-	/* Read the SW-DP IDCODE register to syncronise */
-	/* This could be done with adiv_swdp_low_access(), but this doesn't
-	 * allow the ack to be checked here. */
-	swdptap_seq_out(0xA5, 8);
-	ack = swdptap_seq_in(3);
-	if((ack != SWDP_ACK_OK) || swdptap_seq_in_parity(&dp->idcode, 32)) {
-		DEBUG("\n");
-		morse("NO TARGETS.", 1);
-		free(dp);
-		return -1;
-	}
-
-	dp->dp_write = adiv5_swdp_write;
-	dp->dp_read = adiv5_swdp_read;
-	dp->error = adiv5_swdp_error;
-	dp->low_access = adiv5_swdp_low_access;
-
-	adiv5_dp_init(dp);
-
-	if(!target_list) morse("NO TARGETS.", 1);
-	else morse(NULL, 0);
-
-	return target_list?1:0;
-}
-
-static void adiv5_swdp_write(ADIv5_DP_t *dp, uint8_t addr, uint32_t value)
-{
-	adiv5_swdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_WRITE, addr, value);
-}
-
-static uint32_t adiv5_swdp_read(ADIv5_DP_t *dp, uint8_t addr)
-{
-	return adiv5_swdp_low_access(dp, ADIV5_LOW_DP, ADIV5_LOW_READ, addr, 0);
-}
-
-static uint32_t adiv5_swdp_error(ADIv5_DP_t *dp)
-{
-	uint32_t err, clr = 0;
-
-	err = adiv5_swdp_read(dp, ADIV5_DP_CTRLSTAT) & 
-		(ADIV5_DP_CTRLSTAT_STICKYORUN | ADIV5_DP_CTRLSTAT_STICKYCMP |
-		ADIV5_DP_CTRLSTAT_STICKYERR);
-
-	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;
-
-	adiv5_swdp_write(dp, ADIV5_DP_ABORT, clr);
-	dp->fault = 0;
-
-	return err;
-}
-
-static uint32_t adiv5_swdp_low_access(ADIv5_DP_t *dp, uint8_t APnDP, uint8_t RnW, 
-				      uint8_t addr, uint32_t value)
-{
-	uint8_t request = 0x81;
-	uint32_t response;
-	uint8_t ack;
-
-	if(APnDP && dp->fault) return 0;
-
-	if(APnDP) request ^= 0x22;
-	if(RnW)   request ^= 0x24;
-
-	addr &= 0xC;
-	request |= (addr << 1) & 0x18;
-	if((addr == 4) || (addr == 8))
-		request ^= 0x20;
-
-	do {
-		swdptap_seq_out(request, 8);
-		ack = swdptap_seq_in(3);
-	} while(ack == SWDP_ACK_WAIT);
-
-	if(ack == SWDP_ACK_FAULT) {
-		dp->fault = 1;
-		return 0;
-	}
-
-	if(ack != SWDP_ACK_OK) {
-		/* Fatal error if invalid ACK response */
-		PLATFORM_FATAL_ERROR(1);
-	}
-
-	if(RnW) {
-		if(swdptap_seq_in_parity(&response, 32))  /* Give up on parity error */
-			PLATFORM_FATAL_ERROR(1);
-	} else {
-		swdptap_seq_out_parity(value, 32);
-	}
-
-	/* REMOVE THIS */
-	swdptap_seq_out(0, 8);
-
-	return response;
-}
-

src/arm7tdmi.c

@@ -1,295 +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 the ARM7TDMI target support using the JTAG
- * interface as described in ARM7TDMI Technical Reference Manual,
- * ARM Document DDI 0210C
- */
-
-#include "general.h"
-#include "platform.h"
-#include "target.h"
-#include "jtag_scan.h"
-#include "jtagtap.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-/* TODO:
- * Skeleton target.
- * EmbeddedICE registers, halt/resume target.
- * Check target mode on halt, switch to ARM if needed.
- * Read registers on halt, restore on resume. Give GDB cached copy.
- * System speed access, read/write memory.
- * Misaligned/byte memory access.
- * Breakpoint support.
- * Watchpoint support.
- * Funnies: abort on breakpointed instruction, etc.
- * Flash programming for STR73x and LPC2xxx.
- */
-static const char arm7_driver_str[] = "ARM7TDMI";
-
-/* ARM7 JTAG IR values */
-#define ARM7_IR_EXTEST		0x0
-#define ARM7_IR_SCAN_N		0x2
-#define ARM7_IR_SAMPLE_PRELOAD	0x3
-#define ARM7_IR_RESTART		0x4
-#define ARM7_IR_CLAMP		0x5
-#define ARM7_IR_HIGHZ		0x7
-#define ARM7_IR_CLAMPZ		0x9
-#define ARM7_IR_INTEST		0xC
-#define ARM7_IR_IDCODE		0xE
-#define ARM7_IR_BYPASS		0xF
-
-/* ARM7 SCAN_N scan chain values */
-#define ARM7_SCANN_BOUNDARY	0
-#define ARM7_SCANN_DBUS		1
-#define ARM7_SCANN_EICE		2
-
-/* EmbeddedICE-RT Register addresses */
-#define ARM7_EICE_DEBUG_CTRL		0x00
-#define ARM7_EICE_DEBUG_STAT		0x01
-#define ARM7_EICE_ABORT_STAT		0x02
-#define ARM7_EICE_COMMS_CTRL		0x04
-#define ARM7_EICE_COMMS_DATA		0x05
-#define ARM7_EICE_WATCH_ADDR(x)		(0x08 + (8 * (x))
-#define ARM7_EICE_WATCH_ADDR_MASK(x)	(0x09 + (8 * (x))
-#define ARM7_EICE_WATCH_DATA(x)		(0x0A + (8 * (x))
-#define ARM7_EICE_WATCH_DATA_MASK(x)	(0x0B + (8 * (x))
-#define ARM7_EICE_WATCH_CTRL(x)		(0x0C + (8 * (x))
-#define ARM7_EICE_WATCH_CTRL_MASK(x)	(0x0D + (8 * (x))
-
-/* Read/write bit in EmbeddedICE-RT scan chain */
-#define ARM7_EICE_READ 		(0uLL << 37)
-#define ARM7_EICE_WRITE		(1uLL << 37)
-
-/* Debug Control Register bits */
-#define ARM7_EICE_DEBUG_CTRL_EICE_DISABLE	(1 << 5)
-#define ARM7_EICE_DEBUG_CTRL_MONITOR		(1 << 4)
-/* Bit 3 - Reserved */
-#define ARM7_EICE_DEBUG_CTRL_INTDIS		(1 << 2)
-#define ARM7_EICE_DEBUG_CTRL_DBGRQ		(1 << 1)
-#define ARM7_EICE_DEBUG_CTRL_DBGACK		(1 << 0)
-
-/* Debug Status Register bits */
-#define ARM7_EICE_DEBUG_STAT_TBIT		(1 << 4)
-#define ARM7_EICE_DEBUG_STAT_NMREQ		(1 << 3)
-#define ARM7_EICE_DEBUG_STAT_INTDIS		(1 << 2)
-#define ARM7_EICE_DEBUG_STAT_DBGRQ		(1 << 1)
-#define ARM7_EICE_DEBUG_STAT_DBGACK		(1 << 0)
-
-#define ARM7_OP_NOP		0xE1A00000
-
-struct target_arm7_s {
-	target t;
-	jtag_dev_t *jtag;
-	uint32_t reg_cache[16];
-};
-
-/* FIXME: Remove: */
-static void do_nothing(void)
-{
-}
-
-static void arm7_attach(struct target_s *target);
-static int arm7_regs_read(struct target_s *target, void *data);
-static int arm7_regs_write(struct target_s *target, const void *data);
-static void arm7_halt_request(struct target_s *target);
-static int arm7_halt_wait(struct target_s *target);
-static void arm7_halt_resume(struct target_s *target, uint8_t step);
-
-void arm7tdmi_jtag_handler(jtag_dev_t *dev)
-{
-	struct target_arm7_s *tj = calloc(1, sizeof(*tj));
-	target *t = (target *)tj;
-
-	t->driver = arm7_driver_str;
-	tj->jtag = dev;
-
-	/* Setup mandatory virtual methods */
-	t->attach = arm7_attach;
-	t->detach = (void *)do_nothing;
-	t->check_error = (void *)do_nothing;
-	t->mem_read_words = (void *)do_nothing;
-	t->mem_write_words = (void *)do_nothing;
-	t->mem_read_bytes = (void *)do_nothing;
-	t->mem_write_bytes = (void *)do_nothing;
-	t->regs_size = 16 * 4;
-	t->regs_read = (void *)arm7_regs_read;
-	t->regs_write = (void *)arm7_regs_write;
-	t->pc_write = (void *)do_nothing;
-	t->reset = (void *)do_nothing;
-	t->halt_request = arm7_halt_request;
-	t->halt_wait = arm7_halt_wait;
-	t->halt_resume = arm7_halt_resume;
-	
-	/* TODO: Breakpoint and watchpoint functions. */
-	/* TODO: Fault unwinder. */
-	/* TODO: Memory map / Flash programming. */
-
-	t->next = target_list;
-	target_list = t;
-}
-
-static void arm7_select_scanchain(struct target_arm7_s *target, uint8_t chain)
-{
-	jtag_dev_write_ir(target->jtag, ARM7_IR_SCAN_N);
-	jtag_dev_shift_dr(target->jtag, NULL, &chain, 4);
-	jtag_dev_write_ir(target->jtag, ARM7_IR_INTEST);
-}
-
-static void arm7_eice_write(struct target_arm7_s *target, 
-				uint8_t addr, uint32_t value)
-{
-	uint64_t val = ((uint64_t)addr << 32) | value | ARM7_EICE_WRITE;
-
-	arm7_select_scanchain(target, ARM7_SCANN_EICE);
-	jtag_dev_shift_dr(target->jtag, NULL, (uint8_t *)&val, 38);
-	DEBUG("eice_write(%d, 0x%08X)\n", addr, value);
-}
-
-static uint32_t arm7_eice_read(struct target_arm7_s *target, uint8_t addr)
-{
-	uint64_t val = ((uint64_t)addr << 32) | ARM7_EICE_READ;
-
-	arm7_select_scanchain(target, ARM7_SCANN_EICE);
-	jtag_dev_shift_dr(target->jtag, NULL, (uint8_t *)&val, 38);
-	jtag_dev_shift_dr(target->jtag, (uint8_t *)&val, (uint8_t *)&val, 38);
-	DEBUG("eice_read(%d, 0x%08X)\n", addr, (uint32_t)val);
-
-	return (uint32_t)val;
-}
-
-/* Execute a single instruction at debug speed.
- * Performs datalen data bus accesses after the op to capture data.
- */
-static void arm7_op_debug(struct target_arm7_s *t, uint32_t op, uint32_t *data,
-			int datalen)
-{
-	uint64_t tmp;
-	/* FIXME: This routine is broken.
-	 * This process isn't very well documented.  Maybe NOPs need to
-	 * be shifted into pipeline before data is read out.
-	 */
-	DEBUG("op_debug(0x%08X)\n", op);
-	arm7_select_scanchain(t, ARM7_SCANN_DBUS);
-	tmp = op;
-	jtag_dev_shift_dr(t->jtag, NULL, (const uint8_t*)&tmp, 33);
-	while(datalen--) {
-		tmp = *data;
-		jtag_dev_shift_dr(t->jtag, (uint8_t*)&tmp, (uint8_t*)&tmp, 33);
-		*data = (uint32_t)tmp;
-		DEBUG("\t0x%08X\n", *data);
-		data++;
-	}
-}
-
-/* Execute a single instruction at system speed.  */
-static void arm7_op_system(struct target_arm7_s *t, uint32_t op)
-{
-	uint64_t tmp;
-	arm7_select_scanchain(t, ARM7_SCANN_DBUS);
-	tmp = op | (1uLL << 32);
-	jtag_dev_shift_dr(t->jtag, NULL, (const uint8_t*)&tmp, 33);
-}
-
-static void arm7_halt_request(struct target_s *target)
-{
-	struct target_arm7_s *t = (struct target_arm7_s *)target;
-
-	arm7_eice_write(t, ARM7_EICE_DEBUG_CTRL, ARM7_EICE_DEBUG_CTRL_DBGRQ);
-}
-
-static int arm7_halt_wait(struct target_s *target)
-{
-	struct target_arm7_s *t = (struct target_arm7_s *)target;
-	int stat = arm7_eice_read(t, ARM7_EICE_DEBUG_STAT);
-
-	if(!(stat & ARM7_EICE_DEBUG_STAT_DBGACK))
-		return 0;
-
-	/* We are halted, so switch to ARM mode if needed. */
-	if(stat & ARM7_EICE_DEBUG_STAT_TBIT) {
-		/* This sequence switches to ARM mode:
-		 * 6000  STR R0, [R0]	; Save R0 before use
-		 * 4678  MOV R0, PC	; Copy PC into R0
-		 * 6000  STR R0, [R0]	; Now save the PC in R0
-		 * 4778  BX PC		; Jump into ARM state
-		 * 46c0  MOV R8, R8	; NOP
-		 * 46c0  MOV R8, R8	; NOP
-		 */
-		/* FIXME: Switch to ARM mode. */
-	}
-
-	/* Fetch core register values */
-	/* E880FFFF  STM R0, {R0-R15} */
-	arm7_op_debug(t, 0xE880FFFF, t->reg_cache, 16);
-
-	return 1;
-}
-
-static void arm7_halt_resume(struct target_s *target, uint8_t step)
-{
-	struct target_arm7_s *t = (struct target_arm7_s *)target;
-
-	if(step) {
-		/* FIXME: Set breakpoint on any instruction to single step. */
-	}
-
-	/* Restore core registers. */
-	/* E890FFFF  LDM R0, {R0-R15} */
-	arm7_op_debug(t, 0xE890FFFF, t->reg_cache, 16);
-
-	/* Release DBGRQ */
-	arm7_eice_write(t, ARM7_EICE_DEBUG_CTRL, 0);
-	/* This sequence restores PC if no other instructions issued in 
-	 * debug mode...
-	 * 0 E1A00000; MOV R0, R0
-	 * 1 E1A00000; MOV R0, R0
-	 * 0 EAFFFFFA; B -6
-	 * FIXME: Add adjustment for other opcodes.
-	 */
-	arm7_op_debug(t, ARM7_OP_NOP, NULL, 0);
-	arm7_op_system(t, ARM7_OP_NOP);
-	arm7_op_debug(t, 0xEAFFFFF8, NULL, 0);
-
-	jtag_dev_write_ir(t->jtag, ARM7_IR_RESTART);
-}
-
-static void arm7_attach(struct target_s *target)
-{
-	target_halt_request(target);
-	while(!target_halt_wait(target));
-}
-
-static int arm7_regs_read(struct target_s *target, void *data)
-{
-	struct target_arm7_s *t = (struct target_arm7_s *)target;
-	memcpy(data, t->reg_cache, target->regs_size);
-	return 0;
-}
-
-static int arm7_regs_write(struct target_s *target, const void *data)
-{
-	struct target_arm7_s *t = (struct target_arm7_s *)target;
-	memcpy(t->reg_cache, data, target->regs_size);
-	return 0;
-}
-

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
@@ -20,140 +22,648 @@
 
 /* This file implements a basic command interpreter for GDB 'monitor'
  * commands.
- * 
- * TODO: Add a mechanism for target driver so register new commands.
  */
 
-#include <stdlib.h>
-#include <string.h>
-
 #include "general.h"
-
+#include "exception.h"
 #include "command.h"
 #include "gdb_packet.h"
-
-#include "jtag_scan.h"
 #include "target.h"
+#include "target_internal.h"
+#include "morse.h"
+#include "version.h"
+#include "serialno.h"
 
-#include "adiv5.h"
+#ifdef ENABLE_RTT
+#include "rtt.h"
+#endif
 
-void cmd_version(void);
+#ifdef PLATFORM_HAS_TRACESWO
-void cmd_help(void);
+#	include "traceswo.h"
+#endif
 
-void cmd_jtag_scan(void);
+static bool cmd_version(target *t, int argc, char **argv);
-void cmd_swdp_scan(void);
+#ifdef PLATFORM_HAS_PRINTSERIAL
-void cmd_targets(void);
+static bool cmd_serial(target *t, int argc, char **argv);
-void cmd_morse(void);
+#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(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(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(target *t, int argc, const char **argv);
+#endif
+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
+static bool cmd_convert_tdio(target *t, int argc, const char **argv);
+static bool cmd_set_srst(target *t, int argc, const char **argv);
+#endif
+#ifdef PLATFORM_HAS_BOOTLOADER
+static bool cmd_enter_bootldr(target *t, int argc, const char **argv);
+#endif
 
 const struct command_s cmd_list[] = {
 	{"version", (cmd_handler)cmd_version, "Display firmware version info"},
+#ifdef PLATFORM_HAS_PRINTSERIAL
+	{"serial", (cmd_handler)cmd_serial, "Display firmware serial number"},
+#endif
 	{"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 ENABLE_RTT
+	{"rtt", (cmd_handler)cmd_rtt, "enable|disable|status|channel 0..15|ident (str)|cblock|poll maxms minms maxerr" },
+#endif
+#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
+	{"convert_tdio", (cmd_handler)cmd_convert_tdio,"Switch TDI/O pins to UART TX/RX functions"},
+	{"set_srst", (cmd_handler)cmd_set_srst,"Set output state of SRST pin (enable|disable)"},
+#endif
+#ifdef PLATFORM_HAS_BOOTLOADER
+	{"enter_bootldr", (cmd_handler)cmd_enter_bootldr,"Force BMP into bootloader mode"},
+#endif
 	{NULL, NULL, NULL}
 };
 
+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(char *cmd)
+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++) 
+	for(char *s = cmd; *s; s++)
 		if((*s == ' ') || (*s == '\t')) argc++;
 
 	argv = alloca(sizeof(const char *) * argc);
 
 	/* Tokenize cmd to find argv */
-	for(argc = 0, argv[argc] = strtok(cmd, " \t"); 
+	argc = 0;
-		argv[argc]; argv[++argc] = strtok(NULL, " \t"));
+	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++) {
-		if(!strcmp(argv[0], c->cmd)) {
+		/* Accept a partial match as GDB does.
-			c->handler(argc, argv);
+		 * So 'mon ver' will match 'monitor version'
-			return 0;
+		 */
-		}
+		if ((argc == 0) || !strncmp(argv[0], c->cmd, strlen(argv[0])))
+			return !c->handler(t, argc, argv);
 	}
 
-	return -1;
+	if (!t)
+		return -1;
+
+	return target_command(t, argc, argv);
 }
 
-void cmd_version(void)
+#define BOARD_IDENT "Black Magic Probe" PLATFORM_IDENT FIRMWARE_VERSION
+
+bool cmd_version(target *t, int argc, char **argv)
 {
-	gdb_out("Black Magic Probe (Firmware 1.5" VERSION_SUFFIX ", build " BUILDDATE ")\n");
+	(void)t;
-	gdb_out("Copyright (C) 2011  Black Sphere Technologies Ltd.\n");
+	(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;
 }
 
-void cmd_help(void)
+bool cmd_help(target *t, int argc, char **argv)
 {
+	(void)argc;
+	(void)argv;
 	const struct command_s *c;
 
-	for(c = cmd_list; c->cmd; c++) 
+	if (!t || t->tc->destroy_callback) {
-		gdb_outf("%s -- %s\n", c->cmd, c->help);
+		gdb_out("General commands:\n");
-}
+		for(c = cmd_list; c->cmd; c++)
-
+			gdb_outf("\t%s -- %s\n", c->cmd, c->help);
-void cmd_jtag_scan(void)
-{
-	int devs = jtag_scan();
-
-	if(devs < 0) {
-		gdb_out("JTAG device scan failed!\n");
-		return;
-	} 
-	if(devs == 0) {
-		gdb_out("JTAG scan found no devices!\n");
-		return;
-	} 
-	gdb_outf("Device  IR Len  IDCODE      Description\n");
-	for(int i = 0; i < jtag_dev_count; i++)
-		gdb_outf("%d\t%d\t0x%08lX  %s\n", i, 
-			 jtag_devs[i].ir_len, jtag_devs[i].idcode, 
-			 jtag_devs[i].descr);
-	gdb_out("\n");
-	cmd_targets();
-}
-
-void cmd_swdp_scan(void)
-{
-	if(adiv5_swdp_scan() < 0) {
-		gdb_out("SW-DP scan failed!\n");
-		return;
-	} 
-
-	gdb_outf("SW-DP detected IDCODE: 0x%08X\n", adiv5_dp_list->idcode);
-
-	cmd_targets();
-}
-
-void cmd_targets(void)
-{
-	struct target_s *t;
-	int i;
-
-	if(!target_list) {
-		gdb_out("No usable targets found.\n");
-		return;
 	}
-	
+	if (!t)
+		return -1;
+
+	target_command_help(t);
+
+	return true;
+}
+
+static bool cmd_jtag_scan(target *t, int argc, char **argv)
+{
+	(void)t;
+	uint8_t irlens[argc];
+
+	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 */
+		for (int i = 1; i < argc; i++)
+			irlens[i-1] = atoi(argv[i]);
+		irlens[argc-1] = 0;
+	}
+
+	if(connect_assert_srst)
+		platform_srst_set_val(true); /* will be deasserted after attach */
+
+	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:
+		gdb_outf("Timeout during scan. Is target stuck in WFI?\n");
+		break;
+	case EXCEPTION_ERROR:
+		gdb_outf("Exception: %s\n", e.msg);
+		break;
+	}
+
+	if(devs <= 0) {
+		platform_srst_set_val(false);
+		gdb_out("JTAG device scan failed!\n");
+		return false;
+	}
+	cmd_targets(NULL, 0, NULL);
+	morse(NULL, false);
+	return true;
+}
+
+bool cmd_swdp_scan(target *t, int argc, char **argv)
+{
+	(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 */
+
+	int devs = -1;
+	volatile struct exception e;
+	TRY_CATCH (e, EXCEPTION_ALL) {
+#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");
+		break;
+	case EXCEPTION_ERROR:
+		gdb_outf("Exception: %s\n", e.msg);
+		break;
+	}
+
+	if(devs <= 0) {
+		platform_srst_set_val(false);
+		gdb_out("SW-DP scan failed!\n");
+		return false;
+	}
+
+	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;
+	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(target *t, int argc, char **argv)
+{
+	(void)t;
+	(void)argc;
+	(void)argv;
 	gdb_out("Available Targets:\n");
 	gdb_out("No. Att Driver\n");
-	for(t = target_list, i = 1; t; t = t->next, i++)
+	if (!target_foreach(display_target, NULL)) {
-		gdb_outf("%2d   %c  %s\n", i, t==cur_target?'*':' ', 
+		gdb_out("No usable targets found.\n");
-			 t->driver);
+		return false;
+	}
+
+	return true;
 }
 
-void 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;
+	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");
+	}
+	return true;
+}
+
+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);
+	return true;
+}
+
+#ifdef PLATFORM_HAS_POWER_SWITCH
+static bool cmd_target_power(target *t, int argc, const char **argv)
+{
+	(void)t;
+	if (argc == 1) {
+		gdb_outf("Target Power: %s\n",
+			 platform_target_get_power() ? "enabled" : "disabled");
+	} 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(target *t, int argc, const char **argv)
+{
+	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
+
+#if defined(PLATFORM_HAS_DEBUG) && (PC_HOSTED == 0)
+static bool cmd_debug_bmp(target *t, int argc, const char **argv)
+{
+	(void)t;
+	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");
+	}
+	return true;
+}
+#endif
+
+#ifdef PLATFORM_HAS_UART_WHEN_SWDP
+static bool cmd_convert_tdio(target *t, int argc, const char **argv)
+{
+        (void)t;
+
+	uint8_t val;
+	if (argc > 1) {
+		val = (!strcmp(argv[1], "enable")) ? true : false;
+		usbuart_convert_tdio(val);
+	} else {
+		gdb_outf("Convert_tdio: %s\n",(usbuart_convert_tdio_enabled()) ?
+				"enabled" : "disabled");
+	}
+
+	return true;
+}
+
+static bool cmd_set_srst(target *t, int argc, const char **argv)
+{
+	(void) t;
+
+	uint8_t val;
+	if (argc > 1) {
+		val = (!strcmp(argv[1], "enable")) ? true : false;
+		platform_srst_set_val(val);
+	} else {
+		gdb_outf("SRST: %s\n",(platform_srst_get_val()) ?
+				"enabled" : "disabled");
+	}
+
+	return true;
+}
+#endif
+
+#ifdef PLATFORM_HAS_BOOTLOADER
+static bool cmd_enter_bootldr(target *t, int argc, const char **argv)
+{
+	(void) t;
+	(void) argc;
+	(void) argv;
+
+	scb_reset_system();
+
+	return true;
+}
+#endif
+
+#ifdef PLATFORM_HAS_PRINTSERIAL
+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/cortexm3.c

@@ -1,643 +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 debugging functionality specific to ARM
- * the Cortex-M3 core.  This should be generic to ARMv7-M as it is 
- * implemented according to the "ARMv7-M Architectue Reference Manual",
- * ARM doc DDI0403C.
- *
- * Issues:
- * There are way too many magic numbers used here.
- */
-#include <stdio.h>
-
-#include "general.h"
-#include "jtagtap.h"
-#include "jtag_scan.h"
-#include "adiv5.h"
-#include "target.h"
-
-#include "cortexm3.h"
-#include "lmi.h"
-#include "stm32_tgt.h"
-
-static char cm3_driver_str[] = "ARM Cortex-M3";
-
-/* Private peripheral bus base address */
-#define CM3_PPB_BASE	0xE0000000
-
-#define CM3_SCS_BASE	(CM3_PPB_BASE + 0xE000)
-
-#define CM3_AIRCR	(CM3_SCS_BASE + 0xD0C)
-#define CM3_CFSR	(CM3_SCS_BASE + 0xD28)
-#define CM3_HFSR	(CM3_SCS_BASE + 0xD2C)
-#define CM3_DFSR	(CM3_SCS_BASE + 0xD30)
-#define CM3_DHCSR	(CM3_SCS_BASE + 0xDF0)
-#define CM3_DCRSR	(CM3_SCS_BASE + 0xDF4)
-#define CM3_DCRDR	(CM3_SCS_BASE + 0xDF8)
-#define CM3_DEMCR	(CM3_SCS_BASE + 0xDFC)
-
-#define CM3_FPB_BASE	(CM3_PPB_BASE + 0x2000)
-
-/* ARM Literature uses FP_*, we use CM3_FPB_* consistently */
-#define CM3_FPB_CTRL	(CM3_FPB_BASE + 0x000)
-#define CM3_FPB_REMAP	(CM3_FPB_BASE + 0x004)
-#define CM3_FPB_COMP(i)	(CM3_FPB_BASE + 0x008 + (4*(i)))
-
-#define CM3_DWT_BASE	(CM3_PPB_BASE + 0x1000)
-
-#define CM3_DWT_CTRL	(CM3_DWT_BASE + 0x000)
-#define CM3_DWT_COMP(i)	(CM3_DWT_BASE + 0x020 + (0x10*(i)))
-#define CM3_DWT_MASK(i)	(CM3_DWT_BASE + 0x024 + (0x10*(i)))
-#define CM3_DWT_FUNC(i)	(CM3_DWT_BASE + 0x028 + (0x10*(i)))
-
-/* Application Interrupt and Reset Control Register (AIRCR) */
-#define CM3_AIRCR_VECTKEY	(0x05FA << 16)
-/* Bits 31:16 - Read as VECTKETSTAT, 0xFA05 */
-#define CM3_AIRCR_ENDIANESS	(1 << 15)
-/* Bits 15:11 - Unused, reserved */
-#define CM3_AIRCR_PRIGROUP	(7 << 8)
-/* Bits 7:3 - Unused, reserved */
-#define CM3_AIRCR_SYSRESETREQ	(1 << 2)
-#define CM3_AIRCR_VECTCLRACTIVE	(1 << 1)
-#define CM3_AIRCR_VECTRESET	(1 << 0)
-
-/* HardFault Status Register (HFSR) */
-#define CM3_HFSR_DEBUGEVT	(1 << 31)
-#define CM3_HFSR_FORCED		(1 << 30)
-/* Bits 29:2 - Not specified */
-#define CM3_HFSR_VECTTBL	(1 << 1)
-/* Bits 0 - Reserved */
-
-/* Debug Fault Status Register (DFSR) */
-/* Bits 31:5 - Reserved */
-#define CM3_DFSR_RESETALL	0x1F
-#define CM3_DFSR_EXTERNAL	(1 << 4)
-#define CM3_DFSR_VCATCH		(1 << 3)
-#define CM3_DFSR_DWTTRAP	(1 << 2)
-#define CM3_DFSR_BKPT		(1 << 1)
-#define CM3_DFSR_HALTED		(1 << 0)
-
-/* Debug Halting Control and Status Register (DHCSR) */
-/* This key must be written to bits 31:16 for write to take effect */
-#define CM3_DHCSR_DBGKEY	0xA05F0000
-/* Bits 31:26 - Reserved */
-#define CM3_DHCSR_S_RESET_ST	(1 << 25)
-#define CM3_DHCSR_S_RETIRE_ST	(1 << 24)
-/* Bits 23:20 - Reserved */
-#define CM3_DHCSR_S_LOCKUP	(1 << 19)
-#define CM3_DHCSR_S_SLEEP	(1 << 18)
-#define CM3_DHCSR_S_HALT	(1 << 17)
-#define CM3_DHCSR_S_REGRDY	(1 << 16)
-/* Bits 15:6 - Reserved */
-#define CM3_DHCSR_C_SNAPSTALL	(1 << 5)
-/* Bit 4 - Reserved */
-#define CM3_DHCSR_C_MASKINTS	(1 << 3)
-#define CM3_DHCSR_C_STEP	(1 << 2)
-#define CM3_DHCSR_C_HALT	(1 << 1)
-#define CM3_DHCSR_C_DEBUGEN	(1 << 0)
-
-/* Debug Core Register Selector Register (DCRSR) */
-#define CM3_DCRSR_REGSEL_MASK	0x0000001F
-#define CM3_DCRSR_REGSEL_XPSR	0x00000010
-#define CM3_DCRSR_REGSEL_MSP	0x00000011
-#define CM3_DCRSR_REGSEL_PSP	0x00000012
-
-/* Debug Exception and Monitor Control Register (DEMCR) */
-/* Bits 31:25 - Reserved */
-#define CM3_DEMCR_TRCENA	(1 << 24)
-/* Bits 23:20 - Reserved */
-#define CM3_DEMCR_MON_REQ	(1 << 19)
-#define CM3_DEMCR_MON_STEP	(1 << 18)
-#define CM3_DEMCR_VC_MON_PEND	(1 << 17)
-#define CM3_DEMCR_VC_MON_EN	(1 << 16)
-/* Bits 15:11 - Reserved */
-#define CM3_DEMCR_VC_HARDERR	(1 << 10)
-#define CM3_DEMCR_VC_INTERR	(1 << 9)
-#define CM3_DEMCR_VC_BUSERR	(1 << 8)
-#define CM3_DEMCR_VC_STATERR	(1 << 7)
-#define CM3_DEMCR_VC_CHKERR	(1 << 6)
-#define CM3_DEMCR_VC_NOCPERR	(1 << 5)
-#define CM3_DEMCR_VC_MMERR	(1 << 4)
-/* Bits 3:1 - Reserved */
-#define CM3_DEMCR_VC_CORERESET	(1 << 0)
-
-/* Flash Patch and Breakpoint Control Register (FP_CTRL) */
-/* Bits 32:15 - Reserved */
-/* Bits 14:12 - NUM_CODE2 */
-/* Bits 11:8 - NUM_LIT */
-/* Bits 7:4 - NUM_CODE1 */
-/* Bits 3:2 - Unspecified */
-#define CM3_FPB_CTRL_KEY	(1 << 1)
-#define CM3_FPB_CTRL_ENABLE	(1 << 0)
-
-/* Data Watchpoint and Trace Mask Register (DWT_MASKx) */
-#define CM3_DWT_MASK_BYTE	(0 << 0)
-#define CM3_DWT_MASK_HALFWORD	(1 << 0)
-#define CM3_DWT_MASK_WORD	(3 << 0)
-
-/* Data Watchpoint and Trace Function Register (DWT_FUNCTIONx) */
-#define CM3_DWT_FUNC_MATCHED		(1 << 24)
-#define CM3_DWT_FUNC_DATAVSIZE_WORD	(2 << 10)
-#define CM3_DWT_FUNC_FUNC_READ		(5 << 0)
-#define CM3_DWT_FUNC_FUNC_WRITE		(6 << 0)
-#define CM3_DWT_FUNC_FUNC_ACCESS	(7 << 0)
-
-static void cm3_attach(struct target_s *target);
-static void cm3_detach(struct target_s *target);
-
-static int cm3_regs_read(struct target_s *target, void *data);
-static int cm3_regs_write(struct target_s *target, const void *data);
-static int cm3_pc_write(struct target_s *target, const uint32_t val);
-
-static void cm3_reset(struct target_s *target);
-static void cm3_halt_resume(struct target_s *target, uint8_t step);
-static int cm3_halt_wait(struct target_s *target);
-static void cm3_halt_request(struct target_s *target);
-static int cm3_fault_unwind(struct target_s *target);
-
-static int cm3_set_hw_bp(struct target_s *target, uint32_t addr);
-static int cm3_clear_hw_bp(struct target_s *target, uint32_t addr);
-
-static int cm3_set_hw_wp(struct target_s *target, uint8_t type, uint32_t addr, uint8_t len);
-static int cm3_clear_hw_wp(struct target_s *target, uint8_t type, uint32_t addr, uint8_t len);
-
-static int cm3_check_hw_wp(struct target_s *target, uint32_t *addr);
-
-/* Watchpoint unit status */
-static struct wp_unit_s {
-	uint32_t addr;
-	uint8_t type;
-	uint8_t size;
-} hw_watchpoint[4];
-
-/* Breakpoint unit status */
-static uint32_t hw_breakpoint[6];
-
-/* Register number tables */
-static uint32_t regnum_v7m[] = {
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,	/* standard r0-r15 */
-	0x10,	/* xpsr */
-	0x11,	/* msp */
-	0x12,	/* psp */
-	0x14	/* special */
-};
-#if 0
-/* XXX: need some way for a specific CPU to indicate it has FP registers */
-static uint32_t regnum_v7mf[] = {
-	0x21,	/* fpscr */
-	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,	/* s0-s7 */
-	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,	/* s8-s15 */
-	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,	/* s16-s23 */
-	0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,	/* s24-s31 */
-};
-#endif
-
-static const char tdesc_armv7m[] =
-	"<?xml version=\"1.0\"?>"
-	"<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
-	"<target>"
-	"  <architecture>arm</architecture>"
-	"  <feature name=\"org.gnu.gdb.arm.m-profile\">"
-	"    <reg name=\"r0\" bitsize=\"32\"/>"
-	"    <reg name=\"r1\" bitsize=\"32\"/>"
-	"    <reg name=\"r2\" bitsize=\"32\"/>"
-	"    <reg name=\"r3\" bitsize=\"32\"/>"
-	"    <reg name=\"r4\" bitsize=\"32\"/>"
-	"    <reg name=\"r5\" bitsize=\"32\"/>"
-	"    <reg name=\"r6\" bitsize=\"32\"/>"
-	"    <reg name=\"r7\" bitsize=\"32\"/>"
-	"    <reg name=\"r8\" bitsize=\"32\"/>"
-	"    <reg name=\"r9\" bitsize=\"32\"/>"
-	"    <reg name=\"r10\" bitsize=\"32\"/>"
-	"    <reg name=\"r11\" bitsize=\"32\"/>"
-	"    <reg name=\"r12\" bitsize=\"32\"/>"
-	"    <reg name=\"sp\" bitsize=\"32\" type=\"data_ptr\"/>"
-	"    <reg name=\"lr\" bitsize=\"32\" type=\"code_ptr\"/>"
-	"    <reg name=\"pc\" bitsize=\"32\" type=\"code_ptr\"/>"
-	"    <reg name=\"xpsr\" bitsize=\"32\"/>"
-	"    <reg name=\"msp\" bitsize=\"32\" save-restore=\"no\" type=\"data_ptr\"/>"
-	"    <reg name=\"psp\" bitsize=\"32\" save-restore=\"no\" type=\"data_ptr\"/>"
-	"    <reg name=\"special\" bitsize=\"32\" save-restore=\"no\"/>"
-	"  </feature>"
-	"</target>";
-
-int
-cm3_probe(struct target_s *target)
-{
-	target->driver = cm3_driver_str;
-
-	target->attach = cm3_attach;
-	target->detach = cm3_detach;
-
-	/* Should probe here to make sure it's Cortex-M3 */
-	target->tdesc = tdesc_armv7m;
-	target->regs_read = cm3_regs_read;
-	target->regs_write = cm3_regs_write;
-	target->pc_write = cm3_pc_write;
-
-	target->reset = cm3_reset;
-	target->halt_request = cm3_halt_request;
-	target->halt_wait = cm3_halt_wait;
-	target->halt_resume = cm3_halt_resume;
-	target->fault_unwind = cm3_fault_unwind;
-	target->regs_size = sizeof(regnum_v7m);	/* XXX: detect FP extension */
-
-	if(stm32_probe(target) == 0) return 0;
-	if(stm32f4_probe(target) == 0) return 0;
-	/* if not STM32 try LMI which I don't know how to detect reliably */
-	lmi_probe(target);
-
-	return 0;
-}
-
-static void
-cm3_attach(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-	int i;
-
-	target_halt_request(target);
-	while(!target_halt_wait(target));
-
-	/* Request halt on reset */
-	adiv5_ap_mem_write(t->ap, CM3_DEMCR, 
-			CM3_DEMCR_TRCENA | CM3_DEMCR_VC_HARDERR | 
-			CM3_DEMCR_VC_CORERESET); 
-
-	/* Reset DFSR flags */
-	adiv5_ap_mem_write(t->ap, CM3_DFSR, CM3_DFSR_RESETALL);
-
-	/* Clear any stale breakpoints */
-	for(i = 0; i < 6; i++) {
-		adiv5_ap_mem_write(t->ap, CM3_FPB_COMP(i), 0);
-		hw_breakpoint[i] = 0;
-	}
-
-	/* Clear any stale watchpoints */
-	for(i = 0; i < 4; i++) {
-		adiv5_ap_mem_write(t->ap, CM3_DWT_FUNC(i), 0);
-		hw_watchpoint[i].type = 0;
-	}
-
-	/* Flash Patch Control Register: set ENABLE */
-	adiv5_ap_mem_write(t->ap, CM3_FPB_CTRL, 
-			CM3_FPB_CTRL_KEY | CM3_FPB_CTRL_ENABLE);
-	target->set_hw_bp = cm3_set_hw_bp;
-	target->clear_hw_bp = cm3_clear_hw_bp;
-
-	/* Data Watchpoint and Trace */
-	target->set_hw_wp = cm3_set_hw_wp;
-	target->clear_hw_wp = cm3_clear_hw_wp;
-	target->check_hw_wp = cm3_check_hw_wp;
-}
-
-static void
-cm3_detach(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-	int i;
-
-	/* Clear any stale breakpoints */
-	for(i = 0; i < 6; i++)
-		adiv5_ap_mem_write(t->ap, CM3_FPB_COMP(i), 0);
-
-	/* Clear any stale watchpoints */
-	for(i = 0; i < 4; i++) 
-		adiv5_ap_mem_write(t->ap, CM3_DWT_FUNC(i), 0);
-
-	/* Disable debug */
-	adiv5_ap_mem_write(t->ap, CM3_DHCSR, CM3_DHCSR_DBGKEY);
-}
-
-static int
-cm3_regs_read(struct target_s *target, void *data)
-{
-	struct target_ap_s *t = (void *)target;
-	uint32_t *regs = data;
-	unsigned i;
-
-	/* FIXME: Describe what's really going on here */
-	adiv5_ap_write(t->ap, 0x00, 0xA2000052);
-
-	/* Map the banked data registers (0x10-0x1c) to the
-	 * debug registers DHCSR, DCRSR, DCRDR and DEMCR respectively */
-	adiv5_dp_low_access(t->ap->dp, 1, 0, 0x04, CM3_DHCSR);
-
-	/* Walk the regnum_v7m array, reading the registers it 
-	 * calls out. */
-	adiv5_ap_write(t->ap, 0x14, regnum_v7m[0]); /* Required to switch banks */
-	*regs++ = adiv5_dp_read_ap(t->ap->dp, 0x18);
-	for(i = 1; i < sizeof(regnum_v7m) / 4; i++) {
-		adiv5_dp_low_access(t->ap->dp, 1, 0, 0x14, regnum_v7m[i]);
-		*regs++ = adiv5_dp_read_ap(t->ap->dp, 0x18);
-	}
-
-	return 0;
-}
-
-static int
-cm3_regs_write(struct target_s *target, const void *data)
-{
-	struct target_ap_s *t = (void *)target;
-	const uint32_t *regs = data;
-	int i;
-
-	/* FIXME: Describe what's really going on here */
-	adiv5_ap_write(t->ap, 0x00, 0xA2000052);
-
-	/* Map the banked data registers (0x10-0x1c) to the
-	 * debug registers DHCSR, DCRSR, DCRDR and DEMCR respectively */
-	adiv5_dp_low_access(t->ap->dp, 1, 0, 0x04, CM3_DHCSR);
-
-	/* Walk the regnum_v7m array, writing the registers it 
-	 * calls out. */
-	adiv5_ap_write(t->ap, 0x18, *regs++); /* Required to switch banks */
-	adiv5_dp_low_access(t->ap->dp, 1, 0, 0x14, 0x10000 | regnum_v7m[0]);
-	for(i = 1; i < sizeof(regnum_v7m) / 4; i++) {
-		adiv5_dp_low_access(t->ap->dp, 1, 0, 0x18, *regs++);
-		adiv5_dp_low_access(t->ap->dp, 1, 0, 0x14, 0x10000 | regnum_v7m[i]);
-	}
-
-	return 0;
-}
-
-static int
-cm3_pc_write(struct target_s *target, const uint32_t val)
-{
-	struct target_ap_s *t = (void *)target;
-
-	adiv5_ap_write(t->ap, 0x00, 0xA2000052);
-	adiv5_dp_low_access(t->ap->dp, 1, 0, 0x04, 0xE000EDF0);
-
-	adiv5_ap_write(t->ap, 0x18, val); /* Required to switch banks */
-	adiv5_dp_low_access(t->ap->dp, 1, 0, 0x14, 0x1000F);
-
-	return 0;
-}
-
-/* The following three routines implement target halt/resume
- * using the core debug registers in the NVIC. */
-static void 
-cm3_reset(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-
-	jtagtap_srst();
-
-	/* Request system reset from NVIC: SRST doesn't work correctly */
-	/* This could be VECTRESET: 0x05FA0001 (reset only core)
-	 *          or SYSRESETREQ: 0x05FA0004 (system reset)
-	 */
-	adiv5_ap_mem_write(t->ap, CM3_AIRCR,
-			CM3_AIRCR_VECTKEY | CM3_AIRCR_SYSRESETREQ);
-
-	/* Poll for release from reset */
-	while(adiv5_ap_mem_read(t->ap, CM3_AIRCR) & 
-			(CM3_AIRCR_VECTRESET | CM3_AIRCR_SYSRESETREQ));
-
-	/* Reset DFSR flags */
-	adiv5_ap_mem_write(t->ap, CM3_DFSR, CM3_DFSR_RESETALL);
-}
-
-static void 
-cm3_halt_request(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-
-	adiv5_ap_mem_write(t->ap, CM3_DHCSR, 
-		CM3_DHCSR_DBGKEY | CM3_DHCSR_C_HALT | CM3_DHCSR_C_DEBUGEN);
-}
-
-static int
-cm3_halt_wait(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-
-	return adiv5_ap_mem_read(t->ap, CM3_DHCSR) & CM3_DHCSR_S_HALT;
-}
-
-static void 
-cm3_halt_resume(struct target_s *target, uint8_t step)
-{
-	struct target_ap_s *t = (void *)target;
-	static uint8_t old_step = 0;
-	uint32_t dhcsr = CM3_DHCSR_DBGKEY | CM3_DHCSR_C_DEBUGEN;
-
-	if(step) dhcsr |= CM3_DHCSR_C_STEP | CM3_DHCSR_C_MASKINTS;
-
-	/* Disable interrupts while single stepping... */
-	if(step != old_step) {
-		adiv5_ap_mem_write(t->ap, CM3_DHCSR, dhcsr | CM3_DHCSR_C_HALT);
-		old_step = step;
-	}
-
-	adiv5_ap_mem_write(t->ap, CM3_DHCSR, dhcsr);
-}
-
-static int cm3_fault_unwind(struct target_s *target)
-{
-	struct target_ap_s *t = (void *)target;
-	uint32_t dfsr = adiv5_ap_mem_read(t->ap, CM3_DFSR);
-	uint32_t hfsr = adiv5_ap_mem_read(t->ap, CM3_HFSR);
-	uint32_t cfsr = adiv5_ap_mem_read(t->ap, CM3_CFSR);
-	adiv5_ap_mem_write(t->ap, CM3_DFSR, dfsr);/* write back to reset */
-	adiv5_ap_mem_write(t->ap, CM3_HFSR, hfsr);/* write back to reset */
-	adiv5_ap_mem_write(t->ap, CM3_CFSR, cfsr);/* write back to reset */
-	/* We check for FORCED in the HardFault Status Register or 
-	 * for a configurable fault to avoid catching core resets */
-	if((dfsr & CM3_DFSR_VCATCH) && ((hfsr & CM3_HFSR_FORCED) || cfsr)) {
-		/* Unwind exception */
-		uint32_t regs[target->regs_size];
-		uint32_t stack[8];
-		uint32_t retcode, framesize;
-		/* Read registers for post-exception stack pointer */
-		target_regs_read(target, regs);
-		/* save retcode currently in lr */
-		retcode = regs[14];
-		/* Read stack for pre-exception registers */
-		target_mem_read_words(target, stack, regs[13], sizeof(stack)); 
-		regs[14] = stack[5];	/* restore LR to pre-exception state */
-		regs[15] = stack[6];	/* restore PC to pre-exception state */
-
-		/* adjust stack to pop exception state */
-		framesize = (retcode & (1<<4)) ? 0x68 : 0x20;	/* check for basic vs. extended frame */
-		if (stack[7] & (1<<9))				/* check for stack alignment fixup */
-			framesize += 4;
-		regs[13] += framesize;
-
-		/* FIXME: stack[7] contains xPSR when this is supported */
-		/* although, if we caught the exception it will be unchanged */
-
-		/* Reset exception state to allow resuming from restored
-		 * state.
-		 */
-		adiv5_ap_mem_write(t->ap, CM3_AIRCR, 
-				CM3_AIRCR_VECTKEY | CM3_AIRCR_VECTCLRACTIVE);
-
-		/* Write pre-exception registers back to core */
-		target_regs_write(target, regs);
-
-		return 1;
-	}
-	return 0;
-}
-
-/* The following routines implement hardware breakpoints.
- * The Flash Patch and Breakpoint (FPB) system is used. */
-
-static int
-cm3_set_hw_bp(struct target_s *target, uint32_t addr)
-{
-	struct target_ap_s *t = (void *)target;
-	uint32_t val = addr & 0x1FFFFFFC;
-	int i;
-
-	val |= (addr & 2)?0x80000000:0x40000000;
-	val |= 1;
-
-	for(i = 0; i < 6; i++) 
-		if((hw_breakpoint[i] & 1) == 0) break;
-	
-	if(i == 6) return -1;
-
-	hw_breakpoint[i] = addr | 1;
-
-	adiv5_ap_mem_write(t->ap, CM3_FPB_COMP(i), val);
-
-	return 0;
-}
-
-static int
-cm3_clear_hw_bp(struct target_s *target, uint32_t addr)
-{
-	struct target_ap_s *t = (void *)target;
-	int i;
-
-	for(i = 0; i < 6; i++)
-		if((hw_breakpoint[i] & ~1) == addr) break;
-
-	if(i == 6) return -1;
-
-	hw_breakpoint[i] = 0;
-
-	adiv5_ap_mem_write(t->ap, CM3_FPB_COMP(i), 0);
-
-	return 0; 
-}
-
-
-/* The following routines implement hardware watchpoints.
- * The Data Watch and Trace (DWT) system is used. */
-
-static int
-cm3_set_hw_wp(struct target_s *target, uint8_t type, uint32_t addr, uint8_t len)
-{
-	struct target_ap_s *t = (void *)target;
-	int i;
-
-	switch(len) { /* Convert bytes size to mask size */
-		case 1: len = CM3_DWT_MASK_BYTE; break;
-		case 2: len = CM3_DWT_MASK_HALFWORD; break;
-		case 4: len = CM3_DWT_MASK_WORD; break;
-		default:
-			return -1;
-	}
-
-	switch(type) { /* Convert gdb type to function type */
-		case 2: type = CM3_DWT_FUNC_FUNC_WRITE; break;
-		case 3: type = CM3_DWT_FUNC_FUNC_READ; break;
-		case 4: type = CM3_DWT_FUNC_FUNC_ACCESS; break;
-		default:
-			return -1;
-	}
-
-	for(i = 0; i < 4; i++) 
-		if((hw_watchpoint[i].type) == 0) break;
-	
-	if(i == 4) return -2;
-
-	hw_watchpoint[i].type = type;
-	hw_watchpoint[i].addr = addr;
-	hw_watchpoint[i].size = len;
-
-	adiv5_ap_mem_write(t->ap, CM3_DWT_COMP(i), addr);
-	adiv5_ap_mem_write(t->ap, CM3_DWT_MASK(i), len);
-	adiv5_ap_mem_write(t->ap, CM3_DWT_FUNC(i), 
-			CM3_DWT_FUNC_DATAVSIZE_WORD | type);
-
-	return 0;
-}
-
-static int
-cm3_clear_hw_wp(struct target_s *target, uint8_t type, uint32_t addr, uint8_t len)
-{
-	struct target_ap_s *t = (void *)target;
-	int i;
-
-	switch(len) {
-		case 1: len = CM3_DWT_MASK_BYTE; break;
-		case 2: len = CM3_DWT_MASK_HALFWORD; break;
-		case 4: len = CM3_DWT_MASK_WORD; break;
-		default:
-			return -1;
-	}
-
-	switch(type) {
-		case 2: type = CM3_DWT_FUNC_FUNC_WRITE; break;
-		case 3: type = CM3_DWT_FUNC_FUNC_READ; break;
-		case 4: type = CM3_DWT_FUNC_FUNC_ACCESS; break;
-		default:
-			return -1;
-	}
-
-	for(i = 0; i < 4; i++)
-		if((hw_watchpoint[i].addr == addr) &&
-		   (hw_watchpoint[i].type == type) &&
-		   (hw_watchpoint[i].size == len)) break;
-
-	if(i == 4) return -2;
-
-	hw_watchpoint[i].type = 0;
-
-	adiv5_ap_mem_write(t->ap, CM3_DWT_FUNC(i), 0);
-
-	return 0;
-}
-
-static int
-cm3_check_hw_wp(struct target_s *target, uint32_t *addr)
-{
-	struct target_ap_s *t = (void *)target;
-	int i;
-
-	for(i = 0; i < 4; i++)
-		/* if SET and MATCHED then break */
-		if(hw_watchpoint[i].type && 
-		   (adiv5_ap_mem_read(t->ap, CM3_DWT_FUNC(i)) & 
-					CM3_DWT_FUNC_MATCHED))
-			break;
-
-	if(i == 4) return 0;
-
-	*addr = hw_watchpoint[i].addr;
-	return 1;
-}
-

src/crc32.c

@@ -0,0 +1,190 @@
+/*
+ * 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 "target.h"
+#include "gdb_if.h"
+
+#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,
+	0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
+	0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
+	0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9,
+	0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75,
+	0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011,
+	0x791D4014, 0x7DDC5DA3, 0x709F7B7A, 0x745E66CD,
+	0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
+	0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5,
+	0xBE2B5B58, 0xBAEA46EF, 0xB7A96036, 0xB3687D81,
+	0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D,
+	0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49,
+	0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95,
+	0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1,
+	0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D,
+	0x34867077, 0x30476DC0, 0x3D044B19, 0x39C556AE,
+	0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072,
+	0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16,
+	0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA,
+	0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE,
+	0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02,
+	0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1, 0x53DC6066,
+	0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
+	0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E,
+	0xBFA1B04B, 0xBB60ADFC, 0xB6238B25, 0xB2E29692,
+	0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6,
+	0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A,
+	0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E,
+	0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2,
+	0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686,
+	0xD5B88683, 0xD1799B34, 0xDC3ABDED, 0xD8FBA05A,
+	0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637,
+	0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB,
+	0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F,
+	0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53,
+	0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47,
+	0x36194D42, 0x32D850F5, 0x3F9B762C, 0x3B5A6B9B,
+	0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
+	0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623,
+	0xF12F560E, 0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7,
+	0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B,
+	0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F,
+	0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3,
+	0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7,
+	0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B,
+	0x9B3660C6, 0x9FF77D71, 0x92B45BA8, 0x9675461F,
+	0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3,
+	0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640,
+	0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C,
+	0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8,
+	0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24,
+	0x119B4BE9, 0x155A565E, 0x18197087, 0x1CD86D30,
+	0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
+	0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088,
+	0x2497D08D, 0x2056CD3A, 0x2D15EBE3, 0x29D4F654,
+	0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0,
+	0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C,
+	0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18,
+	0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4,
+	0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0,
+	0x9ABC8BD5, 0x9E7D9662, 0x933EB0BB, 0x97FFAD0C,
+	0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668,
+	0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4,
+};
+
+static uint32_t crc32_calc(uint32_t crc, uint8_t data)
+{
+	return (crc << 8) ^ crc32_table[((crc >> 24) ^ data) & 255];
+}
+
+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);
+		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]);
+
+		base += read_len;
+		len -= read_len;
+	}
+	DEBUG_WARN("%" PRIu32 " ms\n", platform_time_ms() - start_time);
+	*crc_res = crc;
+	return 0;
+}
+#else
+#include <libopencm3/stm32/crc.h>
+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;
+		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));
+
+		base += read_len;
+		len -= read_len;
+	}
+
+	crc = CRC_DR;
+
+	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;
+		for (int i = 0; i < 8; i++) {
+			if (crc & 0x80000000)
+				crc = (crc << 1) ^ 0x4C11DB7;
+			else
+				crc <<= 1;
+		}
+	}
+	*crc_res = crc;
+	return 0;
+}
+#endif
+

src/exception.c

@@ -1,7 +1,7 @@
 /*
  * This file is part of the Black Magic Debug project.
  *
- * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Copyright (C) 2015  Black Sphere Technologies Ltd.
  * Written by Gareth McMullin <gareth@blacksphere.co.nz>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -18,22 +18,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __SWDPTAP_H
-#define __SWDPTAP_H
-
 #include "general.h"
+#include "exception.h"
 
-int swdptap_init(void);
+struct exception *innermost_exception;
-void swdptap_reset(void);
 
-void swdptap_turnaround(uint8_t dir);
+void raise_exception(uint32_t type, const char *msg)
-uint8_t swdptap_bit_in(void);
+{
-void swdptap_bit_out(uint8_t val);
+	struct exception *e;
-
+	for (e = innermost_exception; e; e = e->outer) {
-uint32_t swdptap_seq_in(int ticks);
+		if (e->mask & type) {
-uint8_t swdptap_seq_in_parity(uint32_t *data, int ticks);
+			e->type = type;
-void swdptap_seq_out(uint32_t MS, int ticks);
+			e->msg = msg;
-void swdptap_seq_out_parity(uint32_t MS, int ticks);
+			innermost_exception = e->outer;
-
+			longjmp(e->jmpbuf, type);
-#endif
+		}
+	}
+	DEBUG_WARN("Unhandled exception: %s\n", msg);
+	abort();
+}
 

src/gdb_hostio.c

@@ -0,0 +1,132 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2016  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 "target.h"
+#include "gdb_main.h"
+#include "gdb_hostio.h"
+#include "gdb_packet.h"
+
+int gdb_main_loop(struct target_controller *, bool in_syscall);
+
+int hostio_reply(struct target_controller *tc, char *pbuf, int len)
+{
+	(void)len;
+	int retcode, items, errno_;
+	char c, *p;
+	if (pbuf[1] == '-')
+		p = &pbuf[2];
+	else
+		p = &pbuf[1];
+	items = sscanf(p, "%x,%x,%c", &retcode, &errno_, &c);
+	if (pbuf[1] == '-')
+		retcode = -retcode;
+
+	/* if break is requested */
+	tc->interrupted = items == 3 && c == 'C';
+	tc->errno_ = errno_;
+
+	return retcode;
+}
+
+/* Interface to host system calls */
+int hostio_open(struct target_controller *tc,
+	        target_addr path, size_t path_len,
+                enum target_open_flags flags, mode_t mode)
+{
+	gdb_putpacket_f("Fopen,%08X/%X,%08X,%08X", path, path_len, flags, mode);;;;
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_close(struct target_controller *tc, int fd)
+{
+	gdb_putpacket_f("Fclose,%08X", fd);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_read(struct target_controller *tc,
+	         int fd, target_addr buf, unsigned int count)
+{
+	gdb_putpacket_f("Fread,%08X,%08X,%08X", fd, buf, count);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_write(struct target_controller *tc,
+	          int fd, target_addr buf, unsigned int count)
+{
+	gdb_putpacket_f("Fwrite,%08X,%08X,%08X", fd, buf, count);
+	return gdb_main_loop(tc, true);
+}
+
+long hostio_lseek(struct target_controller *tc,
+	           int fd, long offset, enum target_seek_flag flag)
+{
+	gdb_putpacket_f("Flseek,%08X,%08X,%08X", fd, offset, flag);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_rename(struct target_controller *tc,
+	           target_addr oldpath, size_t old_len,
+	           target_addr newpath, size_t new_len)
+{
+	gdb_putpacket_f("Frename,%08X/%X,%08X/%X",
+	                oldpath, old_len, newpath, new_len);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_unlink(struct target_controller *tc,
+	           target_addr path, size_t path_len)
+{
+	gdb_putpacket_f("Funlink,%08X/%X", path, path_len);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_stat(struct target_controller *tc,
+	         target_addr path, size_t path_len, target_addr buf)
+{
+	gdb_putpacket_f("Fstat,%08X/%X,%08X", path, path_len, buf);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_fstat(struct target_controller *tc, int fd, target_addr buf)
+{
+	gdb_putpacket_f("Ffstat,%X,%08X", fd, buf);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_gettimeofday(struct target_controller *tc,
+		         target_addr tv, target_addr tz)
+{
+	gdb_putpacket_f("Fgettimeofday,%08X,%08X", tv, tz);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_isatty(struct target_controller *tc, int fd)
+{
+	gdb_putpacket_f("Fisatty,%08X", fd);
+	return gdb_main_loop(tc, true);
+}
+
+int hostio_system(struct target_controller *tc,
+	          target_addr cmd, size_t cmd_len)
+{
+	gdb_putpacket_f("Fsystem,%08X/%X", cmd, cmd_len);
+	return gdb_main_loop(tc, true);
+}

src/gdb_hostio.h

@@ -0,0 +1,53 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2016  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/>.
+ */
+#ifndef __GDB_SYSCALLS_H
+#define __GDB_SYSCALLS_H
+
+#include "target.h"
+
+int hostio_reply(struct target_controller *tc, char *packet, int len);
+
+/* Interface to host system calls */
+int hostio_open(struct target_controller *,
+	        target_addr path, size_t path_len,
+                enum target_open_flags flags, mode_t mode);
+int hostio_close(struct target_controller *, int fd);
+int hostio_read(struct target_controller *,
+	         int fd, target_addr buf, unsigned int count);
+int hostio_write(struct target_controller *,
+	          int fd, target_addr buf, unsigned int count);
+long hostio_lseek(struct target_controller *,
+	           int fd, long offset, enum target_seek_flag flag);
+int hostio_rename(struct target_controller *,
+	           target_addr oldpath, size_t old_len,
+	           target_addr newpath, size_t new_len);
+int hostio_unlink(struct target_controller *,
+	           target_addr path, size_t path_len);
+int hostio_stat(struct target_controller *,
+	         target_addr path, size_t path_len, target_addr buf);
+int hostio_fstat(struct target_controller *, int fd, target_addr buf);
+int hostio_gettimeofday(struct target_controller *,
+		         target_addr tv, target_addr tz);
+int hostio_isatty(struct target_controller *, int fd);
+int hostio_system(struct target_controller *,
+	           target_addr cmd, size_t cmd_len);
+
+#endif
+

src/gdb_main.c

@@ -19,417 +19,673 @@
  */
 
 /* This file implements the GDB Remote Serial Debugging protocol as
- * described in "Debugging with GDB" build from GDB source.  
+ * described in "Debugging with GDB" build from GDB source.
  *
  * Originally written for GDB 6.8, updated and tested with GDB 7.2.
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <assert.h>
-
-#include "platform.h"
-
 #include "general.h"
+#include "ctype.h"
 #include "hex_utils.h"
 #include "gdb_if.h"
 #include "gdb_packet.h"
 #include "gdb_main.h"
-
+#include "gdb_hostio.h"
-#include "jtagtap.h"
-#include "jtag_scan.h"
-#include "adiv5.h"
-
 #include "target.h"
-
 #include "command.h"
+#include "crc32.h"
+#include "morse.h"
+#ifdef ENABLE_RTT
+#include "rtt.h"
+#endif
 
-#define BUF_SIZE	1024
+enum gdb_signal {
+	GDB_SIGINT = 2,
+	GDB_SIGTRAP = 5,
+	GDB_SIGSEGV = 11,
+	GDB_SIGLOST = 29,
+};
+
+#define BUF_SIZE	1024U
 
 #define ERROR_IF_NO_TARGET()	\
 	if(!cur_target) { gdb_putpacketz("EFF"); break; }
 
-static unsigned char pbuf[BUF_SIZE];
+typedef struct
-
-static void handle_q_packet(char *packet, int len);
-static void handle_v_packet(char *packet, int len);
-
-void
-gdb_main(void)
 {
-	int size;
+	const char *cmd_prefix;
-	static uint8_t single_step = 0;
+	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, 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) {
+		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;
+}
+
+static void gdb_target_printf(struct target_controller *tc,
+                              const char *fmt, va_list ap)
+{
+	(void)tc;
+	gdb_voutf(fmt, ap);
+}
+
+static struct target_controller gdb_controller = {
+	.destroy_callback = gdb_target_destroy_callback,
+	.printf = gdb_target_printf,
+
+	.open = hostio_open,
+	.close = hostio_close,
+	.read = hostio_read,
+	.write = hostio_write,
+	.lseek = hostio_lseek,
+	.rename = hostio_rename,
+	.unlink = hostio_unlink,
+	.stat = hostio_stat,
+	.fstat = hostio_fstat,
+	.gettimeofday = hostio_gettimeofday,
+	.isatty = hostio_isatty,
+	.system = hostio_system,
+};
+
+int gdb_main_loop(struct target_controller *tc, bool in_syscall)
+{
+	bool single_step = false;
 
-	DEBUG("Entring GDB protocol main loop\n");
 	/* 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);
-		DEBUG("%s\n", pbuf);
+		switch (pbuf[0]) {
-		switch(pbuf[0]) {
+		/* Implementation of these is mandatory! */
-		    /* Implementation of these is mandatory! */
+		case 'g': { /* 'g': Read general registers */
-		    case 'g': { /* 'g': Read general registers */
-			uint32_t arm_regs[cur_target->regs_size];
 			ERROR_IF_NO_TARGET();
-			target_regs_read(cur_target, (void*)arm_regs);
+			uint8_t gp_regs[target_regs_size(cur_target)];
-			gdb_putpacket(hexify(pbuf, (void*)arm_regs, cur_target->regs_size), cur_target->regs_size * 2);
+			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 */
+		case 'm': {	/* 'm addr,len': Read len bytes from addr */
-			unsigned long addr, len;
+			uint32_t addr, len;
-			char *mem;
 			ERROR_IF_NO_TARGET();
-			sscanf(pbuf, "m%08lX,%08lX", &addr, &len);
+			sscanf(pbuf, "m%" SCNx32 ",%" SCNx32, &addr, &len);
-			DEBUG("m packet: addr = %08lX, len = %08lX\n", addr, len);
+			if (len > sizeof(pbuf) / 2) {
-			mem = malloc(len);
+				gdb_putpacketz("E02");
-			if(!mem) break;
+				break;
-			if(((addr & 3) == 0) && ((len & 3) == 0))
+			}
-				target_mem_read_words(cur_target, (void*)mem, 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
-				target_mem_read_bytes(cur_target, (void*)mem, addr, len);
+				gdb_putpacket(hexify(pbuf, mem, len), len * 2U);
-			if(target_check_error(cur_target))
-				gdb_putpacket("E01", 3);
-			else
-				gdb_putpacket(hexify(pbuf, mem, len), len*2);
-			free(mem);
 			break;
-		    }
+		}
-		    case 'G': {	/* 'G XX': Write general registers */
+		case 'G': {	/* 'G XX': Write general registers */
-			uint32_t arm_regs[cur_target->regs_size];
 			ERROR_IF_NO_TARGET();
-			unhexify((void*)arm_regs, &pbuf[1], cur_target->regs_size);
+			uint8_t gp_regs[target_regs_size(cur_target)];
-			target_regs_write(cur_target, arm_regs);
+			unhexify(gp_regs, &pbuf[1], sizeof(gp_regs));
-			gdb_putpacket("OK", 2);
+			target_regs_write(cur_target, gp_regs);
+			gdb_putpacketz("OK");
 			break;
-		    }
+		}
-		    case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
+		case 'M': { /* 'M addr,len:XX': Write len bytes to addr */
-			unsigned long addr, len;
+			uint32_t addr = 0;
+			uint32_t len = 0;
 			int hex;
-			char *mem;
 			ERROR_IF_NO_TARGET();
-			sscanf(pbuf, "M%08lX,%08lX:%n", &addr, &len, &hex);
+			sscanf(pbuf, "M%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &hex);
-			DEBUG("M packet: addr = %08lX, len = %08lX\n", addr, len);
+			if (len > (unsigned)(size - hex) / 2) {
-			mem = malloc(len);
+				gdb_putpacketz("E02");
+				break;
+			}
+			DEBUG_GDB("M packet: addr = %" PRIx32 ", len = %" PRIx32 "\n",
+					  addr, len);
+			uint8_t mem[len];
 			unhexify(mem, pbuf + hex, len);
-			if(((addr & 3) == 0) && ((len & 3) == 0)) 
+			if (target_mem_write(cur_target, addr, mem, len))
-				target_mem_write_words(cur_target, addr, (void*)mem, len);
+				gdb_putpacketz("E01");
-			else 
-				target_mem_write_bytes(cur_target, addr, (void*)mem, len);
-			if(target_check_error(cur_target))
-				gdb_putpacket("E01", 3);
 			else
-				gdb_putpacket("OK", 2);
+				gdb_putpacketz("OK");
-			free(mem);
 			break;
-		    }
+		}
-		    case 's':	/* 's [addr]': Single step [start at addr] */
+		/* '[m|M|g|G|c][thread-id]' : Set the thread ID for the given subsequent operation
-			single_step = 1;
+		 * (we don't actually care which as we only care about the TID for whether to send OK or an error)
-			// Fall through to resume target
+		 */
-		    case 'c':	/* 'c [addr]': Continue [at addr] */
+		case 'H': {
-			if(!cur_target) {
+			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 */
+		case 'c':	/* 'c [addr]': Continue [at addr] */
+			if (!cur_target) {
 				gdb_putpacketz("X1D");
 				break;
 			}
 
 			target_halt_resume(cur_target, single_step);
 			SET_RUN_STATE(1);
-			single_step = 0;
+			single_step = false;
-			// Fall through to wait for target halt
+			/* fall through */
-		    case '?': {	/* '?': Request reason for target halt */
+		case '?': {	/* '?': Request reason for target halt */
 			/* This packet isn't documented as being mandatory,
 			 * but GDB doesn't work without it. */
-			int sent_int = 0;
+			target_addr watch;
-			uint32_t watch_addr;		
+			enum target_halt_reason reason;
 
-			if(!cur_target) {
+			if (!cur_target) {
 				/* Report "target exited" if no target */
 				gdb_putpacketz("W00");
 				break;
 			}
 
 			/* Wait for target halt */
-			while(!target_halt_wait(cur_target)) { 
+			while(!(reason = target_halt_poll(cur_target, &watch))) {
-				unsigned char c = gdb_if_getchar_to(0);
+				char c = (char)gdb_if_getchar_to(0);
-				if((c == '\x03') || (c == '\x04')) {
+				if(c == '\x03' || c == '\x04') {
 					target_halt_request(cur_target);
-					sent_int = 1;
 				}
+				#ifdef ENABLE_RTT
+				if (rtt_enabled) poll_rtt(cur_target);
+				#endif
 			}
-
 			SET_RUN_STATE(0);
-			/* Report reason for halt */
+
-			if(target_check_hw_wp(cur_target, &watch_addr)) {
+			/* Translate reason to GDB signal */
-				/* Watchpoint hit */
+			switch (reason) {
-				gdb_putpacket_f("T05watch:%08X;", watch_addr);
+			case TARGET_HALT_ERROR:
-			} else if(target_fault_unwind(cur_target)) {
+				gdb_putpacket_f("X%02X", GDB_SIGLOST);
-				gdb_putpacketz("T0b");
+				morse("TARGET LOST.", true);
-			} else if(sent_int) {
+				break;
-				/* Target interrupted */
+			case TARGET_HALT_REQUEST:
-				gdb_putpacketz("T02");
+				gdb_putpacket_f("T%02X", GDB_SIGINT);
-			} else {
+				break;
-				gdb_putpacketz("T05");
+			case TARGET_HALT_WATCHPOINT:
+				gdb_putpacket_f("T%02Xwatch:%08X;", GDB_SIGTRAP, watch);
+				break;
+			case TARGET_HALT_FAULT:
+				gdb_putpacket_f("T%02X", GDB_SIGSEGV);
+				break;
+			default:
+				gdb_putpacket_f("T%02X", GDB_SIGTRAP);
 			}
 			break;
-		    }
+		}
 
-		    /* Optional GDB packet support */
+		/* Optional GDB packet support */
-		    case '!':	/* Enable Extended GDB Protocol. */
+		case 'p': { /* Read single register */
-			/* This doesn't do anything, we support the extended 
+			ERROR_IF_NO_TARGET();
-			 * protocol anyway, but GDB will never send us a 'R'
+			uint32_t reg;
-			 * packet unless we answer 'OK' here. 
+			sscanf(pbuf, "p%" SCNx32, &reg);
-			 */
+			uint8_t val[8];
-			gdb_putpacket("OK", 2);
+			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)
+				return hostio_reply(tc, pbuf, size);
+			else {
+				DEBUG_GDB("*** F packet when not in syscall! '%s'\n", pbuf);
+				gdb_putpacketz("");
+			}
 			break;
 
-		    case 0x04:
+		case '!':	/* Enable Extended GDB Protocol. */
-                    case 'D':	/* GDB 'detach' command. */
+			/* This doesn't do anything, we support the extended
-			if(cur_target) 
+			 * protocol anyway, but GDB will never send us a 'R'
+			 * packet unless we answer 'OK' here.
+			 */
+			gdb_putpacketz("OK");
+			break;
+
+		case 0x04:
+		case 'D':	/* GDB 'detach' command. */
+			if(cur_target) {
+				SET_RUN_STATE(1);
 				target_detach(cur_target);
+			}
 			last_target = cur_target;
 			cur_target = NULL;
-			gdb_putpacket("OK", 2);
+			gdb_putpacketz("OK");
 			break;
 
-		    case 'k':	/* Kill the target */
+		case 'k':	/* Kill the target */
-			if(cur_target) {
+			handle_kill_target();
-				target_reset(cur_target);
-				target_detach(cur_target);
-				last_target = cur_target;
-				cur_target = NULL;
-			}
 			break;
 
-		    case 'r':	/* Reset the target system */
+		case 'r':	/* Reset the target system */
-		    case 'R':	/* Restart the target program */
+		case 'R':	/* Restart the target program */
 			if(cur_target)
 				target_reset(cur_target);
 			else if(last_target) {
-				cur_target = last_target;
+				cur_target = target_attach(last_target,
-				target_attach(cur_target);
+						           &gdb_controller);
+				if(cur_target)
+					morse(NULL, false);
 				target_reset(cur_target);
 			}
 			break;
 
-		    case 'X': { /* 'X addr,len:XX': Write binary data to addr */
+		case 'X': { /* 'X addr,len:XX': Write binary data to addr */
-			unsigned long addr, len;
+			uint32_t addr, len;
 			int bin;
 			ERROR_IF_NO_TARGET();
-			sscanf(pbuf, "X%08lX,%08lX:%n", &addr, &len, &bin);
+			sscanf(pbuf, "X%" SCNx32 ",%" SCNx32 ":%n", &addr, &len, &bin);
-			DEBUG("X packet: addr = %08lX, len = %08lX\n", addr, len);
+			if (len > (unsigned)(size - bin)) {
-			if(((addr & 3) == 0) && ((len & 3) == 0)) 
+				gdb_putpacketz("E02");
-				target_mem_write_words(cur_target, addr, (void*)pbuf+bin, len);
+				break;
-			else 
+			}
-				target_mem_write_bytes(cur_target, addr, (void*)pbuf+bin, len);
+			DEBUG_GDB("X packet: addr = %" PRIx32 ", len = %" PRIx32 "\n",
-			if(target_check_error(cur_target))
+					  addr, len);
-				gdb_putpacket("E01", 3);
+			if (target_mem_write(cur_target, addr, pbuf + bin, len))
+				gdb_putpacketz("E01");
 			else
-				gdb_putpacket("OK", 2);
+				gdb_putpacketz("OK");
 			break;
-		    }
+		}
 
-		    case 'q':	/* General query packet */
+		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;
 
-		    /* These packet implement hardware break-/watchpoints */
+		/* These packet implement hardware break-/watchpoints */
-		    case 'Z':	/* Z type,addr,len: Set breakpoint packet */
+		case 'Z':	/* Z type,addr,len: Set breakpoint packet */
-		    case 'z': { /* z type,addr,len: Clear breakpoint packet */
+		case 'z':	/* z type,addr,len: Clear breakpoint packet */
-			uint8_t set = (pbuf[0]=='Z')?1:0;
-			int type, len;
-			unsigned long addr;
-			int ret;
 			ERROR_IF_NO_TARGET();
-			/* I have no idea why this doesn't work. Seems to work
+			handle_z_packet(pbuf, size);
-			 * with real sscanf() though... */
-			//sscanf(pbuf, "%*[zZ]%hhd,%08lX,%hhd", &type, &addr, &len);
-			type = pbuf[1] - '0';
-			sscanf(pbuf + 2, ",%08lX,%d", &addr, &len);
-			switch(type) {
-			    case 1: /* Hardware breakpoint */
-				if(!cur_target->set_hw_bp) { /* Not supported */
-					gdb_putpacket("", 0);
-					break;
-				}
-				if(set) ret = target_set_hw_bp(cur_target, addr);
-				else	ret = target_clear_hw_bp(cur_target, addr);
-
-				if(!ret) gdb_putpacket("OK", 2);
-				else gdb_putpacket("E01", 3);
-
-				break;
-
-			    case 2:
-			    case 3:
-			    case 4:
-				if(!cur_target->set_hw_wp) { /* Not supported */
-					gdb_putpacket("", 0);
-					break;
-				}
-				if(set) ret = target_set_hw_wp(cur_target, type, addr, len);
-				else	ret = target_clear_hw_wp(cur_target, type, addr, len);
-
-				if(!ret) gdb_putpacket("OK", 2);
-				else gdb_putpacket("E01", 3);
-
-				break;
-			    default:
-				gdb_putpacket("", 0);
-			}
 			break;
-		    }
 
-		    default: 	/* Packet not implemented */
+		default: 	/* Packet not implemented */
-			DEBUG("Unsupported packet: %s\n", pbuf);
+			DEBUG_GDB("*** Unsupported packet: %s\n", pbuf);
-			gdb_putpacket("", 0);
+			gdb_putpacketz("");
 		}
 	}
 }
 
-static void
+static bool exec_command(char *packet, const size_t length, const cmd_executer *exec)
-handle_q_string_reply(const char *str, const char *param)
 {
-	unsigned long addr, len;
+	while (exec->cmd_prefix) {
-	
+		const size_t prefix_length = strlen(exec->cmd_prefix);
-	if (sscanf(param, "%08lX,%08lX", &addr, &len) != 2) {
+		if (!strncmp(packet, exec->cmd_prefix, prefix_length)) {
+			exec->func(packet + prefix_length, length - prefix_length);
+			return true;
+		}
+		++exec;
+	}
+	return false;
+}
+
+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)) {
+	if (addr > reply_length) {
-		uint8_t 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
 		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
+static void exec_q_supported(const char *packet, const size_t length)
-handle_q_packet(char *packet, int len)
 {
-	/* These 'monitor' commands only available on the real deal */
+	(void)packet;
-	if(!strncmp(packet, "qRcmd,", 6)) {
+	(void)length;
-		unsigned char *data;
+	gdb_putpacket_f("PacketSize=%X;qXfer:memory-map:read+;qXfer:features:read+", BUF_SIZE);
-		int datalen;
+}
 
-		/* calculate size and allocate buffer for command */
+static void exec_q_memory_map(const char *packet, const size_t length)
-		datalen = (len - 6) / 2;
+{
-		data = alloca(datalen+1);
+	(void)packet;
-		/* dehexify command */
+	(void)length;
-		unhexify(data, packet+6, datalen);
+	/* Read target XML memory map */
-		data[datalen] = 0;	/* add terminating null */
+	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);
+}
 
-		if(command_process(data) < 0) 
+static void exec_q_feature_read(const char *packet, const size_t length)
-			gdb_putpacket("", 0);
+{
-		else	gdb_putpacket("OK", 2);
+	(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);
+}
 
-	} else if (!strncmp (packet, "qSupported", 10)) {
+static void exec_q_crc(const char *packet, const size_t length)
-		/* Query supported protocol features */
+{
-		gdb_putpacket_f("PacketSize=%X;qXfer:memory-map:read+;qXfer:features:read+", BUF_SIZE);
+	(void)length;
-
+	uint32_t addr;
-	} else if (strncmp (packet, "qXfer:memory-map:read::", 23) == 0) {
+	uint32_t addr_length;
-		/* Read target XML memory map */
+	if (sscanf(packet, "%" PRIx32 ",%" PRIx32, &addr, &addr_length) == 2) {
-		if((!cur_target) && last_target) {
+		if (!cur_target) {
-			/* Attach to last target if detached. */
-			cur_target = last_target;
-			target_attach(cur_target);
-		}
-		if((!cur_target) || (!cur_target->xml_mem_map)) {
 			gdb_putpacketz("E01");
 			return;
 		}
-		handle_q_string_reply(cur_target->xml_mem_map, packet + 23);
+		uint32_t crc;
-
+		if (generic_crc32(cur_target, &crc, addr, addr_length))
-	} else if (strncmp (packet, "qXfer:features:read:target.xml:", 31) == 0) {
+			gdb_putpacketz("E03");
-		/* Read target description */
+		else
-		if((!cur_target) && last_target) {
+			gdb_putpacket_f("C%lx", crc);
-			/* Attach to last target if detached. */
+	}
-			cur_target = last_target;
-			target_attach(cur_target);
-		}
-		if((!cur_target) || (!cur_target->tdesc)) {
-			gdb_putpacketz("E01");
-			return;
-		}
-		handle_q_string_reply(cur_target->tdesc, packet + 31);
-
-	} else gdb_putpacket("", 0);
 }
 
-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 */
-		target *t;
+		cur_target = target_attach_n(addr, &gdb_controller);
-		uint32_t i;
+		if(cur_target) {
-		for(t = target_list, i = 1; t; t = t->next, i++) 
+			morse(NULL, false);
-			if(i == addr) {
+			/*
-				cur_target = t;
+			 * We don't actually support threads, but GDB 11 and 12 can't work without
-				target_attach(t);
+			 * us saying we attached to thread 1.. see the following for the low-down of this:
-				gdb_putpacketz("T05");
+			 * https://sourceware.org/bugzilla/show_bug.cgi?id=28405
-				break;
+			 * https://sourceware.org/bugzilla/show_bug.cgi?id=28874
-			}
+			 * https://sourceware.org/pipermail/gdb-patches/2021-December/184171.html
-		if(!cur_target) /* Failed to attach */
+			 * 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 = last_target;
+			cur_target = target_attach(last_target,
-			target_attach(cur_target);
+						   &gdb_controller);
-			target_reset(cur_target);
-			gdb_putpacketz("T05");
-		} else	gdb_putpacketz("E01");
 
-	} else if (sscanf(packet, "vFlashErase:%08lX,%08lX", &addr, &len) == 2) {
+			/* 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 if (sscanf(packet, "vFlashErase:%08" PRIx32 ",%08" PRIx32, &addr, &len) == 2) {
 		/* Erase Flash Memory */
-		DEBUG("Flash Erase %08lX %08lX\n", addr, len);
+		DEBUG_GDB("Flash Erase %08" PRIX32 " %08" PRIX32 "\n", addr, len);
-		if(!cur_target) { gdb_putpacketz("EFF"); return; }
+		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;
+		const uint32_t count = plen - bin;
-		DEBUG("Flash Write %08lX %08lX\n", addr, len);
+		DEBUG_GDB("Flash Write %08" PRIX32 " %08" PRIX32 "\n", addr, count);
-		if(cur_target && target_flash_write_words(cur_target, addr, (void*)packet + bin, len) == 0)
+		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("OK");
+		gdb_putpacketz(target_flash_done(cur_target) ? "EFF" : "OK");
 		flash_mode = 0;
 
-	} else
+	} else if (!strcmp(packet, "vStopped")) {
+		if (gdb_needs_detach_notify) {
+			gdb_putpacketz("W00");
+			gdb_needs_detach_notify = false;
+		} else
+			gdb_putpacketz("OK");
+
+	} else {
+		DEBUG_GDB("*** Unsupported packet: %s\n", packet);
 		gdb_putpacket("", 0);
+	}
 }
 
+static void handle_z_packet(char *packet, const size_t plen)
+{
+	(void)plen;
+
+	uint32_t type;
+	uint32_t len;
+	uint32_t addr;
+	sscanf(packet, "%*[zZ]%" PRIu32 ",%08" PRIx32 ",%" PRIu32, &type, &addr, &len);
+
+	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)
+		gdb_putpacketz("E01");
+	else if (ret > 0)
+		gdb_putpacketz("");
+	else
+		gdb_putpacketz("OK");
+}
+
+void gdb_main(void)
+{
+	gdb_main_loop(&gdb_controller, false);
+}

src/gdb_packet.c

@@ -22,98 +22,207 @@
  * reception and transmission as well as some convenience functions.
  */
 
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <stdarg.h>
-
 #include "general.h"
 #include "gdb_if.h"
 #include "gdb_packet.h"
 #include "hex_utils.h"
+#include "remote.h"
 
-int 
+#include <stdarg.h>
-gdb_getpacket(unsigned 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) {
+	while (1) {
-		/* Wait for packet start */
+	    /* Wait for packet start */
-		while((packet[0] = gdb_if_getchar()) != '$')
+		do {
-			if(packet[0] == 0x04) return 1;
+			/* 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 */
-		/* Capture packet data into buffer */
+						packet[offset] = 0;
-		while((c = gdb_if_getchar()) != '#') {
+						remotePacketProcess(offset, packet);
+						gettingRemotePacket = false;
+						break;
 
-			if(i == size) break; /* Oh shit */
+					case '$': /* A 'real' gdb packet, best stop squatting now */
+						packet[0] = '$';
+						gettingRemotePacket = false;
+						break;
 
-			if(c == '$') { /* Restart capture */
+					default:
-				i = 0; 
+						if (offset < size) {
-				csum = 0; 
+							packet[offset++] = c;
-				continue; 
+						} 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;
 			}
-			if(c == '}') { /* escaped char */
+#endif
+	    } while (packet[0] != '$');
+
+		offset = 0;
+		csum = 0;
+		char c;
+		/* Capture packet data into buffer */
+		while ((c = (char)gdb_if_getchar()) != '#') {
+
+			/* If we run out of buffer space, exit early */
+			if (offset == size)
+				break;
+
+			if (c == '$') { /* Restart capture */
+				offset = 0;
+				csum = 0;
+				continue;
+			}
+			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[0] = (char)gdb_if_getchar();
-		recv_csum[1] = 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;
-	return i;
+
+#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_GDB_WIRE("\\x%02X", c);
+	}
+	DEBUG_GDB_WIRE("\n");
+#endif
+	return offset;
 }
 
-void gdb_putpacket(unsigned 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 {
-		csum = 0;
+		DEBUG_GDB_WIRE("%s: ", __func__);
+		unsigned char csum = 0;
 		gdb_if_putchar('$', 0);
-		for(i = 0; i < size; i++) {
+
-			c = packet[i];
+		for (size_t i = 0; i < size1; ++i)
-			if((c == '$') || (c == '#') || (c == '}')) {
+			gdb_next_char(packet1[i], &csum);
-				gdb_if_putchar('}', 0);
+		for (size_t i = 0; i < size2; ++i)
-				gdb_if_putchar(c ^ 0x20, 0);
+			gdb_next_char(packet2[i], &csum);
-				csum += '}' + (c ^ 0x20);
+
-			} else {
-				gdb_if_putchar(c, 0);
-				csum += c;
-			}
-		}
 		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);
-
+		DEBUG_GDB_WIRE("\n");
-	} while((gdb_if_getchar_to(2000) != '+') && (tries++ < 3));
+	} while (gdb_if_getchar_to(2000) != '+' && tries++ < 3);
-
 }
 
-void gdb_putpacket_f(const unsigned char *fmt, ...)
+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, ...)
 {
 	va_list ap;
 	char *buf;
@@ -128,24 +237,30 @@ void gdb_putpacket_f(const unsigned char *fmt, ...)
 
 void gdb_out(const char *buf)
 {
-	char *hexdata;
+	int l = strlen(buf);
-	int i;
+	char *hexdata = calloc(1, 2 * l + 1);
+	if (!hexdata)
+		return;
+	hexify(hexdata, buf, l);
+	gdb_putpacket2("O", 1, hexdata, 2 * l);
+	free(hexdata);
+}
 
-	hexdata = alloca((i = strlen(buf)*2 + 1) + 1);
+void gdb_voutf(const char *fmt, va_list ap)
-	hexdata[0] = 'O';
+{
-	hexify(hexdata+1, buf, strlen(buf));
+	char *buf;
-	gdb_putpacket(hexdata, i);
+
+	if (vasprintf(&buf, fmt, ap) < 0)
+		return;
+	gdb_out(buf);
+	free(buf);
 }
 
 void gdb_outf(const char *fmt, ...)
 {
 	va_list ap;
-	char *buf;
 
 	va_start(ap, fmt);
-	vasprintf(&buf, fmt, ap);
+	gdb_voutf(fmt, ap);
-	gdb_out(buf);
-	free(buf);
 	va_end(ap);
 }
-

src/hex_utils.c

@@ -18,25 +18,24 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* Convenience function to convert to/from ascii strings of hex digits. 
+/* Convenience function to convert to/from ascii strings of hex digits.
  */
 
-#include <stdio.h>
+#include "general.h"
-#include <stdint.h>
-
 #include "hex_utils.h"
 
-static char hexdigits[] = "0123456789abcdef";
+static const char hexdigits[] = "0123456789abcdef";
 
-char * hexify(char *hex, const unsigned char *buf, int size)
+char *hexify(char *hex, const void *buf, const size_t size)
 {
-	char *tmp = hex;
+	char *dst = hex;
+	const uint8_t *const src = buf;
 
-	while(size--) {
+	for (size_t idx = 0; idx < size; ++idx) {
-		*tmp++ = hexdigits[*buf >> 4];
+		*dst++ = hexdigits[src[idx] >> 4];
-		*tmp++ = hexdigits[*buf++ & 0xF];
+		*dst++ = hexdigits[src[idx] & 0xF];
 	}
-	*tmp++ = 0;
+	*dst++ = 0;
 
 	return hex;
 }
@@ -44,19 +43,18 @@ char * hexify(char *hex, const unsigned char *buf, int 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(unsigned char *buf, const char *hex, int size)
+char *unhexify(void *buf, const char *hex, const size_t size)
 {
-	while(size--) {
+	uint8_t *const dst = buf;
-		*buf = unhex_digit(*hex++) << 4;
+	for (size_t idx = 0; idx < size; ++idx, hex += 2) {
-		*buf++ |= unhex_digit(*hex++);
+		dst[idx] = (unhex_digit(hex[0]) << 4) | unhex_digit(hex[1]);
 	}
 	return buf;
 }
-

src/include/adiv5.h

@@ -1,178 +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/>.
- */
-
-#ifndef __ADIV5_H
-#define __ADIV5_H
-
-#include "general.h"
-#include "jtag_scan.h"
-#include "target.h"
-
-/* ADIv5 DP Register addresses */
-#define ADIV5_DP_IDCODE		0x0
-#define ADIV5_DP_ABORT		0x0
-#define ADIV5_DP_CTRLSTAT	0x4
-#define ADIV5_DP_SELECT		0x8
-#define ADIV5_DP_RDBUFF		0xC
-
-/* AP Abort Register (ABORT) */
-/* Bits 31:5 - Reserved */
-#define ADIV5_DP_ABORT_ORUNERRCLR	(1 << 4)
-#define ADIV5_DP_ABORT_WDERRCLR		(1 << 3)
-#define ADIV5_DP_ABORT_STKERRCLR	(1 << 2)
-#define ADIV5_DP_ABORT_STKCMPCLR	(1 << 1)
-/* Bits 5:1 - SW-DP only, reserved in JTAG-DP */
-#define ADIV5_DP_ABORT_DAPABORT		(1 << 0)
-
-/* Control/Status Register (CTRLSTAT) */
-#define ADIV5_DP_CTRLSTAT_CSYSPWRUPACK	(1u << 31)
-#define ADIV5_DP_CTRLSTAT_CSYSPWRUPREQ	(1u << 30)
-#define ADIV5_DP_CTRLSTAT_CDBGPWRUPACK	(1u << 29)
-#define ADIV5_DP_CTRLSTAT_CDBGPWRUPREQ	(1u << 28)
-#define ADIV5_DP_CTRLSTAT_CDBGRSTACK	(1u << 27)
-#define ADIV5_DP_CTRLSTAT_CDBGRSTREQ	(1u << 26)
-/* Bits 25:24 - Reserved */
-/* Bits 23:12 - TRNCNT */
-#define ADIV5_DP_CTRLSTAT_TRNCNT
-/* Bits 11:8 - MASKLANE */
-#define ADIV5_DP_CTRLSTAT_MASKLANE
-/* Bits 7:6 - Reserved in JTAG-DP */
-#define ADIV5_DP_CTRLSTAT_WDATAERR	(1u << 7)
-#define ADIV5_DP_CTRLSTAT_READOK	(1u << 6)
-#define ADIV5_DP_CTRLSTAT_STICKYERR	(1u << 5)
-#define ADIV5_DP_CTRLSTAT_STICKYCMP	(1u << 4)
-#define ADIV5_DP_CTRLSTAT_TRNMODE_MASK	(3u << 2)
-#define ADIV5_DP_CTRLSTAT_STICKYORUN	(1u << 1)
-#define ADIV5_DP_CTRLSTAT_ORUNDETECT	(1u << 0)
-
-
-/* ADIv5 MEM-AP Registers */
-#define ADIV5_AP_CSW		0x00
-#define ADIV5_AP_TAR		0x04
-/* 0x08 - Reserved */
-#define ADIV5_AP_DRW		0x0C
-#define ADIV5_AP_DB(x)		(0x10 + (4*(x)))
-/* 0x20:0xF0 - Reserved */
-#define ADIV5_AP_CFG		0xF4
-#define ADIV5_AP_BASE		0xF8
-#define ADIV5_AP_IDR		0xFC
-
-/* AP Control and Status Word (CSW) */
-#define ADIV5_AP_CSW_DBGSWENABLE	(1u << 31)
-/* Bits 30:24 - Prot, Implementation defined, for Cortex-M3: */
-#define ADIV5_AP_CSW_MASTERTYPE_DEBUG	(1u << 29)
-#define ADIV5_AP_CSW_HPROT1		(1u << 25)
-#define ADIV5_AP_CSW_SPIDEN		(1u << 23)
-/* Bits 22:12 - Reserved */
-/* Bits 11:8 - Mode, must be zero */
-#define ADIV5_AP_CSW_TRINPROG		(1u << 7)
-#define ADIV5_AP_CSW_DEVICEEN		(1u << 6)
-#define ADIV5_AP_CSW_ADDRINC_NONE	(0u << 4)
-#define ADIV5_AP_CSW_ADDRINC_SINGLE	(1u << 4)
-#define ADIV5_AP_CSW_ADDRINC_PACKED	(2u << 4)
-#define ADIV5_AP_CSW_ADDRINC_MASK	(3u << 4)
-/* Bit 3 - Reserved */
-#define ADIV5_AP_CSW_SIZE_BYTE		(0u << 0)
-#define ADIV5_AP_CSW_SIZE_HALFWORD	(1u << 0)
-#define ADIV5_AP_CSW_SIZE_WORD		(2u << 0)
-#define ADIV5_AP_CSW_SIZE_MASK		(7u << 0)
-
-/* Constants to make RnW and APnDP parameters more clear in code */
-#define ADIV5_LOW_WRITE		0
-#define ADIV5_LOW_READ		1
-#define ADIV5_LOW_DP		0
-#define ADIV5_LOW_AP		1
-
-/* Try to keep this somewhat absract for later adding SW-DP */
-typedef struct ADIv5_DP_s {
-	struct ADIv5_DP_s *next;
-	uint32_t idcode;
-
-	void (*dp_write)(struct ADIv5_DP_s *dp, uint8_t addr, uint32_t value);
-	uint32_t (*dp_read)(struct ADIv5_DP_s *dp, uint8_t addr);
-
-	uint32_t (*error)(struct ADIv5_DP_s *dp);
-
-	uint32_t (*low_access)(struct ADIv5_DP_s *dp, uint8_t APnDP, uint8_t RnW, 
-			uint8_t addr, uint32_t value);
-
-	union {
-		jtag_dev_t *dev;
-		uint8_t fault;
-	};
-} ADIv5_DP_t;
-
-static inline void adiv5_dp_write(ADIv5_DP_t *dp, uint8_t addr, uint32_t value)
-{
-	dp->dp_write(dp, addr, value);
-}
-
-static inline uint32_t adiv5_dp_read(ADIv5_DP_t *dp, uint8_t addr)
-{
-	return dp->dp_read(dp, addr);
-}
-
-static inline uint32_t adiv5_dp_error(ADIv5_DP_t *dp)
-{
-	return dp->error(dp);
-}
-
-static inline uint32_t adiv5_dp_low_access(struct ADIv5_DP_s *dp, uint8_t APnDP, 
-					uint8_t RnW, uint8_t addr, uint32_t value)
-{
-	return dp->low_access(dp, APnDP, RnW, addr, value);
-}
-
-extern ADIv5_DP_t *adiv5_dp_list;
-
-typedef struct ADIv5_AP_s {
-	ADIv5_DP_t *dp;
-	uint8_t apsel;
-
-	uint32_t idr;
-	uint32_t cfg;
-	uint32_t base;
-} ADIv5_AP_t;
-
-struct target_ap_s {
-	target t;
-	ADIv5_AP_t *ap;
-};
-
-extern ADIv5_AP_t adiv5_aps[5];
-extern int adiv5_ap_count;
-
-void adiv5_free_all(void);
-void adiv5_dp_init(ADIv5_DP_t *dp);
-
-void adiv5_dp_write_ap(ADIv5_DP_t *dp, uint8_t addr, uint32_t value);
-uint32_t adiv5_dp_read_ap(ADIv5_DP_t *dp, uint8_t addr);
-
-uint32_t adiv5_ap_mem_read(ADIv5_AP_t *ap, uint32_t addr);
-void adiv5_ap_mem_write(ADIv5_AP_t *ap, uint32_t addr, uint32_t value);
-
-void adiv5_ap_write(ADIv5_AP_t *ap, uint8_t addr, uint32_t value);
-uint32_t adiv5_ap_read(ADIv5_AP_t *ap, uint8_t addr);
-
-void adiv5_jtag_dp_handler(jtag_dev_t *dev);
-int adiv5_swdp_scan(void);
-
-#endif
-

src/include/command.h

@@ -21,17 +21,19 @@
 #ifndef __COMMAND_H
 #define __COMMAND_H
 
-#include "general.h"
+#include <stdbool.h>
 
-int command_process(char *cmd);
+#include "target.h"
-typedef void (*cmd_handler)(int argc, const char **argv);
 
-struct command_s {
+int command_process(target *t, char *cmd);
-	const char *cmd;
-	cmd_handler handler;
 
-	const char *help;
+/*
-};
+ * 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

@@ -18,12 +18,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __CORTEXM3_H
+#ifndef __CRC32_H
-#define __CORTEXM3_H
+#define __CRC32_H
 
-#include "target.h"
+int generic_crc32(target *t, uint32_t *crc, uint32_t base, int len);
-
-int cm3_probe(struct target_s *target);
 
 #endif
-

src/include/exception.h

@@ -0,0 +1,74 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2015  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/>.
+ */
+
+/* Exception handling to escape deep nesting.
+ * Used for the case of communicaiton failure and timeouts.
+ */
+
+/* Example usage:
+ *
+ * volatile struct exception e;
+ * TRY_CATCH (e, EXCEPTION_TIMEOUT) {
+ *    ...
+ *    raise_exception(EXCEPTION_TIMEOUT, "Timeout occurred");
+ *    ...
+ * }
+ * if (e.type == EXCEPTION_TIMEOUT) {
+ *    printf("timeout: %s\n", e.msg);
+ * }
+ */
+
+/* Limitations:
+ * Can't use break, return, goto, etc from inside the TRY_CATCH block.
+ */
+
+#ifndef __EXCEPTION_H
+#define __EXCEPTION_H
+
+#include <setjmp.h>
+#include <stdint.h>
+
+#define EXCEPTION_ERROR   0x01
+#define EXCEPTION_TIMEOUT 0x02
+#define EXCEPTION_ALL     -1
+
+struct exception {
+	uint32_t type;
+	const char *msg;
+	/* private */
+	uint32_t mask;
+	jmp_buf jmpbuf;
+	struct exception *outer;
+};
+
+extern struct exception *innermost_exception;
+
+#define TRY_CATCH(e, type_mask) \
+	(e).type = 0; \
+	(e).mask = (type_mask); \
+	(e).outer = innermost_exception; \
+	innermost_exception = (void*)&(e); \
+	if (setjmp(innermost_exception->jmpbuf) == 0) \
+		for (;innermost_exception == &(e); innermost_exception = (e).outer)
+
+void raise_exception(uint32_t type, const char *msg);
+
+#endif
+

src/include/gdb_if.h

@@ -21,9 +21,16 @@
 #ifndef __GDB_IF_H
 #define __GDB_IF_H
 
+#if PC_HOSTED == 0
+#include <libopencm3/usb/usbd.h>
+void gdb_usb_out_cb(usbd_device *dev, uint8_t ep);
+#endif
+
 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,16 +21,19 @@
 #ifndef __GDB_PACKET_H
 #define __GDB_PACKET_H
 
-#include <string.h>
+#include <stddef.h>
+#include <stdarg.h>
 
-int gdb_getpacket(unsigned char *packet, int size);
+size_t gdb_getpacket(char *packet, size_t size);
-void gdb_putpacket(unsigned char *packet, int 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 unsigned char *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,14 +21,154 @@
 #ifndef __GENERAL_H
 #define __GENERAL_H
 
-#include "platform.h"
+#if !defined(_GNU_SOURCE)
-
+# define _GNU_SOURCE
-#ifndef DEBUG
+#endif
-#include <stdio.h>
+#if !defined(__USE_MINGW_ANSI_STDIO)
-#define DEBUG	printf
+# define __USE_MINGW_ANSI_STDIO 1
 #endif
-
 #include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <inttypes.h>
+#include <sys/types.h>
+
+#include "platform.h"
+#include "platform_support.h"
+
+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/hex_utils.h

@@ -21,9 +21,8 @@
 #ifndef __HEX_UTILS_H
 #define __HEX_UTILS_H
 
-char * hexify(char *hex, const unsigned char *buf, int size);
+char * hexify(char *hex, const void *buf, size_t size);
-
+char * unhexify(void *buf, const char *hex, size_t size);
-char * unhexify(unsigned char *buf, const char *hex, int size);
 
 #endif
 

src/include/jtagtap.h

@@ -21,17 +21,12 @@
 #ifndef __JTAGTAP_H
 #define __JTAGTAP_H
 
-#include "general.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);
-
-void jtagtap_srst(void);
-
-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
@@ -40,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_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_tdo_seq)
-void jtagtap_tdi_seq(const uint8_t final_tms, const uint8_t *DI, int ticks);
+	(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. 
+ * - This is not endian safe: First byte will always be first shifted out.
- * - DO may be NULL to ignore captured data. 
+ * - DO may be NULL to ignore captured data.
- * - DO may be point to the same address as DI. 
+ * - 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/morse.h

@@ -0,0 +1,30 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2015  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/>.
+ */
+
+#ifndef __MORSE_H
+#define __MORSE_H
+
+extern const char *morse_msg;
+
+void morse(const char *msg, char repeat);
+bool morse_update(void);
+
+#endif
+

src/include/platform_support.h

@@ -0,0 +1,54 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2015 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/>.
+ */
+
+#ifndef __PLATFORM_SUPPORT_H
+#define __PLATFORM_SUPPORT_H
+
+#ifndef __GENERAL_H
+#	error "Include 'general.h' instead"
+#endif
+
+#include "target.h"
+
+#if PC_HOSTED == 1
+void platform_init(int argc, char **argv);
+#else
+void platform_init(void);
+#endif
+
+typedef struct platform_timeout platform_timeout;
+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);
+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/queue.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2018 Robert C. Curtis. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ROBERT C. CURTIS ``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 ROBERT C. CURTIS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * official policies, either expressed or implied, of Robert C. Curtis.
+ */
+
+/** @file util/queue.h
+ * Static queue primitives.
+ *
+ * This file contains a set of static queue primitives that are common among
+ * all of the low level queue implementations. The primitives are inline
+ * functions, and will be optimal if size is a constant power of 2.
+ */
+
+#ifndef I__QUEUE_H__
+	#define I__QUEUE_H__
+
+/** Increment a queue index.
+ * @param[in]	idx	Queue index
+ * @param[in]	size	Queue size
+ * @returns	The new queue index value
+ */
+static inline size_t qinc(size_t idx, size_t size)
+{
+	return ((idx + 1) % size);
+}
+
+/** Decrement a queue index.
+ * @param[in]	idx	Queue index
+ * @param[in]	size	Queue size
+ * @returns	The new queue index value
+ */
+static inline size_t qdec(size_t idx, size_t size)
+{
+	return ((idx - 1) % size);
+}
+
+/** Tests if a queue is full.
+ * @param[in]	head	Head index
+ * @param[in]	tail	Tail index
+ * @param[in]	size	Queue size
+ */
+static inline int qfull(size_t head, size_t tail, size_t size)
+{
+	size_t next_head = qinc(head, size);
+	return (next_head == tail);
+}
+
+/** Tests if a queue is empty.
+ * @param[in]	head	Head index
+ * @param[in]	tail	Tail index
+ */
+static inline int qempty(size_t head, size_t tail)
+{
+	return (head == tail);
+}
+
+#endif /* I__QUEUE_H__ */

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

@@ -0,0 +1,26 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2015  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/>.
+ */
+#ifndef __SERIALNO_H
+#define __SERIALNO_H
+
+char *serial_no_read(char *s);
+
+#endif
+

src/include/target.h

@@ -1,7 +1,7 @@
 /*
  * This file is part of the Black Magic Debug project.
  *
- * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Copyright (C) 2016  Black Sphere Technologies Ltd.
  * Written by Gareth McMullin <gareth@blacksphere.co.nz>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -25,153 +25,158 @@
 #ifndef __TARGET_H
 #define __TARGET_H
 
-/* Halt/resume functions */
+#include <stdarg.h>
-#define target_attach(target)	\
+#include <stdbool.h>
-	(target)->attach(target)
+#include <stdint.h>
+#include <sys/types.h>
 
-#define target_detach(target)	\
+typedef struct target_s target;
-	(target)->detach(target)
+typedef uint32_t target_addr;
+struct target_controller;
 
-#define target_check_error(target)	\
+#if PC_HOSTED == 1
-	(target)->check_error(target)
+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);
 
+int target_foreach(void (*cb)(int i, target *t, void *context), void *context);
+void target_list_free(void);
+
+/* Attach/detach functions */
+target *target_attach(target *t, struct target_controller *);
+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 */
-#define target_mem_read_words(target, dest, src, len)	\
+bool target_mem_map(target *t, char *buf, size_t len);
-	(target)->mem_read_words((target), (dest), (src), (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);
-#define target_mem_write_words(target, dest, src, len)	\
+/* Flash memory access functions */
-	(target)->mem_write_words((target), (dest), (src), (len))
+int target_flash_erase(target *t, target_addr addr, size_t len);
-
+int target_flash_write(target *t, target_addr dest, const void *src, size_t len);
-#define target_mem_read_bytes(target, dest, src, len)	\
+int target_flash_done(target *t);
-	(target)->mem_read_bytes((target), (dest), (src), (len))
-
-#define target_mem_write_bytes(target, dest, src, len)	\
-	(target)->mem_write_bytes((target), (dest), (src), (len))
-
 
 /* Register access functions */
-#define target_regs_read(target, data)	\
+size_t target_regs_size(target *t);
-	(target)->regs_read((target), (data))
+const char *target_tdesc(target *t);
-
+void target_regs_read(target *t, void *data);
-#define target_regs_write(target, data)	\
+void target_regs_write(target *t, const void *data);
-	(target)->regs_write((target), (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);
-#define target_pc_read(target)	\
-	(target)->pc_read((target))
-
-#define target_pc_write(target, val)	\
-	(target)->pc_write((target), (val))
-
 
 /* Halt/resume functions */
-#define target_reset(target)	\
+enum target_halt_reason {
-	(target)->reset(target)
+	TARGET_HALT_RUNNING = 0, /* Target not halted */
+	TARGET_HALT_ERROR,       /* Failed to read target status */
+	TARGET_HALT_REQUEST,
+	TARGET_HALT_STEPPING,
+	TARGET_HALT_BREAKPOINT,
+	TARGET_HALT_WATCHPOINT,
+	TARGET_HALT_FAULT,
+};
 
-#define target_halt_request(target)	\
+void target_reset(target *t);
-	(target)->halt_request(target)
+void target_halt_request(target *t);
-
+enum target_halt_reason target_halt_poll(target *t, target_addr *watch);
-#define target_halt_wait(target)	\
+void target_halt_resume(target *t, bool step);
-	(target)->halt_wait(target)
+void target_set_cmdline(target *t, char *cmdline);
-
+void target_set_heapinfo(target *t, target_addr heap_base, target_addr heap_limit,
-#define target_halt_resume(target, step)	\
+	target_addr stack_base, target_addr stack_limit);
-	(target)->halt_resume((target), (step))
-
-#define target_fault_unwind(target)	\
-	((target)->fault_unwind?(target)->fault_unwind((target)):0)
 
 /* Break-/watchpoint functions */
-#define target_set_hw_bp(target, addr)	\
+enum target_breakwatch {
-	(target)->set_hw_bp((target), (addr))
+	TARGET_BREAK_SOFT,
+	TARGET_BREAK_HARD,
+	TARGET_WATCH_WRITE,
+	TARGET_WATCH_READ,
+	TARGET_WATCH_ACCESS,
+};
+int target_breakwatch_set(target *t, enum target_breakwatch, target_addr, size_t);
+int target_breakwatch_clear(target *t, enum target_breakwatch, target_addr, size_t);
 
-#define target_clear_hw_bp(target, addr)	\
+/* Command interpreter */
-	(target)->clear_hw_bp((target), (addr))
+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,
+	TARGET_EBUSY = 16,
+	TARGET_EEXIST = 17,
+	TARGET_ENODEV = 19,
+	TARGET_ENOTDIR = 20,
+	TARGET_EISDIR = 21,
+	TARGET_EINVAL = 22,
+	TARGET_ENFILE = 23,
+	TARGET_EMFILE = 24,
+	TARGET_EFBIG = 27,
+	TARGET_ENOSPC = 28,
+	TARGET_ESPIPE = 29,
+	TARGET_EROFS = 30,
+	TARGET_ENOSYS = 88,
+	TARGET_ENAMETOOLONG = 91,
+	TARGET_EUNKNOWN = 9999,
+};
 
-#define target_set_hw_wp(target, type, addr, len)	\
+enum target_open_flags {
-	(target)->set_hw_wp((target), (type), (addr), (len))
+	TARGET_O_RDONLY = 0,
+	TARGET_O_WRONLY = 1,
+	TARGET_O_RDWR = 2,
+	TARGET_O_APPEND = 0x008,
+	TARGET_O_CREAT = 0x200,
+	TARGET_O_TRUNC = 0x400,
+};
 
-#define target_clear_hw_wp(target, type, addr, len)	\
+enum target_seek_flag {
-	(target)->clear_hw_wp((target), (type), (addr), (len))
+	TARGET_SEEK_SET = 0,
+	TARGET_SEEK_CUR = 1,
+	TARGET_SEEK_END = 2,
+};
 
+struct target_controller {
+	void (*destroy_callback)(struct target_controller *, target *t);
+	void (*printf)(struct target_controller *, const char *fmt, va_list);
 
-#define target_check_hw_wp(target, addr)	\
+	/* Interface to host system calls */
-	((target)->check_hw_wp?(target)->check_hw_wp((target), (addr)):0)
+	int (*open)(struct target_controller *,
-
+	            target_addr path, size_t path_len,
-
+	            enum target_open_flags flags, mode_t mode);
-/* Flash memory access functions */
+	int (*close)(struct target_controller *, int fd);
-#define target_flash_erase(target, addr, len)	\
+	int (*read)(struct target_controller *,
-	(target)->flash_erase((target), (addr), (len))
+	            int fd, target_addr buf, unsigned int count);
-
+	int (*write)(struct target_controller *,
-#define target_flash_write_words(target, dest, src, len)	\
+	             int fd, target_addr buf, unsigned int count);
-	(target)->flash_write_words((target), (dest), (src), (len))
+	long (*lseek)(struct target_controller *,
-
+	              int fd, long offset, enum target_seek_flag flag);
-
+	int (*rename)(struct target_controller *,
-#define TARGET_LIST_FREE() {				\
+	              target_addr oldpath, size_t old_len,
-	while(target_list) {				\
+	              target_addr newpath, size_t new_len);
-		target *t = target_list->next;		\
+	int (*unlink)(struct target_controller *,
-		free(target_list);			\
+	              target_addr path, size_t path_len);
-		target_list = t;			\
+	int (*stat)(struct target_controller *,
-	}						\
+	            target_addr path, size_t path_len, target_addr buf);
-	last_target = cur_target = NULL;		\
+	int (*fstat)(struct target_controller *, int fd, target_addr buf);
-}
+	int (*gettimeofday)(struct target_controller *,
-
+	                    target_addr tv, target_addr tz);
-
+	int (*isatty)(struct target_controller *, int fd);
-typedef struct target_s {
+	int (*system)(struct target_controller *,
-	/* Attach/Detach funcitons */
+	              target_addr cmd, size_t cmd_len);
-	void (*attach)(struct target_s *target);
+	enum target_errno errno_;
-	void (*detach)(struct target_s *target);
+	bool interrupted;
-	int (*check_error)(struct target_s *target);
+};
-
-	/* Memory access functions */
-	int (*mem_read_words)(struct target_s *target, uint32_t *dest, uint32_t src, 
-				int len);
-	int (*mem_write_words)(struct target_s *target, uint32_t dest, 
-				const uint32_t *src, int len);
-
-	int (*mem_read_bytes)(struct target_s *target, uint8_t *dest, uint32_t src, 
-				int len);
-	int (*mem_write_bytes)(struct target_s *target, uint32_t dest, 
-				const uint8_t *src, int len);
-
-	/* Register access functions */
-	int regs_size;
-	const char *tdesc;
-	int (*regs_read)(struct target_s *target, void *data);
-	int (*regs_write)(struct target_s *target, const void *data);
-
-	uint32_t (*pc_read)(struct target_s *target);
-	int (*pc_write)(struct target_s *target, const uint32_t val);
-
-	/* Halt/resume functions */
-	void (*reset)(struct target_s *target);
-	void (*halt_request)(struct target_s *target);
-	int (*halt_wait)(struct target_s *target);
-	void (*halt_resume)(struct target_s *target, uint8_t step);
-	int (*fault_unwind)(struct target_s *target);
-
-	/* Break-/watchpoint functions */
-	int (*set_hw_bp)(struct target_s *target, uint32_t addr);
-	int (*clear_hw_bp)(struct target_s *target, uint32_t addr);
-
-	int (*set_hw_wp)(struct target_s *target, uint8_t type, uint32_t addr, uint8_t len);
-	int (*clear_hw_wp)(struct target_s *target, uint8_t type, uint32_t addr, uint8_t len);
-
-	int (*check_hw_wp)(struct target_s *target, uint32_t *addr);
-
-	/* Flash memory access functions */
-	const char *xml_mem_map;
-	int (*flash_erase)(struct target_s *target, uint32_t addr, int len);
-	int (*flash_write_words)(struct target_s *target, uint32_t dest, 
-				const uint32_t *src, int len);
-
-	const char *driver;
-
-	int size;
-	struct target_s *next;
-} target;
-
-extern target *target_list, *cur_target, *last_target;
 
 #endif
 

src/include/timing.h

@@ -0,0 +1,30 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2016  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/>.
+ */
+#ifndef __TIMING_H
+#define __TIMING_H
+
+struct platform_timeout {
+	uint32_t time;
+};
+
+extern int32_t swj_delay_cnt;
+uint32_t platform_time_ms(void);
+
+#endif /* __TIMING_H */

src/jtag_scan.c

@@ -1,238 +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 JTAG protocol support.  Provides functionality
- * to detect devices on the scan chain and read their IDCODEs.
- * It depends on the low-level function provided by the platform's jtagtap.c.  
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <assert.h>
-
-#include "general.h"
-#include "jtagtap.h"
-#include "jtag_scan.h"
-
-#include "gdb_packet.h"
-
-#include "adiv5.h"
-#include "arm7tdmi.h"
-
-struct jtag_dev_s jtag_devs[JTAG_MAX_DEVS+1];
-int jtag_dev_count;
-
-static struct jtag_dev_descr_s {
-	uint32_t idcode;
-	uint32_t idmask;
-	char *descr;
-	void (*handler)(jtag_dev_t *dev);
-} dev_descr[] = {
-	{.idcode = 0x0BA00477, .idmask = 0x0FFFFFFF, 
-		.descr = "ARM Limited: ADIv5 JTAG-DP port.", 
-		.handler = adiv5_jtag_dp_handler},
-	{.idcode = 0x3F0F0F0F, .idmask = 0xFFFFFFFF, 
-		.descr = "ST Microelectronics: STR730", 
-		.handler = arm7tdmi_jtag_handler},
-	{.idcode = 0x06410041, .idmask = 0x0FFFFFFF, 
-		.descr = "ST Microelectronics: STM32, Medium density."},
-	{.idcode = 0x06412041, .idmask = 0x0FFFFFFF, 
-		.descr = "ST Microelectronics: STM32, Low density."},
-	{.idcode = 0x06414041, .idmask = 0x0FFFFFFF, 
-		.descr = "ST Microelectronics: STM32, High density."},
-	{.idcode = 0x06418041, .idmask = 0x0FFFFFFF, 
-		.descr = "ST Microelectronics: STM32, Connectivity Line."},
-	{.idcode = 0x06420041, .idmask = 0x0FFFFFFF, 
-		.descr = "ST Microelectronics: STM32, Value Line."},
-	{.idcode = 0x06428041, .idmask = 0x0FFFFFFF, 
-		.descr = "ST Microelectronics: STM32, Value Line, High density."},
-	{.idcode = 0x06411041, .idmask = 0xFFFFFFFF, 
-		.descr = "ST Microelectronics: STM32F2xx."},
-	{.idcode = 0x06413041 , .idmask = 0xFFFFFFFF, 
-		.descr = "ST Microelectronics: STM32F4xx."},
-/* Just for fun, unsupported */
-	{.idcode = 0x8940303F, .idmask = 0xFFFFFFFF, .descr = "ATMEL: ATMega16."},
-	{.idcode = 0x0792603F, .idmask = 0xFFFFFFFF, .descr = "ATMEL: AT91SAM9261."},
-	{.idcode = 0x20270013, .idmask = 0xFFFFFFFF, .descr = "Intel: i80386ex."},
-	{.idcode = 0, .idmask = 0, .descr = "Unknown"},
-};
-
-/* bucket of ones for don't care TDI */
-static const char ones[] = "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF";
-
-/* Scan JTAG chain for devices, store IR length and IDCODE (if present).
- * Reset TAP state machine.
- * Select Shift-IR state.
- * Each device is assumed to shift out IR at 0x01. (this may not always be true)
- * Shift in ones until we read two consecutive ones, then we have shifted out the
- * 	IRs of all devices.
- *
- * After this process all the IRs are loaded with the BYPASS command.
- * Select Shift-DR state.
- * Shift in ones and count zeros shifted out. Should be one for each device.
- * Check this against device count obtained by IR scan above.
- *
- * Reset the TAP state machine again. This should load all IRs with IDCODE.
- * For each device, shift out one bit. If this is zero IDCODE isn't present,
- *	continue to next device. If this is one shift out the remaining 31 bits
- *	of the IDCODE register.
- */
-int jtag_scan(void)
-{
-	int i;
-	uint32_t j;
-
-	TARGET_LIST_FREE();
-
-	jtag_dev_count = 0;
-	memset(&jtag_devs, 0, sizeof(jtag_devs));
-
-#warning "These should be elsewhere!"
-	adiv5_free_all();
-
-	/* Run throught the SWD to JTAG sequence for the case where an attached SWJ-DP is
-	 * in SW-DP mode.
-	 */
-	DEBUG("Resetting TAP\n");
-	jtagtap_init();
-	jtagtap_reset();
-
-	DEBUG("Change state to Shift-IR\n");
-	jtagtap_shift_ir();
-
-	DEBUG("Scanning out IRs\n");
-	if(!jtagtap_next(0, 1)) {
-		DEBUG("jtag_scan: Sanity check failed: IR[0] shifted out as 0\n");
-		jtag_dev_count = -1;
-		return -1; /* must be 1 */
-	}
-	jtag_devs[0].ir_len = 1; j = 1;
-	while((jtag_dev_count <= JTAG_MAX_DEVS) && 
-	      (jtag_devs[jtag_dev_count].ir_len <= JTAG_MAX_IR_LEN)) {
-		if(jtagtap_next(0, 1)) {
-			if(jtag_devs[jtag_dev_count].ir_len == 1) break;
-			jtag_devs[++jtag_dev_count].ir_len = 1;
-			jtag_devs[jtag_dev_count].ir_prescan = j;
-			jtag_devs[jtag_dev_count].dev = jtag_dev_count;
-		} else jtag_devs[jtag_dev_count].ir_len++;
-		j++;
-	}
-	if(jtag_dev_count > JTAG_MAX_DEVS) {
-		DEBUG("jtag_scan: Maximum device count exceeded\n");
-		jtag_dev_count = -1;
-		return -1;
-	}
-	if(jtag_devs[jtag_dev_count].ir_len > JTAG_MAX_IR_LEN) {
-		DEBUG("jtag_scan: Maximum IR length exceeded\n");
-		jtag_dev_count = -1;
-		return -1;
-	}
-	
-	DEBUG("Return to Run-Test/Idle\n");
-	jtagtap_next(1, 1);
-	jtagtap_return_idle();
-
-	/* All devices should be in BYPASS now */
-
-	/* Count device on chain */
-	DEBUG("Change state to Shift-DR\n");
-	jtagtap_shift_dr();
-	for(i = 0; (jtagtap_next(0, 1) == 0) && (i <= jtag_dev_count); i++)
-		jtag_devs[i].dr_postscan = jtag_dev_count - i - 1;
-
-	if(i != jtag_dev_count) {
-		DEBUG("jtag_scan: Sanity check failed: "
-			"BYPASS dev count doesn't match IR scan\n");
-		jtag_dev_count = -1;
-		return -1;
-	}
-
-	DEBUG("Return to Run-Test/Idle\n");
-	jtagtap_next(1, 1);
-	jtagtap_return_idle();
-	if(!jtag_dev_count) {
-		morse("NO TARGETS.", 1);
-		return 0;
-	}
-
-	/* Fill in the ir_postscan fields */
-	for(i = jtag_dev_count - 1; i; i--) 
-		jtag_devs[i-1].ir_postscan = jtag_devs[i].ir_postscan + 
-					jtag_devs[i].ir_len;
-
-	/* Reset jtagtap: should take all devs to IDCODE */
-	jtagtap_reset();
-	jtagtap_shift_dr();
-	for(i = 0; i < jtag_dev_count; i++) {
-		if(!jtagtap_next(0, 1)) continue;
-		jtag_devs[i].idcode = 1;
-		for(j = 2; j; j <<= 1) 
-			if(jtagtap_next(0, 1)) jtag_devs[i].idcode |= j;
-		
-	}
-	DEBUG("Return to Run-Test/Idle\n");
-	jtagtap_next(1, 1);
-	jtagtap_return_idle();
-
-	/* Check for known devices and handle accordingly */
-	for(i = 0; i < jtag_dev_count; i++) 
-		for(j = 0; dev_descr[j].idcode; j++) 	
-			if((jtag_devs[i].idcode & dev_descr[j].idmask) == 
-			   dev_descr[j].idcode) {
-				jtag_devs[i].current_ir = -1;
-				/* Save description in table */
-				jtag_devs[i].descr = dev_descr[j].descr;
-				/* Call handler to initialise/probe device further */
-				if(dev_descr[j].handler) 
-					dev_descr[j].handler(&jtag_devs[i]);
-				break;
-			}
-	
-	if(!target_list) morse("NO TARGETS.", 1);
-	else morse(NULL, 0);
-
-	return jtag_dev_count;
-}
-
-void jtag_dev_write_ir(jtag_dev_t *d, uint32_t ir)
-{
-	if(ir == d->current_ir) return;
-	d->current_ir = ir;
-
-	jtagtap_shift_ir();
-	jtagtap_tdi_seq(0, ones, d->ir_prescan);
-	jtagtap_tdi_seq(d->ir_postscan?0:1, (void*)&ir, d->ir_len);
-	jtagtap_tdi_seq(1, ones, d->ir_postscan);
-	jtagtap_return_idle();
-}
-
-void jtag_dev_shift_dr(jtag_dev_t *d, uint8_t *dout, const uint8_t *din, int ticks)
-{
-	jtagtap_shift_dr();
-	jtagtap_tdi_seq(0, ones, d->dr_prescan);
-	if(dout)
-		jtagtap_tdi_tdo_seq((void*)dout, d->dr_postscan?0:1, (void*)din, ticks);
-	else
-		jtagtap_tdi_seq(d->dr_postscan?0:1, (void*)din, ticks);
-	jtagtap_tdi_seq(1, ones, d->dr_postscan);
-	jtagtap_return_idle();
-}
-

src/linux/Makefile.inc

@@ -1 +0,0 @@
-LDFLAGS += -lftdi -lusb

src/linux/gdb_if.c

@@ -1,114 +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 <sys/select.h>
-#else
-#   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, &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, &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)
-{
-	if(gdb_if_conn > 0) 
-		send(gdb_if_conn, &c, 1, 0);
-}
-

src/linux/jtagtap.c

@@ -1,221 +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)
-{
-	int err;
-
-	assert(ftdic != NULL);
-
-	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, "\x86\x00\x00\x80\xA8\xAB", 6) == 6);
-
-	/* 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();
-}
-
-void jtagtap_srst(void)
-{
-	platform_buffer_flush();
-	//ftdi_write_data(ftdic, "\x80\x88\xAB", 3);
-	//usleep(1000);
-	//ftdi_write_data(ftdic, "\x80\xA8\xAB", 3);
-}
-
-#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)
-{
-	char *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 dTDO)
-{
-	uint8_t ret;
-	uint8_t tmp[3] = "\x6B\x00\x00";
-	tmp[2] = (dTDO?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, TDO = %d) = %02X\n", dTMS, dTDO, ret);
-
-	return ret;
-}
-

src/linux/platform.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/>.
- */
-#include "platform.h"
-#include "gdb_if.h"
-#include "jtag_scan.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-struct ftdi_context *ftdic;
-
-#define BUF_SIZE 4096
-static uint8_t outbuf[BUF_SIZE];
-static uint16_t bufptr = 0;
-
-int platform_init(void) 
-{ 
-	int err;
-
-	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, INTERFACE_A)) != 0) {
-		fprintf(stderr, "ftdi_set_interface: %d: %s\n", 
-			err, ftdi_get_error_string(ftdic));
-		abort();
-	}
-	if((err = ftdi_usb_open(ftdic, FT2232_VID, FT2232_PID)) != 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();
-	}
-
-	assert(gdb_if_init() == 0);
-
-	jtag_scan();
-	
-	return 0; 
-}
-
-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
-

src/linux/swdptap.c

@@ -1,172 +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 "platform.h"
-#include "swdptap.h"
-
-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, "\xAB\xA8", 2) == 2);
-
-	/* This must be investigated in more detail.
-	 * As described in STM32 Reference Manual... */
-	swdptap_seq_out(0xFFFF, 16); 
-	swdptap_reset();
-	swdptap_seq_out(0xE79E, 16); /* 0b0111100111100111 */ 
-	swdptap_reset();
-	swdptap_seq_out(0, 16); 
-
-	return 0;
-}
-
-void swdptap_reset(void)
-{
-        swdptap_turnaround(0);
-        /* 50 clocks with TMS high */
-        for(int i = 0; i < 50; i++) swdptap_bit_out(1);
-}
-
-void swdptap_turnaround(uint8_t dir)
-{
-	static uint8_t olddir = 0;
-
-        //DEBUG("%s", dir ? "\n-> ":"\n<- ");
-	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, "\xAB\xA8", 2);
-
-	if(!dir) /* SWDIO goes to output */
-		assert(ftdi_set_bitmode(ftdic, 0xAB, BITMODE_BITBANG) == 0);
-}
-
-uint8_t swdptap_bit_in(void) 
-{
-	uint8_t ret;
-
-	//ftdi_read_data(ftdic, &ret, 1);
-	ftdi_read_pins(ftdic, &ret);
-	ret &= 0x08;
-	ftdi_write_data(ftdic, "\xA1\xA0", 2);
-
-	//DEBUG("%d", ret?1:0);
-
-	return ret;
-}
-
-void swdptap_bit_out(uint8_t val)
-{
-	uint8_t buf[3] = "\xA0\xA1\xA0";
-
-	//DEBUG("%d", val);
-
-	if(val) {
-		for(int i = 0; i < 3; i++)
-			buf[i] |= 0x08;
-	}
-	//ftdi_write_data(ftdic, buf, 3);
-	platform_buffer_write(buf, 3);
-}
-
-uint32_t swdptap_seq_in(int ticks)
-{
-	uint32_t index = 1;
-	uint32_t ret = 0;
-
-	swdptap_turnaround(1);
-
-	while (ticks--) {
-		if (swdptap_bit_in())
-			ret |= index;
-		index <<= 1;
-	}
-
-	return ret;
-}
-
-uint8_t swdptap_seq_in_parity(uint32_t *ret, int ticks)
-{
-	uint32_t index = 1;
-	uint8_t parity = 0;
-	*ret = 0;
-
-	swdptap_turnaround(1);
-
-	while (ticks--) {
-		if (swdptap_bit_in()) {
-			*ret |= index;
-			parity ^= 1;
-		}
-		index <<= 1;
-	}
-	if (swdptap_bit_in())
-		parity ^= 1;
-
-	return parity;
-}
-
-void swdptap_seq_out(uint32_t MS, int ticks)
-{
-	swdptap_turnaround(0);
-
-	while (ticks--) {
-		swdptap_bit_out(MS & 1);
-		MS >>= 1;
-	}
-}
-
-void swdptap_seq_out_parity(uint32_t MS, int ticks)
-{
-	uint8_t parity = 0;
-
-	swdptap_turnaround(0);
-
-	while (ticks--) {
-		swdptap_bit_out(MS & 1);
-		parity ^= MS;
-		MS >>= 1;
-	}
-	swdptap_bit_out(parity & 1);
-}
-

src/lmi.c

@@ -1,153 +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 TI/LMI LM3S target specific functions providing 
- * the XML memory map and Flash memory programming.
- *
- * Issues:
- * No detection of the target device.
- * Add reference to documentation.
- * Flash erase is very slow.
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "general.h"
-#include "adiv5.h"
-#include "target.h"
-
-static int lmi_flash_erase(struct target_s *target, uint32_t addr, int len);
-static int lmi_flash_write_words(struct target_s *target, uint32_t dest, 
-			  const uint32_t *src, int len);
-
-static const char lmi_driver_str[] = "LuminaryMicro Stellaris";
-
-static const char lmi_xml_memory_map[] = "<?xml version=\"1.0\"?>"
-/*	"<!DOCTYPE memory-map "
-	"             PUBLIC \"+//IDN gnu.org//DTD GDB Memory Map V1.0//EN\""
-	"                    \"http://sourceware.org/gdb/gdb-memory-map.dtd\">"*/
-	"<memory-map>"
-	"  <memory type=\"flash\" start=\"0\" length=\"0x20000\">"
-	"    <property name=\"blocksize\">0x400</property>"
-	"  </memory>"
-	"  <memory type=\"ram\" start=\"0x20000000\" length=\"0x10000\"/>"
-	"</memory-map>";
-
-
-uint16_t lmi_flash_write_stub[] = {
-// _start:
-	0x4809,	// ldr r0, [pc, #36] // _flashbase
-	0x490b,	// ldr r1, [pc, #44] // _addr
-	0x467a, // mov r2, pc
-	0x3230, // adds r2, #48
-	0x4b0a, // ldr r3, [pc, #40] // _size
-	0x4d08, // ldr r5, [pc, #32] // _flash_write_cmd
-// _next:
- 	0xb15b, // cbz r3, _done
-	0x6001, // str r1, [r0, #0]
-	0x6814, // ldr r4, [r2]
-	0x6044, // str r4, [r0, #4]
-	0x6085, // str r5, [r0, #8]
-// _wait:
-	0x6884, // ldr r4, [r0, #8]
-	0x2601, // movs r6, #1
-	0x4234, // tst r4, r6
-	0xd1fb, // bne _wait
-
-	0x3b01, // subs r3, #1
-	0x3104, // adds r1, #4
-	0x3204, // adds r2, #4
-	0xe7f2, // b _next
-// _done:
-	0xbe00, // bkpt
-// _flashbase:
- 	0xd000, 0x400f, // .word 0x400fd000
-// _flash_write_cmd:
- 	0x0001, 0xa442, // .word 0xa4420001
-// _addr:
-// 	0x0000, 0x0000,
-// _size:
-// 	0x0000, 0x0000,
-// _data:
-// 	...
-};
-	
-int lmi_probe(struct target_s *target)
-{
-	/* How do we really probe the LMI device??? */
-	target->driver = lmi_driver_str;
-	target->xml_mem_map = lmi_xml_memory_map;
-	target->flash_erase = lmi_flash_erase;
-	target->flash_write_words = lmi_flash_write_words;
-	return 0;
-}
-
-int lmi_flash_erase(struct target_s *target, uint32_t addr, int len)
-{
-	struct target_ap_s *t = (void *)target;
-	uint32_t tmp;
-
-	addr &= 0xFFFFFC00;
-	len &= 0xFFFFFC00;
-
-	/* setup word access */
-	adiv5_ap_write(t->ap, 0x00, 0xA2000052);
-
-	/* select Flash Control */
-	adiv5_dp_low_access(t->ap->dp, 1, 0, 0x04, 0x400FD000);
-
-	while(len) {
-		/* write address to FMA */
-		adiv5_ap_write(t->ap, 0x10, addr); /* Required to switch banks */
-		/* set ERASE bit in FMC */
-		adiv5_dp_low_access(t->ap->dp, 1, 0, 0x08, 0xA4420002);
-		/* Read FMC to poll for ERASE bit */
-		adiv5_dp_low_access(t->ap->dp, 1, 1, 0x08, 0);
-		do {
-			tmp = adiv5_dp_low_access(t->ap->dp, 1, 1, 0x08, 0);
-		} while (tmp & 2);
-
-		len -= 0x400;
-		addr += 0x400;
-	}
-	return 0;
-}
-
-int lmi_flash_write_words(struct target_s *target, uint32_t dest, 
-			  const uint32_t *src, int len)
-{
-	uint32_t data[(len>>2)+2];
-	data[0] = dest;
-	data[1] = len >> 2;
-	memcpy(&data[2], src, len);
-	DEBUG("Sending stub\n");
-	target_mem_write_words(target, 0x20000000, (void*)lmi_flash_write_stub, 0x30);
-	DEBUG("Sending data\n");
-	target_mem_write_words(target, 0x20000030, data, len + 8);
-	DEBUG("Running stub\n");
-	target_pc_write(target, 0x20000000);
-	target_halt_resume(target, 0);
-	DEBUG("Waiting for halt\n");
-	while(!target_halt_wait(target));
-
-	return 0;
-}
-

src/main.c

@@ -18,29 +18,40 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* Provides main entry point.  Initialise subsystems and enter GDB 
+/* Provides main entry point.  Initialise subsystems and enter GDB
  * protocol loop.
  */
 
-#include <stdio.h>
+#include "general.h"
-#include <stdlib.h>
-#include <assert.h>
-
 #include "gdb_if.h"
 #include "gdb_main.h"
-#include "jtagtap.h"
-#include "jtag_scan.h"
-
 #include "target.h"
+#include "exception.h"
+#include "gdb_packet.h"
+#include "morse.h"
 
 int
-main(void)
+main(int argc, char **argv)
 {
-	assert(platform_init() == 0);
+#if PC_HOSTED == 1
+	platform_init(argc, argv);
+#else
+	(void) argc;
+	(void) argv;
+	platform_init();
+#endif
 
-	PLATFORM_SET_FATAL_ERROR_RECOVERY();
+	while (true) {
-
+		volatile struct exception e;
-	gdb_main();
+		TRY_CATCH(e, EXCEPTION_ALL) {
+			gdb_main();
+		}
+		if (e.type) {
+			gdb_putpacketz("EFF");
+			target_list_free();
+			morse("TARGET LOST.", 1);
+		}
+	}
 
 	/* Should never get here */
 	return 0;

src/morse.c

@@ -0,0 +1,106 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2015  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 "morse.h"
+
+/* Morse code patterns and lengths */
+static const struct {
+	uint16_t code;
+	uint8_t bits;
+} morse_letter[] = {
+	{        0b00011101,  8}, // 'A' .-
+	{    0b000101010111, 12}, // 'B' -...
+	{  0b00010111010111, 14}, // 'C' -.-.
+	{      0b0001010111, 10}, // 'D' -..
+	{            0b0001,  4}, // 'E' .
+	{    0b000101110101, 12}, // 'F' ..-.
+	{    0b000101110111, 12}, // 'G' --.
+	{      0b0001010101, 10}, // 'H' ....
+	{          0b000101,  6}, // 'I' ..
+	{0b0001110111011101, 16}, // 'J' .---
+	{    0b000111010111, 12}, // 'K' -.-
+	{    0b000101011101, 12}, // 'L' .-..
+	{      0b0001110111, 10}, // 'M' --
+	{        0b00010111,  8}, // 'N' -.
+	{  0b00011101110111, 14}, // 'O' ---
+	{  0b00010111011101, 14}, // 'P' .--.
+	{0b0001110101110111, 16}, // 'Q' --.-
+	{      0b0001011101, 10}, // 'R' .-.
+	{        0b00010101,  8}, // 'S' ...
+	{          0b000111,  6}, // 'T' -
+	{      0b0001110101, 10}, // 'U' ..-
+	{    0b000111010101, 12}, // 'V' ...-
+	{    0b000111011101, 12}, // 'W' .--
+	{  0b00011101010111, 14}, // 'X' -..-
+	{0b0001110111010111, 16}, // 'Y' -.--
+	{  0b00010101110111, 14}, // 'Z' --..
+};
+
+const char *morse_msg;
+static const char * volatile morse_ptr;
+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)
+{
+	static uint16_t code;
+	static uint8_t bits;
+
+	if (!morse_ptr)
+		return false;
+
+	if (!bits) {
+		char c = *morse_ptr++;
+		if (!c) {
+			if(morse_repeat) {
+				morse_ptr = morse_msg;
+				c = *morse_ptr++;
+			} else {
+				morse_ptr = 0;
+				return false;
+			}
+		}
+		if ((c >= 'A') && (c <= 'Z')) {
+			c -= 'A';
+			code = morse_letter[c].code;
+			bits = morse_letter[c].bits;
+		} else {
+			code = 0; bits = 4;
+		}
+	}
+
+	bool ret = code & 1;
+	code >>= 1;
+	bits--;
+
+	return ret;
+}
+

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

@@ -0,0 +1,591 @@
+/*
+ * 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 the USB Communications Device Class - Abstract
+ * Control Model (CDC-ACM) as defined in CDC PSTN subclass 1.2.
+ * A Device Firmware Upgrade (DFU 1.1) class interface is provided for
+ * 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"
+#include "gdb_if.h"
+#include "cdcacm.h"
+#if defined(PLATFORM_HAS_TRACESWO)
+#	include "traceswo.h"
+#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>
+
+#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;
+
+static int configured;
+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_desc = {
+	.bLength = USB_DT_DEVICE_SIZE,
+	.bDescriptorType = USB_DT_DEVICE,
+	.bcdUSB = 0x0200,
+	.bDeviceClass = 0xEF,		/* Miscellaneous Device */
+	.bDeviceSubClass = 2,		/* Common Class */
+	.bDeviceProtocol = 1,		/* Interface Association */
+#if defined(SAMD21E17) || defined(LM4F)
+	.bMaxPacketSize0 = 64,		/*Fixed for icdi*/
+#else
+	.bMaxPacketSize0 = 32,
+#endif
+	.idVendor = 0x1D50,
+	.idProduct = 0x6018,
+	.bcdDevice = 0x0100,
+	.iManufacturer = 1,
+	.iProduct = 2,
+	.iSerialNumber = 3,
+	.bNumConfigurations = 1,
+};
+
+/* This notification endpoint isn't implemented. According to CDC spec its
+ * optional, but its absence causes a NULL pointer dereference in Linux cdc_acm
+ * driver. */
+static const struct usb_endpoint_descriptor gdb_comm_endp[] = {{
+	.bLength = USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType = USB_DT_ENDPOINT,
+	.bEndpointAddress =  (CDCACM_GDB_ENDPOINT + 1) | USB_REQ_TYPE_IN,
+	.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
+	.wMaxPacketSize = 16,
+	.bInterval = 255,
+}};
+
+static const struct usb_endpoint_descriptor gdb_data_endp[] = {{
+	.bLength = USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType = USB_DT_ENDPOINT,
+	.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 = CDCACM_GDB_ENDPOINT | USB_REQ_TYPE_IN,
+	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
+	.wMaxPacketSize = CDCACM_PACKET_SIZE,
+	.bInterval = 1,
+}};
+
+static const struct {
+	struct usb_cdc_header_descriptor header;
+	struct usb_cdc_call_management_descriptor call_mgmt;
+	struct usb_cdc_acm_descriptor acm;
+	struct usb_cdc_union_descriptor cdc_union;
+} __attribute__((packed)) gdb_cdcacm_functional_descriptors = {
+	.header = {
+		.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
+		.bcdCDC = 0x0110,
+	},
+	.call_mgmt = {
+		.bFunctionLength =
+			sizeof(struct usb_cdc_call_management_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
+		.bmCapabilities = 0,
+		.bDataInterface = GDB_IF_NO + 1,
+	},
+	.acm = {
+		.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_ACM,
+		.bmCapabilities = 2, /* SET_LINE_CODING supported */
+	},
+	.cdc_union = {
+		.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_UNION,
+		.bControlInterface = GDB_IF_NO,
+		.bSubordinateInterface0 = GDB_IF_NO + 1,
+	 }
+};
+
+static const struct usb_interface_descriptor gdb_comm_iface[] = {{
+	.bLength = USB_DT_INTERFACE_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE,
+	.bInterfaceNumber = 0,
+	.bAlternateSetting = 0,
+	.bNumEndpoints = 1,
+	.bInterfaceClass = USB_CLASS_CDC,
+	.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
+	.bInterfaceProtocol = USB_CDC_PROTOCOL_NONE,
+	.iInterface = 4,
+
+	.endpoint = gdb_comm_endp,
+
+	.extra = &gdb_cdcacm_functional_descriptors,
+	.extralen = sizeof(gdb_cdcacm_functional_descriptors)
+}};
+
+static const struct usb_interface_descriptor gdb_data_iface[] = {{
+	.bLength = USB_DT_INTERFACE_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE,
+	.bInterfaceNumber = GDB_IF_NO + 1,
+	.bAlternateSetting = 0,
+	.bNumEndpoints = 2,
+	.bInterfaceClass = USB_CLASS_DATA,
+	.bInterfaceSubClass = 0,
+	.bInterfaceProtocol = 0,
+	.iInterface = 0,
+
+	.endpoint = gdb_data_endp,
+}};
+
+static const struct usb_iface_assoc_descriptor gdb_assoc = {
+	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
+	.bFirstInterface = GDB_IF_NO,
+	.bInterfaceCount = 2,
+	.bFunctionClass = USB_CLASS_CDC,
+	.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
+	.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 = (CDCACM_UART_ENDPOINT + 1) | USB_REQ_TYPE_IN,
+	.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,
+	.wMaxPacketSize = 16,
+	.bInterval = 255,
+}};
+
+static const struct usb_endpoint_descriptor uart_data_endp[] = {{
+	.bLength = USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType = USB_DT_ENDPOINT,
+	.bEndpointAddress = CDCACM_UART_ENDPOINT,
+	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
+	.wMaxPacketSize = CDCACM_PACKET_SIZE / 2,
+	.bInterval = 1,
+}, {
+	.bLength = USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType = USB_DT_ENDPOINT,
+	.bEndpointAddress = CDCACM_UART_ENDPOINT | USB_REQ_TYPE_IN,
+	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
+	.wMaxPacketSize = CDCACM_PACKET_SIZE,
+	.bInterval = 1,
+}};
+
+static const struct {
+	struct usb_cdc_header_descriptor header;
+	struct usb_cdc_call_management_descriptor call_mgmt;
+	struct usb_cdc_acm_descriptor acm;
+	struct usb_cdc_union_descriptor cdc_union;
+} __attribute__((packed)) uart_cdcacm_functional_descriptors = {
+	.header = {
+		.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
+		.bcdCDC = 0x0110,
+	},
+	.call_mgmt = {
+		.bFunctionLength =
+			sizeof(struct usb_cdc_call_management_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
+		.bmCapabilities = 0,
+		.bDataInterface = UART_IF_NO + 1,
+	},
+	.acm = {
+		.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_ACM,
+		.bmCapabilities = 2, /* SET_LINE_CODING supported*/
+	},
+	.cdc_union = {
+		.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
+		.bDescriptorType = CS_INTERFACE,
+		.bDescriptorSubtype = USB_CDC_TYPE_UNION,
+		.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 = UART_IF_NO,
+	.bAlternateSetting = 0,
+	.bNumEndpoints = 1,
+	.bInterfaceClass = USB_CLASS_CDC,
+	.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
+	.bInterfaceProtocol = USB_CDC_PROTOCOL_NONE,
+	.iInterface = 5,
+
+	.endpoint = uart_comm_endp,
+
+	.extra = &uart_cdcacm_functional_descriptors,
+	.extralen = sizeof(uart_cdcacm_functional_descriptors)
+}};
+
+static const struct usb_interface_descriptor uart_data_iface[] = {{
+	.bLength = USB_DT_INTERFACE_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE,
+	.bInterfaceNumber = UART_IF_NO + 1,
+	.bAlternateSetting = 0,
+	.bNumEndpoints = 2,
+	.bInterfaceClass = USB_CLASS_DATA,
+	.bInterfaceSubClass = 0,
+	.bInterfaceProtocol = 0,
+	.iInterface = 0,
+
+	.endpoint = uart_data_endp,
+}};
+
+static const struct usb_iface_assoc_descriptor uart_assoc = {
+	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
+	.bFirstInterface = UART_IF_NO,
+	.bInterfaceCount = 2,
+	.bFunctionClass = USB_CLASS_CDC,
+	.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
+	.bFunctionProtocol = USB_CDC_PROTOCOL_NONE,
+	.iFunction = 5,
+};
+
+const struct usb_dfu_descriptor dfu_function = {
+	.bLength = sizeof(struct usb_dfu_descriptor),
+	.bDescriptorType = DFU_FUNCTIONAL,
+	.bmAttributes = USB_DFU_CAN_DOWNLOAD | USB_DFU_WILL_DETACH,
+	.wDetachTimeout = 255,
+	.wTransferSize = 1024,
+	.bcdDFUVersion = 0x011A,
+};
+
+const struct usb_interface_descriptor dfu_iface = {
+	.bLength = USB_DT_INTERFACE_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE,
+	.bInterfaceNumber = DFU_IF_NO,
+	.bAlternateSetting = 0,
+	.bNumEndpoints = 0,
+	.bInterfaceClass = 0xFE,
+	.bInterfaceSubClass = 1,
+	.bInterfaceProtocol = 1,
+	.iInterface = 6,
+
+	.extra = &dfu_function,
+	.extralen = sizeof(dfu_function),
+};
+
+static const struct usb_iface_assoc_descriptor dfu_assoc = {
+	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
+	.bFirstInterface = DFU_IF_NO,
+	.bInterfaceCount = 1,
+	.bFunctionClass = 0xFE,
+	.bFunctionSubClass = 1,
+	.bFunctionProtocol = 1,
+	.iFunction = 6,
+};
+
+#if defined(PLATFORM_HAS_TRACESWO)
+static const struct usb_endpoint_descriptor trace_endp[] = {{
+	.bLength = USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType = USB_DT_ENDPOINT,
+	.bEndpointAddress = TRACE_ENDPOINT | USB_REQ_TYPE_IN,
+	.bmAttributes = USB_ENDPOINT_ATTR_BULK,
+	.wMaxPacketSize = 64,
+	.bInterval = 0,
+}};
+
+const struct usb_interface_descriptor trace_iface = {
+	.bLength = USB_DT_INTERFACE_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE,
+	.bInterfaceNumber = TRACE_IF_NO,
+	.bAlternateSetting = 0,
+	.bNumEndpoints = 1,
+	.bInterfaceClass = 0xFF,
+	.bInterfaceSubClass = 0xFF,
+	.bInterfaceProtocol = 0xFF,
+	.iInterface = 7,
+
+	.endpoint = trace_endp,
+};
+
+static const struct usb_iface_assoc_descriptor trace_assoc = {
+	.bLength = USB_DT_INTERFACE_ASSOCIATION_SIZE,
+	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
+	.bFirstInterface = TRACE_IF_NO,
+	.bInterfaceCount = 1,
+	.bFunctionClass = 0xFF,
+	.bFunctionSubClass = 0xFF,
+	.bFunctionProtocol = 0xFF,
+	.iFunction = 7,
+};
+#endif
+
+static const struct usb_interface ifaces[] = {{
+	.num_altsetting = 1,
+	.iface_assoc = &gdb_assoc,
+	.altsetting = gdb_comm_iface,
+}, {
+	.num_altsetting = 1,
+	.altsetting = gdb_data_iface,
+}, {
+	.num_altsetting = 1,
+	.iface_assoc = &uart_assoc,
+	.altsetting = uart_comm_iface,
+}, {
+	.num_altsetting = 1,
+	.altsetting = uart_data_iface,
+}, {
+	.num_altsetting = 1,
+	.iface_assoc = &dfu_assoc,
+	.altsetting = &dfu_iface,
+#if defined(PLATFORM_HAS_TRACESWO)
+}, {
+	.num_altsetting = 1,
+	.iface_assoc = &trace_assoc,
+	.altsetting = &trace_iface,
+#endif
+}};
+
+static const struct usb_config_descriptor config = {
+	.bLength = USB_DT_CONFIGURATION_SIZE,
+	.bDescriptorType = USB_DT_CONFIGURATION,
+	.wTotalLength = 0,
+	.bNumInterfaces = TOTAL_INTERFACES,
+	.bConfigurationValue = 1,
+	.iConfiguration = 0,
+	.bmAttributes = 0x80,
+	.bMaxPower = 0x32,
+
+	.interface = ifaces,
+};
+static char serial_no[DFU_SERIAL_LENGTH];
+
+#define BOARD_IDENT "Black Magic Probe " PLATFORM_IDENT FIRMWARE_VERSION
+
+static const char *usb_strings[] = {
+	"Black Magic Debug",
+	BOARD_IDENT,
+	serial_no,
+	"Black Magic GDB Server",
+	"Black Magic UART Port",
+	"Black Magic DFU",
+#if defined(PLATFORM_HAS_TRACESWO)
+	"Black Magic Trace Capture",
+#endif
+};
+
+static void dfu_detach_complete(usbd_device *dev, struct usb_setup_data *req)
+{
+	(void)dev;
+	(void)req;
+
+	platform_request_boot();
+
+	/* Reset core to enter bootloader */
+#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
+	scb_reset_core();
+#else
+	scb_reset_system();
+#endif
+}
+
+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))
+{
+	(void)dev;
+	(void)complete;
+	(void)buf;
+	(void)len;
+
+	switch(req->bRequest) {
+	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 != GDB_IF_NO)
+			return USBD_REQ_HANDLED;
+
+		cdcacm_gdb_dtr = req->wValue & 1;
+
+		return USBD_REQ_HANDLED;
+	case USB_CDC_REQ_SET_LINE_CODING:
+		if(*len < sizeof(struct usb_cdc_line_coding))
+			return USBD_REQ_NOTSUPP;
+
+		switch(req->wIndex) {
+		case UART_IF_NO:
+			usbuart_set_line_coding((struct usb_cdc_line_coding*)*buf);
+			return USBD_REQ_HANDLED;
+		case GDB_IF_NO:
+			return USBD_REQ_HANDLED; /* Ignore on GDB Port */
+		default:
+			return USBD_REQ_NOTSUPP;
+		}
+	case DFU_GETSTATUS:
+		if(req->wIndex == DFU_IF_NO) {
+			(*buf)[0] = DFU_STATUS_OK;
+			(*buf)[1] = 0;
+			(*buf)[2] = 0;
+			(*buf)[3] = 0;
+			(*buf)[4] = STATE_APP_IDLE;
+			(*buf)[5] = 0;	/* iString not used here */
+			*len = 6;
+
+			return USBD_REQ_HANDLED;
+		}
+		return USBD_REQ_NOTSUPP;
+	case DFU_DETACH:
+		if(req->wIndex == DFU_IF_NO) {
+			*complete = dfu_detach_complete;
+			return USBD_REQ_HANDLED;
+		}
+		return USBD_REQ_NOTSUPP;
+	}
+	return USBD_REQ_NOTSUPP;
+}
+
+int cdcacm_get_config(void)
+{
+	return configured;
+}
+
+int cdcacm_get_dtr(void)
+{
+	return cdcacm_gdb_dtr;
+}
+
+static void cdcacm_set_modem_state(usbd_device *dev, int iface, bool dsr, bool dcd)
+{
+	char buf[10];
+	struct usb_cdc_notification *notif = (void*)buf;
+	/* We echo signals back to host as notification */
+	notif->bmRequestType = 0xA1;
+	notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE;
+	notif->wValue = 0;
+	notif->wIndex = iface;
+	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);
+}
+
+static void cdcacm_set_config(usbd_device *dev, uint16_t wValue)
+{
+	configured = wValue;
+
+	/* GDB interface */
+#if defined(STM32F4) || defined(LM4F) || defined(SAMD)
+	usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT, USB_ENDPOINT_ATTR_BULK,
+	              CDCACM_PACKET_SIZE, gdb_usb_out_cb);
+#else
+	usbd_ep_setup(dev, CDCACM_GDB_ENDPOINT, USB_ENDPOINT_ATTR_BULK,
+	              CDCACM_PACKET_SIZE, NULL);
+#endif
+	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, 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, (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, TRACE_ENDPOINT | USB_REQ_TYPE_IN, USB_ENDPOINT_ATTR_BULK,
+					64, trace_buf_drain);
+#endif
+
+	usbd_register_control_callback(dev,
+			USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE,
+			USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
+			cdcacm_control_request);
+
+	/* Notify the host that DCD is asserted.
+	 * Allows the use of /dev/tty* devices on *BSD/MacOS
+	 */
+	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: */
+uint8_t usbd_control_buffer[256];
+
+void cdcacm_init(void)
+{
+	void exti15_10_isr(void);
+
+	serial_no_read(serial_no);
+
+	usbdev = usbd_init(&USB_DRIVER, &dev_desc, &config, usb_strings,
+			    sizeof(usb_strings)/sizeof(char *),
+			    usbd_control_buffer, sizeof(usbd_control_buffer));
+
+	usbd_register_set_config_callback(usbdev, cdcacm_set_config);
+
+	nvic_set_priority(USB_IRQ, IRQ_PRI_USB);
+	nvic_enable_irq(USB_IRQ);
+	usbd_disconnect(usbdev, false);
+}
+
+void USB_ISR(void)
+{
+	usbd_poll(usbdev);
+}

src/platforms/common/cdcacm.h

@@ -0,0 +1,46 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2015  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 the USB Communications Device Class - Abstract
+ * Control Model (CDC-ACM) as defined in CDC PSTN subclass 1.2.
+ * A Device Firmware Upgrade (DFU 1.1) class interface is provided for
+ * field firmware upgrade.
+ *
+ * The device's unique id is used as the USB serial number string.
+ */
+#ifndef __CDCACM_H
+#define __CDCACM_H
+
+#include <libopencm3/usb/usbd.h>
+
+#define CDCACM_PACKET_SIZE 	64
+
+#define CDCACM_GDB_ENDPOINT	1
+#define CDCACM_UART_ENDPOINT	3
+#define TRACE_ENDPOINT			5
+
+extern usbd_device *usbdev;
+
+void cdcacm_init(void);
+/* Returns current usb configuration, or 0 if not configured. */
+int cdcacm_get_config(void);
+int cdcacm_get_dtr(void);
+
+#endif

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

@@ -0,0 +1,215 @@
+/*
+ * 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 SW-DP interface. */
+
+#include "general.h"
+#include "timing.h"
+#include "adiv5.h"
+
+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

@@ -1,7 +1,7 @@
 /*
  * This file is part of the Black Magic Debug project.
  *
- * Copyright (C) 2011  Black Sphere Technologies Ltd.
+ * Copyright (C) 2012  Black Sphere Technologies Ltd.
  * Written by Gareth McMullin <gareth@blacksphere.co.nz>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -17,39 +17,26 @@
  * 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 __TRACESWO_H
+#define __TRACESWO_H
 
-#ifndef __PLATFORM_H
+#include <libopencm3/usb/usbd.h>
-#define __PLATFORM_H
 
-#include <stdint.h>
+#if defined TRACESWO_PROTOCOL && TRACESWO_PROTOCOL == 2
-#include <ftdi.h>
+/* Default line rate, used as default for a request without baudrate */
-
+#define SWO_DEFAULT_BAUD (2250000)
-#ifndef WIN32
+void traceswo_init(uint32_t baudrate, uint32_t swo_chan_bitmask);
-#	include <alloca.h>
 #else
-#	define alloca __builtin_alloca
+void traceswo_init(uint32_t swo_chan_bitmask);
 #endif
 
-#define FT2232_VID	0x0403
+void trace_buf_drain(usbd_device *dev, uint8_t ep);
-#define FT2232_PID	0x6010
 
-#define SET_RUN_STATE(state)
+/* set bitmask of swo channels to be decoded */
-#define SET_IDLE_STATE(state)
+void traceswo_setmask(uint32_t mask);
-#define SET_ERROR_STATE(state)
 
-#define PLATFORM_FATAL_ERROR(error)	abort()
+/* print decoded swo packet on usb serial */
-#define PLATFORM_SET_FATAL_ERROR_RECOVERY()
+uint16_t traceswo_decode(usbd_device *usbd_dev, uint8_t addr,
-
+				const void *buf, uint16_t len);
-#define morse(x, y) do {} while(0)
-#define morse_msg 0
-
-extern struct ftdi_context *ftdic;
-
-int platform_init(void);
-
-void platform_buffer_flush(void);
-int platform_buffer_write(const uint8_t *data, int size);
-int platform_buffer_read(uint8_t *data, int size);
 
 #endif
-

src/platforms/common/usbuart.h

@@ -0,0 +1,32 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2012  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/>.
+ */
+#ifndef __USBUART_H
+#define __USBUART_H
+
+#include <libopencm3/usb/usbd.h>
+#include <libopencm3/usb/cdc.h>
+
+void usbuart_init(void);
+
+void usbuart_set_line_coding(struct usb_cdc_line_coding *coding);
+void usbuart_usb_out_cb(usbd_device *dev, uint8_t ep);
+void usbuart_usb_in_cb(usbd_device *dev, uint8_t ep);
+
+#endif

src/platforms/f4discovery/Makefile.inc

@@ -0,0 +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 -I../libopencm3/include \
+	-Iplatforms/stm32
+
+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.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

@@ -0,0 +1,160 @@
+/*
+ * 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 platform specific functions for the STM32
+ * implementation.
+ */
+
+#include "general.h"
+#include "cdcacm.h"
+#include "usbuart.h"
+#include "morse.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*/
+	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();
+	}
+#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_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, GPIO9 | GPIO11 | GPIO12);
+	gpio_set_af(GPIOA, GPIO_AF10, GPIO9 | GPIO10 | GPIO11 | GPIO12);
+
+#ifdef BLACKPILL
+	GPIOA_OSPEEDR &= 0x3C00000C;
+	GPIOA_OSPEEDR |= 0x28000008;
+#else
+	GPIOC_OSPEEDR &= ~0xF30;
+	GPIOC_OSPEEDR |= 0xA20;
+#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_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_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; }
+bool platform_srst_get_val(void) { return false; }
+
+const char *platform_target_voltage(void)
+{
+	return NULL;
+}
+
+void platform_request_boot(void)
+{
+	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

@@ -0,0 +1,264 @@
+/*
+ * 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 platform specific functions for the STM32
+ * implementation.
+ */
+#ifndef __PLATFORM_H
+#define __PLATFORM_H
+
+#include "gpio.h"
+#include "timing.h"
+#include "timing_stm32.h"
+
+#include <setjmp.h>
+
+#define PLATFORM_HAS_TRACESWO
+#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:
+ *
+ * LED0 = 	PD12	(Green  LED : Running)
+ * LED1 = 	PD13	(Orange LED : Idle)
+ * LED2 = 	PD12	(Red LED    : Error)
+ * LED3 = 	PD15	(Blue LED   : Bootloader active)
+ *
+ * nTRST = 	PC1
+ * SRST_OUT =   PC8
+ * TDI = 	PC2
+ * TMS = 	PC4 (input for SWDP)
+ * TCK = 	PC5/SWCLK
+ * TDO = 	PC6 (input for TRACESWO
+ * nSRST =
+ *
+ * Force DFU mode button: PA0
+ */
+
+/* Hardware definitions... */
+#define JTAG_PORT 	GPIOC
+#define TDI_PORT	JTAG_PORT
+#define TMS_PORT	JTAG_PORT
+#define TCK_PORT	JTAG_PORT
+#define TDO_PORT	GPIOC
+#define TDI_PIN		GPIO2
+#define TMS_PIN		GPIO4
+#define TCK_PIN		GPIO5
+#define TDO_PIN		GPIO6
+
+#define SWDIO_PORT 	JTAG_PORT
+#define SWCLK_PORT 	JTAG_PORT
+#define SWDIO_PIN	TMS_PIN
+#define SWCLK_PIN	TCK_PIN
+
+#define TRST_PORT	GPIOC
+#define TRST_PIN	GPIO1
+#define SRST_PORT	GPIOC
+#define SRST_PIN	GPIO8
+
+#define LED_PORT	GPIOD
+#define LED_PORT_UART	GPIOD
+#define LED_UART	GPIO12
+#define LED_IDLE_RUN	GPIO13
+#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);
+#define SWDIO_MODE_FLOAT() \
+	gpio_mode_setup(SWDIO_PORT, GPIO_MODE_INPUT, \
+	                GPIO_PUPD_NONE, SWDIO_PIN);
+
+#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(x)      otg_fs_isr(x)
+/* Interrupt priorities.  Low numbers are high priority.
+ * TIM3 is used for traceswo capture and must be highest priority.
+ */
+#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 TRACE_TIM TIM3
+#define TRACE_TIM_CLK_EN() rcc_periph_clock_enable(RCC_TIM3)
+#define TRACE_IRQ   NVIC_TIM3_IRQ
+#define TRACE_ISR(x) tim3_isr(x)
+
+#define gpio_set_val(port, pin, val) do {	\
+	if(val)					\
+		gpio_set((port), (pin));	\
+	else					\
+		gpio_clear((port), (pin));	\
+} while(0)
+
+#define SET_RUN_STATE(state)	{running_status = (state);}
+#define SET_IDLE_STATE(state)	{gpio_set_val(LED_PORT, LED_IDLE_RUN, state);}
+#define SET_ERROR_STATE(state)	{gpio_set_val(LED_PORT, LED_ERROR, state);}
+
+static inline int platform_hwversion(void)
+{
+	return 0;
+}
+
+/*
+ * 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

@@ -0,0 +1,73 @@
+/*
+ * This file is part of the Black Magic Debug project.
+ *
+ * Copyright (C) 2013 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 <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)
+{
+	scb_reset_system();
+}
+
+int main(void)
+{
+	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]);
+
+	/* 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);
+
+	/* 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, GPIO11 | GPIO12);
+	gpio_set_af(GPIOA, GPIO_AF10, GPIO11 | GPIO12);
+
+ 	dfu_protect(false);
+	dfu_init(&USB_DRIVER);
+	dfu_main();
+
+}
+
+void dfu_event(void)
+{
+}
+

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);
+}