Add firmware for the ATUSB IEEE 802.15.4 USB Adapter

http://shop.sysmocom.de/products/atusb/

INSTALL

@@ -16,6 +16,8 @@ In order to build everything you will need the following on the host
 system:
 
     * A C/C++ compiler, like GCC
+    * AVR-GCC
+    * Standard C library for AVR-GCC
     * Cmake
     * GNU Bison/YACC
     * GNU Flex
@@ -32,13 +34,27 @@ system:
 
 On GNU/Linux distros that use apt you can install these with:
 
-    apt install binutils-arm-linux-gnueabi binutils-arm-none-eabi bison \
-    cmake flex g++ gcc gcc-arm-linux-gnueabi gcc-arm-none-eabi gperf make wget
+    apt install avr-gcc avr-libc binutils-arm-linux-gnueabi \
+    binutils-arm-none-eabi bison cmake flex g++ gcc \
+    gcc-arm-linux-gnueabi gcc-arm-none-eabi gperf make wget
 
 CARL9170 Firmware Configuration
+-------------------------------
 When building the carl9170 firmware you will be prompted with
 configuration questions.
 
+atusb: Firmware for the ATUSB IEEE 802.15.4 USB Adapter
+-------------------------------------------------------
+
+To flash the firmware you need dfu-util on the host. Issue
+
+    make dfu
+
+right after plugging the device into the USB port while the red led is
+still on.
+
+Refer to the included README file for more information.
+
 Licensing
 ---------
 

Makefile

@@ -17,7 +17,7 @@ shell=/bin/sh
 prefix=/lib/firmware
 install_program=install
 
-.PHONY:	all test clean install a56 as31 aica ath9k_htc_toolchain ath9k_htc av7110 b43-tools carl9170fw-toolchain carl9170fw cis-tools cis dsp56k ihex2fw isci keyspan_pda openfwwf usbdux
+.PHONY:	all test clean install a56 as31 aica ath9k_htc_toolchain ath9k_htc atusb av7110 b43-tools carl9170fw-toolchain carl9170fw cis-tools cis dsp56k ihex2fw isci keyspan_pda openfwwf usbdux
 
 all: aica ath9k_htc av7110 carl9170fw cis dsp56k isci keyspan_pda openfwwf usbdux
 
@@ -36,6 +36,9 @@ ath9k_htc_toolchain:
 ath9k_htc: ath9k_htc_toolchain
 	cd ath9k_htc && $(MAKE) -C target_firmware
 
+atusb:
+	cd atusb && $(MAKE)
+
 av7110:
 	cd av7110 && $(MAKE)
 
@@ -81,6 +84,7 @@ clean:
 	if [ -a as31/Makefile ]; then cd as31 && $(MAKE) clean; fi;
 	cd ath9k_htc && $(MAKE) toolchain-clean
 	cd ath9k_htc && $(MAKE) -C target_firmware clean
+	cd atusb && $(MAKE) clean
 	cd av7110 && $(MAKE) clean
 	cd carl9170fw/toolchain && $(MAKE) clean
 	if [ -a carl9170fw/Makefile ]; then cd carl9170fw && $(MAKE) clean; fi;

WHENCE

@@ -112,6 +112,18 @@ From https://github.com/qca/open-ath9k-htc-firmware
 
 --------------------------------------------------------------------------
 
+atusb: Firmware for the ATUSB IEEE 802.15.4 USB Adapter
+http://shop.sysmocom.de/products/atusb/
+
+From http://projects.qi-hardware.com/index.php/p/ben-wpan/source/tree/master/atusb/fw
+
+License: GPL-2.0-or-later
+
+Version: Based on commit 805db6ebf5d80692158acadf88e239da9d3e67af 
+dated September 13 2017
+
+--------------------------------------------------------------------------
+
 Driver: b43 - OpenFWWF -- Free firmware for some Broadcom 43xx series WLAN chips
 
 License: GPLv2

atusb/Makefile

@@ -0,0 +1,236 @@
+#
+# Makefile - Makefile of the ATUSB firmware
+#
+# Written 2010-2011, 2013 by Werner Almesberger
+# Copyright 2010-2011, 2013 by Werner Almesberger
+#
+# 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 2 of the License, or
+# (at your option) any later version.
+#
+
+SHELL = /bin/bash
+
+NAME = atusb
+DEBUG = false
+
+CFLAGS = -g -mmcu=$(CHIP) -DBOOT_ADDR=$(BOOT_ADDR) \
+	 -Wall -Wextra -Wshadow -Werror -Wno-unused-parameter \
+	 -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes
+
+ifeq ($(DEBUG),true)
+CFLAGS += -DDEBUG
+endif
+
+ifeq ($(NAME),rzusb)
+CHIP=at90usb1287
+CFLAGS += -DRZUSB -DAT86RF230
+else ifeq ($(NAME),hulusb)
+CHIP=at90usb1287
+CFLAGS += -DHULUSB -DAT86RF212
+else
+CHIP=atmega32u2
+CFLAGS += -DATUSB -DAT86RF231
+endif
+HOST=jlime
+BOOT_ADDR=0x7000
+
+AVR_PREFIX = $(BIN_PATH) avr-
+CC = $(AVR_PREFIX)gcc
+OBJCOPY = $(AVR_PREFIX)objcopy
+#OBJDUMP = $(AVR_PREFIX)objdump
+SIZE = $(AVR_PREFIX)size
+
+# BCD notion is 0xJJMM with JJ being major and MM being minor. Thus 0x0020 is
+# version 0.2 */
+USB_BCD_VERSION = 0030
+USB_VENDOR_ID = 20b7
+USB_PRODUCT_ID = 1540
+USB_ID = $(USB_VENDOR_ID):$(USB_PRODUCT_ID)
+
+OBJS = atusb.o board.o board_app.o sernum.o spi.o descr.o ep0.o \
+       dfu_common.o usb.o app-atu2.o mac.o
+BOOT_OBJS = boot.o board.o sernum.o spi.o flash.o dfu.o \
+            dfu_common.o usb.o boot-atu2.o
+
+ifeq ($(DEBUG),true)
+OBJS +=  uart.o
+endif
+
+ifeq ($(NAME),rzusb)
+OBJS += board_rzusb.o
+BOOT_OBJS += board_rzusb.o
+else ifeq ($(NAME),hulusb)
+OBJS += board_hulusb.o
+BOOT_OBJS += board_hulusb.o
+else
+OBJS += board_atusb.o
+BOOT_OBJS += board_atusb.o
+endif
+
+
+vpath %.c usb/
+
+CFLAGS += -Iinclude -Iusb -I.
+
+# ----- Verbosity control -----------------------------------------------------
+
+CC_normal	:= $(CC)
+BUILD_normal	:=
+DEPEND_normal	:= $(CPP) $(CFLAGS) -MM -MG
+
+CC_quiet	= @echo "  CC       " $@ && $(CC_normal)
+BUILD_quiet	= @echo "  BUILD    " $@ && $(BUILD_normal)
+DEPEND_quiet	= @$(DEPEND_normal)
+
+ifeq ($(V),1)
+    CC		= $(CC_normal)
+    BUILD	= $(BUILD_normal)
+    DEPEND	= $(DEPEND_normal)
+else
+    CC		= $(CC_quiet)
+    BUILD	= $(BUILD_quiet)
+    DEPEND	= $(DEPEND_quiet)
+endif
+
+# ----- Rules -----------------------------------------------------------------
+
+.PHONY:		all clean upload prog dfu update version.c bindist
+.PHONY:		prog-app prog-read on off reset
+
+all:		$(NAME).bin boot.hex
+
+$(NAME).elf:	$(OBJS)
+		$(MAKE) version.o
+		$(CC) $(CFLAGS) -o $@ $(OBJS) version.o
+		$(SIZE) $@
+
+boot.elf:	$(BOOT_OBJS)
+		$(CC) $(CFLAGS) -o $@ $(BOOT_OBJS) \
+		  -Wl,--section-start=.text=$(BOOT_ADDR)
+		$(SIZE) $@
+
+%.bin:		%.elf
+		$(BUILD) $(OBJCOPY) -j .text -j .data -O binary $< $@
+		@echo "build #`cat .version`, `ls -l $@`"
+
+%.dfu:		%.bin
+		cp $(NAME).bin $(NAME).dfu
+		dfu-suffix -a $(NAME).dfu -d 0x$(USB_BCD_VERSION) \
+		  -p 0x$(USB_PRODUCT_ID) -v 0x$(USB_VENDOR_ID)
+
+%.hex:		%.elf
+		$(BUILD) $(OBJCOPY) -j .text -j .data -O ihex $< $@
+		@echo "Size: `$(SIZE) -A boot.hex | sed '/Total */s///p;d'` B"
+
+# ----- Cleanup ---------------------------------------------------------------
+
+clean:
+		rm -f $(NAME).bin $(NAME).elf $(NAME).dfu
+		rm -f $(OBJS) $(OBJS:.o=.d)
+		rm -f boot.hex boot.elf
+		rm -f $(BOOT_OBJS) $(BOOT_OBJS:.o=.d)
+		rm -f version.c version.d version.o
+
+# ----- Build version ---------------------------------------------------------
+
+version.c:
+		@if [ -f .version ]; then \
+		    v=`cat .version`; \
+		    expr $$v + 1 >.version; \
+		else \
+		    echo 0 >.version; \
+		fi
+		@[ -s .version ] || echo 0 >.version
+		@echo '/* MACHINE-GENERATED. DO NOT EDIT ! */' >version.c
+		@echo '#include "version.h"' >>version.c
+		@echo "const char *build_date = \"`date`\";" >>version.c
+		@echo "const uint16_t build_number = `cat .version`;" \
+		  >>version.c
+
+# ----- Dependencies ----------------------------------------------------------
+
+MKDEP =									\
+	$(DEPEND) $< |							\
+	  sed 								\
+	    -e 's|^$(basename $(notdir $<)).o:|$@:|'			\
+	    -e '/^\(.*:\)\? */{p;s///;s/ *\\\?$$/ /;s/  */:\n/g;H;}'	\
+	    -e '$${g;p;}'						\
+	    -e d >$(basename $@).d;					\
+	  [ "$${PIPESTATUS[*]}" = "0 0" ] ||				\
+	  { rm -f $(basename $@).d; exit 1; }
+
+%.o:            %.c
+		$(CC) $(CFLAGS) -Os -c $<
+		$(MKDEP)
+
+-include $(OBJS:.o=.d)
+
+# ----- Object file variants --------------------------------------------------
+
+app-%.o:	usb/%.c
+		$(CC) $(CFLAGS) -Os -o $@ -c $<
+		$(MKDEP)
+
+boot-%.o:	usb/%.c
+		$(CC) $(CFLAGS) -DBOOT_LOADER -Os -o $@ -c $<
+		$(MKDEP)
+
+# ----- Distribution ----------------------------------------------------------
+
+BINDIST_BASE=http://downloads.qi-hardware.com/people/werner/wpan/bindist
+ATUSB_BIN_NAME=atusb-`git rev-parse HEAD | cut -c 1-7`.bin
+
+bindist:
+		qippl atusb.bin wpan/bindist/$(ATUSB_BIN_NAME)
+		@echo $(BINDIST_BASE)/$(ATUSB_BIN_NAME)
+		@echo md5sum: `md5sum atusb.bin | sed 's/ .*//'`
+		@echo atrf-id: \
+		  `sed '/.*number = \(.*\);/s//#\1/p;d' version.c` \
+		  `sed '/.*date = "\(.*\)";/s//\1/p;d' version.c`
+
+# ----- Programming and device control ----------------------------------------
+
+upload:		$(NAME).bin boot.hex
+		scp $(NAME).bin boot.hex $(HOST):
+
+# lfuse: external clock, slow start-up
+# hfuse: 4 kB boot loader, reset into boot loader
+# lock: allow everything but SPM to the boot loader
+#       Note: when trying to program 0xef, we get back 0x2f, failing
+#	      verification. So we just program 0x2f.
+
+prog-app:
+		ssh $(HOST) avrdude -F -p $(CHIP) -c nanonote_atusb -e \
+		  -U flash:w:atusb.bin:r \
+		  -U lfuse:w:0x60:m
+
+prog:
+		ssh $(HOST) avrdude -F -p $(CHIP) -c nanonote_atusb -e \
+		  -U flash:w:boot.hex:i \
+		  -U lfuse:w:0x60:m \
+		  -U hfuse:w:0xd8:m \
+		  -U lock:w:0x2f:m
+
+prog-read:
+		ssh $(HOST) avrdude -F -p $(CHIP) -c nanonote_atusb \
+		  -U flash:r:mcu.bin:r
+
+dfu:		$(NAME).dfu
+		dfu-util -d $(USB_ID) -D $(NAME).dfu
+
+update:		$(NAME).bin
+		-atrf-reset -a
+		usbwait -r -i 0.01 -t 5 $(USB_ID)
+		$(MAKE) dfu
+
+on:
+		ssh $(HOST) poke 0x10010318 4
+
+off:
+		ssh $(HOST) poke 0x10010314 4
+
+reset:
+		ssh $(HOST) poke 0x10010318 2048
+		ssh $(HOST) poke 0x10010314 2048

atusb/README

@@ -0,0 +1,94 @@
+Requires a very recent toolchain, because ATmega32U2 is relatively new.
+
+- Building:
+
+  make
+
+- Uploading the firmware to a Ben (for flashing with the atusb-pgm cable):
+
+  make HOST=<hostname> upload
+
+  Example:
+
+  make HOST=ben upload
+
+  HOST defaults to "jlime".
+
+- Flashing the boot loader:
+
+  Prerequisite: avrdude on the Ben.
+
+  Disconnect the atusb board from USB. Insert the atusb-pgm connector into
+  the Ben. Place the atusb-pgm adapter on the exposed contact pads of the
+  atusb board and push it down. Then run
+
+  make prog
+
+  This takes about 30 seconds. If the programming fails with an error
+  message like "Yikes!  Invalid device signature.", verify that the
+  atusb-pgm board is properly connected and placed, then try again.
+
+- Uploading the application:
+
+  Prerequisite: dfu-util installed on the PC.
+
+  Insert atusb into the PC, then run
+
+  make dfu
+
+  Note: since the boot loader resets the USB bus after timing out,
+  this operation can fail with a message like "No DFU capable USB device
+  found". Just retry, and it will eventually get through.
+
+
+HULUSB notes:
+-------------
+To prepare and flash the firmware on a HULUSB device some additional steps are
+needed;
+
+avr-objcopy -O ihex -R .signature -R .fuse -R .eeprom hulusb.elf hulusb.hex
+dfu-programmer at90usb1287 flash hulusb.hex
+dfu-programmer at90usb1287 reset
+
+--------------------------
+
+Making the toolchain:
+
+# patches according to
+# http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=789527
+
+# some gcc prerequisites
+
+apt-get remove avr-libc gcc-avr binutils-avr
+apt-get install libmpfr-dev libmpc-dev
+
+# binutils
+
+wget http://ftp.gnu.org/gnu/binutils/binutils-2.21.tar.bz2
+tar xfj binutils-2.21.tar.bz2 
+cd binutils-2.21
+./configure --target=avr --disable-nls
+make
+make install
+
+# gcc
+
+wget http://ftpmirror.gnu.org/gcc/gcc-4.5.2/gcc-4.5.2.tar.bz2
+wget -O gcc_452_avr.patch http://gcc.gnu.org/bugzilla/attachment.cgi?id=23050
+tar xfj gcc-4.5.2.tar.bz2
+cd gcc-4.5.2
+patch -p1 -s <../gcc_452_avr.patch
+mkdir obj-avr
+cd obj-avr
+../configure --target=avr --enable-languages=c \
+    --disable-nls --disable-libssp --with-dwarf2
+make
+make install
+
+wget http://download.savannah.gnu.org/releases/avr-libc/avr-libc-1.7.1.tar.bz2
+tar xfj avr-libc-1.7.1.tar.bz2 
+cd avr-libc-1.7.1
+./bootstrap	# the automake at the end takes a while
+./configure --build=`./config.guess` --host=avr
+make
+make install

atusb/an/README

@@ -0,0 +1,25 @@
+workflow:
+
+- connect zprobe (note: it currently inverts because it didn't have any
+  other chips around. this may change later.)
+
+- capture the USB signals at an interesting moment with a sample rate of
+  50 MSa/s
+
+- zoom into the frame(s) of interest
+
+- download the data with
+  ./get.py
+
+- decode with
+  ./dec.py
+
+  For manual decoding, set the coders to D+ and D- (we need D- for SE0
+  and SE1 detection), then click on a rising clock edge left of the
+  packet and move the cursor to the right.
+
+- if there are problems with the clock, the analog signal and digital
+  signals derived from it can be examined after running dec.py with
+  ./plot
+
+  (Note that the digital zprobe hides any analog anomalies.)

atusb/an/dec.py

