First import into git

3 files changed, 1340 insertions, 0 deletions

diff --git a/usb_appl/10ch_usb_appl.c b/usb_appl/10ch_usb_appl.c
new file mode 100644
index 0000000..f5a1ce4
--- /dev/null
+++ b/usb_appl/10ch_usb_appl.c
@@ -0,0 +1,839 @@
+/*

+ * Copyright (C) 2010 Andreas Auras

+ *

+ * This file is part of the DF10CH Atmolight controller project.

+ *

+ * DF10CH Atmolight controller is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * DF10CH Atmolight controller is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ */

+

+// ======================================================================

+// Application firmware for USB processor.

+//

+

+#include <stdint.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <avr/io.h>

+#include <avr/interrupt.h>

+#include <avr/wdt.h>

+#include <avr/eeprom.h>

+#include <avr/sleep.h>

+

+#include "../df10ch_common.h"

+#include "../df10ch_usb_proto.h"

+#include "usbconfig.h"

+

+

+// ---

+// Fuse-Bit settings for the flash programmer (ATmega8):

+//	RSTDISBL=1

+//	WDTON=1

+//	SPIEN=0

+//	CKOPT=0

+//	EESAVE=1

+//	BOOTSZ1=0

+//	BOOTSZ0=0

+//	BOOTRST=1

+//

+//	BODLEVEL=0

+//	BODEN=0

+//	SUT1=0

+//	SUT0=1

+//	CKSEL3=1

+//	CKSEL2=1

+//	CKSEL1=1

+//	CKSEL0=1

+//

+// Memory-Lock Bits:

+//	BL12=1, BL11=0, BL02=1, BL01=1, LB2=1, LB1=1

+//

+FUSES = 

+{

+	.low = (FUSE_BODLEVEL & FUSE_BODEN & FUSE_SUT1),

+	.high = (FUSE_SPIEN & FUSE_CKOPT & FUSE_BOOTSZ1 & FUSE_BOOTSZ0)

+};

+LOCKBITS = (LB_MODE_1 & BLB0_MODE_1 & BLB1_MODE_2);

+

+SIGNATURE_DATA = { SIGNATURE_2, SIGNATURE_1, SIGNATURE_0 } ;

+

+

+#define EE_MEM_SIZE	(E2END + 1)

+

+

+// ---

+// System clock related.

+// System clock ist implemented with hardware timer 1

+//

+#define SYS_HWPRESCALE		1024			// Hardware Prescaler

+

+	// useconds <-> timer ticks conversation

+#define US2TICKS(t)	((uint16_t)((double)(t) * (double)F_CPU / (1000000.0 * (double)SYS_HWPRESCALE) + 0.5))

+#define	TICKS2US(t)	((uint16_t)((t) / (F_CPU / (1000000UL * SYS_HWPRESCALE))))

+

+

+// ---

+// pwm controller reset related.

+//

+#define RESET_TIME		US2TICKS(128UL)

+#define STARTUP_TIME	US2TICKS(10000UL)

+

+	// Output pin for PWM controller reset

+#define RESET_PORT		PORTB

+#define RESET_BIT			4

+

+	// Output pin for enabling PWM controller bootloader

+#define BOOTLOADER_PORT 	PORTB

+#define BOOTLOADER_BIT		3

+

+

+// ---

+// bootloader related.

+//

+#define BL_START_VECT			0x1800

+

+// Input/Output pin for bootloader startup

+#define BL_SENSE_DDR		DDRB

+#define BL_SENSE_PORT 	PORTB

+#define BL_SENSE_PIN	 	PINB

+#define BL_SENSE_BIT		0

+

+#define BL_START_DELAY_TIME			US2TICKS(30000UL)

+

+static uint8_t 	bl_start;

+static uint16_t	bl_time;

+

+

+// ---

+// USB related.

+//

+#define USB_SLEEP_TIMEOUT				US2TICKS(5000UL)

+#define USB_DISCONNECT_TIME			US2TICKS(500000UL)

+#define USB_INITIALIZE_TIMEOUT	US2TICKS(1750000UL)

+#define USB_STALL_RC						0xFF

+

+volatile uint16_t usb_sof_time;					// Time of last USB start of frame IRQ
+static uint8_t usb_is_resetting;				// Is true while reset condition on USB bus happen

+static uint8_t usb_is_initialized;			// Is true after USB address has been set

+static uint8_t usb_last_data_token;			// Token PID of last usb packet received

+static uint8_t usb_last_rc;							// Return status of last payload packet

+static uint8_t payload_req;							// ID of actual proccessed USB request

+static uint16_t payload_pos;						// Position of actual payload read/write

+static uint16_t payload_count;					// Number of bytes left of actual payload read/write

+

+

+

+// ---

+// RX buffer related.

+//

+#define RXBUF_SIZE 256

+#if RXBUF_SIZE == 256

+#define CHECK_RXBUF_END(pos)

+#else

+#define CHECK_RXBUF_END(pos)	if ((pos) == RXBUF_SIZE) (pos) = 0

+#endif

+

+static volatile uint8_t rxrpos, rxwpos;

+static volatile uint8_t rxspos;	// Start position of reply

+static uint8_t rxbuf[RXBUF_SIZE] NOMEMINIT;

+

+

+// ---

+// TX buffer related.

+//

+#define TXBUF_SIZE 256

+#if TXBUF_SIZE == 256

+#define CHECK_TXBUF_END(pos)

+#else

+#define CHECK_TXBUF_END(pos)	if ((pos) == TXBUF_SIZE) (pos) = 0

+#endif

+

+static uint8_t txrpos, txwpos;

+static uint8_t txbuf[TXBUF_SIZE] NOMEMINIT;

+

+

+// ---

+// PWM controller communication related.

+//

+#define REPLY_START_TIMEOUT	US2TICKS(50000UL)

+#define REPLY_TIMEOUT				US2TICKS(10000UL)

+

+static uint8_t actual_req_id;

+static uint8_t reply_start;

+static uint8_t reply_count;

+static volatile uint8_t reply_err_status;

+static uint16_t reply_start_timeout = REPLY_START_TIMEOUT;

+static uint16_t reply_timeout = REPLY_TIMEOUT;

