picoboot_connection/picoboot_connection.c - third_party/github/raspberrypi/picotool - Git at Google

 /*
  * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */

 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>

 #include "picoboot_connection.h"

 #if false && !defined(NDEBUG)
 #define output(format,...) printf(format, __VA_ARGS__)
 #else
 #define output(format,...) ((void)0)
 #endif

 static bool verbose;

 // todo test sparse binary (well actually two range is this)

 #define VENDOR_ID_RASPBERRY_PI 0x2e8au
 #define PRODUCT_ID_RP2_USBBOOT 0x0003u
 #define PRODUCT_ID_PICOPROBE   0x0004u
 #define PRODUCT_ID_MICROPYTHON 0x0005u
 #define PRODUCT_ID_STDIO_USB   0x000au

 uint32_t crc32_for_byte(uint32_t remainder) {
     const uint32_t POLYNOMIAL = 0x4C11DB7;
     remainder <<= 24u;
     for (uint bit = 8; bit > 0; bit--) {
         if (remainder & 0x80000000)
             remainder = (remainder << 1) ^ POLYNOMIAL;
         else
             remainder = (remainder << 1);
     }
     return remainder;
 }

 uint32_t crc32_sw(const uint8_t *buf, uint count, uint32_t crc) {
     static uint32_t table[0x100];
     if (!table[1]) {
         for (uint i = 0; i < count_of(table); i++) {
             table[i] = crc32_for_byte(i);
         }
     }
     for (uint i = 0; i < count; ++i) {
         crc = (crc << 8u) ^ table[(uint8_t) ((crc >> 24u) ^ buf[i])];
     }
     return crc;
 }

 uint interface;
 uint out_ep;
 uint in_ep;

 enum picoboot_device_result picoboot_open_device(libusb_device *device, libusb_device_handle **dev_handle) {
     struct libusb_device_descriptor desc;
     struct libusb_config_descriptor *config;

     *dev_handle = NULL;
     int ret = libusb_get_device_descriptor(device, &desc);
     if (ret && verbose) {
         output("Failed to read device descriptor");
     }
     if (!ret) {
         if (desc.idVendor != VENDOR_ID_RASPBERRY_PI) {
             return dr_vidpid_unknown;
         }
         switch (desc.idProduct) {
             case PRODUCT_ID_MICROPYTHON:
                 return dr_vidpid_micropython;
             case PRODUCT_ID_PICOPROBE:
                 return dr_vidpid_picoprobe;
             case PRODUCT_ID_STDIO_USB:
                 return dr_vidpid_stdio_usb;
             case PRODUCT_ID_RP2_USBBOOT:
                 break;
             default:
                 return dr_vidpid_unknown;
         }
         ret = libusb_get_active_config_descriptor(device, &config);
         if (ret && verbose) {
             output("Failed to read config descriptor\n");
         }
     }

     if (!ret) {
         ret  = libusb_open(device, dev_handle);
         if (ret && verbose) {
             output("Failed to open device %d\n", ret);
         }
         if (ret) {
             return dr_vidpid_bootrom_cant_connect;
         }
     }

     if (!ret) {
         if (config->bNumInterfaces == 1) {
             interface = 0;
         } else {
             interface = 1;
         }
         if (config->interface[interface].altsetting[0].bInterfaceClass == 0xff &&
             config->interface[interface].altsetting[0].bNumEndpoints == 2) {
             out_ep = config->interface[interface].altsetting[0].endpoint[0].bEndpointAddress;
             in_ep = config->interface[interface].altsetting[0].endpoint[1].bEndpointAddress;
         }
         if (out_ep && in_ep && !(out_ep & 0x80u) && (in_ep & 0x80u)) {
             if (verbose) output("Found PICOBOOT interface\n");
             ret = libusb_claim_interface(*dev_handle, interface);
             if (ret) {
                 if (verbose) output("Failed to claim interface\n");
                 return dr_vidpid_bootrom_no_interface;
             }

             return dr_vidpid_bootrom_ok;
         } else {
             if (verbose) output("Did not find PICOBOOT interface\n");
             return dr_vidpid_bootrom_no_interface;
         }
     }

     assert(ret);

     if (*dev_handle) {
         libusb_close(*dev_handle);
         *dev_handle = NULL;
     }

     return dr_error;
 }

 static bool is_halted(libusb_device_handle *usb_device, int ep) {
     uint8_t data[2];

     int transferred = libusb_control_transfer(
             usb_device,
             /*LIBUSB_REQUEST_TYPE_STANDARD | */LIBUSB_RECIPIENT_ENDPOINT | LIBUSB_ENDPOINT_IN,
             LIBUSB_REQUEST_GET_STATUS,
             0, ep,
             data, sizeof(data),
             1000);
     if (transferred != sizeof(data)) {
         output("Get status failed\n");
         return false;
     }
     if (data[0] & 1) {
         if (verbose) output("%d was halted\n", ep);
         return true;
     }
     if (verbose) output("%d was not halted\n", ep);
     return false;
 }

 int picoboot_reset(libusb_device_handle *usb_device) {
     if (verbose) output("RESET\n");
     if (is_halted(usb_device, in_ep))
         libusb_clear_halt(usb_device, in_ep);
     if (is_halted(usb_device, out_ep))
         libusb_clear_halt(usb_device, out_ep);
     int ret =
             libusb_control_transfer(usb_device, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE,
                                     PICOBOOT_IF_RESET, 0, interface, NULL, 0, 1000);

     if (ret != 0) {
         output("  ...failed\n");
         return ret;
     }
     if (verbose) output("  ...ok\n");
     return 0;
 }

 int picoboot_cmd_status_verbose(libusb_device_handle *usb_device, struct picoboot_cmd_status *status, bool local_verbose) {
     struct picoboot_cmd_status s;
     if (!status) status = &s;

     if (local_verbose) output("CMD_STATUS\n");
     int ret =
             libusb_control_transfer(usb_device,
                                     LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE | LIBUSB_ENDPOINT_IN,
                                     PICOBOOT_IF_CMD_STATUS, 0, interface, (uint8_t *) status, sizeof(*status), 1000);

     if (ret != sizeof(*status)) {
         output("  ...failed\n");
         return ret;
     }
     if (local_verbose)
         output("  ... cmd %02x%s tok=%08x status=%d\n", status->bCmdId, status->bInProgress ? " (in progress)" : "",
                status->dToken, status->dStatusCode);
     return 0;
 }

 int picoboot_cmd_status(libusb_device_handle *usb_device, struct picoboot_cmd_status *status) {
     return picoboot_cmd_status_verbose(usb_device, status, verbose);
 }

 int one_time_bulk_timeout;

 int picoboot_cmd(libusb_device_handle *usb_device, struct picoboot_cmd *cmd, uint8_t *buffer, uint buf_size) {
     int sent = 0;
     int ret;

     static int token = 1;
     cmd->dMagic = PICOBOOT_MAGIC;
     cmd->dToken = token++;
     ret = libusb_bulk_transfer(usb_device, out_ep, (uint8_t *) cmd, sizeof(struct picoboot_cmd), &sent, 3000);

     if (ret != 0 || sent != sizeof(struct picoboot_cmd)) {
         output("   ...failed to send command %d\n", ret);
         return ret;
     }

     int timeout = 10000;
     if (one_time_bulk_timeout) {
         timeout = one_time_bulk_timeout;
         one_time_bulk_timeout = 0;
     }
     if (cmd->dTransferLength != 0) {
         assert(buf_size >= cmd->dTransferLength);
         if (cmd->bCmdId & 0x80u) {
             if (verbose) output("  receive %d...\n", cmd->dTransferLength);
             int received = 0;
             ret = libusb_bulk_transfer(usb_device, in_ep, buffer, cmd->dTransferLength, &received, timeout);
             if (ret != 0 || received != (int) cmd->dTransferLength) {
                 output("  ...failed to receive data %d %d/%d\n", ret, received, cmd->dTransferLength);
                 if (!ret) ret = 1;
                 return ret;
             }
         } else {
             if (verbose) output("  send %d...\n", cmd->dTransferLength);
             ret = libusb_bulk_transfer(usb_device, out_ep, buffer, cmd->dTransferLength, &sent, timeout);
             if (ret != 0 || sent != (int) cmd->dTransferLength) {
                 output("  ...failed to send data %d %d/%d\n", ret, sent, cmd->dTransferLength);
                 if (!ret) ret = 1;
                 picoboot_cmd_status_verbose(usb_device, NULL, true);
                 return ret;
             }
         }
     }

     // ack is in opposite direction
     int received = 0;
     uint8_t spoon[64];
     if (cmd->bCmdId & 0x80u) {
         if (verbose) output("zero length out\n");
         ret = libusb_bulk_transfer(usb_device, out_ep, spoon, 1, &received, cmd->dTransferLength == 0 ? timeout : 3000);
     } else {
         if (verbose) output("zero length in\n");
         ret = libusb_bulk_transfer(usb_device, in_ep, spoon, 1, &received, cmd->dTransferLength == 0 ? timeout : 3000);
     }
     return ret;
 }

 int picoboot_exclusive_access(libusb_device_handle *usb_device, uint8_t exclusive) {
     if (verbose) output("EXCLUSIVE ACCESS %d\n", exclusive);
     struct picoboot_cmd cmd;
     cmd.bCmdId = PC_EXCLUSIVE_ACCESS;
     cmd.exclusive_cmd.bExclusive = exclusive;
     cmd.bCmdSize = sizeof(struct picoboot_exclusive_cmd);
     cmd.dTransferLength = 0;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_exit_xip(libusb_device_handle *usb_device) {
     struct picoboot_cmd cmd;
     if (verbose) output("EXIT_XIP\n");
     cmd.bCmdId = PC_EXIT_XIP;
     cmd.bCmdSize = 0;
     cmd.dTransferLength = 0;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_enter_cmd_xip(libusb_device_handle *usb_device) {
     struct picoboot_cmd cmd;
     if (verbose) output("ENTER_CMD_XIP\n");
     cmd.bCmdId = PC_ENTER_CMD_XIP;
     cmd.bCmdSize = 0;
     cmd.dTransferLength = 0;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_reboot(libusb_device_handle *usb_device, uint32_t pc, uint32_t sp, uint32_t delay_ms) {
     struct picoboot_cmd cmd;
     if (verbose) output("REBOOT %08x %08x %u\n", (uint) pc, (uint) sp, (uint) delay_ms);
     cmd.bCmdId = PC_REBOOT;
     cmd.bCmdSize = sizeof(cmd.reboot_cmd);
     cmd.dTransferLength = 0;
     cmd.reboot_cmd.dPC = pc;
     cmd.reboot_cmd.dSP = sp;
     cmd.reboot_cmd.dDelayMS = delay_ms;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_exec(libusb_device_handle *usb_device, uint32_t addr) {
     struct picoboot_cmd cmd;
     // shouldn't be necessary any more
     // addr |= 1u; // Thumb bit
     if (verbose) output("EXEC %08x\n", (uint) addr);
     cmd.bCmdId = PC_EXEC;
     cmd.bCmdSize = sizeof(cmd.address_only_cmd);
     cmd.dTransferLength = 0;
     cmd.address_only_cmd.dAddr = addr;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_flash_erase(libusb_device_handle *usb_device, uint32_t addr, uint32_t len) {
     struct picoboot_cmd cmd;
     if (verbose) output("FLASH_ERASE %08x+%08x\n", (uint) addr, (uint) len);
     cmd.bCmdId = PC_FLASH_ERASE;
     cmd.bCmdSize = sizeof(cmd.range_cmd);
     cmd.range_cmd.dAddr = addr;
     cmd.range_cmd.dSize = len;
     cmd.dTransferLength = 0;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_vector(libusb_device_handle *usb_device, uint32_t addr) {
     struct picoboot_cmd cmd;
     if (verbose) output("VECTOR %08x\n", (uint) addr);
     cmd.bCmdId = PC_VECTORIZE_FLASH;
     cmd.bCmdSize = sizeof(cmd.address_only_cmd);
     cmd.range_cmd.dAddr = addr;
     cmd.dTransferLength = 0;
     return picoboot_cmd(usb_device, &cmd, NULL, 0);
 }

 int picoboot_write(libusb_device_handle *usb_device, uint32_t addr, uint8_t *buffer, uint32_t len) {
     struct picoboot_cmd cmd;
     if (verbose) output("WRITE %08x+%08x\n", (uint) addr, (uint) len);
     cmd.bCmdId = PC_WRITE;
     cmd.bCmdSize = sizeof(cmd.range_cmd);
     cmd.range_cmd.dAddr = addr;
     cmd.range_cmd.dSize = cmd.dTransferLength = len;
     return picoboot_cmd(usb_device, &cmd, buffer, len);
 }

 int picoboot_read(libusb_device_handle *usb_device, uint32_t addr, uint8_t *buffer, uint32_t len) {
     memset(buffer, 0xaa, len);
     if (verbose) output("READ %08x+%08x\n", (uint) addr, (uint) len);
     struct picoboot_cmd cmd;
     cmd.bCmdId = PC_READ;
     cmd.bCmdSize = sizeof(cmd.range_cmd);
     cmd.range_cmd.dAddr = addr;
     cmd.range_cmd.dSize = cmd.dTransferLength = len;
     int ret = picoboot_cmd(usb_device, &cmd, buffer, len);
     if (!ret && len < 256 && verbose) {
         for (uint32_t i = 0; i < len; i += 32) {
             output("\t");
             for (uint32_t j = i; j < MIN(len, i + 32); j++) {
                 output("0x%02x, ", buffer[j]);
             }
             output("\n");
         }
     }
     return ret;
 }


 #if 0
 // Peek/poke via EXEC

 // 00000000 <poke>:
 //    0:   4801        ldr r0, [pc, #4]    ; (8 <data>)
 //    2:   4902        ldr r1, [pc, #8]    ; (c <addr>)
 //    4:   6008        str r0, [r1, #0]
 //    6:   4770        bx  lr
 // 00000008 <data>:
 //    8:   12345678    .word   0x12345678
 // 0000000c <addr>:
 //    c:   9abcdef0    .word   0x9abcdef0


 static const size_t picoboot_poke_cmd_len = 8;
 static const uint8_t picoboot_poke_cmd[] = {
         0x01, 0x48, 0x02, 0x49, 0x08, 0x60, 0x70, 0x47
 };

 // 00000000 <peek>:
 //    0:   4802        ldr r0, [pc, #8]    ; (c <inout>)
 //    2:   6800        ldr r0, [r0, #0]
 //    4:   4679        mov r1, pc
 //    6:   6048        str r0, [r1, #4]
 //    8:   4770        bx  lr
 //    a:   46c0        nop         ; (mov r8, r8)
 // 0000000c <inout>:
 //    c:   0add7355    .word   0x0add7355

 static const size_t picoboot_peek_cmd_len = 12;
 static const uint8_t picoboot_peek_cmd[] = {
         0x02, 0x48, 0x00, 0x68, 0x79, 0x46, 0x48, 0x60, 0x70, 0x47, 0xc0, 0x46
 };

 // TODO better place for this e.g. the USB DPRAM location the controller has already put it in
 #define PEEK_POKE_CODE_LOC 0x20000000u

 int picoboot_poke(libusb_device_handle *usb_device, uint32_t addr, uint32_t data) {
     const size_t prog_size = picoboot_poke_cmd_len + 8;
     uint8_t prog[prog_size];
     output("POKE (D)%08x -> (A)%08x\n", data, addr);
     memcpy(prog, picoboot_poke_cmd, picoboot_poke_cmd_len);
     *(uint32_t *) (prog + picoboot_poke_cmd_len) = data;
     *(uint32_t *) (prog + picoboot_poke_cmd_len + 4) = addr;

     int ret = picoboot_write(usb_device, PEEK_POKE_CODE_LOC, prog, prog_size);
     if (ret)
         return ret;
     return picoboot_exec(usb_device, PEEK_POKE_CODE_LOC);
 }

 // TODO haven't checked the store goes to the right address :)
 int picoboot_peek(libusb_device_handle *usb_device, uint32_t addr, uint32_t *data) {
     const size_t prog_size = picoboot_peek_cmd_len + 4;
     uint8_t prog[prog_size];
     output("PEEK %08x\n", addr);
     memcpy(prog, picoboot_peek_cmd, picoboot_peek_cmd_len);
     *(uint32_t *) (prog + picoboot_peek_cmd_len) = addr;

     int ret = picoboot_write(usb_device, PEEK_POKE_CODE_LOC, prog, prog_size);
     if (ret)
         return ret;
     ret = picoboot_exec(usb_device, PEEK_POKE_CODE_LOC);
     if (ret)
         return ret;
     return picoboot_read(usb_device, PEEK_POKE_CODE_LOC + picoboot_peek_cmd_len, (uint8_t *) data, sizeof(uint32_t));
 }
 #endif
	/*
	* Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	#include <stdlib.h>
	#include <string.h>
	#include <stdbool.h>

	#include "picoboot_connection.h"

	#if false && !defined(NDEBUG)
	#define output(format,...) printf(format, __VA_ARGS__)
	#else
	#define output(format,...) ((void)0)
	#endif

	static bool verbose;

	// todo test sparse binary (well actually two range is this)

	#define VENDOR_ID_RASPBERRY_PI 0x2e8au
	#define PRODUCT_ID_RP2_USBBOOT 0x0003u
	#define PRODUCT_ID_PICOPROBE 0x0004u
	#define PRODUCT_ID_MICROPYTHON 0x0005u
	#define PRODUCT_ID_STDIO_USB 0x000au

	uint32_t crc32_for_byte(uint32_t remainder) {
	const uint32_t POLYNOMIAL = 0x4C11DB7;
	remainder <<= 24u;
	for (uint bit = 8; bit > 0; bit--) {
	if (remainder & 0x80000000)
	remainder = (remainder << 1) ^ POLYNOMIAL;
	else
	remainder = (remainder << 1);
	}
	return remainder;
	}

	uint32_t crc32_sw(const uint8_t *buf, uint count, uint32_t crc) {
	static uint32_t table[0x100];
	if (!table[1]) {
	for (uint i = 0; i < count_of(table); i++) {
	table[i] = crc32_for_byte(i);
	}
	}
	for (uint i = 0; i < count; ++i) {
	crc = (crc << 8u) ^ table[(uint8_t) ((crc >> 24u) ^ buf[i])];
	}
	return crc;
	}

	uint interface;
	uint out_ep;
	uint in_ep;

	enum picoboot_device_result picoboot_open_device(libusb_device device, libusb_device_handle *dev_handle) {
	struct libusb_device_descriptor desc;
	struct libusb_config_descriptor *config;

	*dev_handle = NULL;
	int ret = libusb_get_device_descriptor(device, &desc);
	if (ret && verbose) {
	output("Failed to read device descriptor");
	}
	if (!ret) {
	if (desc.idVendor != VENDOR_ID_RASPBERRY_PI) {
	return dr_vidpid_unknown;
	}
	switch (desc.idProduct) {
	case PRODUCT_ID_MICROPYTHON:
	return dr_vidpid_micropython;
	case PRODUCT_ID_PICOPROBE:
	return dr_vidpid_picoprobe;
	case PRODUCT_ID_STDIO_USB:
	return dr_vidpid_stdio_usb;
	case PRODUCT_ID_RP2_USBBOOT:
	break;
	default:
	return dr_vidpid_unknown;
	}
	ret = libusb_get_active_config_descriptor(device, &config);
	if (ret && verbose) {
	output("Failed to read config descriptor\n");
	}
	}

	if (!ret) {
	ret = libusb_open(device, dev_handle);
	if (ret && verbose) {
	output("Failed to open device %d\n", ret);
	}
	if (ret) {
	return dr_vidpid_bootrom_cant_connect;
	}
	}

	if (!ret) {
	if (config->bNumInterfaces == 1) {
	interface = 0;
	} else {
	interface = 1;
	}
	if (config->interface[interface].altsetting[0].bInterfaceClass == 0xff &&
	config->interface[interface].altsetting[0].bNumEndpoints == 2) {
	out_ep = config->interface[interface].altsetting[0].endpoint[0].bEndpointAddress;
	in_ep = config->interface[interface].altsetting[0].endpoint[1].bEndpointAddress;
	}
	if (out_ep && in_ep && !(out_ep & 0x80u) && (in_ep & 0x80u)) {
	if (verbose) output("Found PICOBOOT interface\n");
	ret = libusb_claim_interface(*dev_handle, interface);
	if (ret) {
	if (verbose) output("Failed to claim interface\n");
	return dr_vidpid_bootrom_no_interface;
	}

	return dr_vidpid_bootrom_ok;
	} else {
	if (verbose) output("Did not find PICOBOOT interface\n");
	return dr_vidpid_bootrom_no_interface;
	}
	}

	assert(ret);

	if (*dev_handle) {
	libusb_close(*dev_handle);
	*dev_handle = NULL;
	}

	return dr_error;
	}

	static bool is_halted(libusb_device_handle *usb_device, int ep) {
	uint8_t data[2];

	int transferred = libusb_control_transfer(
	usb_device,
	/LIBUSB_REQUEST_TYPE_STANDARD \| /LIBUSB_RECIPIENT_ENDPOINT \| LIBUSB_ENDPOINT_IN,
	LIBUSB_REQUEST_GET_STATUS,
	0, ep,
	data, sizeof(data),
	1000);
	if (transferred != sizeof(data)) {
	output("Get status failed\n");
	return false;
	}
	if (data[0] & 1) {
	if (verbose) output("%d was halted\n", ep);
	return true;
	}
	if (verbose) output("%d was not halted\n", ep);
	return false;
	}

	int picoboot_reset(libusb_device_handle *usb_device) {
	if (verbose) output("RESET\n");
	if (is_halted(usb_device, in_ep))
	libusb_clear_halt(usb_device, in_ep);
	if (is_halted(usb_device, out_ep))
	libusb_clear_halt(usb_device, out_ep);
	int ret =
	libusb_control_transfer(usb_device, LIBUSB_REQUEST_TYPE_VENDOR \| LIBUSB_RECIPIENT_INTERFACE,
	PICOBOOT_IF_RESET, 0, interface, NULL, 0, 1000);

	if (ret != 0) {
	output(" ...failed\n");
	return ret;
	}
	if (verbose) output(" ...ok\n");
	return 0;
	}

	int picoboot_cmd_status_verbose(libusb_device_handle usb_device, struct picoboot_cmd_status status, bool local_verbose) {
	struct picoboot_cmd_status s;
	if (!status) status = &s;

	if (local_verbose) output("CMD_STATUS\n");
	int ret =
	libusb_control_transfer(usb_device,
	LIBUSB_REQUEST_TYPE_VENDOR \| LIBUSB_RECIPIENT_INTERFACE \| LIBUSB_ENDPOINT_IN,
	PICOBOOT_IF_CMD_STATUS, 0, interface, (uint8_t ) status, sizeof(status), 1000);

	if (ret != sizeof(*status)) {
	output(" ...failed\n");
	return ret;
	}
	if (local_verbose)
	output(" ... cmd %02x%s tok=%08x status=%d\n", status->bCmdId, status->bInProgress ? " (in progress)" : "",
	status->dToken, status->dStatusCode);
	return 0;
	}

	int picoboot_cmd_status(libusb_device_handle usb_device, struct picoboot_cmd_status status) {
	return picoboot_cmd_status_verbose(usb_device, status, verbose);
	}

	int one_time_bulk_timeout;

	int picoboot_cmd(libusb_device_handle usb_device, struct picoboot_cmd cmd, uint8_t *buffer, uint buf_size) {
	int sent = 0;
	int ret;

	static int token = 1;
	cmd->dMagic = PICOBOOT_MAGIC;
	cmd->dToken = token++;
	ret = libusb_bulk_transfer(usb_device, out_ep, (uint8_t *) cmd, sizeof(struct picoboot_cmd), &sent, 3000);

	if (ret != 0 \|\| sent != sizeof(struct picoboot_cmd)) {
	output(" ...failed to send command %d\n", ret);
	return ret;
	}

	int timeout = 10000;
	if (one_time_bulk_timeout) {
	timeout = one_time_bulk_timeout;
	one_time_bulk_timeout = 0;
	}
	if (cmd->dTransferLength != 0) {
	assert(buf_size >= cmd->dTransferLength);
	if (cmd->bCmdId & 0x80u) {
	if (verbose) output(" receive %d...\n", cmd->dTransferLength);
	int received = 0;
	ret = libusb_bulk_transfer(usb_device, in_ep, buffer, cmd->dTransferLength, &received, timeout);
	if (ret != 0 \|\| received != (int) cmd->dTransferLength) {
	output(" ...failed to receive data %d %d/%d\n", ret, received, cmd->dTransferLength);
	if (!ret) ret = 1;
	return ret;
	}
	} else {
	if (verbose) output(" send %d...\n", cmd->dTransferLength);
	ret = libusb_bulk_transfer(usb_device, out_ep, buffer, cmd->dTransferLength, &sent, timeout);
	if (ret != 0 \|\| sent != (int) cmd->dTransferLength) {
	output(" ...failed to send data %d %d/%d\n", ret, sent, cmd->dTransferLength);
	if (!ret) ret = 1;
	picoboot_cmd_status_verbose(usb_device, NULL, true);
	return ret;
	}
	}
	}

	// ack is in opposite direction
	int received = 0;
	uint8_t spoon[64];
	if (cmd->bCmdId & 0x80u) {
	if (verbose) output("zero length out\n");
	ret = libusb_bulk_transfer(usb_device, out_ep, spoon, 1, &received, cmd->dTransferLength == 0 ? timeout : 3000);
	} else {
	if (verbose) output("zero length in\n");
	ret = libusb_bulk_transfer(usb_device, in_ep, spoon, 1, &received, cmd->dTransferLength == 0 ? timeout : 3000);
	}
	return ret;
	}

	int picoboot_exclusive_access(libusb_device_handle *usb_device, uint8_t exclusive) {
	if (verbose) output("EXCLUSIVE ACCESS %d\n", exclusive);
	struct picoboot_cmd cmd;
	cmd.bCmdId = PC_EXCLUSIVE_ACCESS;
	cmd.exclusive_cmd.bExclusive = exclusive;
	cmd.bCmdSize = sizeof(struct picoboot_exclusive_cmd);
	cmd.dTransferLength = 0;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_exit_xip(libusb_device_handle *usb_device) {
	struct picoboot_cmd cmd;
	if (verbose) output("EXIT_XIP\n");
	cmd.bCmdId = PC_EXIT_XIP;
	cmd.bCmdSize = 0;
	cmd.dTransferLength = 0;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_enter_cmd_xip(libusb_device_handle *usb_device) {
	struct picoboot_cmd cmd;
	if (verbose) output("ENTER_CMD_XIP\n");
	cmd.bCmdId = PC_ENTER_CMD_XIP;
	cmd.bCmdSize = 0;
	cmd.dTransferLength = 0;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_reboot(libusb_device_handle *usb_device, uint32_t pc, uint32_t sp, uint32_t delay_ms) {
	struct picoboot_cmd cmd;
	if (verbose) output("REBOOT %08x %08x %u\n", (uint) pc, (uint) sp, (uint) delay_ms);
	cmd.bCmdId = PC_REBOOT;
	cmd.bCmdSize = sizeof(cmd.reboot_cmd);
	cmd.dTransferLength = 0;
	cmd.reboot_cmd.dPC = pc;
	cmd.reboot_cmd.dSP = sp;
	cmd.reboot_cmd.dDelayMS = delay_ms;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_exec(libusb_device_handle *usb_device, uint32_t addr) {
	struct picoboot_cmd cmd;
	// shouldn't be necessary any more
	// addr \|= 1u; // Thumb bit
	if (verbose) output("EXEC %08x\n", (uint) addr);
	cmd.bCmdId = PC_EXEC;
	cmd.bCmdSize = sizeof(cmd.address_only_cmd);
	cmd.dTransferLength = 0;
	cmd.address_only_cmd.dAddr = addr;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_flash_erase(libusb_device_handle *usb_device, uint32_t addr, uint32_t len) {
	struct picoboot_cmd cmd;
	if (verbose) output("FLASH_ERASE %08x+%08x\n", (uint) addr, (uint) len);
	cmd.bCmdId = PC_FLASH_ERASE;
	cmd.bCmdSize = sizeof(cmd.range_cmd);
	cmd.range_cmd.dAddr = addr;
	cmd.range_cmd.dSize = len;
	cmd.dTransferLength = 0;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_vector(libusb_device_handle *usb_device, uint32_t addr) {
	struct picoboot_cmd cmd;
	if (verbose) output("VECTOR %08x\n", (uint) addr);
	cmd.bCmdId = PC_VECTORIZE_FLASH;
	cmd.bCmdSize = sizeof(cmd.address_only_cmd);
	cmd.range_cmd.dAddr = addr;
	cmd.dTransferLength = 0;
	return picoboot_cmd(usb_device, &cmd, NULL, 0);
	}

	int picoboot_write(libusb_device_handle usb_device, uint32_t addr, uint8_t buffer, uint32_t len) {
	struct picoboot_cmd cmd;
	if (verbose) output("WRITE %08x+%08x\n", (uint) addr, (uint) len);
	cmd.bCmdId = PC_WRITE;
	cmd.bCmdSize = sizeof(cmd.range_cmd);
	cmd.range_cmd.dAddr = addr;
	cmd.range_cmd.dSize = cmd.dTransferLength = len;
	return picoboot_cmd(usb_device, &cmd, buffer, len);
	}

	int picoboot_read(libusb_device_handle usb_device, uint32_t addr, uint8_t buffer, uint32_t len) {
	memset(buffer, 0xaa, len);
	if (verbose) output("READ %08x+%08x\n", (uint) addr, (uint) len);
	struct picoboot_cmd cmd;
	cmd.bCmdId = PC_READ;
	cmd.bCmdSize = sizeof(cmd.range_cmd);
	cmd.range_cmd.dAddr = addr;
	cmd.range_cmd.dSize = cmd.dTransferLength = len;
	int ret = picoboot_cmd(usb_device, &cmd, buffer, len);
	if (!ret && len < 256 && verbose) {
	for (uint32_t i = 0; i < len; i += 32) {
	output("\t");
	for (uint32_t j = i; j < MIN(len, i + 32); j++) {
	output("0x%02x, ", buffer[j]);
	}
	output("\n");
	}
	}
	return ret;
	}


	#if 0
	// Peek/poke via EXEC

	// 00000000 <poke>:
	// 0: 4801 ldr r0, [pc, #4] ; (8 <data>)
	// 2: 4902 ldr r1, [pc, #8] ; (c <addr>)
	// 4: 6008 str r0, [r1, #0]
	// 6: 4770 bx lr
	// 00000008 <data>:
	// 8: 12345678 .word 0x12345678
	// 0000000c <addr>:
	// c: 9abcdef0 .word 0x9abcdef0


	static const size_t picoboot_poke_cmd_len = 8;
	static const uint8_t picoboot_poke_cmd[] = {
	0x01, 0x48, 0x02, 0x49, 0x08, 0x60, 0x70, 0x47
	};

	// 00000000 <peek>:
	// 0: 4802 ldr r0, [pc, #8] ; (c <inout>)
	// 2: 6800 ldr r0, [r0, #0]
	// 4: 4679 mov r1, pc
	// 6: 6048 str r0, [r1, #4]
	// 8: 4770 bx lr
	// a: 46c0 nop ; (mov r8, r8)
	// 0000000c <inout>:
	// c: 0add7355 .word 0x0add7355

	static const size_t picoboot_peek_cmd_len = 12;
	static const uint8_t picoboot_peek_cmd[] = {
	0x02, 0x48, 0x00, 0x68, 0x79, 0x46, 0x48, 0x60, 0x70, 0x47, 0xc0, 0x46
	};

	// TODO better place for this e.g. the USB DPRAM location the controller has already put it in
	#define PEEK_POKE_CODE_LOC 0x20000000u

	int picoboot_poke(libusb_device_handle *usb_device, uint32_t addr, uint32_t data) {
	const size_t prog_size = picoboot_poke_cmd_len + 8;
	uint8_t prog[prog_size];
	output("POKE (D)%08x -> (A)%08x\n", data, addr);
	memcpy(prog, picoboot_poke_cmd, picoboot_poke_cmd_len);
	(uint32_t ) (prog + picoboot_poke_cmd_len) = data;
	(uint32_t ) (prog + picoboot_poke_cmd_len + 4) = addr;

	int ret = picoboot_write(usb_device, PEEK_POKE_CODE_LOC, prog, prog_size);
	if (ret)
	return ret;
	return picoboot_exec(usb_device, PEEK_POKE_CODE_LOC);
	}

	// TODO haven't checked the store goes to the right address :)
	int picoboot_peek(libusb_device_handle usb_device, uint32_t addr, uint32_t data) {
	const size_t prog_size = picoboot_peek_cmd_len + 4;
	uint8_t prog[prog_size];
	output("PEEK %08x\n", addr);
	memcpy(prog, picoboot_peek_cmd, picoboot_peek_cmd_len);
	(uint32_t ) (prog + picoboot_peek_cmd_len) = addr;

	int ret = picoboot_write(usb_device, PEEK_POKE_CODE_LOC, prog, prog_size);
	if (ret)
	return ret;
	ret = picoboot_exec(usb_device, PEEK_POKE_CODE_LOC);
	if (ret)
	return ret;
	return picoboot_read(usb_device, PEEK_POKE_CODE_LOC + picoboot_peek_cmd_len, (uint8_t *) data, sizeof(uint32_t));
	}
	#endif