@@ -0,0 +1,127 @@
+#!/usr/bin/python
+
+from tmc.wave import *
+from tmc.dxplore import dxplore
+from tmc.decode import d_usb_stream
+
+
+#
+# Clock recovery: we assume that each change in the wave is triggered by a
+# clock edge. We know the clock's nominal period and resynchronize on each
+# edge. Additionally, we can obtain a list of times when a timing violation
+# has occurred.
+#
+# Note that the timing violations logic doesn't make much sense in its present
+# form, since it mainly measures noise (particularly if we're digitizing slow
+# edges) and not clock drift.
+#
+# A more useful metric would be accumulated error from some point of reference
+# or at least the timing of same edges, to eliminate (generally harmless) time
+# offsets introduced by digitizing.
+#
+# So it would probably make more sense for "recover" not to check for timing
+# violations at all, and leave this to more specialized functions.
+#
+def recover(self, period, min = None, max = None, t0 = None):
+    if t0 is None:
+	t0 = self.data[0]
+    v = not self.initial
+    res = []
+    violations = []
+    for t in self.data:
+	v = not v
+	if t <= t0:
+	    continue
+	n = 0
+	while t0 < t-period/2:
+	    res.append(t0)
+	    t0 += period
+	    n += 1
+	if min is not None:
+	    if t0-t > n*min:
+		violations.append(t)
+	if max is not None:
+	    if t-t0 > n*max:
+		violations.append(t)
+	t0 = t
+    return res, violations
+
+
+#
+# Load the analog waves saved by get.py
+#
+wv = waves()
+wv.load("_wv")
+
+#
+# Digitize the waves and save the result.
+#
+dp = wv[0].digitize(1.5, 1.8)
+dm = wv[1].digitize(1.5, 1.8)
+wv = waves(dp, dm, dp-dm)
+wv.save("_dig")
+
+#
+# Also record the differential signal.
+#
+wd = wv[1]-wv[0]
+dd = wd.digitize(-0.5, 0.5)
+wd.save("_diff")
+
+#
+# Run clock recovery on D+/D-. We only need one, but check both to be sure.
+#
+#p = 1/1.5e6
+p = 1/12e6
+dp_t, viol = recover(dp, p, p*0.9, p*1.1)
+print viol
+dm_t, viol = recover(dm, p, p*.9, p*1.1, t0 = dp.data[0])
+print viol
+
+#
+# Shift the clock by half a period, add a few periods to get steady state and
+# SE0s (if any), and then sample the data lines.
+#
+clk = map(lambda t: t+p/2, dp_t)
+clk.extend((clk[-1]+p, clk[-1]+2*p, clk[-1]+3*p))
+dp_bv = dp.get(clk)
+dm_bv = dm.get(clk)
+
+#
+# Save a wave with the recovered clock to make it easier to find the bits in
+# analog graphs.
+#
+dd.data = dp_t;
+dd.save("_clk")
+
+#
+# For decoding, we need a fake bit clock. We generate it by doubling each data
+# bit and generating a L->H transition during this bit.
+#
+dpd = []
+dmd = []
+dck = []
+
+# err, silly, seems that we've mixed up D+ and D- all over the place :-)
+print d_usb_stream(dm_bv[:], dp_bv[:])
+
+for v in dp_bv:
+    dpd.append(v)
+    dpd.append(v)
+    dck.append(0)
+    dck.append(1)
+
+for v in dm_bv:
+    dmd.append(v)
+    dmd.append(v)
+
+#
+# Display the reconstructed digital signal. Note that the absolute time is only
+# correct at the beginning and that relative time is only accurate over
+# intervals in which no significant clock resynchronization has occurred.
+#
+# In fact, dxplore should probably have an option to either turn off time
+# entirely or to display a user-provided time axis. The latter may be a bit
+# tricky to implement.
+#
+dxplore((dmd, dpd, dck), 0, p/2, labels = ("D+", "D-", "CLK"))

atusb/an/get.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python
+
+from tmc.scope import rigol_ds1000c
+
+#-800, +1600
+s = rigol_ds1000c()
+#s.debug = False
+
+pos = s.hor.pos
+scale = s.hor.scale
+t0 = pos-scale*s.div_hor/2
+t1 = pos+scale*s.div_hor/2
+print t0, t1
+
+#zoom = 10
+#step = scale/s.samples_per_div/zoom
+#print step
+step = 4e-9
+step = 2e-9
+
+w = s.wave((s.ch[0], s.ch[1]), start = t0, end = t1, step = step)
+w[0] = 3.3-w[0]
+w[1] = 3.3-w[1]
+
+s.hor.pos = pos
+s.hor.scale = scale
+
+w[0].label = "D+";
+w[1].label = "D-";
+
+w.save("_wv")

atusb/an/plot

@@ -0,0 +1,12 @@
+#!/bin/sh
+#
+# Plot output of "dec"
+#
+gnuplot -persist <<EOF
+set style data lines
+plot "_wv" using 1:(\$2-4), \
+  "_dig" using 1:(\$2*3.3-4) lw 2, \
+  "_wv" using 1:3, \
+  "_dig" using 1:(\$3*3.3) lw 2, \
+  "_clk" using 1:(\$2+1) lt 7
+EOF

atusb/atusb.c

@@ -0,0 +1,63 @@
+/*
+ * fw/atusb.c - ATUSB initialization and main loop
+ *
+ * Written 2008-2011 by Werner Almesberger
+ * Copyright 2008-2011 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/sleep.h>
+#include <avr/interrupt.h>
+
+#include "usb.h"
+
+#include "board.h"
+#include "sernum.h"
+#include "spi.h"
+#include "atusb/ep0.h"
+
+#ifdef DEBUG
+#include "uart.h"
+#endif
+
+
+int main(void)
+{
+	board_init();
+	board_app_init();
+	reset_rf();
+
+	user_get_descriptor = sernum_get_descr;
+
+	/* now we should be at 8 MHz */
+
+#ifdef DEBUG
+	uart_init();
+	static FILE atben_stdout = FDEV_SETUP_STREAM(uart_write_char, NULL,
+						     _FDEV_SETUP_WRITE);
+	stdout = &atben_stdout;
+#endif
+
+	usb_init();
+	ep0_init();
+#ifdef ATUSB
+	timer_init();
+
+	/* move interrupt vectors to 0 */
+	MCUCR = 1 << IVCE;
+	MCUCR = 0;
+#endif
+
+	sei();
+
+	while (1)
+		sleep_mode();
+}

atusb/board.c

@@ -0,0 +1,120 @@
+/*
+ * fw/board.c - Board-specific functions (for boot loader and application)
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/boot.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include "usb.h"
+#include "at86rf230.h"
+#include "board.h"
+#include "spi.h"
+
+
+uint8_t board_sernum[42] = { 42, USB_DT_STRING };
+
+/* ----- Register access --------------------------------------------------- */
+
+void change_state(uint8_t new)
+{
+	while ((reg_read(REG_TRX_STATUS) & TRX_STATUS_MASK) ==
+		TRX_STATUS_TRANSITION);
+	reg_write(REG_TRX_STATE, new);
+}
+
+
+uint8_t reg_read(uint8_t reg)
+{
+	uint8_t value;
+
+	spi_begin();
+	spi_send(AT86RF230_REG_READ | reg);
+	value = spi_recv();
+	spi_end();
+
+	return value;
+}
+
+
+uint8_t subreg_read(uint8_t address, uint8_t mask, uint8_t position)
+{
+	/* Read current register value and mask out subregister. */
+	uint8_t register_value = reg_read(address);
+	register_value &= mask;
+	register_value >>= position; /* Align subregister value. */
+
+	return register_value;
+}
+
+
+void reg_write(uint8_t reg, uint8_t value)
+{
+	spi_begin();
+	spi_send(AT86RF230_REG_WRITE | reg);
+	spi_send(value);
+	spi_end();
+}
+
+
+void subreg_write(uint8_t address, uint8_t mask, uint8_t position, uint8_t value)
+{
+	/* Read current register value and mask area outside the subregister. */
+	uint8_t register_value = reg_read(address);
+	register_value &= ~mask;
+
+	/* Start preparing the new subregister value. shift in place and mask. */
+	value <<= position;
+	value &= mask;
+
+	value |= register_value; /* Set the new subregister value. */
+
+	/* Write the modified register value. */
+	reg_write(address, value);
+}
+
+
+void panic(void)
+{
+	cli();
+	while (1) {
+		SET(LED);
+		_delay_ms(100);
+		CLR(LED);
+		_delay_ms(100);
+	}
+}
+
+
+static char hex(uint8_t nibble)
+{
+	return nibble < 10 ? '0'+nibble : 'a'+nibble-10;
+}
+
+
+void get_sernum(void)
+{
+	uint8_t sig;
+	uint8_t i;
+
+	for (i = 0; i != 10; i++) {
+		sig = boot_signature_byte_get(i+0xe);
+		board_sernum[(i << 2)+2] = hex(sig >> 4);
+		board_sernum[(i << 2)+4] = hex(sig & 0xf);
+	}
+}

atusb/board.h

@@ -0,0 +1,95 @@
+/*
+ * fw/board.h - Board-specific functions and definitions
+ *
+ * Written 2008-2011, 2013, 2013 by Werner Almesberger
+ * Copyright 2008-2011, 2013, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef BOARD_H
+#define	BOARD_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <atusb/atusb.h>
+
+#ifdef ATUSB
+#include "board_atusb.h"
+#endif
+#ifdef RZUSB
+#include "board_rzusb.h"
+#endif
+#ifdef HULUSB
+#include "board_hulusb.h"
+#endif
+
+#define	SET_2(p, b)	PORT##p |= 1 << (b)
+#define	CLR_2(p, b)	PORT##p &= ~(1 << (b))
+#define	IN_2(p, b)	DDR##p &= ~(1 << (b))
+#define	OUT_2(p, b)	DDR##p |= 1 << (b)
+#define	PIN_2(p, b)	((PIN##p >> (b)) & 1)
+
+#define	SET_1(p, b)	SET_2(p, b)
+#define	CLR_1(p, b)	CLR_2(p, b)
+#define	IN_1(p, b)	IN_2(p, b)
+#define	OUT_1(p, b)	OUT_2(p, b)
+#define	PIN_1(p, b)	PIN_2(p, b)
+
+#define	SET(n)		SET_1(n##_PORT, n##_BIT)
+#define	CLR(n)		CLR_1(n##_PORT, n##_BIT)
+#define	IN(n)		IN_1(n##_PORT, n##_BIT)
+#define	OUT(n)		OUT_1(n##_PORT, n##_BIT)
+#define	PIN(n)		PIN_1(n##_PORT, n##_BIT)
+
+
+#define	USB_VENDOR	ATUSB_VENDOR_ID
+#define	USB_PRODUCT	ATUSB_PRODUCT_ID
+
+#define	DFU_USB_VENDOR	USB_VENDOR
+#define	DFU_USB_PRODUCT	USB_PRODUCT
+
+
+#define	BOARD_MAX_mA	40
+
+#ifdef BOOT_LOADER
+#define	NUM_EPS	1
+#else
+#define	NUM_EPS	2
+#endif
+
+#define	HAS_BOARD_SERNUM
+
+extern uint8_t board_sernum[42];
+extern uint8_t irq_serial;
+
+
+void reset_rf(void);
+void reset_cpu(void);
+uint8_t read_irq(void);
+void slp_tr(void);
+
+void led(bool on);
+void panic(void);
+
+uint64_t timer_read(void);
+void timer_init(void);
+
+bool gpio(uint8_t port, uint8_t data, uint8_t dir, uint8_t mask, uint8_t *res);
+void gpio_cleanup(void);
+
+void get_sernum(void);
+
+void board_app_init(void);
+
+uint8_t reg_read(uint8_t reg);
+uint8_t subreg_read(uint8_t address, uint8_t mask, uint8_t position);
+void reg_write(uint8_t reg, uint8_t value);
+void subreg_write(uint8_t address, uint8_t mask, uint8_t position, uint8_t value);
+void change_state(uint8_t new);
+
+#endif /* !BOARD_H */

atusb/board_app.c

@@ -0,0 +1,173 @@
+/*
+ * fw/board_app.c - Board-specific functions (for the application)
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include "usb.h"
+#include "at86rf230.h"
+#include "spi.h"
+#include "mac.h"
+#include "board.h"
+
+
+static volatile uint32_t timer_h = 0;	/* 2^(16+32) / 8 MHz = ~1.1 years */
+
+
+void reset_cpu(void)
+{
+	WDTCSR = 1 << WDE;
+}
+
+
+uint8_t read_irq(void)
+{
+	return PIN(IRQ_RF);
+}
+
+
+void slp_tr(void)
+{
+	SET(SLP_TR);
+	CLR(SLP_TR);
+}
+
+
+ISR(TIMER1_OVF_vect)
+{
+	timer_h++;
+}
+
+
+uint64_t timer_read(void)
+{
+	uint32_t high;
+	uint8_t low, mid;
+
+	do {
+		if (TIFR1 & (1 << TOV1)) {
+			TIFR1 = 1 << TOV1;
+			timer_h++;
+		}
+		high = timer_h;
+		low = TCNT1L;
+		mid = TCNT1H;
+	}
+	while (TIFR1 & (1 << TOV1));
+
+	/*
+	 * We need all these casts because the intermediate results are handled
+	 * as if they were signed and thus get sign-expanded. Sounds wrong-ish.
+	 */
+	return (uint64_t) high << 16 | (uint64_t) mid << 8 | (uint64_t) low;
+}
+
+
+void timer_init(void)
+{
+	/* configure timer 1 as a free-running CLK counter */
+
+	TCCR1A = 0;
+	TCCR1B = 1 << CS10;
+
+	/* enable timer overflow interrupt */
+
+	TIMSK1 = 1 << TOIE1;
+}
+
+
+bool gpio(uint8_t port, uint8_t data, uint8_t dir, uint8_t mask, uint8_t *res)
+{
+	EIMSK = 0; /* recover INT_RF to ATUSB_GPIO_CLEANUP or an MCU reset */
+
+	switch (port) {
+	case 1:
+		DDRB = (DDRB & ~mask) | dir;
+		PORTB = (PORTB & ~mask) | data;
+		break;
+	case 2:
+		DDRC = (DDRC & ~mask) | dir;
+		PORTC = (PORTC & ~mask) | data;
+		break;
+	case 3:
+		DDRD = (DDRD & ~mask) | dir;
+		PORTD = (PORTD & ~mask) | data;
+		break;
+	default:
+		return 0;
+	}
+
+	/* disable the UART so that we can meddle with these pins as well. */
+	spi_off();
+	_delay_ms(1);
+
+	switch (port) {
+	case 1:
+		res[0] = PINB;
+		res[1] = PORTB;
+		res[2] = DDRB;
+		break;
+	case 2:
+		res[0] = PINC;
+		res[1] = PORTC;
+		res[2] = DDRC;
+		break;
+	case 3:
+		res[0] = PIND;
+		res[1] = PORTD;
+		res[2] = DDRD;
+		break;
+	}
+
+	return 1;
+}
+
+
+void gpio_cleanup(void)
+{
+	EIMSK = 1 << 0;
+}
+
+
+static void done(void *user)
+{
+	led(0);
+}
+
+
+uint8_t irq_serial;
+
+#if defined(ATUSB) || defined(HULUSB)
+ISR(INT0_vect)
+#endif
+#ifdef RZUSB
+ISR(TIMER1_CAPT_vect)
+#endif
+{
+	if (mac_irq) {
+		if (mac_irq())
+			return;
+	}
+	if (eps[1].state == EP_IDLE) {
+		led(1);
+		irq_serial = (irq_serial+1) | 0x80;
+		usb_send(&eps[1], &irq_serial, 1, done, NULL);
+	}
+}

atusb/board_atusb.c

