Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — README 


1 


USB support for Atmels AT90USB microcontroller 

Enumeration (with Linux host) and basic data transfer (LibUSB) works fine now! 

A simple example program for Linux console is included now. 

Basic documentation should be available on my homepage, see http :// www.ssalewski.de/Misc.html 
License: GPL— 2 
S. Salewski 2006/2007 

USB Documentation: 

H.J. Kelm, USB 2.0, LRANZIS 
J . Axelson, USB Complete, Lakeview Research 
www.beyondlogic.org/usbnutshell/usb— in— a— nutshell.pdf 
Atmel: Datasheet for AT90USB 
Atmel: AVR329, USB Lirmware Architecture 

Piles : 

AT90USB-Errata.txt 
com_def.h 
daq_dev.c 
daq dcv.li 
defines .h 
macros, h 
Makefile 
README 
ringbuffer .c 
ringbuffer .h 
SUDAP.c 
SUDD.c 
usart_debug . c 
usart_debug . h 
usart.drv .c 
usart.drv .h 
usb_api .c 
usb_api . h 
usb_drv . c 
usb.drv . h 
usbJsr .c 
usb .requests .c 
usb requests . h 
usb.spec . c 
usb spec . h 

gen.postscript . txt Script for generating postscript from sources for printout using enscript 

gen_pdf.tex Small LaTeX file using listings package for pretty —printing sources 

AT90USB— 20070xyz.tar.gz All source files in compressed form 
AT90USB-20070xyz.zip All source files in zip compressed form 

sources .ps .gz All source files preformated for printout (enscript) 

sources . pdf All source files preformated for printout ( pdflatex ) 


Some remarks about errors or unclear statements in AT90USB datasheet 
Constants which are used by firmware and host application program 
Function for data acquisition using the intern ADC (port ADCO) 

Project specific constants 
Some general macros 

Makefile : type ’’make” to generate all binary files and ’’make dfu” to upload firmware 
This file 

Simple ring buffer (FIFO) for buffering ADC data 

Example firmware application : Data acquisition ( port ADCO) and control of digital port B 
Example host application : Console based data acquisition and control of digital port B 
Functions for debugging over serial port 

Access to serial port 

This file contains constants and functions which need modifications 
to customize the software for a specific device 
Basic USB functions for AT90USB controller 
USB macros, basic low level register stuff 
Interrupt service routines 
USB (standard) requests , enumeration 

USB datastructures and constants 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — SUDAP.c 


2 


// AT90USB/SUDAP.C 

// Simple Usb Data Acquisition Program 

// Sampling an analog voltage using the intern ADC of AT90USB chip and 
// sending data to host (Linux PC) over USB in real time. 

// Sampling inten’al and number of samples is selected with command line options . 

// Additionally you can set output pins of digital port B. 

// The mam purpose of this tiny program is to demonstrate the functionality of my 
// USB firmware written for Atmels AT90USB controller. 

// Licence: GPL— 2 

// Build: gcc —l usb SUDAP.c 

// Usage: see function usage)) below. 

// S. Salewski, 24— MAR— 2007 

#include <stdio.h> 

#include <stdint.h> 

#include <getopt.h> 

#include <errno.h> 

#include <usb.h> 

#include ’’com.def.h” 

#include ’’daq.dev.h” 

#define TimeOut 2000 // ms 

const char trstr [] = ’’Use 1ms, 500us, 200us, lOOus, 50us or 20us for time resolution !”; 


static struct option long_options [] = 
{ 


{’’timeres”, 

required.argument , 

0, ’t’}, 

{’’samples”, 

required.argument , 

0, ’s’}, 

{’’columns”, 

required argument , 

0, ’c’}, 

{’’portb”, 

required.argument , 

0- *p’}, 

{’’help”, 

{0, 0, 0, 0} 

no .argument. 

0, ’h’}, 


}; 

static void 

us age (void) 

{ 

puts (’’Usage: — t lOOus — s 100 —c 1 — p 10001101”); 

printf (”— t or timeres: ”); 

puts ( trstr ) ; 

puts(”— s or samples: number of samples (1 up to 65535)”); 

puts (”— cor columns: number of columns for output, default is 32”); 

puts (”— p or portb: output value for digital port b, use a 8— bit dual number”); 

} 

static struct usb_device 
vUshFind Device) void ) 

{ 

struct usb_bus *bus; 
struct usb device *dev; 
usbJnit () ; 
usb_find_busses () ; 
usb_find_devices () ; 

for (bus = usb .busses; bus; bus = bus— >next) 

{ 

for (dev = bus— >devices; dev; dev = dev— >next) 

{ 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — SUDAP.c 


3 


if ((dev— >descriptor.idVendor == MyUSBJVendorlD) && (dev— >descriptor.idProduct == MyUSB_ProductID)) 
return dev; 

} 

} 

return NULL; 

} 

// We use EP2 for DAQ 

static void 

dodaq( struct usb_dev_handle ^handle, uintl6_t timeres , uintl6_t samples, int columns) 

{ 

unsigned char buf[EP2_FIFO_Size]; 

unsigned char *b; 
unsigned int m; 
unsigned int c = 0; 

if (usb_control_msg(handle, USBJVendorRequestCode, UC_ADC_Read, (int) timeres, (int) samples, NULL, 0, TimeOut) ) 

< 0 ) 

puts (”USB_control_msg error !”) ; // should never occur 
while (samples) 

{ 

if (samples > (EP2_FIFO_Size/2)) 
m = (EP2_FIFO_Size/2); 
else 

m = samples; 

if (usb_bulk_read (handle, 2, (char*) buf, m * 2, TimeOut) < (m * 2)) 
puts (”USB_bulk_read error!”); // should never occur 
b = buf; 
samples — = m; 

while (m ) 

{ 

unsigned int k; 
k = (unsigned int) *b++; 
k += (unsigned int) *b++ * 256; 

C++; 

if ( c == columns) 

{ 

c = 0; 

printf (”%u\n", k); 

} 

else 

printf (”%u ”, k) ; 

} 

} 

if (c) putchar(’\n’); 

} 

int 

main(int argc, char **argv) 