+

+

+// ---

+// Port setup related.

+//

+#define PORTB_INIT	(_BV(BL_SENSE_BIT) | _BV(BOOTLOADER_BIT) | _BV(1) | _BV(2) | _BV(5))

+#define DDRB_INIT		(_BV(BOOTLOADER_BIT) | _BV(RESET_BIT))

+

+#define PORTC_INIT	(0xFF)

+#define DDRC_INIT		(0)

+

+#define PORTD_INIT	(_BV(1) | _BV(5) | _BV(6) | _BV(7))

+#define DDRD_INIT		(_BV(1))

+

+

+#include <usbdrv.c>

+

+

+// ---

+// ISR handler for IRQ's that do not have a dedicated handler.

+//

+ISR(BADISR_vect)

+{

+		for (;;);    // wait until watchdog resets device

+}

+

+

+// ---

+// ISR for receiving data.

+//

+ISR(USART_RXC_vect)

+{

+	clear_bit(UCSRB, RXCIE);

+	sei();

+

+	do

+	{

+		uint8_t i = rxwpos;

+		uint8_t p = i + 1;

+		CHECK_RXBUF_END(p);

+

+		if (bit_is_set(UCSRA, DOR))

+			set_bit(reply_err_status, COMM_ERR_OVERRUN);

+		else if (bit_is_set(UCSRA, FE))

+			set_bit(reply_err_status, COMM_ERR_FRAME);

+		else if (p == rxrpos)

+			set_bit(reply_err_status, COMM_ERR_OVERFLOW);

+		else

+		{

+			if (bit_is_set(UCSRB, RXB8))

+				rxspos = i;	// save reply start position

+			rxwpos = p;		// set data valid

+		}

+		rxbuf[i] = UDR;	// read data

+	}

+	while (bit_is_set(UCSRA, RXC));

+

+	cli();

+	set_bit(UCSRB, RXCIE);

+}

+

+

+// ---

+// Read actual system clock counter.

+// Note: Counter is also read inside USB irq handler -> we need save read!

+//

+static uint16_t get_sys_clock(void)

+{

+	uint8_t sreg = SREG;

+	cli();

+	uint16_t t = TCNT1;

+	SREG = sreg;

+	nop();

+	return t;

+}

+

+

+// ---

+// Calculate timer ticks from milliseconds.

+//

+static uint16_t ms_to_ticks(uint16_t ms)

+{

+	uint32_t t = F_CPU / SYS_HWPRESCALE;

+	t *= ms;

+	t /= 1000;

+	return (uint16_t) t;

+}

+

+

+// ---

+// Processing while waiting for a event.

+//

+static void background_processing(void)

+{

+	wdt_reset();

+

+		// Write data from transmit buffer to USART

+	while (bit_is_set(UCSRA, UDRE))

+	{

+		uint8_t p = txrpos;

+		if (p == txwpos)

+			break;

+

+		UDR = txbuf[p++];

+		CHECK_TXBUF_END(p);

+		txrpos = p;

+	}

+}

+

+

+// ---

+// Timer based delay.

+//

+static void timer_delay(uint16_t d)

+{

+	uint16_t t = get_sys_clock();

+	while ((get_sys_clock() - t) < d)

+		background_processing();

+}

+

+

+// ---

+// Put data into transmit buffer.

+//

+static void send_data(uint8_t c)

+{

+	uint8_t p = txwpos + 1;

+	CHECK_TXBUF_END(p);

+

+		// Wait until space available

+	while (p == txrpos)

+		background_processing();

+

+	txbuf[txwpos] = c;

+	txwpos = p;

+

+	background_processing();

+}

+

+

+// ---

+// Send command request for PWM controller.

+//

+static void send_request(uint8_t req_type)

+{

+		// Wait until transmit buffers are empty

+	while (txrpos != txwpos || bit_is_clear(UCSRA, UDRE))

+		background_processing();

+

+	rxspos = rxwpos - 1;		// Reset start reply position

+

+	++actual_req_id;

+	actual_req_id &= PWMRQ_ID_MASK;

+

+	set_bit(UCSRB, TXB8);						// Set 9th bit for start of request

+	UDR = req_type | actual_req_id;	// Send request type and id unbuffered

+	clear_bit(UCSRB, TXB8);

+}

+

+

+// ---

+// Read reply data.

+//

+static uint8_t read_data(void)

+{

+	uint8_t p = rxrpos;

+	uint8_t c = rxbuf[p++];

+	CHECK_RXBUF_END(p);

+	rxrpos = p;

+	return c;

+}

+

+

+// ---

+// Wait for reply data from PWM controller.

+//

+static uint8_t wait_for_reply(void)

+{

+	uint16_t t = get_sys_clock();

+	uint16_t d = reply_timeout;

+

+	while ((get_sys_clock() - t) < d)

+	{

+		background_processing();

+

+		if (rxwpos != rxrpos)

+		{

+			if (reply_start == rxspos)	// Check for same reply

+				return 1;

+			set_bit(reply_err_status, COMM_ERR_START);

+			return 0;

+		}

+	}

+

+	set_bit(reply_err_status, COMM_ERR_TIMEOUT);

+	return 0;

+}

+

+

+// ---

+// Wait for start of reply data from PWM controller.

+//

+static uint8_t wait_for_reply_start(void)

+{

+	uint16_t t = get_sys_clock();

+	uint16_t d = reply_start_timeout;

+

+	while ((get_sys_clock() - t) < d)

+	{

+		background_processing();

+

+		uint8_t p = rxrpos;

+		if (rxwpos != p)

+		{

+			if (rxspos == p)

+			{		// reply start detected

+				uint8_t id = read_data();

+				if (id == PWMRP_KEEP_ALIVE)

+				{		// keep alive reply

+					t = get_sys_clock();

+					continue;

+				}

+				if ((id & PWMRQ_ID_MASK) == actual_req_id)

+				{		// reply is for actual request

+					reply_start = p;

+					if (!(id & PWMRP_HAS_PAYLOAD))

+					{

+						reply_count = 0;

+						return 1;

+					}

+					if (wait_for_reply())

+					{

+						reply_count = read_data();

+						return 1;

+					}

+					return 0;

+				}

+			}

+				// drop garbagge

+			++p;

+			CHECK_RXBUF_END(p);

+			rxrpos = p;

+		}

+

+		if (bit_is_clear(UCSRA, TXC))

+			t = get_sys_clock();

+	}

+

+	set_bit(reply_err_status, COMM_ERR_TIMEOUT);

+	return 0;

+}