@@ -0,0 +1,162 @@
+/*
+ * fw/board_atusb.c - ATUSB Board-specific functions (for boot loader and application)
+ *
+ * Written 2016 by Stefan Schmidt
+ * Copyright 2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/boot.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include "usb.h"
+#include "at86rf230.h"
+#include "board.h"
+#include "spi.h"
+#include "usb/usb.h"
+
+static bool spi_initialized = 0;
+
+void reset_rf(void)
+{
+	/* set up all the outputs; default port value is 0 */
+
+	DDRB = 0;
+	DDRC = 0;
+	DDRD = 0;
+	PORTB = 0;
+	PORTC = 0;
+	PORTD = 0;
+
+	OUT(LED);
+	OUT(nRST_RF);   /* this also resets the transceiver */
+	OUT(SLP_TR);
+
+	spi_init();
+
+	/* AT86RF231 data sheet, 12.4.13, reset pulse width: 625 ns (min) */
+
+	CLR(nRST_RF);
+	_delay_us(2);
+	SET(nRST_RF);
+
+	/* 12.4.14: SPI access latency after reset: 625 ns (min) */
+
+	_delay_us(2);
+
+	/* we must restore TRX_CTRL_0 after each reset (9.6.4) */
+
+	set_clkm();
+}
+
+void led(bool on)
+{
+	if (on)
+		SET(LED);
+	else
+		CLR(LED);
+}
+
+void set_clkm(void)
+{
+	/* switch CLKM to 8 MHz */
+
+	/*
+	 * @@@ Note: Atmel advise against changing the external clock in
+	 * mid-flight. We should therefore switch to the RC clock first, then
+	 * crank up the external clock, and finally switch back to the external
+	 * clock. The clock switching procedure is described in the ATmega32U2
+	 * data sheet in secton 8.2.2.
+	 */
+	spi_begin();
+	spi_send(AT86RF230_REG_WRITE | REG_TRX_CTRL_0);
+	spi_send(CLKM_CTRL_8MHz);
+	spi_end();
+}
+
+void board_init(void)
+{
+	/* Disable the watchdog timer */
+
+	MCUSR = 0;		/* Remove override */
+	WDTCSR |= 1 << WDCE;	/* Enable change */
+	WDTCSR = 1 << WDCE;	/* Disable watchdog while still enabling
+				   change */
+
+	CLKPR = 1 << CLKPCE;
+	/* We start with a 1 MHz/8 clock. Disable the prescaler. */
+	CLKPR = 0;
+
+	get_sernum();
+}
+
+void spi_begin(void)
+{
+	if (!spi_initialized)
+		spi_init();
+	CLR(nSS);
+}
+
+void spi_off(void)
+{
+	spi_initialized = 0;
+	UCSR1B = 0;
+}
+
+void spi_init(void)
+{
+	SET(nSS);
+	OUT(SCLK);
+	OUT(MOSI);
+	OUT(nSS);
+	IN(MISO);
+
+	UBRR1 = 0;	/* set bit rate to zero to begin */
+	UCSR1C = 1 << UMSEL11 | 1 << UMSEL10;
+			/* set MSPI, MSB first, SPI data mode 0 */
+	UCSR1B = 1 << RXEN1 | 1 << TXEN1;
+			/* enable receiver and transmitter */
+	UBRR1 = 0;	/* reconfirm the bit rate */
+
+	spi_initialized = 1;
+}
+
+void usb_init(void)
+{
+	USBCON |= 1 << FRZCLK;		/* freeze the clock */
+
+	/* enable the PLL and wait for it to lock */
+	PLLCSR &= ~(1 << PLLP2 | 1 << PLLP1 | 1 << PLLP0);
+	PLLCSR |= 1 << PLLE;
+	while (!(PLLCSR & (1 << PLOCK)));
+
+	USBCON &= ~(1 << USBE);		/* reset the controller */
+	USBCON |= 1 << USBE;
+
+	USBCON &= ~(1 << FRZCLK);	/* thaw the clock */
+
+	UDCON &= ~(1 << DETACH);	/* attach the pull-up */
+	UDIEN = 1 << EORSTE;		/* enable device interrupts  */
+//	UDCON |= 1 << RSTCPU;		/* reset CPU on bus reset */
+
+	ep_init();
+}
+
+void board_app_init(void)
+{
+	/* enable INT0, trigger on rising edge */
+	EICRA = 1 << ISC01 | 1 << ISC00;
+	EIMSK = 1 << 0;
+}

atusb/board_atusb.h

@@ -0,0 +1,48 @@
+/*
+ * fw/board_atusb.h - ATUSB Board-specific functions and definitions
+ *
+ * Written 2016 by Stefan Schmidt
+ * Copyright 2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef BOARD_ATUSB_H
+#define	BOARD_ATUSB_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define	LED_PORT	B
+#define	LED_BIT		  6
+#define	nRST_RF_PORT	C
+#define	nRST_RF_BIT	  7
+#define	SLP_TR_PORT	B
+#define	SLP_TR_BIT	  4
+
+#define SCLK_PORT	D
+#define SCLK_BIT	  5
+#define	MOSI_PORT	D
+#define	MOSI_BIT	  3
+
+#define	MISO_PORT	D
+#define	MISO_BIT	  2
+#define	nSS_PORT	D
+#define	nSS_BIT		  1
+#define	IRQ_RF_PORT	D
+#define	IRQ_RF_BIT	  0
+
+#define SPI_WAIT_DONE()	while (!(UCSR1A & 1 << RXC1))
+#define SPI_DATA	UDR1
+
+void set_clkm(void);
+void board_init(void);
+
+void spi_begin(void);
+void spi_off(void);
+void spi_init(void);
+
+#endif /* !BOARD_H */

atusb/board_hulusb.c

@@ -0,0 +1,179 @@
+/*
+ * fw/board_hulusb.c - Busware HUL Board-specific functions (for boot loader and application)
+ *
+ * Written 2017 by Filzmaier Josef
+ * Based on fw/board_rzusb written and Copyright 2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/boot.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include "usb.h"
+#include "at86rf230.h"
+#include "board.h"
+#include "spi.h"
+#include "usb/usb.h"
+
+static bool spi_initialized = 0;
+
+void reset_rf(void)
+{
+	/* set up all the outputs; default port value is 0 */
+
+	DDRB = 0;
+	DDRC = 0;
+	DDRD = 0;
+	PORTB = 0;
+	PORTC = 0;
+	PORTD = 0;
+
+	OUT(LED_RED);
+	OUT(LED_GREEN);
+	SET(LED_RED); /* Leds are active low on HULUSB board */
+	CLR(LED_GREEN); /* Green Led indicates the dongle is running */
+	OUT(nRST_RF);   /* this also resets the transceiver */
+	OUT(SLP_TR);
+
+	spi_init();
+
+	/* AT86RF212 data sheet, Appendix B, p166 Power-On Reset procedure */
+	/*-----------------------------------------------------------------*/
+	CLR(SLP_TR);
+	SET(nRST_RF);
+	SET(nSS);
+	_delay_us(400);
+
+	CLR(nRST_RF);
+	_delay_us(2);
+	SET(nRST_RF);
+
+	/* 5.1.4.5: Wait t10: 625 ns (min) */
+
+	_delay_us(2);
+
+	reg_write(REG_TRX_CTRL_0, 0x19);
+
+	change_state(TRX_CMD_FORCE_TRX_OFF);
+	/*-----------------------------------------------------------------*/
+
+	/* we must restore TRX_CTRL_0 after each reset (7.7.4) */
+
+	set_clkm();
+}
+
+void led_red(bool on) {
+	if (on)
+		CLR(LED_RED);
+	else
+		SET(LED_RED);
+}
+
+void led_green(bool on) {
+	if (on)
+		CLR(LED_GREEN);
+	else
+		SET(LED_GREEN);
+}
+
+void led(bool on)
+{
+	led_red(on);
+}
+
+void set_clkm(void)
+{
+	/* CLKM is not connected on BUSWARE HUL and therefore it is running in
+	 * async mode. */
+	reg_write(REG_TRX_CTRL_0, 0x00);
+
+	/* TX_AUTO_CRC_ON, default disabled */
+	subreg_write(SR_TX_AUTO_CRC_ON, 1);
+}
+
+void board_init(void)
+{
+	/* Disable the watchdog timer */
+
+	MCUSR = 0;		/* Remove override */
+	WDTCSR |= 1 << WDCE;	/* Enable change */
+	WDTCSR = 1 << WDCE;	/* Disable watchdog while still enabling
+	change */
+
+	CLKPR = 1 << CLKPCE;
+	/* We start with a 16 MHz/8 clock. Put the prescaler to 2. */
+	CLKPR = 1 << CLKPS0;
+
+	get_sernum();
+}
+
+void spi_begin(void)
+{
+	if (!spi_initialized)
+		spi_init();
+	CLR(nSS);
+}
+
+void spi_off(void)
+{
+	spi_initialized = 0;
+	SPCR &= ~(1 << SPE);
+}
+
+void spi_init(void)
+{
+	SET(nSS);
+	OUT(SCLK);
+	OUT(MOSI);
+	OUT(nSS);
+	IN(MISO);
+
+	SPCR = (1 << SPE) | (1 << MSTR);
+	SPSR = (1 << SPI2X);
+
+	spi_initialized = 1;
+}
+
+void usb_init(void)
+{
+	USBCON |= 1 << FRZCLK;		/* freeze the clock */
+
+	/* enable the PLL and wait for it to lock */
+	/* TODO sheet page 50 For Atmel AT90USB128x only. Do not use with Atmel AT90USB64x. */
+	/*  FOR 8 XTAL Mhz only!!! */
+	PLLCSR = ((1 << PLLP1) | (1 << PLLP0));
+	PLLCSR |= 1 << PLLE;
+	while (!(PLLCSR & (1 << PLOCK)));
+
+	UHWCON |= (1 << UVREGE);
+
+	USBCON &= ~((1 << USBE) | (1 << OTGPADE));		/* reset the controller */
+	USBCON |= ((1 << USBE) | (1 << OTGPADE));
+
+	USBCON &= ~(1 << FRZCLK);	/* thaw the clock */
+
+	UDCON &= ~(1 << DETACH);	/* attach the pull-up */
+	UDIEN = 1 << EORSTE;		/* enable device interrupts  */
+	//	UDCON |= 1 << RSTCPU;		/* reset CPU on bus reset */
+
+	ep_init();
+}
+
+void board_app_init(void)
+{
+	/* enable INT0, trigger on rising edge */
+	EICRA = 1 << ISC01 | 1 << ISC00;
+	EIMSK = 1 << INT0;
+}

atusb/board_hulusb.h

@@ -0,0 +1,66 @@
+/*
+ * fw/board_hulusb.h - Busware HUL Board-specific functions (for boot loader and application)
+ *
+ * Written 2017 by Filzmaier Josef
+ * Based on fw/board_rzusb written and Copyright 2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef BOARD_HULUSB_H
+#define	BOARD_HULUSB_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define LED_RED_PORT		A
+#define LED_GREEN_PORT		A
+#define LED_RED_BIT		3
+#define LED_GREEN_BIT 		4
+#define LED_PORT		LED_RED_PORT
+#define LED_BIT		  	LED_RED_BIT
+
+#define nRST_RF_PORT		B
+#define nRST_RF_BIT	  	5
+#define SLP_TR_PORT		B
+#define SLP_TR_BIT	  	4
+
+#define SCLK_PORT		B
+#define SCLK_BIT	  	1
+#define MOSI_PORT		B
+#define MOSI_BIT	  	2
+
+#define MISO_PORT		B
+#define MISO_BIT	  	3
+#define nSS_PORT		B
+#define nSS_BIT		  	0
+#define IRQ_RF_PORT		D
+#define IRQ_RF_BIT	  	4
+
+#define SR_TX_AUTO_CRC_ON	0x04, 0x20, 5
+#define SR_CHANNEL		0x08, 0x1f, 0
+
+#define RG_CC_CTRL_1		(0x14)
+
+#define SPI_WAIT_DONE()	while ((SPSR & (1 << SPIF)) == 0)
+#define SPI_DATA	SPDR
+
+void set_clkm(void);
+void board_init(void);
+
+void led_red(bool on);
+void led_green(bool on);
+
+void spi_begin(void);
+void spi_off(void);
+void spi_init(void);
+
+#ifdef DEBUG
+void printStatus(void);
+#define PRINT_STATUS() printStatus()
+#endif
+
+#endif /* !BOARD_HULUSB_H */

atusb/board_rzusb.c

@@ -0,0 +1,169 @@
+/*
+ * fw/board_rzusb.c - RZUSB Board-specific functions (for boot loader and application)
+ *
+ * Written 2016 by Stefan Schmidt
+ * Copyright 2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/boot.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include "usb.h"
+#include "at86rf230.h"
+#include "board.h"
+#include "spi.h"
+#include "usb/usb.h"
+
+static bool spi_initialized = 0;
+
+void reset_rf(void)
+{
+	/* set up all the outputs; default port value is 0 */
+
+	DDRB = 0;
+	DDRC = 0;
+	DDRD = 0;
+	PORTB = 0;
+	PORTC = 0;
+	PORTD = 0;
+
+	OUT(LED);
+	OUT(nRST_RF);   /* this also resets the transceiver */
+	OUT(SLP_TR);
+
+	spi_init();
+
+	/* AT86RF231 data sheet, 12.4.13, reset pulse width: 625 ns (min) */
+
+	CLR(nRST_RF);
+	_delay_us(2);
+	SET(nRST_RF);
+
+	/* 12.4.14: SPI access latency after reset: 625 ns (min) */
+
+	_delay_us(2);
+
+	/* we must restore TRX_CTRL_0 after each reset (9.6.4) */
+
+	set_clkm();
+}
+
+void led(bool on)
+{
+	if (on)
+		SET(LED);
+	else
+		CLR(LED);
+}
+
+void set_clkm(void)
+{
+	/* switch CLKM to 8 MHz */
+
+	/*
+	 * @@@ Note: Atmel advise against changing the external clock in
+	 * mid-flight. We should therefore switch to the RC clock first, then
+	 * crank up the external clock, and finally switch back to the external
+	 * clock. The clock switching procedure is described in the ATmega32U2
+	 * data sheet in secton 8.2.2.
+	 */
+	spi_begin();
+	spi_send(AT86RF230_REG_WRITE | REG_TRX_CTRL_0);
+	spi_send(0x10);
+	spi_end();
+
+	/* TX_AUTO_CRC_ON, default disabled */
+	spi_begin();
+	spi_send(AT86RF230_REG_WRITE | 0x05);
+	spi_send(0x80);
+	spi_end();
+}
+
+void board_init(void)
+{
+	/* Disable the watchdog timer */
+
+	MCUSR = 0;		/* Remove override */
+	WDTCSR |= 1 << WDCE;	/* Enable change */
+	WDTCSR = 1 << WDCE;	/* Disable watchdog while still enabling
+				   change */
+
+	CLKPR = 1 << CLKPCE;
+	/* We start with a 16 MHz/8 clock. Put the prescaler to 2. */
+	CLKPR = 1 << CLKPS0;
+
+	get_sernum();
+}
+
+void spi_begin(void)
+{
+	if (!spi_initialized)
+		spi_init();
+	CLR(nSS);
+}
+
+void spi_off(void)
+{
+	spi_initialized = 0;
+	SPCR &= ~(1 << SPE);
+}
+
+void spi_init(void)
+{
+	SET(nSS);
+	OUT(SCLK);
+	OUT(MOSI);
+	OUT(nSS);
+	IN(MISO);
+
+	SPCR = (1 << SPE) | (1 << MSTR);
+	SPSR = (1 << SPI2X);
+
+	spi_initialized = 1;
+}
+
+void usb_init(void)
+{
+	USBCON |= 1 << FRZCLK;		/* freeze the clock */
+
+	/* enable the PLL and wait for it to lock */
+	/* TODO sheet page 50 For Atmel AT90USB128x only. Do not use with Atmel AT90USB64x. */
+	/*  FOR 8 XTAL Mhz only!!! */
+	PLLCSR = ((1 << PLLP1) | (1 << PLLP0));
+	PLLCSR |= 1 << PLLE;
+	while (!(PLLCSR & (1 << PLOCK)));
+
+	UHWCON |= (1 << UVREGE);
+
+	USBCON &= ~((1 << USBE) | (1 << OTGPADE));		/* reset the controller */
+	USBCON |= ((1 << USBE) | (1 << OTGPADE));
+
+	USBCON &= ~(1 << FRZCLK);	/* thaw the clock */
+
+	UDCON &= ~(1 << DETACH);	/* attach the pull-up */
+	UDIEN = 1 << EORSTE;		/* enable device interrupts  */
+//	UDCON |= 1 << RSTCPU;		/* reset CPU on bus reset */
+
+	ep_init();
+}
+
+void board_app_init(void)
+{
+	/* enable timer input capture 1, trigger on rising edge */
+	TCCR1B = (1 << ICES1);
+	TIFR1 = (1 << ICF1);
+	TIMSK1 = (1 << ICIE1);
+}

atusb/board_rzusb.h

@@ -0,0 +1,48 @@
+/*
+ * fw/board_rzusb.h - RZUSB Board-specific functions and definitions
+ *
+ * Written 2016 by Stefan Schmidt
+ * Copyright 2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef BOARD_RZUSB_H
+#define	BOARD_RZUSB_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define	LED_PORT	D
+#define	LED_BIT		  7
+#define	nRST_RF_PORT	B
+#define	nRST_RF_BIT	  5
+#define	SLP_TR_PORT	B
+#define	SLP_TR_BIT	  4
+
+#define SCLK_PORT	B
+#define SCLK_BIT	  1
+#define	MOSI_PORT	B
+#define	MOSI_BIT	  2
+
+#define	MISO_PORT	B
+#define	MISO_BIT	  3
+#define	nSS_PORT	B
+#define	nSS_BIT		  0
+#define	IRQ_RF_PORT	D
+#define	IRQ_RF_BIT	  4
+
+#define SPI_WAIT_DONE()	while ((SPSR & (1 << SPIF)) == 0)
+#define SPI_DATA	SPDR
+
+void set_clkm(void);
+void board_init(void);
+
+void spi_begin(void);
+void spi_off(void);
+void spi_init(void);
+
+#endif /* !BOARD_H */

atusb/boot.c

