godzil/quickdev16
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

indent cleanup

Browse Source
This commit is contained in:
optixx 2010-07-19 16:35:47 +02:00
parent 0f0c6eb409
commit c09d1a1918
38 changed files with 5177 additions and 3112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
avr/usbload/command.c
View File

@ -19,12 +19,12 @@
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
#include "config.h"
#include "requests.h"
#include "requests.h"
#include "sram.h"
#include "info.h"
#include "irq.h"
@ -64,83 +64,90 @@ void boot_startup_rom(uint16_t init_delay)
uint8_t i;
uint32_t addr = 0x000000;
info_P(PSTR("Fetch loader rom\n"));
system_set_bus_avr();
//snes_irq_lo();
//system_snes_irq_off();
// snes_irq_lo();
// system_snes_irq_off();
system_set_rom_lorom();
//info_P(PSTR("Activate AVR bus\n"));
//avr_bus_active();
//info_P(PSTR("IRQ off\n"));
//snes_irq_lo();
//snes_irq_off();
//snes_lorom();
for (i=0; i<ROM_BUFFER_CNT; i++){
// info_P(PSTR("Activate AVR bus\n"));
// avr_bus_active();
// info_P(PSTR("IRQ off\n"));
// snes_irq_lo();
// snes_irq_off();
// snes_lorom();
for (i = 0; i < ROM_BUFFER_CNT; i++) {
addr += rle_decode(_rom[i], _rom_size[i], addr);
}
info_P(PSTR("\n"));
#if DO_CRC_CHECK_LOADER
#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);
crc = crc_check_bulk_memory((uint32_t) 0x000000, 0x010000, 0x010000);
info(PSTR("crc=%x\n"), crc);
#endif
//snes_irq_lo();
//snes_irq_off();
//snes_hirom();
//snes_wr_disable();
// snes_irq_lo();
// snes_irq_off();
// snes_hirom();
// snes_wr_disable();
//system_set_bus_snes();
//system_set_rom_hirom();
//system_set_wr_disable();
//system_snes_irq_off();
// system_set_bus_snes();
// system_set_rom_hirom();
// system_set_wr_disable();
// system_snes_irq_off();
snes_irq_lo();
system_snes_irq_off();
system_set_rom_hirom();
system_set_wr_disable();
system_set_bus_snes();
system_send_snes_reset();
info_P(PSTR("Move Loader to wram"));
for (i=0;i<30;i++){
for (i = 0; i < 30; i++) {
_delay_ms(20);
info_P(PSTR("."));
}
info_P(PSTR("\n"));
}
void banner(){
void banner()
{
uint8_t i;
for (i=0;i<40;i++)
for (i = 0; i < 40; i++)
info_P(PSTR("\n"));
info_P(PSTR(" ________ .__ __ ________ ____ ________\n"));
info_P(PSTR(" \\_____ \\ __ __|__| ____ | | __\\______ \\ _______ _/_ |/ _____/\n"));
info_P(PSTR(" / / \\ \\| | \\ |/ ___\\| |/ / | | \\_/ __ \\ \\/ /| / __ \\ \n"));
info_P(PSTR(" / \\_/. \\ | / \\ \\___| < | ` \\ ___/\\ / | \\ |__\\ \\ \n"));
info_P(PSTR(" \\_____\\ \\_/____/|__|\\___ >__|_ \\/_______ /\\___ >\\_/ |___|\\_____ / \n"));
info_P(PSTR(" \\__> \\/ \\/ \\/ \\/ \\/ \n"));
info_P(PSTR
(" ________ .__ __ ________ ____ ________\n"));
info_P(PSTR
(" \\_____ \\ __ __|__| ____ | | __\\______ \\ _______ _/_ |/ _____/\n"));
info_P(PSTR
(" / / \\ \\| | \\ |/ ___\\| |/ / | | \\_/ __ \\ \\/ /| / __ \\ \n"));
info_P(PSTR
(" / \\_/. \\ | / \\ \\___| < | ` \\ ___/\\ / | \\ |__\\ \\ \n"));
info_P(PSTR
(" \\_____\\ \\_/____/|__|\\___ >__|_ \\/_______ /\\___ >\\_/ |___|\\_____ / \n"));
info_P(PSTR
(" \\__> \\/ \\/ \\/ \\/ \\/ \n"));
info_P(PSTR("\n"));
info_P(PSTR(" www.optixx.org\n"));
info_P(PSTR("\n"));
info_P(PSTR("System Hw: %s Sw: %s\n"),HW_VERSION,SW_VERSION);
info_P(PSTR("System Hw: %s Sw: %s\n"), HW_VERSION, SW_VERSION);
}
void transaction_status(){
info_P(PSTR("\nAddr 0x%06lx\n"),usb_trans.req_addr);
info_P(PSTR("Bank 0x%02x\n"),usb_trans.req_bank);
info_P(PSTR("Banksize 0x%06lx\n"),usb_trans.req_bank_size);
info_P(PSTR("Bankcount 0x%02x\n"),usb_trans.req_bank_cnt);
info_P(PSTR("Status 0x%02x\n"),usb_trans.req_state);
info_P(PSTR("Percent %02i\n"),usb_trans.req_percent);
info_P(PSTR("TX buffer %02i\n"),usb_trans.tx_remaining);
info_P(PSTR("RX buffer %02i\n"),usb_trans.rx_remaining);
info_P(PSTR("Syncerr %02i\n"),usb_trans.sync_errors);
void transaction_status()
{
info_P(PSTR("\nAddr 0x%06lx\n"), usb_trans.req_addr);
info_P(PSTR("Bank 0x%02x\n"), usb_trans.req_bank);
info_P(PSTR("Banksize 0x%06lx\n"), usb_trans.req_bank_size);
info_P(PSTR("Bankcount 0x%02x\n"), usb_trans.req_bank_cnt);
info_P(PSTR("Status 0x%02x\n"), usb_trans.req_state);
info_P(PSTR("Percent %02i\n"), usb_trans.req_percent);
info_P(PSTR("TX buffer %02i\n"), usb_trans.tx_remaining);
info_P(PSTR("RX buffer %02i\n"), usb_trans.rx_remaining);
info_P(PSTR("Syncerr %02i\n"), usb_trans.sync_errors);
}

2
avr/usbload/config.h
View File

@ -55,4 +55,4 @@
#define DO_TIMER 0
#define DO_SHELL 1
#endif
#endif

31
avr/usbload/crc.c
View File

@ -50,7 +50,7 @@ uint16_t do_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;
}
@ -65,19 +65,24 @@ uint16_t do_crc_update(uint16_t crc, uint8_t * data, uint16_t size)
}
uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t top_addr, uint32_t bank_size)
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);
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);
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;
}
@ -85,8 +90,10 @@ uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t top_addr, uint32_t
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);
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;
}
@ -94,11 +101,13 @@ uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t top_addr, uint32_t
uint16_t crc_check_memory_range(uint32_t start_addr, uint32_t size,uint8_t *buffer)
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) {
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);
}

12
avr/usbload/crc.h
View File

@ -23,13 +23,15 @@
#define __CRC_H__
#include <stdlib.h>
#include <stdint.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);
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

23
avr/usbload/debug.c
View File