+

+

+// ---

+// Stop PWM controller.

+//

+static void stop_pwm_ctrl(void)

+{

+	clear_bit(UCSRB, RXEN);	// Disable USART RX

+	clear_bit(RESET_PORT, RESET_BIT);

+}

+

+

+// ---

+// Reset PWM controller.

+//

+static void reset_pwm_ctrl(void)

+{

+	stop_pwm_ctrl();

+	timer_delay(RESET_TIME);

+

+	set_bit(RESET_PORT, RESET_BIT);

+	timer_delay(STARTUP_TIME);

+

+	rxwpos = rxrpos = 0;	// Flush reply buffer

+	reply_err_status = 0;

+

+	set_bit(UCSRB, RXEN);		// Enable USART RX

+}

+

+

+// ---

+// Send PWM controller request payload data.

+//

+static uint8_t send_payload_data(uint8_t *data, uint8_t len)

+{

+	if(len > payload_count)

+		len = payload_count;

+	payload_count -= len;

+

+	uint8_t i = 0;

+	while (i < len)

+		send_data(data[i++]);

+

+	if (!payload_count)

+	{

+		if (wait_for_reply_start())	// Wait for ACK

+			return 1; // all done successfull

+		return USB_STALL_RC; // error happen

+	}

+

+	return 0; // next packet

+}

+

+

+// ---

+// Read PWM controller request payload data.

+//

+static uint8_t read_payload_data(uint8_t *data, uint8_t len)

+{

+	if (len > reply_count)

+		len = reply_count;

+	if(len > payload_count)

+		len = payload_count;

+	reply_count -= len;

+	payload_count -= len;

+

+	uint8_t i = 0;

+	while (i < len && wait_for_reply())

+		data[i++] = read_data();

+

+	if (i < len)

+		return USB_STALL_RC;	// error happen

+

+	return i;

+}

+

+

+// ---

+// Write EE prom data.

+//

+static uint8_t write_ee_data(uint8_t *data, uint8_t len)

+{

+	if(len > payload_count)

+		len = payload_count;

+	payload_count -= len;

+

+	uint8_t i = 0;

+	while (i < len && payload_pos < EE_MEM_SIZE)

+	{

+		uint8_t old_data = eeprom_read_byte((uint8_t *)payload_pos);

+		uint8_t new_data = data[i];

+		if (old_data != new_data)

+		{

+			eeprom_write_byte((uint8_t *)payload_pos, new_data);

+

+			while (!eeprom_is_ready())

+				background_processing();

+

+			old_data = eeprom_read_byte((uint8_t *)payload_pos);

+			if (old_data != new_data)

+				return USB_STALL_RC; // write error

+		}

+		++i;

+		++payload_pos;

+	}

+

+	return payload_count == 0;

+}

+

+

+// ---

+// Read EE prom data.

+//

+static uint8_t read_ee_data(uint8_t *data, uint8_t len)

+{

+	if(len > payload_count)

+		len = payload_count;

+	payload_count -= len;

+

+	uint8_t i = 0;

+	while (i < len && payload_pos < EE_MEM_SIZE)

+	{

+		data[i] = eeprom_read_byte((uint8_t *)payload_pos);

+		++i;

+		++payload_pos;

+	}

+

+	return i;

+}

+

+

+// ---

+// Write request payload data.

+//

+USB_PUBLIC uint8_t usbFunctionWrite(uint8_t *data, uint8_t len)

+{

+	uint8_t rc = USB_STALL_RC;

+

+	if (usb_last_rc != USB_STALL_RC)

+	{

+		if (len != 8 || usbCrc16(data, 8) == ((uint16_t *)data)[4])

+		{

+			if (usbCurrentDataToken == usb_last_data_token)

+			{

+				set_bit(reply_err_status, COMM_ERR_DUPLICATE);

+				return usb_last_rc;	// Ignore packet

+			}

+

+			if (payload_req >= REQ_PWM_START)

+				rc = send_payload_data(data, len);

+			else if (payload_req == REQ_WRITE_EE_DATA)

+				rc = write_ee_data(data, len);

+		}

+		else

+			set_bit(reply_err_status, COMM_ERR_CRC);

+	}

+

+	usb_last_data_token = usbCurrentDataToken;

+	usb_last_rc = rc;

+

+	return rc;

+}

+

+

+// ---

+// Read request payload data.

+//

+USB_PUBLIC uint8_t usbFunctionRead(uint8_t *data, uint8_t len)

+{

+	uint8_t rc = USB_STALL_RC;

+

+	if (usb_last_rc != USB_STALL_RC)

+	{

+		if (payload_req >= REQ_PWM_START)

+			rc = read_payload_data(data, len);

+		else if (payload_req == REQ_READ_EE_DATA)

+			rc = read_ee_data(data, len);

+	}

+

+	usb_last_rc = rc;

+

+	return rc;

+}

+

+

+// ---

+// Handle a non-standard USB SETUP packet.

+//

+USB_PUBLIC usbMsgLen_t usbFunctionSetup(uint8_t data[8])