@@ -0,0 +1,77 @@
+/*
+ * fw/boot.c - DFU boot loader for ATUSB
+ *
+ * Written 2008-2011 by Werner Almesberger
+ * Copyright 2008-2011 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdint.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include "usb.h"
+#include "dfu.h"
+
+#include "board.h"
+#include "spi.h"
+#include "atusb/ep0.h"
+
+
+#define	MS_TO_LOOPS(ms) ((uint32_t) (ms)*335)
+
+
+static void (*run_payload)(void) = 0;
+
+
+int main(void)
+{
+	/*
+	 * pgm_read_byte gets cached and there doesn't seem to be any other
+	 * way to dissuade gcc from doing this.
+	 */
+	volatile int zero = 0;
+	uint32_t loop = 0;
+
+	board_init();
+	reset_rf();
+
+	/* now we should be at 8 MHz */
+
+	usb_init();
+	dfu_init();
+
+	/* move interrupt vectors to the boot loader */
+	MCUCR = 1 << IVCE;
+	MCUCR = 1 << IVSEL;
+
+	sei();
+
+	led(1);
+
+	while (loop != MS_TO_LOOPS(2500)) {
+		if (dfu.state == dfuIDLE && pgm_read_byte(zero) != 0xff)
+			loop++;
+		else
+			loop = 0;
+	}
+
+	led(0);
+
+	cli();
+
+	usb_reset();
+	run_payload();
+
+	while (1);	/* not reached */
+}

atusb/descr.c

@@ -0,0 +1,104 @@
+/*
+ * fw/descr.c - USB descriptors
+ *
+ * Written 2008-2011, 2014 by Werner Almesberger
+ * Copyright 2008-2011, 2014 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include "usb.h"
+#include "dfu.h"
+#include "board.h"
+
+
+#define LE(x) ((uint16_t) (x) & 0xff), ((uint16_t) (x) >> 8)
+
+/*
+ * Device descriptor
+ */
+
+const uint8_t device_descriptor[18] = {
+	18,			/* bLength */
+	USB_DT_DEVICE,		/* bDescriptorType */
+	LE(0x200),		/* bcdUSB */
+	USB_CLASS_VENDOR_SPEC,	/* bDeviceClass */
+	0x00,			/* bDeviceSubClass */
+	0x00,			/* bDeviceProtocol */
+	EP0_SIZE,		/* bMaxPacketSize */
+	LE(USB_VENDOR),		/* idVendor */
+	LE(USB_PRODUCT),	/* idProduct */
+	LE(0x0001),		/* bcdDevice */
+	0,			/* iManufacturer */
+	0,			/* iProduct */
+#ifdef HAS_BOARD_SERNUM
+	1,			/* iSerialNumber */
+#else
+	0,			/* iSerialNumber */
+#endif
+	1			/* bNumConfigurations */
+};
+
+
+/*
+ * Our configuration
+ *
+ * We're always bus-powered.
+ */
+
+const uint8_t config_descriptor[] = {
+	9,			/* bLength */
+	USB_DT_CONFIG,		/* bDescriptorType */
+#if 0
+	LE(9+9+7+7),		/* wTotalLength */
+#else
+	LE(9+9+7+9),		/* wTotalLength */
+#endif
+	2,			/* bNumInterfaces */
+	1,			/* bConfigurationValue (> 0 !) */
+	0,			/* iConfiguration */
+	USB_ATTR_BUS_POWERED,	/* bmAttributes */
+	((BOARD_MAX_mA)+1)/2,	/* bMaxPower */
+
+	/* Interface #0 */
+
+	9,			/* bLength */
+	USB_DT_INTERFACE,	/* bDescriptorType */
+	0,			/* bInterfaceNumber */
+	0,			/* bAlternateSetting */
+	1,			/* bNumEndpoints */
+	USB_CLASS_VENDOR_SPEC,	/* bInterfaceClass */
+	0,			/* bInterfaceSubClass */
+	0,			/* bInterfaceProtocol */
+	0,			/* iInterface */
+
+#if 0
+	/* EP OUT */
+
+	7,			/* bLength */
+	USB_DT_ENDPOINT,	/* bDescriptorType */
+	0x01,			/* bEndPointAddress */
+	0x02,			/* bmAttributes (bulk) */
+	LE(EP1_SIZE),		/* wMaxPacketSize */
+	0,			/* bInterval */
+#endif
+
+#if 1
+	/* EP IN */
+
+	7,			/* bLength */
+	USB_DT_ENDPOINT,	/* bDescriptorType */
+	0x81,			/* bEndPointAddress */
+	0x02,			/* bmAttributes (bulk) */
+	LE(EP1_SIZE),		/* wMaxPacketSize */
+	0,			/* bInterval */
+#endif
+
+	/* Interface #1 */
+
+	DFU_ITF_DESCR(1, 0, dfu_proto_runtime, 0)
+};

atusb/ep0.c

@@ -0,0 +1,338 @@
+/*
+ * fw/ep0.c - EP0 extension protocol
+ *
+ * Written 2008-2011, 2013 by Werner Almesberger
+ * Copyright 2008-2011, 2013 Werner Almesberger
+ * Copyright 2015-2016 Stefan Schmidt
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <avr/io.h>
+#include <avr/eeprom.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#include "usb.h"
+#include "dfu.h"
+
+#include "at86rf230.h"
+#include "atusb/ep0.h"
+#include "version.h"
+#include "board.h"
+#include "sernum.h"
+#include "spi.h"
+#include "mac.h"
+
+#ifdef ATUSB
+#define	HW_TYPE		ATUSB_HW_TYPE_110131
+#endif
+
+#ifdef RZUSB
+#define	HW_TYPE		ATUSB_HW_TYPE_RZUSB
+#endif
+
+#ifdef HULUSB
+#define HW_TYPE		ATUSB_HW_TYPE_HULUSB
+#endif
+
+#ifdef DEBUG
+#include "uart.h"
+#include <stdio.h>
+#define debug(FORMAT,args...) printf(FORMAT,##args)
+#define error(FORMAT,args...) printf(FORMAT,##args)
+#else
+#define debug(...)
+#define error(...)
+#endif
+
+
+static const uint8_t id[] = { EP0ATUSB_MAJOR, EP0ATUSB_MINOR, HW_TYPE };
+static uint8_t buf[MAX_PSDU+3]; /* command, PHDR, and LQI */
+static uint8_t size;
+
+
+static void do_eeprom_write(void *user)
+{
+	int i;
+
+	for (i = 0; i < size; i++)
+		eeprom_update_byte((uint8_t*)i, buf[i]);
+}
+
+static void do_buf_write(void *user)
+{
+	uint8_t i;
+
+	spi_begin();
+	for (i = 0; i != size; i++)
+		spi_send(buf[i]);
+	spi_end();
+}
+
+
+#define	BUILD_OFFSET	7	/* '#' plus "65535" plus ' ' */
+
+
+static bool my_setup(const struct setup_request *setup)
+{
+	uint16_t req = setup->bmRequestType | setup->bRequest << 8;
+	unsigned tmp;
+	uint8_t i;
+	uint64_t tmp64;
+
+	switch (req) {
+	case ATUSB_FROM_DEV(ATUSB_ID):
+		debug("ATUSB_ID\n");
+		if (setup->wLength > 3)
+			return 0;
+		usb_send(&eps[0], id, setup->wLength, NULL, NULL);
+		return 1;
+	case ATUSB_FROM_DEV(ATUSB_BUILD):
+		debug("ATUSB_BUILD\n");
+		tmp = build_number;
+		for (i = BUILD_OFFSET-2; tmp; i--) {
+			buf[i] = (tmp % 10)+'0';
+			tmp /= 10;
+		}
+		buf[i] = '#';
+		buf[BUILD_OFFSET-1] = ' ';
+		for (size = 0; build_date[size]; size++)
+			buf[BUILD_OFFSET+size] = build_date[size];
+		size += BUILD_OFFSET-i;
+		if (size > setup->wLength)
+			return 0;
+		usb_send(&eps[0], buf+i, size, NULL, NULL);
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_RESET):
+		debug("ATUSB_RESET\n");
+		reset_cpu();
+		while (1);
+
+	case ATUSB_TO_DEV(ATUSB_RF_RESET):
+		debug("ATUSB_RF_RESET\n");
+		reset_rf();
+		mac_reset();
+		//ep_send_zlp(EP_CTRL);
+		return 1;
+
+	case ATUSB_FROM_DEV(ATUSB_POLL_INT):
+		debug("ATUSB_POLL_INT\n");
+		if (setup->wLength < 1)
+			return 0;
+		*buf = read_irq();
+		usb_send(&eps[0], buf, 1, NULL, NULL);
+		return 1;
+
+	case ATUSB_FROM_DEV(ATUSB_TIMER):
+		debug("ATUSB_TIMER\n");
+		size = setup->wLength;
+		if (size > sizeof(tmp64))
+			size = sizeof(tmp64);
+		tmp64 = timer_read();
+		memcpy(buf, &tmp64, sizeof(tmp64));
+		usb_send(&eps[0], buf, size, NULL, NULL);
+		return 1;
+
+	case ATUSB_FROM_DEV(ATUSB_GPIO):
+		debug("ATUSB_GPIO\n");
+		if (setup->wLength < 3)
+			return 0;
+		if (!gpio(setup->wIndex, setup->wValue, setup->wValue >> 8,
+		    setup->wIndex >> 8, buf))
+			return 0;
+		usb_send(&eps[0], buf, 3, NULL, NULL);
+		return 1;
+	case ATUSB_TO_DEV(ATUSB_GPIO_CLEANUP):
+		gpio_cleanup();
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_SLP_TR):
+		debug("ATUSB_SLP_TR\n");
+		slp_tr();
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_REG_WRITE):
+		debug("ATUSB_REG_WRITE\n");
+		spi_begin();
+		spi_send(AT86RF230_REG_WRITE | setup->wIndex);
+		spi_send(setup->wValue);
+		spi_end();
+		//ep_send_zlp(EP_CTRL);
+		return 1;
+	case ATUSB_FROM_DEV(ATUSB_REG_READ):
+		debug("ATUSB_REG_READ\n");
+		spi_begin();
+		spi_send(AT86RF230_REG_READ | setup->wIndex);
+		*buf = spi_recv();
+		spi_end();
+		usb_send(&eps[0], buf, 1, NULL, NULL);
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_BUF_WRITE):
+		debug("ATUSB_BUF_WRITE\n");
+		if (setup->wLength < 1)
+			return 0;
+		if (setup->wLength > MAX_PSDU)
+			return 0;
+		buf[0] = AT86RF230_BUF_WRITE;
+		buf[1] = setup->wLength;
+		size = setup->wLength+2;
+		usb_recv(&eps[0], buf+2, setup->wLength, do_buf_write, NULL);
+		return 1;
+	case ATUSB_FROM_DEV(ATUSB_BUF_READ):
+		debug("ATUSB_BUF_READ\n");
+		if (setup->wLength < 2)			/* PHR+LQI */
+			return 0;
+		if (setup->wLength > MAX_PSDU+2)	/* PHR+PSDU+LQI */
+			return 0;
+		spi_begin();
+		spi_send(AT86RF230_BUF_READ);
+		size = spi_recv();
+		if (size >= setup->wLength)
+			size = setup->wLength-1;
+		for (i = 0; i != size+1; i++)
+			buf[i] = spi_recv();
+		spi_end();
+		usb_send(&eps[0], buf, size+1, NULL, NULL);
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_SRAM_WRITE):
+		debug("ATUSB_SRAM_WRITE\n");
+		if (setup->wIndex > SRAM_SIZE)
+			return 0;
+		if (setup->wIndex+setup->wLength > SRAM_SIZE)
+			return 0;
+		buf[0] = AT86RF230_SRAM_WRITE;
+		buf[1] = setup->wIndex;
+		size = setup->wLength+2;
+		usb_recv(&eps[0], buf+2, setup->wLength, do_buf_write, NULL);
+		return 1;
+	case ATUSB_FROM_DEV(ATUSB_SRAM_READ):
+		debug("ATUSB_SRAM_READ\n");
+		if (setup->wIndex > SRAM_SIZE)
+			return 0;
+		if (setup->wIndex+setup->wLength > SRAM_SIZE)
+			return 0;
+		spi_begin();
+		spi_send(AT86RF230_SRAM_READ);
+		spi_send(setup->wIndex);
+		for (i = 0; i != setup->wLength; i++)
+			buf[i] = spi_recv();
+		spi_end();
+		usb_send(&eps[0], buf, setup->wLength, NULL, NULL);
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_SPI_WRITE):
+		size = setup->wLength+2;
+		if (size > sizeof(buf))
+			return 0;
+		buf[0] = setup->wValue;
+		buf[1] = setup->wIndex;
+		if (setup->wLength)
+			usb_recv(&eps[0], buf+2, setup->wLength,
+			    do_buf_write, NULL);
+		else
+			do_buf_write(NULL);
+		return 1;
+	case ATUSB_FROM_DEV(ATUSB_SPI_WRITE2_SYNC):
+		spi_begin();
+		spi_send(setup->wValue);
+		spi_send(setup->wIndex);
+		spi_end();
+		buf[0] = irq_serial;
+		if (setup->wLength)
+			usb_send(&eps[0], buf, 1, NULL, NULL);
+		return 1;
+
+	case ATUSB_FROM_DEV(ATUSB_SPI_READ1):
+	case ATUSB_FROM_DEV(ATUSB_SPI_READ2):
+		spi_begin();
+		spi_send(setup->wValue);
+		if (req == ATUSB_FROM_DEV(ATUSB_SPI_READ2))
+			spi_send(setup->wIndex);
+		for (i = 0; i != setup->wLength; i++)
+			buf[i] = spi_recv();
+		spi_end();
+		usb_send(&eps[0], buf, setup->wLength, NULL, NULL);
+		return 1;
+
+	case ATUSB_TO_DEV(ATUSB_RX_MODE):
+		return mac_rx(setup->wValue);
+	case ATUSB_TO_DEV(ATUSB_TX):
+		return mac_tx(setup->wValue, setup->wIndex, setup->wLength);
+	case ATUSB_TO_DEV(ATUSB_EUI64_WRITE):
+		debug("ATUSB_EUI64_WRITE\n");
+		usb_recv(&eps[0], buf, setup->wLength, do_eeprom_write, NULL);
+		_delay_ms(100);
+		reset_cpu();
+		return 1;
+
+	case ATUSB_FROM_DEV(ATUSB_EUI64_READ):
+		debug("ATUSB_EUI64_READ\n");
+		eeprom_read_block(buf, (const void*)0, 8);
+		usb_send(&eps[0], buf, 8, NULL, NULL);
+		return 1;
+
+	default:
+		error("Unrecognized SETUP: 0x%02x 0x%02x ...\n",
+		    setup->bmRequestType, setup->bRequest);
+		return 0;
+	}
+}
+
+
+static bool my_dfu_setup(const struct setup_request *setup)
+{
+	switch (setup->bmRequestType | setup->bRequest << 8) {
+	case DFU_TO_DEV(DFU_DETACH):
+		/* @@@ should use wTimeout */
+		dfu.state = appDETACH;
+		return 1;
+	default:
+		return dfu_setup_common(setup);
+	}
+}
+
+
+static void my_set_interface(int nth)
+{
+	if (nth) {
+		user_setup = my_dfu_setup;
+		user_get_descriptor = dfu_my_descr;
+		dfu.state = appIDLE;
+	} else {
+		user_setup = my_setup;
+		user_get_descriptor = sernum_get_descr;
+	}
+}
+
+
+static void my_reset(void)
+{
+	if (dfu.state == appDETACH)
+		reset_cpu();
+}
+
+
+void ep0_init(void)
+{
+	user_setup = my_setup;
+	user_set_interface = my_set_interface;
+	my_set_interface(0);
+	user_reset = my_reset;
+}

atusb/flash.c