@ -28,11 +28,12 @@
extern FILE uart_stdout;
extern int debug_level; /* the higher, the more messages... */
extern int debug_level; /* the higher, the more messages... */
#if defined(NO_DEBUG) && defined(__GNUC__)
#else
void debug(int level, char* format, ...) {
void debug(int level, char *format, ...)
{
#ifdef NO_DEBUG
#else
@ -42,28 +43,28 @@ void debug(int level, char* format, ...) {
va_start(args, format);
vprintf(format, args);
va_end(args);
#endif
#endif
}
#endif
#endif
#ifndef NO_INFO
uint8_t buffer_debug[FORMAT_BUFFER_LEN];
uint8_t buffer_debug[FORMAT_BUFFER_LEN];
#endif
#if defined(NO_DEBUG) && defined(__GNUC__)
#else
void debug_P(int level, PGM_P format, ...) {
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);
strlcpy_P((char *) buffer_debug, format, FORMAT_BUFFER_LEN);
va_start(args, format);
vprintf((char*)buffer_debug, args);
vprintf((char *) buffer_debug, args);
va_end(args);
#endif
}
#endif
#endif

23
avr/usbload/debug.h
View File

@ -29,27 +29,30 @@
#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. */
/*
* 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 */
/*
* 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. */
/*
* 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 */
/*
* print a message, if it is considered significant enough. Adapted from [K&R2], p. 174
*/
#endif
#endif /* DEBUG_H */
#endif /* DEBUG_H */

6
avr/usbload/dump.c
View File

@ -33,7 +33,7 @@ extern FILE uart_stdout;
void dump_packet(uint32_t addr, uint32_t len, uint8_t * packet)
{
uint16_t i,j;
uint16_t i, j;
uint16_t sum = 0;
uint8_t clear = 0;
@ -71,8 +71,8 @@ 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)
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();

5
avr/usbload/dump.h
View File

@ -28,7 +28,6 @@
void dump_memory(uint32_t bottom_addr, uint32_t top_addr);
void dump_packet(uint32_t addr,uint32_t len,uint8_t *packet);
#endif
void dump_packet(uint32_t addr, uint32_t len, uint8_t * packet);
#endif

17
avr/usbload/info.c
View File

@ -37,7 +37,8 @@ extern FILE uart_stdout;
#define info(format, args...) ((void)0)
#else
void info(char* format, ...) {
void info(char *format, ...)
{
#ifdef NO_INFO
#else
@ -45,13 +46,13 @@ void info(char* format, ...) {
va_start(args, format);
vprintf(format, args);
va_end(args);
#endif
#endif
}
#endif
#endif
#ifndef NO_INFO
uint8_t buffer_info[FORMAT_BUFFER_LEN];
uint8_t buffer_info[FORMAT_BUFFER_LEN];
#endif
#if defined(NO_INFO) && defined(__GNUC__)
@ -59,16 +60,16 @@ void info(char* format, ...) {
#define info(format, args...) ((void)0)
#else
void info_P(PGM_P format, ...) {
void info_P(PGM_P format, ...)
{
#ifdef NO_INFO
#else
strlcpy_P((char*)buffer_info,format,FORMAT_BUFFER_LEN);
strlcpy_P((char *) buffer_info, format, FORMAT_BUFFER_LEN);
va_list args;
va_start(args, format);
vprintf((char*)buffer_info, args);
vprintf((char *) buffer_info, args);
va_end(args);
#endif
}
#endif

22
avr/usbload/info.h
View File

@ -29,25 +29,29 @@
#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. */
/*
* 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 */
/*
* 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. */
/*
* 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 */
/*
* print a message, if it is considered significant enough. Adapted from [K&R2], p. 174
*/
#endif
#endif
#endif

32
avr/usbload/irq.c
View File

@ -29,31 +29,32 @@
#include "usbdrv.h"
#include "oddebug.h" /* This is also an example for using debug
* macros */
#include "debug.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(){
void irq_init()
{
cli();
PCMSK3 |=(1<<PCINT27);
PCICR |= (1<<PCIE3);
PCMSK3 |= (1 << PCINT27);
PCICR |= (1 << PCIE3);
sei();
system.reset_irq = RESET_IRQ_ON;
}
}
void irq_stop(){
void irq_stop()
{
cli();
PCMSK3 &=~(1<<PCINT27);
PCMSK3 &= ~(1 << PCINT27);
sei();
system.reset_irq = RESET_IRQ_OFF;
}
}
void leave_application(void)
{
@ -65,12 +66,11 @@ void leave_application(void)
}
ISR (SIG_PIN_CHANGE3)
ISR(SIG_PIN_CHANGE3)
{
if (snes_reset_test()){
if (snes_reset_test()) {
info_P(PSTR("Catch SNES reset button\n"));
info_P(PSTR("Set watchdog...\n"));
leave_application();
}
}
}

5846
avr/usbload/loader.c
View File

File diff suppressed because it is too large Load Diff

5
avr/usbload/loader.h
View File

@ -1,7 +1,6 @@
/*
File: qd16boot01.smc
Time: Fri, 30 Oct 2009 16:49:11
*/
* File: qd16boot01.smc Time: Fri, 30 Oct 2009 16:49:11
*/
#ifndef __FIFO_H__
#define __FIFO_H__

130
avr/usbload/main.c
View File

@ -21,17 +21,17 @@
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <string.h>
#include "usbdrv.h"
#include "oddebug.h"
#include "oddebug.h"
#include "config.h"
#include "requests.h"
#include "requests.h"
#include "uart.h"
#include "sram.h"
#include "debug.h"
@ -51,7 +51,7 @@
#include "shell.h"
#include "system.h"
#ifndef NO_DEBUG
#ifndef NO_DEBUG
extern FILE uart_stdout;
#endif
extern system_t system;
@ -70,27 +70,31 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
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);
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_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);
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);
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
#ifndef NO_DEBUG
timer_start();
#endif
#endif
}
#endif
#endif
/*
* -------------------------------------------------------------------------
*/
@ -102,21 +106,24 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
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 (usb_trans.req_addr
&& usb_trans.req_addr % usb_trans.req_bank_size == 0) {
#if DO_TIMER
#ifndef NO_DEBUG
#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());
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());
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();
timer_start();
#endif
#endif
usb_trans.req_bank++;
@ -137,31 +144,37 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
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 =
(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) {
#endif
if (usb_trans.req_addr
&& (usb_trans.req_addr % usb_trans.req_bank_size) == 0) {
#if DO_TIMER
#ifndef NO_DEBUG
#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());
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());
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();
timer_start();
#endif
#endif
usb_trans.req_bank++;
#if DO_SHM
shared_memory_write(SHARED_MEM_TX_CMD_BANK_CURRENT, usb_trans.req_bank);
shared_memory_write(SHARED_MEM_TX_CMD_BANK_CURRENT,
usb_trans.req_bank);
#endif
}
ret_len = USB_MAX_TRANS;
@ -184,8 +197,10 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
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);
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;
/*
* -------------------------------------------------------------------------
@ -194,7 +209,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
usb_trans.req_state = REQ_STATUS_SNES;
debug_P(DEBUG_USB, PSTR("USB_MODE_SNES:\n"));
ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
@ -218,7 +233,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
ret_len = 0;
}
usbMsgPtr = usb_trans.rx_buffer;
return ret_len;
return ret_len;
}
/*
@ -226,9 +241,10 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
*/
void globals_init(){
memset(&usb_trans,0,sizeof(usb_transaction_t));
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;
@ -240,8 +256,8 @@ void globals_init(){
int main(void)
{
#ifndef NO_DEBUG
#ifndef NO_DEBUG
uart_init();
stdout = &uart_stdout;
banner();
@ -263,12 +279,12 @@ int main(void)
while (usb_trans.req_state != REQ_STATUS_SNES) {
usbPoll();
#if DO_SHELL
#ifndef NO_DEBUG
#ifndef NO_DEBUG
shell_run();
#endif
#endif
#endif
#endif
}
#if DO_SHM
shared_memory_write(SHARED_MEM_TX_CMD_TERMINATE, 0);
#endif
@ -278,11 +294,13 @@ int main(void)
shared_memory_scratchpad_region_rx_restore();
#endif
#if DO_CRC_CHECK
#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
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();
@ -291,15 +309,15 @@ int main(void)
while ((usb_trans.req_state != REQ_STATUS_AVR)) {
usbPoll();
#if DO_SHELL
#ifndef NO_DEBUG
#ifndef NO_DEBUG
shell_run();
#endif
#endif
#endif
#endif
}
info_P(PSTR("-->Switch TO AVR\n"));
shared_memory_init();
irq_init();
if(usb_trans.loader_enabled) {
if (usb_trans.loader_enabled) {
boot_startup_rom(50);
} else {
system_set_bus_avr();

82
avr/usbload/pwm.c
View File

@ -31,32 +31,37 @@
#define PWM_SINE_MAX 64
#define PWM_OVERFLOW_MAX 1024
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
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)
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;
if (pwm_cnt == (uint8_t) (PWM_STEPS - 1))
pwm_cnt = 0;
else
pwm_cnt++;
if (pwm_overflow_max == pwm_overflow++ ){
if (pwm_overflow_max == pwm_overflow++) {
pwm_setting = pwm_sine_table[pwm_idx++];
pwm_overflow = 0;
if (PWM_SINE_MAX == pwm_idx)
@ -64,38 +69,45 @@ volatile uint16_t pwm_overflow_max;
}
}
void pwm_speed(uint16_t val) {
pwm_overflow_max = val;
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_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_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_speed_normal(uint16_t val)
{
pwm_overflow_max = PWM_OVERFLOW_MAX;
}
void pwm_set(uint8_t val) {
void pwm_set(uint8_t val)
{
pwm_setting = val;
}
void pwm_stop(void) {
while(pwm_setting!=0xfd);
void pwm_stop(void)
{
while (pwm_setting != 0xfd);
TIMSK2 = 0;
}
void pwm_init(void) {
void pwm_init(void)
{
pwm_overflow_max = PWM_OVERFLOW_MAX;
pwm_setting = 0x7f;
pwm_overflow = 0;
//cli();
TCCR2B = 1;
TIMSK2 |= (1<<OCIE2A);
sei();
// cli();
TCCR2B = 1;
TIMSK2 |= (1 << OCIE2A);
sei();
}

16
avr/usbload/pwm.h
View File

@ -21,17 +21,17 @@
#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 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
#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_init(void);
void pwm_stop(void);
#endif

4
avr/usbload/requests.h
View File

@ -50,11 +50,11 @@ typedef struct usb_transaction_t {
uint8_t req_percent_last;
uint8_t req_state;
uint8_t rx_remaining;
uint8_t tx_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__ */
#endif /* __REQUESTS_H_INCLUDED__ */

216
avr/usbload/shared_memory.c
View File

@ -48,29 +48,39 @@ uint8_t scratchpad_locked_rx = 1;
uint8_t scratchpad_locked_tx = 1;
void shared_memory_init(void){
void shared_memory_init(void)
{
scratchpad_locked_rx = 1;
scratchpad_locked_tx = 1;
}
uint8_t shared_memory_scratchpad_region_save_helper(uint32_t addr){
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);
#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);
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
#endif
return 1;
}
@ -79,56 +89,70 @@ void shared_memory_scratchpad_region_tx_save()
{
sram_bulk_addr_save();
#if SHARED_SCRATCHPAD_CRC
#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);
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);
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);
#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);
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
#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);
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);
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);
#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);
#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();
@ -138,29 +162,39 @@ 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"));
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);
#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);
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);
#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
#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);
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
}
@ -169,31 +203,41 @@ 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);
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);
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);
#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);
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
}
@ -230,21 +274,22 @@ void shared_memory_irq_restore()
void shared_memory_write(uint8_t cmd, uint8_t value)
{
#if DO_SHM
#if DO_SHM_SCRATCHPAD
if (scratchpad_locked_tx){
#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);
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)
#if (DO_SHM_SCRATCHPAD==0)
shared_memory_scratchpad_tx_save();
#endif
#if SHARED_MEM_SWITCH_IRQ
#if SHARED_MEM_SWITCH_IRQ
shared_memory_irq_hook();
#endif
@ -256,7 +301,7 @@ void shared_memory_write(uint8_t cmd, uint8_t value)
snes_wr_disable();
snes_bus_active();
#if SHARED_MEM_SWITCH_IRQ
#if SHARED_MEM_SWITCH_IRQ
snes_irq_on();
snes_irq_lo();
_delay_us(20);
@ -272,10 +317,10 @@ void shared_memory_write(uint8_t cmd, uint8_t value)
snes_lorom();
snes_wr_disable();
#if (DO_SHM_SCRATCHPAD==0)
#if (DO_SHM_SCRATCHPAD==0)
shared_memory_scratchpad_tx_restore();
#endif
#if SHARED_MEM_SWITCH_IRQ
#if SHARED_MEM_SWITCH_IRQ
shared_memory_irq_restore();
#endif
sram_bulk_addr_restore();
@ -296,12 +341,12 @@ void shared_memory_yield()
}
int shared_memory_read(uint8_t *cmd, uint8_t *len,uint8_t *buffer)
int shared_memory_read(uint8_t * cmd, uint8_t * len, uint8_t * buffer)
{
//uint8_t state;
// uint8_t state;
#if DO_SHM
#if DO_SHM_SCRATCHPAD
if (scratchpad_locked_rx){
#if DO_SHM_SCRATCHPAD
if (scratchpad_locked_rx) {
debug_P(DEBUG_SHM, PSTR("shared_memory_write: locked_tx\n"));
return 1;
}
@ -309,24 +354,25 @@ int shared_memory_read(uint8_t *cmd, uint8_t *len,uint8_t *buffer)
sram_bulk_addr_save();
state = sram_read(SHARED_MEM_RX_LOC_STATE);
if (state != SHARED_MEM_RX_AVR_ACK){
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);
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_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
#if SHARED_MEM_SWITCH_IRQ
snes_irq_on();
snes_irq_lo();
_delay_us(20);

8
avr/usbload/shared_memory.h
View File

@ -56,13 +56,15 @@
#define SHARED_IRQ_LOC_LO 0x00fffe
#define SHARED_IRQ_LOC_HI 0x00ffff
/* Use COP IRQ LOC for hooked IRQ handler */
/*
* 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);
@ -71,6 +73,6 @@ 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);
int shared_memory_read(uint8_t * cmd, uint8_t * len, uint8_t * buffer);
#endif

556
avr/usbload/shell.c
View File

@ -22,8 +22,8 @@
#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
@ -41,7 +41,7 @@
#include "shared_memory.h"
#include "system.h"
extern system_t system;
const char STR_ROM[] PROGMEM = "Rom";
@ -52,10 +52,10 @@ const char STR_SA[] PROGMEM = "SA-1";
uint8_t command_buf[RECEIVE_BUF_LEN];
uint8_t recv_buf[RECEIVE_BUF_LEN];
uint8_t recv_buf[RECEIVE_BUF_LEN];
volatile uint8_t recv_counter = 0;
volatile uint8_t cr = 0;
volatile uint8_t recv_counter = 0;
volatile uint8_t cr = 0;
uint8_t *token_ptr;
@ -63,319 +63,326 @@ uint8_t *token_ptr;
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 *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)
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);
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 get_hex_arg3(uint32_t *hexval1, uint32_t *hexval2, uint32_t *hexval3)
uint8_t parse_hex(const uint8_t * s, uint32_t * hexval)
{
return get_hex(hexval1) && get_hex(hexval2) && get_hex(hexval3);
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);
}
#if 0
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;
}
}
#endif
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)
static uint8_t get_int32(uint32_t * val)
{
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--;
if (!get_hex(val)) {
info_P(PSTR("Invalid argument!\n"));
return 0;
} else {
recv_counter++;
return 1;
}
}
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
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;
}
}
#endif
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"},
};
{"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;
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]);
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;
uint8_t *t;
uint32_t arg1;
uint32_t arg2;
uint16_t crc;
uint16_t crc;
uint16_t offset;
uint8_t c;
if (!cr)
if (!cr)
return;
cr=0;
strcpy((char*)command_buf, (char*)recv_buf);
token_ptr = command_buf;
t = get_token();
if (t == NULL)
cr = 0;
strcpy((char *) command_buf, (char *) recv_buf);
token_ptr = command_buf;
t = get_token();
if (t == NULL)
shell_help();
util_strupper(t);
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
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
} 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) {
} 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) {
} 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) {
} 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) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_AVR]) == 0) {
system_set_bus_avr();
snes_irq_lo();
system_snes_irq_off();
}else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_SNES]) == 0) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_SNES]) == 0) {
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) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_LOROM]) == 0) {
system_set_rom_lorom();
system_set_wr_disable();
}else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_HIROM]) == 0) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_HIROM]) == 0) {
system_set_rom_hirom();
system_set_wr_disable();
}else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_WR]) == 0) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_WR]) == 0) {
arg1 = get_bool();
if(arg1==1){
if (arg1 == 1) {
info_P(PSTR("Set WR enable"));
snes_wr_enable();
}else if (arg1==0){
} 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) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_RESETSNIFF]) == 0) {
arg1 = get_bool();
if(arg1==1){
if (arg1 == 1) {
info_P(PSTR("Start Reset sniffer"));
irq_init();
}else if (arg1==0){
} else if (arg1 == 0) {
info_P(PSTR("Stop Reset sniffer"));
irq_stop();
}
}else if (strcmp_P((char*)t, (PGM_P)cmdlist[CMD_DUMPVEC]) == 0) {
} else if (strcmp_P((char *) t, (PGM_P) cmdlist[CMD_DUMPVEC]) == 0) {
uint16_t offset;
if (system.rom_mode==LOROM)
if (system.rom_mode == LOROM)
offset = 0x8000;
else
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)
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
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.
*/
/*
* # $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++){
for (arg1 = (0xffc0 - offset); arg1 < (0xffc0 - offset + 21); arg1++) {
c = sram_read(arg1);
if (c>0x1f && c<0x7f)
printf("%c",c);
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){
switch (c) {
case 0x20:
info_P(PSTR("LoROM, not fast\n"));
break;
@ -389,13 +396,13 @@ void shell_run(void)
info_P(PSTR("HiRom, fast\n"));
break;
default:
info_P(PSTR("Unkown 0x%02x\n"),c);
info_P(PSTR("Unkown 0x%02x\n"), c);
break;
}
c = sram_read(0xffd6 - offset);
info_P(PSTR("TYPE 0x%04xc"), (0xffd6 - offset),c);
switch(c){
info_P(PSTR("TYPE 0x%04xc"), (0xffd6 - offset), c);
switch (c) {
case 0x00:
info_P(PSTR("Rom\n"));
break;
@ -424,53 +431,58 @@ void shell_run(void)
info_P(PSTR("SA-1"));
break;
default:
info_P(PSTR("Unkown 0x%02x\n"),c);
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 ));
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 )
if (c == 0x00 || c == 0x01 || 0x0d)
info_P(PSTR("NTSC\n"));
else if (c>=0x02 || c<=0x0c )
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("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) {
} 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) {
} 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) {
} 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) {
} 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();
}

2
avr/usbload/shell.h
View File

@ -21,6 +21,6 @@
#ifndef __SHELL_H__
#define __SHELL_H__
void shell_run(void);
void shell_run(void);
#endif

189
avr/usbload/sram.c
View File

@ -37,70 +37,70 @@ 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));
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("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);
AVR_ADDR_SER_PORT |= (1 << AVR_ADDR_SER_PIN);
} else {
AVR_ADDR_SER_PORT &= ~( 1 << AVR_ADDR_SER_PIN);
AVR_ADDR_SER_PORT &= ~(1 << AVR_ADDR_SER_PIN);
debug_P(DEBUG_SREG, PSTR("0"));
}
AVR_ADDR_SCK_PORT |= (1 << AVR_ADDR_SCK_PIN);
@ -109,20 +109,22 @@ void sreg_set(uint32_t addr)
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()
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);
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);
debug_P(DEBUG_SRAM, PSTR("sram_bulk_addr_restore: addr=0x%08lx\n\r"),
addr_stash);
sram_bulk_write_start(addr_stash);
}
@ -148,8 +150,8 @@ void sram_bulk_read_start(uint32_t addr)
asm volatile ("nop");
asm volatile ("nop");
asm volatile ("nop");
}
}
inline void sram_bulk_read_next(void)
{
@ -186,39 +188,40 @@ 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){
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 );
uint8_t lo = sram_read(addr + 1);
return (hi << 8 | lo);
}
void sram_bulk_write_start(uint32_t addr)
@ -242,7 +245,7 @@ inline void sram_bulk_write_next(void)
counter_up();
}
inline void sram_bulk_write( uint8_t data)
inline void sram_bulk_write(uint8_t data)
{
AVR_WR_PORT &= ~(1 << AVR_WR_PIN);
AVR_DATA_PORT = data;
@ -260,22 +263,23 @@ void sram_bulk_write_end(void)
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);
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");
@ -284,7 +288,7 @@ void sram_write(uint32_t addr, uint8_t data)
asm volatile ("nop");
asm volatile ("nop");
AVR_CS_PORT |= (1 << AVR_CS_PIN);
avr_data_in();
}
@ -294,13 +298,15 @@ 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);
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++){
for (i = addr; i < (addr + len); i++) {
sram_bulk_write(*ptr);
//hack
if ((i+1) < (addr + len))
// hack
if ((i + 1) < (addr + len))
sram_bulk_write_next();
ptr++;
}
@ -311,9 +317,11 @@ 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);
// 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();
@ -322,9 +330,11 @@ void sram_bulk_copy_into_buffer(uint32_t addr, uint8_t * dst, uint32_t len)
sram_bulk_read_end();
}
void sram_bulk_set(uint32_t addr, uint32_t len,uint8_t value){
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);
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)
@ -334,4 +344,3 @@ void sram_bulk_set(uint32_t addr, uint32_t len,uint8_t value){
}
sram_bulk_write_end();
}

20
avr/usbload/sram.h
View File

@ -24,12 +24,14 @@
#define __SRAM_H__
#include <stdlib.h>
#include <stdint.h>
#include <stdint.h>
#include <avr/io.h>
/* ---------------------------- PORT A ---------------------------- */
/*
* ---------------------------- PORT A ----------------------------
*/
#define AVR_DATA_PORT PORTA
#define AVR_DATA_DIR DDRA
@ -41,7 +43,9 @@
#define avr_data_out() (AVR_DATA_DIR = 0xff)
/* ---------------------------- PORT B ---------------------------- */
/*
* ---------------------------- PORT B ----------------------------
*/
#define AVR_PORT PORTB
#define AVR_DIR DDRB
@ -78,7 +82,9 @@
#define snes_irq_lo() (SNES_IRQ_PORT &= ~(1 << SNES_IRQ_PIN))
/* ---------------------------- PORT C ---------------------------- */
/*
* ---------------------------- PORT C ----------------------------
*/
#define AVR_ADDR_PORT PORTC
#define AVR_ADDR_DIR DDRC
@ -140,7 +146,9 @@
#define led_pwm_on() (LED_DIR &=~ (1 << LED_PIN))
#define led_pwm_off() (LED_DIR |= (1 << LED_PIN))
/* ---------------------------- PORT D ---------------------------- */
/*
* ---------------------------- PORT D ----------------------------
*/
#define AVR_SNES_PORT PORTD
#define AVR_SNES_DIR DDRD
@ -216,7 +224,7 @@ 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);
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();

59
avr/usbload/system.c
View File

@ -23,7 +23,7 @@
#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h> /* for _delay_ms() */
#include <avr/interrupt.h>
#include <avr/interrupt.h>
#include "config.h"
@ -62,7 +62,7 @@ void system_init(void)
system.reset_irq = RESET_IRQ_OFF;
}
}
void system_send_snes_reset()
{
@ -87,13 +87,13 @@ void system_send_snes_irq()
}
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;
}
@ -106,13 +106,15 @@ void system_set_bus_avr()
system.bus_mode = MODE_AVR;
}
void system_set_wr_disable(){
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(){
void system_set_wr_enable()
{
snes_wr_enable();
system.wr_line = WR_ENABLE;
info_P(PSTR("Enable SNES WR\n"));
@ -125,7 +127,7 @@ void system_set_bus_snes()
info_P(PSTR("Activate SNES bus\n"));
}
void system_set_rom_mode(usb_transaction_t *usb_trans)
void system_set_rom_mode(usb_transaction_t * usb_trans)
{
if (usb_trans->req_bank_size == 0x8000) {
snes_lorom();
@ -153,34 +155,39 @@ void system_set_rom_hirom()
info_P(PSTR("Set SNES hirom \n"));
}
char* system_status_helper(uint8_t val){
if (val)
return "ON";
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";
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";
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);
}
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);
}

