phmatrix new_hmatrix(pccluster rc, pccluster cc) { phmatrix hm = new hmatrix; hm = init_hmatrix(hm, rc, cc); return hm; }
/*! \brief This is an example showing how to toggle a GPIO pin at high speed. */ int main(void) { // Initialize domain clocks (CPU, HSB, PBA and PBB) to the max frequency available // without flash wait states. // Some of the registers in the GPIO module are mapped onto the CPU local bus. // To ensure maximum transfer speed and cycle determinism, any slaves being // addressed by the CPU on the local bus must be able to receive and transmit // data on the bus at CPU clock speeds. The consequences of this is that the // GPIO module has to run at the CPU clock frequency when local bus transfers // are being performed => we want fPBA = fCPU. clockfrequencies_configure(); // initialize hmatrix bus init_hmatrix(); // Enable the local bus interface for GPIO. gpio_local_init(); // Enable the output driver of the example pin. // Note that the GPIO mode of pins is enabled by default after reset. gpio_local_enable_pin_output_driver(GPIO_PIN_EXAMPLE); // Toggle the example GPIO pin at high speed in a loop. while (1) { // Explicit loop unrolling allowing consecutive ST.W instructions without // loop overhead if compiler optimization is activated, except every 128 // ST.W for the while loop. #define INSERT_GPIO_LOCAL_TGL_GPIO_PIN(idx, pin) \ gpio_local_tgl_gpio_pin(pin); MREPEAT(128, INSERT_GPIO_LOCAL_TGL_GPIO_PIN, GPIO_PIN_EXAMPLE) #undef INSERT_GPIO_LOCAL_TGL_GPIO_PIN } }
int __low_level_init(void) #endif { init_exceptions(); init_hmatrix(); init_heap(); // EWAVR32: Request initialization of data segments. // GCC: Don't-care value. return 1; }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); // Initialize the sleep manager sleepmgr_init(); sysclk_init(); board_init(); ui_init(); ui_powerdown(); #if UC3A3 // Init Hmatrix bus sysclk_enable_pbb_module(SYSCLK_HMATRIX); init_hmatrix(); #endif #if (defined AT45DBX_MEM) && (AT45DBX_MEM == ENABLE) at45dbx_init(); #endif #if ((defined SD_MMC_MCI_0_MEM) && (SD_MMC_MCI_0_MEM == ENABLE)) \ || ((defined SD_MMC_MCI_1_MEM) && (SD_MMC_MCI_1_MEM == ENABLE)) // Initialize SD/MMC with MCI PB clock. sysclk_enable_pbb_module(SYSCLK_MCI); sysclk_enable_hsb_module(SYSCLK_DMACA); sd_mmc_mci_resources_init(); #endif // Start USB stack to authorize VBus monitoring udc_start(); if (!udc_include_vbus_monitoring()) { // VBUS monitoring is not available on this product // thereby VBUS has to be considered as present main_vbus_action(true); } // The main loop manages only the power mode // because the USB management is done by interrupt while (true) { sleepmgr_enter_sleep(); if (main_b_msc_enable) { udi_msc_process_trans(); } } }
/*! \brief Main function. Execution starts here. * * \retval 42 Fatal error. */ int main(void) { init_hmatrix(); // Configure standard I/O streams as unbuffered. #if (defined __GNUC__) && (defined __AVR32__) setbuf(stdin, NULL); #endif setbuf(stdout, NULL); #if (defined USB_RESYNC_METHOD) && (USB_RESYNC_METHOD == USB_RESYNC_METHOD_EXT_CLOCK_SYNTHESIZER) // Initialize the TWI using the internal RCOSC init_twi_CS2200(AVR32_PM_RCOSC_FREQUENCY); // Initialize the CS2200 and produce a default 11.2896 MHz frequency cs2200_setup(11289600, FOSC0); #endif // Initializes the MCU system clocks init_sys_clocks(); // Initialize the TWI init_twi(FPBA_HZ); audio_mixer_enable_dacs(DEFAULT_DACS); audio_mixer_dacs_start(DEFAULT_DAC_SAMPLE_RATE_HZ, DEFAULT_DAC_NUM_CHANNELS, DEFAULT_DAC_BITS_PER_SAMPLE, DEFAULT_DAC_SWAP_CHANNELS); // Initialize the display et024006_Init( FCPU_HZ, FHSB_HZ); // Set Backlight gpio_set_gpio_pin(ET024006DHU_BL_PIN); // Clear the display et024006_DrawFilledRect(0, 0, ET024006_WIDTH, ET024006_HEIGHT, WHITE ); // Display a logo. et024006_PutPixmap(avr32_logo, AVR32_LOGO_WIDTH, 0, 0 ,(ET024006_WIDTH - AVR32_LOGO_WIDTH)/2 ,(ET024006_HEIGHT - AVR32_LOGO_HEIGHT)/2, AVR32_LOGO_WIDTH, AVR32_LOGO_HEIGHT); et024006_PrintString(AUDIO_DEMO_STRING, (const unsigned char *)&FONT8x16, 30, 5, BLACK, -1); et024006_PrintString("Please plug the USB.", (const unsigned char *)&FONT8x8, 30, 30, BLACK, -1); // Initialize USB task usb_task_init(); // Initialize Controller controller_init(FCPU_HZ, FHSB_HZ, FPBB_HZ, FPBA_HZ); #if USB_DEVICE_FEATURE == true // Initialize device audio USB task device_audio_task_init(); // Initialize the HID USB task device_hid_task_init(); #endif #if USB_HOST_FEATURE == true // Initialize host audio USB task host_audio_task_init(); #endif #ifdef FREERTOS_USED // Start OS scheduler vTaskStartScheduler(); portDBG_TRACE("FreeRTOS returned."); return 42; #else // No OS here. Need to call each task in round-robin mode. while (true) { usb_task(); #if USB_DEVICE_FEATURE == true device_audio_task(); device_hid_task(); #endif #if USB_HOST_FEATURE == true host_audio_task(); #endif } #endif // FREERTOS_USED }
static void init_spi(void) { #if defined(WL_SPI) int i; #endif #if defined(AT45DBX_SPI) static const gpio_map_t AT45DBX_SPI_GPIO_MAP = { { AT45DBX_SPI_SCK_PIN, AT45DBX_SPI_SCK_FUNCTION }, { AT45DBX_SPI_MISO_PIN, AT45DBX_SPI_MISO_FUNCTION }, { AT45DBX_SPI_MOSI_PIN, AT45DBX_SPI_MOSI_FUNCTION }, { AT45DBX_SPI_NPCS2_PIN, AT45DBX_SPI_NPCS2_FUNCTION }, }; #endif #if defined(WL_SPI) const gpio_map_t WL_SPI_GPIO_MAP = { #if defined(WL_SPI_NPCS0) WL_SPI_NPCS0, #endif WL_SPI_NPCS, WL_SPI_MISO, WL_SPI_MOSI, WL_SPI_SCK }; #endif #if defined(WL_SPI) || defined(AT45DBX_SPI) spi_options_t spiOptions = { .modfdis = 1 /* only param used by spi_initMaster() */ }; #endif #if defined(AT45DBX_SPI) gpio_enable_module(AT45DBX_SPI_GPIO_MAP, sizeof(AT45DBX_SPI_GPIO_MAP) / sizeof(AT45DBX_SPI_GPIO_MAP[0])); spi_initMaster(AT45DBX_SPI, &spiOptions); spi_selectionMode(AT45DBX_SPI, 0, 0, 0); #endif #if defined(WL_SPI) /* same pins might be initialized twice here */ gpio_enable_module(WL_SPI_GPIO_MAP, sizeof(WL_SPI_GPIO_MAP) / sizeof(WL_SPI_GPIO_MAP[0])); for (i = 0; i < sizeof(WL_SPI_GPIO_MAP)/sizeof(WL_SPI_GPIO_MAP[0]); i++) gpio_enable_pin_pull_up(WL_SPI_GPIO_MAP[i].pin); /* same SPI controller might be initialized again */ spi_initMaster(&WL_SPI, &spiOptions); spi_selectionMode(&WL_SPI, 0, 0, 0); #endif #if defined(AT45DBX_SPI) spi_enable(AT45DBX_SPI); /* put up flash reset pin */ gpio_set_gpio_pin(AT45DBX_CHIP_RESET); #endif #if defined(WL_SPI) spi_enable(&WL_SPI); #endif } static void init_rs232(void) { #ifndef NO_SERIAL #if defined(BOARD_RS232_0) const gpio_map_t BOARD_RS232_0_GPIO_MAP = { BOARD_RS232_0_TX, BOARD_RS232_0_RX, #if defined(BOARD_RS232_0_RTS) && defined (BOARD_RS232_0_CTS) BOARD_RS232_0_RTS, BOARD_RS232_0_CTS #endif }; #endif #if defined(BOARD_RS232_1) const gpio_map_t BOARD_RS232_1_GPIO_MAP = { BOARD_RS232_1_TX, BOARD_RS232_1_RX #if defined(BOARD_RS232_1_RTS) && defined (BOARD_RS232_1_CTS) BOARD_RS232_1_RTS, BOARD_RS232_1_CTS #endif }; #endif #if defined(BOARD_RS232_0) gpio_enable_module(BOARD_RS232_0_GPIO_MAP, sizeof(BOARD_RS232_0_GPIO_MAP) / sizeof(BOARD_RS232_0_GPIO_MAP[0])); #endif #if defined(BOARD_RS232_1) gpio_enable_module(BOARD_RS232_1_GPIO_MAP, sizeof(BOARD_RS232_1_GPIO_MAP) / sizeof(BOARD_RS232_1_GPIO_MAP[0])); #endif #endif /* NO_SERIAL */ } static void init_printk(void) { #ifndef NO_SERIAL #if defined(CONFIG_CONSOLE_PORT) const usart_options_t usart_options = { .baudrate = 57600, .charlength = 8, .paritytype = USART_NO_PARITY, .stopbits = USART_1_STOPBIT, .channelmode = USART_NORMAL_CHMODE }; usart_init_rs232(&CONFIG_CONSOLE_PORT, &usart_options, FPBA_HZ); #endif #endif /* NO_SERIAL */ } void board_init(void) { init_exceptions(); init_hmatrix(); init_sys_clocks(); init_interrupts(); init_rs232(); init_printk(); #ifdef WITH_SDRAM sdramc_init(FHSB_HZ); #endif init_spi(); }
/*! \brief Main function. Execution starts here. * * \retval 42 Fatal error. */ int main(void) { uint32_t iter=0; uint32_t cs2200_out_freq=11289600; static bool b_sweep_up=true; static uint32_t freq_step=0; // USART options. static usart_serial_options_t USART_SERIAL_OPTIONS = { .baudrate = USART_SERIAL_EXAMPLE_BAUDRATE, .charlength = USART_SERIAL_CHAR_LENGTH, .paritytype = USART_SERIAL_PARITY, .stopbits = USART_SERIAL_STOP_BIT }; // Initialize the TWI using the internal RCOSC init_twi(AVR32_PM_RCOSC_FREQUENCY); // Initialize the CS2200 and produce a default frequency. cs2200_setup(11289600, FOSC0); sysclk_init(); // Initialize the board. // The board-specific conf_board.h file contains the configuration of the board // initialization. board_init(); // Initialize the TWI init_twi(sysclk_get_pba_hz()); // Initialize Serial Interface using Stdio Library stdio_serial_init(USART_SERIAL_EXAMPLE,&USART_SERIAL_OPTIONS); // Initialize the HMatrix. init_hmatrix(); print_dbg("\r\nCS2200 Example\r\n"); // Generate a 12.288 MHz frequency out of the CS2200. print_dbg("Output 12.288 MHz\r\n"); cs2200_freq_clk_out(_32_BITS_RATIO(12288000, FOSC0)); cpu_delay_ms( 10000, sysclk_get_cpu_hz()); // Generate a 11.2896 MHz frequency out of the CS2200. print_dbg("Output 11.2896 MHz\r\n"); cs2200_freq_clk_out(_32_BITS_RATIO(cs2200_out_freq, FOSC0)); cpu_delay_ms( 10000, sysclk_get_cpu_hz()); print_dbg("Sweep from 11.2896 MHz steps of 100 PPM\r\n"); freq_step = PPM(cs2200_out_freq, 100); while(1) { uint32_t ratio; if(b_sweep_up) { if( iter<=10 ) { print_dbg("Add 100 PPM\r\n"); iter++; cs2200_out_freq += freq_step; ratio = _32_BITS_RATIO(cs2200_out_freq, FOSC0); cs2200_freq_clk_adjust((uint16_t)ratio); cpu_delay_ms( 1000, sysclk_get_cpu_hz()); while( twi_is_busy() ); } else b_sweep_up=false; } if(!b_sweep_up) { if( iter>0 ) { print_dbg("Sub 100 PPM\r\n"); iter--; cs2200_out_freq -= freq_step; ratio = _32_BITS_RATIO(cs2200_out_freq, FOSC0); cs2200_freq_clk_adjust((uint16_t)ratio); cpu_delay_ms( 1000, sysclk_get_cpu_hz()); while( twi_is_busy() ); } else b_sweep_up=true; } } }
/*! \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); }
int main (void) { pcl_freq_param_t local_pcl_freq_param; /* USART_Int_Test (); return (0); */ // Configure system clocks. local_pcl_freq_param = pcl_freq_param; if (pcl_configure_clocks (&local_pcl_freq_param) != PASS) { return 42; } /* 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 ((defined SD_MMC_MCI_0_MEM) && (SD_MMC_MCI_0_MEM == ENABLE)) || ((defined SD_MMC_MCI_1_MEM) && (SD_MMC_MCI_1_MEM == ENABLE)) sd_mmc_mci_resources_init (); #endif #ifdef FREERTOS_USED if (!ctrl_access_init ()) { return 42; } #endif // FREERTOS_USED // Init Hmatrix bus init_hmatrix (); // Initialize USB clock. pcl_configure_usb_clock (); /* SmartCard_test (); return 42; Test_ALL_Pins (); Test_MCI_Pins (); Test_LEDs_Pins (); TestUart0 (); while (1); return (0); */ #ifdef TIME_MEASURING_ENABLE TIME_MEASURING_Init (); #endif // For debugging BUFFERED_SIO_Init (); #ifdef INTERPRETER_ENABLE IDF_task_init (); #endif // Internal work task - FAT Access IW_task_init (); // Initialize USB tasks. usb_task_init (); #if USB_DEVICE_FEATURE == ENABLED #ifdef USB_MSD device_mass_storage_task_init (); #endif // USB_MSD #endif // CCID_Test_task_init (); #ifdef USB_CCID USB_CCID_task_init (); #endif DFU_DisableFirmwareUpdate (); // Stick always starts in application mode /**/ // Protect bootloader #ifdef STICK_20_A_MUSTER_PROD // flashc_set_bootloader_protected_size (0x2000); // flashc_activate_security_bit (); // Debugging disabled, only chip erase works (bootloader is save) , AES storage keys and setup // are erased flashc_lock_external_privileged_fetch (TRUE); // Disable external instruction fetch #endif // DFU_FirmwareResetUserpage (); // Set BOD33 detection reset to 3.06 Volt pm_bod33_ResetDisable (); pm_bod33_set_level (AVR32_PM_BOD33_LEVEL_306_VOLT); pm_bod33_ResetEnable (); // ushell_task_init(pcl_freq_param.pba_f); // Create the semaphore vSemaphoreCreateBinary (AES_semphr); // Wait for the semaphore while (!xSemaphoreTake (AES_semphr, portMAX_DELAY)); // Release the semaphore in order to start a new device/host task portBASE_TYPE task_woken = pdFALSE; /* taskENTER_CRITICAL (); xSemaphoreGiveFromISR (AES_semphr, &task_woken); taskEXIT_CRITICAL (); */ taskENTER_CRITICAL (); xSemaphoreGive (AES_semphr); taskEXIT_CRITICAL (); // Start stick vTaskStartScheduler (); // It never gets to this point return 42; }