@@ -0,0 +1,97 @@
+/*
+ * fw/flash.c - Board-specific flash functions
+ *
+ * Written 2011, 2013-2015 by Werner Almesberger
+ * Copyright 2011, 2013-2015 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/boot.h>
+#include <avr/pgmspace.h>
+
+#include "dfu.h"
+#include "board.h"
+
+
+static uint32_t payload;
+
+
+static void flash_start(void)
+{
+	payload = 0;
+}
+
+
+static bool flash_can_write(uint16_t size)
+{
+	return payload+size <= BOOT_ADDR;
+}
+
+
+static void flash_write(const uint8_t *buf, uint16_t size)
+{
+	static uint8_t last;
+	const uint8_t *p;
+
+	for (p = buf; p != buf+size; p++) {
+		if (!(payload & (SPM_PAGESIZE-1))) {
+			boot_page_erase(payload);
+			boot_spm_busy_wait();
+		}
+
+		if (payload & 1)
+			boot_page_fill(payload, last | (*p << 8));
+		else
+			last = *p;
+		payload++;
+
+		if (!(payload & (SPM_PAGESIZE-1))) {
+			boot_page_write(payload-SPM_PAGESIZE);
+			boot_spm_busy_wait();
+		}
+	}
+}
+
+
+static void flash_end_write(void)
+{
+	if (payload & (SPM_PAGESIZE-1)) {
+		boot_page_write(payload & ~(SPM_PAGESIZE-1));
+		boot_spm_busy_wait();
+	}
+	boot_rww_enable();
+}
+
+
+static uint16_t flash_read(uint8_t *buf, uint16_t size)
+{
+	uint16_t got = 0;
+
+	while (size && payload != (uint32_t) FLASHEND+1) {
+		*buf++ = pgm_read_byte(payload);
+		payload++;
+		size--;
+		got++;
+	}
+	return got;
+}
+
+
+static const struct dfu_flash_ops flash_ops = {
+	.start		= flash_start,
+	.can_write	= flash_can_write,
+	.write		= flash_write,
+	.end_write	= flash_end_write,
+	.read		= flash_read,
+};
+
+
+const struct dfu_flash_ops *dfu_flash_ops = &flash_ops;

atusb/include/at86rf230.h

@@ -0,0 +1,402 @@
+/*
+ * include/at86rf230.h - AT86RF230/AT86RF231 protocol and register definitions
+ *
+ * Written 2008-2011 by Werner Almesberger
+ * Copyright 2008-2011 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#ifndef AT86RF230_H
+#define	AT86RF230_H
+
+enum {
+	AT86RF230_REG_WRITE	= 0xc0, /* 11... */
+	AT86RF230_REG_READ	= 0x80,	/* 10... */
+	AT86RF230_BUF_WRITE	= 0x60,	/* 011... */
+	AT86RF230_BUF_READ	= 0x20,	/* 001... */
+	AT86RF230_SRAM_WRITE	= 0x40,	/* 010... */
+	AT86RF230_SRAM_READ	= 0x00 	/* 000... */
+};
+
+#define	MAX_PSDU	127	/* octets, see AT86RF230 manual section 8.1  */
+#define	SRAM_SIZE	128
+
+
+/* --- Registers ----------------------------------------------------------- */
+
+enum {
+	REG_TRX_STATUS		= 0x01,
+	REG_TRX_STATE		= 0x02,
+	REG_TRX_CTRL_0		= 0x03,
+
+	REG_TRX_CTRL_1		= 0x04,	/* 231 only */
+
+	REG_PHY_TX_PWR		= 0x05,
+	REG_PHY_RSSI		= 0x06,
+	REG_PHY_ED_LEVEL	= 0x07,
+	REG_PHY_CC_CCA		= 0x08,
+	REG_CCA_THRES		= 0x09,
+
+	REG_RX_CTRL		= 0x0a,	/* 231 only */
+	REG_SFD_VALUE		= 0x0b,	/* 231 only */
+	REG_TRX_CTRL_2		= 0x0c,	/* 231 only */
+	REG_ANT_DIV		= 0x0d,	/* 231 only */
+
+	REG_IRQ_MASK		= 0x0e,
+	REG_IRQ_STATUS		= 0x0f,
+	REG_VREG_CTRL		= 0x10,
+	REG_BATMON		= 0x11,
+	REG_XOSC_CTRL		= 0x12,
+
+	REG_RX_SYN		= 0x15,	/* 231 only */
+	REG_XAH_CTRL_1		= 0x17,	/* 231 only */
+	REG_FTN_CTRL		= 0x18,	/* 231 only */
+
+	REG_PLL_CF		= 0x1a,
+	REL_PLL_DCU		= 0x1b,
+	REG_PART_NUM		= 0x1c,
+	REG_VERSION_NUM		= 0x1d,
+	REG_MAN_ID_0		= 0x1e,
+	REG_MAN_ID_1		= 0x1f,
+	REG_SHORT_ADDR_0	= 0x20,
+	REG_SHORT_ADDR_1	= 0x21,
+	REG_PAN_ID_0		= 0x22,
+	REG_PAN_ID_1		= 0x23,
+	REG_IEEE_ADDR_0		= 0x24,
+	REG_IEEE_ADDR_1		= 0x25,
+	REG_IEEE_ADDR_2		= 0x26,
+	REG_IEEE_ADDR_3		= 0x27,
+	REG_IEEE_ADDR_4		= 0x28,
+	REG_IEEE_ADDR_5		= 0x29,
+	REG_IEEE_ADDR_6		= 0x2a,
+	REG_IEEE_ADDR_7		= 0x2b,
+
+	REG_XAH_CTRL_0		= 0x2c,	/* XAH_CTRL in 230 */
+	REG_CSMA_SEED_0		= 0x2d,
+	REG_CSMA_SEED_1		= 0x2e,
+	REG_CSMA_BE		= 0x2f,	/* 231 only */
+
+	REG_CONT_TX_0		= 0x36,
+	REG_CONT_TX_1		= 0x3d,	/* 230 only */
+};
+
+/* --- TRX_STATUS --- ------------------------------------------------------ */
+
+#define	CCA_DONE	(1 << 7)
+#define	CCA_STATUS	(1 << 6)
+
+#define	TRX_STATUS_SHIFT	0
+#define	TRX_STATUS_MASK		0x1f
+
+enum {
+	TRX_STATUS_P_ON			= 0x00,	/* reset default */
+	TRX_STATUS_BUSY_RX		= 0x01,
+	TRX_STATUS_BUSY_TX		= 0x02,
+	TRX_STATUS_RX_ON		= 0x06,
+	TRX_STATUS_TRX_OFF		= 0x08,
+	TRX_STATUS_PLL_ON		= 0x09,
+	TRX_STATUS_SLEEP		= 0x0f,
+	TRX_STATUS_BUSY_RX_AACK		= 0x11,
+	TRX_STATUS_BUSY_TX_ARET		= 0x12,
+	TRX_STATUS_RX_AACK_ON		= 0x16,
+	TRX_STATUS_TX_ARET_ON		= 0x19,
+	TRX_STATUS_RX_ON_NOCLK		= 0x1c,
+	TRX_STATUS_RX_AACK_ON_NOCLK	= 0x1d,
+	TRX_STATUS_BUSY_RX_AACK_NOCLK	= 0x1e,
+	TRX_STATUS_TRANSITION		= 0x1f	/* ..._IN_PROGRESS */
+};
+
+/* --- TRX_STATE ----------------------------------------------------------- */
+
+#define	TRAC_STATUS_SHIFT	5
+#define	TRAC_STATUS_MASK	7
+
+enum {
+	TRAC_STATUS_SUCCESS			= 0,	/* reset default */
+	TRAC_STATUS_SUCCESS_DATA_PENDING	= 1,
+	TRAC_STATUS_SUCCESS_WAIT_FOR_ACK	= 2,	/* 231 only */
+	TRAC_STATUS_CHANNEL_ACCESS_FAILURE	= 3,
+	TRAC_STATUS_NO_ACK			= 5,
+	TRAC_STATUS_INVALID			= 7
+};
+
+#define	TRX_CMD_SHIFT	0
+#define	TRX_CMD_MASK	0x1f
+
+enum {
+	TRX_CMD_NOP		= 0x00,	/* reset default */
+	TRX_CMD_TX_START	= 0x02,
+	TRX_CMD_FORCE_TRX_OFF	= 0x03,
+	TRX_CMD_FORCE_PLL_ON	= 0x04,	/* 231 only */
+	TRX_CMD_RX_ON		= 0x06,
+	TRX_CMD_TRX_OFF		= 0x08,
+	TRX_CMD_PLL_ON		= 0x09,
+	TRX_CMD_RX_AACK_ON	= 0x16,
+	TRX_CMD_TX_ARET_ON	= 0x19,
+};
+
+/* --- TRX_CTRL_0 ---------------------------------------------------------- */
+
+#define	PAD_IO_SHIFT	6
+#define	PAD_IO_MASK	3
+
+enum {
+	PAD_IO_2mA,	/* reset default */
+	PAD_IO_4mA,
+	PAD_IO_6mA,
+	PAD_IO_8mA
+};
+
+#define	PAD_IO_CLKM_SHIFT	4
+#define	PAD_IO_CLKM_MASK	3
+
+enum {
+	PAD_IO_CLKM_2mA,
+	PAD_IO_CLKM_4mA,	/* reset default */
+	PAD_IO_CLKM_5mA,
+	PAD_IO_CLKM_8mA,
+};
+
+#define	CLKM_SHA_SEL		(1 << 3)
+
+#define	CLKM_CTRL_SHIFT	0
+#define	CLKM_CTRL_MASK	7
+
+enum {
+	CLKM_CTRL_OFF	= 0,
+	CLKM_CTRL_1MHz	= 1,	/* reset default */
+	CLKM_CTRL_2MHz	= 2,
+	CLKM_CTRL_4MHz	= 3,
+	CLKM_CTRL_8MHz	= 4,
+	CLKM_CTRL_16MHz	= 5
+};
+
+/* --- TRX_CTRL_1 (231 only) ----------------------------------------------- */
+
+#define	PA_EXT_EN		(1 << 7)
+#define	IRQ_2_EXT_EN		(1 << 6)
+#define	TX_AUTO_CRC_ON		(1 << 5)	/* 231 location */
+#define	RX_BL_CTRL		(1 << 4)
+
+#define	SPI_CMD_MODE_SHIFT	2
+#define	SPI_CMD_MODE_MASK	3
+
+enum {
+	SPI_CMD_MODE_EMPTY	= 0,	/* reset default */
+	SPI_CMD_MODE_TRX_STATUS	= 1,
+	SPI_CMD_MODE_PHY_RSSI	= 2,
+	SPI_CMD_MODE_IRQ_STATUS	= 3,
+};
+
+#define	IRQ_MASK_MODE		(1 << 1)
+#define	IRQ_POLARITY		(1 << 0)
+
+/* --- PHY_TX_PWR ---------------------------------------------------------- */
+
+#define	TX_AUTO_CRC_ON_230	(1 << 7)	/* 230 location */
+
+#define	PA_BUF_LT_SHIFT	6
+#define	PA_BUF_LT_MASK	3
+
+#define	PA_LT_SHIFT	4
+#define	PA_LT_MASK	3
+
+#define	TX_PWR_SHIFT	0
+#define	TX_PWR_MASK	0x0f
+
+/* --- PHY_RSSI ------------------------------------------------------------ */
+
+#define	RX_CRC_VALID	(1 << 7)
+
+#define	RND_VALUE_SHIFT	5		/* 231 only */
+#define	RND_VALUE_MASK	3
+
+#define	RSSI_SHIFT	0
+#define	RSSI_MASK	0x1f
+
+/* --- PHY_CC_CCA ---------------------------------------------------------- */
+
+#define	CCA_REQUEST	(1 << 7)
+
+#define	CCA_MODE_SHIFT	5
+#define	CCA_MODE_MASK	3
+
+enum {
+	CCA_MODE_CARRIER_OR_ENERGY	= 0,	/* 231 only */
+	CCA_MODE_ENERGY			= 1,	/* reset default */
+	CCA_MODE_CARRIER		= 2,
+	CCA_MODE_CARRIER_AND_ENERGY	= 3
+};
+
+#define	CHANNEL_SHIFT	0
+#define	CHANNEL_MASK	0x1f
+
+/* --- CCA_THRES ----------------------------------------------------------- */
+
+#define	CCA_ED_THRES_SHIFT	0
+#define	CCA_ED_THRES_MASK	0x0f
+
+/* --- RX_CTRL (231 only) -------------------------------------------------- */
+
+#define	PDT_THRES_SHIFT	0
+#define	PDT_THRES_MASK	0x0f
+
+enum {
+	PDT_THRES_DEFAULT	= 0x07,	/* reset default */
+	PDT_THRES_DIVERSITY	= 0x03,
+};
+
+/* --- TRX_CTRL_2 (231 only) ----------------------------------------------- */
+
+#define	RX_SAFE_MODE		(1 << 7)
+
+#define	OQPSK_DATA_RATE_SHIFT	0
+#define	OQPSK_DATA_RATE_MASK	3
+
+enum {
+	OQPSK_DATA_RATE_250	= 0,	/* reset default */
+	OQPSK_DATA_RATE_500	= 1,
+	OQPSK_DATA_RATE_1000	= 2,
+	OQPSK_DATA_RATE_2000	= 3
+};
+
+/* --- ANT_DIV (231 only) -------------------------------------------------- */
+
+#define	ANT_SEL		(1 << 7)
+#define	ANT_DIV_EN	(1 << 3)
+#define	ANT_EXT_SW_EN	(1 << 2)
+
+#define	ANT_CTRL_SHIFT	0
+#define	ANT_CTRL_MASK	3
+
+enum {
+	ANT_CTRL_ANT_0	= 1,
+	ANT_CTRL_ANT_1	= 2,
+	ANT_CTRL_NODIV	= 3,	/* reset default */
+};
+
+/* --- IRQ_MASK/IRQ_STATUS ------------------------------------------------- */
+
+enum {
+	IRQ_PLL_LOCK	= 1 << 0,
+	IRQ_PLL_UNLOCK	= 1 << 1,
+	IRQ_RX_START	= 1 << 2,
+	IRQ_TRX_END	= 1 << 3,
+	IRQ_CCA_ED_DONE	= 1 << 4,	/* 231 only */
+	IRQ_AMI		= 1 << 5,	/* 231 only */
+	IRQ_TRX_UR	= 1 << 6,
+	IRQ_BAT_LOW	= 1 << 7
+};
+
+/* --- VREG_CTRL ----------------------------------------------------------- */
+
+#define	AVREG_EXT	(1 << 7)
+#define	AVDD_OK		(1 << 6)
+#define	DVREG_EXT	(1 << 3)
+#define	DVDD_OK		(1 << 2)
+
+/* --- BATMON -------------------------------------------------------------- */
+
+#define	BATMON_OK	(1 << 5)
+#define	BATMON_HR	(1 << 4)
+
+#define	BATMON_VTH_SHIFT	0
+#define	BATMON_VTH_MASK		0x0f
+
+/* --- XOSC_CTRL ----------------------------------------------------------- */
+
+#define	XTAL_MODE_SHIFT	4
+#define	XTAL_MODE_MASK	0x0f
+
+enum {
+	XTAL_MODE_OFF	= 0x0,	/* 230 only */
+	XTAL_MODE_EXT	= 0x4,
+	XTAL_MODE_INT	= 0xf	/* reset default */
+};
+
+#define	XTAL_TRIM_SHIFT	4
+#define	XTAL_TRIM_MASK	0x0f
+
+/* --- RX_SYN (231 only) --------------------------------------------------- */
+
+#define	RX_PDT_DIS		(1 << 7)
+
+#define	RX_PDT_LEVEL_SHIFT	0
+#define	RX_PDT_LEVEL_MASK	0xf
+
+/* --- XAH_CTRL_1 (231 only) ----------------------------------------------- */
+
+#define	AACK_FLTR_RES_FT	(1 << 5)
+#define	AACK_UPLD_RES_FT	(1 << 4)
+#define	AACK_ACK_TIME		(1 << 2)
+#define	AACK_PROM_MODE		(1 << 1)
+
+/* --- FTN_CTRL (231 only) ------------------------------------------------- */
+
+#define	FTN_START		(1 << 7)
+
+/* --- PLL_CF -------------------------------------------------------------- */
+
+#define	PLL_CF_START	(1 << 7)
+
+/* --- PLL_DCU ------------------------------------------------------------- */
+
+#define	PLL_DCU_START	(1 << 7)
+
+/* --- XAH_CTRL_0 (XAH_CTRL in 230) ---------------------------------------- */
+
+#define	MAX_FRAME_RETRIES_SHIFT	4
+#define	MAX_FRAME_RETRIES_MASK	0x0f
+
+#define	MAX_CSMA_RETRIES_SHIFT	1
+#define	MAX_CSMA_RETRIES_MASK	0x07
+
+#define	SLOTTED_OPERATION	(1 << 0)	/* 231 only */
+
+/* --- CSMA_SEED_1 --------------------------------------------------------- */
+
+#define	MIN_BE_SHIFT_230	6	/* 230 location */
+#define	MIN_BE_MASK_230		3
+
+#define	AACK_FVN_MODE_SHIFT	6	/* 231 only */
+#define	AACK_FVN_MODE_MASK	3
+
+enum {
+	AACK_FVN_MODE_0		= 0,
+	AACK_FVN_MODE_01	= 1,	/* reset default */
+	AACK_FVN_MODE_012	= 2,
+	AACK_FVN_MODE_ANY	= 3
+};
+
+#define	AACK_SET_PD		(1 << 5)
+#define	AACK_DIS_ACK		(1 << 4)	/* 231 only */
+#define	I_AM_COORD		(1 << 3)
+
+#define CSMA_SEED_1_SHIFT	0
+#define	CSMA_SEED_1_MASK	7
+
+/* --- CSMA_BE ------------------------------------------------------------- */
+
+#define	MAX_BE_SHIFT		4
+#define	MAX_BE_MASK		0x0f
+
+#define	MIN_BE_SHIFT		0	/* 231 location */
+#define	MIN_BE_MASK		0x0f
+
+/* --- REG_CONT_TX_0 ------------------------------------------------------- */
+
+#define	CONT_TX_MAGIC		0x0f
+
+/* --- REG_CONT_TX_1 (230 only) -------------------------------------------- */
+
+#define	CONT_TX_MOD		0x00	/* modulated */
+#define	CONT_TX_M2M		0x10	/* f_CH-2 MHz */
+#define	CONT_TX_M500K		0x80	/* f_CH-0.5 MHz */
+#define	CONT_TX_P500K		0xc0	/* f_CH+0.5 MHz */
+
+#endif /* !AT86RF230_H */

atusb/include/atusb/atusb.h