12
avr/usbload/system.h
View File

@ -28,12 +28,12 @@
typedef struct system_t {
enum bus_mode_e { MODE_AVR, MODE_SNES } bus_mode;
enum rom_mode_e { LOROM, HIROM } rom_mode;
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;
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;
@ -45,7 +45,7 @@ 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_mode(usb_transaction_t * usb_trans);
void system_set_rom_hirom(void);
void system_set_rom_lorom(void);
void system_snes_irq_off(void);

26
avr/usbload/testing.c
View File

@ -93,29 +93,36 @@ void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr)
}
void test_memory_pattern(uint32_t bottom_addr, uint32_t top_addr, uint32_t bank_size)
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);
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){
if (addr % bank_size == 0) {
pattern++;
info_P(PSTR("test_memory_pattern: write addr=0x%08lx pattern=0x%08lx\n"), addr, 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"));
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);
crc_check_bulk_memory((uint32_t) bottom_addr, top_addr, bank_size);
}
void test_crc()
@ -128,4 +135,3 @@ void test_crc()
info_P(PSTR("test_crc: check\n"));
test_non_zero_memory(0x000000, 0x10000);
}

2
avr/usbload/testing.h
View File

@ -27,5 +27,5 @@ 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

81
avr/usbload/timer.c
View File

