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

cleanup up and remove huffman stuff

Browse Source
This commit is contained in:
David Voswinkel 2009-08-04 08:38:26 +02:00
parent 92762d7f51
commit af45ed720b
10 changed files with 2165 additions and 2300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
avr/usbload/Makefile
View File

@ -30,7 +30,7 @@ SIZE = avr-size
ifeq ($(DEBUG),1)
LDFLAGS = -Wl,-u,vfprintf -lprintf_flt
CFLAGS = -Iusbdrv -I. -DDEBUG_LEVEL=0
OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o main.o usb_bulk.o uart.o fifo.o sram.o crc.o debug.o dump.o timer.o watchdog.o huffman-decode.o rle.c loader.o info.o shared_memory.o
OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o main.o usb_bulk.o uart.o fifo.o sram.o crc.o debug.o dump.o timer.o watchdog.o rle.c loader.o info.o shared_memory.o
else
LDFLAGS = -Wl,-u
CFLAGS = -Iusbdrv -I. -DDEBUG_LEVEL=0 -DNO_DEBUG -DNO_INFO

267
avr/usbload/huffman-decode.c
View File

@ -1,267 +0,0 @@
/*
* =====================================================================================
*
* ________ .__ __ ________ ____ ________
* \_____ \ __ __|__| ____ | | __\______ \ _______ _/_ |/ _____/
* / / \ \| | \ |/ ___\| |/ / | | \_/ __ \ \/ /| / __ \
* / \_/. \ | / \ \___| < | ` \ ___/\ / | \ |__\ \
* \_____\ \_/____/|__|\___ >__|_ \/_______ /\___ >\_/ |___|\_____ /
* \__> \/ \/ \/ \/ \/
*
* www.optixx.org
*
*
* Version: 1.0
* Created: 07/21/2009 03:32:16 PM
*
* =====================================================================================
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "huffman-decode.h"
#include "info.h"
#include "debug.h"
#ifdef DEBUG
#undef DEBUG
#endif
#define DEBUG 1
#if DEBUG
#include <avr/pgmspace.h>
#endif
#define V_NODE (-2)
#define V_EOF (-1)
#define PREFIX_SIZE_B 32
#define ALLOC_ERROR {}
#undef BLOCK_ALLOC 1
typedef struct {
int16_t value;
void* left;
void* right;
} node_t;
#if HUFFMAN_USE_ADDR_16
void huffman_dec_init(huffman_dec_ctx_t* ctx, uint16_t(*rb_func)(uint16_t)){
#else
void huffman_dec_init(huffman_dec_ctx_t* ctx, uint16_t(*rb_func)(uint32_t)){
#endif
ctx->tree = NULL;
ctx->addr = 0;
ctx->read_byte = rb_func;
ctx->rbuffer_index = 8;
}
#if HUFFMAN_USE_ADDR_16
void huffman_dec_set_addr(huffman_dec_ctx_t* ctx, uint16_t addr){
#else
void huffman_dec_set_addr(huffman_dec_ctx_t* ctx, uint32_t addr){
#endif
ctx->addr = addr;
}
static inline void prefix_increment(uint8_t* prefix){
uint8_t i;
for(i=0; i<PREFIX_SIZE_B; ++i){
prefix[i] += 1;
if(prefix[i]!=0)
return;
}
}
static inline void prefix_shiftleft(uint8_t* prefix){
uint8_t i;
uint8_t c[2]={0,0};
uint8_t ci=0;
for(i=0; i<PREFIX_SIZE_B; ++i){
c[ci] = (prefix[i])>>7;
prefix[i]<<=1;
ci ^= 1;
prefix[i]|=c[ci];
}
}
static inline void set_last_to_eof(node_t* start){
node_t* current = start;
while(current->value==V_NODE){
current=current->right;
}
current->value=V_EOF;
}
#if DEBUG
void print_tree(node_t* node){
if(node->value==V_NODE){
info("\n%p --> node->left=%p node->right=%p",node,node->left, node->right);
print_tree(node->left);
print_tree(node->right);
}else{
info("\n%p => %i",node,node->value);
}
}
#endif
uint8_t build_tree(huffman_dec_ctx_t* ctx){
uint16_t treesize;
uint16_t treeindex=1;
int8_t i,t;
if(ctx->read_byte(ctx->addr++)!=0xC0)
return 1;
if(((treesize=ctx->read_byte(ctx->addr++))&0xFE)!=0xDE)
return 1;
treesize = (treesize&1)<<8;
treesize += ctx->read_byte(ctx->addr++);
if(treesize>0x1ff)
return 2;
#if BLOCK_ALLOC
ctx->tree = calloc(2*treesize-1, sizeof(node_t));
#else
ctx->tree = calloc(1, sizeof(node_t));
#endif
((node_t*)(ctx->tree))->value = V_NODE;
uint16_t depth=0;
uint16_t count=0;
uint16_t v;
uint8_t prefix[PREFIX_SIZE_B];
uint8_t cdepth=0;
node_t* current=ctx->tree;
current->value = V_NODE;
memset(prefix, 0, PREFIX_SIZE_B);
do{
while(count==0){
depth++;
count= ctx->read_byte(ctx->addr++);
if(count==255)
count += ctx->read_byte(ctx->addr++);
}
v = ctx->read_byte(ctx->addr++);
if(v>0xff)
return 3;
--count;
for(;cdepth<depth;++cdepth){
prefix_shiftleft(prefix);
}
#if DEBUG
printf("\n value %x => ",v);
#endif
current=ctx->tree;
for(i=depth-1; i>=0; --i){
t=(prefix[i/8])&(1<<(i%8));
if(t==0){
#if DEBUG
printf("0");
#endif
if(current->left==NULL){
#if BLOCK_ALLOC
current->left=&(((node_t*)(ctx->tree))[treeindex++]);
#else
current->left=calloc(1, sizeof(node_t));
#endif
((node_t*)(current->left))->value = V_NODE;
}
current = current->left;
} else {
#if DEBUG
printf("1");
#endif
if(current->right==NULL){
#if BLOCK_ALLOC
current->right=&(((node_t*)(ctx->tree))[treeindex++]);
#else
current->right=calloc(1, sizeof(node_t));
#endif
((node_t*)(current->right))->value=V_NODE;
}
current = current->right;
}
}
#if !BLOCK_ALLOC
if(current==NULL)
ALLOC_ERROR
#endif
current->value=v;
prefix_increment(prefix);
}while(!(prefix[depth/8]&(1<<(depth%8))));
#if DEBUG
print_tree(ctx->tree);
#endif
set_last_to_eof(ctx->tree);
return 0;
}
void free_tree(node_t* node){
#if !BLOCK_ALLOC
if(node->value==V_NODE){
free_tree(node->left);
free_tree(node->right);
}
#endif
free(node);
}
static uint8_t read_bit(huffman_dec_ctx_t* ctx){
uint16_t x;
uint8_t t;
if(ctx->rbuffer_index==8){
x=ctx->read_byte(ctx->addr);
ctx->addr++;
if(t>0xff)
return 0xFF;
ctx->rbuffer = (uint8_t)x;
ctx->rbuffer_index=0;
}
t=(ctx->rbuffer)>>7;
ctx->rbuffer<<=1;
ctx->rbuffer_index++;
return t;
}
uint16_t huffman_dec_byte(huffman_dec_ctx_t* ctx){
node_t* current=ctx->tree;
uint8_t t;
if(current==NULL){
#if DEBUG
printf("\nbuild tree");
#endif
t=build_tree(ctx);
if(t!=0){
#if DEBUG
printf("\n!!! building tree failed !!!\r\n");
#endif
return 0xFFFF;
}
#if DEBUG
printf("\ntree build successful");
#endif
current=ctx->tree;
}
while(current->value==V_NODE){
t=read_bit(ctx);
if(t==0xFF)
goto eof_detected;
if(t==0){
current=current->left;
} else {
current=current->right;
}
}
if(current->value!=V_EOF){
return current->value;
}
eof_detected:
free_tree(ctx->tree);
ctx->tree = NULL;
return 0xFFFF;
}

51
avr/usbload/huffman-decode.h
View File

@ -1,51 +0,0 @@
/*
* =====================================================================================
*
* ________ .__ __ ________ ____ ________
* \_____ \ __ __|__| ____ | | __\______ \ _______ _/_ |/ _____/
* / / \ \| | \ |/ ___\| |/ / | | \_/ __ \ \/ /| / __ \
* / \_/. \ | / \ \___| < | ` \ ___/\ / | \ |__\ \
* \_____\ \_/____/|__|\___ >__|_ \/_______ /\___ >\_/ |___|\_____ /
* \__> \/ \/ \/ \/ \/
*
* www.optixx.org
*
*
* Version: 1.0
* Created: 07/21/2009 03:32:16 PM
*
* =====================================================================================
*/
#ifndef AVR_HUFFMAN_DECODE_H_
#define AVR_HUFFMAN_DECODE_H_
#include <stdint.h>
#define HUFFMAN_USE_ADDR_16 1
typedef struct {
void* tree;
uint8_t rbuffer;
uint8_t rbuffer_index;
#if HUFFMAN_USE_ADDR_16
uint16_t(*read_byte)(uint16_t addr);
uint16_t addr;
#else
uint16_t(*read_byte)(uint32_t addr);
uint32_t addr;
#endif
} huffman_dec_ctx_t;
#if HUFFMAN_USE_ADDR_16
void huffman_dec_init(huffman_dec_ctx_t* ctx, uint16_t(*rb_func)(uint16_t));
void huffman_dec_set_addr(huffman_dec_ctx_t* ctx,uint16_t addr);
#else
void huffman_dec_init(huffman_dec_ctx_t* ctx, uint16_t(*rb_func)(uint32_t));
void huffman_dec_set_addr(huffman_dec_ctx_t* ctx,uint32_t addr);
#endif
uint16_t huffman_dec_byte(huffman_dec_ctx_t* ctx);
#endif /* AVR_HUFFMAN_DECODE_H_ */

