char BSL430_writeMemory(unsigned long startAddr, unsigned int size, char* data) { unsigned long i; char exceptions = SUCCESSFUL_OPERATION; for (i = startAddr; i < startAddr + size; i++) { #ifndef RAM_WRITE_ONLY_BSL if ((startAddr & 0x01) || i == startAddr + size - 1) #endif { exceptions = BSL430_writeByte(i, *data); data += 1; } #ifndef RAM_WRITE_ONLY_BSL else { exceptions = BSL430_writeWord(i, *(int *)data); data += 2; i++; } if (exceptions != SUCCESSFUL_OPERATION) { return exceptions; } // if #endif } // for return exceptions; }
char flushBuffer(void) { unsigned long i; char exceptions = SUCCESSFUL_OPERATION; unsigned char* data = &BlockBuffer[0]; if (LockedStatus == UNLOCKED) { if (((BlockBufferStart & 0x7F) == 0) && (BlockBufferPtr == 128)) //Buffer is full and // aligned { while (FCTL3 & BUSY) ; FCTL3 = FWKEY; // Clear Lock bit FCTL1 = FWKEY + BLKWRT + WRT; // Set write/block bit for (i = BlockBufferStart; i < BlockBufferStart + 128; i += 4) { __data20_write_long(i, *((long*)data)); data += 4; while ((FCTL3 & WAIT) == 0) ; } // for FCTL1 = FwRamKey; while (FCTL3 & BUSY) ; FCTL3 = FwRamKey + LOCK; } // if else { FCTL3 = FwRamKey; // Clear Lock bit FCTL1 = FwRamKey + WRT; // Set write bit for (i = BlockBufferStart; i < BlockBufferStart + BlockBufferPtr; i++) { if ((BlockBufferStart & 0x01) || i == BlockBufferStart + BlockBufferPtr - 1) { exceptions = BSL430_writeByte(i, *data); data += 1; } else { exceptions = BSL430_writeWord(i, *(int *)data); data += 2; i++; } if (exceptions != SUCCESSFUL_OPERATION) { return exceptions; } // if } // for } // else BlockBufferStart = 0; BlockBufferNext = 0; BlockBufferPtr = 0; } else { exceptions = BSL_LOCKED; } return exceptions; }
char BSL430_writeMemory(unsigned long startAddr, unsigned int size, char* data) { unsigned long i; char exceptions = SUCCESSFUL_OPERATION; // Note: this function compiles quite differently based on whether the // BSL is based out of RAM, or not. RAM based BSLs can use buffering // and perform a block long word write. This is primarily used for // USB BSLs for performance increase. // Flash based BSLs will use the second second of code, below #ifdef RAM_BASED_BSL if (LockedStatus == UNLOCKED) { if ((BlockBufferStart == 0) || BlockBufferNext == startAddr) { // if we are starting, or continuing a block... if (BlockBufferStart == 0) { BlockBufferStart = startAddr; // if starting a new block, reset // start addr } BlockBufferNext = startAddr + size; // always update the next addr for // streaming for (i = 0; i < size;) { BlockBuffer[BlockBufferPtr++] = *data; // add the incoming data to the buffer data++; startAddr++; i++; // i incrimented here for check below if (((startAddr) & 0x7F) == 0x00) // we've crossed a 128 byte block // boundary { flushBuffer(); // flush out old buffer, writing... // begin write on block boundary return BSL430_writeMemory(startAddr, (size - i), data); } // if } // for } // if buffer start else { // for when data exists in the buffer, but we are jumping to a new place to write... flushBuffer(); // flush out old buffer, writing.. return BSL430_writeMemory(startAddr, size, data); // begin buffering new data } } // if unlocked else { exceptions = BSL_LOCKED; } // Below is the writeMemory function compiled with Flash based BSLs. #else for (i = startAddr; i < startAddr + size; i++) { # ifndef RAM_WRITE_ONLY_BSL // if the start address is odd, or we're 1 byte from end... if ((startAddr & 0x01) || i == startAddr + size - 1) # endif { exceptions = BSL430_writeByte(i, *data); data += 1; } # ifndef RAM_WRITE_ONLY_BSL // else, we're on an even addr, and have at least 1 word left.. else { exceptions = BSL430_writeWord(i, *(int *)data); data += 2; i++; } if (exceptions != SUCCESSFUL_OPERATION) { return exceptions; } // if # endif } // for #endif return exceptions; }