From 39f1c0c136520a3f4746ad6381d1242979125ff3 Mon Sep 17 00:00:00 2001
From: Peter Henn <Peter.Henn@web.de>
Date: Sat, 28 Feb 2009 12:00:00 +0100
Subject: [PATCH] USBasp 2009.02.28.

unmodified content from archive usbasp.2009-02-28.tar.gz
---
 .gitattributes                                     |   3 +-
 Changelog.txt                                      |  10 +-
 Readme.txt                                         |   2 +-
 bin/firmware/usbasp.atmega48.2007-10-23.hex        | 238 -------
 bin/firmware/usbasp.atmega48.2009-02-28.hex        | 242 +++++++
 bin/firmware/usbasp.atmega8.2007-10-23.hex         | 237 -------
 bin/firmware/usbasp.atmega8.2009-02-28.hex         | 241 +++++++
 bin/win-driver/Readme.txt                          |   2 +
 bin/win-driver/{ => libusb_0.1.10.1}/libusb0.dll   | Bin
 bin/win-driver/{ => libusb_0.1.10.1}/libusb0.sys   | Bin
 bin/win-driver/{ => libusb_0.1.10.1}/usbasp.inf    |   0
 bin/win-driver/libusb_0.1.12.1/libusb0.dll         | Bin 0 -> 43520 bytes
 bin/win-driver/libusb_0.1.12.1/libusb0.sys         | Bin 0 -> 28672 bytes
 bin/win-driver/libusb_0.1.12.1/libusb0_x64.dll     | Bin 0 -> 43008 bytes
 bin/win-driver/libusb_0.1.12.1/libusb0_x64.sys     | Bin 0 -> 16896 bytes
 bin/win-driver/libusb_0.1.12.1/testlibusb-win.exe  | Bin 0 -> 13824 bytes
 bin/win-driver/libusb_0.1.12.1/testlibusb.exe      | Bin 0 -> 8192 bytes
 bin/win-driver/libusb_0.1.12.1/usbasp.cat          |   3 +
 bin/win-driver/libusb_0.1.12.1/usbasp.inf          | 136 ++++
 bin/win-driver/libusb_0.1.12.1/usbasp_x64.cat      |   3 +
 firmware/clock.c                                   |  27 +-
 firmware/clock.h                                   |  16 +-
 firmware/isp.c                                     | 426 ++++++------
 firmware/isp.h                                     |  22 +-
 firmware/main.c                                    | 372 +++++-----
 firmware/usbasp.h                                  |  58 ++
 firmware/usbconfig.h                               |   2 +-
 firmware/usbdrv/Changelog.txt                      | 111 +++
 firmware/usbdrv/CommercialLicense.txt              |  15 +-
 firmware/usbdrv/License.txt                        |  16 +-
 firmware/usbdrv/Readme.txt                         | 107 ++-
 firmware/usbdrv/USBID-License.txt                  |  13 +-
 firmware/usbdrv/asmcommon.inc                      | 185 +++++
 firmware/usbdrv/iarcompat.h                        |  70 --
 firmware/usbdrv/oddebug.c                          |   4 +-
 firmware/usbdrv/oddebug.h                          |   9 +-
 firmware/usbdrv/usbconfig-prototype.h              | 173 +++--
 firmware/usbdrv/usbdrv.c                           | 637 +++++++++--------
 firmware/usbdrv/usbdrv.h                           | 212 ++++--
 firmware/usbdrv/usbdrvasm.S                        | 193 ++++--
 firmware/usbdrv/usbdrvasm.asm                      |   2 +-
 firmware/usbdrv/usbdrvasm12.S                      | 555 ---------------
 firmware/usbdrv/usbdrvasm12.inc                    | 393 +++++++++++
 firmware/usbdrv/usbdrvasm128.inc                   | 752 +++++++++++++++++++++
 firmware/usbdrv/usbdrvasm15.inc                    | 423 ++++++++++++
 firmware/usbdrv/{usbdrvasm16.S => usbdrvasm16.inc} | 252 ++-----
 .../usbdrv/{usbdrvasm165.S => usbdrvasm165.inc}    | 194 +-----
 firmware/usbdrv/usbdrvasm20.inc                    | 360 ++++++++++
 firmware/usbdrv/usbportability.h                   | 140 ++++
 49 files changed, 4466 insertions(+), 2390 deletions(-)
 delete mode 100644 bin/firmware/usbasp.atmega48.2007-10-23.hex
 create mode 100644 bin/firmware/usbasp.atmega48.2009-02-28.hex
 delete mode 100644 bin/firmware/usbasp.atmega8.2007-10-23.hex
 create mode 100644 bin/firmware/usbasp.atmega8.2009-02-28.hex
 create mode 100644 bin/win-driver/Readme.txt
 rename bin/win-driver/{ => libusb_0.1.10.1}/libusb0.dll (100%)
 rename bin/win-driver/{ => libusb_0.1.10.1}/libusb0.sys (100%)
 rename bin/win-driver/{ => libusb_0.1.10.1}/usbasp.inf (100%)
 create mode 100755 bin/win-driver/libusb_0.1.12.1/libusb0.dll
 create mode 100755 bin/win-driver/libusb_0.1.12.1/libusb0.sys
 create mode 100755 bin/win-driver/libusb_0.1.12.1/libusb0_x64.dll
 create mode 100755 bin/win-driver/libusb_0.1.12.1/libusb0_x64.sys
 create mode 100755 bin/win-driver/libusb_0.1.12.1/testlibusb-win.exe
 create mode 100755 bin/win-driver/libusb_0.1.12.1/testlibusb.exe
 create mode 100644 bin/win-driver/libusb_0.1.12.1/usbasp.cat
 create mode 100644 bin/win-driver/libusb_0.1.12.1/usbasp.inf
 create mode 100644 bin/win-driver/libusb_0.1.12.1/usbasp_x64.cat
 create mode 100644 firmware/usbasp.h
 create mode 100644 firmware/usbdrv/asmcommon.inc
 delete mode 100644 firmware/usbdrv/iarcompat.h
 delete mode 100644 firmware/usbdrv/usbdrvasm12.S
 create mode 100644 firmware/usbdrv/usbdrvasm12.inc
 create mode 100644 firmware/usbdrv/usbdrvasm128.inc
 create mode 100644 firmware/usbdrv/usbdrvasm15.inc
 rename firmware/usbdrv/{usbdrvasm16.S => usbdrvasm16.inc} (53%)
 rename firmware/usbdrv/{usbdrvasm165.S => usbdrvasm165.inc} (67%)
 create mode 100644 firmware/usbdrv/usbdrvasm20.inc
 create mode 100644 firmware/usbdrv/usbportability.h

diff --git a/.gitattributes b/.gitattributes
index 3e01c7143..45814c14e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,5 +1,6 @@
 # Declare files that will always have CRLF line endings on checkout.
-*.inf text eol=crlf
+*.inf	text eol=crlf
+*.cat	text eol=crlf
 
 # Declare pacth and diff files allow trailing whitespace
 *.diff	text=auto -whitespace
diff --git a/Changelog.txt b/Changelog.txt
index d38402d38..208da9440 100644
--- a/Changelog.txt
+++ b/Changelog.txt
@@ -1,5 +1,11 @@
-usbasp.2007-10-23
------------------
+usbasp.2009-02-28 (v1.3)
+------------------------
+- added support for software control of ISP speed (based on patch by Jurgis Brigmanis)
+- included new AVRUSB driver version (Release 2008-11-26)
+- added libusb 0.1.12.1 windows drivers (needed for WinAVR version 20080512 or greater)
+
+usbasp.2007-10-23 (v1.2)
+------------------------
 - red LED turns on before connecting to target device: this signal can be used to control external tri-state buffers (by Pawel Szramowski)
 
 usbasp.2007-07-23
diff --git a/Readme.txt b/Readme.txt
index c34bdd7c6..19d1064aa 100644
--- a/Readme.txt
+++ b/Readme.txt
@@ -133,5 +133,5 @@ libusb .......................... http://libusb.sourceforge.net/
 libusb-win32 .................... http://libusb-win32.sourceforge.net/
 
 
-2007-07-23 Thomas Fischl <tfischl@gmx.de>
+2009-02-28 Thomas Fischl <tfischl@gmx.de>
 http://www.fischl.de
diff --git a/bin/firmware/usbasp.atmega48.2007-10-23.hex b/bin/firmware/usbasp.atmega48.2007-10-23.hex
deleted file mode 100644
index 9cc8782d9..000000000
--- a/bin/firmware/usbasp.atmega48.2007-10-23.hex
+++ /dev/null
@@ -1,238 +0,0 @@
-:1000000042C0D7C15BC05AC059C058C057C056C0C3
-:1000100055C054C053C052C051C050C04FC04EC054
-:100020004DC04CC04BC04AC049C048C047C046C084
-:1000300045C044C0040309041C037700770077001F
-:100040002E00660069007300630068006C002E00DB
-:10005000640065000E035500530042006100730008
-:10006000700012011001FF000008C016DC0502013B
-:1000700001020001090212000101008019090400B7
-:1000800000000000000011241FBECFEFD2E0DEBF51
-:10009000CDBF11E0A0E0B1E0E2EBFEE002C00590D0
-:1000A0000D92A230B107D9F711E0A2E0B1E001C092
-:1000B0001D92A334B107E1F797D4FAC6A1CFE9E6C0
-:1000C000F0E0808183608083E89A08950F931F9306
-:1000D000CF93DF9360912701161604F5635080914A
-:1000E0002401C7E3D1E0C81BD109809123018D32DF
-:1000F00009F44DC08091020187FD4EC0CE018CD421
-:100100008F3F09F485C0882309F05AC02FEF30E0F3
-:100110003093020120930001109227018091010188
-:1001200084FF29C0809100018F3F29F1682F893019
-:1001300008F03DC0861B809300018091020180FF82
-:1001400034C003EC8F5F8093020187FD69C0662392
-:1001500009F455C088E191E01BD5682F7727162F49
-:10016000693008F479C08FEF809300019EE100931D
-:100170001701909301019AE083B1837009F0F7C0F1
-:100180009150D1F71092280110922201F0C08AE517
-:10019000809301016830B9F020E030E8309302012B
-:1001A0002093000110922701B9CF0BE4CBCF68E078
-:1001B000861B809300018091020180FFF6CFC1CFA2
-:1001C00020E030E0EBCF8881807609F05CC020E24F
-:1001D00031E0109220018981882309F05BC01092E0
-:1001E0002101309326012093250122E030E88F8100
-:1001F0008823A1F68E81821788F6282FCFCF60E062
-:1002000088E191E0D2D094E08FEF80930001AFCFEE
-:10021000809300018EE1809301012FEF30E078CFD1
-:10022000209125013091260186FD1FC0462F4150A7
-:100230004F3F61F0F901942FA8E1B1E081918D93D6
-:100240009150E0F7240F311D2F5F3F4F309326016F
-:1002500020932501772783CF88E191E0A6D0912FC5
-:100260009C5F183008F083CFCFCF462F41504F3FCF
-:1002700069F3F901942FA8E1B1E084918D9331964F
-:100280009150D8F7DFCFCE01D5D4282F8F3FA9F0DA
-:1002900030E8ADCF853059F08630A9F08830E9F0EC
-:1002A000893021F18A3041F120E030E8A0CF8A8105
-:1002B0008093280120E030E89ACF888187FF27CFFC
-:1002C0002E8130E025CF8B818130E9F0823081F1C1
-:1002D000833011F120E030EC8ACF8AE291E09093F4
-:1002E00026018093250121E030E881CF8A81809327
-:1002F0002A0120E030E87BCF3093260120932501AE
-:1003000021E030E874CF82E690E09093260180935C
-:10031000250122E130EC6BCF8A81882391F484E3BC
-:1003200090E0909326018093250124E030EC5FCF8C
-:1003300084E790E0909326018093250122E130EC40
-:1003400056CF813059F0823029F684E590E09093C1
-:100350002601809325012EE030EC49CF88E390E020
-:1003600090932601809325012CE130EC40CFDF9162
-:10037000CF911F910F910895A82FB92F8FEF9FEF65
-:1003800041E050EA615070F02D9138E0722F7827EB
-:1003900096958795269570FF02C0842795273A95F4
-:1003A000A9F7F0CF809590950895E6DF8D939D9302
-:1003B0000895CF93CFB7CF93189BFECF189B09C05A
-:1003C000189B07C0189B05C0189B03C0189B01C051
-:1003D0009EC0DF93C0912401DD27C55DDE4F189BD1
-:1003E00002C0DF91EBCF2F930F931F9303B12FEF39
-:1003F00000FB20F94F933F9313B14FEF012700FB10
-:1004000021F93BE031C04E7F012F13B1216028C09C
-:10041000102F4D7F2260000003B129C04B7F246064
-:10042000012F000013B12BC013B1477F28602AC0F1
-:100430004F7E03B120612CC04F7D13B120622FC0CD
-:100440004F7B03B1206432C0422703B149934FEF81
-:100450000000102710FB20F913B11370A9F1297FB8
-:1004600091F2012700FB21F903B1237F89F231507A
-:10047000F0F1102710FB22F913B1277E79F2012742
-:1004800000FB23F92F7C81F203B1102710FB24F924
-:100490002F7971F200C013B1012700FB25F92F73EA
-:1004A00059F200C003B1102710FB26F9223040F2A8
-:1004B00000C013B1012700FB27F9243028F64F773D
-:1004C000206813B10000F9CF3B503195333011E073
-:1004D0001CBBB8F0C31BD0400881033C41F10B3476
-:1004E00031F11981412F1F7720912201121731F428
-:1004F000093691F10D3279F0013E69F022272093FF
-:1005000029013F914F911F910F912F91DF91CF9131
-:10051000CFBFCF911895009329013F914F911F9123
-:100520000F912F91DF91CCB3C0FD46CFF0CF00915A
-:100530002901002331F310912701112349F53430AB
-:100540004AF13093270100932301109124013BE0ED
-:10055000311B309324011EC0009127010130C4F4E7
-:100560000AE53091010134FD17C000930101C7E194
-:10057000D1E016C0052710E005B91FC0052722C02D
-:10058000052727C005272CC0052710E005B933C073
-:100590004AE503C042ED01C0432FC4E1D0E032E0A0
-:1005A00014B11360289A05B114B95F9353E020E8A1
-:1005B00020FF052705B9279517951C3FD8F620FF82
-:1005C0000527279505B917951C3FC0F620FF05277D
-:1005D0002795179505B91C3F98F620FF0527279505
-:1005E00017951C3F05B970F600C0499120FF0527FB
-:1005F00005B9279517951C3F38F620FF0527279545
-:1006000005B917951C3F38F520FF05272795179545
-:1006100005B91C3F10F520FF0527279517951C3FAE
-:1006200005B9E8F4242F3A9519F60C7F5F9105B9C6
-:1006300000C010912801C651D04011F01093220142
-:1006400011E01CBB016014B11C7F402F4C7F05B929
-:1006500014B945B956CF0527D3CF0527D8CF0527DD
-:10066000DDCF82E58CBD81E08DBD0895882339F40E
-:1006700087E693E09093420180934101089584E8D6
-:1006800093E09093420180934101089596B586B519
-:10069000891B8C30E0F3089584B18C6284B92A9868
-:1006A0002D98F4DF2A9AF2DF2A98809141019091E7
-:1006B00042018458934009F00895D3DF089584B12E
-:1006C000837D84B985B1837D85B91CBC0895FF9273
-:1006D0000F931F93182FFF2400E00CC02B98FF0CE2
-:1006E0001C99F3942D9AD2DF2D98D0DF0F5F08303C
-:1006F00029F0110F17FFF2CF2B9AF1CF8F2D9927E9
-:100700001F910F91FF9008958EBD0DB407FEFDCF90
-:100710008EB5992708950F931F930FE103C00150E1
-:100720000F3F51F1E0914101F09142018CEA0995AE
-:10073000E0914101F091420183E50995E091410189
-:10074000F091420180E00995182FE0914101F0916C
-:10075000420180E00995133591F01CBC2D9A96DF7B
-:100760002D9894DF809141019091420184589340EB
-:10077000B1F677DF0150B0F681E090E002C080E092
-:1007800090E01F910F910895EF92FF920F931F93A6
-:100790007B018C01862F8170880F880F880FE09174
-:1007A0004101F091420180620995D801C70129E019
-:1007B000B695A795979587952A95D1F7E091410130
-:1007C000F0914201099516950795F794E794E09109
-:1007D0004101F09142018E2D0995E0914101F09186
-:1007E000420180E0099599271F910F91FF90EF90AA
-:1007F00008950F931F938C01E0914101F091420104
-:1008000080EA0995812F9927E0914101F0914201F9
-:100810000995E0914101F0914201802F0995E09105
-:100820004101F091420180E0099599271F910F91B4
-:100830000895FF920F931F938C01F62EE0914101D2
-:10084000F091420180EC0995812F9927E0914101B7
-:10085000F09142010995E0914101F0914201802F10
-:100860000995E0914101F09142018F2D09958EE1AA
-:10087000AED080E090E01F910F91FF900895CF924D
-:10088000DF92EF92FF920F931F936B017C01142F65
-:10089000E0914101F09142018CE40995D701C60134
-:1008A00069E0B695A795979587956A95D1F7E091F8
-:1008B0004101F09142010995D701C601B695A7956E
-:1008C00097958795E0914101F09142010995E0915A
-:1008D0004101F091420180E009951F3FA9F006B562
-:1008E0001EE1C701B60150DF8F3F59F486B5801B6A
-:1008F0008D3310F006B51150112399F781E090E087
-:1009000007C080E090E004C08FE061D080E090E01C
-:100910001F910F91FF90EF90DF90CF900895CF92AD
-:10092000DF92EF92FF920F931F936B017C01042FD4
-:10093000122F862F8170880F880F880FE091410158
-:10094000F091420180640995D701C601E9E0B695AE
-:10095000A79597958795EA95D1F7E0914101F09198
-:1009600042010995D701C601B695A7959795879538
-:10097000E0914101F09142010995E0914101F0912E
-:100980004201802F09951123A1F00F37A9F006B578
-:100990001EE1C701B601F8DE8F3759F486B5801B1A
-:1009A0008D3310F006B51150112399F781E090E0D6
-:1009B00007C080E090E004C08FE009D080E090E0C4
-:1009C0001F910F91FF90EF90DF90CF900895382FF7
-:1009D000882349F020E096B586B5891B8C33E0F377
-:1009E0002F5F3217C1F708951BB815B88BEF8AB97E
-:1009F0008FEF84B99EEF9150F1F78150E1F714B871
-:100A000093E097B98EEF88B995BD81E02FDE57DB73
-:100A100078945CDB5BDBFDCFBF92CF92DF92EF92ED
-:100A2000FF920F931F93CF93DF937C01C62E80918B
-:100A30000301813029F0843019F08FEF90E09EC0DF
-:100A4000CC2009F499C0BB24DD2458C08091130147
-:100A500090911401892B09F063C0CD2DDD27F7019A
-:100A6000EC0FFD1F60910F01709110018091110139
-:100A70009091120121E0408152DF80910401909118
-:100A8000050101979093050180930401892BF1F4EE
-:100A9000109203018091150181FF3FC080911601E2
-:100AA0009927209113013091140182179307A9F11E
-:100AB000CE0DDF1D60910F01709110018091110129
-:100AC000909112014881DBDE91E0B92E80910F01F7
-:100AD00090911001A0911101B09112010196A11DF8
-:100AE000B11D80930F0190931001A0931101B09359
-:100AF0001201D394CD14E9F180910301813009F4FE
-:100B0000A5CFCD2DDD27F701EC0FFD1F6081809172
-:100B10000F01909110018DDEB0CF81E0B82ED6CFBD
-:100B2000CD2DDD2787010C0F1D1F60910F017091E6
-:100B30001001809111019091120120E0F801408193
-:100B4000EEDE80911601815080931601882309F012
-:100B500094CF60910F0170911001809111019091DB
-:100B60001201F80140818BDE809113018093160100
-:100B700084CF8B2D992702C080E090E0DF91CF9148
-:100B80001F910F91FF90EF90DF90CF90BF9008954D
-:100B90000F931F93CF93DF93EC01062F90910301E6
-:100BA000892F8250823018F08FEF90E03EC066238C
-:100BB000C1F110E021C080910F019091100119DE68
-:100BC000FE01E10FF11D808380910F0190911001D2
-:100BD000A0911101B09112010196A11DB11D809348
-:100BE0000F0190931001A0931101B09312011F5FA8
-:100BF000011791F0909103019230E9F660910F0195
-:100C0000709110018091110190911201BDDDFE01E2
-:100C1000E10FF11D8083D8CF083018F0802F99277D
-:100C200004C010920301802F9927DF91CF911F916B
-:100C30000F910895CF93DF93EC018981813041F1C9
-:100C4000823009F4B6C0833009F4B8C0843059F159
-:100C5000873009F484C0853009F41BC1863009F45B
-:100C60004FC0883009F4E5C0893079F481E0809381
-:100C700006018A819B81AC81BD8180930F01909395
-:100C80001001A0931101B093120120E030E006C1E1
-:100C9000329933C080E0EADC109206014198FCDC16
-:100CA00020E030E0FBC0809106018823A1F48B8115
-:100CB0002A819927982F88273327822B932BAA27BD
-:100CC00097FDA095BA2F80930F0190931001A093E8
-:100CD0001101B09312018F812E819927982F8827B7
-:100CE0003327822B932B909305018093040182E09C
-:100CF000809303012FEF30E0D1C081E0B7DCCCCF8F
-:100D000080910601882309F47FC02C819D819F700A
-:100D1000909315018D81482F5527407F5070429543
-:100D20005295507F5427407F5427420F511D5093B6
-:100D300014014093130190FD64C08F812E81992787
-:100D4000982F88273327822B932B9093050180932C
-:100D5000040181E0809303012FEF30E09FC0809178
-:100D600006018823A1F48B812A819927982F88274F
-:100D70003327822B932BAA2797FDA095BA2F809318
-:100D80000F0190931001A0931101B09312018F8174
-:100D90002E819927982F88273327822B932B909386
-:100DA00005018093040183E0809303012FEF30E07D
-:100DB00075C085DC419A20E030E070C0E0914101CF
-:100DC000F09142018A81099580930701E0914101E8
-:100DD000F09142018B81099580930801E0914101D6
-:100DE000F09142018C81099580930901E0914101C4
-:100DF000F09142018D81099580930A0124E030E051
-:100E00004DC04093160199CF8B812A819927982F45
-:100E100088273327822B932BAA2797FDA095BA2FDB
-:100E200080930F0190931001A0931101B0931201D0
-:100E30006CCF809106018823A1F48B812A819927A8
-:100E4000982F88273327822B932BAA2797FDA095CD
-:100E5000BA2F80930F0190931001A0931101B093CA
-:100E600012011092140110921301109215018F813A
-:100E70002E819927982F88273327822B932B9093A5
-:100E800005018093040184E0809303012FEF30E09B
-:100E900005C041DC8093070121E030E087E091E06C
-:100EA0009093260180932501C901DF91CF91089588
-:020EB000FFCF72
-:020EB200FF5AE5
-:00000001FF
diff --git a/bin/firmware/usbasp.atmega48.2009-02-28.hex b/bin/firmware/usbasp.atmega48.2009-02-28.hex
new file mode 100644
index 000000000..1b25ac548
--- /dev/null
+++ b/bin/firmware/usbasp.atmega48.2009-02-28.hex
@@ -0,0 +1,242 @@
+:1000000042C0ADC15BC05AC059C058C057C056C0ED
+:1000100055C054C053C052C051C050C04FC04EC054
+:100020004DC04CC04BC04AC049C048C047C046C084
+:1000300045C044C0040309041C037700770077001F
+:100040002E00660069007300630068006C002E00DB
+:10005000640065000E035500530042006100730008
+:10006000700012011001FF000008C016DC0503013A
+:1000700001020001090212000101008019090400B7
+:1000800000000000000011241FBECFEFD2E0DEBF51
+:10009000CDBF11E0A0E0B1E0E0E0FFE002C00590DC
+:1000A0000D92A230B107D9F711E0A2E0B1E001C092
+:1000B0001D92A734B107E1F7C4D420C7A1CFE9E668
+:1000C000F0E0808183608083E89A08951F93CF9346
+:1000D000DF9360912801635067FD13C08091250173
+:1000E000CCE0D0E0C81BD109C45DDE4F8091240173
+:1000F0008D3209F462C08091020187FD84C01092A4
+:1001000028018091000184FF4AC0609101016F3F86
+:1001100009F445C0693070F1685060930101809125
+:10012000180198E889278093180168E080910201FE
+:1001300087FD8BC0209126013091270186FF6DC07D
+:10014000A9E1B1E080E090E0F901E80FF91FE49146
+:10015000ED9301966817C1F76150862F90E06F5FAD
+:100160000196820F931F9093270180932601162FEB
+:100170001C5F0BC0109201018091180198E889273B
+:1001800080931801662391F614E089E191E0E3D0B1
+:100190001C3019F08FEF809301011093000194E15E
+:1001A00083B1837031F49150D9F7109229011092E4
+:1001B0002301DF91CF911F910895683009F09FCFFF
+:1001C00083EC809318018AE580930001109202016C
+:1001D0008881807659F59A8110922101898188233E
+:1001E00009F043C01092220122E081E291E0909355
+:1001F0002701809326018F81882319F49E8192170D
+:1002000008F1922F1FC0CE012DD48F3F51F18823CA
+:1002100009F475CF1092010172CF962FD901E9E14F
+:10022000F1E08D9181939150E1F796CFCE010CD5FD
+:10023000282F8F3F01F7888187FD25C09FEF80E839
+:1002400080930201909301015ACF89E191E0ACD4EF
+:10025000682F893008F453C08FEF809301011EE1AD
+:100260009CCF8EE1809300014ACF853071F08630BB
+:1002700091F0883031F1893061F18A3031F120E03C
+:1002800081E291E0B4CF9E81DACF9093290120E002
+:1002900081E291E0ACCF8B81813049F18230F9F07D
+:1002A000833029F020E080E480930201A4CF9923D9
+:1002B00049F584E390E0909327018093260124E0A0
+:1002C000F2CF21E08BE291E092CF21E081E291E058
+:1002D0008ECF90932B0120E081E291E088CF84E7DC
+:1002E00090E0909327018093260122E1DCCF82E603
+:1002F00090E0909327018093260122E1D4CF182F1C
+:100300001C5F43CF913051F0923061F684E590E06C
+:1003100090932701809326012EE0C5CF88E390E0DB
+:1003200090932701809326012CE1BDCFA82FB92FF0
+:1003300080E090E041E050EA60956F5F58F42D91C5
+:1003400038EF82279795879510F0842795273F5F90
+:10035000C8F3F3CF0895EADF8D939D930895CF936B
+:10036000CFB7CF93C395189BE9F7189B09C0189B8B
+:1003700007C0189B05C0189B03C0189B01C0A1C0F3
+:10038000DF93C0912501DD27C45DDE4F189B02C0BD
+:10039000DF91EBCF2F930F931F9303B12FEF00FB50
+:1003A00020F94F933F9313B14FEF012700FB21F941
+:1003B0003BE031C04E7F012F13B1216028C0102FC8
+:1003C0004D7F2260000003B129C04B7F2460012FC4
+:1003D000000013B12BC013B1477F28602AC04F7EA5
+:1003E00003B120612CC04F7D13B120622FC04F7B21
+:1003F00003B1206432C0422703B149934FEF00009C
+:10040000102710FB20F913B11370C9F1297F91F265
+:10041000012700FB21F903B1237F89F2315058F104
+:10042000102710FB22F913B1277E79F2012700FB78
+:1004300023F92F7C81F203B1102710FB24F92F79C7
+:1004400071F200C013B1012700FB25F92F7359F297
+:1004500000C003B1102710FB26F9223040F200C083
+:1004600013B1012700FB27F9243028F64F772068C5
+:1004700013B10000F9CF11E01CBB002717C03B509F
+:100480003195C31BD04011E01CBB0881033CE9F04F
+:100490000B34D9F0209123011981110F1213EDCFE4
+:1004A000093641F10D3211F0013E39F700932A016E
+:1004B0003F914F911F910F912F91DF91CCB3C0FDD0
+:1004C00051CFCF91CFBFCF91189520912A012223F0
+:1004D00079F310912801112311F5343012F1309382
+:1004E000280120932401109125013BE0311B30931A
+:1004F000250117C00091280101308CF40AE53091E4
+:10050000000134FD10C000930001C8E1D1E00FC02C
+:100510002795A8F45150A9F4220F0000F9CF4AE51D
+:1005200003C042ED01C0432FC4E1D0E032E014B17A
+:100530001360289A14B905B120E413E05F930127F2
+:1005400056E005B9279520F4515021F4220FF9CF38
+:10055000012756E000003B5A05B9D0F2279528F450
+:10056000515029F4220F0000F9CF012756E02795BA
+:1005700005B920F4515021F4220FF9CF012756E09C
+:100580002991332305B921F60C7F10912901110F10
+:10059000C651D04005B911F01093230111E01CBBE6
+:1005A000016014B11C7F402F4C7F5F9100C000C0E0
+:1005B00005B914B945B97CCF809145018CBD8091B6
+:1005C00042018DBD0895282F8823A1F0883008F0BE
+:1005D0003FC08CE793E09093440180934301243023
+:1005E00001F12530A0F0263081F1263050F127307E
+:1005F000E1F008958DE993E09093440180934301E5
+:1006000082E58093450181E0809342010895223084
+:10061000A1F0233070F4213061F780EC8093460123
+:10062000089588E180934601089583E08093460110
+:10063000089580E380934601089580E68093460103
+:1006400008958CE080934601089520934601089513
+:100650008DE993E09093440180934301109242010D
+:10066000293041F02A3050F4283051F683E5809348
+:100670004501089582E58093450108952B3031F0BE
+:100680002C3009F0BDCF81E08093420181E5809359
+:100690004501089526B59091460186B5821B8917BC
+:1006A000E0F3089584B18C6284B92A982D9896B5A8
+:1006B0002091460186B5891B8217E0F32A9A96B5E8
+:1006C00086B5891B8217E0F32A98809143019091A7
+:1006D00044018D59934009F00895809145018CBDE6
+:1006E000809142018DBD089584B1837D84B985B127
+:1006F000837D85B91CBC0895582F2091460140E0A8
+:1007000030E057FD16C02B98440F1C994F5F2D9A6F
+:1007100096B586B5891B8217E0F32D9896B586B5F8
+:10072000891B8217E0F33F5F383029F0550F57FFE0
+:10073000EACF2B9AE9CF842F08958EBD0DB407FE22
+:10074000FDCF8EB508950F931F930FE1E091430104
+:10075000F09144018CEA0995E0914301F091440144
+:1007600083E50995E0914301F091440180E009950A
+:10077000182FE0914301F091440180E00995133571
+:1007800039F11CBC2D9A96B52091460186B5891B7E
+:100790008217E0F32D9896B586B5891B8217E0F392
+:1007A000E0914301F091440183E0ED39F80721F035
+:1007B000002351F00150CECF809145018CBD809136
+:1007C00042018DBD0023B1F781E01F910F91089583
+:1007D00080E01F910F910895EF92FF920F931F9366
+:1007E0007B018C01862F8170880F880F880FE09124
+:1007F0004301F091440180620995D801C70129E0C5
+:10080000B695A795979587952A95D1F7E0914301DD
+:10081000F0914401099516950795F794E794E091B6
+:100820004301F09144018E2D0995E0914301F0912F
+:10083000440180E009951F910F91FF90EF9008957A
+:100840000F931F938C01E0914301F091440180EAE2
+:100850000995E0914301F0914401812F0995E091C0
+:100860004301F0914401802F0995E0914301F091FB
+:10087000440180E009951F910F910895FF920F9315
+:100880001F938C01F62EE0914301F091440180EC1E
+:100890000995E0914301F0914401812F0995E09180
+:1008A0004301F0914401802F0995E0914301F091BB
+:1008B00044018F2D09958EE1B7D080E01F910F91F3
+:1008C000FF900895CF92DF92EF92FF920F931F93C4
+:1008D0006B017C01142FE0914301F09144018CE401
+:1008E0000995D701C60149E0B695A79597958795D3
+:1008F0004A95D1F7E0914301F09144010995D70160
+:10090000C601B695A79597958795E0914301F0911B
+:1009100044010995E0914301F091440180E009957B
+:100920001F3FF1F016B50EE1C701B60155DF8F3F4D
+:1009300079F486B5811B8D33B8F316B50150A1F754
+:1009400081E01F910F91FF90EF90DF90CF9008957D
+:1009500080E01F910F91FF90EF90DF90CF9008956E
+:100960008FE062D080E01F910F91FF90EF90DF90B9
+:10097000CF900895CF92DF92EF92FF920F931F9343
+:100980006B017C01042F122F862F8170880F880F36
+:10099000880FE0914301F091440180640995D701EB
+:1009A000C60169E0B695A795979587956A95D1F7A1
+:1009B000E0914301F09144010995D701C601B69534
+:1009C000A79597958795E0914301F091440109958A
+:1009D000E0914301F0914401802F09951123C1F06A
+:1009E0000F37F1F016B50EE1C701B601F5DE8F370E
+:1009F00079F486B5811B8D33B8F316B50150A1F794
+:100A000081E01F910F91FF90EF90DF90CF900895BC
+:100A100080E01F910F91FF90EF90DF90CF900895AD
+:100A20008FE002D080E0F5CF382F882349F020E016
+:100A300096B586B5891B8C33E0F32F5F2317C0F37F
+:100A400008951BB815B88BEF8AB98FEF84B914B825
+:100A500093E097B98EEF88B995BD31DB789436DB9A
+:100A600035DBFDCFFF920F931F93CF93DF93F82ECB
+:100A7000292F062F40910301413051F0443041F0BD
+:100A80001FEF812FDF91CF911F910F91FF9008955C
+:100A9000002309F487C08F2D922F9C01E90110E0FB
+:100AA00053C08091140190911501892B09F058C011
+:100AB00060911001709111018091120190911301C8
+:100AC00021E0488157DF8091040190910501019751
+:100AD0009093050180930401892BD9F410920301AE
+:100AE0008091160181FF3AC08091170190E020911A
+:100AF0001401309115018217930781F16091100163
+:100B00007091110180911201909113014881DADEF8
+:100B100011E08091100190911101A0911201B0910A
+:100B200013010196A11DB11D809310019093110135
+:100B3000A0931201B093130121969E012F19201743
+:100B400008F09FCF40910301413009F4AACF68819A
+:100B5000809110019091110191DEB5CF11E0D9CFB4
+:100B60006091100170911101809112019091130117
+:100B700020E04881FFDE80911701815080931701AA
+:100B8000882309F0A0CF609110017091110180912C
+:100B9000120190911301488195DE80911401809398
+:100BA000170191CF10E06DCF0F931F93CF93DF9379
+:100BB000082F162F40910301842F8250823038F085
+:100BC0001FEF812FDF91CF911F910F910895662321
+:100BD00099F1802F9C01E90120C080911001909132
+:100BE00011012EDE88838091100190911101A09156
+:100BF0001201B09113010196A11DB11D8093100146
+:100C000090931101A0931201B093130121969E01BC
+:100C1000201B211778F4409103014230F1F66091D6
+:100C20001001709111018091120190911301D4DD96
+:100C30008883D9CF183028F610920301812FDF91D5
+:100C4000CF911F910F9108950F931F93CF93DF932F
+:100C50008C01EC0189818130F1F0823009F4B0C05F
+:100C6000833031F1843009F482C0873009F456C0F2
+:100C7000853009F41EC1863009F4D7C0883009F4E4
+:100C8000A5C0893009F41CC18A3009F42DC180E067
+:100C9000C8E0D1E037C0329B3EC08091060193DCB2
+:100CA000109207014198FEDC80E0C8E0D1E02AC044
+:100CB000E0914301F0914401E8018A810995C8E07F
+:100CC000D1E0809308012091430130914401F80163
+:100CD0008381F901099580930901209143013091A5
+:100CE0004401F8018481F901099580930A0120915A
+:100CF000430130914401F8018581F9010995809300
+:100D00000B0184E0D0932701C0932601DF91CF919E
+:100D10001F910F91089585E056DCC2CF80910701A5
+:100D2000882399F4E8019B8180E02A8130E0822BBE
+:100D3000932BAA2797FDA095BA2F8093100190932B
+:100D40001101A0931201B0931301F801978180E083
+:100D5000268130E0822B932B909305018093040130
+:100D600083E0809303018FEFC8E0D1E0CBCF809187
+:100D70000701882399F4E8019B8180E02A8130E013
+:100D8000822B932BAA2797FDA095BA2F8093100151
+:100D900090931101A0931201B0931301F801978170
+:100DA00080E0268130E0822B932B90930501809385
+:100DB000040182E0809303018FEFC8E0D1E0A2CF6D
+:100DC00093DC419A80E0C8E0D1E09CCF809107019C
+:100DD000882399F4F801938180E0228130E0822B0E
+:100DE000932BAA2797FDA095BA2F8093100190937B
+:100DF0001101A0931201B0931301109215011092EA
+:100E0000140110921601E8019F8180E02E8130E0EC
+:100E1000822B932B909305018093040184E08093AF
+:100E200003018FEFC8E0D1E06DCF809107018823E7
+:100E300099F4E8019B8180E02A8130E0822B932B9A
+:100E4000AA2797FDA095BA2F8093100190931101C6
+:100E5000A0931201B0931301F80184819581292F89
+:100E60002F7020931601492F50E0407F507042951B
+:100E70005295507F5427407F5427480F511D50935F
+:100E800015014093140120FF02C040931701E801AF
+:100E90009F8180E02E8130E0822B932B909305017F
+:100EA0008093040181E0809303018FEFC8E0D1E0DB
+:100EB00029CF49DCC8E0D1E08093080181E022CF4E
+:100EC00081E080930701F80182819381A481B5813B
+:100ED0008093100190931101A0931201B09313011C
+:100EE00080E0C8E0D1E00ECFE8018A81809306015E
+:100EF000C8E0D1E01092080181E004CFF894FFCF60
+:020F00005AFF96
+:00000001FF
diff --git a/bin/firmware/usbasp.atmega8.2007-10-23.hex b/bin/firmware/usbasp.atmega8.2007-10-23.hex
deleted file mode 100644
index 71f99a346..000000000
--- a/bin/firmware/usbasp.atmega8.2007-10-23.hex
+++ /dev/null
@@ -1,237 +0,0 @@
-:100000003BC0D0C154C053C052C051C050C04FC0FB
-:100010004EC04DC04CC04BC04AC049C048C047C08C
-:1000200046C045C044C0040309041C0377007700A0
-:1000300077002E00660069007300630068006C00A2
-:100040002E00640065000E0355005300420061005D
-:100050007300700012011001FF000008C016DC05DB
-:1000600002010102000109021200010100801909C8
-:10007000040000000000000011241FBECFE5D4E002
-:10008000DEBFCDBF10E0A0E6B0E0E2EAFEE002C0D5
-:1000900005900D92A236B107D9F710E0A2E6B0E0C4
-:1000A00001C01D92A33AB107E1F796D4F9C6A8CFD3
-:1000B00085B7836085BF8BB780648BBF08950F932E
-:1000C0001F93CF93DF9360918700161604F563505A
-:1000D00080918400C7E9D0E0C81BD10980918300DA
-:1000E0008D3209F44DC08091620087FD4EC0CE0173
-:1000F0008BD48F3F09F485C0882309F05AC02FEFB5
-:1001000030E030936200209360001092870080916D
-:10011000610084FF29C0809160008F3F29F1682F22
-:10012000893008F03DC0861B80936000809162009A
-:1001300080FF34C003EC8F5F8093620087FD69C04D
-:10014000662309F455C088E790E01AD5682F772711
-:10015000162F693008F479C08FEF809360009EE11C
-:1001600000937700909361009AE086B3837009F062
-:10017000F7C09150D1F71092880010928200F0C021
-:100180008AE5809361006830B9F020E030E8309370
-:1001900062002093600010928700B9CF0BE4CBCFB0
-:1001A00068E0861B809360008091620080FFF6CF3C
-:1001B000C1CF20E030E0EBCF8881807609F05CC0D1
-:1001C00020E830E0109280008981882309F05BC02C
-:1001D00010928100309386002093850022E030E861
-:1001E0008F818823A1F68E81821788F6282FCFCFA2
-:1001F00060E088E790E0D2D094E08FEF80936000D9
-:10020000AFCF809360008EE1809361002FEF30E0EC
-:1002100078CF209185003091860086FD1FC0462F43
-:1002200041504F3F61F0F901942FA8E7B0E0819170
-:100230008D939150E0F7240F311D2F5F3F4F309386
-:10024000860020938500772783CF88E790E0A6D0AB
-:10025000912F9C5F183008F083CFCFCF462F4150AD
-:100260004F3F69F3F901942FA8E7B0E084918D9393
-:1002700031969150D8F7DFCFCE01D4D4282F8F3FBD
-:10028000A9F030E8ADCF853059F08630A9F088303C
-:10029000E9F0893021F18A3041F120E030E8A0CF47
-:1002A0008A818093880020E030E89ACF888187FF98
-:1002B00027CF2E8130E025CF8B818130E9F082304D
-:1002C00081F1833011F120E030EC8ACF8AE890E0B0
-:1002D000909386008093850021E030E881CF8A8169
-:1002E00080938A0020E030E87BCF30938600209313
-:1002F000850021E030E874CF84E590E0909386009B
-:100300008093850022E130EC6BCF8A81882391F4C1
-:1003100086E290E0909386008093850024E030ECA4
-:100320005FCF86E690E0909386008093850022E17F
-:1003300030EC56CF813059F0823029F686E490E0D7
-:1003400090938600809385002EE030EC49CF8AE2BE
-:1003500090E090938600809385002CE130EC40CFB4
-:10036000DF91CF911F910F910895A82FB92F8FEF93
-:100370009FEF41E050EA615070F02D9138E0722F0C
-:10038000782796958795269570FF02C08427952734
-:100390003A95A9F7F0CF809590950895E6DF8D9373
-:1003A0009D930895CF93CFB7CF93B09BFECFB09BD3
-:1003B00009C0B09B07C0B09B05C0B09B03C0B09BF9
-:1003C00001C09EC0DF93C0918400DD27C557DF4F79
-:1003D000B09B02C0DF91EBCF2F930F931F9306B317
-:1003E0002FEF00FB20F94F933F9316B34FEF0127F8
-:1003F00000FB21F93BE031C04E7F012F16B3216095
-:1004000028C0102F4D7F2260000006B329C04B7F0B
-:100410002460012F000016B32BC016B3477F28605D
-:100420002AC04F7E06B320612CC04F7D16B32062D8
-:100430002FC04F7B06B3206432C0422706B34993D6
-:100440004FEF0000102710FB20F916B31370A9F12D
-:10045000297F91F2012700FB21F906B3237F89F25E
-:100460003150F0F1102710FB22F916B3277E79F2F4
-:10047000012700FB23F92F7C81F206B3102710FB24
-:1004800024F92F7971F200C016B3012700FB25F97A
-:100490002F7359F200C006B3102710FB26F9223043
-:1004A00040F200C016B3012700FB27F9243028F6DC
-:1004B0004F77206816B30000F9CF3B5031953330A9
-:1004C00010E41ABFB8F0C31BD0400881033C41F1CF
-:1004D0000B3431F11981412F1F77209182001217BF
-:1004E00031F4093691F10D3279F0013E69F022279D
-:1004F000209389003F914F911F910F912F91DF9190
-:10050000CF91CFBFCF911895009389003F914F9124
-:100510001F910F912F91DF91CAB7C6FD46CFF0CF43
-:1005200000918900002331F310918700112349F5D0
-:1005300034304AF130938700009383001091840097
-:100540003BE0311B309384001EC0009187000130D6
-:10055000C4F40AE53091610034FD17C000936100D6
-:10056000C7E7D0E016C0052710E008BB1FC005276D
-:1005700022C0052727C005272CC0052710E008BB8F
-:1005800033C04AE503C042ED01C0432FC4E1D0E0CF
-:1005900032E017B31360C09A08B317BB5F9353E000
-:1005A00020E820FF052708BB279517951C3FD8F6A4
-:1005B00020FF0527279508BB17951C3FC0F620FF95
-:1005C00005272795179508BB1C3F98F620FF0527A0
-:1005D000279517951C3F08BB70F600C0499120FF76
-:1005E000052708BB279517951C3F38F620FF0527E0
-:1005F000279508BB17951C3F38F520FF0527279541
-:10060000179508BB1C3F10F520FF05272795179568
-:100610001C3F08BBE8F4242F3A9519F60C7F5F9134
-:1006200008BB00C010918800C651D04011F0109353
-:10063000820010E41ABF016017B31C7F402F4C7F6B
-:1006400008BB17BB48BB56CF0527D3CF0527D8CF4C
-:100650000527DDCF82E58DB981E08EB90895882325
-:1006600039F480E693E09093A2008093A10008956E
-:100670008DE793E09093A2008093A100089592B734
-:1006800082B7891B8C30E0F3089587B38C6287BBF7
-:10069000C298C598F4DFC29AF2DFC2988091A10097
-:1006A0009091A2008D57934009F00895D3DF0895EB
-:1006B00087B3837D87BB88B3837D88BB1DB80895CE
-:1006C000FF920F931F93182FFF2400E00CC0C398D4
-:1006D000FF0CB499F394C59AD2DFC598D0DF0F5FB1
-:1006E000083029F0110F17FFF2CFC39AF1CF8F2DE9
-:1006F00099271F910F91FF9008958FB9779BFECF97
-:100700008FB1992708950F931F930FE103C00150F4
-:100710000F3F51F1E091A100F091A2008CEA099500
-:10072000E091A100F091A20083E50995E091A1007C
-:10073000F091A20080E00995182FE091A100F091BE
-:10074000A20080E00995133591F01DB8C59A97DF96
-:10075000C59895DF8091A1009091A2008D5793409C
-:10076000B1F678DF0150B0F681E090E002C080E0A1
-:1007700090E01F910F910895EF92FF920F931F93B6
-:100780007B018C01862F8170880F880F880FE09184
-:10079000A100F091A20080620995D801C70129E06B
-:1007A000B695A795979587952A95D1F7E091A100E1
-:1007B000F091A200099516950795F794E794E091BA
-:1007C000A100F091A2008E2D0995E091A100F09179
-:1007D000A20080E0099599271F910F91FF90EF905B
-:1007E00008950F931F938C01E091A100F091A20056
-:1007F00080EA0995812F9927E091A100F091A2004C
-:100800000995E091A100F091A200802F0995E09157
-:10081000A100F091A20080E0099599271F910F9106
-:100820000895FF920F931F938C01F62EE091A10083
-:10083000F091A20080EC0995812F9927E091A10009
-:10084000F091A2000995E091A100F091A200802F03
-:100850000995E091A100F091A2008F2D09958EE1FC
-:10086000AED080E090E01F910F91FF900895CF925D
-:10087000DF92EF92FF920F931F936B017C01142F75
-:10088000E091A100F091A2008CE40995D701C60186
-:1008900069E0B695A795979587956A95D1F7E09108
-:1008A000A100F091A2000995D701C601B695A795C0
-:1008B00097958795E091A100F091A2000995E091AC
-:1008C000A100F091A20080E009951F3FA9F002B7B6
-:1008D0001EE1C701B60150DF8F3F59F482B7801B7C
-:1008E0008D3310F002B71150112399F781E090E099
-:1008F00007C080E090E004C08FE061D080E090E02D
-:100900001F910F91FF90EF90DF90CF900895CF92BD
-:10091000DF92EF92FF920F931F936B017C01042FE4
-:10092000122F862F8170880F880F880FE091A10009
-:10093000F091A20080640995D701C601E9E0B6955F
-:10094000A79597958795EA95D1F7E091A100F09149
-:10095000A2000995D701C601B695A79597958795E9
-:10096000E091A100F091A2000995E091A100F09121
-:10097000A200802F09951123A1F00F37A9F002B72B
-:100980001EE1C701B601F8DE8F3759F482B7801B2C
-:100990008D3310F002B71150112399F781E090E0E8
-:1009A00007C080E090E004C08FE009D080E090E0D4
-:1009B0001F910F91FF90EF90DF90CF900895382F07
-:1009C000882349F020E092B782B7891B8C33E0F38B
-:1009D0002F5F3217C1F7089512BA18BA8BEF81BB97
-:1009E0008FEF87BB9EEF9150F1F78150E1F717BA77
-:1009F00093E094BB8EEF85BB93BF81E030DE58DB84
-:100A000078945DDB5CDBFDCFBF92CF92DF92EF92FB
-:100A1000FF920F931F93CF93DF937C01C62E80919B
-:100A20006300813029F0843019F08FEF90E09EC090
-:100A3000CC2009F499C0BB24DD2458C080917300F8
-:100A400090917400892B09F063C0CD2DDD27F7014B
-:100A5000EC0FFD1F60916F0070917000809171002C
-:100A60009091720021E0408152DF8091640090916A
-:100A7000650001979093650080936400892BF1F4E1
-:100A8000109263008091750081FF3FC080917600D5
-:100A90009927209173003091740082179307A9F170
-:100AA000CE0DDF1D60916F0070917000809171001C
-:100AB000909172004881DBDE91E0B92E80916F0049
-:100AC00090917000A0917100B09172000196A11DEB
-:100AD000B11D80936F0090937000A0937100B0934C
-:100AE0007200D394CD14E9F180916300813009F450
-:100AF000A5CFCD2DDD27F701EC0FFD1F6081809183
-:100B00006F00909170008DDEB0CF81E0B82ED6CF0F
-:100B1000CD2DDD2787010C0F1D1F60916F00709197
-:100B20007000809171009091720020E0F801408186
-:100B3000EEDE80917600815080937600882309F064
-:100B400094CF60916F0070917000809171009091CE
-:100B50007200F80140818BDE8091730080937600F3
-:100B600084CF8B2D992702C080E090E0DF91CF9158
-:100B70001F910F91FF90EF90DF90CF90BF9008955D
-:100B80000F931F93CF93DF93EC01062F9091630097
-:100B9000892F8250823018F08FEF90E03EC066239C
-:100BA000C1F110E021C080916F009091700019DEBA
-:100BB000FE01E10FF11D808380916F009091700024
-:100BC000A0917100B09172000196A11DB11D80939A
-:100BD0006F0090937000A0937100B09372001F5F3C
-:100BE000011791F0909163009230E9F660916F00E7
-:100BF000709170008091710090917200BDDDFE01D6
-:100C0000E10FF11D8083D8CF083018F0802F99278D
-:100C100004C010926300802F9927DF91CF911F911C
-:100C20000F910895CF93DF93EC018981813041F1D9
-:100C3000823009F4B6C0833009F4B8C0843059F169
-:100C4000873009F484C0853009F41BC1863009F46B
-:100C50004FC0883009F4E5C0893079F481E0809391
-:100C600066008A819B81AC81BD8180936F009093E7
-:100C70007000A0937100B093720020E030E006C1D4
-:100C80009A9933C080E0EBDC10926600A998FDDCF5
-:100C900020E030E0FBC0809166008823A1F48B81C6
-:100CA0002A819927982F88273327822B932BAA27CD
-:100CB00097FDA095BA2F80936F0090937000A0933A
-:100CC0007100B09372008F812E819927982F882709
-:100CD0003327822B932B909365008093640082E0EE
-:100CE000809363002FEF30E0D1C081E0B8DCCCCF3F
-:100CF00080916600882309F47FC02C819D819F70BC
-:100D0000909375008D81482F5527407F50704295F4
-:100D10005295507F5427407F5427420F511D5093C6
-:100D200074004093730090FD64C08F812E819927D9
-:100D3000982F88273327822B932B909365008093DD
-:100D4000640081E0809363002FEF30E09FC08091CA
-:100D500066008823A1F48B812A819927982F882700
-:100D60003327822B932BAA2797FDA095BA2F809328
-:100D70006F0090937000A0937100B09372008F8108
-:100D80002E819927982F88273327822B932B909396
-:100D900065008093640083E0809363002FEF30E070
-:100DA00075C086DCA99A20E030E070C0E091A10017
-:100DB000F091A2008A81099580936700E091A100DB
-:100DC000F091A2008B81099580936800E091A100C9
-:100DD000F091A2008C81099580936900E091A100B7
-:100DE000F091A2008D81099580936A0024E030E0A3
-:100DF0004DC04093760099CF8B812A819927982FF7
-:100E000088273327822B932BAA2797FDA095BA2FEB
-:100E100080936F0090937000A0937100B093720064
-:100E20006CCF809166008823A1F48B812A81992759
-:100E3000982F88273327822B932BAA2797FDA095DD
-:100E4000BA2F80936F0090937000A0937100B093BD
-:100E500072001092740010927300109275008F81CE
-:100E60002E819927982F88273327822B932B9093B5
-:100E700065008093640084E0809363002FEF30E08E
-:100E800005C041DC8093670021E030E087E690E018
-:100E90009093860080938500C901DF91CF910895DA
-:020EA000FFCF82
-:020EA200FF5AF5
-:00000001FF
diff --git a/bin/firmware/usbasp.atmega8.2009-02-28.hex b/bin/firmware/usbasp.atmega8.2009-02-28.hex
new file mode 100644
index 000000000..b06b92574
--- /dev/null
+++ b/bin/firmware/usbasp.atmega8.2009-02-28.hex
@@ -0,0 +1,241 @@
+:100000003BC0A6C154C053C052C051C050C04FC025
+:100010004EC04DC04CC04BC04AC049C048C047C08C
+:1000200046C045C044C0040309041C0377007700A0
+:1000300077002E00660069007300630068006C00A2
+:100040002E00640065000E0355005300420061005D
+:100050007300700012011001FF000008C016DC05DB
+:1000600003010102000109021200010100801909C7
+:10007000040000000000000011241FBECFE5D4E002
+:10008000DEBFCDBF10E0A0E6B0E0E0EFFEE002C0D2
+:1000900005900D92A236B107D9F710E0A2E6B0E0C4
+:1000A00001C01D92A73AB107E1F7C3D41FC7A8CF7B
+:1000B00085B7836085BF8BB780648BBF08951F931E
+:1000C000CF93DF9360918800635067FD13C08091E8
+:1000D0008500CCE0D0E0C81BD109C457DF4F809128
+:1000E00084008D3209F462C08091620087FD84C073
+:1000F000109288008091600084FF4AC06091610086
+:100100006F3F09F445C0693070F168506093610039
+:100110008091780098E889278093780068E0809142
+:10012000620087FD8BC0209186003091870086FF9A
+:100130006DC0A9E7B0E080E090E0F901E80FF91F99
+:10014000E491ED9301966817C1F76150862F90E016
+:100150006F5F0196820F931F9093870080938600B4
+:10016000162F1C5F0BC0109261008091780098E8F8
+:10017000892780937800662391F614E089E790E060
+:10018000E3D01C3019F08FEF809361001093600072
+:1001900094E186B3837031F49150D9F710928900BD
+:1001A00010928300DF91CF911F910895683009F07C
+:1001B0009FCF83EC809378008AE580936000109253
+:1001C00062008881807659F59A8110928100898138
+:1001D000882309F043C01092820022E081E890E079
+:1001E00090938700809386008F81882319F49E81E5
+:1001F000921708F1922F1FC0CE012CD48F3F51F1DE
+:10020000882309F475CF1092610072CF962FD9011F
+:10021000E9E7F0E08D9181939150E1F796CFCE011F
+:100220000BD5282F8F3F01F7888187FD25C09FEFD1
+:1002300080E880936200909361005ACF89E790E054
+:10024000ABD4682F893008F453C08FEF80936100DE
+:100250001EE19CCF8EE1809360004ACF853071F023
+:10026000863091F0883031F1893061F18A3031F196
+:1002700020E081E890E0B4CF9E81DACF90938900AE
+:1002800020E081E890E0ACCF8B81813049F1823071
+:10029000F9F0833029F020E080E480936200A4CF5D
+:1002A000992349F586E290E0909387008093860039
+:1002B00024E0F2CF21E08BE890E092CF21E081E8CA
+:1002C00090E08ECF90938B0020E081E890E088CF83
+:1002D00086E690E0909387008093860022E1DCCF51
+:1002E00084E590E0909387008093860022E1D4CF4C
+:1002F000182F1C5F43CF913051F0923061F686E4A5
+:1003000090E090938700809386002EE0C5CF8AE22C
+:1003100090E090938700809386002CE1BDCFA82FBA
+:10032000B92F80E090E041E050EA60956F5F58F4AB
+:100330002D9138EF82279795879510F08427952780
+:100340003F5FC8F3F3CF0895EADF8D939D9308953F
+:10035000CF93CFB7CF93C395B09BE9F7B09B09C0BC
+:10036000B09B07C0B09B05C0B09B03C0B09B01C051
+:10037000A1C0DF93C0918500DD27C457DF4FB09B3C
+:1003800002C0DF91EBCF2F930F931F9306B32FEF94
+:1003900000FB20F94F933F9316B34FEF012700FB6B
+:1003A00021F93BE031C04E7F012F16B3216028C0F8
+:1003B000102F4D7F2260000006B329C04B7F2460C0
+:1003C000012F000016B32BC016B3477F28602AC048
+:1003D0004F7E06B320612CC04F7D16B320622FC024
+:1003E0004F7B06B3206432C0422706B349934FEFD8
+:1003F0000000102710FB20F916B31370C9F1297FF4
+:1004000091F2012700FB21F906B3237F89F23150D5
+:1004100058F1102710FB22F916B3277E79F2012735
+:1004200000FB23F92F7C81F206B3102710FB24F97F
+:100430002F7971F200C016B3012700FB25F92F7345
+:1004400059F200C006B3102710FB26F9223040F203
+:1004500000C016B3012700FB27F9243028F64F7798
+:10046000206816B30000F9CF10E41ABF002717C0A8
+:100470003B503195C31BD04010E41ABF0881033CA8
+:10048000E9F00B34D9F0209183001981110F121378
+:10049000EDCF093641F10D3211F0013E39F70093ED
+:1004A0008A003F914F911F910F912F91DF91CAB711
+:1004B000C6FD51CFCF91CFBFCF91189520918A0023
+:1004C000222379F310918800112311F5343012F1B1
+:1004D0003093880020938400109185003BE0311B0D
+:1004E0003093850017C00091880001308CF40AE534
+:1004F0003091600034FD10C000936000C8E7D0E088
+:100500000FC02795A8F45150A9F4220F0000F9CF8D
+:100510004AE503C042ED01C0432FC4E1D0E032E020
+:1005200017B31360C09A17BB08B320E413E05F93BE
+:10053000012756E008BB279520F4515021F4220FE3
+:10054000F9CF012756E000003B5A08BBD0F22795AF
+:1005500028F4515029F4220F0000F9CF012756E06A
+:10056000279508BB20F4515021F4220FF9CF012721
+:1005700056E02991332308BB21F60C7F10918900A6
+:10058000110FC651D04008BB11F01093830010E446
+:100590001ABF016017B31C7F402F4C7F5F9100C0D2
+:1005A00000C008BB17BB48BB7CCF8091A5008DB9AC
+:1005B0008091A2008EB90895282F8823A1F0883059
+:1005C00008F03FC085E793E09093A4008093A300D8
+:1005D000243001F12530A0F0263081F1263050F191
+:1005E0002730E1F0089586E993E09093A40080938A
+:1005F000A30082E58093A50081E08093A200089586
+:100600002230A1F0233070F4213061F780EC809328
+:10061000A600089588E18093A600089583E0809362
+:10062000A600089580E38093A600089580E6809355
+:10063000A60008958CE08093A60008952093A6005C
+:10064000089586E993E09093A4008093A30010920C
+:10065000A200293041F02A3050F4283051F683E5C9
+:100660008093A500089582E58093A50008952B301E
+:1006700031F02C3009F0BDCF81E08093A20081E5FC
+:100680008093A500089522B79091A60082B7821B9F
+:100690008917E0F3089587B38C6287BBC298C59829
+:1006A00092B72091A60082B7891B8217E0F3C29A05
+:1006B00092B782B7891B8217E0F3C2988091A3009A
+:1006C0009091A4008659934009F008958091A50067
+:1006D0008DB98091A2008EB9089587B3837D87BBC1
+:1006E00088B3837D88BB1DB80895582F2091A6003C
+:1006F00040E030E057FD16C0C398440FB4994F5FF7
+:10070000C59A92B782B7891B8217E0F3C59892B752
+:1007100082B7891B8217E0F33F5F383029F0550F0D
+:1007200057FFEACFC39AE9CF842F08958FB9779BFB
+:10073000FECF8FB108950F931F930FE1E091A300B7
+:10074000F091A4008CEA0995E091A300F091A40037
+:1007500083E50995E091A300F091A40080E009955C
+:10076000182FE091A300F091A40080E009951335C3
+:1007700039F11DB8C59A92B72091A60082B7891B9E
+:100780008217E0F3C59892B782B7891B8217E0F30E
+:10079000E091A300F091A40083E0E639F80721F08E
+:1007A000002351F00150CECF8091A5008DB98091EA
+:1007B000A2008EB90023B1F781E01F910F91089537
+:1007C00080E01F910F910895EF92FF920F931F9376
+:1007D0007B018C01862F8170880F880F880FE09134
+:1007E000A300F091A40080620995D801C70129E017
+:1007F000B695A795979587952A95D1F7E091A3008F
+:10080000F091A400099516950795F794E794E09167
+:10081000A300F091A4008E2D0995E091A300F09122
+:10082000A40080E009951F910F91FF90EF9008952B
+:100830000F931F938C01E091A300F091A40080EA34
+:100840000995E091A300F091A400812F0995E09112
+:10085000A300F091A400802F0995E091A300F091EE
+:10086000A40080E009951F910F910895FF920F93C6
+:100870001F938C01F62EE091A300F091A40080EC70
+:100880000995E091A300F091A400812F0995E091D2
+:10089000A300F091A400802F0995E091A300F091AE
+:1008A000A4008F2D09958EE1B7D080E01F910F91A4
+:1008B000FF900895CF92DF92EF92FF920F931F93D4
+:1008C0006B017C01142FE091A300F091A4008CE453
+:1008D0000995D701C60149E0B695A79597958795E3
+:1008E0004A95D1F7E091A300F091A4000995D701B2
+:1008F000C601B695A79597958795E091A300F091CD
+:10090000A4000995E091A300F091A40080E009956E
+:100910001F3FF1F012B70EE1C701B60155DF8F3F5F
+:1009200079F482B7811B8D33B8F312B70150A1F768
+:1009300081E01F910F91FF90EF90DF90CF9008958D
+:1009400080E01F910F91FF90EF90DF90CF9008957E
+:100950008FE062D080E01F910F91FF90EF90DF90C9
+:10096000CF900895CF92DF92EF92FF920F931F9353
+:100970006B017C01042F122F862F8170880F880F46
+:10098000880FE091A300F091A40080640995D7013D
+:10099000C60169E0B695A795979587956A95D1F7B1
+:1009A000E091A300F091A4000995D701C601B69586
+:1009B000A79597958795E091A300F091A4000995DC
+:1009C000E091A300F091A400802F09951123C1F0BC
+:1009D0000F37F1F012B70EE1C701B601F5DE8F3720
+:1009E00079F482B7811B8D33B8F312B70150A1F7A8
+:1009F00081E01F910F91FF90EF90DF90CF900895CD
+:100A000080E01F910F91FF90EF90DF90CF900895BD
+:100A10008FE002D080E0F5CF382F882349F020E026
+:100A200092B782B7891B8C33E0F32F5F2317C0F393
+:100A3000089512BA18BA8BEF81BB8FEF87BB17BA34
+:100A400093E094BB8EEF85BB93BF32DB789437DBAA
+:100A500036DBFDCFFF920F931F93CF93DF93F82EDA
+:100A6000292F062F40916300413051F0443041F06E
+:100A70001FEF812FDF91CF911F910F91FF9008956C
+:100A8000002309F487C08F2D922F9C01E90110E00B
+:100A900053C08091740090917500892B09F058C063
+:100AA000609170007091710080917200909173005C
+:100AB00021E0488157DF80916400909165000197A3
+:100AC0009093650080936400892BD9F410926300A1
+:100AD0008091760081FF3AC08091770090E020916C
+:100AE0007400309175008217930781F16091700056
+:100AF0007091710080917200909173004881DADEEC
+:100B000011E08091700090917100A0917200B091FD
+:100B100073000196A11DB11D809370009093710028
+:100B2000A0937200B093730021969E012F19201795
+:100B300008F09FCF40916300413009F4AACF68814B
+:100B4000809170009091710091DEB5CF11E0D9CF06
+:100B500060917000709171008091720090917300AB
+:100B600020E04881FFDE80917700815080937700FC
+:100B7000882309F0A0CF609170007091710080917E
+:100B8000720090917300488195DE8091740080938B
+:100B9000770091CF10E06DCF0F931F93CF93DF932A
+:100BA000082F162F40916300842F8250823038F036
+:100BB0001FEF812FDF91CF911F910F910895662331
+:100BC00099F1802F9C01E90120C0809170009091E3
+:100BD00071002EDE88838091700090917100A09149
+:100BE0007200B09173000196A11DB11D8093700039
+:100BF00090937100A0937200B093730021969E01B0
+:100C0000201B211778F4409163004230F1F6609187
+:100C10007000709171008091720090917300D4DD2A
+:100C20008883D9CF183028F610926300812FDF9186
+:100C3000CF911F910F9108950F931F93CF93DF933F
+:100C40008C01EC0189818130F1F0823009F4B0C06F
+:100C5000833031F1843009F482C0873009F456C002
+:100C6000853009F41EC1863009F4D7C0883009F4F4
+:100C7000A5C0893009F41CC18A3009F42DC180E077
+:100C8000C8E6D0E037C09A9B3EC08091660094DCF5
+:100C900010926700A998FFDC80E0C8E6D0E02AC087
+:100CA000E091A300F091A400E8018A810995C8E6CB
+:100CB000D0E0809368002091A3003091A400F80157
+:100CC0008381F9010995809369002091A3003091F7
+:100CD000A400F8018481F901099580936A002091AC
+:100CE000A3003091A400F8018581F9010995809352
+:100CF0006B0084E0D0938700C0938600DF91CF9192
+:100D00001F910F91089585E057DCC2CF8091670055
+:100D1000882399F4E8019B8180E02A8130E0822BCE
+:100D2000932BAA2797FDA095BA2F809370009093DC
+:100D30007100A0937200B0937300F801978180E076
+:100D4000268130E0822B932B909365008093640082
+:100D500083E0809363008FEFC8E6D0E0CBCF809133
+:100D60006700882399F4E8019B8180E02A8130E0C4
+:100D7000822B932BAA2797FDA095BA2F8093700002
+:100D800090937100A0937200B0937300F801978163
+:100D900080E0268130E0822B932B90936500809336
+:100DA000640082E0809363008FEFC8E6D0E0A2CFBA
+:100DB00094DCA99A80E0C8E6D0E09CCF80916700DF
+:100DC000882399F4F801938180E0228130E0822B1E
+:100DD000932BAA2797FDA095BA2F8093700090932C
+:100DE0007100A0937200B09373001092750010927E
+:100DF000740010927600E8019F8180E02E8130E03F
+:100E0000822B932B909365008093640084E0809301
+:100E100063008FEFC8E6D0E06DCF80916700882334
+:100E200099F4E8019B8180E02A8130E0822B932BAA
+:100E3000AA2797FDA095BA2F809370009093710018
+:100E4000A0937200B0937300F80184819581292FDB
+:100E50002F7020937600492F50E0407F50704295CC
+:100E60005295507F5427407F5427480F511D50936F
+:100E700075004093740020FF02C040937700E801A2
+:100E80009F8180E02E8130E0822B932B9093650030
+:100E90008093640081E0809363008FEFC8E6D0E028
+:100EA00029CF49DCC8E6D0E08093680081E022CFFA
+:100EB00081E080936700F80182819381A481B581EC
+:100EC0008093700090937100A0937200B0937300B0
+:100ED00080E0C8E6D0E00ECFE8018A81809366000A
+:100EE000C8E6D0E01092680081E004CFF894FFCF0C
+:020EF0005AFFA7
+:00000001FF
diff --git a/bin/win-driver/Readme.txt b/bin/win-driver/Readme.txt
new file mode 100644
index 000000000..37170d791
--- /dev/null
+++ b/bin/win-driver/Readme.txt
@@ -0,0 +1,2 @@
+With WinAVR version 20080512 or greater, please use libusb_0.1.12.1.
+Use libusb_0.1.10.1 with older WinAVR versions.
diff --git a/bin/win-driver/libusb0.dll b/bin/win-driver/libusb_0.1.10.1/libusb0.dll
similarity index 100%
rename from bin/win-driver/libusb0.dll
rename to bin/win-driver/libusb_0.1.10.1/libusb0.dll
diff --git a/bin/win-driver/libusb0.sys b/bin/win-driver/libusb_0.1.10.1/libusb0.sys
similarity index 100%
rename from bin/win-driver/libusb0.sys
rename to bin/win-driver/libusb_0.1.10.1/libusb0.sys
diff --git a/bin/win-driver/usbasp.inf b/bin/win-driver/libusb_0.1.10.1/usbasp.inf
similarity index 100%
rename from bin/win-driver/usbasp.inf
rename to bin/win-driver/libusb_0.1.10.1/usbasp.inf
diff --git a/bin/win-driver/libusb_0.1.12.1/libusb0.dll b/bin/win-driver/libusb_0.1.12.1/libusb0.dll
new file mode 100755
index 0000000000000000000000000000000000000000..9387bedad1d4ec91bfb903486d1ed37abccab63e
GIT binary patch
literal 43520
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
J;QvoP{{uEZBLe^c

literal 0
HcmV?d00001

diff --git a/bin/win-driver/libusb_0.1.12.1/libusb0.sys b/bin/win-driver/libusb_0.1.12.1/libusb0.sys
new file mode 100755
index 0000000000000000000000000000000000000000..0a02d3ee3319b77949c890c206b02c824007bb49
GIT binary patch
literal 28672
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

literal 0
HcmV?d00001

diff --git a/bin/win-driver/libusb_0.1.12.1/libusb0_x64.dll b/bin/win-driver/libusb_0.1.12.1/libusb0_x64.dll
new file mode 100755
index 0000000000000000000000000000000000000000..c89a59fe38b5cd1a9470b75deccb26b552ac1c7e
GIT binary patch
literal 43008
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

literal 0
HcmV?d00001

diff --git a/bin/win-driver/libusb_0.1.12.1/libusb0_x64.sys b/bin/win-driver/libusb_0.1.12.1/libusb0_x64.sys
new file mode 100755
index 0000000000000000000000000000000000000000..07cf0858ae7562dbd8304933ac7190fb6bf7535f
GIT binary patch
literal 16896
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
L7W$K?KkfNXdJ6SB

literal 0
HcmV?d00001

diff --git a/bin/win-driver/libusb_0.1.12.1/testlibusb-win.exe b/bin/win-driver/libusb_0.1.12.1/testlibusb-win.exe
new file mode 100755
index 0000000000000000000000000000000000000000..a0c3e31775db4ad6b4e364c94bb06482d886c86c
GIT binary patch
literal 13824
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

literal 0
HcmV?d00001

diff --git a/bin/win-driver/libusb_0.1.12.1/testlibusb.exe b/bin/win-driver/libusb_0.1.12.1/testlibusb.exe
new file mode 100755
index 0000000000000000000000000000000000000000..e6a0b62907d0c0fea7b017521e7eb7d124d04f99
GIT binary patch
literal 8192
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

literal 0
HcmV?d00001

diff --git a/bin/win-driver/libusb_0.1.12.1/usbasp.cat b/bin/win-driver/libusb_0.1.12.1/usbasp.cat
new file mode 100644
index 000000000..d40149030
--- /dev/null
+++ b/bin/win-driver/libusb_0.1.12.1/usbasp.cat
@@ -0,0 +1,3 @@
+This file will contain the digital signature of the files to be installed
+on the system.
+This file will be provided by Microsoft upon certification of your drivers.
diff --git a/bin/win-driver/libusb_0.1.12.1/usbasp.inf b/bin/win-driver/libusb_0.1.12.1/usbasp.inf
new file mode 100644
index 000000000..54d1973bd
--- /dev/null
+++ b/bin/win-driver/libusb_0.1.12.1/usbasp.inf
@@ -0,0 +1,136 @@
+[Version]
+Signature = "$Chicago$"
+provider  = %manufacturer%
+DriverVer = 03/20/2007,0.1.12.1
+CatalogFile = usbasp.cat
+CatalogFile.NT = usbasp.cat
+CatalogFile.NTAMD64 = usbasp_x64.cat
+
+Class = LibUsbDevices
+ClassGUID = {EB781AAF-9C70-4523-A5DF-642A87ECA567}
+
+[ClassInstall]
+AddReg=libusb_class_install_add_reg
+
+[ClassInstall32]
+AddReg=libusb_class_install_add_reg
+
+[libusb_class_install_add_reg]
+HKR,,,,"LibUSB-Win32 Devices"
+HKR,,Icon,,"-20"
+
+[Manufacturer]
+%manufacturer%=Devices,NT,NTAMD64
+
+;--------------------------------------------------------------------------
+; Files
+;--------------------------------------------------------------------------
+
+[SourceDisksNames]
+1 = "Libusb-Win32 Driver Installation Disk",,
+
+[SourceDisksFiles]
+libusb0.sys = 1,,
+libusb0.dll = 1,,
+libusb0_x64.sys = 1,,
+libusb0_x64.dll = 1,,
+
+[DestinationDirs]
+libusb_files_sys = 10,system32\drivers
+libusb_files_sys_x64 = 10,system32\drivers
+libusb_files_dll = 10,system32
+libusb_files_dll_wow64 = 10,syswow64
+libusb_files_dll_x64 = 10,system32
+
+[libusb_files_sys]
+libusb0.sys
+
+[libusb_files_sys_x64]
+libusb0.sys,libusb0_x64.sys
+
+[libusb_files_dll]
+libusb0.dll
+
+[libusb_files_dll_wow64]
+libusb0.dll
+
+[libusb_files_dll_x64]
+libusb0.dll,libusb0_x64.dll
+
+;--------------------------------------------------------------------------
+; Device driver
+;--------------------------------------------------------------------------
+
+[LIBUSB_DEV]
+CopyFiles = libusb_files_sys, libusb_files_dll
+AddReg    = libusb_add_reg
+
+[LIBUSB_DEV.NT]
+CopyFiles = libusb_files_sys, libusb_files_dll
+
+[LIBUSB_DEV.NTAMD64]
+CopyFiles = libusb_files_sys_x64, libusb_files_dll_wow64, libusb_files_dll_x64
+
+[LIBUSB_DEV.HW]
+DelReg = libusb_del_reg_hw
+AddReg = libusb_add_reg_hw
+
+[LIBUSB_DEV.NT.HW]
+DelReg = libusb_del_reg_hw
+AddReg = libusb_add_reg_hw
+
+[LIBUSB_DEV.NTAMD64.HW]
+DelReg = libusb_del_reg_hw
+AddReg = libusb_add_reg_hw
+
+[LIBUSB_DEV.NT.Services]
+AddService = libusb0, 0x00000002, libusb_add_service
+
+[LIBUSB_DEV.NTAMD64.Services]
+AddService = libusb0, 0x00000002, libusb_add_service
+
+[libusb_add_reg]
+HKR,,DevLoader,,*ntkern
+HKR,,NTMPDriver,,libusb0.sys
+
+; Older versions of this .inf file installed filter drivers. They are not
+; needed any more and must be removed
+[libusb_del_reg_hw]
+HKR,,LowerFilters
+HKR,,UpperFilters
+
+; Device properties
+[libusb_add_reg_hw]
+HKR,,SurpriseRemovalOK, 0x00010001, 1
+
+;--------------------------------------------------------------------------
+; Services
+;--------------------------------------------------------------------------
+
+[libusb_add_service]
+DisplayName    = "LibUsb-Win32 - Kernel Driver 03/20/2007, 0.1.12.1"
+ServiceType    = 1
+StartType      = 3
+ErrorControl   = 0
+ServiceBinary  = %12%\libusb0.sys
+
+;--------------------------------------------------------------------------
+; Devices
+;--------------------------------------------------------------------------
+
+[Devices]
+"USBasp"=LIBUSB_DEV, USB\VID_16c0&PID_05dc
+
+[Devices.NT]
+"USBasp"=LIBUSB_DEV, USB\VID_16c0&PID_05dc
+
+[Devices.NTAMD64]
+"USBasp"=LIBUSB_DEV, USB\VID_16c0&PID_05dc
+
+
+;--------------------------------------------------------------------------
+; Strings
+;--------------------------------------------------------------------------
+
+[Strings]
+manufacturer = "www.fischl.de"
diff --git a/bin/win-driver/libusb_0.1.12.1/usbasp_x64.cat b/bin/win-driver/libusb_0.1.12.1/usbasp_x64.cat
new file mode 100644
index 000000000..d40149030
--- /dev/null
+++ b/bin/win-driver/libusb_0.1.12.1/usbasp_x64.cat
@@ -0,0 +1,3 @@
+This file will contain the digital signature of the files to be installed
+on the system.
+This file will be provided by Microsoft upon certification of your drivers.
diff --git a/firmware/clock.c b/firmware/clock.c
index 52138e534..3b90a68ae 100644
--- a/firmware/clock.c
+++ b/firmware/clock.c
@@ -1,12 +1,12 @@
 /*
-  clock.c - part of USBasp
-
-  Autor..........: Thomas Fischl <tfischl@gmx.de>
-  Description....: Provides functions for timing/waiting
-  Licence........: GNU GPL v2 (see Readme.txt)
-  Creation Date..: 2005-02-23
-  Last change....: 2005-04-20
-*/
+ * clock.c - part of USBasp
+ *
+ * Autor..........: Thomas Fischl <tfischl@gmx.de>
+ * Description....: Provides functions for timing/waiting
+ * Licence........: GNU GPL v2 (see Readme.txt)
+ * Creation Date..: 2005-02-23
+ * Last change....: 2005-04-20
+ */
 
 #include <inttypes.h>
 #include <avr/io.h>
@@ -15,9 +15,10 @@
 /* wait time * 320 us */
 void clockWait(uint8_t time) {
 
-  uint8_t i;
-  for (i = 0; i < time; i++) {
-    uint8_t starttime = TIMERVALUE;
-    while ((uint8_t) (TIMERVALUE - starttime) < CLOCK_T_320us) {}
-  }
+	uint8_t i;
+	for (i = 0; i < time; i++) {
+		uint8_t starttime = TIMERVALUE;
+		while ((uint8_t) (TIMERVALUE - starttime) < CLOCK_T_320us) {
+		}
+	}
 }
diff --git a/firmware/clock.h b/firmware/clock.h
index 405fe2fe7..0183297a5 100644
--- a/firmware/clock.h
+++ b/firmware/clock.h
@@ -1,12 +1,12 @@
 /*
-  clock.h - part of USBasp
-
-  Autor..........: Thomas Fischl <tfischl@gmx.de>
-  Description....: Provides functions for timing/waiting
-  Licence........: GNU GPL v2 (see Readme.txt)
-  Creation Date..: 2005-02-23
-  Last change....: 2006-11-16
-*/
+ * clock.h - part of USBasp
+ *
+ * Autor..........: Thomas Fischl <tfischl@gmx.de>
+ * Description....: Provides functions for timing/waiting
+ * Licence........: GNU GPL v2 (see Readme.txt)
+ * Creation Date..: 2005-02-23
+ * Last change....: 2006-11-16
+ */
 
 #ifndef __clock_h_included__
 #define	__clock_h_included__
diff --git a/firmware/isp.c b/firmware/isp.c
index 5153c8eb4..6305aacab 100644
--- a/firmware/isp.c
+++ b/firmware/isp.c
@@ -1,274 +1,304 @@
 /*
-  isp.c - part of USBasp
-
-  Autor..........: Thomas Fischl <tfischl@gmx.de>
-  Description....: Provides functions for communication/programming
-                   over ISP interface
-  Licence........: GNU GPL v2 (see Readme.txt)
-  Creation Date..: 2005-02-23
-  Last change....: 2007-07-23
-*/
+ * isp.c - part of USBasp
+ *
+ * Autor..........: Thomas Fischl <tfischl@gmx.de>
+ * Description....: Provides functions for communication/programming
+ *                  over ISP interface
+ * Licence........: GNU GPL v2 (see Readme.txt)
+ * Creation Date..: 2005-02-23
+ * Last change....: 2009-02-28
+ */
 
 #include <avr/io.h>
 #include "isp.h"
 #include "clock.h"
+#include "usbasp.h"
 
 #define spiHWdisable() SPCR = 0
 
-void spiHWenable() {
+uchar sck_sw_delay;
+uchar sck_spcr;
+uchar sck_spsr;
 
-  /* enable SPI, master, 375kHz SCK */
-  SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1);
-  SPSR = (1 << SPI2X);
+void spiHWenable() {
+	SPCR = sck_spcr;
+	SPSR = sck_spsr;
 }
 
 void ispSetSCKOption(uchar option) {
 
-  if (option == 0) {
-
-    /* use software spi */
-    ispTransmit = ispTransmit_sw;
-    //    spiHWdisable();
-
-  } else {
-
-    /* use hardware spi */
-    ispTransmit = ispTransmit_hw;
-
-  }
+	if (option == USBASP_ISP_SCK_AUTO)
+		option = USBASP_ISP_SCK_375;
+
+	if (option >= USBASP_ISP_SCK_93_75) {
+		ispTransmit = ispTransmit_hw;
+		sck_spsr = 0;
+
+		switch (option) {
+
+		case USBASP_ISP_SCK_1500:
+			/* enable SPI, master, 1.5MHz, XTAL/8 */
+			sck_spcr = (1 << SPE) | (1 << MSTR) | (1 << SPR0);
+			sck_spsr = (1 << SPI2X);
+		case USBASP_ISP_SCK_750:
+			/* enable SPI, master, 750kHz, XTAL/16 */
+			sck_spcr = (1 << SPE) | (1 << MSTR) | (1 << SPR0);
+			break;
+		case USBASP_ISP_SCK_375:
+		default:
+			/* enable SPI, master, 375kHz, XTAL/32 (default) */
+			sck_spcr = (1 << SPE) | (1 << MSTR) | (1 << SPR1);
+			sck_spsr = (1 << SPI2X);
+			break;
+		case USBASP_ISP_SCK_187_5:
+			/* enable SPI, master, 187.5kHz XTAL/64 */
+			sck_spcr = (1 << SPE) | (1 << MSTR) | (1 << SPR1);
+			break;
+		case USBASP_ISP_SCK_93_75:
+			/* enable SPI, master, 93.75kHz XTAL/128 */
+			sck_spcr = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0);
+			break;
+		}
+
+	} else {
+		ispTransmit = ispTransmit_sw;
+		switch (option) {
+
+		case USBASP_ISP_SCK_32:
+			sck_sw_delay = 3;
+
+			break;
+		case USBASP_ISP_SCK_16:
+			sck_sw_delay = 6;
+
+			break;
+		case USBASP_ISP_SCK_8:
+			sck_sw_delay = 12;
+
+			break;
+		case USBASP_ISP_SCK_4:
+			sck_sw_delay = 24;
+
+			break;
+		case USBASP_ISP_SCK_2:
+			sck_sw_delay = 48;
+
+			break;
+		case USBASP_ISP_SCK_1:
+			sck_sw_delay = 96;
+
+			break;
+		case USBASP_ISP_SCK_0_5:
+			sck_sw_delay = 192;
+
+			break;
+		}
+	}
 }
 
 void ispDelay() {
 
-  uint8_t starttime = TIMERVALUE;
-  while ((uint8_t) (TIMERVALUE - starttime) < 12) { }
+	uint8_t starttime = TIMERVALUE;
+	while ((uint8_t) (TIMERVALUE - starttime) < sck_sw_delay) {
+	}
 }
 
 void ispConnect() {
 
-  /* all ISP pins are inputs before */
-  /* now set output pins */
-  ISP_DDR |= (1 << ISP_RST) | (1 << ISP_SCK) | (1 << ISP_MOSI);
+	/* all ISP pins are inputs before */
+	/* now set output pins */
+	ISP_DDR |= (1 << ISP_RST) | (1 << ISP_SCK) | (1 << ISP_MOSI);
 
-  /* reset device */
-  ISP_OUT &= ~(1 << ISP_RST);   /* RST low */
-  ISP_OUT &= ~(1 << ISP_SCK);   /* SCK low */
+	/* reset device */
+	ISP_OUT &= ~(1 << ISP_RST); /* RST low */
+	ISP_OUT &= ~(1 << ISP_SCK); /* SCK low */
 
-  /* positive reset pulse > 2 SCK (target) */
-  ispDelay();
-  ISP_OUT |= (1 << ISP_RST);    /* RST high */
-  ispDelay();
-  ISP_OUT &= ~(1 << ISP_RST);   /* RST low */
+	/* positive reset pulse > 2 SCK (target) */
+	ispDelay();
+	ISP_OUT |= (1 << ISP_RST); /* RST high */
+	ispDelay();
+	ISP_OUT &= ~(1 << ISP_RST); /* RST low */
 
-  if (ispTransmit == ispTransmit_hw) {
-    spiHWenable();
-  }
+	if (ispTransmit == ispTransmit_hw) {
+		spiHWenable();
+	}
 }
 
 void ispDisconnect() {
 
-  /* set all ISP pins inputs */
-  ISP_DDR &= ~((1 << ISP_RST) | (1 << ISP_SCK) | (1 << ISP_MOSI));
-  /* switch pullups off */
-  ISP_OUT &= ~((1 << ISP_RST) | (1 << ISP_SCK) | (1 << ISP_MOSI));
+	/* set all ISP pins inputs */
+	ISP_DDR &= ~((1 << ISP_RST) | (1 << ISP_SCK) | (1 << ISP_MOSI));
+	/* switch pullups off */
+	ISP_OUT &= ~((1 << ISP_RST) | (1 << ISP_SCK) | (1 << ISP_MOSI));
 
-  /* disable hardware SPI */
-  spiHWdisable();
+	/* disable hardware SPI */
+	spiHWdisable();
 }
 
 uchar ispTransmit_sw(uchar send_byte) {
 
-  uchar rec_byte = 0;
-  uchar i;
-  for (i = 0; i < 8; i++) {
-
-    /* set MSB to MOSI-pin */
-    if ((send_byte & 0x80) != 0) {
-      ISP_OUT |= (1 << ISP_MOSI);  /* MOSI high */
-    } else {
-      ISP_OUT &= ~(1 << ISP_MOSI); /* MOSI low */
-    }
-    /* shift to next bit */
-    send_byte  = send_byte << 1;
-
-    /* receive data */
-    rec_byte = rec_byte << 1;
-    if ((ISP_IN & (1 << ISP_MISO)) != 0) {
-      rec_byte++;
-    }
-
-    /* pulse SCK */
-    ISP_OUT |= (1 << ISP_SCK);     /* SCK high */
-    ispDelay();
-    ISP_OUT &= ~(1 << ISP_SCK);    /* SCK low */
-    ispDelay();
-  }
-
-  return rec_byte;
+	uchar rec_byte = 0;
+	uchar i;
+	for (i = 0; i < 8; i++) {
+
+		/* set MSB to MOSI-pin */
+		if ((send_byte & 0x80) != 0) {
+			ISP_OUT |= (1 << ISP_MOSI); /* MOSI high */
+		} else {
+			ISP_OUT &= ~(1 << ISP_MOSI); /* MOSI low */
+		}
+		/* shift to next bit */
+		send_byte = send_byte << 1;
+
+		/* receive data */
+		rec_byte = rec_byte << 1;
+		if ((ISP_IN & (1 << ISP_MISO)) != 0) {
+			rec_byte++;
+		}
+
+		/* pulse SCK */
+		ISP_OUT |= (1 << ISP_SCK); /* SCK high */
+		ispDelay();
+		ISP_OUT &= ~(1 << ISP_SCK); /* SCK low */
+		ispDelay();
+	}
+
+	return rec_byte;
 }
 
 uchar ispTransmit_hw(uchar send_byte) {
-  SPDR = send_byte;
+	SPDR = send_byte;
 
-  while (!(SPSR & (1 << SPIF)));
-  return SPDR;
+	while (!(SPSR & (1 << SPIF)))
+		;
+	return SPDR;
 }
 
 uchar ispEnterProgrammingMode() {
-  uchar check;
-  uchar count = 32;
+	uchar check;
+	uchar count = 32;
 
-  while (count--) {
-    ispTransmit(0xAC);
-    ispTransmit(0x53);
-    check = ispTransmit(0);
-    ispTransmit(0);
+	while (count--) {
+		ispTransmit(0xAC);
+		ispTransmit(0x53);
+		check = ispTransmit(0);
+		ispTransmit(0);
 
-    if (check == 0x53) {
-      return 0;
-    }
+		if (check == 0x53) {
+			return 0;
+		}
 
-    spiHWdisable();
+		spiHWdisable();
 
-    /* pulse SCK */
-    ISP_OUT |= (1 << ISP_SCK);     /* SCK high */
-    ispDelay();
-    ISP_OUT &= ~(1 << ISP_SCK);    /* SCK low */
-    ispDelay();
+		/* pulse SCK */
+		ISP_OUT |= (1 << ISP_SCK); /* SCK high */
+		ispDelay();
+		ISP_OUT &= ~(1 << ISP_SCK); /* SCK low */
+		ispDelay();
 
-    if (ispTransmit == ispTransmit_hw) {
-      spiHWenable();
-    }
+		if (ispTransmit == ispTransmit_hw) {
+			spiHWenable();
+		}
 
-  }
+	}
 
-  return 1;  /* error: device dosn't answer */
+	return 1; /* error: device dosn't answer */
 }
 
 uchar ispReadFlash(unsigned long address) {
-  ispTransmit(0x20 | ((address & 1) << 3));
-  ispTransmit(address >> 9);
-  ispTransmit(address >> 1);
-  return ispTransmit(0);
+	ispTransmit(0x20 | ((address & 1) << 3));
+	ispTransmit(address >> 9);
+	ispTransmit(address >> 1);
+	return ispTransmit(0);
 }
 
-
 uchar ispWriteFlash(unsigned long address, uchar data, uchar pollmode) {
 
-  /* 0xFF is value after chip erase, so skip programming
-  if (data == 0xFF) {
-    return 0;
-  }
-  */
-
-  ispTransmit(0x40 | ((address & 1) << 3));
-  ispTransmit(address >> 9);
-  ispTransmit(address >> 1);
-  ispTransmit(data);
-
-  if (pollmode == 0)
-    return 0;
-
-  if (data == 0x7F) {
-    clockWait(15); /* wait 4,8 ms */
-    return 0;
-  } else {
-
-    /* polling flash */
-    uchar retries = 30;
-    uint8_t starttime = TIMERVALUE;
-    while (retries != 0) {
-      if (ispReadFlash(address) != 0x7F) {
-	return 0;
-      };
-
-      if ((uint8_t) (TIMERVALUE - starttime) > CLOCK_T_320us) {
-	starttime = TIMERVALUE;
-	retries --;
-      }
-
-    }
-    return 1; /* error */
-  }
+	/* 0xFF is value after chip erase, so skip programming
+	 if (data == 0xFF) {
+	 return 0;
+	 }
+	 */
+
+	ispTransmit(0x40 | ((address & 1) << 3));
+	ispTransmit(address >> 9);
+	ispTransmit(address >> 1);
+	ispTransmit(data);
+
+	if (pollmode == 0)
+		return 0;
+
+	if (data == 0x7F) {
+		clockWait(15); /* wait 4,8 ms */
+		return 0;
+	} else {
+
+		/* polling flash */
+		uchar retries = 30;
+		uint8_t starttime = TIMERVALUE;
+		while (retries != 0) {
+			if (ispReadFlash(address) != 0x7F) {
+				return 0;
+			};
+
+			if ((uint8_t) (TIMERVALUE - starttime) > CLOCK_T_320us) {
+				starttime = TIMERVALUE;
+				retries--;
+			}
+
+		}
+		return 1; /* error */
+	}
 
 }
 
-
 uchar ispFlushPage(unsigned long address, uchar pollvalue) {
-  ispTransmit(0x4C);
-  ispTransmit(address >> 9);
-  ispTransmit(address >> 1);
-  ispTransmit(0);
-
+	ispTransmit(0x4C);
+	ispTransmit(address >> 9);
+	ispTransmit(address >> 1);
+	ispTransmit(0);
 
-  if (pollvalue == 0xFF) {
-    clockWait(15);
-    return 0;
-  } else {
+	if (pollvalue == 0xFF) {
+		clockWait(15);
+		return 0;
+	} else {
 
-    /* polling flash */
-    uchar retries = 30;
-    uint8_t starttime = TIMERVALUE;
+		/* polling flash */
+		uchar retries = 30;
+		uint8_t starttime = TIMERVALUE;
 
-    while (retries != 0) {
-      if (ispReadFlash(address) != 0xFF) {
-	return 0;
-      };
+		while (retries != 0) {
+			if (ispReadFlash(address) != 0xFF) {
+				return 0;
+			};
 
-      if ((uint8_t) (TIMERVALUE - starttime) > CLOCK_T_320us) {
-	starttime = TIMERVALUE;
-	retries --;
-      }
+			if ((uint8_t) (TIMERVALUE - starttime) > CLOCK_T_320us) {
+				starttime = TIMERVALUE;
+				retries--;
+			}
 
-    }
+		}
 
-    return 1; /* error */
-  }
+		return 1; /* error */
+	}
 
 }
 
-
 uchar ispReadEEPROM(unsigned int address) {
-  ispTransmit(0xA0);
-  ispTransmit(address >> 8);
-  ispTransmit(address);
-  return ispTransmit(0);
+	ispTransmit(0xA0);
+	ispTransmit(address >> 8);
+	ispTransmit(address);
+	return ispTransmit(0);
 }
 
-
 uchar ispWriteEEPROM(unsigned int address, uchar data) {
 
-  ispTransmit(0xC0);
-  ispTransmit(address >> 8);
-  ispTransmit(address);
-  ispTransmit(data);
+	ispTransmit(0xC0);
+	ispTransmit(address >> 8);
+	ispTransmit(address);
+	ispTransmit(data);
 
-  clockWait(30); // wait 9,6 ms
+	clockWait(30); // wait 9,6 ms
 
-  return 0;
-  /*
-  if (data == 0xFF) {
-    clockWait(30); // wait 9,6 ms
-    return 0;
-  } else {
-
-    // polling eeprom
-    uchar retries = 30; // about 9,6 ms
-    uint8_t starttime = TIMERVALUE;
-
-    while (retries != 0) {
-      if (ispReadEEPROM(address) != 0xFF) {
 	return 0;
-      };
-
-      if ((uint8_t) (TIMERVALUE - starttime) > CLOCK_T_320us) {
-	starttime = TIMERVALUE;
-	retries --;
-      }
-
-    }
-    return 1; // error
-  }
-  */
-
 }
diff --git a/firmware/isp.h b/firmware/isp.h
index e3862e592..0acbb3d65 100644
--- a/firmware/isp.h
+++ b/firmware/isp.h
@@ -1,13 +1,13 @@
 /*
-  isp.h - part of USBasp
-
-  Autor..........: Thomas Fischl <tfischl@gmx.de>
-  Description....: Provides functions for communication/programming
-                   over ISP interface
-  Licence........: GNU GPL v2 (see Readme.txt)
-  Creation Date..: 2005-02-23
-  Last change....: 2007-07-23
-*/
+ * isp.h - part of USBasp
+ *
+ * Autor..........: Thomas Fischl <tfischl@gmx.de>
+ * Description....: Provides functions for communication/programming
+ *                  over ISP interface
+ * Licence........: GNU GPL v2 (see Readme.txt)
+ * Creation Date..: 2005-02-23
+ * Last change....: 2009-02-28
+ */
 
 #ifndef __isp_h_included__
 #define	__isp_h_included__
@@ -24,10 +24,6 @@
 #define ISP_MISO  PB4
 #define ISP_SCK   PB5
 
-#define ISP_DELAY 1
-#define ISP_SCK_SLOW 0
-#define ISP_SCK_FAST 1
-
 /* Prepare connection to target device */
 void ispConnect();
 
diff --git a/firmware/main.c b/firmware/main.c
index af740fcc3..ca65df24f 100644
--- a/firmware/main.c
+++ b/firmware/main.c
@@ -1,53 +1,32 @@
 /*
-  USBasp - USB in-circuit programmer for Atmel AVR controllers
-
-  Thomas Fischl <tfischl@gmx.de>
-
-  License........: GNU GPL v2 (see Readme.txt)
-  Target.........: ATMega8 at 12 MHz
-  Creation Date..: 2005-02-20
-  Last change....: 2007-07-23
-
-  PC2 SCK speed option. GND  -> slow (8khz SCK),
-                        open -> fast (375kHz SCK)
-*/
+ * USBasp - USB in-circuit programmer for Atmel AVR controllers
+ *
+ * Thomas Fischl <tfischl@gmx.de>
+ *
+ * License........: GNU GPL v2 (see Readme.txt)
+ * Target.........: ATMega8 at 12 MHz
+ * Creation Date..: 2005-02-20
+ * Last change....: 2009-02-28
+ *
+ * PC2 SCK speed option.
+ * GND  -> slow (8khz SCK),
+ * open -> software set speed (default is 375kHz SCK)
+ */
 
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <avr/pgmspace.h>
 #include <avr/wdt.h>
 
+#include "usbasp.h"
 #include "usbdrv.h"
 #include "isp.h"
 #include "clock.h"
 
-#define USBASP_FUNC_CONNECT     1
-#define USBASP_FUNC_DISCONNECT  2
-#define USBASP_FUNC_TRANSMIT    3
-#define USBASP_FUNC_READFLASH   4
-#define USBASP_FUNC_ENABLEPROG  5
-#define USBASP_FUNC_WRITEFLASH  6
-#define USBASP_FUNC_READEEPROM  7
-#define USBASP_FUNC_WRITEEEPROM 8
-#define USBASP_FUNC_SETLONGADDRESS 9
-
-#define PROG_STATE_IDLE         0
-#define PROG_STATE_WRITEFLASH   1
-#define PROG_STATE_READFLASH    2
-#define PROG_STATE_READEEPROM   3
-#define PROG_STATE_WRITEEEPROM  4
-
-#define PROG_BLOCKFLAG_FIRST    1
-#define PROG_BLOCKFLAG_LAST     2
-
-#define ledRedOn()    PORTC &= ~(1 << PC1)
-#define ledRedOff()   PORTC |= (1 << PC1)
-#define ledGreenOn()  PORTC &= ~(1 << PC0)
-#define ledGreenOff() PORTC |= (1 << PC0)
-
 static uchar replyBuffer[8];
 
 static uchar prog_state = PROG_STATE_IDLE;
+static uchar prog_sck = USBASP_ISP_SCK_AUTO;
 
 static uchar prog_address_newmode = 0;
 static unsigned long prog_address;
@@ -56,211 +35,220 @@ static unsigned int prog_pagesize;
 static uchar prog_blockflags;
 static uchar prog_pagecounter;
 
-
 uchar usbFunctionSetup(uchar data[8]) {
 
-  uchar len = 0;
-
-  if(data[1] == USBASP_FUNC_CONNECT){
+	uchar len = 0;
 
-    /* set SCK speed */
-    if ((PINC & (1 << PC2)) == 0) {
-      ispSetSCKOption(ISP_SCK_SLOW);
-    } else {
-      ispSetSCKOption(ISP_SCK_FAST);
-    }
+	if (data[1] == USBASP_FUNC_CONNECT) {
 
-    /* set compatibility mode of address delivering */
-    prog_address_newmode = 0;
+		/* set SCK speed */
+		if ((PINC & (1 << PC2)) == 0) {
+			ispSetSCKOption(USBASP_ISP_SCK_8);
+		} else {
+			ispSetSCKOption(prog_sck);
+		}
 
-    ledRedOn();
-    ispConnect();
+		/* set compatibility mode of address delivering */
+		prog_address_newmode = 0;
 
-  } else if (data[1] == USBASP_FUNC_DISCONNECT) {
-    ispDisconnect();
-    ledRedOff();
+		ledRedOn();
+		ispConnect();
 
-  } else if (data[1] == USBASP_FUNC_TRANSMIT) {
-    replyBuffer[0] = ispTransmit(data[2]);
-    replyBuffer[1] = ispTransmit(data[3]);
-    replyBuffer[2] = ispTransmit(data[4]);
-    replyBuffer[3] = ispTransmit(data[5]);
-    len = 4;
+	} else if (data[1] == USBASP_FUNC_DISCONNECT) {
+		ispDisconnect();
+		ledRedOff();
 
-  } else if (data[1] == USBASP_FUNC_READFLASH) {
+	} else if (data[1] == USBASP_FUNC_TRANSMIT) {
+		replyBuffer[0] = ispTransmit(data[2]);
+		replyBuffer[1] = ispTransmit(data[3]);
+		replyBuffer[2] = ispTransmit(data[4]);
+		replyBuffer[3] = ispTransmit(data[5]);
+		len = 4;
 
-    if (!prog_address_newmode)
-      prog_address = (data[3] << 8) | data[2];
+	} else if (data[1] == USBASP_FUNC_READFLASH) {
 
-    prog_nbytes = (data[7] << 8) | data[6];
-    prog_state = PROG_STATE_READFLASH;
-    len = 0xff; /* multiple in */
+		if (!prog_address_newmode)
+			prog_address = (data[3] << 8) | data[2];
 
-  } else if (data[1] == USBASP_FUNC_READEEPROM) {
+		prog_nbytes = (data[7] << 8) | data[6];
+		prog_state = PROG_STATE_READFLASH;
+		len = 0xff; /* multiple in */
 
-    if (!prog_address_newmode)
-       prog_address = (data[3] << 8) | data[2];
+	} else if (data[1] == USBASP_FUNC_READEEPROM) {
 
-    prog_nbytes = (data[7] << 8) | data[6];
-    prog_state = PROG_STATE_READEEPROM;
-    len = 0xff; /* multiple in */
+		if (!prog_address_newmode)
+			prog_address = (data[3] << 8) | data[2];
 
-  } else if (data[1] == USBASP_FUNC_ENABLEPROG) {
-    replyBuffer[0] = ispEnterProgrammingMode();;
-    len = 1;
+		prog_nbytes = (data[7] << 8) | data[6];
+		prog_state = PROG_STATE_READEEPROM;
+		len = 0xff; /* multiple in */
 
-  } else if (data[1] == USBASP_FUNC_WRITEFLASH) {
+	} else if (data[1] == USBASP_FUNC_ENABLEPROG) {
+		replyBuffer[0] = ispEnterProgrammingMode();
+		len = 1;
 
-    if (!prog_address_newmode)
-      prog_address = (data[3] << 8) | data[2];
+	} else if (data[1] == USBASP_FUNC_WRITEFLASH) {
 
-    prog_pagesize = data[4];
-    prog_blockflags = data[5] & 0x0F;
-    prog_pagesize += (((unsigned int)data[5] & 0xF0)<<4);
-    if (prog_blockflags & PROG_BLOCKFLAG_FIRST) {
-      prog_pagecounter = prog_pagesize;
-    }
-    prog_nbytes = (data[7] << 8) | data[6];
-    prog_state = PROG_STATE_WRITEFLASH;
-    len = 0xff; /* multiple out */
+		if (!prog_address_newmode)
+			prog_address = (data[3] << 8) | data[2];
 
-  } else if (data[1] == USBASP_FUNC_WRITEEEPROM) {
+		prog_pagesize = data[4];
+		prog_blockflags = data[5] & 0x0F;
+		prog_pagesize += (((unsigned int) data[5] & 0xF0) << 4);
+		if (prog_blockflags & PROG_BLOCKFLAG_FIRST) {
+			prog_pagecounter = prog_pagesize;
+		}
+		prog_nbytes = (data[7] << 8) | data[6];
+		prog_state = PROG_STATE_WRITEFLASH;
+		len = 0xff; /* multiple out */
 
-    if (!prog_address_newmode)
-      prog_address = (data[3] << 8) | data[2];
+	} else if (data[1] == USBASP_FUNC_WRITEEEPROM) {
 
-    prog_pagesize = 0;
-    prog_blockflags = 0;
-    prog_nbytes = (data[7] << 8) | data[6];
-    prog_state = PROG_STATE_WRITEEEPROM;
-    len = 0xff; /* multiple out */
+		if (!prog_address_newmode)
+			prog_address = (data[3] << 8) | data[2];
 
-  } else if(data[1] == USBASP_FUNC_SETLONGADDRESS) {
+		prog_pagesize = 0;
+		prog_blockflags = 0;
+		prog_nbytes = (data[7] << 8) | data[6];
+		prog_state = PROG_STATE_WRITEEEPROM;
+		len = 0xff; /* multiple out */
 
-    /* set new mode of address delivering (ignore address delivered in commands) */
-    prog_address_newmode = 1;
-    /* set new address */
-    prog_address = *((unsigned long*)&data[2]);
-  }
+	} else if (data[1] == USBASP_FUNC_SETLONGADDRESS) {
 
-  usbMsgPtr = replyBuffer;
+		/* set new mode of address delivering (ignore address delivered in commands) */
+		prog_address_newmode = 1;
+		/* set new address */
+		prog_address = *((unsigned long*) &data[2]);
 
-  return len;
-}
+	} else if (data[1] == USBASP_FUNC_SETISPSCK) {
 
+		/* set sck option */
+		prog_sck = data[2];
+		replyBuffer[0] = 0;
+		len = 1;
+	}
 
-uchar usbFunctionRead(uchar *data, uchar len) {
+	usbMsgPtr = replyBuffer;
 
-  uchar i;
-
-  /* check if programmer is in correct read state */
-  if ((prog_state != PROG_STATE_READFLASH) &&
-      (prog_state != PROG_STATE_READEEPROM)) {
-    return 0xff;
-  }
-
-  /* fill packet */
-  for (i = 0; i < len; i++) {
-    if (prog_state == PROG_STATE_READFLASH) {
-      data[i] = ispReadFlash(prog_address);
-    } else {
-      data[i] = ispReadEEPROM(prog_address);
-    }
-    prog_address++;
-  }
-
-  /* last packet? */
-  if (len < 8) {
-    prog_state = PROG_STATE_IDLE;
-  }
-
-  return len;
+	return len;
 }
 
+uchar usbFunctionRead(uchar *data, uchar len) {
 
-uchar usbFunctionWrite(uchar *data, uchar len) {
+	uchar i;
 
-  uchar retVal = 0;
-  uchar i;
+	/* check if programmer is in correct read state */
+	if ((prog_state != PROG_STATE_READFLASH) && (prog_state
+			!= PROG_STATE_READEEPROM)) {
+		return 0xff;
+	}
 
-  /* check if programmer is in correct write state */
-  if ((prog_state != PROG_STATE_WRITEFLASH) &&
-      (prog_state != PROG_STATE_WRITEEEPROM)) {
-    return 0xff;
-  }
+	/* fill packet */
+	for (i = 0; i < len; i++) {
+		if (prog_state == PROG_STATE_READFLASH) {
+			data[i] = ispReadFlash(prog_address);
+		} else {
+			data[i] = ispReadEEPROM(prog_address);
+		}
+		prog_address++;
+	}
+
+	/* last packet? */
+	if (len < 8) {
+		prog_state = PROG_STATE_IDLE;
+	}
 
+	return len;
+}
 
-  for (i = 0; i < len; i++) {
+uchar usbFunctionWrite(uchar *data, uchar len) {
 
-    if (prog_state == PROG_STATE_WRITEFLASH) {
-      /* Flash */
+	uchar retVal = 0;
+	uchar i;
 
-      if (prog_pagesize == 0) {
-	/* not paged */
-	ispWriteFlash(prog_address, data[i], 1);
-      } else {
-	/* paged */
-	ispWriteFlash(prog_address, data[i], 0);
-	prog_pagecounter --;
-	if (prog_pagecounter == 0) {
-	  ispFlushPage(prog_address, data[i]);
-	  prog_pagecounter = prog_pagesize;
+	/* check if programmer is in correct write state */
+	if ((prog_state != PROG_STATE_WRITEFLASH) && (prog_state
+			!= PROG_STATE_WRITEEEPROM)) {
+		return 0xff;
 	}
-      }
 
-    } else {
-      /* EEPROM */
-      ispWriteEEPROM(prog_address, data[i]);
-    }
+	for (i = 0; i < len; i++) {
 
-    prog_nbytes --;
+		if (prog_state == PROG_STATE_WRITEFLASH) {
+			/* Flash */
 
-    if (prog_nbytes == 0) {
-      prog_state = PROG_STATE_IDLE;
-      if ((prog_blockflags & PROG_BLOCKFLAG_LAST) &&
-	  (prog_pagecounter != prog_pagesize)) {
+			if (prog_pagesize == 0) {
+				/* not paged */
+				ispWriteFlash(prog_address, data[i], 1);
+			} else {
+				/* paged */
+				ispWriteFlash(prog_address, data[i], 0);
+				prog_pagecounter--;
+				if (prog_pagecounter == 0) {
+					ispFlushPage(prog_address, data[i]);
+					prog_pagecounter = prog_pagesize;
+				}
+			}
 
-	/* last block and page flush pending, so flush it now */
-	ispFlushPage(prog_address, data[i]);
-      }
+		} else {
+			/* EEPROM */
+			ispWriteEEPROM(prog_address, data[i]);
+		}
 
-	  retVal = 1; // Need to return 1 when no more data is to be received
-    }
+		prog_nbytes--;
 
-    prog_address ++;
-  }
+		if (prog_nbytes == 0) {
+			prog_state = PROG_STATE_IDLE;
+			if ((prog_blockflags & PROG_BLOCKFLAG_LAST) && (prog_pagecounter
+					!= prog_pagesize)) {
 
-  return retVal;
-}
+				/* last block and page flush pending, so flush it now */
+				ispFlushPage(prog_address, data[i]);
+			}
 
+			retVal = 1; // Need to return 1 when no more data is to be received
+		}
 
-int main(void)
-{
-  uchar   i, j;
-
-  PORTD = 0;
-  PORTB = 0;		/* no pullups on USB and ISP pins */
-  DDRD = ~(1 << 2);	/* all outputs except PD2 = INT0 */
+		prog_address++;
+	}
 
-  DDRB = ~0;            /* output SE0 for USB reset */
-  j = 0;
-  while(--j){           /* USB Reset by device only required on Watchdog Reset */
-      i = 0;
-      while(--i);       /* delay >10ms for USB reset */
-  }
-  DDRB = 0;             /* all USB and ISP pins inputs */
+	return retVal;
+}
 
-  DDRC = 0x03;          /* all inputs except PC0, PC1 */
-  PORTC = 0xfe;
+int main(void) {
+	uchar i, j;
+
+	/* no pullups on USB and ISP pins */
+	PORTD = 0;
+	PORTB = 0;
+	/* all outputs except PD2 = INT0 */
+	DDRD = ~(1 << 2);
+
+	/* output SE0 for USB reset */
+	DDRB = ~0;
+	j = 0;
+	/* USB Reset by device only required on Watchdog Reset */
+	while (--j) {
+		i = 0;
+		/* delay >10ms for USB reset */
+		while (--i)
+			;
+	}
+	/* all USB and ISP pins inputs */
+	DDRB = 0;
 
-  clockInit();          /* init timer */
+	/* all inputs except PC0, PC1 */
+	DDRC = 0x03;
+	PORTC = 0xfe;
 
-  ispSetSCKOption(ISP_SCK_FAST);
+	/* init timer */
+	clockInit();
 
-  usbInit();
-  sei();
-  for(;;){	        /* main event loop */
-    usbPoll();
-  }
-  return 0;
+	/* main event loop */
+	usbInit();
+	sei();
+	for (;;) {
+		usbPoll();
+	}
+	return 0;
 }
diff --git a/firmware/usbasp.h b/firmware/usbasp.h
new file mode 100644
index 000000000..6953e8aa4
--- /dev/null
+++ b/firmware/usbasp.h
@@ -0,0 +1,58 @@
+/*
+ * usbasp.c - part of USBasp
+ *
+ * Autor..........: Thomas Fischl <tfischl@gmx.de>
+ * Description....: Definitions and macros for usbasp
+ * Licence........: GNU GPL v2 (see Readme.txt)
+ * Creation Date..: 2009-02-28
+ * Last change....: 2009-02-28
+ */
+
+#ifndef USBASP_H_
+#define USBASP_H_
+
+/* USB function call identifiers */
+#define USBASP_FUNC_CONNECT     1
+#define USBASP_FUNC_DISCONNECT  2
+#define USBASP_FUNC_TRANSMIT    3
+#define USBASP_FUNC_READFLASH   4
+#define USBASP_FUNC_ENABLEPROG  5
+#define USBASP_FUNC_WRITEFLASH  6
+#define USBASP_FUNC_READEEPROM  7
+#define USBASP_FUNC_WRITEEEPROM 8
+#define USBASP_FUNC_SETLONGADDRESS 9
+#define USBASP_FUNC_SETISPSCK 10
+
+/* programming state */
+#define PROG_STATE_IDLE         0
+#define PROG_STATE_WRITEFLASH   1
+#define PROG_STATE_READFLASH    2
+#define PROG_STATE_READEEPROM   3
+#define PROG_STATE_WRITEEEPROM  4
+
+/* Block mode flags */
+#define PROG_BLOCKFLAG_FIRST    1
+#define PROG_BLOCKFLAG_LAST     2
+
+/* ISP SCK speed identifiers */
+#define USBASP_ISP_SCK_AUTO   0
+#define USBASP_ISP_SCK_0_5    1   /* 500 Hz */
+#define USBASP_ISP_SCK_1      2   /*   1 kHz */
+#define USBASP_ISP_SCK_2      3   /*   2 kHz */
+#define USBASP_ISP_SCK_4      4   /*   4 kHz */
+#define USBASP_ISP_SCK_8      5   /*   8 kHz */
+#define USBASP_ISP_SCK_16     6   /*  16 kHz */
+#define USBASP_ISP_SCK_32     7   /*  32 kHz */
+#define USBASP_ISP_SCK_93_75  8   /*  93.75 kHz */
+#define USBASP_ISP_SCK_187_5  9   /* 187.5  kHz */
+#define USBASP_ISP_SCK_375    10  /* 375 kHz   */
+#define USBASP_ISP_SCK_750    11  /* 750 kHz   */
+#define USBASP_ISP_SCK_1500   12  /* 1.5 MHz   */
+
+/* macros for gpio functions */
+#define ledRedOn()    PORTC &= ~(1 << PC1)
+#define ledRedOff()   PORTC |= (1 << PC1)
+#define ledGreenOn()  PORTC &= ~(1 << PC0)
+#define ledGreenOff() PORTC |= (1 << PC0)
+
+#endif /* USBASP_H_ */
diff --git a/firmware/usbconfig.h b/firmware/usbconfig.h
index 7170def9c..e8d0ed9ee 100644
--- a/firmware/usbconfig.h
+++ b/firmware/usbconfig.h
@@ -124,7 +124,7 @@ the newest features and options.
  * you use obdev's free shared VID/PID pair. Be sure to read the rules in
  * USBID-License.txt!
  */
-#define USB_CFG_DEVICE_VERSION  0x02, 0x01
+#define USB_CFG_DEVICE_VERSION  0x03, 0x01
 /* Version number of the device: Minor number first, then major number.
  */
 #define	USB_CFG_VENDOR_NAME     'w', 'w', 'w', '.', 'f', 'i', 's', 'c', 'h', 'l', '.', 'd', 'e'
diff --git a/firmware/usbdrv/Changelog.txt b/firmware/usbdrv/Changelog.txt
index 0e9e8bfaf..cdb6ed300 100644
--- a/firmware/usbdrv/Changelog.txt
+++ b/firmware/usbdrv/Changelog.txt
@@ -150,3 +150,114 @@ Scroll down to the bottom to see the most recent changes.
   - 16 MHz module: Do SE0 check in stuffed bits as well.
 
 * Release 2007-07-07
+
+  - Define hi8(x) for IAR compiler to limit result to 8 bits. This is necessary
+    for negative values.
+  - Added 15 MHz module contributed by V. Bosch.
+  - Interrupt vector name can now be configured. This is useful if somebody
+    wants to use a different hardware interrupt than INT0.
+
+* Release 2007-08-07
+
+  - Moved handleIn3 routine in usbdrvasm16.S so that relative jump range is
+    not exceeded.
+  - More config options: USB_RX_USER_HOOK(), USB_INITIAL_DATATOKEN,
+    USB_COUNT_SOF
+  - USB_INTR_PENDING can now be a memory address, not just I/O
+
+* Release 2007-09-19
+
+  - Split out common parts of assembler modules into separate include file
+  - Made endpoint numbers configurable so that given interface definitions
+    can be matched. See USB_CFG_EP3_NUMBER in usbconfig-prototype.h.
+  - Store endpoint number for interrupt/bulk-out so that usbFunctionWriteOut()
+    can handle any number of endpoints.
+  - Define usbDeviceConnect() and usbDeviceDisconnect() even if no
+    USB_CFG_PULLUP_IOPORTNAME is defined. Directly set D+ and D- to 0 in this
+    case.
+
+* Release 2007-12-01
+
+  - Optimize usbDeviceConnect() and usbDeviceDisconnect() for less code size
+    when USB_CFG_PULLUP_IOPORTNAME is not defined.
+
+* Release 2007-12-13
+
+  - Renamed all include-only assembler modules from *.S to *.inc so that
+    people don't add them to their project sources.
+  - Distribute leap bits in tx loop more evenly for 16 MHz module.
+  - Use "macro" and "endm" instead of ".macro" and ".endm" for IAR
+  - Avoid compiler warnings for constant expr range by casting some values in
+    USB descriptors.
+
+* Release 2008-01-21
+
+  - Fixed bug in 15 and 16 MHz module where the new address set with
+    SET_ADDRESS was already accepted at the next NAK or ACK we send, not at
+    the next data packet we send. This caused problems when the host polled
+    too fast. Thanks to Alexander Neumann for his help and patience debugging
+    this issue!
+
+* Release 2008-02-05
+
+  - Fixed bug in 16.5 MHz module where a register was used in the interrupt
+    handler before it was pushed. This bug was introduced with version
+    2007-09-19 when common parts were moved to a separate file.
+  - Optimized CRC routine (thanks to Reimar Doeffinger).
+
+* Release 2008-02-16
+
+  - Removed outdated IAR compatibility stuff (code sections).
+  - Added hook macros for USB_RESET_HOOK() and USB_SET_ADDRESS_HOOK().
+  - Added optional routine usbMeasureFrameLength() for calibration of the
+    internal RC oscillator.
+
+* Release 2008-02-28
+
+  - USB_INITIAL_DATATOKEN defaults to USBPID_DATA1 now, which means that we
+    start with sending USBPID_DATA0.
+  - Changed defaults in usbconfig-prototype.h
+  - Added free USB VID/PID pair for MIDI class devices
+  - Restructured AVR-USB as separate package, not part of PowerSwitch any more.
+
+* Release 2008-04-18
+
+  - Restructured usbdrv.c so that it is easier to read and understand.
+  - Better code optimization with gcc 4.
+  - If a second interrupt in endpoint is enabled, also add it to config
+    descriptor.
+  - Added config option for long transfers (above 254 bytes), see
+    USB_CFG_LONG_TRANSFERS in usbconfig.h.
+  - Added 20 MHz module contributed by Jeroen Benschop.
+
+* Release 2008-05-13
+
+  - Fixed bug in libs-host/hiddata.c function usbhidGetReport(): length
+    was not incremented, pointer to length was incremented instead.
+  - Added code to command line tool(s) which claims an interface. This code
+    is disabled by default, but may be necessary on newer Linux kernels.
+  - Added usbconfig.h option "USB_CFG_CHECK_DATA_TOGGLING".
+  - New header "usbportability.h" prepares ports to other development
+    environments.
+  - Long transfers (above 254 bytes) did not work when usbFunctionRead() was
+    used to supply the data. Fixed this bug. [Thanks to Alexander Neumann!]
+  - In hiddata.c (example code for sending/receiving data over HID), use
+    USB_RECIP_DEVICE instead of USB_RECIP_INTERFACE for control transfers so
+    that we need not claim the interface.
+  - in usbPoll() loop 20 times polling for RESET state instead of 10 times.
+    This accounts for the higher clock rates we now support.
+  - Added a module for 12.8 MHz RC oscillator with PLL in receiver loop.
+  - Added hook to SOF code so that oscillator can be tuned to USB frame clock.
+  - Added timeout to waitForJ loop. Helps preventing unexpected hangs.
+  - Added example code for oscillator tuning to libs-device (thanks to
+    Henrik Haftmann for the idea to this routine).
+  - Implemented option USB_CFG_SUPPRESS_INTR_CODE.
+
+* Release 2008-10-22
+
+  - Fixed libs-device/osctune.h: OSCCAL is memory address on ATMega88 and
+    similar, not offset of 0x20 needs to be added.
+  - Allow distribution under GPLv3 for those who have to link against other
+    code distributed under GPLv3.
+
+* Release 2008-11-26
diff --git a/firmware/usbdrv/CommercialLicense.txt b/firmware/usbdrv/CommercialLicense.txt
index 1e4ae0b5c..9fd040fda 100644
--- a/firmware/usbdrv/CommercialLicense.txt
+++ b/firmware/usbdrv/CommercialLicense.txt
@@ -1,5 +1,5 @@
 AVR-USB Driver Software License Agreement
-Version 2006-07-24
+Version 2008-10-07
 
 THIS LICENSE AGREEMENT GRANTS YOU CERTAIN RIGHTS IN A SOFTWARE. YOU CAN
 ENTER INTO THIS AGREEMENT AND ACQUIRE THE RIGHTS OUTLINED BELOW BY PAYING
@@ -13,10 +13,11 @@ Grosse Schiffgasse 1A/7, 1020 Wien, AUSTRIA.
 
 1.2 "You" shall mean the Licensee.
 
-1.3 "AVR-USB" shall mean the firmware-only USB device implementation for
-Atmel AVR microcontrollers distributed by OBJECTIVE DEVELOPMENT and
-consisting of the files usbdrv.c, usbdrv.h, usbdrvasm.S, oddebug.c,
-oddebug.h, usbdrvasm.asm, iarcompat.h and usbconfig-prototype.h.
+1.3 "AVR-USB" shall mean all files included in the package distributed under
+the name "avrusb" by OBJECTIVE DEVELOPMENT (http://www.obdev.at/avrusb/)
+unless otherwise noted. This includes the firmware-only USB device
+implementation for Atmel AVR microcontrollers, some simple device examples
+and host side software examples and libraries.
 
 
 2 LICENSE GRANTS
@@ -25,11 +26,11 @@ oddebug.h, usbdrvasm.asm, iarcompat.h and usbconfig-prototype.h.
 code of AVR-USB.
 
 2.2 Distribution and Use. OBJECTIVE DEVELOPMENT grants you the
-non-exclusive right to use and distribute AVR-USB with your hardware
+non-exclusive right to use, copy and distribute AVR-USB with your hardware
 product(s), restricted by the limitations in section 3 below.
 
 2.3 Modifications. OBJECTIVE DEVELOPMENT grants you the right to modify
-your copy of AVR-USB according to your needs.
+the source code and your copy of AVR-USB according to your needs.
 
 2.4 USB IDs. OBJECTIVE DEVELOPMENT grants you the exclusive rights to use
 USB Product ID(s) sent to you in e-mail after receiving your payment in
diff --git a/firmware/usbdrv/License.txt b/firmware/usbdrv/License.txt
index a435e0e9b..e9b2752a3 100644
--- a/firmware/usbdrv/License.txt
+++ b/firmware/usbdrv/License.txt
@@ -1,6 +1,8 @@
 OBJECTIVE DEVELOPMENT GmbH's AVR-USB driver software is distributed under the
-terms and conditions of the GNU GPL version 2, see the text below. In addition
-to the requirements in the GPL, we STRONGLY ENCOURAGE you to do the following:
+terms and conditions of the GNU GPL version 2 or the GNU GPL version 3. It is
+your choice whether you apply the terms of version 2 or version 3. The full
+text of GPLv2 is included below. In addition to the requirements in the GPL,
+we STRONGLY ENCOURAGE you to do the following:
 
 (1) Publish your entire project on a web site and drop us a note with the URL.
 Use the form at http://www.obdev.at/avrusb/feedback.html for your submission.
@@ -74,7 +76,7 @@ patent must be licensed for everyone's free use or not licensed at all.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
-
+
                     GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
@@ -129,7 +131,7 @@ above, provided that you also meet all of these conditions:
     License.  (Exception: if the Program itself is interactive but
     does not normally print such an announcement, your work based on
     the Program is not required to print an announcement.)
-
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -187,7 +189,7 @@ access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
+
   4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -244,7 +246,7 @@ impose that choice.
 
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
+
   8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -297,7 +299,7 @@ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
                      END OF TERMS AND CONDITIONS
-
+
             How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
diff --git a/firmware/usbdrv/Readme.txt b/firmware/usbdrv/Readme.txt
index debc75682..024af5885 100644
--- a/firmware/usbdrv/Readme.txt
+++ b/firmware/usbdrv/Readme.txt
@@ -3,8 +3,9 @@ for Atmel AVR microcontrollers. For more information please visit
 http://www.obdev.at/avrusb/
 
 This directory contains the USB firmware only. Copy it as-is to your own
-project and add your own version of "usbconfig.h". A template for your own
-"usbconfig.h" can be found in "usbconfig-prototype.h" in this directory.
+project and add all .c and .S files to your project (these files are marked
+with an asterisk in the list below). Then copy usbconfig-prototype.h as
+usbconfig.h to your project and edit it according to your configuration.
 
 
 TECHNICAL DOCUMENTATION
@@ -23,19 +24,16 @@ The driver consists of the following files:
                            a stub and includes one of the usbdrvasm*.S files
                            depending on processor clock. Link this module to
                            your code!
-  usbdrvasm12.S .......... 12 MHz version of the assembler routines. Included
-                           by usbdrvasm.S, don't link it directly!
-  usbdrvasm16.S .......... 16 MHz version of the assembler routines. Included
-                           by usbdrvasm.S, don't link it directly!
-  usbdrvasm165.S ......... 16.5 MHz version of the assembler routines including
-                           a PLL so that an 1% accurate RC oscillator can be
-                           used. Included by usbdrvasm.S, don't link directly!
+  usbdrvasm*.inc ......... Assembler routines for particular clock frequencies.
+                           Included by usbdrvasm.S, don't link it directly!
+  asmcommon.inc .......... Common assembler routines. Included by
+                           usbdrvasm*.inc, don't link it directly!
   usbconfig-prototype.h .. Prototype for your own usbdrv.h file.
 * oddebug.c .............. Debug functions. Only used when DEBUG_LEVEL is
                            defined to a value greater than 0. Link this module
                            to your code!
   oddebug.h .............. Interface definitions of the debug module.
-  iarcompat.h ............ Compatibility definitions for IAR C-compiler.
+  usbportability.h ....... Header with compiler-dependent stuff.
   usbdrvasm.asm .......... Compatibility stub for IAR-C-compiler. Use this
                            module instead of usbdrvasm.S when you assembler
                            with IAR's tools.
@@ -49,14 +47,19 @@ The driver consists of the following files:
 
 CPU CORE CLOCK FREQUENCY
 ========================
-We supply assembler modules for clock frequencies of 12 MHz, 16 MHz and
-16.5 MHz. Other clock rates are not supported. The actual clock rate must be
-configured in usbdrv.h unless you use the default 12 MHz.
+We supply assembler modules for clock frequencies of 12 MHz, 12.8 MHz, 15 MHz,
+16 MHz, 16.5 MHz and 20 MHz. Other clock rates are not supported. The actual
+clock rate must be configured in usbdrv.h unless you use the default 12 MHz.
 
 12 MHz Clock
 This is the traditional clock rate of AVR-USB because it's the lowest clock
 rate where the timing constraints of the USB spec can be met.
 
+15 MHz Clock
+Similar to 12 MHz, but some NOPs inserted. On the other hand, the higher clock
+rate allows for some loops which make the resulting code size somewhat smaller
+than the 12 MHz version.
+
 16 MHz Clock
 This clock rate has been added for users of the Arduino board and other
 ready-made boards which come with a fixed 16 MHz crystal. It's also an option
@@ -64,21 +67,23 @@ if you need the slightly higher clock rate for performance reasons. Since
 16 MHz is not divisible by the USB low speed bit clock of 1.5 MHz, the code
 is somewhat tricky and has to insert a leap cycle every third byte.
 
-16.5 MHz Clock
-The assembler module for this clock rate differs from the other modules because
-it has been built for an RC oscillator with only 1% precision. The receiver
-code inserts leap cycles to compensate for clock deviations. 1% is also the
-precision which can be achieved by calibrating the internal RC oscillator of
-the AVR. Please note that only AVRs with internal 64 MHz PLL oscillator can be
-used since the 8 MHz RC oscillator cannot be trimmed up to 16.5 MHz. This
-includes the very popular ATTiny25, ATTiny45, ATTiny85 series as well as the
-ATTiny26.
+12.8 MHz and 16.5 MHz Clock
+The assembler modules for these clock rates differ from the other modules
+because they have been built for an RC oscillator with only 1% precision. The
+receiver code inserts leap cycles to compensate for clock deviations. 1% is
+also the precision which can be achieved by calibrating the internal RC
+oscillator of the AVR. Please note that only AVRs with internal 64 MHz PLL
+oscillator can reach 16.5 MHz with the RC oscillator. This includes the very
+popular ATTiny25, ATTiny45, ATTiny85 series as well as the ATTiny26. Almost
+all AVRs can reach 12.8 MHz, although this is outside the specified range.
+
+See the EasyLogger example at http://www.obdev.at/avrusb/easylogger.html for
+code which calibrates the RC oscillator based on the USB frame clock.
 
-We recommend that you obtain appropriate calibration values for 16.5 MHz core
-clock at programming time and store it in flash or EEPROM or compute the value
-from a reference clock at run time. However, since Atmel's 8 MHz calibration
-is much more precise than the guaranteed 10%, it's usually possible to add a
-fixed offset to this value.
+20 MHz Clock
+This module is for people who won't do it with less than the maximum. Since
+20 MHz is not divisible by the USB low speed bit clock of 1.5 MHz, the code
+uses similar tricks as the 16 MHz module to insert leap cycles.
 
 
 USB IDENTIFIERS
@@ -88,49 +93,39 @@ are obtained from usb.org for a price of 1,500 USD. Once you have a VID, you
 can assign PIDs at will.
 
 Since an entry level cost of 1,500 USD is too high for most small companies
-and hobbyists, we provide a single VID/PID pair for free. If you want to use
-your own VID and PID instead of our's, define the macros "USB_CFG_VENDOR_ID"
-and "USB_CFG_DEVICE_ID" accordingly in "usbconfig.h".
-
-To use our predefined VID/PID pair, you MUST conform to a couple of
-requirements. See the file "USBID-License.txt" for details.
-
-Objective Development also has some offerings which include product IDs. See
-http://www.obdev.at/avrusb/ for details.
-
+and hobbyists, we provide some VID/PID pairs for free. See the file
+USBID-License.txt for details.
 
-HOST DRIVER
-===========
-You have received this driver together with an example device implementation
-and an example host driver. The host driver is based on libusb and compiles
-on various Unix flavors (Linux, BSD, Mac OS X). It also compiles natively on
-Windows using MinGW (see www.mingw.org) and libusb-win32 (see
-libusb-win32.sourceforge.net). The "Automator" project contains a native
-Windows host driver (not based on libusb) for Human Interface Devices.
+Objective Development also has some license offerings which include product
+IDs. See http://www.obdev.at/avrusb/ for details.
 
 
 DEVELOPMENT SYSTEM
 ==================
 This driver has been developed and optimized for the GNU compiler version 3
-(gcc 3). It does work well with gcc 4 and future versions will probably be
-optimized for gcc 4. We recommend that you use the GNU compiler suite because
-it is freely available. AVR-USB has also been ported to the IAR compiler and
-assembler. It has been tested with IAR 4.10B/W32 and 4.12A/W32 on an ATmega8
-with the "small" and "tiny" memory model. Please note that gcc is more
-efficient for usbdrv.c because this module has been deliberately optimized
-for gcc.
+(gcc 3). It does work well with gcc 4, but with bigger code size. We recommend
+that you use the GNU compiler suite because it is freely available. AVR-USB
+has also been ported to the IAR compiler and assembler. It has been tested
+with IAR 4.10B/W32 and 4.12A/W32 on an ATmega8 with the "small" and "tiny"
+memory model. Not every release is tested with IAR CC and the driver may
+therefore fail to compile with IAR. Please note that gcc is more efficient for
+usbdrv.c because this module has been deliberately optimized for gcc.
 
 
 USING AVR-USB FOR FREE
 ======================
 The AVR firmware driver is published under the GNU General Public License
-Version 2 (GPL2). See the file "License.txt" for details.
+Version 2 (GPL2) and the GNU General Public License Version 3 (GPL3). It is
+your choice whether you apply the terms of version 2 or version 3.
 
-If you decide for the free GPL2, we STRONGLY ENCOURAGE you to do the following
-things IN ADDITION to the obligations from the GPL2:
+If you decide for the free GPL2 or GPL3, we STRONGLY ENCOURAGE you to do the
+following things IN ADDITION to the obligations from the GPL:
 
 (1) Publish your entire project on a web site and drop us a note with the URL.
 Use the form at http://www.obdev.at/avrusb/feedback.html for your submission.
+If you don't have a web site, you can publish the project in obdev's
+documentation wiki at
+http://www.obdev.at/goto.php?t=avrusb-wiki&p=hosted-projects.
 
 (2) Adhere to minimum publication standards. Please include AT LEAST:
     - a circuit diagram in PDF, PNG or GIF format
@@ -145,7 +140,7 @@ to your modifications for our commercial license offerings.
 
 COMMERCIAL LICENSES FOR AVR-USB
 ===============================
-If you don't want to publish your source code under the terms of the GPL2,
+If you don't want to publish your source code under the terms of the GPL,
 you can simply pay money for AVR-USB. As an additional benefit you get
 USB PIDs for free, licensed exclusively to you. See the file
 "CommercialLicense.txt" for details.
diff --git a/firmware/usbdrv/USBID-License.txt b/firmware/usbdrv/USBID-License.txt
index 4739a57fe..984c9eef1 100644
--- a/firmware/usbdrv/USBID-License.txt
+++ b/firmware/usbdrv/USBID-License.txt
@@ -1,7 +1,7 @@
 Royalty-Free Non-Exclusive License USB Product-ID
 =================================================
 
-Version 2006-06-19
+Version 2008-04-07
 
 OBJECTIVE DEVELOPMENT Software GmbH hereby grants you the non-exclusive
 right to use three USB.org vendor-ID (VID) / product-ID (PID) pairs with
@@ -19,6 +19,9 @@ Atmel AVR microcontrollers:
  * VID = 5824 (=0x16c0) / PID = 1505 (=0x5e1) for CDC class modem devices
    Devices using this pair will be referred to as "CDC-ACM CLASS" devices.
 
+ * VID = 5824 (=0x16c0) / PID = 1508 (=0x5e4) for MIDI class devices
+   Devices using this pair will be referred to as "MIDI CLASS" devices.
+
 Since the granted right is non-exclusive, the same VID/PID pairs may be
 used by many companies and individuals for different products. To avoid
 conflicts, your device and host driver software MUST adhere to the rules
@@ -56,8 +59,8 @@ matching. This means that operating system features which are based on
 VID/PID matching only (e.g. Windows kernel level drivers, automatic actions
 when the device is plugged in etc) MUST NOT be used. The driver matching
 MUST be a comparison of the entire strings, NOT a sub-string match. For
-CDC-ACM CLASS devices, a generic class driver should be used and the
-matching is based on the USB device class.
+CDC-ACM CLASS and MIDI CLASS devices, a generic class driver should be used
+and the matching is based on the USB device class.
 
 (6) The extent to which VID/PID matching is allowed for non device-specific
 drivers or features depends on the operating system and particular VID/PID
@@ -86,8 +89,8 @@ HOW TO IMPLEMENT THESE RULES
 ============================
 
 The following rules are for VENDOR CLASS and HID CLASS devices. CDC-ACM
-CLASS devices use the operating system's class driver and don't need a
-custom driver.
+CLASS and MIDI CLASS devices use the operating system's class driver and
+don't need a custom driver.
 
 The host driver MUST iterate over all devices with the given VID/PID
 numbers in their device descriptors and query the string representation for
diff --git a/firmware/usbdrv/asmcommon.inc b/firmware/usbdrv/asmcommon.inc
new file mode 100644
index 000000000..1af53b8ba
--- /dev/null
+++ b/firmware/usbdrv/asmcommon.inc
@@ -0,0 +1,185 @@
+/* Name: asmcommon.inc
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2007-11-05
+ * Tabsize: 4
+ * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Revision: $Id$
+ */
+
+/* Do not link this file! Link usbdrvasm.S instead, which includes the
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file contains assembler code which is shared among the USB driver
+implementations for different CPU cocks. Since the code must be inserted
+in the middle of the module, it's split out into this file and #included.
+
+Jump destinations called from outside:
+    sofError: Called when no start sequence was found.
+    se0: Called when a package has been successfully received.
+    overflow: Called when receive buffer overflows.
+    doReturn: Called after sending data.
+
+Outside jump destinations used by this module:
+    waitForJ: Called to receive an already arriving packet.
+    sendAckAndReti:
+    sendNakAndReti:
+    sendCntAndReti:
+    usbSendAndReti:
+
+The following macros must be defined before this file is included:
+    .macro POP_STANDARD
+    .endm
+    .macro POP_RETI
+    .endm
+*/
+
+#define token   x1
+
+overflow:
+    ldi     x2, 1<<USB_INTR_PENDING_BIT
+    USB_STORE_PENDING(x2)       ; clear any pending interrupts
+ignorePacket:
+    clr     token
+    rjmp    storeTokenAndReturn
+
+;----------------------------------------------------------------------------
+; Processing of received packet (numbers in brackets are cycles after center of SE0)
+;----------------------------------------------------------------------------
+;This is the only non-error exit point for the software receiver loop
+;we don't check any CRCs here because there is no time left.
+se0:
+    subi    cnt, USB_BUFSIZE    ;[5]
+    neg     cnt                 ;[6]
+    sub     YL, cnt             ;[7]
+    sbci    YH, 0               ;[8]
+    ldi     x2, 1<<USB_INTR_PENDING_BIT ;[9]
+    USB_STORE_PENDING(x2)       ;[10] clear pending intr and check flag later. SE0 should be over.
+    ld      token, y            ;[11]
+    cpi     token, USBPID_DATA0 ;[13]
+    breq    handleData          ;[14]
+    cpi     token, USBPID_DATA1 ;[15]
+    breq    handleData          ;[16]
+    lds     shift, usbDeviceAddr;[17]
+    ldd     x2, y+1             ;[19] ADDR and 1 bit endpoint number
+    lsl     x2                  ;[21] shift out 1 bit endpoint number
+    cpse    x2, shift           ;[22]
+    rjmp    ignorePacket        ;[23]
+/* only compute endpoint number in x3 if required later */
+#if USB_CFG_HAVE_INTRIN_ENDPOINT || USB_CFG_IMPLEMENT_FN_WRITEOUT
+    ldd     x3, y+2             ;[24] endpoint number + crc
+    rol     x3                  ;[26] shift in LSB of endpoint
+#endif
+    cpi     token, USBPID_IN    ;[27]
+    breq    handleIn            ;[28]
+    cpi     token, USBPID_SETUP ;[29]
+    breq    handleSetupOrOut    ;[30]
+    cpi     token, USBPID_OUT   ;[31]
+    brne    ignorePacket        ;[32] must be ack, nak or whatever
+;   rjmp    handleSetupOrOut    ; fallthrough
+
+;Setup and Out are followed by a data packet two bit times (16 cycles) after
+;the end of SE0. The sync code allows up to 40 cycles delay from the start of
+;the sync pattern until the first bit is sampled. That's a total of 56 cycles.
+handleSetupOrOut:               ;[32]
+#if USB_CFG_IMPLEMENT_FN_WRITEOUT   /* if we have data for endpoint != 0, set usbCurrentTok to address */
+    andi    x3, 0xf             ;[32]
+    breq    storeTokenAndReturn ;[33]
+    mov     token, x3           ;[34] indicate that this is endpoint x OUT
+#endif
+storeTokenAndReturn:
+    sts     usbCurrentTok, token;[35]
+doReturn:
+    POP_STANDARD                ;[37] 12...16 cycles
+    USB_LOAD_PENDING(YL)        ;[49]
+    sbrc    YL, USB_INTR_PENDING_BIT;[50] check whether data is already arriving
+    rjmp    waitForJ            ;[51] save the pops and pushes -- a new interrupt is already pending
+sofError:
+    POP_RETI                    ;macro call
+    reti
+
+handleData:
+    lds     shift, usbCurrentTok;[18]
+    tst     shift               ;[20]
+    breq    doReturn            ;[21]
+    lds     x2, usbRxLen        ;[22]
+    tst     x2                  ;[24]
+    brne    sendNakAndReti      ;[25]
+; 2006-03-11: The following two lines fix a problem where the device was not
+; recognized if usbPoll() was called less frequently than once every 4 ms.
+    cpi     cnt, 4              ;[26] zero sized data packets are status phase only -- ignore and ack
+    brmi    sendAckAndReti      ;[27] keep rx buffer clean -- we must not NAK next SETUP
+#if USB_CFG_CHECK_DATA_TOGGLING
+    sts     usbCurrentDataToken, token  ; store for checking by C code
+#endif
+    sts     usbRxLen, cnt       ;[28] store received data, swap buffers
+    sts     usbRxToken, shift   ;[30]
+    lds     x2, usbInputBufOffset;[32] swap buffers
+    ldi     cnt, USB_BUFSIZE    ;[34]
+    sub     cnt, x2             ;[35]
+    sts     usbInputBufOffset, cnt;[36] buffers now swapped
+    rjmp    sendAckAndReti      ;[38] 40 + 17 = 57 until SOP
+
+handleIn:
+;We don't send any data as long as the C code has not processed the current
+;input data and potentially updated the output data. That's more efficient
+;in terms of code size than clearing the tx buffers when a packet is received.
+    lds     x1, usbRxLen        ;[30]
+    cpi     x1, 1               ;[32] negative values are flow control, 0 means "buffer free"
+    brge    sendNakAndReti      ;[33] unprocessed input packet?
+    ldi     x1, USBPID_NAK      ;[34] prepare value for usbTxLen
+#if USB_CFG_HAVE_INTRIN_ENDPOINT
+    andi    x3, 0xf             ;[35] x3 contains endpoint
+#if USB_CFG_SUPPRESS_INTR_CODE
+    brne    sendNakAndReti      ;[36]
+#else
+    brne    handleIn1           ;[36]
+#endif
+#endif
+    lds     cnt, usbTxLen       ;[37]
+    sbrc    cnt, 4              ;[39] all handshake tokens have bit 4 set
+    rjmp    sendCntAndReti      ;[40] 42 + 16 = 58 until SOP
+    sts     usbTxLen, x1        ;[41] x1 == USBPID_NAK from above
+    ldi     YL, lo8(usbTxBuf)   ;[43]
+    ldi     YH, hi8(usbTxBuf)   ;[44]
+    rjmp    usbSendAndReti      ;[45] 57 + 12 = 59 until SOP
+
+; Comment about when to set usbTxLen to USBPID_NAK:
+; We should set it back when we receive the ACK from the host. This would
+; be simple to implement: One static variable which stores whether the last
+; tx was for endpoint 0 or 1 and a compare in the receiver to distinguish the
+; ACK. However, we set it back immediately when we send the package,
+; assuming that no error occurs and the host sends an ACK. We save one byte
+; RAM this way and avoid potential problems with endless retries. The rest of
+; the driver assumes error-free transfers anyway.
+
+#if !USB_CFG_SUPPRESS_INTR_CODE && USB_CFG_HAVE_INTRIN_ENDPOINT /* placed here due to relative jump range */
+handleIn1:                      ;[38]
+#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+; 2006-06-10 as suggested by O.Tamura: support second INTR IN / BULK IN endpoint
+    cpi     x3, USB_CFG_EP3_NUMBER;[38]
+    breq    handleIn3           ;[39]
+#endif
+    lds     cnt, usbTxLen1      ;[40]
+    sbrc    cnt, 4              ;[42] all handshake tokens have bit 4 set
+    rjmp    sendCntAndReti      ;[43] 47 + 16 = 63 until SOP
+    sts     usbTxLen1, x1       ;[44] x1 == USBPID_NAK from above
+    ldi     YL, lo8(usbTxBuf1)  ;[46]
+    ldi     YH, hi8(usbTxBuf1)  ;[47]
+    rjmp    usbSendAndReti      ;[48] 50 + 12 = 62 until SOP
+
+#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+handleIn3:
+    lds     cnt, usbTxLen3      ;[41]
+    sbrc    cnt, 4              ;[43]
+    rjmp    sendCntAndReti      ;[44] 49 + 16 = 65 until SOP
+    sts     usbTxLen3, x1       ;[45] x1 == USBPID_NAK from above
+    ldi     YL, lo8(usbTxBuf3)  ;[47]
+    ldi     YH, hi8(usbTxBuf3)  ;[48]
+    rjmp    usbSendAndReti      ;[49] 51 + 12 = 63 until SOP
+#endif
+#endif
diff --git a/firmware/usbdrv/iarcompat.h b/firmware/usbdrv/iarcompat.h
deleted file mode 100644
index 1a4554098..000000000
--- a/firmware/usbdrv/iarcompat.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* Name: iarcompat.h
- * Project: AVR USB driver
- * Author: Christian Starkjohann
- * Creation Date: 2006-03-01
- * Tabsize: 4
- * Copyright: (c) 2006 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: iarcompat.h 275 2007-03-20 09:58:28Z cs $
- */
-
-/*
-General Description:
-This header is included when we compile with the IAR C-compiler and assembler.
-It defines macros for cross compatibility between gcc and IAR-cc.
-
-Thanks to Oleg Semyonov for his help with the IAR tools port!
-*/
-
-#ifndef __iarcompat_h_INCLUDED__
-#define __iarcompat_h_INCLUDED__
-
-#if defined __IAR_SYSTEMS_ICC__ || defined __IAR_SYSTEMS_ASM__
-
-/* Enable bit definitions */
-#ifndef ENABLE_BIT_DEFINITIONS
-#   define ENABLE_BIT_DEFINITIONS	1
-#endif
-
-/* Include IAR headers */
-#include <ioavr.h>
-#ifndef __IAR_SYSTEMS_ASM__
-#   include <inavr.h>
-#endif
-
-#define __attribute__(arg)
-#define IAR_SECTION(section)    @ section
-
-#ifndef USB_BUFFER_SECTION
-#   define  USB_BUFFER_SECTION  "TINY_Z"    /* if user has not selected a named section */
-#endif
-
-#ifdef __IAR_SYSTEMS_ASM__
-#   define __ASSEMBLER__
-#endif
-
-#ifdef __HAS_ELPM__
-#   define PROGMEM __farflash
-#else
-#   define PROGMEM __flash
-#endif
-
-#define PRG_RDB(addr)   (*(PROGMEM char *)(addr))
-
-/* The following definitions are not needed by the driver, but may be of some
- * help if you port a gcc based project to IAR.
- */
-#define cli()       __disable_interrupt()
-#define sei()       __enable_interrupt()
-#define wdt_reset() __watchdog_reset()
-
-/* Depending on the device you use, you may get problems with the way usbdrv.h
- * handles the differences between devices. Since IAR does not use #defines
- * for MCU registers, we can't check for the existence of a particular
- * register with an #ifdef. If the autodetection mechanism fails, include
- * definitions for the required USB_INTR_* macros in your usbconfig.h. See
- * usbconfig-prototype.h and usbdrv.h for details.
- */
-
-#endif  /* defined __IAR_SYSTEMS_ICC__ || defined __IAR_SYSTEMS_ASM__ */
-#endif  /* __iarcompat_h_INCLUDED__ */
diff --git a/firmware/usbdrv/oddebug.c b/firmware/usbdrv/oddebug.c
index bd528e2d3..945457c1f 100644
--- a/firmware/usbdrv/oddebug.c
+++ b/firmware/usbdrv/oddebug.c
@@ -4,8 +4,8 @@
  * Creation Date: 2005-01-16
  * Tabsize: 4
  * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: oddebug.c 275 2007-03-20 09:58:28Z cs $
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: oddebug.c 692 2008-11-07 15:07:40Z cs $
  */
 
 #include "oddebug.h"
diff --git a/firmware/usbdrv/oddebug.h b/firmware/usbdrv/oddebug.h
index 1b11ef07d..d61309daa 100644
--- a/firmware/usbdrv/oddebug.h
+++ b/firmware/usbdrv/oddebug.h
@@ -4,8 +4,8 @@
  * Creation Date: 2005-01-16
  * Tabsize: 4
  * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: oddebug.h 275 2007-03-20 09:58:28Z cs $
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: oddebug.h 692 2008-11-07 15:07:40Z cs $
  */
 
 #ifndef __oddebug_h_included__
@@ -29,10 +29,7 @@ the output and a memory block to dump in hex ('data' and 'len').
 #endif
 
 /* make sure we have the UART defines: */
-#include "iarcompat.h"
-#ifndef __IAR_SYSTEMS_ICC__
-#   include <avr/io.h>
-#endif
+#include "usbportability.h"
 
 #ifndef uchar
 #   define  uchar   unsigned char
diff --git a/firmware/usbdrv/usbconfig-prototype.h b/firmware/usbdrv/usbconfig-prototype.h
index e1138c9f6..6c9e37a82 100644
--- a/firmware/usbdrv/usbconfig-prototype.h
+++ b/firmware/usbdrv/usbconfig-prototype.h
@@ -4,8 +4,8 @@
  * Creation Date: 2005-04-01
  * Tabsize: 4
  * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: usbconfig-prototype.h 358 2007-06-23 13:30:30Z cs $
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbconfig-prototype.h 692 2008-11-07 15:07:40Z cs $
  */
 
 #ifndef __usbconfig_h_included__
@@ -14,12 +14,14 @@
 /*
 General Description:
 This file is an example configuration (with inline documentation) for the USB
-driver. It configures AVR-USB for an ATMega8 with USB D+ connected to Port D
-bit 2 (which is also hardware interrupt 0) and USB D- to Port D bit 0. You may
-wire the lines to any other port, as long as D+ is also wired to INT0.
-To create your own usbconfig.h file, copy this file to the directory
-containing "usbdrv" (that is your project firmware source directory) and
-rename it to "usbconfig.h". Then edit it accordingly.
+driver. It configures AVR-USB for USB D+ connected to Port D bit 2 (which is
+also hardware interrupt 0 on many devices) and USB D- to Port D bit 4. You may
+wire the lines to any other port, as long as D+ is also wired to INT0 (or any
+other hardware interrupt, as long as it is the highest level interrupt, see
+section at the end of this file).
++ To create your own usbconfig.h file, copy this file to your project's
++ firmware source directory) and rename it to "usbconfig.h".
++ Then edit it accordingly.
 */
 
 /* ---------------------------- Hardware Config ---------------------------- */
@@ -28,20 +30,24 @@ rename it to "usbconfig.h". Then edit it accordingly.
 /* This is the port where the USB bus is connected. When you configure it to
  * "B", the registers PORTB, PINB and DDRB will be used.
  */
-#define USB_CFG_DMINUS_BIT      0
+#define USB_CFG_DMINUS_BIT      4
 /* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected.
  * This may be any bit in the port.
  */
 #define USB_CFG_DPLUS_BIT       2
 /* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected.
  * This may be any bit in the port. Please note that D+ must also be connected
- * to interrupt pin INT0!
+ * to interrupt pin INT0! [You can also use other interrupts, see section
+ * "Optional MCU Description" below, or you can connect D- to the interrupt, as
+ * it is required if you use the USB_COUNT_SOF feature. If you use D- for the
+ * interrupt, the USB interrupt will also be triggered at Start-Of-Frame
+ * markers every millisecond.]
  */
-/* #define USB_CFG_CLOCK_KHZ       (F_CPU/1000) */
-/* Clock rate of the AVR in MHz. Legal values are 12000, 16000 or 16500.
- * The 16.5 MHz version of the code requires no crystal, it tolerates +/- 1%
- * deviation from the nominal frequency. All other rates require a precision
- * of 2000 ppm and thus a crystal!
+#define USB_CFG_CLOCK_KHZ       (F_CPU/1000)
+/* Clock rate of the AVR in MHz. Legal values are 12000, 12800, 15000, 16000,
+ * 16500 and 20000. The 12.8 MHz and 16.5 MHz versions of the code require no
+ * crystal, they tolerate +/- 1% deviation from the nominal frequency. All
+ * other rates require a precision of 2000 ppm and thus a crystal!
  * Default if not specified: 12 MHz
  */
 
@@ -61,14 +67,26 @@ rename it to "usbconfig.h". Then edit it accordingly.
 
 /* --------------------------- Functional Range ---------------------------- */
 
-#define USB_CFG_HAVE_INTRIN_ENDPOINT    1
+#define USB_CFG_HAVE_INTRIN_ENDPOINT    0
 /* Define this to 1 if you want to compile a version with two endpoints: The
- * default control endpoint 0 and an interrupt-in endpoint 1.
+ * default control endpoint 0 and an interrupt-in endpoint (any other endpoint
+ * number).
  */
 #define USB_CFG_HAVE_INTRIN_ENDPOINT3   0
 /* Define this to 1 if you want to compile a version with three endpoints: The
- * default control endpoint 0, an interrupt-in endpoint 1 and an interrupt-in
- * endpoint 3. You must also enable endpoint 1 above.
+ * default control endpoint 0, an interrupt-in endpoint 3 (or the number
+ * configured below) and a catch-all default interrupt-in endpoint as above.
+ * You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature.
+ */
+#define USB_CFG_EP3_NUMBER              3
+/* If the so-called endpoint 3 is used, it can now be configured to any other
+ * endpoint number (except 0) with this macro. Default if undefined is 3.
+ */
+/* #define USB_INITIAL_DATATOKEN           USBPID_DATA1 */
+/* The above macro defines the startup condition for data toggling on the
+ * interrupt/bulk endpoints 1 and 3. Defaults to USBPID_DATA1.
+ * Since the token is toggled BEFORE sending any data, the first packet is
+ * sent with the oposite value of this configuration!
  */
 #define USB_CFG_IMPLEMENT_HALT          0
 /* Define this to 1 if you also want to implement the ENDPOINT_HALT feature
@@ -76,7 +94,15 @@ rename it to "usbconfig.h". Then edit it accordingly.
  * it is required by the standard. We have made it a config option because it
  * bloats the code considerably.
  */
-#define USB_CFG_INTR_POLL_INTERVAL      20
+#define USB_CFG_SUPPRESS_INTR_CODE      0
+/* Define this to 1 if you want to declare interrupt-in endpoints, but don't
+ * want to send any data over them. If this macro is defined to 1, functions
+ * usbSetInterrupt() and usbSetInterrupt3() are omitted. This is useful if
+ * you need the interrupt-in endpoints in order to comply to an interface
+ * (e.g. HID), but never want to send any data. This option saves a couple
+ * of bytes in flash memory and the transmit buffers in RAM.
+ */
+#define USB_CFG_INTR_POLL_INTERVAL      10
 /* If you compile a version with endpoint 1 (interrupt-in), this is the poll
  * interval. The value is in milliseconds and must not be less than 10 ms for
  * low speed devices.
@@ -102,39 +128,97 @@ rename it to "usbconfig.h". Then edit it accordingly.
  * usbFunctionSetup(). This saves a couple of bytes.
  */
 #define USB_CFG_IMPLEMENT_FN_WRITEOUT   0
-/* Define this to 1 if you want to use interrupt-out (or bulk out) endpoint 1.
+/* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints.
  * You must implement the function usbFunctionWriteOut() which receives all
- * interrupt/bulk data sent to endpoint 1.
+ * interrupt/bulk data sent to any endpoint other than 0. The endpoint number
+ * can be found in 'usbRxToken'.
  */
 #define USB_CFG_HAVE_FLOWCONTROL        0
 /* Define this to 1 if you want flowcontrol over USB data. See the definition
  * of the macros usbDisableAllRequests() and usbEnableAllRequests() in
  * usbdrv.h.
  */
+#define USB_CFG_LONG_TRANSFERS          0
+/* Define this to 1 if you want to send/receive blocks of more than 254 bytes
+ * in a single control-in or control-out transfer. Note that the capability
+ * for long transfers increases the driver size.
+ */
+/* #define USB_RX_USER_HOOK(data, len)     if(usbRxToken == (uchar)USBPID_SETUP) blinkLED(); */
+/* This macro is a hook if you want to do unconventional things. If it is
+ * defined, it's inserted at the beginning of received message processing.
+ * If you eat the received message and don't want default processing to
+ * proceed, do a return after doing your things. One possible application
+ * (besides debugging) is to flash a status LED on each packet.
+ */
+/* #define USB_RESET_HOOK(resetStarts)     if(!resetStarts){hadUsbReset();} */
+/* This macro is a hook if you need to know when an USB RESET occurs. It has
+ * one parameter which distinguishes between the start of RESET state and its
+ * end.
+ */
+/* #define USB_SET_ADDRESS_HOOK()              hadAddressAssigned(); */
+/* This macro (if defined) is executed when a USB SET_ADDRESS request was
+ * received.
+ */
+#define USB_COUNT_SOF                   0
+/* define this macro to 1 if you need the global variable "usbSofCount" which
+ * counts SOF packets. This feature requires that the hardware interrupt is
+ * connected to D- instead of D+.
+ */
+/* #ifdef __ASSEMBLER__
+ * macro myAssemblerMacro
+ *     in      YL, TCNT0
+ *     sts     timer0Snapshot, YL
+ *     endm
+ * #endif
+ * #define USB_SOF_HOOK                    myAssemblerMacro
+ * This macro (if defined) is executed in the assembler module when a
+ * Start Of Frame condition is detected. It is recommended to define it to
+ * the name of an assembler macro which is defined here as well so that more
+ * than one assembler instruction can be used. The macro may use the register
+ * YL and modify SREG. If it lasts longer than a couple of cycles, USB messages
+ * immediately after an SOF pulse may be lost and must be retried by the host.
+ * What can you do with this hook? Since the SOF signal occurs exactly every
+ * 1 ms (unless the host is in sleep mode), you can use it to tune OSCCAL in
+ * designs running on the internal RC oscillator.
+ * Please note that Start Of Frame detection works only if D- is wired to the
+ * interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES!
+ */
+#define USB_CFG_CHECK_DATA_TOGGLING     0
+/* define this macro to 1 if you want to filter out duplicate data packets
+ * sent by the host. Duplicates occur only as a consequence of communication
+ * errors, when the host does not receive an ACK. Please note that you need to
+ * implement the filtering yourself in usbFunctionWriteOut() and
+ * usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable
+ * for each control- and out-endpoint to check for duplicate packets.
+ */
+#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH   0
+/* define this macro to 1 if you want the function usbMeasureFrameLength()
+ * compiled in. This function can be used to calibrate the AVR's RC oscillator.
+ */
 
 /* -------------------------- Device Description --------------------------- */
 
 #define  USB_CFG_VENDOR_ID       0xc0, 0x16
 /* USB vendor ID for the device, low byte first. If you have registered your
- * own Vendor ID, define it here. Otherwise you use obdev's free shared
- * VID/PID pair. Be sure to read USBID-License.txt for rules!
- * This template uses obdev's shared VID/PID pair for HIDs: 0x16c0/0x5df.
- * Use this VID/PID pair ONLY if you understand the implications!
+ * own Vendor ID, define it here. Otherwise you use one of obdev's free shared
+ * VID/PID pairs. Be sure to read USBID-License.txt for rules!
+ * + This template uses obdev's shared VID/PID pair: 0x16c0/0x5dc.
+ * + Use this VID/PID pair ONLY if you understand the implications!
  */
-#define  USB_CFG_DEVICE_ID       0xdf, 0x05
+#define  USB_CFG_DEVICE_ID       0xdc, 0x05
 /* This is the ID of the product, low byte first. It is interpreted in the
  * scope of the vendor ID. If you have registered your own VID with usb.org
  * or if you have licensed a PID from somebody else, define it here. Otherwise
  * you use obdev's free shared VID/PID pair. Be sure to read the rules in
  * USBID-License.txt!
- * This template uses obdev's shared VID/PID pair for HIDs: 0x16c0/0x5df.
- * Use this VID/PID pair ONLY if you understand the implications!
+ * + This template uses obdev's shared VID/PID pair: 0x16c0/0x5dc.
+ * + Use this VID/PID pair ONLY if you understand the implications!
  */
 #define USB_CFG_DEVICE_VERSION  0x00, 0x01
 /* Version number of the device: Minor number first, then major number.
  */
-#define USB_CFG_VENDOR_NAME     'w', 'w', 'w', '.', 'o', 'b', 'd', 'e', 'v', '.', 'a', 't'
-#define USB_CFG_VENDOR_NAME_LEN 12
+#define USB_CFG_VENDOR_NAME     'o', 'b', 'd', 'e', 'v', '.', 'a', 't'
+#define USB_CFG_VENDOR_NAME_LEN 8
 /* These two values define the vendor name returned by the USB device. The name
  * must be given as a list of characters under single quotes. The characters
  * are interpreted as Unicode (UTF-16) entities.
@@ -158,23 +242,23 @@ rename it to "usbconfig.h". Then edit it accordingly.
  * to fine tune control over USB descriptors such as the string descriptor
  * for the serial number.
  */
-#define USB_CFG_DEVICE_CLASS        0
+#define USB_CFG_DEVICE_CLASS        0xff    /* set to 0 if deferred to interface */
 #define USB_CFG_DEVICE_SUBCLASS     0
 /* See USB specification if you want to conform to an existing device class.
+ * Class 0xff is "vendor specific".
  */
-#define USB_CFG_INTERFACE_CLASS     3   /* HID */
+#define USB_CFG_INTERFACE_CLASS     0   /* define class here if not at device level */
 #define USB_CFG_INTERFACE_SUBCLASS  0
 #define USB_CFG_INTERFACE_PROTOCOL  0
 /* See USB specification if you want to conform to an existing device class or
- * protocol.
- * This template defines a HID class device. If you implement a vendor class
- * device, set USB_CFG_INTERFACE_CLASS to 0 and USB_CFG_DEVICE_CLASS to 0xff.
+ * protocol. The following classes must be set at interface level:
+ * HID class is 3, no subclass and protocol required (but may be useful!)
+ * CDC class is 2, use subclass 2 and protocol 1 for ACM
  */
-#define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    42  /* total length of report descriptor */
+/* #define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    42 */
 /* Define this to the length of the HID report descriptor, if you implement
  * an HID device. Otherwise don't define it or define it to 0.
- * Since this template defines a HID device, it must also specify a HID
- * report descriptor length. You must add a PROGMEM character array named
+ * If you use this define, you must add a PROGMEM character array named
  * "usbHidReportDescriptor" to your code which contains the report descriptor.
  * Don't forget to keep the array and this define in sync!
  */
@@ -194,7 +278,9 @@ rename it to "usbconfig.h". Then edit it accordingly.
  * no properties are defined or if they are 0, the default descriptor is used.
  * Possible properties are:
  *   + USB_PROP_IS_DYNAMIC: The data for the descriptor should be fetched
- *     at runtime via usbFunctionDescriptor().
+ *     at runtime via usbFunctionDescriptor(). If the usbMsgPtr mechanism is
+ *     used, the data is in FLASH by default. Add property USB_PROP_IS_RAM if
+ *     you want RAM pointers.
  *   + USB_PROP_IS_RAM: The data returned by usbFunctionDescriptor() or found
  *     in static memory is in RAM, not in flash memory.
  *   + USB_PROP_LENGTH(len): If the data is in static memory (RAM or flash),
@@ -226,6 +312,12 @@ rename it to "usbconfig.h". Then edit it accordingly.
  *   USB_CFG_DESCR_PROPS_HID_REPORT
  *   USB_CFG_DESCR_PROPS_UNKNOWN (for all descriptors not handled by the driver)
  *
+ * Note about string descriptors: String descriptors are not just strings, they
+ * are Unicode strings prefixed with a 2 byte header. Example:
+ * int  serialNumberDescriptor[] = {
+ *     USB_STRING_DESCRIPTOR_HEADER(6),
+ *     'S', 'e', 'r', 'i', 'a', 'l'
+ * };
  */
 
 #define USB_CFG_DESCR_PROPS_DEVICE                  0
@@ -254,5 +346,6 @@ rename it to "usbconfig.h". Then edit it accordingly.
 /* #define USB_INTR_ENABLE_BIT     INT0 */
 /* #define USB_INTR_PENDING        GIFR */
 /* #define USB_INTR_PENDING_BIT    INTF0 */
+/* #define USB_INTR_VECTOR         SIG_INTERRUPT0 */
 
 #endif /* __usbconfig_h_included__ */
diff --git a/firmware/usbdrv/usbdrv.c b/firmware/usbdrv/usbdrv.c
index 04603bd37..02ffed64f 100644
--- a/firmware/usbdrv/usbdrv.c
+++ b/firmware/usbdrv/usbdrv.c
@@ -4,15 +4,11 @@
  * Creation Date: 2004-12-29
  * Tabsize: 4
  * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: usbdrv.c 350 2007-06-13 11:43:16Z cs $
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbdrv.c 692 2008-11-07 15:07:40Z cs $
  */
 
-#include "iarcompat.h"
-#ifndef __IAR_SYSTEMS_ICC__
-#   include <avr/io.h>
-#   include <avr/pgmspace.h>
-#endif
+#include "usbportability.h"
 #include "usbdrv.h"
 #include "oddebug.h"
 
@@ -22,14 +18,6 @@ This module implements the C-part of the USB driver. See usbdrv.h for a
 documentation of the entire driver.
 */
 
-#ifndef IAR_SECTION
-#define IAR_SECTION(arg)
-#define __no_init
-#endif
-/* The macro IAR_SECTION is a hack to allow IAR-cc compatibility. On gcc, it
- * is defined to nothing. __no_init is required on IAR.
- */
-
 /* ------------------------------------------------------------------------- */
 
 /* raw USB registers / interface to assembler code: */
@@ -39,38 +27,40 @@ uchar       usbDeviceAddr;      /* assigned during enumeration, defaults to 0 */
 uchar       usbNewDeviceAddr;   /* device ID which should be set after status phase */
 uchar       usbConfiguration;   /* currently selected configuration. Administered by driver, but not used */
 volatile schar usbRxLen;        /* = 0; number of bytes in usbRxBuf; 0 means free, -1 for flow control */
-uchar       usbCurrentTok;      /* last token received, if more than 1 rx endpoint: MSb=endpoint */
-uchar       usbRxToken;         /* token for data we received; if more than 1 rx endpoint: MSb=endpoint */
-uchar       usbMsgLen = 0xff;   /* remaining number of bytes, no msg to send if -1 (see usbMsgPtr) */
+uchar       usbCurrentTok;      /* last token received or endpoint number for last OUT token if != 0 */
+uchar       usbRxToken;         /* token for data we received; or endpont number for last OUT */
 volatile uchar usbTxLen = USBPID_NAK;   /* number of bytes to transmit with next IN token or handshake token */
 uchar       usbTxBuf[USB_BUFSIZE];/* data to transmit with next IN, free if usbTxLen contains handshake token */
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-volatile uchar usbTxLen1 = USBPID_NAK;  /* TX count for endpoint 1 */
-uchar       usbTxBuf1[USB_BUFSIZE];     /* TX data for endpoint 1 */
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-volatile uchar usbTxLen3 = USBPID_NAK;  /* TX count for endpoint 1 */
-uchar       usbTxBuf3[USB_BUFSIZE];     /* TX data for endpoint 1 */
+#if USB_COUNT_SOF
+volatile uchar  usbSofCount;    /* incremented by assembler module every SOF */
+#endif
+#if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
+usbTxStatus_t  usbTxStatus1;
+#   if USB_CFG_HAVE_INTRIN_ENDPOINT3
+usbTxStatus_t  usbTxStatus3;
+#   endif
 #endif
+#if USB_CFG_CHECK_DATA_TOGGLING
+uchar       usbCurrentDataToken;/* when we check data toggling to ignore duplicate packets */
 #endif
 
 /* USB status registers / not shared with asm code */
-uchar           *usbMsgPtr;     /* data to transmit next -- ROM or RAM address */
-static uchar    usbMsgFlags;    /* flag values see below */
+uchar               *usbMsgPtr;     /* data to transmit next -- ROM or RAM address */
+static usbMsgLen_t  usbMsgLen = USB_NO_MSG; /* remaining number of bytes */
+static uchar        usbMsgFlags;    /* flag values see below */
 
-#define USB_FLG_TX_PACKET       (1<<0)
-/* Leave free 6 bits after TX_PACKET. This way we can increment usbMsgFlags to toggle TX_PACKET */
 #define USB_FLG_MSGPTR_IS_ROM   (1<<6)
-#define USB_FLG_USE_DEFAULT_RW  (1<<7)
+#define USB_FLG_USE_USER_RW     (1<<7)
 
 /*
 optimizing hints:
 - do not post/pre inc/dec integer values in operations
-- assign value of PRG_RDB() to register variables and don't use side effects in arg
+- assign value of USB_READ_FLASH() to register variables and don't use side effects in arg
 - use narrow scope for variables which should be in X/Y/Z register
 - assign char sized expressions to variables to force 8 bit arithmetics
 */
 
-/* ------------------------------------------------------------------------- */
+/* -------------------------- String Descriptors --------------------------- */
 
 #if USB_CFG_DESCR_PROPS_STRINGS == 0
 
@@ -113,6 +103,8 @@ PROGMEM int usbDescriptorStringSerialNumber[] = {
 
 #endif  /* USB_CFG_DESCR_PROPS_STRINGS == 0 */
 
+/* --------------------------- Device Descriptor --------------------------- */
+
 #if USB_CFG_DESCR_PROPS_DEVICE == 0
 #undef USB_CFG_DESCR_PROPS_DEVICE
 #define USB_CFG_DESCR_PROPS_DEVICE  sizeof(usbDescriptorDevice)
@@ -124,8 +116,11 @@ PROGMEM char usbDescriptorDevice[] = {    /* USB device descriptor */
     USB_CFG_DEVICE_SUBCLASS,
     0,                      /* protocol */
     8,                      /* max packet size */
-    USB_CFG_VENDOR_ID,      /* 2 bytes */
-    USB_CFG_DEVICE_ID,      /* 2 bytes */
+    /* the following two casts affect the first byte of the constant only, but
+     * that's sufficient to avoid a warning with the default values.
+     */
+    (char)USB_CFG_VENDOR_ID,/* 2 bytes */
+    (char)USB_CFG_DEVICE_ID,/* 2 bytes */
     USB_CFG_DEVICE_VERSION, /* 2 bytes */
     USB_CFG_DESCR_PROPS_STRING_VENDOR != 0 ? 1 : 0,         /* manufacturer string index */
     USB_CFG_DESCR_PROPS_STRING_PRODUCT != 0 ? 2 : 0,        /* product string index */
@@ -134,6 +129,8 @@ PROGMEM char usbDescriptorDevice[] = {    /* USB device descriptor */
 };
 #endif
 
+/* ----------------------- Configuration Descriptor ------------------------ */
+
 #if USB_CFG_DESCR_PROPS_HID_REPORT != 0 && USB_CFG_DESCR_PROPS_HID == 0
 #undef USB_CFG_DESCR_PROPS_HID
 #define USB_CFG_DESCR_PROPS_HID     9   /* length of HID descriptor in config descriptor below */
@@ -145,15 +142,16 @@ PROGMEM char usbDescriptorDevice[] = {    /* USB device descriptor */
 PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor */
     9,          /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */
     USBDESCR_CONFIG,    /* descriptor type */
-    18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + (USB_CFG_DESCR_PROPS_HID & 0xff), 0,
+    18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 +
+                (USB_CFG_DESCR_PROPS_HID & 0xff), 0,
                 /* total length of data returned (including inlined descriptors) */
     1,          /* number of interfaces in this configuration */
     1,          /* index of this configuration */
     0,          /* configuration name string index */
 #if USB_CFG_IS_SELF_POWERED
-    USBATTR_SELFPOWER,  /* attributes */
+    USBATTR_SELFPOWER,      /* attributes */
 #else
-    USBATTR_BUSPOWER,   /* attributes */
+    (char)USBATTR_BUSPOWER, /* attributes */
 #endif
     USB_CFG_MAX_BUS_POWER/2,            /* max USB current in 2mA units */
 /* interface descriptor follows inline: */
@@ -161,7 +159,7 @@ PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor
     USBDESCR_INTERFACE, /* descriptor type */
     0,          /* index of this interface */
     0,          /* alternate setting for this interface */
-    USB_CFG_HAVE_INTRIN_ENDPOINT,   /* endpoints excl 0: number of endpoint descriptors to follow */
+    USB_CFG_HAVE_INTRIN_ENDPOINT + USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */
     USB_CFG_INTERFACE_CLASS,
     USB_CFG_INTERFACE_SUBCLASS,
     USB_CFG_INTERFACE_PROTOCOL,
@@ -178,7 +176,15 @@ PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor
 #if USB_CFG_HAVE_INTRIN_ENDPOINT    /* endpoint descriptor for endpoint 1 */
     7,          /* sizeof(usbDescrEndpoint) */
     USBDESCR_ENDPOINT,  /* descriptor type = endpoint */
-    0x81,       /* IN endpoint number 1 */
+    (char)0x81, /* IN endpoint number 1 */
+    0x03,       /* attrib: Interrupt endpoint */
+    8, 0,       /* maximum packet size */
+    USB_CFG_INTR_POLL_INTERVAL, /* in ms */
+#endif
+#if USB_CFG_HAVE_INTRIN_ENDPOINT3   /* endpoint descriptor for endpoint 3 */
+    7,          /* sizeof(usbDescrEndpoint) */
+    USBDESCR_ENDPOINT,  /* descriptor type = endpoint */
+    (char)0x83, /* IN endpoint number 1 */
     0x03,       /* attrib: Interrupt endpoint */
     8, 0,       /* maximum packet size */
     USB_CFG_INTR_POLL_INTERVAL, /* in ms */
@@ -186,304 +192,372 @@ PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor
 };
 #endif
 
-/* We don't use prog_int or prog_int16_t for compatibility with various libc
- * versions. Here's an other compatibility hack:
- */
-#ifndef PRG_RDB
-#define PRG_RDB(addr)   pgm_read_byte(addr)
-#endif
-
-typedef union{
-    unsigned    word;
-    uchar       *ptr;
-    uchar       bytes[2];
-}converter_t;
-/* We use this union to do type conversions. This is better optimized than
- * type casts in gcc 3.4.3 and much better than using bit shifts to build
- * ints from chars. Byte ordering is not a problem on an 8 bit platform.
- */
+/* ------------------------------------------------------------------------- */
+
+static inline void  usbResetDataToggling(void)
+{
+#if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
+    USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN);  /* reset data toggling for interrupt endpoint */
+#   if USB_CFG_HAVE_INTRIN_ENDPOINT3
+    USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN);  /* reset data toggling for interrupt endpoint */
+#   endif
+#endif
+}
+
+static inline void  usbResetStall(void)
+{
+#if USB_CFG_IMPLEMENT_HALT && USB_CFG_HAVE_INTRIN_ENDPOINT
+        usbTxLen1 = USBPID_NAK;
+#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+        usbTxLen3 = USBPID_NAK;
+#endif
+#endif
+}
 
 /* ------------------------------------------------------------------------- */
 
+#if !USB_CFG_SUPPRESS_INTR_CODE
 #if USB_CFG_HAVE_INTRIN_ENDPOINT
-USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len)
+static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus)
 {
-uchar       *p, i;
+uchar   *p;
+char    i;
 
 #if USB_CFG_IMPLEMENT_HALT
     if(usbTxLen1 == USBPID_STALL)
         return;
 #endif
-#if 0   /* No runtime checks! Caller is responsible for valid data! */
-    if(len > 8) /* interrupt transfers are limited to 8 bytes */
-        len = 8;
-#endif
-    if(usbTxLen1 & 0x10){   /* packet buffer was empty */
-        usbTxBuf1[0] ^= USBPID_DATA0 ^ USBPID_DATA1;    /* toggle token */
+    if(txStatus->len & 0x10){   /* packet buffer was empty */
+        txStatus->buffer[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* toggle token */
     }else{
-        usbTxLen1 = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */
+        txStatus->len = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */
     }
-    p = usbTxBuf1 + 1;
-    for(i=len;i--;)
+    p = txStatus->buffer + 1;
+    i = len;
+    do{                         /* if len == 0, we still copy 1 byte, but that's no problem */
         *p++ = *data++;
-    usbCrc16Append(&usbTxBuf1[1], len);
-    usbTxLen1 = len + 4;    /* len must be given including sync byte */
-    DBG2(0x21, usbTxBuf1, len + 3);
+    }while(--i > 0);            /* loop control at the end is 2 bytes shorter than at beginning */
+    usbCrc16Append(&txStatus->buffer[1], len);
+    txStatus->len = len + 4;    /* len must be given including sync byte */
+    DBG2(0x21 + (((int)txStatus >> 3) & 3), txStatus->buffer, len + 3);
+}
+
+USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len)
+{
+    usbGenericSetInterrupt(data, len, &usbTxStatus1);
 }
 #endif
 
 #if USB_CFG_HAVE_INTRIN_ENDPOINT3
 USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len)
 {
-uchar       *p, i;
-
-    if(usbTxLen3 & 0x10){   /* packet buffer was empty */
-        usbTxBuf3[0] ^= USBPID_DATA0 ^ USBPID_DATA1;    /* toggle token */
-    }else{
-        usbTxLen3 = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */
-    }
-    p = usbTxBuf3 + 1;
-    for(i=len;i--;)
-        *p++ = *data++;
-    usbCrc16Append(&usbTxBuf3[1], len);
-    usbTxLen3 = len + 4;    /* len must be given including sync byte */
-    DBG2(0x23, usbTxBuf3, len + 3);
+    usbGenericSetInterrupt(data, len, &usbTxStatus3);
 }
 #endif
+#endif /* USB_CFG_SUPPRESS_INTR_CODE */
 
+/* ------------------ utilities for code following below ------------------- */
 
-static uchar usbRead(uchar *data, uchar len)
-{
-#if USB_CFG_IMPLEMENT_FN_READ
-    if(usbMsgFlags & USB_FLG_USE_DEFAULT_RW){
-#endif
-        uchar i = len, *r = usbMsgPtr;
-        if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){    /* ROM data */
-            while(i--){
-                uchar c = PRG_RDB(r);    /* assign to char size variable to enforce byte ops */
-                *data++ = c;
-                r++;
-            }
-        }else{                  /* RAM data */
-            while(i--)
-                *data++ = *r++;
-        }
-        usbMsgPtr = r;
-        return len;
-#if USB_CFG_IMPLEMENT_FN_READ
-    }else{
-        if(len != 0)    /* don't bother app with 0 sized reads */
-            return usbFunctionRead(data, len);
-        return 0;
-    }
+/* Use defines for the switch statement so that we can choose between an
+ * if()else if() and a switch/case based implementation. switch() is more
+ * efficient for a LARGE set of sequential choices, if() is better in all other
+ * cases.
+ */
+#if USB_CFG_USE_SWITCH_STATEMENT
+#   define SWITCH_START(cmd)       switch(cmd){{
+#   define SWITCH_CASE(value)      }break; case (value):{
+#   define SWITCH_CASE2(v1,v2)     }break; case (v1): case(v2):{
+#   define SWITCH_CASE3(v1,v2,v3)  }break; case (v1): case(v2): case(v3):{
+#   define SWITCH_DEFAULT          }break; default:{
+#   define SWITCH_END              }}
+#else
+#   define SWITCH_START(cmd)       {uchar _cmd = cmd; if(0){
+#   define SWITCH_CASE(value)      }else if(_cmd == (value)){
+#   define SWITCH_CASE2(v1,v2)     }else if(_cmd == (v1) || _cmd == (v2)){
+#   define SWITCH_CASE3(v1,v2,v3)  }else if(_cmd == (v1) || _cmd == (v2) || (_cmd == v3)){
+#   define SWITCH_DEFAULT          }else{
+#   define SWITCH_END              }}
 #endif
-}
 
+#ifndef USB_RX_USER_HOOK
+#define USB_RX_USER_HOOK(data, len)
+#endif
+#ifndef USB_SET_ADDRESS_HOOK
+#define USB_SET_ADDRESS_HOOK()
+#endif
+
+/* ------------------------------------------------------------------------- */
 
+/* We use if() instead of #if in the macro below because #if can't be used
+ * in macros and the compiler optimizes constant conditions anyway.
+ * This may cause problems with undefined symbols if compiled without
+ * optimizing!
+ */
 #define GET_DESCRIPTOR(cfgProp, staticName)         \
     if(cfgProp){                                    \
         if((cfgProp) & USB_PROP_IS_RAM)             \
-            flags &= ~USB_FLG_MSGPTR_IS_ROM;        \
+            flags = 0;                              \
         if((cfgProp) & USB_PROP_IS_DYNAMIC){        \
-            replyLen = usbFunctionDescriptor(rq);   \
+            len = usbFunctionDescriptor(rq);        \
         }else{                                      \
-            replyData = (uchar *)(staticName);      \
-            SET_REPLY_LEN((cfgProp) & 0xff);        \
+            len = USB_PROP_LENGTH(cfgProp);         \
+            usbMsgPtr = (uchar *)(staticName);      \
         }                                           \
     }
-/* We use if() instead of #if in the macro above because #if can't be used
- * in macros and the compiler optimizes constant conditions anyway.
+
+/* usbDriverDescriptor() is similar to usbFunctionDescriptor(), but used
+ * internally for all types of descriptors.
+ */
+static inline usbMsgLen_t usbDriverDescriptor(usbRequest_t *rq)
+{
+usbMsgLen_t len = 0;
+uchar       flags = USB_FLG_MSGPTR_IS_ROM;
+
+    SWITCH_START(rq->wValue.bytes[1])
+    SWITCH_CASE(USBDESCR_DEVICE)    /* 1 */
+        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice)
+    SWITCH_CASE(USBDESCR_CONFIG)    /* 2 */
+        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration)
+    SWITCH_CASE(USBDESCR_STRING)    /* 3 */
+#if USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC
+        if(USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_RAM)
+            flags = 0;
+        len = usbFunctionDescriptor(rq);
+#else   /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
+        SWITCH_START(rq->wValue.bytes[0])
+        SWITCH_CASE(0)
+            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0)
+        SWITCH_CASE(1)
+            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor)
+        SWITCH_CASE(2)
+            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice)
+        SWITCH_CASE(3)
+            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER, usbDescriptorStringSerialNumber)
+        SWITCH_DEFAULT
+            if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){
+                len = usbFunctionDescriptor(rq);
+            }
+        SWITCH_END
+#endif  /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
+#if USB_CFG_DESCR_PROPS_HID_REPORT  /* only support HID descriptors if enabled */
+    SWITCH_CASE(USBDESCR_HID)       /* 0x21 */
+        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID, usbDescriptorConfiguration + 18)
+    SWITCH_CASE(USBDESCR_HID_REPORT)/* 0x22 */
+        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID_REPORT, usbDescriptorHidReport)
+#endif
+    SWITCH_DEFAULT
+        if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){
+            len = usbFunctionDescriptor(rq);
+        }
+    SWITCH_END
+    usbMsgFlags = flags;
+    return len;
+}
+
+/* ------------------------------------------------------------------------- */
+
+/* usbDriverSetup() is similar to usbFunctionSetup(), but it's used for
+ * standard requests instead of class and custom requests.
  */
+static inline usbMsgLen_t usbDriverSetup(usbRequest_t *rq)
+{
+uchar   len  = 0, *dataPtr = usbTxBuf + 9;  /* there are 2 bytes free space at the end of the buffer */
+uchar   value = rq->wValue.bytes[0];
+#if USB_CFG_IMPLEMENT_HALT
+uchar   index = rq->wIndex.bytes[0];
+#endif
+
+    dataPtr[0] = 0; /* default reply common to USBRQ_GET_STATUS and USBRQ_GET_INTERFACE */
+    SWITCH_START(rq->bRequest)
+    SWITCH_CASE(USBRQ_GET_STATUS)           /* 0 */
+        uchar recipient = rq->bmRequestType & USBRQ_RCPT_MASK;  /* assign arith ops to variables to enforce byte size */
+        if(USB_CFG_IS_SELF_POWERED && recipient == USBRQ_RCPT_DEVICE)
+            dataPtr[0] =  USB_CFG_IS_SELF_POWERED;
+#if USB_CFG_IMPLEMENT_HALT
+        if(recipient == USBRQ_RCPT_ENDPOINT && index == 0x81)   /* request status for endpoint 1 */
+            dataPtr[0] = usbTxLen1 == USBPID_STALL;
+#endif
+        dataPtr[1] = 0;
+        len = 2;
+#if USB_CFG_IMPLEMENT_HALT
+    SWITCH_CASE2(USBRQ_CLEAR_FEATURE, USBRQ_SET_FEATURE)    /* 1, 3 */
+        if(value == 0 && index == 0x81){    /* feature 0 == HALT for endpoint == 1 */
+            usbTxLen1 = rq->bRequest == USBRQ_CLEAR_FEATURE ? USBPID_NAK : USBPID_STALL;
+            usbResetDataToggling();
+        }
+#endif
+    SWITCH_CASE(USBRQ_SET_ADDRESS)          /* 5 */
+        usbNewDeviceAddr = value;
+        USB_SET_ADDRESS_HOOK();
+    SWITCH_CASE(USBRQ_GET_DESCRIPTOR)       /* 6 */
+        len = usbDriverDescriptor(rq);
+        goto skipMsgPtrAssignment;
+    SWITCH_CASE(USBRQ_GET_CONFIGURATION)    /* 8 */
+        dataPtr = &usbConfiguration;  /* send current configuration value */
+        len = 1;
+    SWITCH_CASE(USBRQ_SET_CONFIGURATION)    /* 9 */
+        usbConfiguration = value;
+        usbResetStall();
+    SWITCH_CASE(USBRQ_GET_INTERFACE)        /* 10 */
+        len = 1;
+#if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
+    SWITCH_CASE(USBRQ_SET_INTERFACE)        /* 11 */
+        usbResetDataToggling();
+        usbResetStall();
+#endif
+    SWITCH_DEFAULT                          /* 7=SET_DESCRIPTOR, 12=SYNC_FRAME */
+        /* Should we add an optional hook here? */
+    SWITCH_END
+    usbMsgPtr = dataPtr;
+skipMsgPtrAssignment:
+    return len;
+}
 
+/* ------------------------------------------------------------------------- */
 
-/* Don't make this function static to avoid inlining.
- * The entire function would become too large and exceed the range of
- * relative jumps.
- * 2006-02-25: Either gcc 3.4.3 is better than the gcc used when the comment
- * above was written, or other parts of the code have changed. We now get
- * better results with an inlined function. Test condition: PowerSwitch code.
+/* usbProcessRx() is called for every message received by the interrupt
+ * routine. It distinguishes between SETUP and DATA packets and processes
+ * them accordingly.
  */
-static void usbProcessRx(uchar *data, uchar len)
+static inline void usbProcessRx(uchar *data, uchar len)
 {
 usbRequest_t    *rq = (void *)data;
-uchar           replyLen = 0, flags = USB_FLG_USE_DEFAULT_RW;
-/* We use if() cascades because the compare is done byte-wise while switch()
- * is int-based. The if() cascades are therefore more efficient.
- */
+
 /* usbRxToken can be:
- * 0x2d 00101101 (USBPID_SETUP for endpoint 0)
- * 0xe1 11100001 (USBPID_OUT for endpoint 0)
- * 0xff 11111111 (USBPID_OUT for endpoint 1)
+ * 0x2d 00101101 (USBPID_SETUP for setup data)
+ * 0xe1 11100001 (USBPID_OUT: data phase of setup transfer)
+ * 0...0x0f for OUT on endpoint X
  */
-    DBG2(0x10 + ((usbRxToken >> 1) & 3), data, len);    /* SETUP0=12; OUT0=10; OUT1=13 */
+    DBG2(0x10 + (usbRxToken & 0xf), data, len); /* SETUP=1d, SETUP-DATA=11, OUTx=1x */
+    USB_RX_USER_HOOK(data, len)
 #if USB_CFG_IMPLEMENT_FN_WRITEOUT
-    if(usbRxToken == 0xff){
+    if(usbRxToken < 0x10){  /* OUT to endpoint != 0: endpoint number in usbRxToken */
         usbFunctionWriteOut(data, len);
-        return; /* no reply expected, hence no usbMsgPtr, usbMsgFlags, usbMsgLen set */
+        return;
     }
 #endif
     if(usbRxToken == (uchar)USBPID_SETUP){
-        usbTxLen = USBPID_NAK;  /* abort pending transmit */
-        if(len == 8){   /* Setup size must be always 8 bytes. Ignore otherwise. */
-            uchar type = rq->bmRequestType & USBRQ_TYPE_MASK;
-            if(type == USBRQ_TYPE_STANDARD){
-                #define SET_REPLY_LEN(len)  replyLen = (len); usbMsgPtr = replyData
-                /* This macro ensures that replyLen and usbMsgPtr are always set in the same way.
-                 * That allows optimization of common code in if() branches */
-                uchar *replyData = usbTxBuf + 9; /* there is 3 bytes free space at the end of the buffer */
-                replyData[0] = 0;   /* common to USBRQ_GET_STATUS and USBRQ_GET_INTERFACE */
-                if(rq->bRequest == USBRQ_GET_STATUS){           /* 0 */
-                    uchar __attribute__((__unused__)) recipient = rq->bmRequestType & USBRQ_RCPT_MASK;  /* assign arith ops to variables to enforce byte size */
-#if USB_CFG_IS_SELF_POWERED
-                    if(recipient == USBRQ_RCPT_DEVICE)
-                        replyData[0] =  USB_CFG_IS_SELF_POWERED;
-#endif
-#if USB_CFG_HAVE_INTRIN_ENDPOINT && USB_CFG_IMPLEMENT_HALT
-                    if(recipient == USBRQ_RCPT_ENDPOINT && rq->wIndex.bytes[0] == 0x81)   /* request status for endpoint 1 */
-                        replyData[0] = usbTxLen1 == USBPID_STALL;
-#endif
-                    replyData[1] = 0;
-                    SET_REPLY_LEN(2);
-                }else if(rq->bRequest == USBRQ_SET_ADDRESS){    /* 5 */
-                    usbNewDeviceAddr = rq->wValue.bytes[0];
-                }else if(rq->bRequest == USBRQ_GET_DESCRIPTOR){ /* 6 */
-                    flags = USB_FLG_MSGPTR_IS_ROM | USB_FLG_USE_DEFAULT_RW;
-                    if(rq->wValue.bytes[1] == USBDESCR_DEVICE){ /* 1 */
-                        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice)
-                    }else if(rq->wValue.bytes[1] == USBDESCR_CONFIG){   /* 2 */
-                        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration)
-                    }else if(rq->wValue.bytes[1] == USBDESCR_STRING){   /* 3 */
-#if USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC
-                        if(USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_RAM)
-                            flags &= ~USB_FLG_MSGPTR_IS_ROM;
-                        replyLen = usbFunctionDescriptor(rq);
-#else   /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
-                        if(rq->wValue.bytes[0] == 0){   /* descriptor index */
-                            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0)
-                        }else if(rq->wValue.bytes[0] == 1){
-                            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor)
-                        }else if(rq->wValue.bytes[0] == 2){
-                            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice)
-                        }else if(rq->wValue.bytes[0] == 3){
-                            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER, usbDescriptorStringSerialNumber)
-                        }else if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){
-                            replyLen = usbFunctionDescriptor(rq);
-                        }
-#endif  /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
-                    }else if(rq->wValue.bytes[1] == USBDESCR_HID){          /* 0x21 */
-                        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID, usbDescriptorConfiguration + 18)
-                    }else if(rq->wValue.bytes[1] == USBDESCR_HID_REPORT){   /* 0x22 */
-                        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID_REPORT, usbDescriptorHidReport)
-                    }else if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){
-                        replyLen = usbFunctionDescriptor(rq);
-                    }
-                }else if(rq->bRequest == USBRQ_GET_CONFIGURATION){  /* 8 */
-                    replyData = &usbConfiguration;  /* send current configuration value */
-                    SET_REPLY_LEN(1);
-                }else if(rq->bRequest == USBRQ_SET_CONFIGURATION){  /* 9 */
-                    usbConfiguration = rq->wValue.bytes[0];
-#if USB_CFG_IMPLEMENT_HALT
-                    usbTxLen1 = USBPID_NAK;
-#endif
-                }else if(rq->bRequest == USBRQ_GET_INTERFACE){      /* 10 */
-                    SET_REPLY_LEN(1);
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-                }else if(rq->bRequest == USBRQ_SET_INTERFACE){      /* 11 */
-                    USB_SET_DATATOKEN1(USBPID_DATA0);   /* reset data toggling for interrupt endpoint */
-#   if USB_CFG_HAVE_INTRIN_ENDPOINT3
-                    USB_SET_DATATOKEN3(USBPID_DATA0);   /* reset data toggling for interrupt endpoint */
-#   endif
-#   if USB_CFG_IMPLEMENT_HALT
-                    usbTxLen1 = USBPID_NAK;
-                }else if(rq->bRequest == USBRQ_CLEAR_FEATURE || rq->bRequest == USBRQ_SET_FEATURE){   /* 1|3 */
-                    if(rq->wValue.bytes[0] == 0 && rq->wIndex.bytes[0] == 0x81){   /* feature 0 == HALT for endpoint == 1 */
-                        usbTxLen1 = rq->bRequest == USBRQ_CLEAR_FEATURE ? USBPID_NAK : USBPID_STALL;
-                        USB_SET_DATATOKEN1(USBPID_DATA0);   /* reset data toggling for interrupt endpoint */
-#       if USB_CFG_HAVE_INTRIN_ENDPOINT3
-                        USB_SET_DATATOKEN3(USBPID_DATA0);   /* reset data toggling for interrupt endpoint */
-#       endif
-                    }
-#   endif
-#endif
+        if(len != 8)    /* Setup size must be always 8 bytes. Ignore otherwise. */
+            return;
+        usbMsgLen_t replyLen;
+        usbTxBuf[0] = USBPID_DATA0;         /* initialize data toggling */
+        usbTxLen = USBPID_NAK;              /* abort pending transmit */
+        usbMsgFlags = 0;
+        uchar type = rq->bmRequestType & USBRQ_TYPE_MASK;
+        if(type != USBRQ_TYPE_STANDARD){    /* standard requests are handled by driver */
+            replyLen = usbFunctionSetup(data);
+        }else{
+            replyLen = usbDriverSetup(rq);
+        }
+#if USB_CFG_IMPLEMENT_FN_READ || USB_CFG_IMPLEMENT_FN_WRITE
+        if(replyLen == USB_NO_MSG){         /* use user-supplied read/write function */
+            /* do some conditioning on replyLen, but on IN transfers only */
+            if((rq->bmRequestType & USBRQ_DIR_MASK) != USBRQ_DIR_HOST_TO_DEVICE){
+                if(sizeof(replyLen) < sizeof(rq->wLength.word)){ /* help compiler with optimizing */
+                    replyLen = rq->wLength.bytes[0];
                 }else{
-                    /* the following requests can be ignored, send default reply */
-                    /* 1: CLEAR_FEATURE, 3: SET_FEATURE, 7: SET_DESCRIPTOR */
-                    /* 12: SYNCH_FRAME */
+                    replyLen = rq->wLength.word;
                 }
-                #undef SET_REPLY_LEN
-            }else{  /* not a standard request -- must be vendor or class request */
-                replyLen = usbFunctionSetup(data);
             }
-#if USB_CFG_IMPLEMENT_FN_READ || USB_CFG_IMPLEMENT_FN_WRITE
-            if(replyLen == 0xff){   /* use user-supplied read/write function */
-                if((rq->bmRequestType & USBRQ_DIR_MASK) == USBRQ_DIR_DEVICE_TO_HOST){
-                    replyLen = rq->wLength.bytes[0];    /* IN transfers only */
-                }
-                flags &= ~USB_FLG_USE_DEFAULT_RW;  /* we have no valid msg, use user supplied read/write functions */
-            }else   /* The 'else' prevents that we limit a replyLen of 0xff to the maximum transfer len. */
+            usbMsgFlags = USB_FLG_USE_USER_RW;
+        }else   /* The 'else' prevents that we limit a replyLen of USB_NO_MSG to the maximum transfer len. */
 #endif
-            if(!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0])  /* limit length to max */
+        if(sizeof(replyLen) < sizeof(rq->wLength.word)){ /* help compiler with optimizing */
+            if(!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0])    /* limit length to max */
                 replyLen = rq->wLength.bytes[0];
+        }else{
+            if(replyLen > rq->wLength.word)     /* limit length to max */
+                replyLen = rq->wLength.word;
         }
-        /* make sure that data packets which are sent as ACK to an OUT transfer are always zero sized */
-    }else{  /* DATA packet from out request */
+        usbMsgLen = replyLen;
+    }else{  /* usbRxToken must be USBPID_OUT, which means data phase of setup (control-out) */
 #if USB_CFG_IMPLEMENT_FN_WRITE
-        if(!(usbMsgFlags & USB_FLG_USE_DEFAULT_RW)){
+        if(usbMsgFlags & USB_FLG_USE_USER_RW){
             uchar rval = usbFunctionWrite(data, len);
-            replyLen = 0xff;
-            if(rval == 0xff){       /* an error occurred */
-                usbMsgLen = 0xff;   /* cancel potentially pending data packet for ACK */
+            if(rval == 0xff){   /* an error occurred */
                 usbTxLen = USBPID_STALL;
             }else if(rval != 0){    /* This was the final package */
-                replyLen = 0;       /* answer with a zero-sized data packet */
+                usbMsgLen = 0;  /* answer with a zero-sized data packet */
             }
-            flags = 0;    /* start with a DATA1 package, stay with user supplied write() function */
         }
 #endif
     }
-    usbMsgFlags = flags;
-    usbMsgLen = replyLen;
 }
 
 /* ------------------------------------------------------------------------- */
 
-static void usbBuildTxBlock(void)
+/* This function is similar to usbFunctionRead(), but it's also called for
+ * data handled automatically by the driver (e.g. descriptor reads).
+ */
+static uchar usbDeviceRead(uchar *data, uchar len)
 {
-uchar   wantLen, len, txLen, token;
+    if(len > 0){    /* don't bother app with 0 sized reads */
+#if USB_CFG_IMPLEMENT_FN_READ
+        if(usbMsgFlags & USB_FLG_USE_USER_RW){
+            len = usbFunctionRead(data, len);
+        }else
+#endif
+        {
+            uchar i = len, *r = usbMsgPtr;
+            if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){    /* ROM data */
+                do{
+                    uchar c = USB_READ_FLASH(r);    /* assign to char size variable to enforce byte ops */
+                    *data++ = c;
+                    r++;
+                }while(--i);
+            }else{  /* RAM data */
+                do{
+                    *data++ = *r++;
+                }while(--i);
+            }
+            usbMsgPtr = r;
+        }
+    }
+    return len;
+}
+
+/* ------------------------------------------------------------------------- */
+
+/* usbBuildTxBlock() is called when we have data to transmit and the
+ * interrupt routine's transmit buffer is empty.
+ */
+static inline void usbBuildTxBlock(void)
+{
+usbMsgLen_t wantLen;
+uchar       len;
 
     wantLen = usbMsgLen;
     if(wantLen > 8)
         wantLen = 8;
     usbMsgLen -= wantLen;
-    token = USBPID_DATA1;
-    if(usbMsgFlags & USB_FLG_TX_PACKET)
-        token = USBPID_DATA0;
-    usbMsgFlags++;
-    len = usbRead(usbTxBuf + 1, wantLen);
+    usbTxBuf[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* DATA toggling */
+    len = usbDeviceRead(usbTxBuf + 1, wantLen);
     if(len <= 8){           /* valid data packet */
         usbCrc16Append(&usbTxBuf[1], len);
-        txLen = len + 4;    /* length including sync byte */
-        if(len < 8)         /* a partial package identifies end of message */
-            usbMsgLen = 0xff;
+        len += 4;           /* length including sync byte */
+        if(len < 12)        /* a partial package identifies end of message */
+            usbMsgLen = USB_NO_MSG;
     }else{
-        txLen = USBPID_STALL;   /* stall the endpoint */
-        usbMsgLen = 0xff;
+        len = USBPID_STALL;   /* stall the endpoint */
+        usbMsgLen = USB_NO_MSG;
     }
-    usbTxBuf[0] = token;
-    usbTxLen = txLen;
-    DBG2(0x20, usbTxBuf, txLen-1);
+    usbTxLen = len;
+    DBG2(0x20, usbTxBuf, len-1);
 }
 
-static inline uchar isNotSE0(void)
+/* ------------------------------------------------------------------------- */
+
+static inline void usbHandleResetHook(uchar notResetState)
 {
-uchar   rval;
-/* We want to do
- *     return (USBIN & USBMASK);
- * here, but the compiler does int-expansion acrobatics.
- * We can avoid this by assigning to a char-sized variable.
- */
-    rval = USBIN & USBMASK;
-    return rval;
+#ifdef USB_RESET_HOOK
+static uchar    wasReset;
+uchar           isReset = !notResetState;
+
+    if(wasReset != isReset){
+        USB_RESET_HOOK(isReset);
+        wasReset = isReset;
+    }
+#endif
 }
 
 /* ------------------------------------------------------------------------- */
@@ -493,14 +567,15 @@ USB_PUBLIC void usbPoll(void)
 schar   len;
 uchar   i;
 
-    if((len = usbRxLen) > 0){
+    len = usbRxLen - 3;
+    if(len >= 0){
 /* We could check CRC16 here -- but ACK has already been sent anyway. If you
  * need data integrity checks with this driver, check the CRC in your app
  * code and report errors back to the host. Since the ACK was already sent,
  * retries must be handled on application level.
  * unsigned crc = usbCrc16(buffer + 1, usbRxLen - 3);
  */
-        usbProcessRx(usbRxBuf + USB_BUFSIZE + 1 - usbInputBufOffset, len - 3);
+        usbProcessRx(usbRxBuf + USB_BUFSIZE + 1 - usbInputBufOffset, len);
 #if USB_CFG_HAVE_FLOWCONTROL
         if(usbRxLen > 0)    /* only mark as available if not inactivated */
             usbRxLen = 0;
@@ -508,26 +583,23 @@ uchar   i;
         usbRxLen = 0;       /* mark rx buffer as available */
 #endif
     }
-    if(usbTxLen & 0x10){ /* transmit system idle */
-        if(usbMsgLen != 0xff){  /* transmit data pending? */
+    if(usbTxLen & 0x10){    /* transmit system idle */
+        if(usbMsgLen != USB_NO_MSG){    /* transmit data pending? */
             usbBuildTxBlock();
         }
     }
-    for(i = 10; i > 0; i--){
-        if(isNotSE0())
-            break;
-    }
-    if(i == 0){ /* RESET condition, called multiple times during reset */
-        usbNewDeviceAddr = 0;
-        usbDeviceAddr = 0;
-#if USB_CFG_IMPLEMENT_HALT
-        usbTxLen1 = USBPID_NAK;
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-        usbTxLen3 = USBPID_NAK;
-#endif
-#endif
-        DBG1(0xff, 0, 0);
+    for(i = 20; i > 0; i--){
+        uchar usbLineStatus = USBIN & USBMASK;
+        if(usbLineStatus != 0)  /* SE0 has ended */
+            goto isNotReset;
     }
+    /* RESET condition, called multiple times during reset */
+    usbNewDeviceAddr = 0;
+    usbDeviceAddr = 0;
+    usbResetStall();
+    DBG1(0xff, 0, 0);
+isNotReset:
+    usbHandleResetHook(i);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -541,11 +613,12 @@ USB_PUBLIC void usbInit(void)
     USB_INTR_CFG &= ~(USB_INTR_CFG_CLR);
 #endif
     USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT);
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-    USB_SET_DATATOKEN1(USBPID_DATA0);   /* reset data toggling for interrupt endpoint */
-#   if USB_CFG_HAVE_INTRIN_ENDPOINT3
-    USB_SET_DATATOKEN3(USBPID_DATA0);   /* reset data toggling for interrupt endpoint */
-#   endif
+    usbResetDataToggling();
+#if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
+    usbTxLen1 = USBPID_NAK;
+#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+    usbTxLen3 = USBPID_NAK;
+#endif
 #endif
 }
 
diff --git a/firmware/usbdrv/usbdrv.h b/firmware/usbdrv/usbdrv.h
index 94085762d..0ae387169 100644
--- a/firmware/usbdrv/usbdrv.h
+++ b/firmware/usbdrv/usbdrv.h
@@ -4,33 +4,38 @@
  * Creation Date: 2004-12-29
  * Tabsize: 4
  * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: usbdrv.h 375 2007-07-07 12:01:52Z cs $
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbdrv.h 697 2008-11-26 17:24:43Z cs $
  */
 
 #ifndef __usbdrv_h_included__
 #define __usbdrv_h_included__
 #include "usbconfig.h"
-#include "iarcompat.h"
+#include "usbportability.h"
 
 /*
 Hardware Prerequisites:
 =======================
-USB lines D+ and D- MUST be wired to the same I/O port. D+ must (also) be
-connected to INT0. D- requires a pullup of 1.5k to +3.5V (and the device
-must be powered at 3.5V) to identify as low-speed USB device. A pullup of
-1M SHOULD be connected from D+ to +3.5V to prevent interference when no USB
-master is connected. We use D+ as interrupt source and not D- because it
-does not trigger on keep-alive and RESET states.
-
-As a compile time option, the 1.5k pullup resistor on D- can be made
+USB lines D+ and D- MUST be wired to the same I/O port. We recommend that D+
+triggers the interrupt (best achieved by using INT0 for D+), but it is also
+possible to trigger the interrupt from D-. If D- is used, interrupts are also
+triggered by SOF packets. D- requires a pull-up of 1.5k to +3.5V (and the
+device must be powered at 3.5V) to identify as low-speed USB device. A
+pull-down or pull-up of 1M SHOULD be connected from D+ to +3.5V to prevent
+interference when no USB master is connected. If you use Zener diodes to limit
+the voltage on D+ and D-, you MUST use a pull-down resistor, not a pull-up.
+We use D+ as interrupt source and not D- because it does not trigger on
+keep-alive and RESET states. If you want to count keep-alive events with
+USB_COUNT_SOF, you MUST use D- as an interrupt source.
+
+As a compile time option, the 1.5k pull-up resistor on D- can be made
 switchable to allow the device to disconnect at will. See the definition of
 usbDeviceConnect() and usbDeviceDisconnect() further down in this file.
 
 Please adapt the values in usbconfig.h according to your hardware!
 
-The device MUST be clocked at exactly 12 MHz or 16 MHz or at 16.5 MHz +/- 1%.
-See usbconfig-prototype.h for details.
+The device MUST be clocked at exactly 12 MHz, 15 MHz, 16 MHz or 20 MHz
+or at 12.8 MHz resp. 16.5 MHz +/- 1%. See usbconfig-prototype.h for details.
 
 
 Limitations:
@@ -53,16 +58,26 @@ bit rate over the same hardware, we should be on the safe side. Even the spec
 requires detection of asymmetric states at high bit rate for SE0 detection.
 
 Number of endpoints:
-The driver supports up to four endpoints: One control endpoint (endpoint 0),
-two interrupt-in (or bulk-in) endpoints (endpoint 1 and 3) and one
-interrupt-out (or bulk-out) endpoint (endpoint 1). Please note that the USB
-standard forbids bulk endpoints for low speed devices! Most operating systems
-allow them anyway, but the AVR will spend 90% of the CPU time in the USB
-interrupt polling for bulk data.
-By default, only the control endpoint 0 is enabled. To get the other endpoints,
-define USB_CFG_HAVE_INTRIN_ENDPOINT, USB_CFG_HAVE_INTRIN_ENDPOINT3 and/or
-USB_CFG_IMPLEMENT_FN_WRITEOUT respectively (see usbconfig-prototype.h for
-details).
+The driver supports the following endpoints:
+
+- Endpoint 0, the default control endpoint.
+- Any number of interrupt- or bulk-out endpoints. The data is sent to
+  usbFunctionWriteOut() and USB_CFG_IMPLEMENT_FN_WRITEOUT must be defined
+  to 1 to activate this feature. The endpoint number can be found in the
+  global variable 'usbRxToken'.
+- One default interrupt- or bulk-in endpoint. This endpoint is used for
+  interrupt- or bulk-in transfers which are not handled by any other endpoint.
+  You must define USB_CFG_HAVE_INTRIN_ENDPOINT in order to activate this
+  feature and call usbSetInterrupt() to send interrupt/bulk data.
+- One additional interrupt- or bulk-in endpoint. This was endpoint 3 in
+  previous versions of this driver but can now be configured to any endpoint
+  number. You must define USB_CFG_HAVE_INTRIN_ENDPOINT3 in order to activate
+  this feature and call usbSetInterrupt3() to send interrupt/bulk data. The
+  endpoint number can be set with USB_CFG_EP3_NUMBER.
+
+Please note that the USB standard forbids bulk endpoints for low speed devices!
+Most operating systems allow them anyway, but the AVR will spend 90% of the CPU
+time in the USB interrupt polling for bulk data.
 
 Maximum data payload:
 Data payload of control in and out transfers may be up to 254 bytes. In order
@@ -76,22 +91,23 @@ bus power anyway. Bus-powered devices can achieve this only by putting the
 CPU in sleep mode. The driver does not implement suspend handling by itself.
 However, the application may implement activity monitoring and wakeup from
 sleep. The host sends regular SE0 states on the bus to keep it active. These
-SE0 states can be detected by wiring the INT1 pin to D-. It is not necessary
-to enable the interrupt, checking the interrupt pending flag should suffice.
-Before entering sleep mode, the application should enable INT1 for a wakeup
-on the next bus activity.
+SE0 states can be detected by using D- as the interrupt source. Define
+USB_COUNT_SOF to 1 and use the global variable usbSofCount to check for bus
+activity.
 
 Operation without an USB master:
 The driver behaves neutral without connection to an USB master if D- reads
 as 1. To avoid spurious interrupts, we recommend a high impedance (e.g. 1M)
-pullup resistor on D+. If D- becomes statically 0, the driver may block in
-the interrupt routine.
+pull-down or pull-up resistor on D+ (interrupt). If Zener diodes are used,
+use a pull-down. If D- becomes statically 0, the driver may block in the
+interrupt routine.
 
 Interrupt latency:
 The application must ensure that the USB interrupt is not disabled for more
-than 20 cycles. This implies that all interrupt routines must either be
-declared as "INTERRUPT" instead of "SIGNAL" (see "avr/signal.h") or that they
-are written in assembler with "sei" as the first instruction.
+than 25 cycles (this is for 12 MHz, faster clocks allow longer latency).
+This implies that all interrupt routines must either be declared as "INTERRUPT"
+instead of "SIGNAL" (see "avr/signal.h") or that they are written in assembler
+with "sei" as the first instruction.
 
 Maximum interrupt duration / CPU cycle consumption:
 The driver handles all USB communication during the interrupt service
@@ -106,7 +122,7 @@ USB messages, even if they address another (low-speed) device on the same bus.
 /* --------------------------- Module Interface ---------------------------- */
 /* ------------------------------------------------------------------------- */
 
-#define USBDRV_VERSION  20070707
+#define USBDRV_VERSION  20081126
 /* This define uniquely identifies a driver version. It is a decimal number
  * constructed from the driver's release date in the form YYYYMMDD. If the
  * driver's behavior or interface changes, you can use this constant to
@@ -134,6 +150,19 @@ USB messages, even if they address another (low-speed) device on the same bus.
 #endif
 /* shortcuts for well defined 8 bit integer types */
 
+#if USB_CFG_LONG_TRANSFERS  /* if more than 254 bytes transfer size required */
+#   define usbMsgLen_t unsigned
+#else
+#   define usbMsgLen_t uchar
+#endif
+/* usbMsgLen_t is the data type used for transfer lengths. By default, it is
+ * defined to uchar, allowing a maximum of 254 bytes (255 is reserved for
+ * USB_NO_MSG below). If the usbconfig.h defines USB_CFG_LONG_TRANSFERS to 1,
+ * a 16 bit data type is used, allowing up to 16384 bytes (the rest is used
+ * for flags in the descriptor configuration).
+ */
+#define USB_NO_MSG  ((usbMsgLen_t)-1)   /* constant meaning "no message" */
+
 struct usbRequest;  /* forward declaration */
 
 USB_PUBLIC void usbInit(void);
@@ -152,7 +181,7 @@ extern uchar *usbMsgPtr;
  * implementation of usbFunctionWrite(). It is also used internally by the
  * driver for standard control requests.
  */
-USB_PUBLIC uchar usbFunctionSetup(uchar data[8]);
+USB_PUBLIC usbMsgLen_t usbFunctionSetup(uchar data[8]);
 /* This function is called when the driver receives a SETUP transaction from
  * the host which is not answered by the driver itself (in practice: class and
  * vendor requests). All control transfers start with a SETUP transaction where
@@ -165,21 +194,21 @@ USB_PUBLIC uchar usbFunctionSetup(uchar data[8]);
  * requested data to the driver. There are two ways to transfer this data:
  * (1) Set the global pointer 'usbMsgPtr' to the base of the static RAM data
  * block and return the length of the data in 'usbFunctionSetup()'. The driver
- * will handle the rest. Or (2) return 0xff in 'usbFunctionSetup()'. The driver
- * will then call 'usbFunctionRead()' when data is needed. See the
+ * will handle the rest. Or (2) return USB_NO_MSG in 'usbFunctionSetup()'. The
+ * driver will then call 'usbFunctionRead()' when data is needed. See the
  * documentation for usbFunctionRead() for details.
  *
  * If the SETUP indicates a control-out transfer, the only way to receive the
  * data from the host is through the 'usbFunctionWrite()' call. If you
- * implement this function, you must return 0xff in 'usbFunctionSetup()' to
- * indicate that 'usbFunctionWrite()' should be used. See the documentation of
- * this function for more information. If you just want to ignore the data sent
- * by the host, return 0 in 'usbFunctionSetup()'.
+ * implement this function, you must return USB_NO_MSG in 'usbFunctionSetup()'
+ * to indicate that 'usbFunctionWrite()' should be used. See the documentation
+ * of this function for more information. If you just want to ignore the data
+ * sent by the host, return 0 in 'usbFunctionSetup()'.
  *
  * Note that calls to the functions usbFunctionRead() and usbFunctionWrite()
  * are only done if enabled by the configuration in usbconfig.h.
  */
-USB_PUBLIC uchar usbFunctionDescriptor(struct usbRequest *rq);
+USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq);
 /* You need to implement this function ONLY if you provide USB descriptors at
  * runtime (which is an expert feature). It is very similar to
  * usbFunctionSetup() above, but it is called only to request USB descriptor
@@ -193,7 +222,6 @@ USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len);
  * interrupt status to the host.
  * If you need to transfer more bytes, use a control read after the interrupt.
  */
-extern volatile uchar usbTxLen1;
 #define usbInterruptIsReady()   (usbTxLen1 & 0x10)
 /* This macro indicates whether the last interrupt message has already been
  * sent. If you set a new interrupt message before the old was sent, the
@@ -201,7 +229,6 @@ extern volatile uchar usbTxLen1;
  */
 #if USB_CFG_HAVE_INTRIN_ENDPOINT3
 USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len);
-extern volatile uchar usbTxLen3;
 #define usbInterruptIsReady3()   (usbTxLen3 & 0x10)
 /* Same as above for endpoint 3 */
 #endif
@@ -248,25 +275,33 @@ USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len);
 #endif /* USB_CFG_IMPLEMENT_FN_READ */
 #if USB_CFG_IMPLEMENT_FN_WRITEOUT
 USB_PUBLIC void usbFunctionWriteOut(uchar *data, uchar len);
-/* This function is called by the driver when data on interrupt-out or bulk-
- * out endpoint 1 is received. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT
- * to 1 in usbconfig.h to get this function called.
+/* This function is called by the driver when data is received on an interrupt-
+ * or bulk-out endpoint. The endpoint number can be found in the global
+ * variable usbRxToken. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT to 1 in
+ * usbconfig.h to get this function called.
  */
 #endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */
 #ifdef USB_CFG_PULLUP_IOPORTNAME
 #define usbDeviceConnect()      ((USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT)), \
                                   (USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT)))
-/* This macro (intended to look like a function) connects the device to the
- * USB bus. It is only available if you have defined the constants
- * USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT in usbconfig.h.
- */
 #define usbDeviceDisconnect()   ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \
                                   (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT)))
-/* This macro (intended to look like a function) disconnects the device from
- * the USB bus. It is only available if you have defined the constants
- * USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT in usbconfig.h.
+#else /* USB_CFG_PULLUP_IOPORTNAME */
+#define usbDeviceConnect()      (USBDDR &= ~(1<<USBMINUS))
+#define usbDeviceDisconnect()   (USBDDR |= (1<<USBMINUS))
+#endif /* USB_CFG_PULLUP_IOPORTNAME */
+/* The macros usbDeviceConnect() and usbDeviceDisconnect() (intended to look
+ * like a function) connect resp. disconnect the device from the host's USB.
+ * If the constants USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT are defined
+ * in usbconfig.h, a disconnect consists of removing the pull-up resisitor
+ * from D-, otherwise the disconnect is done by brute-force pulling D- to GND.
+ * This does not conform to the spec, but it works.
+ * Please note that the USB interrupt must be disabled while the device is
+ * in disconnected state, or the interrupt handler will hang! You can either
+ * turn off the USB interrupt selectively with
+ *     USB_INTR_ENABLE &= ~(1 << USB_INTR_ENABLE_BIT)
+ * or use cli() to disable interrupts globally.
  */
-#endif /* USB_CFG_PULLUP_IOPORT */
 extern unsigned usbCrc16(unsigned data, uchar len);
 #define usbCrc16(data, len) usbCrc16((unsigned)(data), len)
 /* This function calculates the binary complement of the data CRC used in
@@ -281,6 +316,16 @@ extern unsigned usbCrc16Append(unsigned data, uchar len);
  * the 2 bytes CRC (lowbyte first) in the 'data' buffer after reading 'len'
  * bytes.
  */
+#if USB_CFG_HAVE_MEASURE_FRAME_LENGTH
+extern unsigned usbMeasureFrameLength(void);
+/* This function MUST be called IMMEDIATELY AFTER USB reset and measures 1/7 of
+ * the number of CPU cycles during one USB frame minus one low speed bit
+ * length. In other words: return value = 1499 * (F_CPU / 10.5 MHz)
+ * Since this is a busy wait, you MUST disable all interrupts with cli() before
+ * calling this function.
+ * This can be used to calibrate the AVR's RC oscillator.
+ */
+#endif
 extern uchar    usbConfiguration;
 /* This value contains the current configuration set by the host. The driver
  * allows setting and querying of this variable with the USB SET_CONFIGURATION
@@ -288,6 +333,19 @@ extern uchar    usbConfiguration;
  * You may want to reflect the "configured" status with a LED on the device or
  * switch on high power parts of the circuit only if the device is configured.
  */
+#if USB_COUNT_SOF
+extern volatile uchar   usbSofCount;
+/* This variable is incremented on every SOF packet. It is only available if
+ * the macro USB_COUNT_SOF is defined to a value != 0.
+ */
+#endif
+#if USB_CFG_CHECK_DATA_TOGGLING
+extern uchar    usbCurrentDataToken;
+/* This variable can be checked in usbFunctionWrite() and usbFunctionWriteOut()
+ * to ignore duplicate packets.
+ */
+#endif
+
 #define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2*(stringLength)+2) | (3<<8))
 /* This macro builds a descriptor header for a string descriptor given the
  * string's length. See usbdrv.c for an example how to use it.
@@ -313,7 +371,9 @@ extern volatile schar   usbRxLen;
 #define USB_SET_DATATOKEN1(token)   usbTxBuf1[0] = token
 #define USB_SET_DATATOKEN3(token)   usbTxBuf3[0] = token
 /* These two macros can be used by application software to reset data toggling
- * for interrupt-in endpoints 1 and 3.
+ * for interrupt-in endpoints 1 and 3. Since the token is toggled BEFORE
+ * sending data, you must set the opposite value of the token which should come
+ * first.
  */
 
 #endif  /* __ASSEMBLER__ */
@@ -326,16 +386,18 @@ extern volatile schar   usbRxLen;
  * about the various methods to define USB descriptors. If you do nothing,
  * the default descriptors will be used.
  */
-#define USB_PROP_IS_DYNAMIC     (1 << 8)
+#define USB_PROP_IS_DYNAMIC     (1 << 14)
 /* If this property is set for a descriptor, usbFunctionDescriptor() will be
- * used to obtain the particular descriptor.
+ * used to obtain the particular descriptor. Data directly returned via
+ * usbMsgPtr are FLASH data by default, combine (OR) with USB_PROP_IS_RAM to
+ * return RAM data.
  */
-#define USB_PROP_IS_RAM         (1 << 9)
+#define USB_PROP_IS_RAM         (1 << 15)
 /* If this property is set for a descriptor, the data is read from RAM
  * memory instead of Flash. The property is used for all methods to provide
  * external descriptors.
  */
-#define USB_PROP_LENGTH(len)    ((len) & 0xff)
+#define USB_PROP_LENGTH(len)    ((len) & 0x3fff)
 /* If a static external descriptor is used, this is the total length of the
  * descriptor in bytes.
  */
@@ -488,6 +550,13 @@ int usbDescriptorStringSerialNumber[];
 #define USB_CFG_PULLUP_IOPORT   USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
 #endif
 
+#ifndef USB_CFG_EP3_NUMBER  /* if not defined in usbconfig.h */
+#define USB_CFG_EP3_NUMBER  3
+#endif
+
+#ifndef USB_CFG_HAVE_INTRIN_ENDPOINT3
+#define USB_CFG_HAVE_INTRIN_ENDPOINT3   0
+#endif
 
 #define USB_BUFSIZE     11  /* PID, 8 bytes data, 2 bytes CRC */
 
@@ -501,7 +570,14 @@ int usbDescriptorStringSerialNumber[];
 #   endif
 #endif
 #ifndef USB_INTR_CFG_SET    /* allow user to override our default */
-#   define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01))    /* cfg for rising edge */
+#   if defined(USB_COUNT_SOF) || defined(USB_SOF_HOOK)
+#       define USB_INTR_CFG_SET (1 << ISC01)                    /* cfg for falling edge */
+        /* If any SOF logic is used, the interrupt must be wired to D- where
+         * we better trigger on falling edge
+         */
+#   else
+#       define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01))   /* cfg for rising edge */
+#   endif
 #endif
 #ifndef USB_INTR_CFG_CLR    /* allow user to override our default */
 #   define USB_INTR_CFG_CLR 0    /* no bits to clear */
@@ -558,9 +634,23 @@ at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM
 #define USBPID_NAK      0x5a
 #define USBPID_STALL    0x1e
 
+#ifndef USB_INITIAL_DATATOKEN
+#define USB_INITIAL_DATATOKEN   USBPID_DATA1
+#endif
+
 #ifndef __ASSEMBLER__
 
-extern uchar    usbTxBuf1[USB_BUFSIZE], usbTxBuf3[USB_BUFSIZE];
+typedef struct usbTxStatus{
+    volatile uchar   len;
+    uchar   buffer[USB_BUFSIZE];
+}usbTxStatus_t;
+
+extern usbTxStatus_t   usbTxStatus1, usbTxStatus3;
+#define usbTxLen1   usbTxStatus1.len
+#define usbTxBuf1   usbTxStatus1.buffer
+#define usbTxLen3   usbTxStatus3.len
+#define usbTxBuf3   usbTxStatus3.buffer
+
 
 typedef union usbWord{
     unsigned    word;
diff --git a/firmware/usbdrv/usbdrvasm.S b/firmware/usbdrv/usbdrvasm.S
index 3f67f5335..c3fc0bbcd 100644
--- a/firmware/usbdrv/usbdrvasm.S
+++ b/firmware/usbdrv/usbdrvasm.S
@@ -4,8 +4,8 @@
  * Creation Date: 2007-06-13
  * Tabsize: 4
  * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * Revision: $Id$
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Revision: $Id: usbdrvasm.S 692 2008-11-07 15:07:40Z cs $
  */
 
 /*
@@ -15,15 +15,9 @@ general code (preprocessor acrobatics and CRC computation) and then includes
 the file appropriate for the given clock rate.
 */
 
-#include "iarcompat.h"
-#ifndef __IAR_SYSTEMS_ASM__
-    /* configs for io.h */
-#   define __SFR_OFFSET 0
-#   define _VECTOR(N)   __vector_ ## N   /* io.h does not define this for asm */
-#   include <avr/io.h> /* for CPU I/O register definitions and vectors */
-#endif  /* __IAR_SYSTEMS_ASM__ */
-#include "usbdrv.h" /* for common defs */
-
+#define __SFR_OFFSET 0      /* used by avr-libc's register definitions */
+#include "usbportability.h"
+#include "usbdrv.h"         /* for common defs */
 
 /* register names */
 #define x1      r16
@@ -39,40 +33,53 @@ the file appropriate for the given clock rate.
 /* Some assembler dependent definitions and declarations: */
 
 #ifdef __IAR_SYSTEMS_ASM__
-
-#   define nop2     rjmp    $+2 /* jump to next instruction */
-#   define XL       r26
-#   define XH       r27
-#   define YL       r28
-#   define YH       r29
-#   define ZL       r30
-#   define ZH       r31
-#   define lo8(x)   LOW(x)
-#   define hi8(x)   ((x)>>8)    /* not HIGH to allow XLINK to make a proper range check */
-
     extern  usbRxBuf, usbDeviceAddr, usbNewDeviceAddr, usbInputBufOffset
     extern  usbCurrentTok, usbRxLen, usbRxToken, usbTxLen
-    extern  usbTxBuf, usbMsgLen, usbTxLen1, usbTxBuf1, usbTxLen3, usbTxBuf3
+    extern  usbTxBuf, usbTxStatus1, usbTxStatus3
+#   if USB_COUNT_SOF
+        extern usbSofCount
+#   endif
     public  usbCrc16
     public  usbCrc16Append
 
     COMMON  INTVEC
-    ORG     INT0_vect
-    rjmp    SIG_INTERRUPT0
+#   ifndef USB_INTR_VECTOR
+        ORG     INT0_vect
+#   else /* USB_INTR_VECTOR */
+        ORG     USB_INTR_VECTOR
+#       undef   USB_INTR_VECTOR
+#   endif /* USB_INTR_VECTOR */
+#   define  USB_INTR_VECTOR usbInterruptHandler
+    rjmp    USB_INTR_VECTOR
     RSEG    CODE
 
 #else /* __IAR_SYSTEMS_ASM__ */
 
-#   define nop2     rjmp    .+0 /* jump to next instruction */
-
+#   ifndef USB_INTR_VECTOR /* default to hardware interrupt INT0 */
+#       define USB_INTR_VECTOR  SIG_INTERRUPT0
+#   endif
     .text
-    .global SIG_INTERRUPT0
-    .type   SIG_INTERRUPT0, @function
+    .global USB_INTR_VECTOR
+    .type   USB_INTR_VECTOR, @function
     .global usbCrc16
     .global usbCrc16Append
-
 #endif /* __IAR_SYSTEMS_ASM__ */
 
+
+#if USB_INTR_PENDING < 0x40 /* This is an I/O address, use in and out */
+#   define  USB_LOAD_PENDING(reg)   in reg, USB_INTR_PENDING
+#   define  USB_STORE_PENDING(reg)  out USB_INTR_PENDING, reg
+#else   /* It's a memory address, use lds and sts */
+#   define  USB_LOAD_PENDING(reg)   lds reg, USB_INTR_PENDING
+#   define  USB_STORE_PENDING(reg)  sts USB_INTR_PENDING, reg
+#endif
+
+#define usbTxLen1   usbTxStatus1
+#define usbTxBuf1   (usbTxStatus1 + 1)
+#define usbTxLen3   usbTxStatus3
+#define usbTxBuf3   (usbTxStatus3 + 1)
+
+
 ;----------------------------------------------------------------------------
 ; Utility functions
 ;----------------------------------------------------------------------------
@@ -144,33 +151,30 @@ RTMODEL "__rt_version", "3"
 usbCrc16:
     mov     ptrL, argPtrL
     mov     ptrH, argPtrH
-    ldi     resCrcL, 0xff
-    ldi     resCrcH, 0xff
+    ldi     resCrcL, 0
+    ldi     resCrcH, 0
     ldi     polyL, lo8(0xa001)
     ldi     polyH, hi8(0xa001)
+    com     argLen      ; argLen = -argLen - 1
 crcByteLoop:
-    subi    argLen, 1
-    brcs    crcReady
+    subi    argLen, -1
+    brcc    crcReady    ; modified loop to ensure that carry is set below
     ld      byte, ptr+
-    ldi     bitCnt, 8
+    ldi     bitCnt, -8  ; strange loop counter to ensure that carry is set where we need it
+    eor     resCrcL, byte
 crcBitLoop:
-    mov     scratch, byte
-    eor     scratch, resCrcL
-    lsr     resCrcH
+    ror     resCrcH     ; carry is always set here
     ror     resCrcL
-    lsr     byte
-    sbrs    scratch, 0
-    rjmp    crcNoXor
+    brcs    crcNoXor
     eor     resCrcL, polyL
     eor     resCrcH, polyH
 crcNoXor:
-    dec     bitCnt
-    brne    crcBitLoop
+    subi    bitCnt, -1
+    brcs    crcBitLoop
     rjmp    crcByteLoop
 crcReady:
-    com     resCrcL
-    com     resCrcH
     ret
+; Thanks to Reimar Doeffinger for optimizing this CRC routine!
 
 ; extern unsigned usbCrc16Append(unsigned char *data, unsigned char len);
 usbCrc16Append:
@@ -179,6 +183,93 @@ usbCrc16Append:
     st      ptr+, resCrcH
     ret
 
+#undef argLen
+#undef argPtrL
+#undef argPtrH
+#undef resCrcL
+#undef resCrcH
+#undef ptrL
+#undef ptrH
+#undef ptr
+#undef byte
+#undef bitCnt
+#undef polyL
+#undef polyH
+#undef scratch
+
+
+#if USB_CFG_HAVE_MEASURE_FRAME_LENGTH
+#ifdef __IAR_SYSTEMS_ASM__
+/* Register assignments for usbMeasureFrameLength on IAR cc */
+/* Calling conventions on IAR:
+ * First parameter passed in r16/r17, second in r18/r19 and so on.
+ * Callee must preserve r4-r15, r24-r29 (r28/r29 is frame pointer)
+ * Result is passed in r16/r17
+ * In case of the "tiny" memory model, pointers are only 8 bit with no
+ * padding. We therefore pass argument 1 as "16 bit unsigned".
+ */
+#   define resL     r16
+#   define resH     r17
+#   define cnt16L   r30
+#   define cnt16H   r31
+#   define cntH     r18
+
+#else  /* __IAR_SYSTEMS_ASM__ */
+/* Register assignments for usbMeasureFrameLength on gcc */
+/* Calling conventions on gcc:
+ * First parameter passed in r24/r25, second in r22/23 and so on.
+ * Callee must preserve r1-r17, r28/r29
+ * Result is passed in r24/r25
+ */
+#   define resL     r24
+#   define resH     r25
+#   define cnt16L   r24
+#   define cnt16H   r25
+#   define cntH     r26
+#endif
+#   define cnt16    cnt16L
+
+; extern unsigned usbMeasurePacketLength(void);
+; returns time between two idle strobes in multiples of 7 CPU clocks
+.global usbMeasureFrameLength
+usbMeasureFrameLength:
+    ldi     cntH, 6         ; wait ~ 10 ms for D- == 0
+    clr     cnt16L
+    clr     cnt16H
+usbMFTime16:
+    dec     cntH
+    breq    usbMFTimeout
+usbMFWaitStrobe:            ; first wait for D- == 0 (idle strobe)
+    sbiw    cnt16, 1        ;[0] [6]
+    breq    usbMFTime16     ;[2]
+    sbic    USBIN, USBMINUS ;[3]
+    rjmp    usbMFWaitStrobe ;[4]
+usbMFWaitIdle:              ; then wait until idle again
+    sbis    USBIN, USBMINUS ;1 wait for D- == 1
+    rjmp    usbMFWaitIdle   ;2
+    ldi     cnt16L, 1       ;1 represents cycles so far
+    clr     cnt16H          ;1
+usbMFWaitLoop:
+    in      cntH, USBIN     ;[0] [7]
+    adiw    cnt16, 1        ;[1]
+    breq    usbMFTimeout    ;[3]
+    andi    cntH, USBMASK   ;[4]
+    brne    usbMFWaitLoop   ;[5]
+usbMFTimeout:
+#if resL != cnt16L
+    mov     resL, cnt16L
+    mov     resH, cnt16H
+#endif
+    ret
+
+#undef resL
+#undef resH
+#undef cnt16
+#undef cnt16L
+#undef cnt16H
+#undef cntH
+
+#endif  /* USB_CFG_HAVE_MEASURE_FRAME_LENGTH */
 
 ;----------------------------------------------------------------------------
 ; Now include the clock rate specific code
@@ -189,11 +280,17 @@ usbCrc16Append:
 #endif
 
 #if USB_CFG_CLOCK_KHZ == 12000
-#   include "usbdrvasm12.S"
+#   include "usbdrvasm12.inc"
+#elif USB_CFG_CLOCK_KHZ == 12800
+#   include "usbdrvasm128.inc"
+#elif USB_CFG_CLOCK_KHZ == 15000
+#   include "usbdrvasm15.inc"
 #elif USB_CFG_CLOCK_KHZ == 16000
-#   include "usbdrvasm16.S"
+#   include "usbdrvasm16.inc"
 #elif USB_CFG_CLOCK_KHZ == 16500
-#   include "usbdrvasm165.S"
+#   include "usbdrvasm165.inc"
+#elif USB_CFG_CLOCK_KHZ == 20000
+#   include "usbdrvasm20.inc"
 #else
 #   error "USB_CFG_CLOCK_KHZ is not one of the supported rates!"
 #endif
diff --git a/firmware/usbdrv/usbdrvasm.asm b/firmware/usbdrv/usbdrvasm.asm
index 4a5486fda..a534b73bb 100644
--- a/firmware/usbdrv/usbdrvasm.asm
+++ b/firmware/usbdrv/usbdrvasm.asm
@@ -4,7 +4,7 @@
  * Creation Date: 2006-03-01
  * Tabsize: 4
  * Copyright: (c) 2006 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
  * This Revision: $Id$
  */
 
diff --git a/firmware/usbdrv/usbdrvasm12.S b/firmware/usbdrv/usbdrvasm12.S
deleted file mode 100644
index b141e85e8..000000000
--- a/firmware/usbdrv/usbdrvasm12.S
+++ /dev/null
@@ -1,555 +0,0 @@
-/* Name: usbdrvasm12.S
- * Project: AVR USB driver
- * Author: Christian Starkjohann
- * Creation Date: 2004-12-29
- * Tabsize: 4
- * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * This Revision: $Id: usbdrvasm12.S 353 2007-06-21 19:05:08Z cs $
- */
-
-/* Do not link this file! Link usbdrvasm.S instead, which includes the
- * appropriate implementation!
- */
-
-/*
-General Description:
-This file is the 12 MHz version of the asssembler part of the USB driver. It
-requires a 12 MHz crystal (not a ceramic resonator and not a calibrated RC
-oscillator).
-
-See usbdrv.h for a description of the entire driver.
-
-Since almost all of this code is timing critical, don't change unless you
-really know what you are doing! Many parts require not only a maximum number
-of CPU cycles, but even an exact number of cycles!
-
-
-Timing constraints according to spec (in bit times):
-timing subject                                      min max    CPUcycles
----------------------------------------------------------------------------
-EOP of OUT/SETUP to sync pattern of DATA0 (both rx) 2   16     16-128
-EOP of IN to sync pattern of DATA0 (rx, then tx)    2   7.5    16-60
-DATAx (rx) to ACK/NAK/STALL (tx)                    2   7.5    16-60
-*/
-
-;Software-receiver engine. Strict timing! Don't change unless you can preserve timing!
-;interrupt response time: 4 cycles + insn running = 7 max if interrupts always enabled
-;max allowable interrupt latency: 34 cycles -> max 25 cycles interrupt disable
-;max stack usage: [ret(2), YL, SREG, YH, shift, x1, x2, x3, cnt, x4] = 11 bytes
-;Numbers in brackets are maximum cycles since SOF.
-SIG_INTERRUPT0:
-;order of registers pushed: YL, SREG [sofError], YH, shift, x1, x2, x3, cnt
-    push    YL              ;2 [35] push only what is necessary to sync with edge ASAP
-    in      YL, SREG        ;1 [37]
-    push    YL              ;2 [39]
-;----------------------------------------------------------------------------
-; Synchronize with sync pattern:
-;----------------------------------------------------------------------------
-;sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
-;sync up with J to K edge during sync pattern -- use fastest possible loops
-;first part has no timeout because it waits for IDLE or SE1 (== disconnected)
-waitForJ:
-    sbis    USBIN, USBMINUS ;1 [40] wait for D- == 1
-    rjmp    waitForJ        ;2
-waitForK:
-;The following code results in a sampling window of 1/4 bit which meets the spec.
-    sbis    USBIN, USBMINUS
-    rjmp    foundK
-    sbis    USBIN, USBMINUS
-    rjmp    foundK
-    sbis    USBIN, USBMINUS
-    rjmp    foundK
-    sbis    USBIN, USBMINUS
-    rjmp    foundK
-    sbis    USBIN, USBMINUS
-    rjmp    foundK
-    rjmp    sofError
-foundK:
-;{3, 5} after falling D- edge, average delay: 4 cycles [we want 4 for center sampling]
-;we have 1 bit time for setup purposes, then sample again. Numbers in brackets
-;are cycles from center of first sync (double K) bit after the instruction
-    push    YH                  ;2 [2]
-    lds     YL, usbInputBufOffset;2 [4]
-    clr     YH                  ;1 [5]
-    subi    YL, lo8(-(usbRxBuf));1 [6]
-    sbci    YH, hi8(-(usbRxBuf));1 [7]
-
-    sbis    USBIN, USBMINUS ;1 [8] we want two bits K [sample 1 cycle too early]
-    rjmp    haveTwoBitsK    ;2 [10]
-    pop     YH              ;2 [11] undo the push from before
-    rjmp    waitForK        ;2 [13] this was not the end of sync, retry
-haveTwoBitsK:
-;----------------------------------------------------------------------------
-; push more registers and initialize values while we sample the first bits:
-;----------------------------------------------------------------------------
-    push    shift           ;2 [16]
-    push    x1              ;2 [12]
-    push    x2              ;2 [14]
-
-    in      x1, USBIN       ;1 [17] <-- sample bit 0
-    ldi     shift, 0xff     ;1 [18]
-    bst     x1, USBMINUS    ;1 [19]
-    bld     shift, 0        ;1 [20]
-    push    x3              ;2 [22]
-    push    cnt             ;2 [24]
-
-    in      x2, USBIN       ;1 [25] <-- sample bit 1
-    ser     x3              ;1 [26] [inserted init instruction]
-    eor     x1, x2          ;1 [27]
-    bst     x1, USBMINUS    ;1 [28]
-    bld     shift, 1        ;1 [29]
-    ldi     cnt, USB_BUFSIZE;1 [30] [inserted init instruction]
-    rjmp    rxbit2          ;2 [32]
-
-;----------------------------------------------------------------------------
-; Receiver loop (numbers in brackets are cycles within byte after instr)
-;----------------------------------------------------------------------------
-
-unstuff0:               ;1 (branch taken)
-    andi    x3, ~0x01   ;1 [15]
-    mov     x1, x2      ;1 [16] x2 contains last sampled (stuffed) bit
-    in      x2, USBIN   ;1 [17] <-- sample bit 1 again
-    ori     shift, 0x01 ;1 [18]
-    rjmp    didUnstuff0 ;2 [20]
-
-unstuff1:               ;1 (branch taken)
-    mov     x2, x1      ;1 [21] x1 contains last sampled (stuffed) bit
-    andi    x3, ~0x02   ;1 [22]
-    ori     shift, 0x02 ;1 [23]
-    nop                 ;1 [24]
-    in      x1, USBIN   ;1 [25] <-- sample bit 2 again
-    rjmp    didUnstuff1 ;2 [27]
-
-unstuff2:               ;1 (branch taken)
-    andi    x3, ~0x04   ;1 [29]
-    ori     shift, 0x04 ;1 [30]
-    mov     x1, x2      ;1 [31] x2 contains last sampled (stuffed) bit
-    nop                 ;1 [32]
-    in      x2, USBIN   ;1 [33] <-- sample bit 3
-    rjmp    didUnstuff2 ;2 [35]
-
-unstuff3:               ;1 (branch taken)
-    in      x2, USBIN   ;1 [34] <-- sample stuffed bit 3 [one cycle too late]
-    andi    x3, ~0x08   ;1 [35]
-    ori     shift, 0x08 ;1 [36]
-    rjmp    didUnstuff3 ;2 [38]
-
-unstuff4:               ;1 (branch taken)
-    andi    x3, ~0x10   ;1 [40]
-    in      x1, USBIN   ;1 [41] <-- sample stuffed bit 4
-    ori     shift, 0x10 ;1 [42]
-    rjmp    didUnstuff4 ;2 [44]
-
-unstuff5:               ;1 (branch taken)
-    andi    x3, ~0x20   ;1 [48]
-    in      x2, USBIN   ;1 [49] <-- sample stuffed bit 5
-    ori     shift, 0x20 ;1 [50]
-    rjmp    didUnstuff5 ;2 [52]
-
-unstuff6:               ;1 (branch taken)
-    andi    x3, ~0x40   ;1 [56]
-    in      x1, USBIN   ;1 [57] <-- sample stuffed bit 6
-    ori     shift, 0x40 ;1 [58]
-    rjmp    didUnstuff6 ;2 [60]
-
-; extra jobs done during bit interval:
-; bit 0:    store, clear [SE0 is unreliable here due to bit dribbling in hubs]
-; bit 1:    se0 check
-; bit 2:    overflow check
-; bit 3:    recovery from delay [bit 0 tasks took too long]
-; bit 4:    none
-; bit 5:    none
-; bit 6:    none
-; bit 7:    jump, eor
-rxLoop:
-    eor     x3, shift   ;1 [0] reconstruct: x3 is 0 at bit locations we changed, 1 at others
-    in      x1, USBIN   ;1 [1] <-- sample bit 0
-    st      y+, x3      ;2 [3] store data
-    ser     x3          ;1 [4]
-    nop                 ;1 [5]
-    eor     x2, x1      ;1 [6]
-    bst     x2, USBMINUS;1 [7]
-    bld     shift, 0    ;1 [8]
-    in      x2, USBIN   ;1 [9] <-- sample bit 1 (or possibly bit 0 stuffed)
-    andi    x2, USBMASK ;1 [10]
-    breq    se0         ;1 [11] SE0 check for bit 1
-    andi    shift, 0xf9 ;1 [12]
-didUnstuff0:
-    breq    unstuff0    ;1 [13]
-    eor     x1, x2      ;1 [14]
-    bst     x1, USBMINUS;1 [15]
-    bld     shift, 1    ;1 [16]
-rxbit2:
-    in      x1, USBIN   ;1 [17] <-- sample bit 2 (or possibly bit 1 stuffed)
-    andi    shift, 0xf3 ;1 [18]
-    breq    unstuff1    ;1 [19] do remaining work for bit 1
-didUnstuff1:
-    subi    cnt, 1      ;1 [20]
-    brcs    overflow    ;1 [21] loop control
-    eor     x2, x1      ;1 [22]
-    bst     x2, USBMINUS;1 [23]
-    bld     shift, 2    ;1 [24]
-    in      x2, USBIN   ;1 [25] <-- sample bit 3 (or possibly bit 2 stuffed)
-    andi    shift, 0xe7 ;1 [26]
-    breq    unstuff2    ;1 [27]
-didUnstuff2:
-    eor     x1, x2      ;1 [28]
-    bst     x1, USBMINUS;1 [29]
-    bld     shift, 3    ;1 [30]
-didUnstuff3:
-    andi    shift, 0xcf ;1 [31]
-    breq    unstuff3    ;1 [32]
-    in      x1, USBIN   ;1 [33] <-- sample bit 4
-    eor     x2, x1      ;1 [34]
-    bst     x2, USBMINUS;1 [35]
-    bld     shift, 4    ;1 [36]
-didUnstuff4:
-    andi    shift, 0x9f ;1 [37]
-    breq    unstuff4    ;1 [38]
-    nop2                ;2 [40]
-    in      x2, USBIN   ;1 [41] <-- sample bit 5
-    eor     x1, x2      ;1 [42]
-    bst     x1, USBMINUS;1 [43]
-    bld     shift, 5    ;1 [44]
-didUnstuff5:
-    andi    shift, 0x3f ;1 [45]
-    breq    unstuff5    ;1 [46]
-    nop2                ;2 [48]
-    in      x1, USBIN   ;1 [49] <-- sample bit 6
-    eor     x2, x1      ;1 [50]
-    bst     x2, USBMINUS;1 [51]
-    bld     shift, 6    ;1 [52]
-didUnstuff6:
-    cpi     shift, 0x02 ;1 [53]
-    brlo    unstuff6    ;1 [54]
-    nop2                ;2 [56]
-    in      x2, USBIN   ;1 [57] <-- sample bit 7
-    eor     x1, x2      ;1 [58]
-    bst     x1, USBMINUS;1 [59]
-    bld     shift, 7    ;1 [60]
-didUnstuff7:
-    cpi     shift, 0x04 ;1 [61]
-    brsh    rxLoop      ;2 [63] loop control
-unstuff7:
-    andi    x3, ~0x80   ;1 [63]
-    ori     shift, 0x80 ;1 [64]
-    in      x2, USBIN   ;1 [65] <-- sample stuffed bit 7
-    nop                 ;1 [66]
-    rjmp    didUnstuff7 ;2 [68]
-
-
-;----------------------------------------------------------------------------
-; Processing of received packet (numbers in brackets are cycles after end of SE0)
-;----------------------------------------------------------------------------
-;This is the only non-error exit point for the software receiver loop
-;we don't check any CRCs here because there is no time left.
-#define token   x1
-se0:                            ;  [0]
-    subi    cnt, USB_BUFSIZE    ;1 [1]
-    neg     cnt                 ;1 [2]
-    cpi     cnt, 3              ;1 [3]
-    ldi     x2, 1<<USB_INTR_PENDING_BIT ;1 [4]
-    out     USB_INTR_PENDING, x2;1 [5] clear pending intr and check flag later. SE0 should be over.
-    brlo    doReturn            ;1 [6] this is probably an ACK, NAK or similar packet
-    sub     YL, cnt             ;1 [7]
-    sbci    YH, 0               ;1 [8]
-    ld      token, y            ;2 [10]
-    cpi     token, USBPID_DATA0 ;1 [11]
-    breq    handleData          ;1 [12]
-    cpi     token, USBPID_DATA1 ;1 [13]
-    breq    handleData          ;1 [14]
-    ldd     x2, y+1             ;2 [16] ADDR and 1 bit endpoint number
-    mov     x3, x2              ;1 [17] store for endpoint number
-    andi    x2, 0x7f            ;1 [18] x2 is now ADDR
-    lds     shift, usbDeviceAddr;2 [20]
-    cp      x2, shift           ;1 [21]
-overflow:                       ; This is a hack: brcs overflow will never have Z flag set
-    brne    ignorePacket        ;1 [22] packet for different address
-    cpi     token, USBPID_IN    ;1 [23]
-    breq    handleIn            ;1 [24]
-    cpi     token, USBPID_SETUP ;1 [25]
-    breq    handleSetupOrOut    ;1 [26]
-    cpi     token, USBPID_OUT   ;1 [27]
-    breq    handleSetupOrOut    ;1 [28]
-;   rjmp    ignorePacket        ;fallthrough, should not happen anyway.
-
-ignorePacket:
-    clr     shift
-    sts     usbCurrentTok, shift
-doReturn:
-    pop     cnt
-    pop     x3
-    pop     x2
-    pop     x1
-    pop     shift
-    pop     YH
-sofError:
-    pop     YL
-    out     SREG, YL
-    pop     YL
-    reti
-
-#if USB_CFG_HAVE_INTRIN_ENDPOINT && USB_CFG_HAVE_INTRIN_ENDPOINT3
-handleIn3:                      ;1 [38] (branch taken)
-    lds     cnt, usbTxLen3      ;2 [40]
-    sbrc    cnt, 4              ;2 [42]
-    rjmp    sendCntAndReti      ;0 43 + 17 = 60 until SOP
-    sts     usbTxLen3, x1       ;2 [44] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf3)  ;1 [45]
-    ldi     YH, hi8(usbTxBuf3)  ;1 [46]
-    rjmp    usbSendAndReti      ;2 [48] + 13 = 61 until SOP (violates the spec by 1 cycle)
-#endif
-
-;Setup and Out are followed by a data packet two bit times (16 cycles) after
-;the end of SE0. The sync code allows up to 40 cycles delay from the start of
-;the sync pattern until the first bit is sampled. That's a total of 56 cycles.
-handleSetupOrOut:               ;1 [29] (branch taken)
-#if USB_CFG_IMPLEMENT_FN_WRITEOUT   /* if we have data for second OUT endpoint, set usbCurrentTok to -1 */
-    sbrc    x3, 7               ;1 [30] skip if endpoint 0
-    ldi     token, -1           ;1 [31] indicate that this is endpoint 1 OUT
-#endif
-    sts     usbCurrentTok, token;2 [33]
-    pop     cnt                 ;2 [35]
-    pop     x3                  ;2 [37]
-    pop     x2                  ;2 [39]
-    pop     x1                  ;2 [41]
-    pop     shift               ;2 [43]
-    pop     YH                  ;2 [45]
-    in      YL, USB_INTR_PENDING;1 [46]
-    sbrc    YL, USB_INTR_PENDING_BIT;1 [47] check whether data is already arriving
-    rjmp    waitForJ            ;2 [49] save the pops and pushes -- a new interrupt is aready pending
-    rjmp    sofError            ;2 not an error, but it does the pops and reti we want
-
-
-handleData:                     ;1 [15] (branch taken)
-    lds     token, usbCurrentTok;2 [17]
-    tst     token               ;1 [18]
-    breq    doReturn            ;1 [19]
-    lds     x2, usbRxLen        ;2 [21]
-    tst     x2                  ;1 [22]
-    brne    sendNakAndReti      ;1 [23]
-; 2006-03-11: The following two lines fix a problem where the device was not
-; recognized if usbPoll() was called less frequently than once every 4 ms.
-    cpi     cnt, 4              ;1 [24] zero sized data packets are status phase only -- ignore and ack
-    brmi    sendAckAndReti      ;1 [25] keep rx buffer clean -- we must not NAK next SETUP
-    sts     usbRxLen, cnt       ;2 [27] store received data, swap buffers
-    sts     usbRxToken, token   ;2 [29]
-    lds     x2, usbInputBufOffset;2 [31] swap buffers
-    ldi     cnt, USB_BUFSIZE    ;1 [32]
-    sub     cnt, x2             ;1 [33]
-    sts     usbInputBufOffset, cnt;2 [35] buffers now swapped
-    rjmp    sendAckAndReti      ;2 [37] + 19 = 56 until SOP
-
-handleIn:                       ;1 [25] (branch taken)
-;We don't send any data as long as the C code has not processed the current
-;input data and potentially updated the output data. That's more efficient
-;in terms of code size than clearing the tx buffers when a packet is received.
-    lds     x1, usbRxLen        ;2 [27]
-    cpi     x1, 1               ;1 [28] negative values are flow control, 0 means "buffer free"
-    brge    sendNakAndReti      ;1 [29] unprocessed input packet?
-    ldi     x1, USBPID_NAK      ;1 [30] prepare value for usbTxLen
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-    sbrc    x3, 7               ;2 [33] x3 contains addr + endpoint
-    rjmp    handleIn1           ;0
-#endif
-    lds     cnt, usbTxLen       ;2 [34]
-    sbrc    cnt, 4              ;2 [36] all handshake tokens have bit 4 set
-    rjmp    sendCntAndReti      ;0 37 + 17 = 54 until SOP
-    sts     usbTxLen, x1        ;2 [38] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf)   ;1 [39]
-    ldi     YH, hi8(usbTxBuf)   ;1 [40]
-    rjmp    usbSendAndReti      ;2 [42] + 14 = 56 until SOP
-
-; Comment about when to set usbTxLen to USBPID_NAK:
-; We should set it back when we receive the ACK from the host. This would
-; be simple to implement: One static variable which stores whether the last
-; tx was for endpoint 0 or 1 and a compare in the receiver to distinguish the
-; ACK. However, we set it back immediately when we send the package,
-; assuming that no error occurs and the host sends an ACK. We save one byte
-; RAM this way and avoid potential problems with endless retries. The rest of
-; the driver assumes error-free transfers anyway.
-
-#if USB_CFG_HAVE_INTRIN_ENDPOINT    /* placed here due to relative jump range */
-handleIn1:                      ;1 [33] (branch taken)
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-; 2006-06-10 as suggested by O.Tamura: support second INTR IN / BULK IN endpoint
-    ldd     x2, y+2             ;2 [35]
-    sbrc    x2, 0               ;2 [37]
-    rjmp    handleIn3           ;0
-#endif
-    lds     cnt, usbTxLen1      ;2 [39]
-    sbrc    cnt, 4              ;2 [41] all handshake tokens have bit 4 set
-    rjmp    sendCntAndReti      ;0 42 + 17 = 59 until SOP
-    sts     usbTxLen1, x1       ;2 [43] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf1)  ;1 [44]
-    ldi     YH, hi8(usbTxBuf1)  ;1 [45]
-    rjmp    usbSendAndReti      ;2 [47] + 13 = 60 until SOP
-#endif
-
-
-;----------------------------------------------------------------------------
-; Transmitting data
-;----------------------------------------------------------------------------
-
-bitstuff0:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    ldi     x2, 0           ;1
-    out     USBOUT, x1      ;1 <-- out
-    rjmp    didStuff0       ;2 branch back 2 cycles earlier
-bitstuff1:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    rjmp    didStuff1       ;2 we know that C is clear, jump back to do OUT and ror 0 into x2
-bitstuff2:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    rjmp    didStuff2       ;2 jump back 4 cycles earlier and do out and ror 0 into x2
-bitstuff3:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    rjmp    didStuff3       ;2 jump back earlier and ror 0 into x2
-bitstuff4:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    ldi     x2, 0           ;1
-    out     USBOUT, x1      ;1 <-- out
-    rjmp    didStuff4       ;2 jump back 2 cycles earlier
-
-sendNakAndReti:                 ;0 [-19] 19 cycles until SOP
-    ldi     x3, USBPID_NAK      ;1 [-18]
-    rjmp    usbSendX3           ;2 [-16]
-sendAckAndReti:                 ;0 [-19] 19 cycles until SOP
-    ldi     x3, USBPID_ACK      ;1 [-18]
-    rjmp    usbSendX3           ;2 [-16]
-sendCntAndReti:                 ;0 [-17] 17 cycles until SOP
-    mov     x3, cnt             ;1 [-16]
-usbSendX3:                      ;0 [-16]
-    ldi     YL, 20              ;1 [-15] 'x3' is R20
-    ldi     YH, 0               ;1 [-14]
-    ldi     cnt, 2              ;1 [-13]
-;   rjmp    usbSendAndReti      fallthrough
-
-; USB spec says:
-; idle = J
-; J = (D+ = 0), (D- = 1) or USBOUT = 0x01
-; K = (D+ = 1), (D- = 0) or USBOUT = 0x02
-; Spec allows 7.5 bit times from EOP to SOP for replies (= 60 cycles)
-
-;usbSend:
-;pointer to data in 'Y'
-;number of bytes in 'cnt' -- including sync byte
-;uses: x1...x4, shift, cnt, Y
-;Numbers in brackets are time since first bit of sync pattern is sent
-usbSendAndReti:             ;0 [-13] timing: 13 cycles until SOP
-    in      x2, USBDDR      ;1 [-12]
-    ori     x2, USBMASK     ;1 [-11]
-    sbi     USBOUT, USBMINUS;2 [-9] prepare idle state; D+ and D- must have been 0 (no pullups)
-    in      x1, USBOUT      ;1 [-8] port mirror for tx loop
-    out     USBDDR, x2      ;1 [-7] <- acquire bus
-; need not init x2 (bitstuff history) because sync starts with 0
-    push    x4              ;2 [-5]
-    ldi     x4, USBMASK     ;1 [-4] exor mask
-    ldi     shift, 0x80     ;1 [-3] sync byte is first byte sent
-txLoop:                     ;       [62]
-    sbrs    shift, 0        ;1 [-2] [62]
-    eor     x1, x4          ;1 [-1] [63]
-    out     USBOUT, x1      ;1 [0] <-- out bit 0
-    ror     shift           ;1 [1]
-    ror     x2              ;1 [2]
-didStuff0:
-    cpi     x2, 0xfc        ;1 [3]
-    brsh    bitstuff0       ;1 [4]
-    sbrs    shift, 0        ;1 [5]
-    eor     x1, x4          ;1 [6]
-    ror     shift           ;1 [7]
-didStuff1:
-    out     USBOUT, x1      ;1 [8] <-- out bit 1
-    ror     x2              ;1 [9]
-    cpi     x2, 0xfc        ;1 [10]
-    brsh    bitstuff1       ;1 [11]
-    sbrs    shift, 0        ;1 [12]
-    eor     x1, x4          ;1 [13]
-    ror     shift           ;1 [14]
-didStuff2:
-    ror     x2              ;1 [15]
-    out     USBOUT, x1      ;1 [16] <-- out bit 2
-    cpi     x2, 0xfc        ;1 [17]
-    brsh    bitstuff2       ;1 [18]
-    sbrs    shift, 0        ;1 [19]
-    eor     x1, x4          ;1 [20]
-    ror     shift           ;1 [21]
-didStuff3:
-    ror     x2              ;1 [22]
-    cpi     x2, 0xfc        ;1 [23]
-    out     USBOUT, x1      ;1 [24] <-- out bit 3
-    brsh    bitstuff3       ;1 [25]
-    nop2                    ;2 [27]
-    ld      x3, y+          ;2 [29]
-    sbrs    shift, 0        ;1 [30]
-    eor     x1, x4          ;1 [31]
-    out     USBOUT, x1      ;1 [32] <-- out bit 4
-    ror     shift           ;1 [33]
-    ror     x2              ;1 [34]
-didStuff4:
-    cpi     x2, 0xfc        ;1 [35]
-    brsh    bitstuff4       ;1 [36]
-    sbrs    shift, 0        ;1 [37]
-    eor     x1, x4          ;1 [38]
-    ror     shift           ;1 [39]
-didStuff5:
-    out     USBOUT, x1      ;1 [40] <-- out bit 5
-    ror     x2              ;1 [41]
-    cpi     x2, 0xfc        ;1 [42]
-    brsh    bitstuff5       ;1 [43]
-    sbrs    shift, 0        ;1 [44]
-    eor     x1, x4          ;1 [45]
-    ror     shift           ;1 [46]
-didStuff6:
-    ror     x2              ;1 [47]
-    out     USBOUT, x1      ;1 [48] <-- out bit 6
-    cpi     x2, 0xfc        ;1 [49]
-    brsh    bitstuff6       ;1 [50]
-    sbrs    shift, 0        ;1 [51]
-    eor     x1, x4          ;1 [52]
-    ror     shift           ;1 [53]
-didStuff7:
-    ror     x2              ;1 [54]
-    cpi     x2, 0xfc        ;1 [55]
-    out     USBOUT, x1      ;1 [56] <-- out bit 7
-    brsh    bitstuff7       ;1 [57]
-    mov     shift, x3       ;1 [58]
-    dec     cnt             ;1 [59]
-    brne    txLoop          ;1/2 [60/61]
-;make SE0:
-    cbr     x1, USBMASK     ;1 [61] prepare SE0 [spec says EOP may be 15 to 18 cycles]
-    pop     x4              ;2 [63]
-;brackets are cycles from start of SE0 now
-    out     USBOUT, x1      ;1 [0] <-- out SE0 -- from now 2 bits = 16 cycles until bus idle
-    nop2                    ;2 [2]
-;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
-;set address only after data packet was sent, not after handshake
-    lds     x2, usbNewDeviceAddr;2 [4]
-    subi    YL, 20 + 2      ;1 [5]
-    sbci    YH, 0           ;1 [6]
-    breq    skipAddrAssign  ;2 [8]
-    sts     usbDeviceAddr, x2;0  if not skipped: SE0 is one cycle longer
-skipAddrAssign:
-;end of usbDeviceAddress transfer
-    ldi     x2, 1<<USB_INTR_PENDING_BIT;1 [9] int0 occurred during TX -- clear pending flag
-    out     USB_INTR_PENDING, x2;1 [10]
-    ori     x1, USBIDLE     ;1 [11]
-    in      x2, USBDDR      ;1 [12]
-    cbr     x2, USBMASK     ;1 [13] set both pins to input
-    mov     x3, x1          ;1 [14]
-    cbr     x3, USBMASK     ;1 [15] configure no pullup on both pins
-    out     USBOUT, x1      ;1 [16] <-- out J (idle) -- end of SE0 (EOP signal)
-    out     USBDDR, x2      ;1 [17] <-- release bus now
-    out     USBOUT, x3      ;1 [18] <-- ensure no pull-up resistors are active
-    rjmp    doReturn
-
-bitstuff5:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    rjmp    didStuff5       ;2 same trick as above...
-bitstuff6:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    rjmp    didStuff6       ;2 same trick as above...
-bitstuff7:                  ;1 (for branch taken)
-    eor     x1, x4          ;1
-    rjmp    didStuff7       ;2 same trick as above...
diff --git a/firmware/usbdrv/usbdrvasm12.inc b/firmware/usbdrv/usbdrvasm12.inc
new file mode 100644
index 000000000..528ca4136
--- /dev/null
+++ b/firmware/usbdrv/usbdrvasm12.inc
@@ -0,0 +1,393 @@
+/* Name: usbdrvasm12.inc
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2004-12-29
+ * Tabsize: 4
+ * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbdrvasm12.inc 692 2008-11-07 15:07:40Z cs $
+ */
+
+/* Do not link this file! Link usbdrvasm.S instead, which includes the
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file is the 12 MHz version of the asssembler part of the USB driver. It
+requires a 12 MHz crystal (not a ceramic resonator and not a calibrated RC
+oscillator).
+
+See usbdrv.h for a description of the entire driver.
+
+Since almost all of this code is timing critical, don't change unless you
+really know what you are doing! Many parts require not only a maximum number
+of CPU cycles, but even an exact number of cycles!
+
+
+Timing constraints according to spec (in bit times):
+timing subject                                      min max    CPUcycles
+---------------------------------------------------------------------------
+EOP of OUT/SETUP to sync pattern of DATA0 (both rx) 2   16     16-128
+EOP of IN to sync pattern of DATA0 (rx, then tx)    2   7.5    16-60
+DATAx (rx) to ACK/NAK/STALL (tx)                    2   7.5    16-60
+*/
+
+;Software-receiver engine. Strict timing! Don't change unless you can preserve timing!
+;interrupt response time: 4 cycles + insn running = 7 max if interrupts always enabled
+;max allowable interrupt latency: 34 cycles -> max 25 cycles interrupt disable
+;max stack usage: [ret(2), YL, SREG, YH, shift, x1, x2, x3, cnt, x4] = 11 bytes
+;Numbers in brackets are maximum cycles since SOF.
+USB_INTR_VECTOR:
+;order of registers pushed: YL, SREG [sofError], YH, shift, x1, x2, x3, cnt
+    push    YL              ;2 [35] push only what is necessary to sync with edge ASAP
+    in      YL, SREG        ;1 [37]
+    push    YL              ;2 [39]
+;----------------------------------------------------------------------------
+; Synchronize with sync pattern:
+;----------------------------------------------------------------------------
+;sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
+;sync up with J to K edge during sync pattern -- use fastest possible loops
+;The first part waits at most 1 bit long since we must be in sync pattern.
+;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to
+;waitForJ, ensure that this prerequisite is met.
+waitForJ:
+    inc     YL
+    sbis    USBIN, USBMINUS
+    brne    waitForJ        ; just make sure we have ANY timeout
+waitForK:
+;The following code results in a sampling window of 1/4 bit which meets the spec.
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+#if USB_COUNT_SOF
+    lds     YL, usbSofCount
+    inc     YL
+    sts     usbSofCount, YL
+#endif  /* USB_COUNT_SOF */
+#ifdef USB_SOF_HOOK
+    USB_SOF_HOOK
+#endif
+    rjmp    sofError
+foundK:
+;{3, 5} after falling D- edge, average delay: 4 cycles [we want 4 for center sampling]
+;we have 1 bit time for setup purposes, then sample again. Numbers in brackets
+;are cycles from center of first sync (double K) bit after the instruction
+    push    YH                  ;2 [2]
+    lds     YL, usbInputBufOffset;2 [4]
+    clr     YH                  ;1 [5]
+    subi    YL, lo8(-(usbRxBuf));1 [6]
+    sbci    YH, hi8(-(usbRxBuf));1 [7]
+
+    sbis    USBIN, USBMINUS ;1 [8] we want two bits K [sample 1 cycle too early]
+    rjmp    haveTwoBitsK    ;2 [10]
+    pop     YH              ;2 [11] undo the push from before
+    rjmp    waitForK        ;2 [13] this was not the end of sync, retry
+haveTwoBitsK:
+;----------------------------------------------------------------------------
+; push more registers and initialize values while we sample the first bits:
+;----------------------------------------------------------------------------
+    push    shift           ;2 [16]
+    push    x1              ;2 [12]
+    push    x2              ;2 [14]
+
+    in      x1, USBIN       ;1 [17] <-- sample bit 0
+    ldi     shift, 0xff     ;1 [18]
+    bst     x1, USBMINUS    ;1 [19]
+    bld     shift, 0        ;1 [20]
+    push    x3              ;2 [22]
+    push    cnt             ;2 [24]
+
+    in      x2, USBIN       ;1 [25] <-- sample bit 1
+    ser     x3              ;1 [26] [inserted init instruction]
+    eor     x1, x2          ;1 [27]
+    bst     x1, USBMINUS    ;1 [28]
+    bld     shift, 1        ;1 [29]
+    ldi     cnt, USB_BUFSIZE;1 [30] [inserted init instruction]
+    rjmp    rxbit2          ;2 [32]
+
+;----------------------------------------------------------------------------
+; Receiver loop (numbers in brackets are cycles within byte after instr)
+;----------------------------------------------------------------------------
+
+unstuff0:               ;1 (branch taken)
+    andi    x3, ~0x01   ;1 [15]
+    mov     x1, x2      ;1 [16] x2 contains last sampled (stuffed) bit
+    in      x2, USBIN   ;1 [17] <-- sample bit 1 again
+    ori     shift, 0x01 ;1 [18]
+    rjmp    didUnstuff0 ;2 [20]
+
+unstuff1:               ;1 (branch taken)
+    mov     x2, x1      ;1 [21] x1 contains last sampled (stuffed) bit
+    andi    x3, ~0x02   ;1 [22]
+    ori     shift, 0x02 ;1 [23]
+    nop                 ;1 [24]
+    in      x1, USBIN   ;1 [25] <-- sample bit 2 again
+    rjmp    didUnstuff1 ;2 [27]
+
+unstuff2:               ;1 (branch taken)
+    andi    x3, ~0x04   ;1 [29]
+    ori     shift, 0x04 ;1 [30]
+    mov     x1, x2      ;1 [31] x2 contains last sampled (stuffed) bit
+    nop                 ;1 [32]
+    in      x2, USBIN   ;1 [33] <-- sample bit 3
+    rjmp    didUnstuff2 ;2 [35]
+
+unstuff3:               ;1 (branch taken)
+    in      x2, USBIN   ;1 [34] <-- sample stuffed bit 3 [one cycle too late]
+    andi    x3, ~0x08   ;1 [35]
+    ori     shift, 0x08 ;1 [36]
+    rjmp    didUnstuff3 ;2 [38]
+
+unstuff4:               ;1 (branch taken)
+    andi    x3, ~0x10   ;1 [40]
+    in      x1, USBIN   ;1 [41] <-- sample stuffed bit 4
+    ori     shift, 0x10 ;1 [42]
+    rjmp    didUnstuff4 ;2 [44]
+
+unstuff5:               ;1 (branch taken)
+    andi    x3, ~0x20   ;1 [48]
+    in      x2, USBIN   ;1 [49] <-- sample stuffed bit 5
+    ori     shift, 0x20 ;1 [50]
+    rjmp    didUnstuff5 ;2 [52]
+
+unstuff6:               ;1 (branch taken)
+    andi    x3, ~0x40   ;1 [56]
+    in      x1, USBIN   ;1 [57] <-- sample stuffed bit 6
+    ori     shift, 0x40 ;1 [58]
+    rjmp    didUnstuff6 ;2 [60]
+
+; extra jobs done during bit interval:
+; bit 0:    store, clear [SE0 is unreliable here due to bit dribbling in hubs]
+; bit 1:    se0 check
+; bit 2:    overflow check
+; bit 3:    recovery from delay [bit 0 tasks took too long]
+; bit 4:    none
+; bit 5:    none
+; bit 6:    none
+; bit 7:    jump, eor
+rxLoop:
+    eor     x3, shift   ;1 [0] reconstruct: x3 is 0 at bit locations we changed, 1 at others
+    in      x1, USBIN   ;1 [1] <-- sample bit 0
+    st      y+, x3      ;2 [3] store data
+    ser     x3          ;1 [4]
+    nop                 ;1 [5]
+    eor     x2, x1      ;1 [6]
+    bst     x2, USBMINUS;1 [7]
+    bld     shift, 0    ;1 [8]
+    in      x2, USBIN   ;1 [9] <-- sample bit 1 (or possibly bit 0 stuffed)
+    andi    x2, USBMASK ;1 [10]
+    breq    se0         ;1 [11] SE0 check for bit 1
+    andi    shift, 0xf9 ;1 [12]
+didUnstuff0:
+    breq    unstuff0    ;1 [13]
+    eor     x1, x2      ;1 [14]
+    bst     x1, USBMINUS;1 [15]
+    bld     shift, 1    ;1 [16]
+rxbit2:
+    in      x1, USBIN   ;1 [17] <-- sample bit 2 (or possibly bit 1 stuffed)
+    andi    shift, 0xf3 ;1 [18]
+    breq    unstuff1    ;1 [19] do remaining work for bit 1
+didUnstuff1:
+    subi    cnt, 1      ;1 [20]
+    brcs    overflow    ;1 [21] loop control
+    eor     x2, x1      ;1 [22]
+    bst     x2, USBMINUS;1 [23]
+    bld     shift, 2    ;1 [24]
+    in      x2, USBIN   ;1 [25] <-- sample bit 3 (or possibly bit 2 stuffed)
+    andi    shift, 0xe7 ;1 [26]
+    breq    unstuff2    ;1 [27]
+didUnstuff2:
+    eor     x1, x2      ;1 [28]
+    bst     x1, USBMINUS;1 [29]
+    bld     shift, 3    ;1 [30]
+didUnstuff3:
+    andi    shift, 0xcf ;1 [31]
+    breq    unstuff3    ;1 [32]
+    in      x1, USBIN   ;1 [33] <-- sample bit 4
+    eor     x2, x1      ;1 [34]
+    bst     x2, USBMINUS;1 [35]
+    bld     shift, 4    ;1 [36]
+didUnstuff4:
+    andi    shift, 0x9f ;1 [37]
+    breq    unstuff4    ;1 [38]
+    nop2                ;2 [40]
+    in      x2, USBIN   ;1 [41] <-- sample bit 5
+    eor     x1, x2      ;1 [42]
+    bst     x1, USBMINUS;1 [43]
+    bld     shift, 5    ;1 [44]
+didUnstuff5:
+    andi    shift, 0x3f ;1 [45]
+    breq    unstuff5    ;1 [46]
+    nop2                ;2 [48]
+    in      x1, USBIN   ;1 [49] <-- sample bit 6
+    eor     x2, x1      ;1 [50]
+    bst     x2, USBMINUS;1 [51]
+    bld     shift, 6    ;1 [52]
+didUnstuff6:
+    cpi     shift, 0x02 ;1 [53]
+    brlo    unstuff6    ;1 [54]
+    nop2                ;2 [56]
+    in      x2, USBIN   ;1 [57] <-- sample bit 7
+    eor     x1, x2      ;1 [58]
+    bst     x1, USBMINUS;1 [59]
+    bld     shift, 7    ;1 [60]
+didUnstuff7:
+    cpi     shift, 0x04 ;1 [61]
+    brsh    rxLoop      ;2 [63] loop control
+unstuff7:
+    andi    x3, ~0x80   ;1 [63]
+    ori     shift, 0x80 ;1 [64]
+    in      x2, USBIN   ;1 [65] <-- sample stuffed bit 7
+    nop                 ;1 [66]
+    rjmp    didUnstuff7 ;2 [68]
+
+macro POP_STANDARD ; 12 cycles
+    pop     cnt
+    pop     x3
+    pop     x2
+    pop     x1
+    pop     shift
+    pop     YH
+    endm
+macro POP_RETI     ; 5 cycles
+    pop     YL
+    out     SREG, YL
+    pop     YL
+    endm
+
+#include "asmcommon.inc"
+
+;----------------------------------------------------------------------------
+; Transmitting data
+;----------------------------------------------------------------------------
+
+txByteLoop:
+txBitloop:
+stuffN1Delay:                   ;     [03]
+    ror     shift               ;[-5] [11] [59]
+    brcc    doExorN1            ;[-4]      [60]
+    subi    x4, 1               ;[-3]
+    brne    commonN1            ;[-2]
+    lsl     shift               ;[-1] compensate ror after rjmp stuffDelay
+    nop                         ;[00] stuffing consists of just waiting 8 cycles
+    rjmp    stuffN1Delay        ;[01] after ror, C bit is reliably clear
+
+sendNakAndReti:                 ;0 [-19] 19 cycles until SOP
+    ldi     x3, USBPID_NAK      ;1 [-18]
+    rjmp    usbSendX3           ;2 [-16]
+sendAckAndReti:                 ;0 [-19] 19 cycles until SOP
+    ldi     x3, USBPID_ACK      ;1 [-18]
+    rjmp    usbSendX3           ;2 [-16]
+sendCntAndReti:                 ;0 [-17] 17 cycles until SOP
+    mov     x3, cnt             ;1 [-16]
+usbSendX3:                      ;0 [-16]
+    ldi     YL, 20              ;1 [-15] 'x3' is R20
+    ldi     YH, 0               ;1 [-14]
+    ldi     cnt, 2              ;1 [-13]
+;   rjmp    usbSendAndReti      fallthrough
+
+; USB spec says:
+; idle = J
+; J = (D+ = 0), (D- = 1) or USBOUT = 0x01
+; K = (D+ = 1), (D- = 0) or USBOUT = 0x02
+; Spec allows 7.5 bit times from EOP to SOP for replies (= 60 cycles)
+
+;usbSend:
+;pointer to data in 'Y'
+;number of bytes in 'cnt' -- including sync byte
+;uses: x1...x2, x4, shift, cnt, Y [x1 = mirror USBOUT, x2 = USBMASK, x4 = bitstuff cnt]
+;Numbers in brackets are time since first bit of sync pattern is sent (start of instruction)
+usbSendAndReti:
+    in      x2, USBDDR          ;[-12] 12 cycles until SOP
+    ori     x2, USBMASK         ;[-11]
+    sbi     USBOUT, USBMINUS    ;[-10] prepare idle state; D+ and D- must have been 0 (no pullups)
+    out     USBDDR, x2          ;[-8] <--- acquire bus
+    in      x1, USBOUT          ;[-7] port mirror for tx loop
+    ldi     shift, 0x40         ;[-6] sync byte is first byte sent (we enter loop after ror)
+    ldi     x2, USBMASK         ;[-5]
+    push    x4                  ;[-4]
+doExorN1:
+    eor     x1, x2              ;[-2] [06] [62]
+    ldi     x4, 6               ;[-1] [07] [63]
+commonN1:
+stuffN2Delay:
+    out     USBOUT, x1          ;[00] [08] [64] <--- set bit
+    ror     shift               ;[01]
+    brcc    doExorN2            ;[02]
+    subi    x4, 1               ;[03]
+    brne    commonN2            ;[04]
+    lsl     shift               ;[05] compensate ror after rjmp stuffDelay
+    rjmp    stuffN2Delay        ;[06] after ror, C bit is reliably clear
+doExorN2:
+    eor     x1, x2              ;[04] [12]
+    ldi     x4, 6               ;[05] [13]
+commonN2:
+    nop                         ;[06] [14]
+    subi    cnt, 171            ;[07] [15] trick: (3 * 171) & 0xff = 1
+    out     USBOUT, x1          ;[08] [16] <--- set bit
+    brcs    txBitloop           ;[09]      [25] [41]
+
+stuff6Delay:
+    ror     shift               ;[42] [50]
+    brcc    doExor6             ;[43]
+    subi    x4, 1               ;[44]
+    brne    common6             ;[45]
+    lsl     shift               ;[46] compensate ror after rjmp stuffDelay
+    nop                         ;[47] stuffing consists of just waiting 8 cycles
+    rjmp    stuff6Delay         ;[48] after ror, C bit is reliably clear
+doExor6:
+    eor     x1, x2              ;[45] [53]
+    ldi     x4, 6               ;[46]
+common6:
+stuff7Delay:
+    ror     shift               ;[47] [55]
+    out     USBOUT, x1          ;[48] <--- set bit
+    brcc    doExor7             ;[49]
+    subi    x4, 1               ;[50]
+    brne    common7             ;[51]
+    lsl     shift               ;[52] compensate ror after rjmp stuffDelay
+    rjmp    stuff7Delay         ;[53] after ror, C bit is reliably clear
+doExor7:
+    eor     x1, x2              ;[51] [59]
+    ldi     x4, 6               ;[52]
+common7:
+    ld      shift, y+           ;[53]
+    tst     cnt                 ;[55]
+    out     USBOUT, x1          ;[56] <--- set bit
+    brne    txByteLoop          ;[57]
+
+;make SE0:
+    cbr     x1, USBMASK         ;[58] prepare SE0 [spec says EOP may be 15 to 18 cycles]
+    lds     x2, usbNewDeviceAddr;[59]
+    lsl     x2                  ;[61] we compare with left shifted address
+    subi    YL, 2 + 20          ;[62] Only assign address on data packets, not ACK/NAK in x3
+    sbci    YH, 0               ;[63]
+    out     USBOUT, x1          ;[00] <-- out SE0 -- from now 2 bits = 16 cycles until bus idle
+;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
+;set address only after data packet was sent, not after handshake
+    breq    skipAddrAssign      ;[01]
+    sts     usbDeviceAddr, x2   ; if not skipped: SE0 is one cycle longer
+skipAddrAssign:
+;end of usbDeviceAddress transfer
+    ldi     x2, 1<<USB_INTR_PENDING_BIT;[03] int0 occurred during TX -- clear pending flag
+    USB_STORE_PENDING(x2)       ;[04]
+    ori     x1, USBIDLE         ;[05]
+    in      x2, USBDDR          ;[06]
+    cbr     x2, USBMASK         ;[07] set both pins to input
+    mov     x3, x1              ;[08]
+    cbr     x3, USBMASK         ;[09] configure no pullup on both pins
+    pop     x4                  ;[10]
+    nop2                        ;[12]
+    nop2                        ;[14]
+    out     USBOUT, x1          ;[16] <-- out J (idle) -- end of SE0 (EOP signal)
+    out     USBDDR, x2          ;[17] <-- release bus now
+    out     USBOUT, x3          ;[18] <-- ensure no pull-up resistors are active
+    rjmp    doReturn
diff --git a/firmware/usbdrv/usbdrvasm128.inc b/firmware/usbdrv/usbdrvasm128.inc
new file mode 100644
index 000000000..db8cc8277
--- /dev/null
+++ b/firmware/usbdrv/usbdrvasm128.inc
@@ -0,0 +1,752 @@
+/* Name: usbdrvasm128.inc
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2008-10-11
+ * Tabsize: 4
+ * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbdrvasm128.inc 692 2008-11-07 15:07:40Z cs $
+ */
+
+/* Do not link this file! Link usbdrvasm.S instead, which includes the
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file is the 12.8 MHz version of the USB driver. It is intended for use
+with the internal RC oscillator. Although 12.8 MHz is outside the guaranteed
+calibration range of the oscillator, almost all AVRs can reach this frequency.
+This version contains a phase locked loop in the receiver routine to cope with
+slight clock rate deviations of up to +/- 1%.
+
+See usbdrv.h for a description of the entire driver.
+
+LIMITATIONS
+===========
+Although it may seem very handy to save the crystal and use the internal
+RC oscillator of the CPU, this method (and this module) has some serious
+limitations:
+(1) The guaranteed calibration range of the oscillator is only 8.1 MHz.
+They typical range is 14.5 MHz and most AVRs can actually reach this rate.
+(2) Writing EEPROM and Flash may be unreliable (short data lifetime) since
+the write procedure is timed from the RC oscillator.
+(3) End Of Packet detection is between bit 0 and bit 1 where the EOP condition
+may not be reliable when a hub is used. It should be in bit 1.
+(4) Code size is much larger than that of the other modules.
+
+Since almost all of this code is timing critical, don't change unless you
+really know what you are doing! Many parts require not only a maximum number
+of CPU cycles, but even an exact number of cycles!
+
+Implementation notes:
+======================
+min frequency: 67 cycles for 8 bit -> 12.5625 MHz
+max frequency: 69.286 cycles for 8 bit -> 12.99 MHz
+nominal frequency: 12.77 MHz ( = sqrt(min * max))
+
+sampling positions: (next even number in range [+/- 0.5])
+cycle index range: 0 ... 66
+bits:
+.5, 8.875, 17.25, 25.625, 34, 42.375, 50.75, 59.125
+[0/1], [9], [17], [25/+26], [34], [+42/43], [51], [59]
+
+bit number:     0   1   2   3   4   5   6   7
+spare cycles    1   2   1   2   1   1   1   0
+
+operations to perform:      duration cycle
+                            ----------------
+    eor     fix, shift          1 -> 00
+    andi    phase, USBMASK      1 -> 08
+    breq    se0                 1 -> 16 (moved to 11)
+    st      y+, data            2 -> 24, 25
+    mov     data, fix           1 -> 33
+    ser     data                1 -> 41
+    subi    cnt, 1              1 -> 49
+    brcs    overflow            1 -> 50
+
+layout of samples and operations:
+[##] = sample bit
+<##> = sample phase
+*##* = operation
+
+0:  *00* [01]  02   03   04  <05>  06   07
+1:  *08* [09]  10   11   12  <13>  14   15  *16*
+2:  [17]  18   19   20  <21>  22   23
+3:  *24* *25* [26]  27   28   29  <30>  31   32
+4:  *33* [34]  35   36   37  <38>  39   40
+5:  *41* [42]  43   44   45  <46>  47   48
+6:  *49* *50* [51]  52   53   54  <55>  56   57   58
+7:  [59]  60   61   62  <63>  64   65   66
+*****************************************************************************/
+
+/* we prefer positive expressions (do if condition) instead of negative
+ * (skip if condition), therefore use defines for skip instructions:
+ */
+#define ifioclr sbis
+#define ifioset sbic
+#define ifrclr  sbrs
+#define ifrset  sbrc
+
+/* The registers "fix" and "data" swap their meaning during the loop. Use
+ * defines to keep their name constant.
+ */
+#define fix     x2
+#define data    x1
+#undef phase        /* phase has a default definition to x4 */
+#define phase   x3
+
+
+USB_INTR_VECTOR:
+;order of registers pushed: YL, SREG [sofError], YH, shift, x1, x2, x3, cnt, r0
+    push    YL              ;2 push only what is necessary to sync with edge ASAP
+    in      YL, SREG        ;1
+    push    YL              ;2
+;----------------------------------------------------------------------------
+; Synchronize with sync pattern:
+;----------------------------------------------------------------------------
+;sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
+;sync up with J to K edge during sync pattern -- use fastest possible loops
+;The first part waits at most 1 bit long since we must be in sync pattern.
+;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to
+;waitForJ, ensure that this prerequisite is met.
+waitForJ:
+    inc     YL
+    sbis    USBIN, USBMINUS
+    brne    waitForJ        ; just make sure we have ANY timeout
+waitForK:
+;The following code results in a sampling window of 1/4 bit which meets the spec.
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS ;[0]
+    rjmp    foundK          ;[1]
+#if USB_COUNT_SOF
+    lds     YL, usbSofCount
+    inc     YL
+    sts     usbSofCount, YL
+#endif  /* USB_COUNT_SOF */
+#ifdef USB_SOF_HOOK
+    USB_SOF_HOOK
+#endif
+    rjmp    sofError
+
+foundK:
+;{3, 5} after falling D- edge, average delay: 4 cycles [we want 4 for center sampling]
+;we have 1 bit time for setup purposes, then sample again. Numbers in brackets
+;are cycles from center of first sync (double K) bit after the instruction
+    push    YH                  ;[2]
+    lds     YL, usbInputBufOffset;[4]
+    clr     YH                  ;[6]
+    subi    YL, lo8(-(usbRxBuf));[7]
+    sbci    YH, hi8(-(usbRxBuf));[8]
+
+    sbis    USBIN, USBMINUS     ;[9] we want two bits K [we want to sample at 8 + 4 - 1.5 = 10.5]
+    rjmp    haveTwoBitsK        ;[10]
+    pop     YH                  ;[11] undo the push from before
+    rjmp    waitForK            ;[13] this was not the end of sync, retry
+haveTwoBitsK:
+;----------------------------------------------------------------------------
+; push more registers and initialize values while we sample the first bits:
+;----------------------------------------------------------------------------
+#define fix     x2
+#define data    x1
+
+    push    shift               ;[12]
+    push    x1                  ;[14]
+    push    x2                  ;[16]
+    ldi     shift, 0x80         ;[18] prevent bit-unstuffing but init low bits to 0
+    ifioset USBIN, USBMINUS     ;[19] [01] <--- bit 0 [10.5 + 8 = 18.5]
+    ori     shift, 1<<0         ;[02]
+    push    x3                  ;[03]
+    push    cnt                 ;[05]
+    push    r0                  ;[07]
+    ifioset USBIN, USBMINUS     ;[09] <--- bit 1
+    ori     shift, 1<<1         ;[10]
+    ser     fix                 ;[11]
+    ldi     cnt, USB_BUFSIZE    ;[12]
+    mov     data, shift         ;[13]
+    lsl     shift               ;[14]
+    nop2                        ;[15]
+    ifioset USBIN, USBMINUS     ;[17] <--- bit 2
+    ori     data, 3<<2          ;[18] store in bit 2 AND bit 3
+    eor     shift, data         ;[19] do nrzi decoding
+    andi    data, 1<<3          ;[20]
+    in      phase, USBIN        ;[21] <- phase
+    brne    jumpToEntryAfterSet ;[22] if USBMINS at bit 3 was 1
+    nop                         ;[23]
+    rjmp    entryAfterClr       ;[24]
+jumpToEntryAfterSet:
+    rjmp    entryAfterSet       ;[24]
+
+;----------------------------------------------------------------------------
+; Receiver loop (numbers in brackets are cycles within byte after instr)
+;----------------------------------------------------------------------------
+#undef  fix
+#define  fix    x1
+#undef  data
+#define data    x2
+
+bit7IsSet:
+    ifrclr  phase, USBMINUS     ;[62] check phase only if D- changed
+    lpm                         ;[63]
+    in      phase, USBIN        ;[64] <- phase (one cycle too late)
+    ori     shift, 1 << 7       ;[65]
+    nop                         ;[66]
+;;;;rjmp    bit0AfterSet        ; -> [00] == [67] moved block up to save jump
+bit0AfterSet:
+    eor     fix, shift          ;[00]
+#undef  fix
+#define fix     x2
+#undef  data
+#define data    x1  /* we now have result in data, fix is reset to 0xff */
+    ifioclr USBIN, USBMINUS     ;[01] <--- sample 0
+    rjmp    bit0IsClr           ;[02]
+    andi    shift, ~(7 << 0)    ;[03]
+    breq    unstuff0s           ;[04]
+    in      phase, USBIN        ;[05] <- phase
+    rjmp    bit1AfterSet        ;[06]
+unstuff0s:
+    in      phase, USBIN        ;[06] <- phase (one cycle too late)
+    andi    fix, ~(1 << 0)      ;[07]
+    ifioclr USBIN, USBMINUS     ;[00]
+    ifioset USBIN, USBPLUS      ;[01]
+    rjmp    bit0IsClr           ;[02] executed if first expr false or second true
+jumpToSe0AndStore:
+    rjmp    se0AndStore         ;[03] executed only if both bits 0
+bit0IsClr:
+    ifrset  phase, USBMINUS     ;[04] check phase only if D- changed
+    lpm                         ;[05]
+    in      phase, USBIN        ;[06] <- phase (one cycle too late)
+    ori     shift, 1 << 0       ;[07]
+bit1AfterClr:
+    andi    phase, USBMASK      ;[08]
+    ifioset USBIN, USBMINUS     ;[09] <--- sample 1
+    rjmp    bit1IsSet           ;[10]
+    breq    jumpToSe0AndStore   ;[11]
+    andi    shift, ~(7 << 1)    ;[12]
+    in      phase, USBIN        ;[13] <- phase
+    breq    unstuff1c           ;[14]
+    rjmp    bit2AfterClr        ;[15]
+unstuff1c:
+    andi    fix, ~(1 << 1)      ;[16]
+    nop2                        ;[08]
+    nop2                        ;[10]
+bit1IsSet:
+    ifrclr  phase, USBMINUS     ;[12] check phase only if D- changed
+    lpm                         ;[13]
+    in      phase, USBIN        ;[14] <- phase (one cycle too late)
+    ori     shift, 1 << 1       ;[15]
+    nop                         ;[16]
+bit2AfterSet:
+    ifioclr USBIN, USBMINUS     ;[17] <--- sample 2
+    rjmp    bit2IsClr           ;[18]
+    andi    shift, ~(7 << 2)    ;[19]
+    breq    unstuff2s           ;[20]
+    in      phase, USBIN        ;[21] <- phase
+    rjmp    bit3AfterSet        ;[22]
+unstuff2s:
+    in      phase, USBIN        ;[22] <- phase (one cycle too late)
+    andi    fix, ~(1 << 2)      ;[23]
+    nop2                        ;[16]
+    nop2                        ;[18]
+bit2IsClr:
+    ifrset  phase, USBMINUS     ;[20] check phase only if D- changed
+    lpm                         ;[21]
+    in      phase, USBIN        ;[22] <- phase (one cycle too late)
+    ori     shift, 1 << 2       ;[23]
+bit3AfterClr:
+    st      y+, data            ;[24]
+entryAfterClr:
+    ifioset USBIN, USBMINUS     ;[26] <--- sample 3
+    rjmp    bit3IsSet           ;[27]
+    andi    shift, ~(7 << 3)    ;[28]
+    breq    unstuff3c           ;[29]
+    in      phase, USBIN        ;[30] <- phase
+    rjmp    bit4AfterClr        ;[31]
+unstuff3c:
+    in      phase, USBIN        ;[31] <- phase (one cycle too late)
+    andi    fix, ~(1 << 3)      ;[32]
+    nop2                        ;[25]
+    nop2                        ;[27]
+bit3IsSet:
+    ifrclr  phase, USBMINUS     ;[29] check phase only if D- changed
+    lpm                         ;[30]
+    in      phase, USBIN        ;[31] <- phase (one cycle too late)
+    ori     shift, 1 << 3       ;[32]
+bit4AfterSet:
+    mov     data, fix           ;[33] undo this move by swapping defines
+#undef  fix
+#define fix     x1
+#undef  data
+#define data    x2
+    ifioclr USBIN, USBMINUS     ;[34] <--- sample 4
+    rjmp    bit4IsClr           ;[35]
+    andi    shift, ~(7 << 4)    ;[36]
+    breq    unstuff4s           ;[37]
+    in      phase, USBIN        ;[38] <- phase
+    rjmp    bit5AfterSet        ;[39]
+unstuff4s:
+    in      phase, USBIN        ;[39] <- phase (one cycle too late)
+    andi    fix, ~(1 << 4)      ;[40]
+    nop2                        ;[33]
+    nop2                        ;[35]
+bit4IsClr:
+    ifrset  phase, USBMINUS     ;[37] check phase only if D- changed
+    lpm                         ;[38]
+    in      phase, USBIN        ;[39] <- phase (one cycle too late)
+    ori     shift, 1 << 4       ;[40]
+bit5AfterClr:
+    ser     data                ;[41]
+    ifioset USBIN, USBMINUS     ;[42] <--- sample 5
+    rjmp    bit5IsSet           ;[43]
+    andi    shift, ~(7 << 5)    ;[44]
+    breq    unstuff5c           ;[45]
+    in      phase, USBIN        ;[46] <- phase
+    rjmp    bit6AfterClr        ;[47]
+unstuff5c:
+    in      phase, USBIN        ;[47] <- phase (one cycle too late)
+    andi    fix, ~(1 << 5)      ;[48]
+    nop2                        ;[41]
+    nop2                        ;[43]
+bit5IsSet:
+    ifrclr  phase, USBMINUS     ;[45] check phase only if D- changed
+    lpm                         ;[46]
+    in      phase, USBIN        ;[47] <- phase (one cycle too late)
+    ori     shift, 1 << 5       ;[48]
+bit6AfterSet:
+    subi    cnt, 1              ;[49]
+    brcs    jumpToOverflow      ;[50]
+    ifioclr USBIN, USBMINUS     ;[51] <--- sample 6
+    rjmp    bit6IsClr           ;[52]
+    andi    shift, ~(3 << 6)    ;[53]
+    cpi     shift, 2            ;[54]
+    in      phase, USBIN        ;[55] <- phase
+    brlt    unstuff6s           ;[56]
+    rjmp    bit7AfterSet        ;[57]
+
+jumpToOverflow:
+    rjmp    overflow
+
+unstuff6s:
+    andi    fix, ~(1 << 6)      ;[50]
+    lpm                         ;[51]
+bit6IsClr:
+    ifrset  phase, USBMINUS     ;[54] check phase only if D- changed
+    lpm                         ;[55]
+    in      phase, USBIN        ;[56] <- phase (one cycle too late)
+    ori     shift, 1 << 6       ;[57]
+    nop                         ;[58]
+bit7AfterClr:
+    ifioset USBIN, USBMINUS     ;[59] <--- sample 7
+    rjmp    bit7IsSet           ;[60]
+    andi    shift, ~(1 << 7)    ;[61]
+    cpi     shift, 4            ;[62]
+    in      phase, USBIN        ;[63] <- phase
+    brlt    unstuff7c           ;[64]
+    rjmp    bit0AfterClr        ;[65] -> [00] == [67]
+unstuff7c:
+    andi    fix, ~(1 << 7)      ;[58]
+    nop                         ;[59]
+    rjmp    bit7IsSet           ;[60]
+
+se0AndStore:
+    st      y+, x1              ;[15/17] cycles after start of byte
+    rjmp    se0                 ;[17/19]
+
+bit7IsClr:
+    ifrset  phase, USBMINUS     ;[62] check phase only if D- changed
+    lpm                         ;[63]
+    in      phase, USBIN        ;[64] <- phase (one cycle too late)
+    ori     shift, 1 << 7       ;[65]
+    nop                         ;[66]
+;;;;rjmp    bit0AfterClr        ; -> [00] == [67] moved block up to save jump
+bit0AfterClr:
+    eor     fix, shift          ;[00]
+#undef  fix
+#define fix     x2
+#undef  data
+#define data    x1  /* we now have result in data, fix is reset to 0xff */
+    ifioset USBIN, USBMINUS     ;[01] <--- sample 0
+    rjmp    bit0IsSet           ;[02]
+    andi    shift, ~(7 << 0)    ;[03]
+    breq    unstuff0c           ;[04]
+    in      phase, USBIN        ;[05] <- phase
+    rjmp    bit1AfterClr        ;[06]
+unstuff0c:
+    in      phase, USBIN        ;[06] <- phase (one cycle too late)
+    andi    fix, ~(1 << 0)      ;[07]
+    ifioclr USBIN, USBMINUS     ;[00]
+    ifioset USBIN, USBPLUS      ;[01]
+    rjmp    bit0IsSet           ;[02] executed if first expr false or second true
+    rjmp    se0AndStore         ;[03] executed only if both bits 0
+bit0IsSet:
+    ifrclr  phase, USBMINUS     ;[04] check phase only if D- changed
+    lpm                         ;[05]
+    in      phase, USBIN        ;[06] <- phase (one cycle too late)
+    ori     shift, 1 << 0       ;[07]
+bit1AfterSet:
+    andi    phase, USBMASK      ;[08]
+    ifioclr USBIN, USBMINUS     ;[09] <--- sample 1
+    rjmp    bit1IsClr           ;[10]
+    andi    shift, ~(7 << 1)    ;[11]
+    breq    unstuff1s           ;[12]
+    in      phase, USBIN        ;[13] <- phase
+    nop                         ;[14]
+    rjmp    bit2AfterSet        ;[15]
+unstuff1s:
+    in      phase, USBIN        ;[14] <- phase (one cycle too late)
+    andi    fix, ~(1 << 1)      ;[15]
+    nop2                        ;[08]
+    nop2                        ;[10]
+bit1IsClr:
+    ifrset  phase, USBMINUS     ;[12] check phase only if D- changed
+    lpm                         ;[13]
+    in      phase, USBIN        ;[14] <- phase (one cycle too late)
+    breq    se0AndStore         ;[15] if we come from unstuff1s, Z bit is never set
+    ori     shift, 1 << 1       ;[16]
+bit2AfterClr:
+    ifioset USBIN, USBMINUS     ;[17] <--- sample 2
+    rjmp    bit2IsSet           ;[18]
+    andi    shift, ~(7 << 2)    ;[19]
+    breq    unstuff2c           ;[20]
+    in      phase, USBIN        ;[21] <- phase
+    rjmp    bit3AfterClr        ;[22]
+unstuff2c:
+    in      phase, USBIN        ;[22] <- phase (one cycle too late)
+    andi    fix, ~(1 << 2)      ;[23]
+    nop2                        ;[16]
+    nop2                        ;[18]
+bit2IsSet:
+    ifrclr  phase, USBMINUS     ;[20] check phase only if D- changed
+    lpm                         ;[21]
+    in      phase, USBIN        ;[22] <- phase (one cycle too late)
+    ori     shift, 1 << 2       ;[23]
+bit3AfterSet:
+    st      y+, data            ;[24]
+entryAfterSet:
+    ifioclr USBIN, USBMINUS     ;[26] <--- sample 3
+    rjmp    bit3IsClr           ;[27]
+    andi    shift, ~(7 << 3)    ;[28]
+    breq    unstuff3s           ;[29]
+    in      phase, USBIN        ;[30] <- phase
+    rjmp    bit4AfterSet        ;[31]
+unstuff3s:
+    in      phase, USBIN        ;[31] <- phase (one cycle too late)
+    andi    fix, ~(1 << 3)      ;[32]
+    nop2                        ;[25]
+    nop2                        ;[27]
+bit3IsClr:
+    ifrset  phase, USBMINUS     ;[29] check phase only if D- changed
+    lpm                         ;[30]
+    in      phase, USBIN        ;[31] <- phase (one cycle too late)
+    ori     shift, 1 << 3       ;[32]
+bit4AfterClr:
+    mov     data, fix           ;[33] undo this move by swapping defines
+#undef  fix
+#define fix     x1
+#undef  data
+#define data    x2
+    ifioset USBIN, USBMINUS     ;[34] <--- sample 4
+    rjmp    bit4IsSet           ;[35]
+    andi    shift, ~(7 << 4)    ;[36]
+    breq    unstuff4c           ;[37]
+    in      phase, USBIN        ;[38] <- phase
+    rjmp    bit5AfterClr        ;[39]
+unstuff4c:
+    in      phase, USBIN        ;[39] <- phase (one cycle too late)
+    andi    fix, ~(1 << 4)      ;[40]
+    nop2                        ;[33]
+    nop2                        ;[35]
+bit4IsSet:
+    ifrclr  phase, USBMINUS     ;[37] check phase only if D- changed
+    lpm                         ;[38]
+    in      phase, USBIN        ;[39] <- phase (one cycle too late)
+    ori     shift, 1 << 4       ;[40]
+bit5AfterSet:
+    ser     data                ;[41]
+    ifioclr USBIN, USBMINUS     ;[42] <--- sample 5
+    rjmp    bit5IsClr           ;[43]
+    andi    shift, ~(7 << 5)    ;[44]
+    breq    unstuff5s           ;[45]
+    in      phase, USBIN        ;[46] <- phase
+    rjmp    bit6AfterSet        ;[47]
+unstuff5s:
+    in      phase, USBIN        ;[47] <- phase (one cycle too late)
+    andi    fix, ~(1 << 5)      ;[48]
+    nop2                        ;[41]
+    nop2                        ;[43]
+bit5IsClr:
+    ifrset  phase, USBMINUS     ;[45] check phase only if D- changed
+    lpm                         ;[46]
+    in      phase, USBIN        ;[47] <- phase (one cycle too late)
+    ori     shift, 1 << 5       ;[48]
+bit6AfterClr:
+    subi    cnt, 1              ;[49]
+    brcs    overflow            ;[50]
+    ifioset USBIN, USBMINUS     ;[51] <--- sample 6
+    rjmp    bit6IsSet           ;[52]
+    andi    shift, ~(3 << 6)    ;[53]
+    cpi     shift, 2            ;[54]
+    in      phase, USBIN        ;[55] <- phase
+    brlt    unstuff6c           ;[56]
+    rjmp    bit7AfterClr        ;[57]
+unstuff6c:
+    andi    fix, ~(1 << 6)      ;[50]
+    lpm                         ;[51]
+bit6IsSet:
+    ifrclr  phase, USBMINUS     ;[54] check phase only if D- changed
+    lpm                         ;[55]
+    in      phase, USBIN        ;[56] <- phase (one cycle too late)
+    ori     shift, 1 << 6       ;[57]
+bit7AfterSet:
+    ifioclr USBIN, USBMINUS     ;[59] <--- sample 7
+    rjmp    bit7IsClr           ;[60]
+    andi    shift, ~(1 << 7)    ;[61]
+    cpi     shift, 4            ;[62]
+    in      phase, USBIN        ;[63] <- phase
+    brlt    unstuff7s           ;[64]
+    rjmp    bit0AfterSet        ;[65] -> [00] == [67]
+unstuff7s:
+    andi    fix, ~(1 << 7)      ;[58]
+    nop                         ;[59]
+    rjmp    bit7IsClr           ;[60]
+
+macro POP_STANDARD ; 14 cycles
+    pop     r0
+    pop     cnt
+    pop     x3
+    pop     x2
+    pop     x1
+    pop     shift
+    pop     YH
+    endm
+macro POP_RETI     ; 5 cycles
+    pop     YL
+    out     SREG, YL
+    pop     YL
+    endm
+
+#include "asmcommon.inc"
+
+;----------------------------------------------------------------------------
+; Transmitting data
+;----------------------------------------------------------------------------
+
+txByteLoop:
+txBitloop:
+stuffN1Delay:                   ;     [03]
+    ror     shift               ;[-5] [11] [63]
+    brcc    doExorN1            ;[-4]      [64]
+    subi    x3, 1               ;[-3]
+    brne    commonN1            ;[-2]
+    lsl     shift               ;[-1] compensate ror after rjmp stuffDelay
+    nop                         ;[00] stuffing consists of just waiting 8 cycles
+    rjmp    stuffN1Delay        ;[01] after ror, C bit is reliably clear
+
+sendNakAndReti:
+    ldi     cnt, USBPID_NAK ;[-19]
+    rjmp    sendCntAndReti  ;[-18]
+sendAckAndReti:
+    ldi     cnt, USBPID_ACK ;[-17]
+sendCntAndReti:
+    mov     r0, cnt         ;[-16]
+    ldi     YL, 0           ;[-15] R0 address is 0
+    ldi     YH, 0           ;[-14]
+    ldi     cnt, 2          ;[-13]
+;   rjmp    usbSendAndReti      fallthrough
+
+; USB spec says:
+; idle = J
+; J = (D+ = 0), (D- = 1) or USBOUT = 0x01
+; K = (D+ = 1), (D- = 0) or USBOUT = 0x02
+; Spec allows 7.5 bit times from EOP to SOP for replies (= 60 cycles)
+
+;usbSend:
+;pointer to data in 'Y'
+;number of bytes in 'cnt' -- including sync byte
+;uses: x1...x3, shift, cnt, Y [x1 = mirror USBOUT, x2 = USBMASK, x3 = bitstuff cnt]
+;Numbers in brackets are time since first bit of sync pattern is sent (start of instruction)
+usbSendAndReti:
+    in      x2, USBDDR          ;[-10] 10 cycles until SOP
+    ori     x2, USBMASK         ;[-9]
+    sbi     USBOUT, USBMINUS    ;[-8] prepare idle state; D+ and D- must have been 0 (no pullups)
+    out     USBDDR, x2          ;[-6] <--- acquire bus
+    in      x1, USBOUT          ;[-5] port mirror for tx loop
+    ldi     shift, 0x40         ;[-4] sync byte is first byte sent (we enter loop after ror)
+    ldi     x2, USBMASK         ;[-3]
+doExorN1:
+    eor     x1, x2              ;[-2] [06] [62]
+    ldi     x3, 6               ;[-1] [07] [63]
+commonN1:
+stuffN2Delay:
+    out     USBOUT, x1          ;[00] [08] [64] <--- set bit
+    ror     shift               ;[01]
+    brcc    doExorN2            ;[02]
+    subi    x3, 1               ;[03]
+    brne    commonN2            ;[04]
+    lsl     shift               ;[05] compensate ror after rjmp stuffDelay
+    rjmp    stuffN2Delay        ;[06] after ror, C bit is reliably clear
+doExorN2:
+    eor     x1, x2              ;[04] [12]
+    ldi     x3, 6               ;[05] [13]
+commonN2:
+    nop2                        ;[06] [14]
+    subi    cnt, 171            ;[08] [16] trick: (3 * 171) & 0xff = 1
+    out     USBOUT, x1          ;[09] [17] <--- set bit
+    brcs    txBitloop           ;[10]      [27] [44]
+
+stuff6Delay:
+    ror     shift               ;[45] [53]
+    brcc    doExor6             ;[46]
+    subi    x3, 1               ;[47]
+    brne    common6             ;[48]
+    lsl     shift               ;[49] compensate ror after rjmp stuffDelay
+    nop                         ;[50] stuffing consists of just waiting 8 cycles
+    rjmp    stuff6Delay         ;[51] after ror, C bit is reliably clear
+doExor6:
+    eor     x1, x2              ;[48] [56]
+    ldi     x3, 6               ;[49]
+common6:
+stuff7Delay:
+    ror     shift               ;[50] [58]
+    out     USBOUT, x1          ;[51] <--- set bit
+    brcc    doExor7             ;[52]
+    subi    x3, 1               ;[53]
+    brne    common7             ;[54]
+    lsl     shift               ;[55] compensate ror after rjmp stuffDelay
+    rjmp    stuff7Delay         ;[56] after ror, C bit is reliably clear
+doExor7:
+    eor     x1, x2              ;[54] [62]
+    ldi     x3, 6               ;[55]
+common7:
+    ld      shift, y+           ;[56]
+    nop                         ;[58]
+    tst     cnt                 ;[59]
+    out     USBOUT, x1          ;[60] [00]<--- set bit
+    brne    txByteLoop          ;[61] [01]
+;make SE0:
+    cbr     x1, USBMASK         ;[02] prepare SE0 [spec says EOP may be 15 to 18 cycles]
+    lds     x2, usbNewDeviceAddr;[03]
+    lsl     x2                  ;[05] we compare with left shifted address
+    subi    YL, 2 + 0           ;[06] Only assign address on data packets, not ACK/NAK in r0
+    sbci    YH, 0               ;[07]
+    out     USBOUT, x1          ;[00] <-- out SE0 -- from now 2 bits = 16 cycles until bus idle
+;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
+;set address only after data packet was sent, not after handshake
+    breq    skipAddrAssign      ;[01]
+    sts     usbDeviceAddr, x2   ; if not skipped: SE0 is one cycle longer
+skipAddrAssign:
+;end of usbDeviceAddress transfer
+    ldi     x2, 1<<USB_INTR_PENDING_BIT;[03] int0 occurred during TX -- clear pending flag
+    USB_STORE_PENDING(x2)       ;[04]
+    ori     x1, USBIDLE         ;[05]
+    in      x2, USBDDR          ;[06]
+    cbr     x2, USBMASK         ;[07] set both pins to input
+    mov     x3, x1              ;[08]
+    cbr     x3, USBMASK         ;[09] configure no pullup on both pins
+    lpm                         ;[10]
+    lpm                         ;[13]
+    out     USBOUT, x1          ;[16] <-- out J (idle) -- end of SE0 (EOP signal)
+    out     USBDDR, x2          ;[17] <-- release bus now
+    out     USBOUT, x3          ;[18] <-- ensure no pull-up resistors are active
+    rjmp    doReturn
+
+
+
+/*****************************************************************************
+The following PHP script generates a code skeleton for the receiver routine:
+
+<?php
+
+function printCmdBuffer($thisBit)
+{
+global $cycle;
+
+    $nextBit = ($thisBit + 1) % 8;
+    $s = ob_get_contents();
+    ob_end_clean();
+    $s = str_replace("#", $thisBit, $s);
+    $s = str_replace("@", $nextBit, $s);
+    $lines = explode("\n", $s);
+    for($i = 0; $i < count($lines); $i++){
+        $s = $lines[$i];
+        if(ereg("\\[([0-9-][0-9])\\]", $s, $regs)){
+            $c = $cycle + (int)$regs[1];
+            $s = ereg_replace("\\[[0-9-][0-9]\\]", sprintf("[%02d]", $c), $s);
+        }
+        if(strlen($s) > 0)
+            echo "$s\n";
+    }
+}
+
+function printBit($isAfterSet, $bitNum)
+{
+    ob_start();
+    if($isAfterSet){
+?>
+    ifioclr USBIN, USBMINUS     ;[00] <--- sample
+    rjmp    bit#IsClr           ;[01]
+    andi    shift, ~(7 << #)    ;[02]
+    breq    unstuff#s           ;[03]
+    in      phase, USBIN        ;[04] <- phase
+    rjmp    bit@AfterSet        ;[05]
+unstuff#s:
+    in      phase, USBIN        ;[05] <- phase (one cycle too late)
+    andi    fix, ~(1 << #)      ;[06]
+    nop2                        ;[-1]
+    nop2                        ;[01]
+bit#IsClr:
+    ifrset  phase, USBMINUS     ;[03] check phase only if D- changed
+    lpm                         ;[04]
+    in      phase, USBIN        ;[05] <- phase (one cycle too late)
+    ori     shift, 1 << #       ;[06]
+<?php
+    }else{
+?>
+    ifioset USBIN, USBMINUS     ;[00] <--- sample
+    rjmp    bit#IsSet           ;[01]
+    andi    shift, ~(7 << #)    ;[02]
+    breq    unstuff#c           ;[03]
+    in      phase, USBIN        ;[04] <- phase
+    rjmp    bit@AfterClr        ;[05]
+unstuff#c:
+    in      phase, USBIN        ;[05] <- phase (one cycle too late)
+    andi    fix, ~(1 << #)      ;[06]
+    nop2                        ;[-1]
+    nop2                        ;[01]
+bit#IsSet:
+    ifrclr  phase, USBMINUS     ;[03] check phase only if D- changed
+    lpm                         ;[04]
+    in      phase, USBIN        ;[05] <- phase (one cycle too late)
+    ori     shift, 1 << #       ;[06]
+<?php
+    }
+    printCmdBuffer($bitNum);
+}
+
+$bitStartCycles = array(1, 9, 17, 26, 34, 42, 51, 59);
+for($i = 0; $i < 16; $i++){
+    $bit = $i % 8;
+    $emitClrCode = ($i + (int)($i / 8)) % 2;
+    $cycle = $bitStartCycles[$bit];
+    if($emitClrCode){
+        printf("bit%dAfterClr:\n", $bit);
+    }else{
+        printf("bit%dAfterSet:\n", $bit);
+    }
+    ob_start();
+    echo "    *****                       ;[-1]\n";
+    printCmdBuffer($bit);
+    printBit(!$emitClrCode, $bit);
+    if($i == 7)
+        echo "\n";
+}
+
+?>
+*****************************************************************************/
diff --git a/firmware/usbdrv/usbdrvasm15.inc b/firmware/usbdrv/usbdrvasm15.inc
new file mode 100644
index 000000000..29edee5d4
--- /dev/null
+++ b/firmware/usbdrv/usbdrvasm15.inc
@@ -0,0 +1,423 @@
+/* Name: usbdrvasm15.inc
+ * Project: AVR USB driver
+ * Author: contributed by V. Bosch
+ * Creation Date: 2007-08-06
+ * Tabsize: 4
+ * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Revision: $Id: usbdrvasm15.inc 692 2008-11-07 15:07:40Z cs $
+ */
+
+/* Do not link this file! Link usbdrvasm.S instead, which includes the
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file is the 15 MHz version of the asssembler part of the USB driver. It
+requires a 15 MHz crystal (not a ceramic resonator and not a calibrated RC
+oscillator).
+
+See usbdrv.h for a description of the entire driver.
+
+Since almost all of this code is timing critical, don't change unless you
+really know what you are doing! Many parts require not only a maximum number
+of CPU cycles, but even an exact number of cycles!
+*/
+
+;max stack usage: [ret(2), YL, SREG, YH, bitcnt, shift, x1, x2, x3, x4, cnt] = 12 bytes
+;nominal frequency: 15 MHz -> 10.0 cycles per bit, 80.0 cycles per byte
+; Numbers in brackets are clocks counted from center of last sync bit
+; when instruction starts
+
+;----------------------------------------------------------------------------
+; order of registers pushed:
+;	YL, SREG [sofError] YH, shift, x1, x2, x3, bitcnt, cnt, x4
+;----------------------------------------------------------------------------
+USB_INTR_VECTOR:
+    push    YL                   ;2 	push only what is necessary to sync with edge ASAP
+    in      YL, SREG             ;1
+    push    YL                   ;2
+;----------------------------------------------------------------------------
+; Synchronize with sync pattern:
+;
+;   sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
+;   sync up with J to K edge during sync pattern -- use fastest possible loops
+;The first part waits at most 1 bit long since we must be in sync pattern.
+;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to
+;waitForJ, ensure that this prerequisite is met.
+waitForJ:
+    inc     YL
+    sbis    USBIN, USBMINUS
+    brne    waitForJ        ; just make sure we have ANY timeout
+;-------------------------------------------------------------------------------
+; The following code results in a sampling window of < 1/4 bit
+;	which meets the spec.
+;-------------------------------------------------------------------------------
+waitForK:			 ;-
+    sbis    USBIN, USBMINUS      ;1 [00] <-- sample
+    rjmp    foundK               ;2 [01]
+    sbis    USBIN, USBMINUS	 ;	 <-- sample
+    rjmp    foundK
+    sbis    USBIN, USBMINUS	 ;	 <-- sample
+    rjmp    foundK
+    sbis    USBIN, USBMINUS	 ;	 <-- sample
+    rjmp    foundK
+    sbis    USBIN, USBMINUS	 ;	 <-- sample
+    rjmp    foundK
+    sbis    USBIN, USBMINUS	 ;	 <-- sample
+    rjmp    foundK
+#if USB_COUNT_SOF
+    lds     YL, usbSofCount
+    inc     YL
+    sts     usbSofCount, YL
+#endif  /* USB_COUNT_SOF */
+#ifdef USB_SOF_HOOK
+    USB_SOF_HOOK
+#endif
+    rjmp    sofError
+;------------------------------------------------------------------------------
+; {3, 5} after falling D- edge, average delay: 4 cycles [we want 5 for
+;	center sampling]
+; 	we have 1 bit time for setup purposes, then sample again.
+;	Numbers in brackets are cycles from center of first sync (double K)
+;	bit after the instruction
+;------------------------------------------------------------------------------
+foundK:                          ;- [02]
+    lds     YL, usbInputBufOffset;2 [03+04]	tx loop
+    push    YH                   ;2 [05+06]
+    clr     YH                   ;1 [07]
+    subi    YL, lo8(-(usbRxBuf)) ;1 [08] 	[rx loop init]
+    sbci    YH, hi8(-(usbRxBuf)) ;1 [09] 	[rx loop init]
+    push    shift                ;2 [10+11]
+    ser	    shift		 ;1 [12]
+    sbis    USBIN, USBMINUS      ;1 [-1] [13] <--sample:we want two bits K (sample 1 cycle too early)
+    rjmp    haveTwoBitsK         ;2 [00] [14]
+    pop     shift                ;2 	 [15+16] undo the push from before
+    pop     YH 			 ;2 	 [17+18] undo the push from before
+    rjmp    waitForK             ;2 	 [19+20] this was not the end of sync, retry
+; The entire loop from waitForK until rjmp waitForK above must not exceed two
+; bit times (= 20 cycles).
+
+;----------------------------------------------------------------------------
+; push more registers and initialize values while we sample the first bits:
+;----------------------------------------------------------------------------
+haveTwoBitsK:			;- [01]
+    push    x1              	;2 [02+03]
+    push    x2              	;2 [04+05]
+    push    x3              	;2 [06+07]
+    push    bitcnt              ;2 [08+09]
+    in      x1, USBIN       	;1 [00] [10] <-- sample bit 0
+    bst     x1, USBMINUS    	;1 [01]
+    bld     shift, 0        	;1 [02]
+    push    cnt             	;2 [03+04]
+    ldi     cnt, USB_BUFSIZE	;1 [05]
+    push    x4              	;2 [06+07] tx loop
+    rjmp    rxLoop          	;2 [08]
+;----------------------------------------------------------------------------
+; Receiver loop (numbers in brackets are cycles within byte after instr)
+;----------------------------------------------------------------------------
+unstuff0:               	;- [07] (branch taken)
+    andi    x3, ~0x01   	;1 [08]
+    mov     x1, x2      	;1 [09] x2 contains last sampled (stuffed) bit
+    in      x2, USBIN   	;1 [00] [10] <-- sample bit 1 again
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0Hop         	;1 [02] SE0 check for bit 1
+    ori     shift, 0x01 	;1 [03] 0b00000001
+    nop				;1 [04]
+    rjmp    didUnstuff0 	;2 [05]
+;-----------------------------------------------------
+unstuff1:               	;- [05] (branch taken)
+    mov     x2, x1      	;1 [06] x1 contains last sampled (stuffed) bit
+    andi    x3, ~0x02   	;1 [07]
+    ori     shift, 0x02 	;1 [08] 0b00000010
+    nop                 	;1 [09]
+    in      x1, USBIN   	;1 [00] [10] <-- sample bit 2 again
+    andi    x1, USBMASK 	;1 [01]
+    breq    se0Hop         	;1 [02] SE0 check for bit 2
+    rjmp    didUnstuff1 	;2 [03]
+;-----------------------------------------------------
+unstuff2:               	;- [05] (branch taken)
+    andi    x3, ~0x04   	;1 [06]
+    ori     shift, 0x04 	;1 [07] 0b00000100
+    mov     x1, x2      	;1 [08] x2 contains last sampled (stuffed) bit
+    nop                 	;1 [09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample bit 3
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0Hop         	;1 [02] SE0 check for bit 3
+    rjmp    didUnstuff2 	;2 [03]
+;-----------------------------------------------------
+unstuff3:               	;- [00] [10]  (branch taken)
+    in      x2, USBIN   	;1 [01] [11] <-- sample stuffed bit 3 one cycle too late
+    andi    x2, USBMASK 	;1 [02]
+    breq    se0Hop         	;1 [03] SE0 check for stuffed bit 3
+    andi    x3, ~0x08   	;1 [04]
+    ori     shift, 0x08 	;1 [05] 0b00001000
+    rjmp    didUnstuff3 	;2 [06]
+;----------------------------------------------------------------------------
+; extra jobs done during bit interval:
+;
+; bit 0:    store, clear [SE0 is unreliable here due to bit dribbling in hubs],
+; 		overflow check, jump to the head of rxLoop
+; bit 1:    SE0 check
+; bit 2:    SE0 check, recovery from delay [bit 0 tasks took too long]
+; bit 3:    SE0 check, recovery from delay [bit 0 tasks took too long]
+; bit 4:    SE0 check, none
+; bit 5:    SE0 check, none
+; bit 6:    SE0 check, none
+; bit 7:    SE0 check, reconstruct: x3 is 0 at bit locations we changed, 1 at others
+;----------------------------------------------------------------------------
+rxLoop:				;- [09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample bit 1 (or possibly bit 0 stuffed)
+    andi    x2, USBMASK 	;1 [01]
+    brne    SkipSe0Hop		;1 [02]
+se0Hop:				;- [02]
+    rjmp    se0         	;2 [03] SE0 check for bit 1
+SkipSe0Hop:			;- [03]
+    ser     x3          	;1 [04]
+    andi    shift, 0xf9 	;1 [05] 0b11111001
+    breq    unstuff0    	;1 [06]
+didUnstuff0:			;- [06]
+    eor     x1, x2      	;1 [07]
+    bst     x1, USBMINUS	;1 [08]
+    bld     shift, 1    	;1 [09]
+    in      x1, USBIN   	;1 [00] [10] <-- sample bit 2 (or possibly bit 1 stuffed)
+    andi    x1, USBMASK 	;1 [01]
+    breq    se0Hop         	;1 [02] SE0 check for bit 2
+    andi    shift, 0xf3 	;1 [03] 0b11110011
+    breq    unstuff1    	;1 [04] do remaining work for bit 1
+didUnstuff1:			;- [04]
+    eor     x2, x1      	;1 [05]
+    bst     x2, USBMINUS	;1 [06]
+    bld     shift, 2    	;1 [07]
+    nop2			;2 [08+09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample bit 3 (or possibly bit 2 stuffed)
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0Hop         	;1 [02] SE0 check for bit 3
+    andi    shift, 0xe7 	;1 [03] 0b11100111
+    breq    unstuff2    	;1 [04]
+didUnstuff2:			;- [04]
+    eor     x1, x2      	;1 [05]
+    bst     x1, USBMINUS	;1 [06]
+    bld     shift, 3    	;1 [07]
+didUnstuff3:			;- [07]
+    andi    shift, 0xcf 	;1 [08] 0b11001111
+    breq    unstuff3    	;1 [09]
+    in      x1, USBIN   	;1 [00] [10] <-- sample bit 4
+    andi    x1, USBMASK 	;1 [01]
+    breq    se0Hop         	;1 [02] SE0 check for bit 4
+    eor     x2, x1      	;1 [03]
+    bst     x2, USBMINUS	;1 [04]
+    bld     shift, 4    	;1 [05]
+didUnstuff4:			;- [05]
+    andi    shift, 0x9f 	;1 [06] 0b10011111
+    breq    unstuff4    	;1 [07]
+    nop2			;2 [08+09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample bit 5
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for bit 5
+    eor     x1, x2      	;1 [03]
+    bst     x1, USBMINUS	;1 [04]
+    bld     shift, 5    	;1 [05]
+didUnstuff5:			;- [05]
+    andi    shift, 0x3f 	;1 [06] 0b00111111
+    breq    unstuff5    	;1 [07]
+    nop2			;2 [08+09]
+    in      x1, USBIN   	;1 [00] [10] <-- sample bit 6
+    andi    x1, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for bit 6
+    eor     x2, x1      	;1 [03]
+    bst     x2, USBMINUS	;1 [04]
+    bld     shift, 6   	 	;1 [05]
+didUnstuff6:			;- [05]
+    cpi     shift, 0x02 	;1 [06] 0b00000010
+    brlo    unstuff6    	;1 [07]
+    nop2			;2 [08+09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample bit 7
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for bit 7
+    eor     x1, x2      	;1 [03]
+    bst     x1, USBMINUS	;1 [04]
+    bld     shift, 7    	;1 [05]
+didUnstuff7:			;- [05]
+    cpi     shift, 0x04 	;1 [06] 0b00000100
+    brlo    unstuff7		;1 [07]
+    eor     x3, shift   	;1 [08] reconstruct: x3 is 0 at bit locations we changed, 1 at others
+    nop				;1 [09]
+    in      x1, USBIN   	;1 [00]	[10] <-- sample bit 0
+    st      y+, x3      	;2 [01+02] store data
+    eor     x2, x1      	;1 [03]
+    bst     x2, USBMINUS	;1 [04]
+    bld     shift, 0    	;1 [05]
+    subi    cnt, 1		;1 [06]
+    brcs    overflow	;1 [07]
+    rjmp    rxLoop		;2 [08]
+;-----------------------------------------------------
+unstuff4:               	;- [08]
+    andi    x3, ~0x10   	;1 [09]
+    in      x1, USBIN   	;1 [00] [10] <-- sample stuffed bit 4
+    andi    x1, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for stuffed bit 4
+    ori     shift, 0x10 	;1 [03]
+    rjmp    didUnstuff4 	;2 [04]
+;-----------------------------------------------------
+unstuff5:               	;- [08]
+    ori     shift, 0x20 	;1 [09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample stuffed bit 5
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for stuffed bit 5
+    andi    x3, ~0x20   	;1 [03]
+    rjmp    didUnstuff5		;2 [04]
+;-----------------------------------------------------
+unstuff6:               	;- [08]
+    andi    x3, ~0x40   	;1 [09]
+    in      x1, USBIN   	;1 [00] [10] <-- sample stuffed bit 6
+    andi    x1, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for stuffed bit 6
+    ori     shift, 0x40 	;1 [03]
+    rjmp    didUnstuff6 	;2 [04]
+;-----------------------------------------------------
+unstuff7:			;- [08]
+    andi    x3, ~0x80   	;1 [09]
+    in      x2, USBIN   	;1 [00] [10] <-- sample stuffed bit 7
+    andi    x2, USBMASK 	;1 [01]
+    breq    se0         	;1 [02] SE0 check for stuffed bit 7
+    ori     shift, 0x80 	;1 [03]
+    rjmp    didUnstuff7 	;2 [04]
+
+macro POP_STANDARD ; 16 cycles
+    pop     x4
+    pop     cnt
+    pop     bitcnt
+    pop     x3
+    pop     x2
+    pop     x1
+    pop     shift
+    pop     YH
+    endm
+macro POP_RETI     ; 5 cycles
+    pop     YL
+    out     SREG, YL
+    pop     YL
+    endm
+
+#include "asmcommon.inc"
+
+;---------------------------------------------------------------------------
+; USB spec says:
+; idle = J
+; J = (D+ = 0), (D- = 1)
+; K = (D+ = 1), (D- = 0)
+; Spec allows 7.5 bit times from EOP to SOP for replies
+;---------------------------------------------------------------------------
+bitstuffN:		    	;- [04]
+    eor     x1, x4          	;1 [05]
+    clr	    x2			;1 [06]
+    nop				;1 [07]
+    rjmp    didStuffN       	;1 [08]
+;---------------------------------------------------------------------------
+bitstuff6:		    	;- [04]
+    eor     x1, x4          	;1 [05]
+    clr	    x2			;1 [06]
+    rjmp    didStuff6       	;1 [07]
+;---------------------------------------------------------------------------
+bitstuff7:		    	;- [02]
+    eor     x1, x4          	;1 [03]
+    clr	    x2			;1 [06]
+    nop			    	;1 [05]
+    rjmp    didStuff7       	;1 [06]
+;---------------------------------------------------------------------------
+sendNakAndReti:			;- [-19]
+    ldi     x3, USBPID_NAK  	;1 [-18]
+    rjmp    sendX3AndReti   	;1 [-17]
+;---------------------------------------------------------------------------
+sendAckAndReti:			;- [-17]
+    ldi     cnt, USBPID_ACK 	;1 [-16]
+sendCntAndReti:			;- [-16]
+    mov     x3, cnt         	;1 [-15]
+sendX3AndReti:			;- [-15]
+    ldi     YL, 20          	;1 [-14] x3==r20 address is 20
+    ldi     YH, 0           	;1 [-13]
+    ldi     cnt, 2          	;1 [-12]
+;   rjmp    usbSendAndReti      fallthrough
+;---------------------------------------------------------------------------
+;usbSend:
+;pointer to data in 'Y'
+;number of bytes in 'cnt' -- including sync byte [range 2 ... 12]
+;uses: x1...x4, btcnt, shift, cnt, Y
+;Numbers in brackets are time since first bit of sync pattern is sent
+;We need not to match the transfer rate exactly because the spec demands
+;only 1.5% precision anyway.
+usbSendAndReti:             	;- [-13] 13 cycles until SOP
+    in      x2, USBDDR      	;1 [-12]
+    ori     x2, USBMASK     	;1 [-11]
+    sbi     USBOUT, USBMINUS	;2 [-09-10] prepare idle state; D+ and D- must have been 0 (no pullups)
+    in      x1, USBOUT      	;1 [-08] port mirror for tx loop
+    out     USBDDR, x2      	;1 [-07] <- acquire bus
+	; need not init x2 (bitstuff history) because sync starts with 0
+    ldi     x4, USBMASK     	;1 [-06] 	exor mask
+    ldi     shift, 0x80     	;1 [-05] 	sync byte is first byte sent
+    ldi     bitcnt, 6    	;1 [-04]
+txBitLoop:		    	;- [-04] [06]
+    sbrs    shift, 0        	;1 [-03] [07]
+    eor     x1, x4          	;1 [-02] [08]
+    ror     shift           	;1 [-01] [09]
+didStuffN:		    	;-       [09]
+    out     USBOUT, x1      	;1 [00]  [10] <-- out N
+    ror     x2              	;1 [01]
+    cpi     x2, 0xfc        	;1 [02]
+    brcc    bitstuffN       	;1 [03]
+    dec     bitcnt          	;1 [04]
+    brne    txBitLoop       	;1 [05]
+    sbrs    shift, 0        	;1 [06]
+    eor     x1, x4          	;1 [07]
+    ror     shift           	;1 [08]
+didStuff6:			;- [08]
+    nop				;1 [09]
+    out     USBOUT, x1      	;1 [00] [10] <-- out 6
+    ror     x2              	;1 [01]
+    cpi     x2, 0xfc        	;1 [02]
+    brcc    bitstuff6       	;1 [03]
+    sbrs    shift, 0        	;1 [04]
+    eor     x1, x4          	;1 [05]
+    ror     shift           	;1 [06]
+    ror     x2              	;1 [07]
+didStuff7:			;- [07]
+    ldi     bitcnt, 6    	;1 [08]
+    cpi     x2, 0xfc        	;1 [09]
+    out     USBOUT, x1      	;1 [00] [10] <-- out 7
+    brcc    bitstuff7       	;1 [01]
+    ld      shift, y+       	;2 [02+03]
+    dec     cnt             	;1 [04]
+    brne    txBitLoop      	;1 [05]
+makeSE0:
+    cbr     x1, USBMASK     	;1 [06] 	prepare SE0 [spec says EOP may be 19 to 23 cycles]
+    lds     x2, usbNewDeviceAddr;2 [07+08]
+    lsl     x2                  ;1 [09] we compare with left shifted address
+;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
+;set address only after data packet was sent, not after handshake
+    out     USBOUT, x1      	;1 [00] [10] <-- out SE0-- from now 2 bits==20 cycl. until bus idle
+    subi    YL, 20 + 2          ;1 [01] Only assign address on data packets, not ACK/NAK in x3
+    sbci    YH, 0           	;1 [02]
+    breq    skipAddrAssign  	;1 [03]
+    sts     usbDeviceAddr, x2	;2 [04+05] if not skipped: SE0 is one cycle longer
+;----------------------------------------------------------------------------
+;end of usbDeviceAddress transfer
+skipAddrAssign:				;- [03/04]
+    ldi     x2, 1<<USB_INTR_PENDING_BIT	;1 [05] int0 occurred during TX -- clear pending flag
+    USB_STORE_PENDING(x2)           ;1 [06]
+    ori     x1, USBIDLE     		;1 [07]
+    in      x2, USBDDR      		;1 [08]
+    cbr     x2, USBMASK     		;1 [09] set both pins to input
+    mov     x3, x1          		;1 [10]
+    cbr     x3, USBMASK     		;1 [11] configure no pullup on both pins
+    ldi     x4, 3           		;1 [12]
+se0Delay:				;- [12] [15]
+    dec     x4              		;1 [13] [16]
+    brne    se0Delay        		;1 [14] [17]
+    nop2				;2      [18+19]
+    out     USBOUT, x1      		;1      [20] <--out J (idle) -- end of SE0 (EOP sig.)
+    out     USBDDR, x2      		;1      [21] <--release bus now
+    out     USBOUT, x3      		;1      [22] <--ensure no pull-up resistors are active
+    rjmp    doReturn			;1	[23]
+;---------------------------------------------------------------------------
diff --git a/firmware/usbdrv/usbdrvasm16.S b/firmware/usbdrv/usbdrvasm16.inc
similarity index 53%
rename from firmware/usbdrv/usbdrvasm16.S
rename to firmware/usbdrv/usbdrvasm16.inc
index ae4121dd5..1a1add5ab 100644
--- a/firmware/usbdrv/usbdrvasm16.S
+++ b/firmware/usbdrv/usbdrvasm16.inc
@@ -1,11 +1,11 @@
-/* Name: usbdrvasm16.S
+/* Name: usbdrvasm16.inc
  * Project: AVR USB driver
  * Author: Christian Starkjohann
  * Creation Date: 2007-06-15
  * Tabsize: 4
  * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * Revision: $Id$
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Revision: $Id: usbdrvasm16.inc 692 2008-11-07 15:07:40Z cs $
  */
 
 /* Do not link this file! Link usbdrvasm.S instead, which includes the
@@ -30,7 +30,7 @@ of CPU cycles, but even an exact number of cycles!
 ; Numbers in brackets are clocks counted from center of last sync bit
 ; when instruction starts
 
-SIG_INTERRUPT0:
+USB_INTR_VECTOR:
 ;order of registers pushed: YL, SREG YH, [sofError], bitcnt, shift, x1, x2, x3, x4, cnt
     push    YL                  ;[-25] push only what is necessary to sync with edge ASAP
     in      YL, SREG            ;[-23]
@@ -41,10 +41,13 @@ SIG_INTERRUPT0:
 ;----------------------------------------------------------------------------
 ;sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
 ;sync up with J to K edge during sync pattern -- use fastest possible loops
-;first part has no timeout because it waits for IDLE or SE1 (== disconnected)
+;The first part waits at most 1 bit long since we must be in sync pattern.
+;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to
+;waitForJ, ensure that this prerequisite is met.
 waitForJ:
-    sbis    USBIN, USBMINUS     ;[-18] wait for D- == 1
-    rjmp    waitForJ
+    inc     YL
+    sbis    USBIN, USBMINUS
+    brne    waitForJ        ; just make sure we have ANY timeout
 waitForK:
 ;The following code results in a sampling window of < 1/4 bit which meets the spec.
     sbis    USBIN, USBMINUS     ;[-15]
@@ -59,6 +62,14 @@ waitForK:
     rjmp    foundK
     sbis    USBIN, USBMINUS
     rjmp    foundK
+#if USB_COUNT_SOF
+    lds     YL, usbSofCount
+    inc     YL
+    sts     usbSofCount, YL
+#endif  /* USB_COUNT_SOF */
+#ifdef USB_SOF_HOOK
+    USB_SOF_HOOK
+#endif
     rjmp    sofError
 foundK:                         ;[-12]
 ;{3, 5} after falling D- edge, average delay: 4 cycles [we want 5 for center sampling]
@@ -193,47 +204,9 @@ didUnstuffO:
     subi    cnt, 1      ;[10]
     in      x1, USBIN   ;[00] [11] <-- sample bit 6
     brcc    rxByteLoop  ;[01]
-    rjmp    ignorePacket; overflow
-
-;----------------------------------------------------------------------------
-; Processing of received packet (numbers in brackets are cycles after center of SE0)
-;----------------------------------------------------------------------------
-;This is the only non-error exit point for the software receiver loop
-;we don't check any CRCs here because there is no time left.
-#define token   x1
-se0:
-    subi    cnt, USB_BUFSIZE    ;[5]
-    neg     cnt                 ;[6]
-    cpi     cnt, 3              ;[7]
-    ldi     x2, 1<<USB_INTR_PENDING_BIT ;[8]
-    out     USB_INTR_PENDING, x2;[9] clear pending intr and check flag later. SE0 should be over.
-    brlo    doReturn            ;[10] this is probably an ACK, NAK or similar packet
-    sub     YL, cnt             ;[11]
-    sbci    YH, 0               ;[12]
-    ld      token, y            ;[13]
-    cpi     token, USBPID_DATA0 ;[15]
-    breq    handleData          ;[16]
-    cpi     token, USBPID_DATA1 ;[17]
-    breq    handleData          ;[18]
-    ldd     x2, y+1             ;[19] ADDR and 1 bit endpoint number
-    mov     x3, x2              ;[21] store for endpoint number
-    andi    x2, 0x7f            ;[22] x2 is now ADDR
-    lds     shift, usbDeviceAddr;[23]
-    cp      x2, shift           ;[25]
-overflow:                       ; This is a hack: brcs overflow will never have Z flag set
-    brne    ignorePacket        ;[26] packet for different address
-    cpi     token, USBPID_IN    ;[27]
-    breq    handleIn            ;[28]
-    cpi     token, USBPID_SETUP ;[29]
-    breq    handleSetupOrOut    ;[30]
-    cpi     token, USBPID_OUT   ;[31]
-    breq    handleSetupOrOut    ;[32]
-;   rjmp    ignorePacket        ;fallthrough, should not happen anyway.
+    rjmp    overflow
 
-ignorePacket:
-    clr     shift
-    sts     usbCurrentTok, shift
-doReturn:
+macro POP_STANDARD ; 14 cycles
     pop     cnt
     pop     x4
     pop     x3
@@ -241,111 +214,15 @@ doReturn:
     pop     x1
     pop     shift
     pop     bitcnt
-sofError:
+    endm
+macro POP_RETI     ; 7 cycles
     pop     YH
     pop     YL
     out     SREG, YL
     pop     YL
-    reti
-
-#if USB_CFG_HAVE_INTRIN_ENDPOINT && USB_CFG_HAVE_INTRIN_ENDPOINT3
-handleIn3:
-    lds     cnt, usbTxLen3      ;[43]
-    sbrc    cnt, 4              ;[45]
-    rjmp    sendCntAndReti      ;[46] 48 + 16 = 64 until SOP
-    sts     usbTxLen3, x1       ;[47] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf3)  ;[49]
-    ldi     YH, hi8(usbTxBuf3)  ;[50]
-    rjmp    usbSendAndReti      ;[51] 53 + 12 = 65 until SOP
-#endif
-
-;Setup and Out are followed by a data packet two bit times (16 cycles) after
-;the end of SE0. The sync code allows up to 40 cycles delay from the start of
-;the sync pattern until the first bit is sampled. That's a total of 56 cycles.
-handleSetupOrOut:               ;[34]
-#if USB_CFG_IMPLEMENT_FN_WRITEOUT   /* if we have data for second OUT endpoint, set usbCurrentTok to -1 */
-    sbrc    x3, 7               ;[34] skip if endpoint 0
-    ldi     token, -1           ;[35] indicate that this is endpoint 1 OUT
-#endif
-    sts     usbCurrentTok, token;[36]
-    pop     cnt                 ;[38]
-    pop     x4                  ;[40]
-    pop     x3                  ;[42]
-    pop     x2                  ;[44]
-    pop     x1                  ;[46]
-    pop     shift               ;[48]
-    pop     bitcnt              ;[50]
-    in      YL, USB_INTR_PENDING;[52]
-    sbrc    YL, USB_INTR_PENDING_BIT;[53] check whether data is already arriving
-    rjmp    waitForJ            ;[54] save the pops and pushes -- a new interrupt is aready pending
-    rjmp    sofError            ;[55] not an error, but it does the pops and reti we want
-
-
-handleData:
-    lds     token, usbCurrentTok;[20]
-    tst     token               ;[22]
-    breq    doReturn            ;[23]
-    lds     x2, usbRxLen        ;[24]
-    tst     x2                  ;[26]
-    brne    sendNakAndReti      ;[27]
-; 2006-03-11: The following two lines fix a problem where the device was not
-; recognized if usbPoll() was called less frequently than once every 4 ms.
-    cpi     cnt, 4              ;[28] zero sized data packets are status phase only -- ignore and ack
-    brmi    sendAckAndReti      ;[29] keep rx buffer clean -- we must not NAK next SETUP
-    sts     usbRxLen, cnt       ;[30] store received data, swap buffers
-    sts     usbRxToken, token   ;[32]
-    lds     x2, usbInputBufOffset;[34] swap buffers
-    ldi     cnt, USB_BUFSIZE    ;[36]
-    sub     cnt, x2             ;[37]
-    sts     usbInputBufOffset, cnt;[38] buffers now swapped
-    rjmp    sendAckAndReti      ;[40] 42 + 17 = 59 until SOP
-
-handleIn:
-;We don't send any data as long as the C code has not processed the current
-;input data and potentially updated the output data. That's more efficient
-;in terms of code size than clearing the tx buffers when a packet is received.
-    lds     x1, usbRxLen        ;[30]
-    cpi     x1, 1               ;[32] negative values are flow control, 0 means "buffer free"
-    brge    sendNakAndReti      ;[33] unprocessed input packet?
-    ldi     x1, USBPID_NAK      ;[34] prepare value for usbTxLen
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-    sbrc    x3, 7               ;[35] x3 contains addr + endpoint
-    rjmp    handleIn1           ;[36]
-#endif
-    lds     cnt, usbTxLen       ;[37]
-    sbrc    cnt, 4              ;[39] all handshake tokens have bit 4 set
-    rjmp    sendCntAndReti      ;[40] 42 + 16 = 58 until SOP
-    sts     usbTxLen, x1        ;[41] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf)   ;[43]
-    ldi     YH, hi8(usbTxBuf)   ;[44]
-    rjmp    usbSendAndReti      ;[45] 47 + 12 = 59 until SOP
-
-; Comment about when to set usbTxLen to USBPID_NAK:
-; We should set it back when we receive the ACK from the host. This would
-; be simple to implement: One static variable which stores whether the last
-; tx was for endpoint 0 or 1 and a compare in the receiver to distinguish the
-; ACK. However, we set it back immediately when we send the package,
-; assuming that no error occurs and the host sends an ACK. We save one byte
-; RAM this way and avoid potential problems with endless retries. The rest of
-; the driver assumes error-free transfers anyway.
-
-#if USB_CFG_HAVE_INTRIN_ENDPOINT    /* placed here due to relative jump range */
-handleIn1:                      ;[38]
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-; 2006-06-10 as suggested by O.Tamura: support second INTR IN / BULK IN endpoint
-    ldd     x2, y+2             ;[38]
-    sbrc    x2, 0               ;[40]
-    rjmp    handleIn3           ;[41]
-#endif
-    lds     cnt, usbTxLen1      ;[42]
-    sbrc    cnt, 4              ;[44] all handshake tokens have bit 4 set
-    rjmp    sendCntAndReti      ;[45] 47 + 16 = 63 until SOP
-    sts     usbTxLen1, x1       ;[46] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf1)  ;[48]
-    ldi     YH, hi8(usbTxBuf1)  ;[49]
-    rjmp    usbSendAndReti      ;[50] 52 + 12 + 64 until SOP
-#endif
+    endm
 
+#include "asmcommon.inc"
 
 ; USB spec says:
 ; idle = J
@@ -362,15 +239,14 @@ bitstuffN:
     rjmp    didStuffN       ;[0]
 
 bitstuff6:
-    eor     x1, x4          ;[4]
-    ldi     x2, 0           ;[5]
-    nop2                    ;[6] C is zero (brcc)
+    eor     x1, x4          ;[5]
+    ldi     x2, 0           ;[6] Carry is zero due to brcc
+    rol     shift           ;[7] compensate for ror shift at branch destination
     rjmp    didStuff6       ;[8]
 
 bitstuff7:
-    eor     x1, x4          ;[3]
-    ldi     x2, 0           ;[4]
-    rjmp    didStuff7       ;[5]
+    ldi     x2, 0           ;[2] Carry is zero due to brcc
+    rjmp    didStuff7       ;[3]
 
 
 sendNakAndReti:
@@ -403,7 +279,7 @@ usbSendAndReti:             ; 12 cycles until SOP
     ldi     x4, USBMASK     ;[-6] exor mask
     ldi     shift, 0x80     ;[-5] sync byte is first byte sent
 txByteLoop:
-    ldi     bitcnt, 0x2a    ;[-4] [6] binary 00101010
+    ldi     bitcnt, 0x35    ;[-4] [6] binary 0011 0101
 txBitLoop:
     sbrs    shift, 0        ;[-3] [7]
     eor     x1, x4          ;[-2] [8]
@@ -419,49 +295,49 @@ didStuffN:
 
     sbrs    shift, 0        ;[7]
     eor     x1, x4          ;[8]
-    ror     shift           ;[9]
 didStuff6:
-    out     USBOUT, x1      ;[-1] [10] <-- out 6
-    ror     x2              ;[0] [11]
-    cpi     x2, 0xfc        ;[1]
-    brcc    bitstuff6       ;[2]
-    sbrs    shift, 0        ;[3]
-    eor     x1, x4          ;[4]
-    ror     shift           ;[5]
-    ror     x2              ;[6]
+    out     USBOUT, x1      ;[-1] [9] <-- out 6
+    ror     shift           ;[0] [10]
+    ror     x2              ;[1]
+    cpi     x2, 0xfc        ;[2]
+    brcc    bitstuff6       ;[3]
+    ror     shift           ;[4]
 didStuff7:
-    nop                     ;[7]
-    nop2                    ;[8]
+    ror     x2              ;[5]
+    sbrs    x2, 7           ;[6]
+    eor     x1, x4          ;[7]
+    nop                     ;[8]
+    cpi     x2, 0xfc        ;[9]
     out     USBOUT, x1      ;[-1][10] <-- out 7
-    cpi     x2, 0xfc        ;[0] [11]
-    brcc    bitstuff7       ;[1]
-    ld      shift, y+       ;[2]
-    dec     cnt             ;[4]
+    brcc    bitstuff7       ;[0] [11]
+    ld      shift, y+       ;[1]
+    dec     cnt             ;[3]
     brne    txByteLoop      ;[4]
 ;make SE0:
-    cbr     x1, USBMASK     ;[7] prepare SE0 [spec says EOP may be 21 to 25 cycles]
-    lds     x2, usbNewDeviceAddr;[8]
-    out     USBOUT, x1      ;[10] <-- out SE0 -- from now 2 bits = 22 cycles until bus idle
+    cbr     x1, USBMASK     ;[5] prepare SE0 [spec says EOP may be 21 to 25 cycles]
+    lds     x2, usbNewDeviceAddr;[6]
+    lsl     x2              ;[8] we compare with left shifted address
+    subi    YL, 20 + 2      ;[9] Only assign address on data packets, not ACK/NAK in x3
+    sbci    YH, 0           ;[10]
+    out     USBOUT, x1      ;[11] <-- out SE0 -- from now 2 bits = 22 cycles until bus idle
 ;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
 ;set address only after data packet was sent, not after handshake
-    subi    YL, 2           ;[0]
-    sbci    YH, 0           ;[1]
-    breq    skipAddrAssign  ;[2]
+    breq    skipAddrAssign  ;[0]
     sts     usbDeviceAddr, x2; if not skipped: SE0 is one cycle longer
 skipAddrAssign:
 ;end of usbDeviceAddress transfer
-    ldi     x2, 1<<USB_INTR_PENDING_BIT;[4] int0 occurred during TX -- clear pending flag
-    out     USB_INTR_PENDING, x2;[5]
-    ori     x1, USBIDLE     ;[6]
-    in      x2, USBDDR      ;[7]
-    cbr     x2, USBMASK     ;[8] set both pins to input
-    mov     x3, x1          ;[9]
-    cbr     x3, USBMASK     ;[10] configure no pullup on both pins
-    ldi     x4, 4           ;[11]
+    ldi     x2, 1<<USB_INTR_PENDING_BIT;[2] int0 occurred during TX -- clear pending flag
+    USB_STORE_PENDING(x2)   ;[3]
+    ori     x1, USBIDLE     ;[4]
+    in      x2, USBDDR      ;[5]
+    cbr     x2, USBMASK     ;[6] set both pins to input
+    mov     x3, x1          ;[7]
+    cbr     x3, USBMASK     ;[8] configure no pullup on both pins
+    ldi     x4, 4           ;[9]
 se0Delay:
-    dec     x4              ;[12] [15] [18] [21]
-    brne    se0Delay        ;[13] [16] [19] [22]
-    out     USBOUT, x1      ;[23] <-- out J (idle) -- end of SE0 (EOP signal)
-    out     USBDDR, x2      ;[24] <-- release bus now
-    out     USBOUT, x3      ;[25] <-- ensure no pull-up resistors are active
+    dec     x4              ;[10] [13] [16] [19]
+    brne    se0Delay        ;[11] [14] [17] [20]
+    out     USBOUT, x1      ;[21] <-- out J (idle) -- end of SE0 (EOP signal)
+    out     USBDDR, x2      ;[22] <-- release bus now
+    out     USBOUT, x3      ;[23] <-- ensure no pull-up resistors are active
     rjmp    doReturn
diff --git a/firmware/usbdrv/usbdrvasm165.S b/firmware/usbdrv/usbdrvasm165.inc
similarity index 67%
rename from firmware/usbdrv/usbdrvasm165.S
rename to firmware/usbdrv/usbdrvasm165.inc
index 23261e813..0b252e6ce 100644
--- a/firmware/usbdrv/usbdrvasm165.S
+++ b/firmware/usbdrv/usbdrvasm165.inc
@@ -1,11 +1,11 @@
-/* Name: usbdrvasm165.S
+/* Name: usbdrvasm165.inc
  * Project: AVR USB driver
  * Author: Christian Starkjohann
  * Creation Date: 2007-04-22
  * Tabsize: 4
  * Copyright: (c) 2007 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
- * Revision: $Id$
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Revision: $Id: usbdrvasm165.inc 692 2008-11-07 15:07:40Z cs $
  */
 
 /* Do not link this file! Link usbdrvasm.S instead, which includes the
@@ -36,20 +36,23 @@ of CPU cycles, but even an exact number of cycles!
 ; when instruction starts
 
 
-SIG_INTERRUPT0:
-;order of registers pushed: r0, SREG [sofError], YL, YH, shift, x1, x2, x3, x4, cnt
-    push    r0                  ;[-23] push only what is necessary to sync with edge ASAP
-    in      r0, SREG            ;[-21]
-    push    r0                  ;[-20]
+USB_INTR_VECTOR:
+;order of registers pushed: YL, SREG [sofError], r0, YH, shift, x1, x2, x3, x4, cnt
+    push    YL                  ;[-23] push only what is necessary to sync with edge ASAP
+    in      YL, SREG            ;[-21]
+    push    YL                  ;[-20]
 ;----------------------------------------------------------------------------
 ; Synchronize with sync pattern:
 ;----------------------------------------------------------------------------
 ;sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
 ;sync up with J to K edge during sync pattern -- use fastest possible loops
-;first part has no timeout because it waits for IDLE or SE1 (== disconnected)
+;The first part waits at most 1 bit long since we must be in sync pattern.
+;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to
+;waitForJ, ensure that this prerequisite is met.
 waitForJ:
-    sbis    USBIN, USBMINUS     ;[-18] wait for D- == 1
-    rjmp    waitForJ
+    inc     YL
+    sbis    USBIN, USBMINUS
+    brne    waitForJ        ; just make sure we have ANY timeout
 waitForK:
 ;The following code results in a sampling window of < 1/4 bit which meets the spec.
     sbis    USBIN, USBMINUS     ;[-15]
@@ -64,12 +67,20 @@ waitForK:
     rjmp    foundK
     sbis    USBIN, USBMINUS
     rjmp    foundK
+#if USB_COUNT_SOF
+    lds     YL, usbSofCount
+    inc     YL
+    sts     usbSofCount, YL
+#endif  /* USB_COUNT_SOF */
+#ifdef USB_SOF_HOOK
+    USB_SOF_HOOK
+#endif
     rjmp    sofError
 foundK:                         ;[-12]
 ;{3, 5} after falling D- edge, average delay: 4 cycles [we want 5 for center sampling]
 ;we have 1 bit time for setup purposes, then sample again. Numbers in brackets
 ;are cycles from center of first sync (double K) bit after the instruction
-    push    YL                  ;[-12]
+    push    r0                  ;[-12]
 ;   [---]                       ;[-11]
     push    YH                  ;[-10]
 ;   [---]                       ;[-9]
@@ -82,7 +93,7 @@ foundK:                         ;[-12]
     sbis    USBIN, USBMINUS     ;[-2] we want two bits K (sample 2 cycles too early)
     rjmp    haveTwoBitsK        ;[-1]
     pop     YH                  ;[0] undo the pushes from before
-    pop     YL                  ;[2]
+    pop     r0                  ;[2]
     rjmp    waitForK            ;[4] this was not the end of sync, retry
 ; The entire loop from waitForK until rjmp waitForK above must not exceed two
 ; bit times (= 22 cycles).
@@ -320,45 +331,7 @@ didUnstuff4:                ;[   ]
     rjmp    continueWithBit5;[053]
 ;   [---]                   ;[054]
 
-;----------------------------------------------------------------------------
-; Processing of received packet (numbers in brackets are cycles after center of SE0)
-;----------------------------------------------------------------------------
-;This is the only non-error exit point for the software receiver loop
-;we don't check any CRCs here because there is no time left.
-#define token   x1
-se0:
-    subi    cnt, USB_BUFSIZE    ;[5]
-    neg     cnt                 ;[6]
-    cpi     cnt, 3              ;[7]
-    ldi     x2, 1<<USB_INTR_PENDING_BIT ;[8]
-    out     USB_INTR_PENDING, x2;[9] clear pending intr and check flag later. SE0 should be over.
-    brlo    doReturn            ;[10] this is probably an ACK, NAK or similar packet
-    sub     YL, cnt             ;[11]
-    sbci    YH, 0               ;[12]
-    ld      token, y            ;[13]
-    cpi     token, USBPID_DATA0 ;[15]
-    breq    handleData          ;[16]
-    cpi     token, USBPID_DATA1 ;[17]
-    breq    handleData          ;[18]
-    ldd     x2, y+1             ;[19] ADDR and 1 bit endpoint number
-    mov     x3, x2              ;[21] store for endpoint number
-    andi    x2, 0x7f            ;[22] x2 is now ADDR
-    lds     shift, usbDeviceAddr;[23]
-    cp      x2, shift           ;[25]
-overflow:                       ; This is a hack: brcs overflow will never have Z flag set
-    brne    ignorePacket        ;[26] packet for different address
-    cpi     token, USBPID_IN    ;[27]
-    breq    handleIn            ;[28]
-    cpi     token, USBPID_SETUP ;[29]
-    breq    handleSetupOrOut    ;[30]
-    cpi     token, USBPID_OUT   ;[31]
-    breq    handleSetupOrOut    ;[32]
-;   rjmp    ignorePacket        ;fallthrough, should not happen anyway.
-
-ignorePacket:
-    clr     shift
-    sts     usbCurrentTok, shift
-doReturn:
+macro POP_STANDARD ; 16 cycles
     pop     cnt
     pop     x4
     pop     x3
@@ -366,111 +339,15 @@ doReturn:
     pop     x1
     pop     shift
     pop     YH
-    pop     YL
-sofError:
-    pop     r0
-    out     SREG, r0
     pop     r0
-    reti
-
-#if USB_CFG_HAVE_INTRIN_ENDPOINT && USB_CFG_HAVE_INTRIN_ENDPOINT3
-handleIn3:
-    lds     cnt, usbTxLen3      ;[43]
-    sbrc    cnt, 4              ;[45]
-    rjmp    sendCntAndReti      ;[46] 48 + 16 = 64 until SOP
-    sts     usbTxLen3, x1       ;[47] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf3)  ;[49]
-    ldi     YH, hi8(usbTxBuf3)  ;[50]
-    rjmp    usbSendAndReti      ;[51] 53 + 12 = 65 until SOP
-#endif
-
-;Setup and Out are followed by a data packet two bit times (16 cycles) after
-;the end of SE0. The sync code allows up to 40 cycles delay from the start of
-;the sync pattern until the first bit is sampled. That's a total of 56 cycles.
-handleSetupOrOut:               ;[34]
-#if USB_CFG_IMPLEMENT_FN_WRITEOUT   /* if we have data for second OUT endpoint, set usbCurrentTok to -1 */
-    sbrc    x3, 7               ;[34] skip if endpoint 0
-    ldi     token, -1           ;[35] indicate that this is endpoint 1 OUT
-#endif
-    sts     usbCurrentTok, token;[36]
-    pop     cnt                 ;[38]
-    pop     x4                  ;[40]
-    pop     x3                  ;[42]
-    pop     x2                  ;[44]
-    pop     x1                  ;[46]
-    pop     shift               ;[48]
-    pop     YH                  ;[50]
-    pop     YL                  ;[52]
-    in      r0, USB_INTR_PENDING;[54]
-    sbrc    r0, USB_INTR_PENDING_BIT;[55] check whether data is already arriving
-    rjmp    waitForJ            ;[56] save the pops and pushes -- a new interrupt is aready pending
-    rjmp    sofError            ;[57] not an error, but it does the pops and reti we want
-
-
-handleData:
-    lds     token, usbCurrentTok;[20]
-    tst     token               ;[22]
-    breq    doReturn            ;[23]
-    lds     x2, usbRxLen        ;[24]
-    tst     x2                  ;[26]
-    brne    sendNakAndReti      ;[27]
-; 2006-03-11: The following two lines fix a problem where the device was not
-; recognized if usbPoll() was called less frequently than once every 4 ms.
-    cpi     cnt, 4              ;[28] zero sized data packets are status phase only -- ignore and ack
-    brmi    sendAckAndReti      ;[29] keep rx buffer clean -- we must not NAK next SETUP
-    sts     usbRxLen, cnt       ;[30] store received data, swap buffers
-    sts     usbRxToken, token   ;[32]
-    lds     x2, usbInputBufOffset;[34] swap buffers
-    ldi     cnt, USB_BUFSIZE    ;[36]
-    sub     cnt, x2             ;[37]
-    sts     usbInputBufOffset, cnt;[38] buffers now swapped
-    rjmp    sendAckAndReti      ;[40] 42 + 17 = 59 until SOP
-
-handleIn:
-;We don't send any data as long as the C code has not processed the current
-;input data and potentially updated the output data. That's more efficient
-;in terms of code size than clearing the tx buffers when a packet is received.
-    lds     x1, usbRxLen        ;[30]
-    cpi     x1, 1               ;[32] negative values are flow control, 0 means "buffer free"
-    brge    sendNakAndReti      ;[33] unprocessed input packet?
-    ldi     x1, USBPID_NAK      ;[34] prepare value for usbTxLen
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-    sbrc    x3, 7               ;[35] x3 contains addr + endpoint
-    rjmp    handleIn1           ;[36]
-#endif
-    lds     cnt, usbTxLen       ;[37]
-    sbrc    cnt, 4              ;[39] all handshake tokens have bit 4 set
-    rjmp    sendCntAndReti      ;[40] 42 + 16 = 58 until SOP
-    sts     usbTxLen, x1        ;[41] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf)   ;[43]
-    ldi     YH, hi8(usbTxBuf)   ;[44]
-    rjmp    usbSendAndReti      ;[45] 47 + 12 = 59 until SOP
-
-; Comment about when to set usbTxLen to USBPID_NAK:
-; We should set it back when we receive the ACK from the host. This would
-; be simple to implement: One static variable which stores whether the last
-; tx was for endpoint 0 or 1 and a compare in the receiver to distinguish the
-; ACK. However, we set it back immediately when we send the package,
-; assuming that no error occurs and the host sends an ACK. We save one byte
-; RAM this way and avoid potential problems with endless retries. The rest of
-; the driver assumes error-free transfers anyway.
+    endm
+macro POP_RETI     ; 5 cycles
+    pop     YL
+    out     SREG, YL
+    pop     YL
+    endm
 
-#if USB_CFG_HAVE_INTRIN_ENDPOINT    /* placed here due to relative jump range */
-handleIn1:                      ;[38]
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-; 2006-06-10 as suggested by O.Tamura: support second INTR IN / BULK IN endpoint
-    ldd     x2, y+2             ;[38]
-    sbrc    x2, 0               ;[40]
-    rjmp    handleIn3           ;[41]
-#endif
-    lds     cnt, usbTxLen1      ;[42]
-    sbrc    cnt, 4              ;[44] all handshake tokens have bit 4 set
-    rjmp    sendCntAndReti      ;[45] 47 + 16 = 63 until SOP
-    sts     usbTxLen1, x1       ;[46] x1 == USBPID_NAK from above
-    ldi     YL, lo8(usbTxBuf1)  ;[48]
-    ldi     YH, hi8(usbTxBuf1)  ;[49]
-    rjmp    usbSendAndReti      ;[50] 52 + 12 + 64 until SOP
-#endif
+#include "asmcommon.inc"
 
 
 ; USB spec says:
@@ -548,17 +425,18 @@ didStuff7:
 ;make SE0:
     cbr     x1, USBMASK     ;[7] prepare SE0 [spec says EOP may be 21 to 25 cycles]
     lds     x2, usbNewDeviceAddr;[8]
-    out     USBOUT, x1      ;[10] <-- out SE0 -- from now 2 bits = 22 cycles until bus idle
+    lsl     x2              ;[10] we compare with left shifted address
+    out     USBOUT, x1      ;[11] <-- out SE0 -- from now 2 bits = 22 cycles until bus idle
 ;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
 ;set address only after data packet was sent, not after handshake
-    subi    YL, 2           ;[0]
+    subi    YL, 2           ;[0] Only assign address on data packets, not ACK/NAK in r0
     sbci    YH, 0           ;[1]
     breq    skipAddrAssign  ;[2]
     sts     usbDeviceAddr, x2; if not skipped: SE0 is one cycle longer
 skipAddrAssign:
 ;end of usbDeviceAddress transfer
     ldi     x2, 1<<USB_INTR_PENDING_BIT;[4] int0 occurred during TX -- clear pending flag
-    out     USB_INTR_PENDING, x2;[5]
+    USB_STORE_PENDING(x2)   ;[5]
     ori     x1, USBIDLE     ;[6]
     in      x2, USBDDR      ;[7]
     cbr     x2, USBMASK     ;[8] set both pins to input
diff --git a/firmware/usbdrv/usbdrvasm20.inc b/firmware/usbdrv/usbdrvasm20.inc
new file mode 100644
index 000000000..fcdd429fc
--- /dev/null
+++ b/firmware/usbdrv/usbdrvasm20.inc
@@ -0,0 +1,360 @@
+/* Name: usbdrvasm20.inc
+ * Project: AVR USB driver
+ * Author: Jeroen Benschop
+ * Based on usbdrvasm16.inc from Christian Starkjohann
+ * Creation Date: 2008-03-05
+ * Tabsize: 4
+ * Copyright: (c) 2008 by Jeroen Benschop and OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * Revision: $Id: usbdrvasm20.inc 692 2008-11-07 15:07:40Z cs $
+ */
+
+/* Do not link this file! Link usbdrvasm.S instead, which includes the
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file is the 20 MHz version of the asssembler part of the USB driver. It
+requires a 20 MHz crystal (not a ceramic resonator and not a calibrated RC
+oscillator).
+
+See usbdrv.h for a description of the entire driver.
+
+Since almost all of this code is timing critical, don't change unless you
+really know what you are doing! Many parts require not only a maximum number
+of CPU cycles, but even an exact number of cycles!
+*/
+
+#define leap2   x3
+#ifdef __IAR_SYSTEMS_ASM__
+#define nextInst    $+2
+#else
+#define nextInst    .+0
+#endif
+
+;max stack usage: [ret(2), YL, SREG, YH, bitcnt, shift, x1, x2, x3, x4, cnt] = 12 bytes
+;nominal frequency: 20 MHz -> 13.333333 cycles per bit, 106.666667 cycles per byte
+; Numbers in brackets are clocks counted from center of last sync bit
+; when instruction starts
+;register use in receive loop:
+; shift assembles the byte currently being received
+; x1 holds the D+ and D- line state
+; x2 holds the previous line state
+; x4 (leap)  is used to add a leap cycle once every three bytes received
+; X3 (leap2) is used to add a leap cycle once every three stuff bits received
+; bitcnt is used to determine when a stuff bit is due
+; cnt holds the number of bytes left in the receive buffer
+
+USB_INTR_VECTOR:
+;order of registers pushed: YL, SREG YH, [sofError], bitcnt, shift, x1, x2, x3, x4, cnt
+    push    YL                  ;[-28] push only what is necessary to sync with edge ASAP
+    in      YL, SREG            ;[-26]
+    push    YL                  ;[-25]
+    push    YH                  ;[-23]
+;----------------------------------------------------------------------------
+; Synchronize with sync pattern:
+;----------------------------------------------------------------------------
+;sync byte (D-) pattern LSb to MSb: 01010100 [1 = idle = J, 0 = K]
+;sync up with J to K edge during sync pattern -- use fastest possible loops
+;The first part waits at most 1 bit long since we must be in sync pattern.
+;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to
+;waitForJ, ensure that this prerequisite is met.
+waitForJ:
+    inc     YL
+    sbis    USBIN, USBMINUS
+    brne    waitForJ        ; just make sure we have ANY timeout
+waitForK:
+;The following code results in a sampling window of < 1/4 bit which meets the spec.
+    sbis    USBIN, USBMINUS     ;[-19]
+    rjmp    foundK              ;[-18]
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+    sbis    USBIN, USBMINUS
+    rjmp    foundK
+#if USB_COUNT_SOF
+    lds     YL, usbSofCount
+    inc     YL
+    sts     usbSofCount, YL
+#endif  /* USB_COUNT_SOF */
+#ifdef USB_SOF_HOOK
+    USB_SOF_HOOK
+#endif
+    rjmp    sofError
+foundK:                         ;[-16]
+;{3, 5} after falling D- edge, average delay: 4 cycles
+;bit0 should be at 34 for center sampling. Currently at 4 so 30 cylces till bit 0 sample
+;use 1 bit time for setup purposes, then sample again. Numbers in brackets
+;are cycles from center of first sync (double K) bit after the instruction
+    push    bitcnt              ;[-16]
+;   [---]                       ;[-15]
+    lds     YL, usbInputBufOffset;[-14]
+;   [---]                       ;[-13]
+    clr     YH                  ;[-12]
+    subi    YL, lo8(-(usbRxBuf));[-11] [rx loop init]
+    sbci    YH, hi8(-(usbRxBuf));[-10] [rx loop init]
+    push    shift               ;[-9]
+;   [---]                       ;[-8]
+    ldi     shift,0x40          ;[-7] set msb to "1" so processing bit7 can be detected
+    nop2                        ;[-6]
+;   [---]                       ;[-5]
+    ldi     bitcnt, 5           ;[-4] [rx loop init]
+    sbis    USBIN, USBMINUS     ;[-3] we want two bits K (sample 3 cycles too early)
+    rjmp    haveTwoBitsK        ;[-2]
+    pop     shift               ;[-1] undo the push from before
+    pop     bitcnt              ;[1]
+    rjmp    waitForK            ;[3] this was not the end of sync, retry
+; The entire loop from waitForK until rjmp waitForK above must not exceed two
+; bit times (= 27 cycles).
+
+;----------------------------------------------------------------------------
+; push more registers and initialize values while we sample the first bits:
+;----------------------------------------------------------------------------
+haveTwoBitsK:
+    push    x1                  ;[0]
+    push    x2                  ;[2]
+    push    x3                  ;[4] (leap2)
+    ldi     leap2, 0x55         ;[6] add leap cycle on 2nd,5th,8th,... stuff bit
+    push    x4                  ;[7] == leap
+    ldi     leap, 0x55          ;[9] skip leap cycle on 2nd,5th,8th,... byte received
+    push    cnt                 ;[10]
+    ldi     cnt, USB_BUFSIZE    ;[12] [rx loop init]
+    ldi     x2, 1<<USBPLUS      ;[13] current line state is K state. D+=="1", D-=="0"
+bit0:
+    in      x1, USBIN           ;[0] sample line state
+    andi    x1, USBMASK         ;[1] filter only D+ and D- bits
+    rjmp    handleBit           ;[2] make bit0 14 cycles long
+
+;----------------------------------------------------------------------------
+; Process bit7. However, bit 6 still may need unstuffing.
+;----------------------------------------------------------------------------
+
+b6checkUnstuff:
+    dec     bitcnt              ;[9]
+    breq    unstuff6            ;[10]
+bit7:
+    subi    cnt, 1              ;[11] cannot use dec becaus it does not affect the carry flag
+    brcs    overflow            ;[12] Too many bytes received. Ignore packet
+    in      x1, USBIN           ;[0] sample line state
+    andi    x1, USBMASK         ;[1] filter only D+ and D- bits
+    cpse    x1, x2              ;[2] when previous line state equals current line state, handle "1"
+    rjmp    b7handle0           ;[3] when line state differs, handle "0"
+    sec                         ;[4]
+    ror     shift               ;[5] shift "1" into the data
+    st      y+, shift           ;[6] store the data into the buffer
+    ldi     shift, 0x40         ;[7] reset data for receiving the next byte
+    subi    leap, 0x55          ;[9] trick to introduce a leap cycle every 3 bytes
+    brcc    nextInst            ;[10 or 11] it will fail after 85 bytes. However low speed can only receive 11
+    dec     bitcnt              ;[11 or 12]
+    brne    bit0                ;[12 or 13]
+    ldi     x1, 1               ;[13 or 14] unstuffing bit 7
+    in      bitcnt, USBIN       ;[0] sample stuff bit
+    rjmp    unstuff             ;[1]
+
+b7handle0:
+    mov     x2,x1               ;[5] Set x2 to current line state
+    ldi     bitcnt, 6           ;[6]
+    lsr     shift               ;[7] shift "0" into the data
+    st      y+, shift           ;[8] store data into the buffer
+    ldi     shift, 0x40         ;[10] reset data for receiving the next byte
+    subi    leap, 0x55          ;[11] trick to introduce a leap cycle every 3 bytes
+    brcs    bit0                ;[12] it will fail after 85 bytes. However low speed can only receive 11
+    rjmp    bit0                ;[13]
+
+
+;----------------------------------------------------------------------------
+; Handle unstuff
+; x1==0xFF indicate unstuffing bit6
+;----------------------------------------------------------------------------
+
+unstuff6:
+    ldi     x1,0xFF             ;[12] indicate unstuffing bit 6
+    in      bitcnt, USBIN       ;[0]  sample stuff bit
+    nop                         ;[1]  fix timing
+unstuff:                        ;b0-5  b6   b7
+    mov     x2,bitcnt           ;[3]  [2]  [3]  Set x2 to match line state
+    subi    leap2, 0x55         ;[4]  [3]  [4]  delay loop
+    brcs    nextInst            ;[5]  [4]  [5]  add one cycle every three stuff bits
+    sbci    leap2,0             ;[6]  [5]  [6]
+    ldi     bitcnt,6            ;[7]  [6]  [7]  reset bit stuff counter
+    andi    x2, USBMASK         ;[8]  [7]  [8] only keep D+ and D-
+    cpi     x1,0                ;[9]  [8]  [9]
+    brmi    bit7                ;[10] [9]  [10] finished unstuffing bit6 When x1<0
+    breq    bitloop             ;[11] ---  [11] finished unstuffing bit0-5 when x1=0
+    nop                         ;---  ---  [12]
+    in      x1, USBIN           ;---  ---  [0] sample line state for bit0
+    andi    x1, USBMASK         ;---  ---  [1] filter only D+ and D- bits
+    rjmp    handleBit           ;---  ---  [2] make bit0 14 cycles long
+
+;----------------------------------------------------------------------------
+; Receiver loop (numbers in brackets are cycles within byte after instr)
+;----------------------------------------------------------------------------
+bitloop:
+    in      x1, USBIN           ;[0] sample line state
+    andi    x1, USBMASK         ;[1] filter only D+ and D- bits
+    breq    se0                 ;[2] both lines are low so handle se0
+handleBit:
+    cpse    x1, x2              ;[3] when previous line state equals current line state, handle "1"
+    rjmp    handle0             ;[4] when line state differs, handle "0"
+    sec                         ;[5]
+    ror     shift               ;[6] shift "1" into the data
+    brcs    b6checkUnstuff      ;[7] When after shift C is set, next bit is bit7
+    nop2                        ;[8]
+    dec     bitcnt              ;[10]
+    brne    bitloop             ;[11]
+    ldi     x1,0                ;[12] indicate unstuff for bit other than bit6 or bit7
+    in      bitcnt, USBIN       ;[0] sample stuff bit
+    rjmp    unstuff             ;[1]
+
+handle0:
+    mov     x2, x1              ;[6] Set x2 to current line state
+    ldi     bitcnt, 6           ;[7] reset unstuff counter.
+    lsr     shift               ;[8] shift "0" into the data
+    brcs    bit7                ;[9] When after shift C is set, next bit is bit7
+    nop                         ;[10]
+    rjmp    bitloop             ;[11]
+
+;----------------------------------------------------------------------------
+; End of receive loop. Now start handling EOP
+;----------------------------------------------------------------------------
+
+macro POP_STANDARD ; 14 cycles
+    pop     cnt
+    pop     x4
+    pop     x3
+    pop     x2
+    pop     x1
+    pop     shift
+    pop     bitcnt
+    endm
+macro POP_RETI     ; 7 cycles
+    pop     YH
+    pop     YL
+    out     SREG, YL
+    pop     YL
+    endm
+
+
+
+#include "asmcommon.inc"
+
+; USB spec says:
+; idle = J
+; J = (D+ = 0), (D- = 1)
+; K = (D+ = 1), (D- = 0)
+; Spec allows 7.5 bit times from EOP to SOP for replies
+; 7.5 bit times is 100 cycles. This implementation arrives a bit later at se0
+; then specified in the include file but there is plenty of time
+
+bitstuffN:
+    eor     x1, x4          ;[8]
+    ldi     x2, 0           ;[9]
+    nop2                    ;[10]
+    out     USBOUT, x1      ;[12] <-- out
+    rjmp    didStuffN       ;[0]
+
+bitstuff7:
+    eor     x1, x4          ;[6]
+    ldi     x2, 0           ;[7] Carry is zero due to brcc
+    rol     shift           ;[8] compensate for ror shift at branch destination
+    nop2                    ;[9]
+    rjmp    didStuff7       ;[11]
+
+sendNakAndReti:
+    ldi     x3, USBPID_NAK  ;[-18]
+    rjmp    sendX3AndReti   ;[-17]
+sendAckAndReti:
+    ldi     cnt, USBPID_ACK ;[-17]
+sendCntAndReti:
+    mov     x3, cnt         ;[-16]
+sendX3AndReti:
+    ldi     YL, 20          ;[-15] x3==r20 address is 20
+    ldi     YH, 0           ;[-14]
+    ldi     cnt, 2          ;[-13]
+;   rjmp    usbSendAndReti      fallthrough
+
+;usbSend:
+;pointer to data in 'Y'
+;number of bytes in 'cnt' -- including sync byte [range 2 ... 12]
+;uses: x1...x4, btcnt, shift, cnt, Y
+;Numbers in brackets are time since first bit of sync pattern is sent
+;We don't match the transfer rate exactly (don't insert leap cycles every third
+;byte) because the spec demands only 1.5% precision anyway.
+usbSendAndReti:             ; 12 cycles until SOP
+    in      x2, USBDDR      ;[-12]
+    ori     x2, USBMASK     ;[-11]
+    sbi     USBOUT, USBMINUS;[-10] prepare idle state; D+ and D- must have been 0 (no pullups)
+    in      x1, USBOUT      ;[-8] port mirror for tx loop
+    out     USBDDR, x2      ;[-7] <- acquire bus
+; need not init x2 (bitstuff history) because sync starts with 0
+    ldi     x4, USBMASK     ;[-6] exor mask
+    ldi     shift, 0x80     ;[-5] sync byte is first byte sent
+txByteLoop:
+    ldi     bitcnt, 0x49    ;[-4]        [10] binary 01001001
+txBitLoop:
+    sbrs    shift, 0        ;[-3] [10]   [11]
+    eor     x1, x4          ;[-2] [11]   [12]
+    out     USBOUT, x1      ;[-1] [12]   [13]   <-- out N
+    ror     shift           ;[0]  [13]   [14]
+    ror     x2              ;[1]
+didStuffN:
+    nop2                    ;[2]
+    nop                     ;[4]
+    cpi     x2, 0xfc        ;[5]
+    brcc    bitstuffN       ;[6]
+    lsr     bitcnt          ;[7]
+    brcc    txBitLoop       ;[8]
+    brne    txBitLoop       ;[9]
+
+    sbrs    shift, 0        ;[10]
+    eor     x1, x4          ;[11]
+didStuff7:
+    out     USBOUT, x1      ;[-1] [13] <-- out 7
+    ror     shift           ;[0] [14]
+    ror     x2              ;[1]
+    nop                     ;[2]
+    cpi     x2, 0xfc        ;[3]
+    brcc    bitstuff7       ;[4]
+    ld      shift, y+       ;[5]
+    dec     cnt             ;[7]
+    brne    txByteLoop      ;[8]
+;make SE0:
+    cbr     x1, USBMASK     ;[9] prepare SE0 [spec says EOP may be 25 to 30 cycles]
+    lds     x2, usbNewDeviceAddr;[10]
+    lsl     x2              ;[12] we compare with left shifted address
+    out     USBOUT, x1      ;[13] <-- out SE0 -- from now 2 bits = 22 cycles until bus idle
+    subi    YL, 20 + 2      ;[0] Only assign address on data packets, not ACK/NAK in x3
+    sbci    YH, 0           ;[1]
+;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm:
+;set address only after data packet was sent, not after handshake
+    breq    skipAddrAssign  ;[2]
+    sts     usbDeviceAddr, x2; if not skipped: SE0 is one cycle longer
+skipAddrAssign:
+;end of usbDeviceAddress transfer
+    ldi     x2, 1<<USB_INTR_PENDING_BIT;[4] int0 occurred during TX -- clear pending flag
+    USB_STORE_PENDING(x2)   ;[5]
+    ori     x1, USBIDLE     ;[6]
+    in      x2, USBDDR      ;[7]
+    cbr     x2, USBMASK     ;[8] set both pins to input
+    mov     x3, x1          ;[9]
+    cbr     x3, USBMASK     ;[10] configure no pullup on both pins
+    ldi     x4, 5           ;[11]
+se0Delay:
+    dec     x4              ;[12] [15] [18] [21] [24]
+    brne    se0Delay        ;[13] [16] [19] [22] [25]
+    out     USBOUT, x1      ;[26] <-- out J (idle) -- end of SE0 (EOP signal)
+    out     USBDDR, x2      ;[27] <-- release bus now
+    out     USBOUT, x3      ;[28] <-- ensure no pull-up resistors are active
+    rjmp    doReturn
diff --git a/firmware/usbdrv/usbportability.h b/firmware/usbdrv/usbportability.h
new file mode 100644
index 000000000..2dd24245f
--- /dev/null
+++ b/firmware/usbdrv/usbportability.h
@@ -0,0 +1,140 @@
+/* Name: usbportability.h
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2008-06-17
+ * Tabsize: 4
+ * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbportability.h 692 2008-11-07 15:07:40Z cs $
+ */
+
+/*
+General Description:
+This header is intended to contain all (or at least most of) the compiler
+and library dependent stuff. The C code is written for avr-gcc and avr-libc.
+The API of other development environments is converted to gcc's and avr-libc's
+API by means of defines.
+
+This header also contains all system includes since they depend on the
+development environment.
+
+Thanks to Oleg Semyonov for his help with the IAR tools port!
+*/
+
+#ifndef __usbportability_h_INCLUDED__
+#define __usbportability_h_INCLUDED__
+
+/* We check explicitly for IAR and CodeVision. Default is avr-gcc/avr-libc. */
+
+/* ------------------------------------------------------------------------- */
+#if defined __IAR_SYSTEMS_ICC__ || defined __IAR_SYSTEMS_ASM__  /* check for IAR */
+/* ------------------------------------------------------------------------- */
+
+#ifndef ENABLE_BIT_DEFINITIONS
+#   define ENABLE_BIT_DEFINITIONS	1   /* Enable bit definitions */
+#endif
+
+/* Include IAR headers */
+#include <ioavr.h>
+#ifndef __IAR_SYSTEMS_ASM__
+#   include <inavr.h>
+#endif
+
+#define __attribute__(arg)  /* not supported on IAR */
+
+#ifdef __IAR_SYSTEMS_ASM__
+#   define __ASSEMBLER__    /* IAR does not define standard macro for asm */
+#endif
+
+#ifdef __HAS_ELPM__
+#   define PROGMEM __farflash
+#else
+#   define PROGMEM __flash
+#endif
+
+#define USB_READ_FLASH(addr)    (*(PROGMEM char *)(addr))
+
+/* The following definitions are not needed by the driver, but may be of some
+ * help if you port a gcc based project to IAR.
+ */
+#define cli()       __disable_interrupt()
+#define sei()       __enable_interrupt()
+#define wdt_reset() __watchdog_reset()
+#define _BV(x)      (1 << (x))
+
+/* assembler compatibility macros */
+#define nop2    rjmp    $+2 /* jump to next instruction */
+#define XL      r26
+#define XH      r27
+#define YL      r28
+#define YH      r29
+#define ZL      r30
+#define ZH      r31
+#define lo8(x)  LOW(x)
+#define hi8(x)  (((x)>>8) & 0xff)   /* not HIGH to allow XLINK to make a proper range check */
+
+/* Depending on the device you use, you may get problems with the way usbdrv.h
+ * handles the differences between devices. Since IAR does not use #defines
+ * for MCU registers, we can't check for the existence of a particular
+ * register with an #ifdef. If the autodetection mechanism fails, include
+ * definitions for the required USB_INTR_* macros in your usbconfig.h. See
+ * usbconfig-prototype.h and usbdrv.h for details.
+ */
+
+/* ------------------------------------------------------------------------- */
+#elif __CODEVISIONAVR__ /* check for CodeVision AVR */
+/* ------------------------------------------------------------------------- */
+/* This port is not working (yet) */
+
+/* #define F_CPU   _MCU_CLOCK_FREQUENCY_    seems to be defined automatically */
+
+#include <io.h>
+#include <delay.h>
+
+#define __attribute__(arg)  /* not supported on IAR */
+
+#define PROGMEM                 __flash
+#define USB_READ_FLASH(addr)    (*(PROGMEM char *)(addr))
+
+#ifndef __ASSEMBLER__
+static inline void  cli(void)
+{
+    #asm("cli");
+}
+static inline void  sei(void)
+{
+    #asm("sei");
+}
+#endif
+#define _delay_ms(t)    delay_ms(t)
+#define _BV(x)          (1 << (x))
+#define USB_CFG_USE_SWITCH_STATEMENT 1  /* macro for if() cascase fails for unknown reason */
+
+#define macro   .macro
+#define endm    .endmacro
+#define nop2    rjmp    .+0 /* jump to next instruction */
+
+/* ------------------------------------------------------------------------- */
+#else   /* default development environment is avr-gcc/avr-libc */
+/* ------------------------------------------------------------------------- */
+
+#include <avr/io.h>
+#ifdef __ASSEMBLER__
+#   define _VECTOR(N)   __vector_ ## N   /* io.h does not define this for asm */
+#else
+#   include <avr/pgmspace.h>
+#endif
+
+#define USB_READ_FLASH(addr)    pgm_read_byte(addr)
+
+#define macro   .macro
+#define endm    .endm
+#define nop2    rjmp    .+0 /* jump to next instruction */
+
+#endif  /* development environment */
+
+/* for conveniecne, ensure that PRG_RDB exists */
+#ifndef PRG_RDB
+#   define PRG_RDB(addr)    USB_READ_FLASH(addr)
+#endif
+#endif  /* __usbportability_h_INCLUDED__ */
-- 
2.11.0