3605
avr/usbload/loader.c
View File

File diff suppressed because it is too large Load Diff

4
avr/usbload/loader.h
View File

@ -2,8 +2,8 @@
#ifndef __FIFO_H__
#define __FIFO_H__
#define ROM_BUFFER_SIZE 27288
#define ROM_HUFFMAN_SIZE 27288
#define ROM_BUFFER_SIZE 30344
#define ROM_HUFFMAN_SIZE 0
#define ROM_RLE_SIZE 30344
#endif

326
avr/usbload/main.c
View File

@ -28,8 +28,7 @@
#include <avr/eeprom.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"
@ -41,7 +40,6 @@
#include "usb_bulk.h"
#include "timer.h"
#include "watchdog.h"
#include "huffman-decode.h"
#include "rle.h"
#include "loader.h"
#include "shared_memory.h"
@ -50,7 +48,7 @@
extern const char _rom[] PROGMEM;
extern FILE uart_stdout;
uint8_t debug_level = ( DEBUG | DEBUG_USB | DEBUG_CRC );
uint8_t debug_level = (DEBUG | DEBUG_USB | DEBUG_CRC);
uint8_t read_buffer[TRANSFER_BUFFER_SIZE];
uint32_t req_addr = 0;
@ -76,26 +74,27 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
usbRequest_t *rq = (void *) data;
uint8_t ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
if (rq->bRequest == USB_UPLOAD_INIT) {
if (req_state != REQ_STATUS_IDLE){
debug(DEBUG_USB,"USB_UPLOAD_INIT: ERROR state is not REQ_STATUS_IDLE\n");
if (req_state != REQ_STATUS_IDLE) {
debug(DEBUG_USB,
"USB_UPLOAD_INIT: ERROR state is not REQ_STATUS_IDLE\n");
return 0;
}
req_bank = 0;
rx_remaining = 0;
req_bank_size = (uint32_t)1 << rq->wValue.word;
req_bank_size = (uint32_t) 1 << rq->wValue.word;
sync_errors = 0;
crc = 0;
debug(DEBUG_USB,"USB_UPLOAD_INIT: bank_size=0x%08lx\n", req_bank_size);
debug(DEBUG_USB, "USB_UPLOAD_INIT: bank_size=0x%08lx\n", req_bank_size);
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_UPLOAD_ADDR) {
req_state = REQ_STATUS_UPLOAD;
@ -105,7 +104,8 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
if (rx_remaining) {
sync_errors++;
debug
(DEBUG_USB,"USB_UPLOAD_ADDR: Out of sync addr=0x%lx remain=%i packet=%i sync_error=%i\n",
(DEBUG_USB,
"USB_UPLOAD_ADDR: Out of sync addr=0x%lx remain=%i packet=%i sync_error=%i\n",
req_addr, rx_remaining, rq->wLength.word, sync_errors);
ret_len = 0;
}
@ -114,52 +114,57 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
if (req_addr && (req_addr % 0x1000) == 0) {
debug(DEBUG_USB,"USB_UPLOAD_ADDR: bank=0x%02x addr=0x%08lx crc=%04x\n",
req_bank, req_addr,crc_check_bulk_memory(req_addr - 0x1000,req_addr,req_bank_size));
debug(DEBUG_USB,
"USB_UPLOAD_ADDR: bank=0x%02x addr=0x%08lx crc=%04x\n",
req_bank, req_addr, crc_check_bulk_memory(req_addr - 0x1000,
req_addr,
req_bank_size));
}
if (req_addr && req_addr % req_bank_size == 0) {
debug(DEBUG_USB,"USB_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx\n",
req_bank, req_addr);
debug(DEBUG_USB, "USB_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx\n",
req_bank, req_addr);
req_bank++;
//shared_memory_put(SHARED_MEM_CMD_UPLOAD_PROGESS,req_bank);
// shared_memory_put(SHARED_MEM_CMD_UPLOAD_PROGESS,req_bank);
}
ret_len = USB_MAX_TRANS;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_DOWNLOAD_INIT) {
debug(DEBUG_USB,"USB_DOWNLOAD_INIT\n");
debug(DEBUG_USB, "USB_DOWNLOAD_INIT\n");
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_DOWNLOAD_ADDR) {
debug(DEBUG_USB,"USB_DOWNLOAD_ADDR\n");
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_BULK_UPLOAD_INIT) {
debug(DEBUG_USB, "USB_DOWNLOAD_ADDR\n");
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_BULK_UPLOAD_INIT) {
req_bank = 0;
rx_remaining = 0;
debug(DEBUG_USB,"USB_BULK_UPLOAD_INIT: %i %i\n",rq->wValue.word, rq->wIndex.word);
req_bank_size = (uint32_t)(1L << rq->wValue.word);
debug(DEBUG_USB, "USB_BULK_UPLOAD_INIT: %i %i\n", rq->wValue.word,
rq->wIndex.word);
req_bank_size = (uint32_t) (1L << rq->wValue.word);
req_bank_cnt = rq->wIndex.word;
req_addr_end = (uint32_t)req_bank_size * req_bank_cnt;
req_addr_end = (uint32_t) req_bank_size *req_bank_cnt;
sync_errors = 0;
debug(DEBUG_USB,"USB_BULK_UPLOAD_INIT: bank_size=0x%08lx bank_cnt=0x%x end_addr=0x%08lx\n",
req_bank_size, req_bank_cnt, req_addr_end);
debug(DEBUG_USB,
"USB_BULK_UPLOAD_INIT: bank_size=0x%08lx bank_cnt=0x%x end_addr=0x%08lx\n",
req_bank_size, req_bank_cnt, req_addr_end);
shared_memory_put(SHARED_MEM_CMD_BANK_COUNT,req_bank_cnt);
if (req_addr == 0x000000){
shared_memory_put(SHARED_MEM_CMD_BANK_COUNT, req_bank_cnt);
if (req_addr == 0x000000) {
timer_start();
}
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_BULK_UPLOAD_ADDR) {
req_state = REQ_STATUS_BULK_UPLOAD;
@ -169,15 +174,17 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
rx_remaining = rq->wLength.word;
if (req_addr && req_addr % req_bank_size == 0) {
#ifdef FLT_DEBUG
debug(DEBUG_USB,"USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%.4f\n",
req_bank, req_addr,timer_stop());
#else
debug(DEBUG_USB,"USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%i\n",
req_bank, req_addr,timer_stop_int());
#endif
#ifdef FLT_DEBUG
debug(DEBUG_USB,
"USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%.4f\n",
req_bank, req_addr, timer_stop());
#else
debug(DEBUG_USB,
"USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%i\n",
req_bank, req_addr, timer_stop_int());
#endif
req_bank++;
shared_memory_put(SHARED_MEM_CMD_UPLOAD_PROGESS,req_bank);
shared_memory_put(SHARED_MEM_CMD_UPLOAD_PROGESS, req_bank);
sram_bulk_write_start(req_addr);
timer_start();
@ -186,9 +193,9 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
}
ret_len = USB_MAX_TRANS;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_BULK_UPLOAD_NEXT) {
req_state = REQ_STATUS_BULK_UPLOAD;
@ -198,87 +205,94 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
rx_remaining = rq->wLength.word;
#if 0
if (req_addr && (req_addr % 0x1000) == 0) {
debug(DEBUG_USB,"USB_BULK_UPLOAD_NEXT: bank=0x%02x addr=0x%08lx crc=%04x\n",
req_bank, req_addr,crc_check_bulk_memory(req_addr - 0x1000,req_addr,req_bank_size));
debug(DEBUG_USB,
"USB_BULK_UPLOAD_NEXT: bank=0x%02x addr=0x%08lx crc=%04x\n",
req_bank, req_addr, crc_check_bulk_memory(req_addr - 0x1000,
req_addr,
req_bank_size));
}
sram_bulk_write_start(req_addr);
#endif
if (req_addr && ( req_addr % req_bank_size) == 0) {
#ifdef FLT_DEBUG
debug(DEBUG_USB,"USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%.4f\n",
req_bank, req_addr,timer_stop());
#else
debug(DEBUG_USB,"USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%i\n",
req_bank, req_addr,timer_stop_int());
#endif
if (req_addr && (req_addr % req_bank_size) == 0) {
#ifdef FLT_DEBUG
debug(DEBUG_USB,
"USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%.4f\n",
req_bank, req_addr, timer_stop());
#else
debug(DEBUG_USB,
"USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%i\n",
req_bank, req_addr, timer_stop_int());
#endif
req_bank++;
timer_start();
shared_memory_put(SHARED_MEM_CMD_BANK_CURRENT,req_bank);
shared_memory_put(SHARED_MEM_CMD_BANK_CURRENT, req_bank);
sram_bulk_write_start(req_addr);
}
ret_len = USB_MAX_TRANS;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_BULK_UPLOAD_END) {
if (req_state != REQ_STATUS_BULK_UPLOAD){
debug(DEBUG_USB,"USB_BULK_UPLOAD_END: ERROR state is not REQ_STATUS_BULK_UPLOAD\n");
if (req_state != REQ_STATUS_BULK_UPLOAD) {
debug(DEBUG_USB,
"USB_BULK_UPLOAD_END: ERROR state is not REQ_STATUS_BULK_UPLOAD\n");
return 0;
}
debug(DEBUG_USB,"USB_BULK_UPLOAD_END:\n");
debug(DEBUG_USB, "USB_BULK_UPLOAD_END:\n");
req_state = REQ_STATUS_IDLE;
sram_bulk_write_end();
shared_memory_put(SHARED_MEM_CMD_UPLOAD_END,0);
shared_memory_put(SHARED_MEM_CMD_UPLOAD_END, 0);
ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_CRC) {
req_addr = rq->wValue.word;
req_addr = req_addr << 16;
req_addr = req_addr | rq->wIndex.word;
debug(DEBUG_USB,"USB_CRC: addr=0x%08lx \n", req_addr);
debug(DEBUG_USB, "USB_CRC: addr=0x%08lx \n", req_addr);
crc_check_bulk_memory(0x000000, req_addr, req_bank_size);
ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_MODE_SNES) {
req_state = REQ_STATUS_SNES;
debug(DEBUG_USB,"USB_MODE_SNES:\n");
debug(DEBUG_USB, "USB_MODE_SNES:\n");
ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_MODE_AVR) {
req_state = REQ_STATUS_AVR;
debug(DEBUG_USB,"USB_MODE_AVR:\n");
debug(DEBUG_USB, "USB_MODE_AVR:\n");
ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_AVR_RESET) {
debug(DEBUG_USB,"USB_AVR_RESET:\n");
debug(DEBUG_USB, "USB_AVR_RESET:\n");
soft_reset();
ret_len = 0;
/*
* -------------------------------------------------------------------------
*/
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_CRC_ADDR) {
req_state = REQ_STATUS_CRC;
req_addr = rq->wValue.word;
req_addr = req_addr << 16;
req_addr = req_addr | rq->wIndex.word;
debug(DEBUG_USB,"USB_CRC_ADDR: addr=0x%lx size=%i\n", req_addr,
rq->wLength.word);
debug(DEBUG_USB, "USB_CRC_ADDR: addr=0x%lx size=%i\n", req_addr,
rq->wLength.word);
req_size = rq->wLength.word;
req_size = req_size << 2;
tx_remaining = 2;
debug(DEBUG_USB,"USB_CRC_ADDR: addr=0x%lx size=%li\n", req_addr, req_size);
debug(DEBUG_USB, "USB_CRC_ADDR: addr=0x%lx size=%li\n", req_addr,
req_size);
crc = crc_check_memory_range(req_addr, req_size, read_buffer);
tx_buffer[0] = crc & 0xff;
@ -288,8 +302,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
}
usbMsgPtr = data_buffer;
return ret_len; /* default for not implemented requests: return
* no data back to host */
return ret_len; /* default for not implemented requests: return no data back to host */
}
@ -297,25 +310,27 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
* -------------------------------------------------------------------------
*/
void test_read_write(){
void test_read_write()
{
uint8_t i;
uint32_t addr;
avr_bus_active();
addr = 0x000000;
i = 1;
while (addr++ <= 0x0000ff){
sram_write(addr,i++);
while (addr++ <= 0x0000ff) {
sram_write(addr, i++);
}
addr = 0x000000;
while (addr++ <= 0x0000ff){
info("read addr=0x%08lx %x\n",addr,sram_read(addr));
while (addr++ <= 0x0000ff) {
info("read addr=0x%08lx %x\n", addr, sram_read(addr));
}
}
void test_bulk_read_write(){
void test_bulk_read_write()
{
uint8_t i;
uint32_t addr;
@ -323,7 +338,7 @@ void test_bulk_read_write(){
addr = 0x000000;
i = 0;
sram_bulk_write_start(addr);
while (addr++ <= 0x8000){
while (addr++ <= 0x8000) {
sram_bulk_write(i++);
sram_bulk_write_next();
}
@ -331,8 +346,8 @@ void test_bulk_read_write(){
addr = 0x000000;
sram_bulk_read_start(addr);
while (addr <= 0x8000){
info("addr=0x%08lx %x\n",addr,sram_bulk_read());
while (addr <= 0x8000) {
info("addr=0x%08lx %x\n", addr, sram_bulk_read());
sram_bulk_read_next();
addr++;
}
@ -340,15 +355,15 @@ void test_bulk_read_write(){
}
void test_non_zero_memory(uint32_t bottom_addr,uint32_t top_addr)
void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr)
{
uint32_t addr = 0;
uint8_t c;
sram_bulk_read_start(bottom_addr);
for (addr = bottom_addr; addr < top_addr; addr++) {
c = sram_bulk_read();
if (c!=0xff)
info("addr=0x%08lx c=0x%x\n",addr,c);
if (c != 0xff)
info("addr=0x%08lx c=0x%x\n", addr, c);
sram_bulk_read_next();
}
sram_bulk_read_end();
@ -356,55 +371,30 @@ void test_non_zero_memory(uint32_t bottom_addr,uint32_t top_addr)
void test_crc(){
void test_crc()
{
info("test_crc: clear\n");
avr_bus_active();
sram_bulk_set(0x000000,0x10000,0xff);
sram_bulk_set(0x000000, 0x10000, 0xff);
info("test_crc: crc\n");
crc_check_bulk_memory(0x000000,0x10000,0x8000);
crc_check_bulk_memory(0x000000, 0x10000, 0x8000);
info("test_crc: check\n");
test_non_zero_memory(0x000000,0x10000);
test_non_zero_memory(0x000000, 0x10000);
}
uint16_t read_byte_pgm(uint16_t addr){
return pgm_read_byte((PGM_VOID_P)addr);
uint16_t read_byte_pgm(uint16_t addr)
{
return pgm_read_byte((PGM_VOID_P) addr);
}
uint16_t read_byte_ee(uint16_t addr){
return eeprom_read_byte((uint8_t*)addr);
uint16_t read_byte_ee(uint16_t addr)
{
return eeprom_read_byte((uint8_t *) addr);
}
void decompress(PGM_VOID_P addr, uint16_t(*fp)(uint16_t)){
uint16_t c;
uint32_t i = 0;
huffman_dec_ctx_t ctx;
huffman_dec_init(&ctx, fp);
huffman_dec_set_addr(&ctx, (uint16_t)addr);
while(1){
i++;
c=huffman_dec_byte(&ctx);
if (i%1024==0)
info(".");
if(c>0xff){
return;
}
c&=0xff;
sram_bulk_write(c);
}
}
void decompress_huffman(void){
info("Decompress Rom %p to 0x000000\n",(void*)_rom);
sram_bulk_write_start(0x000000);
decompress(&_rom,read_byte_pgm);
sram_bulk_write_end();
info("Done\n");
}
void send_reset(){
void send_reset()
{
info("Reset Snes\n");
snes_reset_on();
snes_reset_lo();
@ -413,7 +403,8 @@ void send_reset(){
snes_reset_off();
}
void send_irq(){
void send_irq()
{
snes_irq_on();
snes_irq_lo();
_delay_us(20);
@ -421,8 +412,9 @@ void send_irq(){
snes_irq_off();
}
void set_rom_mode(){
if (req_bank_size == 0x8000){
void set_rom_mode()
{
if (req_bank_size == 0x8000) {
snes_lorom();
info("Set Snes lowrom \n");
} else {
@ -432,7 +424,8 @@ void set_rom_mode(){
}
void usb_connect(){
void usb_connect()
{
uint8_t i = 0;
info("USB init\n");
usbDeviceDisconnect(); /* enforce re-enumeration, do this while */
@ -451,7 +444,8 @@ void usb_connect(){
}
void boot_startup_rom(){
void boot_startup_rom()
{
info("Activate AVR bus\n");
@ -464,18 +458,7 @@ void boot_startup_rom(){
snes_lorom();
info("Set Snes lowrom \n");
/*
info("Set Snes hirom\n");
snes_hirom();
info("Disable snes WR\n");
snes_wr_disable();
info("IRQ off\n");
snes_irq_lo();
snes_irq_off();
*/
rle_decode(&_rom, ROM_SIZE, 0x000000);
rle_decode(&_rom, ROM_BUFFER_SIZE, 0x000000);
dump_memory(0x10000 - 0x100, 0x10000);
snes_reset_hi();
@ -496,7 +479,7 @@ void boot_startup_rom(){
uint8_t i = 0;
i = 20;
info("Wait");
while (--i){
while (--i) {
_delay_ms(500);
info(".");
}
@ -517,7 +500,7 @@ int main(void)
test_read_write();
test_bulk_read_write();
test_crc();
while(1);
while (1);
#endif
info("Boot startup rom\n");
@ -526,7 +509,7 @@ int main(void)
usbInit();
usb_connect();
while (1){
while (1) {
avr_bus_active();
info("Activate AVR bus\n");
info("IRQ off\n");
@ -538,10 +521,10 @@ int main(void)
snes_wr_disable();
sei();
info("USB poll\n");
while (req_state != REQ_STATUS_SNES){
while (req_state != REQ_STATUS_SNES) {
usbPoll();
}
shared_memory_put(SHARED_MEM_CMD_TERMINATE,0);
shared_memory_put(SHARED_MEM_CMD_TERMINATE, 0);
info("USB poll done\n");
snes_reset_hi();
snes_reset_off();
@ -558,7 +541,7 @@ int main(void)
send_reset();
info("Poll\n");
while (req_state != REQ_STATUS_AVR){
while (req_state != REQ_STATUS_AVR) {
usbPoll();
@ -569,7 +552,7 @@ int main(void)
while (--i) {
_delay_ms(100);
}
info("Send IRQ %i\n",++irq_count);
info("Send IRQ %i\n", ++irq_count);
send_irq();
#endif
@ -583,7 +566,7 @@ int main(void)
info("Wait to switch to snes mode %i\n", i);
}
if (req_bank_size == 0x8000){
if (req_bank_size == 0x8000) {
snes_lorom();
info("Set Snes lowrom \n");
} else {
@ -594,11 +577,10 @@ int main(void)
info("Disable snes WR\n");
snes_bus_active();
info("Activate Snes bus\n");
info("Read 0x3000=%c\n",c);
info("Read 0x3000=%c\n", c);
#endif
}
}
return 0;
}

77
avr/usbload/rle.c
View File

@ -34,12 +34,12 @@
uint8_t rle_decode(PGM_VOID_P in_addr, int32_t in_len, uint32_t out_addr)
{
uint8_t in_byte, in_repeat, last_byte;
uint32_t out_len, out_len_left;
info("RLE decode len=%li addr=0x%08lx\n",in_len,out_addr);
uint8_t in_byte, in_repeat, last_byte;
uint32_t out_len, out_len_left;
info("RLE decode len=%li addr=0x%08lx\n", in_len, out_addr);
last_byte = 0;
out_len_left = out_len;
out_len_left = out_len;
sram_bulk_write_start(out_addr);
#define INBYTE(b) \
do { \
@ -58,41 +58,46 @@ uint8_t rle_decode(PGM_VOID_P in_addr, int32_t in_len, uint32_t out_addr)
out_addr++;\
} while(0)
INBYTE(in_byte);
INBYTE(in_byte);
if (in_byte == RUNCHAR) {
INBYTE(in_repeat);
if (in_repeat != 0) {
info("Orphaned RLE code at start\n");
return 1;
}
OUTBYTE(RUNCHAR);
} else {
OUTBYTE(in_byte);
}
if (in_byte == RUNCHAR) {
INBYTE(in_repeat);
if (in_repeat != 0) {
info("Orphaned RLE code at start\n");
return 1;
}
OUTBYTE(RUNCHAR);
} else {
OUTBYTE(in_byte);
}
while( in_len > 0 ) {
INBYTE(in_byte);
if (in_len%1024==0)
while (in_len > 0) {
INBYTE(in_byte);
if (in_len % 1024 == 0)
info(".");
if (in_byte == RUNCHAR) {
INBYTE(in_repeat);
if ( in_repeat == 0 ) {
/* Just an escaped RUNCHAR value */
OUTBYTE(RUNCHAR);
} else {
/* Pick up value and output a sequence of it */
in_byte = last_byte; //;out_data[-1];
while ( --in_repeat > 0 )
OUTBYTE(in_byte);
}
} else {
/* Normal byte */
OUTBYTE(in_byte);
}
if (in_byte == RUNCHAR) {
INBYTE(in_repeat);
if (in_repeat == 0) {
/*
* Just an escaped RUNCHAR value
*/
OUTBYTE(RUNCHAR);
} else {
/*
* Pick up value and output a sequence of it
*/
in_byte = last_byte; // ;out_data[-1];
while (--in_repeat > 0)
OUTBYTE(in_byte);
}
} else {
/*
* Normal byte
*/
OUTBYTE(in_byte);
}
last_byte = in_byte;
}
}
sram_bulk_write_end();
return 0;
return 0;
}

6
avr/usbload/rle.h
View File

@ -18,11 +18,11 @@
* =====================================================================================
*/
#ifndef __RLE_H__
#define __RLE_H__
#ifndef __RLE_H__
#define __RLE_H__
#include <avr/pgmspace.h>
uint8_t rle_decode(PGM_VOID_P in_addr,uint32_t in_len, uint32_t out_addr);
uint8_t rle_decode(PGM_VOID_P in_addr, uint32_t in_len, uint32_t out_addr);
#endif

25
avr/usbload/shared_memory.c
View File

@ -38,40 +38,46 @@ uint8_t scratchpad_state;
uint8_t scratchpad_cmd;
uint8_t scratchpad_payload;
void shared_memory_scratchpad_save(){
void shared_memory_scratchpad_save()
{
scratchpad_state = sram_read(SHARED_MEM_LOC_STATE);
scratchpad_cmd = sram_read(SHARED_MEM_LOC_CMD);
scratchpad_payload = sram_read(SHARED_MEM_LOC_PAYLOAD);
}
void shared_memory_scratchpad_restore(){
void shared_memory_scratchpad_restore()
{
sram_write(SHARED_MEM_LOC_STATE, scratchpad_state);
sram_write(SHARED_MEM_LOC_CMD, scratchpad_cmd);
sram_write(SHARED_MEM_LOC_PAYLOAD, scratchpad_payload);
}
void shared_memory_irq_hook(){
void shared_memory_irq_hook()
{
irq_addr_lo = sram_read(SHARED_IRQ_LOC_LO);
irq_addr_hi = sram_read(SHARED_IRQ_LOC_HI);
sram_write(SHARED_IRQ_HANDLER_LO, 0);
sram_write(SHARED_IRQ_HANDLER_HI, 0);
}
void shared_memory_irq_restore(){
void shared_memory_irq_restore()
{
sram_write(SHARED_IRQ_LOC_LO, irq_addr_lo);
sram_write(SHARED_IRQ_LOC_HI, irq_addr_hi);
}
void shared_memory_put(uint8_t cmd, uint8_t value){
void shared_memory_put(uint8_t cmd, uint8_t value)
{
info("Write shared memory 0x%04x=0x%02x 0x%04x=0x%02x \n",SHARED_MEM_LOC_CMD,cmd,SHARED_MEM_LOC_PAYLOAD,value);
info("Write shared memory 0x%04x=0x%02x 0x%04x=0x%02x \n",
SHARED_MEM_LOC_CMD, cmd, SHARED_MEM_LOC_PAYLOAD, value);
shared_memory_scratchpad_save();
shared_memory_irq_hook();
sram_write(SHARED_MEM_LOC_STATE,SHARED_MEM_SNES_ACK);
sram_write(SHARED_MEM_LOC_CMD,cmd);
sram_write(SHARED_MEM_LOC_PAYLOAD,value);
sram_write(SHARED_MEM_LOC_STATE, SHARED_MEM_SNES_ACK);
sram_write(SHARED_MEM_LOC_CMD, cmd);
sram_write(SHARED_MEM_LOC_PAYLOAD, value);
snes_hirom();
snes_wr_disable();
@ -89,4 +95,3 @@ void shared_memory_put(uint8_t cmd, uint8_t value){
shared_memory_irq_restore();
}