{ 

struct usb.device *dev; 
struct usb dev handle ^handle; 
int port = — 1; 
uintl6_t samples = 0; 
uintl6_t timeres = 0; 
int columns = 32; 
uint8_t status ; 
if (argc == 1) 

{ 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — SUDAP.c 


4 


usage (); 

exit (EXIT_FAILURE); 

} 

while (1) 

{ 

char * tail ; 
long int 1 ; 
int option Jndex = 0; 

int c; 

c = getopt Jong ( argc , argv, ”t:s:p:c:h”, long .options , &option Jndex) ; 
if (c == —1) break; 
switch (c) 

{ 

case ’h’: 
usage () ; 

exit ( EXIT JFAILURE) ; 
case ’p’: 
errno = 0; 

1 = strtol (optarg, &tail, 2); 

if ((errno == 0) && (*tail == ’\0’) && (1 >= 0) && (1 < 256)) 
port = ( int ) 1 ; 
else 
{ 

puts (’’Use a 8— bit binary number for setting port pins!”); 
exit (EXIT FAILURE); 

} 

break; 

case ’c’ : 
errno = 0; 

1 = strtol (optarg, &tail, 0); 

if ((errno == 0) && (*tail == ’\0’) && (1 > 0) && (1 <= 256)) 
columns = ( int ) 1 ; 
else 
{ 

puts (’’Use a positive integer <= 256 for number of columns!”); 
exit (EXITJFAILURE); 

} 

break; 

case ’ t ’ : 

if (( optarg [0]==' 1’) && (optarg[l ]==’m’) && (optarg[2]==V ) && (optarg[3]==0)) 
timeres = ADC lms; 

else if (( optarg [0]==’ 5 ’ ) && (optarg[l]==’0’) && (optarg[2]==’0’) && (optarg[3]=='u’) && (optarg[4]==’s’ ) ) 
&& (optarg[5]==0)) 
timeres = ADC500us; 

else if (( optarg [0]==’2’) && (optarg[l]==’0’) && (optarg[2]==’0’) && (optarg[3]=='u’) && (optarg[4]==’s’ ) i> 
&& (optarg [5 ]==0)) 
timeres = ADC200us; 

else if ((optarg[0]==’l’) && (optarg[l ]==’0’) && (optarg[2]==’0’) && (optarg[3]=='u’) && (optarg[4]==’s’ ) 2 
&& (optarg[5]==0)) 
timeres = ADClOOus; 

else if (( optarg [0]==’ 5 ’ ) && (optarg[l]==’0’) && (optarg[2]==’u’) && (optarg[3]=='s’ ) && (optarg[4]==0)) 
timeres = ADC50us; 

else if (( optarg [0]==’ 2’) && (optarg[l]==’0’) && (optarg[2]==’u’) && (optarg[3]=='s’ ) && (optarg[4]==0)) 
timeres = ADC20us; 
else 
{ 

puts ( trstr ) ; 

exit (EXIT JFAILURE); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — SUDAP.c 


5 


} 

break; 

case ’s’: 
errno = 0; 

1 = strtol (optarg, &tail, 0); 

if ((errno == 0) && (*tail == ’\0’) && (1 > 0) && (1 <= MaxSamples)) 
samples = ( uintl6_t ) 1 ; 
else 
{ 

puts (’’Use 0 < samples < 65536!”); 
exit (EXIT_FAILURE); 

} 

break; 

case ’?’ : 

exit (EXIT_FAILURE); 

break; 
default : 

abort () ; 

} 

} 

if (optind < argc) 

{ 

printf (’’Unsupported arguments: ”); 
while (optind < argc) 

printf (”%s ”, argv[ optind ++]); 
putchar ( ’ \n’ ) ; 
exit ( EXIT JFAILURE) ; 

} 

if ((! samples) && (timeres)) 

{ 

puts (’’Required option: — s or samples”); 

exit ( EXIT .FAILURE) ; 

} 

if ((samples) && (Itimeres)) 

{ 

puts (’’Required option : — t or timeres”); 

exit ( EXIT .FAILURE) ; 

} 

dev = UsbFindDevice(); 
if (dev == NULL) 

{ 

puts (’’USB device not found!”) ; 
exit (EXIT_FAILURE); 

} 

handle = usb_open(dev) ; 
if (handle == NULL) 

{ 

puts (’’USB device handle not found!”); 
exit (EXIT JFAILURE); 

} 

if ( usb claim interface (handle, 0) < 0) 

{ 

puts (’’Can not claim interface !”); 
usb_close (handle) ; 
exit ( EXIT ^FAILURE) ; 

} 

if (port != -1) 

{ 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — SUDAP.c 


status = ( uint8_t ) port; 

if ( usb_bulk_write (handle, 3, (char*) & status, 1, TimeOut) < 1) 
puts (’’Can not set digital port B!”); 

} 

if (samples && timeres) 

{ 

dodaq(handle, timeres, samples, columns); 
usb_bulk_read (handle, 1, (char*) &status, 1, TimeOut); 
switch ( status ) 

{ 

case (UsbDevStatusOK): 

break; 

case ( U sbDevS tatusD AQ B ufferOverflow) : 
putsC’DAQ Buffer Overflow!”); 

break; 

case ( U sbDevS tatusD AQ _TimerOverflow) : 
putsC’DAQ Timer Overflow!”); 

break; 

case (UsbDevStatusDAQ.ConversionNotFinished): 

puts (”DAQ Conversion was not finished when reading result!”); 

break; 
default : 

puts (’’Unknown error has occurred ! ”) ; 

} 

} 

usb .release -interface (handle, 0); 
usb .close (handle) ; 
exit (EXIT.SUCCESS); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — SUDD.c 


1 


// AT90USB/SUDD.C 

// Simple Usb Data— acquisition Device 

// S. Salewski 23— MAR— 2007 

// Start minicom with 8N1 configuration to see debug messages 
// The real work happens inside of interrupt —service— routines 

#include <avr/io.h> 

#include <avr/ interrupt .h> 

#include ” us art drv . h” 

#include ”usb_drv.h” 

static void blinkforever (void) ; 

int 

main(void) 

{ 

cli 0 ; 

CLKPR = (1<<7); 

CLKPR = 0; // clock prescaler == 0, so we have 16 MHz mpu frequency with our 16 MHz crystal 
USART Tnit(); 

USART_WriteString(”\r\n ) 

\r\n”); 

U sbDevLaunchDevice( false) ; 

// UsbDevWaitStartupFinislied(); // no reason to wait 
blinkforever () ; 

return 0; 

} 

// a LED connected to PORTAO will toggle to indicate the unused processing power 

static void 

blinkforever (void) 

{ _ 

int i = 0; // to suppress warning of avr—gcc 
DDRA |=(1«DDA0); 
while (1) 

{ 

while (i++); 

PORTA "= (1«PORTAO); 

} 

} 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — daq dev.h 


// AT90USB/daq_dev.h 

// Very simple data — acquisition device 

// S. Salewski 19— MAR— 2007 

#ifndef _DAQ_DEV_H_ 

#define _DAQ_DEV_H_ 

#include <stdint.h> 

// user commands 
#define UC_ADC_Read 1 

// sampling time 

#define ADC20us 1 

#define ADC50us 2 

#define ADClOOus 3 

#define ADC200us 4 

#define ADC500us 5 

#define ADC lms 6 

extern uint8_t DAQ_Result; 

void ProcessUserCommand(uint8_t command, uintl6_t pari , uintl6_t par2); 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — daq dev.c 


9 


// AT90USB/daq_dev.c 

// This file implements basic functionality of a simple data— acquisition device 
// S. Salewski 23— MAR— 2007 

#include <avr/io.h> 

#include <avr/ interrupt .h> 

#include ’’macros. h” 

#include ”usb drv.h” 

#include ’’usart debug . h” 

#include ” ringbuffer . h” 

#include ”daq_dev.h” 

#include ”com_def.h” 

uint8 t DAQ Result; 

static uintl6_t SamplesToRead; 

void 

ProcessUserCommand(uint8_t command, uintl6_t pari , uintl6_t par2) 

{ 

uint8 t prescalerADC; 
uint8_t prescalerTO ; 
uint8_t counterTOMax; 
switch (command) 

{ 

case UC ADC Read: 
switch (( uint8_t ) pari) 

{ 

case ADC20us: 

prescalerADC = ((1<<ADPS2)); // mpu clock / 16 
prescalerTO = (1«CS01); // == 8 
counterTOMax = 40; 

break; 

case ADC50us: 

prescalerADC = ((1«ADPS2) | (1«ADPS0)); //mpu clock 732 
prescalerTO = (1«CS01); // == 8 
counterTOMax = 100; 

break; 

case ADClOOus: 

prescalerADC = ((1«ADPS2) | (1«ADPS1)); //mpu clock/ 64 
prescalerTO = (1«CS01); // == 8 
counterTOMax = 200; 

break; 

case ADC200us: 

prescalerADC = ((1«ADPS2) | (1«ADPS1) | (1«ADPS0)); //mpu clock/ 128 
prescalerTO = ((1«CS01) | (l«CS00));//== 64 
counterTOMax = 50; // 400 / 8 

break; 

case ADC500us: 

prescalerADC = ((1«ADPS2) | (1«ADPS1) | (1«ADPS0)); //mpu clock/ 128 
prescalerTO = ((1«CS01) | (l«CS00));//== 64 
counterTOMax =125; 

break; 

case ADC lms: 

prescalerADC = ((1«ADPS2) | (1«ADPS1) | (1«ADPS0)); //mpu clock/ 128 
prescalerTO = ((1«CS01) | (l«CS00));//== 64 
counterTOMax = 250; 

break; 
default : 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — daq dev.c 


10 


Debugf’DaqDev: Unsupported sampling rate!\r\n”); 

return; 

} 

ADMUX = (1<<REFS1) | (1<<REFS0); // ADCO single ended input, internal 2.56V reference with external ) 
capacitor on AREF pin 

ADCS RA = prescaler ADC | (1<<ADEN) | (1<<ADSC );// set prescaler, enable ADC and start conversion 

TCCROA = (1 <<WGM01 ); //set timer registers: clear on compare match 

TCCROB = prescalerTO; // set prescaler 

OCROA = counterTOMax; // set output compare register 

SamplesToRead = par2; 

RB_Init(); 

DAQ .Result = UsbDevStatusOK; 

prescalerTO = 20; // do a few conversions to warm up 

while ( prescalerTO > 0) 

{ 

while (ADCSRA & (1<<ADSC)); 

ADCSRA l=(l«ADSC); 

1 

TCNTO = counterTOMax + 1 \// set start value behind compare match we need some time to finish this USB— h 

ISR 

TIMSKO = (1<<OCIEOA); // activate compare match interrupt 

TIFRO j= (1<<OCFOA); //clear compare match flag we will wait for next compare match 

break; 
default : 

Debugf’DaqDev: Unsupported user command !\r\n”); 

} 

} 

ISR(TIMERO_COMPA_vect) 

{ 

uintl6_t w; 

// static uint8_t cnt; 

if (ADCSRA & (1<<ADSC))// conversion finished? 

DAQ .Result = UsbDevStatusDAQ.ConversionNotFinished; 
w = ADCW; 

ADCSRA [= (1<<ADSC); //start next conversion as soon as possible 
if (SamplesToRead > 0) 

{ 

if (RBJsFullO) 

{ 

DAQ .Result = IJsbDcvStatusDAQ Bu fferOverflow; 

} 

else 

{ 

if (DAQ .Result == UsbDevStatusOK) 

RB.Write(w); 

else 

RB.Write(OxFFFF); 

SamplesToRead ; 

} 

} 

UsbDevSelectEndpoint(2); 
if (UsbDevTransmitterReadyO) 

{ 

uint8_t i; 

if (( SamplesToRead == 0) && (RB Entries == 0)) 

{ 


TIMSKO = 0; 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — daq dev.c 


11 


i = 64; 

} 

else 

i = UsbDevGetByteCountLow(); 
switch (i) 

{ 

default : 

w = RB_Read(); 

//w = cut; dump counter to FIFO for testing 
UsbDevWriteByte(LSB(w)); 

UsbDevWriteByte(MSB(w)); 
case 62; 

if (RB Entries > 0) 

{ 

w = RB_Read(); 

UsbDevWriteByte(LSB(w)); 

UsbDevWriteByte(MSB(w)); 

} 

break; 

case 64: 

U sbDevClearTransmitterReady () ; 

UsbDevSendInData(); 

} 

} 

if (TIFRO &(1<<OCFOA ))// is interrupt flag already set again ? 

{ 

DAQ .Result = UsbDevStatusDAQ.TimerOverflow; 

} 

// cnt = TCNTO; if there are too many instructions in this ISR , we may get timer— counter overflow 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.h 


12 


// AT90USB/usbjapi.h 

// Usb_api contains constants and functions which are project specific . 

// You may modify this file ( and usbmpi . c ) for your application . 

// S. Salewski 21— MAR— 2007 

// The current version of this file is adapted to a simple Data— Acquisition— Device. 

// Our DAQ device uses endpoints 0, 1, 2 and 3. 

// Commands are send to our device by vendor— requests using endpoint 0. 

// Endpoint 1 is configured as Bulk— IN— endpoint and used to transfer status information 

// from device to the host. Whenever the host tries to read data from empty endpoint 1, 

// a NAK— interrupt is generated, causing firmware to write status information to this ep. 

// Endpoint 2 is configured an Bulk— IN— Endpoint and used to send DAQ— data to the host . 

// DAQ operation starts when host sends a vendor request . Controlled by a periodically 
// activated timer interrupt, daq data is put to the FIFO of endpoint 2. 

// Endpoint 3 is configured as Bulk— OUT— Endpoint and used to send a single byte from the 

// host to the device . This byte sets the pins of digital port B of our AT90USB. 

#ifndef _USB_API_H_ 

#define USB API H 

#include <stdint.h> 

#include <stdbool.h> 

#include ”usb_spec . h” 

// USB Vendor ID is assigned by www.usb.org 

// Vendor— and product id is defined in coniudefh, because we need it in our host program too! 

//# define MyUSB _VendorID 0x03eb // Atmel code 

//# define MyUSB _Pro due tID 0x0001 

#define MyUSB_DeviceBCD 0x0001 

// modify these values for your application ! 

#define USB_NumConfigurations 1 // 1 or more 

#define USB_MaxConfigurations 4 // our device can have multiple configuration with different number of j 

interfaces 

#define USB_MaxInterfaces 4 // each interface of a configuration has a number of endpoints 

#define USB MaxStringDescriptorLength 22 

// An interface can have multiple alternate settings , but number of endpoints of this interface is fix . 

// To ensure that reallocation of endpoints with new FIFO size of one interface will not interfere with other D 
interfaces , 

// only the interface with highest number should use multiple alternate settings with different endpoint FIFO D 
sizes 

#define EPO_FIFO_Size 8 // 8, 16, 32 or 64 byte 
// FIFO size of EP1 upto EP6 is defined in conudef.h 

// These macros are called if an endpoint interrupt is triggered ( if enabled ) 

// and may be used to fill ( IN— Endpoint) or read ( OUT— Endpoint) the FIFO. 

#define UsbDevEP lint Action!) UsbDevFillEPlFIFO() //send status to host 
#define UsbDevEP2Int Action!) // EP2, used for DAQ data, is filled by timer— ISR 
#define UsbDevEP3IntAction!) UsbDevReadEP3FIFO() // read data byte for digital port B 
#define UsbDevEP4Int Action!) 

#define UsbDevEP5Int Action!) 

#define UsbDevEP6Int Action!) 

// These functions provides the host with device specific USB descriptors during the enumeration process 
void UsbGetDeviccDcscriptor!USB DeviceDescriptor *d); 

bool UsbGetConfigurationDescriptor(USB_ConfigurationDescriptor *c, uint8_t conflndex); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.h 


13 


bool UsbGetlnterfaceDescriptor ( USB JnterfaceDescriptor *i, uint8_t conflndex, uint8_t intlndex , uint8_t altSetting ) 

); 

bool UsbGetEndpointDescriptor(USB_EndpointDescriptor *e, uint8 t conflndex, uint8 t intlndex, uint8 t altSetting , ) 
uint8 t endlndex); 

void UsbGetStringDescriptorfchar s [], uint8_t index); 

// These functions allocate FIFO memory and setup all used endpoints 
bool UsbDevSetConfiguration( uint8_t c); 

bool UsbDevSetInterface( uint8_t conf, uint8 t inf, uint8 t as); 

// User defined function , used in our application to start data acquisition 
void UsbDevProcessVendorRequest(USB_DeviceRequest *req); 

// These functions are called from within ISR and fill or read FIFO 
void UsbDevFillEPlFIFO(void); 
void UsbDevReadEP3FIFO(void); 

#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


14 


// AT90USB/usb_api.c 

// This file contains functions which are project specific and should be modified 
// to customize the USB— driver. 

// S. Salewski 21— MAR— 2007 

#include <stdint.h> 

#include <stdbool.h> 

#include ” defines . h” 

#include ”com_def.h” 

#include ”usart_debug .h” 

#include ”usb_spec . h” 

#include ”usb_drv.h” 

#include ”daq_dev.h” // ProcessU serCommand(), DAQJlesult 
#include ”usb api . h” 

#include ” usb .requests .h” 

// The behavior of USB devices is specified by different descriptors defined by www.usb.org. 

// In the simplest case a device has one Device— Descriptor, one Configuration —Descriptor, 

// one Interface — Descriptor and a few Endpoint— Descriptors . For more advanced devices 

// there may exist multiple Configuration — and Interface — Descriptors , each with multiple Endpoint— 

// Descriptors . We may store all these structures in arrays or linked lists , which takes 
// much storage in RAM and is not easy to handle. 

// My currently preferred solution to handle the descriptors is to generate them on the fly if 
// they are requested by the host. This is simple and consumes very few RAM. 

// If a descriptor is needed during enumeration process, one of the functions 

// of this file is called to initialize the structure according to specific parameters, 

// and then the structure is passed to the USB host. The user has to modify the constants 

// and the functions of this file for a specific device . For simple devices this is very 

// easy for devices with multiple configurations / interfaces it is more demanding. 

// You may add constants , variables or functions to this file, i.e. to remember the state of an ep. 

// First let us write down the parameters of the endpoints which we want to use. 

// We have to remember these facts during enumeration, when filling or reading the FIFO, 

// and for the communication of the host with our device . 

// The current version of this file is adapted to a simple Data— Acquisition— Device. 

// Our DAQ device has only one configuration with one single interface . 

// Numbers of configurations , interfaces , alternate settings and endpoints start with 0, 

// configuration 0 indicates unconfigured (addressed) state, and endpoint 0 is the control endpoint. 

// Our device use control endpoint 0 and data endpoints 1, 2 and 3 of interface 0. 

// Commands are send to our device by vendor— requests using endpoint 0. 

// Endpoint 1 is configured as Bulk— IN— endpoint and used to transfer status information 

// from device to the host. Whenever the host tries to read data from empty endpoint 1, 

// a NAK— interrupt is generated, causing firmware to write status information to this ep. 

// Endpoint 2 is configured as Bulk— IN— Endpoint and used to send DAQ— data to the host . 

// DAQ operation starts when host sends a vendor request . Controlled by a periodically 
// activated timer interrupt , daq data is put to the FIFO of endpoint 2. 

// Endpoint 3 is configured as Bulk— OUT— Endpoint and used to send a single byte from the 
// host to the device . This byte sets the pins of digital port B of our AT90USB. 

// To keep it simple: Only one configuration, only one interface. 

// EP1: Bulk— IN, 8 bytes FIFO, one bank. 

// EP2: Bulk— IN, 64 bytes FIFO, dual bank. 

// EP3: Bulk— OUT, 8 bytes FIFO, one bank. 

const uint8 t USBJnterfaces[USBJVlaxConfigurations] = {1, 0, 0, 0}; // number of interfaces in each configuration 
const uint8 t USB JMaxPower_2mA[USB JVIaxConfigurations] = {50, 0, 0, 0}; //power consumption of each configuration 2 
in 2mA units 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


15 


const uint8_t USB_AltSettings[USB_MaxConfigurations][USB_MaxInterfaces] = 

{{1, 0, 0, 0}, // number of alt . settings of interfaces of first configuration 

{0, 0, 0, 0}, // number of alt . settings of interfaces of second configuration 

{ 0 , 0 , 0 , 0 }, 

{ 0 , 0 , 0 , 0 }}; 

const uint8_t USB_Endpoints[USB_MaxConfigurations][USB_MaxInterfaces] = 

{{3, 0, 0, 0}, // number of endpoints of interfaces of first configuration 

{0, 0, 0, 0}, // number of endpoints of interfaces of second configuration 

{ 0 , 0 , 0 , 0 }, 

{0, 0, 0, 0}}; 

static void UsbDevDisableAndFreeEndpoint(uint8_t i) ; 
static void UsbDevSetUnconfiguredState(void); 

void 

U sbGetDeviceDescriptor(USB _DeviceDescriptor *d) 

{ 

d— >bLength = USB_DeviceDescriptorLength; 
d— >bDescriptorType = US B DeviceDescriptorType; 
d - >bcdUSB = USB _Spec 1_1 ; 
d— >bDeviceClass = UsbNoDeviceClass; 
d— >bDeviceSubClass = UsbNoDeviceSubClass; 
d— >bDeviceProtocoll = UsbNoDeviceProtokoll; 
d— >bMaxPacketSizeO = EP0 FIFO Size; 
d— >idVendor = MyUSBJVendorlD; 
d— >idProduct = MyUSB_ProductID; 
d— >bcdDevice = MyUSB_DeviceBCD; 
d— >iManufacturer = USB_ManufacturerStringIndex; 
d— >iProduct = USB_ProductStringIndex; 
d— >iSerialNumber = USB S erialNumber S tringlndex ; 
d— >bNumConfigurations = USB_NumConfigurations; 

} 

bool 

UsbGetConfigurationDescriptor(USB_ConfigurationDescriptor *c, uint8 t conflndex) 

{ 

uint8_t i; 

if (conflndex >= USB_NumConfigurations) return false; 
c— >bLength = USB_ConfigurationDescriptorLength; 
c— >bDescriptorType = USB_ConfigurationDescriptorType; 
c— >wTotalLength = USB_ConfigurationDescriptorLength; 
i = USBJnterfaces [conflndex]; 
c — >bNumInterfaces = i; 
while ( i — >0) 

c— >wTotalLength += (USB JnterfaceDescriptorLength+USB_EndpointDescriptorLength*USB_Endpoints[confIndex][i])* ) 
USB A]tSettings[confTndex][i]; 

c — >bConfiguration Value = UsbConfigurationValue(conflndex) ; 

c— >iConfiguration = UsbNoDescriptionString; //no textual configuration description 
c— >bmAttributes = UsbConfDesAttrBusPowered; // bus— powered, no remote wakeup 
c — >MaxPower = US B_MaxPower_2m A [conflndex]; 
return true ; 

} 

bool 

UsbGetlnterfaceDescriptor ( USBJnterfaceDescriptor *i, uint8_t conflndex, uint8_t intlndex , uint8_t altSetting ) 

{ 

if (( conflndex >=USB NumConfigurations)||(intIndex>=USB Interfaces [cont'I ndex])| ( altSetting ;>=USB AltSettings[ ) 
conflndex] [intlndex ]) ) return false; 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


16 


i — >bLength = USBJnterfaceDescriptorLength; 
i — >bDescriptorType = USB JnterfaceDescriptorType; 
i — >bInterfaceNumber = intlndex; 
i — >bAlternateSetting = altSetting ; 

i — >bNumEndpoints = USB_Endpoints[confIndex][intIndex]; 
i — >bInterfaceClass = UsbNoInterfaceClass; 
i — >bInterfaceSubClass = UsbNoInterfaceSubClass; 
i — >bInterfaceProtocol = UsbNoInterfaceProtokoll ; 

i — >ilnterface = UsbNoDescriptionString; // no textual interface description 
return true ; 

} 

// Not used for EPO, so 1 <= endlndex <= USB NumEndpoints <= 6 
bool 

UsbGetEndpointDescriptor(USB JEndpointDescriptor *e, uint8_t conflndex, uint8_t intlndex, uint8_t altSetting , ) 
uint8_t endlndex) 

{ 

if ((conflndex>=USB_NumConfigurations)||(intIndex>=USB_Interfaces[confIndex])||( altSetting >=USB_AltSettings[ ) 
conflndex] [intlndex ]) || 

(endIndex>USBJEndpoints[conf!ndex] [intlndex])) return false ; 

// components identical for all of our endpoints 
e— >bLength = USB_EndpointDescriptorLength; 
e— >bDescriptorType = USB_EndpointDescriptorType; 
e— >bmAttributes = USB BulkTransfer; 
e— >blnterval = 0; // bulk endpoint, no polling 
// components which differ 

switch (endlndex) // only endpoints for interface 0 in our application 

{ 

case 1: 

e— >bEndpoint Address = UsblnEndpointAdress(l); 
e— >wMaxPacketSize = EPl_FIFO_Size; 

break; 

case 2: 

e— >bEndpoint Address = UsblnEndpointAdress(2); 
e— >wMaxPacketSize = EP2 FIFO Size; 

break; 
case 3; 

e— >bEndpoint Address = UsbOutEndpointAdress(3); 
e— >wMaxPacketSize = EP3_FIFO_Size; 

break; 

} 

return true ; 

} 

