esError storageWrite(
struct storageSpace * space,
const void * buffer) {
esError error;
if ((error = storageClearSpace(space))) {
return (error);
}
if ((error = flashWrite(STORAGE_DATA_ADDRESS(space->phy.base), buffer, space->data.size))) {
return (error);
}
space->data.checksum = checksumParity8(buffer, space->data.size);
space->checksum = 0;
space->checksum = checksumParity8(space, sizeof(*space));
if ((error = flashWrite(space->phy.base, space, sizeof(*space)))) {
return (error);
}
return (ES_ERROR_NONE);
}
/******************************************************************************
Name: flashWriteCmd
Description: Sends a command sequence to flash.
Parameters: 1) command
2) address (for sector erase command only)
Returns: none
******************************************************************************/
void flashWriteCmd(U8 cmd, U32 adr)
{
/* write unlock commands */
flashWrite(ADR_UNLOCK1, (U16)CMD_UNLOCK1);
flashWrite(ADR_UNLOCK2, (U16)CMD_UNLOCK2);
/* write command */
if (cmd == CMD_SECTOR_ERASE) flashWrite(adr, (U16)CMD_SECTOR_ERASE);
else flashWrite(ADR_UNLOCK1, (U16)cmd);
}
void write16(const u32 address, const u16 value)
{
switch (address >> 24)
{
case 8:
if (address == 0x80000c4 || address == 0x80000c6 || address == 0x80000c8)
{
rtcWrite(address, value);
}
break;
case 13:
if (game.hasEEPROM())
{
eepromWrite(address, (u8)value);
}
break;
case 14:
if (game.hasSRAM())
{
sramWrite(address, (u8)value);
}
else if (game.hasFlash())
{
flashWrite(address, (u8)value);
}
break;
default:
break;
}
}
/******************************************************************************
Name: GNDS_FL_Write
Description: Writes to flash memory.
Parameters: 1) start address (in flash memory space)
2) pointer to buffer
3) size = number of words to write
Returns: GD_OK
GD_ERR_FLASH_WRITE if device returns an error
GD_ERR_TIMEOUT if custom timeout
******************************************************************************/
GERR GNDS_FL_Write(U32 address, U16* data, U32 size)
{
U16 rd;
U32 i, timeout;
GERR ferr;
ferr = GD_OK;
for (i = 0; i < size; i++)
{
flashWriteCmd(CMD_PROGRAM, 0);
flashWrite(address, data[i]);
/* wait until programming is finished */
ferr = GD_ERR_BAD_PARAMETER;
timeout = TIMEOUT;
while ((ferr == GD_ERR_BAD_PARAMETER)&&((timeout--) > 0))
{
rd = flashRead(address);
if ((rd&DQ7)==(data[i]&DQ7)) ferr = GD_OK;
else if ((rd&DQ5)==DQ5)
{
/* check DQ7 again according to flash device specification */
rd = flashRead(address);
if ((rd&DQ7)==(data[i]&DQ7)) ferr = GD_OK;
else ferr = GD_ERR_FLASH_WRITE;
}
}
if (timeout == 0) ferr = GD_ERR_TIMEOUT;
if (ferr != GD_OK) return ferr;
address++;
}
return ferr;
}
/*-----------------------------------------------------------------------
* Write a word to Flash, returns:
* 0 - OK
* 1 - write timeout
* 2 - Flash not erased
*/
static int write_word (flash_info_t * info, ulong dest, ulong data)
{
flash_dev_t *dev = getFlashDevFromInfo (info);
int addr = dest - info->start[0];
if (!dev)
return 1;
if (OK != flashWrite (dev, addr, (char *) &data, sizeof (ulong))) {
printf ("ERROR: could not write to addr=0x%x, data=0x%x\n",
(unsigned int) addr, (unsigned) data);
return 1;
}
if ((addr % FLASH_SECTOR_SIZE) == 0)
printf (".");
PRINTF ("write_word:0x%x, base=0x%x, addr=0x%x, data=0x%x\n",
(unsigned) info->start[0],
(unsigned) dest,
(unsigned) (dest - info->start[0]), (unsigned) data);
return (0);
}
static void ram_to_rom(struct ParseState *Parser, struct Value *ReturnValue,
struct Value **Param, int NumArgs)
{
(void) ReturnValue;
(void) NumArgs;
(void) Param;
//delete flash page
PlatformPrintf(Parser->pc, "erasing flash\n");
if (!flashErase(sector))
{
//write data to flash
PlatformPrintf(Parser->pc, "writing to flash\n");
if (!flashWrite((uint32_t *) flash_base, script_buffer,
strlen(script_buffer) + 1))
{
PlatformPrintf(Parser->pc, "done!\n");
}
else
{
PlatformPrintf(Parser->pc, "!! writing error !!\n");
}
}
else
{
PlatformPrintf(Parser->pc, "!! flash erasing error !!\n");
}
}
void eeprom_flush(void *arg) {
(void)arg;
flashErase(((uint32_t)&flash_area) / 1024, 1);
flashWrite((uint8_t *)flash_backing, (const uint8_t *)&flash_area,
sizeof(flash_backing));
flash_state = STATE_CLEAN;
}
void writeToFlash(void) {
flashState.version = FLASH_DATA_VERSION;
scheduleMsg(&logger, "FLASH_DATA_VERSION=%d", flashState.version);
crc result = flashStateCrc(&flashState);
flashState.value = result;
scheduleMsg(&logger, "Reseting flash=%d", FLASH_USAGE);
flashErase(FLASH_ADDR, FLASH_USAGE);
scheduleMsg(&logger, "Flashing with CRC=%d", result);
time_t now = chTimeNow();
result = flashWrite(FLASH_ADDR, (const char *) &flashState, FLASH_USAGE);
scheduleMsg(&logger, "Flash programmed in (ms): %d", chTimeNow() - now);
scheduleMsg(&logger, "Flashed: %d", result);
}
void CalibrationTable::createFastCal(void)
{
#ifdef NZS_FAST_CAL
int32_t i;
uint16_t cs=0;
uint16_t data[256];
int32_t j;
j=0;
cs=0;
LOG("setting fast calibration");
for (i=0; i<16384; i++)
{
uint16_t x;
x=reverseLookup(i*4);
data[j]=x;
j++;
if (j>=256)
{
flashWrite(&NVM->FastCal.angle[i-255],data,256*sizeof(uint16_t));
//LOG("Wrote fastcal at index %d-%d", i-255, i);
j=0;
}
cs+=x;
}
//update the checksum
flashWrite(&NVM->FastCal.checkSum,&cs,sizeof(uint16_t));
fastCalVaild=true;
//this is a quick test
/*
for (i=0; i<16384; i++)
{
LOG("fast Cal %d,%d,%d",i,NVM->FastCal.angle[i],(uint32_t)reverseLookup(i*4));
}
*/
#endif
}
// -------------------------------------
// Main function
// -------------------------------------
void appMain(void)
{
uint16_t i;
// timers (used to get an extra interrupt context)
alarmInit(&timer, onTimer, NULL);
alarmSchedule(&timer, 1000);
// radio
radioSetReceiveHandle(radioRecvCb);
radioOn();
for (i = 0; i < BUFFER_SIZE; i++) {
buffer[i] = i;
}
randomInit();
// SELECT_FLASH;
// extFlashBulkErase();
// UNSELECT_FLASH;
for (i = 0; ; i++) {
uint32_t address = i * 64ul;
SELECT_FLASH;
if (IS_ALIGNED(address, EXT_FLASH_SECTOR_SIZE)) {
PRINTF("erase address %lu\n", address);
flashErase(address);
}
PRINTF("write address %lu\n", address);
flashWrite(address);
if (address > 0) {
PRINTF("verify...\n");
flashRead(address - 64);
}
UNSELECT_FLASH;
msleep(randomInRange(400, 1000));
PRINTF("send smth to radio...\n");
radioSend("hello world", sizeof("hello world"));
greenLedToggle();
}
}
void writeToFlash(void) {
#if EFI_INTERNAL_FLASH
persistentState.size = PERSISTENT_SIZE;
persistentState.version = FLASH_DATA_VERSION;
scheduleMsg(&logger, "flash compatible with %d", persistentState.version);
crc_t result = flashStateCrc(&persistentState);
persistentState.value = result;
scheduleMsg(&logger, "Reseting flash: size=%d", PERSISTENT_SIZE);
flashErase(FLASH_ADDR, PERSISTENT_SIZE);
scheduleMsg(&logger, "Flashing with CRC=%d", result);
efitimems_t nowMs = currentTimeMillis();
result = flashWrite(FLASH_ADDR, (const char *) &persistentState, PERSISTENT_SIZE);
scheduleMsg(&logger, "Flash programmed in (ms): %d", currentTimeMillis() - nowMs);
scheduleMsg(&logger, "Flashing result: %d", result);
#endif /* EFI_INTERNAL_FLASH */
}
__attribute__((naked)) __attribute__((noreturn)) void write(uint8_t *work_area_p,
uint8_t *fifo_end,
uint8_t *target_address,
uint32_t count)
{
uint32_t retval;
volatile work_area_t *work_area = (work_area_t *) work_area_p;
uint8_t *fifo_start = (uint8_t *) work_area->rp;
while (count) {
volatile int32_t fifo_linear_size;
/* Wait for some data in the FIFO */
while (work_area->rp == work_area->wp)
;
if (work_area->wp == 0) {
/* Aborted by other party */
break;
}
if (work_area->rp > work_area->wp) {
fifo_linear_size = fifo_end-work_area->rp;
} else {
fifo_linear_size = (work_area->wp - work_area->rp);
if (fifo_linear_size < 0)
fifo_linear_size = 0;
}
if (fifo_linear_size < 16) {
/* We should never get here */
continue;
}
retval = flashWrite((uint32_t) target_address, (uint8_t **) &work_area->rp, fifo_linear_size);
if (retval != SUCCESS) {
work_area->rp = (uint8_t *)retval;
break;
}
target_address += fifo_linear_size;
if (work_area->rp >= fifo_end)
work_area->rp = fifo_start;
count -= fifo_linear_size;
}
__asm("bkpt 0");
}
void writeToFlashNow(void) {
scheduleMsg(logger, " !!!!!!!!!!!!!!!!!!!! BE SURE NOT WRITE WITH IGNITION ON !!!!!!!!!!!!!!!!!!!!");
persistentState.size = PERSISTENT_SIZE;
persistentState.version = FLASH_DATA_VERSION;
scheduleMsg(logger, "flash compatible with %d", persistentState.version);
crc_t crcResult = flashStateCrc(&persistentState);
persistentState.value = crcResult;
scheduleMsg(logger, "Reseting flash: size=%d", PERSISTENT_SIZE);
flashErase(FLASH_ADDR, PERSISTENT_SIZE);
scheduleMsg(logger, "Flashing with CRC=%d", crcResult);
efitimems_t nowMs = currentTimeMillis();
int result = flashWrite(FLASH_ADDR, (const char *) &persistentState, PERSISTENT_SIZE);
scheduleMsg(logger, "Flash programmed in %dms", currentTimeMillis() - nowMs);
bool isSuccess = result == FLASH_RETURN_SUCCESS;
if (isSuccess) {
scheduleMsg(logger, FLASH_SUCCESS_MSG);
} else {
scheduleMsg(logger, "Flashing failed");
}
maxLockTime = 0;
}
int flashWriteBlock( void *dst, const void *src, int cb )
{
uint32_t *d = dst;
const uint32_t *s = src;
int rc;
// convert count of bytes to count of uint32_t
int n = (cb >> 2);
// round up if remainder
if (cb & 0x02)
n++;
// copy block one uint32_t at a time
while (n-- > 0)
{
rc = flashWrite(d++, *s++);
if (rc != 0)
return rc;
}
return 0;
}
void write8(const u32 address, const u8 value)
{
switch (address >> 24)
{
case 13:
if (game.hasEEPROM())
{
eepromWrite(address, value);
}
break;
case 14:
if (game.hasSRAM())
{
sramWrite(address, value);
}
else if (game.hasFlash())
{
flashWrite(address, value);
}
break;
default:
break;
}
}
/**
* reads the EEPROM common configuration area, if this area is invalid then
* a default configuration is used and also stored in EEPROM for next start,
* it also reads the backplane fru eeprom
*
* \return E_OK if configuration is valid, otherwise Errorcode
*/
int global_config(void)
{
unsigned int eeprom_valid = 0x00000000;
#if defined(CFG_LAN) || defined(CFG_PEF_ENABLE)
unsigned short i;
#endif
#ifdef CFG_ONCHIP_FLASH_GLOBAL_CONF
unsigned char buf[] = { 0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00 }; /* 0xDEADBEEF */
#endif
#ifdef CFG_LAN
unsigned short len;
#endif
/* read valid flag */
#ifndef CFG_ONCHIP_FLASH_GLOBAL_CONF
fs_read(FILE_INTEGRITY_AREA1, 0, sizeof(unsigned int), &eeprom_valid);
#else
eeprom_valid = *(unsigned int *)OCFLH_GBLCFG_ADDR_BASE;
#endif
/* the EEPROM configuration is empty or invalid */
if (eeprom_valid != EEPROM_VALID_FLAG)
{
/* init global config with default values */
global_conf.allow_sdr_access = YES;
global_conf.allow_coldreset = YES;
global_conf.global_enables = CFG_GLOBAL_ENABLES;
#ifdef CFG_MCMC
global_conf.operation_mode = CFG_OPERATION_MODE;
#endif
#ifdef CFG_LAN
/* load LAN configuration */
load_global_lan_config();
/* save the lan configuration to eeprom */
save_global_lan_config();
/* load user configuration */
load_global_user_config();
/* save the user configuration to eeprom */
save_global_user_config();
/* restore MC NC-SI MAC address from FRU */
custom_set_ncsi_mac();
#endif /* CFG_LAN */
/* load default oem configuration */
custom_load_oem_config_defaults();
/* save default configuration settings to eeprom */
save_oem_config();
#ifdef CFG_UART_MUX
/* UART MUX setting needs to be updated */
custom_set_uart_mux();
#endif
/* set event receiver address and lun, default */
event_receiver_addr = 0x20;
event_receiver_lun = 0x00;
/* init the SDR Repository */
sdr_repo_info.add_timestamp = 0xFFFFFFFF;
sdr_repo_info.erase_timestamp = 0xFFFFFFFF;
#ifdef CFG_PEF_ENABLE
/* init PEF configuration */
pef_config.set_in_progress = 0x00;
pef_config.control = DISABLE_PEF;
pef_config.action_control = PEF_DEFAULT_ACTION;
pef_config.startup_delay = PEF_DEFAULT_STARTUP_DELAY;
pef_config.alert_startup_delay = PEF_DEFAULT_ALERT_STARTUP_DELAY;
pef_config.number_event_filters = 0;
pef_config.number_alert_policy = 0;
memset(&pef_config.system_guid.node[0], 0x00, 16);
pef_config.number_alert_strings = 0;
pef_config.number_group_control = 0;
/* init PEF event filters */
for (i = 0; i < MAX_EVENT_FILTERS; i++)
{
event_filter_table[i].config = DISABLE_FILTER;
}
#endif /* CFG_PEF_ENABLE */
#ifdef CFG_ONCHIP_FLASH_GLOBAL_CONF
flashErase(OCFLH_GBLCFG_SECT_START, OCFLH_GBLCFG_SECT_END);
flashWrite((void *)OCFLH_GBLCFG_ADDR_BASE, (void *)buf, sizeof(buf));
eeprom_valid = *(unsigned int *)OCFLH_GBLCFG_ADDR_BASE;
#endif
}
else /* valid EEPROM configuration exists */
{
/* init global config with default values */
global_conf.allow_sdr_access = YES;
global_conf.allow_coldreset = YES;
global_conf.global_enables = CFG_GLOBAL_ENABLES;
#ifdef CFG_MCMC
global_conf.operation_mode = CFG_OPERATION_MODE;
#endif
#if defined (CFG_ATCA) || defined (CFG_MCMC)
/* set event receiver address and lun, default */
event_receiver_addr = 0x20;
event_receiver_lun = 0x00;
#endif /* CFG_ATCA || CFG_MCMC */
#ifdef CFG_LAN
/* read lan interface specific parameter */
spi_eeprom_safe_area_read(LAN_CONFIGURATION_OFFSET, sizeof(global_lan_conf_t), &lan_conf);
/* check CRC for lan configuration */
len = ((unsigned char *)(&(lan_conf.crc)) - (unsigned char *)(&lan_conf));
if (!_check_crc(&lan_conf, len, lan_conf.crc))
{
uart_printf("Error Lan Config CRC\n");
}
#ifdef CFG_HW_DEPENDENT_LAN_ADDRESS
custom_set_hw_dependent_ip_mac_addr();
#endif
/* set volatile privilege level to the non-volatile value */
lan_conf.priv_level_curr = lan_conf.priv_level;
/* read user specific parameter */
spi_eeprom_safe_area_read(USER_CONFIGURATION_OFFSET, sizeof(global_user_conf_t), &global_user);
/* check CRC for user configuration */
len = ((unsigned char *)(&(global_user.crc)) - (unsigned char *)(&global_user));
if (!_check_crc(&global_user, len, global_user.crc))
{
uart_printf("Error User Config CRC\n");
}
/* decrypt the passwords with the XTEA algorithm */
for (i = 0; i < configPRIV_MAX_USERS; i++)
{
if (xtea_decrypt_block((unsigned char *)(global_user.user[i].password), IPMI_PRIV_PW_MAX_LEN, pw_crypto_key) != 0)
{
uart_printf("Error User Config Decryption\n");
}
}
#endif /* CFG_LAN */
/* read oem configuration from eeprom */
load_oem_config();
/* load oem configuration defaults, if version number is different */
if (oem_config.version != OEM_CONFIG_VERSION)
{
uart_printf("Configuration setting EEPROM layout (version 0x%02X) "
"updated to version 0x%02X\n", oem_config.version, OEM_CONFIG_VERSION);
/* load default oem configuration */
custom_load_oem_config_defaults();
/* save default configuration settings to eeprom */
save_oem_config();
#ifdef CFG_UART_MUX
/* UART MUX setting needs to be updated */
custom_set_uart_mux();
#endif
}
}
return E_OK;
}
void flashDelayedWrite(u32 address, u8 byte)
{
saveType = 2;
cpuSaveGameFunc = flashWrite;
flashWrite(address, byte);
}
int flashIHexFile(FIL* file)
{
IHexRecord irec;
flashsector_t sector;
bool erasedSectors[FLASH_SECTOR_COUNT] = { FALSE };
flashaddr_t baseAddress = 0;
flashaddr_t address = 0;
while (Read_IHexRecord(&irec, file) == IHEX_OK)
{
switch (irec.type)
{
case IHEX_TYPE_00: /**< Data Record */
/* Compute the target address in flash */
address = baseAddress + irec.address;
/* Erase the corresponding addresses if needed */
for (sector = flashSectorAt(address); sector <= flashSectorAt(address + irec.dataLen - 1); ++sector)
{
/* Check if the sector has been erased during this IHex flashing procedure to
prevent erasing already written data */
if (erasedSectors[sector] == TRUE)
continue;
/* Check if the sector in flash needs to be erased */
if (flashIsErased(flashSectorBegin(sector), flashSectorSize(sector)) == FALSE)
{
/* Erase the sector */
if (flashSectorErase(sector) != FLASH_RETURN_SUCCESS)
return BOOTLOADER_ERROR_BADFLASH;
}
/* Set the erased flag to prevent erasing the same sector twice during
the IHex flashing procedure */
erasedSectors[sector] = TRUE;
}
/* Write the data in flash */
if (flashWrite(address, (const char*)irec.data, irec.dataLen) != FLASH_RETURN_SUCCESS)
return BOOTLOADER_ERROR_BADFLASH;
break;
case IHEX_TYPE_04: /**< Extended Linear Address Record */
/* Compute the base address of the following data records */
baseAddress = irec.data[0];
baseAddress <<= 8;
baseAddress += irec.data[1];
baseAddress <<= 16;
break;
case IHEX_TYPE_01: /**< End of File Record */
/* Check that the end of file record is at the end of the file... */
return f_eof(file) ? BOOTLOADER_SUCCESS : BOOTLOADER_ERROR_BADHEX;
case IHEX_TYPE_05: /**< Start Linear Address Record */
/* Ignored */
break;
case IHEX_TYPE_02: /**< Extended Segment Address Record */
case IHEX_TYPE_03: /**< Start Segment Address Record */
/* Not supported */
return BOOTLOADER_ERROR_BADHEX;
}
}
return BOOTLOADER_ERROR_BADHEX;
}
STATUS flashDiag (flash_dev_t * dev)
{
unsigned int *buf = 0;
int i, len, sector;
int rv = ERROR;
if (flashCheck (dev) == ERROR)
return ERROR;
printf ("flashDiag: Testing device %d, "
"base: 0x%x, %d sectors @ %d kB = %d kB\n",
DEV_NO (dev), dev->base,
dev->sectors,
1 << (dev->lgSectorSize - 10),
dev->sectors << (dev->lgSectorSize - 10));
len = 1 << dev->lgSectorSize;
printf ("flashDiag: Erasing\n");
if (flashErase (dev) == ERROR) {
printf ("flashDiag: Erase failed\n");
goto done;
}
printf ("%d bytes requested ...\n", len);
buf = malloc (len);
printf ("allocated %d bytes ...\n", len);
if (buf == 0) {
printf ("flashDiag: Out of memory\n");
goto done;
}
/*
* Write unique counting pattern to each sector
*/
for (sector = 0; sector < dev->sectors; sector++) {
printf ("flashDiag: Write sector %d\n", sector);
for (i = 0; i < len / 4; i++)
buf[i] = sector << 24 | i;
if (flashWrite (dev,
sector << dev->lgSectorSize,
(char *) buf, len) == ERROR) {
printf ("flashDiag: Write failed (dev: %d, sector: %d)\n",
DEV_NO (dev), sector);
goto done;
}
}
/*
* Verify
*/
for (sector = 0; sector < dev->sectors; sector++) {
printf ("flashDiag: Verify sector %d\n", sector);
if (flashRead (dev,
sector << dev->lgSectorSize,
(char *) buf, len) == ERROR) {
printf ("flashDiag: Read failed (dev: %d, sector: %d)\n",
DEV_NO (dev), sector);
goto done;
}
for (i = 0; i < len / 4; i++) {
if (buf[i] != (sector << 24 | i)) {
printf ("flashDiag: Verify error "
"(dev: %d, sector: %d, offset: 0x%x)\n",
DEV_NO (dev), sector, i);
printf ("flashDiag: Expected 0x%08x, got 0x%08x\n",
sector << 24 | i, buf[i]);
goto done;
}
}
}
printf ("flashDiag: Erasing\n");
if (flashErase (dev) == ERROR) {
printf ("flashDiag: Final erase failed\n");
goto done;
}
rv = OK;
done:
if (buf)
free (buf);
if (rv == OK)
printf ("flashDiag: Device %d passed\n", DEV_NO (dev));
else
printf ("flashDiag: Device %d failed\n", DEV_NO (dev));
return rv;
}
void cmd_flash(BaseSequentialStream *chp, int argc, char *argv[])
{
int j, blockoffset;
int status, address;
char readBufferBefore[32];
flashsector_t i;
chprintf(chp, "Flash test UTIL\r\n");
/* Handle warnings: */
if (argc >= 1)
{
if (strncmp(argv[0], "write", sizeof("write")) == 0)
{
if (argc >= 3)
{
blockoffset = atoi(argv[1]);
if (blockoffset < 0 || blockoffset > FLASH_BLOCK_TESTCASE_COUNT)
{
chprintf(chp, "Offset must between %d and %d. Actual one was: %d \r\n",
0, FLASH_BLOCK_TESTCASE_COUNT, blockoffset);
return;
}
/* use the fourth memory block for the tests */
address = FLASH_BASEADDR + (blockoffset * FLASH_BLOCKSIZE);
/* extract the new value to store into it */
readBufferBefore[0] = atoi(argv[2]);
status = flashWrite(address, readBufferBefore, FLASH_BLOCKSIZE);
if (status != FLASH_RETURN_SUCCESS)
{
chprintf(chp, "Writing returned %d \r\n", status);
return;
}
chprintf(chp, "test sector %u : stored at 0x%x %d\r\n",
flashSectorAt(address), address, readBufferBefore[0]);
}
else
{
chprintf(chp, "flash needs additional parameter\r\n");
}
}
else if (strncmp(argv[0], "read", sizeof("read")) == 0)
{
for (i = 0; i < FLASH_BLOCK_TESTCASE_COUNT; ++i)
{
address = FLASH_BASEADDR + (i * FLASH_BLOCKSIZE);
chprintf(chp, "test sector %u\t: 0x%x -> 0x%x (%u bytes)\r\n",
flashSectorAt(address), address,
address + FLASH_BLOCKSIZE,
FLASH_BLOCKSIZE);
status = flashRead(address, readBufferBefore, FLASH_BLOCKSIZE);
if (status != FLASH_RETURN_SUCCESS)
{
chprintf(chp, "Reading returned %d\r\n", status);
return;
}
for (j = 0; j < FLASH_BLOCKSIZE; j++)
{
chprintf(chp, "%02X ", readBufferBefore[j]);
}
chprintf(chp, "\r\n");
}
}
}
else
{
flash_usage(chp);
}
}
void evalOpcode(unsigned char opcode) {
int i;
int16 opr1, opr2, opr3;
unsigned int16 genPurpose = 0;
if (opcode & 0b10000000) {
genPurpose = gblMemPtr + 2;
gblMemPtr = ((((unsigned int16)opcode & 0b00111111) << 8) + 2*fetchNextOpcode());
opr1 = fetchNextOpcode();
if (opcode & 0b01000000) {
for (i = 0; i < (opr1 + 3); i++) {
inputPop();
}
}
for (i = 0; i < opr1; i++) {
inputPush (stkPop());
}
inputPush (gblStkPtr);
inputPush (genPurpose);
inputPush(gblInputStkPtr - (opr1 + 2));
return;
}
switch (opcode) {
case CODE_END:
gblLogoIsRunning = 0;
output_low (RUN_LED);
// clear thes variables just in case.
gblLoopAddress = 0;
gblRepeatCount = 0;
break;
case NUM8:
int8 Hi3 = fetchNextOpcode();
stkPush(Hi3);
break;
case NUM16:
int8 Hi2 = fetchNextOpcode();
int8 Lo2 = fetchNextOpcode();
unsigned int16 teste4 = Hi2 << 8;
teste4 += Lo2;
stkPush (teste4);
break;
case LIST:
stkPush(gblMemPtr + 2); //incremento de 2 em 2
gblMemPtr += (2 * fetchNextOpcode());
break;
case EOL:
genPurpose = stkPop();
if (genPurpose > gblMemPtr) {
//printf(usb_cdc_putc,"genPurpose >>>> gblMemPtr");
gblMemPtr = genPurpose;
} else {
//printf(usb_cdc_putc,"genPurpose <<<< gblMemPtr");
gblMemPtr = genPurpose;
gblRepeatCount = stkPop(); // repeat count
//printf(usb_cdc_putc," gblRepeatCount %Lu \n",genPurpose);
if (gblRepeatCount > 1)
gblRepeatCount--;
if (gblRepeatCount != 1) {
stkPush (gblRepeatCount);
stkPush (gblMemPtr);
}
}
break;
case EOLR:
if (stkPop()) { // if condition is true
stkPop(); // throw away the loop address
gblMemPtr = stkPop(); // fetch the next command address
} else { // if condition if false -> keep on looping.
gblMemPtr = stkPop();
stkPush (gblMemPtr);
delay_ms(5); // this prevents the waituntil loop to execute too rapidly
// which has proven to cause some problems when reading sensor values.
}
break;
case LTHING:
genPurpose = 2 * fetchNextOpcode(); // index of the input variable
opr1 = inputPop(); // base address in the input stack
inputPush(opr1); // push the base address back to the stack.
stkPush (gblInputStack[opr1 + genPurpose]);
break;
case STOP:
case OUTPUT:
if (opcode == OUTPUT){
genPurpose = stkPop(); // this is the output value
}
opr1 = inputPop(); // this is the proc-input stack base address
gblMemPtr = inputPop(); // this is the return address
opr2 = inputPop(); // this is the data stack index;
// remove any remaining data that belongs to the current procedure from the data stack
// Usually this is important for the STOP opcode.
while (gblStkPtr > opr2){
stkPop();
}
// remove the procedure inputs from the input stack
while (gblInputStkPtr > opr1){
inputPop();
}
// Output will push the output to the stack
if (opcode == OUTPUT){
stkPush (genPurpose);
}
break;
case REPEAT:
gblLoopAddress = stkPop();
gblRepeatCount = stkPop();
// these will be poped by EOL
stkPush (gblMemPtr); // address after repeat is complete
if (gblRepeatCount > 1) {
stkPush (gblRepeatCount);
stkPush (gblLoopAddress); // address while still repeating
gblMemPtr = gblLoopAddress;
} else if (gblRepeatCount == 1) {
gblMemPtr = gblLoopAddress;
} else { // if loop count = 0
gblMemPtr = stkPop();
}
break;
case COND_IF:
opr1 = stkPop(); // if true pointer address
opr2 = stkPop(); // condition
if (opr2) {
stkPush(gblMemPtr);
gblMemPtr = opr1;
}
break;
case COND_IFELSE:
opr1 = stkPop(); // if false pointer address
opr2 = stkPop(); // if true pointer address
opr3 = stkPop(); // condition
stkPush(gblMemPtr);
if (opr3) {
gblMemPtr = opr2;
} else {
gblMemPtr = opr1;
}
break;
case BEEP:
beep();
break;
case WAITUNTIL:
gblLoopAddress = stkPop();
// these will be poped by EOLR
stkPush(gblMemPtr); // address after repeat is complete
stkPush (gblLoopAddress); // address while still repeating
gblMemPtr = gblLoopAddress;
break;
case LOOP:
gblLoopAddress = stkPop(); // the begining of loop
gblRepeatCount = 0; // disable this counter (loop forever)
stkPush(0); // this distinguishes LOOP from Repeat. (see EOL)
stkPush(gblLoopAddress); // push loop address back into the stack
// so that EOL will loop
gblMemPtr = gblLoopAddress;
break;
case WAIT:
gblWaitCounter = stkPop() * 4;
break;
case TIMER:
stkPush(gblTimer); // gblTimer increases every 1ms. See in RTCC interrupt
break;
case RESETT:
gblTimer = 0;
break;
case SEND:
genPurpose = stkPop();
break;
case IR:
stkPush (gblMostRecentlyReceivedByte);
gblNewByteHasArrivedFlag = 0;
break;
case NEWIR:
stkPush (gblNewByteHasArrivedFlag);
break;
case RANDOM:
stkPush (rand());
break;
case OP_PLUS:
case OP_MINUS:
case OP_MULTIPLY:
case OP_DIVISION:
case OP_REMAINDER:
case OP_EQUAL:
case OP_GREATER:
case OP_LESS:
case OP_AND:
case OP_OR:
case OP_XOR:
opr2=stkPop(); // second operand
opr1=stkPop();// first operand
switch (opcode) {
case OP_PLUS:
opr1+=opr2;
break;
case OP_MINUS:
opr1-=opr2;
break;
case OP_MULTIPLY:
opr1*=opr2;
break;
case OP_DIVISION:
opr1/=opr2;
break;
case OP_REMAINDER:
opr1%=opr2;
break;
case OP_EQUAL:
opr1=(opr1==opr2);
break;
case OP_GREATER:
opr1=(opr1>opr2);
break;
case OP_LESS:
opr1=(opr1<opr2);
break;
case OP_AND:
opr1=(opr1&&opr2);
break;
case OP_OR:
opr1=(opr1||opr2);
break;
case OP_XOR:
opr1=(opr1^opr2);
break;
};
stkPush(opr1);
break;
case OP_NOT:
stkPush(!stkPop());
break;
case SETGLOBAL:
genPurpose = stkPop();// this is the value
globalVariables[stkPop()] = genPurpose;
break;
case GETGLOBAL:
stkPush(globalVariables[stkPop()]);
break;
case ASET:
opr2 = stkPop();// this is the value to be stored
opr1 = stkPop() * 2;// this is the array index. Each entry is two bytes wide.
genPurpose = ARRAY_BASE_ADDRESS + stkPop();// this is the base address of the array.
flashSetWordAddress(genPurpose + opr1);
flashWrite(opr2);
break;
case AGET:
opr1 = stkPop() * 2;// this is the array index. Each entry is two bytes wide.
genPurpose = ARRAY_BASE_ADDRESS + stkPop();// this is the base address of the array.
opr2 = read_program_eeprom(genPurpose + opr1);
stkPush(opr2);
break;
case RECORD:
genPurpose = stkPop();
// PCM parts (14 bit PICs like the 16F877) uses an external EEPROM for data Logging storage
flashSetWordAddress(RECORD_BASE_ADDRESS + gblRecordPtr++);
flashWrite(genPurpose);
// save current record pointer location
flashSetWordAddress(MEM_PTR_LOG_BASE_ADDRESS);
flashWrite(gblRecordPtr);
break;
case RECALL:
genPurpose = read_program_eeprom(RECORD_BASE_ADDRESS + gblRecordPtr++);
stkPush(genPurpose);
break;
case RESETDP:
gblRecordPtr = 0;
break;
case SETDP:
gblRecordPtr = stkPop() * 2;
break;
case ERASE:
opr1 = stkPop() * 2;
for (genPurpose=0; genPurpose<opr1; genPurpose++) {
flashSetWordAddress(RECORD_BASE_ADDRESS + genPurpose);
flashWrite(0);
}
gblRecordPtr = 0;
break;
case OPC_MOTORS_OFF:
motors_off();
break;
case OPC_MOTORS_THATWAY:
motors_that_way();
break;
case OPC_MOTORS_THISWAY:
motors_this_way();
break;
case OPC_MOTORS_REVERT:
motors_reverse();
break;
case OPC_MOTORS_ON_FOR:
case OPC_MOTORS_ON:
motors_on();
if (opcode == OPC_MOTORS_ON_FOR) {
set_on_for(stkPop()*4);
}
break;
case OPC_MOTORS_POWER:
motors_power(stkPop());
break;
case OPC_MOTORS_ANGLE:
motors_angle(stkPop());
break;
case OPC_ACTIVATE_MOTORS:
mtrsActive = stkPop();
break;
case REALLY_STOP:
start_stop_logo_machine = 1;
break;
case EB:
stkPush(read_program_eeprom(stkPop()));
break;
case DB:
opr1 = stkPop();
opr2 = stkPop();
flashSetWordAddress(opr2);
flashWrite(opr1);
break;
case LOW_BYTE:
stkPush(stkPop() & 0xff);
break;
case HIGH_BYTE:
stkPush(stkPop() >> 8);
break;
case SENSOR1:
case SENSOR2:
case SENSOR3:
case SENSOR4:
case SENSOR5:
case SENSOR6:
case SENSOR7:
case SENSOR8:
if (opcode < SENSOR3) {
i = opcode - SENSOR1;
} else {
i = opcode - SENSOR3 + 2;
}
stkPush(readSensor(i));
break;
case SWITCH1:
case SWITCH2:
case SWITCH3:
case SWITCH4:
case SWITCH5:
case SWITCH6:
case SWITCH7:
case SWITCH8:
if (opcode < SWITCH3) {
i = opcode - SWITCH1;
} else {
i = opcode - SWITCH3 + 2;
}
stkPush(readSensor(i)>>9);
break;
case ULED_ON:
output_high(USER_LED);
break;
case ULED_OFF:
output_low(USER_LED);
break;
case CL_I2C_START:
i2c_start();
break;
case CL_I2C_STOP:
i2c_stop();
break;
case CL_I2C_WRITE:
i2c_write(stkPop());
break;
case CL_I2C_READ:
stkPush(i2c_read(stkPop()));
break;
default:
start_stop_logo_machine = 1;
break;
};
}
GERR GD_FL_Goke_Write(U32 address, U16* data, U32 size)
{
U32 cnt;
U16 rd;
U32 i, timeout;
GERR ferr;
if (size == 0) return GD_OK;
ferr = GD_OK;
if ( (size == 1)
|| (thisManufacturerCode == MANUFACTURER_CODE_MACRONIX)
|| (thisManufacturerCode == MANUFACTURER_CODE_EXELSEMI) ) // slow programming just for security, maybe not necessary
{
for (i=0; (i<size) && (ferr==GD_OK); i++)
{
flashWriteCmd(CMD_PROGRAM, 0);
flashWrite(address, data[i]);
/* it must be ensured that this loop is not optimized away */
for (cnt = 0; cnt < delayLoops; cnt++) _ASM("nop");
/* wait until programming is finished */
ferr = GD_ERR_BAD_PARAMETER;
timeout = TIMEOUT;
while ( (ferr == GD_ERR_BAD_PARAMETER) && ((timeout--) > 0) )
{
rd = flashRead(address);
if ( (rd & DQ7) == (data[i] & DQ7) )
{
ferr = GD_OK;
}
else if ( (rd & DQ5) == DQ5 )
{
/* check DQ7 again according to flash device specification */
rd = flashRead(address);
if ( (rd & DQ7) == (data[i] & DQ7) )
{
ferr = GD_OK;
}
else
{
ferr = GD_ERR_FLASH_WRITE;
}
}
}
if (timeout == 0)
{
ferr = GD_ERR_TIMEOUT;
}
address++;
}
}
else
{
/* enter fast mode */
flashWriteCmd(CMD_SET_FAST_MODE, 0);
for (i=0; (i<size) && (ferr==GD_OK); i++)
{
flashWrite(address, CMD_PROGRAM);
flashWrite(address, data[i]);
/* it must be ensured that this loop is not optimized away */
for (cnt = 0; cnt < delayLoops; cnt++) _ASM("nop");
/* wait until programming is finished */
ferr = GD_ERR_BAD_PARAMETER;
timeout = TIMEOUT;
while ((ferr == GD_ERR_BAD_PARAMETER)&&((timeout--) > 0))
{
rd = flashRead(address);
if ( (rd & DQ7) == (data[i] & DQ7) )
{
ferr = GD_OK;
}
else if ( (rd & DQ5) == DQ5 )
{
rd = flashRead(address);
if ( (rd & DQ7) == (data[i] & DQ7) )
{
ferr = GD_OK;
}
else
{
ferr = GD_ERR_FLASH_WRITE;
}
}
}
if (timeout == 0)
{
ferr = GD_ERR_TIMEOUT;
}
address++;
}
/* reset fast programming mode */
address--;
flashWrite(address, CMD_RESET_FAST_MODE_1);
flashWrite(address, CMD_RESET_FAST_MODE_2);
}
return ferr;
}
