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) ifeq ($(DEBUG),1)
LDFLAGS = -Wl,-u,vfprintf -lprintf_flt LDFLAGS = -Wl,-u,vfprintf -lprintf_flt
CFLAGS = -Iusbdrv -I. -DDEBUG_LEVEL=0 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 else
LDFLAGS = -Wl,-u LDFLAGS = -Wl,-u
CFLAGS = -Iusbdrv -I. -DDEBUG_LEVEL=0 -DNO_DEBUG -DNO_INFO 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__ #ifndef __FIFO_H__
#define __FIFO_H__ #define __FIFO_H__
#define ROM_BUFFER_SIZE 27288 #define ROM_BUFFER_SIZE 30344
#define ROM_HUFFMAN_SIZE 27288 #define ROM_HUFFMAN_SIZE 0
#define ROM_RLE_SIZE 30344 #define ROM_RLE_SIZE 30344
#endif #endif

398
avr/usbload/main.c
View File

@ -25,11 +25,10 @@
#include <util/delay.h> /* for _delay_ms() */ #include <util/delay.h> /* for _delay_ms() */
#include <stdlib.h> #include <stdlib.h>
#include <avr/pgmspace.h> /* required by usbdrv.h */ #include <avr/pgmspace.h> /* required by usbdrv.h */
#include <avr/eeprom.h> #include <avr/eeprom.h>
#include "usbdrv.h" #include "usbdrv.h"
#include "oddebug.h" /* This is also an example for using debug #include "oddebug.h" /* This is also an example for using debug macros */
* macros */
#include "config.h" #include "config.h"
#include "requests.h" /* The custom request numbers we use */ #include "requests.h" /* The custom request numbers we use */
#include "uart.h" #include "uart.h"
@ -41,7 +40,6 @@
#include "usb_bulk.h" #include "usb_bulk.h"
#include "timer.h" #include "timer.h"
#include "watchdog.h" #include "watchdog.h"
#include "huffman-decode.h"
#include "rle.h" #include "rle.h"
#include "loader.h" #include "loader.h"
#include "shared_memory.h" #include "shared_memory.h"
@ -50,7 +48,7 @@
extern const char _rom[] PROGMEM; extern const char _rom[] PROGMEM;
extern FILE uart_stdout; 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]; uint8_t read_buffer[TRANSFER_BUFFER_SIZE];
uint32_t req_addr = 0; uint32_t req_addr = 0;
@ -76,28 +74,29 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
usbRequest_t *rq = (void *) data; usbRequest_t *rq = (void *) data;
uint8_t ret_len = 0; uint8_t ret_len = 0;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
if (rq->bRequest == USB_UPLOAD_INIT) { if (rq->bRequest == USB_UPLOAD_INIT) {
if (req_state != REQ_STATUS_IDLE){ if (req_state != REQ_STATUS_IDLE) {
debug(DEBUG_USB,"USB_UPLOAD_INIT: ERROR state is not REQ_STATUS_IDLE\n"); debug(DEBUG_USB,
"USB_UPLOAD_INIT: ERROR state is not REQ_STATUS_IDLE\n");
return 0; return 0;
} }
req_bank = 0; req_bank = 0;
rx_remaining = 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; sync_errors = 0;
crc = 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) {
/*
* -------------------------------------------------------------------------
*/
} else if (rq->bRequest == USB_UPLOAD_ADDR) {
req_state = REQ_STATUS_UPLOAD; req_state = REQ_STATUS_UPLOAD;
req_addr = rq->wValue.word; req_addr = rq->wValue.word;
req_addr = req_addr << 16; req_addr = req_addr << 16;
@ -105,61 +104,67 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
if (rx_remaining) { if (rx_remaining) {
sync_errors++; sync_errors++;
debug 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); req_addr, rx_remaining, rq->wLength.word, sync_errors);
ret_len = 0; ret_len = 0;
} }
rx_remaining = rq->wLength.word; rx_remaining = rq->wLength.word;
ret_len = USB_MAX_TRANS; ret_len = USB_MAX_TRANS;
if (req_addr && (req_addr % 0x1000) == 0) { if (req_addr && (req_addr % 0x1000) == 0) {
debug(DEBUG_USB,"USB_UPLOAD_ADDR: bank=0x%02x addr=0x%08lx crc=%04x\n", debug(DEBUG_USB,
req_bank, req_addr,crc_check_bulk_memory(req_addr - 0x1000,req_addr,req_bank_size)); "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) { if (req_addr && req_addr % req_bank_size == 0) {
debug(DEBUG_USB,"USB_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx\n", debug(DEBUG_USB, "USB_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx\n",
req_bank, req_addr); req_bank, req_addr);
req_bank++; 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; ret_len = USB_MAX_TRANS;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_DOWNLOAD_INIT) { } 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) { } else if (rq->bRequest == USB_DOWNLOAD_ADDR) {
debug(DEBUG_USB,"USB_DOWNLOAD_ADDR\n"); debug(DEBUG_USB, "USB_DOWNLOAD_ADDR\n");
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_BULK_UPLOAD_INIT) { } else if (rq->bRequest == USB_BULK_UPLOAD_INIT) {
req_bank = 0; req_bank = 0;
rx_remaining = 0; rx_remaining = 0;
debug(DEBUG_USB,"USB_BULK_UPLOAD_INIT: %i %i\n",rq->wValue.word, rq->wIndex.word); debug(DEBUG_USB, "USB_BULK_UPLOAD_INIT: %i %i\n", rq->wValue.word,
req_bank_size = (uint32_t)(1L << rq->wValue.word); rq->wIndex.word);
req_bank_size = (uint32_t) (1L << rq->wValue.word);
req_bank_cnt = rq->wIndex.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; sync_errors = 0;
debug(DEBUG_USB,"USB_BULK_UPLOAD_INIT: bank_size=0x%08lx bank_cnt=0x%x end_addr=0x%08lx\n", debug(DEBUG_USB,
req_bank_size, req_bank_cnt, req_addr_end); "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(); timer_start();
} }
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_BULK_UPLOAD_ADDR) { } else if (rq->bRequest == USB_BULK_UPLOAD_ADDR) {
req_state = REQ_STATUS_BULK_UPLOAD; req_state = REQ_STATUS_BULK_UPLOAD;
@ -167,28 +172,30 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
req_addr = req_addr << 16; req_addr = req_addr << 16;
req_addr = req_addr | rq->wIndex.word; req_addr = req_addr | rq->wIndex.word;
rx_remaining = rq->wLength.word; rx_remaining = rq->wLength.word;
if (req_addr && req_addr % req_bank_size == 0) { if (req_addr && req_addr % req_bank_size == 0) {
#ifdef FLT_DEBUG #ifdef FLT_DEBUG
debug(DEBUG_USB,"USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%.4f\n", debug(DEBUG_USB,
req_bank, req_addr,timer_stop()); "USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%.4f\n",
#else req_bank, req_addr, timer_stop());
debug(DEBUG_USB,"USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%i\n", #else
req_bank, req_addr,timer_stop_int()); debug(DEBUG_USB,
#endif "USB_BULK_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx time=%i\n",
req_bank, req_addr, timer_stop_int());
#endif
req_bank++; 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); sram_bulk_write_start(req_addr);
timer_start(); timer_start();
} else { } else {
sram_bulk_write_start(req_addr); sram_bulk_write_start(req_addr);
} }
ret_len = USB_MAX_TRANS; ret_len = USB_MAX_TRANS;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_BULK_UPLOAD_NEXT) { } else if (rq->bRequest == USB_BULK_UPLOAD_NEXT) {
req_state = REQ_STATUS_BULK_UPLOAD; req_state = REQ_STATUS_BULK_UPLOAD;
@ -198,87 +205,94 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
rx_remaining = rq->wLength.word; rx_remaining = rq->wLength.word;
#if 0 #if 0
if (req_addr && (req_addr % 0x1000) == 0) { if (req_addr && (req_addr % 0x1000) == 0) {
debug(DEBUG_USB,"USB_BULK_UPLOAD_NEXT: bank=0x%02x addr=0x%08lx crc=%04x\n", debug(DEBUG_USB,
req_bank, req_addr,crc_check_bulk_memory(req_addr - 0x1000,req_addr,req_bank_size)); "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); sram_bulk_write_start(req_addr);
#endif #endif
if (req_addr && ( req_addr % req_bank_size) == 0) { if (req_addr && (req_addr % req_bank_size) == 0) {
#ifdef FLT_DEBUG #ifdef FLT_DEBUG
debug(DEBUG_USB,"USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%.4f\n", debug(DEBUG_USB,
req_bank, req_addr,timer_stop()); "USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%.4f\n",
#else req_bank, req_addr, timer_stop());
debug(DEBUG_USB,"USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%i\n", #else
req_bank, req_addr,timer_stop_int()); debug(DEBUG_USB,
#endif "USB_BULK_UPLOAD_NEXT: req_bank=0x%02x addr=0x%08lx time=%i\n",
req_bank, req_addr, timer_stop_int());
#endif
req_bank++; req_bank++;
timer_start(); 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); sram_bulk_write_start(req_addr);
} }
ret_len = USB_MAX_TRANS; ret_len = USB_MAX_TRANS;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_BULK_UPLOAD_END) { } else if (rq->bRequest == USB_BULK_UPLOAD_END) {
if (req_state != REQ_STATUS_BULK_UPLOAD){ if (req_state != REQ_STATUS_BULK_UPLOAD) {
debug(DEBUG_USB,"USB_BULK_UPLOAD_END: ERROR state is not REQ_STATUS_BULK_UPLOAD\n"); debug(DEBUG_USB,
"USB_BULK_UPLOAD_END: ERROR state is not REQ_STATUS_BULK_UPLOAD\n");
return 0; return 0;
} }
debug(DEBUG_USB,"USB_BULK_UPLOAD_END:\n"); debug(DEBUG_USB, "USB_BULK_UPLOAD_END:\n");
req_state = REQ_STATUS_IDLE; req_state = REQ_STATUS_IDLE;
sram_bulk_write_end(); 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; ret_len = 0;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_CRC) { } else if (rq->bRequest == USB_CRC) {
req_addr = rq->wValue.word; req_addr = rq->wValue.word;
req_addr = req_addr << 16; req_addr = req_addr << 16;
req_addr = req_addr | rq->wIndex.word; 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); crc_check_bulk_memory(0x000000, req_addr, req_bank_size);
ret_len = 0; ret_len = 0;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_MODE_SNES) { } else if (rq->bRequest == USB_MODE_SNES) {
req_state = REQ_STATUS_SNES; req_state = REQ_STATUS_SNES;
debug(DEBUG_USB,"USB_MODE_SNES:\n"); debug(DEBUG_USB, "USB_MODE_SNES:\n");
ret_len = 0; ret_len = 0;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_MODE_AVR) { } else if (rq->bRequest == USB_MODE_AVR) {
req_state = REQ_STATUS_AVR; req_state = REQ_STATUS_AVR;
debug(DEBUG_USB,"USB_MODE_AVR:\n"); debug(DEBUG_USB, "USB_MODE_AVR:\n");
ret_len = 0; ret_len = 0;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_AVR_RESET) { } else if (rq->bRequest == USB_AVR_RESET) {
debug(DEBUG_USB,"USB_AVR_RESET:\n"); debug(DEBUG_USB, "USB_AVR_RESET:\n");
soft_reset(); soft_reset();
ret_len = 0; ret_len = 0;
/* /*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
} else if (rq->bRequest == USB_CRC_ADDR) { } else if (rq->bRequest == USB_CRC_ADDR) {
req_state = REQ_STATUS_CRC; req_state = REQ_STATUS_CRC;
req_addr = rq->wValue.word; req_addr = rq->wValue.word;
req_addr = req_addr << 16; req_addr = req_addr << 16;
req_addr = req_addr | rq->wIndex.word; req_addr = req_addr | rq->wIndex.word;
debug(DEBUG_USB,"USB_CRC_ADDR: addr=0x%lx size=%i\n", req_addr, debug(DEBUG_USB, "USB_CRC_ADDR: addr=0x%lx size=%i\n", req_addr,
rq->wLength.word); rq->wLength.word);
req_size = rq->wLength.word; req_size = rq->wLength.word;
req_size = req_size << 2; req_size = req_size << 2;
tx_remaining = 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); crc = crc_check_memory_range(req_addr, req_size, read_buffer);
tx_buffer[0] = crc & 0xff; tx_buffer[0] = crc & 0xff;
@ -288,8 +302,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
} }
usbMsgPtr = data_buffer; usbMsgPtr = data_buffer;
return ret_len; /* default for not implemented requests: return return ret_len; /* default for not implemented requests: return no data back to host */
* no data back to host */
} }
@ -297,33 +310,35 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
void test_read_write(){ void test_read_write()
{
uint8_t i; uint8_t i;
uint32_t addr; uint32_t addr;
avr_bus_active(); avr_bus_active();
addr = 0x000000; addr = 0x000000;
i = 1; i = 1;
while (addr++ <= 0x0000ff){ while (addr++ <= 0x0000ff) {
sram_write(addr,i++); sram_write(addr, i++);
} }
addr = 0x000000; addr = 0x000000;
while (addr++ <= 0x0000ff){ while (addr++ <= 0x0000ff) {
info("read addr=0x%08lx %x\n",addr,sram_read(addr)); info("read addr=0x%08lx %x\n", addr, sram_read(addr));
} }
} }
void test_bulk_read_write(){ void test_bulk_read_write()
{
uint8_t i; uint8_t i;
uint32_t addr; uint32_t addr;
avr_bus_active(); avr_bus_active();
addr = 0x000000; addr = 0x000000;
i = 0; i = 0;
sram_bulk_write_start(addr); sram_bulk_write_start(addr);
while (addr++ <= 0x8000){ while (addr++ <= 0x8000) {
sram_bulk_write(i++); sram_bulk_write(i++);
sram_bulk_write_next(); sram_bulk_write_next();
} }
@ -331,8 +346,8 @@ void test_bulk_read_write(){
addr = 0x000000; addr = 0x000000;
sram_bulk_read_start(addr); sram_bulk_read_start(addr);
while (addr <= 0x8000){ while (addr <= 0x8000) {
info("addr=0x%08lx %x\n",addr,sram_bulk_read()); info("addr=0x%08lx %x\n", addr, sram_bulk_read());
sram_bulk_read_next(); sram_bulk_read_next();
addr++; 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; uint32_t addr = 0;
uint8_t c; uint8_t c;
sram_bulk_read_start(bottom_addr); sram_bulk_read_start(bottom_addr);
for (addr = bottom_addr; addr < top_addr; addr++) { for (addr = bottom_addr; addr < top_addr; addr++) {
c = sram_bulk_read(); c = sram_bulk_read();
if (c!=0xff) if (c != 0xff)
info("addr=0x%08lx c=0x%x\n",addr,c); info("addr=0x%08lx c=0x%x\n", addr, c);
sram_bulk_read_next(); sram_bulk_read_next();
} }
sram_bulk_read_end(); 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"); info("test_crc: clear\n");
avr_bus_active(); avr_bus_active();
sram_bulk_set(0x000000,0x10000,0xff); sram_bulk_set(0x000000, 0x10000, 0xff);
info("test_crc: crc\n"); info("test_crc: crc\n");
crc_check_bulk_memory(0x000000,0x10000,0x8000); crc_check_bulk_memory(0x000000, 0x10000, 0x8000);
info("test_crc: check\n"); 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){ uint16_t read_byte_pgm(uint16_t addr)
return pgm_read_byte((PGM_VOID_P)addr); {
return pgm_read_byte((PGM_VOID_P) addr);
} }
uint16_t read_byte_ee(uint16_t addr){ uint16_t read_byte_ee(uint16_t addr)
return eeprom_read_byte((uint8_t*)addr); {
return eeprom_read_byte((uint8_t *) addr);
} }
void decompress(PGM_VOID_P addr, uint16_t(*fp)(uint16_t)){ void send_reset()
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(){
info("Reset Snes\n"); info("Reset Snes\n");
snes_reset_on(); snes_reset_on();
snes_reset_lo(); snes_reset_lo();
@ -413,7 +403,8 @@ void send_reset(){
snes_reset_off(); snes_reset_off();
} }
void send_irq(){ void send_irq()
{
snes_irq_on(); snes_irq_on();
snes_irq_lo(); snes_irq_lo();
_delay_us(20); _delay_us(20);
@ -421,8 +412,9 @@ void send_irq(){
snes_irq_off(); snes_irq_off();
} }
void set_rom_mode(){ void set_rom_mode()
if (req_bank_size == 0x8000){ {
if (req_bank_size == 0x8000) {
snes_lorom(); snes_lorom();
info("Set Snes lowrom \n"); info("Set Snes lowrom \n");
} else { } else {
@ -432,15 +424,16 @@ void set_rom_mode(){
} }
void usb_connect(){ void usb_connect()
{
uint8_t i = 0; uint8_t i = 0;
info("USB init\n"); info("USB init\n");
usbDeviceDisconnect(); /* enforce re-enumeration, do this while */ usbDeviceDisconnect(); /* enforce re-enumeration, do this while */
cli(); cli();
info("USB disconnect\n"); info("USB disconnect\n");
i = 10; i = 10;
while (--i) { /* fake USB disconnect for > 250 ms */ while (--i) { /* fake USB disconnect for > 250 ms */
led_on(); led_on();
_delay_ms(35); _delay_ms(35);
led_off(); led_off();
_delay_ms(65); _delay_ms(65);
@ -451,9 +444,10 @@ void usb_connect(){
} }
void boot_startup_rom(){ void boot_startup_rom()
{
info("Activate AVR bus\n"); info("Activate AVR bus\n");
avr_bus_active(); avr_bus_active();
@ -464,27 +458,16 @@ void boot_startup_rom(){
snes_lorom(); snes_lorom();
info("Set Snes lowrom \n"); info("Set Snes lowrom \n");
/* rle_decode(&_rom, ROM_BUFFER_SIZE, 0x000000);
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);
dump_memory(0x10000 - 0x100, 0x10000); dump_memory(0x10000 - 0x100, 0x10000);
snes_reset_hi(); snes_reset_hi();
snes_reset_off(); snes_reset_off();
snes_irq_lo(); snes_irq_lo();
snes_irq_off(); snes_irq_off();
info("IRQ off\n"); info("IRQ off\n");
snes_hirom(); snes_hirom();
snes_wr_disable(); snes_wr_disable();
info("Disable snes WR\n"); info("Disable snes WR\n");
snes_bus_active(); snes_bus_active();
info("Activate Snes bus\n"); info("Activate Snes bus\n");
@ -496,20 +479,20 @@ void boot_startup_rom(){
uint8_t i = 0; uint8_t i = 0;
i = 20; i = 20;
info("Wait"); info("Wait");
while (--i){ while (--i) {
_delay_ms(500); _delay_ms(500);
info("."); info(".");
} }
info("\n"); info("\n");
#endif #endif
} }
int main(void) int main(void)
{ {
uart_init(); uart_init();
stdout = &uart_stdout; stdout = &uart_stdout;
info("Sytem start\n"); info("Sytem start\n");
system_init(); system_init();
@ -517,16 +500,16 @@ int main(void)
test_read_write(); test_read_write();
test_bulk_read_write(); test_bulk_read_write();
test_crc(); test_crc();
while(1); while (1);
#endif #endif
info("Boot startup rom\n"); info("Boot startup rom\n");
boot_startup_rom(); boot_startup_rom();
usbInit(); usbInit();
usb_connect(); usb_connect();
while (1){ while (1) {
avr_bus_active(); avr_bus_active();
info("Activate AVR bus\n"); info("Activate AVR bus\n");
info("IRQ off\n"); info("IRQ off\n");
@ -535,13 +518,13 @@ int main(void)
info("Set Snes lowrom\n"); info("Set Snes lowrom\n");
snes_lorom(); snes_lorom();
info("Disable snes WR\n"); info("Disable snes WR\n");
snes_wr_disable(); snes_wr_disable();
sei(); sei();
info("USB poll\n"); info("USB poll\n");
while (req_state != REQ_STATUS_SNES){ while (req_state != REQ_STATUS_SNES) {
usbPoll(); usbPoll();
} }
shared_memory_put(SHARED_MEM_CMD_TERMINATE,0); shared_memory_put(SHARED_MEM_CMD_TERMINATE, 0);
info("USB poll done\n"); info("USB poll done\n");
snes_reset_hi(); snes_reset_hi();
snes_reset_off(); snes_reset_off();
@ -549,7 +532,7 @@ int main(void)
snes_irq_off(); snes_irq_off();
info("IRQ off\n"); info("IRQ off\n");
set_rom_mode(); set_rom_mode();
snes_wr_disable(); snes_wr_disable();
info("Disable snes WR\n"); info("Disable snes WR\n");
snes_bus_active(); snes_bus_active();
info("Activate Snes bus\n"); info("Activate Snes bus\n");
@ -558,47 +541,46 @@ int main(void)
send_reset(); send_reset();
info("Poll\n"); info("Poll\n");
while (req_state != REQ_STATUS_AVR){ while (req_state != REQ_STATUS_AVR) {
usbPoll(); usbPoll();
#ifdef DO_IRQ #ifdef DO_IRQ
uint8_t i; uint8_t i;
uint16_t irq_count = 0; uint16_t irq_count = 0;
i = 10; i = 10;
while (--i) { while (--i) {
_delay_ms(100); _delay_ms(100);
} }
info("Send IRQ %i\n",++irq_count); info("Send IRQ %i\n", ++irq_count);
send_irq(); send_irq();
#endif #endif
#ifdef DO_BUS_STEALING #ifdef DO_BUS_STEALING
avr_bus_active(); avr_bus_active();
sram_bulk_read_start(0x003000); sram_bulk_read_start(0x003000);
c = sram_bulk_read(); c = sram_bulk_read();
i = 5; i = 5;
while (--i) { while (--i) {
_delay_ms(500); _delay_ms(500);
info("Wait to switch to snes mode %i\n", i); info("Wait to switch to snes mode %i\n", i);
} }
if (req_bank_size == 0x8000){ if (req_bank_size == 0x8000) {
snes_lorom(); snes_lorom();
info("Set Snes lowrom \n"); info("Set Snes lowrom \n");
} else { } else {
snes_hirom(); snes_hirom();
info("Set Snes hirom \n"); info("Set Snes hirom \n");
} }
snes_wr_disable(); snes_wr_disable();
info("Disable snes WR\n"); info("Disable snes WR\n");
snes_bus_active(); snes_bus_active();
info("Activate Snes bus\n"); info("Activate Snes bus\n");
info("Read 0x3000=%c\n",c); info("Read 0x3000=%c\n", c);
#endif #endif
} }
} }
return 0; return 0;
} }

81
avr/usbload/rle.c
View File

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

10
avr/usbload/rle.h
View File

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

45
avr/usbload/shared_memory.c
View File

@ -19,11 +19,11 @@
* *
* ===================================================================================== * =====================================================================================
*/ */
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <util/delay.h> #include <util/delay.h>
#include "shared_memory.h" #include "shared_memory.h"
#include "config.h" #include "config.h"
@ -38,55 +38,60 @@ uint8_t scratchpad_state;
uint8_t scratchpad_cmd; uint8_t scratchpad_cmd;
uint8_t scratchpad_payload; uint8_t scratchpad_payload;
void shared_memory_scratchpad_save(){ void shared_memory_scratchpad_save()
{
scratchpad_state = sram_read(SHARED_MEM_LOC_STATE); scratchpad_state = sram_read(SHARED_MEM_LOC_STATE);
scratchpad_cmd = sram_read(SHARED_MEM_LOC_CMD); scratchpad_cmd = sram_read(SHARED_MEM_LOC_CMD);
scratchpad_payload = sram_read(SHARED_MEM_LOC_PAYLOAD); 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_STATE, scratchpad_state);
sram_write(SHARED_MEM_LOC_CMD, scratchpad_cmd); sram_write(SHARED_MEM_LOC_CMD, scratchpad_cmd);
sram_write(SHARED_MEM_LOC_PAYLOAD, scratchpad_payload); 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_lo = sram_read(SHARED_IRQ_LOC_LO);
irq_addr_hi = sram_read(SHARED_IRQ_LOC_HI); irq_addr_hi = sram_read(SHARED_IRQ_LOC_HI);
sram_write(SHARED_IRQ_HANDLER_LO, 0); sram_write(SHARED_IRQ_HANDLER_LO, 0);
sram_write(SHARED_IRQ_HANDLER_HI, 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_LO, irq_addr_lo);
sram_write(SHARED_IRQ_LOC_HI, irq_addr_hi); 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_scratchpad_save();
shared_memory_irq_hook(); shared_memory_irq_hook();
sram_write(SHARED_MEM_LOC_STATE,SHARED_MEM_SNES_ACK); sram_write(SHARED_MEM_LOC_STATE, SHARED_MEM_SNES_ACK);
sram_write(SHARED_MEM_LOC_CMD,cmd); sram_write(SHARED_MEM_LOC_CMD, cmd);
sram_write(SHARED_MEM_LOC_PAYLOAD,value); sram_write(SHARED_MEM_LOC_PAYLOAD, value);
snes_hirom(); snes_hirom();
snes_wr_disable(); snes_wr_disable();
snes_bus_active(); snes_bus_active();
_delay_ms(50); _delay_ms(50);
avr_bus_active(); avr_bus_active();
snes_irq_lo(); snes_irq_lo();
snes_irq_off(); snes_irq_off();
snes_lorom(); snes_lorom();
snes_wr_disable(); snes_wr_disable();
shared_memory_scratchpad_restore(); shared_memory_scratchpad_restore();
shared_memory_irq_restore(); shared_memory_irq_restore();
} }

2
avr/usbload/shared_memory.h
View File

@ -17,7 +17,7 @@
* *
* ===================================================================================== * =====================================================================================
*/ */
#ifndef __SHARED_MEMORY_H__ #ifndef __SHARED_MEMORY_H__
#define __SHARED_MEMORY_H__ #define __SHARED_MEMORY_H__