void 

UsbGetStringDescriptor(char s [], uint8 t index) 

{ 

uint8_t i; 

#if (USB_MaxStringDescriptorLength < 18) 

#error USB_MaxStringDescriptorLength too small! 

#endif 

i = USBJdaxStringDescriptorLength; 
while (i — )*s++=’\0’; 
s — = USB JVlaxStringDescriptorLength; 
s [1] = USB_StringDescriptorType; 
switch (index) 

{ 

case USB_LanguageDescriptorIndex: // == 0 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


17 


s [0] = 4; 

s [2] = 9; // two byte language code, only support for English 
s [3] = 4; 

break; 

case USB _ManufacturerStringIndex: 
s [2] = ’S’; 
s [4] = ’A’; 
s [6] = ’L’; 
s [8] = ’E’; 
s [10] = ’W’; 
s [12] = ’S’; 
s [14] = ’K’; 
s [16] = ’I’; 

s [0] = 18; // length of descriptor 

break; 

case USB_ProductStringIndex: 
s [2] = ’A’; 
s[4] = ’T’; 
s [6] = ’9’; 
s [8] = ’O’; 
s [10] = ’U’; 
s [12] = ’S’; 
s [14] = ’B’; 
s [0] = 16; 
break; 

case US B _S erialN umberS tringlndex : 
s [2] = ’O’; 
s [4] = ’O’; 
s[6] = ’ 1’ ; 
s [0] = 8; 
break; 
default : 
s[2] = ’?’ ; 
s [0] = 4; 

} 

} 

static void 

U sbDevDisable AndFreeEndpointl uint8 _t i ) 

{ 

UsbDevSelectEndpoint(i) ; 

U sbDevDisableEndpoint() ; 

UsbDevClearEndpointAllocBit(); 

} 

static void 

UsbDevSetUnconfiguredState(void) 

{ 

uint8_t i; 

UsbDevConfValue = UsbUnconfiguredState; 
i = UsbNumEndpointsAT90USB; 

while ( i > 0) // free all endpoints but EP0 

U sbDevDisable AndFreeEndpoint(i) ; 

UsbAllocatedEPs = 1; 

} 

// A device can have multiple configurations . In the simplest case configurations may differ only in power D 
consumption. 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


18 


// But configurations can be totally different ( differ in number of interfaces, endpoints, ... 
bool 

UsbDevSetConfiguration( uint8 t c) 

{ 

uint8_t i; 
switch (c) 

{ 

case 0: // go back to unconfigured ( addressed ) state 
U sbDevSetUnconfiguredState() ; 
return true ; 
break; 

case 1: // set configuration 1 
if (UsbDevConfValue != c) 

{ 

i = USB_MaxInterfaces; 

while (i >0) AltSettingOflnterface [i] = UsblnterfaceUnconfigured ; 

} 

for (i = 0; i < USB_Interfaces[c— 1]; i++) 

{ 

if (! UsbDevSetInterface(c, i , 0)) 

{ 

UsbDevSetUnconfiguredState() ; 
return false ; 

} 

} 

UsbDevConfValue = c; 
return true ; 
break; 
default : 

Debug(”UsbDevSetConfiguration(): configuration does not exist !\r\n”); 
return false ; 

} 

} 

// Multiple interfaces can exist at the same time! These interfaces have to use different endpoints. 

// For example interface 1 can use epl and ep2, and interface 2 can use some of the other endpoints ( ep3, ep4, ep5 D 
, ep6). 

// A special problem occurs from FIFO memory management of AT90USB: Memory for FIFO has to be allocated in growing D 
order. 

// If we use multiple interfaces with multiple alternate settings there may occur memory conflicts concerning D 
FIFO memory: 

// If we allocate memory for endpoint i, there may be an overlap with FIFO of endpoint i + 1 or memory of endpoint i D 
+1 may slide . 

// This is a result of internal design of AT90USB, see section 21.7 in datasheet. 

// But from USB design interfaces should be independent , changes of interface i should not affect interface j#i 
// To prevent conflicts , following strategy is useful : 

// Use endpoints 1 to n for interface 1, endpoints n+1 to mfor interface 2, and endpoints m+1, m+2 ... for D 
interface 3. 

// Give only more than one alternate setting to the interface with the highest number. So changes of alternate D 
setting 

// with new FIFO sizes can not disturb other interfaces . 

// If you really need more than one interface with different alternate settings ( endpoint FIFO sizes ) you may try D 
to 

// insert unused dummy endpoints to prevent memory slides or overlaps . Or use different configurations or force D 
reallocation of all endpoints . 

// Our application uses only interface 0 with endpoints epl, ep2, ep3. But the code is designed to support more D 
interfaces . 


bool 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


19 


UsbDevSetInterface( uint8_t conf, uint8_t inf, uint8_t as) 

{ 

uint8 _t i; 

if (conf == UsbUnconfiguredState) // each interface should be bound to a configuration 

{ 

Debug(”UsbDevSetInterface(): called from unconfigured (addressed) state !\r\n”); 
return false ; 

} 

if ((inf >= USB -Interfaces [conf ]) || (as >= USB A ItSetti ngs [conf | [ inf ])) 

{ 

Debug(”UsbDevSetInterface(): interface not supported !\r\n”); 
return false ; 

} 

if ((as > 0) && (inf != (USB -Interfaces [conf] — 1))) 

{ 

Debug(”UsbDevSetInterface(): Multiple interfaces with more than one alternate setting => FIFO memory conflicts ) 
may occur!\r\n”) ; 
return false ; 

} 

if ( AltSettingOflnterface | inf ] == as) // no changes, reset toggle bits of endpoints of this interface 

{ 

if (conf == 0) 

{ _ 

if (inf == 0) // first interface of first configuration 

{ 

for (i = 1; i < 4; i++) // reset toggle bit of all endpoints of this interface ; an endpoint reset may be 2 
necessary too 

{ 

UsbDevSelectEndpoint(i) ; 

UsbDevResetEndpoint(i); 

UsbDevResetDataToggleBit(); 

} 

} 

else if (inf == 1) // second interface of first configuration 

{ 

// reset endpoints of second interface 

} 

} 

else if (conf == 2) // similar operations 

{ 

} 

return true ; 

} 

if (conf == 0) 

{ _ 

if ( inf == 0) // first allocation or reallocation with new alternate setting 

{ 

UsbDevDisableAndFreeEndpoint(3); 

UsbDevDisableAndFreeEndpoint(2); 

U sbDevDisable AndFreeEndpoint( 1 ); 

UsbAllocatedEPs = 1; 

AltSettingOflnterface [0] = UsblnterfaceUnconfigured ; 
if (as == 0) // use alternate setting 0 
{ 

if (UsbDevEP_Setup(l, UsbEP.TypeBulk, EPl_FIFO_Size, 1, UsbEP_DirIn)) 

{ 

Debug(”H! Successful set up EPl!\r\n”); 

//UsbDevSelectEndpoint(l); this ep is already selected by UsbDevEPSetupO 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


20 


UsbDevEnableNAKJN_Int(); // trigger interrupt when host got a NAK as a result of a read request 

} 

else 

{ 

Debug(”!!! Setup of EP1 failed !\r\n”); // should not occur ;—) 
return false ; 

} 

if (UsbDevEP_Setup(2, UsbEP TypeBulk, EP2 FIFO Size, 2, UsbEP Dirln)) 

{ 

Debug(”H! Successful set up EP2!\r\n”); 

} 

else 

{ 

Debug(”!!! Setup of EP2 failed !\r\n”); 
return false ; 

} 

if (UsbDevEP_Setup(3, UsbEP.TypeBulk, EP3_FIFO_Size, 1, UsbEP_DirOut)) 

{ 

Debug(”!!! Successful set up EP3!\r\n”); 

UsbDcvEnableReceivcdOUT DA'I’A Inti);// trimmer interrupt when out data is available 

} 

else 

{ 

Debug(”H! Setup of EP3 failed !\r\n”); 
return false ; 

} 

} 

else if (as == 1) // alternate setting 1 

{ 

// set up same endpoints with different parameters (FIFO— size) 

} 

AltSettingOflnterface [0] = as; 

UsbStartupFinished = 1; 
return true ; 

} 

else if ( inf == 1) // setup interface 1 

{ 

} 

} 

else if (conf == 1) // similar setup if configuration 2 with other interfaces is selected 

{ 

} 

return false ; // dummy to suppress compiler warning 

} 

void 

UsbDevProcessVendorRequest(USB_DeviceRequest *req) 

{ 

ProcessUserCommand(req— >bRequest, req ->wValue, req— >wlndex); 

} 

// This function is called whenever host tries to read data from epl 
// We send a status byte which indicates success of DAQ operation 

void 

U sbDevFillEP 1 FIFO(void) 

{ 

if UsbDevTransmitterReadyO 

{ 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb api.c 


21 


U sbDevClearTransmitterReady () ; 
UsbDevClearNAK_ResponseInBit(); 
U sbDevW riteByte(D AQ Result) ; 

U sbDevS endInData() ; 

} 


// This function is called whenever OUT FIFO has data for us 

void 

UsbDevReadEP3FIFO(void) 

{ 

if (UsbDevHasReceivedOUT_Data()) 

{ 

U sbDe vC learHa sReeeivedOUT D at a( ) ; 
if (UsbDevReadAllowedO) 

{ 

DDRB = OxFF; 

PORTB = UsbDevReadByte(); 

UsbDevClearFifoControllBit() ; // mavbe we should use an alias for this 

} 

} 

} 


macro 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.!! 


22 


// AT90USB/usb _requests. h 
// Handling of USB (standard) requests 
// S. Salewski 22— MAR— 2007 


#ifndef JJSB .REQUESTS _H_ 

#define _USB .REQUESTS _H_ 

#include <stdint.h> 

#include <stdbool.h> 

#include ”usb_spec . h” 

#include ”usb_api.h” // USB_MaxInterfaces 


// USB— Standard— Device— Requests, H.J. Kelm USB 2.0, section 2.9.1, page 108 

#define USB StdDcvRcqGET STATUS 0x00 

#define USB.StdDcvRcqCLEAR J’EA'I URE 0x01 

#define USB_StdDevReqSET_FEATURE 0x03 

#define USB_StdDevReqSET_ADDRESS 0x05 

#define USB_StdDevReqGET_DESCRIPTOR 0x06 

#define USB StdDevReqSET DESCRIPTOR 0x07 

#define USB StdDcvRcqGET CONFIGURATION 0x08 

#define USB_StdDevReqSET_CONFIGURATION 0x09 

#define USB .StdDevReqGETJNTER FACE OxOA 

#define USB_StdDevReqSET_INTERFACE OxOB 

#define USB Std DevReqS YNC H FRAME OxOC 


// Meaning of bmRequestType, H.J. Kelm 
#define UsblsDataHostToDevice(bm) 
#define UsblsDataDeviceToHost(bm) 


#define UsblsStandardRequest(bm) 
#define UsblsClassRequest(bm) 

#define UsbIsVendorRequest(bm) 

#define UsblsRequestForDevice(bm) 
#define UsblsRequestForlnterface (bm) 
#define U sblsRequestForEndpoint(bm) 
#define UsblsRequestForOther(bm) 


USB 2.0, section 2.9.1, page 107 
(!(bm&(l«7))) 

(bm & (1<<7)) 

(bm & (3«5)) == 0 
(bm&(3«5)) == (1«5) 
(bm&(3«5)) == (1«6) 

(bm & (31) == 0 
(bm & (31) == 1 
(bm & (31) == 2 
(bm & (31) == 3 


extern uint8_t UsbDevConfValue; // current configuration of our device; 0 is unconfigured state 

extern uint8 t AltSettingOflnterface [USBJMaxInterfaces]; // current alternate setting of active interfaces 


void UsbProcessSetupRequest(void); 


//void UsbDevWriteDescriptor(void *d, uint8j * written , uint8_t requested); 
//void UsbDevReadBytesN(void *c, uint8_t n); 

// void WaitZLP JFromHost(void); 

// void UsbProcessSetupRequest(void); 

//bool UsbSendDescriptorsf uint8j cdi, uint8_t * written , uint8j requested); 
//bool UsbDevSetInterface( uint8j inf, uint8_t as); 

//bool UsbDevSetConfigurationf uint8j c); 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


23 


// AT90USB/usb _requests. c 
// Handling of USB (standard) requests 
// S. Salewski 22— MAR— 2007 

#include <stdint.h> 

#include ’’macros. h” 

#include ”usb_spec.h” 

#include ”usb drv.h” 

#include ”usart debug . h” 

#include ”usb_api.h” // EPO-FIFO-Size and USBJVumlnterfaces 
#include ” usb .requests .h” 

uint8 t UsbDevConfValue = UsbUnconfiguredState; 

uint8 t AltSettingOflnterface [4] = { UsblnterfaceUnconfigured , UsblnterfaceUnconfigured, UsblnterfaceUnconfigured , ) 
UsblnterfaceUnconfigured }; 
uint8_t RemoteWakeup Active = 0; 

static void UsbDevWriteDescriptorlvoid *d, uint8_t * written, uint8_t requested); 
static void UsbDevReadBytesN(void *c, uint8_t n); 

static bool UsbSendDescriptors( uint8_t cdi, uint8 t * written, uint8 t requested); 

// Send descriptor to host, but don’t send more total bytes than requested. 

// Stop if there is a ZLP ( abort ) from host or if all bytes are send, else 
// fill FIFO and send FIFO if FIFO is full . 

static void 

UsbDevWriteDescriptor(void *d, uint8_t * written, uint8_t requested) 

{ 

uint8_t 1; 

1 = requested — * written; // we may send l bytes more 

if (1 > *( uint8 _t *)d) 1 = *( uint8_t *)d; // clip to size of this descriptor 

while (1 — ) 

{ 

if UsbDevHasReceivedOUT_Data() // ZLP from host abort 

{ 

* written = requested; // prevent further writes 

return; 

} 

UsbDevWriteByte(*(uint8_t*)d++); // put byte to FIFO 
if (((* written +=1) % EPO .FIFO .Size) == 0) // if FIFO full 
{ 

UsbDevSendControlIn(); // send FIFO 

//while (!( UsbDevHasReceivedOUTJData() || UsbDevTransmitterReadyO)); 

while (!(UEINTX&((l«RXOUTI) | (1«TXINI)))); //the same saves a few bytes 

} 

} 

} 

// Read n bytes from FIFO; FIFO should contain exactly n bytes 
// Limited to n < 256 

static void 

UsbDevReadBytesN(void *c, uint8 t n) 

{ 

Assert (UsbDevGetByteCountLow() == n); 
while (n ) *(uint8_t*)c++ = UsbDevReadByte(); 

} 


static void 

WaitZLP_FromHost(void) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


24 


{ 

while (! UsbDevHasReceivedOUT_Data()); 

UsbDcvCIearHasReceivetlOUT Data(); 

} 

void 

UsbProcessSetupRequest(void) 

{ 

USB DeviceRequest req; 

union // we can use the same piece of memory for these descriptors 

{ 

USB_DeviceDescriptor devDes; 

USB Con figuration Descriptor confDes; 
char strDes [USB MaxStriiigDcscriptorLength |; 

} u; 

uint8_t b; 

UsbDevSelectEndpoint(O); 

UsbDevReadBytesN(&req, 8); 

// Caution: We have to delay the AcknowledgeSETUPf) if request is a 3 stage — transfer with out data 
// because host may send out data immediately after our acknowledge and may not see our stall request! 
if (!( req.bRequest == USB_StdDevReqSET_DESCRIPTOR)) /// 3 stage— transfer with out data 
UsbDevAcknowledgeSETUP(); 

UsbDumpSetupRequest(&req); 
if (UsblsVendorRequest(req.bmRequestType)) 

{ 

ReqDebugC’Received UsbVendorRequest”); 

UsbDevProcessVendorRequest(&req); 

U sbDevS electEndpoint( 0) ; 

UsbDevSendControlInO; // send ZLP 

} 

else if (UsbIsStandardRequest(req . bmRequestType)) 

{ 

ReqDebugC’Received UsbStandardRequest”); 
switch (req.bRequest) 

{ 

case USB StdDcvRcqGET STATUS: // 3 stages with 2 byte IN— data not tested yet 

ReqDebug(”USB_StdDevReqGET_STATUS”); 

Assert ( req . w Value == 0) ; 

Assert ( req . wLength == 2); 
switch ( req . bmRequestType) 

< 

case 128: // device: Self —Power— Bit, Remote— Wakeup— Bit set? 

Assert ( req . wlndex == 0) ; 

if (UsbDevConfValue == UsbUnconfiguredState) 

{ 

ReqDebugC’Error: USB.StdDevReqGET .STATUS device in unconfigured state!”); 
UsbDevRequestStallHandshake(); 

return; 

} 

UsbGetConfigurationDescriptorl&u.confDes, UsbDevConfValue); 

if (u. confDes. bmAttributes &(l<<6))b=l; else b = 0; // self powered? 

if ((u. confDes. bmAttributes & (1<<5)) && (RemoteWakeupActive)) b |= (1 << 1); 

UsbDevWriteByte(b); 

break; 

case 129: // interface : Always return 0 

if (UsbDevConfValue == UsbUnconfiguredState) 

{ 

ReqDebugC’Error: USB_StdDevReqGET .STATUS interface in unconfigured state!”); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


25 


UsbDevRequestStallHandshake(); 

return; 

} 

// Assert (req.wlndex < USB Jnterfaces[U sbDevConjValue]); 

UsbDevWriteByte(O); 

break; 

case 130: // endpoint: is this endpoint stalled? 

Assert ((MSB(req.wIndex) == 0)); 
b = LSB(req.wIndex) & 127; // endpoint number 
if (b >= U sbNumEndpointsAT90U SB) 

{ 

ReqDebugC’Error: USB_StdDevReqGET .STATUS endpoint does not exist!”); 
UsbDevRequestStallHandshake(); 

return; 

} 

if ((UsbDevConfValue == UsbUnconfiguredState) && (b > 0)) 

{ 

ReqDebugC’Error: USB.StdDevReqGET .STATUS for ep > 0 in unconfigured state!”); 
UsbDevRequestStallHandshake(); 

return; 

} 