+{

+	usbRequest_t *r = (usbRequest_t *) data;

+	static uint8_t reply[1];

+

+	usb_last_data_token = USBPID_SETUP;

+	usb_last_rc = USB_STALL_RC;

+	uint8_t rc = USB_NO_MSG;

+

+	if (usbCrc16(data, 8) != ((uint16_t *)data)[4])

+	{

+		set_bit(reply_err_status, COMM_ERR_CRC);

+		return rc;

+	}

+

+	uint8_t req = r->bRequest;

+

+	if (req >= REQ_PWM_START)

+	{

+		if (bit_is_clear (RESET_PORT, RESET_BIT))

+			reset_pwm_ctrl();

+			

+		uint8_t req_type = (r->bmRequestType & USBRQ_DIR_MASK) == USBRQ_DIR_DEVICE_TO_HOST ? PWMRQ_DEVICE_TO_HOST: 0;

+		if (r->wLength.word <= MAX_REQ_PAYLOAD_SIZE)

+		{

+			send_request(req_type);

+			send_data(req);

+			send_data(r->wValue.bytes[0]);

+			send_data(r->wValue.bytes[1]);

+			send_data(r->wIndex.bytes[0]);

+			send_data(r->wIndex.bytes[1]);

+			send_data(r->wLength.bytes[0]);

+			send_data(r->wLength.bytes[1]);

+

+			payload_req = req;

+			payload_count = r->wLength.word;

+

+			if (req_type == PWMRQ_DEVICE_TO_HOST || !r->wLength.word)

+			{

+				if (wait_for_reply_start())

+				{

+					if (reply_count && r->wLength.word)

+						usb_last_rc = 0;

+					else

+						rc = 0;

+				}

+			}

+			else

+				usb_last_rc = 0;

+		}

+	}

+	else if (req == REQ_READ_EE_DATA || req == REQ_WRITE_EE_DATA)

+	{

+		if (r->wLength.word)

+		{

+			payload_pos = r->wIndex.word;

+			payload_req = req;

+			payload_count = r->wLength.word;

+			usb_last_rc = 0;

+		}

+		else

+			rc = 0;

+	}

+	else if (req == REQ_STOP_PWM_CTRL)

+	{

+		set_bit(BOOTLOADER_PORT, BOOTLOADER_BIT);

+		stop_pwm_ctrl();

+		rc = 0;

+	}

+	else if (req == REQ_RESET_PWM_CTRL)

+	{

+		set_bit(BOOTLOADER_PORT, BOOTLOADER_BIT);

+		reset_pwm_ctrl();

+		rc = 0;

+	}

+	else if (req == REQ_BOOTLOADER_RESET_PWM_CTRL)

+	{

+		clear_bit(BOOTLOADER_PORT, BOOTLOADER_BIT);

+		reset_pwm_ctrl();

+		rc = 0;

+	}

+	else if (req == REQ_GET_REPLY_ERR_STATUS)

+	{

+		reply[0] = reply_err_status;

+		reply_err_status = 0; 

+		usbMsgPtr = reply;

+		rc = 1;

+	}

+	else if (req == REQ_SET_REPLY_TIMEOUT)

+	{

+		reply_start_timeout = ms_to_ticks(r->wValue.word);

+		reply_timeout = ms_to_ticks(r->wIndex.word);

+		rc = 0;

+	}

+	else if (req == REQ_START_BOOTLOADER)

+	{

+		bl_start = 1;

+		bl_time = get_sys_clock();

+		rc = 0;

+	}

+

+	return rc;

+}

+

+

+// ----

+// Main

+//

+void main(void) NORETURN;

+void main(void)

+{

+  wdt_enable(WDTO_120MS);	// Set watchdog timeout

+

+		// Initialize Ports

+	PORTB = PORTB_INIT;

+	DDRB = DDRB_INIT;

+	PORTC = PORTC_INIT;

+	DDRC = DDRC_INIT;

+	PORTD = PORTD_INIT;

+	DDRD = DDRD_INIT;

+

+	usbDeviceDisconnect();

+

+	set_bit(ACSR, ACD);	// Disable analog comparator saving some power

+

+		// Initialize Timer 1

+	TCNT1 = 0;

+	TCCR1B = _BV(CS12) | _BV(CS10);			// Start timer 1, Prescaler 1024

+

+		// Initialize USART

+#include <util/setbaud.h>

+  UBRRH = UBRRH_VALUE;

+  UBRRL = UBRRL_VALUE;

+#if USE_2X

+  UCSRA = _BV(U2X);

+#endif

+	UCSRC = _BV(URSEL) | _BV(UCSZ1) | _BV(UCSZ0);	// 9 data bits, 1 stop bit, no parity, asynchron mode

+  UCSRB = _BV(TXEN) | _BV(UCSZ2) | _BV(RXCIE);	// Enable TX and RX IRQ

+

+	reset_pwm_ctrl();

+

+	timer_delay(USB_DISCONNECT_TIME);

+	usbDeviceConnect();

+	usbInit();

+

+	sei();

+

+		// Main loop

+  for (;;)

+  {	

+		background_processing();

+

+		usbPoll();	// process USB requests

+

+		if ((bit_is_clear(BL_SENSE_PIN, BL_SENSE_BIT) ||

+				 (bl_start && (get_sys_clock() - bl_time) > BL_START_DELAY_TIME)) &&

+				 pgm_read_word(BL_START_VECT) != 0xFFFF)

+		{

+			cli();

+			stop_pwm_ctrl();

+	    clear_bit(USB_INTR_ENABLE, USB_INTR_ENABLE_BIT);	// Stop USB

+			UCSRB = 0;	// Stop USART

+			TCCR1B = 0;	// Stop Timer
+

+				// enable boot loader by setting sense pin to 0

+			clear_bit(BL_SENSE_PORT, BL_SENSE_BIT);

+			set_bit(BL_SENSE_DDR, BL_SENSE_BIT);

+

+				// start bootloader

+			void (*jump_to_bl)(void) = BL_START_VECT / 2;		// Need flash word address for jump!

+			jump_to_bl();

+		}

+

+

+#if 0

+		if (!usb_is_initialized && get_sys_clock() > USB_INITIALIZE_TIMEOUT)

+		{		// request USB device enumeration

+			cli();

+			usb_is_initialized = 1;

+			usbDeviceDisconnect();

+			timer_delay(USB_DISCONNECT_TIME);

+			usbDeviceConnect();

+			usbInit();

+			sei();

+		}

+#endif

+

+			// Check for standby state

+		if (usb_is_resetting)

+		{		// ongoing USB reset -> reset activity timeout

+			cli();

+			usb_sof_time = TCNT1;

+			sei();

+		}

+		else

+		{

+			cli();

+			uint16_t t = usb_sof_time;

+			sei();

+			if ((get_sys_clock() - t) > USB_SLEEP_TIMEOUT)

+			{		// no USB activity -> go sleeping

+				cli();

+				stop_pwm_ctrl();

+	      set_sleep_mode(SLEEP_MODE_PWR_DOWN);

+				USB_INTR_CFG &= ~USB_INTR_CFG_SET;	// set low level triggered IRQ for wakeup

+				USB_INTR_PENDING = _BV(USB_INTR_PENDING_BIT);	// reset pending IRQ

+				wdt_disable();

+        sleep_enable();

+        sei();

+        sleep_cpu();

+        sleep_disable();

+			  wdt_enable(WDTO_30MS);

+				cli();

+				TCNT1 = 0;

+				usb_sof_time = 0;

+				sei();

+				reset_pwm_ctrl();			

+			}

+		}

+  }

+}