@ -23,72 +23,69 @@
#include <stdint.h>
#include <stdio.h>
#include <avr/io.h>
#include <avr/io.h>
#include <avr/io.h>
#include <avr/interrupt.h> /* for sei() */
#include "debug.h"
#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
#define OCR1A OCR1 // 2313 support
#endif
//#define XTAL 11059201L // nominal value
#define XTAL 20000000UL
#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)
uint16_t volatile second; // count seconds
ISR(SIG_OUTPUT_COMPARE1A)
{
#if XTAL % DEBOUNCE // bei rest
OCR1A = 20000000UL / DEBOUNCE - 1; // compare DEBOUNCE - 1 times
#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
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 )
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();
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;
uint16_t t = ((DEBOUNCE - prescaler) / DEBOUNCE) + second;
return t;
}

14
avr/usbload/timer.h
View File

@ -17,13 +17,13 @@
*
* =====================================================================================
*/
#ifndef __TIMER_H__
#define __TIMER_H__
int16_t timer_start( void );
double timer_stop( void );
int16_t timer_stop_int( void );
#ifndef __TIMER_H__
#define __TIMER_H__
int16_t timer_start(void);
double timer_stop(void);
int16_t timer_stop_int(void);
#endif

21
avr/usbload/uart.c
View File

@ -38,31 +38,22 @@ volatile char rxbuff;
static int uart_stream(char c, FILE *stream);
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;
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;
}
}
*/
* 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)
{

3
avr/usbload/uart.h
View File

@ -34,6 +34,3 @@ void uart_puts(const char *s);
void uart_puts_P(PGM_P s);
#endif

33
avr/usbload/usb_bulk.c
View File

@ -27,8 +27,7 @@
#include <stdlib.h>
#include "usbdrv.h"
#include "oddebug.h" /* This is also an example for using debug
* macros */
#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"
@ -45,21 +44,24 @@ extern usb_transaction_t usb_trans;
uint8_t usbFunctionWrite(uint8_t * data, uint8_t len)
{
uint8_t *ptr;
uint8_t i;
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;
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);
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--){
while (i--) {
sram_bulk_write(*ptr++);
sram_bulk_write_next();
}
@ -70,13 +72,14 @@ uint8_t usbFunctionWrite(uint8_t * data, uint8_t 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);
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 = usb_trans.tx_buffer[len];
data++;
}
return len;