UsbDevSelectEndpoint(b); 

if ( UsbDevIsEndpointStalled () ) // stalled bit is marked write— only in datasheet do we need a ) 

separate state variable ? 

UsbDev WriteBy tel 1 ) ; 
else 

U sbDev WriteBy te(0) ; 

UsbDevSelectEndpoint(O); 

break; 
default : 

ReqDebugC’Error; USB.StdDevReqGET.STATUS !”); 

UsbDevRequestStallHandshakel); 

return; 

} 

UsbDevWriteByte(O); 

UsbDevSendControlIn(); 

Wai tZLP .From Host() ; 

break; 

case USB.StdDevReqCLEARJFEATURE; // 2 stages (no data— stage) not tested yet 

case USB_StdDevReqSET_FEATURE: 

ReqDebug(”USB_StdDevReqCLEAR/SETJFEATURE”); 

Assert ( req . wLength == 0); 
switch 1 req . bmRequestType) 

{ 

case 0: // device 
Assert 1 req . wlndex == 0) ; 

if ( req. w Value != 1) // Feature selector != DEVICE .REMOTE J/VAKEUP 

{ 

ReqDebugC’Error: USB_StdDevReqSET/CLEAR_FEATURE wrong feature selector for device!”); 
UsbDevRequestStallHandshakel); 

return; 

} 

if (req .bRequest == USB_StdDevReqCLEAR_FEATURE) 

{ 

RemoteWakeupActive = 0; 

} 

else 

{ 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


26 


UsbGetConfigurationDescriptor(&u.confDes, UsbDevConfValue); 

if (!(u.confDes.bmAttributes &(1<<5)))// Remote— Wakeup support set in configuration descriptor? 

{ 

ReqDebugC’Error: USB StdDcvRcqSET FEATURE, Remote— Wakeup not supported!”); 
UsbDevRequestStallHandshake(); 

return; 

I 

RemoteWakeupActive = 1 ; // here we only set a flag of course this is not enough to reactivate the 

sleeping bus 

} 

break; 

case 1: // interface nothing to do. Should we request a stall handshake? 

ReqDebugC’Error: USB StdDevReqSET/CLEAR FEATURE with receiver == interface!”); 
UsbDevRequestStallHandshake(); 

return; 

break; 

case 2: // endpoint 
Assert (MSB(req.wIndex) == 0); 

if (req.wValue != 0) // Feature selector != ENDPOINT STALL 

{ 

ReqDebugC’Error: USB_StdDevReqSET/CLEAR_FEATURE wrong feature selector for endpoint!”); 
UsbDevRequestStallHandshake(); 

return; 

} 

b = LSB(req.wIndex) & 127; // endpoint address 
if (b >= U sbNumEndpointsAT90U SB) 

{ 

ReqDebugC’Error: USB_StdDevReqSET/CLEAR_FEATURE endpoint does not exist!”); 
UsbDevRequestStallHandshake(); 

return; 

} 

if ((UsbDevConfValue == UsbUnconfiguredState) && (b > 0)) 

{ 

ReqDebug(”Error: USB_StdDevReqClearSetFeature forep > 0 in unconfigured state !”); 
UsbDevRequestStallHandshake(); 

return; 

} 

// Caution: what shall we do if (b == 0)? 

UsbDevSelectEndpoint(b); 

if ( req . bRequest == USB StdDcvRcqCLEAR FEATURE) 

{ 

UsbDevClearStallRequest() ; 

UsbDevResetEndpoint(b); // should we do an endpoint reset ? 

UsbDevResetDataToggleBit(); 

} 

else 

{ 

UsbDevRequestStallHandshake(); // for endpoint b 

} 

UsbDevSelectEndpoint(O); 

break; 
default : 

ReqDebugC’Error: USB_StdDevReqClearSetFeature!”); 

UsbDevRequestStallHandshake(); 

return; 

} 

UsbDevSendControlIn(); // send ZLP 

break; 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


21 


case USB_StdDevReqSET_ADDRESS: //2 stages (no data— stage) 
ReqDebug(”USB_StdDevReqSET_ADDRESS”); 

if ((LSB(req.wValue) == 0) && (UsbDevConfValue != UsbUnconfiguredState)) 

{ 

ReqDebug(”Error: USB_StdDevReqSET .ADDRESS address 0 in configured state!”); 
UsbDevRequestStallHandshake(); 

return; 

} 

Assert (req.bmRequestType == 0); 

Assert (MSB(req.wValue) == 0); 

Assert (req . wlndex == 0) ; 

Assert (req . wLength == 0); 

UsbDevSetAddress(LSB(req.wValue)); 

UsbDevSendControlInO; // send ZLP 
UsbDevWaitTransmitterReadyO; 

UsbDevEnableAddress(); 

break; 

case USB_StdDevReqSET_DESCRIPTOR: // 3 stage— transfer with out data 
ReqDebugf’Error: USB.StdDevReqSET .DESCRIPTOR currently not supported!”); 
UsbDevRequestStallHandshake(); // RequestStalIHandshake() before UsbDevAcknowledgeSETUP() 
UsbDev AcknowledgeSETUP(); //to ensure that host will not send out data! 

// you may implement this request if you have any idea for what you can use it 
break; 

case USB StdDevReqGET CONFIGURATION: // 3 stages with 1 byte IN— data not tested yet 

ReqDebug(”USB_StdDevReqGET_CONFIGURATION”); 

Assert (req.bmRequestType == 128); 

Assert ( req . w Value == 0) ; 

Assert ( req . wlndex == 0) ; 

Assert (req. wLength == 1); 

U sbDev WriteBy te(U sbDevConfValue) ; 

UsbDevSendControlInO; 

W a i t Z L P .Fro m H o s t () ; 
break; 

case USB_StdDevReqSET_CONFIGURATION: // 2 stages (no data— stage) 
ReqDebug(”USB_StdDevReqSET_CONFIGURATK)N”); 

Assert (req.bmRequestType == 0); 

Assert (MSB(req.wValue) == 0); 

Assert ( req . wlndex == 0) ; 

Assert ( req . wLength == 0); 
if (UsbDevSetConfiguration(LSB(req.wValue))) 

{ 

UsbDevSelectEndpoint(O); // UsbDevSetConfigurationf) may select other ep 
UsbDevSendControlInO; // send ZLP 

} 

else 

{ 

ReqDebugf’Error: USB.StdDevReqSET .CONFIGURATION unsupported configuration!”); 
UsbDevSelectEndpoint(O); 

UsbDevRequestStallHandshake(); 

} 

break; 

case USB.StdDevReqGETJNTERFACE: // 3 stages with 1 byte IN— data not tested yet 

ReqDebug(”USB_StdDevReqGET_INTERFACE”); 
if (UsbDevConfValue == UsbUnconfiguredState) 

{ 

ReqDebugf’Error: USB.StdDevReqGETJNTERFACE in unconfigured state!”); 
UsbDevRequestStallHandshake(); 

return; 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


28 


} 

Assert (req.bmRequestType == 129); 

Assert (req . w Value == 0) ; 

Assert (MSB(req.wIndex) == 0); 

Assert (req. wLength == 1); 

UsbDevWriteByte(AltSettingOfInterface [( uint8_t ) LSB(req.wIndex)]); 

UsbDevSendControlIn(); 

WaitZLP FromHostf); 

break; 

case USB_StdDevReqSET_INTERFACE: // 2 stages (no data— stage) 
ReqDebug(”USB_StdDevReqSET_INTERFACE”); 
if (UsbDevConfValue == UsbUnconfiguredState) 

{ 

ReqDebugf’Error: USB StdDcvReqSET INTERFACE in unconfigured state!”); 

UsbDevRequestStallHandshake(); 

return; 

} 

Assert (req.bmRequestType == 1); 

Assert (MSB(req.wValue) == 0); 

Assert (MSB(req.wIndex) == 0); 

Assert (req . wLength == 0); 

if (UsbDevSetInterface(UsbDevConfValue, LSB(req.wIndex), LSB(req.wValue))) 

{ 

UsbDevSelectEndpoint(O); // UsbDevSetlnterface () may select other ep 
UsbDevSendControlIn(); // send ZLP 

} 

else 

{ 

UsbDevSelectEndpoint(O); 

ReqDebug(”Error: USB.StdDevReqSET .INTERFACE alt. setting does not exist!”); 
UsbDevRequestStallHandshake(); 

} 

break; 

case USB_StdDevReqSYNCH_FRAME; // 3 stages with 2 byte IN— data not supported 

ReqDcbugf’ljSB StdDevRcqSYNCH FRAME not supported!”); 

UsbDevRequestStallHandshake(); 

return; 

case USB_StdDevReqGET_DESCRIPTOR: // 3 stages transfer 
ReqDebug(”USB_StdDevReqGET_DESCRIPTOR”); 

Assert (req.bmRequestType == 128); 

{ 

uint8_t requested ; 
uint8_t written = 0; 

if (MSB(req. wLength)) requested = 255; else requested = LSB(req. wLength); // we will never send more ) 
than 255 bytes 
switch (MSB(req.wValue)) 

{ 

case 1: // Device— Descriptor 
Assert ( req . wlndex == 0) ; 

Assert (LSB(req.wValue) == 0); 

UsbGetDeviceDescriptor(&u.devDes); 

U sbDumpDeviceDescriptor( &u .devDes) ; 

UsbDevWriteDescriptorl&u.devDes, &written, requested ) ; 
break; 

case 2: // Configuration — Descriptor 

if (! UsbSendDescriptors(LSB(req.wValue), &written, requested)) 

{ 

ReqDebug(”Error: USB.StdDevReqGET .DESCRIPTOR: can not sent Configuration— Descriptor!”); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


29 


UsbDevRequestStallHandshake(); 

return; 

} 

break; 

case 3: // String —Descriptor 

UsbGetStringDescriptor(u. strDes , LSB(req.wValue)); // strDes is an array, so no & is necessary! 
UsbDumpStringDescriptor(u.strDes) ; 

UsbDevWriteDescriptor(u. strDes , &written, requested); 

break; 
default : 

ReqDebug(”USB_StdDevReqGET_DESCRIPTOR: Unknown type!”); 

return; 

} 

if UsbDevHasReceivedOUT_Data() // got ZLP from host abort! 

{ 

UsbDevClearHasReceivedOUT_Data(); 

ReqDebug(”USB_StdDevReqGET .DESCRIPTOR: Abort from host!”); 

return; 

} 

if (((written % EPCLFIFO.Size) != 0) || (written < requested)) 

U sbDevSendControlIn() ; 

WaitZLP_FromHost(); 

} 

break; 
default : 

ReqDebugf’Received unsupported UsbStandardRequest!”); 

UsbDevRequestStallHandshake(); 

} 

} 

else 

{ 

ReqDebug(”Unsupported nonstandard request!”) ; 

UsbDevRequestStallHandshake(); 

} 

} 

static bool 

UsbSendDescriptors( uint8_t cdi, uint8_t * written, uint8_t requested) 

{ 

union // we can use the same piece of memory for these descriptors 

{ 

USB .Configuration Descriptor confDes; 

USBJnterfaceDescriptor intDes; 

USB_EndpointDescriptor endDes; 

} u; 

// uint8J cdi; // configuration descriptor index 
uint8_t idi ; // interface descriptor index 
uint8_t as; // alternate setting of interface 
uint8_t edi ; // endpoint descriptor index 
if ( UsbGetConfigurationDescriptor(&u.confDes, cdi)) 

{ 

UsbDumpConfigurationDescriptor(&u.confDes); 

UsbDevWriteDescriptor(&u.confDes, written , requested ) ; 
idi =0; 

do 

{ 

as = 0; 

while ( UsbGetlnterfaceDescriptor (&u.intDes, cdi, idi, as)) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb requests.e 


{ 

UsbDumpInterfaceDescriptor(&u.intDes); 
UsbDevWriteDescriptor(&u.intDes, written, requested); 
for (edi = 1; edi < UsbNumEndpointsAT90USB; edi++) 

{ 

if (UsbGetEndpointDescriptor(&u.endDes, edi, idi , as, edi)) 

{ 

UsbDumpEndpointDescriptor(&u.endDes); 
UsbDevWriteDescriptor(&u.endDes, written , requested ) ; 

} 

} 

as++; 

} 

idi ++; 

} while (as >0); 

return true ; 

} 

else return false ; 

} 



