summaryrefslogtreecommitdiff
path: root/usb_appl
diff options
context:
space:
mode:
Diffstat (limited to 'usb_appl')
-rw-r--r--usb_appl/10ch_usb_appl.c839
-rw-r--r--usb_appl/Makefile109
-rw-r--r--usb_appl/usbconfig.h392
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__ */
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-24 07:59:21 +0000