2
avr/usbload/usb_bulk.h
View File

@ -18,7 +18,7 @@
* =====================================================================================
*/
#ifndef __USB_BULK_H__
#define __USB_BULK_H__

483
avr/usbload/usbconfig.h
View File

@ -20,326 +20,288 @@
/* Name: usbconfig.h
* Project: V-USB, virtual USB port for Atmel's(r) AVR(r) microcontrollers
* Author: Christian Starkjohann
* Creation Date: 2005-04-01
* Tabsize: 4
* Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
* License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
* This Revision: $Id: usbconfig-prototype.h 740 2009-04-13 18:23:31Z cs $
/*
* Name: usbconfig.h Project: V-USB, virtual USB port for Atmel's(r) AVR(r) microcontrollers Author: Christian Starkjohann Creation Date:
* 2005-04-01 Tabsize: 4 Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH License: GNU GPL v2 (see License.txt), GNU GPL v3 or
* proprietary (CommercialLicense.txt) This Revision: $Id: usbconfig-prototype.h 740 2009-04-13 18:23:31Z cs $
*/
#ifndef __usbconfig_h_included__
#define __usbconfig_h_included__
/*
General Description:
This file is an example configuration (with inline documentation) for the USB
driver. It configures V-USB for USB D+ connected to Port D bit 2 (which is
also hardware interrupt 0 on many devices) and USB D- to Port D bit 4. You may
wire the lines to any other port, as long as D+ is also wired to INT0 (or any
other hardware interrupt, as long as it is the highest level interrupt, see
section at the end of this file).
*/
* General Description: This file is an example configuration (with inline documentation) for the USB driver. It configures V-USB for USB
* D+ connected to Port D bit 2 (which is also hardware interrupt 0 on many devices) and USB D- to Port D bit 4. You may wire the lines to
* any other port, as long as D+ is also wired to INT0 (or any other hardware interrupt, as long as it is the highest level interrupt, see
* section at the end of this file).
*/
/* ---------------------------- Hardware Config ---------------------------- */
/*
* ---------------------------- Hardware Config ----------------------------
*/
#define USB_CFG_IOPORTNAME D
/* This is the port where the USB bus is connected. When you configure it to
* "B", the registers PORTB, PINB and DDRB will be used.
/*
* This is the port where the USB bus is connected. When you configure it to "B", the registers PORTB, PINB and DDRB will be used.
*/
#define USB_CFG_DMINUS_BIT 4
/* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected.
* This may be any bit in the port.
/*
* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected. This may be any bit in the port.
*/
#define USB_CFG_DPLUS_BIT 2
/* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected.
* This may be any bit in the port. Please note that D+ must also be connected
* to interrupt pin INT0! [You can also use other interrupts, see section
* "Optional MCU Description" below, or you can connect D- to the interrupt, as
* it is required if you use the USB_COUNT_SOF feature. If you use D- for the
* interrupt, the USB interrupt will also be triggered at Start-Of-Frame
* markers every millisecond.]
/*
* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected. This may be any bit in the port. Please note that D+ must
* also be connected to interrupt pin INT0! [You can also use other interrupts, see section "Optional MCU Description" below, or you can
* connect D- to the interrupt, as it is required if you use the USB_COUNT_SOF feature. If you use D- for the interrupt, the USB interrupt
* will also be triggered at Start-Of-Frame markers every millisecond.]
*/
#define USB_CFG_CLOCK_KHZ (F_CPU/1000)
/* Clock rate of the AVR in kHz. Legal values are 12000, 12800, 15000, 16000,
* 16500 and 20000. The 12.8 MHz and 16.5 MHz versions of the code require no
* crystal, they tolerate +/- 1% deviation from the nominal frequency. All
* other rates require a precision of 2000 ppm and thus a crystal!
* Default if not specified: 12 MHz
/*
* Clock rate of the AVR in kHz. Legal values are 12000, 12800, 15000, 16000, 16500 and 20000. The 12.8 MHz and 16.5 MHz versions of the
* code require no crystal, they tolerate +/- 1% deviation from the nominal frequency. All other rates require a precision of 2000 ppm and
* thus a crystal! Default if not specified: 12 MHz
*/
#define USB_CFG_CHECK_CRC 0
/* Define this to 1 if you want that the driver checks integrity of incoming
* data packets (CRC checks). CRC checks cost quite a bit of code size and are
* currently only available for 18 MHz crystal clock. You must choose
* USB_CFG_CLOCK_KHZ = 18000 if you enable this option.
/*
* Define this to 1 if you want that the driver checks integrity of incoming data packets (CRC checks). CRC checks cost quite a bit of code
* size and are currently only available for 18 MHz crystal clock. You must choose USB_CFG_CLOCK_KHZ = 18000 if you enable this option.
*/
/* ----------------------- Optional Hardware Config ------------------------ */
//#define USB_CFG_PULLUP_IOPORTNAME D
/* If you connect the 1.5k pullup resistor from D- to a port pin instead of
* V+, you can connect and disconnect the device from firmware by calling
* the macros usbDeviceConnect() and usbDeviceDisconnect() (see usbdrv.h).
* This constant defines the port on which the pullup resistor is connected.
*/
//#define USB_CFG_PULLUP_BIT 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.
/*
* ----------------------- Optional Hardware Config ------------------------
*/
/* --------------------------- Functional Range ---------------------------- */
// #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 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.
*/
/*
* --------------------------- Functional Range ----------------------------
*/
#define USB_CFG_HAVE_INTRIN_ENDPOINT 0
/* Define this to 1 if you want to compile a version with two endpoints: The
* default control endpoint 0 and an interrupt-in endpoint (any other endpoint
* number).
/*
* Define this to 1 if you want to compile a version with two endpoints: The default control endpoint 0 and an interrupt-in endpoint (any
* other endpoint number).
*/
#define USB_CFG_HAVE_INTRIN_ENDPOINT3 0
/* Define this to 1 if you want to compile a version with three endpoints: The
* default control endpoint 0, an interrupt-in endpoint 3 (or the number
* configured below) and a catch-all default interrupt-in endpoint as above.
* You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature.
/*
* Define this to 1 if you want to compile a version with three endpoints: The default control endpoint 0, an interrupt-in endpoint 3 (or
* the number configured below) and a catch-all default interrupt-in endpoint as above. You must also define USB_CFG_HAVE_INTRIN_ENDPOINT
* to 1 for this feature.
*/
#define USB_CFG_EP3_NUMBER 3
/* If the so-called endpoint 3 is used, it can now be configured to any other
* endpoint number (except 0) with this macro. Default if undefined is 3.
/*
* If the so-called endpoint 3 is used, it can now be configured to any other endpoint number (except 0) with this macro. Default if
* undefined is 3.
*/
/* #define USB_INITIAL_DATATOKEN USBPID_DATA1 */
/* The above macro defines the startup condition for data toggling on the
* interrupt/bulk endpoints 1 and 3. Defaults to USBPID_DATA1.
* Since the token is toggled BEFORE sending any data, the first packet is
* sent with the oposite value of this configuration!
/*
* #define USB_INITIAL_DATATOKEN USBPID_DATA1
*/
/*
* The above macro defines the startup condition for data toggling on the interrupt/bulk endpoints 1 and 3. Defaults to USBPID_DATA1. Since
* the token is toggled BEFORE sending any data, the first packet is sent with the oposite value of this configuration!
*/
#define USB_CFG_IMPLEMENT_HALT 0
/* Define this to 1 if you also want to implement the ENDPOINT_HALT feature
* for endpoint 1 (interrupt endpoint). Although you may not need this feature,
* it is required by the standard. We have made it a config option because it
* bloats the code considerably.
/*
* Define this to 1 if you also want to implement the ENDPOINT_HALT feature for endpoint 1 (interrupt endpoint). Although you may not need
* this feature, it is required by the standard. We have made it a config option because it bloats the code considerably.
*/
#define USB_CFG_SUPPRESS_INTR_CODE 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
* you need the interrupt-in endpoints in order to comply to an interface
* (e.g. HID), but never want to send any data. This option saves a couple
* of bytes in flash memory and the transmit buffers in RAM.
/*
* Define this to 1 if you want to declare interrupt-in endpoints, but don't want to send any data over them. If this macro is defined to
* 1, functions usbSetInterrupt() and usbSetInterrupt3() are omitted. This is useful if you need the interrupt-in endpoints in order to
* comply to an interface (e.g. HID), but never want to send any data. This option saves a couple of bytes in flash memory and the transmit
* buffers in RAM.
*/
#define USB_CFG_INTR_POLL_INTERVAL 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.
/*
* If you compile a version with endpoint 1 (interrupt-in), this is the poll interval. The value is in milliseconds and must not be less
* than 10 ms for low speed devices.
*/
#define USB_CFG_IS_SELF_POWERED 0
/* Define this to 1 if the device has its own power supply. Set it to 0 if the
* device is powered from the USB bus.
/*
* Define 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 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.]
/*
* Set this variable to the maximum USB bus power consumption of your device. The value is in milliamperes. [It will be divided by two
* since USB communicates power requirements in units of 2 mA.]
*/
#define USB_CFG_IMPLEMENT_FN_WRITE 1
/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
* transfers. Set it to 0 if you don't need it and want to save a couple of
* bytes.
/*
* Set this to 1 if you want usbFunctionWrite() to be called for control-out transfers. Set it to 0 if you don't need it and want to save a
* couple of bytes.
*/
#define USB_CFG_IMPLEMENT_FN_READ 0
/* Set this to 1 if you need to send control replies which are generated
* "on the fly" when usbFunctionRead() is called. If you only want to send
* data from a static buffer, set it to 0 and return the data from
* usbFunctionSetup(). This saves a couple of bytes.
/*
* Set this to 1 if you need to send control replies which are generated "on the fly" when usbFunctionRead() is called. If you only want to
* send data from a static buffer, set it to 0 and return the data from usbFunctionSetup(). This saves a couple of bytes.
*/
#define USB_CFG_IMPLEMENT_FN_WRITEOUT 0
/* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints.
* You must implement the function usbFunctionWriteOut() which receives all
* interrupt/bulk data sent to any endpoint other than 0. The endpoint number
* can be found in 'usbRxToken'.
/*
* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints. You must implement the function usbFunctionWriteOut() which
* receives all interrupt/bulk data sent to any endpoint other than 0. The endpoint number can be found in 'usbRxToken'.
*/
#define USB_CFG_HAVE_FLOWCONTROL 0
/* Define this to 1 if you want flowcontrol over USB data. See the definition
* of the macros usbDisableAllRequests() and usbEnableAllRequests() in
* usbdrv.h.
/*
* Define this to 1 if you want flowcontrol over USB data. See the definition of the macros usbDisableAllRequests() and
* usbEnableAllRequests() in usbdrv.h.
*/
#define USB_CFG_LONG_TRANSFERS 0
/* Define this to 1 if you want to send/receive blocks of more than 254 bytes
* in a single control-in or control-out transfer. Note that the capability
* for long transfers increases the driver size.
/*
* Define this to 1 if you want to send/receive blocks of more than 254 bytes in a single control-in or control-out transfer. Note that the
* capability for long transfers increases the driver size.
*/
/* #define USB_RX_USER_HOOK(data, len) if(usbRxToken == (uchar)USBPID_SETUP) blinkLED(); */
/* This macro is a hook if you want to do unconventional things. If it is
* defined, it's inserted at the beginning of received message processing.
* If you eat the received message and don't want default processing to
* proceed, do a return after doing your things. One possible application
* (besides debugging) is to flash a status LED on each packet.
/*
* #define USB_RX_USER_HOOK(data, len) if(usbRxToken == (uchar)USBPID_SETUP) blinkLED();
*/
/* #define USB_RESET_HOOK(resetStarts) if(!resetStarts){hadUsbReset();} */
/* This macro is a hook if you need to know when an USB RESET occurs. It has
* one parameter which distinguishes between the start of RESET state and its
* end.
/*
* This macro is a hook if you want to do unconventional things. If it is defined, it's inserted at the beginning of received message
* processing. If you eat the received message and don't want default processing to proceed, do a return after doing your things. One
* possible application (besides debugging) is to flash a status LED on each packet.
*/
/* #define USB_SET_ADDRESS_HOOK() hadAddressAssigned(); */
/* This macro (if defined) is executed when a USB SET_ADDRESS request was
* received.
/*
* #define USB_RESET_HOOK(resetStarts) if(!resetStarts){hadUsbReset();}
*/
/*
* This macro is a hook if you need to know when an USB RESET occurs. It has one parameter which distinguishes between the start of RESET
* state and its end.
*/
/*
* #define USB_SET_ADDRESS_HOOK() hadAddressAssigned();
*/
/*
* This macro (if defined) is executed when a USB SET_ADDRESS request was received.
*/
#define USB_COUNT_SOF 0
/* define this macro to 1 if you need the global variable "usbSofCount" which
* counts SOF packets. This feature requires that the hardware interrupt is
* connected to D- instead of D+.
/*
* define this macro to 1 if you need the global variable "usbSofCount" which counts SOF packets. This feature requires that the hardware
* interrupt is connected to D- instead of D+.
*/
/* #ifdef __ASSEMBLER__
* macro myAssemblerMacro
* in YL, TCNT0
* sts timer0Snapshot, YL
* endm
* #endif
* #define USB_SOF_HOOK myAssemblerMacro
* This macro (if defined) is executed in the assembler module when a
* Start Of Frame condition is detected. It is recommended to define it to
* the name of an assembler macro which is defined here as well so that more
* than one assembler instruction can be used. The macro may use the register
* YL and modify SREG. If it lasts longer than a couple of cycles, USB messages
* immediately after an SOF pulse may be lost and must be retried by the host.
* What can you do with this hook? Since the SOF signal occurs exactly every
* 1 ms (unless the host is in sleep mode), you can use it to tune OSCCAL in
* designs running on the internal RC oscillator.
* Please note that Start Of Frame detection works only if D- is wired to the
* interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES!
/*
* #ifdef __ASSEMBLER__ macro myAssemblerMacro in YL, TCNT0 sts timer0Snapshot, YL endm #endif #define USB_SOF_HOOK myAssemblerMacro This
* macro (if defined) is executed in the assembler module when a Start Of Frame condition is detected. It is recommended to define it to
* the name of an assembler macro which is defined here as well so that more than one assembler instruction can be used. The macro may use
* the register YL and modify SREG. If it lasts longer than a couple of cycles, USB messages immediately after an SOF pulse may be lost and
* must be retried by the host. What can you do with this hook? Since the SOF signal occurs exactly every 1 ms (unless the host is in sleep
* mode), you can use it to tune OSCCAL in designs running on the internal RC oscillator. Please note that Start Of Frame detection works
* only if D- is wired to the interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES!
*/
#define USB_CFG_CHECK_DATA_TOGGLING 0
/* define this macro to 1 if you want to filter out duplicate data packets
* sent by the host. Duplicates occur only as a consequence of communication
* errors, when the host does not receive an ACK. Please note that you need to
* implement the filtering yourself in usbFunctionWriteOut() and
* usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable
* for each control- and out-endpoint to check for duplicate packets.
/*
* define this macro to 1 if you want to filter out duplicate data packets sent by the host. Duplicates occur only as a consequence of
* communication errors, when the host does not receive an ACK. Please note that you need to implement the filtering yourself in
* usbFunctionWriteOut() and usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable for each control- and
* out-endpoint to check for duplicate packets.
*/
#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH 0
/* define this macro to 1 if you want the function usbMeasureFrameLength()
* compiled in. This function can be used to calibrate the AVR's RC oscillator.
/*
* define this macro to 1 if you want the function usbMeasureFrameLength() compiled in. This function can be used to calibrate the AVR's RC
* oscillator.
*/
/* -------------------------- Device Description --------------------------- */
/*
* -------------------------- Device Description ---------------------------
*/
#define USB_CFG_VENDOR_ID 0xc0, 0x16
/* USB vendor ID for the device, low byte first. If you have registered your
* own Vendor ID, define it here. Otherwise you use one of obdev's free shared
* VID/PID pairs. Be sure to read USBID-License.txt for rules!
/*
* USB vendor ID for the device, low byte first. If you have registered your own Vendor ID, define it here. Otherwise you use one of
* obdev's free shared VID/PID pairs. Be sure to read USBID-License.txt for rules!
*/
#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
* you use obdev's free shared VID/PID pair. Be sure to read the rules in
* USBID-License.txt!
/*
* This is the ID of the product, low byte first. It is interpreted in the scope of the vendor ID. If you have registered your own VID with
* usb.org or if you have licensed a PID from somebody else, define it here. Otherwise you use obdev's free shared VID/PID pair. Be sure to
* read the rules in USBID-License.txt!
*/
#define USB_CFG_DEVICE_VERSION 0x00, 0x01
/* Version number of the device: Minor number first, then major number.
/*
* Version number of the device: Minor number first, then major number.
*/
#define USB_CFG_VENDOR_NAME 'o', 'p', 't', 'i', 'x', 'x', '.', 'o', 'r', 'g'
#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.
* If you don't want a vendor name string, undefine these macros.
* ALWAYS define a vendor name containing your Internet domain name if you use
* obdev's free shared VID/PID pair. See the file USBID-License.txt for
* details.
/*
* These two values define the vendor name returned by the USB device. The name must be given as a list of characters under single quotes.
* The characters are interpreted as Unicode (UTF-16) entities. If you don't want a vendor name string, undefine these macros. ALWAYS
* define a vendor name containing your Internet domain name if you use obdev's free shared VID/PID pair. See the file USBID-License.txt
* for details.
*/
#define USB_CFG_DEVICE_NAME '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
* use a shared VID/PID.
/*
* Same as above for the device name. If you don't want a device name, undefine the macros. See the file USBID-License.txt before you
* assign a name if you use a shared VID/PID.
*/
/*#define USB_CFG_SERIAL_NUMBER 'N', 'o', 'n', 'e' */
/*#define USB_CFG_SERIAL_NUMBER_LEN 0 */
/* Same as above for the serial number. If you don't want a serial number,
* undefine the macros.
* It may be useful to provide the serial number through other means than at
* compile time. See the section about descriptor properties below for how
* to fine tune control over USB descriptors such as the string descriptor
* for the serial number.
/*
* #define USB_CFG_SERIAL_NUMBER 'N', 'o', 'n', 'e'
*/
#define USB_CFG_DEVICE_CLASS 0xff /* set to 0 if deferred to interface */
/*
* #define USB_CFG_SERIAL_NUMBER_LEN 0
*/
/*
* Same as above for the serial number. If you don't want a serial number, undefine the macros. It may be useful to provide the serial
* number through other means than at compile time. See the section about descriptor properties below for how to fine tune control over USB
* descriptors such as the string descriptor for the serial number.
*/
#define USB_CFG_DEVICE_CLASS 0xff /* set to 0 if deferred to interface */
#define USB_CFG_DEVICE_SUBCLASS 0
/* See USB specification if you want to conform to an existing device class.
* Class 0xff is "vendor specific".
/*
* See USB specification if you want to conform to an existing device class. Class 0xff is "vendor specific".
*/
#define USB_CFG_INTERFACE_CLASS 0 /* define class here if not at device level */
#define USB_CFG_INTERFACE_SUBCLASS 0
#define USB_CFG_INTERFACE_PROTOCOL 0
/* See USB specification if you want to conform to an existing device class or
* protocol. The following classes must be set at interface level:
* HID class is 3, no subclass and protocol required (but may be useful!)
* CDC class is 2, use subclass 2 and protocol 1 for ACM
/*
* See USB specification if you want to conform to an existing device class or protocol. The following classes must be set at interface
* level: HID class is 3, no subclass and protocol required (but may be useful!) CDC class is 2, use subclass 2 and protocol 1 for ACM
*/
#define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH 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
* "usbHidReportDescriptor" to your code which contains the report descriptor.
* Don't forget to keep the array and this define in sync!
#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 "usbHidReportDescriptor" to your code which contains the report
* descriptor. Don't forget to keep the array and this define in sync!
*/
/* #define USB_PUBLIC static */
/* Use the define above if you #include usbdrv.c instead of linking against it.
* This technique saves a couple of bytes in flash memory.
/*
* #define USB_PUBLIC static
*/
/*
* Use the define above if you #include usbdrv.c instead of linking against it. This technique saves a couple of bytes in flash memory.
*/
/* ------------------- Fine Control over USB Descriptors ------------------- */
/* If you don't want to use the driver's default USB descriptors, you can
* provide our own. These can be provided as (1) fixed length static data in
* flash memory, (2) fixed length static data in RAM or (3) dynamically at
* runtime in the function usbFunctionDescriptor(). See usbdrv.h for more
* information about this function.
* Descriptor handling is configured through the descriptor's properties. If
* no properties are defined or if they are 0, the default descriptor is used.
* Possible properties are:
* + USB_PROP_IS_DYNAMIC: The data for the descriptor should be fetched
* at runtime via usbFunctionDescriptor(). If the usbMsgPtr mechanism is
* used, the data is in FLASH by default. Add property USB_PROP_IS_RAM if
* you want RAM pointers.
* + USB_PROP_IS_RAM: The data returned by usbFunctionDescriptor() or found
* in static memory is in RAM, not in flash memory.
* + USB_PROP_LENGTH(len): If the data is in static memory (RAM or flash),
* the driver must know the descriptor's length. The descriptor itself is
* found at the address of a well known identifier (see below).
* List of static descriptor names (must be declared PROGMEM if in flash):
* char usbDescriptorDevice[];
* char usbDescriptorConfiguration[];
* char usbDescriptorHidReport[];
* char usbDescriptorString0[];
* int usbDescriptorStringVendor[];
* int usbDescriptorStringDevice[];
* int usbDescriptorStringSerialNumber[];
* Other descriptors can't be provided statically, they must be provided
* dynamically at runtime.
*
* Descriptor properties are or-ed or added together, e.g.:
* #define USB_CFG_DESCR_PROPS_DEVICE (USB_PROP_IS_RAM | USB_PROP_LENGTH(18))
*
* The following descriptors are defined:
* USB_CFG_DESCR_PROPS_DEVICE
* USB_CFG_DESCR_PROPS_CONFIGURATION
* USB_CFG_DESCR_PROPS_STRINGS
* USB_CFG_DESCR_PROPS_STRING_0
* USB_CFG_DESCR_PROPS_STRING_VENDOR
* USB_CFG_DESCR_PROPS_STRING_PRODUCT
* USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
* USB_CFG_DESCR_PROPS_HID
* USB_CFG_DESCR_PROPS_HID_REPORT
* USB_CFG_DESCR_PROPS_UNKNOWN (for all descriptors not handled by the driver)
*
* Note about string descriptors: String descriptors are not just strings, they
* are Unicode strings prefixed with a 2 byte header. Example:
* int serialNumberDescriptor[] = {
* USB_STRING_DESCRIPTOR_HEADER(6),
* 'S', 'e', 'r', 'i', 'a', 'l'
* };
/*
* ------------------- Fine Control over USB Descriptors -------------------
*/
/*
* If you don't want to use the driver's default USB descriptors, you can provide our own. These can be provided as (1) fixed length static
* data in flash memory, (2) fixed length static data in RAM or (3) dynamically at runtime in the function usbFunctionDescriptor(). See
* usbdrv.h for more information about this function. Descriptor handling is configured through the descriptor's properties. If no
* properties are defined or if they are 0, the default descriptor is used. Possible properties are: + USB_PROP_IS_DYNAMIC: The data for
* the descriptor should be fetched at runtime via usbFunctionDescriptor(). If the usbMsgPtr mechanism is used, the data is in FLASH by
* default. Add property USB_PROP_IS_RAM if you want RAM pointers. + USB_PROP_IS_RAM: The data returned by usbFunctionDescriptor() or
* found in static memory is in RAM, not in flash memory. + USB_PROP_LENGTH(len): If the data is in static memory (RAM or flash), the
* driver must know the descriptor's length. The descriptor itself is found at the address of a well known identifier (see below). List of
* static descriptor names (must be declared PROGMEM if in flash): char usbDescriptorDevice[]; char usbDescriptorConfiguration[]; char
* usbDescriptorHidReport[]; char usbDescriptorString0[]; int usbDescriptorStringVendor[]; int usbDescriptorStringDevice[]; int
* usbDescriptorStringSerialNumber[]; Other descriptors can't be provided statically, they must be provided dynamically at runtime.
* Descriptor properties are or-ed or added together, e.g.: #define USB_CFG_DESCR_PROPS_DEVICE (USB_PROP_IS_RAM | USB_PROP_LENGTH(18)) The
* following descriptors are defined: USB_CFG_DESCR_PROPS_DEVICE USB_CFG_DESCR_PROPS_CONFIGURATION USB_CFG_DESCR_PROPS_STRINGS
* USB_CFG_DESCR_PROPS_STRING_0 USB_CFG_DESCR_PROPS_STRING_VENDOR USB_CFG_DESCR_PROPS_STRING_PRODUCT
* USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER USB_CFG_DESCR_PROPS_HID USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_DESCR_PROPS_UNKNOWN (for all
* descriptors not handled by the driver) Note about string descriptors: String descriptors are not just strings, they are Unicode strings
* prefixed with a 2 byte header. Example: int serialNumberDescriptor[] = { USB_STRING_DESCRIPTOR_HEADER(6), 'S', 'e', 'r', 'i', 'a', 'l'
* };
*/
#define USB_CFG_DESCR_PROPS_DEVICE 0
@ -353,21 +315,38 @@ section at the end of this file).
#define USB_CFG_DESCR_PROPS_HID_REPORT 0
#define USB_CFG_DESCR_PROPS_UNKNOWN 0
/* ----------------------- Optional MCU Description ------------------------ */
/* The following configurations have working defaults in usbdrv.h. You
* usually don't need to set them explicitly. Only if you want to run
* the driver on a device which is not yet supported or with a compiler
* which is not fully supported (such as IAR C) or if you use a differnt
* interrupt than INT0, you may have to define some of these.
/*
* ----------------------- Optional MCU Description ------------------------
*/
/* #define USB_INTR_CFG MCUCR */
/* #define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) */
/* #define USB_INTR_CFG_CLR 0 */
/* #define USB_INTR_ENABLE GIMSK */
/* #define USB_INTR_ENABLE_BIT INT0 */
/* #define USB_INTR_PENDING GIFR */
/* #define USB_INTR_PENDING_BIT INTF0 */
/* #define USB_INTR_VECTOR SIG_INTERRUPT0 */
#endif /* __usbconfig_h_included__ */
/*
* The following configurations have working defaults in usbdrv.h. You usually don't need to set them explicitly. Only if you want to run
* the driver on a device which is not yet supported or with a compiler which is not fully supported (such as IAR C) or if you use a
* differnt interrupt than INT0, you may have to define some of these.
*/
/*
* #define USB_INTR_CFG MCUCR
*/
/*
* #define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01))
*/
/*
* #define USB_INTR_CFG_CLR 0
*/
/*
* #define USB_INTR_ENABLE GIMSK
*/
/*
* #define USB_INTR_ENABLE_BIT INT0
*/
/*
* #define USB_INTR_PENDING GIFR
*/
/*
* #define USB_INTR_PENDING_BIT INTF0
*/
/*
* #define USB_INTR_VECTOR SIG_INTERRUPT0
*/
#endif /* __usbconfig_h_included__ */