Free (GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor 


usbjspec.h 


31 


// AT90USB/usb_spec.h 

// USB datastructures as defined by www.usb.org 
// S. Salewski 27— FEB— 2007 

#ifndef _USB_SPEC_H_ 

#define _USB_SPEC_H_ 

#include <stdint.h> 

#define USB_Specl_l 0x0110 
#define USB_Spec2_0 0x0200 

#define USB_ControlTransfer 0 

#define USB JsochronousTransfer 1 

#define USB BulkTransfer 2 

#define USBJnterruptTransfer 3 

#define USB_DeviceDescriptorType 
#define USB_ConfigurationDescriptorType 
#define USB StringDcscriptor Iype 
#define USB JnterfaceDescriptorType 
#define USB_EndpointDescriptorType 
// #define USBJJeviceQualifierDescriptorType 0x06 // only used for high speed devices 
// # define USBJDtherSpeedConfigurationDescriptorType 0x07 // only used for high speed devices 


#define USB DeviceDescriptorLength 0x12 

#define USB -Configuration DescriptorUength 0x09 

#define USBJnterfaceDescriptorLength 0x09 

#define USB_EndpointDescriptorLength 0x07 

#define USBXanguageDescriptorlndex 0 

#define USB_ManufacturerStringIndex 1 

#define USB_ProductStringIndex 2 

#define USB.SerialNumberStringlndex 3 


// USB uses little endian format, avr—gcc too, so no byte— swap is necessary for 16 bit data 

// USB— Device— Request, H.J. Kelm USB 2.0, section 2.9.1, page 107 

typedef struct 

{ 


uint8_t 

bmRequestType; 

uint8_t 

bRequest; 

uintl6_t 

wValue; 

uintl6_t 

wlndex; 

uintl6_t 

wLength; 


} USB_DeviceRequest; 

// Device— Descriptor, H.J. Kelm, USB 2.0, section 2.8.2 (page 98) and section 9.4.7 (page 296) 

typedef struct 

{ 


uint8_t 

bLength; 

uint8_t 

bDescriptorType ; 

uintl6_t 

bcdUSB; 

uint8_t 

bDeviceClass; 

uint8_t 

bDeviceSubClass; 

uint8_t 

bDeviceProtocoll ; 

uint8_t 

bMaxPacketSizeO; 

uintl6_t 

idVendor; 

uintl6_t 

idProduct ; 


0x01 

0x02 

0x03 

0x04 

0x05 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usbjspec.h 


32 


uintl6_t 

bcdDevice; 

uint8_t 

iManufacturer ; 

uint8_t 

iProduct ; 

uint8_t 

iSerialNumber; 

uint8_t 

bNumConfigurations; 


} USB_DeviceDescriptor; 


// Configuration— Descriptor, H.J. Kelm, USB 2.0, section 2.8.3 (page 100) and section 9.4.7 (page 297) 

typedef struct 

{ 


uint8_t 

bLength; 

uint8_t 

bDescriptorType ; 

uintl6_t 

wTotal Length; 

uint8_t 

bNumlnterfaces ; 

uint8_t 

bConfigurationValue ; 

uint8_t 

iConfiguration ; 

uint8_t 

bm Attributes ; 

uint8_t 

MaxPower; 


} USB_ConfigurationDescriptor; 

// Interface —Descriptor, H.J. Kelm, USB 2.0, section 2.8.4 (page 101) and section 9.4.7 (page 297) 

typedef struct 

{ 


uint8_t 

bLength; 

uint8_t 

bDescriptorType ; 

uint8_t 

blnterfaceNumber; 

uint8_t 

bAlternateSetting ; 

uint8_t 

bNumEndpoints; 

uint8_t 

blnterfaceClass ; 

uint8_t 

blnterfaceSubClass 

uint8_t 

blnterfaceProtocol 

uint8_t 

ilnterface ; 


} USBJnterfaceDescriptor ; 

// Endpoint— Descriptor, H.J. Kelm, USB 2.0, section 2.8.5 (page 102) and section 9.4.7 (page 298) 

typedef struct 

{ 


uint8_t 

bLength; 

uint8_t 

bDescriptorType ; 

uint8_t 

bEndpointAddress; 

uint8_t 

bm Attributes ; 

uintl6_t 

wMaxPacketSize; 

uint8_t 

blnterval ; 


} USB_EndpointDescriptor; 

/* not used 

typedef char USBStringDescriptor[USB-MaxStringDescriptorLength ]; 
void InitDeviceDes ( USB _DeviceDescriptor *d); 
void InitConfigurationDes (USB_ConfigurationDescriptor *c); 
void InitInterfaceDes(USBJnterfaceDescriptor *i); 
void InitEndpointDes ( USB JEndpointDescriptor *e); 

*/ 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb spec.c 


33 


// AT90USB/usb_spec.c 
// Initialization of USB datastructures 
// S. Salewski 27— FEB— 2007 

#include ”usb_spec.h” 

#include ”usb_api.h” 

// USB uses little endian format, avr—gcc too, so no byte— swap is necessary for 16 bit data 

/* set defaults, we don’t really need this 

void 

InitDeviceDes ( USB DeviceDescriptor *d ) 

{ 

d—>bLength = USB JOeviceDescriptorLength; 
d—>bDescriptorType = USBJDeviceDescriptorType; 
d—>bcdUSB = USBSpeclJ; 
d—>bDeviceClass = 0; 
d—>bDeviceSubClass = 0; 
d—>bDeviceProtocoll = 0; 
d—>bMaxPacketSizeO = EPO _FIFO Size; 
d—>idVendor = MyUSB _VendorID; 
d—>idProduct = MyUSB _ProductID; 
d—>bcdDevice = My USB De viceB CD ; 
d—>iManufacturer = USB JdanufacturerStringlndex; 
d—>iProduct = USB -/‘roductSt ring Index; 
d—>iSeriaINumber = USBSerialNumberStringlndex; 
d—>bNumConfiqurations = 1; 

} 

void 

InitConfigurationDes (USB_ConfigurationDescriptor *c) 

{ 

c—>bLength = USB _Configu ration Descri/)torLength; 
c—>bDescriptorType = USBJSonfigurationDescriptorType; 

c—>wTotalLength = 0; // this and the following fields must be filled with correct values! 

c—>bNumInterfaces = 0; 

c—>bConfigurationValue = 0; 

c—>iConfiguration = 0; 

c—>bmAttributes = 0; 

c—>MaxPower = 0; 

} 

void 

InitlnterfaceDes (USBJnterfaceDescriptor *i) 

{ 

i—>bLength = USBJnterfaceDescriptorLength; 
i — >bDescriptorType = USB JnterfaceDescriptorType; 

i->bInterfaceNumber = 0;// this and the following fields must be filled with correct values! 
i — >bAlternateSetting = 0; 
i — >bNumEndpoints = 0; 
i — >bInterfaceClass = 0; 
i — >bInterfaceSubClass = 0; 
i — >bInterfaceProtocol = 0; 
i — >ilnterface = 0; 

} 


void 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usbjspec.c 


InitEndpointDes ( USB _EndpointDescriptor *e) 

{ 

e—>bLength = USB Endpoint Descriptor Length; 
e—>bDescriptorType = USB Endpoint DescriptorType; 

e->bEndpointAddress = 0;// this and the following fields must be filled with correct values 
e—>bmAttributes = 0; 
e—>wMaxPacketSize = 0; 
e—>blnter\’al = 0; 

} 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


35 


// AT90USB/usb_drv.h 

// Macros for access to USB registers of Atmels AT90USB microcontrollers 
// This file contains low level register stuff as described in 
// Atmels AT90USB datasheet 7593D—AVR— 07/06 
// S. Salewski 21— MAR— 2007 

#ifndef _USB_DRV_H_ 

#define USB DRV H 

#include <avr/io.h> 

#include <stdint.h> 

#include <stdbool.h> 

#include ” defines . h” 


#define UsbNumEndpointsAT90USB 7 


#define UsbEP_TypeControl 0 
#define UsbEP.Typelso 1 

#define UsbEP TypeBulk 2 

#define UsbEP _TypeInterrupt 3 
#define UsbEP _DirOut 0 

#define UsbEP _DirControl 0 

#define UsbEP _DirIn 1 

#define UsbUnconfiguredState 0 
#define UsblnterfaceUnconfigured OxFF 
#define UsbNoInterfaceClass OxFF 
#define UsbNoInterfaceSubClass OxFF 
#define UsbNoInterfaceProtokoll OxFF 
#define UsbNoDeviceClass OxFF 
#define UsbNoDeviceSubClass OxFF 
#define UsbNoDeviceProtokoll OxFF 
#define UsbNoDescriptionString 0 


extern uintS t UsbAllocatedEPs; 

extern volatile uintS t UsbStartupFinished ; 

void UsbDevFaunchDevice(bool lowspeed); 

bool UsbDevEP_Setup(uint8_t num, uint8_t type, uintl6_t size, uint8_t banks, uint8_t dir); 

void UsblnitialReset (void); 

void UsbStartPFF(void); 

void UsbDevStartDeviceEPO(void); 


// A few macros for bit fiddling 
#define SetBit(adr, bit) 

#define ClearBit(adr, bit) 
#define BitlsSet (adr, bit) 
#define BitlsClear ( adr , bit ) 


(adr |= (l«bit)) 
(adr &=~(l<<bit)) 
(adr &(l<<bit)) 

(!( adr &(l«bit))) 


// A few simple macros 

#define UsbDevWaitStartupFinished() 

#define UsbOutEndpointAdress(endpointlndex) 
#define UsblnEndpointAdress(endpointlndex) 
#define UsbConfigurationValue(conflndex) 
unconfigured ( addressed ) state 
// # define UsbMaxPower2mA( mA ) 

#define UsbConfDesAttrBusPowered 
Attributes 


while (! UsbStartupFinished) ; 

( endpointlndex & 15) 

( endpointlndex & 15) | (1<<7) 

(conflndex + 1) // +1, because 0 indicates 2 

(mA/2) 

(1<<7) // use | to combine these 3 2 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


36 


#define UsbConfDesAttrSelfPowered (1<<7) | (1<<6) 

#define UsbConfDesAttrRemoteWakeup (1<<7) j (1<<5) 

// Section and page references refer to release 7593D—AVR— 07/06 of 


// Atmels Manual for AT90USB devices 

// USB general registers, section 21.12.1 
// UHWCON ( U sbHardWareCON figuration ) 
#define UsbSetDeviceMode() 
manually 

#define UsbSetHostMode() 

#define UsbEnableUID_ModeSelection() 
pin 

#define UsbDisableUID ModeSelection() 
#define UsbEnableUVCON_PinControl() 
figure 21—7 

#define UsbDisableUVCONJPinControK) 
#define UsbEnablePadsRegulator() 

#define UsbDisablePadsRegulator() 

// USBCON (USB CONfiguration) 

#define UsbEnableController() 

#define UsbDisableController () 

#define UsblsControllerEnabled () 

#define UsbSetHostModeRegO 
registers 

#define UsbSetDeviceModeRegO 
#define UsbFreezeClock() 

#define UsbEnableClock() 

#define UsblsClockFreezedQ 
#define UsbEnableOTG_Pad() 

#define UsbDisableOTG_Pad() 

#define UsbEnableID_TransitionInt () 
generation 

#define UsbDi sable ID Transition I lit () 
#define UsbEnable VB US _TransitionInt() 
interrupt 

#define UsbDisableVBUS_TransitionInt() 


, page 263 of datasheet 

SetBit (UHWCON, UIMOD) 

ClearBit (UHWCON, UIMOD) 
SetBit (UHWCON, UIDE) 

ClearBit (UHWCON, UIDE) 
SetBit (UHWCON, UVCONE) 

ClearBit (UHWCON, UVCON) 
SetBit (UHWCON, UVREGE) 
ClearBit (UHWCON, UVREGE) 


SetBit (USBCON, USBE) 
ClearBit (USBCON, USBE) 
BitlsSet (USBCON, USBE) 
SetBit (USBCON, HOST) 

ClearBit (USBCON, HOST) 
SetBit (USBCON, FRZCLK) 
ClearBit (USBCON, FRZCLK) 
BitlsSet (USBCON, FRZCLK) 
SetBit (USBCON, OTGPADE) 
ClearBit (USBCON, OTGPADE) 
SetBit (USBCON, IDTE) 

ClearBit (USBCON, IDTE) 
SetBit (USBCON, VBUSTE) 

ClearBit (USBCON, VBUSTE) 


// USBSTA (USBSTAtus, read only) 

#define UsbIsFullSpeedMode() BitlsSet (USBSTA, SPEED) 

is in fullspeed mode, 

#define UsbIsLowSpeedMode() BitlsClear (USBSTA, SPEED) 

indeterminate in device mode 

#define UsbIsUID_PinHigh() BitlsSet (USBSTA, ID) 

#define UsblsVBUS PinHight) BitlsSet (USBSTA, VBUS) 


// USBINT (USBINTerrupt) 

#define UsbIsIDTI_FlagSet() BitlsSet (USBINT, IDTI) 

transition detected 

#define UsbClearlDTI Flag() ClearBit (USBINT, IDTI) 

#define UsbIsVBUSTIJFlagSet() BitlsSet (USBINT, VBUSTI) 

on VBUS pad is detected 

#define UsbClearVBUSTI_Flag() ClearBit (USBINT, VBUSTI) 


// OTGCON ( OnTheGoCONfiguration ) 
// to do ... 


// select host or device mode ) 

// enable mode selection by UID ) 
// enable UVCON pin control, ) 

// USB pads (D+, D-) supply 

// USB controller enable 
// reset and disable controller 

// select multiplexed controller ) 

// 

// reduce power consumption 

// ??? is this the UID pad? 

// enable ID transition interrupt ) 

// enable VBUS transition ) 

// set by hardware if controller ) 

// use in host mode only, ) 

// query UID pad/pin 
// query VBUS pad/pin 

// set by hardware if ID pin ) 

// shall be cleared by software 
// set by hardware if transition ) 

// shall be cleared by software 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


37 


// OTGTCON ( OnTheGoTimerCONfiguration ) 

// to do ... 

// OTGIEN ( On TheGoInterruptEnable ) 

// to do ... 

// OTGINT (OnTheGoINTerrupt) 

// to do ... 

// USB device general registers, section 22.19.1, page 281 
// UDCON (Usb Device CONfiguration ) 

#define UsbDevSelectLowSpeed() SetBit (UDCON, LSM) // Page 258, figure 21-14 

#define UsbDevSelectFullSpeed() ClearBit (UDCON, LSM) 

#define UsbDevIsLowSpeedSelected() BitlsSet (UDCON, LSM) 

#define UsbDevInitiateRemoteWakeupO SetBit (UDCON, RMWKUP) // cleared by hardware, see ) 

section 22.11, page 273 

#define UsbDevIsRemoteWakeupPendingO BitlsSet (UDCON, RMWKUP) 

#define UsbDevDetach() SetBit (UDCON, DETACH) // disconnect internal pull— up on ) 

D+ or D— 

#define UsbDev Attach!) ClearBit (UDCON, DETACH) // connect internal pull-up on D+ ) 

or D— 

#define UsbDevIsDetached() BitlsSet (UDCON, DETACH) 

#define UsbDevIsAttached() BitlsClear (UDCON, DETACH) 

// UDINT (Usb Device INTerrupt) 

#define UsbDevIsUpstreamResumeFlagSet() BitIsSet(UDINT, UPRSMI) // set by hardware 

#define UsbDevClearUpstreamResumeFlagO ClearBit(UDINT, UPRSMI) // shall be cleared by software 

#define UsbDevIsEndOfResumeFlagSet() BitlsSet (UDINT, EORSMI) // set by hardware if host sends ” ) 

end of resume” 

#define UsbDevClearEndOfResumeFlagO ClearBit (UDINT, EORSMI) // shall be cleared by software 

#define UsbDevIsWakeupCPU_FlagSet() BitlsSet (UDINT, WAKEUPI) // set by hardware when USB ) 

controller is reactivated 

#define UsbDevClearWakeupCPU_Flag() ClearBit (UDINT, WAKEUPI) // shall be cleared by software ) 

after enabling USB clock inputs 

#define UsbDevIsEndOfResetFlagSet() BitlsSet (UDINT, EORSTI) // set by hardware when USB ) 

controller has detected ’’End Of Reset" 

#define UsbDevClearEndOfResetFlagO ClearBit (UDINT, EORSTI) // shall be cleared by software 

#define UsbDevIsStartOfFrameFlagSet() BitlsSet (UDINT, SOFI) // set by hardware when an USB ” 0 

Start Of Frame ” has been detected 

#define UsbDevClearStartOfFrameFlagO ClearBit (UDINT, SOFI) 

#define UsbDevIsSuspendFlagSet() BitlsSet (UDINT, SUSPI) // set by hardware when USB bus is ) 

idle 

#define UsbDevClearSuspendFlagO ClearBit (UDINT, SUSPI) // shall be cleared by software 

// UDIEN (Usb Device Interrupt ENable) 

#define UsbDevEnableUpstreamResumeInt() SetBit(UDIEN, UPRSME) 

#define UsbDevDisableUpstreamResumeInt() ClearBit (UDIEN, UPRSME) 

#define UsbDevEnableEndOfResumeInt() SetBit (UDIEN, EORSME) 

#define UsbDevDisableEndOfResumeInt() Clear(UDIEN, EORSME) 

#define UsbDevEnableWakeupCPU_Int() SetBit (UDIEN, WAKEUPE) 

#define UsbDevDisableWakeupCPU Jnt() ClearBit (UDIEN, WAKEUPE) 

#define UsbDevEnableEndOfResetInt() SetBit (UDIEN, EORSTE) 

#define UsbDevDisableEndOfResetInt() ClearBit (UDIEN, EORSTE) 

#define UsbDevEnableStartOfFrameInt() SetBit (UDIEN, SOFE) 

#define UsbDevDisableStartOfFrameInt() ClearBit (UDIEN, SOFE) 

#define UsbDevEnableSuspendInt() SetBit (UDIEN, SUSPE) 

#define UsbDevDisableSuspendInt() ClearBit (UDIEN, SUSPE) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


38 


// UDADDR (Usb Device ADDRess) 

#define UsbDevEnableAddress() SetBit (UDADDR, ADDEN) // cleared by hardware 

#define UsbDevSetAddress(adr) UDADDR = (adr & 127) // set by software 

// UDFNUMH ( Usb Device Frame NUMber High ) 

#define UsbDevGetFrameNumberHigh(num) num = UDFNUMH // 3 MSB of 1 1— bits frame number; ) 

set by hardware 

// UDFNUML ( Usb Device Frame NUMber Low) 

#define UsbDevGetFrameNumberLow(num) num = UDFNUML // 8 LSB of 1 1— bits frame number; ) 

set by hardware 

// UDMFN 

#define UsbDcvTsFrameNumberCRC ErrorQ BitlsSet (UDMFN, FNCERR) // set by hardware if CRC error of ) 

framenumber 

// USB device endpoint registers , section 22.19.2 page 284 
// UENUM (Usb Endpoint NUMber) 

#define UsbDevSelectEndpoint(num) UENUM = (num & 7) // num ==0,1, ..., 6 

// UERST (Usb Endpoint ReSeT) 

#define UsbDevResetEndpoints(mask) 

UERST = 0 necessary? 

#define U sbDevResetEndpoint(num) 

// UECONX (Usb Endpoint CONfiguration X) 

#define UsbDevRequestStallHandshake() 
host for next handshake 
#define UsbDevClearStallRequest() 
mechanism 

#define UsbDevIsEndpointStalled() 
write— only in datasheet 
#define UsbDevResetDataToggleBit() 

#define UsbDevEnableEndpoint() 
device configuration 
#define UsbDevDisableEndpoint() 

#define UsbDevIsEndpointEnabled() 

// UECFGOX (Usb Endpoint ConFiGuration OX) 

#define UsbDevSetEndpointTypeControl() UECFGOX &= '((1«EPTYPE1)|(1«EPTYPE0)) 

#define UsbDevSetEndpointTypeIso() UECFGOX = (UECFGOX & ~(1«EPTYPE1)) | (1«EPTYPE0) 

#define UsbDevSetEndpointTypeBulk() UECFGOX = (UECFGOX & ~(1«EPTYPE0)) j (1«EPTYPE1) 

#define UsbDevSetEndpointTypeInt() UECFGOX |= ((1«EPTYPE1)|(1«EPTYPE0)) 

#define UsbDevSetEnpointDirectionIn() SetBit (UECFGOX, EPDIR) 

#define UsbDevSetEnpointDirectionOut() ClearBit (UECFGOX, EPDIR) 

#define UsbDevSetEnpointDirectionControl() ClearBit (UECFGOX, EPDIR) 


SetBit (UECONX, STALLRQ) 

SetBit (UECONX,STALLRQC) 

BitlsSet (UECONX, STALLRQ) 

SetBit (UECONX, RSTDT) 
SetBit (UECONX, EPEN) 

ClearBit (UECONX, EPEN) 
BitlsSet (UECONX, EPEN) 


// request a STALL answer to the ) 

// disable STALL handshake ) 

// Caution: This bit is marked ) 

// next packet is dataO 
// enable endpoint according to ) 


UERST = mask & 127; UERST = 0 // reset selected endpoints; is ) 
UERST 1= (l<<num); UERST = 0 // reset this endpoint 


// UECFG1X (Usb Endpoint ConFiGuration IX) 

// here we access bits direct , without using bitnames 

#define UsbDevSetEndpointSize8() UECFG1X = (UECFG1X & (4+8)) // preserve bank, 

size 


#define U sbDevSetEndpointS ize 1 6() 
#define UsbDevSetEndpointSize32() 
#define U sbDevSetEndpointS ize64() 
#define U sbDevSetEndpointS ize 1 28 () 
#define UsbDevSetEndpointSize256() 
#define UsbDevSetEndpointSize5 12() 
#define UsbDevSetEndpointOneBank() 


UECFG1X 

UECFG1X 

UECFG1X 

UECFG1X 

UECFG1X 

UECFG1X 


(UECFG1X & 
(UECFG1X & 
(UECFG1X & 
(UECFG1X & 
(UECFG1X & 
(UECFG1X & 


(4+8)) 

(4+8)) 

(4+8)) 

(4+8)) 

(4+8)) 

(4+8)) 


(1«4) 

(2«4) 

(3«4) 

(4«4) 

(5«4) 

(6«4) 


UECFG1X = (UECFG1X & (7«4)) //preserve size, 


clear ALLOC, set ) 


clear ALLOC, set ) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


39 


bank 

#define UsbDevSetEndpointDoubleBankO UECFG1X = (UECFG1X & (7«4)) | (1«EPBK0) 

#define UsbDevSetEndpointAllocBit() SetBit(UECFG IX, ALLOC) // allocate endpoint memory 

#define UsbDevClearEndpointAllocBit() ClearBit(UECFGlX, ALLOC) // free endpoint memory 

// UESTAOX (Usb Endpoint STAtus OX) 

#define UsbDevIsConfigurationOk() BitlsSet (UESTAOX, CFGOK) // updated when ALLOC bit is set 

#define UsbDevIsOverflowErrorFlagSet() BitlsSet (UESTAOX, OVERFL) // indicates overflow in ) 

isochronous endpoint 

#define UsbDevClearOverflowErrorFlagO ClearBit (UESTAOX, OVERFL) // shall be cleared by software 

#define UsbDevIsUnderflowErrorFlagSet() BitlsSet (UESTAOX, UNDERFL) // indicates underflow in ) 

isochronous endpoint 

#define UsbDevClearUnderflowErrorFlagO ClearBit (UESTAOX, UNDERFL) // shall be cleared by software 

#define UsbDevZeroLengthPackedSeen() BitlsSet (UESTAOX, ZLPSEEN) 

#define UsbDevClearZeroLengthPackedFlagO ClearBit (UESTAOX, ZLPSEEN) // shall be cleared by software 
#define UsbDevIsDataOO UESTAOX & ((1«DTSEQ0) | (1«DTSEQ1)) == 0 

#define UsbDevIsDatal() UESTAOX & ((1«DTSEQ0) j (1«DTSEQ1)) == (1«DTSEQ0) 

#define UsbDevGetNumberOfBusyBanks() (UESTAOX & 3) // if 0 then all banks are free , ) 

if 1 then 1 bank is busy ... 

// UESTA1X (Usb Endpoint STAtus IX) 

#define UsbDevIsControlDirectionIn() BitlsSet (UESTA1X, CTRLDIR) // direction of next packed after ) 

SETUP packed 

#define UsbDevIsControlDirectionOut() BitlsClear (UESTA1X, CTRLDIR) // set and cleared by hardware 

#define UsbDevGetCurrentBank() (UESTA1X & 3) // set by hardware, number of 0 

current bank, 0 or 1 

// UEINTX ( Usb Endpoint INTerrupt X) 

#define UsbDevIsFifoControllBitSet () BitlsSet (UEINTX, FIFOCON) // see page 289 

#define UsbDevClearFifoControllBit () ClearBit (UEINTX, FIFOCON) 

#define UsbDevSendInData() ClearBit (UEINTX, FIFOCON) // see section 22.15, page 277 

#define UsbDevNAK_ResponseSendToInRequest() BitlsSet (UEINTX, NAKINI) 

#define UsbDevClearNAK_ResponseInBit() ClearBit (UEINTX, NAKINI) // shall be cleared by software 

//# define UsbDevReadWriteAllowed() BitlsSet (UEINTX, RWAL) // set by hardware, don’t use for ) 

control endpoint 

#define UsbDevReadAllowedO BitlsSet (UEINTX, RWAL) 

#define UsbDevWriteAllowed() BitlsSet (UEINTX, RWAL) 

#define UsbDevNAK_ResponseSendToOutRequest() BitlsSet (UEINTX, NAKOUTI) 

#define UsbDevClearNAK_ResponseOutBit() ClearBit (UEINTX, NAKOUTI) // shall be cleared by software 

#define UsbDevHasReceivedSETUP() BitlsSet (UEINTX, RXSTPI) // set by hardware if current bank ) 

contains a valid SETUP packet 

// # define UsbDevClearHasReceivedSETUPf ) ClearBit (UEINTX, RXSTPI) // shall be cleared by software 

#define UsbDevAcknowledgeSETUP() ClearBit (UEINTX, RXSTPI) // acknowledge request and clear ) 

fifo , see section 22.13 

#define UsbDevHasReceivedOUT_Data() BitlsSet (UEINTX, RXOUTI) // set by hardware if current bank ) 

contains a new packed 

#define UsbDevClearHasReceivedOUT_Data() ClearBit (UEINTX, RXOUTI) // shall be cleared by software 

#define UsbDevKillLastWrittenBankO SetBit (UEINTX, RXOUTI) // see page 278 for abort ) 

operation 

#define UsbDevSTALLHandshakeSendO BitlsSet (UEINTX, STALLEDI) // STALL send or CRC error in OUT 1 

isochronous endpoint 

#define UsbDevTransmitterReadyO BitlsSet (UEINTX, TXINI) // current bank is free and can be 0 

filled 

#define UsbDevWaitTransmitterReadyO while (!( UEINTX & (1«TXINI))); 

#define UsbDevClearTransmitterReadyO ClearBit (UEINTX, TXINI) // shall be cleared by software 

#define UsbDevSendControlInO ClearBit (UEINTX, TXINI) // see section 22.13, page 274 ( ) 

control endpoint management ) 

#define UsbDevAcknowledgelnBankFreelntQ ClearBit (UEINTX, TXINI) // TXINI is set by hardware if in ) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


40 


bank becomes free , see section 22.15 
// UEIENX (Usb Endpoint Interupt ENable X) 

#define UsbDevEnableFlowErrorInt() SetBit (UEIENX, FLERRE) 

#define UsbDevDisableFlowErrorInt() ClearBit (UEIENX, FLERRE) 

#define UsbDevEnableNAKJN_Int() SetBit (UEIENX, NAKINE) 

#define UsbDevDisableNAKJNJnt() ClearBit (UEIENX, NAKINE) 

#define UsbDevEnableNAK OUT Int() SetBit (UEIENX, NAKOUTE) 

#define UsbDevDisableNAK OUT Int() ClearBit (UEIENX, NAKOUTE) 

#define UsbDevEnableReceivedSETUPJnt() SetBit (UEIENX, RXSTPE) 

#define UsbDevDisableReceivedSETUP_Int() ClearBit (UEIENX, RXSTPE) 

#define UsbDevEnableReceivedOUT_DATA_Int() SetBit (UEIENX, RXOUTE) 

#define UsbDevDisableReceivedOUT_DATAJnt() ClearBit (UEIENX, RXOUTE) 

#define U sbDevEnableS TALLED _Int() SetBit (UEIENX, STALLEDE) 

#define UsbDevDisableSTALLED_Int() ClearBit (UEIENX, STALLEDE) 

#define UsbDevEnableTransmitterReadyInt() SetBit (UEIENX, TXINE) 

#define UsbDevDisableTransmitterReadyInt() ClearBit (UEIENX, TXINE) 

// UEDATX (Usb Endpoint DATa X) 

#define UsbDevReadByte() 
selected by EPNUM 
#define UsbDevWriteByte(byte) 
selected by EPNUM 

// UEBCHX (Usb Endpoint Byte Count High X) 

#define UsbDevGetByteCountHighO UEBCHX // 3 MSB of the byte count of the ) 

FIFO endpoint 

// UEBCLX (Usb Endpoint Byte Count Low X) 

#define UsbDevGetByteCountLow() UEBCLX // 8 LSB of the byte count of the ) 

FIFO endpoint 

// UEINT (Usb Endpoint INTerrupt) 

#define UsbDevGetEndpointIntBits() UEINT // set by hardware when interrupt ) 

is triggered , cleared if int source is ser\’ed 


UEDATX // read byte from endpoint FIFO 0 

UEDATX = byte // write byte to endpoint FIFO ) 


// PEL clock for USB interface , section 6.11, page 50 
// PLLCSR (PEL Control and Status Register) 

// set PLL prescaler according to XTAL crystal frequency 


// # define UsbXTALFrequencyIs2MHz( ) 
// # define UsbXTALFrequencyIs4MHz( ) 
// # define UsbXTALFrequencyIs6MHz( ) 
// # define UsbXTALFrequencyIs8MHz( ) 
// # define UsbXTALFrequencylsl 2MHz( ) 
// # define UsbXTALFrequencylsl 6MHz( ) 
#if (F XTAL == 2000000) 

#define _pre_ 0 

# elif (F_XTAL == 4000000) 

#define _pre_ 1 

# elif (F_XTAL == 6000000) 

#define _pre_ 2 

# elif (F XTAL == 8000000) 

#define _pre_ 3 

# elif (F_XTAL == 12000000) 

#define _pre_ 4 

# elif (F XTAL == 1 6000000) 

#define _pre_ 5 

#else 


PLLCSR 

PLLCSR 

PLLCSR 

PLLCSR 

PLLCSR 

PLLCSR 


(PLLCSR & 
(PLLCSR & 
(PLLCSR & 
(PLLCSR & 
(PLLCSR & 
(PLLCSR & 


T 15«1)) 
T 15«1)) 
T 15«1)) 
T 15«1)) 
T 15«1)) 
T 15«1)) 


( 1 « 2 ) 

( 2 « 2 ) 

(3«2) 

(4«2) 

(5«2) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.h 


41 


# error ”XTAL— Frequency has to be 2, 4, 6, 

#endif 

#define UsbSetPLL X'I’AL FrcquencyO 
#define UsbEnablePLL() 

#define UsbDisablePLL() 

#define UsbIsPLL_Locked() 

#define UsbWaitPLLXocked() 

#endif 


8, 12 or 16 MHz for USB devices!” 

PLLCSR = ( pre «2) 
SetBit(PLLCSR, PLLE) 

ClearBit (PLLCSR, PLLE) 

BitlsSet (PLLCSR, PLOCK) 
while (!( PLLCSR & (l«PLOCK))); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.c 


42 


// AT90USB/usb_drv.c 

// Basic functions for Atmels AT90USB microcontrollers 
// Based on Atmels AT90USB datasheet 7593D—AVR— 07/06 
// S. Salewski 21— MAR— 2007 

#include <stdbool.h> 

#include <stdint.h> 

#include <avr/ interrupt .h> // sei () 

#include ”usb_drv.h” 

#include ”usart_debug .h” 

#include ”usb_api.h” // EPO_FIFOASize 

uint8 t UsbAllocatedEPs = 0; 

volatile uint8 t UsbStartupFinished = 0; 

// Set some registers to their initial (reset) value. 

// Reason: Atmels bootloader activates some interrupts . 

// This function deactivates it , so we have clean start 
// conditions if our program is started from bootloader . 

void 

UsblnitialReset (void) 

{ 

USBCON = (1«FRZCLK); 

OTGIEN = 0; 

UDIEN = 0; 

UHIEN = 0; 

UEIENX = 0; 

UPIENX = 0; 

UHWCON = (l«UIMOD); 

} 

// Start PLL and enable clock 

void 

UsbStartPLL(void) 

{ 

UsbSetPLL XTAL FrequencyO; 

UsbEnablePLL(); 

UsbWaitPLLXocked(); 

U sbEnableClockO ; 

} 

// Basic USB activation necessary to trigger a wakeup interrupt 

// Wakeup ISR will start PLL clock, then USB— END— OF— RESET interrupts are recognized 

void 

UsbDevLaunchDevice(bool lowspeed) 

{ 

UsblnitialReset () ; 

if (1) // set it to (1) if you need very small code size (i.e. bootloader, saves 78 bytes) 

{ 

UHWCON = ((l«UIMOD) | (1«UVREGE)); 

USBCON = ((1«USBE) | (l«OTGPADE) | (1«FRZCLK)); 

asm volatile (”nop”); // nop may be are necessary if mpu is clocked with 16 MHz (deactivated prescaler) 

// asm volatile ("nop”); 
if (lowspeed) UDCON = (1«LSM); 

USBCON = ((1«USBE) | (l«OTGPADE)); 

USBCON = ((1<<USBE) | (l<<OTGPADE) | (1<<FRZCLK ));// setting FRZCLK again in not necessary (see below) 
UDIEN = ((1«WAKEUPE) | (l«EORSTE)); 

} 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.c 


43 


else // do the same thing , bit for bit, with named macros 

{ 

UsbEnablePadsRegulatorQ ; 

UsbEnableControllerO ; 

UsbEnableOTG_Pad(); // necessary to power on the device (undocumented feature) 

UsbDisableUlD_ModeSelection(); 

UsbSetDeviceMode(); 

UsbSetDeviceModeRegO; 

if (lowspeed) UsbDevSelectLowSpeed(); // fullspeed is default 
UsbEnableClock(); // without this no (wakeup) interrupt is triggered !!! 

UsbFreezeClock(); // FreezeClock() is not really necessary, but we may feel better because PLL in not running ) 
yet 

U sbDevEnable WakeupCPU _Int() ; 

UsbDevEnableEndOfResetInt(); // call this AFTER (UsbEnableControllerO; UshEnableOTG Pad( );) 

} 

UsbDev Attach!); 
sei () ; 

} 

// Called by USB— END— OF— RESET interrupt 
// USB reset resets EPO! (see section 22.5) 

void 

UsbDevStartDeviceEPO(void) 

{ 

U sbDevSelectEndpoint( 0) ; 

if UsbDevIsEndpointEnabled() // can this be true ? 

Debug(” EPO already enabled !\r\n”); 
else 
{ 

Debug(” Setting up EP0...\r\n”); 

UsbAllocatedEPs = 0; 

if (UsbDevEP_Setup(0, UsbEP_TypeControl, EPO_FIFO_Size, 1, UsbEP_DirControl)) 

DebugC’ Successful set up EP0!\r\n”); 

else 

Debug(” Setup of EPO failed !\r\n”); 

} 

UsbDevEnableReceivedSETUP_Int(); 

} 

// To reduce codesize , you may comment this function out and allocate your ep with low level macros 
// num: 0...6 

// type: UsbEP JypeControl, UsbEP CTypelso, UsbEP JypeBulk, U sbEP JType Interrupt 
// size: 8, 16, 32, 64. Only for isochronous ep 128, 256 or 512. 

// banks: 1 or 2 

// dir: UsbEP _DirOut, UsbEP _Dir Control, UsbEP _DirIn 

// more than one control ep or more than one bank for control epO may work, but is not recommended 
bool 

UsbDevEP_Setup(uint8_t num, uint8_t type, uintl6_t size, uint8_t banks, uint8_t dir) 

{ 

uint8_t i , j ; 
banks ; 

if ((num > 6) || (dir >1) || (banks >1) || (type >3) || (size & 0xFC07)) return false ; 
i = ( uint8_t ) ( size / 8) ; 

if ((UsbDevIsLowSpeedSelectedQ) && ((type == UsbEP _TypeBulk) 1 1 (type == UsbEP _TypeIso) || (i >1))) return ) 
false ; 

if (!(( i == 1) || (i == 2) || (i == 4) || (i =8))) 
if (!((( i ==16) || (i ==32) || (i ==64)) && (type == UsbEP _TypeIso))) return false; 
if ((type == UsbEP _TypeControl) && ((dir != UsbEP _DirControl) || (banks >0))) return false; 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usb drv.c 


44 


if (num == 0) 

{ 

if ((dir != UsbEP DirControl) || (type != UsbEP _TypeControl)) return false; // EPO is always control ep 

} 

else 
{ .. 

if ((num != UsbAllocatedEPs) || // allocate eps in growing order, see section 21.7 
(type == UsbEP _TypeControl)) return false; // more than one control ep may be ok? 

} 

U sbDevSelectEndpoint( num) ; 

UsbDevEnableEndpoint(); // enable ep before memory is allocated? Yes, see figure 22—2 
j = 0; 

while ((i = (i >> 1))) j++; 

UECFGOX = ((type « 6) | (dir)) ; 

UECFG1X = ((j « 4) | (banks « 2)); 

UECFG1X |= (1 « ALLOC); 
if (UESTAOX & (1 « CFGOK)) 

{ 

U sb AllocatedEPs++ ; 
return true ; 

} 

else 

{ 

U sbDevDisableEndpoint() ; 
return false ; 

} 

} 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usart drv.h 


45 


// AT90USB/usart_drv.h 

// Basic output routines for USART, adapted to Atmels AT90USB microcontrollers 
// Based on AT90USB datasheet (7593D—AVR— 07/06), chapter 18 and examples from 
// http :// www.mikrocontroller . net/ articles / AVR—GCC— Tutorial and 
// http :// www.roboternetz.de/wissen/index . php/UART jnit_avr— gcc 
// S. Salewski 29-JAN-2007 

#ifndef USART DRV H 
#define USART DRV H 

#include <stdint.h> 

#include ” defines . h” 

#ifndef NOUART 

void USART Jnit(void); // initialize USART, 8N1 mode 

void USART _WriteChar(char c); 

void USART _WriteHex(unsigned char c); 

void USART _WriteHexW(uintl6_t w); 

void USART _WriteString(char *s); 

void USART_NewLine(void); 

#else 

#define USART_Init() 

#define USART_WriteChar(c) 

#define USAR'I WritcHcxfcj 
#define USAR'I WritcHexW(w) 

#define USART_WriteString(s) 

#define USART_NewLine() 

#endif 

#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usart drv.c 


46 


// AT90USB/usartjdrv.c 

// Basic output routines for USART, adapted to Atmels AT90USB microcontrollers 
// Based on AT90USB Datasheet (7593D—AVR— 07/06), chapter 18 and examples from 
// http :// www.mikrocontroller . net/ articles / AVR—GCC— Tutorial and 
// http :// www.roboternetz.de/wissen/index . php/UART jnit_avr— gcc 
// S. Salewski 27— FEB— 2007 

#include <avr/io.h> 

#include ” defines . h” 

#include ” usart.drv . h” 

#include ’’macros. h” 

#ifndef NOUART 

#define Wait_USART_Ready() while (!(UCSR1A & (1«UDRE1))) 

#define UART.UBRR (F_CPU/(16L*USART_BAUD)-1) 

// initialize USART, 8N1 mode 

void 

USART Jnit(void) 

{ 

UBRR1 = UARTJUBRR; 

UCSR1C = (1«UCSZ10) | (1«UCSZ11); 

UCSR1B = (1<<TXEN1); 

} 

void 

USART_WriteChar(char c) 

{ 

Wait JUS ART .Ready () ; 

UDR1 = c; 

} 

void 

USART_WriteHex(unsigned char c) 

{ 

unsigned char nibble ; 
nibble = (c >>4); 

if (nibble < 10) nibble +=’0’; else nibble += (’A’ -10); 

Wait JUS ART _Ready(); 

UDR1 = nibble; 
nibble = (c & OxOF); 

if (nibble < 10) nibble +=’0’; else nibble += (’A’ — 10); 

Wait_US ART .Ready () ; 

UDR1 = nibble; 

} 

void 

USART_WriteHexW(uintl6_t w) 

{ 

USART_WriteHex(MSB(w)); 

USART_WriteHex(LSB(w)); 

} 

void 

USART JWriteString(char *s) 

{ 

while (*s) USART_WriteChar(*s++); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usart drv.c 


} 

void 

USART _Ne wLine ( void) 

{ 

WaitJJS ART .Ready () ; 

udri = V; 

Wait JJS ART .Ready () ; 
UDRI = ’\n’; 

} 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usart debug.h 


48 


// AT90USB/usart_debug.h 

// A few macros for debugging by sending messages over the serial port 
// S. Salewski 22— MAR— 2007 

#ifndef _USART_DEBUG_H_ 

#define _USART_DEBUG_H_ 

#include ” defines . h” 

#include ” usart drv . h” 

#include ”usb_spec . h” 

#ifdef DEBUG 

#define Debug(msg) USART WriteString(msg) 

//#define ReqDebug(msg) USART Write St ring) msg ” (” JFILE ”)\r\n”) 

#define ReqDebug(msg) USART_WriteString(”|” msg ”\r\n”) 

#else 

#define Debug(msg) 

#define ReqDebug(msg) 

#endif 

#ifdef DEBUG 

#define Assert(exp) if (exp == 0) USART_WriteString(”Error: ” #exp ” == 0 (” __FILE__ ”)\r\n”); 
#else 

#define Assert (exp) 

#endif 

#ifdef DEBUG 

void UsbDumpDeviceDescriptor(USB_DeviceDescriptor *d); 

void UsbDumpConfigurationDescriptor(USB_ConfigurationDescriptor *c) ; 

void UsbDumpInterfaceDescriptor(USB JnterfaceDescriptor *i ) ; 

void UsbDumpEndpointDescriptor(USB_EndpointDescriptor *e); 

void UsbDumpStringDescriptor(char *s); 

void UsbDumpSetupRequest(USB_DeviceRequest *rcq); 

#else 

#define UsbDumpDeviceDescriptor(d) 

#define UsbDumpConfigurationDescriptor(c) 

#define U sbDumpInterfaceDescriptor( i ) 

#define UsbDumpEndpointDescriptor(e) 

#define UsbDumpStringDescriptor(s) 

#define UsbDumpSetupRequest(req) 

#endif 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usart debug.c 


49 


// AT90USB/iisart_debug.c 

// Debugging by sending messages over the serial port 
// S. Salewski 22— MAR— 2007 

#include ” defines . h” 

#ifdef DEBUG 

#include ''usart debug . h” 

#include ”usb_spec . h” 

#include ”usart_drv .h” 

void 

UsbDumpDevieeDescriptor(USB DeviccDcscriptor *d) 

{ 

USART_WriteString(”USB Device— Descriptor:”); 

USART _WriteString(”\r\n d— >bLength: ”); USART_WriteHex(d— >bLength); 

USART_WriteString(”\r\n d— >bDescriptorType: ”); USART_WriteHex(d— >bDescriptorType); 

USART WriteString(”\r\n d->bcdUSB: ”); USART_WriteHexW(d->bcdUSB); 

USART _WriteString(”\r\n d— >bDeviceClass: ”); USART WriteHex(d- ->bDevieeClass); 
USART_WriteString(”\r\n d— >bDeviceSubClass: ”); USART_WriteHex(d— >bDeviceSubClass); 

USART _WriteString(”\r\n d— >bDeviceProtocoll: ”); USART _WriteHexfd—>bDeviceProtocoll); 

USART _WriteString(”\r\n d— >bMaxPacketSizeO: ”); USART JWriteHexfd— >bMaxPacketSizeO); 

USART _WriteString(”\r\n d— >idVendor: ”); USART_WriteHexW(d— >idVendor); 

USART _WriteString(”\r\n d— >idProduct: ”); USART WriteHexWfd — >idPmduct); 

USART _WriteString(”\r\n d— >bcdDevice: ”); USART_WriteHexW(d— >bcdDevice); 
USART_WriteString(”\r\n d— >iManufacturer: ”); USART_WriteHex(d— >iManufacturer); 

USART _WriteString(”\r\n d— >iProduct: ”); USART _WriteHex(d— >iProduct); 
USART_WriteString(”\r\n d— >iSerialNumber: ”); USART_WriteHex(d— >iSerialNumber); 

USART WriteStringf ’\r\n d— >bNumConfigurations: ”); USAR'I WritcHcxfd — >bNumCoufigurations); 
USART_NewLine(); 

} 

void 

UsbDumpCoufiguratioiiDcscriptorfUSB ConfigurationDcscriptor *c) 

{ 

USART _WriteString(” —USB Configuration— Descriptor:”); 

USART _WriteString(”\r\n c— >bLength: ”); USART_WriteHex(c— >bLength); 
USART_WriteString(”\r\n c— >bDescriptorType: ”); USART_WriteHex(c— >bDescriptorType); 

USART _WriteString(”\r\n c— >wTotalLength: ”); USART_WriteHexW(c— >wTotalLength); 

USAR'I’ WriteStri ng(”\r\ n c— >bNumInterfaces: ”); USART_WriteHex(c— >bNumInterfaces); 

USART _WriteString(”\r\n c—>bConfiguration Value: ”); USART_WriteHex(c—>bConfiguration Value); 
USART _WriteString(”\r\n c— >iConfiguration: ”); USART _WriteHex(c— >iConfiguration); 
USART_WriteString(”\r\n c— >bmAttributes: ”); USART_WriteHex(c— >bmAttributes); 
USART_WriteString(”\r\n c— >MaxPower: ”); USART_WriteHex(c— >MaxPower); 

USART_NewLine(); 

} 

void 

U sbDumpInterfaceDescriptorf USB JnterfaceDescriptor * i ) 

{ 

USAR'I WriteStringf’ —USB Interface— Descriptor:”); 

USART_WriteString(”\r\n i — >bLength: ”); USART_WriteHex(i— >bLength); 

USART_WriteString(”\r\n i — >bDescriptorType: ”); USART_WriteHex(i— >bDescriptorType); 

USART_WriteString(”\r\n i — >bInterfaceNumber: ”); USART_WriteHex(i— >bInterfaceNumber); 

USART _WriteString(”\r\n i — >bAlternateSetting: ”); USART WriteHexii — >bAltcrnateSetting); 

USART _WriteString(”\r\n i — >bNumEndpoints: ”); USAR'I WriteHexii — >bNumEndpoints); 

USART _WriteString(”\r\n i — >b!nterfaceClass: ”); USART _WriteHex(i— >b!nterfaceClass); 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usart debug.c 


50 


USART _WriteString(”\r\n i — >bInterfaceSubClass: ”); USART _WriteHex(i— >bInterfaceSubClass); 

USART_WriteString(”\r\n i — >bInterfaceProtocol: ”); USART _WriteHex(i— >bInterfaceProtocol); 
USART WriteString(”\r\n i — >ilnterface: ”); USART_WriteHex(i— >ilnterface); 
USART_NewLine(); 

} 

void 

UsbDumpEndpointDescriptor(USB _EndpointDescriptor *e) 

{ 

USART _WriteString(” —USB Endpoint— Descriptor:”); 

USART _WriteString(”\r\n e— >bLength: ”); USART _WriteHex(e— >bLength); 

USART_WriteString(”\r\n e— >bDescriptorType: ”); USART_WriteHex(e— >bDescriptorType); 

USART WriteString(”\r\n e— >bEndpointAddress: ”); USART WritcHexie—>bEndpoi lit Address); 

USART _WriteString(”\r\n e— >bmAttributes: ”); US AR'I WriteHex(e— >bmAttributes); 

USART _WriteString(”\r\n e— >wMaxPacketSize: ”); USART_WriteHexW(e— >wMaxPacketSize); 

USART _WriteString(”\r\n e— >blnterval: ”); USART_WriteHex(e— >blnterval); 

USART_NewLine(); 

} 

void 

U sbDumpS tringDescriptorl char * s) 

{ 

uint8_t i; 
i = *s; 

US AR'I WriteString(”USB String— Descriptor:\r\n”); 

while (i ) USART_WriteHex(*s++); 

USART_NewLine(); 

} 

void 

UsbDumpSetupRequest(USB_DeviceRequest *req) 

{ 

U S ART _ W riteS tring(” S etup Reque st :”) ; 

USART_WriteString(” \r\nbmRequestType: ”); USART_WriteHex(req— >bmRequestType); 

USART WriteStringi” \r\nbRequest: ”); USART WritcHexireq — >bRequest); 

USART WriteStringi” \r\nwValue: ”); USART WritcHexWireq ->wValue); 

USART_WriteString(” \r\nwlndex: ”); USART_WriteHexW(req— >wlndex); 

USART _WriteString(” \r\nwLength: ”); USART _WriteHexW(req— >wLength); 

USART_NewLine(); 

} 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — ringbuffer.h 


51 


// AT90USB/ringbuffer.h 

// Simple Ring— Buffer (FIFO) for Elements of type Q 
// S. Salewski, 20— MAR— 2007 

#ifndef _RINGJBUFFER_H_ 

#define _RINGJBUFFER_H_ 

#include <stdint.h> 

#define BufElements 1024 
#define Q uintl6_t 

extern u inti 6 t RB Entries; 

#define RB_FreeSpace() (BufElements — RB_Entries) 
#define RBJsFulH) (RB .Entries == BufElements) 
#define RB JsEmptyO (RBJEntries == 0) 

void RB Jnit(void) ; 
void RB_Write(Q el); 

Q RB Jlead(void); 

#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — ringbuffer.c 


52 


// AT90USB/ringbuffer.c 

// Simple Ring— Buffer (FIFO) for Elements of type Q 
// S. Salewski, 19— MAR— 2007 

/* 

t—> o 

o <— w 

X 

x <—r 
b—> x 
*/ 

#include <stdint.h> 

#include ” ringbuffer . h” 

static Q buf[BufElements]; 
uintl6_t RBJEntries; 

#define t &buf[BufElements — 1] 

#define b &buf[0] 

// Q *t = &buf[ BufElements — 1 ]; 

//Q *b = &buf[0]; 

Q *r; // position from where we can read ( if RB JEntries >0) 
Q *w; // next free position ( if RBJEntries < BufElements)) 

void 

RBJnit(void) 

{ 

r = b; 
w = b; 

RB .Entries = 0; 

} 

Q 

RB Read(void) 

{ 

// Assert ( RB_Entries > 0); 

RB .Entries ; 

if (r > t) r = b; 
return *r++; 

} 

void 

RB_Write(Q el) 

{ 

// Assert ( RB -Entries < BufElements ); 

RB _Entries++; 
if (w > t) w = b; 

*w++ = el; 

} 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usbJsr.c 


53 


// AT90USB/usb_isr.c 

// USB Interrupt Service Routines 

// S. Salewski 22— MAR— 2007 

#include <avr/ interrupt .h> 

#include <stdint.h> 

#include ”usb_drv.h” 

#include ’’usart debug . h” 

#include ’’usb.api.h” 

#include ”usb .requests .h” 

// USB General Interrupt Handler (Figure 21.11) 
// USB Registers: USBINT.O, USBINT.l, UDINT 
ISR(USB_GEN_vect) 

{ 

Debug(”ISR(USB_GEN_vect)\r\n”); 
if UsbIsIDTI_FlagSet() 

{ 

UsbClearlDTI JFlagO ; 

Debug(”=== IDTIJFlagSet\r\n”); 

} 

if UsbIsVBUSTI_FlagSet() 

{ 

UsbClearVBUSTLFlag(); 

Debug(”=== VBUSTLFlagSet\r\n”); 

} 

if UsbDevIsEndOfResetFlagSet() 

{ 

UsbDevClearEndOfResetFlagO; 

U sbDevS tartDeviceEPO() ; 

Debug(”=== EndOfResetFlagSet\r\n”); 

} 

if UsbDevIsWakeupCPU JlagSetO 

{ 

U sbDevDisable WakeupCPU _Int() ; 

U s b D c vC lea r Wa l< e u p C P U Flag() ; 
UsbStartPLL(); 

Debug(”=== WakeupCPU _FlagSet\r\n”); 

} 


// USB Endpoint/Pipe Interrupt Handler (Figure 21.12) 

// Endpoint Registers : UEINTX, UESTAX.6 and UESTAX.5 
// Setup— Request may reset endpoints, so we process data endpoints first ! 
// User defined actions have to acknowledge the interrupt ! 
ISR(USB_COM_vect) 

{ 

uint8_t mask; 
uint8_t ep; 

Debug(”ISR(USB_COM_vect)\r\n”); 
mask = UsbDevGetEndpointIntBits(); 
ep = UsbNumEndpointsAT90USB; 
while (ep — > 0) 

{ 

if (mask & (l<<ep)) 

{ 

UsbDevSelectEndpoint(ep); 
switch (ep) 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — usbJsr.c 


54 


{ 

case 0: 

if UsbDevHasReceivedSETUPC) 

U sbProcessSetupRequest() ; 

break; 
case 1: 

UsbDevEPlIntActionQ; 

break; 

case 2: 

UsbDevEP2IntAction(); 

break; 
case 3; 

UsbDevEP3IntAction(); 

break; 
case 4: 

UsbDevEP4IntAction(); 

break; 

case 5: 

UsbDevEP5IntAction(); 

break; 
case 6: 

UsbDevEP6IntAction(); 

break; 
default : 

Debugf’Error in ISR(USB COM vect)\r\n”); 

} 

} 

} 

} 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — com def.h 