@@ -0,0 +1,97 @@
+/*
+ * atusb.h - Definitions shared between kernel and ATUSB firmware
+ *
+ * Written 2013 by Werner Almesberger <werner@almesberger.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, version 2, or
+ * (at your option) any later version.
+ *
+ * This file should be identical for kernel and firmware.
+ * Kernel: drivers/net/ieee802154/atusb.h
+ * Firmware: ben-wpan/atusb/fw/include/atusb/atusb.h
+ */
+
+#ifndef	_ATUSB_H
+#define	_ATUSB_H
+
+#define ATUSB_VENDOR_ID	0x20b7	/* Qi Hardware*/
+#define ATUSB_PRODUCT_ID 0x1540	/* 802.15.4, device 0 */
+				/*     -- -         - */
+
+#define ATUSB_BUILD_SIZE 256	/* maximum build version/date message length */
+
+/* Commands to our device. Make sure this is synced with the firmware */
+enum atusb_requests {
+	ATUSB_ID			= 0x00,	/* system status/control grp */
+	ATUSB_BUILD,
+	ATUSB_RESET,
+	ATUSB_RF_RESET			= 0x10,	/* debug/test group */
+	ATUSB_POLL_INT,
+	ATUSB_TEST,			/* atusb-sil only */
+	ATUSB_TIMER,
+	ATUSB_GPIO,
+	ATUSB_SLP_TR,
+	ATUSB_GPIO_CLEANUP,
+	ATUSB_REG_WRITE			= 0x20,	/* transceiver group */
+	ATUSB_REG_READ,
+	ATUSB_BUF_WRITE,
+	ATUSB_BUF_READ,
+	ATUSB_SRAM_WRITE,
+	ATUSB_SRAM_READ,
+	ATUSB_SPI_WRITE			= 0x30,	/* SPI group */
+	ATUSB_SPI_READ1,
+	ATUSB_SPI_READ2,
+	ATUSB_SPI_WRITE2_SYNC,
+	ATUSB_RX_MODE			= 0x40, /* HardMAC group */
+	ATUSB_TX,
+	ATUSB_EUI64_WRITE		= 0x50, /* Parameter in EEPROM grp */
+	ATUSB_EUI64_READ,
+};
+
+enum {
+	ATUSB_HW_TYPE_100813,	/* 2010-08-13 */
+	ATUSB_HW_TYPE_101216,	/* 2010-12-16 */
+	ATUSB_HW_TYPE_110131,	/* 2011-01-31, ATmega32U2-based */
+	ATUSB_HW_TYPE_RZUSB,	/* Atmel Raven USB dongle with at86rf230 */
+	ATUSB_HW_TYPE_HULUSB,	/* Busware HUL USB dongle with at86rf212 */
+};
+
+/*
+ * Direction	bRequest		wValue		wIndex	wLength
+ *
+ * ->host	ATUSB_ID		-		-	3
+ * ->host	ATUSB_BUILD		-		-	#bytes
+ * host->	ATUSB_RESET		-		-	0
+ *
+ * host->	ATUSB_RF_RESET		-		-	0
+ * ->host	ATUSB_POLL_INT		-		-	1
+ * host->	ATUSB_TEST		-		-	0
+ * ->host	ATUSB_TIMER		-		-	#bytes (6)
+ * ->host	ATUSB_GPIO		dir+data	mask+p#	3
+ * host->	ATUSB_SLP_TR		-		-	0
+ * host->	ATUSB_GPIO_CLEANUP	-		-	0
+ *
+ * host->	ATUSB_REG_WRITE		value		addr	0
+ * ->host	ATUSB_REG_READ		-		addr	1
+ * host->	ATUSB_BUF_WRITE		-		-	#bytes
+ * ->host	ATUSB_BUF_READ		-		-	#bytes
+ * host->	ATUSB_SRAM_WRITE	-		addr	#bytes
+ * ->host	ATUSB_SRAM_READ		-		addr	#bytes
+ *
+ * host->	ATUSB_SPI_WRITE		byte0		byte1	#bytes
+ * ->host	ATUSB_SPI_READ1		byte0		-	#bytes
+ * ->host	ATUSB_SPI_READ2		byte0		byte1	#bytes
+ * ->host	ATUSB_SPI_WRITE2_SYNC	byte0		byte1	0/1
+ *
+ * host->	ATUSB_RX_MODE		on		-	0
+ * host->	ATUSB_TX		flags		ack_seq	#bytes
+ * host->	ATUSB_EUI64_WRITE	-		-	#bytes (8)
+ * ->host	ATUSB_EUI64_READ	-		-	#bytes (8)
+ */
+
+#define ATUSB_REQ_FROM_DEV	(USB_TYPE_VENDOR | USB_DIR_IN)
+#define ATUSB_REQ_TO_DEV	(USB_TYPE_VENDOR | USB_DIR_OUT)
+
+#endif /* !_ATUSB_H */

atusb/include/atusb/ep0.h

@@ -0,0 +1,64 @@
+/*
+ * include/atusb/ep0.h - EP0 extension protocol
+ *
+ * Written 2008-2011, 2013 by Werner Almesberger
+ * Copyright 2008-2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#ifndef EP0_H
+#define EP0_H
+
+#include <atusb/atusb.h>
+
+
+/*
+ * EP0 protocol:
+ *
+ * 0.0	initial release
+ * 0.1  addition of ATUSB_TEST
+ * 0.2  First public release
+ * 0.3	ATUSB_EUI64_READ/WRITE for permanent EUI64 handling
+ * 	Support to run the firmware on Atmel Raven USB dongles
+ * 	Remove FCS frame check from firmware and leave it to the driver
+ * 	Use extended operation mode for TX for automatic ACK handling
+ */
+
+#define EP0ATUSB_MAJOR	0	/* EP0 protocol, major revision */
+#define EP0ATUSB_MINOR	3	/* EP0 protocol, minor revision */
+
+
+/*
+ * bmRequestType:
+ *
+ * D7 D6..5 D4...0
+ * |  |     |
+ * direction (0 = host->dev)
+ *    type (2 = vendor)
+ *          recipient (0 = device)
+ */
+
+#ifndef USB_TYPE_VENDOR
+#define	USB_TYPE_VENDOR		0x40
+#endif
+
+#ifndef USB_DIR_IN
+#define	USB_DIR_IN		0x80
+#endif
+
+#ifndef USB_DIR_OUT
+#define	USB_DIR_OUT		0x00
+#endif
+
+#define	ATUSB_FROM_DEV(req)	(ATUSB_REQ_FROM_DEV | (req) << 8)
+#define	ATUSB_TO_DEV(req)	(ATUSB_REQ_TO_DEV | (req) << 8)
+
+
+void ep0_init(void);
+
+#endif /* !EP0_H */

atusb/mac.c

@@ -0,0 +1,250 @@
+/*
+ * fw/mac.c - HardMAC functions
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb.h"
+
+#include "at86rf230.h"
+#include "spi.h"
+#include "board.h"
+#include "mac.h"
+
+#define	RX_BUFS	3
+
+
+bool (*mac_irq)(void) = NULL;
+
+
+static uint8_t rx_buf[RX_BUFS][MAX_PSDU+2]; /* PHDR+payload+LQ */
+static uint8_t tx_buf[MAX_PSDU];
+static uint8_t tx_size = 0;
+static bool txing = 0;
+static bool queued_tx_ack = 0;
+static uint8_t next_seq, this_seq, queued_seq;
+
+
+/* ----- Receive buffer management ----------------------------------------- */
+
+
+static uint8_t rx_in = 0, rx_out = 0;
+
+
+static inline void next_buf(uint8_t *index)
+{
+	*index = (*index+1) % RX_BUFS;
+}
+
+
+/* ----- Interrupt handling ------------------------------------------------ */
+
+
+static void rx_done(void *user);
+static void tx_ack_done(void *user);
+
+
+static void usb_next(void)
+{
+	const uint8_t *buf;
+
+	if (rx_in != rx_out) {
+		buf = rx_buf[rx_out];
+		led(1);
+		usb_send(&eps[1], buf, buf[0]+2, rx_done, NULL);
+	}
+
+	if (queued_tx_ack) {
+		usb_send(&eps[1], &queued_seq, 1, tx_ack_done, NULL);
+		queued_tx_ack = 0;	
+	}
+}
+
+
+static void tx_ack_done(void *user)
+{
+	usb_next();
+}
+
+static void rx_done(void *user)
+{
+	led(0);
+	next_buf(&rx_out);
+	usb_next();
+#ifdef AT86RF230
+	/* slap at86rf230 - reduce fragmentation issue */
+	change_state(TRX_STATUS_RX_AACK_ON);
+#endif
+}
+
+
+static void receive_frame(void)
+{
+	uint8_t size;
+	uint8_t *buf;
+
+	spi_begin();
+	spi_io(AT86RF230_BUF_READ);
+
+	size = spi_recv();
+	if (!size || (size & 0x80)) {
+		spi_end();
+		return;
+	}
+
+	buf = rx_buf[rx_in];
+	spi_recv_block(buf+1, size+1);
+	spi_end();
+
+	buf[0] = size;
+	next_buf(&rx_in);
+
+	if (eps[1].state == EP_IDLE)
+		usb_next();
+}
+
+
+static bool handle_irq(void)
+{
+	uint8_t irq;
+
+	irq = reg_read(REG_IRQ_STATUS);
+	if (!(irq & IRQ_TRX_END))
+		return 1;
+
+	if (txing) {
+		if (eps[1].state == EP_IDLE) {
+			usb_send(&eps[1], &this_seq, 1, tx_ack_done, NULL);
+		} else {
+			queued_tx_ack = 1;
+			queued_seq = this_seq;
+		}
+		txing = 0;
+		return 1;
+	}
+
+	/* likely */
+	if (eps[1].state == EP_IDLE || rx_in != rx_out)
+		receive_frame();
+
+	return 1;
+}
+
+
+/* ----- TX/RX ------------------------------------------------------------- */
+
+
+bool mac_rx(int on)
+{
+	if (on) {
+		mac_irq = handle_irq;
+		reg_read(REG_IRQ_STATUS);
+		change_state(TRX_CMD_RX_AACK_ON);
+	} else {
+		mac_irq = NULL;
+		change_state(TRX_CMD_FORCE_TRX_OFF);
+		txing = 0;
+	}
+	return 1;
+}
+
+
+static void do_tx(void *user)
+{
+	uint16_t timeout = 0xffff;
+	uint8_t status;
+	uint8_t i;
+
+	/*
+	 * If we time out here, the host driver will time out waiting for the
+	 * TRX_END acknowledgement.
+	 */
+	do {
+		if (!--timeout)
+			return;
+		status = reg_read(REG_TRX_STATUS) & TRX_STATUS_MASK;
+	}
+	while (status != TRX_STATUS_RX_ON && status != TRX_STATUS_RX_AACK_ON);
+
+#ifdef AT86RF231
+	/*
+	 * We use TRX_CMD_FORCE_PLL_ON instead of TRX_CMD_PLL_ON because a new
+	 * reception may have begun while we were still working on the previous
+	 * one.
+	 */
+	reg_write(REG_TRX_STATE, TRX_CMD_FORCE_PLL_ON);
+#endif
+#ifdef AT86RF230
+	/*
+	 * at86rf230 doesn't support force change, nevetherless this works
+	 * somehow
+	 */
+	reg_write(REG_TRX_STATE, TRX_CMD_PLL_ON);
+#endif
+#ifdef AT86RF212
+	/*
+	* We use TRX_CMD_FORCE_PLL_ON instead of TRX_CMD_PLL_ON because a new
+	* reception may have begun while we were still working on the previous
+	* one.
+	*/
+	reg_write(REG_TRX_STATE, TRX_CMD_FORCE_PLL_ON);
+#endif
+
+	handle_irq();
+
+	spi_begin();
+	spi_send(AT86RF230_BUF_WRITE);
+	spi_send(tx_size+2); /* CRC */
+	for (i = 0; i != tx_size; i++)
+		spi_send(tx_buf[i]);
+	spi_end();
+
+	change_state(TRX_STATUS_TX_ARET_ON);
+
+	slp_tr();
+
+	txing = 1;
+	this_seq = next_seq;
+
+	/*
+	 * Wait until we reach BUSY_TX_ARET, so that we command the transition to
+	 * RX_AACK_ON which will be executed upon TX completion.
+	 */
+	change_state(TRX_CMD_PLL_ON);
+	change_state(TRX_CMD_RX_AACK_ON);
+}
+
+
+bool mac_tx(uint16_t flags, uint8_t seq, uint16_t len)
+{
+	if (len > MAX_PSDU)
+		return 0;
+	tx_size = len;
+	next_seq = seq;
+	usb_recv(&eps[0], tx_buf, len, do_tx, NULL);
+	return 1;
+}
+
+
+void mac_reset(void)
+{
+	mac_irq = NULL;
+	txing = 0;
+	queued_tx_ack = 0;
+	rx_in = rx_out = 0;
+	next_seq = this_seq = queued_seq = 0;
+
+	/* enable CRC and PHY_RSSI (with RX_CRC_VALID) in SPI status return */
+	reg_write(REG_TRX_CTRL_1,
+	    TX_AUTO_CRC_ON | SPI_CMD_MODE_PHY_RSSI << SPI_CMD_MODE_SHIFT);
+}

atusb/mac.h

@@ -0,0 +1,26 @@
+/*
+ * fw/mac.h - HardMAC functions
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef MAC_H
+#define	MAC_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+
+extern bool (*mac_irq)(void);
+
+bool mac_rx(int on);
+bool mac_tx(uint16_t flags, uint8_t seq, uint16_t len);
+void mac_reset(void);
+
+#endif /* !MAC_H */

atusb/sernum.c

@@ -0,0 +1,47 @@
+/*
+ * fw/sernum.c - ATUSB serial number
+ *
+ * Written 2008-2011, 2013 by Werner Almesberger
+ * Copyright 2008-2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb.h"
+
+#include "board.h"
+#include "sernum.h"
+
+
+static const uint8_t string_descriptor_0[] = {
+	4,				/* blength */
+	USB_DT_STRING,			/* bDescriptorType */
+	LE(USB_LANGID_ENGLISH_US)	/* wLANGID[0]  */
+};
+
+
+bool sernum_get_descr(uint8_t type, uint8_t index, const uint8_t **reply,
+    uint8_t *size)
+{
+	if (type != USB_DT_STRING)
+		return 0;
+	switch (index) {
+	case 0:
+		*reply = string_descriptor_0;
+		*size = sizeof(string_descriptor_0);
+		return 1;
+	case 1:
+		*reply = board_sernum;
+		*size = sizeof(board_sernum);
+		return 1;
+	default:
+		return 0;
+	}
+}

atusb/sernum.h

@@ -0,0 +1,37 @@
+/*
+ * fw/sernum.h - ATUSB serial number
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef SERNUM_H
+#define	SERNUM_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "board.h"
+
+
+#ifdef HAS_BOARD_SERNUM
+
+bool sernum_get_descr(uint8_t type, uint8_t index, const uint8_t **reply,
+    uint8_t *size);
+
+#else /* HAS_BOARD_SERNUM */
+
+static inline bool sernum_get_descr(uint8_t type, uint8_t index,
+    const uint8_t **reply, uint8_t *size)
+{
+	return 0;
+}
+
+#endif /* !HAS_BOARD_SERNUM */
+
+#endif /* !SERNUM_H */

atusb/spi.c

@@ -0,0 +1,51 @@
+/*
+ * fw/spi.c - ATmega8 family SPI I/O
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <avr/io.h>
+
+#include "board.h"
+#include "spi.h"
+
+
+uint8_t spi_io(uint8_t v)
+{
+//      while (!(UCSR1A & 1 << UDRE1));
+	SPI_DATA = v;
+	SPI_WAIT_DONE();
+	return SPI_DATA;
+}
+
+
+void spi_end(void)
+{
+//      while (!(UCSR1A & 1 << TXC1));
+	SET(nSS);
+}
+
+
+void spi_recv_block(uint8_t *buf, uint8_t n)
+{
+	if (!n)
+		return;
+	SPI_DATA = 0;
+	while (--n) {
+		SPI_WAIT_DONE();
+		*buf++ = SPI_DATA;
+		SPI_DATA = 0;
+	}
+	SPI_WAIT_DONE();
+	*buf++ = SPI_DATA;
+}

atusb/spi.h

@@ -0,0 +1,30 @@
+/*
+ * fw/spi.h - ATmega8 family SPI I/O
+ *
+ * Written 2011, 2013 by Werner Almesberger
+ * Copyright 2011, 2013 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef SPI_H
+#define	SPI_H
+
+#include <stdint.h>
+
+
+void spi_begin(void);
+uint8_t spi_io(uint8_t v);
+void spi_end(void);
+void spi_off(void);
+void spi_init(void);
+
+#define	spi_send(v)	(void) spi_io(v)
+#define	spi_recv(v)	spi_io(0)
+
+void spi_recv_block(uint8_t *buf, uint8_t n);
+
+#endif /* !SPI_H */

atusb/uart.c

