/**
* NOTE: don't attempt to quicken by change send rate to 500 ms or less --
* it's too fast for default 9600 baud rate.
* For AGPS online, force dumping EPH and ALM.
*/
gboolean agps_dump_aid_data(gboolean agps_online)
{
log_info("Dump AID data...");
get_aid_file_names();
/* avoid garbage */
uart_flush_output();
gboolean ret = FALSE;
struct stat st;
struct timeval time;
gettimeofday(&time, NULL);
aid_args_t config[] = {
{aid_eph_file, "EPH", UBX_ID_AID_EPH, 104, 32},
{aid_alm_file, "ALM", UBX_ID_AID_ALM, 40, 32},
{aid_hui_file, "HUI", UBX_ID_AID_HUI, 72, 1} /* must be last */
};
int i;
int count = sizeof(config)/sizeof(aid_args_t);
int skip_counter = 0;
/* AGPS online data does not contain HUI */
if (agps_online)
--count;
for (i=0; i<count; i++) {
if (agps_online || (stat(config[i].file, &st) != 0) ||
(st.st_mtim.tv_sec + MIN_DUMP_INTERVAL_S < time.tv_sec)) {
if (! dump_aid_data(&config[i])) {
ret = FALSE;
break;
}
} else {
++skip_counter;
}
}
ret = (i == count);
if (ret) {
log_info("Dump AID data result: types=%d", count - skip_counter);
} else {
log_info("Dump AID data: failed");
}
if (! g_context.uart_conflict)
uart_flush_output();
return ret;
}
void cts_task(void)
{
enum cts_rc result;
int i;
uart_flush_output();
for (i = 0; i < CTS_TEST_ID_COUNT; i++) {
sync();
result = tests[i].run();
CPRINTF("\n%s %d\n", tests[i].name, result);
uart_flush_output();
}
CPRINTS("GPIO test suite finished");
uart_flush_output();
while (1) {
watchdog_reload();
sleep(1);
}
}
void panic_puts(const char *outstr)
{
/* Flush the output buffer */
uart_flush_output();
/* Put all characters in the output buffer */
while (*outstr)
panic_txchar(NULL, *outstr++);
/* Flush the transmit FIFO */
uart_tx_flush();
}
/**
* Jump to what we hope is the init address of an image.
*
* This function does not return.
*
* @param init_addr Init address of target image
*/
static void jump_to_image(uintptr_t init_addr)
{
void (*resetvec)(void) = (void(*)(void))init_addr;
/*
* Jumping to any image asserts the signal to the Silego chip that that
* EC is not in read-only firmware. (This is not technically true if
* jumping from RO -> RO, but that's not a meaningful use case...).
*
* Pulse the signal long enough to set the latch in the Silego, then
* drop it again so we don't leak power through the pulldown in the
* Silego.
*/
gpio_set_level(GPIO_ENTERING_RW, 1);
usleep(MSEC);
gpio_set_level(GPIO_ENTERING_RW, 0);
#ifdef CONFIG_USB_POWER_DELIVERY
/*
* Notify USB PD module that we are about to sysjump and give it time
* to do what it needs.
*/
pd_prepare_sysjump();
usleep(5*MSEC);
#endif
/* Flush UART output unless the UART hasn't been initialized yet */
if (uart_init_done())
uart_flush_output();
/* Disable interrupts before jump */
interrupt_disable();
#ifdef CONFIG_DMA
/* Disable all DMA channels to avoid memory corruption */
dma_disable_all();
#endif /* CONFIG_DMA */
/* Fill in preserved data between jumps */
jdata->reserved0 = 0;
jdata->magic = JUMP_DATA_MAGIC;
jdata->version = JUMP_DATA_VERSION;
jdata->reset_flags = reset_flags;
jdata->jump_tag_total = 0; /* Reset tags */
jdata->struct_size = sizeof(struct jump_data);
/* Call other hooks; these may add tags */
hook_notify(HOOK_SYSJUMP);
/* Jump to the reset vector */
resetvec();
}
/**
* Jump to what we hope is the init address of an image.
*
* This function does not return.
*
* @param init_addr Init address of target image
*/
static void jump_to_image(uintptr_t init_addr)
{
void (*resetvec)(void) = (void(*)(void))init_addr;
/*
* Jumping to any image asserts the signal to the Silego chip that that
* EC is not in read-only firmware. (This is not technically true if
* jumping from RO -> RO, but that's not a meaningful use case...).
*
* Pulse the signal long enough to set the latch in the Silego, then
* drop it again so we don't leak power through the pulldown in the
* Silego.
*/
gpio_set_level(GPIO_ENTERING_RW, 1);
usleep(MSEC);
gpio_set_level(GPIO_ENTERING_RW, 0);
#ifdef CONFIG_USB_POWER_DELIVERY
/*
* On sysjump, we are most definitely going to drop pings (if any)
* and lose all of our PD state. Instead of trying to remember all
* the states and deal with on-going transmission, let's send soft
* reset here so that the communication starts over without dropping
* power.
*/
pd_soft_reset();
usleep(5*MSEC);
#endif
/* Flush UART output unless the UART hasn't been initialized yet */
if (uart_init_done())
uart_flush_output();
/* Disable interrupts before jump */
interrupt_disable();
/* Fill in preserved data between jumps */
jdata->reserved0 = 0;
jdata->magic = JUMP_DATA_MAGIC;
jdata->version = JUMP_DATA_VERSION;
jdata->reset_flags = reset_flags;
jdata->jump_tag_total = 0; /* Reset tags */
jdata->struct_size = sizeof(struct jump_data);
/* Call other hooks; these may add tags */
hook_notify(HOOK_SYSJUMP);
/* Jump to the reset vector */
resetvec();
}
void panic_printf(const char *format, ...)
{
va_list args;
/* Flush the output buffer */
uart_flush_output();
va_start(args, format);
vfnprintf(panic_txchar, NULL, format, args);
va_end(args);
/* Flush the transmit FIFO */
uart_tx_flush();
}
/**
* baud_rate: only support [1,2,4,8] * 4800
* called by polling thread!
*/
gboolean uart_init()
{
log_info("UART init: message rate=%d ms, baud rate=%d...", SEND_RATE, BAUD_RATE);
show_status("Initializing GPS...");
/* open UART */
if (uart_open((U4)BAUD_RATE, TRUE) <= 0) {
log_error("Open UART failed");
return FALSE;
}
ubx_init(gps_dev_fd);
if (! ubx_cfg_rate((U2)SEND_RATE, TRUE))
return FALSE;
if (! ubx_cfg_prt(0x01, 0x01, 0x01, BAUD_RATE, TRUE))
return FALSE;
/* Disable NMEA to avoid flushing UBX binary output */
if (! ubx_cfg_msg_nmea_ubx(0x0, TRUE, TRUE))
return FALSE;
if (! ubx_cfg_msg_nmea_std(0x0, TRUE, TRUE))
return FALSE;
if (! ubx_cfg_sbas(TRUE, TRUE))
return FALSE;
show_status("Set initial AID data...");
/* no matter success or failure */
set_initial_aid_data();
uart_flush_output();
show_status("GPS was initialized.");
//ubx_mon_ver_poll(g_ubx_receiver_versions, sizeof(g_ubx_receiver_versions));
//show_status(g_ubx_receiver_versions);
return TRUE;
}
/*
* If the read size < expected length, retry even if EOF
*/
gboolean inline read_fixed_len(U1 *buf, int expected_len)
{
int len = 0, count;
while (TRUE) {
count = read_with_timeout(&buf[len], expected_len);
if (count == expected_len) {
return TRUE;
} else if (count <= 0) {
uart_flush_output();
return FALSE;
} else {
len += count;
expected_len -= count;
if (expected_len == 0)
return TRUE;
}
}
}
void board_hibernate(void)
{
CPRINTS("Triggering PMIC shutdown.");
uart_flush_output();
/* Trigger PMIC shutdown. */
if (i2c_write8(I2C_PORT_PMIC, I2C_ADDR_BD99992, 0x49, 0x01)) {
/*
* If we can't tell the PMIC to shutdown, instead reset
* and don't start the AP. Hopefully we'll be able to
* communicate with the PMIC next time.
*/
CPRINTS("PMIC i2c failed.");
system_reset(SYSTEM_RESET_LEAVE_AP_OFF);
}
/* Await shutdown. */
while (1)
;
}
/**
* Jump to what we hope is the init address of an image.
*
* This function does not return.
*
* @param init_addr Init address of target image
*/
static void jump_to_image(uintptr_t init_addr)
{
void (*resetvec)(void) = (void(*)(void))init_addr;
/*
* Jumping to any image asserts the signal to the Silego chip that that
* EC is not in read-only firmware. (This is not technically true if
* jumping from RO -> RO, but that's not a meaningful use case...).
*
* Pulse the signal long enough to set the latch in the Silego, then
* drop it again so we don't leak power through the pulldown in the
* Silego.
*/
gpio_set_level(GPIO_ENTERING_RW, 1);
usleep(MSEC);
gpio_set_level(GPIO_ENTERING_RW, 0);
/* Flush UART output unless the UART hasn't been initialized yet */
if (uart_init_done())
uart_flush_output();
/* Disable interrupts before jump */
interrupt_disable();
/* Fill in preserved data between jumps */
jdata->reserved0 = 0;
jdata->magic = JUMP_DATA_MAGIC;
jdata->version = JUMP_DATA_VERSION;
jdata->reset_flags = reset_flags;
jdata->jump_tag_total = 0; /* Reset tags */
jdata->struct_size = sizeof(struct jump_data);
/* Call other hooks; these may add tags */
hook_notify(HOOK_SYSJUMP);
/* Jump to the reset vector */
resetvec();
}
