static void request_ram_repair(void)
{
struct flow_ctlr * const flow = (void *)(uintptr_t)TEGRA_FLOW_BASE;
const uint32_t req = 1 << 0;
const uint32_t sts = 1 << 1;
uint32_t reg;
struct stopwatch sw;
printk(BIOS_DEBUG, "Requesting RAM repair.\n");
stopwatch_init(&sw);
/* Perform cluster 0 ram repair */
reg = read32(&flow->ram_repair);
reg |= req;
write32(&flow->ram_repair, reg);
while ((read32(&flow->ram_repair) & sts) != sts)
;
/* Perform cluster 1 ram repair */
reg = read32(&flow->ram_repair_cluster1);
reg |= req;
write32(&flow->ram_repair_cluster1, reg);
while ((read32(&flow->ram_repair_cluster1) & sts) != sts)
;
printk(BIOS_DEBUG, "RAM repair complete in %ld usecs.\n",
stopwatch_duration_usecs(&sw));
}
int google_chromeec_command(struct chromeec_command *cec_command)
{
static struct spi_slave *slave = NULL;
if (!slave) {
slave = spi_setup_slave(CONFIG_EC_GOOGLE_CHROMEEC_SPI_BUS,
CONFIG_EC_GOOGLE_CHROMEEC_SPI_CHIP);
stopwatch_init(&cs_cooldown_sw);
}
return crosec_command_proto(cec_command, crosec_spi_io, slave);
}
/**@brief Function for application main entry.
*/
int main(void)
{
#ifdef OSSW_DEBUG
init_uart();
#endif
spi_init();
ext_ram_init();
init_lcd_with_splash_screen();
accel_init();
// Initialize.
timers_init();
rtc_timer_init();
buttons_init();
battery_init();
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// splash screen
nrf_delay_ms(500);
fs_init();
config_init();
scr_mngr_init();
vibration_init();
notifications_init();
stopwatch_init();
timer_feature_init();
mlcd_timers_init();
// Enter main loop.
for (;;)
{
if (rtc_should_store_current_time()) {
rtc_store_current_time();
}
app_sched_execute();
stopwatch_process();
command_process();
watchset_process_async_operation();
scr_mngr_draw_screen();
power_manage();
}
}
int google_chromeec_command(struct chromeec_command *cec_command)
{
static int done = 0;
static struct spi_slave slave;
if (!done) {
if (spi_setup_slave(CONFIG_EC_GOOGLE_CHROMEEC_SPI_BUS,
CONFIG_EC_GOOGLE_CHROMEEC_SPI_CHIP, &slave))
return -1;
stopwatch_init(&cs_cooldown_sw);
done = 1;
}
return crosec_command_proto(cec_command, crosec_spi_io, &slave);
}
int ccplex_load_mts(void)
{
ssize_t nread;
struct stopwatch sw;
struct cbfsf mts_file;
struct region_device fh;
/*
* MTS location is hard coded to this magic address. The hardware will
* take the MTS from this location and place it in the final resting
* place in the carveout region.
*/
void * const mts = (void *)(uintptr_t)MTS_LOAD_ADDRESS;
stopwatch_init(&sw);
if (cbfs_boot_locate(&mts_file, MTS_FILE_NAME, NULL)) {
printk(BIOS_DEBUG, "MTS file not found: %s\n", MTS_FILE_NAME);
return -1;
}
cbfs_file_data(&fh, &mts_file);
/* Read MTS file into the carveout region. */
nread = rdev_readat(&fh, mts, 0, region_device_sz(&fh));
if (nread != region_device_sz(&fh)) {
printk(BIOS_DEBUG, "MTS bytes read (%zu) != file length(%u)!\n",
nread, region_device_sz(&fh));
return -1;
}
printk(BIOS_DEBUG, "MTS: %zu bytes loaded @ %p in %ld usecs.\n",
nread, mts, stopwatch_duration_usecs(&sw));
return ccplex_start();
}
void main(void)
{
char* input_data = malloc(DATA_SIZE);
FILE* input_file;
input_file = fopen(INPUT_FILE, "r");
if(input_file == NULL){
fprintf(stderr, "Failed to open %s\n", INPUT_FILE);
exit(1);
}
int i = 0;
char buffer[BLOCK_SIZE];
while(fgets(buffer, BLOCK_SIZE, input_file)){
strcpy(input_data+i,buffer);
i = i + BLOCK_SIZE - 1;
}
fclose(input_file);
/*Replace the line field ascii with \0*/
input_data[strlen(input_data) - 1] = '\0';
struct stopwatch_t* sw = stopwatch_create();
/*--------------------------------------------------------------------------------------*/
stopwatch_init();
stopwatch_start(sw);
printf("crcSlow() 0x%X ", crcSlow(input_data, strlen(input_data)));
stopwatch_stop(sw);
printf(" Time: %Lg\n", stopwatch_elapsed(sw));
/*--------------------------------------------------------------------------------------*/
stopwatch_start(sw);
size_t input_data_len = strlen(input_data);
int input_blocks = input_data_len / BLOCK_SIZE;
int extra_blocks = 0;
if(input_data_len % BLOCK_SIZE != 0)
extra_blocks = 1;
int total_blocks = input_blocks + extra_blocks;
int *result = malloc(total_blocks * sizeof(int));
omp_set_num_threads(16);
unsigned int ans = 0;
char* block_data = malloc(input_blocks * (BLOCK_SIZE + 1));
char* block_addr;
i = 0;
#pragma omp parallel for default(none) shared(input_blocks, input_data, result, block_data) private (i, block_addr)
for(i = 0; i < input_blocks; ++i){
block_addr = block_data + (BLOCK_SIZE + 1) * i;
strncpy(block_addr, input_data + BLOCK_SIZE * i, BLOCK_SIZE);
*(block_addr + BLOCK_SIZE) = '\0';
result[i] = CrcHash(block_addr, BLOCK_SIZE);
}
int rem = input_data_len % BLOCK_SIZE;
char* last_block_data = malloc(rem + 1);
if(extra_blocks == 1){
strncpy(last_block_data, input_data + BLOCK_SIZE * input_blocks, rem);
*(last_block_data + rem) = '\0';
result[input_blocks] = CrcHash(last_block_data, rem);
}
i=0;
for(i = 0; i < input_blocks; ++i){
ans = crc32_combine(ans, result[i], BLOCK_SIZE);
}
if(extra_blocks == 1)
ans = crc32_combine(ans, result[i], rem);
stopwatch_stop(sw);
printf("Parallel() 0x%X Time: %Lg \n",ans, stopwatch_elapsed(sw));
/*--------------------------------------------------------------------------------------*/
crcInit();
stopwatch_start(sw);
printf("crcFast() 0x%X ", crcFast(input_data, strlen(input_data)));
stopwatch_stop(sw);
printf(" Time: %Lg\n", stopwatch_elapsed(sw));
stopwatch_destroy(sw);
/*--------------------------------------------------------------------------------------*/
stopwatch_start(sw);
printf("crc_intel() 0x%X ", CrcHash((const void*)input_data, strlen(input_data)));
stopwatch_stop(sw);
printf(" Time: %Lg\n", stopwatch_elapsed(sw));
/*--------------------------------------------------------------------------------------*/
/*Cleanup*/
free(last_block_data);
free(block_data);
free(input_data);
}