@@ -0,0 +1,64 @@
+/*
+ * fw/uart.h - Functions needed for debugging over uart
+ *
+ * Code adapted from http://www.roboternetz.de/wissen/index.php/UART_mit_avr-gcc
+ * and http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
+ *
+ * Published under the Creative Commons Share-Alike licence
+ * https://creativecommons.org/licenses/by-sa/2.0/de/
+ *
+ * S. Salewski 2007
+ *
+ * Adapted by
+ * Josef Filzmaier 2017
+ */
+
+#include <avr/io.h>
+#include "uart.h"
+
+#define USART_BAUD 38400UL
+#define F_CPU 8000000UL
+
+#define Wait_USART_Ready() while (!(UCSR1A & (1<<UDRE1)))
+#define UART_UBRR (F_CPU/(16L*USART_BAUD)-1)
+
+// initialize USART, 8N1 mode
+void
+uart_init(void)
+{
+/* TODO: Find a working configuration for uart for the atmega32u2 */
+#if CHIP == at90usb1287
+	CLKPR = (1 << CLKPCE);
+	CLKPR = 0; // clock prescaler == 0, so we have 16 MHz mpu frequency
+	UBRR1 = UART_UBRR;
+	UCSR1C = (1 << UCSZ10) | (1 << UCSZ11);
+	UCSR1B = (1 << TXEN1);
+	do
+	{
+		UDR1;
+	}
+	while (UCSR1A & (1 << RXC1));
+#endif
+
+}
+
+int uart_write_char(char c, FILE* stream)
+{
+	if (c == '\n'){
+		uart_new_line();
+	}
+	else {
+		Wait_USART_Ready();
+		UDR1 = c;
+	}
+	return 0;
+}
+
+void
+uart_new_line(void)
+{
+	Wait_USART_Ready();
+	UDR1 = '\r';
+	Wait_USART_Ready();
+	UDR1 = '\n';
+}

atusb/uart.h

@@ -0,0 +1,25 @@
+/*
+ * fw/uart.h - Functions needed for debugging over uart
+ *
+ * Code adapted from http://www.roboternetz.de/wissen/index.php/UART_mit_avr-gcc
+ * and http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
+ *
+ * Published under the Creative Commons Share-Alike licence
+ * https://creativecommons.org/licenses/by-sa/2.0/de/
+ *
+ * S. Salewski 2007
+ *
+ * Adapted by
+ * Josef Filzmaier 2017
+ */
+
+#ifndef UART_H_
+#define	UART_H_
+
+#include <stdio.h>
+
+void uart_init(void);
+int uart_write_char(char c, FILE* stream);
+void uart_new_line(void);
+
+#endif /* UART_H_ */

atusb/usb/atu2.c

@@ -0,0 +1,247 @@
+/*
+ * fw/usb/atu2.c - Chip-specific driver for Atmel ATxxxU2 USB chips
+ *
+ * Written 2008-2011, 2013-2014 by Werner Almesberger
+ * Copyright 2008-2011, 2013-2014 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+/*
+ * Known issues:
+ * - no suspend/resume
+ * - we don't call back after failed transmissions,
+ * - we don't reset the EP buffer after failed receptions
+ * - enumeration often encounters an error -71 (from which it recovers)
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define F_CPU   8000000UL
+#include <util/delay.h>
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "usb.h"
+#include "board.h"
+
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#if 1
+#define BUG_ON(cond)    do { if (cond) panic(); } while (0)
+#else
+#define BUG_ON(cond)
+#endif
+
+
+struct ep_descr eps[NUM_EPS];
+
+
+static uint16_t usb_read_word(void)
+{
+	uint8_t low;
+
+	low = UEDATX;
+	return low | UEDATX << 8;
+}
+
+
+static void enable_addr(void *user)
+{
+	while (!(UEINTX & (1 << TXINI)));
+	UDADDR |= 1 << ADDEN;
+}
+
+
+void set_addr(uint8_t addr)
+{
+	UDADDR = addr;
+	usb_send(&eps[0], NULL, 0, enable_addr, NULL);
+}
+
+
+void usb_ep_change(struct ep_descr *ep)
+{
+	if (ep->state == EP_TX) {
+		UENUM = ep-eps;
+		UEIENX |= 1 << TXINE;
+	}
+}
+
+
+static bool ep_setup(void)
+{
+	struct setup_request setup;
+
+	BUG_ON(UEBCLX < 8);
+
+	setup.bmRequestType = UEDATX;
+	setup.bRequest = UEDATX;
+	setup.wValue = usb_read_word();
+	setup.wIndex = usb_read_word();
+	setup.wLength = usb_read_word();
+
+	if (!handle_setup(&setup))
+		return 0;
+	if (!(setup.bmRequestType & 0x80) && eps[0].state == EP_IDLE)
+		usb_send(&eps[0], NULL, 0, NULL, NULL);
+	return 1;
+}
+
+
+static bool ep_rx(struct ep_descr *ep)
+{
+	uint8_t size;
+
+	size = UEBCLX;
+	if (size > ep->end-ep->buf)
+		return 0;
+	while (size--)
+		*ep->buf++ = UEDATX;
+	if (ep->buf == ep->end) {
+		ep->state = EP_IDLE;
+		if (ep->callback)
+			ep->callback(ep->user);
+//		if (ep == &eps[0])
+			usb_send(ep, NULL, 0, NULL, NULL);
+	}
+	return 1;
+}
+
+
+static void ep_tx(struct ep_descr *ep)
+{
+	uint8_t size = ep->end-ep->buf;
+	uint8_t left;
+
+	if (size > ep->size)
+		size = ep->size;
+	for (left = size; left; left--)
+		UEDATX = *ep->buf++;
+	if (size == ep->size)
+		return;
+	ep->state = EP_IDLE;
+}
+
+
+static void handle_ep(int n)
+{
+	struct ep_descr *ep = eps+n;
+	uint8_t mask;
+
+	UENUM = n;
+	if (UEINTX & (1 << RXSTPI)) {
+		/* @@@ EP_RX. EP_TX: cancel */
+		ep->state = EP_IDLE;
+		if (!ep_setup())
+			goto stall;
+		UEINTX = ~(1 << RXSTPI);
+	}
+	if (UEINTX & (1 << RXOUTI)) {
+		/* @@ EP_TX: cancel */
+		if (ep->state != EP_RX)
+			goto stall;
+		if (!ep_rx(ep))
+			goto stall;
+		/* @@@ gcc 4.5.2 wants this cast */
+		UEINTX = (uint8_t) ~(1 << RXOUTI | 1 << FIFOCON);
+	}
+	if (UEINTX & (1 << STALLEDI)) {
+		ep->state = EP_IDLE;
+		UEINTX = ~(1 << STALLEDI);
+	}
+	if (UEINTX & (1 << TXINI)) {
+		/* @@ EP_RX: cancel (?) */
+		if (ep->state == EP_TX) {
+			ep_tx(ep);
+			mask = 1 << TXINI;
+			if (n)
+				mask |= 1 << FIFOCON;
+			UEINTX = ~mask;
+			if (ep->state == EP_IDLE && ep->callback)
+				ep->callback(ep->user);
+		} else {
+			UEIENX &= ~(1 << TXINE);
+		}
+	}
+	return;
+
+stall:
+	UEINTX = ~(1 << RXSTPI | 1 << RXOUTI | 1 << STALLEDI);
+	ep->state = EP_IDLE;
+	UECONX |= 1 << STALLRQ;
+}
+
+
+void ep_init(void)
+{
+	UENUM = 0;
+	UECONX = (1 << RSTDT) | (1 << EPEN);	/* enable */
+	UECFG0X = 0;	/* control, direction is ignored */
+	UECFG1X = 3 << EPSIZE0;	/* 64 bytes */
+	UECFG1X |= 1 << ALLOC;
+
+	while (!(UESTA0X & (1 << CFGOK)));
+
+	UEIENX =
+	    (1 << RXSTPE) | (1 << RXOUTE) | (1 << STALLEDE) | (1 << TXINE);
+
+	eps[0].state = EP_IDLE;
+	eps[0].size = 64;
+
+#ifndef BOOT_LOADER
+
+	UENUM = 1;
+	UECONX = (1 << RSTDT) | (1 << EPEN);	/* enable */
+	UECFG0X = (1 << EPTYPE1) | (1 << EPDIR); /* bulk IN */
+	UECFG1X = 3 << EPSIZE0;	/* 64 bytes */
+	UECFG1X |= 1 << ALLOC;
+
+	while (!(UESTA0X & (1 << CFGOK)));
+
+	UEIENX = (1 << STALLEDE) | (1 << TXINE);
+
+	eps[1].state = EP_IDLE;
+	eps[1].size = 64;
+
+#endif
+}
+
+
+ISR(USB_GEN_vect)
+{
+	uint8_t flags;
+
+	flags = UDINT;
+	if (flags & (1 << EORSTI)) {
+		if (user_reset)
+			user_reset();
+		ep_init();
+		UDINT = ~(1 << EORSTI);
+	}
+}
+
+
+ISR(USB_COM_vect)
+{
+	uint8_t flags, i;
+
+	flags = UEINT;
+	for (i = 0; i != NUM_EPS; i++)
+		if (flags & (1 << i))
+			handle_ep(i);
+}
+
+
+void usb_reset(void)
+{
+	UDCON |= 1 << DETACH;	/* detach the pull-up */
+	_delay_ms(1);
+}

atusb/usb/dfu.c

@@ -0,0 +1,260 @@
+/*
+ * boot/dfu.c - DFU protocol engine
+ *
+ * Written 2008-2011, 2013-2015 by Werner Almesberger
+ * Copyright 2008-2011, 2013-2015 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+/*
+ * http://www.usb.org/developers/devclass_docs/DFU_1.1.pdf
+ */
+
+/*
+ * A few, erm, shortcuts:
+ *
+ * - we don't bother with the app* states since DFU is all this firmware does
+ * - after DFU_DNLOAD, we just block until things are written, so we never
+ *   enter dfuDNLOAD_SYNC or dfuDNBUSY
+ * - no dfuMANIFEST_SYNC, dfuMANIFEST, or dfuMANIFEST_WAIT_RESET
+ * - to keep our buffers small, we only accept EP0-sized blocks
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb.h"
+#include "dfu.h"
+
+#include "board.h"
+
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define debug(...)
+#define error(...)
+
+
+#ifndef DFU_ALT_SETTINGS
+#define	DFU_ALT_SETTINGS	1
+#endif
+
+#ifndef DFU_ALT_NAME_0_IDX
+#define	DFU_ALT_NAME_0_IDX	0
+#endif
+
+#ifndef DFU_ALT_NAME_1_IDX
+#define	DFU_ALT_NAME_1_IDX	0
+#endif
+
+#ifndef DFU_ALT_NAME_2_IDX
+#define	DFU_ALT_NAME_2_IDX	0
+#endif
+
+
+const uint8_t device_descriptor[] = {
+	18,			/* bLength */
+	USB_DT_DEVICE,		/* bDescriptorType */
+	LE(0x100),		/* bcdUSB */
+	USB_CLASS_APP_SPEC,	/* bDeviceClass */
+	0x00,			/* bDeviceSubClass (per interface) */
+	0x00,			/* bDeviceProtocol (per interface) */
+	EP0_SIZE,		/* bMaxPacketSize */
+	LE(DFU_USB_VENDOR),	/* idVendor */
+	LE(DFU_USB_PRODUCT),	/* idProduct */
+	LE(0x0001),		/* bcdDevice */
+	0,			/* iManufacturer */
+	0,			/* iProduct */
+#ifdef HAS_BOARD_SERNUM
+	1,			/* iSerialNumber */
+#else
+	0,			/* iSerialNumber */
+#endif
+	1			/* bNumConfigurations */
+};
+
+
+const uint8_t config_descriptor[] = {
+	9,			/* bLength */
+	USB_DT_CONFIG,		/* bDescriptorType */
+	LE(9+9*DFU_ALT_SETTINGS), /* wTotalLength */
+	1,			/* bNumInterfaces */
+	1,			/* bConfigurationValue (> 0 !) */
+	0,			/* iConfiguration */
+//	USB_ATTR_SELF_POWERED | USB_ATTR_BUS_POWERED,
+	USB_ATTR_BUS_POWERED,	/* bmAttributes */
+	((BOARD_MAX_mA)+1)/2,	/* bMaxPower */
+
+	/* Interface #0 */
+
+	DFU_ITF_DESCR(0, 0, dfu_proto_dfu, DFU_ALT_NAME_0_IDX)
+#if DFU_ALT_SETTINGS > 1
+	DFU_ITF_DESCR(0, 1, dfu_proto_dfu, DFU_ALT_NAME_1_IDX)
+#endif
+#if DFU_ALT_SETTINGS > 2
+	DFU_ITF_DESCR(0, 2, dfu_proto_dfu, DFU_ALT_NAME_2_IDX)
+#endif
+};
+
+
+static uint16_t next_block = 0;
+static bool did_download;
+
+
+static uint8_t buf[EP0_SIZE];
+
+
+static void block_write(void *user)
+{
+	uint16_t *size = user;
+
+	dfu_flash_ops->write(buf, *size);
+}
+
+
+static bool block_receive(uint16_t length)
+{
+	static uint16_t size;
+
+	if (!dfu_flash_ops->can_write(length)) {
+		dfu.state = dfuERROR;	
+		dfu.status = errADDRESS;
+		return 0;
+	}
+	if (length > EP0_SIZE) {
+		dfu.state = dfuERROR;	
+		dfu.status = errUNKNOWN;
+		return 0;
+	}
+	size = length;
+	usb_recv(&eps[0], buf, size, block_write, &size);
+	return 1;
+}
+
+
+static bool block_transmit(uint16_t length)
+{
+	uint16_t got;
+
+	if (length > EP0_SIZE) {
+		dfu.state = dfuERROR;	
+		dfu.status = errUNKNOWN;
+		return 1;
+	}
+	got = dfu_flash_ops->read(buf, length);
+	if (got < length) {
+		length = got;
+		dfu.state = dfuIDLE;
+	}
+	usb_send(&eps[0], buf, length, NULL, NULL);
+	return 1;
+}
+
+
+static bool my_setup(const struct setup_request *setup)
+{
+	bool ok;
+
+	switch (setup->bmRequestType | setup->bRequest << 8) {
+	case DFU_TO_DEV(DFU_DETACH):
+		debug("DFU_DETACH\n");
+		/*
+		 * The DFU spec says thay this is sent in protocol 1 only.
+		 * However, dfu-util also sends it to get out of DFU mode,
+		 * so we just don't make a fuss and ignore it.
+		 */
+		return 1;
+	case DFU_TO_DEV(DFU_DNLOAD):
+		debug("DFU_DNLOAD\n");
+		if (dfu.state == dfuIDLE) {
+			next_block = setup->wValue;
+			dfu_flash_ops->start();
+		}
+		else if (dfu.state != dfuDNLOAD_IDLE) {
+			error("bad state\n");
+			return 0;
+		}
+		if (dfu.state != dfuIDLE && setup->wValue == next_block-1) {
+			debug("retransmisson\n");
+			return 1;
+		}
+		if (setup->wValue != next_block) {
+			debug("bad block (%d vs. %d)\n",
+			    setup->wValue, next_block);
+			dfu.state = dfuERROR;
+			dfu.status = errUNKNOWN;
+			return 1;
+		}
+		if (!setup->wLength) {
+			debug("DONE\n");
+			dfu_flash_ops->end_write();
+			dfu.state = dfuIDLE;
+			did_download = 1;
+			return 1;
+		}
+		ok = block_receive(setup->wLength);
+		next_block++;
+		dfu.state = dfuDNLOAD_IDLE;
+		return ok;
+	case DFU_FROM_DEV(DFU_UPLOAD):
+		debug("DFU_UPLOAD\n");
+		if (dfu.state == dfuIDLE) {
+			next_block = setup->wValue;
+			dfu_flash_ops->start();
+		}
+		else if (dfu.state != dfuUPLOAD_IDLE)
+			return 0;
+		if (dfu.state != dfuIDLE && setup->wValue == next_block-1) {
+			debug("retransmisson\n");
+			/* @@@ try harder */
+			dfu.state = dfuERROR;
+			dfu.status = errUNKNOWN;
+			return 1;
+		}
+		if (setup->wValue != next_block) {
+			debug("bad block (%d vs. %d)\n",
+			    setup->wValue, next_block);
+			dfu.state = dfuERROR;
+			dfu.status = errUNKNOWN;
+			return 1;
+		}
+		ok = block_transmit(setup->wLength);
+		next_block++;
+		dfu.state = dfuUPLOAD_IDLE;
+		return ok;
+	case DFU_TO_DEV(DFU_ABORT):
+		debug("DFU_ABORT\n");
+		dfu.state = dfuIDLE;
+		dfu.status = OK;
+		return 1;
+	default:
+		return dfu_setup_common(setup);
+	}
+}
+
+
+static void my_reset(void)
+{
+#if 0
+	/* @@@ not nice -- think about where this should go */
+	extern void run_payload(void);
+
+	if (did_download)
+		run_payload();
+#endif
+}
+
+
+void dfu_init(void)
+{
+	user_setup = my_setup;
+	user_get_descriptor = dfu_my_descr;
+	user_reset = my_reset;
+}

atusb/usb/dfu.h

