From 93ac315e7851c3094fe1b78648c0dfc3f6923b20 Mon Sep 17 00:00:00 2001
From: Michael 'PoempelFox' Meier <unrz191@legolas.rrze.uni-erlangen.de>
Date: Mon, 2 Aug 2010 14:26:24 +0200
Subject: [PATCH 1/1] manueller import aus nem CVS checkout (ist eh nur zum
testen)
---
LICENSE | 297 ++++++++++++
Makefile | 91 ++++
README | 56 +++
ds1820.c | 212 +++++++++
ds1820.h | 67 +++
ds1820tousb.shipped.bin | Bin 0 -> 3902 bytes
ds1wire.h | 104 +++++
hardware/.cvsignore | 6 +
hardware/circuit-att45ds1820.brd | Bin 0 -> 14562 bytes
hardware/circuit-att45ds1820.sch | Bin 0 -> 246063 bytes
hostsoftware.c | 689 ++++++++++++++++++++++++++++
main.c | 221 +++++++++
time.c | 35 ++
time.h | 18 +
usbconfig.h | 352 +++++++++++++++
usbdrv/Changelog.txt | 263 +++++++++++
usbdrv/CommercialLicense.txt | 156 +++++++
usbdrv/License.txt | 361 +++++++++++++++
usbdrv/Readme.txt | 147 ++++++
usbdrv/USBID-License.txt | 146 ++++++
usbdrv/asmcommon.inc | 185 ++++++++
usbdrv/oddebug.c | 50 ++
usbdrv/oddebug.h | 123 +++++
usbdrv/this-is-avrusb-20081126 | 0
usbdrv/usbconfig-prototype.h | 351 +++++++++++++++
usbdrv/usbdrv.c | 625 +++++++++++++++++++++++++
usbdrv/usbdrv.h | 731 ++++++++++++++++++++++++++++++
usbdrv/usbdrvasm.S | 296 ++++++++++++
usbdrv/usbdrvasm.asm | 21 +
usbdrv/usbdrvasm12.inc | 393 ++++++++++++++++
usbdrv/usbdrvasm128.inc | 752 +++++++++++++++++++++++++++++++
usbdrv/usbdrvasm15.inc | 423 +++++++++++++++++
usbdrv/usbdrvasm16.inc | 343 ++++++++++++++
usbdrv/usbdrvasm165.inc | 453 +++++++++++++++++++
usbdrv/usbdrvasm20.inc | 360 +++++++++++++++
usbdrv/usbportability.h | 140 ++++++
36 files changed, 8467 insertions(+)
create mode 100644 LICENSE
create mode 100644 Makefile
create mode 100644 README
create mode 100644 ds1820.c
create mode 100644 ds1820.h
create mode 100755 ds1820tousb.shipped.bin
create mode 100644 ds1wire.h
create mode 100644 hardware/.cvsignore
create mode 100644 hardware/circuit-att45ds1820.brd
create mode 100644 hardware/circuit-att45ds1820.sch
create mode 100644 hostsoftware.c
create mode 100644 main.c
create mode 100644 time.c
create mode 100644 time.h
create mode 100644 usbconfig.h
create mode 100644 usbdrv/Changelog.txt
create mode 100644 usbdrv/CommercialLicense.txt
create mode 100644 usbdrv/License.txt
create mode 100644 usbdrv/Readme.txt
create mode 100644 usbdrv/USBID-License.txt
create mode 100644 usbdrv/asmcommon.inc
create mode 100644 usbdrv/oddebug.c
create mode 100644 usbdrv/oddebug.h
create mode 100644 usbdrv/this-is-avrusb-20081126
create mode 100644 usbdrv/usbconfig-prototype.h
create mode 100644 usbdrv/usbdrv.c
create mode 100644 usbdrv/usbdrv.h
create mode 100644 usbdrv/usbdrvasm.S
create mode 100644 usbdrv/usbdrvasm.asm
create mode 100644 usbdrv/usbdrvasm12.inc
create mode 100644 usbdrv/usbdrvasm128.inc
create mode 100644 usbdrv/usbdrvasm15.inc
create mode 100644 usbdrv/usbdrvasm16.inc
create mode 100644 usbdrv/usbdrvasm165.inc
create mode 100644 usbdrv/usbdrvasm20.inc
create mode 100644 usbdrv/usbportability.h
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d4ffe9a
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,297 @@
+ds1820-to-usb Software
+(C) Michael Meier 2009
+Contact: ds1820tousb@mulder.franken.de
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of version 2 of the GNU General Public License
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+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
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ 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
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+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
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+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
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ad237a3
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,91 @@
+# $Id: Makefile,v 1.2 2010/03/23 07:55:23 simimeie Exp $
+# Makefile for the ds1820-to-usb project
+
+CC = avr-gcc
+OBJDUMP = avr-objdump
+OBJCOPY = avr-objcopy
+AVRDUDE = avrdude
+INCDIR = .
+
+# target mcu (at90s8515, atmega16, atmega8515...)
+MCU = attiny45
+# Since avrdude is generally crappy software (I liked uisp a lot better, too
+# bad the project is dead :-/), it cannot use the MCU name everybody else
+# uses, it has to invent its own name for it. So this defines the same
+# MCU as above, but with the name avrdude understands.
+AVRDMCU = t45
+
+# Some more settings
+# Clock Frequency of the AVR. Needed for various calculations.
+CPUFREQ = 15000000UL
+
+# Additional defines
+# Known defines are:
+# -DKISS enables Keep-It-Simple-Stupid mode, which can only handle one
+# temperature sensor on the bus.
+ADDDEFS =
+
+SRCS = usbdrv/usbdrv.c ds1820.c main.c time.c
+ASMS = usbdrv/usbdrvasm.S
+PROG = ds1820tousb
+
+# compiler flags
+CFLAGS = -g -Os -Wall -fno-strict-aliasing -mmcu=$(MCU) $(ADDDEFS)
+
+# linker flags
+LDFLAGS = -g -mmcu=$(MCU) -Wl,-Map,$(PROG).map
+
+CFLAGS += -DCPUFREQ=$(CPUFREQ) -DF_CPU=$(CPUFREQ)
+
+OBJS = $(SRCS:.c=.o) $(ASMS:.S=.o)
+
+all: compile dump text eeprom
+
+compile: $(OBJS)
+ $(CC) $(LDFLAGS) -o $(PROG).elf $(OBJS)
+
+dump: compile
+ $(OBJDUMP) -h -S $(PROG).elf > $(PROG).lst
+
+hostsoftware: hostsoftware.c
+ gcc -o hostsoftware -O2 -Wall -lusb hostsoftware.c
+
+%o : %c
+ $(CC) $(CFLAGS) -I$(INCDIR) -c $< -o $@
+
+%o : %S
+ $(CC) $(CFLAGS) -I$(INCDIR) -c $< -o $@
+
+# Create the flash contents
+text: compile
+ $(OBJCOPY) -j .text -j .data -O ihex $(PROG).elf $(PROG).hex
+ $(OBJCOPY) -j .text -j .data -O srec $(PROG).elf $(PROG).srec
+ $(OBJCOPY) -j .text -j .data -O binary $(PROG).elf $(PROG).bin
+
+# Rules for building the .eeprom rom images
+eeprom: compile
+ $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O ihex $(PROG).elf $(PROG)_eeprom.hex
+ $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O srec $(PROG).elf $(PROG)_eeprom.srec
+ $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O binary $(PROG).elf $(PROG)_eeprom.bin
+
+clean:
+ rm -f $(PROG) *~ *.elf *.rom *.bin *.eep *.o usbdrv/*.o *.lst *.map *.srec *.hex
+
+upload: uploadflash uploadeeprom
+
+uploadflash:
+ $(AVRDUDE) -c stk500v2 -p $(AVRDMCU) -P /dev/ttyS0 -U flash:w:$(PROG).srec:s
+
+uploadeeprom:
+ $(AVRDUDE) -c stk500v2 -p $(AVRDMCU) -P /dev/ttyS0 -U eeprom:w:$(PROG)_eeprom.srec:s
+
+uploadfuses:
+ @echo "Sorry, I will not program the fuses for you, since things will"
+ @echo "go horribly wrong if you make a mistake there. It is safest to set"
+ @echo "them with avrstudio."
+ @echo "If you want to use attiny45/85, you will probably want"
+ @echo " lfuse=0xff, hfuse=0xdd, efuse=0xff"
+ @echo "Command line will be something along the lines of"
+ @echo $(AVRDUDE) -c stk500v2 -p $(AVRDMCU) -P /dev/ttyS0 -U lfuse:w:0xff:m
+ @echo $(AVRDUDE) -c stk500v2 -p $(AVRDMCU) -P /dev/ttyS0 -U hfuse:w:0xdd:m
+ @echo $(AVRDUDE) -c stk500v2 -p $(AVRDMCU) -P /dev/ttyS0 -U efuse:w:0xff:m
diff --git a/README b/README
new file mode 100644
index 0000000..55c587f
--- /dev/null
+++ b/README
@@ -0,0 +1,56 @@
+$Id: README,v 1.3 2009/03/22 22:18:54 simimeie Exp $
+
+Intro
+======
+
+This project contains schematics and firmware for a little
+board with an Atmel AVR ATtiny45 microcontroller that
+allows you to connect Dallas/Maxim DS18b20 temperature
+probes to an USB port on your computer.
+
+Some linux software to read the data from the USB device is also included.
+
+Licence for my own source code is GPL,
+Licence for the included libavrusb is their Licence - see the files in the
+usbdrv directory.
+
+Features
+=========
+
+The attiny45 is very small, it only has 8 pins. All of these pins are used
+by this project.
+An external crystal is used to generate a 15 MHz clock.
+In theory, you can connect an unlimited amount of temperature probes to the
+onewire-bus, and read them. However, in reality there are a few limitations:
+- There is a maximum number of probes supported set at compiletime. You can
+ increase the define in ds1820.c, but be aware that each additional
+ probe will require memory, and you will run out of memory at some point.
+ You could use an attiny85 (that has the same pinout but more memory)
+ to increase the number of probes possible.
+- The length of the bus, and the power used by the probes. If the bus gets
+ too long, signals and power won't be delivered anymore. The same is true
+ for too many probes on the bus.
+I currently have NO idea what these limits are - I only tested 2 probes on
+a short cable so far. Feel free to send me success-reports.
+
+When compiled with avr-libc 1.4.7 and avr-gcc 4.2.2 (and -Os as a compiler
+switch to optimize for size), this code uses around 3900 of the 4096 bytes
+of flash the attiny45 has. If you want to add your own extensions, you'll
+probably have to resort to the attiny85 instead, which has 8 KB flash
+instead of 4.
+
+How to use
+===========
+
+To make any use of this, you will need:
+
+To compile the AVR firmware: avr-gcc, avr-libc
+ use 'make all' to compile.
+To compile the linux host software: libusb, libusb-dev
+ use 'make hostsoftware' to compile.
+For flashing the AVR with avrdude, there is a 'make upload' target.
+That target is configured for a STK500 on /dev/ttyS0 - you will have to
+adapt the makefile if you use a different programmer and/or port.
+
+For hostsoftware usage information, call it with parameter --help.
+
diff --git a/ds1820.c b/ds1820.c
new file mode 100644
index 0000000..285f3e0
--- /dev/null
+++ b/ds1820.c
@@ -0,0 +1,212 @@
+/* $Id: ds1820.c,v 1.3 2010/07/16 19:31:18 simimeie Exp $
+ * USB interface for ds1820
+ * This file handles everything that has to do with the temperature probes.
+ * (C) Michael "Fox" Meier 2009
+ */
+
+#include "usbdrv/usbdrv.h"
+#include "ds1wire.h"
+#include "time.h"
+
+#include "ds1820.h"
+
+struct probe ds1820probes[DS1820_MAXPROBES];
+
+void ds1820init(void) {
+ ds1wire_init(B, 0);
+ ds1wire_reset(B, 0);
+}
+
+void ds1820killbus(void) {
+ ds1wire_pulldown(B, 0);
+}
+
+static void ds1820write(uint8_t val) {
+ uint8_t i;
+ for (i = 0; i < 8; i++) {
+ if (val & 0x01) {
+ ds1wire_send1(B, 0);
+ } else {
+ ds1wire_send0(B, 0);
+ }
+ val >>= 1;
+ }
+}
+
+static uint8_t ds1820read(void) {
+ uint8_t i;
+ uint8_t res = 0;
+ for (i = 0; i < 8; i++) {
+ res |= ((ds1wire_read(B, 0)) << i);
+ }
+ return res;
+}
+
+void ds1820queryprobe(uint8_t probenum)
+{
+ uint8_t i; uint8_t crc = 0;
+ ds1wire_reset(B, 0);
+#ifdef KISS
+ ds1820write(DS1820_CMD_SKIPROM); /* Skip ROM */
+#else
+ ds1820write(DS1820_CMD_MATCHROM); /* Match ROM */
+ /* Send 64 bit serial */
+ ds1820write(ds1820probes[probenum].family);
+ crc = ds1wire_calccrc8(crc, ds1820probes[probenum].family);
+ for (i = 0; i < 6; i++) {
+ ds1820write(ds1820probes[probenum].serial[i]);
+ crc = ds1wire_calccrc8(crc, ds1820probes[probenum].serial[i]);
+ }
+ ds1820write(crc);
+#endif /* KISS */
+ /* Issue 'start temperature conversion' */
+ ds1820write(DS1820_CMD_CONVERTT);
+ if (ds1820probes[probenum].flags & DS1820FLAG_PARASITE) {
+ /* Provide parasite power */
+ ds1wire_parasitepoweron(B, 0);
+ }
+}
+
+/* Returns 1 on successful update, 0 otherwise */
+uint8_t ds1820updateprobe(uint8_t probenum)
+{
+ uint8_t i; uint8_t crc = 0; uint8_t t1 = 0; uint8_t t2 = 0;
+ if (ds1820probes[probenum].flags & DS1820FLAG_PARASITE) {
+ /* No longer provide parasite power */
+ ds1wire_parasitepoweroff(B, 0);
+ }
+ ds1wire_reset(B, 0);
+#ifdef KISS
+ ds1820write(DS1820_CMD_SKIPROM); /* Skip ROM */
+#else
+ ds1820write(DS1820_CMD_MATCHROM); /* Match ROM */
+ /* Send 64 bit serial */
+ ds1820write(ds1820probes[probenum].family);
+ crc = ds1wire_calccrc8(crc, ds1820probes[probenum].family);
+ for (i = 0; i < 6; i++) {
+ ds1820write(ds1820probes[probenum].serial[i]);
+ crc = ds1wire_calccrc8(crc, ds1820probes[probenum].serial[i]);
+ }
+ ds1820write(crc);
+#endif /* KISS */
+ /* Read Scratchpad */
+ ds1820write(DS1820_CMD_READSCRPAD);
+ crc = 0;
+ for (i = 0; i < 9; i++) {
+ uint8_t v = ds1820read();
+ if (i == 0) { t1 = v; }
+ if (i == 1) { t2 = v; }
+ crc = ds1wire_calccrc8(crc, v);
+ }
+ /* For parasite powered probes, reading 0x50 0x05 (85.0 deg) usually
+ * means the probe has lost power during temperature conversion and
+ * reset (85.0 is the poweron value of the temperature scratchpad).
+ * So we filter the value 85.0 for parasite powered probes. This means
+ * you can never use parasite powered probes for temperatures in this
+ * range. */
+ if ((crc == 0)
+ && (((ds1820probes[probenum].flags & DS1820FLAG_PARASITE) == 0)
+ || (t1 != 0x50) || (t2 != 0x05))) {
+ ds1820probes[probenum].lastts = gettime();
+ ds1820probes[probenum].lasttemp[0] = t1;
+ ds1820probes[probenum].lasttemp[1] = t2;
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+/* This is going to be a tough one:
+ * Scan the bus to find all probes.
+ */
+void ds1820scan(void) {
+#ifdef KISS
+ ds1wire_reset(B, 0);
+ ds1820probes[0].flags |= DS1820FLAG_SLOTINUSE;
+ ds1820write(DS1820_CMD_SKIPROM); /* Skip ROM */
+ ds1820write(DS1820_CMD_READPOWER); /* Read power supply */
+ if (ds1wire_read(B, 0) == 0) { /* Parasite powered probes return 0 */
+ ds1820probes[0].flags |= DS1820FLAG_PARASITE;
+ } else {
+ ds1820probes[0].flags &= ~DS1820FLAG_PARASITE;
+ }
+#else /* KISS */
+ uint8_t lastserialfound[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+ int8_t lastcolwith0 = -1;
+ int8_t prevcolwith0;
+ int8_t i;
+ uint8_t j;
+ for (i = 0; i < DS1820_MAXPROBES; i++) { /* Clear list of probes */
+ ds1820probes[i].flags = 0;
+ }
+ do {
+ ds1wire_reset(B, 0);
+ prevcolwith0 = lastcolwith0;
+ lastcolwith0 = -1;
+ /* Send scan command */
+ ds1820write(DS1820_CMD_SEARCHROM);
+ for (i = 0; i < 64; i++) {
+ uint8_t val1 = ds1wire_read(B, 0);
+ uint8_t val2 = ds1wire_read(B, 0);
+ if (val1 == val2) { /* Collission */
+ if (val1 == 1) { /* and thus val2 is 1 too */
+ /* Nothing matched on the bus! This is actually pretty fatal! */
+ /* Try to get out alive. Send all 0. */
+ ds1wire_send0(B, 0); lastcolwith0 = -1;
+ } else { /* Both 0 */
+ /* Was that where we stopped last time? */
+ if (prevcolwith0 == i) { /* Send a 1 this time */
+ ds1wire_send1(B, 0);
+ lastserialfound[i >> 3] |= _BV(i & 0x07);
+ } else {
+ lastcolwith0 = i;
+ ds1wire_send0(B, 0);
+ lastserialfound[i >> 3] &= (uint8_t)~_BV(i & 0x07);
+ }
+ }
+ } else { /* val1 != val2 */
+ if (val1 == 0) { /* Was a 0, so select that */
+ ds1wire_send0(B, 0);
+ lastserialfound[i >> 3] &= (uint8_t)~_BV(i & 0x07);
+ } else { /* Was a 1 */
+ ds1wire_send1(B, 0);
+ lastserialfound[i >> 3] |= _BV(i & 0x07);
+ }
+ }
+ }
+ /* lastserialfound now contains the serial of the last probe we found,
+ * AND that probe is selected. */
+ /* Check CRC of serial number. */
+ j = 0; /* Used as CRC here */
+ for (i = 0; i < 8; i++) {
+ j = ds1wire_calccrc8(j, lastserialfound[i]);
+ }
+ if (j == 0) { /* CRC of serial number OK! */
+ for (i = 0; i < DS1820_MAXPROBES; i++) {
+ if ((ds1820probes[i].flags & DS1820FLAG_SLOTINUSE) == 0) {
+ /* Empty slot, use it. */
+ break;
+ }
+ }
+ if (i == DS1820_MAXPROBES) { /* No match. Overwrite last entry. */
+ i = DS1820_MAXPROBES - 1;
+ }
+ ds1820probes[i].flags |= DS1820FLAG_SLOTINUSE;
+ ds1820probes[i].family = lastserialfound[0];
+ for (j = 0; j < 6; j++) {
+ ds1820probes[i].serial[j] = lastserialfound[j+1];
+ }
+ ds1820probes[i].lastts = 0;
+ ds1820probes[i].lasttemp[0] = 0;
+ ds1820probes[i].lasttemp[1] = 0;
+ /* Find out if the probe is parasite powered or not. */
+ ds1820write(DS1820_CMD_READPOWER); /* Read power supply */
+ if (ds1wire_read(B, 0) == 0) { /* Parasite powered probes return 0 */
+ ds1820probes[i].flags |= DS1820FLAG_PARASITE;
+ } else {
+ ds1820probes[i].flags &= ~DS1820FLAG_PARASITE;
+ }
+ }
+ } while (lastcolwith0 >= 0);
+#endif /* KISS */
+}
diff --git a/ds1820.h b/ds1820.h
new file mode 100644
index 0000000..90d0725
--- /dev/null
+++ b/ds1820.h
@@ -0,0 +1,67 @@
+/* $Id: ds1820.h,v 1.2 2010/03/23 07:57:04 simimeie Exp $
+ * USB interface for ds1820
+ * This file handles everything that has to do with the temperature probes.
+ * (C) Michael "Fox" Meier 2009
+ * There are two modes: KISS (keep it simple stupid), activated when you
+ * define KISS, can only ever support one probe on the bus. When KISS is
+ * not defined, multiple probes are supported up to a compile time maximum,
+ * and the bus is searched for probes.
+ */
+
+#ifndef __DS1820_H__
+#define __DS1820_H__
+
+#include <inttypes.h>
+
+/* Number of probes supported */
+#define DS1820_MAXPROBES 4
+
+#ifdef KISS /* We can only ever handle one probe in this mode, so override define */
+#undef DS1820_MAXPROBES
+#define DS1820_MAXPROBES 1
+#endif
+
+#define DS1820FLAG_SLOTINUSE 0x01 /* 1 if this slot is in use */
+#define DS1820FLAG_PARASITE 0x02 /* 1 if the device is parasite powered */
+
+#define DS1820_CMD_SEARCHROM 0xF0
+#define DS1820_CMD_SKIPROM 0xCC
+#define DS1820_CMD_MATCHROM 0x55
+#define DS1820_CMD_READROM 0x33
+#define DS1820_CMD_CONVERTT 0x44
+#define DS1820_CMD_READSCRPAD 0xBE
+#define DS1820_CMD_READPOWER 0xB4
+
+struct probe {
+ uint8_t family;
+ uint8_t serial[6];
+ uint8_t flags;
+ uint8_t lasttemp[2]; /* Temperature we read last */
+ uint32_t lastts; /* Timestamp when we last read it */
+};
+
+extern struct probe ds1820probes[DS1820_MAXPROBES];
+
+/* Inits ds1820 code and bus */
+void ds1820init(void);
+
+/* Actively pull down the bus. For hard resetting probes that have gone
+ * bonkers. */
+void ds1820killbus(void);
+
+/* Scan the bus to find all probes. Populates the ds1820probes array. */
+void ds1820scan(void);
+
+/* Tells one probe to do temperature conversion. Since that takes
+ * about 1 second, you will need to wait that long before
+ * calling ds1820updateprobe.
+ * the number is the index number for the ds1820probes array. */
+void ds1820queryprobe(uint8_t probenum);
+
+/* Reads the answer from the probe queried with ds1820queryprobe
+ * before and updates its data.
+ * the number is the index number for the ds1820probes array.
+ * Returns 1 on successful update, 0 otherwise */
+uint8_t ds1820updateprobe(uint8_t probenum);
+
+#endif /* __DS1820_H__ */
diff --git a/ds1820tousb.shipped.bin b/ds1820tousb.shipped.bin
new file mode 100755
index 0000000000000000000000000000000000000000..9d1775f83d6dc37724afeb0d161d32740b3c3c6a
GIT binary patch
literal 3902
zcmZu!3vd(H6@BZk1OZ7v{Hg6&vJ_+o<6RSyA)m(3WYUtB$V^L`khYQ?<6z21Oj5`f
z@6*SUzuLF!^@or^(zIdP>43+R7)n78NWf%<tO<}Q6O7iz2Ad>!9g7GD9QCbau+yNO
z_d9#{zI*Sx@7}8?@S<ZC_yt^!&wk>-cKj#&NBjr;JYJ2T!_VTRL~W8KaVt=tBH#p@
zz#6cDjBCJpP)Sy=5VV4<G7>AmOQ0Am0gC_wUM6q;Le}MA4yC7}0BCU9`D8#*34qcj
zWReMBGqp(oP=NeWlVPF;bOVDW_mDJrO1=<08Ju^>->3WNdNVv|_>b<8Ufy+SuYBcV
zR8GLj+${e62Rl;FMfCFf1f_5e|If!dQu`vMXC64-CV9JD4sWo&i>;^+)(^0P3)Bs=
z0t6Z{S2$0l(JX?%6HUb|a)Gv?TB}Nth~qSfzBr`FjR*>;G&Ak|SQ+ge;^cSEX500I
zLoQNzNJ2>95D$dX)`?bZL;=8}CeXM@t2E&@Myu50BUgIlBUz`k?yp&4OKf)s(DN0*
z57{jy<umH<XY%PvydCQKYETRPW>Z+tvmj4?278&zFeeD06xT4PuGK@xEDJXcaxy0%
zzzQ75>sx?b1Y<8xVFi6A>}E#8?PfyTH-%f|yD=iPuKsCQ|4hsitY%;e%kQJGQD%vy
zDnJ(YGp4Xf_6~Eh0oTT)5rG!hF$RLB;Ch0@ZEBPQ(`2Aa9t!)RZ=wjYLn@zC9Ej=F
z1YPNxa6WAm%7_JcVkrl){qKnF%Rrz+8@AyLx|Y!>88Xab2@Q+3OrFUWU@&hUWl;t2
zMN@DY?IXM0_&kHoBNpcXgAk~R&cKKsr#`s6SN5Prp|}N=o{MO1V~}8|v@ddkqFM~4
zP=|7I?YHch$vDDso_o)f(d+H&nPo~~M3o>3$H$F*4#5GM`)WFCoW)_4vz`}-4vip$
zB&2%6P3lXEg`Neh+dbGSQ>~*B4ti)-tTnT4c$JGGg{ZE-B{pMaPPUj0VMxa5-`4ik
ziPOJqimi8`x)BvO%8cA>HYg@Co}e^h8*P+p=^AT`$VL-z!%&-*w&ybjrBVz_wRF2x
zBkpU%ZOi1!i%!{hk(2)w(ulZi-*%0dPcyQSc>TWZu8S(?eQkjeb#+V9eQjP@#Y^l<
z2*3H_u%r<sKE#jkQC=s+y*`7U;>?D;gJ(mBi+U}`sEx8yt~~n&)j%b!%C%i5R_P91
zryP)#KL};em#L$xLN*}#;lWT9g7n)2)7ev){gDqto`KF#{QD=*-lPUrMQuI^iDr2F
zzU^^4>rj*%;X<6mX~aEzkpF*~x^GKxFOlGD>SMB3AjadzmdGdaz8Uhv*F$TGT+fFz
zlXB^aT$_npEWMIox%M<7S5>I#s~1Ch`5%@8maCSiWd)wnJ1^93y{jkz`*rQPGn)G&
zngynoZst_-=19}Rt42e3S5YE{j5fTt$U#HeN_5pU_hpY}*UCd_qe;uI8O)j2;u@bk
zGo^6~W(RktWrn@-zO;7b@zeFx4k}Ld?@6iz-&~)?_keF#O-GIDLnMBYJ_!RE%RTZQ
z>Hn=2<n|DY(R>MS<L&$=zM2p4JNY|V@MPD8uEJI|)?Nte4xJ3@`A*{Jhe?x2>jghh
z#Vvk0MCI^x;&5cE<+WxT^#k=#%lE!vA1@aa6&DuH{`o!cQ2F)}+oQe(zA0O6yugke
zy-;ac*Q{C*%Dam?3VjQ`qWY-kcKl{fbN5~6vV9AE&U>i@{KQ?Wvg^eD$n1qvJl0*9
z?sYF*$Vk^JCD_1}g@5Y1>P}U7+q^3BZpzD5ul|B+K%RmIVf7t6K3P;BnT}d7PblKh
ztnr-Vl+VdIMIuq2?*3d=q7xJ=8lj8a?2Uy>@YRKbqWZK_Rwv^$m=E7UmMLzZ5I(B6
z+(-DtxupH*7OL{ynR*AgNiGs!;vU2e3=<F1Do)8mvGRYZ4XBZd^bUK!_s&kwP2C^y
zo3+Xc5?MO|JCQ)VV-}eoj?JO!El7&ZT_j(+WeshxrcUU^?%3V+pN@N?6`CAYcL6lI
zN2&AFUsnZfY7AZAebn2ZK9+hS5~tpL`qn+4Q!}?_Ud`P#`Wi!x=c~_pr%o-<d!1?}
z8Nd+c9SQjDYO->_cryWSDO5fyY?<=4J9+I+F2GfDn>agX<4QQ1c=40;d5R&~(M%WU
zT(nCJI6aI}c__;ri+HqiKJ#q2-Ks_*Gts19H=3hH5(sDD`OM16H))ePvams*v6Wdq
ziO-nCeQ-?5zl}yek6VQG4oL;K(eNY+y}eS=?LCJH`f!W7>s7L=BxUm@c0&t?hQVUu
ztACT4b(}B^JTY01PgXbVhtR<uWIuGpdOzv+Z_gjPzt49W#j=H|lv#QrvcIkUOFzlz
zw5(cew+IjF4w(+l?)|>U+vVHl4SKuSa&PdJ<|ayK&$aCqJHBMm72r1)Ut>|ZIx5j#
zJzq|4@c>vy^5y_=5h+wV1tvA|K{b!K=o!6GW`!#t<&;Ah1Ww@+sWvVHP8b4D<C{H3
zG)OY;C9o7-2Bl~SlxMv((=$_?x#9lJ$uJou%cIkImrdhsA-pZUeltZfxmtB)6F(dP
zaT!+JvL>u`yI`H$4eQ+=*x>fUMt2Qta<krm8+!e|wQ@I=M>HD%0Xr)U01u;ARE_jJ
z(N*+F@!X_FG0U_lc9SwdgZb64_tI3Q<ASWP2DnLI30x$4{)WVn%xeujRqof^_3j<+
z>9l%&4bT(1T0;FIs3ZMaP*3_Q&_Mciz(efyXClLT;3u4{cn-7wM|;Ijz@*gmt9zzk
zU!OXvRxT$!C(p)nnF3Px4THdl8qMdC%Id!JyTzy!s}z26M>L|l%j<9lYe{um8zglo
zuj6$e>3D;M76QUfVUG|LMue#FO0yAd07lW|>?aZJsxF$Vw*Kd$HWniI9_)lv%ey%p
zIjkGG-*b1mjlu>HMI$JP_Mn|8fM}%Sbcb|YE|($7gwv0CIN)aJf&$ctyXpP3D(N!0
z^om2=WPdii5G@&TSzAS)s8>8z(OP2f9vdT7#FbE^@U}pz2|?<Tgrj1|Tf>o#w`Ssw
zx3r|Cl9o(bB54#pf-$M5Lqf0h(`Q09TA)YNH#7>NOOjfJ*n~|&N+)&0I9?(=BHM*~
z@YB^4oz|J=>{Cn*0CKRNUQwM#W+|O1PNd}EUsqck6b*n%vr@SSt7Eb9%j$ebR&1^f
zmt)&VLG`(BDJyluG_HQvF=i%fz146dZydy^s>ZC_PQ@t9<MbQD->OuZV=9GZoPM=n
zG)^@<s`9vZoPNnb5S8ZLQI%%?cph_IiPJn6qp^-#7+Lv+Rh4tOpwbw}i%Ywek0jeR
z^}EB0vFx;DELWvPitWuWB-`sMUZxl;&PledaV?B%&rAA&p9O(66F*W~EFR73S*orz
zF!53C=*-3AiV-z}OlZ)}nfs0O6nr9A`{2saS&Iw`^;kg!2+hEbO3)@`BlWC~oO}p<
z+I4KANRp5glu(9fM9m=2Ts5XA|8@-K+G~rMx=}{pfl+7zdU8&W$i-QV5CHQrAQTjn
zbZy3<&AB|xkSc%iL^cMbf<AV+N6x|wx&4bL<`M*gBSSs%9Gq-55bZN#WA5b2f}a{p
zz>B_loc_44M_weSccwWGZ`X9DA9zMK4pox+HQ8zvH3!ng?2_x>trPc0;t2VB8N<52
zi?7qgN;$hkb70qZ1?XYX6wy}ekpK)j&4FVpdzKm$z0e3$J0&>MJ2R`7(#xxVE3YP5
z7+}KZz^@LxEUmHviy9eIX8%67Qnxj??C#CUCZ&b=HfU{+h%~!ULvHHoC<Xop>jZMY
literal 0
HcmV?d00001
diff --git a/ds1wire.h b/ds1wire.h
new file mode 100644
index 0000000..df32881
--- /dev/null
+++ b/ds1wire.h
@@ -0,0 +1,104 @@
+/* $Id: ds1wire.h,v 1.2 2010/03/23 07:57:04 simimeie Exp $
+ * Basic operations for dallas / maxim 1wire bus
+ * (C) Michael "Fox" Meier 2009
+ */
+
+#ifndef __DS1WIRE_H__
+#define __DS1WIRE_H__
+
+#include <util/delay.h>
+
+/* This macro is redundant after powerup, as all bits zero is the default
+ * state after powerup. */
+#define ds1wire_init(port, bit) {\
+ DDR##port &= (uint8_t)~(_BV(bit)); /* Do not actively drive the bus */ \
+ PORT##port &= (uint8_t)~(_BV(bit)); /* Always output a 0, so we just need to change */ \
+ /* the DDR register to pull the bus low. */ \
+}
+
+/* Reset the 1 wire bus. Works by driving it low for > 480 us.
+ * we do 500 to make sure.
+ * We then read the presence pulse 60 us after releasing the bus,
+ * and wait for another 420+1 us for the bus to become free.
+ * Returns 1 if there was a presence pulse, and 0 otherwise.
+ * takes about 981 usec to execute.
+ */
+#define ds1wire_reset(port, bit) \
+ __ds1wire_reset(&DDR##port, &PIN##port, _BV(bit))
+
+static inline uint8_t __ds1wire_reset(volatile uint8_t * ddr, volatile uint8_t * pin, uint8_t bv) {
+ uint8_t ret;
+ *ddr |= bv; /* drive the bus low */
+ _delay_ms(0.50);
+ *ddr &= (uint8_t)~bv; /* release the bus */
+ _delay_us(60.0);
+ ret = ((*pin & bv) == 0);
+ _delay_ms(0.421);
+ return ret;
+}
+
+/* Actively pull down the 1 wire bus. For hard resetting parasite powered
+ * probes that have gone bonkers. */
+#define ds1wire_pulldown(port, bit) {\
+ PORT##port &= (uint8_t)~(_BV(bit)); /* Output 0 (sucking away the current from the pullup) */ \
+ DDR##port |= _BV(bit); /* Actively drive the bus */ \
+}
+
+/* Read a bit from the 1 wire bus. takes 61 usec to execute. */
+#define ds1wire_read(port, bit) \
+ __ds1wire_read(&DDR##port, &PIN##port, _BV(bit))
+
+static inline uint8_t __ds1wire_read(volatile uint8_t * ddr, volatile uint8_t * pin, uint8_t bv) {
+ uint8_t ret;
+ *ddr |= bv; /* drive the bus low */
+ _delay_us(5.0); /* everything > 1 us should suffice, more to be sure. */
+ *ddr &= (uint8_t)~bv; /* release the bus */
+ _delay_us(6.0); /* Wait for the probe to pull the bus */
+ ret = ((*pin & bv) != 0);
+ _delay_us(50.0); /* after that the bus is free again */
+ return ret;
+}
+
+/* Sends a 0 bit to the 1 wire bus. takes 61 usec to execute. */
+#define ds1wire_send0(port, bit) {\
+ DDR##port |= _BV(bit); /* pull low */ \
+ _delay_us(60.0); /* worst case timing */ \
+ DDR##port &= (uint8_t)~_BV(bit); /* release */ \
+ _delay_us(1.0); /* bus is free again after that */ \
+ }
+
+/* Sends a 1 bit to the 1 wire bus. takes 61 usec to execute. */
+#define ds1wire_send1(port, bit) {\
+ DDR##port |= _BV(bit); /* pull low */ \
+ _delay_us(10.0); /* everything > 1 us should suffice, try to be close to 15 us. */ \
+ DDR##port &= (uint8_t)~_BV(bit); /* release */ \
+ _delay_us(51.0); /* bus is free again after that */ \
+}
+
+/* Enable power for parasite powered probes. Warning: You must
+ * not forget to call parasitepoweroff after some time! */
+#define ds1wire_parasitepoweron(port, bit) { \
+ PORT##port |= _BV(bit); \
+ DDR##port |= _BV(bit); \
+}
+
+/* Disable power for parasite powered probes. */
+#define ds1wire_parasitepoweroff(port, bit) \
+ ds1wire_init(port, bit)
+
+static inline uint8_t ds1wire_calccrc8(uint8_t shiftreg, uint8_t data)
+{
+ uint8_t i;
+ for (i = 0; i < 8; i++) {
+ /* XOR LSB of shiftreg with LSB of data */
+ uint8_t feedback = (shiftreg & 0x01) ^ (data & 0x01);
+ shiftreg >>= 1; /* first position in shiftreg now is 0 - important for below! */
+ if (feedback == 1) {
+ shiftreg = shiftreg ^ 0x8C; /* binary 10001100 */
+ }
+ data >>= 1;
+ }
+ return shiftreg;
+}
+
+#endif /* __DS1WIRE_H__ */
diff --git a/hardware/.cvsignore b/hardware/.cvsignore
new file mode 100644
index 0000000..e91b8e4
--- /dev/null
+++ b/hardware/.cvsignore
@@ -0,0 +1,6 @@
+DS18B20.pdf
+DS18S20.pdf
+appibstd-book-of-ibutton-standards.pdf
+circuit-att45ds1820.b#*
+circuit-att45ds1820.s#*
+
diff --git a/hardware/circuit-att45ds1820.brd b/hardware/circuit-att45ds1820.brd
new file mode 100644
index 0000000000000000000000000000000000000000..bf536ca431063a7541786c686791a9aeab2762cf
GIT binary patch
literal 14562
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
literal 0
HcmV?d00001
diff --git a/hardware/circuit-att45ds1820.sch b/hardware/circuit-att45ds1820.sch
new file mode 100644
index 0000000000000000000000000000000000000000..b320af34d5b8b56d9e5780e225fa17d87c6a4c76
GIT binary patch
literal 246063
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�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
literal 0
HcmV?d00001
diff --git a/hostsoftware.c b/hostsoftware.c
new file mode 100644
index 0000000..d17d86f
--- /dev/null
+++ b/hostsoftware.c
@@ -0,0 +1,689 @@
+/* $Id: hostsoftware.c,v 1.10 2010/07/13 20:12:10 simimeie Exp $
+ * This is the control software for the ds1820-to-usb device that runs
+ * on the USB host to which the device is connected.
+ * You will need libusb and its development headers to compile this.
+ * On Linux, you will usually have to run this as root to be allowed to
+ * access the device, unless you configure udev accordingly.
+ * This is based on powerSwitch.c, included in the reference implementation
+ * from Objective Development Software GmbH for the avrusb library from the
+ * same company.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <usb.h> /* this is libusb, see http://libusb.sourceforge.net/ */
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/select.h> /* According to POSIX.1-2001 */
+
+int verblev = 1;
+#define VERBPRINT(lev, fmt...) \
+ if (verblev > lev) { \
+ printf(fmt); \
+ fflush(stdout); \
+ }
+int devicenr = 1;
+int runinforeground = 0;
+int restartonerror = 0;
+
+#define USBDEV_SHARED_VENDOR 0x16C0 /* VOTI */
+#define USBDEV_SHARED_PRODUCT 0x05DC /* Obdev's free shared PID */
+/* Use obdev's generic shared VID/PID pair and follow the rules outlined
+ * in firmware/usbdrv/USBID-License.txt.
+ */
+
+/* These are the vendor specific SETUP commands implemented by our USB device */
+#define CMD_ECHO 0 /* echo 2 bytes */
+#define CMD_STATUS_SHORT 1 /* query device for status */
+#define CMD_RESCAN 2 /* tell the device to rescan the probe bus */
+#define CMD_STATUS_LONG 3 /* query device for list of probes and their status */
+#define CMD_HARDRESET 4 /* reset device and probe bus */
+
+struct daemondata {
+ unsigned char serial[6];
+ unsigned int port;
+ int fd;
+ time_t lastseen;
+ double lasttemp;
+ unsigned char outputformat[1000];
+ struct daemondata * next;
+};
+
+static void usage(char *name)
+{
+ printf("usage: %s [-v] [-q] [-d n] [-h] command <parameters>\n", name);
+ printf(" -v more verbose output. can be repeated numerous times.\n");
+ printf(" -q less verbose output. using this more than once will have no effect.\n");
+ printf(" -d n Use the n-th device found (default: 1)\n");
+ printf(" -f relevant for daemon mode only: run in foreground.\n");
+ printf(" -h show this help\n");
+ printf("Valid commands are:\n");
+ printf(" test do an echo test with the device\n");
+ printf(" status query and show device status\n");
+ printf(" rescan tell the device to rescan its probe bus\n");
+ printf(" reset tell the device to reset the probe bus and itself\n");
+ printf(" showint shows 'interrupts' received from the device. These are\n");
+ printf(" not real interrupts, they are USB 'interrupts', and actually\n");
+ printf(" work by polling in regular intervals...\n");
+ printf(" daemon Daemonize and answer queries. This requires one or more\n");
+ printf(" parameters in the format 'serial:port', where serial is the serial\n");
+ printf(" number of a probe, and port is a TCP port where the data from this\n");
+ printf(" probe is to be served, e.g.: affeaffeaf:31337\n");
+ printf(" optionally, you can give a third parameter, that specifies how the\n");
+ printf(" output to the network should look like, e.g.: affeaffeaf:31337:%%T\n");
+ printf(" Available are: %%S = serial of probe, %%T = temperature,\n");
+ printf(" %%L = last seen timestamp. The default is '%%S %%T'.\n");
+}
+
+
+void sigpipehandler(int bla) { /* Dummyhandler for catching the event */
+ return;
+}
+
+
+static int usbGetStringAscii(usb_dev_handle *dev, int index, int langid, char *buf, int buflen)
+{
+ char buffer[256];
+ int rval, i;
+
+ if ((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, langid, buffer, sizeof(buffer), 1000)) < 0) {
+ return rval;
+ }
+ if (buffer[1] != USB_DT_STRING) {
+ return 0;
+ }
+ if ((unsigned char)buffer[0] < rval) {
+ rval = (unsigned char)buffer[0];
+ }
+ /* lossy conversion to ISO Latin1 */
+ rval /= 2;
+ for (i = 1; i < rval; i++) {
+ if (i > buflen) { /* destination buffer overflow */
+ break;
+ }
+ buf[i-1] = buffer[2 * i];
+ if (buffer[2 * i + 1] != 0) { /* outside of ISO Latin1 range */
+ buf[i-1] = '?';
+ }
+ }
+ buf[i-1] = 0;
+ return i-1;
+}
+
+
+static int usbOpenDevice(usb_dev_handle **device, int vendor, char *vendorName, int product, char *productName, int devicerequested)
+{
+ struct usb_bus *bus;
+ struct usb_device *dev;
+ usb_dev_handle *handle = NULL;
+ static int didUsbInit = 0;
+ int devicesfound = 0;
+
+ if (!didUsbInit) {
+ didUsbInit = 1;
+ usb_init();
+ }
+ usb_find_busses();
+ usb_find_devices();
+ for (bus = usb_get_busses(); bus; bus = bus->next) {
+ for (dev = bus->devices; dev; dev = dev->next) {
+ if ((dev->descriptor.idVendor == vendor) && (dev->descriptor.idProduct == product)) {
+ char string[256];
+ int len;
+ handle = usb_open(dev); /* we need to open the device in order to query strings */
+ if (!handle) {
+ VERBPRINT(1, "Warning: cannot open USB device: %s\n", usb_strerror());
+ continue;
+ }
+ if ((vendorName == NULL) && (productName == NULL)) { /* name does not matter */
+ /* we found it! */
+ devicesfound++;
+ if (devicesfound == devicerequested) {
+ break;
+ } else {
+ usb_close(handle);
+ handle = NULL;
+ continue;
+ }
+ }
+ /* now check whether the names match: */
+ len = usbGetStringAscii(handle, dev->descriptor.iManufacturer, 0x0409, string, sizeof(string));
+ if (len < 0) {
+ VERBPRINT(1, "Warning: cannot query manufacturer for device: %s\n", usb_strerror());
+ } else {
+ VERBPRINT(3, "seen device from vendor '%s'\n", string);
+ if (strcmp(string, vendorName) == 0) {
+ len = usbGetStringAscii(handle, dev->descriptor.iProduct, 0x0409, string, sizeof(string));
+ if (len < 0) {
+ VERBPRINT(1, "Warning: cannot query product for device: %s\n", usb_strerror());
+ } else {
+ VERBPRINT(3, "seen product '%s'\n", string);
+ if (strcmp(string, productName) == 0) {
+ devicesfound++;
+ if (devicesfound == devicerequested) {
+ break;
+ }
+ }
+ }
+ }
+ usb_close(handle);
+ handle = NULL;
+ }
+ }
+ if (handle) {
+ break; /* Stop searching */
+ }
+ }
+ }
+ if (handle != NULL) {
+ *device = handle;
+ return 0;
+ }
+ return 1;
+}
+
+void dodevicetest(usb_dev_handle * handle)
+{
+ unsigned char buffer[8];
+ unsigned short int i, v, r;
+ int nBytes;
+
+ VERBPRINT(0, "Doing device test, this may take some time...\n");
+ /* The test consists of writing 1000 random numbers to the device and checking
+ * the echo. This should discover systematic bit errors (e.g. in bit stuffing).
+ */
+ for (i = 0; i < 1000; i++){
+ VERBPRINT(2, ".");
+ v = rand() & 0xffff;
+ nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_ECHO, v, 0, (char *)buffer, sizeof(buffer), 5000);
+ if (nBytes != 2) {
+ if (nBytes < 0) {
+ fprintf(stderr, "ERROR: USB error: %s\n", usb_strerror());
+ }
+ fprintf(stderr, "ERROR: wrong number of bytes (%d instead of 2) received in iteration %d\n", nBytes, i);
+ fprintf(stderr, "value sent = 0x%x\n", v);
+ exit(1);
+ }
+ r = buffer[0] | (buffer[1] << 8);
+ if (r != v) {
+ fprintf(stderr, "ERROR: data error: received 0x%x instead of 0x%x in iteration %d\n", r, v, i);
+ exit(1);
+ }
+ }
+ VERBPRINT(0, "Test succeeded.\n");
+ exit(0);
+}
+
+static uint32_t make32bit(unsigned char * d) {
+ return *((uint32_t *)d);
+}
+
+static double maketemp(unsigned char * d) {
+ double res; int32_t t2;
+ t2 = ((d[1] & 0x0F) << 8) + d[0];
+ if (t2 > 0x07FF) { /* Negative temperature */
+ t2 -= 0x1000;
+ }
+ res = (double)t2 * 0.0625L;
+ return res;
+}
+
+static void dodevicestatus(usb_dev_handle * handle) {
+ int nBytes; int p; int i;
+ unsigned char buffer[1024]; /* That would be enough for 64 probes... */
+ uint32_t devicetime;
+ unsigned int nprobes;
+
+ nBytes = usb_control_msg(handle,
+ USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_STATUS_SHORT,
+ 0, 0,
+ (char *)buffer, 8,
+ 5000);
+ if (nBytes < 0) {
+ fprintf(stderr, "ERROR: USB error: %s\n", usb_strerror());
+ exit(1);
+ }
+ if (nBytes != 8) {
+ fprintf(stderr, "ERROR: invalid status received from device (%d bytes)\n", nBytes);
+ exit(1);
+ }
+ printf("Device Version is %02x.%02x\n", buffer[0], buffer[1]);
+ devicetime = make32bit(&buffer[2]);
+ printf("Device time is currently timestamp %u\n", devicetime);
+ nprobes = buffer[6];
+ printf("%u probes supported by device\n", nprobes);
+ if (nprobes >= ((sizeof(buffer)) / 16)) {
+ nprobes = ((sizeof(buffer)) / 16) - 1;
+ printf("Warning: Cannot handle this many probes myself - will only show first %u.\n", buffer[6]);
+ }
+ nBytes = usb_control_msg(handle,
+ USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_STATUS_LONG,
+ 0, 0,
+ (char *)buffer, (nprobes * 16),
+ 5000);
+ if ((nBytes % 16) != 0) {
+ fprintf(stderr, "ERROR: invalid status received from device (%d bytes)\n", nBytes);
+ exit(1);
+ }
+ if (nBytes != (nprobes * 16)) {
+ fprintf(stderr, "WARNING: expected %u probes, got %u.\n", nprobes, (nBytes / 16));
+ }
+ printf("%2s %-12s %2s %10s %10s %-6s\n", "fa", "serial", "fl", "lastseen", "ticksago", "lastvalue");
+ for (p = 0; p < nBytes; p += 16) {
+ printf("%02x ", buffer[p+6]);
+ for (i = 5; i >= 0; i--) {
+ printf("%02x", buffer[p+i]);
+ }
+ if ((buffer[p+7] & 0x01) == 0x01) { /* in USE */
+ printf(" U");
+ } else {
+ printf(" ");
+ }
+ if ((buffer[p+7] & 0x02) == 0x02) { /* Parasite powered */
+ printf("P");
+ } else {
+ printf(" ");
+ }
+ printf(" %10u %10u ", make32bit(&buffer[p+10]),
+ devicetime - make32bit(&buffer[p+10]));
+ printf("%6.2lf\n", maketemp(&buffer[p+8]));
+ }
+}
+
+static void doshowint(usb_dev_handle * handle) {
+ int nBytes; int i;
+ unsigned char buffer[8];
+
+ printf("Waiting for 'interrupts' from the device - abort with ctrl+c\n");
+ while (1) {
+ nBytes = usb_interrupt_read(handle,
+ USB_ENDPOINT_IN | 0x01,
+ (char *)buffer, sizeof(buffer),
+ 0 /* no timeout */ );
+ if (nBytes < 0) {
+ fprintf(stderr, "ERROR: USB error: %s\n", usb_strerror());
+ exit(1);
+ }
+ if (nBytes != 8) {
+ fprintf(stderr, "ERROR: invalid interrupt message received from device (%d bytes instead of 8) - continuing\n", nBytes);
+ continue;
+ }
+ {
+ char tbuf[100];
+ time_t tt;
+ tt = time(NULL);
+ strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", localtime(&tt));
+ printf("[%s] ", tbuf);
+ }
+ printf("Data: probeserial='");
+ for (i = 5; i >= 0; i--) {
+ printf("%02x", buffer[i]);
+ }
+ printf("' temp='%6.2lf'\n", maketemp(&buffer[6]));
+ }
+ /* never reached */
+}
+
+void logaccess(struct sockaddr * soa, int soalen, char * txt) {
+ struct sockaddr_in * sav4;
+ struct sockaddr_in6 * sav6;
+
+ if (soalen == sizeof(struct sockaddr_in6)) {
+ sav6 = (struct sockaddr_in6 *)soa;
+ if ((sav6->sin6_addr.s6_addr[ 0] == 0)
+ && (sav6->sin6_addr.s6_addr[ 1] == 0)
+ && (sav6->sin6_addr.s6_addr[ 2] == 0)
+ && (sav6->sin6_addr.s6_addr[ 3] == 0)
+ && (sav6->sin6_addr.s6_addr[ 4] == 0)
+ && (sav6->sin6_addr.s6_addr[ 5] == 0)
+ && (sav6->sin6_addr.s6_addr[ 6] == 0)
+ && (sav6->sin6_addr.s6_addr[ 7] == 0)
+ && (sav6->sin6_addr.s6_addr[ 8] == 0)
+ && (sav6->sin6_addr.s6_addr[ 9] == 0)
+ && (sav6->sin6_addr.s6_addr[10] == 0xFF)
+ && (sav6->sin6_addr.s6_addr[11] == 0xFF)) {
+ /* This is really a IPv4 not a V6 access, so log it as
+ * a such. */
+ VERBPRINT(2, "%d.%d.%d.%d\t%s\n", sav6->sin6_addr.s6_addr[12],
+ sav6->sin6_addr.s6_addr[13],
+ sav6->sin6_addr.s6_addr[14],
+ sav6->sin6_addr.s6_addr[15], txt);
+ } else {
+ /* True IPv6 access */
+ VERBPRINT(2, "%x:%x:%x:%x:%x:%x:%x:%x\t%s\n",
+ (sav6->sin6_addr.s6_addr[ 0] << 8) | sav6->sin6_addr.s6_addr[ 1],
+ (sav6->sin6_addr.s6_addr[ 2] << 8) | sav6->sin6_addr.s6_addr[ 3],
+ (sav6->sin6_addr.s6_addr[ 4] << 8) | sav6->sin6_addr.s6_addr[ 5],
+ (sav6->sin6_addr.s6_addr[ 6] << 8) | sav6->sin6_addr.s6_addr[ 7],
+ (sav6->sin6_addr.s6_addr[ 8] << 8) | sav6->sin6_addr.s6_addr[ 9],
+ (sav6->sin6_addr.s6_addr[10] << 8) | sav6->sin6_addr.s6_addr[11],
+ (sav6->sin6_addr.s6_addr[12] << 8) | sav6->sin6_addr.s6_addr[13],
+ (sav6->sin6_addr.s6_addr[14] << 8) | sav6->sin6_addr.s6_addr[15],
+ txt);
+ }
+ } else if (soalen == sizeof(struct sockaddr_in)) {
+ unsigned char brokeni32[4];
+
+ sav4 = (struct sockaddr_in *)soa;
+ brokeni32[0] = (sav4->sin_addr.s_addr & 0xFF000000UL) >> 24;
+ brokeni32[1] = (sav4->sin_addr.s_addr & 0x00FF0000UL) >> 16;
+ brokeni32[2] = (sav4->sin_addr.s_addr & 0x0000FF00UL) >> 8;
+ brokeni32[3] = (sav4->sin_addr.s_addr & 0x000000FFUL) >> 0;
+ VERBPRINT(2, "%d.%d.%d.%d\t%s\n", brokeni32[0], brokeni32[1],
+ brokeni32[2], brokeni32[3], txt);
+ } else {
+ VERBPRINT(2, "!UNKNOWN_ADDRESS_TYPE!\t%s\n", txt);
+ }
+}
+
+
+static void printtooutbuf(char * outbuf, int oblen, struct daemondata * dd) {
+ unsigned char * pos = &dd->outputformat[0];
+ while (*pos != 0) {
+ if (*pos == '%') {
+ pos++;
+ if (*pos == 'S') { /* Serial */
+ int i;
+ for (i = 5; i >= 0; i--) {
+ outbuf += sprintf(outbuf, "%02x", dd->serial[i]);
+ }
+ } else if ((*pos == 'T') || (*pos == 't')) { /* Temperature */
+ if ((dd->lastseen + 60) < time(NULL)) { /* Stale data / no data yet */
+ outbuf += sprintf(outbuf, "%s", "N/A");
+ } else {
+ if (*pos == 'T') { /* fixed width */
+ outbuf += sprintf(outbuf, "%6.2lf", dd->lasttemp);
+ } else { /* variable width. */
+ outbuf += sprintf(outbuf, "%.2lf", dd->lasttemp);
+ }
+ }
+ } else if (*pos == 'r') { /* carriage return */
+ *outbuf = '\r';
+ outbuf++;
+ } else if (*pos == 'n') { /* linefeed / Newline */
+ *outbuf = '\n';
+ outbuf++;
+ } else if (*pos == 'L') { /* Last seen */
+ outbuf += sprintf(outbuf, "%u", (unsigned int)dd->lastseen);
+ } else if (*pos == 0) {
+ *outbuf = 0;
+ return;
+ }
+ pos++;
+ } else {
+ *outbuf = *pos;
+ outbuf++;
+ pos++;
+ }
+ }
+ *outbuf = 0;
+}
+
+static void dotryrestart(struct daemondata * dd, char ** argv) {
+ if (restartonerror) {
+ struct daemondata * curdd = dd;
+ while (curdd != NULL) {
+ close(curdd->fd);
+ curdd = curdd->next;
+ }
+ fprintf(stderr, "Will try to restart in %d second(s)...\n", restartonerror);
+ sleep(restartonerror);
+ execv(argv[0], argv);
+ }
+}
+
+static void dodaemon(usb_dev_handle * handle, struct daemondata * dd, char ** argv) {
+ fd_set mylsocks;
+ struct daemondata * curdd;
+ struct timeval to;
+ int nBytes;
+ unsigned char buffer[8];
+ int maxfd;
+ int readysocks;
+
+ while (1) {
+ do {
+ curdd = dd; /* Start from beginning */
+ maxfd = 0;
+ FD_ZERO(&mylsocks);
+ while (curdd != NULL) {
+ FD_SET(curdd->fd, &mylsocks);
+ if (curdd->fd > maxfd) { maxfd = curdd->fd; }
+ curdd = curdd->next;
+ }
+ to.tv_sec = 0; to.tv_usec = 1;
+ if ((readysocks = select((maxfd + 1), &mylsocks, NULL, NULL, &to)) < 0) { /* Error?! */
+ if (errno != EINTR) {
+ perror("ERROR: error on select()");
+ dotryrestart(dd, argv);
+ exit(1);
+ }
+ } else {
+ curdd = dd;
+ while (curdd != NULL) {
+ if (FD_ISSET(curdd->fd, &mylsocks)) {
+ int tmpfd;
+ struct sockaddr_in6 srcad;
+ socklen_t adrlen = sizeof(srcad);
+ tmpfd = accept(curdd->fd, (struct sockaddr *)&srcad, &adrlen);
+ if (tmpfd < 0) {
+ perror("WARNING: Failed to accept() connection");
+ } else {
+ char outbuf[250];
+ printtooutbuf(outbuf, strlen(outbuf), curdd);
+ logaccess((struct sockaddr *)&srcad, adrlen, outbuf);
+ write(tmpfd, outbuf, strlen(outbuf));
+ close(tmpfd);
+ }
+ }
+ curdd = curdd->next;
+ }
+ }
+ } while (readysocks > 0);
+ /* Now check if there is anything available on USB */
+ nBytes = usb_interrupt_read(handle,
+ USB_ENDPOINT_IN | 0x01,
+ (char *)buffer, sizeof(buffer),
+ 100 /* short timeout - but can't be shorter, else no data is seen? strange. */ );
+ if (nBytes < 0) { /* error reported by libusb */
+ /* As nice as libusb is, the documentation is just HORROR. And so is
+ * this interface: This is the best way I have found to check if the
+ * error is actually a timeout. I would expect something like an
+ * usb_errno variable one can poll, but no... */
+ if (nBytes != -ETIMEDOUT) {
+ fprintf(stderr, "ERROR: USB error: %s\n", usb_strerror());
+ dotryrestart(dd, argv);
+ exit(1);
+ }
+ } else if (nBytes != 8) { /* No error but wrong number of bytes */
+ fprintf(stderr, "WARNING: invalid interrupt message received from device (%d bytes instead of 8) - continuing\n", nBytes);
+ } else {
+ VERBPRINT(3, "interrupt data received from device %02x%02x%02x%02x%02x%02x ",
+ buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
+ curdd = dd;
+ while (curdd != NULL) {
+ if (memcmp(&curdd->serial[0], &buffer[0], 6) == 0) {
+ /* This belongs here - update! */
+ curdd->lasttemp = maketemp(&buffer[6]);
+ VERBPRINT(3, "temp = %.2f\n", curdd->lasttemp);
+ curdd->lastseen = time(NULL);
+ }
+ curdd = curdd->next;
+ }
+ }
+ }
+ /* never reached */
+}
+
+int main(int argc, char ** argv)
+{
+ usb_dev_handle * handle = NULL;
+ unsigned char buffer[8];
+ int nBytes;
+ int curarg;
+
+ for (curarg = 1; curarg < argc; curarg++) {
+ if (strcmp(argv[curarg], "-v") == 0) {
+ verblev++;
+ } else if (strcmp(argv[curarg], "-q") == 0) {
+ verblev--;
+ } else if (strcmp(argv[curarg], "-f") == 0) {
+ runinforeground = 1;
+ } else if (strcmp(argv[curarg], "-h") == 0) {
+ usage(argv[0]); exit(0);
+ } else if (strcmp(argv[curarg], "--help") == 0) {
+ usage(argv[0]); exit(0);
+ } else if (strcmp(argv[curarg], "--restartonerror") == 0) {
+ restartonerror++;
+ } else if (strcmp(argv[curarg], "-d") == 0) {
+ curarg++;
+ if (curarg >= argc) {
+ fprintf(stderr, "ERROR: -d requires a numeric parameter >= 1!\n");
+ usage(argv[0]); exit(1);
+ }
+ devicenr = strtoul(argv[curarg], NULL, 10);
+ if (devicenr <= 0) {
+ fprintf(stderr, "ERROR: -d requires a numeric parameter >= 1!\n");
+ usage(argv[0]); exit(1);
+ }
+ } else {
+ /* Unknown - must be the command. */
+ break;
+ }
+ }
+ if (curarg == argc) {
+ fprintf(stderr, "ERROR: No command given!\n");
+ usage(argv[0]);
+ exit(1);
+ }
+ usb_init();
+ if (usbOpenDevice(&handle, USBDEV_SHARED_VENDOR, "www.poempelfox.de", USBDEV_SHARED_PRODUCT, "ds1820tousb", devicenr) != 0) {
+ fprintf(stderr, "ERROR: Could not find the ds1820tousb device nr. %d on the USB.\n", devicenr);
+ exit(1);
+ }
+ if (usb_claim_interface(handle, 0) < 0) {
+ fprintf(stderr, "ERROR: Failed to claim ds1820tousb device nr. %d on the USB: %s\n", devicenr, usb_strerror());
+ exit(1);
+ }
+ if (strcmp(argv[curarg], "test") == 0) {
+ dodevicetest(handle);
+ } else if (strcmp(argv[1], "status") == 0) {
+ dodevicestatus(handle);
+ } else if (strcmp(argv[curarg], "rescan") == 0) {
+ nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_RESCAN, 0, 0, (char *)buffer, sizeof(buffer), 5000);
+ if (nBytes < 0) {
+ fprintf(stderr, "ERROR: USB error: %s\n", usb_strerror());
+ } else {
+ if (nBytes == 1) {
+ switch(buffer[0]) {
+ case 23:
+ VERBPRINT(0, "Device responded: OK, scheduling rescan\n");
+ break;
+ case 42:
+ VERBPRINT(0, "Device responded: rescan already scheduled or in progress\n");
+ break;
+ default:
+ fprintf(stderr, "ERROR: Invalid reply to rescan command from device (unknown status %02x)\n", buffer[0]);
+ break;
+ };
+ } else {
+ fprintf(stderr, "ERROR: Invalid reply to rescan command from device (%d bytes instead of 1)\n", nBytes);
+ }
+ }
+ } else if (strcmp(argv[curarg], "reset") == 0) {
+ nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CMD_HARDRESET, 0, 0, (char *)buffer, sizeof(buffer), 5000);
+ VERBPRINT(1, "%d bytes received as reply.\n", nBytes);
+ VERBPRINT(0, "%s\n", "Reset command sent. If this worked, you should see an USB disconnect and reconnect now\n");
+ } else if (strcmp(argv[curarg], "showint") == 0) { /* More of a debug mode: Show interrupt data */
+ doshowint(handle);
+ } else if (strcmp(argv[curarg], "daemon") == 0) { /* Daemon mode */
+ struct daemondata * mydaemondata = NULL;
+ curarg++;
+ do {
+ int l; int optval;
+ struct daemondata * newdd;
+ struct sockaddr_in6 soa;
+
+ if (curarg >= argc) continue;
+ newdd = calloc(sizeof(struct daemondata), 1);
+ newdd->next = mydaemondata;
+ mydaemondata = newdd;
+ l = sscanf(argv[curarg], "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx:%u:%999[^\n]",
+ &mydaemondata->serial[5], &mydaemondata->serial[4], &mydaemondata->serial[3], &mydaemondata->serial[2],
+ &mydaemondata->serial[1], &mydaemondata->serial[0], &mydaemondata->port, &mydaemondata->outputformat[0]);
+ if (l < 7) {
+ fprintf(stderr, "ERROR: failed to parse daemon command parameter '%s'\n", argv[curarg]);
+ exit(1);
+ }
+ if (l == 7) {
+ strcpy((char *)&mydaemondata->outputformat[0], "%S %T");
+ }
+ /* Open the port */
+ mydaemondata->fd = socket(PF_INET6, SOCK_STREAM, 0);
+ soa.sin6_family = AF_INET6;
+ soa.sin6_addr = in6addr_any;
+ soa.sin6_port = htons(mydaemondata->port);
+ optval = 1;
+ setsockopt(mydaemondata->fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
+ if (bind(mydaemondata->fd, (struct sockaddr *)&soa, sizeof(soa)) < 0) {
+ perror("Bind failed");
+ printf("Could not bind to port %u\n", mydaemondata->port);
+ exit(1);
+ }
+ if (listen(mydaemondata->fd, 20) < 0) { /* Large Queue as we block for some time while reading USB! */
+ perror("Listen failed");
+ exit(1);
+ }
+ curarg++;
+ } while (curarg < argc);
+ if (mydaemondata == NULL) {
+ fprintf(stderr, "ERROR: the daemon command requires parameters.\n");
+ exit(1);
+ }
+ /* the good old doublefork trick from 'systemprogrammierung 1' */
+ if (runinforeground != 1) {
+ int ourpid;
+ VERBPRINT(2, "launching into the background...\n");
+ ourpid = fork();
+ if (ourpid < 0) {
+ perror("Ooops, fork() #1 failed");
+ exit(1);
+ }
+ if (ourpid == 0) { /* We're the child */
+ ourpid = fork(); /* fork again */
+ if (ourpid < 0) {
+ perror("Ooooups. fork() #2 failed");
+ exit(1);
+ }
+ if (ourpid == 0) { /* Child again */
+ /* Just don't exit, we'll continue below. */
+ } else { /* Parent */
+ exit(0); /* Just exit */
+ }
+ } else { /* Parent */
+ exit(0); /* Just exit */
+ }
+ }
+ {
+ struct sigaction sia;
+ sia.sa_handler = sigpipehandler;
+ sigemptyset(&sia.sa_mask); /* If we don't do this, we're likely */
+ sia.sa_flags = 0; /* to die from 'broken pipe'! */
+ sigaction(SIGPIPE, &sia, NULL);
+ }
+ dodaemon(handle, mydaemondata, argv);
+ } else {
+ fprintf(stderr, "ERROR: Command '%s' is unknown.\n", argv[curarg]);
+ usage(argv[0]);
+ exit(1);
+ }
+ usb_close(handle);
+ return 0;
+}
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..d590ce2
--- /dev/null
+++ b/main.c
@@ -0,0 +1,221 @@
+/* $Id: main.c,v 1.5 2010/06/09 23:13:28 simimeie Exp $
+ * USB interface for ds1820
+ * This is the main file that glues it all together.
+ * (C) Michael "Fox" Meier 2009
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/wdt.h>
+#include <avr/power.h>
+#include <avr/sleep.h>
+#include <util/delay.h>
+#include "usbdrv/usbdrv.h"
+#include "ds1820.h"
+#include "time.h"
+
+uint8_t doprobescan = 1;
+uint8_t curprobe;
+uint8_t usbreadpos;
+uint32_t readpendingts;
+uint8_t readpending;
+
+/* This is needed to recover from a watchdog reset, as the watchdog
+ * stays active after the reset. Without this we'll just do an
+ * endless reset loop */
+void get_mcusr(void) __attribute__((naked)) __attribute__((section(".init3")));
+void get_mcusr(void) {
+ MCUSR = 0;
+ wdt_disable();
+}
+
+/* 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
+ * the host communicates the parameters of the following (optional) data
+ * transfer. The SETUP data is available in the 'data' parameter which can
+ * (and should) be casted to 'usbRequest_t *' for a more user-friendly access
+ * to parameters. [...]
+ * in short: Set usbMsgPtr to your answer, and return number of bytes.
+ * return USB_NO_MSG to supply the long answer packets with the usbFunctionRead. */
+usbMsgLen_t usbFunctionSetup(uchar data[8])
+{
+ usbRequest_t *rq = (void *)data;
+ static uchar replyBuf[8];
+
+ if (rq->bRequest == 0){ /* ECHO */
+ usbMsgPtr = replyBuf;
+ replyBuf[0] = rq->wValue.bytes[0];
+ replyBuf[1] = rq->wValue.bytes[1];
+ return 2;
+ }
+ if (rq->bRequest == 1) { /* GET_STATUS_SHORT */
+ uint32_t curtime = gettime();
+ usbMsgPtr = replyBuf;
+ replyBuf[0] = 0; /* Version high */
+ replyBuf[1] = 1; /* Version low */
+ replyBuf[2] = ((uint8_t *)&curtime)[0]; /* Time */
+ replyBuf[3] = ((uint8_t *)&curtime)[1];
+ replyBuf[4] = ((uint8_t *)&curtime)[2];
+ replyBuf[5] = ((uint8_t *)&curtime)[3];
+ replyBuf[6] = DS1820_MAXPROBES; /* max. number of probes */
+ replyBuf[7] = 0; /* UNUSED */
+ return 8;
+ }
+ if (rq->bRequest == 2) { /* RESCAN_BUS */
+ usbMsgPtr = replyBuf;
+ if (doprobescan) {
+ replyBuf[0] = 42; /* Scan already scheduled / in progress */
+ } else {
+ replyBuf[0] = 23; /* OK, scan scheduled */
+ doprobescan = 1;
+ }
+ return 1;
+ }
+ if (rq->bRequest == 3) { /* GET_STATUS_LONG */
+ /* the answer to this query will list all probes on the bus
+ * and thus can be very lengthy. We will handle that with usbFunctionRead */
+ usbreadpos = 0;
+ return USB_NO_MSG;
+ }
+ if (rq->bRequest == 4) { /* RESET_HARD */
+ /* Reset, both the probe bus and ourselves. We reset ourselves through
+ * the watchdog timer and just pull the 1wire bus low. */
+ ds1820killbus();
+ wdt_reset(); /* Make sure we get the full 2 seconds */
+ for (;;) { }
+ }
+ /* Unknown request. Ignore. */
+ return 0;
+}
+
+/* This function is called by the driver to ask the application for a control
+ * transfer's payload data (control-in). It is called in chunks of up to 8
+ * bytes each. You should copy the data to the location given by 'data' and
+ * return the actual number of bytes copied. If you return less than requested,
+ * the control-in transfer is terminated. If you return 0xff, the driver aborts
+ * the transfer with a STALL token. */
+uchar usbFunctionRead(uchar *data, uchar len) {
+ uint8_t i;
+ for (i = 0; i < len; i++) {
+ uint8_t j = usbreadpos + i;
+ uint8_t probenum = j / 16;
+ uint8_t probeoff = j % 16;
+ if (probenum >= DS1820_MAXPROBES) {
+ return (i - usbreadpos); /* the end - no more data */
+ }
+ if (probeoff < 6) {
+ data[i] = ds1820probes[probenum].serial[probeoff];
+ } else if (probeoff == 6) {
+ data[i] = ds1820probes[probenum].family;
+ } else if (probeoff == 7) {
+ data[i] = ds1820probes[probenum].flags;
+ } else if (probeoff == 8) {
+ data[i] = ds1820probes[probenum].lasttemp[0];
+ } else if (probeoff == 9) {
+ data[i] = ds1820probes[probenum].lasttemp[1];
+ } else if (probeoff < 14) {
+ uint8_t * tp = (uint8_t *)&ds1820probes[probenum].lastts;
+ data[i] = tp[probeoff - 10];
+ } else {
+ data[i] = 0; /* Unused */
+ }
+ }
+ usbreadpos += len;
+ return len;
+}
+
+int main(void)
+{
+ /* Some powersaving: Disable unused stuff */
+ power_adc_disable();
+ power_usi_disable();
+ power_timer1_disable();
+
+ /* From the avr usb doku wiki: Call usbDeviceDisconnect(), wait several
+ * 100 milliseconds and then call usbDeviceConnect(). This enforces
+ * (re-)enumeration of the device. In theory, you don't need this, but
+ * it prevents inconsistencies between host and device after hardware
+ * or watchdog resets. */
+ usbDeviceDisconnect();
+ _delay_ms(500.0);
+ usbDeviceConnect();
+
+ /* This function must be called before interrupts are enabled and the main
+ * loop is entered. */
+ usbInit();
+
+ /* Reset if we don't return to the main loop within 2 seconds */
+ wdt_enable(WDTO_2S);
+
+ /* Init the ds1820 code and bus */
+ ds1820init();
+
+ /* Init timer */
+ time_init();
+
+ /* Prepare sleep mode */
+ set_sleep_mode(SLEEP_MODE_IDLE);
+ sleep_enable();
+
+ /* All set up, enable interrupts and go. */
+ sei();
+
+ while (1) { /* We should never exit, or should we? */
+ wdt_reset();
+
+ /* This function must be called at regular intervals from the main loop.
+ * Maximum delay between calls is somewhat less than 50ms (USB timeout for
+ * accepting a Setup message). Otherwise the device will not be recognized.
+ * If other functions are called from the USB code, they will be called from
+ * usbPoll(). */
+ usbPoll();
+
+ if ((readpending == 0) && (doprobescan)) {
+ ds1820scan();
+ doprobescan = 0;
+ curprobe = 0;
+ } else {
+ if (readpending == 0) {
+ /* Select next probe to query */
+ if ((ds1820probes[curprobe].flags & DS1820FLAG_SLOTINUSE) == DS1820FLAG_SLOTINUSE) {
+ ds1820queryprobe(curprobe);
+ }
+ readpending = 1;
+ readpendingts = gettime();
+ } else {
+ if ((gettime() - readpendingts) > 60) { /* >1 second passed, data should be ready */
+ if ((ds1820probes[curprobe].flags & DS1820FLAG_SLOTINUSE) == DS1820FLAG_SLOTINUSE) { /* Is that probe even there? */
+ if (ds1820updateprobe(curprobe)) { /* Successful, send updated data */
+ if (usbInterruptIsReady()) { /* Last message has been sent, so send new data */
+ uint8_t whattosend[8];
+ uint8_t i;
+ for (i = 0; i < 6; i++) {
+ whattosend[i] = ds1820probes[curprobe].serial[i];
+ }
+ whattosend[6] = ds1820probes[curprobe].lasttemp[0];
+ whattosend[7] = ds1820probes[curprobe].lasttemp[1];
+ /* This function sets the message which will be sent during the next interrupt
+ * IN transfer. The message is copied to an internal buffer and must not exceed
+ * a length of 8 bytes. The message may be 0 bytes long just to indicate the
+ * interrupt status to the host.
+ * If you need to transfer more bytes, use a control read after the interrupt. */
+ /* void usbSetInterrupt(uchar *data, uchar len);*/
+ usbSetInterrupt(whattosend, 8);
+ }
+ }
+ }
+ curprobe++;
+ if (curprobe >= DS1820_MAXPROBES) { curprobe = 0; }
+ readpending = 0;
+ }
+ }
+ }
+
+ /* Go to sleep now */
+ sleep_cpu();
+ }
+
+ /* Never reached */
+ return 0;
+}
diff --git a/time.c b/time.c
new file mode 100644
index 0000000..cc38652
--- /dev/null
+++ b/time.c
@@ -0,0 +1,35 @@
+/* $Id: time.c,v 1.2 2009/03/16 20:32:23 simimeie Exp $
+ * USB interface for ds1820
+ * This file provides time functions.
+ * (C) Michael "Fox" Meier 2009
+ */
+
+#include <avr/interrupt.h>
+#include "time.h"
+
+static volatile uint32_t curts[2] = { 0, 0 };
+static volatile uint8_t actts = 0;
+
+void time_init(void) {
+ /* Set timer0 to run with CLK/1024. That gives 57.2 Overflow interrupts
+ * per second at 15 MHz. */
+ TCCR0B |= _BV(2) | _BV(0);
+ /* Enable timer interrupts */
+ TIMSK |= _BV(1);
+}
+
+/* ISR(TIM1_OVF_vect, ISR_NOBLOCK) doesn't work in the goddamn stoneage ubuntu version */
+ISR(TIM0_OVF_vect)
+{
+ sei(); /* Workaround, should use ISR_NOBLOCK instead */
+ {
+ uint8_t nextts = (~actts) & 0x01;
+ curts[nextts]++;
+ actts = nextts;
+ }
+}
+
+uint32_t gettime(void)
+{
+ return curts[actts];
+}
diff --git a/time.h b/time.h
new file mode 100644
index 0000000..d7487a9
--- /dev/null
+++ b/time.h
@@ -0,0 +1,18 @@
+/* $Id: time.h,v 1.1.1.1 2009/03/15 17:46:59 simimeie Exp $
+ * USB interface for ds1820
+ * This file provides time functions.
+ * (C) Michael "Fox" Meier 2009
+ */
+
+#ifndef __TIME_H__
+#define __TIME_H__
+
+
+/* This inits the timer */
+void time_init(void);
+
+/* This returns a timestamp. The timestamp increments about 10 times
+ * per second. */
+uint32_t gettime(void);
+
+#endif /* __TIME_H__ */
diff --git a/usbconfig.h b/usbconfig.h
new file mode 100644
index 0000000..e7ae7a5
--- /dev/null
+++ b/usbconfig.h
@@ -0,0 +1,352 @@
+/* Name: usbconfig.h
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2005-04-01
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbconfig.h,v 1.1.1.1 2009/03/15 17:46:59 simimeie Exp $
+ */
+
+#ifndef __usbconfig_h_included__
+#define __usbconfig_h_included__
+
+/*
+General Description:
+This file is an example configuration (with inline documentation) for the USB
+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 ---------------------------- */
+
+#define USB_CFG_IOPORTNAME B
+/* 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 1
+/* 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! [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, 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
+ */
+
+/* ----------------------- Optional Hardware Config ------------------------ */
+
+/* #define USB_CFG_PULLUP_IOPORTNAME D */
+/* If you connect the 1.5k pullup resistor from D- to a port pin instead of
+ * V+, you can connect and disconnect the device from firmware by calling
+ * the macros usbDeviceConnect() and usbDeviceDisconnect() (see usbdrv.h).
+ * This constant defines the port on which the pullup resistor is connected.
+ */
+/* #define USB_CFG_PULLUP_BIT 4 */
+/* This constant defines the bit number in USB_CFG_PULLUP_IOPORT (defined
+ * above) where the 1.5k pullup resistor is connected. See description
+ * above for details.
+ */
+
+/* --------------------------- Functional Range ---------------------------- */
+
+#define USB_CFG_HAVE_INTRIN_ENDPOINT 1
+/* Define this to 1 if you want to compile a version with two endpoints: The
+ * 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 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
+ * for endpoint 1 (interrupt endpoint). Although you may not need this feature,
+ * it is required by the standard. We have made it a config option because it
+ * bloats the code considerably.
+ */
+#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 200
+/* 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.
+ * (fox) don't make this too high, it will overflow due to the high clock rate
+ */
+#define USB_CFG_IS_SELF_POWERED 0
+/* Define this to 1 if the device has its own power supply. Set it to 0 if the
+ * device is powered from the USB bus.
+ */
+#define USB_CFG_MAX_BUS_POWER 50
+/* Set this variable to the maximum USB bus power consumption of your device.
+ * The value is in milliamperes. [It will be divided by two since USB
+ * communicates power requirements in units of 2 mA.]
+ */
+#define USB_CFG_IMPLEMENT_FN_WRITE 0
+/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
+ * transfers. Set it to 0 if you don't need it and want to save a couple of
+ * bytes.
+ */
+#define USB_CFG_IMPLEMENT_FN_READ 1
+/* Set this to 1 if you need to send control replies which are generated
+ * "on the fly" when usbFunctionRead() is called. If you only want to send
+ * data from a static buffer, set it to 0 and return the data from
+ * 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) endpoints.
+ * You must implement the function usbFunctionWriteOut() which receives all
+ * 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 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 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: 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', '.', 'p', 'o', 'e', 'm', 'p', 'e', 'l', 'f', 'o', 'x', '.', 'd', 'e'
+#define USB_CFG_VENDOR_NAME_LEN 17
+/* 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.
+ * If you don't want a vendor name string, undefine these macros.
+ * ALWAYS define a vendor name containing your Internet domain name if you use
+ * obdev's free shared VID/PID pair. See the file USBID-License.txt for
+ * details.
+ */
+#define USB_CFG_DEVICE_NAME 'd', 's', '1', '8', '2', '0', 't', 'o', 'u', 's', 'b'
+#define USB_CFG_DEVICE_NAME_LEN 11
+/* Same as above for the device name. If you don't want a device name, undefine
+ * the macros. See the file USBID-License.txt before you assign a name if you
+ * use a shared VID/PID.
+ */
+/*#define USB_CFG_SERIAL_NUMBER 'N', 'o', 'n', 'e' */
+/*#define USB_CFG_SERIAL_NUMBER_LEN 0 */
+/* Same as above for the serial number. If you don't want a serial number,
+ * undefine the macros.
+ * It may be useful to provide the serial number through other means than at
+ * compile time. See the section about descriptor properties below for how
+ * to fine tune control over USB descriptors such as the string descriptor
+ * for the serial number.
+ */
+#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 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. 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 */
+/* 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.
+ * 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!
+ */
+
+/* #define USB_PUBLIC static */
+/* Use the define above if you #include usbdrv.c instead of linking against it.
+ * This technique saves a couple of bytes in flash memory.
+ */
+
+/* ------------------- Fine Control over USB Descriptors ------------------- */
+/* If you don't want to use the driver's default USB descriptors, you can
+ * provide our own. These can be provided as (1) fixed length static data in
+ * flash memory, (2) fixed length static data in RAM or (3) dynamically at
+ * runtime in the function usbFunctionDescriptor(). See usbdrv.h for more
+ * information about this function.
+ * Descriptor handling is configured through the descriptor's properties. If
+ * 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(). 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),
+ * the driver must know the descriptor's length. The descriptor itself is
+ * found at the address of a well known identifier (see below).
+ * List of static descriptor names (must be declared PROGMEM if in flash):
+ * char usbDescriptorDevice[];
+ * char usbDescriptorConfiguration[];
+ * char usbDescriptorHidReport[];
+ * char usbDescriptorString0[];
+ * int usbDescriptorStringVendor[];
+ * int usbDescriptorStringDevice[];
+ * int usbDescriptorStringSerialNumber[];
+ * Other descriptors can't be provided statically, they must be provided
+ * dynamically at runtime.
+ *
+ * Descriptor properties are or-ed or added together, e.g.:
+ * #define USB_CFG_DESCR_PROPS_DEVICE (USB_PROP_IS_RAM | USB_PROP_LENGTH(18))
+ *
+ * The following descriptors are defined:
+ * USB_CFG_DESCR_PROPS_DEVICE
+ * USB_CFG_DESCR_PROPS_CONFIGURATION
+ * USB_CFG_DESCR_PROPS_STRINGS
+ * USB_CFG_DESCR_PROPS_STRING_0
+ * USB_CFG_DESCR_PROPS_STRING_VENDOR
+ * USB_CFG_DESCR_PROPS_STRING_PRODUCT
+ * USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+ * USB_CFG_DESCR_PROPS_HID
+ * 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
+#define USB_CFG_DESCR_PROPS_CONFIGURATION 0
+#define USB_CFG_DESCR_PROPS_STRINGS 0
+#define USB_CFG_DESCR_PROPS_STRING_0 0
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0
+#define USB_CFG_DESCR_PROPS_HID 0
+#define USB_CFG_DESCR_PROPS_HID_REPORT 0
+#define USB_CFG_DESCR_PROPS_UNKNOWN 0
+
+/* ----------------------- Optional MCU Description ------------------------ */
+
+/* The following configurations have working defaults in usbdrv.h. You
+ * usually don't need to set them explicitly. Only if you want to run
+ * the driver on a device which is not yet supported or with a compiler
+ * which is not fully supported (such as IAR C) or if you use a differnt
+ * interrupt than INT0, you may have to define some of these.
+ */
+/* #define USB_INTR_CFG MCUCR */
+/* #define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) */
+/* #define USB_INTR_CFG_CLR 0 */
+/* #define USB_INTR_ENABLE GIMSK */
+/* #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/usbdrv/Changelog.txt b/usbdrv/Changelog.txt
new file mode 100644
index 0000000..cdb6ed3
--- /dev/null
+++ b/usbdrv/Changelog.txt
@@ -0,0 +1,263 @@
+This file documents changes in the firmware-only USB driver for atmel's AVR
+microcontrollers. New entries are always appended to the end of the file.
+Scroll down to the bottom to see the most recent changes.
+
+2005-04-01:
+ - Implemented endpoint 1 as interrupt-in endpoint.
+ - Moved all configuration options to usbconfig.h which is not part of the
+ driver.
+ - Changed interface for usbVendorSetup().
+ - Fixed compatibility with ATMega8 device.
+ - Various minor optimizations.
+
+2005-04-11:
+ - Changed interface to application: Use usbFunctionSetup(), usbFunctionRead()
+ and usbFunctionWrite() now. Added configuration options to choose which
+ of these functions to compile in.
+ - Assembler module delivers receive data non-inverted now.
+ - Made register and bit names compatible with more AVR devices.
+
+2005-05-03:
+ - Allow address of usbRxBuf on any memory page as long as the buffer does
+ not cross 256 byte page boundaries.
+ - Better device compatibility: works with Mega88 now.
+ - Code optimization in debugging module.
+ - Documentation updates.
+
+2006-01-02:
+ - Added (free) default Vendor- and Product-IDs bought from voti.nl.
+ - Added USBID-License.txt file which defines the rules for using the free
+ shared VID/PID pair.
+ - Added Readme.txt to the usbdrv directory which clarifies administrative
+ issues.
+
+2006-01-25:
+ - Added "configured state" to become more standards compliant.
+ - Added "HALT" state for interrupt endpoint.
+ - Driver passes the "USB Command Verifier" test from usb.org now.
+ - Made "serial number" a configuration option.
+ - Minor optimizations, we now recommend compiler option "-Os" for best
+ results.
+ - Added a version number to usbdrv.h
+
+2006-02-03:
+ - New configuration variable USB_BUFFER_SECTION for the memory section where
+ the USB rx buffer will go. This defaults to ".bss" if not defined. Since
+ this buffer MUST NOT cross 256 byte pages (not even touch a page at the
+ end), the user may want to pass a linker option similar to
+ "-Wl,--section-start=.mybuffer=0x800060".
+ - Provide structure for usbRequest_t.
+ - New defines for USB constants.
+ - Prepared for HID implementations.
+ - Increased data size limit for interrupt transfers to 8 bytes.
+ - New macro usbInterruptIsReady() to query interrupt buffer state.
+
+2006-02-18:
+ - Ensure that the data token which is sent as an ack to an OUT transfer is
+ always zero sized. This fixes a bug where the host reports an error after
+ sending an out transfer to the device, although all data arrived at the
+ device.
+ - Updated docs in usbdrv.h to reflect changed API in usbFunctionWrite().
+
+* Release 2006-02-20
+
+ - Give a compiler warning when compiling with debugging turned on.
+ - Added Oleg Semyonov's changes for IAR-cc compatibility.
+ - Added new (optional) functions usbDeviceConnect() and usbDeviceDisconnect()
+ (also thanks to Oleg!).
+ - Rearranged tests in usbPoll() to save a couple of instructions in the most
+ likely case that no actions are pending.
+ - We need a delay between the SET ADDRESS request until the new address
+ becomes active. This delay was handled in usbPoll() until now. Since the
+ spec says that the delay must not exceed 2ms, previous versions required
+ aggressive polling during the enumeration phase. We have now moved the
+ handling of the delay into the interrupt routine.
+ - We must not reply with NAK to a SETUP transaction. We can only achieve this
+ by making sure that the rx buffer is empty when SETUP tokens are expected.
+ We therefore don't pass zero sized data packets from the status phase of
+ a transfer to usbPoll(). This change MAY cause troubles if you rely on
+ receiving a less than 8 bytes long packet in usbFunctionWrite() to
+ identify the end of a transfer. usbFunctionWrite() will NEVER be called
+ with a zero length.
+
+* Release 2006-03-14
+
+ - Improved IAR C support: tiny memory model, more devices
+ - Added template usbconfig.h file under the name usbconfig-prototype.h
+
+* Release 2006-03-26
+
+ - Added provision for one more interrupt-in endpoint (endpoint 3).
+ - Added provision for one interrupt-out endpoint (endpoint 1).
+ - Added flowcontrol macros for USB.
+ - Added provision for custom configuration descriptor.
+ - Allow ANY two port bits for D+ and D-.
+ - Merged (optional) receive endpoint number into global usbRxToken variable.
+ - Use USB_CFG_IOPORTNAME instead of USB_CFG_IOPORT. We now construct the
+ variable name from the single port letter instead of computing the address
+ of related ports from the output-port address.
+
+* Release 2006-06-26
+
+ - Updated documentation in usbdrv.h and usbconfig-prototype.h to reflect the
+ new features.
+ - Removed "#warning" directives because IAR does not understand them. Use
+ unused static variables instead to generate a warning.
+ - Do not include <avr/io.h> when compiling with IAR.
+ - Introduced USB_CFG_DESCR_PROPS_* in usbconfig.h to configure how each
+ USB descriptor should be handled. It is now possible to provide descriptor
+ data in Flash, RAM or dynamically at runtime.
+ - STALL is now a status in usbTxLen* instead of a message. We can now conform
+ to the spec and leave the stall status pending until it is cleared.
+ - Made usbTxPacketCnt1 and usbTxPacketCnt3 public. This allows the
+ application code to reset data toggling on interrupt pipes.
+
+* Release 2006-07-18
+
+ - Added an #if !defined __ASSEMBLER__ to the warning in usbdrv.h. This fixes
+ an assembler error.
+ - usbDeviceDisconnect() takes pull-up resistor to high impedance now.
+
+* Release 2007-02-01
+
+ - Merged in some code size improvements from usbtiny (thanks to Dick
+ Streefland for these optimizations!)
+ - Special alignment requirement for usbRxBuf not required any more. Thanks
+ again to Dick Streefland for this hint!
+ - Reverted to "#warning" instead of unused static variables -- new versions
+ of IAR CC should handle this directive.
+ - Changed Open Source license to GNU GPL v2 in order to make linking against
+ other free libraries easier. We no longer require publication of the
+ circuit diagrams, but we STRONGLY encourage it. If you improve the driver
+ itself, PLEASE grant us a royalty free license to your changes for our
+ commercial license.
+
+* Release 2007-03-29
+
+ - New configuration option "USB_PUBLIC" in usbconfig.h.
+ - Set USB version number to 1.10 instead of 1.01.
+ - Code used USB_CFG_DESCR_PROPS_STRING_DEVICE and
+ USB_CFG_DESCR_PROPS_STRING_PRODUCT inconsistently. Changed all occurrences
+ to USB_CFG_DESCR_PROPS_STRING_PRODUCT.
+ - New assembler module for 16.5 MHz RC oscillator clock with PLL in receiver
+ code.
+ - New assembler module for 16 MHz crystal.
+ - usbdrvasm.S contains common code only, clock-specific parts have been moved
+ to usbdrvasm12.S, usbdrvasm16.S and usbdrvasm165.S respectively.
+
+* Release 2007-06-25
+
+ - 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/usbdrv/CommercialLicense.txt b/usbdrv/CommercialLicense.txt
new file mode 100644
index 0000000..6d8bf39
--- /dev/null
+++ b/usbdrv/CommercialLicense.txt
@@ -0,0 +1,156 @@
+AVR-USB Driver Software License Agreement
+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
+THE AMOUNT ACCORDING TO SECTION 4 ("PAYMENT") TO OBJECTIVE DEVELOPMENT.
+
+
+1 DEFINITIONS
+
+1.1 "OBJECTIVE DEVELOPMENT" shall mean OBJECTIVE DEVELOPMENT Software GmbH,
+Grosse Schiffgasse 1A/7, 1020 Wien, AUSTRIA.
+
+1.2 "You" shall mean the Licensee.
+
+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
+
+2.1 Source Code. OBJECTIVE DEVELOPMENT shall furnish you with the source
+code of AVR-USB.
+
+2.2 Distribution and Use. OBJECTIVE DEVELOPMENT grants you the
+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
+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
+conjunction with USB Vendor ID 5824. OBJECTIVE DEVELOPMENT has acquired an
+exclusive license for this pair of USB identifiers from Wouter van Ooijen
+(www.voti.nl), who has licensed the VID from the USB Implementers Forum,
+Inc. (www.usb.org).
+
+
+3 LICENSE RESTRICTIONS
+
+3.1 Number of Units. Only one of the following three definitions is
+applicable. Which one is determined by the amount you pay to OBJECTIVE
+DEVELOPMENT, see section 4 ("Payment") below.
+
+Hobby License: You may use AVR-USB according to section 2 above in no more
+than 5 hardware units. These units must not be sold for profit.
+
+Entry Level License: You may use AVR-USB according to section 2 above in no
+more than 150 hardware units.
+
+Professional License: You may use AVR-USB according to section 2 above in
+any number of hardware units, except for large scale production ("unlimited
+fair use"). Quantities below 10,000 units are not considered large scale
+production. If your reach quantities which are obviously large scale
+production, you must pay a license fee of 0.10 EUR per unit for all units
+above 10,000.
+
+3.2 Rental. You may not rent, lease, or lend AVR-USB or otherwise encumber
+any copy of AVR-USB, or any of the rights granted herein.
+
+3.3 Transfer. You may not transfer your rights under this Agreement to
+another party without OBJECTIVE DEVELOPMENT's prior written consent. If
+such consent is obtained, you may permanently transfer this License to
+another party. The recipient of such transfer must agree to all terms and
+conditions of this Agreement.
+
+3.4 Reservation of Rights. OBJECTIVE DEVELOPMENT retains all rights not
+expressly granted.
+
+3.5 Non-Exclusive Rights. Your license rights under this Agreement are
+non-exclusive.
+
+3.6 Third Party Rights. This Agreement cannot grant you rights controlled
+by third parties. In particular, you are not allowed to use the USB logo or
+other trademarks owned by the USB Implementers Forum, Inc. without their
+consent. Since such consent depends on USB certification, it should be
+noted that AVR-USB will not pass certification because it does not
+implement checksum verification and the microcontroller ports do not meet
+the electrical specifications.
+
+
+4 PAYMENT
+
+The payment amount depends on the variation of this agreement (according to
+section 3.1) into which you want to enter. Concrete prices are listed on
+OBJECTIVE DEVELOPMENT's web site, usually at
+http://www.obdev.at/avrusb/license.html. You agree to pay the amount listed
+there to OBJECTIVE DEVELOPMENT or OBJECTIVE DEVELOPMENT's payment processor
+or reseller.
+
+
+5 COPYRIGHT AND OWNERSHIP
+
+AVR-USB is protected by copyright laws and international copyright
+treaties, as well as other intellectual property laws and treaties. AVR-USB
+is licensed, not sold.
+
+
+6 TERM AND TERMINATION
+
+6.1 Term. This Agreement shall continue indefinitely. However, OBJECTIVE
+DEVELOPMENT may terminate this Agreement and revoke the granted license and
+USB-IDs if you fail to comply with any of its terms and conditions.
+
+6.2 Survival of Terms. All provisions regarding secrecy, confidentiality
+and limitation of liability shall survive termination of this agreement.
+
+
+7 DISCLAIMER OF WARRANTY AND LIABILITY
+
+LIMITED WARRANTY. AVR-USB IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, OBJECTIVE
+DEVELOPMENT AND ITS SUPPLIERS HEREBY DISCLAIM ALL WARRANTIES, EITHER
+EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+NON-INFRINGEMENT, WITH REGARD TO AVR-USB, AND THE PROVISION OF OR FAILURE
+TO PROVIDE SUPPORT SERVICES. THIS LIMITED WARRANTY GIVES YOU SPECIFIC LEGAL
+RIGHTS. YOU MAY HAVE OTHERS, WHICH VARY FROM STATE/JURISDICTION TO
+STATE/JURISDICTION.
+
+LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
+IN NO EVENT SHALL OBJECTIVE DEVELOPMENT OR ITS SUPPLIERS BE LIABLE FOR ANY
+SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER
+(INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
+BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY
+LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE AVR-USB OR THE
+PROVISION OF OR FAILURE TO PROVIDE SUPPORT SERVICES, EVEN IF OBJECTIVE
+DEVELOPMENT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. IN ANY
+CASE, OBJECTIVE DEVELOPMENT'S ENTIRE LIABILITY UNDER ANY PROVISION OF THIS
+AGREEMENT SHALL BE LIMITED TO THE AMOUNT ACTUALLY PAID BY YOU FOR AVR-USB.
+
+
+8 MISCELLANEOUS TERMS
+
+8.1 Marketing. OBJECTIVE DEVELOPMENT has the right to mention for marketing
+purposes that you entered into this agreement.
+
+8.2 Entire Agreement. This document represents the entire agreement between
+OBJECTIVE DEVELOPMENT and you. It may only be modified in writing signed by
+an authorized representative of both, OBJECTIVE DEVELOPMENT and you.
+
+8.3 Severability. In case a provision of these terms and conditions should
+be or become partly or entirely invalid, ineffective, or not executable,
+the validity of all other provisions shall not be affected.
+
+8.4 Applicable Law. This agreement is governed by the laws of the Republic
+of Austria.
+
+8.5 Responsible Courts. The responsible courts in Vienna/Austria will have
+exclusive jurisdiction regarding all disputes in connection with this
+agreement.
+
diff --git a/usbdrv/License.txt b/usbdrv/License.txt
new file mode 100644
index 0000000..e9b2752
--- /dev/null
+++ b/usbdrv/License.txt
@@ -0,0 +1,361 @@
+OBJECTIVE DEVELOPMENT GmbH's AVR-USB driver software is distributed under the
+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.
+
+(2) Adhere to minimum publication standards. Please include AT LEAST:
+ - a circuit diagram in PDF, PNG or GIF format
+ - full source code for the host software
+ - a Readme.txt file in ASCII format which describes the purpose of the
+ project and what can be found in which directories and which files
+ - a reference to http://www.obdev.at/avrusb/
+
+(3) If you improve the driver firmware itself, please give us a free license
+to your modifications for our commercial license offerings.
+
+
+
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+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
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ 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
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+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
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+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
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+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
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/usbdrv/Readme.txt b/usbdrv/Readme.txt
new file mode 100644
index 0000000..7828f64
--- /dev/null
+++ b/usbdrv/Readme.txt
@@ -0,0 +1,147 @@
+This is the Readme file to Objective Development's firmware-only USB driver
+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 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
+=======================
+The technical documentation (API) for the firmware driver is contained in the
+file "usbdrv.h". Please read all of it carefully! Configuration options are
+documented in "usbconfig-prototype.h".
+
+The driver consists of the following files:
+ Readme.txt ............. The file you are currently reading.
+ Changelog.txt .......... Release notes for all versions of the driver.
+ usbdrv.h ............... Driver interface definitions and technical docs.
+* usbdrv.c ............... High level language part of the driver. Link this
+ module to your code!
+* usbdrvasm.S ............ Assembler part of the driver. This module is mostly
+ a stub and includes one of the usbdrvasm*.S files
+ depending on processor clock. Link this module to
+ your code!
+ 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.
+ 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.
+ License.txt ............ Open Source license for this driver.
+ CommercialLicense.txt .. Optional commercial license for this driver.
+ USBID-License.txt ...... Terms and conditions for using particular USB ID
+ values for particular purposes.
+
+(*) ... These files should be linked to your project.
+
+
+CPU CORE CLOCK FREQUENCY
+========================
+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
+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.
+
+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.
+
+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
+===============
+Every USB device needs a vendor- and a product-identifier (VID and PID). VIDs
+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 some VID/PID pairs for free. See the file
+USBID-License.txt for details.
+
+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, 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) 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 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
+ - full source code for the host software
+ - a Readme.txt file in ASCII format which describes the purpose of the
+ project and what can be found in which directories and which files
+ - a reference to http://www.obdev.at/avrusb/
+
+(3) If you improve the driver firmware itself, please give us a free license
+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 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/usbdrv/USBID-License.txt b/usbdrv/USBID-License.txt
new file mode 100644
index 0000000..984c9ee
--- /dev/null
+++ b/usbdrv/USBID-License.txt
@@ -0,0 +1,146 @@
+Royalty-Free Non-Exclusive License USB Product-ID
+=================================================
+
+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
+products based on Objective Development's firmware-only USB driver for
+Atmel AVR microcontrollers:
+
+ * VID = 5824 (=0x16c0) / PID = 1500 (=0x5dc) for devices implementing no
+ USB device class (vendor-class devices with USB class = 0xff). Devices
+ using this pair will be referred to as "VENDOR CLASS" devices.
+
+ * VID = 5824 (=0x16c0) / PID = 1503 (=0x5df) for HID class devices
+ (excluding mice and keyboards). Devices using this pair will be referred
+ to as "HID CLASS" devices.
+
+ * 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
+outlined below.
+
+OBJECTIVE DEVELOPMENT Software GmbH has licensed these VID/PID pairs from
+Wouter van Ooijen (see www.voti.nl), who has licensed the VID from the USB
+Implementers Forum, Inc. (see www.usb.org). The VID is registered for the
+company name "Van Ooijen Technische Informatica".
+
+
+RULES AND RESTRICTIONS
+======================
+
+(1) The USB device MUST provide a textual representation of the
+manufacturer and product identification. The manufacturer identification
+MUST be available at least in USB language 0x0409 (English/US).
+
+(2) The textual manufacturer identification MUST contain either an Internet
+domain name (e.g. "mycompany.com") registered and owned by you, or an
+e-mail address under your control (e.g. "myname@gmx.net"). You can embed
+the domain name or e-mail address in any string you like, e.g. "Objective
+Development http://www.obdev.at/avrusb/".
+
+(3) You are responsible for retaining ownership of the domain or e-mail
+address for as long as any of your products are in use.
+
+(4) You may choose any string for the textual product identification, as
+long as this string is unique within the scope of your textual manufacturer
+identification.
+
+(5) Matching of device-specific drivers MUST be based on the textual
+manufacturer and product identification in addition to the usual VID/PID
+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 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
+pair used:
+
+ * Mac OS X, Linux, FreeBSD and other Unixes: No VID/PID matching is
+ required and hence no VID/PID-only matching is allowed at all.
+
+ * Windows: The operating system performs VID/PID matching for the kernel
+ level driver. You are REQUIRED to use libusb-win32 (see
+ http://libusb-win32.sourceforge.net/) as the kernel level driver for
+ VENDOR CLASS devices. HID CLASS devices all use the generic HID class
+ driver shipped with Windows, except mice and keyboards. You therefore
+ MUST NOT use any of the shared VID/PID pairs for mice or keyboards.
+ CDC-ACM CLASS devices require a ".inf" file which matches on the VID/PID
+ pair. This ".inf" file MUST load the "usbser" driver to configure the
+ device as modem (COM-port).
+
+(7) OBJECTIVE DEVELOPMENT Software GmbH disclaims all liability for any
+problems which are caused by the shared use of these VID/PID pairs. You
+have been warned that the sharing of VID/PID pairs may cause problems. If
+you want to avoid them, get your own VID/PID pair for exclusive use.
+
+
+HOW TO IMPLEMENT THESE RULES
+============================
+
+The following rules are for VENDOR CLASS and HID CLASS devices. CDC-ACM
+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
+the manufacturer name in USB language 0x0409 (English/US). It MUST compare
+the ENTIRE string with your textual manufacturer identification chosen in
+(2) above. A substring search for your domain or e-mail address is NOT
+acceptable. The driver MUST NOT touch the device (other than querying the
+descriptors) unless the strings match.
+
+For all USB devices with matching VID/PID and textual manufacturer
+identification, the host driver must query the textual product
+identification and string-compare it with the name of the product it can
+control. It may only initialize the device if the product matches exactly.
+
+Objective Development provides examples for these matching rules with the
+"PowerSwitch" project (using libusb) and with the "Automator" project
+(using Windows calls on Windows and libusb on Unix).
+
+
+Technical Notes:
+================
+
+Sharing the same VID/PID pair among devices is possible as long as ALL
+drivers which match the VID/PID also perform matching on the textual
+identification strings. This is easy on all operating systems except
+Windows, since Windows establishes a static connection between the VID/PID
+pair and a kernel level driver. All devices with the same VID/PID pair must
+therefore use THE SAME kernel level driver.
+
+We therefore demand that you use libusb-win32 for VENDOR CLASS devices.
+This is a generic kernel level driver which allows all types of USB access
+for user space applications. This is only a partial solution of the
+problem, though, because different device drivers may come with different
+versions of libusb-win32 and they may not work with the libusb version of
+the respective other driver. You are therefore encouraged to test your
+driver against a broad range of libusb-win32 versions. Do not use new
+features in new versions, or check for their existence before you use them.
+When a new libusb-win32 becomes available, make sure that your driver is
+compatible with it.
+
+For HID CLASS devices it is necessary that all those devices bind to the
+same kernel driver: Microsoft's generic USB HID driver. This is true for
+all HID devices except those with a specialized driver. Currently, the only
+HIDs with specialized drivers are mice and keyboards. You therefore MUST
+NOT use a shared VID/PID with mouse and keyboard devices.
+
+Sharing the same VID/PID among different products is unusual and probably
+violates the USB specification. If you do it, you do it at your own risk.
+
+To avoid possible incompatibilities, we highly recommend that you get your
+own VID/PID pair if you intend to sell your product. Objective
+Development's commercial licenses for AVR-USB include a PID for
+unrestricted exclusive use.
diff --git a/usbdrv/asmcommon.inc b/usbdrv/asmcommon.inc
new file mode 100644
index 0000000..1af53b8
--- /dev/null
+++ b/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/usbdrv/oddebug.c b/usbdrv/oddebug.c
new file mode 100644
index 0000000..945457c
--- /dev/null
+++ b/usbdrv/oddebug.c
@@ -0,0 +1,50 @@
+/* Name: oddebug.c
+ * Project: AVR library
+ * Author: Christian Starkjohann
+ * Creation Date: 2005-01-16
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * 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"
+
+#if DEBUG_LEVEL > 0
+
+#warning "Never compile production devices with debugging enabled"
+
+static void uartPutc(char c)
+{
+ while(!(ODDBG_USR & (1 << ODDBG_UDRE))); /* wait for data register empty */
+ ODDBG_UDR = c;
+}
+
+static uchar hexAscii(uchar h)
+{
+ h &= 0xf;
+ if(h >= 10)
+ h += 'a' - (uchar)10 - '0';
+ h += '0';
+ return h;
+}
+
+static void printHex(uchar c)
+{
+ uartPutc(hexAscii(c >> 4));
+ uartPutc(hexAscii(c));
+}
+
+void odDebug(uchar prefix, uchar *data, uchar len)
+{
+ printHex(prefix);
+ uartPutc(':');
+ while(len--){
+ uartPutc(' ');
+ printHex(*data++);
+ }
+ uartPutc('\r');
+ uartPutc('\n');
+}
+
+#endif
diff --git a/usbdrv/oddebug.h b/usbdrv/oddebug.h
new file mode 100644
index 0000000..d61309d
--- /dev/null
+++ b/usbdrv/oddebug.h
@@ -0,0 +1,123 @@
+/* Name: oddebug.h
+ * Project: AVR library
+ * Author: Christian Starkjohann
+ * Creation Date: 2005-01-16
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * 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__
+#define __oddebug_h_included__
+
+/*
+General Description:
+This module implements a function for debug logs on the serial line of the
+AVR microcontroller. Debugging can be configured with the define
+'DEBUG_LEVEL'. If this macro is not defined or defined to 0, all debugging
+calls are no-ops. If it is 1, DBG1 logs will appear, but not DBG2. If it is
+2, DBG1 and DBG2 logs will be printed.
+
+A debug log consists of a label ('prefix') to indicate which debug log created
+the output and a memory block to dump in hex ('data' and 'len').
+*/
+
+
+#ifndef F_CPU
+# define F_CPU 12000000 /* 12 MHz */
+#endif
+
+/* make sure we have the UART defines: */
+#include "usbportability.h"
+
+#ifndef uchar
+# define uchar unsigned char
+#endif
+
+#if DEBUG_LEVEL > 0 && !(defined TXEN || defined TXEN0) /* no UART in device */
+# warning "Debugging disabled because device has no UART"
+# undef DEBUG_LEVEL
+#endif
+
+#ifndef DEBUG_LEVEL
+# define DEBUG_LEVEL 0
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#if DEBUG_LEVEL > 0
+# define DBG1(prefix, data, len) odDebug(prefix, data, len)
+#else
+# define DBG1(prefix, data, len)
+#endif
+
+#if DEBUG_LEVEL > 1
+# define DBG2(prefix, data, len) odDebug(prefix, data, len)
+#else
+# define DBG2(prefix, data, len)
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#if DEBUG_LEVEL > 0
+extern void odDebug(uchar prefix, uchar *data, uchar len);
+
+/* Try to find our control registers; ATMEL likes to rename these */
+
+#if defined UBRR
+# define ODDBG_UBRR UBRR
+#elif defined UBRRL
+# define ODDBG_UBRR UBRRL
+#elif defined UBRR0
+# define ODDBG_UBRR UBRR0
+#elif defined UBRR0L
+# define ODDBG_UBRR UBRR0L
+#endif
+
+#if defined UCR
+# define ODDBG_UCR UCR
+#elif defined UCSRB
+# define ODDBG_UCR UCSRB
+#elif defined UCSR0B
+# define ODDBG_UCR UCSR0B
+#endif
+
+#if defined TXEN
+# define ODDBG_TXEN TXEN
+#else
+# define ODDBG_TXEN TXEN0
+#endif
+
+#if defined USR
+# define ODDBG_USR USR
+#elif defined UCSRA
+# define ODDBG_USR UCSRA
+#elif defined UCSR0A
+# define ODDBG_USR UCSR0A
+#endif
+
+#if defined UDRE
+# define ODDBG_UDRE UDRE
+#else
+# define ODDBG_UDRE UDRE0
+#endif
+
+#if defined UDR
+# define ODDBG_UDR UDR
+#elif defined UDR0
+# define ODDBG_UDR UDR0
+#endif
+
+static inline void odDebugInit(void)
+{
+ ODDBG_UCR |= (1<<ODDBG_TXEN);
+ ODDBG_UBRR = F_CPU / (19200 * 16L) - 1;
+}
+#else
+# define odDebugInit()
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#endif /* __oddebug_h_included__ */
diff --git a/usbdrv/this-is-avrusb-20081126 b/usbdrv/this-is-avrusb-20081126
new file mode 100644
index 0000000..e69de29
diff --git a/usbdrv/usbconfig-prototype.h b/usbdrv/usbconfig-prototype.h
new file mode 100644
index 0000000..6c9e37a
--- /dev/null
+++ b/usbdrv/usbconfig-prototype.h
@@ -0,0 +1,351 @@
+/* Name: usbconfig.h
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2005-04-01
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * 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__
+#define __usbconfig_h_included__
+
+/*
+General Description:
+This file is an example configuration (with inline documentation) for the USB
+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 ---------------------------- */
+
+#define USB_CFG_IOPORTNAME D
+/* 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 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! [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, 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
+ */
+
+/* ----------------------- Optional Hardware Config ------------------------ */
+
+/* #define USB_CFG_PULLUP_IOPORTNAME D */
+/* If you connect the 1.5k pullup resistor from D- to a port pin instead of
+ * V+, you can connect and disconnect the device from firmware by calling
+ * the macros usbDeviceConnect() and usbDeviceDisconnect() (see usbdrv.h).
+ * This constant defines the port on which the pullup resistor is connected.
+ */
+/* #define USB_CFG_PULLUP_BIT 4 */
+/* This constant defines the bit number in USB_CFG_PULLUP_IOPORT (defined
+ * above) where the 1.5k pullup resistor is connected. See description
+ * above for details.
+ */
+
+/* --------------------------- Functional Range ---------------------------- */
+
+#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 (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 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
+ * for endpoint 1 (interrupt endpoint). Although you may not need this feature,
+ * it is required by the standard. We have made it a config option because it
+ * bloats the code considerably.
+ */
+#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.
+ */
+#define USB_CFG_IS_SELF_POWERED 0
+/* Define this to 1 if the device has its own power supply. Set it to 0 if the
+ * device is powered from the USB bus.
+ */
+#define USB_CFG_MAX_BUS_POWER 100
+/* Set this variable to the maximum USB bus power consumption of your device.
+ * The value is in milliamperes. [It will be divided by two since USB
+ * communicates power requirements in units of 2 mA.]
+ */
+#define USB_CFG_IMPLEMENT_FN_WRITE 0
+/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
+ * transfers. Set it to 0 if you don't need it and want to save a couple of
+ * bytes.
+ */
+#define USB_CFG_IMPLEMENT_FN_READ 0
+/* Set this to 1 if you need to send control replies which are generated
+ * "on the fly" when usbFunctionRead() is called. If you only want to send
+ * data from a static buffer, set it to 0 and return the data from
+ * 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) endpoints.
+ * You must implement the function usbFunctionWriteOut() which receives all
+ * 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 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 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: 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 '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.
+ * If you don't want a vendor name string, undefine these macros.
+ * ALWAYS define a vendor name containing your Internet domain name if you use
+ * obdev's free shared VID/PID pair. See the file USBID-License.txt for
+ * details.
+ */
+#define USB_CFG_DEVICE_NAME 'T', 'e', 'm', 'p', 'l', 'a', 't', 'e'
+#define USB_CFG_DEVICE_NAME_LEN 8
+/* Same as above for the device name. If you don't want a device name, undefine
+ * the macros. See the file USBID-License.txt before you assign a name if you
+ * use a shared VID/PID.
+ */
+/*#define USB_CFG_SERIAL_NUMBER 'N', 'o', 'n', 'e' */
+/*#define USB_CFG_SERIAL_NUMBER_LEN 0 */
+/* Same as above for the serial number. If you don't want a serial number,
+ * undefine the macros.
+ * It may be useful to provide the serial number through other means than at
+ * compile time. See the section about descriptor properties below for how
+ * to fine tune control over USB descriptors such as the string descriptor
+ * for the serial number.
+ */
+#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 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. 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 */
+/* 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.
+ * 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!
+ */
+
+/* #define USB_PUBLIC static */
+/* Use the define above if you #include usbdrv.c instead of linking against it.
+ * This technique saves a couple of bytes in flash memory.
+ */
+
+/* ------------------- Fine Control over USB Descriptors ------------------- */
+/* If you don't want to use the driver's default USB descriptors, you can
+ * provide our own. These can be provided as (1) fixed length static data in
+ * flash memory, (2) fixed length static data in RAM or (3) dynamically at
+ * runtime in the function usbFunctionDescriptor(). See usbdrv.h for more
+ * information about this function.
+ * Descriptor handling is configured through the descriptor's properties. If
+ * 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(). 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),
+ * the driver must know the descriptor's length. The descriptor itself is
+ * found at the address of a well known identifier (see below).
+ * List of static descriptor names (must be declared PROGMEM if in flash):
+ * char usbDescriptorDevice[];
+ * char usbDescriptorConfiguration[];
+ * char usbDescriptorHidReport[];
+ * char usbDescriptorString0[];
+ * int usbDescriptorStringVendor[];
+ * int usbDescriptorStringDevice[];
+ * int usbDescriptorStringSerialNumber[];
+ * Other descriptors can't be provided statically, they must be provided
+ * dynamically at runtime.
+ *
+ * Descriptor properties are or-ed or added together, e.g.:
+ * #define USB_CFG_DESCR_PROPS_DEVICE (USB_PROP_IS_RAM | USB_PROP_LENGTH(18))
+ *
+ * The following descriptors are defined:
+ * USB_CFG_DESCR_PROPS_DEVICE
+ * USB_CFG_DESCR_PROPS_CONFIGURATION
+ * USB_CFG_DESCR_PROPS_STRINGS
+ * USB_CFG_DESCR_PROPS_STRING_0
+ * USB_CFG_DESCR_PROPS_STRING_VENDOR
+ * USB_CFG_DESCR_PROPS_STRING_PRODUCT
+ * USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+ * USB_CFG_DESCR_PROPS_HID
+ * 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
+#define USB_CFG_DESCR_PROPS_CONFIGURATION 0
+#define USB_CFG_DESCR_PROPS_STRINGS 0
+#define USB_CFG_DESCR_PROPS_STRING_0 0
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0
+#define USB_CFG_DESCR_PROPS_HID 0
+#define USB_CFG_DESCR_PROPS_HID_REPORT 0
+#define USB_CFG_DESCR_PROPS_UNKNOWN 0
+
+/* ----------------------- Optional MCU Description ------------------------ */
+
+/* The following configurations have working defaults in usbdrv.h. You
+ * usually don't need to set them explicitly. Only if you want to run
+ * the driver on a device which is not yet supported or with a compiler
+ * which is not fully supported (such as IAR C) or if you use a differnt
+ * interrupt than INT0, you may have to define some of these.
+ */
+/* #define USB_INTR_CFG MCUCR */
+/* #define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) */
+/* #define USB_INTR_CFG_CLR 0 */
+/* #define USB_INTR_ENABLE GIMSK */
+/* #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/usbdrv/usbdrv.c b/usbdrv/usbdrv.c
new file mode 100644
index 0000000..02ffed6
--- /dev/null
+++ b/usbdrv/usbdrv.c
@@ -0,0 +1,625 @@
+/* Name: usbdrv.c
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2004-12-29
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * 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 "usbportability.h"
+#include "usbdrv.h"
+#include "oddebug.h"
+
+/*
+General Description:
+This module implements the C-part of the USB driver. See usbdrv.h for a
+documentation of the entire driver.
+*/
+
+/* ------------------------------------------------------------------------- */
+
+/* raw USB registers / interface to assembler code: */
+uchar usbRxBuf[2*USB_BUFSIZE]; /* raw RX buffer: PID, 8 bytes data, 2 bytes CRC */
+uchar usbInputBufOffset; /* offset in usbRxBuf used for low level receiving */
+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 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_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 usbMsgLen_t usbMsgLen = USB_NO_MSG; /* remaining number of bytes */
+static uchar usbMsgFlags; /* flag values see below */
+
+#define USB_FLG_MSGPTR_IS_ROM (1<<6)
+#define USB_FLG_USE_USER_RW (1<<7)
+
+/*
+optimizing hints:
+- do not post/pre inc/dec integer values in operations
+- 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
+
+#if USB_CFG_DESCR_PROPS_STRING_0 == 0
+#undef USB_CFG_DESCR_PROPS_STRING_0
+#define USB_CFG_DESCR_PROPS_STRING_0 sizeof(usbDescriptorString0)
+PROGMEM char usbDescriptorString0[] = { /* language descriptor */
+ 4, /* sizeof(usbDescriptorString0): length of descriptor in bytes */
+ 3, /* descriptor type */
+ 0x09, 0x04, /* language index (0x0409 = US-English) */
+};
+#endif
+
+#if USB_CFG_DESCR_PROPS_STRING_VENDOR == 0 && USB_CFG_VENDOR_NAME_LEN
+#undef USB_CFG_DESCR_PROPS_STRING_VENDOR
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR sizeof(usbDescriptorStringVendor)
+PROGMEM int usbDescriptorStringVendor[] = {
+ USB_STRING_DESCRIPTOR_HEADER(USB_CFG_VENDOR_NAME_LEN),
+ USB_CFG_VENDOR_NAME
+};
+#endif
+
+#if USB_CFG_DESCR_PROPS_STRING_PRODUCT == 0 && USB_CFG_DEVICE_NAME_LEN
+#undef USB_CFG_DESCR_PROPS_STRING_PRODUCT
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT sizeof(usbDescriptorStringDevice)
+PROGMEM int usbDescriptorStringDevice[] = {
+ USB_STRING_DESCRIPTOR_HEADER(USB_CFG_DEVICE_NAME_LEN),
+ USB_CFG_DEVICE_NAME
+};
+#endif
+
+#if USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER == 0 && USB_CFG_SERIAL_NUMBER_LEN
+#undef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER sizeof(usbDescriptorStringSerialNumber)
+PROGMEM int usbDescriptorStringSerialNumber[] = {
+ USB_STRING_DESCRIPTOR_HEADER(USB_CFG_SERIAL_NUMBER_LEN),
+ USB_CFG_SERIAL_NUMBER
+};
+#endif
+
+#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)
+PROGMEM char usbDescriptorDevice[] = { /* USB device descriptor */
+ 18, /* sizeof(usbDescriptorDevice): length of descriptor in bytes */
+ USBDESCR_DEVICE, /* descriptor type */
+ 0x10, 0x01, /* USB version supported */
+ USB_CFG_DEVICE_CLASS,
+ USB_CFG_DEVICE_SUBCLASS,
+ 0, /* protocol */
+ 8, /* max packet size */
+ /* 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 */
+ USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER != 0 ? 3 : 0, /* serial number string index */
+ 1, /* number of configurations */
+};
+#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 */
+#endif
+
+#if USB_CFG_DESCR_PROPS_CONFIGURATION == 0
+#undef USB_CFG_DESCR_PROPS_CONFIGURATION
+#define USB_CFG_DESCR_PROPS_CONFIGURATION sizeof(usbDescriptorConfiguration)
+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 + 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 */
+#else
+ (char)USBATTR_BUSPOWER, /* attributes */
+#endif
+ USB_CFG_MAX_BUS_POWER/2, /* max USB current in 2mA units */
+/* interface descriptor follows inline: */
+ 9, /* sizeof(usbDescrInterface): length of descriptor in bytes */
+ USBDESCR_INTERFACE, /* descriptor type */
+ 0, /* index of this interface */
+ 0, /* alternate setting for this interface */
+ 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,
+ 0, /* string index for interface */
+#if (USB_CFG_DESCR_PROPS_HID & 0xff) /* HID descriptor */
+ 9, /* sizeof(usbDescrHID): length of descriptor in bytes */
+ USBDESCR_HID, /* descriptor type: HID */
+ 0x01, 0x01, /* BCD representation of HID version */
+ 0x00, /* target country code */
+ 0x01, /* number of HID Report (or other HID class) Descriptor infos to follow */
+ 0x22, /* descriptor type: report */
+ USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH, 0, /* total length of report descriptor */
+#endif
+#if USB_CFG_HAVE_INTRIN_ENDPOINT /* endpoint descriptor for endpoint 1 */
+ 7, /* sizeof(usbDescrEndpoint) */
+ USBDESCR_ENDPOINT, /* descriptor type = endpoint */
+ (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 */
+#endif
+};
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+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
+static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus)
+{
+uchar *p;
+char i;
+
+#if USB_CFG_IMPLEMENT_HALT
+ if(usbTxLen1 == USBPID_STALL)
+ return;
+#endif
+ if(txStatus->len & 0x10){ /* packet buffer was empty */
+ txStatus->buffer[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* toggle token */
+ }else{
+ txStatus->len = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */
+ }
+ p = txStatus->buffer + 1;
+ i = len;
+ do{ /* if len == 0, we still copy 1 byte, but that's no problem */
+ *p++ = *data++;
+ }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)
+{
+ usbGenericSetInterrupt(data, len, &usbTxStatus3);
+}
+#endif
+#endif /* USB_CFG_SUPPRESS_INTR_CODE */
+
+/* ------------------ utilities for code following below ------------------- */
+
+/* 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 = 0; \
+ if((cfgProp) & USB_PROP_IS_DYNAMIC){ \
+ len = usbFunctionDescriptor(rq); \
+ }else{ \
+ len = USB_PROP_LENGTH(cfgProp); \
+ usbMsgPtr = (uchar *)(staticName); \
+ } \
+ }
+
+/* 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;
+}
+
+/* ------------------------------------------------------------------------- */
+
+/* usbProcessRx() is called for every message received by the interrupt
+ * routine. It distinguishes between SETUP and DATA packets and processes
+ * them accordingly.
+ */
+static inline void usbProcessRx(uchar *data, uchar len)
+{
+usbRequest_t *rq = (void *)data;
+
+/* usbRxToken can be:
+ * 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 & 0xf), data, len); /* SETUP=1d, SETUP-DATA=11, OUTx=1x */
+ USB_RX_USER_HOOK(data, len)
+#if USB_CFG_IMPLEMENT_FN_WRITEOUT
+ if(usbRxToken < 0x10){ /* OUT to endpoint != 0: endpoint number in usbRxToken */
+ usbFunctionWriteOut(data, len);
+ return;
+ }
+#endif
+ if(usbRxToken == (uchar)USBPID_SETUP){
+ 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{
+ replyLen = rq->wLength.word;
+ }
+ }
+ 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(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;
+ }
+ 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_USER_RW){
+ uchar rval = usbFunctionWrite(data, len);
+ if(rval == 0xff){ /* an error occurred */
+ usbTxLen = USBPID_STALL;
+ }else if(rval != 0){ /* This was the final package */
+ usbMsgLen = 0; /* answer with a zero-sized data packet */
+ }
+ }
+#endif
+ }
+}
+
+/* ------------------------------------------------------------------------- */
+
+/* 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)
+{
+ 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;
+ usbTxBuf[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* DATA toggling */
+ len = usbDeviceRead(usbTxBuf + 1, wantLen);
+ if(len <= 8){ /* valid data packet */
+ usbCrc16Append(&usbTxBuf[1], len);
+ len += 4; /* length including sync byte */
+ if(len < 12) /* a partial package identifies end of message */
+ usbMsgLen = USB_NO_MSG;
+ }else{
+ len = USBPID_STALL; /* stall the endpoint */
+ usbMsgLen = USB_NO_MSG;
+ }
+ usbTxLen = len;
+ DBG2(0x20, usbTxBuf, len-1);
+}
+
+/* ------------------------------------------------------------------------- */
+
+static inline void usbHandleResetHook(uchar notResetState)
+{
+#ifdef USB_RESET_HOOK
+static uchar wasReset;
+uchar isReset = !notResetState;
+
+ if(wasReset != isReset){
+ USB_RESET_HOOK(isReset);
+ wasReset = isReset;
+ }
+#endif
+}
+
+/* ------------------------------------------------------------------------- */
+
+USB_PUBLIC void usbPoll(void)
+{
+schar len;
+uchar i;
+
+ 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);
+#if USB_CFG_HAVE_FLOWCONTROL
+ if(usbRxLen > 0) /* only mark as available if not inactivated */
+ usbRxLen = 0;
+#else
+ usbRxLen = 0; /* mark rx buffer as available */
+#endif
+ }
+ if(usbTxLen & 0x10){ /* transmit system idle */
+ if(usbMsgLen != USB_NO_MSG){ /* transmit data pending? */
+ usbBuildTxBlock();
+ }
+ }
+ 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);
+}
+
+/* ------------------------------------------------------------------------- */
+
+USB_PUBLIC void usbInit(void)
+{
+#if USB_INTR_CFG_SET != 0
+ USB_INTR_CFG |= USB_INTR_CFG_SET;
+#endif
+#if USB_INTR_CFG_CLR != 0
+ USB_INTR_CFG &= ~(USB_INTR_CFG_CLR);
+#endif
+ USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT);
+ 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/usbdrv/usbdrv.h b/usbdrv/usbdrv.h
new file mode 100644
index 0000000..0ae3871
--- /dev/null
+++ b/usbdrv/usbdrv.h
@@ -0,0 +1,731 @@
+/* Name: usbdrv.h
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2004-12-29
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * 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 "usbportability.h"
+
+/*
+Hardware Prerequisites:
+=======================
+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, 15 MHz, 16 MHz or 20 MHz
+or at 12.8 MHz resp. 16.5 MHz +/- 1%. See usbconfig-prototype.h for details.
+
+
+Limitations:
+============
+Robustness with respect to communication errors:
+The driver assumes error-free communication. It DOES check for errors in
+the PID, but does NOT check bit stuffing errors, SE0 in middle of a byte,
+token CRC (5 bit) and data CRC (16 bit). CRC checks can not be performed due
+to timing constraints: We must start sending a reply within 7 bit times.
+Bit stuffing and misplaced SE0 would have to be checked in real-time, but CPU
+performance does not permit that. The driver does not check Data0/Data1
+toggling, but application software can implement the check.
+
+Input characteristics:
+Since no differential receiver circuit is used, electrical interference
+robustness may suffer. The driver samples only one of the data lines with
+an ordinary I/O pin's input characteristics. However, since this is only a
+low speed USB implementation and the specification allows for 8 times the
+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 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
+to accept payload data of out transfers, you need to implement
+'usbFunctionWrite()'.
+
+USB Suspend Mode supply current:
+The USB standard limits power consumption to 500uA when the bus is in suspend
+mode. This is not a problem for self-powered devices since they don't need
+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 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)
+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 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
+routine. The routine will not return before an entire USB message is received
+and the reply is sent. This may be up to ca. 1200 cycles @ 12 MHz (= 100us) if
+the host conforms to the standard. The driver will consume CPU cycles for all
+USB messages, even if they address another (low-speed) device on the same bus.
+
+*/
+
+/* ------------------------------------------------------------------------- */
+/* --------------------------- Module Interface ---------------------------- */
+/* ------------------------------------------------------------------------- */
+
+#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
+ * distinguish versions. If it is not defined, the driver's release date is
+ * older than 2006-01-25.
+ */
+
+
+#ifndef USB_PUBLIC
+#define USB_PUBLIC
+#endif
+/* USB_PUBLIC is used as declaration attribute for all functions exported by
+ * the USB driver. The default is no attribute (see above). You may define it
+ * to static either in usbconfig.h or from the command line if you include
+ * usbdrv.c instead of linking against it. Including the C module of the driver
+ * directly in your code saves a couple of bytes in flash memory.
+ */
+
+#ifndef __ASSEMBLER__
+#ifndef uchar
+#define uchar unsigned char
+#endif
+#ifndef schar
+#define schar signed char
+#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);
+/* This function must be called before interrupts are enabled and the main
+ * loop is entered.
+ */
+USB_PUBLIC void usbPoll(void);
+/* This function must be called at regular intervals from the main loop.
+ * Maximum delay between calls is somewhat less than 50ms (USB timeout for
+ * accepting a Setup message). Otherwise the device will not be recognized.
+ * Please note that debug outputs through the UART take ~ 0.5ms per byte
+ * at 19200 bps.
+ */
+extern uchar *usbMsgPtr;
+/* This variable may be used to pass transmit data to the driver from the
+ * implementation of usbFunctionWrite(). It is also used internally by the
+ * driver for standard control requests.
+ */
+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
+ * the host communicates the parameters of the following (optional) data
+ * transfer. The SETUP data is available in the 'data' parameter which can
+ * (and should) be casted to 'usbRequest_t *' for a more user-friendly access
+ * to parameters.
+ *
+ * If the SETUP indicates a control-in transfer, you should provide the
+ * 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 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 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 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
+ * data. See the documentation of usbFunctionSetup() above for more info.
+ */
+#if USB_CFG_HAVE_INTRIN_ENDPOINT
+USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len);
+/* This function sets the message which will be sent during the next interrupt
+ * IN transfer. The message is copied to an internal buffer and must not exceed
+ * a length of 8 bytes. The message may be 0 bytes long just to indicate the
+ * interrupt status to the host.
+ * If you need to transfer more bytes, use a control read after the interrupt.
+ */
+#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
+ * message already buffered will be lost.
+ */
+#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len);
+#define usbInterruptIsReady3() (usbTxLen3 & 0x10)
+/* Same as above for endpoint 3 */
+#endif
+#endif /* USB_CFG_HAVE_INTRIN_ENDPOINT */
+#if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* simplified interface for backward compatibility */
+#define usbHidReportDescriptor usbDescriptorHidReport
+/* should be declared as: PROGMEM char usbHidReportDescriptor[]; */
+/* If you implement an HID device, you need to provide a report descriptor.
+ * The HID report descriptor syntax is a bit complex. If you understand how
+ * report descriptors are constructed, we recommend that you use the HID
+ * Descriptor Tool from usb.org, see http://www.usb.org/developers/hidpage/.
+ * Otherwise you should probably start with a working example.
+ */
+#endif /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */
+#if USB_CFG_IMPLEMENT_FN_WRITE
+USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len);
+/* This function is called by the driver to provide a control transfer's
+ * payload data (control-out). It is called in chunks of up to 8 bytes. The
+ * total count provided in the current control transfer can be obtained from
+ * the 'length' property in the setup data. If an error occurred during
+ * processing, return 0xff (== -1). The driver will answer the entire transfer
+ * with a STALL token in this case. If you have received the entire payload
+ * successfully, return 1. If you expect more data, return 0. If you don't
+ * know whether the host will send more data (you should know, the total is
+ * provided in the usbFunctionSetup() call!), return 1.
+ * NOTE: If you return 0xff for STALL, 'usbFunctionWrite()' may still be called
+ * for the remaining data. You must continue to return 0xff for STALL in these
+ * calls.
+ * In order to get usbFunctionWrite() called, define USB_CFG_IMPLEMENT_FN_WRITE
+ * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
+ */
+#endif /* USB_CFG_IMPLEMENT_FN_WRITE */
+#if USB_CFG_IMPLEMENT_FN_READ
+USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len);
+/* This function is called by the driver to ask the application for a control
+ * transfer's payload data (control-in). It is called in chunks of up to 8
+ * bytes each. You should copy the data to the location given by 'data' and
+ * return the actual number of bytes copied. If you return less than requested,
+ * the control-in transfer is terminated. If you return 0xff, the driver aborts
+ * the transfer with a STALL token.
+ * In order to get usbFunctionRead() called, define USB_CFG_IMPLEMENT_FN_READ
+ * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
+ */
+#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 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)))
+#define usbDeviceDisconnect() ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \
+ (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT)))
+#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.
+ */
+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
+ * USB data packets. The value is used to build raw transmit packets.
+ * You may want to use this function for data checksums or to verify received
+ * data. We enforce 16 bit calling conventions for compatibility with IAR's
+ * tiny memory model.
+ */
+extern unsigned usbCrc16Append(unsigned data, uchar len);
+#define usbCrc16Append(data, len) usbCrc16Append((unsigned)(data), len)
+/* This function is equivalent to usbCrc16() above, except that it appends
+ * 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
+ * and GET_CONFIGURATION requests, but does not use it otherwise.
+ * 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.
+ */
+#if USB_CFG_HAVE_FLOWCONTROL
+extern volatile schar usbRxLen;
+#define usbDisableAllRequests() usbRxLen = -1
+/* Must be called from usbFunctionWrite(). This macro disables all data input
+ * from the USB interface. Requests from the host are answered with a NAK
+ * while they are disabled.
+ */
+#define usbEnableAllRequests() usbRxLen = 0
+/* May only be called if requests are disabled. This macro enables input from
+ * the USB interface after it has been disabled with usbDisableAllRequests().
+ */
+#define usbAllRequestsAreDisabled() (usbRxLen < 0)
+/* Use this macro to find out whether requests are disabled. It may be needed
+ * to ensure that usbEnableAllRequests() is never called when requests are
+ * enabled.
+ */
+#endif
+
+#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. Since the token is toggled BEFORE
+ * sending data, you must set the opposite value of the token which should come
+ * first.
+ */
+
+#endif /* __ASSEMBLER__ */
+
+
+/* ------------------------------------------------------------------------- */
+/* ----------------- Definitions for Descriptor Properties ----------------- */
+/* ------------------------------------------------------------------------- */
+/* This is advanced stuff. See usbconfig-prototype.h for more information
+ * about the various methods to define USB descriptors. If you do nothing,
+ * the default descriptors will be used.
+ */
+#define USB_PROP_IS_DYNAMIC (1 << 14)
+/* If this property is set for a descriptor, usbFunctionDescriptor() will be
+ * 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 << 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) & 0x3fff)
+/* If a static external descriptor is used, this is the total length of the
+ * descriptor in bytes.
+ */
+
+/* all descriptors which may have properties: */
+#ifndef USB_CFG_DESCR_PROPS_DEVICE
+#define USB_CFG_DESCR_PROPS_DEVICE 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_CONFIGURATION
+#define USB_CFG_DESCR_PROPS_CONFIGURATION 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_STRINGS
+#define USB_CFG_DESCR_PROPS_STRINGS 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_STRING_0
+#define USB_CFG_DESCR_PROPS_STRING_0 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_STRING_VENDOR
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_STRING_PRODUCT
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0
+#endif
+#ifndef USB_CFG_DESCR_PROPS_HID
+#define USB_CFG_DESCR_PROPS_HID 0
+#endif
+#if !(USB_CFG_DESCR_PROPS_HID_REPORT)
+# undef USB_CFG_DESCR_PROPS_HID_REPORT
+# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */
+# define USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
+# else
+# define USB_CFG_DESCR_PROPS_HID_REPORT 0
+# endif
+#endif
+#ifndef USB_CFG_DESCR_PROPS_UNKNOWN
+#define USB_CFG_DESCR_PROPS_UNKNOWN 0
+#endif
+
+/* ------------------ forward declaration of descriptors ------------------- */
+/* If you use external static descriptors, they must be stored in global
+ * arrays as declared below:
+ */
+#ifndef __ASSEMBLER__
+extern
+#if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+char usbDescriptorDevice[];
+
+extern
+#if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+char usbDescriptorConfiguration[];
+
+extern
+#if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+char usbDescriptorHidReport[];
+
+extern
+#if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+char usbDescriptorString0[];
+
+extern
+#if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+int usbDescriptorStringVendor[];
+
+extern
+#if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+int usbDescriptorStringDevice[];
+
+extern
+#if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM)
+PROGMEM
+#endif
+int usbDescriptorStringSerialNumber[];
+
+#endif /* __ASSEMBLER__ */
+
+/* ------------------------------------------------------------------------- */
+/* ------------------------ General Purpose Macros ------------------------- */
+/* ------------------------------------------------------------------------- */
+
+#define USB_CONCAT(a, b) a ## b
+#define USB_CONCAT_EXPANDED(a, b) USB_CONCAT(a, b)
+
+#define USB_OUTPORT(name) USB_CONCAT(PORT, name)
+#define USB_INPORT(name) USB_CONCAT(PIN, name)
+#define USB_DDRPORT(name) USB_CONCAT(DDR, name)
+/* The double-define trick above lets us concatenate strings which are
+ * defined by macros.
+ */
+
+/* ------------------------------------------------------------------------- */
+/* ------------------------- Constant definitions -------------------------- */
+/* ------------------------------------------------------------------------- */
+
+#if !defined __ASSEMBLER__ && (!defined USB_CFG_VENDOR_ID || !defined USB_CFG_DEVICE_ID)
+#warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h"
+/* If the user has not defined IDs, we default to obdev's free IDs.
+ * See USBID-License.txt for details.
+ */
+#endif
+
+/* make sure we have a VID and PID defined, byte order is lowbyte, highbyte */
+#ifndef USB_CFG_VENDOR_ID
+# define USB_CFG_VENDOR_ID 0xc0, 0x16 /* 5824 in dec, stands for VOTI */
+#endif
+
+#ifndef USB_CFG_DEVICE_ID
+# if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
+# define USB_CFG_DEVICE_ID 0xdf, 0x05 /* 1503 in dec, shared PID for HIDs */
+# elif USB_CFG_INTERFACE_CLASS == 2
+# define USB_CFG_DEVICE_ID 0xe1, 0x05 /* 1505 in dec, shared PID for CDC Modems */
+# else
+# define USB_CFG_DEVICE_ID 0xdc, 0x05 /* 1500 in dec, obdev's free PID */
+# endif
+#endif
+
+/* Derive Output, Input and DataDirection ports from port names */
+#ifndef USB_CFG_IOPORTNAME
+#error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h"
+#endif
+
+#define USBOUT USB_OUTPORT(USB_CFG_IOPORTNAME)
+#define USB_PULLUP_OUT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
+#define USBIN USB_INPORT(USB_CFG_IOPORTNAME)
+#define USBDDR USB_DDRPORT(USB_CFG_IOPORTNAME)
+#define USB_PULLUP_DDR USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME)
+
+#define USBMINUS USB_CFG_DMINUS_BIT
+#define USBPLUS USB_CFG_DPLUS_BIT
+#define USBIDLE (1<<USB_CFG_DMINUS_BIT) /* value representing J state */
+#define USBMASK ((1<<USB_CFG_DPLUS_BIT) | (1<<USB_CFG_DMINUS_BIT)) /* mask for USB I/O bits */
+
+/* defines for backward compatibility with older driver versions: */
+#define USB_CFG_IOPORT USB_OUTPORT(USB_CFG_IOPORTNAME)
+#ifdef USB_CFG_PULLUP_IOPORTNAME
+#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 */
+
+/* ----- Try to find registers and bits responsible for ext interrupt 0 ----- */
+
+#ifndef USB_INTR_CFG /* allow user to override our default */
+# if defined EICRA
+# define USB_INTR_CFG EICRA
+# else
+# define USB_INTR_CFG MCUCR
+# endif
+#endif
+#ifndef USB_INTR_CFG_SET /* allow user to override our default */
+# 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 */
+#endif
+
+#ifndef USB_INTR_ENABLE /* allow user to override our default */
+# if defined GIMSK
+# define USB_INTR_ENABLE GIMSK
+# elif defined EIMSK
+# define USB_INTR_ENABLE EIMSK
+# else
+# define USB_INTR_ENABLE GICR
+# endif
+#endif
+#ifndef USB_INTR_ENABLE_BIT /* allow user to override our default */
+# define USB_INTR_ENABLE_BIT INT0
+#endif
+
+#ifndef USB_INTR_PENDING /* allow user to override our default */
+# if defined EIFR
+# define USB_INTR_PENDING EIFR
+# else
+# define USB_INTR_PENDING GIFR
+# endif
+#endif
+#ifndef USB_INTR_PENDING_BIT /* allow user to override our default */
+# define USB_INTR_PENDING_BIT INTF0
+#endif
+
+/*
+The defines above don't work for the following chips
+at90c8534: no ISC0?, no PORTB, can't find a data sheet
+at86rf401: no PORTB, no MCUCR etc, low clock rate
+atmega103: no ISC0? (maybe omission in header, can't find data sheet)
+atmega603: not defined in avr-libc
+at43usb320, at43usb355, at76c711: have USB anyway
+at94k: is different...
+
+at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM
+*/
+
+/* ------------------------------------------------------------------------- */
+/* ----------------- USB Specification Constants and Types ----------------- */
+/* ------------------------------------------------------------------------- */
+
+/* USB Token values */
+#define USBPID_SETUP 0x2d
+#define USBPID_OUT 0xe1
+#define USBPID_IN 0x69
+#define USBPID_DATA0 0xc3
+#define USBPID_DATA1 0x4b
+
+#define USBPID_ACK 0xd2
+#define USBPID_NAK 0x5a
+#define USBPID_STALL 0x1e
+
+#ifndef USB_INITIAL_DATATOKEN
+#define USB_INITIAL_DATATOKEN USBPID_DATA1
+#endif
+
+#ifndef __ASSEMBLER__
+
+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;
+ uchar bytes[2];
+}usbWord_t;
+
+typedef struct usbRequest{
+ uchar bmRequestType;
+ uchar bRequest;
+ usbWord_t wValue;
+ usbWord_t wIndex;
+ usbWord_t wLength;
+}usbRequest_t;
+/* This structure matches the 8 byte setup request */
+#endif
+
+/* bmRequestType field in USB setup:
+ * d t t r r r r r, where
+ * d ..... direction: 0=host->device, 1=device->host
+ * t ..... type: 0=standard, 1=class, 2=vendor, 3=reserved
+ * r ..... recipient: 0=device, 1=interface, 2=endpoint, 3=other
+ */
+
+/* USB setup recipient values */
+#define USBRQ_RCPT_MASK 0x1f
+#define USBRQ_RCPT_DEVICE 0
+#define USBRQ_RCPT_INTERFACE 1
+#define USBRQ_RCPT_ENDPOINT 2
+
+/* USB request type values */
+#define USBRQ_TYPE_MASK 0x60
+#define USBRQ_TYPE_STANDARD (0<<5)
+#define USBRQ_TYPE_CLASS (1<<5)
+#define USBRQ_TYPE_VENDOR (2<<5)
+
+/* USB direction values: */
+#define USBRQ_DIR_MASK 0x80
+#define USBRQ_DIR_HOST_TO_DEVICE (0<<7)
+#define USBRQ_DIR_DEVICE_TO_HOST (1<<7)
+
+/* USB Standard Requests */
+#define USBRQ_GET_STATUS 0
+#define USBRQ_CLEAR_FEATURE 1
+#define USBRQ_SET_FEATURE 3
+#define USBRQ_SET_ADDRESS 5
+#define USBRQ_GET_DESCRIPTOR 6
+#define USBRQ_SET_DESCRIPTOR 7
+#define USBRQ_GET_CONFIGURATION 8
+#define USBRQ_SET_CONFIGURATION 9
+#define USBRQ_GET_INTERFACE 10
+#define USBRQ_SET_INTERFACE 11
+#define USBRQ_SYNCH_FRAME 12
+
+/* USB descriptor constants */
+#define USBDESCR_DEVICE 1
+#define USBDESCR_CONFIG 2
+#define USBDESCR_STRING 3
+#define USBDESCR_INTERFACE 4
+#define USBDESCR_ENDPOINT 5
+#define USBDESCR_HID 0x21
+#define USBDESCR_HID_REPORT 0x22
+#define USBDESCR_HID_PHYS 0x23
+
+#define USBATTR_BUSPOWER 0x80
+#define USBATTR_SELFPOWER 0x40
+#define USBATTR_REMOTEWAKE 0x20
+
+/* USB HID Requests */
+#define USBRQ_HID_GET_REPORT 0x01
+#define USBRQ_HID_GET_IDLE 0x02
+#define USBRQ_HID_GET_PROTOCOL 0x03
+#define USBRQ_HID_SET_REPORT 0x09
+#define USBRQ_HID_SET_IDLE 0x0a
+#define USBRQ_HID_SET_PROTOCOL 0x0b
+
+/* ------------------------------------------------------------------------- */
+
+#endif /* __usbdrv_h_included__ */
diff --git a/usbdrv/usbdrvasm.S b/usbdrv/usbdrvasm.S
new file mode 100644
index 0000000..0d650d7
--- /dev/null
+++ b/usbdrv/usbdrvasm.S
@@ -0,0 +1,296 @@
+/* Name: usbdrvasm.S
+ * Project: AVR USB driver
+ * Author: Christian Starkjohann
+ * Creation Date: 2007-06-13
+ * 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: usbdrvasm.S 692 2008-11-07 15:07:40Z cs $
+ */
+
+/*
+General Description:
+This module is the assembler part of the USB driver. This file contains
+general code (preprocessor acrobatics and CRC computation) and then includes
+the file appropriate for the given clock rate.
+*/
+
+#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
+#define x2 r17
+#define shift r18
+#define cnt r19
+#define x3 r20
+#define x4 r21
+#define bitcnt r22
+#define phase x4
+#define leap x4
+
+/* Some assembler dependent definitions and declarations: */
+
+#ifdef __IAR_SYSTEMS_ASM__
+ extern usbRxBuf, usbDeviceAddr, usbNewDeviceAddr, usbInputBufOffset
+ extern usbCurrentTok, usbRxLen, usbRxToken, usbTxLen
+ extern usbTxBuf, usbTxStatus1, usbTxStatus3
+# if USB_COUNT_SOF
+ extern usbSofCount
+# endif
+ public usbCrc16
+ public usbCrc16Append
+
+ COMMON INTVEC
+# 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__ */
+
+# ifndef USB_INTR_VECTOR /* default to hardware interrupt INT0 */
+# define USB_INTR_VECTOR SIG_INTERRUPT0
+# endif
+ .text
+ .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
+;----------------------------------------------------------------------------
+
+#ifdef __IAR_SYSTEMS_ASM__
+/* Register assignments for usbCrc16 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".
+ */
+RTMODEL "__rt_version", "3"
+/* The line above will generate an error if cc calling conventions change.
+ * The value "3" above is valid for IAR 4.10B/W32
+ */
+# define argLen r18 /* argument 2 */
+# define argPtrL r16 /* argument 1 */
+# define argPtrH r17 /* argument 1 */
+
+# define resCrcL r16 /* result */
+# define resCrcH r17 /* result */
+
+# define ptrL ZL
+# define ptrH ZH
+# define ptr Z
+# define byte r22
+# define bitCnt r19
+# define polyL r20
+# define polyH r21
+# define scratch r23
+
+#else /* __IAR_SYSTEMS_ASM__ */
+/* Register assignments for usbCrc16 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 argLen r22 /* argument 2 */
+# define argPtrL r24 /* argument 1 */
+# define argPtrH r25 /* argument 1 */
+
+# define resCrcL r24 /* result */
+# define resCrcH r25 /* result */
+
+# define ptrL XL
+# define ptrH XH
+# define ptr x
+# define byte r18
+# define bitCnt r19
+# define polyL r20
+# define polyH r21
+# define scratch r23
+
+#endif
+
+; extern unsigned usbCrc16(unsigned char *data, unsigned char len);
+; data: r24/25
+; len: r22
+; temp variables:
+; r18: data byte
+; r19: bit counter
+; r20/21: polynomial
+; r23: scratch
+; r24/25: crc-sum
+; r26/27=X: ptr
+usbCrc16:
+ mov ptrL, argPtrL
+ mov ptrH, argPtrH
+ ldi resCrcL, 0
+ ldi resCrcH, 0
+ ldi polyL, lo8(0xa001)
+ ldi polyH, hi8(0xa001)
+ com argLen ; argLen = -argLen - 1
+crcByteLoop:
+ subi argLen, -1
+ brcc crcReady ; modified loop to ensure that carry is set below
+ ld byte, ptr+
+ ldi bitCnt, -8 ; strange loop counter to ensure that carry is set where we need it
+ eor resCrcL, byte
+crcBitLoop:
+ ror resCrcH ; carry is always set here
+ ror resCrcL
+ brcs crcNoXor
+ eor resCrcL, polyL
+ eor resCrcH, polyH
+crcNoXor:
+ subi bitCnt, -1
+ brcs crcBitLoop
+ rjmp crcByteLoop
+crcReady:
+ ret
+; Thanks to Reimar Doeffinger for optimizing this CRC routine!
+
+; extern unsigned usbCrc16Append(unsigned char *data, unsigned char len);
+usbCrc16Append:
+ rcall usbCrc16
+ st ptr+, resCrcL
+ 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
+;----------------------------------------------------------------------------
+
+#ifndef USB_CFG_CLOCK_KHZ
+# define USB_CFG_CLOCK_KHZ 12000
+#endif
+
+#if USB_CFG_CLOCK_KHZ == 12000
+# 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.inc"
+#elif USB_CFG_CLOCK_KHZ == 16500
+# 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/usbdrv/usbdrvasm.asm b/usbdrv/usbdrvasm.asm
new file mode 100644
index 0000000..a534b73
--- /dev/null
+++ b/usbdrv/usbdrvasm.asm
@@ -0,0 +1,21 @@
+/* Name: usbdrvasm.asm
+ * 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), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id$
+ */
+
+/*
+General Description:
+The IAR compiler/assembler system prefers assembler files with file extension
+".asm". We simply provide this file as an alias for usbdrvasm.S.
+
+Thanks to Oleg Semyonov for his help with the IAR tools port!
+*/
+
+#include "usbdrvasm.S"
+
+end
diff --git a/usbdrv/usbdrvasm12.inc b/usbdrv/usbdrvasm12.inc
new file mode 100644
index 0000000..08dddd3
--- /dev/null
+++ b/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/usbdrv/usbdrvasm128.inc b/usbdrv/usbdrvasm128.inc
new file mode 100644
index 0000000..db8cc82
--- /dev/null
+++ b/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/usbdrv/usbdrvasm15.inc b/usbdrv/usbdrvasm15.inc
new file mode 100644
index 0000000..1016124
--- /dev/null
+++ b/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/usbdrv/usbdrvasm16.inc b/usbdrv/usbdrvasm16.inc
new file mode 100644
index 0000000..a1774fb
--- /dev/null
+++ b/usbdrv/usbdrvasm16.inc
@@ -0,0 +1,343 @@
+/* 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), 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
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file is the 16 MHz version of the asssembler part of the USB driver. It
+requires a 16 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: 16 MHz -> 10.6666666 cycles per bit, 85.333333333 cycles per byte
+; Numbers in brackets are clocks counted from center of last sync bit
+; when instruction starts
+
+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]
+ push YL ;[-22]
+ push YH ;[-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
+;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 ;[-15]
+ rjmp foundK ;[-14]
+ 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: ;[-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 bitcnt ;[-12]
+; [---] ;[-11]
+ lds YL, usbInputBufOffset;[-10]
+; [---] ;[-9]
+ clr YH ;[-8]
+ subi YL, lo8(-(usbRxBuf));[-7] [rx loop init]
+ sbci YH, hi8(-(usbRxBuf));[-6] [rx loop init]
+ push shift ;[-5]
+; [---] ;[-4]
+ ldi bitcnt, 0x55 ;[-3] [rx loop init]
+ sbis USBIN, USBMINUS ;[-2] we want two bits K (sample 2 cycles too early)
+ rjmp haveTwoBitsK ;[-1]
+ pop shift ;[0] undo the push from before
+ pop bitcnt ;[2] undo the push from before
+ 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 (= 21 cycles).
+
+;----------------------------------------------------------------------------
+; push more registers and initialize values while we sample the first bits:
+;----------------------------------------------------------------------------
+haveTwoBitsK:
+ push x1 ;[1]
+ push x2 ;[3]
+ push x3 ;[5]
+ ldi shift, 0 ;[7]
+ ldi x3, 1<<4 ;[8] [rx loop init] first sample is inverse bit, compensate that
+ push x4 ;[9] == leap
+
+ in x1, USBIN ;[11] <-- sample bit 0
+ andi x1, USBMASK ;[12]
+ bst x1, USBMINUS ;[13]
+ bld shift, 7 ;[14]
+ push cnt ;[15]
+ ldi leap, 0 ;[17] [rx loop init]
+ ldi cnt, USB_BUFSIZE;[18] [rx loop init]
+ rjmp rxbit1 ;[19] arrives at [21]
+
+;----------------------------------------------------------------------------
+; Receiver loop (numbers in brackets are cycles within byte after instr)
+;----------------------------------------------------------------------------
+
+unstuff6:
+ andi x2, USBMASK ;[03]
+ ori x3, 1<<6 ;[04] will not be shifted any more
+ andi shift, ~0x80;[05]
+ mov x1, x2 ;[06] sampled bit 7 is actually re-sampled bit 6
+ subi leap, 3 ;[07] since this is a short (10 cycle) bit, enforce leap bit
+ rjmp didUnstuff6 ;[08]
+
+unstuff7:
+ ori x3, 1<<7 ;[09] will not be shifted any more
+ in x2, USBIN ;[00] [10] re-sample bit 7
+ andi x2, USBMASK ;[01]
+ andi shift, ~0x80;[02]
+ subi leap, 3 ;[03] since this is a short (10 cycle) bit, enforce leap bit
+ rjmp didUnstuff7 ;[04]
+
+unstuffEven:
+ ori x3, 1<<6 ;[09] will be shifted right 6 times for bit 0
+ in x1, USBIN ;[00] [10]
+ andi shift, ~0x80;[01]
+ andi x1, USBMASK ;[02]
+ breq se0 ;[03]
+ subi leap, 3 ;[04] since this is a short (10 cycle) bit, enforce leap bit
+ nop ;[05]
+ rjmp didUnstuffE ;[06]
+
+unstuffOdd:
+ ori x3, 1<<5 ;[09] will be shifted right 4 times for bit 1
+ in x2, USBIN ;[00] [10]
+ andi shift, ~0x80;[01]
+ andi x2, USBMASK ;[02]
+ breq se0 ;[03]
+ subi leap, 3 ;[04] since this is a short (10 cycle) bit, enforce leap bit
+ nop ;[05]
+ rjmp didUnstuffO ;[06]
+
+rxByteLoop:
+ andi x1, USBMASK ;[03]
+ eor x2, x1 ;[04]
+ subi leap, 1 ;[05]
+ brpl skipLeap ;[06]
+ subi leap, -3 ;1 one leap cycle every 3rd byte -> 85 + 1/3 cycles per byte
+ nop ;1
+skipLeap:
+ subi x2, 1 ;[08]
+ ror shift ;[09]
+didUnstuff6:
+ cpi shift, 0xfc ;[10]
+ in x2, USBIN ;[00] [11] <-- sample bit 7
+ brcc unstuff6 ;[01]
+ andi x2, USBMASK ;[02]
+ eor x1, x2 ;[03]
+ subi x1, 1 ;[04]
+ ror shift ;[05]
+didUnstuff7:
+ cpi shift, 0xfc ;[06]
+ brcc unstuff7 ;[07]
+ eor x3, shift ;[08] reconstruct: x3 is 1 at bit locations we changed, 0 at others
+ st y+, x3 ;[09] store data
+rxBitLoop:
+ in x1, USBIN ;[00] [11] <-- sample bit 0/2/4
+ andi x1, USBMASK ;[01]
+ eor x2, x1 ;[02]
+ andi x3, 0x3f ;[03] topmost two bits reserved for 6 and 7
+ subi x2, 1 ;[04]
+ ror shift ;[05]
+ cpi shift, 0xfc ;[06]
+ brcc unstuffEven ;[07]
+didUnstuffE:
+ lsr x3 ;[08]
+ lsr x3 ;[09]
+rxbit1:
+ in x2, USBIN ;[00] [10] <-- sample bit 1/3/5
+ andi x2, USBMASK ;[01]
+ breq se0 ;[02]
+ eor x1, x2 ;[03]
+ subi x1, 1 ;[04]
+ ror shift ;[05]
+ cpi shift, 0xfc ;[06]
+ brcc unstuffOdd ;[07]
+didUnstuffO:
+ subi bitcnt, 0xab;[08] == addi 0x55, 0x55 = 0x100/3
+ brcs rxBitLoop ;[09]
+
+ subi cnt, 1 ;[10]
+ in x1, USBIN ;[00] [11] <-- sample bit 6
+ brcc rxByteLoop ;[01]
+ rjmp overflow
+
+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
+
+bitstuffN:
+ eor x1, x4 ;[5]
+ ldi x2, 0 ;[6]
+ nop2 ;[7]
+ nop ;[9]
+ out USBOUT, x1 ;[10] <-- out
+ rjmp didStuffN ;[0]
+
+bitstuff6:
+ 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:
+ ldi x2, 0 ;[2] Carry is zero due to brcc
+ rjmp didStuff7 ;[3]
+
+
+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, 0x35 ;[-4] [6] binary 0011 0101
+txBitLoop:
+ sbrs shift, 0 ;[-3] [7]
+ eor x1, x4 ;[-2] [8]
+ out USBOUT, x1 ;[-1] [9] <-- out N
+ ror shift ;[0] [10]
+ ror x2 ;[1]
+didStuffN:
+ cpi x2, 0xfc ;[2]
+ brcc bitstuffN ;[3]
+ lsr bitcnt ;[4]
+ brcc txBitLoop ;[5]
+ brne txBitLoop ;[6]
+
+ sbrs shift, 0 ;[7]
+ eor x1, x4 ;[8]
+didStuff6:
+ 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:
+ ror x2 ;[5]
+ sbrs x2, 7 ;[6]
+ eor x1, x4 ;[7]
+ nop ;[8]
+ cpi x2, 0xfc ;[9]
+ out USBOUT, x1 ;[-1][10] <-- out 7
+ brcc bitstuff7 ;[0] [11]
+ ld shift, y+ ;[1]
+ dec cnt ;[3]
+ brne txByteLoop ;[4]
+;make SE0:
+ 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
+ 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;[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 ;[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/usbdrv/usbdrvasm165.inc b/usbdrv/usbdrvasm165.inc
new file mode 100644
index 0000000..7c2d565
--- /dev/null
+++ b/usbdrv/usbdrvasm165.inc
@@ -0,0 +1,453 @@
+/* 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), 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
+ * appropriate implementation!
+ */
+
+/*
+General Description:
+This file is the 16.5 MHz version of the USB driver. It is intended for the
+ATTiny45 and similar controllers running on 16.5 MHz internal RC oscillator.
+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.
+
+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!
+*/
+
+;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: 59 cycles -> max 52 cycles interrupt disable
+;max stack usage: [ret(2), r0, SREG, YL, YH, shift, x1, x2, x3, x4, cnt] = 12 bytes
+;nominal frequency: 16.5 MHz -> 11 cycles per bit
+; 16.3125 MHz < F_CPU < 16.6875 MHz (+/- 1.1%)
+; Numbers in brackets are clocks counted from center of last sync bit
+; when instruction starts
+
+
+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
+;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 ;[-15]
+ rjmp foundK ;[-14]
+ 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: ;[-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 r0 ;[-12]
+; [---] ;[-11]
+ push YH ;[-10]
+; [---] ;[-9]
+ lds YL, usbInputBufOffset;[-8]
+; [---] ;[-7]
+ clr YH ;[-6]
+ subi YL, lo8(-(usbRxBuf));[-5] [rx loop init]
+ sbci YH, hi8(-(usbRxBuf));[-4] [rx loop init]
+ mov r0, x2 ;[-3] [rx loop init]
+ 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 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).
+
+;----------------------------------------------------------------------------
+; push more registers and initialize values while we sample the first bits:
+;----------------------------------------------------------------------------
+haveTwoBitsK: ;[1]
+ push shift ;[1]
+ push x1 ;[3]
+ push x2 ;[5]
+ push x3 ;[7]
+ ldi shift, 0xff ;[9] [rx loop init]
+ ori x3, 0xff ;[10] [rx loop init] == ser x3, clear zero flag
+
+ in x1, USBIN ;[11] <-- sample bit 0
+ bst x1, USBMINUS ;[12]
+ bld shift, 0 ;[13]
+ push x4 ;[14] == phase
+; [---] ;[15]
+ push cnt ;[16]
+; [---] ;[17]
+ ldi phase, 0 ;[18] [rx loop init]
+ ldi cnt, USB_BUFSIZE;[19] [rx loop init]
+ rjmp rxbit1 ;[20]
+; [---] ;[21]
+
+;----------------------------------------------------------------------------
+; Receiver loop (numbers in brackets are cycles within byte after instr)
+;----------------------------------------------------------------------------
+/*
+byte oriented operations done during loop:
+bit 0: store data
+bit 1: SE0 check
+bit 2: overflow check
+bit 3: catch up
+bit 4: rjmp to achieve conditional jump range
+bit 5: PLL
+bit 6: catch up
+bit 7: jump, fixup bitstuff
+; 87 [+ 2] cycles
+------------------------------------------------------------------
+*/
+continueWithBit5:
+ in x2, USBIN ;[055] <-- bit 5
+ eor r0, x2 ;[056]
+ or phase, r0 ;[057]
+ sbrc phase, USBMINUS ;[058]
+ lpm ;[059] optional nop3; modifies r0
+ in phase, USBIN ;[060] <-- phase
+ eor x1, x2 ;[061]
+ bst x1, USBMINUS ;[062]
+ bld shift, 5 ;[063]
+ andi shift, 0x3f ;[064]
+ in x1, USBIN ;[065] <-- bit 6
+ breq unstuff5 ;[066] *** unstuff escape
+ eor phase, x1 ;[067]
+ eor x2, x1 ;[068]
+ bst x2, USBMINUS ;[069]
+ bld shift, 6 ;[070]
+didUnstuff6: ;[ ]
+ in r0, USBIN ;[071] <-- phase
+ cpi shift, 0x02 ;[072]
+ brlo unstuff6 ;[073] *** unstuff escape
+didUnstuff5: ;[ ]
+ nop2 ;[074]
+; [---] ;[075]
+ in x2, USBIN ;[076] <-- bit 7
+ eor x1, x2 ;[077]
+ bst x1, USBMINUS ;[078]
+ bld shift, 7 ;[079]
+didUnstuff7: ;[ ]
+ eor r0, x2 ;[080]
+ or phase, r0 ;[081]
+ in r0, USBIN ;[082] <-- phase
+ cpi shift, 0x04 ;[083]
+ brsh rxLoop ;[084]
+; [---] ;[085]
+unstuff7: ;[ ]
+ andi x3, ~0x80 ;[085]
+ ori shift, 0x80 ;[086]
+ in x2, USBIN ;[087] <-- sample stuffed bit 7
+ nop ;[088]
+ rjmp didUnstuff7 ;[089]
+; [---] ;[090]
+ ;[080]
+
+unstuff5: ;[067]
+ eor phase, x1 ;[068]
+ andi x3, ~0x20 ;[069]
+ ori shift, 0x20 ;[070]
+ in r0, USBIN ;[071] <-- phase
+ mov x2, x1 ;[072]
+ nop ;[073]
+ nop2 ;[074]
+; [---] ;[075]
+ in x1, USBIN ;[076] <-- bit 6
+ eor r0, x1 ;[077]
+ or phase, r0 ;[078]
+ eor x2, x1 ;[079]
+ bst x2, USBMINUS ;[080]
+ bld shift, 6 ;[081] no need to check bitstuffing, we just had one
+ in r0, USBIN ;[082] <-- phase
+ rjmp didUnstuff5 ;[083]
+; [---] ;[084]
+ ;[074]
+
+unstuff6: ;[074]
+ andi x3, ~0x40 ;[075]
+ in x1, USBIN ;[076] <-- bit 6 again
+ ori shift, 0x40 ;[077]
+ nop2 ;[078]
+; [---] ;[079]
+ rjmp didUnstuff6 ;[080]
+; [---] ;[081]
+ ;[071]
+
+unstuff0: ;[013]
+ eor r0, x2 ;[014]
+ or phase, r0 ;[015]
+ andi x2, USBMASK ;[016] check for SE0
+ in r0, USBIN ;[017] <-- phase
+ breq didUnstuff0 ;[018] direct jump to se0 would be too long
+ andi x3, ~0x01 ;[019]
+ ori shift, 0x01 ;[020]
+ mov x1, x2 ;[021] mov existing sample
+ in x2, USBIN ;[022] <-- bit 1 again
+ rjmp didUnstuff0 ;[023]
+; [---] ;[024]
+ ;[014]
+
+unstuff1: ;[024]
+ eor r0, x1 ;[025]
+ or phase, r0 ;[026]
+ andi x3, ~0x02 ;[027]
+ in r0, USBIN ;[028] <-- phase
+ ori shift, 0x02 ;[029]
+ mov x2, x1 ;[030]
+ rjmp didUnstuff1 ;[031]
+; [---] ;[032]
+ ;[022]
+
+unstuff2: ;[035]
+ eor r0, x2 ;[036]
+ or phase, r0 ;[037]
+ andi x3, ~0x04 ;[038]
+ in r0, USBIN ;[039] <-- phase
+ ori shift, 0x04 ;[040]
+ mov x1, x2 ;[041]
+ rjmp didUnstuff2 ;[042]
+; [---] ;[043]
+ ;[033]
+
+unstuff3: ;[043]
+ in x2, USBIN ;[044] <-- bit 3 again
+ eor r0, x2 ;[045]
+ or phase, r0 ;[046]
+ andi x3, ~0x08 ;[047]
+ ori shift, 0x08 ;[048]
+ nop ;[049]
+ in r0, USBIN ;[050] <-- phase
+ rjmp didUnstuff3 ;[051]
+; [---] ;[052]
+ ;[042]
+
+unstuff4: ;[053]
+ andi x3, ~0x10 ;[054]
+ in x1, USBIN ;[055] <-- bit 4 again
+ ori shift, 0x10 ;[056]
+ rjmp didUnstuff4 ;[057]
+; [---] ;[058]
+ ;[048]
+
+rxLoop: ;[085]
+ eor x3, shift ;[086] reconstruct: x3 is 0 at bit locations we changed, 1 at others
+ in x1, USBIN ;[000] <-- bit 0
+ st y+, x3 ;[001]
+; [---] ;[002]
+ eor r0, x1 ;[003]
+ or phase, r0 ;[004]
+ eor x2, x1 ;[005]
+ in r0, USBIN ;[006] <-- phase
+ ser x3 ;[007]
+ bst x2, USBMINUS ;[008]
+ bld shift, 0 ;[009]
+ andi shift, 0xf9 ;[010]
+rxbit1: ;[ ]
+ in x2, USBIN ;[011] <-- bit 1
+ breq unstuff0 ;[012] *** unstuff escape
+ andi x2, USBMASK ;[013] SE0 check for bit 1
+didUnstuff0: ;[ ] Z only set if we detected SE0 in bitstuff
+ breq se0 ;[014]
+ eor r0, x2 ;[015]
+ or phase, r0 ;[016]
+ in r0, USBIN ;[017] <-- phase
+ eor x1, x2 ;[018]
+ bst x1, USBMINUS ;[019]
+ bld shift, 1 ;[020]
+ andi shift, 0xf3 ;[021]
+didUnstuff1: ;[ ]
+ in x1, USBIN ;[022] <-- bit 2
+ breq unstuff1 ;[023] *** unstuff escape
+ eor r0, x1 ;[024]
+ or phase, r0 ;[025]
+ subi cnt, 1 ;[026] overflow check
+ brcs overflow ;[027]
+ in r0, USBIN ;[028] <-- phase
+ eor x2, x1 ;[029]
+ bst x2, USBMINUS ;[030]
+ bld shift, 2 ;[031]
+ andi shift, 0xe7 ;[032]
+didUnstuff2: ;[ ]
+ in x2, USBIN ;[033] <-- bit 3
+ breq unstuff2 ;[034] *** unstuff escape
+ eor r0, x2 ;[035]
+ or phase, r0 ;[036]
+ eor x1, x2 ;[037]
+ bst x1, USBMINUS ;[038]
+ in r0, USBIN ;[039] <-- phase
+ bld shift, 3 ;[040]
+ andi shift, 0xcf ;[041]
+didUnstuff3: ;[ ]
+ breq unstuff3 ;[042] *** unstuff escape
+ nop ;[043]
+ in x1, USBIN ;[044] <-- bit 4
+ eor x2, x1 ;[045]
+ bst x2, USBMINUS ;[046]
+ bld shift, 4 ;[047]
+didUnstuff4: ;[ ]
+ eor r0, x1 ;[048]
+ or phase, r0 ;[049]
+ in r0, USBIN ;[050] <-- phase
+ andi shift, 0x9f ;[051]
+ breq unstuff4 ;[052] *** unstuff escape
+ rjmp continueWithBit5;[053]
+; [---] ;[054]
+
+macro POP_STANDARD ; 16 cycles
+ pop cnt
+ pop x4
+ pop x3
+ pop x2
+ pop x1
+ pop shift
+ pop YH
+ pop r0
+ 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
+
+bitstuff7:
+ eor x1, x4 ;[4]
+ ldi x2, 0 ;[5]
+ nop2 ;[6] C is zero (brcc)
+ rjmp didStuff7 ;[8]
+
+bitstuffN:
+ eor x1, x4 ;[5]
+ ldi x2, 0 ;[6]
+ lpm ;[7] 3 cycle NOP, modifies r0
+ out USBOUT, x1 ;[10] <-- out
+ rjmp didStuffN ;[0]
+
+#define bitStatus x3
+
+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
+
+;usbSend:
+;pointer to data in 'Y'
+;number of bytes in 'cnt' -- including sync byte [range 2 ... 12]
+;uses: x1...x4, shift, cnt, Y
+;Numbers in brackets are time since first bit of sync pattern is sent
+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
+ ldi bitStatus, 0xff ;[-4] init bit loop counter, works for up to 12 bytes
+byteloop:
+bitloop:
+ sbrs shift, 0 ;[8] [-3]
+ eor x1, x4 ;[9] [-2]
+ out USBOUT, x1 ;[10] [-1] <-- out
+ ror shift ;[0]
+ ror x2 ;[1]
+didStuffN:
+ cpi x2, 0xfc ;[2]
+ brcc bitstuffN ;[3]
+ nop ;[4]
+ subi bitStatus, 37 ;[5] 256 / 7 ~=~ 37
+ brcc bitloop ;[6] when we leave the loop, bitStatus has almost the initial value
+ sbrs shift, 0 ;[7]
+ eor x1, x4 ;[8]
+ ror shift ;[9]
+didStuff7:
+ out USBOUT, x1 ;[10] <-- out
+ ror x2 ;[0]
+ cpi x2, 0xfc ;[1]
+ brcc bitstuff7 ;[2]
+ ld shift, y+ ;[3]
+ dec cnt ;[5]
+ brne byteloop ;[6]
+;make SE0:
+ cbr x1, USBMASK ;[7] prepare SE0 [spec says EOP may be 21 to 25 cycles]
+ lds x2, usbNewDeviceAddr;[8]
+ 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] 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
+ 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, 4 ;[11]
+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
+ rjmp doReturn
+
diff --git a/usbdrv/usbdrvasm20.inc b/usbdrv/usbdrvasm20.inc
new file mode 100644
index 0000000..5cfaa5f
--- /dev/null
+++ b/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/usbdrv/usbportability.h b/usbdrv/usbportability.h
new file mode 100644
index 0000000..2dd2424
--- /dev/null
+++ b/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.43.0