defalte testing

Conflicts:
	avr/usbload/Makefile

.ditz-config

@@ -1,4 +0,0 @@
---- !ditz.rubyforge.org,2008-03-06/config 
-name: David
-email: david@optixx.org
-issue_dir: bugs

.gitignore

@@ -21,3 +21,18 @@
 *.swc
 *.rom
 *.usage
+*.moc
+*.obj
+*.TMP
+*.vfat
+*.wla*
+*.rcc
+*.log
+bootloader
+snesuploader
+tmtags
+bsnes
+web
+ucon64.exe
+
+

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "scripts/webpy"]
+	path = scripts/webpy
+	url = git://github.com/webpy/webpy.git

README

@@ -1 +1,8 @@
-o Test
+  ________        .__        __    ________               ____  ________
+  \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+   /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+  /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+  \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+         \__>             \/     \/        \/     \/                 \/
+ 
+                                   www.optixx.org

avr/bootloader/Makefile

@@ -0,0 +1,78 @@
+
+# microcontroller and project specific settings
+TARGET = bootloader
+F_CPU = 20000000UL
+MCU = atmega644
+
+SRC = bootloader.c  
+ASRC = usbdrv/usbdrvasm.S interrupts.S
+OBJECTS += $(patsubst %.c,%.o,${SRC})
+OBJECTS += $(patsubst %.S,%.o,${ASRC})
+HEADERS += $(shell echo *.h)
+# CFLAGS += -Werror
+
+LDFLAGS += -L/usr/local/avr/avr/lib
+CFLAGS += -Iusbdrv -I.
+CFLAGS += -DHARDWARE_REV=$(HARDWARE_REV)
+CDEFS += -DF_CPU
+ASFLAGS += -x assembler-with-cpp
+ASFLAGS += -Iusbdrv -I.
+
+# use own linkerscript, for special interrupt table handling
+LDFLAGS += -T ./ldscripts/avr5.x
+
+# no safe mode checks
+AVRDUDE_FLAGS += -u
+
+# set name for dependency-file
+MAKEFILE = Makefile
+
+# bootloader section start
+# (see datasheet)
+ifeq ($(MCU),atmega168)
+	# atmega168 with 1024 words bootloader:
+	# bootloader section starts at 0x1c00 (word-address) == 0x3800 (byte-address)
+	BOOT_SECTION_START = 0x3800
+else ifeq ($(MCU),atmega88)
+	# atmega88 with 1024 words bootloader:
+	# bootloader section starts at 0xc00 (word-address) == 0x1800 (byte-address)
+	BOOT_SECTION_START = 0x1800
+else ifeq ($(MCU),atmega644)
+        # atmega644 with 2048 words bootloader:
+        # bootloader section starts at 0x7800 (word-address) == 0xF000 (byte-address)
+        BOOT_SECTION_START = 0xf000
+endif
+
+LDFLAGS += -Wl,--section-start=.text=$(BOOT_SECTION_START) -Wl,-u,vfprintf
+CFLAGS += -DBOOT_SECTION_START=$(BOOT_SECTION_START)
+
+
+include avr.mk
+
+.PHONY: all
+
+all: $(TARGET).hex $(TARGET).lss
+	@echo "==============================="
+	@echo "$(TARGET) compiled for: $(MCU)"
+	@echo -n "size is: "
+	@$(SIZE) -A $(TARGET).hex | grep "\.sec1" | tr -s " " | cut -d" " -f2
+	@echo "==============================="
+
+$(TARGET): $(OBJECTS) $(TARGET).o
+
+%.o: $(HEADERS)
+
+.PHONY: clean clean-$(TARGET) 
+
+clean: clean-$(TARGET) 
+
+clean-$(TARGET):
+	$(RM) $(TARGET) $(OBJECTS)
+
+
+.PHONY: depend test 
+
+depend:
+	$(CC) $(CFLAGS) -M $(CDEFS) $(CINCS) $(SRC) >> $(MAKEFILE).dep
+
+-include $(MAKEFILE).dep

avr/bootloader/avr.mk

@@ -1,7 +1,7 @@
 # Programmer used for In System Programming
-ISP_PROG = dapa
+ISP_PROG = usbasp
 # device the ISP programmer is connected to
-ISP_DEV = /dev/parport0
+ISP_DEV = 
 # Programmer used for serial programming (using the bootloader)
 SERIAL_PROG = avr109
 # device the serial programmer is connected to
@@ -15,7 +15,6 @@ AS = avr-as
 CP = cp
 RM = rm -f
 AVRDUDE = avrdude
-AVRDUDE_BAUDRATE = 19200
 SIZE = avr-size
 
 -include $(CURDIR)/config.mk
@@ -33,8 +32,12 @@ endif
 ifeq ($(MCU),atmega168)
 	AVRDUDE_MCU=m168
 endif
+ifeq ($(MCU),atmega644)
+	AVRDUDE_MCU=m644
+endif
 
-AVRDUDE_FLAGS += -p $(AVRDUDE_MCU) -b $(AVRDUDE_BAUDRATE)
+
+AVRDUDE_FLAGS += -p $(AVRDUDE_MCU) 
 
 # flags for the compiler
 CFLAGS += -g -Os -finline-limit=800 -mmcu=$(MCU) -DF_CPU=$(F_CPU) -std=gnu99
@@ -62,27 +65,14 @@ $(OBJECTS):
 clean:
 	$(RM) *.hex *.eep.hex *.o *.lst *.lss
 
-interactive-isp:
-	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(ISP_PROG) -P $(ISP_DEV) -t
-
-interactive-serial:
-	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(SERIAL_PROG) -P $(SERIAL_DEV) -t
-
-
 .PHONY: all clean interactive-isp interactive-serial launch-bootloader
 
-program-isp-%: %.hex
+flash: bootloader.hex
-	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(ISP_PROG) -P $(ISP_DEV) -U flash:w:$<
+	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(ISP_PROG) -U flash:w:$<
 
-program-isp-eeprom-%: %.eep.hex
+flash-eeprom-%: %.eep.hex
 	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(ISP_PROG) -P $(ISP_DEV) -U eeprom:w:$<
 
-program-serial-%: %.hex
-	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(SERIAL_PROG) -P $(SERIAL_DEV) -U flash:w:$<
-
-program-serial-eeprom-%: %.eep.hex launch-bootloader
-	$(AVRDUDE) $(AVRDUDE_FLAGS) -c $(SERIAL_PROG) -P $(SERIAL_DEV) -U eeprom:w:$<
-
 %.hex: %
 	$(OBJCOPY) -O ihex -R .eeprom $< $@
 
@@ -94,6 +84,3 @@ program-serial-eeprom-%: %.eep.hex launch-bootloader
 
 %-size: %.hex
 	$(SIZE) $<
-
-launch-bootloader:
-	launch-bootloader $(SERIAL_DEV) $(AVRDUDE_BAUDRATE)

avr/bootloader/bootloader.c

@@ -0,0 +1,558 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ *        simple USBasp compatible bootloader by 
+ *        Alexander Neumann <alexander@lochraster.org> 
+ *        inspired by USBasploader by Christian Starkjohann,
+ * =====================================================================================
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <avr/boot.h>
+#include <avr/eeprom.h>
+#include <util/delay.h>
+#include <string.h>
+#include <avr/wdt.h>
+
+#include "config.h"
+#include "usbdrv/usbdrv.c"
+
+
+
+
+
+/*
+ * USBasp requests, taken from the original USBasp sourcecode 
+ */
+#define USBASP_FUNC_CONNECT     1
+#define USBASP_FUNC_DISCONNECT  2
+#define USBASP_FUNC_TRANSMIT    3
+#define USBASP_FUNC_READFLASH   4
+#define USBASP_FUNC_ENABLEPROG  5
+#define USBASP_FUNC_WRITEFLASH  6
+#define USBASP_FUNC_READEEPROM  7
+#define USBASP_FUNC_WRITEEEPROM 8
+#define USBASP_FUNC_SETLONGADDRESS 9
+
+/*
+ * additional functions 
+ */
+#define FUNC_ECHO               0x17
+
+/*
+ * atmel isp commands 
+ */
+#define ISP_CHIP_ERASE1         0xAC
+#define ISP_CHIP_ERASE2         0x80
+#define ISP_READ_SIGNATURE      0x30
+#define ISP_READ_EEPROM         0xa0
+#define ISP_WRITE_EEPROM        0xc0
+
+
+
+#define LED_PORT	            PORTC
+#define LED_DIR		            DDRC
+#define LED_PIN		            PC7
+
+#define DLED_ON  {((LED_PORT &=~ (1 << LED_PIN)),\
+                  (LED_DIR &=~ (1 << LED_PIN))); }
+#define DLED_OFF {((LED_PORT &=~ (1 << LED_PIN)),\
+                   (LED_DIR |= (1 << LED_PIN))); }
+#define DLED_TGL {((LED_PORT &=~ (1 << LED_PIN)),\
+                  (LED_DIR ^= (1 << LED_PIN)));}
+
+
+#define AVR_BTLDR_EN_PORT	    PORTC
+#define AVR_BTLDR_EN_DIR	    DDRC
+#define AVR_BTLDR_EN_PIN	    PC1
+#define AVR_BTLDR_EN_IN	        PINC
+
+#undef AVR_BTLDR_SWITCH
+/*
+ * some predefined signatures, taken from the original USBasp sourcecode 
+ */
+static const uint8_t signature[4] = {
+#ifdef SIGNATURE_BYTES
+    SIGNATURE_BYTES
+#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega8HVA__)
+    0x1e, 0x93, 0x07, 0
+#elif defined (__AVR_ATmega48__) || defined (__AVR_ATmega48P__)
+    0x1e, 0x92, 0x05, 0
+#elif defined (__AVR_ATmega88__) || defined (__AVR_ATmega88P__)
+    0x1e, 0x93, 0x0a, 0
+#elif defined (__AVR_ATmega168__) || defined (__AVR_ATmega168P__)
+    0x1e, 0x94, 0x06, 0
+#elif defined (__AVR_ATmega328P__)
+    0x1e, 0x95, 0x0f, 0
+#elif defined (__AVR_ATmega644__)
+    0x1e, 0x96, 0x09, 0
+#else
+#   error "Device signature is not known, please edit config.h!"
+#endif
+};
+
+#ifndef BOOT_SECTION_START
+#   error "BOOT_SECTION_START undefined!"
+#endif
+
+#if defined (__AVR_ATmega644__)
+    /*
+     * Due arvdude limitations we can't erase the whole progmem without running into an usb timeount on cleint side. So we we limit the
+     * erase section by 0x1000 
+     */
+#define ERASE_SECTION 0xe000
+#else
+#define ERASE_SECTION BOOT_SECTION_START
+#endif
+
+
+#ifdef DEBUG_UART
+static __attribute__ ((__noinline__))
+     void uart_putc(uint8_t data)
+{
+    while (!(UCSR0A & _BV(UDRE0)));
+    UDR0 = data;
+}
+#else
+#define uart_putc(x)
+#endif
+
+#ifdef DEBUG_UART
+static __attribute__ ((__noinline__))
+     void uart_puts(uint8_t * data)
+{
+    while (*data) {
+        uart_putc(*data);
+        data++;
+    }
+}
+#else
+#define uart_puts(x)
+#endif
+
+
+/*
+ * supply custom usbDeviceConnect() and usbDeviceDisconnect() macros which turn the interrupt on and off at the right times, and prevent
+ * the execution of an interrupt while the pullup resistor is switched off 
+ */
+
+#ifdef USB_CFG_PULLUP_IOPORTNAME
+#undef usbDeviceConnect
+#define usbDeviceConnect()      do { \
+                                    USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT); \
+                                    USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT); \
+                                    USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT); \
+                                   } while(0);
+#undef usbDeviceDisconnect
+#define usbDeviceDisconnect()   do { \
+                                    USB_INTR_ENABLE &= ~(1 << USB_INTR_ENABLE_BIT); \
+                                    USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT); \
+                                    USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT); \
+                                   } while(0);
+#endif
+
+/*
+ * prototypes 
+ */
+void __attribute__ ((__noreturn__, __noinline__,
+                     __naked__)) leave_bootloader(void);
+
+/*
+ * we just support flash sizes <= 64kb, for code size reasons if you need to program bigger devices, have a look at USBasploader:
+ * http://www.obdev.at/products/avrusb/usbasploader.html 
+ */
+#if FLASHEND > 0xffff
+#   error "usbload only supports up to 64kb of flash!"
+#endif
+
+/*
+ * we are just checking the lower byte of flash_address, so make sure SPM_PAGESIZE is <= 256 
+ */
+#if SPM_PAGESIZE > 256
+#   error "SPM_PAGESIZE is too big (just checking lower byte)"
+#endif
+
+/*
+ * start flash (byte address) read/write at this address 
+ */
+usbWord_t flash_address;
+uint8_t bytes_remaining;
+uint8_t request;
+uint8_t request_exit;
+
+uint8_t timeout;
+
+
+
+usbMsgLen_t usbFunctionSetup(uchar data[8])
+{
+    usbRequest_t *req = (void *) data;
+    uint8_t len = 0;
+    static uint8_t buf[4];
+
+    /*
+     * set global data pointer to local buffer 
+     */
+    usbMsgPtr = buf;
+
+    /*
+     * on enableprog just return one zero, which means success 
+     */
+    if (req->bRequest == USBASP_FUNC_ENABLEPROG) {
+        buf[0] = 0;
+        len = 1;
+        timeout = 255;
+    } else if (req->bRequest == USBASP_FUNC_CONNECT) {
+        /*
+         * turn on led 
+         */
+        DLED_ON;
+    } else if (req->bRequest == USBASP_FUNC_DISCONNECT) {
+        /*
+         * turn off led 
+         */
+        DLED_OFF;
+        request_exit = 1;
+        /*
+         * catch query for the devicecode, chip erase and eeprom byte requests 
+         */
+    } else if (req->bRequest == USBASP_FUNC_TRANSMIT) {
+
+        /*
+         * reset buffer with zeroes 
+         */
+        memset(buf, '\0', sizeof(buf));
+
+        /*
+         * read the address for eeprom operations 
+         */
+        usbWord_t address;
+        address.bytes[0] = data[4];     /* low byte is data[4] */
+        address.bytes[1] = data[3];     /* high byte is data[3] */
+
+        /*
+         * if this is a request to read the device signature, answer with the appropiate signature byte 
+         */
+        if (data[2] == ISP_READ_SIGNATURE) {
+            /*
+             * the complete isp data is reported back to avrdude, but we just need byte 4 bits 0 and 1 of byte 3 determine the signature
+             * byte address 
+             */
+            buf[3] = signature[data[4] & 0x03];
+
+#ifdef ENABLE_CATCH_EEPROM_ISP
+            /*
+             * catch eeprom read 
+             */
+        } else if (data[2] == ISP_READ_EEPROM) {
+
+            buf[3] = eeprom_read_byte((uint8_t *) address.word);
+
+            /*
+             * catch eeprom write 
+             */
+        } else if (data[2] == ISP_WRITE_EEPROM) {
+
+            /*
+             * address is in data[4], data[3], and databyte is in data[5] 
+             */
+            eeprom_write_byte((uint8_t *) address.word, data[5]);
+#endif
+
+            /*
+             * catch a chip erase 
+             */
+        } else if (data[2] == ISP_CHIP_ERASE1 && data[3] == ISP_CHIP_ERASE2) {
+            uart_puts("\n\rErase Flash");
+            for (flash_address.word = 0;
+                 flash_address.word < ERASE_SECTION;
+                 flash_address.word += SPM_PAGESIZE) {
+
+                /*
+                 * wait and erase page 
+                 */
+                boot_spm_busy_wait();
+                if (flash_address.word && flash_address.word % 1024 == 0)
+                    uart_putc('.');
+                cli();
+                boot_page_erase(flash_address.word);
+                sei();
+            }
+            uart_puts("\n\rWrite Flash");
+        }
+
+        /*
+         * in case no data has been filled in by the if's above, just return zeroes 
+         */
+        len = 4;
+
+#ifdef ENABLE_ECHO_FUNC
+        /*
+         * implement a simple echo function, for testing the usb connectivity 
+         */
+    } else if (req->bRequest == FUNC_ECHO) {
+        buf[0] = req->wValue.bytes[0];
+        buf[1] = req->wValue.bytes[1];
+        len = 2;
+#endif
+    } else if (req->bRequest >= USBASP_FUNC_READFLASH) {
+        /*
+         * && req->bRequest <= USBASP_FUNC_SETLONGADDRESS 
+         */
+        /*
+         * extract address and length 
+         */
+        flash_address.word = req->wValue.word;
+        bytes_remaining = req->wLength.bytes[0];
+        request = req->bRequest;
+        /*
+         * hand control over to usbFunctionRead()/usbFunctionWrite() 
+         */
+        len = 0xff;
+    }
+
+    return len;
+}
+
+uchar usbFunctionWrite(uchar * data, uchar len)
+{
+    if (len > bytes_remaining)
+        len = bytes_remaining;
+    bytes_remaining -= len;
+    if (request == USBASP_FUNC_WRITEEEPROM) {
+        for (uint8_t i = 0; i < len; i++)
+            eeprom_write_byte((uint8_t *) flash_address.word++, *data++);
+    } else {
+        /*
+         * data is handled wordwise, adjust len 
+         */
+        len /= 2;
+        len -= 1;
+        for (uint8_t i = 0; i <= len; i++) {
+            uint16_t *w = (uint16_t *) data;
+            cli();
+            boot_page_fill(flash_address.word, *w);
+            sei();
+
+            usbWord_t next_address;
+            next_address.word = flash_address.word;
+            next_address.word += 2;
+            data += 2;
+
+            /*
+             * write page if page boundary is crossed or this is the last page 
+             */
+            if (next_address.bytes[0] % SPM_PAGESIZE == 0 ||
+                (bytes_remaining == 0 && i == len)) {
+                cli();
+                boot_page_write(flash_address.word);
+                sei();
+                boot_spm_busy_wait();
+                cli();
+                boot_rww_enable();
+                sei();
+            }
+
+            flash_address.word = next_address.word;
+        }
+    }
+
+    /*
+     * flash led on activity 
+     */
+    DLED_TGL;
+
+    return (bytes_remaining == 0);
+}
+
+uchar usbFunctionRead(uchar * data, uchar len)
+{
+    if (len > bytes_remaining)
+        len = bytes_remaining;
+    bytes_remaining -= len;
+
+    for (uint8_t i = 0; i < len; i++) {
+        if (request == USBASP_FUNC_READEEPROM)
+            *data = eeprom_read_byte((void *) flash_address.word);
+        else
+            *data = pgm_read_byte_near((void *) flash_address.word);
+        data++;
+        flash_address.word++;
+    }
+
+    /*
+     * flash led on activity 
+     */
+    DLED_TGL;
+
+    return len;
+}
+
+void (*jump_to_app) (void) = 0x0000;
+void leave_bootloader(void)
+{
+
+    cli();
+
+    /*
+     * disconnect usb 
+     */
+    usbDeviceDisconnect();
+#if 0    
+    for (uint8_t i = 0; i < 50; i++)
+        _delay_ms(10);          /* 0 means 0x10000, 38*1/f*0x10000 =~ 498ms */
+#endif
+    /*
+     * enable watchdog to soft-reset the uC for clean startup of new application 
+     */
+    wdt_enable(WDTO_15MS);
+
+    /*
+     * let watchdog kick in and reset uC 
+     */
+    while (1);
+
+}
+
+void banner(){
+    uart_puts("\n\r");
+    uart_puts("\n\r");
+    uart_puts("\n\r");
+    uart_puts("Quickdev16 Bootloader v0.2\n\r"); 
+    uart_puts("www.optixx.org\n\r");
+}
+
+int __attribute__ ((noreturn, OS_main)) main(void)
+{
+    /*
+     * start bootloader 
+     */
+
+#ifdef DEBUG_UART
+    /*
+     * init uart (115200 baud, at 20mhz) 
+     */
+    UBRR0L = 10;
+    UCSR0C = _BV(UCSZ00) | _BV(UCSZ01);
+    UCSR0B = _BV(TXEN0);
+#endif
+
+    uint8_t reset = MCUSR;
+    uint16_t delay = 0;
+    timeout = TIMEOUT;
+
+    DDRC &= ~(1 << AVR_BTLDR_EN_PIN);	    
+    PORTC &= ~(1 << AVR_BTLDR_EN_PIN);	    
+
+    /*
+     * if watchdog reset, disable watchdog and jump to app 
+     */
+    if (reset & _BV(WDRF)) {
+        uart_puts("Found watchdog reset\n\r");
+        MCUSR = 0;
+        wdt_disable();
+        uart_puts("Jump to 0x0000\n\r");
+        jump_to_app();
+    }
+
+#ifdef AVR_BTLDR_SWITCH ENABLE
+    if ((AVR_BTLDR_EN_IN & ( 1 << AVR_BTLDR_EN_PIN)) == 0){
+        banner();
+        uart_puts("Bootloader flashing is disabled\n\r");
+        MCUSR = 0;
+        leave_bootloader();
+        
+    }
+#endif
+
+    /*
+     * if power-on reset, quit bootloader via watchdog reset 
+     */
+    if (reset & _BV(PORF)) {
+        banner();
+        uart_puts("Found power on reset\n\r");
+        MCUSR = 0;
+        leave_bootloader();
+    }
+    banner();
+    uart_puts("Enter programming mode\n\r");
+    /*
+     * else: enter programming mode 
+     */
+
+    /*
+     * clear external reset flags 
+     */
+    MCUSR = 0;
+
+    /*
+     * init exit request state 
+     */
+    request_exit = 0;
+
+    /*
+     * move interrupts to boot section 
+     */
+
+    MCUCR = (1 << IVCE);
+    MCUCR = (1 << IVSEL);
+
+    /*
+     * enable interrupts 
+     */
+    sei();
+
+    /*
+     * initialize usb pins 
+     */
+    usbInit();
+
+
+    /*
+     * disconnect for ~500ms, so that the host re-enumerates this device 
+     */
+    usbDeviceDisconnect();
+    for (uint8_t i = 0; i < 50; i++)
+        _delay_ms(10);          /* 0 means 0x10000, 38*1/f*0x10000 =~ 498ms */
+    usbDeviceConnect();
+    uart_puts("Wait for firmware");
+    while (1) {
+        usbPoll();
+
+        delay++;
+
+        /*
+         * do some led blinking, so that it is visible that the bootloader is still running 
+         */
+        if (delay == 0) {
+            uart_putc('.');
+            DLED_TGL;
+            if (timeout < 255)
+                timeout--;
+        }
+
+        if (request_exit || timeout == 0) {
+            uart_puts("\n\rExit\n\r");
+            _delay_ms(10);
+            leave_bootloader();
+        }
+
+    }
+
+}

avr/bootloader/config.h

@@ -15,4 +15,8 @@
 //#define ENABLE_ECHO_FUNC
 
 /* uncomment this for debug information via uart */
-//#define DEBUG_UART
+#define DEBUG_UART
+
+
+#define DEBUG                       1
+#define DEBUG_USB                   2

avr/bootloader/usbconfig.h

@@ -42,13 +42,13 @@ the newest features and options.
 
 /* ----------------------- Optional Hardware Config ------------------------ */
 
-#define USB_CFG_PULLUP_IOPORTNAME   B
+//#define USB_CFG_PULLUP_IOPORTNAME   B
 /* 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          0
+//#define USB_CFG_PULLUP_BIT          0
 /* 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.

avr/usbload/Makefile

@@ -0,0 +1,117 @@
+# =====================================================================================
+#
+# ________        .__        __    ________               ____  ________
+# \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+#  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+# /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+# \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+#        \__>             \/     \/        \/     \/                 \/
+#                                  www.optixx.org
+#
+#
+#        Version:  1.0
+#        Created:  07/21/2009 03:32:16 PM
+#         Author:  david@optixx.org
+#       Based on:  custom-class, a basic USB example 
+#         Author:  Christian Starkjohann 
+# =====================================================================================
+
+DEBUG   = 1
+TTY     = /dev/tty.PL2303-00002126
+DEVICE  = atmega644
+F_CPU   = 20000000
+TARGET  = main
+AVRDUDE = avrdude -c usbasp -p $(DEVICE)
+SIZE    = avr-size
+BOOT_ROM01  = ../../roms/qd16boot01.smc
+BOOT_ROM02  = ../../roms/qd16boot02.smc
+CONVERT_RLE = ../../scripts/conv_rle.py
+CONVERT_ZIP = ../../scripts/conv_zip.py
+
+
+
+ifeq ($(DEBUG),1)
+    LDFLAGS =-Wl,-u,vfprintf 
+    CFLAGS  =-Iusbdrv -I. -DDEBUG_LEVEL=0 
+    OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o \
+               main.o usb_bulk.o uart.o fifo.o sram.o crc.o debug.o \
+               dump.o timer.o watchdog.o rle.c loader.o info.o shared_memory.o \
+               system.o pwm.o util.o shell.o irq.o command.o testing.o inflate.o neginf/neginf.o
+else 
+    LDFLAGS =-Wl,-u
+    CFLAGS  =-Iusbdrv -I. -DDEBUG_LEVEL=0 -DNO_DEBUG -DNO_INFO
+    OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o  main.o usb_bulk.o \
+              sram.o crc.o debug.o dump.o rle.c loader.o \
+              system.o util.o info.o shared_memory.o command.o irq.o \
+              pwm.o inflate.o neginf/neginf.o
+endif
+
+COMPILE = avr-gcc -Wall -Os -DF_CPU=$(F_CPU) $(CFLAGS) -mmcu=$(DEVICE)
+
+##############################################################################
+# Fuse values for particular devices
+##############################################################################
+# http://www.engbedded.com/fusecalc/
+FUSE_L  = 0xf7
+FUSE_H  = 0xda
+
+all: hex
+
+help:
+	@echo "This Makefile has no default rule. Use one of the following:"
+	@echo "make hex ....... to build main.hex"
+	@echo "make program ... to flash fuses and firmware"
+	@echo "make fuse ...... to flash the fuses"
+	@echo "make flash ..... to flash the firmware (use this on metaboard)"
+	@echo "make clean ..... to delete objects and hex file"
+
+hex: main.hex
+	@echo "$(TARGET) compiled for: $(DEVICE)"
+	@./checksize $(TARGET).elf
+
+program: flash fuse
+
+# rule for programming fuse bits:
+fuse:
+	@[ "$(FUSE_H)" != "" -a "$(FUSE_L)" != "" ] || \
+		{ echo "*** Edit Makefile and choose values for FUSE_L and FUSE_H!"; exit 1; }
+	$(AVRDUDE) -U hfuse:w:$(FUSE_H):m -U lfuse:w:$(FUSE_L):m
+
+flash: main.hex
+	$(AVRDUDE) -U flash:w:main.hex:i
+
+loader01:
+	python $(CONVERT_RLE) $(BOOT_ROM01)
+
+loader02:
+	python $(CONVERT_ZIP) $(BOOT_ROM02)
+
+.c.o:
+	$(COMPILE) -c $< -o $@
+
+.S.o:
+	$(COMPILE) -x assembler-with-cpp -c $< -o $@
+
+.c.s:
+	$(COMPILE) -S $< -o $@
+
+
+usbdrv:
+	cp -r ../../../usbdrv .
+
+main.elf: usbdrv $(OBJECTS)	# usbdrv dependency only needed because we copy it
+	$(COMPILE) -o main.elf $(OBJECTS) $(LDFLAGS) 
+
+main.hex: main.elf
+	rm -f main.hex main.eep.hex
+	avr-objcopy -j .text -j .data -O ihex main.elf main.hex
+	avr-size main.hex
+
+disasm:	main.elf
+	avr-objdump -d main.elf
+
+cpp:
+	$(COMPILE) -E main.c
+
+clean:
+	rm -f main.hex main.lst main.obj main.cof main.list main.map main.eep.hex main.elf *.o usbdrv/*.o main.s usbdrv/oddebug.s usbdrv/usbdrv.s neginf/*.o

avr/usbload/Makefile.test

@@ -0,0 +1,19 @@
+
+MD5=md5
+
+all:
+	gcc -c loader_test.c
+	gcc -c inflate.c
+	gcc -c neginf/neginf.c
+	gcc -c inflate_test.c
+	gcc -c ringbuffer.c
+	gcc -o inflate_test inflate.o neginf.o inflate_test.o loader_test.o ringbuffer.o
+loader:
+	python ../../scripts/conv_zip_test.py ../../roms/qd16boot02_half.smc
+	
+test:
+	./inflate_test
+	@$(MD5) out.smc
+	@$(MD5) out_ref.smc
+	@$(MD5) ../../roms/qd16boot02_half.smc
+

avr/usbload/checksize

@@ -0,0 +1,35 @@
+#!/bin/sh
+# Name: checksize
+# Project: PowerSwitch/AVR-USB
+# Author: Christian Starkjohann
+# Creation Date: 2004-12-29
+# Tabsize: 4
+# Copyright: (c) 2005 OBJECTIVE DEVELOPMENT Software GmbH.
+# Revision: $:Id: checksize 83 2006-01-05 22:20:53Z cs $
+
+error=0
+codelimit=61440  # default value
+datalimit=4064   # default value; leave 32 bytes for stack
+
+if [ $# -gt 1 ]; then
+	codelimit="$2"
+fi
+if [ $# -gt 2 ]; then
+	datalimit="$3"
+fi
+
+set -- `avr-size -d "$1" | awk '/[0-9]/ {print $1 + $2, $2 + $3, $2}'`
+if [ $1 -gt $codelimit ]; then
+	echo "*** code size $1 exceeds limit of $codelimit"
+	error=1
+else
+	echo "ROM: $1 bytes (data=$3)"
+fi
+if [ $2 -gt $datalimit ]; then
+	echo "*** data size $2 exceeds limit of $datalimit"
+	error=1
+else
+	echo "RAM: $2 bytes"
+fi
+
+exit $error

avr/usbload/command.c

@@ -0,0 +1,120 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>      
+#include <util/delay.h>         
+#include <stdlib.h>
+
+#include "config.h"
+#include "requests.h"           
+#include "sram.h"
+#include "info.h"
+#include "irq.h"
+#include "usbdrv.h"
+#include "rle.h"
+#include "loader.h"
+#include "system.h"
+
+#include "neginf/neginf.h"
+#include "inflate.h"
+
+
+extern usb_transaction_t usb_trans;
+extern system_t system;
+
+extern const char *_rom[];
+extern const char _rom01[];
+extern const int _rom_size[];
+
+void usb_connect()
+{
+    uint8_t i = 0;
+    info_P(PSTR("USB init\n"));
+    usbDeviceDisconnect();      /* enforce re-enumeration, do this while */
+    cli();
+    info_P(PSTR("USB disconnect\n"));
+    i = 10;
+    while (--i) {               /* fake USB disconnect for > 250 ms */
+        _delay_ms(50);
+    }
+    led_on();
+    usbDeviceConnect();
+    info_P(PSTR("USB connect\n"));
+}
+
+
+
+void boot_startup_rom(uint16_t init_delay)
+{
+    uint8_t i;
+    uint8_t c;
+    uint16_t j;
+    uint32_t addr = 0x000000;
+    PGM_VOID_P p_addr;
+    
+    info_P(PSTR("Fetch loader rom\n"));
+    
+    system_set_bus_avr();
+    snes_irq_lo();
+    system_snes_irq_off();
+    system_set_rom_lorom();
+    
+    
+    inflate_init();
+    for (i=0; i<ROM_BUFFER_CNT; i++){
+        p_addr = _rom[i];
+        printf("idx: %i %lx\n",i,p_addr);
+        for (j=0; j<_rom_size[i]; j++){
+            //rle_decode(_rom[i], _rom_size[i], addr);
+            c = pgm_read_byte((PGM_VOID_P)p_addr++); 
+            printf("%02x ",c);
+            neginf_process_byte(c);
+            
+        }
+    }
+    info_P(PSTR("\n"));
+
+#if DO_CRC_CHECK_LOADER     
+    dump_memory(0x010000 - 0x100, 0x010000);
+    uint16_t crc;
+    crc = crc_check_bulk_memory((uint32_t)0x000000,0x010000, 0x010000);
+    info(PSTR("crc=%x\n"),crc);
+#endif
+
+ 
+    snes_irq_lo();
+    system_snes_irq_off();
+    system_set_rom_hirom();
+    system_set_wr_disable();
+    system_set_bus_snes();
+    
+    
+    system_send_snes_reset();
+    _delay_ms(init_delay);
+}
+
+void banner(){
+    
+}
+
+void transaction_status(){
+}
+