@@ -0,0 +1,119 @@
+/*
+ * boot/dfu.h - DFU protocol constants and data structures
+ *
+ * Written 2008, 2011, 2013-2015 by Werner Almesberger
+ * Copyright 2008, 2011, 2013-2015 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#ifndef DFU_H
+#define DFU_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb.h"
+
+
+enum dfu_request {
+	DFU_DETACH,
+	DFU_DNLOAD,
+	DFU_UPLOAD,
+	DFU_GETSTATUS,
+	DFU_CLRSTATUS,
+	DFU_GETSTATE,
+	DFU_ABORT,
+};
+
+
+enum dfu_status {
+	OK,
+	errTARGET,
+	errFILE,
+	errWRITE,
+	errERASE,
+	errCHECK_ERASED,
+	errPROG,
+	errVERIFY,
+	errADDRESS,
+	errNOTDONE,
+	errFIRMWARE,
+	errVENDOR,
+	errUSBR,
+	errPOR,
+	errUNKNOWN,
+	errSTALLEDPKT,
+};
+
+
+enum dfu_state {
+	appIDLE,
+	appDETACH,
+	dfuIDLE,
+	dfuDNLOAD_SYNC,
+	dfuDNBUSY,
+	dfuDNLOAD_IDLE,
+	dfuMANIFEST_SYNC,
+	dfuMANIFEST,
+	dfuMANIFEST_WAIT_RESET,
+	dfuUPLOAD_IDLE,
+	dfuERROR
+};
+
+enum dfu_itf_proto {
+	dfu_proto_runtime	= 1,	/* Runtime protocol */
+	dfu_proto_dfu		= 2,	/* DFU mode protocol */
+};
+
+
+#define DFU_DT_FUNCTIONAL	0x21	/* DFU FUNCTIONAL descriptor type */
+
+
+#define	DFU_TO_DEV(req)		(0x21 | (req) << 8)
+#define	DFU_FROM_DEV(req)	(0xa1 | (req) << 8)
+
+
+struct dfu {
+	uint8_t status;		/* bStatus */
+	uint8_t toL, toM, toH;	/* bwPollTimeout */
+	uint8_t state;		/* bState */
+	uint8_t iString;
+};
+
+
+#define	DFU_ITF_DESCR(itf, alt, proto, idx)				     \
+	9,			/* bLength */				     \
+	USB_DT_INTERFACE,	/* bDescriptorType */			     \
+	(itf),			/* bInterfaceNumber */			     \
+	(alt),			/* bAlternateSetting */			     \
+	0,			/* bNumEndpoints */			     \
+	0xfe,			/* bInterfaceClass (application specific) */ \
+	0x01,			/* bInterfaceSubClass (device fw upgrade) */ \
+	(proto),		/* bInterfaceProtocol (dfu_proto_*) */	     \
+	(idx),			/* iInterface */
+
+
+struct dfu_flash_ops {
+	void (*start)(void);
+	bool (*can_write)(uint16_t size);
+	void (*write)(const uint8_t *buf, uint16_t size);
+	void (*end_write)(void);
+	uint16_t (*read)(uint8_t *buf, uint16_t size);
+};
+
+extern struct dfu dfu;
+extern const struct dfu_flash_ops *dfu_flash_ops;
+
+
+bool dfu_setup_common(const struct setup_request *setup);
+bool dfu_my_descr(uint8_t type, uint8_t index, const uint8_t **reply,
+    uint8_t *size);
+
+void dfu_init(void);
+
+#endif /* !DFU_H */

atusb/usb/dfu_common.c

@@ -0,0 +1,101 @@
+/*
+ * boot/dfu_common.c - DFU protocol engine parts common to App/DFU
+ *
+ * Written 2008-2011, 2013-2014 by Werner Almesberger
+ * Copyright 2008-2011, 2013-2014 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+/*
+ * http://www.usb.org/developers/devclass_docs/DFU_1.1.pdf
+ */
+
+/*
+ * A few, erm, shortcuts:
+ *
+ * - we don't bother with the app* states since DFU is all this firmware does
+ * - after DFU_DNLOAD, we just block until things are written, so we never
+ *   enter dfuDNLOAD_SYNC or dfuDNBUSY
+ * - no dfuMANIFEST_SYNC, dfuMANIFEST, or dfuMANIFEST_WAIT_RESET
+ * - to keep our buffers small, we only accept EP0-sized blocks
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb.h"
+#include "dfu.h"
+
+#include "board.h"
+#include "../sernum.h"
+
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define debug(...)
+#define error(...)
+
+
+static const uint8_t functional_descriptor[] = {
+	9,			/* bLength */
+	DFU_DT_FUNCTIONAL,	/* bDescriptorType */
+	0xf,			/* bmAttributes (claim omnipotence :-) */
+	LE(0xffff),		/* wDetachTimeOut (we're very patient) */
+	LE(EP0_SIZE),		/* wTransferSize */
+	LE(0x101),		/* bcdDFUVersion */
+};
+
+
+/*
+ * The worst-case activity would be flashing a one page and erasing another
+ * one, would should take less than 10 ms. A 100 ms timeout ought to be plenty.
+ */
+
+struct dfu dfu = {
+	OK,			/* bStatus */
+	LE(100), 0,		/* bwPollTimeout, 100 ms */
+	dfuIDLE,		/* bState */
+	0,			/* iString */
+};
+
+
+bool dfu_setup_common(const struct setup_request *setup)
+{
+	switch (setup->bmRequestType | setup->bRequest << 8) {
+	case DFU_FROM_DEV(DFU_GETSTATUS):
+		debug("DFU_GETSTATUS\n");
+		usb_send(&eps[0], (uint8_t *) &dfu, sizeof(dfu), NULL, NULL);
+		return 1;
+	case DFU_TO_DEV(DFU_CLRSTATUS):
+		debug("DFU_CLRSTATUS\n");
+		dfu.state = dfuIDLE;
+		dfu.status = OK;
+		return 1;
+	case DFU_FROM_DEV(DFU_GETSTATE):
+		debug("DFU_GETSTATE\n");
+		usb_send(&eps[0], &dfu.state, 1, NULL, NULL);
+		return 1;
+	default:
+		error("DFU rt %x, rq%x ?\n",
+		    setup->bmRequestType, setup->bRequest);
+		return 0;
+	}
+}
+
+
+bool dfu_my_descr(uint8_t type, uint8_t index, const uint8_t **reply,
+    uint8_t *size)
+{
+	if (type != DFU_DT_FUNCTIONAL)
+		return sernum_get_descr(type, index, reply, size);
+	*reply = functional_descriptor;
+	*size = sizeof(functional_descriptor);
+	return 1;
+}

atusb/usb/usb.c

@@ -0,0 +1,181 @@
+/*
+ * fw/usb/usb.c - USB hardware setup and standard device requests
+ *
+ * Written 2008-2011, 2013, 2015 by Werner Almesberger
+ * Copyright 2008-2011, 2013, 2015 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+/*
+ * Known issues:
+ * - no suspend/resume
+ * - should support EP clearing and stalling
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "usb.h"
+#include "board.h"
+
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#if 1
+extern void panic(void);
+#define BUG_ON(cond)	do { if (cond) panic(); } while (0)
+#else
+#define BUG_ON(cond)
+#endif
+
+bool (*user_setup)(const struct setup_request *setup);
+void (*user_set_interface)(int nth);
+bool (*user_get_descriptor)(uint8_t type, uint8_t index,
+    const uint8_t **reply, uint8_t *size);
+void (*user_reset)(void);
+
+
+void usb_io(struct ep_descr *ep, enum ep_state state, uint8_t *buf,
+    uint8_t size, void (*callback)(void *user), void *user)
+{
+	BUG_ON(ep->state);
+	ep->state = state;
+	ep->buf = buf;
+	ep->end = buf+size;
+	ep->callback = callback;
+	ep->user = user;
+	usb_ep_change(ep);
+}
+
+
+static bool get_descriptor(uint8_t type, uint8_t index, uint16_t length)
+{
+	const uint8_t *reply;
+	uint8_t size;
+
+	switch (type) {
+	case USB_DT_DEVICE:
+		reply = device_descriptor;
+		size = reply[0];
+		break;
+	case USB_DT_CONFIG:
+		if (index)
+			return 0;
+		reply = config_descriptor;
+		size = reply[2];
+		break;
+	default:
+		if (!user_get_descriptor)
+			return 0;
+		if (!user_get_descriptor(type, index, &reply, &size))
+			return 0;
+	}
+	if (length < size)
+		size = length;
+	usb_send(&eps[0], reply, size, NULL, NULL);
+	return 1;
+}
+
+
+bool handle_setup(const struct setup_request *setup)
+{
+	switch (setup->bmRequestType | setup->bRequest << 8) {
+
+	/*
+	 * Device request
+	 *
+	 * See http://www.beyondlogic.org/usbnutshell/usb6.htm
+	 */
+
+	case FROM_DEVICE(GET_STATUS):
+		if (setup->wLength != 2)
+			return 0;
+		usb_send(&eps[0], "\000", 2, NULL, NULL);
+		break;
+	case TO_DEVICE(CLEAR_FEATURE):
+		break;
+	case TO_DEVICE(SET_FEATURE):
+		return 0;
+	case TO_DEVICE(SET_ADDRESS):
+		set_addr(setup->wValue);
+		break;
+	case FROM_DEVICE(GET_DESCRIPTOR):
+	case FROM_INTERFACE(GET_DESCRIPTOR):
+		if (!get_descriptor(setup->wValue >> 8, setup->wValue,
+		    setup->wLength))
+			return 0;
+		break;
+	case TO_DEVICE(SET_DESCRIPTOR):
+		return 0;
+	case FROM_DEVICE(GET_CONFIGURATION):
+		usb_send(&eps[0], "", 1, NULL, NULL);
+		break;
+	case TO_DEVICE(SET_CONFIGURATION):
+		if (setup->wValue != config_descriptor[5])
+			return 0;
+		break;
+
+	/*
+	 * Interface request
+	 */
+
+	case FROM_INTERFACE(GET_STATUS):
+		return 0;
+	case TO_INTERFACE(CLEAR_FEATURE):
+		return 0;
+	case TO_INTERFACE(SET_FEATURE):
+		return 0;
+	case FROM_INTERFACE(GET_INTERFACE):
+		return 0;
+	case TO_INTERFACE(SET_INTERFACE):
+		{
+			const uint8_t *interface_descriptor =
+			    config_descriptor+9;
+			const uint8_t *p;
+			int i;
+
+			i = 0;
+			for (p = interface_descriptor;
+			    p != config_descriptor+config_descriptor[2];
+			    p += p[0]) {
+				if (p[1] != USB_DT_INTERFACE)
+					continue;
+				if (p[2] == setup->wIndex &&
+				    p[3] == setup->wValue) {
+					if (user_set_interface)
+						user_set_interface(i);
+					return 1;
+				}
+				i++;
+			}
+			return 0;
+		}
+		break;
+
+	/*
+	 * Endpoint request
+	 */
+
+	case FROM_ENDPOINT(GET_STATUS):
+		return 0;
+	case TO_ENDPOINT(CLEAR_FEATURE):
+		return 0;
+	case TO_ENDPOINT(SET_FEATURE):
+		return 0;
+	case FROM_ENDPOINT(SYNCH_FRAME):
+		return 0;
+
+	default:
+		if (user_setup)
+			return user_setup(setup);
+		return 0;
+	}
+
+	return 1;
+}

atusb/usb/usb.h

@@ -0,0 +1,189 @@
+/*
+ * fw/usb//usb.h - USB hardware setup and standard device requests
+ *
+ * Written 2008, 2009, 2011, 2013, 2015 by Werner Almesberger
+ * Copyright 2008, 2009, 2011, 2013, 2015 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#ifndef USB_H
+#define USB_H
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+
+/*
+ * Packet identifier types
+ */
+
+#define	PID_OUT		0x1
+#define	PID_IN		0x9
+#define	PID_SOF		0x5
+#define	PID_SETUP	0xd
+#define	PID_DATA0	0x3
+#define	PID_DATA1	0xb
+#define	PID_ACK		0x2
+#define	PID_NAK		0xa
+#define	PID_STALL	0xe
+
+/*
+ * Descriptor types
+ *
+ * Reuse libusb naming scheme (/usr/include/usb.h)
+ */
+
+#define	USB_DT_DEVICE		1
+#define	USB_DT_CONFIG		2
+#define	USB_DT_STRING		3
+#define	USB_DT_INTERFACE	4
+#define	USB_DT_ENDPOINT		5
+
+/*
+ * Device classes
+ *
+ * Reuse libusb naming scheme (/usr/include/usb.h)
+ */
+
+#define USB_CLASS_PER_INTERFACE	0
+#define	USB_CLASS_COMM		2
+#define	USB_CLASS_HID		3
+#define	USB_CLASS_MASS_STORAGE	8
+#define	USB_CLASS_HUB		9
+#define	USB_CLASS_DATA		10
+#define	USB_CLASS_APP_SPEC	0xfe
+#define USB_CLASS_VENDOR_SPEC	0xff
+
+/*
+ * Configuration attributes
+ */
+
+#define	USB_ATTR_BUS_POWERED	0x80
+#define	USB_ATTR_SELF_POWERED	0x40
+#define	USB_ATTR_REMOTE_WAKEUP	0x20
+
+/*
+ * Endpoint type
+ */
+
+#define	USB_ENDPOINT_TYPE_CONTROL	0
+#define	USB_ENDPOINT_TYPE_ISOCHRONOUS	1
+#define	USB_ENDPOINT_TYPE_BULK		2
+#define	USB_ENDPOINT_TYPE_INTERRUPT	3
+
+/*
+ * Setup request types
+ */
+
+#define	TO_DEVICE(req)		(0x00 | (req) << 8)
+#define	FROM_DEVICE(req)	(0x80 | (req) << 8)
+#define	TO_INTERFACE(req)	(0x01 | (req) << 8)
+#define	FROM_INTERFACE(req)	(0x81 | (req) << 8)
+#define	TO_ENDPOINT(req)	(0x02 | (req) << 8)
+#define	FROM_ENDPOINT(req)	(0x82 | (req) << 8)
+
+/*
+ * Setup requests
+ */
+
+#define	GET_STATUS		0x00
+#define	CLEAR_FEATURE		0x01
+#define	SET_FEATURE		0x03
+#define	SET_ADDRESS		0x05
+#define	GET_DESCRIPTOR		0x06
+#define	SET_DESCRIPTOR		0x07
+#define	GET_CONFIGURATION	0x08
+#define	SET_CONFIGURATION	0x09
+#define	GET_INTERFACE		0x0a
+#define	SET_INTERFACE		0x0b
+#define	SYNCH_FRAME		0x0c
+
+/*
+ * USB Language ID codes
+ *
+ * http://www.usb.org/developers/docs/USB_LANGIDs.pdf
+ */
+
+#define	USB_LANGID_ENGLISH_US	0x409
+
+
+/*
+ * Odd. sdcc seems to think "x" assumes the size of the destination, i.e.,
+ * uint8_t. Hence the cast.
+ */
+
+#define LE(x) ((uint16_t) (x) & 0xff), ((uint16_t) (x) >> 8)
+
+#define LO(x) (((uint8_t *) &(x))[0])
+#define HI(x) (((uint8_t *) &(x))[1])
+
+
+#ifdef LOW_SPEED
+#define	EP0_SIZE	8
+#else
+#define	EP0_SIZE	64
+#endif
+
+#define	EP1_SIZE	64	/* simplify */
+
+
+enum ep_state {
+	EP_IDLE,
+	EP_RX,
+	EP_TX,
+	EP_STALL,
+};
+
+struct ep_descr {
+	enum ep_state state;
+	uint8_t *buf;
+	uint8_t *end;
+	uint8_t size;
+	void (*callback)(void *user);
+	void *user;
+};
+
+struct setup_request {
+	uint8_t bmRequestType;
+	uint8_t bRequest;
+	uint16_t wValue;
+	uint16_t wIndex;
+	uint16_t wLength;
+};
+
+
+extern const uint8_t device_descriptor[];
+extern const uint8_t config_descriptor[];
+extern struct ep_descr eps[];
+
+extern bool (*user_setup)(const struct setup_request *setup);
+extern void (*user_set_interface)(int nth);
+extern bool (*user_get_descriptor)(uint8_t type, uint8_t index,
+    const uint8_t **reply, uint8_t *size);
+extern void (*user_reset)(void);
+
+
+#define	usb_left(ep) ((ep)->end-(ep)->buf)
+#define usb_send(ep, buf, size, callback, user) \
+	usb_io(ep, EP_TX, (void *) buf, size, callback, user)
+#define usb_recv(ep, buf, size, callback, user) \
+	usb_io(ep, EP_RX, buf, size, callback, user)
+
+void usb_io(struct ep_descr *ep, enum ep_state state, uint8_t *buf,
+    uint8_t size, void (*callback)(void *user), void *user);
+
+bool handle_setup(const struct setup_request *setup);
+void set_addr(uint8_t addr);
+void usb_ep_change(struct ep_descr *ep);
+void usb_reset(void);
+void usb_init(void);
+
+void ep_init(void);
+
+#endif /* !USB_H */

atusb/version.h

@@ -0,0 +1,23 @@
+/*
+ * fw/version.h - Automatically generated version string
+ *
+ * Written 2008, 2011 by Werner Almesberger
+ * Copyright 2008, 2011 Werner Almesberger
+ *
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#ifndef VERSION_H
+#define VERSION_H
+
+#include <stdint.h>
+
+
+extern const char *build_date;
+extern const uint16_t build_number;
+
+#endif /* !VERSION_H */