55 


// AT90USB/com_defh 

// Common defines for firmware and PC program 
// S. Salewski, 23— MAR-2007 

#ifndef _COM_DEF_H_ 

#define _COM_DEF_H_ 

#define My USB VendorlD 0x()3eh // Atmel code 
#define MyUSB _ProductID 0x0001 // arbitrary value 
#define USB.VendorRequestCode (1<<6) 

// Endpoint 1, used for transferring status information : 
// Bulk IN, 8 byte FIFO 
// Filled by "NAK— IN— WAS— SEND” ISR 
#define EPl_FIFO_Size 8 

// Endpoint 2, used for transferring DAQ data: 

// Bulk IN, 64 byte dual bank FIFO 
// Filled from within timer ISR 
#define EP2 FIFO Size 64 

// Endpoint 3, used to set digital port B 
// Bulk OUT ; 8 byte FIFO 
// Read by "OUT— FIFO— IS— FILLED” ISR 
#define EP3 FIFO Size 8 

#define MaxSamples 65535 

// Status codes 

#define UsbDevStatusOK 0 

#define UsbDevStatusDAQ_BufferOverflow 1 

#define U s b Dev S t at u s D A Q _Ti m e if ) vc r fl o w 2 

#define UsbDevStatusDAQ_ConversionNotFinished 3 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — deSnes.h 


