long int pcl_configure_clocks(pcl_freq_param_t *param) { #ifndef AVR32_PM_VERSION_RESETVALUE // Implementation for UC3A, UC3A3, UC3B parts. return(pm_configure_clocks(param)); #else #ifdef AVR32_PM_410_H_INCLUDED // Implementation for UC3C parts. return(pcl_configure_clocks_uc3c(param)); #else // Implementation for UC3L parts. return(pcl_configure_clocks_uc3l(param)); #endif #endif }
/** function to do hardware initialization * -> hwInit() is called in main() (src/independent/main.cpp) */ void hwInit(){ // Input and output parameters when initializing PM clocks using pm_configure_clocks(). // - parameters are defined in params.h and evk1100.h pm_freq_param_t clkParams = { CPU_CLK, // unsigned long cpu_f; PBA_CLK, // unsigned long pba_f; ! PBA frequency (input/output argument). FOSC0, // unsigned long osc0_f; ! Oscillator 0's external crystal(or external clock) frequency (board dependant) (input argument). OSC0_STARTUP // unsigned long osc0_startup; ! Oscillator 0's external crystal(or external clock) startup time: AVR32_PM_OSCCTRL0_STARTUP_x_RCOSC (input argument). }; pm_configure_clocks(&clkParams); Disable_global_interrupt(); INTC_init_interrupts(); // Initialize interrupt vectors. uart0.init(115200); uart1.init(115200); // interrupts will be enabled when loading the context of the first thread (idlethread) //Enable_global_interrupt(); }
/*! \brief Main function. Execution starts here. */ int main(void) { U32 n_sector = 0; U32 card_size; // Unit is in sector. U32 bench_start_sector; U16 i = 0; U16 j = 0; t_cpu_time timer; Ctrl_status status; // Set CPU and PBA clock if( PM_FREQ_STATUS_FAIL==pm_configure_clocks(&pm_freq_param) ) return 42; // Initialize HMatrix init_hmatrix(); // Initialize debug RS232 with PBA clock init_dbg_rs232(pm_freq_param.pba_f); // Start test print_dbg("\r\nInitialize SD/MMC driver"); // Initialize SD/MMC driver resources: GPIO, SDIO and SD/MMC. sd_mmc_mci_resources_init(); // Wait for a card to be inserted #if (BOARD == EVK1104) #if EXAMPLE_SD_SLOT == SD_SLOT_8BITS print_dbg("\r\nInsert a MMC/SD card into the SD/MMC 8bits slot..."); #elif EXAMPLE_SD_SLOT == SD_SLOT_4BITS print_dbg("\r\nInsert a MMC/SD card into the SD/MMC 4bits slot..."); #else # error SD_SLOT not supported #endif while (!sd_mmc_mci_mem_check(EXAMPLE_SD_SLOT)); #else # error Board not supported #endif print_dbg("Card detected!\r\n"); // Read Card capacity sd_mmc_mci_read_capacity(EXAMPLE_SD_SLOT, &card_size); print_dbg("\r\nCapacity = "); print_dbg_ulong(card_size*512); print_dbg(" Bytes\r\n"); // Read the first sector number 0 of the card status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } // Display the ram_buffer content print_dbg("\r\nFirst sector of the card:\r\n"); for (i=0;i<(512);i++) { print_dbg_char_hex(buffer_in[i]); j++; if (j%32==0) print_dbg("\r\n"), j=0; else if (j%4==0) print_dbg(" "); } // Write some patterns in the first sector number 0 of the card print_dbg("Testing write.\r\n"); if( !test_sd_mmc_write(0) ) return -1; if( !test_sd_mmc_write(1) ) return -1; if( !test_sd_mmc_write(2) ) return -1; if( !test_sd_mmc_write(3) ) return -1; // Bench single-block read operations without DMA // print_dbg("Benching single-block read (without DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench single-block read operations with DMA // print_dbg("Benching single-block read (with DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block read operations without DMA // print_dbg("Benching multi-block read (without DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_multiple_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block read operations with DMA // print_dbg("Benching multi-block read (with DMA). Please wait..."); n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_multiple_mem_2_ram(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench single-block write operations without DMA // print_dbg("Benching single-block write (without DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench single-block write operations with DMA // print_dbg("Benching single-block write (with DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=1; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block write operations without DMA // print_dbg("Benching multi-block write (without DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_multiple_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); // Bench multi-block write operations with DMA // print_dbg("Benching multi-block write (with DMA). Please wait..."); status = sd_mmc_mci_mem_2_ram(EXAMPLE_SD_SLOT, 0, buffer_in); // Backup the first sector number 0 of the card if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not read device.\r\n"); return -1; } n_sector = bench_start_sector = (card_size<BENCH_START_SECTOR) ? 0 : BENCH_START_SECTOR; cpu_set_timeout( cpu_ms_2_cy(BENCH_TIME_MS, pm_freq_param.cpu_f), &timer); while( !cpu_is_timeout(&timer) ) { status = sd_mmc_mci_dma_multiple_ram_2_mem(EXAMPLE_SD_SLOT, n_sector, buffer_in, ALLOCATED_SECTORS); if( status!=CTRL_GOOD ) { print_dbg("\r\nERROR: can not write device.\r\n"); return -1; } n_sector+=ALLOCATED_SECTORS; } display_perf_bps((((U64)n_sector-bench_start_sector)*512)/(BENCH_TIME_MS/1000)); return 0; }
/*! \brief The main function. * */ int main(void) { aes_config_t AesConf; // AES config structure int i; static const gpio_map_t USART_GPIO_MAP = // USART GPIO map { {DMACA_AES_EVAL_USART_RX_PIN, DMACA_AES_EVAL_USART_RX_FUNCTION}, {DMACA_AES_EVAL_USART_TX_PIN, DMACA_AES_EVAL_USART_TX_FUNCTION} }; static const usart_options_t USART_OPTIONS = // USART options. { .baudrate = DMACA_AES_EVAL_USART_BAUDRATE, .charlength = 8, .paritytype = USART_NO_PARITY, .stopbits = USART_1_STOPBIT, .channelmode = USART_NORMAL_CHMODE }; #if BOARD == EVK1104 if( PM_FREQ_STATUS_FAIL==pm_configure_clocks(&pm_freq_param) ) while(1); #endif init_hmatrix(); // Assign GPIO to USART. gpio_enable_module(USART_GPIO_MAP, sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0])); // Initialize USART in RS232 mode. usart_init_rs232(DMACA_AES_EVAL_USART, &USART_OPTIONS, DMACA_AES_EVAL_CPU_FREQ); print(DMACA_AES_EVAL_USART, "\x1B[2J\x1B[H.: Using the AES with the DMACA at "); print_ulong(DMACA_AES_EVAL_USART, DMACA_AES_EVAL_CPU_FREQ); print(DMACA_AES_EVAL_USART, "Hz :.\r\n\r\n"); //**************************************************************************** // CIPHER IN DMA MODE: RAM -> AES -> RAM // - 256bit cryptographic key // - CBC cipher mode // - No counter measures //**************************************************************************** // Init the input array. for(i=0; i<DMACA_AES_EVAL_BUF_SIZE; i+=DMACA_AES_EVAL_REFBUF_SIZE) { memcpy(InputData+i, RefInputData, DMACA_AES_EVAL_REFBUF_SIZE*sizeof(unsigned int)); } //==================== // Configure the AES. //==================== AesConf.ProcessingMode = AES_PMODE_CIPHER; // Cipher AesConf.ProcessingDelay = 0; // No delay: best performance AesConf.StartMode = AES_START_MODE_DMA; // DMA mode AesConf.KeySize = AES_KEY_SIZE_256; // 256bit cryptographic key AesConf.OpMode = AES_CBC_MODE; // CBC cipher mode AesConf.LodMode = 0; // LODMODE == 0 : the end of the // encryption is notified by the DMACA transfer complete interrupt. The output // is available in the OutputData[] buffer. AesConf.CFBSize = 0; // Don't-care because we're using the CBC mode. AesConf.CounterMeasureMask = 0; // Disable all counter measures. aes_configure(&AVR32_AES, &AesConf); //**************************************************************************** // - input of 16 32bit words in CPUSRAM // - output of 16 32bit words in CPUSRAM //**************************************************************************** print(DMACA_AES_EVAL_USART, "\r\n---------------------------------------------------\r\n"); print(DMACA_AES_EVAL_USART, "------ Cipher in DMA Mode: CPUSRAM -> AES -> CPUSRAM ------\r\n"); print(DMACA_AES_EVAL_USART, " - 256bit cryptographic key\r\n"); print(DMACA_AES_EVAL_USART, " - CBC cipher mode\r\n"); print(DMACA_AES_EVAL_USART, " - No counter measures\r\n"); print(DMACA_AES_EVAL_USART, " - input of 16 32bit words in CPUSRAM\r\n"); print(DMACA_AES_EVAL_USART, " - output of 16 32bit words in CPUSRAM\r\n"); print(DMACA_AES_EVAL_USART, "---------------------------------------------------\r\n"); test_ram_aes_ram(16, (unsigned int *)InputData, (unsigned int *)OutputData); gpio_clr_gpio_pin(DMACA_AES_EVAL_LED1); //**************************************************************************** // - input of 256 32bit words in CPUSRAM // - output of 256 32bit words in CPUSRAM //**************************************************************************** print(DMACA_AES_EVAL_USART, "\r\n---------------------------------------------------\r\n"); print(DMACA_AES_EVAL_USART, "------ Cipher in DMA Mode: CPUSRAM -> AES -> CPUSRAM ------\r\n"); print(DMACA_AES_EVAL_USART, " - 256bit cryptographic key\r\n"); print(DMACA_AES_EVAL_USART, " - CBC cipher mode\r\n"); print(DMACA_AES_EVAL_USART, " - No counter measures\r\n"); print(DMACA_AES_EVAL_USART, " - input of 256 32bit words in CPUSRAM\r\n"); print(DMACA_AES_EVAL_USART, " - output of 256 32bit words in CPUSRAM\r\n"); print(DMACA_AES_EVAL_USART, "---------------------------------------------------\r\n"); test_ram_aes_ram(256, (unsigned int *)InputData, (unsigned int *)OutputData); gpio_clr_gpio_pin(DMACA_AES_EVAL_LED2); //**************************************************************************** // - input of 256 32bit words in HSBSRAM0 // - output of 256 32bit words in HSBSRAM1 //**************************************************************************** print(DMACA_AES_EVAL_USART, "\r\n---------------------------------------------------\r\n"); print(DMACA_AES_EVAL_USART, "------ Cipher in DMA Mode: HSBSRAM0 -> AES -> HSBSRAM1 ------\r\n"); print(DMACA_AES_EVAL_USART, " - 256bit cryptographic key\r\n"); print(DMACA_AES_EVAL_USART, " - CBC cipher mode\r\n"); print(DMACA_AES_EVAL_USART, " - No counter measures\r\n"); print(DMACA_AES_EVAL_USART, " - Input of 256 32bit words in HSBSRAM0\r\n"); print(DMACA_AES_EVAL_USART, " - Output of 256 32bit words in HSBSRAM1\r\n"); print(DMACA_AES_EVAL_USART, "---------------------------------------------------\r\n"); // Set the Src and Dst array addresses to respectively HSBSRAM0 & HSBRAM1. pSrcData_HsbSram = (unsigned int *)AVR32_INTRAM0_ADDRESS; pDstData_HsbSram = (unsigned int *)AVR32_INTRAM1_ADDRESS; // Init the input array. for(i=0; i<DMACA_AES_EVAL_BUF_SIZE; i+=DMACA_AES_EVAL_REFBUF_SIZE) { memcpy(pSrcData_HsbSram+i, RefInputData, DMACA_AES_EVAL_REFBUF_SIZE*sizeof(unsigned int)); } test_ram_aes_ram(256, pSrcData_HsbSram, (unsigned int *)pDstData_HsbSram); gpio_clr_gpio_pin(DMACA_AES_EVAL_LED3); print(DMACA_AES_EVAL_USART, "\r\nDone!"); // End of tests: go to sleep. SLEEP(AVR32_PM_SMODE_STATIC); while (true); }
/* * Low-level initialization routine called during startup, before the main * function. * This version comes in replacement to the default one provided by Newlib. * Newlib's _init_startup only calls init_exceptions, but Newlib's exception * vectors are not compatible with the SCALL management in the current FreeRTOS * port. More low-level initializations are besides added here. */ void _init_startup(void) { /* Import the Exception Vector Base Address. */ extern void _evba; #if configHEAP_INIT extern void __heap_start__; extern void __heap_end__; portBASE_TYPE *pxMem; #endif /* Load the Exception Vector Base Address in the corresponding system register. */ Set_system_register( AVR32_EVBA, ( int ) &_evba ); /* Enable exceptions. */ ENABLE_ALL_EXCEPTIONS(); /* Initialize interrupt handling. */ INTC_init_interrupts(); #if configHEAP_INIT /* Initialize the heap used by malloc. */ for( pxMem = &__heap_start__; pxMem < ( portBASE_TYPE * )&__heap_end__; ) { *pxMem++ = 0xA5A5A5A5; } #endif /* Give the used CPU clock frequency to Newlib, so it can work properly. */ set_cpu_hz( configCPU_CLOCK_HZ ); // Input and output parameters when initializing PM clocks using pm_configure_clocks(). pm_freq_param_t clkParams = { configCPU_CLOCK_HZ, // unsigned long cpu_f; configPBA_CLOCK_HZ, // unsigned long pba_f; ! PBA frequency (input/output argument). FOSC0, // unsigned long osc0_f; ! Oscillator 0's external crystal(or external clock) frequency (board dependant) (input argument). OSC0_STARTUP // unsigned long osc0_startup; ! Oscillator 0's external crystal(or external clock) startup time: AVR32_PM_OSCCTRL0_STARTUP_x_RCOSC (input argument). }; pm_configure_clocks(&clkParams); /* Code section present if and only if the debug trace is activated. */ #if configDBG { static const gpio_map_t DBG_USART_GPIO_MAP = { { configDBG_USART_RX_PIN, configDBG_USART_RX_FUNCTION }, { configDBG_USART_TX_PIN, configDBG_USART_TX_FUNCTION } }; /* Initialize the USART used for the debug trace with the configured parameters. */ set_usart_base( ( void * ) configDBG_USART ); gpio_enable_module( DBG_USART_GPIO_MAP, sizeof( DBG_USART_GPIO_MAP ) / sizeof( DBG_USART_GPIO_MAP[0] ) ); usart_init( configDBG_USART_BAUDRATE ); /*const usart_options_t USART_OPTIONS = { configDBG_USART_BAUDRATE, // baudrate 8, // charlength USART_NO_PARITY, // paritytype USART_1_STOPBIT, // stopbits USART_NORMAL_CHMODE // channelmode }; usart_init_rs232(configDBG_USART, &USART_OPTIONS, configPBA_CLOCK_HZ);*/ } #endif }