diff --git a/usb_appl/Makefile b/usb_appl/Makefile
new file mode 100644
index 0000000..03ca6d8
--- /dev/null
+++ b/usb_appl/Makefile
@@ -0,0 +1,109 @@
+#

+# Copyright (C) 2010 Andreas Auras

+#

+# This file is part of the DF10CH Atmolight controller project.

+#

+# DF10CH Atmolight controller is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# DF10CH Atmolight controller is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+#

+#

+###############################################################################

+# Makefile for the application firmware of USB processor

+###############################################################################

+

+## General Flags

+PROJECT = 10ch_usb_appl

+MCU = atmega8

+TARGET = 10ch_usb_appl.elf

+CC = avr-gcc

+AVRDUDE ?= avrdude -c stk500v2 -P avrdoper

+USBDRV ?= ../usbdrv

+F_CPU ?= 16000000UL

+FIRMWARE_VERSION ?= 1

+

+## Options common to compile, link and assembly rules

+COMMON = -mmcu=$(MCU)

+

+## Compile options common for all C compilation units.

+CFLAGS = $(COMMON)

+CFLAGS += -Wall -gdwarf-2 -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums

+CFLAGS += -DF_CPU=$(F_CPU) -DFIRMWARE_VERSION=$(FIRMWARE_VERSION)

+

+## Assembly specific flags

+ASMFLAGS = $(COMMON)

+ASMFLAGS += $(CFLAGS)

+ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2

+

+## Linker flags

+LDFLAGS = $(COMMON)

+LDFLAGS += -Wl,-Map=10ch_usb_appl.map

+

+

+## Intel Hex file production flags

+HEX_FLASH_FLAGS = -R .eeprom -R .fuse -R .lock -R .signature

+

+HEX_EEPROM_FLAGS = -j .eeprom

+HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"

+

+## Include Directories

+INCLUDES = -I. -I.. -I$(USBDRV) 

+

+## Objects that must be built in order to link

+OBJECTS = 10ch_usb_appl.o usbdrvasm.o 

+

+## Objects explicitly added by the user

+LINKONLYOBJECTS = 

+

+## Build

+all: $(TARGET) 10ch_usb_appl.dff 10ch_usb_appl.lss size

+

+10ch_usb_appl.dff: 10ch_usb_appl.hex

+	echo "@DF10CH-USB" $(FIRMWARE_VERSION) > $@

+	cat 10ch_usb_appl.hex >> $@

+	

+prog: flash

+	$(AVRDUDE) -p $(MCU) -u -Ulfuse:w:0x1F:m -Uhfuse:w:0xC9:m -Ulock:w:0xEF:m

+

+flash: 10ch_usb_appl.hex

+	$(AVRDUDE) -p $(MCU) -Uflash:w:10ch_usb_appl.hex:i

+

+

+## Compile

+usbdrvasm.o: $(USBDRV)/usbdrvasm.S usbconfig.h

+	$(CC) $(INCLUDES) $(ASMFLAGS) -c  $<

+

+10ch_usb_appl.o: 10ch_usb_appl.c usbconfig.h ../df10ch_usb_proto.h ../df10ch_common.h

+	$(CC) $(INCLUDES) $(CFLAGS) -c  $<

+

+##Link

+$(TARGET): $(OBJECTS)