181
avr/usbload/util.c
View File

@ -17,116 +17,129 @@
*
* =====================================================================================
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
uint8_t *util_strupper(uint8_t *s)
uint8_t *util_strupper(uint8_t * s)
{
uint8_t *p;
for (p = s; *p != '\0'; p++)
if (*p >= 'a' && *p <= 'z')
*p += 'A' - 'a';
return s;
uint8_t *p;
for (p = s; *p != '\0'; p++)
if (*p >= 'a' && *p <= 'z')
*p += 'A' - 'a';
return s;
}
uint8_t *util_strlower(uint8_t *s)
uint8_t *util_strlower(uint8_t * s)
{
uint8_t *p;
for (p = s; *p != '\0'; p++)
if (*p >= 'A' && *p <= 'Z')
*p += 'a' - 'A';
return s;
uint8_t *p;
for (p = s; *p != '\0'; p++)
if (*p >= 'A' && *p <= 'Z')
*p += 'a' - 'A';
return s;
}
void util_chomp(uint8_t *s)
void util_chomp(uint8_t * s)
{
uint16_t len;
uint16_t len;
len = strlen((char*)s);
if (len >= 2 && s[len - 1] == '\n' && s[len - 2] == '\r')
s[len - 2] = '\0';
else if (len >= 1 && (s[len - 1] == '\n' || s[len - 1] == '\r'))
s[len - 1] = '\0';
len = strlen((char *) s);
if (len >= 2 && s[len - 1] == '\n' && s[len - 2] == '\r')
s[len - 2] = '\0';
else if (len >= 1 && (s[len - 1] == '\n' || s[len - 1] == '\r'))
s[len - 1] = '\0';
}
void util_trim(uint8_t *s)
void util_trim(uint8_t * s)
{
uint8_t *p = s;
uint8_t *q;
/* skip leading whitespace */
while (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n')
p++;
/* now p points at the first non-whitespace uint8_tacter */
uint8_t *p = s;
uint8_t *q;
/*
* skip leading whitespace
*/
while (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n')
p++;
/*
* now p points at the first non-whitespace uint8_tacter
*/
if (*p == '\0') {
/* only whitespace */
*s = '\0';
return;
}
if (*p == '\0') {
/*
* only whitespace
*/
*s = '\0';
return;
}
q = s + strlen((char*)s);
/* skip trailing whitespace */
/* we have found p < q such that *p is non-whitespace,
so this loop terminates with q >= p */
do
q--;
while (*q == ' ' || *q == '\t' || *q == '\r' || *q == '\n');
q = s + strlen((char *) s);
/*
* skip trailing whitespace
*/
/*
* we have found p < q such that *p is non-whitespace, so this loop terminates with q >= p
*/
do
q--;
while (*q == ' ' || *q == '\t' || *q == '\r' || *q == '\n');
/* now q points at the last non-whitespace uint8_tacter */
/* cut off trailing whitespace */
*++q = '\0';
/*
* now q points at the last non-whitespace uint8_tacter
*/
/*
* cut off trailing whitespace
*/
*++q = '\0';
/* move to string */
memmove(s, p, q + 1 - p);
/*
* move to string
*/
memmove(s, p, q + 1 - p);
}
uint32_t util_sscandec(const uint8_t *s)
uint32_t util_sscandec(const uint8_t * s)
{
uint32_t result;
if (*s == '\0')
return -1;
result = 0;
for (;;) {
if (*s >= '0' && *s <= '9')
result = 10 * result + *s - '0';
else if (*s == '\0')
return result;
else
return -1;
s++;
}
uint32_t result;
if (*s == '\0')
return -1;
result = 0;
for (;;) {
if (*s >= '0' && *s <= '9')
result = 10 * result + *s - '0';
else if (*s == '\0')
return result;
else
return -1;
s++;
}
}
uint32_t util_sscanhex(const uint8_t *s)
uint32_t util_sscanhex(const uint8_t * s)
{
int32_t result;
if (*s == '\0')
return -1;
result = 0;
for (;;) {
if (*s >= '0' && *s <= '9')
result = 16 * result + *s - '0';
else if (*s >= 'A' && *s <= 'F')
result = 16 * result + *s - 'A' + 10;
else if (*s >= 'a' && *s <= 'f')
result = 16 * result + *s - 'a' + 10;
else if (*s == '\0')
return result;
else
return -1;
s++;
}
int32_t result;
if (*s == '\0')
return -1;
result = 0;
for (;;) {
if (*s >= '0' && *s <= '9')
result = 16 * result + *s - '0';
else if (*s >= 'A' && *s <= 'F')
result = 16 * result + *s - 'A' + 10;
else if (*s >= 'a' && *s <= 'f')
result = 16 * result + *s - 'a' + 10;
else if (*s == '\0')
return result;
else
return -1;
s++;
}
}
uint8_t util_sscanbool(const uint8_t *s)
uint8_t util_sscanbool(const uint8_t * s)
{
if (*s == '0' && s[1] == '\0')
return 0;
if (*s == '1' && s[1] == '\0')
return 1;
return -1;
if (*s == '0' && s[1] == '\0')
return 0;
if (*s == '1' && s[1] == '\0')
return 1;
return -1;
}

14
avr/usbload/util.h
View File

@ -21,12 +21,12 @@
#ifndef __UTIL_H__
#define __UTIL_H__
uint8_t *util_strupper(uint8_t *s);
uint8_t *util_strlower(uint8_t *s);
void util_chomp(uint8_t *s);
void util_trim(uint8_t *s);
uint32_t util_sscandec(const uint8_t *s);
uint32_t util_sscanhex(const uint8_t *s);
uint8_t util_sscanbool(const uint8_t *s);
uint8_t *util_strupper(uint8_t * s);
uint8_t *util_strlower(uint8_t * s);
void util_chomp(uint8_t * s);
void util_trim(uint8_t * s);
uint32_t util_sscandec(const uint8_t * s);
uint32_t util_sscanhex(const uint8_t * s);
uint8_t util_sscanbool(const uint8_t * s);
#endif

1
avr/usbload/watchdog.c
View File

@ -28,4 +28,3 @@ void wdt_init(void)
return;
}

3
avr/usbload/watchdog.h
View File

@ -27,7 +27,7 @@
#define __WATCHDOG_H__
void wdt_init(void) __attribute__((naked)) __attribute__((section(".init3")));
void wdt_init(void) __attribute__ ((naked)) __attribute__ ((section(".init3")));
#define soft_reset() \
do \
@ -39,4 +39,3 @@ do \
} while(0)
#endif