int writeToAddress (hBSP430m25p m25p,
uint8_t cmd,
unsigned long addr,
const uint8_t * data,
unsigned int len)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
unsigned long t0;
unsigned long t1;
int rc;
int sr;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
if (0 != iBSP430m25pStrobeCommand_ni(m25p, BSP430_M25P_CMD_WREN)) {
rc = -1;
break;
}
if (0 != iBSP430m25pInitiateAddressCommand_ni(m25p, cmd, addr)) {
rc = -1;
break;
}
rc = iBSP430m25pCompleteTxRx_ni(m25p, data, len, 0, NULL);
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
t0 = ulBSP430uptime();
do {
sr = iBSP430m25pStatus(m25p);
} while ((0 <= sr) && (BSP430_M25P_SR_WIP & sr));
t1 = ulBSP430uptime();
cprintf("Write %d took %lu\n", len, t1 - t0);
return rc;
}
unsigned int
uiBSP430tlvChecksum (const unsigned char * data,
size_t len)
{
#ifdef __MSP430_HAS_CRC__
BSP430_CORE_INTERRUPT_STATE_T istate;
unsigned int rv;
size_t i;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
CRCINIRES = 0xFFFF;
for (i = 0; i < len; ++i) {
/* @warning Reversed CRC not available on certain MCUs; see
* function description */
CRCDIRB_L = data[i];
}
rv = CRCINIRES;
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
#else /* __MSP430_HAS_CRC__ */
/* This implementation is appropriate for 2xx/4xx TLV structures. */
const unsigned int * sp = (unsigned int *) data;
const unsigned int * const ep = (unsigned int *)(data + len);
unsigned int crc = 0;
while (sp < ep) {
crc ^= *sp++;
}
return -crc;
#endif /* __MSP430_HAS_CRC__ */
}
static int
cmd_uptime (const char * argstr)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
cprintf("Up %s\n", xBSP430uptimeAsText_ni(ulBSP430uptime_ni()));
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return 0;
}
int
iBSP430consoleInitialize (void)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rv;
hBSP430halSERIAL hal;
if (console_hal_) {
return 0;
}
hal = hBSP430serialLookup(BSP430_CONSOLE_SERIAL_PERIPH_HANDLE);
if (NULL == hal) {
return -1;
}
rv = -1;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
#if BSP430_CONSOLE_RX_BUFFER_SIZE - 0
/* Associate the callback before opening the device, so the
* interrupts are enabled properly. */
rx_buffer_.head = rx_buffer_.tail = 0;
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRVoidChainNode, hal->rx_cbchain_ni, rx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_RX_BUFFER_SIZE */
#if BSP430_CONSOLE_TX_BUFFER_SIZE - 0
uartTransmit_ni = console_tx_queue_ni;
tx_buffer_.wake_available = 0;
tx_buffer_.head = tx_buffer_.tail = 0;
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRVoidChainNode, hal->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_TX_BUFFER_SIZE */
/* Attempt to configure and install the console */
console_hal_ = hBSP430serialOpenUART(hal, 0, 0, BSP430_CONSOLE_BAUD_RATE);
if (! console_hal_) {
/* Open failed, revert the callback association. */
#if BSP430_CONSOLE_RX_BUFFER_SIZE - 0
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, hal->rx_cbchain_ni, rx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_RX_BUFFER_SIZE */
break;
}
#if BSP430_PLATFORM_SPIN_FOR_JUMPER - 0
vBSP430platformSpinForJumper_ni();
#endif /* BSP430_PLATFORM_SPIN_FOR_JUMPER */
/* All is good */
rv = 0;
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
int
iBSP430consoleFlush (void)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rv;
if (! console_hal_) {
return 0;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = iBSP430consoleWaitForTxSpace_ni(-1);
vBSP430serialFlush_ni(console_hal_);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
int
vcprintf (const char * fmt, va_list ap)
{
int rv;
BSP430_CORE_INTERRUPT_STATE_T istate;
/* Fail fast if printing is disabled */
if (! console_hal_) {
return 0;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = vuprintf(emit_char_ni, fmt, ap);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
int
iBSP430usciClose (hBSP430halSERIAL hal)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rc;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
SERIAL_HAL_HPL(hal)->ctl1 = UCSWRST;
rc = iBSP430platformConfigurePeripheralPins_ni((tBSP430periphHandle)(uintptr_t)(SERIAL_HAL_HPL(hal)),
peripheralConfigFlag(SERIAL_HAL_HPL(hal)->ctl0),
0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rc;
}
int
cputs (const char * s)
{
int rv = 0;
hBSP430halSERIAL uart = console_hal_;
BSP430_CORE_INTERRUPT_STATE_T istate;
if (! uart) {
return 0;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = emit_text_ni(s, uart);
emit_char2_ni('\n', uart);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return 1+rv;
}
static
hBSP430halSERIAL
usciConfigure (hBSP430halSERIAL hal,
unsigned char ctl0_byte,
unsigned char ctl1_byte,
unsigned int brw,
int mctl)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
SERIAL_HAL_HPL(hal)->ctl1 = UCSWRST;
do {
int periph_config = peripheralConfigFlag(ctl0_byte);
if (0 != iBSP430platformConfigurePeripheralPins_ni(xBSP430periphFromHPL(SERIAL_HAL_HPL(hal)), periph_config, 1)) {
hal = NULL;
break;
}
SERIAL_HAL_HPL(hal)->ctl1 |= ctl1_byte;
SERIAL_HAL_HPL(hal)->ctl0 = ctl0_byte;
SERIAL_HAL_HPL(hal)->br0 = brw % 256;
SERIAL_HAL_HPL(hal)->br1 = brw / 256;
if (0 <= mctl) {
SERIAL_HAL_HPL(hal)->mctl = mctl;
}
/* Mark the hal active */
hal->num_rx = hal->num_tx = 0;
/* Attempt to release the device for use; if that failed, reset it
* and return an error */
if (0 != iBSP430usciSetHold_ni(hal, 0)) {
SERIAL_HAL_HPL(hal)->ctl1 = UCSWRST;
hal = NULL;
}
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return hal;
}
int readFromAddress (hBSP430m25p m25p,
unsigned long addr,
unsigned int len)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rc = -1;
if (len > sizeof(buffer)) {
len = sizeof(buffer);
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
if (0 == iBSP430m25pInitiateAddressCommand_ni(m25p, BSP430_M25P_CMD_FAST_READ, addr)) {
rc = iBSP430m25pCompleteTxRx_ni(m25p, NULL, 0, len, buffer);
}
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rc;
}
int
iBSP430consoleDeconfigure (void)
{
int rv = 0;
BSP430_CORE_INTERRUPT_STATE_T istate;
if (! console_hal_) {
return rv;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = iBSP430serialClose(console_hal_);
#if BSP430_CONSOLE_RX_BUFFER_SIZE - 0
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, console_hal_->rx_cbchain_ni, rx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_RX_BUFFER_SIZE */
#if BSP430_CONSOLE_TX_BUFFER_SIZE - 0
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, console_hal_->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_TX_BUFFER_SIZE */
console_hal_ = NULL;
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
void main ()
{
BSP430_CORE_INTERRUPT_STATE_T istate;
#if BSP430_MODULE_SYS - 0
unsigned long reset_causes = 0;
unsigned int reset_flags = 0;
#endif /* BSP430_MODULE_SYS */
#if BSP430_MODULE_SYS - 0
{
unsigned int sysrstiv;
/* Record all the reset causes */
while (0 != ((sysrstiv = uiBSP430sysSYSRSTGenerator_ni(&reset_flags)))) {
reset_causes |= 1UL << (sysrstiv / 2);
}
}
#endif /* BSP430_MODULE_SYS */
vBSP430platformInitialize_ni();
(void)iBSP430consoleInitialize();
#if BSP430_MODULE_SYS - 0
cprintf("System reset bitmask %lx; causes:\n", reset_causes);
{
int bit = 0;
while (bit < (8 * sizeof(reset_causes))) {
if (reset_causes & (1UL << bit)) {
cprintf("\t%s\n", xBSP430sysSYSRSTIVDescription(2*bit));
}
++bit;
}
}
cputtext_ni("System reset included:");
if (reset_flags) {
if (reset_flags & BSP430_SYS_FLAG_SYSRST_BOR) {
cputtext_ni(" BOR");
}
if (reset_flags & BSP430_SYS_FLAG_SYSRST_LPM5WU) {
cputtext_ni(" LPM5WU");
}
if (reset_flags & BSP430_SYS_FLAG_SYSRST_POR) {
cputtext_ni(" POR");
}
if (reset_flags & BSP430_SYS_FLAG_SYSRST_PUC) {
cputtext_ni(" PUC");
}
} else {
cputtext_ni(" no data");
}
cputchar_ni('\n');
#endif /* BSP430_MODULE_SYS */
BSP430_CORE_ENABLE_INTERRUPT();
memcpy(ivect, VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
dumpRegion("Cached vectors", ivect, VECTOR_LENGTH_BYTES);
dumpRegion("Vectors", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
/* Note: You need to flush the console if you want to see the
* output now; otherwise it'll be printed once interrupt-driven
* transmission is re-enabled. */
iBSP430consoleFlush();
iBSP430consoleTransmitUseInterrupts_ni(0);
(void)iBSP430flashEraseSegment_ni((void*)0xFE00);
dumpRegion("Vectors with 0xFE00", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
(void)iBSP430flashEraseSegment_ni(VECTOR_OFFSET);
vBSP430ledSet(0, 1);
dumpRegion("Vectors as erased", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
memcpy(erased_ivect, VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
(void)iBSP430flashWriteData_ni(VECTOR_OFFSET, ivect, VECTOR_LENGTH_BYTES);
vBSP430ledSet(1, 1);
iBSP430consoleTransmitUseInterrupts_ni(1);
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
dumpRegion("Erased Vectors", erased_ivect, VECTOR_LENGTH_BYTES);
dumpRegion("Restored Vectors", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
iBSP430consoleFlush();
}