+	 $(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o $(TARGET)

+

+%.hex: $(TARGET)

+	avr-objcopy -O ihex $(HEX_FLASH_FLAGS)  $< $@

+

+%.eep: $(TARGET)

+	-avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@ || exit 0

+

+%.lss: $(TARGET)

+	avr-objdump -h -S $< > $@

+

+size: ${TARGET}

+	@echo

+	@avr-size -C --mcu=${MCU} ${TARGET}

+

+## Clean target

+.PHONY: clean

+clean:

+	-rm -rf $(OBJECTS) 10ch_usb_appl.elf 10ch_usb_appl.dff 10ch_usb_appl.hex 10ch_usb_appl.eep 10ch_usb_appl.lss 10ch_usb_appl.map

diff --git a/usb_appl/usbconfig.h b/usb_appl/usbconfig.h
new file mode 100644
index 0000000..0744d16
--- /dev/null
+++ b/usb_appl/usbconfig.h
@@ -0,0 +1,392 @@
+/* Name: usbconfig.h
+ * Project: V-USB, virtual USB port for Atmel's(r) AVR(r) microcontrollers
+ * Author: Christian Starkjohann
+ * Creation Date: 2005-04-01
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbconfig-prototype.h 740 2009-04-13 18:23:31Z cs $
+ */
+
+#ifndef __usbconfig_h_included__
+#define __usbconfig_h_included__
+
+/*
+General Description:
+This file is an example configuration (with inline documentation) for the USB
+driver. It configures V-USB for USB D+ connected to Port D bit 2 (which is
+also hardware interrupt 0 on many devices) and USB D- to Port D bit 4. You may
+wire the lines to any other port, as long as D+ is also wired to INT0 (or any
+other hardware interrupt, as long as it is the highest level interrupt, see
+section at the end of this file).
++ To create your own usbconfig.h file, copy this file to your project's
++ firmware source directory) and rename it to "usbconfig.h".
++ Then edit it accordingly.
+*/
+
+/* ---------------------------- Hardware Config ---------------------------- */
+
+#define USB_CFG_IOPORTNAME      D
+/* This is the port where the USB bus is connected. When you configure it to
+ * "B", the registers PORTB, PINB and DDRB will be used.
+ */
+#define USB_CFG_DMINUS_BIT      3
+/* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected.
+ * This may be any bit in the port.
+ */
+#define USB_CFG_DPLUS_BIT       2
+/* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected.
+ * This may be any bit in the port. Please note that D+ must also be connected
+ * to interrupt pin INT0! [You can also use other interrupts, see section
+ * "Optional MCU Description" below, or you can connect D- to the interrupt, as
+ * it is required if you use the USB_COUNT_SOF feature. If you use D- for the
+ * interrupt, the USB interrupt will also be triggered at Start-Of-Frame
+ * markers every millisecond.]
+ */
+#define USB_CFG_CLOCK_KHZ       (F_CPU/1000)
+/* Clock rate of the AVR in kHz. Legal values are 12000, 12800, 15000, 16000,
+ * 16500 and 20000. The 12.8 MHz and 16.5 MHz versions of the code require no
+ * crystal, they tolerate +/- 1% deviation from the nominal frequency. All
+ * other rates require a precision of 2000 ppm and thus a crystal!
+ * Default if not specified: 12 MHz
+ */
+#define USB_CFG_CHECK_CRC       0
+/* Define this to 1 if you want that the driver checks integrity of incoming
+ * data packets (CRC checks). CRC checks cost quite a bit of code size and are
+ * currently only available for 18 MHz crystal clock. You must choose
+ * USB_CFG_CLOCK_KHZ = 18000 if you enable this option.
+ */
+
+/* ----------------------- Optional Hardware Config ------------------------ */
+
+#define USB_CFG_PULLUP_IOPORTNAME   D
+/* If you connect the 1.5k pullup resistor from D- to a port pin instead of
+ * V+, you can connect and disconnect the device from firmware by calling
+ * the macros usbDeviceConnect() and usbDeviceDisconnect() (see usbdrv.h).
+ * This constant defines the port on which the pullup resistor is connected.
+ */
+#define USB_CFG_PULLUP_BIT          4
+/* This constant defines the bit number in USB_CFG_PULLUP_IOPORT (defined
+ * above) where the 1.5k pullup resistor is connected. See description
+ * above for details.
+ */
+
+/* --------------------------- Functional Range ---------------------------- */
+
+#define USB_CFG_HAVE_INTRIN_ENDPOINT    0
+/* Define this to 1 if you want to compile a version with two endpoints: The
+ * default control endpoint 0 and an interrupt-in endpoint (any other endpoint
+ * number).
+ */
+#define USB_CFG_HAVE_INTRIN_ENDPOINT3   0
+/* Define this to 1 if you want to compile a version with three endpoints: The
+ * default control endpoint 0, an interrupt-in endpoint 3 (or the number
+ * configured below) and a catch-all default interrupt-in endpoint as above.
+ * You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature.
+ */
+#define USB_CFG_EP3_NUMBER              3
+/* If the so-called endpoint 3 is used, it can now be configured to any other
+ * endpoint number (except 0) with this macro. Default if undefined is 3.
+ */
+/* #define USB_INITIAL_DATATOKEN           USBPID_DATA1 */
+/* The above macro defines the startup condition for data toggling on the
+ * interrupt/bulk endpoints 1 and 3. Defaults to USBPID_DATA1.
+ * Since the token is toggled BEFORE sending any data, the first packet is
+ * sent with the oposite value of this configuration!
+ */
+#define USB_CFG_IMPLEMENT_HALT          0
+/* Define this to 1 if you also want to implement the ENDPOINT_HALT feature
+ * for endpoint 1 (interrupt endpoint). Although you may not need this feature,
+ * it is required by the standard. We have made it a config option because it
+ * bloats the code considerably.
+ */
+#define USB_CFG_SUPPRESS_INTR_CODE      0
+/* Define this to 1 if you want to declare interrupt-in endpoints, but don't
+ * want to send any data over them. If this macro is defined to 1, functions
+ * usbSetInterrupt() and usbSetInterrupt3() are omitted. This is useful if
+ * you need the interrupt-in endpoints in order to comply to an interface
+ * (e.g. HID), but never want to send any data. This option saves a couple
+ * of bytes in flash memory and the transmit buffers in RAM.
+ */
+#define USB_CFG_INTR_POLL_INTERVAL      25
+/* If you compile a version with endpoint 1 (interrupt-in), this is the poll
+ * interval. The value is in milliseconds and must not be less than 10 ms for
+ * low speed devices.
+ */
+#define USB_CFG_IS_SELF_POWERED         0
+/* Define this to 1 if the device has its own power supply. Set it to 0 if the
+ * device is powered from the USB bus.
+ */
+#define USB_CFG_MAX_BUS_POWER           98
+/* Set this variable to the maximum USB bus power consumption of your device.
+ * The value is in milliamperes. [It will be divided by two since USB
+ * communicates power requirements in units of 2 mA.]
+ */
+#define USB_CFG_IMPLEMENT_FN_WRITE      1
+/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
+ * transfers. Set it to 0 if you don't need it and want to save a couple of
+ * bytes.
+ */
+#define USB_CFG_IMPLEMENT_FN_READ       1
+/* Set this to 1 if you need to send control replies which are generated
+ * "on the fly" when usbFunctionRead() is called. If you only want to send
+ * data from a static buffer, set it to 0 and return the data from
+ * usbFunctionSetup(). This saves a couple of bytes.
+ */
+#define USB_CFG_IMPLEMENT_FN_WRITEOUT   0
+/* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints.
+ * You must implement the function usbFunctionWriteOut() which receives all
+ * interrupt/bulk data sent to any endpoint other than 0. The endpoint number
+ * can be found in 'usbRxToken'.
+ */
+#define USB_CFG_HAVE_FLOWCONTROL        0
+/* Define this to 1 if you want flowcontrol over USB data. See the definition
+ * of the macros usbDisableAllRequests() and usbEnableAllRequests() in
+ * usbdrv.h.
+ */
+#define USB_CFG_LONG_TRANSFERS          0
+/* Define this to 1 if you want to send/receive blocks of more than 254 bytes
+ * in a single control-in or control-out transfer. Note that the capability
+ * for long transfers increases the driver size.
+ */
+/* #define USB_RX_USER_HOOK(data, len)     if(usbRxToken == (uchar)USBPID_SETUP) blinkLED(); */
+/* This macro is a hook if you want to do unconventional things. If it is
+ * defined, it's inserted at the beginning of received message processing.
+ * If you eat the received message and don't want default processing to
+ * proceed, do a return after doing your things. One possible application
+ * (besides debugging) is to flash a status LED on each packet.
+ */
+#define USB_RESET_HOOK(resetStarts)     usb_is_resetting = resetStarts;
+/* This macro is a hook if you need to know when an USB RESET occurs. It has
+ * one parameter which distinguishes between the start of RESET state and its
+ * end.
+ */
+#define USB_SET_ADDRESS_HOOK()          usb_is_initialized = 1;
+/* This macro (if defined) is executed when a USB SET_ADDRESS request was
+ * received.
+ */
+#define USB_COUNT_SOF                   0
+/* define this macro to 1 if you need the global variable "usbSofCount" which
+ * counts SOF packets. This feature requires that the hardware interrupt is
+ * connected to D- instead of D+.
+ */
+#define USB_SOF_HOOK                    customSofHook
+/* This macro (if defined) is executed in the assembler module when a
+ * Start Of Frame condition is detected. It is recommended to define it to
+ * the name of an assembler macro which is defined here as well so that more
+ * than one assembler instruction can be used. The macro may use the register
+ * YL and modify SREG. If it lasts longer than a couple of cycles, USB messages
+ * immediately after an SOF pulse may be lost and must be retried by the host.
+ * What can you do with this hook? Since the SOF signal occurs exactly every
+ * 1 ms (unless the host is in sleep mode), you can use it to tune OSCCAL in
+ * designs running on the internal RC oscillator.
+ * Please note that Start Of Frame detection works only if D- is wired to the
+ * interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES!
+ */
+

+/* Save timestamp of sof */

+
+#ifdef __ASSEMBLER__

+macro customSofHook

+    in      YL, TCNT1L
+    sts     usb_sof_time, YL
+    in      YL, TCNT1H
+    sts     usb_sof_time+1, YL
+endm
+#endif
+

+#define USB_CFG_CHECK_DATA_TOGGLING     1
+/* define this macro to 1 if you want to filter out duplicate data packets
+ * sent by the host. Duplicates occur only as a consequence of communication
+ * errors, when the host does not receive an ACK. Please note that you need to
+ * implement the filtering yourself in usbFunctionWriteOut() and
+ * usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable
+ * for each control- and out-endpoint to check for duplicate packets.
+ */
+#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH   0
+/* define this macro to 1 if you want the function usbMeasureFrameLength()
+ * compiled in. This function can be used to calibrate the AVR's RC oscillator.
+ */
+#define USB_USE_FAST_CRC                1

+/* The assembler module has two implementations for the CRC algorithm. One is

+ * faster, the other is smaller. This CRC routine is only used for transmitted

+ * messages where timing is not critical. The faster routine needs 31 cycles

+ * per byte while the smaller one needs 61 to 69 cycles. The faster routine

+ * may be worth the 32 bytes bigger code size if you transmit lots of data and

+ * run the AVR close to its limit.

+ */

+

+/* -------------------------- Device Description --------------------------- */
+
+#define  USB_CFG_VENDOR_ID       0xc0, 0x16
+/* USB vendor ID for the device, low byte first. If you have registered your
+ * own Vendor ID, define it here. Otherwise you use one of obdev's free shared
+ * VID/PID pairs. Be sure to read USBID-License.txt for rules!
+ * + This template uses obdev's shared VID/PID pair: 0x16c0/0x5dc.
+ * + Use this VID/PID pair ONLY if you understand the implications!
+ */
+#define  USB_CFG_DEVICE_ID       0xdc, 0x05
+/* This is the ID of the product, low byte first. It is interpreted in the
+ * scope of the vendor ID. If you have registered your own VID with usb.org
+ * or if you have licensed a PID from somebody else, define it here. Otherwise
+ * you use obdev's free shared VID/PID pair. Be sure to read the rules in
+ * USBID-License.txt!
+ * + This template uses obdev's shared VID/PID pair: 0x16c0/0x5dc.
+ * + Use this VID/PID pair ONLY if you understand the implications!
+ */
+#define USB_CFG_DEVICE_VERSION  0x00, FIRMWARE_VERSION
+/* Version number of the device: Minor number first, then major number.
+ */
+#define USB_CFG_VENDOR_NAME     'y', 'a', 'k', '5', '4', '@', 'g', 'm', 'x', '.', 'n', 'e', 't'
+#define USB_CFG_VENDOR_NAME_LEN 13
+/* These two values define the vendor name returned by the USB device. The name
+ * must be given as a list of characters under single quotes. The characters
+ * are interpreted as Unicode (UTF-16) entities.
+ * If you don't want a vendor name string, undefine these macros.
+ * ALWAYS define a vendor name containing your Internet domain name if you use
+ * obdev's free shared VID/PID pair. See the file USBID-License.txt for
+ * details.
+ */
+#define USB_CFG_DEVICE_NAME     'D', 'F', '1', '0', 'C', 'H'
+#define USB_CFG_DEVICE_NAME_LEN 6
+/* Same as above for the device name. If you don't want a device name, undefine
+ * the macros. See the file USBID-License.txt before you assign a name if you
+ * use a shared VID/PID.
+ */
+#define USB_CFG_SERIAL_NUMBER   'A', 'P'
+#define USB_CFG_SERIAL_NUMBER_LEN   2
+/* Same as above for the serial number. If you don't want a serial number,
+ * undefine the macros.
+ * It may be useful to provide the serial number through other means than at
+ * compile time. See the section about descriptor properties below for how
+ * to fine tune control over USB descriptors such as the string descriptor
+ * for the serial number.
+ */
+#define USB_CFG_DEVICE_CLASS        0xff    /* set to 0 if deferred to interface */
+#define USB_CFG_DEVICE_SUBCLASS     0
+/* See USB specification if you want to conform to an existing device class.
+ * Class 0xff is "vendor specific".
+ */
+#define USB_CFG_INTERFACE_CLASS     0xff   /* define class here if not at device level */
+#define USB_CFG_INTERFACE_SUBCLASS  0
+#define USB_CFG_INTERFACE_PROTOCOL  0
+/* See USB specification if you want to conform to an existing device class or
+ * protocol. The following classes must be set at interface level:
+ * HID class is 3, no subclass and protocol required (but may be useful!)
+ * CDC class is 2, use subclass 2 and protocol 1 for ACM
+ */
+/* #define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    42 */
+/* Define this to the length of the HID report descriptor, if you implement
+ * an HID device. Otherwise don't define it or define it to 0.
+ * If you use this define, you must add a PROGMEM character array named
+ * "usbHidReportDescriptor" to your code which contains the report descriptor.
+ * Don't forget to keep the array and this define in sync!
+ */
+
+#define USB_PUBLIC static
+/* Use the define above if you #include usbdrv.c instead of linking against it.
+ * This technique saves a couple of bytes in flash memory.
+ */
+
+/* ------------------- Fine Control over USB Descriptors ------------------- */
+/* If you don't want to use the driver's default USB descriptors, you can
+ * provide our own. These can be provided as (1) fixed length static data in
+ * flash memory, (2) fixed length static data in RAM or (3) dynamically at
+ * runtime in the function usbFunctionDescriptor(). See usbdrv.h for more
+ * information about this function.
+ * Descriptor handling is configured through the descriptor's properties. If
+ * no properties are defined or if they are 0, the default descriptor is used.
+ * Possible properties are:
+ *   + USB_PROP_IS_DYNAMIC: The data for the descriptor should be fetched
+ *     at runtime via usbFunctionDescriptor(). If the usbMsgPtr mechanism is
+ *     used, the data is in FLASH by default. Add property USB_PROP_IS_RAM if
+ *     you want RAM pointers.
+ *   + USB_PROP_IS_RAM: The data returned by usbFunctionDescriptor() or found
+ *     in static memory is in RAM, not in flash memory.
+ *   + USB_PROP_LENGTH(len): If the data is in static memory (RAM or flash),
+ *     the driver must know the descriptor's length. The descriptor itself is
+ *     found at the address of a well known identifier (see below).
+ * List of static descriptor names (must be declared PROGMEM if in flash):
+ *   char usbDescriptorDevice[];
+ *   char usbDescriptorConfiguration[];
+ *   char usbDescriptorHidReport[];
+ *   char usbDescriptorString0[];
+ *   int usbDescriptorStringVendor[];
+ *   int usbDescriptorStringDevice[];
+ *   int usbDescriptorStringSerialNumber[];
+ * Other descriptors can't be provided statically, they must be provided
+ * dynamically at runtime.
+ *
+ * Descriptor properties are or-ed or added together, e.g.:
+ * #define USB_CFG_DESCR_PROPS_DEVICE   (USB_PROP_IS_RAM | USB_PROP_LENGTH(18))
+ *
+ * The following descriptors are defined:
+ *   USB_CFG_DESCR_PROPS_DEVICE
+ *   USB_CFG_DESCR_PROPS_CONFIGURATION
+ *   USB_CFG_DESCR_PROPS_STRINGS
+ *   USB_CFG_DESCR_PROPS_STRING_0
+ *   USB_CFG_DESCR_PROPS_STRING_VENDOR
+ *   USB_CFG_DESCR_PROPS_STRING_PRODUCT
+ *   USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+ *   USB_CFG_DESCR_PROPS_HID
+ *   USB_CFG_DESCR_PROPS_HID_REPORT
+ *   USB_CFG_DESCR_PROPS_UNKNOWN (for all descriptors not handled by the driver)
+ *
+ * Note about string descriptors: String descriptors are not just strings, they
+ * are Unicode strings prefixed with a 2 byte header. Example:
+ * int  serialNumberDescriptor[] = {
+ *     USB_STRING_DESCRIPTOR_HEADER(6),
+ *     'S', 'e', 'r', 'i', 'a', 'l'
+ * };
+ */
+
+#define USB_CFG_DESCR_PROPS_DEVICE                  0
+#define USB_CFG_DESCR_PROPS_CONFIGURATION           0
+#define USB_CFG_DESCR_PROPS_STRINGS                 0
+#define USB_CFG_DESCR_PROPS_STRING_0                0
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR           0
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT          0
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    0
+#define USB_CFG_DESCR_PROPS_HID                     0
+#define USB_CFG_DESCR_PROPS_HID_REPORT              0
+#define USB_CFG_DESCR_PROPS_UNKNOWN                 0
+
+/* ----------------------- Optional MCU Description ------------------------ */
+
+/* The following configurations have working defaults in usbdrv.h. You
+ * usually don't need to set them explicitly. Only if you want to run
+ * the driver on a device which is not yet supported or with a compiler
+ * which is not fully supported (such as IAR C) or if you use a differnt
+ * interrupt than INT0, you may have to define some of these.
+ */
+#define USB_INTR_CFG            MCUCR
+#if defined(USB_COUNT_SOF) || defined(USB_SOF_HOOK)
+#define USB_INTR_CFG_SET        ((1 << ISC11))

+#else
+#define USB_INTR_CFG_SET        ((1 << ISC10) | (1 << ISC11))

+#endif
+/* #define USB_INTR_CFG_CLR        0 */
+/* #define USB_INTR_ENABLE         GIMSK */
+#define USB_INTR_ENABLE_BIT     INT1
+/* #define USB_INTR_PENDING        GIFR */
+#define USB_INTR_PENDING_BIT    INTF1
+#define USB_INTR_VECTOR         SIG_INTERRUPT1
+

+

+/* This is a new macro that is executed and the beginning of the usb irq handler.

+ * This needs a patch in the corresponding clock dependend assembler file of VUSB!!!

+ * It is save to use register YH here

+ */ 

+#define USB_START_IRQ_HOOK	customTriggerHook

+

+

+/* Reinstall edge level interrupt triggering (after sleep) */
+#ifdef __ASSEMBLER__
+macro customTriggerHook

+    in     YH, USB_INTR_CFG

+		ori 	 YH, USB_INTR_CFG_SET
+    out    USB_INTR_CFG, YH
+endm

+#endif
+

+#endif /* __usbconfig_h_included__ */