avr/usbload/command.h

@@ -0,0 +1,31 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __COMMAND_H__
+#define __COMMAND_H__
+
+void usb_connect();
+void boot_startup_rom(uint16_t init_delay);
+void banner();
+void transaction_status();
+
+
+#endif

avr/usbload/commandline/Makefile

@@ -1,5 +1,5 @@
 # Name: Makefile
-# Project: usbtool
+# Project: custom-class example
 # Author: Christian Starkjohann
 # Creation Date: 2008-04-06
 # Tabsize: 4
@@ -22,7 +22,7 @@ EXE_SUFFIX =
 #USBLIBS = -L/usr/local/lib -lusb
 #EXE_SUFFIX = .exe
 
-NAME = usbtool
+NAME = snesuploader
 
 OBJECTS = opendevice.o $(NAME).o
 

avr/usbload/commandline/opendevice.c

@@ -0,0 +1,296 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *       Based on:  custom-class, a basic USB example 
+ *         Author:  Christian Starkjohann 
+ * =====================================================================================
+ */
+
+
+
+
+#include <stdio.h>
+#include "opendevice.h"
+
+/*
+ * ------------------------------------------------------------------------- 
+ */
+
+#define MATCH_SUCCESS			1
+#define MATCH_FAILED			0
+#define MATCH_ABORT				-1
+
+/*
+ * private interface: match text and p, return MATCH_SUCCESS, MATCH_FAILED, or
+ * MATCH_ABORT. 
+ */
+static int _shellStyleMatch(char *text, char *p)
+{
+    int last,
+     matched,
+     reverse;
+
+    for (; *p; text++, p++) {
+        if (*text == 0 && *p != '*')
+            return MATCH_ABORT;
+        switch (*p) {
+        case '\\':
+            /*
+             * Literal match with following character. 
+             */
+            p++;
+            /*
+             * FALLTHROUGH 
+             */
+        default:
+            if (*text != *p)
+                return MATCH_FAILED;
+            continue;
+        case '?':
+            /*
+             * Match anything. 
+             */
+            continue;
+        case '*':
+            while (*++p == '*')
+                /*
+                 * Consecutive stars act just like one. 
+                 */
+                continue;
+            if (*p == 0)
+                /*
+                 * Trailing star matches everything. 
+                 */
+                return MATCH_SUCCESS;
+            while (*text)
+                if ((matched = _shellStyleMatch(text++, p)) != MATCH_FAILED)
+                    return matched;
+            return MATCH_ABORT;
+        case '[':
+            reverse = p[1] == '^';
+            if (reverse)        /* Inverted character class. */
+                p++;
+            matched = MATCH_FAILED;
+            if (p[1] == ']' || p[1] == '-')
+                if (*++p == *text)
+                    matched = MATCH_SUCCESS;
+            for (last = *p; *++p && *p != ']'; last = *p)
+                if (*p == '-' && p[1] != ']' ? *text <= *++p
+                    && *text >= last : *text == *p)
+                    matched = MATCH_SUCCESS;
+            if (matched == reverse)
+                return MATCH_FAILED;
+            continue;
+        }
+    }
+    return *text == 0;
+}
+
+/*
+ * public interface for shell style matching: returns 0 if fails, 1 if matches 
+ */
+static int shellStyleMatch(char *text, char *pattern)
+{
+    if (pattern == NULL)        /* NULL pattern is synonymous to "*" */
+        return 1;
+    return _shellStyleMatch(text, pattern) == MATCH_SUCCESS;
+}
+
+/*
+ * ------------------------------------------------------------------------- 
+ */
+
+int usbGetStringAscii(usb_dev_handle * dev, int index, char *buf, int buflen)
+{
+    char buffer[256];
+    int rval,
+     i;
+
+    if ((rval = usb_get_string_simple(dev, index, buf, buflen)) >= 0)   /* use
+                                                                         * libusb 
+                                                                         * version 
+                                                                         * if
+                                                                         * it
+                                                                         * works 
+                                                                         */
+        return rval;
+    if ((rval =
+         usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
+                         (USB_DT_STRING << 8) + index, 0x0409, buffer,
+                         sizeof(buffer), 5000)) < 0)
+        return rval;
+    if (buffer[1] != USB_DT_STRING) {
+        *buf = 0;
+        return 0;
+    }
+    if ((unsigned char) buffer[0] < rval)
+        rval = (unsigned char) buffer[0];
+    rval /= 2;
+    /*
+     * lossy conversion to ISO Latin1: 
+     */
+    for (i = 1; i < rval; i++) {
+        if (i > buflen)         /* destination buffer overflow */
+            break;
+        buf[i - 1] = buffer[2 * i];
+        if (buffer[2 * i + 1] != 0)     /* outside of ISO Latin1 range */
+            buf[i - 1] = '?';
+    }
+    buf[i - 1] = 0;
+    return i - 1;
+}
+
+/*
+ * ------------------------------------------------------------------------- 
+ */
+
+int usbOpenDevice(usb_dev_handle ** device, int vendorID,
+                  char *vendorNamePattern, int productID,
+                  char *productNamePattern, char *serialNamePattern,
+                  FILE * printMatchingDevicesFp, FILE * warningsFp)
+{
+    struct usb_bus *bus;
+    struct usb_device *dev;
+    usb_dev_handle *handle = NULL;
+    int errorCode = USBOPEN_ERR_NOTFOUND;
+
+    usb_find_busses();
+    usb_find_devices();
+    for (bus = usb_get_busses(); bus; bus = bus->next) {
+        for (dev = bus->devices; dev; dev = dev->next) {        /* iterate over 
+                                                                 * all devices
+                                                                 * on all
+                                                                 * busses */
+            if ((vendorID == 0 || dev->descriptor.idVendor == vendorID)
+                && (productID == 0 || dev->descriptor.idProduct == productID)) {
+                char vendor[256],
+                 product[256],
+                 serial[256];
+                int len;
+                handle = usb_open(dev); /* we need to open the device in order
+                                         * to query strings */
+                if (!handle) {
+                    errorCode = USBOPEN_ERR_ACCESS;
+                    if (warningsFp != NULL)
+                        fprintf(warningsFp,
+                                "Warning: cannot open VID=0x%04x PID=0x%04x: %s\n",
+                                dev->descriptor.idVendor,
+                                dev->descriptor.idProduct, usb_strerror());
+                    continue;
+                }
+                /*
+                 * now check whether the names match: 
+                 */
+                len = vendor[0] = 0;
+                if (dev->descriptor.iManufacturer > 0) {
+                    len =
+                        usbGetStringAscii(handle, dev->descriptor.iManufacturer,
+                                          vendor, sizeof(vendor));
+                }
+                if (len < 0) {
+                    errorCode = USBOPEN_ERR_ACCESS;
+                    if (warningsFp != NULL)
+                        fprintf(warningsFp,
+                                "Warning: cannot query manufacturer for VID=0x%04x PID=0x%04x: %s\n",
+                                dev->descriptor.idVendor,
+                                dev->descriptor.idProduct, usb_strerror());
+                } else {
+                    errorCode = USBOPEN_ERR_NOTFOUND;
+                    /*
+                     * printf("seen device from vendor ->%s<-\n", vendor); 
+                     */
+                    if (shellStyleMatch(vendor, vendorNamePattern)) {
+                        len = product[0] = 0;
+                        if (dev->descriptor.iProduct > 0) {
+                            len =
+                                usbGetStringAscii(handle,
+                                                  dev->descriptor.iProduct,
+                                                  product, sizeof(product));
+                        }
+                        if (len < 0) {
+                            errorCode = USBOPEN_ERR_ACCESS;
+                            if (warningsFp != NULL)
+                                fprintf(warningsFp,
+                                        "Warning: cannot query product for VID=0x%04x PID=0x%04x: %s\n",
+                                        dev->descriptor.idVendor,
+                                        dev->descriptor.idProduct,
+                                        usb_strerror());
+                        } else {
+                            errorCode = USBOPEN_ERR_NOTFOUND;
+                            /*
+                             * printf("seen product ->%s<-\n", product); 
+                             */
+                            if (shellStyleMatch(product, productNamePattern)) {
+                                len = serial[0] = 0;
+                                if (dev->descriptor.iSerialNumber > 0) {
+                                    len =
+                                        usbGetStringAscii(handle,
+                                                          dev->descriptor.
+                                                          iSerialNumber, serial,
+                                                          sizeof(serial));
+                                }
+                                if (len < 0) {
+                                    errorCode = USBOPEN_ERR_ACCESS;
+                                    if (warningsFp != NULL)
+                                        fprintf(warningsFp,
+                                                "Warning: cannot query serial for VID=0x%04x PID=0x%04x: %s\n",
+                                                dev->descriptor.idVendor,
+                                                dev->descriptor.idProduct,
+                                                usb_strerror());
+                                }
+                                if (shellStyleMatch(serial, serialNamePattern)) {
+                                    if (printMatchingDevicesFp != NULL) {
+                                        if (serial[0] == 0) {
+                                            fprintf(printMatchingDevicesFp,
+                                                    "VID=0x%04x PID=0x%04x vendor=\"%s\" product=\"%s\"\n",
+                                                    dev->descriptor.idVendor,
+                                                    dev->descriptor.idProduct,
+                                                    vendor, product);
+                                        } else {
+                                            fprintf(printMatchingDevicesFp,
+                                                    "VID=0x%04x PID=0x%04x vendor=\"%s\" product=\"%s\" serial=\"%s\"\n",
+                                                    dev->descriptor.idVendor,
+                                                    dev->descriptor.idProduct,
+                                                    vendor, product, serial);
+                                        }
+                                    } else {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                usb_close(handle);
+                handle = NULL;
+            }
+        }
+        if (handle)             /* we have found a deice */
+            break;
+    }
+    if (handle != NULL) {
+        errorCode = 0;
+        *device = handle;
+    }
+    if (printMatchingDevicesFp != NULL) /* never return an error for listing
+                                         * only */
+        errorCode = 0;
+    return errorCode;
+}
+
+/*
+ * ------------------------------------------------------------------------- 
+ */

avr/usbload/commandline/opendevice.h

@@ -1,24 +1,24 @@
-/* Name: opendevice.h
+/*
- * Project: V-USB host-side library
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *       Based on:  custom-class, a basic USB example 
  *         Author:  Christian Starkjohann 
- * Creation Date: 2008-04-10
+ * =====================================================================================
- * Tabsize: 4
- * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH
- * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
- * This Revision: $Id: opendevice.h 740 2009-04-13 18:23:31Z cs $
  */
 
-/*
-General Description:
-This module offers additional functionality for host side drivers based on
-libusb or libusb-win32. It includes a function to find and open a device
-based on numeric IDs and textual description. It also includes a function to
-obtain textual descriptions from a device.
-
-To use this functionality, simply copy opendevice.c and opendevice.h into your
-project and add them to your Makefile. You may modify and redistribute these
-files according to the GNU General Public License (GPL) version 2 or 3.
-*/
 
 #ifndef __OPENDEVICE_H_INCLUDED__
 #define __OPENDEVICE_H_INCLUDED__

avr/usbload/commandline/snesuploader.c

@@ -0,0 +1,313 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *       Based on:  custom-class, a basic USB example 
+ *         Author:  Christian Starkjohann 
+ * =====================================================================================
+ */
+#define BANK_SIZE_SHIFT     15
+#define BANK_SIZE           (1<<BANK_SIZE_SHIFT)
+#define READ_BUFFER_SIZE    (1<<BANK_SIZE_SHIFT)
+#define SEND_BUFFER_SIZE    128
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <usb.h>                /* this is libusb */
+
+#include "opendevice.h"         /* common code moved to separate module */
+
+#include "../requests.h"        /* custom request numbers */
+#include "../usbconfig.h"       /* device's VID/PID and names */
+
+
+
+void dump_packet(uint32_t addr, uint32_t len, uint8_t * packet)
+{
+    uint16_t i,
+     j;
+    uint16_t sum = 0;
+    uint8_t clear = 0;
+
+    for (i = 0; i < len; i += 16) {
+
+        sum = 0;
+        for (j = 0; j < 16; j++) {
+            sum += packet[i + j];
+        }
+        if (!sum) {
+            clear = 1;
+            continue;
+        }
+        if (clear) {
+            printf("*\n");
+            clear = 0;
+        }
+        printf("%08x:", addr + i);
+        for (j = 0; j < 16; j++) {
+            printf(" %02x", packet[i + j]);
+        }
+        printf(" |");
+        for (j = 0; j < 16; j++) {
+            if (packet[i + j] >= 33 && packet[i + j] <= 126)
+                printf("%c", packet[i + j]);
+            else
+                printf(".");
+        }
+        printf("|\n");
+    }
+}
+
+
+uint16_t crc_xmodem_update(uint16_t crc, uint8_t data)
+{
+    int i;
+    crc = crc ^ ((uint16_t) data << 8);
+    for (i = 0; i < 8; i++) {
+        if (crc & 0x8000)
+            crc = (crc << 1) ^ 0x1021;
+        else
+            crc <<= 1;
+    }
+
+    return crc;
+}
+
+uint16_t do_crc(uint8_t * data, uint16_t size)
+{
+    uint16_t crc = 0;
+    uint16_t i;
+    for (i = 0; i < size; i++) {
+        crc = crc_xmodem_update(crc, data[i]);
+    }
+    return crc;
+}
+
+
+uint16_t do_crc_update(uint16_t crc, uint8_t * data, uint16_t size)
+{
+    uint16_t i;
+    for (i = 0; i < size; i++)
+        crc = crc_xmodem_update(crc, data[i]);
+    return crc;
+}
+
+
+
+static void usage(char *name)
+{
+    fprintf(stderr, "usage:\n");
+    fprintf(stderr, "  %s upload filename.. upload\n", name);
+}
+
+
+int main(int argc, char **argv)
+{
+    usb_dev_handle *handle = NULL;
+    const unsigned char rawVid[2] = { USB_CFG_VENDOR_ID }, rawPid[2] = {
+    USB_CFG_DEVICE_ID};
+    char vendor[] = { USB_CFG_VENDOR_NAME, 0 }, product[] = {
+    USB_CFG_DEVICE_NAME, 0};
+    int cnt, vid, pid;
+    uint8_t *read_buffer;
+    uint8_t *crc_buffer;
+    uint8_t *ptr;
+    
+    uint32_t addr = 0;
+    uint16_t addr_lo = 0;
+    uint16_t addr_hi = 0;
+    uint32_t step = 0;
+    uint16_t crc = 0;
+    uint8_t bank = 0;
+    uint8_t bank_cnt = 0;
+    uint32_t file_size = 0;
+    uint32_t file_offset = 0;
+    
+    FILE *fp;
+    usb_init();
+    if (argc < 2) {             /* we need at least one argument */
+        usage(argv[0]);
+        exit(1);
+    }
+    /*
+     * compute VID/PID from usbconfig.h so that there is a central source
+     * of information
+     */
+    vid = rawVid[1] * 256 + rawVid[0];
+    pid = rawPid[1] * 256 + rawPid[0];
+    /*
+     * The following function is in opendevice.c: 
+     */
+    if (usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) !=
+        0) {
+        fprintf(stderr,
+                "Could not find USB device \"%s\" with vid=0x%x pid=0x%x\n",
+                product, vid, pid);
+        exit(1);
+    }
+    printf("Open USB device \"%s\" with vid=0x%x pid=0x%x\n", product, vid,
+           pid);
+    if (strcasecmp(argv[1], "upload") == 0) {
+        if (argc < 3) {         /* we need at least one argument */
+            usage(argv[0]);
+            exit(1);
+        }
+        fp = fopen(argv[2], "r");
+        if (fp == NULL) {
+            fprintf(stderr, "Cannot open file %s ", argv[2]);
+            exit(1);
+        }
+        
+        fseek (fp, 0, SEEK_END);
+        file_size = ftell (fp);
+        file_offset = 512;
+        if (strstr(argv[2],".smc") || strstr(argv[2],".swc")){
+            printf("Skip 512 Byte header\n");
+            file_size -= 512;
+            
+            fseek (fp, 512, SEEK_SET);
+            
+        } else { 
+            fseek (fp, 0, SEEK_SET);
+        }
+
+        bank_cnt = file_size / BANK_SIZE;
+        printf("Transfer '%s' %i Bytes, %i Banks\n",argv[2],file_size,bank_cnt);
+    
+          
+            
+        read_buffer = (unsigned char *) malloc(READ_BUFFER_SIZE);
+        crc_buffer = (unsigned char *) malloc(0x1000);
+        memset(crc_buffer, 0, 0x1000);
+        addr = 0x000000;
+        
+        cnt = usb_control_msg(handle,
+                            USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                            USB_ENDPOINT_OUT, USB_MODE_AVR, 0, 0, NULL,
+                            0, 5000);
+        
+        
+        
+        cnt = usb_control_msg(handle,
+                        USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
+                        USB_BULK_UPLOAD_INIT, BANK_SIZE_SHIFT , bank_cnt, NULL, 0, 5000);
+
+        if (cnt < 0) {
+            fprintf(stderr, "USB error: %s\n", usb_strerror());
+            usb_close(handle);
+            exit(-1);
+        } 
+        ptr = crc_buffer;
+        while ((cnt = fread(read_buffer, READ_BUFFER_SIZE, 1, fp)) > 0) {
+            ptr = crc_buffer;
+            for (step = 0; step < READ_BUFFER_SIZE; step += SEND_BUFFER_SIZE) {
+                
+                
+                addr_lo = addr & 0xffff;
+                addr_hi = (addr >> 16) & 0x00ff;
+                if (addr == 0x000000){
+
+                    cnt = usb_control_msg(handle,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                                USB_ENDPOINT_OUT, USB_BULK_UPLOAD_ADDR, addr_hi,
+                                addr_lo, (char *) read_buffer + step,
+                                SEND_BUFFER_SIZE, 5000);
+                } else {
+                    
+                    cnt = usb_control_msg(handle,
+                                USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                                USB_ENDPOINT_OUT, USB_BULK_UPLOAD_NEXT, addr_hi,
+                                addr_lo, (char *) read_buffer + step,
+                                SEND_BUFFER_SIZE, 5000);
+                    
+                }
+                if (cnt < 0) {
+                    fprintf(stderr, "USB error: %s\n", usb_strerror());
+                    usb_close(handle);
+                    exit(-1);
+                } 
+                
+                memcpy(ptr, read_buffer + step, SEND_BUFFER_SIZE);
+                addr += SEND_BUFFER_SIZE;
+                ptr += SEND_BUFFER_SIZE;
+                if ( addr % BANK_SIZE == 0){
+                    crc = do_crc(crc_buffer, 0x1000);
+                    printf ("bank=0x%02x addr=0x%08x addr=0x%08x crc=0x%04x\n", bank, addr - 0x1000, addr, crc);
+                    ptr = crc_buffer;
+                    if ( addr % BANK_SIZE == 0) {
+                        bank++;
+                        
+                    }
+                }                
+            }
+        }
+        bank = 0;
+        cnt = usb_control_msg(handle,
+                             USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                             USB_ENDPOINT_OUT, USB_BULK_UPLOAD_END, 0, 0, NULL,
+                             0, 5000);
+ 
+        
+        fseek(fp, file_offset, SEEK_SET);
+        while ((cnt = fread(read_buffer, READ_BUFFER_SIZE, 1, fp)) > 0) {
+            printf ("bank=0x%02x crc=0x%04x\n", bank++, 
+                do_crc(read_buffer, READ_BUFFER_SIZE));
+        }
+        fclose(fp);
+        
+        cnt = usb_control_msg(handle,
+                            USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                            USB_ENDPOINT_OUT, USB_MODE_SNES, 0, 0, NULL,
+                            0, 5000);
+        
+
+        if (cnt < 1) {
+            if (cnt < 0) {
+                fprintf(stderr, "USB error: %s\n", usb_strerror());
+            } else {
+                fprintf(stderr, "only %d bytes received.\n", cnt);
+            }
+        }
+    } else if (strcasecmp(argv[1], "crc") == 0) {
+        /*
+         * if(argc < 2){ usage(argv[0]); exit(1); } 
+         */
+        addr = 0x000000;
+        addr_lo = addr & 0xffff;
+        addr_hi = (addr >> 16) & 0xff;
+        printf("Request CRC for Addr: 0x%06x\n", addr);
+
+        cnt = usb_control_msg(handle,
+                              USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                              USB_ENDPOINT_OUT, USB_CRC_ADDR, addr_hi, addr_lo,
+                              NULL, (1 << 15) / 4, 5000);
+
+        if (cnt < 1) {
+            if (cnt < 0) {
+                fprintf(stderr, "USB error: %s\n", usb_strerror());
+            } else {
+                fprintf(stderr, "only %d bytes received.\n", cnt);
+            }
+        }
+    } else {
+        usage(argv[0]);
+        exit(1);
+    }
+    usb_close(handle);
+    return 0;
+}

avr/usbload/commandline/snesuploader.ll

@@ -0,0 +1,809 @@
+; ModuleID = '/Users/david/Devel/arch/avr/code/snesram/poc/avr_usbload/commandline/snesuploader.c'
+target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
+target triple = "i386-apple-darwin9"
+	%struct.__sFILE = type <{ i8*, i32, i32, i16, i16, %struct.__sbuf, i32, i8*, i32 (i8*)*, i32 (i8*, i8*, i32)*, i64 (i8*, i64, i32)*, i32 (i8*, i8*, i32)*, %struct.__sbuf, %struct.__sFILEX*, i32, [3 x i8], [1 x i8], %struct.__sbuf, i32, i64 }>
+	%struct.__sFILEX = type opaque
+	%struct.__sbuf = type <{ i8*, i32 }>
+	%struct.usb_dev_handle = type opaque
+@"\01LC" = internal constant [3 x i8] c"*\0A\00"		; <[3 x i8]*> [#uses=1]
+@"\01LC1" = internal constant [6 x i8] c"%08x:\00"		; <[6 x i8]*> [#uses=1]
+@"\01LC2" = internal constant [6 x i8] c" %02x\00"		; <[6 x i8]*> [#uses=1]
+@"\01LC3" = internal constant [3 x i8] c" |\00"		; <[3 x i8]*> [#uses=1]
+@"\01LC4" = internal constant [3 x i8] c"%c\00"		; <[3 x i8]*> [#uses=1]
+@"\01LC5" = internal constant [2 x i8] c".\00"		; <[2 x i8]*> [#uses=1]
+@"\01LC6" = internal constant [3 x i8] c"|\0A\00"		; <[3 x i8]*> [#uses=1]
+@__stderrp = external global %struct.__sFILE*		; <%struct.__sFILE**> [#uses=8]
+@"\01LC7" = internal constant [55 x i8] c"Could not find USB device \22%s\22 with vid=0x%x pid=0x%x\0A\00"		; <[55 x i8]*> [#uses=1]
+@"\01LC8" = internal constant [45 x i8] c"Open USB device \22%s\22 with vid=0x%x pid=0x%x\0A\00"		; <[45 x i8]*> [#uses=1]
+@"\01LC9" = internal constant [7 x i8] c"upload\00"		; <[7 x i8]*> [#uses=1]
+@"\01LC10" = internal constant [2 x i8] c"r\00"		; <[2 x i8]*> [#uses=1]
+@"\01LC11" = internal constant [21 x i8] c"Cannot open file %s \00"		; <[21 x i8]*> [#uses=1]
+@"\01LC12" = internal constant [70 x i8] c"Addr: 0x%06x Bank: 0x%02x HiAddr: 0x%02x  LoAddr: 0x%04x Crc: 0x%04x\0A\00"		; <[70 x i8]*> [#uses=1]
+@"\01LC13" = internal constant [15 x i8] c"USB error: %s\0A\00"		; <[15 x i8]*> [#uses=1]
+@"\01LC14" = internal constant [25 x i8] c"only %d bytes received.\0A\00"		; <[25 x i8]*> [#uses=1]
+@"\01LC15" = internal constant [4 x i8] c"crc\00"		; <[4 x i8]*> [#uses=1]
+@"\01LC16" = internal constant [30 x i8] c"Request CRC for Addr: 0x%06x\0A\00"		; <[30 x i8]*> [#uses=1]
+@"\01LC17" = internal constant [8 x i8] c"usage:\0A\00"		; <[8 x i8]*> [#uses=1]
+@"\01LC18" = internal constant [31 x i8] c"  %s upload filename.. upload\0A\00"		; <[31 x i8]*> [#uses=1]
+
+define void @dump_packet(i32 %addr, i32 %len, i8* %packet) nounwind {
+entry:
+	%addr.addr = alloca i32		; <i32*> [#uses=2]
+	%len.addr = alloca i32		; <i32*> [#uses=2]
+	%packet.addr = alloca i8*		; <i8**> [#uses=6]
+	%i = alloca i16, align 2		; <i16*> [#uses=10]
+	%j = alloca i16, align 2		; <i16*> [#uses=17]
+	%sum = alloca i16, align 2		; <i16*> [#uses=5]
+	%clear = alloca i8, align 1		; <i8*> [#uses=4]
+	store i32 %addr, i32* %addr.addr
+	store i32 %len, i32* %len.addr
+	store i8* %packet, i8** %packet.addr
+	store i16 0, i16* %sum
+	store i8 0, i8* %clear
+	store i16 0, i16* %i
+	br label %for.cond
+
+for.cond:		; preds = %for.inc98, %entry
+	%tmp = load i16* %i		; <i16> [#uses=1]
+	%conv = zext i16 %tmp to i32		; <i32> [#uses=1]
+	%tmp1 = load i32* %len.addr		; <i32> [#uses=1]
+	%cmp = icmp ult i32 %conv, %tmp1		; <i1> [#uses=1]
+	br i1 %cmp, label %for.body, label %for.end103
+
+for.body:		; preds = %for.cond
+	store i16 0, i16* %sum
+	store i16 0, i16* %j
+	br label %for.cond3
+
+for.cond3:		; preds = %for.inc, %for.body
+	%tmp4 = load i16* %j		; <i16> [#uses=1]
+	%conv5 = zext i16 %tmp4 to i32		; <i32> [#uses=1]
+	%cmp6 = icmp slt i32 %conv5, 16		; <i1> [#uses=1]
+	br i1 %cmp6, label %for.body8, label %for.end
+
+for.body8:		; preds = %for.cond3
+	%tmp9 = load i16* %sum		; <i16> [#uses=1]
+	%conv10 = zext i16 %tmp9 to i32		; <i32> [#uses=1]
+	%tmp11 = load i16* %i		; <i16> [#uses=1]
+	%conv12 = zext i16 %tmp11 to i32		; <i32> [#uses=1]
+	%tmp13 = load i16* %j		; <i16> [#uses=1]
+	%conv14 = zext i16 %tmp13 to i32		; <i32> [#uses=1]
+	%add = add i32 %conv12, %conv14		; <i32> [#uses=1]
+	%tmp15 = load i8** %packet.addr		; <i8*> [#uses=1]
+	%arrayidx = getelementptr i8* %tmp15, i32 %add		; <i8*> [#uses=1]
+	%tmp16 = load i8* %arrayidx		; <i8> [#uses=1]
+	%conv17 = zext i8 %tmp16 to i32		; <i32> [#uses=1]
+	%add18 = add i32 %conv10, %conv17		; <i32> [#uses=1]
+	%conv19 = trunc i32 %add18 to i16		; <i16> [#uses=1]
+	store i16 %conv19, i16* %sum
+	br label %for.inc
+
+for.inc:		; preds = %for.body8
+	%tmp20 = load i16* %j		; <i16> [#uses=1]
+	%inc = add i16 %tmp20, 1		; <i16> [#uses=1]
+	store i16 %inc, i16* %j
+	br label %for.cond3
+
+for.end:		; preds = %for.cond3
+	%tmp21 = load i16* %sum		; <i16> [#uses=1]
+	%tobool = icmp ne i16 %tmp21, 0		; <i1> [#uses=1]
+	br i1 %tobool, label %if.end, label %if.then
+
+if.then:		; preds = %for.end
+	store i8 1, i8* %clear
+	br label %for.inc98
+
+if.end:		; preds = %for.end
+	%tmp22 = load i8* %clear		; <i8> [#uses=1]
+	%tobool23 = icmp ne i8 %tmp22, 0		; <i1> [#uses=1]
+	br i1 %tobool23, label %if.then24, label %if.end25
+
+if.then24:		; preds = %if.end
+	%call = call i32 (i8*, ...)* @printf(i8* getelementptr ([3 x i8]* @"\01LC", i32 0, i32 0))		; <i32> [#uses=0]
+	store i8 0, i8* %clear
+	br label %if.end25
+
+if.end25:		; preds = %if.then24, %if.end
+	%tmp26 = load i32* %addr.addr		; <i32> [#uses=1]
+	%tmp27 = load i16* %i		; <i16> [#uses=1]
+	%conv28 = zext i16 %tmp27 to i32		; <i32> [#uses=1]
+	%add29 = add i32 %tmp26, %conv28		; <i32> [#uses=1]
+	%call30 = call i32 (i8*, ...)* @printf(i8* getelementptr ([6 x i8]* @"\01LC1", i32 0, i32 0), i32 %add29)		; <i32> [#uses=0]
+	store i16 0, i16* %j
+	br label %for.cond31
+
+for.cond31:		; preds = %for.inc47, %if.end25
+	%tmp32 = load i16* %j		; <i16> [#uses=1]
+	%conv33 = zext i16 %tmp32 to i32		; <i32> [#uses=1]
+	%cmp34 = icmp slt i32 %conv33, 16		; <i1> [#uses=1]
+	br i1 %cmp34, label %for.body36, label %for.end50
+
+for.body36:		; preds = %for.cond31
+	%tmp37 = load i16* %i		; <i16> [#uses=1]
+	%conv38 = zext i16 %tmp37 to i32		; <i32> [#uses=1]
+	%tmp39 = load i16* %j		; <i16> [#uses=1]
+	%conv40 = zext i16 %tmp39 to i32		; <i32> [#uses=1]
+	%add41 = add i32 %conv38, %conv40		; <i32> [#uses=1]
+	%tmp42 = load i8** %packet.addr		; <i8*> [#uses=1]
+	%arrayidx43 = getelementptr i8* %tmp42, i32 %add41		; <i8*> [#uses=1]
+	%tmp44 = load i8* %arrayidx43		; <i8> [#uses=1]
+	%conv45 = zext i8 %tmp44 to i32		; <i32> [#uses=1]
+	%call46 = call i32 (i8*, ...)* @printf(i8* getelementptr ([6 x i8]* @"\01LC2", i32 0, i32 0), i32 %conv45)		; <i32> [#uses=0]
+	br label %for.inc47
+
+for.inc47:		; preds = %for.body36
+	%tmp48 = load i16* %j		; <i16> [#uses=1]
+	%inc49 = add i16 %tmp48, 1		; <i16> [#uses=1]
+	store i16 %inc49, i16* %j
+	br label %for.cond31
+
+for.end50:		; preds = %for.cond31
+	%call51 = call i32 (i8*, ...)* @printf(i8* getelementptr ([3 x i8]* @"\01LC3", i32 0, i32 0))		; <i32> [#uses=0]
+	store i16 0, i16* %j
+	br label %for.cond52
+
+for.cond52:		; preds = %for.inc93, %for.end50
+	%tmp53 = load i16* %j		; <i16> [#uses=1]
+	%conv54 = zext i16 %tmp53 to i32		; <i32> [#uses=1]
+	%cmp55 = icmp slt i32 %conv54, 16		; <i1> [#uses=1]
+	br i1 %cmp55, label %for.body57, label %for.end96
+
+for.body57:		; preds = %for.cond52
+	%tmp58 = load i16* %i		; <i16> [#uses=1]
+	%conv59 = zext i16 %tmp58 to i32		; <i32> [#uses=1]
+	%tmp60 = load i16* %j		; <i16> [#uses=1]
+	%conv61 = zext i16 %tmp60 to i32		; <i32> [#uses=1]
+	%add62 = add i32 %conv59, %conv61		; <i32> [#uses=1]
+	%tmp63 = load i8** %packet.addr		; <i8*> [#uses=1]
+	%arrayidx64 = getelementptr i8* %tmp63, i32 %add62		; <i8*> [#uses=1]
+	%tmp65 = load i8* %arrayidx64		; <i8> [#uses=1]
+	%conv66 = zext i8 %tmp65 to i32		; <i32> [#uses=1]
+	%cmp67 = icmp sge i32 %conv66, 33		; <i1> [#uses=1]
+	br i1 %cmp67, label %land.lhs.true, label %if.else
+
+land.lhs.true:		; preds = %for.body57
+	%tmp69 = load i16* %i		; <i16> [#uses=1]
+	%conv70 = zext i16 %tmp69 to i32		; <i32> [#uses=1]
+	%tmp71 = load i16* %j		; <i16> [#uses=1]
+	%conv72 = zext i16 %tmp71 to i32		; <i32> [#uses=1]
+	%add73 = add i32 %conv70, %conv72		; <i32> [#uses=1]
+	%tmp74 = load i8** %packet.addr		; <i8*> [#uses=1]
+	%arrayidx75 = getelementptr i8* %tmp74, i32 %add73		; <i8*> [#uses=1]
+	%tmp76 = load i8* %arrayidx75		; <i8> [#uses=1]
+	%conv77 = zext i8 %tmp76 to i32		; <i32> [#uses=1]
+	%cmp78 = icmp sle i32 %conv77, 126		; <i1> [#uses=1]
+	br i1 %cmp78, label %if.then80, label %if.else
+
+if.then80:		; preds = %land.lhs.true
+	%tmp81 = load i16* %i		; <i16> [#uses=1]
+	%conv82 = zext i16 %tmp81 to i32		; <i32> [#uses=1]
+	%tmp83 = load i16* %j		; <i16> [#uses=1]
+	%conv84 = zext i16 %tmp83 to i32		; <i32> [#uses=1]
+	%add85 = add i32 %conv82, %conv84		; <i32> [#uses=1]
+	%tmp86 = load i8** %packet.addr		; <i8*> [#uses=1]
+	%arrayidx87 = getelementptr i8* %tmp86, i32 %add85		; <i8*> [#uses=1]
+	%tmp88 = load i8* %arrayidx87		; <i8> [#uses=1]
+	%conv89 = zext i8 %tmp88 to i32		; <i32> [#uses=1]
+	%call90 = call i32 (i8*, ...)* @printf(i8* getelementptr ([3 x i8]* @"\01LC4", i32 0, i32 0), i32 %conv89)		; <i32> [#uses=0]
+	br label %if.end92
+
+if.else:		; preds = %land.lhs.true, %for.body57
+	%call91 = call i32 (i8*, ...)* @printf(i8* getelementptr ([2 x i8]* @"\01LC5", i32 0, i32 0))		; <i32> [#uses=0]
+	br label %if.end92
+
+if.end92:		; preds = %if.else, %if.then80
+	br label %for.inc93
+
+for.inc93:		; preds = %if.end92
+	%tmp94 = load i16* %j		; <i16> [#uses=1]
+	%inc95 = add i16 %tmp94, 1		; <i16> [#uses=1]
+	store i16 %inc95, i16* %j
+	br label %for.cond52
+
+for.end96:		; preds = %for.cond52
+	%call97 = call i32 (i8*, ...)* @printf(i8* getelementptr ([3 x i8]* @"\01LC6", i32 0, i32 0))		; <i32> [#uses=0]
+	br label %for.inc98
+
+for.inc98:		; preds = %for.end96, %if.then
+	%tmp99 = load i16* %i		; <i16> [#uses=1]
+	%conv100 = zext i16 %tmp99 to i32		; <i32> [#uses=1]
+	%add101 = add i32 %conv100, 16		; <i32> [#uses=1]
+	%conv102 = trunc i32 %add101 to i16		; <i16> [#uses=1]
+	store i16 %conv102, i16* %i
+	br label %for.cond
+
+for.end103:		; preds = %for.cond
+	ret void
+}
+
+declare i32 @printf(i8*, ...)
+
+define zeroext i16 @crc_xmodem_update(i16 zeroext %crc, i8 zeroext %data) nounwind {
+entry:
+	%retval = alloca i16		; <i16*> [#uses=2]
+	%crc.addr = alloca i16		; <i16*> [#uses=9]
+	%data.addr = alloca i8		; <i8*> [#uses=2]
+	%i = alloca i32, align 4		; <i32*> [#uses=4]
+	store i16 %crc, i16* %crc.addr
+	store i8 %data, i8* %data.addr
+	%tmp = load i16* %crc.addr		; <i16> [#uses=1]
+	%conv = zext i16 %tmp to i32		; <i32> [#uses=1]
+	%tmp1 = load i8* %data.addr		; <i8> [#uses=1]
+	%conv2 = zext i8 %tmp1 to i32		; <i32> [#uses=1]
+	%conv3 = trunc i32 %conv2 to i16		; <i16> [#uses=1]
+	%conv4 = zext i16 %conv3 to i32		; <i32> [#uses=1]
+	%shl = shl i32 %conv4, 8		; <i32> [#uses=1]
+	%xor = xor i32 %conv, %shl		; <i32> [#uses=1]
+	%conv5 = trunc i32 %xor to i16		; <i16> [#uses=1]
+	store i16 %conv5, i16* %crc.addr
+	store i32 0, i32* %i
+	br label %for.cond
+
+for.cond:		; preds = %for.inc, %entry
+	%tmp6 = load i32* %i		; <i32> [#uses=1]
+	%cmp = icmp slt i32 %tmp6, 8		; <i1> [#uses=1]
+	br i1 %cmp, label %for.body, label %for.end
+
+for.body:		; preds = %for.cond
+	%tmp8 = load i16* %crc.addr		; <i16> [#uses=1]
+	%conv9 = zext i16 %tmp8 to i32		; <i32> [#uses=1]
+	%and = and i32 %conv9, 32768		; <i32> [#uses=1]
+	%tobool = icmp ne i32 %and, 0		; <i1> [#uses=1]
+	br i1 %tobool, label %if.then, label %if.else
+
+if.then:		; preds = %for.body
+	%tmp10 = load i16* %crc.addr		; <i16> [#uses=1]
+	%conv11 = zext i16 %tmp10 to i32		; <i32> [#uses=1]
+	%shl12 = shl i32 %conv11, 1		; <i32> [#uses=1]
+	%xor13 = xor i32 %shl12, 4129		; <i32> [#uses=1]
+	%conv14 = trunc i32 %xor13 to i16		; <i16> [#uses=1]
+	store i16 %conv14, i16* %crc.addr
+	br label %if.end
+
+if.else:		; preds = %for.body
+	%tmp15 = load i16* %crc.addr		; <i16> [#uses=1]
+	%conv16 = zext i16 %tmp15 to i32		; <i32> [#uses=1]
+	%shl17 = shl i32 %conv16, 1		; <i32> [#uses=1]
+	%conv18 = trunc i32 %shl17 to i16		; <i16> [#uses=1]
+	store i16 %conv18, i16* %crc.addr
+	br label %if.end
+
+if.end:		; preds = %if.else, %if.then
+	br label %for.inc
+
+for.inc:		; preds = %if.end
+	%tmp19 = load i32* %i		; <i32> [#uses=1]
+	%inc = add i32 %tmp19, 1		; <i32> [#uses=1]
+	store i32 %inc, i32* %i
+	br label %for.cond
+
+for.end:		; preds = %for.cond
+	%tmp20 = load i16* %crc.addr		; <i16> [#uses=1]
+	store i16 %tmp20, i16* %retval
+	%0 = load i16* %retval		; <i16> [#uses=1]
+	ret i16 %0
+}
+
+define zeroext i16 @do_crc(i8* %data, i16 zeroext %size) nounwind {
+entry:
+	%retval = alloca i16		; <i16*> [#uses=2]
+	%data.addr = alloca i8*		; <i8**> [#uses=2]
+	%size.addr = alloca i16		; <i16*> [#uses=2]
+	%crc = alloca i16, align 2		; <i16*> [#uses=4]
+	%i = alloca i16, align 2		; <i16*> [#uses=5]
+	store i8* %data, i8** %data.addr
+	store i16 %size, i16* %size.addr
+	store i16 0, i16* %crc
+	store i16 0, i16* %i
+	br label %for.cond
+
+for.cond:		; preds = %for.inc, %entry
+	%tmp = load i16* %i		; <i16> [#uses=1]
+	%conv = zext i16 %tmp to i32		; <i32> [#uses=1]
+	%tmp1 = load i16* %size.addr		; <i16> [#uses=1]
+	%conv2 = zext i16 %tmp1 to i32		; <i32> [#uses=1]
+	%cmp = icmp slt i32 %conv, %conv2		; <i1> [#uses=1]
+	br i1 %cmp, label %for.body, label %for.end
+
+for.body:		; preds = %for.cond
+	%tmp4 = load i16* %crc		; <i16> [#uses=1]
+	%tmp5 = load i16* %i		; <i16> [#uses=1]
+	%tmp6 = load i8** %data.addr		; <i8*> [#uses=1]
+	%idxprom = zext i16 %tmp5 to i32		; <i32> [#uses=1]
+	%arrayidx = getelementptr i8* %tmp6, i32 %idxprom		; <i8*> [#uses=1]
+	%tmp7 = load i8* %arrayidx		; <i8> [#uses=1]
+	%call = call zeroext i16 @crc_xmodem_update(i16 zeroext %tmp4, i8 zeroext %tmp7)		; <i16> [#uses=1]
+	store i16 %call, i16* %crc
+	br label %for.inc
+
+for.inc:		; preds = %for.body
+	%tmp8 = load i16* %i		; <i16> [#uses=1]
+	%inc = add i16 %tmp8, 1		; <i16> [#uses=1]
+	store i16 %inc, i16* %i
+	br label %for.cond
+
+for.end:		; preds = %for.cond
+	%tmp9 = load i16* %crc		; <i16> [#uses=1]
+	store i16 %tmp9, i16* %retval
+	%0 = load i16* %retval		; <i16> [#uses=1]
+	ret i16 %0
+}
+
+define zeroext i16 @do_crc_update(i16 zeroext %crc, i8* %data, i16 zeroext %size) nounwind {
+entry:
+	%retval = alloca i16		; <i16*> [#uses=2]
+	%crc.addr = alloca i16		; <i16*> [#uses=4]
+	%data.addr = alloca i8*		; <i8**> [#uses=2]
+	%size.addr = alloca i16		; <i16*> [#uses=2]
+	%i = alloca i16, align 2		; <i16*> [#uses=5]
+	store i16 %crc, i16* %crc.addr
+	store i8* %data, i8** %data.addr
+	store i16 %size, i16* %size.addr
+	store i16 0, i16* %i
+	br label %for.cond
+
+for.cond:		; preds = %for.inc, %entry
+	%tmp = load i16* %i		; <i16> [#uses=1]
+	%conv = zext i16 %tmp to i32		; <i32> [#uses=1]
+	%tmp1 = load i16* %size.addr		; <i16> [#uses=1]
+	%conv2 = zext i16 %tmp1 to i32		; <i32> [#uses=1]
+	%cmp = icmp slt i32 %conv, %conv2		; <i1> [#uses=1]
+	br i1 %cmp, label %for.body, label %for.end
+
+for.body:		; preds = %for.cond
+	%tmp4 = load i16* %crc.addr		; <i16> [#uses=1]
+	%tmp5 = load i16* %i		; <i16> [#uses=1]
+	%tmp6 = load i8** %data.addr		; <i8*> [#uses=1]
+	%idxprom = zext i16 %tmp5 to i32		; <i32> [#uses=1]
+	%arrayidx = getelementptr i8* %tmp6, i32 %idxprom		; <i8*> [#uses=1]
+	%tmp7 = load i8* %arrayidx		; <i8> [#uses=1]
+	%call = call zeroext i16 @crc_xmodem_update(i16 zeroext %tmp4, i8 zeroext %tmp7)		; <i16> [#uses=1]
+	store i16 %call, i16* %crc.addr
+	br label %for.inc
+
+for.inc:		; preds = %for.body
+	%tmp8 = load i16* %i		; <i16> [#uses=1]
+	%inc = add i16 %tmp8, 1		; <i16> [#uses=1]
+	store i16 %inc, i16* %i
+	br label %for.cond
+
+for.end:		; preds = %for.cond
+	%tmp9 = load i16* %crc.addr		; <i16> [#uses=1]
+	store i16 %tmp9, i16* %retval
+	%0 = load i16* %retval		; <i16> [#uses=1]
+	ret i16 %0
+}
+
+define i32 @main(i32 %argc, i8** %argv) nounwind {
+entry:
+	%retval = alloca i32		; <i32*> [#uses=2]
+	%argc.addr = alloca i32		; <i32*> [#uses=3]
+	%argv.addr = alloca i8**		; <i8***> [#uses=8]
+	%handle = alloca %struct.usb_dev_handle*, align 4		; <%struct.usb_dev_handle**> [#uses=7]
+	%rawVid = alloca [2 x i8], align 1		; <[2 x i8]*> [#uses=4]
+	%rawPid = alloca [2 x i8], align 1		; <[2 x i8]*> [#uses=4]
+	%vendor = alloca [11 x i8], align 1		; <[11 x i8]*> [#uses=12]
+	%product = alloca [8 x i8], align 1		; <[8 x i8]*> [#uses=11]
+	%cnt = alloca i32, align 4		; <i32*> [#uses=9]
+	%vid = alloca i32, align 4		; <i32*> [#uses=4]
+	%pid = alloca i32, align 4		; <i32*> [#uses=4]
+	%cnt_crc = alloca i32, align 4		; <i32*> [#uses=6]
+	%read_buffer = alloca i8*, align 4		; <i8**> [#uses=4]
+	%crc_buffer = alloca i8*, align 4		; <i8**> [#uses=5]
+	%addr = alloca i32, align 4		; <i32*> [#uses=11]
+	%addr_lo = alloca i16, align 2		; <i16*> [#uses=7]
+	%addr_hi = alloca i16, align 2		; <i16*> [#uses=7]
+	%step = alloca i16, align 2		; <i16*> [#uses=6]
+	%crc = alloca i16, align 2		; <i16*> [#uses=3]
+	%bank = alloca i8, align 1		; <i8*> [#uses=4]
+	%fp = alloca %struct.__sFILE*, align 4		; <%struct.__sFILE**> [#uses=3]
+	store i32 %argc, i32* %argc.addr
+	store i8** %argv, i8*** %argv.addr
+	store %struct.usb_dev_handle* null, %struct.usb_dev_handle** %handle
+	%.array = getelementptr [2 x i8]* %rawVid, i32 0, i32 0		; <i8*> [#uses=1]
+	store i8 -64, i8* %.array
+	%.array1 = getelementptr [2 x i8]* %rawVid, i32 0, i32 1		; <i8*> [#uses=1]
+	store i8 22, i8* %.array1
+	%.array2 = getelementptr [2 x i8]* %rawPid, i32 0, i32 0		; <i8*> [#uses=1]
+	store i8 -36, i8* %.array2
+	%.array3 = getelementptr [2 x i8]* %rawPid, i32 0, i32 1		; <i8*> [#uses=1]
+	store i8 5, i8* %.array3
+	%.array4 = getelementptr [11 x i8]* %vendor, i32 0, i32 0		; <i8*> [#uses=1]
+	store i8 111, i8* %.array4
+	%.array5 = getelementptr [11 x i8]* %vendor, i32 0, i32 1		; <i8*> [#uses=1]
+	store i8 112, i8* %.array5
+	%.array6 = getelementptr [11 x i8]* %vendor, i32 0, i32 2		; <i8*> [#uses=1]
+	store i8 116, i8* %.array6
+	%.array7 = getelementptr [11 x i8]* %vendor, i32 0, i32 3		; <i8*> [#uses=1]
+	store i8 105, i8* %.array7
+	%.array8 = getelementptr [11 x i8]* %vendor, i32 0, i32 4		; <i8*> [#uses=1]
+	store i8 120, i8* %.array8
+	%.array9 = getelementptr [11 x i8]* %vendor, i32 0, i32 5		; <i8*> [#uses=1]
+	store i8 120, i8* %.array9
+	%.array10 = getelementptr [11 x i8]* %vendor, i32 0, i32 6		; <i8*> [#uses=1]
+	store i8 46, i8* %.array10
+	%.array11 = getelementptr [11 x i8]* %vendor, i32 0, i32 7		; <i8*> [#uses=1]
+	store i8 111, i8* %.array11
+	%.array12 = getelementptr [11 x i8]* %vendor, i32 0, i32 8		; <i8*> [#uses=1]
+	store i8 114, i8* %.array12
+	%.array13 = getelementptr [11 x i8]* %vendor, i32 0, i32 9		; <i8*> [#uses=1]
+	store i8 103, i8* %.array13
+	%.array14 = getelementptr [11 x i8]* %vendor, i32 0, i32 10		; <i8*> [#uses=1]
+	store i8 0, i8* %.array14
+	%.array15 = getelementptr [8 x i8]* %product, i32 0, i32 0		; <i8*> [#uses=1]
+	store i8 83, i8* %.array15
+	%.array16 = getelementptr [8 x i8]* %product, i32 0, i32 1		; <i8*> [#uses=1]
+	store i8 78, i8* %.array16
+	%.array17 = getelementptr [8 x i8]* %product, i32 0, i32 2		; <i8*> [#uses=1]
+	store i8 69, i8* %.array17
+	%.array18 = getelementptr [8 x i8]* %product, i32 0, i32 3		; <i8*> [#uses=1]
+	store i8 83, i8* %.array18
+	%.array19 = getelementptr [8 x i8]* %product, i32 0, i32 4		; <i8*> [#uses=1]
+	store i8 82, i8* %.array19
+	%.array20 = getelementptr [8 x i8]* %product, i32 0, i32 5		; <i8*> [#uses=1]
+	store i8 65, i8* %.array20
+	%.array21 = getelementptr [8 x i8]* %product, i32 0, i32 6		; <i8*> [#uses=1]
+	store i8 77, i8* %.array21
+	%.array22 = getelementptr [8 x i8]* %product, i32 0, i32 7		; <i8*> [#uses=1]
+	store i8 0, i8* %.array22
+	store i32 0, i32* %cnt_crc
+	store i32 0, i32* %addr
+	store i16 0, i16* %addr_lo
+	store i16 0, i16* %addr_hi
+	store i16 0, i16* %step
+	store i16 0, i16* %crc
+	store i8 0, i8* %bank
+	call void @usb_init()
+	%tmp = load i32* %argc.addr		; <i32> [#uses=1]
+	%cmp = icmp slt i32 %tmp, 2		; <i1> [#uses=1]
+	br i1 %cmp, label %if.then, label %if.end
+
+if.then:		; preds = %entry
+	%tmp23 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx = getelementptr i8** %tmp23, i32 0		; <i8**> [#uses=1]
+	%tmp24 = load i8** %arrayidx		; <i8*> [#uses=1]
+	call void @usage(i8* %tmp24)
+	call void @exit(i32 1) noreturn
+	unreachable
+		; No predecessors!
+	br label %if.end
+
+if.end:		; preds = %0, %entry
+	%arraydecay = getelementptr [2 x i8]* %rawVid, i32 0, i32 0		; <i8*> [#uses=1]
+	%arrayidx25 = getelementptr i8* %arraydecay, i32 1		; <i8*> [#uses=1]
+	%tmp26 = load i8* %arrayidx25		; <i8> [#uses=1]
+	%conv = zext i8 %tmp26 to i32		; <i32> [#uses=1]
+	%mul = mul i32 %conv, 256		; <i32> [#uses=1]
+	%arraydecay27 = getelementptr [2 x i8]* %rawVid, i32 0, i32 0		; <i8*> [#uses=1]
+	%arrayidx28 = getelementptr i8* %arraydecay27, i32 0		; <i8*> [#uses=1]
+	%tmp29 = load i8* %arrayidx28		; <i8> [#uses=1]
+	%conv30 = zext i8 %tmp29 to i32		; <i32> [#uses=1]
+	%add = add i32 %mul, %conv30		; <i32> [#uses=1]
+	store i32 %add, i32* %vid
+	%arraydecay31 = getelementptr [2 x i8]* %rawPid, i32 0, i32 0		; <i8*> [#uses=1]
+	%arrayidx32 = getelementptr i8* %arraydecay31, i32 1		; <i8*> [#uses=1]
+	%tmp33 = load i8* %arrayidx32		; <i8> [#uses=1]
+	%conv34 = zext i8 %tmp33 to i32		; <i32> [#uses=1]
+	%mul35 = mul i32 %conv34, 256		; <i32> [#uses=1]
+	%arraydecay36 = getelementptr [2 x i8]* %rawPid, i32 0, i32 0		; <i8*> [#uses=1]
+	%arrayidx37 = getelementptr i8* %arraydecay36, i32 0		; <i8*> [#uses=1]
+	%tmp38 = load i8* %arrayidx37		; <i8> [#uses=1]
+	%conv39 = zext i8 %tmp38 to i32		; <i32> [#uses=1]
+	%add40 = add i32 %mul35, %conv39		; <i32> [#uses=1]
+	store i32 %add40, i32* %pid
+	%tmp41 = load i32* %vid		; <i32> [#uses=1]
+	%arraydecay42 = getelementptr [11 x i8]* %vendor, i32 0, i32 0		; <i8*> [#uses=1]
+	%tmp43 = load i32* %pid		; <i32> [#uses=1]
+	%arraydecay44 = getelementptr [8 x i8]* %product, i32 0, i32 0		; <i8*> [#uses=1]
+	%call = call i32 @usbOpenDevice(%struct.usb_dev_handle** %handle, i32 %tmp41, i8* %arraydecay42, i32 %tmp43, i8* %arraydecay44, i8* null, %struct.__sFILE* null, %struct.__sFILE* null)		; <i32> [#uses=1]
+	%cmp45 = icmp ne i32 %call, 0		; <i1> [#uses=1]
+	br i1 %cmp45, label %if.then47, label %if.end53
+
+if.then47:		; preds = %if.end
+	%tmp48 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%arraydecay49 = getelementptr [8 x i8]* %product, i32 0, i32 0		; <i8*> [#uses=1]
+	%tmp50 = load i32* %vid		; <i32> [#uses=1]
+	%tmp51 = load i32* %pid		; <i32> [#uses=1]
+	%call52 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp48, i8* getelementptr ([55 x i8]* @"\01LC7", i32 0, i32 0), i8* %arraydecay49, i32 %tmp50, i32 %tmp51)		; <i32> [#uses=0]
+	call void @exit(i32 1) noreturn
+	unreachable
+		; No predecessors!
+	br label %if.end53
+
+if.end53:		; preds = %1, %if.end
+	%arraydecay54 = getelementptr [8 x i8]* %product, i32 0, i32 0		; <i8*> [#uses=1]
+	%tmp55 = load i32* %vid		; <i32> [#uses=1]
+	%tmp56 = load i32* %pid		; <i32> [#uses=1]
+	%call57 = call i32 (i8*, ...)* @printf(i8* getelementptr ([45 x i8]* @"\01LC8", i32 0, i32 0), i8* %arraydecay54, i32 %tmp55, i32 %tmp56)		; <i32> [#uses=0]
+	%tmp58 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx59 = getelementptr i8** %tmp58, i32 1		; <i8**> [#uses=1]
+	%tmp60 = load i8** %arrayidx59		; <i8*> [#uses=1]
+	%call61 = call i32 @strcasecmp(i8* %tmp60, i8* getelementptr ([7 x i8]* @"\01LC9", i32 0, i32 0))		; <i32> [#uses=1]
+	%cmp62 = icmp eq i32 %call61, 0		; <i1> [#uses=1]
+	br i1 %cmp62, label %if.then64, label %if.else171
+
+if.then64:		; preds = %if.end53
+	%tmp65 = load i32* %argc.addr		; <i32> [#uses=1]
+	%cmp66 = icmp slt i32 %tmp65, 3		; <i1> [#uses=1]
+	br i1 %cmp66, label %if.then68, label %if.end72
+
+if.then68:		; preds = %if.then64
+	%tmp69 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx70 = getelementptr i8** %tmp69, i32 0		; <i8**> [#uses=1]
+	%tmp71 = load i8** %arrayidx70		; <i8*> [#uses=1]
+	call void @usage(i8* %tmp71)
+	call void @exit(i32 1) noreturn
+	unreachable
+		; No predecessors!
+	br label %if.end72
+
+if.end72:		; preds = %2, %if.then64
+	%tmp73 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx74 = getelementptr i8** %tmp73, i32 2		; <i8**> [#uses=1]
+	%tmp75 = load i8** %arrayidx74		; <i8*> [#uses=1]
+	%call76 = call %struct.__sFILE* @fopen(i8* %tmp75, i8* getelementptr ([2 x i8]* @"\01LC10", i32 0, i32 0))		; <%struct.__sFILE*> [#uses=1]
+	store %struct.__sFILE* %call76, %struct.__sFILE** %fp
+	%tmp77 = load %struct.__sFILE** %fp		; <%struct.__sFILE*> [#uses=1]
+	%cmp78 = icmp eq %struct.__sFILE* %tmp77, null		; <i1> [#uses=1]
+	br i1 %cmp78, label %if.then80, label %if.end86
+
+if.then80:		; preds = %if.end72
+	%tmp81 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%tmp82 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx83 = getelementptr i8** %tmp82, i32 2		; <i8**> [#uses=1]
+	%tmp84 = load i8** %arrayidx83		; <i8*> [#uses=1]
+	%call85 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp81, i8* getelementptr ([21 x i8]* @"\01LC11", i32 0, i32 0), i8* %tmp84)		; <i32> [#uses=0]
+	call void @exit(i32 1) noreturn
+	unreachable
+		; No predecessors!
+	br label %if.end86
+
+if.end86:		; preds = %3, %if.end72
+	%call87 = call i8* @malloc(i32 1024)		; <i8*> [#uses=1]
+	store i8* %call87, i8** %read_buffer
+	%call88 = call i8* @malloc(i32 32768)		; <i8*> [#uses=1]
+	store i8* %call88, i8** %crc_buffer
+	%tmp89 = load i8** %crc_buffer		; <i8*> [#uses=1]
+	%call90 = call i8* @memset(i8* %tmp89, i32 0, i32 32768)		; <i8*> [#uses=0]
+	store i32 0, i32* %addr
+	%tmp91 = load %struct.usb_dev_handle** %handle		; <%struct.usb_dev_handle*> [#uses=1]
+	%call92 = call i32 @usb_control_msg(%struct.usb_dev_handle* %tmp91, i32 64, i32 0, i32 0, i32 0, i8* null, i32 0, i32 5000)		; <i32> [#uses=0]
+	br label %while.cond
+
+while.cond:		; preds = %if.end148, %if.end86
+	%tmp93 = load i8** %read_buffer		; <i8*> [#uses=1]
+	%tmp94 = load %struct.__sFILE** %fp		; <%struct.__sFILE*> [#uses=1]
+	%call95 = call i32 @fread(i8* %tmp93, i32 1024, i32 1, %struct.__sFILE* %tmp94)		; <i32> [#uses=2]
+	store i32 %call95, i32* %cnt
+	%cmp96 = icmp sgt i32 %call95, 0		; <i1> [#uses=1]
+	br i1 %cmp96, label %while.body, label %while.end
+
+while.body:		; preds = %while.cond
+	store i16 0, i16* %step
+	br label %for.cond
+
+for.cond:		; preds = %for.inc, %while.body
+	%tmp98 = load i16* %step		; <i16> [#uses=1]
+	%conv99 = zext i16 %tmp98 to i32		; <i32> [#uses=1]
+	%cmp100 = icmp slt i32 %conv99, 1024		; <i1> [#uses=1]
+	br i1 %cmp100, label %for.body, label %for.end
+
+for.body:		; preds = %for.cond
+	%tmp102 = load i32* %addr		; <i32> [#uses=1]
+	%and = and i32 %tmp102, 65535		; <i32> [#uses=1]
+	%conv103 = trunc i32 %and to i16		; <i16> [#uses=1]
+	store i16 %conv103, i16* %addr_lo
+	%tmp104 = load i32* %addr		; <i32> [#uses=1]
+	%shr = lshr i32 %tmp104, 16		; <i32> [#uses=1]
+	%and105 = and i32 %shr, 255		; <i32> [#uses=1]
+	%conv106 = trunc i32 %and105 to i16		; <i16> [#uses=1]
+	store i16 %conv106, i16* %addr_hi
+	%tmp107 = load %struct.usb_dev_handle** %handle		; <%struct.usb_dev_handle*> [#uses=1]
+	%tmp108 = load i16* %addr_hi		; <i16> [#uses=1]
+	%conv109 = zext i16 %tmp108 to i32		; <i32> [#uses=1]
+	%tmp110 = load i16* %addr_lo		; <i16> [#uses=1]
+	%conv111 = zext i16 %tmp110 to i32		; <i32> [#uses=1]
+	%tmp112 = load i8** %read_buffer		; <i8*> [#uses=1]
+	%tmp113 = load i16* %step		; <i16> [#uses=1]
+	%conv114 = zext i16 %tmp113 to i32		; <i32> [#uses=1]
+	%add.ptr = getelementptr i8* %tmp112, i32 %conv114		; <i8*> [#uses=1]
+	%call115 = call i32 @usb_control_msg(%struct.usb_dev_handle* %tmp107, i32 64, i32 1, i32 %conv109, i32 %conv111, i8* %add.ptr, i32 128, i32 5000)		; <i32> [#uses=0]
+	%tmp116 = load i32* %addr		; <i32> [#uses=1]
+	%add117 = add i32 %tmp116, 128		; <i32> [#uses=1]
+	store i32 %add117, i32* %addr
+	br label %for.inc
+
+for.inc:		; preds = %for.body
+	%tmp118 = load i16* %step		; <i16> [#uses=1]
+	%conv119 = zext i16 %tmp118 to i32		; <i32> [#uses=1]
+	%add120 = add i32 %conv119, 128		; <i32> [#uses=1]
+	%conv121 = trunc i32 %add120 to i16		; <i16> [#uses=1]
+	store i16 %conv121, i16* %step
+	br label %for.cond
+
+for.end:		; preds = %for.cond
+	%tmp122 = load i8** %crc_buffer		; <i8*> [#uses=1]
+	%tmp123 = load i32* %cnt_crc		; <i32> [#uses=1]
+	%add.ptr124 = getelementptr i8* %tmp122, i32 %tmp123		; <i8*> [#uses=1]
+	%tmp125 = load i8** %read_buffer		; <i8*> [#uses=1]
+	%call126 = call i8* @memcpy(i8* %add.ptr124, i8* %tmp125, i32 1024)		; <i8*> [#uses=0]
+	%tmp127 = load i32* %cnt_crc		; <i32> [#uses=1]
+	%add128 = add i32 %tmp127, 1024		; <i32> [#uses=1]
+	store i32 %add128, i32* %cnt_crc
+	%tmp129 = load i32* %cnt_crc		; <i32> [#uses=1]
+	%cmp130 = icmp sge i32 %tmp129, 32768		; <i1> [#uses=1]
+	br i1 %cmp130, label %if.then132, label %if.end148
+
+if.then132:		; preds = %for.end
+	%tmp133 = load i8** %crc_buffer		; <i8*> [#uses=1]
+	%call134 = call zeroext i16 @do_crc(i8* %tmp133, i16 zeroext -32768)		; <i16> [#uses=1]
+	store i16 %call134, i16* %crc
+	%tmp135 = load i32* %addr		; <i32> [#uses=1]
+	%tmp136 = load i8* %bank		; <i8> [#uses=1]
+	%conv137 = zext i8 %tmp136 to i32		; <i32> [#uses=1]
+	%tmp138 = load i16* %addr_hi		; <i16> [#uses=1]
+	%conv139 = zext i16 %tmp138 to i32		; <i32> [#uses=1]
+	%tmp140 = load i16* %addr_lo		; <i16> [#uses=1]
+	%conv141 = zext i16 %tmp140 to i32		; <i32> [#uses=1]
+	%tmp142 = load i16* %crc		; <i16> [#uses=1]
+	%conv143 = zext i16 %tmp142 to i32		; <i32> [#uses=1]
+	%call144 = call i32 (i8*, ...)* @printf(i8* getelementptr ([70 x i8]* @"\01LC12", i32 0, i32 0), i32 %tmp135, i32 %conv137, i32 %conv139, i32 %conv141, i32 %conv143)		; <i32> [#uses=0]
+	%tmp145 = load i8** %crc_buffer		; <i8*> [#uses=1]
+	%call146 = call i8* @memset(i8* %tmp145, i32 0, i32 32768)		; <i8*> [#uses=0]
+	%tmp147 = load i8* %bank		; <i8> [#uses=1]
+	%inc = add i8 %tmp147, 1		; <i8> [#uses=1]
+	store i8 %inc, i8* %bank
+	store i32 0, i32* %cnt_crc
+	br label %if.end148
+
+if.end148:		; preds = %if.then132, %for.end
+	br label %while.cond
+
+while.end:		; preds = %while.cond
+	%tmp149 = load %struct.usb_dev_handle** %handle		; <%struct.usb_dev_handle*> [#uses=1]
+	%tmp150 = load i16* %addr_hi		; <i16> [#uses=1]
+	%conv151 = zext i16 %tmp150 to i32		; <i32> [#uses=1]
+	%tmp152 = load i16* %addr_lo		; <i16> [#uses=1]
+	%conv153 = zext i16 %tmp152 to i32		; <i32> [#uses=1]
+	%call154 = call i32 @usb_control_msg(%struct.usb_dev_handle* %tmp149, i32 64, i32 4, i32 %conv151, i32 %conv153, i8* null, i32 0, i32 5000)		; <i32> [#uses=1]
+	store i32 %call154, i32* %cnt
+	%tmp155 = load i32* %cnt		; <i32> [#uses=1]
+	%cmp156 = icmp slt i32 %tmp155, 1		; <i1> [#uses=1]
+	br i1 %cmp156, label %if.then158, label %if.end170
+
+if.then158:		; preds = %while.end
+	%tmp159 = load i32* %cnt		; <i32> [#uses=1]
+	%cmp160 = icmp slt i32 %tmp159, 0		; <i1> [#uses=1]
+	br i1 %cmp160, label %if.then162, label %if.else
+
+if.then162:		; preds = %if.then158
+	%tmp163 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%call164 = call i8* @usb_strerror()		; <i8*> [#uses=1]
+	%call165 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp163, i8* getelementptr ([15 x i8]* @"\01LC13", i32 0, i32 0), i8* %call164)		; <i32> [#uses=0]
+	br label %if.end169
+
+if.else:		; preds = %if.then158
+	%tmp166 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%tmp167 = load i32* %cnt		; <i32> [#uses=1]
+	%call168 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp166, i8* getelementptr ([25 x i8]* @"\01LC14", i32 0, i32 0), i32 %tmp167)		; <i32> [#uses=0]
+	br label %if.end169
+
+if.end169:		; preds = %if.else, %if.then162
+	br label %if.end170
+
+if.end170:		; preds = %if.end169, %while.end
+	br label %if.end216
+
+if.else171:		; preds = %if.end53
+	%tmp172 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx173 = getelementptr i8** %tmp172, i32 1		; <i8**> [#uses=1]
+	%tmp174 = load i8** %arrayidx173		; <i8*> [#uses=1]
+	%call175 = call i32 @strcasecmp(i8* %tmp174, i8* getelementptr ([4 x i8]* @"\01LC15", i32 0, i32 0))		; <i32> [#uses=1]
+	%cmp176 = icmp eq i32 %call175, 0		; <i1> [#uses=1]
+	br i1 %cmp176, label %if.then178, label %if.else211
+
+if.then178:		; preds = %if.else171
+	store i32 0, i32* %addr
+	%tmp179 = load i32* %addr		; <i32> [#uses=1]
+	%and180 = and i32 %tmp179, 65535		; <i32> [#uses=1]
+	%conv181 = trunc i32 %and180 to i16		; <i16> [#uses=1]
+	store i16 %conv181, i16* %addr_lo
+	%tmp182 = load i32* %addr		; <i32> [#uses=1]
+	%shr183 = lshr i32 %tmp182, 16		; <i32> [#uses=1]
+	%and184 = and i32 %shr183, 255		; <i32> [#uses=1]
+	%conv185 = trunc i32 %and184 to i16		; <i16> [#uses=1]
+	store i16 %conv185, i16* %addr_hi
+	%tmp186 = load i32* %addr		; <i32> [#uses=1]
+	%call187 = call i32 (i8*, ...)* @printf(i8* getelementptr ([30 x i8]* @"\01LC16", i32 0, i32 0), i32 %tmp186)		; <i32> [#uses=0]
+	%tmp188 = load %struct.usb_dev_handle** %handle		; <%struct.usb_dev_handle*> [#uses=1]
+	%tmp189 = load i16* %addr_hi		; <i16> [#uses=1]
+	%conv190 = zext i16 %tmp189 to i32		; <i32> [#uses=1]
+	%tmp191 = load i16* %addr_lo		; <i16> [#uses=1]
+	%conv192 = zext i16 %tmp191 to i32		; <i32> [#uses=1]
+	%call193 = call i32 @usb_control_msg(%struct.usb_dev_handle* %tmp188, i32 64, i32 5, i32 %conv190, i32 %conv192, i8* null, i32 8192, i32 5000)		; <i32> [#uses=1]
+	store i32 %call193, i32* %cnt
+	%tmp194 = load i32* %cnt		; <i32> [#uses=1]
+	%cmp195 = icmp slt i32 %tmp194, 1		; <i1> [#uses=1]
+	br i1 %cmp195, label %if.then197, label %if.end210
+
+if.then197:		; preds = %if.then178
+	%tmp198 = load i32* %cnt		; <i32> [#uses=1]
+	%cmp199 = icmp slt i32 %tmp198, 0		; <i1> [#uses=1]
+	br i1 %cmp199, label %if.then201, label %if.else205
+
+if.then201:		; preds = %if.then197
+	%tmp202 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%call203 = call i8* @usb_strerror()		; <i8*> [#uses=1]
+	%call204 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp202, i8* getelementptr ([15 x i8]* @"\01LC13", i32 0, i32 0), i8* %call203)		; <i32> [#uses=0]
+	br label %if.end209
+
+if.else205:		; preds = %if.then197
+	%tmp206 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%tmp207 = load i32* %cnt		; <i32> [#uses=1]
+	%call208 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp206, i8* getelementptr ([25 x i8]* @"\01LC14", i32 0, i32 0), i32 %tmp207)		; <i32> [#uses=0]
+	br label %if.end209
+
+if.end209:		; preds = %if.else205, %if.then201
+	br label %if.end210
+
+if.end210:		; preds = %if.end209, %if.then178
+	br label %if.end215
+
+if.else211:		; preds = %if.else171
+	%tmp212 = load i8*** %argv.addr		; <i8**> [#uses=1]
+	%arrayidx213 = getelementptr i8** %tmp212, i32 0		; <i8**> [#uses=1]
+	%tmp214 = load i8** %arrayidx213		; <i8*> [#uses=1]
+	call void @usage(i8* %tmp214)
+	call void @exit(i32 1) noreturn
+	unreachable
+		; No predecessors!
+	br label %if.end215
+
+if.end215:		; preds = %4, %if.end210
+	br label %if.end216
+
+if.end216:		; preds = %if.end215, %if.end170
+	%tmp217 = load %struct.usb_dev_handle** %handle		; <%struct.usb_dev_handle*> [#uses=1]
+	%call218 = call i32 @usb_close(%struct.usb_dev_handle* %tmp217)		; <i32> [#uses=0]
+	store i32 0, i32* %retval
+	%5 = load i32* %retval		; <i32> [#uses=1]
+	ret i32 %5
+}
+
+declare void @usb_init()
+
+define internal void @usage(i8* %name) nounwind {
+entry:
+	%name.addr = alloca i8*		; <i8**> [#uses=2]
+	store i8* %name, i8** %name.addr
+	%tmp = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%call = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp, i8* getelementptr ([8 x i8]* @"\01LC17", i32 0, i32 0))		; <i32> [#uses=0]
+	%tmp1 = load %struct.__sFILE** @__stderrp		; <%struct.__sFILE*> [#uses=1]
+	%tmp2 = load i8** %name.addr		; <i8*> [#uses=1]
+	%call3 = call i32 (%struct.__sFILE*, i8*, ...)* @fprintf(%struct.__sFILE* %tmp1, i8* getelementptr ([31 x i8]* @"\01LC18", i32 0, i32 0), i8* %tmp2)		; <i32> [#uses=0]
+	ret void
+}
+
+declare void @exit(i32) noreturn
+
+declare i32 @usbOpenDevice(%struct.usb_dev_handle**, i32, i8*, i32, i8*, i8*, %struct.__sFILE*, %struct.__sFILE*)
+
+declare i32 @fprintf(%struct.__sFILE*, i8*, ...)
+
+declare i32 @strcasecmp(i8*, i8*)
+
+declare %struct.__sFILE* @fopen(i8*, i8*)
+
+declare i8* @malloc(i32)
+
+declare i8* @memset(i8*, i32, i32)
+
+declare i32 @usb_control_msg(%struct.usb_dev_handle*, i32, i32, i32, i32, i8*, i32, i32)
+
+declare i32 @fread(i8*, i32, i32, %struct.__sFILE*)
+
+declare i8* @memcpy(i8*, i8*, i32)
+
+declare i8* @usb_strerror()
+
+declare i32 @usb_close(%struct.usb_dev_handle*)

avr/usbload/config.h

@@ -0,0 +1,57 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#ifndef __CONFIH_H__
+#define __CONFIH_H__
+
+
+#define DEBUG                       1
+#define DEBUG_USB                   2
+#define DEBUG_USB_TRANS             4
+#define DEBUG_SRAM                  8
+#define DEBUG_SRAM_RAW              16
+#define DEBUG_SREG                  32
+#define DEBUG_CRC                   64
+#define DEBUG_SHM                   128
+
+#define REQ_STATUS_IDLE             0x01
+#define REQ_STATUS_UPLOAD           0x02
+#define REQ_STATUS_BULK_UPLOAD      0x03
+#define REQ_STATUS_BULK_NEXT        0x04
+#define REQ_STATUS_CRC              0x05
+#define REQ_STATUS_SNES             0x06
+#define REQ_STATUS_AVR              0x07
+
+#define USB_MAX_TRANS               0xff
+#define USB_CRC_CHECK               0x01
+
+#define TRANSFER_BUFFER_SIZE        0x000
+#define FORMAT_BUFFER_LEN           0x080
+#define RECEIVE_BUF_LEN             0x030
+#define HW_VERSION                  "2.6"
+#define SW_VERSION                  "1.0"
+
+#define DO_CRC_CHECK_LOADER         0
+#define DO_CRC_CHECK                0
+#define DO_SHM_SCRATCHPAD           0
+#define DO_SHM                      0
+#define DO_TIMER                    0
+
+#endif 

avr/usbload/crc.c

@@ -0,0 +1,106 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "crc.h"
+#include "uart.h"
+#include "config.h"
+#include "sram.h"
+#include "debug.h"
+#include "info.h"
+
+extern FILE uart_stdout;
+
+uint16_t crc_xmodem_update(uint16_t crc, uint8_t data)
+{
+    int i;
+    crc = crc ^ ((uint16_t) data << 8);
+    for (i = 0; i < 8; i++) {
+        if (crc & 0x8000)
+            crc = (crc << 1) ^ 0x1021;
+        else
+            crc <<= 1;
+    }
+    return crc;
+}
+
+uint16_t do_crc(uint8_t * data, uint16_t size)
+{
+    uint16_t crc = 0;
+    uint16_t i;
+    for (i = 0; i < size; i++) {
+        crc = crc_xmodem_update(crc, data[i]);
+        
+    }
+    return crc;
+}
+
+
+uint16_t do_crc_update(uint16_t crc, uint8_t * data, uint16_t size)
+{
+    uint16_t i;
+    for (i = 0; i < size; i++)
+        crc = crc_xmodem_update(crc, data[i]);
+    return crc;
+}
+
+
+uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t top_addr, uint32_t bank_size)
+{
+    uint16_t crc = 0;
+    uint32_t addr = 0;
+    uint8_t req_bank = 0;
+    sram_bulk_read_start(bottom_addr);
+    debug_P(DEBUG_CRC, PSTR("crc_check_bulk_memory: bottom_addr=0x%08lx top_addr=0x%08lx\n"),
+        bottom_addr,top_addr);
+    
+    for (addr = bottom_addr; addr < top_addr; addr++) {
+        if (addr && ((addr % bank_size) == 0)) {
+            debug_P(DEBUG_CRC, PSTR("crc_check_bulk_memory: bank=0x%02x addr=0x%08lx crc=0x%04x\n"),
+                req_bank,addr,crc);
+            req_bank++;
+            crc = 0;
+        }
+        crc = crc_xmodem_update(crc, sram_bulk_read());
+        sram_bulk_read_next();
+    }
+    if (addr % 0x8000 == 0)
+        debug_P(DEBUG_CRC, PSTR("crc_check_bulk_memory: bank=0x%02x addr=0x%08lx crc=0x%04x\n"),
+            req_bank,addr,crc);
+    sram_bulk_read_end();
+    return crc;
+}
+
+
+
+
+uint16_t crc_check_memory_range(uint32_t start_addr, uint32_t size,uint8_t *buffer)
+{
+    uint16_t crc = 0;
+    uint32_t addr;
+    for (addr = start_addr; addr < start_addr + size; addr += TRANSFER_BUFFER_SIZE) {
+        sram_bulk_copy_into_buffer(addr, buffer, TRANSFER_BUFFER_SIZE);
+        crc = do_crc_update(crc, buffer, TRANSFER_BUFFER_SIZE);
+    }
+    return crc;
+}

avr/usbload/crc.h

@@ -0,0 +1,35 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __CRC_H__
+#define __CRC_H__
+
+#include <stdlib.h>
+#include <stdint.h> 
+
+
+uint16_t crc_xmodem_update(uint16_t crc, uint8_t data);
+uint16_t do_crc(uint8_t * data,uint16_t size);
+uint16_t do_crc_update(uint16_t crc,uint8_t * data,uint16_t size);
+uint16_t crc_check_memory_range(uint32_t start_addr, uint32_t size,uint8_t *buffer);
+uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t bank_size,uint32_t top_addr);
+
+#endif

avr/usbload/debug.c

@@ -0,0 +1,54 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <avr/pgmspace.h>
+
+#include "debug.h"
+#include "uart.h"
+#include "config.h"
+
+extern FILE uart_stdout;
+
+extern int debug_level; /* the higher, the more messages... */
+
+
+#ifndef NO_INFO
+    uint8_t buffer_debug[FORMAT_BUFFER_LEN];
+#endif
+   
+#if defined(NO_DEBUG) && defined(__GNUC__)
+#else
+void debug_P(int level, PGM_P format, ...) {
+#ifdef NO_DEBUG
+
+#else
+    va_list args;
+    if (!(debug_level & level))
+        return;
+    strlcpy_P((char*)buffer_debug,format,FORMAT_BUFFER_LEN);
+    va_start(args, format);
+    vprintf((char*)buffer_debug, args);
+    va_end(args);
+#endif
+}
+#endif 
+

avr/usbload/debug.h

@@ -0,0 +1,55 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <avr/pgmspace.h>
+
+#if defined(NO_DEBUG) && defined(__GNUC__)
+/* gcc's cpp has extensions; it allows for macros with a variable number of
+   arguments. We use this extension here to preprocess pmesg away. */
+#define debug(level, format, args...) ((void)0)
+#else
+void debug(int level, char *format, ...);
+/* print a message, if it is considered significant enough.
+      Adapted from [K&R2], p. 174 */
+#endif
+
+
+
+#if defined(NO_DEBUG) && defined(__GNUC__)
+/* gcc's cpp has extensions; it allows for macros with a variable number of
+   arguments. We use this extension here to preprocess pmesg away. */
+#define debug_P(level, format, args...) ((void)0)
+#else
+void debug_P(int level, PGM_P format, ...);
+/* print a message, if it is considered significant enough.
+      Adapted from [K&R2], p. 174 */
+#endif
+
+
+#endif /* DEBUG_H */
+        

avr/usbload/dump.c

@@ -0,0 +1,83 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "debug.h"
+#include "info.h"
+#include "uart.h"
+#include "sram.h"
+#include "dump.h"
+
+
+extern FILE uart_stdout;
+
+void dump_packet(uint32_t addr, uint32_t len, uint8_t * packet)
+{
+    uint16_t i,j;
+    uint16_t sum = 0;
+    uint8_t clear = 0;
+
+    for (i = 0; i < len; i += 16) {
+
+        sum = 0;
+        for (j = 0; j < 16; j++) {
+            sum += packet[i + j];
+        }
+        if (!sum) {
+            clear = 1;
+            continue;
+        }
+        if (clear) {
+            info_P(PSTR("*\n"));
+            clear = 0;
+        }
+        info_P(PSTR("%08lx:"), addr + i);
+        for (j = 0; j < 16; j++) {
+            info_P(PSTR(" %02x"), packet[i + j]);
+        }
+        info_P(PSTR(" |"));
+        for (j = 0; j < 16; j++) {
+            if (packet[i + j] >= 33 && packet[i + j] <= 126)
+                info_P(PSTR("%c"), packet[i + j]);
+            else
+                info_P(PSTR("."));
+        }
+        info_P(PSTR("|\n"));
+    }
+}
+
+void dump_memory(uint32_t bottom_addr, uint32_t top_addr)
+{
+    uint32_t addr;
+    uint8_t byte;
+    sram_bulk_read_start(bottom_addr);
+    for ( addr = bottom_addr; addr < top_addr; addr++) {
+        if (addr%0x10 == 0)
+            info_P(PSTR("\n%08lx:"), addr);
+        byte = sram_bulk_read();
+        sram_bulk_read_next();
+        info_P(PSTR(" %02x"), byte);
+    }
+    info_P(PSTR("\n"));
+    sram_bulk_read_end();
+}

avr/usbload/dump.h

@@ -0,0 +1,34 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __DUMP_H__
+#define __DUMP_H__
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+
+void dump_memory(uint32_t bottom_addr, uint32_t top_addr);
+
+void dump_packet(uint32_t addr,uint32_t len,uint8_t *packet);
+
+#endif 
+

avr/usbload/fifo.c

@@ -0,0 +1,50 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+#include "fifo.h"
+
+void fifo_init(fifo_t * f, uint8_t * buffer, const uint8_t size)
+{
+    f->count = 0;
+    f->pread = f->pwrite = buffer;
+    f->read2end = f->write2end = f->size = size;
+}
+
+uint8_t fifo_put(fifo_t * f, const uint8_t data)
+{
+    return _inline_fifo_put(f, data);
+}
+
+uint8_t fifo_get_wait(fifo_t * f)
+{
+    while (!f->count);
+
+    return _inline_fifo_get(f);
+}
+
+int fifo_get_nowait(fifo_t * f)
+{
+    if (!f->count)
+        return -1;
+
+    return (int) _inline_fifo_get(f);
+}

avr/usbload/fifo.h

@@ -0,0 +1,88 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+#ifndef __FIFO_H__
+#define __FIFO_H__
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+typedef struct {
+    uint8_t volatile count;     // # Zeichen im Puffer
+    uint8_t size;               // Puffer-Größe
+    uint8_t *pread;             // Lesezeiger
+    uint8_t *pwrite;            // Schreibzeiger
+    uint8_t read2end, write2end;        // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
+} fifo_t;
+
+extern void fifo_init(fifo_t *, uint8_t * buf, const uint8_t size);
+extern uint8_t fifo_put(fifo_t *, const uint8_t data);
+extern uint8_t fifo_get_wait(fifo_t *);
+extern int fifo_get_nowait(fifo_t *);
+
+static inline uint8_t _inline_fifo_put(fifo_t * f, const uint8_t data)
+{
+    if (f->count >= f->size)
+        return 0;
+
+    uint8_t *pwrite = f->pwrite;
+
+    *(pwrite++) = data;
+
+    uint8_t write2end = f->write2end;
+
+    if (--write2end == 0) {
+        write2end = f->size;
+        pwrite -= write2end;
+    }
+
+    f->write2end = write2end;
+    f->pwrite = pwrite;
+
+    uint8_t sreg = SREG;
+    cli();
+    f->count++;
+    SREG = sreg;
+
+    return 1;
+}
+
+static inline uint8_t _inline_fifo_get(fifo_t * f)
+{
+    uint8_t *pread = f->pread;
+    uint8_t data = *(pread++);
+    uint8_t read2end = f->read2end;
+
+    if (--read2end == 0) {
+        read2end = f->size;
+        pread -= read2end;
+    }
+
+    f->pread = pread;
+    f->read2end = read2end;
+
+    uint8_t sreg = SREG;
+    cli();
+    f->count--;
+    SREG = sreg;
+
+    return data;
+}
+
+#endif                          /* _FIFO_H_ */

avr/usbload/inflate.c

@@ -0,0 +1,85 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  09/22/2009
+ *         Author:  jannis@harderweb.de
+ *
+ * =====================================================================================
+ */
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "neginf/neginf.h"
+#include "inflate.h"
+#include "assert.h"
+#include "ringbuffer.h"
+
+char inflate_done = 0;
+char *mem_ref;
+
+int addr_ref = 0;
+
+int cnt_hit = 0;
+int cnt = 0;
+
+
+void inflate_init() 
+{
+    neginf_init(0);
+    mem_ref = (char*)malloc(2<<15);
+    addr_ref = 0;
+    rb_init();
+}
+
+void inflate_flush() 
+{    
+
+    rb_flush();
+    FILE *file;
+    printf("write out_ref.smc\n");
+    file = fopen("out_ref.smc","w");
+    fwrite(mem_ref,2<<15,1,file);
+    fclose(file);
+    printf("cnt=%i cnt_hit=%i\n",cnt,cnt_hit);
+}
+
+void neginf_cb_completed()
+{
+    inflate_done = 1;
+}
+
+void neginf_cb_seq_byte(nbyte byte)
+{
+    mem_ref[addr_ref++] = byte; 
+    rb_put(byte);
+}
+
+void neginf_cb_copy(nsize from, nsize to, nint length)
+{
+    int i;
+    cnt++;
+    if ((to - from) < ( 1024 * 2 ) ){
+        cnt_hit++;
+    }
+    printf("neginf_cb_copy from=0x%06x to=0x%06x dist=%i len=%i\n",(int)from, (int)to, (int)(to - from), (int)length);
+    for (i=0; i<length;i++){
+        mem_ref[to+i] = mem_ref[from+i];
+    }
+    addr_ref = to + length;
+}
+
+
+
+

avr/usbload/inflate.h

@@ -0,0 +1,28 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  09/22/2009
+ *         Author:  jannis@harderweb.de
+ *
+ * =====================================================================================
+ */
+
+
+
+#ifndef __INFLATE_H__
+#define __INFLATE_H__
+
+extern char inflate_done;
+
+#endif

avr/usbload/inflate_test.c

@@ -0,0 +1,44 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "neginf/neginf.h"
+#include "inflate.h"
+#include "loader_test.h"
+
+extern const char _rom[];
+extern char inflate_done;
+
+
+int main(int argc, char **argv)
+{
+    
+    int j;
+    char c;
+    inflate_init();
+    for (j=0; j< ROM_ZIP_SIZE; j++){
+        neginf_process_byte(_rom[j]);
+    }
+    while(!inflate_done)
+        neginf_process_byte(0x00);
+    inflate_flush();
+    return 0;
+}

avr/usbload/info.c

@@ -0,0 +1,56 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <avr/pgmspace.h>
+
+#include "info.h"
+#include "uart.h"
+#include "config.h"
+
+
+
+
+extern FILE uart_stdout;
+
+
+#ifndef NO_INFO
+    uint8_t buffer_info[FORMAT_BUFFER_LEN];
+#endif
+
+#if defined(NO_INFO) && defined(__GNUC__)
+
+#define info(format, args...) ((void)0)
+
+#else
+void info_P(PGM_P format, ...) {
+#ifdef NO_INFO
+
+#else
+    strlcpy_P((char*)buffer_info,format,FORMAT_BUFFER_LEN);
+    va_list args;
+    va_start(args, format);
+    vprintf((char*)buffer_info, args);
+    va_end(args);
+#endif
+}
+#endif
+   

avr/usbload/info.h

@@ -0,0 +1,53 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+#ifndef __INFO_H__
+#define __INFO_H__
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <avr/pgmspace.h>
+
+#if defined(NO_INFO) && defined(__GNUC__)
+/* gcc's cpp has extensions; it allows for macros with a variable number of
+   arguments. We use this extension here to preprocess pmesg away. */
+#define info(format, args...) ((void)0)
+#else
+void info(char *format, ...);
+/* print a message, if it is considered significant enough.
+      Adapted from [K&R2], p. 174 */
+#endif
+
+
+#if defined(NO_INFO) && defined(__GNUC__)
+/* gcc's cpp has extensions; it allows for macros with a variable number of
+   arguments. We use this extension here to preprocess pmesg away. */
+#define info_P(format, args...) ((void)0)
+#else
+void info_P(PGM_P format, ...);
+/* print a message, if it is considered significant enough.
+      Adapted from [K&R2], p. 174 */
+#endif
+
+
+#endif 

avr/usbload/irq.c

@@ -0,0 +1,76 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+
+#include <stdint.h>
+#include <stdio.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>      /* for sei() */
+#include <avr/wdt.h>
+
+
+#include "usbdrv.h"
+#include "oddebug.h"            /* This is also an example for using debug
+                                 * macros */
+#include "debug.h" 
+#include "info.h"
+#include "sram.h"
+#include "system.h"
+
+extern system_t system;
+  
+void (*jump_to_app) (void) = 0x0000;
+  
+void irq_init(){
+    cli();
+    PCMSK3 |=(1<<PCINT27);
+    PCICR  |= (1<<PCIE3);
+    sei();
+    system.reset_irq = RESET_IRQ_ON;
+} 
+
+void irq_stop(){
+    cli();
+    PCMSK3 &=~(1<<PCINT27);
+    sei();
+    system.reset_irq = RESET_IRQ_OFF;
+} 
+
+void leave_application(void)
+{
+    cli();
+    usbDeviceDisconnect();
+    system.avr_reset_count++;
+    wdt_enable(WDTO_15MS);
+    while (1);
+
+}
+
+ISR (SIG_PIN_CHANGE3)
+{
+    if (snes_reset_test()){
+        info_P(PSTR("Catch SNES reset button\n"));
+        info_P(PSTR("Set watchdog...\n"));
+        leave_application();
+    }    
+}
+ 

avr/usbload/irq.h

@@ -0,0 +1,28 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __IRQ_H__
+#define __IRQ_H__
+
+void irq_init();
+void irq_stop();
+void leave_application(void);
+#endif

avr/usbload/loader.h

@@ -0,0 +1,14 @@
+/*
+File: qd16boot02.smc 
+Time: Sat, 24 Oct 2009 19:05:36
+*/
+#ifndef __FIFO_H__
+#define __FIFO_H__
+
+#define ROM_ZIP_SIZE     33654
+#define ROM_BUFFER_CNT   2
+
+#define ROM_BUFFER_SIZE01  32767
+#define ROM_BUFFER_SIZE02  887
+
+#endif

avr/usbload/loader_test.h

@@ -0,0 +1,7 @@
+
+#ifndef __FIFO_H__
+#define __FIFO_H__
+
+#define ROM_ZIP_SIZE     35543
+
+#endif

avr/usbload/main.c

@@ -0,0 +1,324 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+#include <avr/io.h>
+#include <avr/interrupt.h>      
+#include <util/delay.h>         
+#include <stdlib.h>
+#include <avr/pgmspace.h>       
+#include <avr/eeprom.h>
+#include <string.h>
+
+#include "usbdrv.h"
+#include "oddebug.h"            
+#include "config.h"
+#include "requests.h"           
+#include "uart.h"
+#include "sram.h"
+#include "debug.h"
+#include "info.h"
+#include "dump.h"
+#include "crc.h"
+#include "usb_bulk.h"
+#include "timer.h"
+#include "watchdog.h"
+#include "rle.h"
+#include "loader.h"
+#include "command.h"
+#include "shared_memory.h"
+#include "irq.h"
+#include "pwm.h"
+#include "testing.h"
+#include "shell.h"
+#include "system.h"
+
+#ifndef NO_DEBUG            
+extern FILE uart_stdout;
+#endif
+extern system_t system;
+
+uint8_t debug_level = (DEBUG | DEBUG_CRC);
+
+
+usb_transaction_t usb_trans;
+
+usbMsgLen_t usbFunctionSetup(uchar data[8])
+{
+
+    usbRequest_t *rq = (void *) data;
+    uint8_t ret_len = 0;
+
+    if (rq->bRequest == USB_BULK_UPLOAD_INIT) {
+
+        usb_trans.req_bank = 0;
+        usb_trans.rx_remaining = 0;
+        debug_P(DEBUG_USB, PSTR("USB_BULK_UPLOAD_INIT: %i %i\n"), rq->wValue.word,
+              rq->wIndex.word);
+        usb_trans.req_bank_size = (uint32_t) (1L << rq->wValue.word);
+        usb_trans.req_bank_cnt = rq->wIndex.word;
+        usb_trans.req_addr_end = (uint32_t) usb_trans.req_bank_size * usb_trans.req_bank_cnt;
+        usb_trans.req_percent = 0;
+        usb_trans.req_percent_last = 0;
+        usb_trans.sync_errors = 0;
+        debug_P(DEBUG_USB,
+              PSTR("USB_BULK_UPLOAD_INIT: bank_size=0x%08lx bank_cnt=0x%x end_addr=0x%08lx\n"),
+              usb_trans.req_bank_size, usb_trans.req_bank_cnt, usb_trans.req_addr_end);
+
+        shared_memory_write(SHARED_MEM_TX_CMD_UPLOAD_START, 0);
+        shared_memory_write(SHARED_MEM_TX_CMD_BANK_COUNT, usb_trans.req_bank_cnt);
+#if DO_TIMER
+        if (usb_trans.req_addr == 0x000000) {
+#ifndef NO_DEBUG            
+            timer_start();
+#endif       
+        }
+#endif       
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_BULK_UPLOAD_ADDR) {
+
+        usb_trans.req_state = REQ_STATUS_BULK_UPLOAD;
+        usb_trans.req_addr = rq->wValue.word;
+        usb_trans.req_addr = usb_trans.req_addr << 16;
+        usb_trans.req_addr = usb_trans.req_addr | rq->wIndex.word;
+        usb_trans.rx_remaining = rq->wLength.word;
+
+        
+
+        if (usb_trans.req_addr && usb_trans.req_addr % usb_trans.req_bank_size == 0) {
+#if DO_TIMER
+#ifndef NO_DEBUG            
+#ifdef FLT_DEBUG
+            debug_P(DEBUG_USB,
+                  PSTR("USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%.4f\n"),
+                  usb_trans.req_bank, usb_trans.req_addr, timer_stop());
+#else
+            debug_P(DEBUG_USB,
+                  PSTR("USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%i\n"),
+                  usb_trans.req_bank, usb_trans.req_addr, timer_stop_int());
+#endif
+              timer_start();
+#endif
+#endif
+            usb_trans.req_bank++;
+
+        } else {
+            sram_bulk_write_start(usb_trans.req_addr);
+        }
+        ret_len = USB_MAX_TRANS;
+
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_BULK_UPLOAD_NEXT) {
+        usb_trans.req_state = REQ_STATUS_BULK_UPLOAD;
+        usb_trans.req_addr = rq->wValue.word;
+        usb_trans.req_addr = usb_trans.req_addr << 16;
+        usb_trans.req_addr = usb_trans.req_addr | rq->wIndex.word;
+        usb_trans.rx_remaining = rq->wLength.word;
+
+#if DO_SHM
+        usb_trans.req_percent = (uint32_t)( 100 * usb_trans.req_addr )  / usb_trans.req_addr_end;
+        if (usb_trans.req_percent!=usb_trans.req_percent_last){
+            shared_memory_write(SHARED_MEM_TX_CMD_UPLOAD_PROGESS, usb_trans.req_percent);
+        }
+        usb_trans.req_percent_last = usb_trans.req_percent;
+        shared_memory_scratchpad_region_save_helper(usb_trans.req_addr);
+#endif        
+        if (usb_trans.req_addr && (usb_trans.req_addr % usb_trans.req_bank_size) == 0) {
+#if DO_TIMER
+#ifndef NO_DEBUG            
+#ifdef FLT_DEBUG
+            debug_P(DEBUG_USB,
+                  PSTR("USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%.4f\n"),
+                  usb_trans.req_bank, usb_trans.req_addr, timer_stop());
+#else
+            debug_P(DEBUG_USB,
+                  PSTR("USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%i\n"),
+                  usb_trans.req_bank, usb_trans.req_addr, timer_stop_int());
+#endif
+              timer_start();
+#endif
+#endif
+            usb_trans.req_bank++;
+#if DO_SHM
+            shared_memory_write(SHARED_MEM_TX_CMD_BANK_CURRENT, usb_trans.req_bank);
+#endif
+        }
+        ret_len = USB_MAX_TRANS;
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_BULK_UPLOAD_END) {
+        if (usb_trans.req_state != REQ_STATUS_BULK_UPLOAD) {
+            debug_P(DEBUG_USB,
+                  PSTR("USB_BULK_UPLOAD_END: ERROR state is not REQ_STATUS_BULK_UPLOAD\n"));
+            return 0;
+        }
+        debug_P(DEBUG_USB, PSTR("USB_BULK_UPLOAD_END:\n"));
+        usb_trans.req_state = REQ_STATUS_IDLE;
+        sram_bulk_write_end();
+#if DO_SHM
+        shared_memory_write(SHARED_MEM_TX_CMD_UPLOAD_END, 0);
+#endif
+        ret_len = 0;
+
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_CRC) {
+        usb_trans.req_addr = rq->wValue.word;
+        usb_trans.req_addr = usb_trans.req_addr << 16;
+        usb_trans.req_addr = usb_trans.req_addr | rq->wIndex.word;
+        debug_P(DEBUG_USB, PSTR("USB_CRC: addr=0x%08lx \n"), usb_trans.req_addr);
+        crc_check_bulk_memory(0x000000, usb_trans.req_addr, usb_trans.req_bank_size);
+        ret_len = 0;
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_MODE_AVR) {
+        usb_trans.req_state = REQ_STATUS_AVR;
+        debug_P(DEBUG_USB, PSTR("USB_MODE_AVR:\n"));
+        ret_len = 0;
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_AVR_RESET) {
+        debug_P(DEBUG_USB, PSTR("USB_AVR_RESET:\n"));
+        soft_reset();
+        ret_len = 0;
+        /*
+         * -------------------------------------------------------------------------
+         */
+    } else if (rq->bRequest == USB_SET_LAODER) {
+        usb_trans.loader_enabled = rq->wValue.word;
+        ret_len = 0;
+    }
+    usbMsgPtr = usb_trans.rx_buffer;
+    return ret_len;             
+}
+
+/*
+ * ------------------------------------------------------------------------- 
+ */
+
+
+void globals_init(){
+    memset(&usb_trans,0,sizeof(usb_transaction_t));
+    
+    usb_trans.req_addr = 0;
+    usb_trans.req_addr_end = 0;
+    usb_trans.req_state = REQ_STATUS_IDLE;
+    usb_trans.rx_remaining = 0;
+    usb_trans.tx_remaining = 0;
+    usb_trans.sync_errors = 0;
+    usb_trans.loader_enabled = 1;
+}
+
+int main(void)
+{
+    
+#ifndef NO_DEBUG            
+    uart_init();
+    stdout = &uart_stdout;
+    banner();
+#endif
+    shared_memory_init();
+    system_init();
+    sram_init();
+    //pwm_init();
+    irq_init();
+    boot_startup_rom(50);
+    globals_init();
+    //pwm_stop();
+    usbInit();
+    usb_connect();
+    sei();
+    while (1) {
+
+        system_set_bus_avr();
+        system_set_wr_disable();
+        info_P(PSTR("USB poll\n"));
+        while (usb_trans.req_state != REQ_STATUS_SNES) {
+            usbPoll();
+#ifdef DO_SHELL
+#ifndef NO_DEBUG            
+            shell_run();
+#endif        
+#endif        
+        }
+        
+#if DO_SHM
+        shared_memory_write(SHARED_MEM_TX_CMD_TERMINATE, 0);
+#endif
+
+#if DO_SHM_SCRATCHPAD
+        shared_memory_scratchpad_region_tx_restore();
+        shared_memory_scratchpad_region_rx_restore();
+#endif
+
+#if DO_CRC_CHECK     
+        info_P(PSTR("-->CRC Check\n"));
+        crc_check_bulk_memory(0x000000, usb_trans.req_bank_size * usb_trans.req_bank_cnt, usb_trans.req_bank_size);
+#endif        
+        
+        system_set_rom_mode(&usb_trans);
+        system_set_wr_disable();
+        system_set_bus_snes();
+        system_send_snes_reset();
+        irq_stop();
+/*        
+        info_P(PSTR("-->Switch TO SNES\n"));
+        set_rom_mode();
+        snes_wr_disable();
+        info_P(PSTR("Disable SNES WR\n"));
+        snes_bus_active();
+        info_P(PSTR("Activate SNES bus\n"));
+        irq_stop();
+        send_reset();
+*/        
+        info_P(PSTR("Poll USB\n"));
+        while ((usb_trans.req_state != REQ_STATUS_AVR)) {
+            usbPoll();
+#ifdef DO_SHELL
+#ifndef NO_DEBUG            
+            shell_run();
+#endif        
+#endif        
+
+        }
+        //info_P(PSTR("-->Switch TO AVR\n"));
+        shared_memory_init();
+        if(usb_trans.loader_enabled) {
+            boot_startup_rom(500);
+        } else {
+            system_set_bus_avr();
+            system_send_snes_reset();
+            //avr_bus_active();
+            //send_reset();
+            
+        }
+        irq_init();
+    }
+    return 0;
+}

avr/usbload/memmory.txt

@@ -0,0 +1,30 @@
+
+Loader Version 1
+
+DEBUG:
+Bootloader:     4096
+CODE:           24984 
+RAM:            742
+LOADER:         31091
+
+NO_DEBUG:
+Bootloader:     4096
+CODE:           7532 
+RAM:            344
+LOADER:         31091
+ 
+
+Loader Version 2
+
+DEBUG:
+Bootloader:     4096
+CODE:           24984 
+RAM:            742
+LOADER:         58046
+
+NO_DEBUG:
+Bootloader:     4096
+CODE:           7532 
+RAM:            344
+LOADER:         58046
+

avr/usbload/neginf/neginf.c

@@ -0,0 +1,466 @@
+/*
+ *  neginf.c
+ *  neginf -- embedded inflate lib
+ *
+ *  inflate routines
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "neginf.h"
+#include "neginf_priv.h"
+
+typedef void(*mode_fun)() ;
+
+static neginf_state state;
+static const mode_fun mode_tab[mode_count] = {
+    &await_block,
+    &raw_block_begin,
+    &raw_block_begin2,
+    &raw_block,
+    &fixed_block_begin,
+    &huff_block,
+    &huff_len_addbits,
+    &huff_dist,
+    &huff_dist_addbits,
+    &dynamic_block_begin,
+    &dynamic_read_lc,
+    &dynamic_read_lit_len,
+    &dynamic_read_dist
+};
+
+void neginf_init(nsize start_pos)
+{
+    state.queue_size = 0;
+    state.mode = mode_await_block;
+    state.last_block = 0;
+#ifdef NEGINF_POS_TRACKING
+    state.output_pos = start_pos;
+#endif
+}
+
+
+void neginf_process_byte(nbyte byte)
+{
+    assert(state.queue_size <= 16);
+    state.input_queue |= (byte << state.queue_size);
+    state.queue_size += 8;
+    
+    while(state.queue_size >= 16)
+    {
+        //printf("qsize=%i mode=%i\n",state.queue_size,state.mode);
+        mode_tab[state.mode]();
+    }
+}
+
+#ifdef NEGINF_POS_TRACKING
+nsize neginf_output_position()
+{
+    return state.output_pos;
+}
+#endif
+
+nint lookahead()
+{
+    //printf("lookahead\n");
+    return state.input_queue;
+}
+
+void consume(ntiny amount)
+{
+    //printf("consume %i %i\n",state.queue_size,amount);
+    assert(state.queue_size > amount);
+    state.input_queue >>= amount;
+    state.queue_size -= amount;
+}
+
+void await_block()
+{
+    //printf("wait block\n");
+    if(state.last_block)
+    {
+        neginf_cb_completed();
+        consume(16);
+    }
+    else
+    {
+        nint la = lookahead();
+        state.last_block = la & 1;
+        consume(3);
+        switch(la & 6)
+        {
+            case 0: // 00 uncompressed
+                consume((state.queue_size) & 7); // align to byte
+                state.mode = mode_raw_block_begin;
+                break;
+            case 2: // 01 fixed huffman
+                state.mode = mode_fixed_block_begin;
+                break;
+            case 4: // 10 dynamic huffman
+                state.mode = mode_dynamic_block_begin;
+                break;
+            default:
+                assert(0);
+        }
+    }
+}
+
+void raw_block_begin()
+{
+    //printf("raw block begin\n");
+    state.raw_size = lookahead() & 0xFFFF; // size of raw block
+    consume(16);
+    state.mode = mode_raw_block_begin2;
+}
+
+void raw_block_begin2()
+{
+    //printf("raw block begin2\n");
+    consume(16); // we ignore the inverted size
+    state.mode = mode_raw_block;
+}
+
+void raw_block()
+{
+    //printf("raw block\n");
+    if(state.raw_size == 0)
+    {
+        state.mode = mode_await_block;
+    }
+    else
+    {
+        state.raw_size--;
+        neginf_cb_seq_byte(lookahead() & 0xFF);
+#ifdef NEGINF_POS_TRACKING
+        state.output_pos++;
+#endif
+        consume(8);
+    }
+}
+
+void fixed_block_begin()
+{
+    //printf("fixed block begin\n");
+    
+    nint i = 0;
+    for(; i < 144; i++)
+        state.lit_len_lengths[i] = 8;
+    for(; i < 256; i++)
+        state.lit_len_lengths[i] = 9;
+    for(; i < 280; i++)
+        state.lit_len_lengths[i] = 7;
+    for(; i < 288; i++)
+        state.lit_len_lengths[i] = 8;
+    
+    ntiny j;
+    for(j = 0; i < 32; i++)
+        state.dist_lengths[i] = 5;
+    
+    compute_begins();
+    state.mode = mode_huff_block;
+}
+
+void huff_block()
+{
+    //printf("huff block\n");
+    nint code = lit_len_read();
+    if(code == 256)
+    {
+        state.mode = mode_await_block;
+    }
+    else if(code < 256)
+    {
+        neginf_cb_seq_byte(code);
+#ifdef NEGINF_POS_TRACKING
+        state.output_pos++;
+#endif
+    }
+    else
+    {
+        state.code = code;
+        state.mode = mode_huff_len_addbits;
+    }
+}
+
+void huff_len_addbits()
+{
+    //printf("huff len addbits\n");
+    nint len;
+    nint code = state.code;
+    nint la = lookahead();
+    if(code < 265)
+        len = code - 257 + 3;
+    else if(code < 269)
+    {
+        len = (code - 265) * 2 + 11 + (la & 1);
+        consume(1);
+    }
+    else if(code < 273)
+    {
+        len = (code - 269) * 4 + 19 + (la & 3);
+        consume(2);
+    }
+    else if(code < 277)
+    {
+        len = (code - 273) * 8 + 35 + (la & 7);
+        consume(3);
+    }
+    else if(code < 281)
+    {
+        len = (code - 277) * 16 + 67 + (la & 15);
+        consume(4);
+    }
+    else if(code < 285)
+    {
+        len = (code - 281) * 32 + 131 + (la & 31);
+        consume(5);
+    }
+    else
+    {
+        len = 258;
+    }
+    state.match_len = len;
+    state.mode = mode_huff_dist;
+}
+
+void huff_dist()
+{
+    //printf("huff dist\n");
+    state.tcode = dist_read();
+    state.mode = mode_huff_dist_addbits;
+}
+
+void huff_dist_addbits()
+{
+    //printf("huff addbits\n");
+    nint dist;
+    ntiny code = state.tcode;
+    
+    if(code < 4)
+    {
+        dist = code+1;
+    }
+    else if(code > 29)
+    {
+        assert(0);
+    }
+    else
+    {
+        nint la = lookahead();
+        ntiny len = (code - 2) / 2;
+        dist = ((2 + (code & 1)) << len) + 1 + (((1 << len) - 1) & la);
+        consume(len);
+    }
+    neginf_cb_rel_copy(dist, state.match_len);
+#ifdef NEGINF_POS_TRACKING
+    state.output_pos += state.match_len;
+#endif
+    
+    state.mode = mode_huff_block;
+}
+
+void dynamic_block_begin()
+{
+    nint j;
+    ntiny i;
+    //printf("dynamic block begin\n");
+    for(j = 0; j < 288; j++)
+        state.lit_len_lengths[j] = 0;
+    for(i = 0; i < 32; i++)
+        state.dist_lengths[i] = 0;
+    for(i = 0; i < 19; i++)
+        state.hc_lengths[i] = 0;
+    
+    nint la = lookahead();
+    state.hlit = (la & 31) + 257;
+    state.hdist = ((la >> 5) & 31) + 1;
+    state.hclen = ((la >> 10) & 15) + 4;
+    state.torder = 0;
+    consume(5+5+4);
+    state.mode = mode_dynamic_read_lc;
+}
+
+void dynamic_read_lc()
+{
+    //printf("dynamic read lc\n");
+    if(state.hclen == 0)
+    {
+        compute_begin(state.hc_lengths, state.hc_begins, 19);
+        state.mode = mode_dynamic_read_lit_len;
+        state.order = 0;
+    }
+    else
+    {
+        static const ntiny order[19] = {
+            16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+        };
+        ntiny i = lookahead() & 7;
+        state.hc_lengths[order[state.torder]] = i;
+        consume(3);
+        
+        state.torder++;
+        state.hclen--;
+    }
+}
+
+void dynamic_read_lit_len()
+{
+    //printf("dynamic read lit len\n");
+    if(state.hlit == 0)
+    {
+        state.mode = mode_dynamic_read_dist;
+        state.order = 0;
+    }
+    else
+    {
+        state.hlit -= lc_read(state.lit_len_lengths);
+    }
+}
+
+void dynamic_read_dist()
+{
+    //printf("dynamic read dist\n");
+    if(state.hdist == 0)
+    {
+        compute_begins();
+        state.mode = mode_huff_block;
+    }
+    else
+    {
+        state.hdist -= lc_read(state.dist_lengths);
+    }
+}
+
+ntiny lc_read(ntiny * lenghts)
+{
+    //printf("read lc\n");
+    ntiny code = huff_read(state.hc_lengths, state.hc_begins, 19);
+    // this reads 7 bits max so we still have 9 bits left in the buffer
+    if(code < 16)
+    {
+        lenghts[state.order] = code;
+        state.order++;
+        return 1;
+    }
+    else if(code == 16)
+    {
+        ntiny i;
+        ntiny copy = (lookahead() & 3) + 3;
+        consume(2);
+        for(i = 0; i < copy; i++)
+            lenghts[state.order + i] = lenghts[state.order - 1];
+        state.order += copy;
+        return copy;
+    }
+    else
+    {
+        ntiny fill;
+        ntiny i;
+        
+        if(code == 17)
+        {
+            fill = (lookahead() & 7) + 3;
+            consume(3);
+        }
+        else
+        {
+            fill = (lookahead() & 127) + 11;
+            consume(7);
+        }
+        for(i = 0; i < fill; i++)
+        {
+            lenghts[state.order] = 0;
+            state.order++;
+        }
+        return fill;
+    }    
+}
+
+
+void compute_begins()
+{
+    //printf("compute begins\n");
+    compute_begin(state.lit_len_lengths, state.lit_len_begins, 288);
+    compute_begin(state.dist_lengths, state.dist_begins, 32);
+}
+
+
+void compute_begin(ntiny * lengths, nint * begins, nint size)
+{
+    ntiny j;
+    nint i;
+    //printf("compute begin\n");
+    for(j = 0; j < 14; j++)
+        begins[j] = 0;
+    for(i = 0; i < size; i++)
+    {
+        nint len = lengths[i];
+        if(len != 0 && len != 15)
+            begins[len-1] += 1 << (15 - len);
+    }
+    nint acc = 0;
+    for(j = 0; j < 14; j++)
+    {
+        nint val = begins[j];
+        acc += val;
+        begins[j] = acc;
+    }    
+}
+
+nint lit_len_read()
+{
+    //printf("lit len read\n");
+    
+    return huff_read(state.lit_len_lengths, state.lit_len_begins, 288);
+}
+
+nint dist_read()
+{
+    //printf("dist read\n");
+    return huff_read(state.dist_lengths, state.dist_begins, 32);
+}
+
+nint huff_read(ntiny * lenghts, nint * begins, nint size)
+{
+    //printf("huff read\n");
+    nint code = 0;
+    ntiny i;
+    for(i = 1; i < 16; i++)
+    {
+        
+        code |= (lookahead() & 1) << (15-i);
+        consume(1);
+        if(i == 15 || code < begins[i-1])
+            break;
+    }
+    code -= begins[i-2];
+    code >>= (15-i);
+    nint j;
+    for(j = 0; j < size; j++)
+    {
+        if(lenghts[j] == i)
+        {
+            if(code == 0)
+                return j;
+            code--;
+        }
+    }
+    //assert(0);
+    return 0; // silent warning
+}
+
+#ifndef NEGINF_USE_SEQ_WRITES
+void neginf_cb_seq_byte(nbyte byte)
+{
+    neginf_cb_byte(state.output_pos, byte);
+}
+#endif
+
+#ifndef NEGINF_USE_REL_COPY
+void neginf_cb_rel_copy(nint distance, nint length)
+{
+    neginf_cb_copy(state.output_pos - distance, state.output_pos, length);
+}
+#endif

avr/usbload/neginf/neginf.h

@@ -0,0 +1,43 @@
+/*
+ *  neginf.h 
+ *  neginf -- embedded inflate lib
+ *
+ *  public header file
+ */
+
+#ifndef NEGINF_H
+#define NEGINF_H
+
+#include "neginf_conf.h"
+
+#if defined(NEGINF_USE_SEQ_WRITES) && defined(NEGINF_USE_REL_COPY)
+#else
+#ifndef NEGINF_POS_TRACKING
+#define NEGINF_POS_TRACKING
+#endif
+#endif
+
+void neginf_init(nsize start_pos);
+void neginf_process_byte(nbyte byte);
+
+#ifdef NEGINF_POS_TRACKING
+nsize neginf_output_position();
+#endif
+
+// callbacks
+
+#ifdef NEGINF_USE_SEQ_WRITES
+void neginf_cb_seq_byte(nbyte byte);
+#else
+void neginf_cb_byte(nsize pos, nbyte byte);
+#endif
+
+#ifdef NEGINF_USE_REL_COPY
+void neginf_cb_rel_copy(nint distance, nint length);
+#else
+void neginf_cb_copy(nsize from, nsize to, nint length);
+#endif
+
+void neginf_cb_completed();
+
+#endif

avr/usbload/neginf/neginf_conf.h

@@ -0,0 +1,48 @@
+/*
+ *  neginf_conf.h
+ *  neginf -- embedded inflate lib
+ *
+ *  configuration header file
+ */
+
+#ifndef NEGINF_CONF_H
+#define NEGINF_CONF_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+
+#define NEGINF_USE_SEQ_WRITES
+//#define NEGINF_USE_REL_COPY
+//#define NEGINF_POS_TRACKING
+
+//#define NEGINF_8BIT
+#define NEGINF_PACKED_STATE
+
+
+#ifdef NEGINF_8BIT
+
+typedef char nbool;
+typedef uint8_t nbyte;
+typedef uint8_t ntiny;
+typedef uint16_t nint;
+typedef uint32_t nbuf;
+
+typedef uint32_t nsize;
+
+#else
+
+typedef int nbool; // boolean
+typedef uint8_t nbyte; // has to be exaclty 8 bit, unsigned
+typedef unsigned int ntiny; // has to be at least 8 bit, unsigned
+typedef unsigned int nint; // has to be at least 16 bit, unsigned
+typedef unsigned int nbuf; // has to be at least 24 bit, unsigned
+
+
+typedef size_t nsize; // has be at least 24 bit, unsigned
+
+#endif
+
+
+
+#endif

avr/usbload/neginf/neginf_priv.h

@@ -0,0 +1,102 @@
+/*
+ *  neginf_priv.h
+ *  neginf -- embedded inflate lib
+ *
+ *  internal header file
+ */
+
+#ifndef NEGINF_PRIV_H
+#define NEGINF_PRIV_H
+
+typedef struct neginf_state_s neginf_state;
+struct neginf_state_s {
+    ntiny queue_size; // 0 .. 24
+    ntiny mode;
+    nbool last_block;
+#ifdef NEGINF_POS_TRACKING
+    nsize output_pos;
+#endif
+    // can be left uninitialized
+    nbuf input_queue; // three input bytes
+    
+    ntiny raw_size;
+    ntiny tcode;
+    nint code;
+    nint match_len;
+    
+    nint order;
+    ntiny torder;
+    nint hlit;
+    ntiny hdist;
+    ntiny hclen;
+    
+    ntiny lit_len_lengths[288];
+    nint lit_len_begins[14];
+    
+    ntiny dist_lengths[32];
+    nint dist_begins[14];
+    
+    ntiny hc_lengths[19];
+    nint hc_begins[14];
+    // what could be saved by limiting this to 7
+    // will be lost due to the extra code i guess
+    
+    
+}
+#ifdef NEGINF_PACKED_STATE
+__attribute__((__packed__))
+#endif
+;
+
+enum neginf_mode {
+    mode_await_block = 0,
+    mode_raw_block_begin,
+    mode_raw_block_begin2,
+    mode_raw_block,
+    mode_fixed_block_begin,
+    mode_huff_block,
+    mode_huff_len_addbits,
+    mode_huff_dist,
+    mode_huff_dist_addbits,
+    mode_dynamic_block_begin,
+    mode_dynamic_read_lc,
+    mode_dynamic_read_lit_len,
+    mode_dynamic_read_dist,
+    mode_count
+};
+
+static void await_block();
+static void raw_block_begin();
+static void raw_block_begin2();
+static void raw_block();
+static void fixed_block_begin();
+static void huff_block();
+static void huff_len_addbits();
+static void huff_dist();
+static void huff_dist_addbits();
+static void dynamic_block_begin();
+static void dynamic_read_lc();
+static void dynamic_read_lit_len();
+static void dynamic_read_dist();
+
+static void compute_begins();
+static void compute_begin(ntiny * lengths, nint * begins, nint size);
+static nint lit_len_read();
+static nint dist_read();
+static nint huff_read(ntiny * lengths, nint * begins, nint size);
+static ntiny lc_read(ntiny * lengths);
+
+static nint lookahead();
+static void consume(ntiny amount);
+
+#ifndef NEGINF_USE_SEQ_WRITES
+static void neginf_cb_seq_byte(nbyte byte);
+#endif
+
+#ifndef NEGINF_USE_REL_COPY
+void neginf_cb_rel_copy(nint distance, nint length);
+#endif
+
+#endif
+
+

avr/usbload/pwm.c

@@ -0,0 +1,104 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+#include <stdint.h>
+#include <string.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+#include "pwm.h"
+#include "debug.h"
+#include "info.h"
+#include "sram.h"
+
+
+#define PWM_SINE_MAX 64
+#define PWM_OVERFLOW_MAX 1024
+
+#if 0
+
+uint8_t pwm_sine_table[]  = {
+0x7f,0x8b,0x97,0xa4,0xaf,0xbb,0xc5,0xcf,0xd9,0xe1,0xe8,0xef,0xf4,0xf8,0xfb,0xfd,
+0xfd,0xfd,0xfb,0xf8,0xf3,0xee,0xe7,0xe0,0xd7,0xce,0xc4,0xb9,0xae,0xa2,0x96,0x89,
+0x7e,0x71,0x65,0x59,0x4d,0x42,0x37,0x2d,0x24,0x1c,0x15,0x0f,0x09,0x05,0x03,0x01,
+0x01,0x01,0x03,0x07,0x0b,0x11,0x17,0x1f,0x28,0x31,0x3b,0x46,0x52,0x5e,0x6a,0x76
+};
+
+volatile uint8_t pwm_setting;                   
+volatile uint16_t pwm_overflow;                    
+volatile uint8_t pwm_idx;                    
+volatile uint16_t pwm_overflow_max;                    
+ 
+ ISR(TIMER2_COMPA_vect) {
+    static uint8_t pwm_cnt=0;
+    OCR2A += (uint16_t)T_PWM;
+        
+    if (pwm_setting> pwm_cnt) 
+        led_pwm_on();
+    else
+        led_pwm_off();
+    
+    if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
+        pwm_cnt=0;
+    else
+        pwm_cnt++;
+    if (pwm_overflow_max == pwm_overflow++ ){
+        pwm_setting = pwm_sine_table[pwm_idx++];
+        pwm_overflow = 0;
+        if (PWM_SINE_MAX == pwm_idx)
+            pwm_idx = 0;
+    }
+}
+
+void pwm_speed(uint16_t val) {
+    pwm_overflow_max = val; 
+}
+
+void pwm_speed_slow(uint16_t val) {
+    pwm_overflow_max = PWM_OVERFLOW_MAX * 2 ; 
+}
+
+void pwm_speed_fast(uint16_t val) {
+    pwm_overflow_max = PWM_OVERFLOW_MAX / 2; 
+}
+
+void pwm_speed_normal(uint16_t val) {
+    pwm_overflow_max = PWM_OVERFLOW_MAX; 
+}
+
+
+void pwm_set(uint8_t val) {
+    pwm_setting = val;
+}
+
+void pwm_stop(void) {
+    while(pwm_setting!=0xfd);
+    TIMSK2 = 0;
+}
+
+void pwm_init(void) {
+    pwm_overflow_max = PWM_OVERFLOW_MAX;
+    pwm_setting = 0x7f;
+    pwm_overflow = 0;
+    //cli();
+    TCCR2B = 1;         
+    TIMSK2 |= (1<<OCIE2A);       
+    sei();                  
+}
+#endif

avr/usbload/pwm.h

@@ -0,0 +1,37 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#ifndef __PWM_H__
+#define __PWM_H__
+
+#define F_PWM 100                       // PWM-Frequenz in Hz
+#define PWM_STEPS 256                   // PWM-Schritte pro Zyklus(1..256)
+ 
+#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
+ 
+#if (T_PWM<(93+5))
+    #error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
+#endif
+
+ void pwm_init(void);
+void pwm_stop(void);
+ 
+ 
+#endif

avr/usbload/requests.h

@@ -0,0 +1,60 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __REQUESTS_H__
+#define __REQUESTS_H__
+
+#define USB_UPLOAD_INIT         0
+#define USB_UPLOAD_ADDR         1
+
+#define USB_DOWNLOAD_INIT       2
+#define USB_DOWNLOAD_ADDR       3
+
+#define USB_CRC                 4
+#define USB_CRC_ADDR            5
+
+#define USB_BULK_UPLOAD_INIT    6
+#define USB_BULK_UPLOAD_ADDR    7
+#define USB_BULK_UPLOAD_NEXT    8
+#define USB_BULK_UPLOAD_END     9
+#define USB_MODE_SNES           10
+#define USB_MODE_AVR            11
+#define USB_AVR_RESET           12
+#define USB_SET_LAODER          13
+
+typedef struct usb_transaction_t {
+    uint32_t req_addr;
+    uint32_t req_addr_end;
+    uint8_t req_bank;
+    uint32_t req_bank_size;
+    uint16_t req_bank_cnt;
+    uint8_t req_percent;
+    uint8_t req_percent_last;
+    uint8_t req_state;
+    uint8_t rx_remaining;
+    uint8_t tx_remaining ;
+    uint16_t sync_errors;
+    uint8_t tx_buffer[32];
+    uint8_t rx_buffer[8];
+    uint8_t loader_enabled;
+} usb_transaction_t;
+
+#endif /* __REQUESTS_H_INCLUDED__ */

avr/usbload/ringbuffer.c

@@ -0,0 +1,126 @@
+// AT90USB/ringbuffer.c
+// Simple Ring-Buffer (FIFO) for Elements of type char
+// S. Salewski, 19-MAR-2007
+
+/*
+t-> o
+    o <-w
+    x 
+    x <-r
+b-> x
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include "ringbuffer.h"
+#define memory_size         65536
+#define t &buf[ringbuffer_size - 1]
+#define b &buf[0]
+
+char buf[ringbuffer_size];
+int rb_count;
+char *memory;
+int pos_mem;
+int pos_head;
+
+
+//char *t = &buf[ringbuffer_size - 1];
+//char *b = &buf[0];
+
+char *r; // position from where we can read (if rb_count > 0)
+char *w; // next free position (if rb_count < ringbuffer_size))
+char *o; // output pointer
+
+void rb_init()
+{
+    r = b;
+    w = b;
+    o = b;
+    rb_count = 0;
+    memory = (char*)malloc(memory_size);
+    pos_mem = 0;
+    pos_head = 0;
+}
+
+
+void rb_dump()
+{
+    int i;
+    printf("b=0x%02x t=0x%02x w=0x%02x o=0x%02x\n",*b,*t,*w,*o);
+    for (i=0; i<ringbuffer_size; i++)
+        printf("%02i 0x%02x\n",i, buf[i]);
+
+}
+void rb_flush(){
+    FILE *file;
+    while(!rb_isempty()){
+        memory[pos_mem++] = rb_get();
+    }
+    printf("write out.smc\n");
+    file = fopen("out.smc","w");
+    fwrite(memory,memory_size,1,file);
+    fclose(file);
+}
+
+char rb_get(void)
+{
+    rb_count--;
+    if (r > t)
+        r = b;
+    return *r++;
+}
+
+
+char rb_read(int pos)
+{
+    char *p;
+    printf("rb_read: pos_mem=%06i pos_head=%06i pos=%06i\n",
+    	pos_mem, pos_head,pos);
+    
+    if ( pos_head - pos > ringbuffer_size){
+        printf("rb_read: memory[%i]=0x%02x \n", 
+            pos,
+            memory[pos]);
+        return memory[pos];
+    }
+    if (w - index >= b)
+        p = w - index;
+    else
+        p = b + (b - ( w - index ));
+    return *p;
+}
+
+void rb_copy(int from,int to,int len){
+    int i;
+    char c;
+    for (i = from; i< to; i++){
+        c = rb_read(i);
+        rb_put(c);
+    }
+}
+
+
+
+
+
+void rb_put(char el)
+{
+    pos_head++;
+    rb_count++;
+
+    if ( rb_count > ringbuffer_size){
+        rb_dump();
+        memory[pos_mem++]=*o++;
+        if (o > t){
+            o = b;
+        }
+    }
+    printf("rb_count=%i pos_head=0x%06x add_mem=0x%06x\n",rb_count, pos_head,pos_mem);
+
+    if (w > t){
+        w = b;
+    }
+    *w++ = el;
+}

avr/usbload/ringbuffer.h

@@ -0,0 +1,19 @@
+
+#ifndef _RING_BUFFER_H_
+#define _RING_BUFFER_H_
+
+
+#define ringbuffer_size 8
+
+extern int rb_count;
+
+#define rb_free() (ringbuffer_size - rb_count)
+#define rb_isfull() (rb_count == ringbuffer_size)
+#define rb_isempty() (rb_count == 0)
+
+void rb_init(void);
+void rb_put(char el);
+char rb_get(void);
+void rb_flush(void);
+
+#endif

avr/usbload/rle.c

@@ -0,0 +1,106 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <avr/io.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <avr/pgmspace.h>       /* required by usbdrv.h */
+#include <util/delay.h>         /* for _delay_ms() */
+#include <avr/interrupt.h>      /* for sei() */
+
+#include "sram.h"
+#include "debug.h"
+#include "info.h"
+
+#define RUNCHAR 0x90
+
+#if 0
+
+uint32_t rle_decode(PGM_VOID_P in_addr, int32_t in_len, uint32_t out_addr)
+{
+    uint8_t in_byte, in_repeat, last_byte;
+    info_P(PSTR("RLE decode len=%li addr=0x%08lx\n"), in_len, out_addr);
+    last_byte = 0;
+
+    sram_bulk_write_start(out_addr);
+#define INBYTE(b) \
+	do { \
+	         if ( --in_len < 0 ) { \
+			   return 1; \
+		 } \
+         cli();\
+         b = pgm_read_byte((PGM_VOID_P)in_addr++);  \
+         sei();\
+	} while(0)
+
+#define OUTBYTE(b) \
+	do { \
+        sram_bulk_write(b);\
+        sram_bulk_write_next();\
+        out_addr++;\
+	} while(0)
+
+    INBYTE(in_byte);
+
+    if (in_byte == RUNCHAR) {
+        INBYTE(in_repeat);
+        if (in_repeat != 0) {
+            info_P(PSTR("Orphaned RLE code at start\n"));
+            return 1;
+        }
+        OUTBYTE(RUNCHAR);
+    } else {
+        OUTBYTE(in_byte);
+    }
+
+    while (in_len > 0) {
+        INBYTE(in_byte);
+        if (in_len % 1024 == 0)
+            info_P(PSTR("."));
+        if (in_byte == RUNCHAR) {
+            INBYTE(in_repeat);
+            if (in_repeat == 0) {
+                /*
+                 * Just an escaped RUNCHAR value 
+                 */
+                OUTBYTE(RUNCHAR);
+            } else {
+                /*
+                 * Pick up value and output a sequence of it 
+                 */
+                in_byte = last_byte;    // ;out_data[-1];
+                while (--in_repeat > 0)
+                    OUTBYTE(in_byte);
+            }
+        } else {
+            /*
+             * Normal byte 
+             */
+            OUTBYTE(in_byte);
+        }
+        last_byte = in_byte;
+    }
+    sram_bulk_write_end();
+    info_P(PSTR("\nDone addr=0x%08lx\n"), out_addr);
+    return out_addr;
+}
+
+#endif

avr/usbload/rle.h

@@ -0,0 +1,28 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#ifndef __RLE_H__
+#define __RLE_H__
+
+#include <avr/pgmspace.h>
+
+uint32_t rle_decode(PGM_VOID_P in_addr, uint32_t in_len, uint32_t out_addr);
+
+#endif

avr/usbload/shared_memory.c

@@ -0,0 +1,345 @@
+
+
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <util/delay.h>
+
+#include "shared_memory.h"
+#include "config.h"
+#include "sram.h"
+#include "debug.h"
+#include "dump.h"
+#include "info.h"
+#include "crc.h"
+
+
+uint8_t irq_addr_lo;
+uint8_t irq_addr_hi;
+
+uint8_t scratchpad_state;
+uint8_t scratchpad_cmd;
+uint8_t scratchpad_payload;
+
+uint8_t scratchpad_region_rx[SHARED_MEM_RX_LOC_SIZE];
+uint8_t scratchpad_region_tx[SHARED_MEM_TX_LOC_SIZE];
+
+uint8_t scratchpad_locked_rx = 1;
+uint8_t scratchpad_locked_tx = 1;
+
+
+void shared_memory_init(void){
+    scratchpad_locked_rx = 1;
+    scratchpad_locked_tx = 1;
+    
+}
+
+
+uint8_t shared_memory_scratchpad_region_save_helper(uint32_t addr){
+
+
+
+#if DO_SHM_SCRATCHPAD    
+    if(addr > (SHARED_MEM_TX_LOC_STATE +  (SHARED_MEM_TX_LOC_SIZE )) &&  scratchpad_locked_tx){
+        debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_save_helper: open tx addr=0x%06lx\n"),addr);
+        shared_memory_scratchpad_region_tx_save();
+        return 0;
+    }
+    if(addr > (SHARED_MEM_RX_LOC_STATE +  ( SHARED_MEM_RX_LOC_SIZE )) &&  scratchpad_locked_rx){
+        debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_save_helper: open rx addr=0x%06lx\n"),addr);
+        shared_memory_scratchpad_region_rx_save();
+        return 0;
+    }
+#endif    
+    return 1;
+}
+
+
+void shared_memory_scratchpad_region_tx_save()
+{
+    sram_bulk_addr_save();
+
+#if SHARED_SCRATCHPAD_CRC    
+    uint16_t crc;
+    crc = crc_check_bulk_memory((uint32_t)SHARED_MEM_TX_LOC_STATE, 
+        (uint32_t)(SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE), 0x8000);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_save: crc=%x\n"),crc);
+    
+#endif
+
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_save: unlock\n"));
+    sram_bulk_copy_into_buffer((uint32_t)SHARED_MEM_TX_LOC_STATE,scratchpad_region_tx,
+        (uint32_t)SHARED_MEM_TX_LOC_SIZE);
+    scratchpad_locked_tx = 0;
+
+#if SHARED_SCRATCHPAD_CRC    
+    do_crc_update(0, scratchpad_region_tx,SHARED_MEM_TX_LOC_SIZE);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_save: crc=%x\n"),crc);
+#endif
+
+#if SHARED_SCRATCHPAD_DUMP
+    dump_packet(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_SIZE, scratchpad_region_tx);
+    dump_memory(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE);
+#endif
+    sram_bulk_addr_restore();
+    
+}
+
+void shared_memory_scratchpad_region_rx_save()
+{
+
+    sram_bulk_addr_save();
+#if SHARED_SCRATCHPAD_CRC    
+    uint16_t crc;
+    crc = crc_check_bulk_memory((uint32_t)SHARED_MEM_RX_LOC_STATE, 
+        (uint32_t)(SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE), 0x8000);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_save: crc=%x\n"),crc);
+#endif
+
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_save: unlock\n"));
+    sram_bulk_copy_into_buffer((uint32_t)SHARED_MEM_RX_LOC_STATE,scratchpad_region_rx,
+        (uint32_t)SHARED_MEM_RX_LOC_SIZE);
+    scratchpad_locked_rx = 0;
+
+#if SHARED_SCRATCHPAD_CRC    
+    do_crc_update(0, scratchpad_region_rx,SHARED_MEM_RX_LOC_SIZE);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_save: crc=%x\n"),crc);
+#endif
+
+#if SHARED_SCRATCHPAD_DUMP    
+    dump_packet(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_LOC_SIZE, scratchpad_region_rx);
+    dump_memory(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE);
+#endif
+    sram_bulk_addr_restore();
+
+}
+
+void shared_memory_scratchpad_region_tx_restore()
+{
+    if (scratchpad_locked_tx)
+        return;
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_restore: lock\n"));
+
+#if SHARED_SCRATCHPAD_DUMP    
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_restore: memory\n"));
+    dump_memory(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE);
+#endif
+
+    sram_bulk_copy_from_buffer((uint32_t)SHARED_MEM_TX_LOC_STATE,scratchpad_region_tx,
+        (uint32_t)SHARED_MEM_TX_LOC_SIZE);
+    scratchpad_locked_tx = 1;
+
+#if SHARED_SCRATCHPAD_DUMP    
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_restore: buffer\n"));
+    dump_packet(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_SIZE, scratchpad_region_tx);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_restore: memory\n"));
+    dump_memory(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE);
+#endif
+
+#if SHARED_SCRATCHPAD_CRC    
+    uint16_t crc;
+    crc = crc_check_bulk_memory((uint32_t)SHARED_MEM_TX_LOC_STATE, 
+        (uint32_t)(SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE), 0x8000);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_tx_restore: crc=%x\n"),crc);
+#endif
+}
+
+
+void shared_memory_scratchpad_region_rx_restore()
+{
+    if (scratchpad_locked_rx)
+        return;
+    
+
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_restore: lock\n"));
+
+#if SHARED_SCRATCHPAD_DUMP    
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_restore: memory\n"));
+    dump_memory(SHARED_MEM_RX_LOC_STATE - 0x10, SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE);
+#endif
+    
+    sram_bulk_copy_from_buffer((uint32_t)SHARED_MEM_RX_LOC_STATE,scratchpad_region_rx,
+        (uint32_t)SHARED_MEM_RX_LOC_SIZE);
+    scratchpad_locked_rx = 1;
+
+#if SHARED_SCRATCHPAD_DUMP    
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_restore: buffer\n"));
+    dump_packet(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_LOC_SIZE, scratchpad_region_rx);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_restore: memory\n"));
+    dump_memory(SHARED_MEM_RX_LOC_STATE - 0x10, SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE);
+#endif
+
+#if SHARED_SCRATCHPAD_CRC
+    uint16_t crc;
+    crc = crc_check_bulk_memory((uint32_t)SHARED_MEM_RX_LOC_STATE, 
+        (uint32_t)(SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE), 0x8000);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_scratchpad_region_rx_restore: crc=%x\n"),crc);
+#endif
+}
+
+
+void shared_memory_scratchpad_tx_save()
+{
+    scratchpad_state = sram_read(SHARED_MEM_TX_LOC_STATE);
+    scratchpad_cmd = sram_read(SHARED_MEM_TX_LOC_CMD);
+    scratchpad_payload = sram_read(SHARED_MEM_TX_LOC_PAYLOAD);
+}
+
+void shared_memory_scratchpad_tx_restore()
+{
+    sram_write(SHARED_MEM_TX_LOC_STATE, scratchpad_state);
+    sram_write(SHARED_MEM_TX_LOC_CMD, scratchpad_cmd);
+    sram_write(SHARED_MEM_TX_LOC_PAYLOAD, scratchpad_payload);
+}
+
+
+void shared_memory_irq_hook()
+{
+    irq_addr_lo = sram_read(SHARED_IRQ_LOC_LO);
+    irq_addr_hi = sram_read(SHARED_IRQ_LOC_HI);
+    sram_write(SHARED_IRQ_HANDLER_LO, 0);
+    sram_write(SHARED_IRQ_HANDLER_HI, 0);
+}
+
+void shared_memory_irq_restore()
+{
+    sram_write(SHARED_IRQ_LOC_LO, irq_addr_lo);
+    sram_write(SHARED_IRQ_LOC_HI, irq_addr_hi);
+}
+
+void shared_memory_write(uint8_t cmd, uint8_t value)
+{
+#if DO_SHM
+#if DO_SHM_SCRATCHPAD    
+    if (scratchpad_locked_tx){ 
+        debug_P(DEBUG_SHM, PSTR("shared_memory_write:  locked_tx\n"));
+        return;
+    }
+#endif
+    debug_P(DEBUG_SHM, PSTR("shared_memory_write:  0x%04x=0x%02x 0x%04x=0x%02x \n"),
+         SHARED_MEM_TX_LOC_CMD, cmd, SHARED_MEM_TX_LOC_PAYLOAD, value);
+
+    sram_bulk_addr_save();
+
+#if (DO_SHM_SCRATCHPAD==0)    
+    shared_memory_scratchpad_tx_save();
+#endif
+#if SHARED_MEM_SWITCH_IRQ    
+    shared_memory_irq_hook();
+#endif
+
+    sram_write(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_SNES_ACK);
+    sram_write(SHARED_MEM_TX_LOC_CMD, cmd);
+    sram_write(SHARED_MEM_TX_LOC_PAYLOAD, value);
+
+    snes_hirom();
+    snes_wr_disable();
+    snes_bus_active();
+
+#if SHARED_MEM_SWITCH_IRQ    
+    snes_irq_on();
+    snes_irq_lo();
+    _delay_us(20);
+    snes_irq_hi();
+    snes_irq_off();
+#else
+    _delay_ms(SHARED_MEM_SWITCH_DELAY);
+#endif
+
+    avr_bus_active();
+    snes_irq_lo();
+    snes_irq_off();
+    snes_lorom();
+    snes_wr_disable();
+
+#if (DO_SHM_SCRATCHPAD==0)    
+    shared_memory_scratchpad_tx_restore();
+#endif
+#if SHARED_MEM_SWITCH_IRQ    
+    shared_memory_irq_restore();
+#endif
+    sram_bulk_addr_restore();
+#endif
+}
+
+void shared_memory_yield()
+{
+
+    snes_hirom();
+    snes_wr_disable();
+    snes_bus_active();
+    _delay_ms(SHARED_MEM_SWITCH_DELAY);
+    avr_bus_active();
+    snes_lorom();
+    snes_wr_disable();
+
+}
+
+
+int shared_memory_read(uint8_t *cmd, uint8_t *len,uint8_t *buffer)
+{
+    uint8_t state;
+#if DO_SHM
+#if DO_SHM_SCRATCHPAD    
+    if (scratchpad_locked_rx){ 
+        debug_P(DEBUG_SHM, PSTR("shared_memory_write:  locked_tx\n"));
+        return 1;
+    }
+#endif
+    sram_bulk_addr_save();
+
+    state = sram_read(SHARED_MEM_RX_LOC_STATE);
+    if (state != SHARED_MEM_RX_AVR_ACK){
+        sram_bulk_addr_restore();
+        return 1;
+    }
+
+    *cmd = sram_read(SHARED_MEM_RX_LOC_CMD);
+    *len = sram_read(SHARED_MEM_RX_LOC_LEN);
+    debug_P(DEBUG_SHM, PSTR("shared_memory_read: 0x%04x=0x%02x 0x%04x=0x%02x \n"),
+         SHARED_MEM_RX_LOC_CMD, *cmd, SHARED_MEM_RX_LOC_LEN, *len);
+
+    sram_bulk_copy_into_buffer(SHARED_MEM_RX_LOC_PAYLOAD,buffer, *len);
+    sram_write(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_AVR_RTS);
+
+    snes_hirom();
+    snes_wr_disable();
+    snes_bus_active();
+
+#if SHARED_MEM_SWITCH_IRQ    
+    snes_irq_on();
+    snes_irq_lo();
+    _delay_us(20);
+    snes_irq_hi();
+    snes_irq_off();
+#else
+    _delay_ms(SHARED_MEM_SWITCH_DELAY);
+#endif
+
+    avr_bus_active();
+    snes_lorom();
+    snes_wr_disable();
+    sram_bulk_addr_restore();
+#endif
+    return 0;
+}

avr/usbload/shared_memory.h

@@ -0,0 +1,76 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#ifndef __SHARED_MEMORY_H__
+#define __SHARED_MEMORY_H__
+
+
+#define SHARED_MEM_SWITCH_IRQ               0
+#define SHARED_MEM_SWITCH_DELAY             20
+
+#define SHARED_MEM_TX_SNES_ACK              0xa5
+#define SHARED_MEM_TX_SNES_RTS              0x5a
+
+#define SHARED_MEM_TX_CMD_BANK_COUNT        0x00
+#define SHARED_MEM_TX_CMD_BANK_CURRENT      0x01
+
+#define SHARED_MEM_TX_CMD_UPLOAD_START      0x03
+#define SHARED_MEM_TX_CMD_UPLOAD_END        0x04
+#define SHARED_MEM_TX_CMD_UPLOAD_PROGESS    0x05
+#define SHARED_MEM_TX_CMD_TERMINATE         0x06
+
+#define SHARED_MEM_TX_LOC_STATE             0x000000
+#define SHARED_MEM_TX_LOC_SIZE              0x000040
+#define SHARED_MEM_TX_LOC_CMD               0x000001
+#define SHARED_MEM_TX_LOC_PAYLOAD           0x000002
+
+#define SHARED_MEM_RX_AVR_ACK               0xa5
+#define SHARED_MEM_RX_AVR_RTS               0x5a
+
+#define SHARED_MEM_RX_CMD_PRINFT            0x00
+#define SHARED_MEM_RX_CMD_FILESEL           0x01
+
+#define SHARED_MEM_RX_LOC_STATE             0x001000
+#define SHARED_MEM_RX_LOC_SIZE              0x000040
+#define SHARED_MEM_RX_LOC_CMD               0x001001
+#define SHARED_MEM_RX_LOC_LEN               0x001002
+#define SHARED_MEM_RX_LOC_PAYLOAD           0x001003
+
+#define SHARED_IRQ_LOC_LO                   0x00fffe
+#define SHARED_IRQ_LOC_HI                   0x00ffff
+
+/* Use COP IRQ LOC for hooked IRQ handler */
+#define SHARED_IRQ_HANDLER_LO               0x0ffe4
+#define SHARED_IRQ_HANDLER_HI               0x0ffe5
+
+#define SHARED_SCRATCHPAD_DUMP              0
+#define SHARED_SCRATCHPAD_CRC               0
+        
+
+void shared_memory_init(void);
+uint8_t shared_memory_scratchpad_region_save_helper(uint32_t addr);
+void shared_memory_scratchpad_region_tx_save();
+void shared_memory_scratchpad_region_tx_restore();
+void shared_memory_scratchpad_region_rx_save();
+void shared_memory_scratchpad_region_rx_restore();
+void shared_memory_write(uint8_t cmd, uint8_t value);
+int shared_memory_read(uint8_t *cmd, uint8_t *len,uint8_t *buffer);
+
+#endif

avr/usbload/shell.c

@@ -0,0 +1,487 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+#include <stdint.h>
+#include <string.h>
+#include <avr/io.h>
+#include <stdlib.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>         
+#include <avr/pgmspace.h>       
+#include <avr/eeprom.h>
+
+
+#include "pwm.h"
+#include "debug.h"
+#include "info.h"
+#include "sram.h"
+#include "util.h"
+#include "uart.h"
+#include "dump.h"
+#include "irq.h"
+#include "config.h"
+#include "crc.h"
+#include "command.h"
+#include "shared_memory.h"
+#include "system.h"
+
+ 
+extern system_t system;
+
+uint8_t command_buf[RECEIVE_BUF_LEN];
+uint8_t	recv_buf[RECEIVE_BUF_LEN];
+
+volatile uint8_t	recv_counter = 0;
+volatile uint8_t	cr = 0;
+
+uint8_t *token_ptr;
+
+#ifdef DO_SHELL
+
+uint8_t *get_token(void)
+{
+ 	uint8_t *p = token_ptr;
+ 	while (*p == ' ')
+ 		p++;
+ 	if (*p == '\0')
+ 		return NULL;
+ 	token_ptr = p;
+ 	do {
+ 		token_ptr++;
+ 		if (*token_ptr == ' ' || *token_ptr == '\n' || *token_ptr == '\r') {
+ 			*token_ptr++ = '\0';
+ 			break;
+ 		}
+ 	} while (*token_ptr != ' ' && *token_ptr != '\n' && *token_ptr != '\r');
+ 	return p;
+}
+
+uint8_t get_dec(uint32_t *decval)
+{
+ 	const uint8_t *t;
+ 	t = get_token();
+ 	if (t != NULL) {
+ 		int x = util_sscandec(t);
+ 		if (x < 0)
+ 			return 0;
+ 		*decval = x;
+ 		return 1;
+ 	}
+ 	return 0;
+ }
+
+uint8_t parse_hex(const uint8_t *s, uint32_t *hexval)
+{
+ 	uint32_t x = util_sscanhex(s);
+ 	*hexval = (uint32_t) x;
+ 	return 1;
+ }
+
+uint8_t get_hex(uint32_t *hexval)
+{
+ 	const uint8_t *t;
+ 	t = get_token();
+ 	if (t != NULL)
+ 		return parse_hex(t, hexval);
+ 	return 0;
+ }
+
+uint8_t get_hex_arg2(uint32_t *hexval1, uint32_t *hexval2)
+{
+ 	return get_hex(hexval1) && get_hex(hexval2);
+}
+
+uint8_t get_hex_arg3(uint32_t *hexval1, uint32_t *hexval2, uint32_t *hexval3)
+{
+ 	return get_hex(hexval1) && get_hex(hexval2) && get_hex(hexval3);
+}
+
+static uint8_t get_int32(uint32_t *val)
+ {
+ 	if (!get_hex(val)){
+ 		info_P(PSTR("Invalid argument!\n"));
+        return 0;
+    } else {
+        return 1;
+    }
+ }
+
+ static uint8_t get_int8(uint8_t *val)
+ {
+ 	uint32_t ret;
+ 	if (!get_hex(&ret) ||ret > 0xff){
+ 		info_P(PSTR("Invalid argument!\n"));
+        return 0;
+ 	}else{
+ 		*val = (uint8_t)ret;
+        return 1;
+    }
+ }
+
+ static int get_bool(void)
+ {
+ 	const uint8_t *t;
+ 	t = get_token();
+ 	if (t != NULL) {
+ 		int result = util_sscanbool(t);
+ 		if (result >= 0)
+ 			return result;
+ 	}
+ 	info_P(PSTR("Invalid argument (should be 0 or 1)!\n"));
+ 	return -1;
+ } 
+ void prompt(void){
+     
+     uart_putc('\r');
+     uart_putc('\n');
+     uart_putc('>');
+     
+ }
+ 
+ISR(USART0_RX_vect)		
+{
+  UCSR0B &= (255 - (1<<RXCIE0));//	Interrupts disable for RxD
+  sei();
+  if(recv_counter == (sizeof(recv_buf)-1)) {
+    cr=1;
+    recv_buf[recv_counter]='\0';
+    recv_counter=0;
+    prompt();
+  }
+  recv_buf[recv_counter] = UDR0;
+  uart_putc(recv_buf[recv_counter]); 
+  if (recv_buf[recv_counter] == 0x0d) {
+    /* recv_buf[recv_counter] = 0; */
+    cr = 1;				
+    recv_buf[++recv_counter]='\0';  
+    recv_counter = 0;
+    prompt();
+  } else {
+    // we accept backspace or delete
+    if ((recv_buf[recv_counter] == 0x08 || recv_buf[recv_counter] == 0x7f) && recv_counter > 0) {
+      recv_counter--;
+    } else {
+      recv_counter++;
+    }
+  }
+  UCSR0B |= (1<<RXCIE0);
+}
+
+enum cmds { 
+            CMD_DUMP,
+            CMD_DUMPVEC,
+            CMD_DUMPHEADER,
+            CMD_CRC,
+            CMD_EXIT,
+            CMD_RESET,
+            CMD_RESETSNIFF,
+            CMD_IRQ,
+            CMD_AVR,
+            CMD_SNES,
+            CMD_LOROM,
+            CMD_HIROM,
+            CMD_WR,
+            CMD_SHMWR,
+            CMD_SHMSAVE,
+            CMD_SHMRESTORE,
+            CMD_LOADER,
+            CMD_RECONNECT,
+            CMD_STATUS,
+            CMD_SYS,
+            CMD_HELP
+};
+
+uint8_t cmdlist[][CMD_HELP] PROGMEM = {
+            {"DUMP"},
+            {"DUMPVEC"},
+            {"DUMPHEADER"},
+            {"CRC"},
+            {"EXIT"},
+            {"RESET"},
+            {"RESETSNIFF"},
+            {"IRQ"},
+            {"AVR"},
+            {"SNES"},
+            {"LOROM"},
+            {"HIROM"},
+            {"WR"},
+            {"SHMWR"},
+            {"SHMSAVE"},
+            {"SHMRESTORE"},
+            {"LOADER"},
+            {"RECONNECT"},
+            {"STATUS"},
+            {"SYS"},
+            {"HELP"},
+        };
+
+
+void shell_help(void){
+	uint8_t i;
+    info_P(PSTR("\n"));
+    for (i=CMD_DUMP; i<CMD_HELP; i++){
+        info_P((PGM_P)cmdlist[i]);
+        info_P(PSTR("\n"));
+        
+    }
+}
+
+
+void shell_run(void)
+{
+	uint8_t *t;
+    uint32_t arg1;
+    uint32_t arg2;
+    uint32_t arg3;
+	uint16_t crc;
+    uint16_t offset;
+    uint16_t i;
+    uint8_t c;
+    
+	if (!cr)
+        return;
+    cr=0;
+	strcpy((char*)command_buf, (char*)recv_buf);
+	
+	token_ptr = command_buf;
+	t = get_token();
+	
+	if (t == NULL)
+        shell_help();
+
+	util_strupper(t);
+
+	if (strcmp_P((const char*)t,(PGM_P)cmdlist[CMD_DUMP]) == 0) {
+        if (get_hex_arg2(&arg1,&arg2))
+            dump_memory(arg1,arg2);
+        else 
+            info_P(PSTR("DUMP <start addr> <end addr>\n"));
+    
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_CRC]) == 0) {
+        if (get_hex_arg2(&arg1,&arg2)){
+            crc = crc_check_bulk_memory(arg1,arg2,0x8000);
+            info_P(PSTR("0x%06lx - 0x%06lx crc=0x%04x\n"),arg1,arg2,crc);
+        } else 
+            info_P(PSTR("CRC <start addr> <end addr>\n"));
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_EXIT]) == 0) {
+        leave_application();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_RESET]) == 0) {
+        system_send_snes_reset();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_IRQ]) == 0) {
+        info_P(PSTR("Send IRQ\n"));
+        snes_irq_on();
+        snes_irq_lo();
+        _delay_us(20);
+        snes_irq_hi();
+        snes_irq_off();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_AVR]) == 0) {
+         //info_P(PSTR("Activate AVR bus\n"));
+         //avr_bus_active();
+         //snes_irq_lo();
+         //snes_irq_off();
+        system_set_bus_avr();
+        snes_irq_lo();
+        system_snes_irq_off();
+        
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_SNES]) == 0) {
+        //info_P(PSTR("Activate SNES bus\n"));
+        //snes_irq_lo();
+        //snes_irq_off();
+        //snes_wr_disable();
+        //snes_bus_active();
+        snes_irq_lo();
+        system_snes_irq_off();
+        system_set_wr_disable();
+        system_set_bus_snes();
+        
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_LOROM]) == 0) {
+        //info_P(PSTR("Set LOROM\n"));
+        //snes_lorom();
+        //snes_wr_disable();
+        system_set_rom_lorom();
+        system_set_wr_disable();
+        
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_HIROM]) == 0) {
+        //info_P(PSTR("Set HIROM\n"));
+        //snes_hirom();
+        //snes_wr_disable();
+        system_set_rom_hirom();
+        system_set_wr_disable();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_WR]) == 0) {
+        arg1 = get_bool();
+        if(arg1==1){
+            info_P(PSTR("Set WR enable"));
+            snes_wr_enable();
+        }else if (arg1==0){
+            info_P(PSTR("Set WR disable"));
+            snes_wr_disable();
+        }
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_RESETSNIFF]) == 0) {
+        arg1 = get_bool();
+        if(arg1==1){
+            info_P(PSTR("Start Reset sniffer"));
+            irq_init();
+        }else if (arg1==0){
+            info_P(PSTR("Stop Reset sniffer"));
+            irq_stop();
+        }
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_DUMPVEC]) == 0) {
+        uint16_t offset;
+    	if (system.rom_mode==LOROM)
+            offset = 0x8000;
+    	else
+            offset = 0x0000;
+    	
+        info_P(PSTR("ABORT	0x%04x 0x%04x\n"), (0xFFE8 - offset),sram_read16_be(0xFFE8 - offset));
+        info_P(PSTR("BRK	0x%04x 0x%04x\n"), (0xFFE6 - offset),sram_read16_be(0xFFE6 - offset));
+        info_P(PSTR("COP	0x%04x 0x%04x\n"), (0xFFE4 - offset),sram_read16_be(0xFFE4 - offset));
+        info_P(PSTR("IRQ	0x%04x 0x%04x\n"), (0xFFEE - offset),sram_read16_be(0xFFEE - offset));
+        info_P(PSTR("NMI	0x%04x 0x%04x\n"), (0xFFEA - offset),sram_read16_be(0xFFEA - offset));
+        info_P(PSTR("RES	0x%04x 0x%04x\n"), (0xFFFC - offset),sram_read16_be(0xFFFC - offset));
+    	
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_DUMPHEADER]) == 0) {
+        
+    	if (system.rom_mode==LOROM)
+            offset = 0x8000;
+    	else
+            offset = 0x0000;
+    	/*
+    	#  $ffc0..$ffd4 => Name of the ROM, typically in ASCII, using spaces to pad the name to 21 bytes.
+        # $ffd5 => ROM layout, typically $20 for LoROM, or $21 for HiROM. Add $10 for FastROM.
+        # $ffd6 => Cartridge type, typically $00 for ROM only, or $02 for ROM with save-RAM.
+        # $ffd7 => ROM size byte.
+        # $ffd8 => RAM size byte.
+        # $ffd9 => Country code, which selects the video in the emulator. Values $00, $01, $0d use NTSC. Values in range $02..$0c use PAL. Other values are invalid.
+        # $ffda => Licensee code. If this value is $33, then the ROM has an extended header with ID at $ffb2..$ffb5.
+        # $ffdb => Version number, typically $00.
+        # $ffdc..$ffdd => Checksum complement, which is the bitwise-xor of the checksum and $ffff.
+        # $ffde..$ffdf => SNES checksum, an unsigned 16-bit checksum of bytes.
+        # $ffe0..$ffe3 => Unknown.
+        */
+        info_P(PSTR("NAME	0x%04x "), (0xffc0 - offset));
+        for(arg1=(0xffc0 - offset); arg1<(0xffc0 - offset + 21);arg1++){
+            c = sram_read(arg1);
+            if (c>0x1f && c<0x7f)
+                printf("%c",c);
+        }
+        printf("\n");
+        c = sram_read(0xffd5 - offset);
+        info_P(PSTR("LAYOUT	0x%04x "), (0xffd5 - offset));
+        
+        switch(c){
+            case 0x20:
+                info_P(PSTR("LoROM, not fast\n"));
+                break;
+            case 0x21:
+                info_P(PSTR("HiRom, not fast\n"));
+                break;
+            case 0x30:
+                info_P(PSTR("LoROM, fast\n"));
+                break;
+            case 0x31:
+                info_P(PSTR("HiRom, fast\n"));
+                break;
+            default:
+                info_P(PSTR("Unkown 0x%02x\n"),c);
+                break;
+        }
+
+        c = sram_read(0xffd6 - offset);
+        info_P(PSTR("TYPE	0x%04x "), (0xffd6 - offset),c);
+        switch(c){
+            case 0x00:
+                info_P(PSTR("Rom\n"));
+                break;
+            case 0x01:
+                info_P(PSTR("Rom + Sram\n"));
+                break;
+            case 0x02:
+                info_P(PSTR("Rom + Sram + Battery\n"));
+                break;
+            case 0x13:
+                info_P(PSTR("SuperFX\n"));
+                break;
+            case 0x14:
+                info_P(PSTR("SuperFX\n"));
+                break;
+            case 0x15:
+                info_P(PSTR("SuperFX + Sram\n"));
+                break;
+            case 0x1a:
+                info_P(PSTR("SuperFX + Sram\n"));
+                break;
+            case 0x34:
+                info_P(PSTR("SA-1"));
+                break;
+            case 0x35:
+                info_P(PSTR("SA-1"));
+                break;
+            default:
+                info_P(PSTR("Unkown 0x%02x\n"),c);
+                break;
+        }
+        arg1 = ( 2 << ( sram_read(0xffd7 - offset) - 1 ));    
+        info_P(PSTR("ROM	0x%04x %li MBit ( %li KiB)\n"), (0xffd7 - offset), (arg1 / 128), arg1);
+        arg1 = ( 2 << ( sram_read(0xffd8 - offset) - 1 ));
+        info_P(PSTR("RAM	0x%04x %li KiB\n"), (0xffd8 - offset), arg1);
+
+        info_P(PSTR("CCODE	0x%04x "), (0xffd9 - offset));
+        c = sram_read(0xffd9 - offset);
+        if (c==0x00 || c==0x01 || 0x0d )
+            info_P(PSTR("NTSC\n"));
+        else if (c>=0x02 || c<=0x0c )
+            info_P(PSTR("PAL\n"));
+        else
+            info_P(PSTR("Unkown 0x%02x\n"),c);
+        
+        info_P(PSTR("LIC	0x%04x 0x%02x\n"), (0xffda - offset),sram_read(0xffda - offset));
+        info_P(PSTR("VER	0x%04x 0x%02x\n"), (0xffdb - offset),sram_read(0xffdb - offset));
+        info_P(PSTR("SUM1	0x%04x 0x%04x\n"), (0xffdc - offset),sram_read16_be(0xffdc - offset));
+        info_P(PSTR("SUM2	0x%04x 0x%04x\n"), (0xffde - offset),sram_read16_be(0xffde - offset));
+    	
+    
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_SHMWR]) == 0) {
+        if (get_hex_arg2(&arg1,&arg2))
+            shared_memory_write((uint8_t)arg1, (uint8_t)arg1);
+        else 
+            info_P(PSTR("SHMWR <command> <value>\n"));
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_SHMSAVE]) == 0) {
+        shared_memory_scratchpad_region_tx_save();
+        shared_memory_scratchpad_region_rx_save();
+        info_P(PSTR("Save scratchpad\n"));
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_SHMRESTORE]) == 0) {
+        shared_memory_scratchpad_region_tx_restore();
+        shared_memory_scratchpad_region_rx_restore();
+        info_P(PSTR("Restore scratchpad\n"));
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_LOADER]) == 0) {
+        boot_startup_rom(500);    
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_RECONNECT]) == 0) {
+        usb_connect();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_STATUS]) == 0) {
+            transaction_status();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_SYS]) == 0) {
+            system_status();
+    }else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_HELP]) == 0) {
+        shell_help();
+    }    
+    prompt();
+}
+
+
+#endif

avr/usbload/shell.h

@@ -0,0 +1,26 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#ifndef __SHELL_H__
+#define __SHELL_H__
+
+ void shell_run(void);
+
+#endif

avr/usbload/sram.c

@@ -0,0 +1,338 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <avr/io.h>
+#include <util/delay.h>         /* for _delay_ms() */
+
+
+#include "config.h"
+#include "sram.h"
+#include "uart.h"
+#include "debug.h"
+#include "info.h"
+
+uint32_t addr_current = 0;
+uint32_t addr_stash = 0;
+
+void sram_init(void)
+{
+    /*-------------------------------------------------*/
+    
+    DDRA =  0x00;
+    PORTA =  0x00;
+    
+    /*-------------------------------------------------*/
+    
+    DDRC |=     ( (1 << AVR_ADDR_LATCH_PIN)	    
+                | (1 << AVR_ADDR_SCK_PIN)	    
+                | (1 << AVR_ADDR_SER_PIN)	    
+                | (1 << AVR_ADDR_LOAD_PIN)	    
+                | (1 << AVR_ADDR_UP_PIN));	    
+    
+    DDRC &=     ~ ((1 << SNES_WR_PIN)	    
+                | (1 << AVR_BTLDR_EN_PIN));
+ 
+    PORTC &=    ~((1 << AVR_ADDR_LATCH_PIN)	    
+                | (1 << AVR_ADDR_SCK_PIN)
+                | (1 << SNES_WR_PIN));
+ 
+    
+    PORTC |=    ( (1 << AVR_ADDR_UP_PIN)
+                | (1 << AVR_ADDR_LOAD_PIN));    
+                
+                //| (1 << SNES_WR_PIN));
+    /*-------------------------------------------------*/
+    
+    DDRB |=     ( (1 << AVR_RD_PIN)	            
+                | (1 << AVR_WR_PIN) 
+                | (1 << AVR_CS_PIN)	            
+                | (1 << SNES_IRQ_PIN));
+
+    
+    PORTB |=    ( (1 << AVR_RD_PIN)	            
+                | (1 << AVR_WR_PIN) 
+                | (1 << AVR_CS_PIN)	            
+                | (1 << SNES_IRQ_PIN));
+ 
+    /*-------------------------------------------------*/
+                	        
+    
+    DDRD |=     ( (1 << AVR_SNES_SW_PIN)	            
+                | (1 << HI_LOROM_SW_PIN) 
+                | (1 << SNES_WR_EN_PIN));
+
+    PORTD |=    (1 << HI_LOROM_SW_PIN);
+                
+    PORTD &=    ~((1 << AVR_SNES_SW_PIN) 
+                | (1 << SNES_WR_EN_PIN));
+
+    /*-------------------------------------------------*/
+                	    
+    
+}   
+
+void sreg_set(uint32_t addr)
+{
+    uint8_t i = 24;
+    debug_P(DEBUG_SREG, PSTR("sreg_set: addr=0x%08lx"),addr);
+    while(i--) {
+        if ((addr & ( 1L << i))){
+            debug_P(DEBUG_SREG, PSTR("1"));
+            AVR_ADDR_SER_PORT |= ( 1 << AVR_ADDR_SER_PIN);
+        } else {
+            AVR_ADDR_SER_PORT &= ~( 1 << AVR_ADDR_SER_PIN);
+            debug_P(DEBUG_SREG, PSTR("0"));
+        }
+        AVR_ADDR_SCK_PORT |= (1 << AVR_ADDR_SCK_PIN);
+        AVR_ADDR_SCK_PORT &= ~(1 << AVR_ADDR_SCK_PIN);
+    }
+    debug_P(DEBUG_SREG, PSTR("\n"));
+    AVR_ADDR_LATCH_PORT |= (1 << AVR_ADDR_LATCH_PIN);
+    AVR_ADDR_LATCH_PORT &= ~(1 << AVR_ADDR_LATCH_PIN);
+    
+    counter_load();
+    
+}
+
+ void sram_bulk_addr_save()
+{
+    addr_stash = addr_current;
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_addr_save: addr=0x%08lx\n\r"), addr_stash);
+}
+
+inline void sram_bulk_addr_restore()
+{
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_addr_restore: addr=0x%08lx\n\r"), addr_stash);
+    sram_bulk_write_start(addr_stash);
+}
+
+
+void sram_bulk_read_start(uint32_t addr)
+{
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_read_start: addr=0x%08lx\n\r"), addr);
+
+    addr_current = addr;
+
+    avr_data_in();
+
+    AVR_CS_PORT &= ~(1 << AVR_CS_PIN);
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+
+    sreg_set(addr);
+
+    AVR_RD_PORT &= ~(1 << AVR_RD_PIN);
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+ 
+ }
+
+inline void sram_bulk_read_next(void)
+{
+    addr_current++;
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+    counter_up();
+    AVR_RD_PORT &= ~(1 << AVR_RD_PIN);
+
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+
+}
+
+
+inline uint8_t sram_bulk_read(void)
+{
+    return AVR_DATA_PIN;
+}
+
+void sram_bulk_read_end(void)
+{
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_read_end:\n"));
+
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+    AVR_CS_PORT |= (1 << AVR_CS_PIN);
+    avr_data_in();
+}
+
+uint8_t sram_read(uint32_t addr)
+{
+    uint8_t byte;
+    debug_P(DEBUG_SRAM_RAW, PSTR("sram_read: addr=0x%08lx\n\r"), addr);
+    
+    avr_data_in();
+    
+    AVR_CS_PORT &= ~(1 << AVR_CS_PIN);
+
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+    
+    sreg_set(addr);
+    
+    AVR_RD_PORT &= ~(1 << AVR_RD_PIN);
+    
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    
+    byte = AVR_DATA_PIN;
+
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+    AVR_CS_PORT |= (1 << AVR_CS_PIN);
+    
+    avr_data_in();
+    return byte;
+
+}
+
+uint16_t sram_read16_be(uint32_t addr){
+    uint8_t hi = sram_read(addr);
+    uint8_t lo = sram_read(addr+1);
+    return (hi << 8 | lo );
+}
+
+void sram_bulk_write_start(uint32_t addr)
+{
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_write_start: addr=0x%08lx\n\r"), addr);
+    addr_current = addr;
+
+    avr_data_out();
+
+    AVR_CS_PORT &= ~(1 << AVR_CS_PIN);
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+
+    sreg_set(addr);
+
+}
+
+inline void sram_bulk_write_next(void)
+{
+    AVR_WR_PORT &= ~(1 << AVR_WR_PIN);
+    addr_current++;
+    counter_up();
+}
+
+inline void sram_bulk_write( uint8_t data)
+{
+    AVR_WR_PORT &= ~(1 << AVR_WR_PIN);
+    AVR_DATA_PORT = data;
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+}
+
+void sram_bulk_write_end(void)
+{
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_write_end:"));
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+    AVR_CS_PORT |= (1 << AVR_CS_PIN);
+    avr_data_in();
+}
+
+
+void sram_write(uint32_t addr, uint8_t data)
+{
+    debug_P(DEBUG_SRAM_RAW, PSTR("sram_write: addr=0x%08lx data=%x\n\r"), addr, data);
+
+    avr_data_out();
+    
+    AVR_CS_PORT &= ~(1 << AVR_CS_PIN);
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+    AVR_RD_PORT |= (1 << AVR_RD_PIN);
+    
+    sreg_set(addr);
+    
+    AVR_WR_PORT &= ~(1 << AVR_WR_PIN);
+
+
+    AVR_DATA_PORT = data;
+
+        
+    AVR_WR_PORT |= (1 << AVR_WR_PIN);
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    asm volatile ("nop");
+    AVR_CS_PORT |= (1 << AVR_CS_PIN);
+    
+    avr_data_in();
+}
+
+
+void sram_bulk_copy_from_buffer(uint32_t addr, uint8_t * src, uint32_t len)
+{
+
+    uint32_t i;
+    uint8_t *ptr = src;
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_copy_from_buffer: addr=0x%08lx src=0x%p len=%li\n\r"), 
+        addr, src, len);
+    sram_bulk_write_start(addr);
+    for (i = addr; i < (addr + len); i++){
+        sram_bulk_write(*ptr);
+//hack
+        if ((i+1) < (addr + len))
+            sram_bulk_write_next();
+        ptr++;
+    }
+    sram_bulk_write_end();
+}
+
+void sram_bulk_copy_into_buffer(uint32_t addr, uint8_t * dst, uint32_t len)
+{
+
+    uint32_t i;
+    uint8_t *ptr = dst;
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_copy_into_buffer: addr=0x%08lx dst=0x%p len=%li\n\r"), 
+        addr, dst, len);
+    sram_bulk_read_start(addr);
+    for (i = addr; i < (addr + len); i++) {
+        dst[i] = sram_bulk_read();
+        sram_bulk_read_next();
+    }
+    sram_bulk_read_end();
+}
+
+void sram_bulk_set(uint32_t addr, uint32_t len,uint8_t value){
+    uint32_t i;
+    debug_P(DEBUG_SRAM, PSTR("sram_bulk_set: addr=0x%08lx len=%li\n\r"), addr,len);
+    sram_bulk_write_start(addr);
+    for (i = addr; i < (addr + len); i++) {
+        if (0 == i % 0xfff)
+            debug_P(DEBUG_SRAM, PSTR("sram_bulk_set: addr=0x%08lx\n\r"), i);
+        sram_bulk_write(value);
+        sram_bulk_write_next();
+    }
+    sram_bulk_write_end();
+}
+

avr/usbload/sram.h

@@ -0,0 +1,226 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+#ifndef __SRAM_H__
+#define __SRAM_H__
+
+#include <stdlib.h>
+#include <stdint.h> 
+#include <avr/io.h>
+
+
+
+/* ---------------------------- PORT A ---------------------------- */
+
+#define AVR_DATA_PORT           PORTA
+#define AVR_DATA_DIR            DDRA
+#define AVR_DATA_PIN            PINA
+
+#define avr_data_in()           ((AVR_DATA_DIR = 0x00),\
+                                (AVR_DATA_PORT = 0x00))
+
+#define avr_data_out()          (AVR_DATA_DIR = 0xff)
+
+
+/* ---------------------------- PORT B ---------------------------- */
+
+#define AVR_PORT                PORTB
+#define AVR_DIR                 DDRB
+#define AVR_RD_PORT             PORTB
+#define AVR_RD_DIR              DDRB
+#define AVR_RD_PIN              PB2
+
+#define avr_rd_hi()             (AVR_RD_PORT |= (1 << AVR_RD_PIN))
+#define avr_rd_lo()             (AVR_RD_PORT &= ~(1 << AVR_RD_PIN))
+
+#define AVR_WR_PORT             PORTB
+#define AVR_WR_DIR              DDRB
+#define AVR_WR_PIN              PB1
+
+#define avr_wr_hi()             (AVR_WR_PORT |= (1 << AVR_WR_PIN))
+#define avr_wr_lo()             (AVR_WR_PORT &= ~(1 << AVR_WR_PIN))
+
+#define AVR_CS_PORT             PORTB
+#define AVR_CS_DIR              DDRB
+#define AVR_CS_PIN              PB0
+
+#define avr_cs_hi()             (AVR_CS_PORT |= (1 << AVR_CS_PIN))
+#define avr_cs_lo()             (AVR_CS_PORT &= ~(1 << AVR_CS_PIN))
+
+#define SNES_IRQ_PORT           PORTB
+#define SNES_IRQ_DIR            DDRB
+#define SNES_IRQ_PIN            PB3
+
+
+#define snes_irq_on()          (SNES_IRQ_DIR |= (1 << SNES_IRQ_PIN))
+#define snes_irq_hi()          (SNES_IRQ_PORT |= (1 << SNES_IRQ_PIN))
+
+#define snes_irq_off()          (SNES_IRQ_DIR &= ~(1 << SNES_IRQ_PIN))
+#define snes_irq_lo()           (SNES_IRQ_PORT &= ~(1 << SNES_IRQ_PIN))
+
+
+/* ---------------------------- PORT C ---------------------------- */
+
+#define AVR_ADDR_PORT	    	PORTC
+#define AVR_ADDR_DIR	    	DDRC
+#define AVR_ADDR_LATCH_PORT	    PORTC
+#define AVR_ADDR_LATCH_DIR	    DDRC
+#define AVR_ADDR_LATCH_PIN	    PC6
+
+#define avr_addr_latch_hi()       (AVR_ADDR_LATCH_PORT |= (1 << AVR_ADDR_LATCH_PIN))
+#define avr_addr_latch_lo()       (AVR_ADDR_LATCH_PORT &= ~(1 << AVR_ADDR_LATCH_PIN))
+
+#define AVR_ADDR_SCK_PORT	    PORTC
+#define AVR_ADDR_SCK_DIR	    DDRC
+#define AVR_ADDR_SCK_PIN	    PC5
+
+#define avr_addr_sck_hi()       (AVR_ADDR_SCK_PORT |= (1 << AVR_ADDR_SCK_PIN))
+#define avr_addr_sck_lo()       (AVR_ADDR_SCK_PORT &= ~(1 << AVR_ADDR_SCK_PIN))
+
+#define AVR_ADDR_SER_PORT	    PORTC
+#define AVR_ADDR_SER_DIR	    DDRC
+#define AVR_ADDR_SER_PIN	    PC4
+
+#define avr_addr_ser_hi()       (AVR_ADDR_SER_PORT |= (1 << AVR_ADDR_SER_PIN))
+#define avr_addr_ser_lo()       (AVR_ADDR_SER_PORT &= ~(1 << AVR_ADDR_SER_PIN))
+
+#define AVR_ADDR_LOAD_PORT	    PORTC
+#define AVR_ADDR_LOAD_DIR	    DDRC
+#define AVR_ADDR_LOAD_PIN	    PC2
+
+#define counter_load()	        ((AVR_ADDR_LOAD_PORT &= ~(1 << AVR_ADDR_LOAD_PIN)),\
+                                (AVR_ADDR_LOAD_PORT |= (1 << AVR_ADDR_LOAD_PIN)))
+
+#define AVR_BTLDR_EN_PORT	    PORTC
+#define AVR_BTLDR_EN_DIR	    DDRC
+#define AVR_BTLDR_EN_PIN	    PC1
+
+#define btldr_down()	        ((AVR_BTLDR_EN_PORT &= ~(1 << AVR_BTLDR_EN_PIN)),\
+                                (AVR_BTLDR_EN_PORT |= (1 << AVR_BTLDR_EN_PIN)))
+
+#define AVR_ADDR_UP_PORT	    PORTC
+#define AVR_ADDR_UP_DIR	        DDRC
+#define AVR_ADDR_UP_PIN	        PC0
+
+#define counter_up()	        ((AVR_ADDR_UP_PORT &= ~(1 << AVR_ADDR_UP_PIN)),\
+                                (AVR_ADDR_UP_PORT |= (1 << AVR_ADDR_UP_PIN)))
+
+#define SNES_WR_PORT	        PORTC
+#define SNES_WR_DIR	            DDRC
+#define SNES_WR_PIN	            PC3
+
+#define LED_PORT	            PORTC
+#define LED_DIR		            DDRC
+#define LED_PIN		            PC7
+
+#define led_on()	            ((LED_PORT &=~ (1 << LED_PIN)),\
+                                (LED_DIR &=~ (1 << LED_PIN)))
+#define led_off()	            ((LED_PORT &=~ (1 << LED_PIN)),\
+                                (LED_DIR |= (1 << LED_PIN)))
+
+#define led_pwm_on()	        (LED_DIR &=~ (1 << LED_PIN))
+#define led_pwm_off()	        (LED_DIR |= (1 << LED_PIN))
+
+/* ---------------------------- PORT D ---------------------------- */
+
+#define AVR_SNES_PORT	        PORTD
+#define AVR_SNES_DIR	        DDRD
+#define AVR_SNES_SW_PORT	    PORTD
+#define AVR_SNES_SW_DIR	        DDRD
+#define AVR_SNES_SW_PIN	        PD5
+
+#define avr_bus_active()	    ((AVR_SNES_SW_PORT &= ~(1 << AVR_SNES_SW_PIN)),\
+                                (HI_LOROM_SW_PORT |= (1 << HI_LOROM_SW_PIN)),\
+                                (AVR_CS_DIR |= (1 << AVR_CS_PIN)))
+
+#define snes_bus_active()	    ((AVR_SNES_SW_PORT |= (1 << AVR_SNES_SW_PIN)),\
+                                (AVR_CS_DIR &= ~(1 << AVR_CS_PIN)),\
+                                (AVR_CS_PORT |= (1 << AVR_CS_PIN)))
+
+#define HI_LOROM_SW_PORT	    PORTD
+#define HI_LOROM_SW_DIR	        DDRD
+#define HI_LOROM_SW_PIN	        PD6
+
+#define snes_hirom()	        (HI_LOROM_SW_PORT &= ~(1 << HI_LOROM_SW_PIN))
+#define snes_lorom()	        (HI_LOROM_SW_PORT |= (1 << HI_LOROM_SW_PIN))
+
+#define SNES_WR_EN_PORT	        PORTD
+#define SNES_WR_EN_DIR	        DDRD
+#define SNES_WR_EN_PIN	        PD7
+
+#define snes_wr_disable()	    (SNES_WR_EN_PORT &= ~(1 << SNES_WR_EN_PIN))
+
+#define snes_wr_enable()	    (SNES_WR_EN_PORT |= (1 << SNES_WR_EN_PIN))
+
+#define SNES_RESET_PORT         PORTD
+#define SNES_RESET_DIR          DDRD
+#define SNES_RESET_PIN          PD3
+#define SNES_RESET_INP          PIND
+
+#define snes_reset_on()         (SNES_RESET_DIR |= (1 << SNES_RESET_PIN))
+#define snes_reset_hi()         (SNES_RESET_PORT |= (1 << SNES_RESET_PIN))
+
+#define snes_reset_off()        (SNES_RESET_DIR &= ~(1 << SNES_RESET_PIN))
+#define snes_reset_lo()         (SNES_RESET_PORT &= ~(1 << SNES_RESET_PIN))
+
+#define snes_reset_test()       ((SNES_RESET_INP & (1 << SNES_RESET_PIN)) == 0)
+
+#define MMC_PORT                PORTB
+#define MMC_DIR                 DDRB
+
+#define MMC_MISO_PIN            PB6
+#define MMC_MOSI_PIN            PB5
+#define MMC_SCK_PIN             PB7
+#define MMC_CS_PIN              PB4
+
+
+
+
+
+void sram_init(void);
+void sreg_set(uint32_t addr);
+
+uint8_t sram_read(uint32_t addr);
+void sram_write(uint32_t addr, uint8_t data);
+
+void sram_bulk_read_start(uint32_t addr);
+inline void sram_bulk_read_next(void);
+inline void sram_bulk_read_end(void);
+uint8_t sram_bulk_read(void);
+uint16_t sram_read16_be(uint32_t addr);
+
+void sram_bulk_write_start(uint32_t addr);
+inline void sram_bulk_write_next(void);
+inline void sram_bulk_write_end(void);
+void sram_bulk_write(uint8_t data);
+
+void sram_bulk_copy_from_buffer(uint32_t addr, uint8_t * src, uint32_t len);
+void sram_bulk_copy_into_buffer(uint32_t addr, uint8_t * dst, uint32_t len);
+
+void sram_bulk_set(uint32_t addr, uint32_t len,uint8_t value);
+
+inline void sram_bulk_addr_save();
+inline void sram_bulk_addr_restore();
+
+
+
+#endif

avr/usbload/system.c

@@ -0,0 +1,186 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <avr/io.h>
+#include <util/delay.h>         /* for _delay_ms() */
+#include <avr/interrupt.h>      
+
+
+#include "config.h"
+#include "sram.h"
+#include "system.h"
+#include "uart.h"
+#include "debug.h"
+#include "info.h"
+#include "requests.h"
+#include "irq.h"
+
+system_t system;
+
+void system_init(void)
+{
+    snes_reset_hi();
+    snes_reset_off();
+    system.reset_line = RESET_OFF;
+
+    snes_irq_hi();
+    snes_irq_off();
+    system.irq_line = IRQ_OFF;
+
+
+    snes_wr_disable();
+    system.wr_line = WR_DISABLE;
+
+    avr_bus_active();
+    system.bus_mode = MODE_AVR;
+
+    snes_lorom();
+    system.rom_mode = LOROM;
+
+    system.snes_reset_count = 0;
+    system.avr_reset_count = 0;
+
+    system.reset_irq = RESET_IRQ_OFF;
+
+}   
+
+void system_send_snes_reset()
+{
+    info_P(PSTR("Reset SNES\n"));
+    cli();
+    snes_reset_on();
+    snes_reset_lo();
+    _delay_ms(2);
+    snes_reset_hi();
+    snes_reset_off();
+    sei();
+    system.snes_reset_count++;
+}
+
+void system_send_snes_irq()
+{
+    snes_irq_on();
+    snes_irq_lo();
+    _delay_us(20);
+    snes_irq_hi();
+    snes_irq_off();
+}
+
+void system_snes_irq_off()
+{    
+    snes_irq_off();
+    system.irq_line = IRQ_OFF;
+}
+
+void system_snes_irq_on()
+{    
+    snes_irq_on();
+    system.irq_line = IRQ_ON;
+}
+
+
+void system_set_bus_avr()
+{
+    avr_bus_active();
+    info_P(PSTR("Activate AVR bus\n"));
+    system.bus_mode = MODE_AVR;
+}
+
+void system_set_wr_disable(){
+    snes_wr_disable();
+    system.wr_line = WR_DISABLE;
+    info_P(PSTR("Disable SNES WR\n"));
+}
+
+void system_set_wr_enable(){
+    snes_wr_enable();
+    system.wr_line = WR_ENABLE;
+    info_P(PSTR("Enable SNES WR\n"));
+}
+
+void system_set_bus_snes()
+{
+    snes_bus_active();
+    system.bus_mode = MODE_SNES;
+    info_P(PSTR("Activate SNES bus\n"));
+}
+
+void system_set_rom_mode(usb_transaction_t *usb_trans)
+{
+    if (usb_trans->req_bank_size == 0x8000) {
+        snes_lorom();
+        system.rom_mode = LOROM;
+        info_P(PSTR("Set SNES lorom \n"));
+    } else {
+        snes_hirom();
+        system.rom_mode = HIROM;
+        info_P(PSTR("Set SNES hirom \n"));
+    }
+}
+
+void system_set_rom_lorom()
+{
+    snes_lorom();
+    system.rom_mode = LOROM;
+    info_P(PSTR("Set SNES lorom \n"));
+}
+
+
+void system_set_rom_hirom()
+{
+    snes_hirom();
+    system.rom_mode = HIROM;
+    info_P(PSTR("Set SNES hirom \n"));
+}
+
+char* system_status_helper(uint8_t val){
+   if (val)
+       return "ON";
+    else
+        return "OFF";
+}
+
+char* system_status_bus(uint8_t val){
+   if (val)
+       return "SNES";
+    else
+        return "AVR";
+}
+
+char* system_status_rom(uint8_t val){
+   if (val)
+       return "HIROM";
+    else
+        return "LOROM";
+}
+
+void system_status(){
+    info_P(PSTR("\nBus Mode       %s\n"),system_status_bus(system.bus_mode));
+    info_P(PSTR("Rom Mode       %s\n"),system_status_rom(system.rom_mode));
+    info_P(PSTR("Reset Line     %s\n"),system_status_helper(system.reset_line));
+    info_P(PSTR("IRQ Line       %s\n"),system_status_helper(system.irq_line));
+    info_P(PSTR("WR Line        %s\n"),system_status_helper(system.wr_line));
+    info_P(PSTR("Reset IRQ      %s\n"),system_status_helper(system.reset_irq));
+    info_P(PSTR("SNES Reset     0x%02x\n"),system.snes_reset_count);
+    info_P(PSTR("AVR Reset      0x%02x\n"),system.avr_reset_count);
+}   

avr/usbload/system.h

@@ -0,0 +1,57 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+#ifndef __SYSTEM_H__
+#define __SYSTEM_H__
+
+#include "requests.h"
+
+
+
+typedef struct system_t {
+    enum bus_mode_e   { MODE_AVR, MODE_SNES } bus_mode;
+    enum rom_mode_e   { LOROM, HIROM } rom_mode;
+    enum reset_line_e { RESET_OFF, RESET_ON } reset_line;
+    enum irq_line_e   { IRQ_ON, IRQ_OFF } irq_line;
+    enum wr_line_e    { WR_DISABLE, WR_ENABLE } wr_line;
+    enum reset_irq_e   { RESET_IRQ_OFF, RESET_IRQ_ON } reset_irq;
+
+    uint8_t snes_reset_count;
+    uint8_t avr_reset_count;
+} system_t;
+
+void system_init(void);
+void system_init(void);
+void system_send_snes_reset(void);
+void system_send_snes_irq(void);
+void system_set_bus_avr(void);
+void system_set_bus_snes(void);
+void system_set_rom_mode(usb_transaction_t *usb_trans);
+void system_set_rom_hirom(void);
+void system_set_rom_lorom(void);
+void system_snes_irq_off(void);
+void system_set_wr_disable(void);
+void system_set_wr_enable(void);
+
+void system_status();
+
+#endif

avr/usbload/testing.c

@@ -0,0 +1,131 @@
+
+
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <util/delay.h>
+
+#include "shared_memory.h"
+#include "config.h"
+#include "sram.h"
+#include "debug.h"
+#include "crc.h"
+#include "info.h"
+#include "dump.h"
+
+void test_read_write()
+{
+
+    uint8_t i;
+    uint32_t addr;
+    avr_bus_active();
+    addr = 0x000000;
+    i = 1;
+    while (addr++ <= 0x0000ff) {
+        sram_write(addr, i++);
+    }
+    addr = 0x000000;
+    while (addr++ <= 0x0000ff) {
+        info_P(PSTR("read addr=0x%08lx %x\n"), addr, sram_read(addr));
+    }
+}
+
+
+
+void test_bulk_read_write()
+{
+
+    uint8_t i;
+    uint32_t addr;
+    avr_bus_active();
+    addr = 0x000000;
+    i = 0;
+    sram_bulk_write_start(addr);
+    while (addr++ <= 0x8000) {
+        sram_bulk_write(i++);
+        sram_bulk_write_next();
+    }
+    sram_bulk_write_end();
+
+    addr = 0x000000;
+    sram_bulk_read_start(addr);
+    while (addr <= 0x8000) {
+        info_P(PSTR("addr=0x%08lx %x\n"), addr, sram_bulk_read());
+        sram_bulk_read_next();
+        addr++;
+    }
+    sram_bulk_read_end();
+}
+
+
+void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr)
+{
+    uint32_t addr = 0;
+    uint8_t c;
+    sram_bulk_read_start(bottom_addr);
+    for (addr = bottom_addr; addr < top_addr; addr++) {
+        c = sram_bulk_read();
+        if (c != 0xff)
+            info_P(PSTR("addr=0x%08lx c=0x%x\n"), addr, c);
+        sram_bulk_read_next();
+    }
+    sram_bulk_read_end();
+}
+
+
+void test_memory_pattern(uint32_t bottom_addr, uint32_t top_addr, uint32_t bank_size)
+{
+    uint32_t addr = 0;
+    uint8_t pattern = 0x55;
+    info_P(PSTR("test_memory_pattern: bottom_addr=0x%08lx top_addr=0x%08lx\n"), bottom_addr, top_addr);
+    sram_bulk_write_start(bottom_addr);
+    for (addr = bottom_addr; addr < top_addr; addr++) {
+        if (addr % bank_size == 0){
+            pattern++;
+            info_P(PSTR("test_memory_pattern: write addr=0x%08lx pattern=0x%08lx\n"), addr, pattern);
+        }
+        sram_bulk_write(pattern);
+    }
+    sram_bulk_write_end();
+
+
+    for (addr = bottom_addr; addr < top_addr; addr+=bank_size) {
+        info_P(PSTR("test_memory_pattern: dump bottom_addr=0x%08lx top_addr=0x%08lx\n"), addr, addr + bank_size);
+        dump_memory(addr, addr + bank_size );
+        info_P(PSTR("----------------------------------------------------------------\n"));
+    }
+
+    crc_check_bulk_memory((uint32_t)bottom_addr,top_addr, bank_size);
+}
+
+void test_crc()
+{
+    info_P(PSTR("test_crc: clear\n"));
+    avr_bus_active();
+    sram_bulk_set(0x000000, 0x10000, 0xff);
+    info_P(PSTR("test_crc: crc\n"));
+    crc_check_bulk_memory(0x000000, 0x10000, 0x8000);
+    info_P(PSTR("test_crc: check\n"));
+    test_non_zero_memory(0x000000, 0x10000);
+}
+

avr/usbload/testing.h

@@ -0,0 +1,31 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __TESTING_H__
+#define __TESTING_H__
+
+
+void test_read_write();
+void test_bulk_read_write();
+void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr);
+void test_crc();
+ 
+#endif

avr/usbload/timer.c

@@ -0,0 +1,94 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
+
+#include <stdint.h>
+#include <stdio.h>
+#include <avr/io.h> 
+#include <avr/io.h>
+#include <avr/interrupt.h>      /* for sei() */
+
+#include "debug.h" 
+#include "info.h"
+#include "sram.h"
+ 
+ 
+extern uint8_t snes_reset_line;
+  
+#ifndef OCR1A
+    #define OCR1A OCR1  // 2313 support
+#endif
+ 
+#ifndef WGM12
+    #define WGM12 CTC1  // 2313 support
+#endif
+
+//#define XTAL      11059201L   // nominal value
+#define XTAL        20000000UL 
+
+#define DEBOUNCE    500L        // debounce clock (256Hz = 4msec)
+ 
+#define uint8_t unsigned char
+#define uint unsigned int
+ 
+uint16_t prescaler;
+uint16_t volatile second;          // count seconds
+ 
+ 
+ISR (SIG_OUTPUT_COMPARE1A)
+{
+
+ 
+#if XTAL % DEBOUNCE                     // bei rest
+    OCR1A = 20000000UL / DEBOUNCE - 1;      // compare DEBOUNCE - 1 times
+#endif
+  if( --prescaler == 0 ){
+    prescaler = (uint16_t)DEBOUNCE;
+    second++;               // exact one second over
+#if XTAL % DEBOUNCE         // handle remainder
+    OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per second
+#endif
+  }
+}
+ 
+void timer_start( void )
+{
+  TCCR1B = (1<<WGM12) | (1<<CS10);      // divide by 1
+                                        // clear on compare
+  OCR1A = XTAL / DEBOUNCE - 1UL;          // Output Compare Register
+  TCNT1 = 0;                            // Timmer startet mit 0
+  second = 0;
+  prescaler = (uint16_t)DEBOUNCE;          //software teiler
+  TIMSK1 = 1<<OCIE1A;                    // beim Vergleichswertes Compare Match                    
+                                        // Interrupt (SIG_OUTPUT_COMPARE1A)
+  sei();
+
+}
+
+uint16_t timer_stop_int(void)
+{
+    uint16_t t = ((DEBOUNCE - prescaler) / DEBOUNCE )  + second;
+    return t;
+}
+
+
+

avr/usbload/timer.h

@@ -0,0 +1,29 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+ 
+ #ifndef __TIMER_H__
+ #define __TIMER_H__
+ 
+
+int16_t timer_start( void );
+double timer_stop( void );
+int16_t timer_stop_int( void );
+
+#endif

avr/usbload/uart.c

@@ -0,0 +1,100 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <stdio.h>
+#include "uart.h"
+#include "fifo.h"
+
+
+
+volatile struct {
+    uint8_t tmr_int:1;
+    uint8_t adc_int:1;
+    uint8_t rx_int:1;
+} intflags;
+
+
+volatile char rxbuff;
+
+
+
+static int uart_stream(char c, FILE *stream);
+
+FILE uart_stdout = FDEV_SETUP_STREAM(uart_stream, NULL, _FDEV_SETUP_WRITE);
+
+void uart_init(void)
+{
+    UCSR0A = _BV(U2X0);           /* improves baud rate error @ F_CPU = 1 MHz */
+    UCSR0B = _BV(TXEN0) | _BV(RXEN0) | _BV(RXCIE0); /* tx/rx enable, rx complete
+                                                 * intr */
+    UBRR0L = (F_CPU / (8 * 115200UL)) - 1;       
+
+
+}
+
+/*
+ISR(USART0_RX_vect)
+{
+    uint8_t c;
+    c = UDR0;
+    if (bit_is_clear(UCSR0A, FE0)) {
+        rxbuff = c;
+        intflags.rx_int = 1;
+    }
+}
+*/
+
+void uart_putc(uint8_t c)
+{
+    loop_until_bit_is_set(UCSR0A, UDRE0);
+    UDR0 = c;
+}
+
+
+void uart_puts(const char *s)
+{
+    do {
+        uart_putc(*s);
+    }
+    while (*s++);
+}
+
+void uart_puts_P(PGM_P s)
+{
+    while (1) {
+        unsigned char c = pgm_read_byte(s);
+        s++;
+        if ('\0' == c)
+            break;
+        uart_putc(c);
+    }
+}
+
+static int uart_stream(char c, FILE * stream)
+{
+    if (c == '\n')
+        uart_putc('\r');
+    loop_until_bit_is_set(UCSR0A, UDRE0);
+    UDR0 = c;
+    return 0;
+}

avr/usbload/uart.h

@@ -0,0 +1,39 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __UART_H__
+#define __UART_H__
+
+#define CR "\r\n"
+
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <stdio.h>
+
+void uart_init(void);
+void uart_putc(const uint8_t);
+void uart_puts(const char *s);
+void uart_puts_P(PGM_P s);
+
+#endif
+
+
+

avr/usbload/usb_bulk.c

@@ -0,0 +1,83 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <avr/io.h>
+#include <avr/pgmspace.h>       /* required by usbdrv.h */
+#include <avr/interrupt.h>      /* for sei() */
+#include <util/delay.h>         /* for _delay_ms() */
+
+#include <stdlib.h>
+
+#include "usbdrv.h"
+#include "oddebug.h"            /* This is also an example for using debug
+                                 * macros */
+#include "config.h"
+#include "requests.h"           /* The custom request numbers we use */
+#include "uart.h"
+#include "sram.h"
+#include "debug.h"
+#include "info.h"
+
+#include "crc.h"
+#include "usb_bulk.h"
+
+
+extern usb_transaction_t usb_trans;
+
+uint8_t usbFunctionWrite(uint8_t * data, uint8_t len)
+{
+    uint8_t *ptr;
+    uint8_t  i;
+    
+    if (len > usb_trans.rx_remaining) {
+        info_P(PSTR("ERROR:usbFunctionWrite more data than expected remain: %i len: %i\n"),
+                usb_trans.rx_remaining, len);
+        len =  usb_trans.rx_remaining;
+    }
+    if (usb_trans.req_state == REQ_STATUS_BULK_UPLOAD) {
+
+        usb_trans.rx_remaining -= len;
+        debug_P(DEBUG_USB_TRANS, PSTR("usbFunctionWrite REQ_STATUS_BULK_UPLOAD addr: 0x%08lx len: %i rx_remaining=%i\n"),
+                usb_trans.req_addr, len,  usb_trans.rx_remaining);
+        ptr = data;
+        i = len;
+        while(i--){
+            sram_bulk_write(*ptr++);
+            sram_bulk_write_next();
+        }
+    }
+    return len;
+}
+
+uint8_t usbFunctionRead(uint8_t * data, uint8_t len)
+{
+    uint8_t i;
+    if (len >  usb_trans.tx_remaining)
+        len =  usb_trans.tx_remaining;
+     usb_trans.tx_remaining -= len;
+    debug_P(DEBUG_USB_TRANS, PSTR("usbFunctionRead len=%i tx_remaining=%i \n"), len, usb_trans.tx_remaining);
+
+    for (i = 0; i < len; i++) {
+        *data =  usb_trans.tx_buffer[len];
+        data++;
+    }
+    return len;
+}

avr/usbload/usb_bulk.h

@@ -0,0 +1,29 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+ 
+#ifndef __USB_BULK_H__
+#define __USB_BULK_H__
+
+
+uint8_t usbFunctionWrite(uint8_t * data, uint8_t len);
+uint8_t usbFunctionRead(uint8_t * data, uint8_t len);
+
+#endif

avr/usbload/usbconfig.h

@@ -1,3 +1,25 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+
 /* Name: usbconfig.h
  * Project: V-USB, virtual USB port for Atmel's(r) AVR(r) microcontrollers
  * Author: Christian Starkjohann
@@ -56,13 +78,13 @@ section at the end of this file).
 
 /* ----------------------- Optional Hardware Config ------------------------ */
 
-/* #define USB_CFG_PULLUP_IOPORTNAME   D */
+//#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 */
+//#define USB_CFG_PULLUP_BIT          6 
 /* 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.
@@ -97,7 +119,7 @@ section at the end of this file).
  * 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 USB_CFG_SUPPRESS_INTR_CODE      1
 /* 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
@@ -105,7 +127,7 @@ section at the end of this file).
  * (e.g. HID), but never want to send any data. This option saves a couple
  * of bytes in flash memory and the transmit buffers in RAM.
  */
-#define USB_CFG_INTR_POLL_INTERVAL      10
+#define USB_CFG_INTR_POLL_INTERVAL      20
 /* 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.
@@ -114,12 +136,12 @@ section at the end of this file).
 /* 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           40
+#define USB_CFG_MAX_BUS_POWER           300
 /* Set this variable to the maximum USB bus power consumption of your device.
  * The value is in milliamperes. [It will be divided by two since USB
  * communicates power requirements in units of 2 mA.]
  */
-#define USB_CFG_IMPLEMENT_FN_WRITE      0
+#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.
@@ -206,7 +228,7 @@ section at the end of this file).
  * 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!
  */
-#define  USB_CFG_DEVICE_ID       0xdc, 0x05
+#define  USB_CFG_DEVICE_ID       0xdd, 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
@@ -216,8 +238,8 @@ section at the end of this file).
 #define USB_CFG_DEVICE_VERSION  0x00, 0x01
 /* Version number of the device: Minor number first, then major number.
  */
-#define USB_CFG_VENDOR_NAME     'o', 'b', 'd', 'e', 'v', '.', 'a', 't'
+#define USB_CFG_VENDOR_NAME     'o', 'p', 't', 'i', 'x', 'x', '.', 'o', 'r', 'g'
-#define USB_CFG_VENDOR_NAME_LEN 8
+#define USB_CFG_VENDOR_NAME_LEN 10
 /* 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.
@@ -226,7 +248,7 @@ section at the end of this file).
  * obdev's free shared VID/PID pair. See the file USBID-License.txt for
  * details.
  */
-#define USB_CFG_DEVICE_NAME     'L', 'E', 'D', 'C', 'o', 'n', 't', 'r', 'o', 'l'
+#define USB_CFG_DEVICE_NAME     'Q', 'U', 'I', 'C', 'K', 'D', 'E', 'V', '1', '6'
 #define USB_CFG_DEVICE_NAME_LEN 10
 /* 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
@@ -254,7 +276,8 @@ section at the end of this file).
  * 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 USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    0
+ 
 /* 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