// AT90USB/defines.h 

// Adapt the constants in this file to your project 
// S. Salewski 29-JAN-2007 

#ifndef _DEFINES_H_ 

#define .DEFINES _H_ 


#define DEBUG // send debug messages over serial port 
// #undef DEBUG 


//# define NOUART // do not use usartjjrv .c at all 

#undef NOUART 


#define F XTAL 16000000 

USB is used. 

#define F_CPU 16000000UL 

#define US ART .BAUD 9600UL 
#define UART.BAUD US ART .BAUD 


// XTAL frequency (Hz). Use a crystal with 2, 4, 6, 8, 12 or 16 MHz if 2 

// mpu frequency (may be divided by prescaler, default prescaler is 8) 

// baud( rate ) for serial port 
// alias 


#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — macros.h 


57 


// AT90USB/macros.h 

// S. Salewski 29-JAN-2007 

#ifndef MACROS H 
#define _MACROS_H_ 

#define MSB(w) ((char*) &w)[l] 
#define LSB(w) ((char*) &w)[0] 

#endif 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — AT90USB-Errata.txt 


58 


ATMEL AT90USB Datasheet (7593D-AVR -07/06) 

There exists some errors or at least unclear statements as listed below: 

21.4 General Operating Modes 

21.4.2 Power— on and reset (page 253) 

The SPDCONF bits can be set by software . 

! ! ! QUESTION: What is SPDCONF 

Figure 21 — 12. USB Endpoint/Pipe Interrupt vector sources (page 256) 

Figure 22—5. USB Device Controller Endpoint Interrupt System (page 280) 

TXOUTE UEIENX.3 

! ! ! Name TXOUTE should be RXSTPE for Device-Mode 

Figure 21 — 12. USB Endpoint/Pipe Interrupt vector sources (page 256) 

Figure 23—5. USB Device Controller Pipe Interrupt System (page 300) 

UPIEN 

!!! Correct Name of register is UPIENX 

21.6.1 Device mode (page 258) 

!!! UDSS register mentioned in text does not exists . 

21.6.2 Host mode (page 259) 

When the USB interface is configured in device mode, internal Pull Down resistors are activated 
on both UDP UDM lines and the interface detects the type of device connected . 

!!! It should be ”... configured in host mode,...” 

21.12.1 USB general registers (page 264) 

4 - OTGPADE: OTG Pad Enable 

Set to enable the OTG pad. Clear to disable the OTG pad. 

!!! This bit seems to be important to activate the USB device, but its not clear 
! ! ! why and what OTG Pad is. 

21.13 USB Software Operating modes (page 267) 

Wait USB pads regulator ready state 
! ! ! How to detect ready state ? 

21.13 USB Software Operating modes (page 268) 

Set USB suspend clock 

Clear USB suspend clock 
! ! ! What is suspend clock 

22.6 Endpoint selection (page 270) 

Clearing EPNUMS 

! ! ! Register EPNUMS does not exists ! 

Figure 22—2. Endpoint activation flow: (page 271) 
the Not Yet Disable feature 
! ! ! What is the Not Yet Disable feature 

22.13 CONTROL endpoint management (page 274) 

CONTROL endpoints should not be managed by interrupts , but only by polling the status bits . 

!!! What does this mean? Using interrupts seems to work fine? 

22.12.2 STALL handshake and Retry mechanism (page 274) 

The Retry mechanism has priority over the STALL handshake. A STALL handshake is sent if the 
STALLRQ request bit is set and if there is no retry required . 

!!! What is the ’’Retry mechanism”? 



Free ( GPL) USB Firmware for Atmels AT90USB 8-bit microprocessor — AT90USB-Errata.txt 


59 


22.19.1 USB device general registers (page 281) 

2—0 — FNUM10:8 — Frame Number Upper Flag 
FNUM is updated if a corrupted SOF is received . 

! ! ! Strange statement ! 

22.19.2 USB device endpoint register 

6—0 — EPRST6:0 — Endpoint FIFO Reset Bits 

Then, cleared by software to complete the reset operation and start using the endpoint. 

!!! Is clearing by software really necessary? In most similar cases this is done by hardware! 

22.19.2 USB device endpoint registers (page 285) ***NEW 

Register UECONX: Bit 5 — STALLRQ — STALL Request Handshake Bit is marked WRITE— ONLY 
! ! ! This seems to be wrong, we can read this bit . Reading is necessary to query stalled state ! 

22.16 Isochronous mode (page 278) 

For Isochronous IN endpoints , it is possible to automatically switch the banks on each start of 
frame (SOF). This is done by setting ISOS W. The CPU has to fill the bank of the endpoint; the 
bank switching will be automatic as soon as a SOF is seen by the hardware. 

!!! ISOSW is mentioned here and in the 31. Register Summary (page 414), but no where else . 

!!! In Register Summary (page 414) Flags SOS W, AUTOS W, NYETSDIS are mentioned, but not explained! 

25.4 Prescaling and Conversion Timing (page 319) ***NEW 

setting the ADHSM bit in ADCSRB allows an increased ADC clock frequency 

! ! ! ADHSM bit is mentioned multiple times in datasheet , but it does not exist . 

25.8.2 ADC Control and Status Register A — ADCSRA (332) ***NEW 
Bits 2:0 — ADPS2:0: ADC Prescaler Select Bits 

These bits determine the division factor between the XTAL frequency and the input clock to the ADC. 

! ! ! Input clock of ADC prescaler seems to be not the XTAL frequency, but the ( already prescaled ) 

!!! mpu frequency. 


Stefan Salewski, 20-MAR-2007