/** * \brief Initialize SD/MMC storage. */ static void init_storage(void) { FRESULT res; Ctrl_status status; /* Initialize SD/MMC stack. */ sd_mmc_init(); while (true) { printf("init_storage: Please plug an SD/MMC card in slot.\r\n"); /* Wait card present and ready. */ do { status = sd_mmc_test_unit_ready(0); if (CTRL_FAIL == status) { printf("init_storage: SD Card install Failed.\r\n"); printf("init_storage: Please unplug and re-plug the card.\r\n"); while (CTRL_NO_PRESENT != sd_mmc_check(0)) { } } } while (CTRL_GOOD != status); printf("init_storage: Mount SD card...\r\n"); memset(&fatfs, 0, sizeof(FATFS)); res = f_mount(LUN_ID_SD_MMC_0_MEM, &fatfs); if (FR_INVALID_DRIVE == res) { printf("init_storage: SD card Mount failed. res %d\r\n", res); return; } printf("init_storage: SD card Mount OK.\r\n"); add_state(STORAGE_READY); return; } }
/** * Initialize for SD/MMC support */ void media_sd_init(void) { dbg_print("media_sd: init ...\r\n"); /* IOs are initialized in board_init() */ sd_mmc_init(); dbg_print("media_sd: init ... done\r\n"); }
void MassStorage::Init() { static const char * const VolMutexNames[] = { "SD0", "SD1" }; static_assert(ARRAY_SIZE(VolMutexNames) >= NumSdCards, "Incorrect VolMutexNames array"); // Create the mutexes fsMutex.Create("FileSystem"); dirMutex.Create("DirSearch"); for (size_t i = 0; i < NumFileWriteBuffers; ++i) { freeWriteBuffers = new FileWriteBuffer(freeWriteBuffers); } for (size_t card = 0; card < NumSdCards; ++card) { SdCardInfo& inf = info[card]; memset(&inf.fileSystem, 0, sizeof(inf.fileSystem)); inf.mounting = inf.isMounted = false; inf.cdPin = SdCardDetectPins[card]; inf.cardState = (inf.cdPin == NoPin) ? CardDetectState::present : CardDetectState::notPresent; inf.volMutex.Create(VolMutexNames[card]); } sd_mmc_init(SdWriteProtectPins, SdSpiCSPins); // initialize SD MMC stack // We no longer mount the SD card here because it may take a long time if it fails }
void memories_initialization(void) { #ifdef CONF_BOARD_SMC_PSRAM psram_init(); #endif #ifdef CONF_BOARD_SRAM ext_sram_init(); #endif #if defined CONF_BOARD_SD_MMC_HSMCI || defined CONF_BOARD_SD_MMC_SPI sd_mmc_init(); #endif }
/** * \brief Application entry point. * * \return Unused (ANSI-C compatibility). */ int main(void) { uint8_t slot = 0; sd_mmc_err_t err; system_init(); delay_init(); cdc_uart_init(); irq_initialize_vectors(); cpu_irq_enable(); time_tick_init(); // Initialize SD MMC stack sd_mmc_init(); printf("\x0C\n\r-- SD/MMC Card Example --\n\r"); printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__); while (1) { if (slot == sd_mmc_nb_slot()) { slot = 0; } printf("Please plug an SD/MMC card in slot %d.\n\r", slot+1); // Wait for a card and ready do { err = sd_mmc_check(slot); if ((SD_MMC_ERR_NO_CARD != err) && (SD_MMC_INIT_ONGOING != err) && (SD_MMC_OK != err)) { printf("Card install FAILED\n\r"); printf("Please unplug and re-plug the card.\n\r"); while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) { } } } while (SD_MMC_OK != err); // Display basic card information main_display_info_card(slot); /* Test the card */ if (sd_mmc_get_type(slot) & (CARD_TYPE_SD | CARD_TYPE_MMC)) { // SD/MMC Card R/W main_test_memory(slot); } printf("Test finished, please unplugged the card.\n\r"); while (SD_MMC_OK == sd_mmc_check(slot)) { } slot++; } }
void memories_initialization(void) { #if (defined AT45DBX_MEM) && (AT45DBX_MEM == ENABLE) // sysclk_enable_peripheral_clock(AT45DBX_SPI_MODULE); // is already done by XMEGA SPI driver at45dbx_init(); #endif #if ((defined SD_MMC_0_MEM) && (SD_MMC_0_MEM == ENABLE)) \ || ((defined SD_MMC_1_MEM) && (SD_MMC_1_MEM == ENABLE)) sd_mmc_init(); #endif }
void sd_open(struct memory_card *card) { int ret; struct aml_card_info *aml_card_info = card->card_plat_info; SD_MMC_Card_Info_t *sd_mmc_info = (SD_MMC_Card_Info_t *)card->card_info; #if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 switch_mod_gate_by_type(MOD_SDIO,1); #endif if (aml_card_info->card_extern_init) aml_card_info->card_extern_init(); ret = sd_mmc_init(sd_mmc_info); if(ret) ret = sd_mmc_init(sd_mmc_info); if(ret) ret = sd_mmc_init(sd_mmc_info); card->capacity = sd_mmc_info->blk_nums; card->sdio_funcs = sd_mmc_info->sdio_function_nums; memcpy(card->raw_cid, &(sd_mmc_info->raw_cid), sizeof(card->raw_cid)); if(sd_mmc_info->write_protected_flag) card->state |= CARD_STATE_READONLY; #if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 switch_mod_gate_by_type(MOD_SDIO,0); #endif if(ret) card->unit_state = CARD_UNIT_READY; else card->unit_state = CARD_UNIT_PROCESSED; return; }
void memories_initialization(void) { #ifdef CONF_BOARD_SMC_PSRAM psram_init(); #endif #ifdef CONF_BOARD_SRAM sram_init(); #endif #ifdef CONF_BOARD_SDRAMC /* Enable SMC peripheral clock */ pmc_enable_periph_clk(ID_SMC); /* Complete SDRAM configuration */ sdramc_init((sdramc_memory_dev_t *)&SDRAM_MICRON_MT48LC16M16A2, sysclk_get_cpu_hz()); #endif #ifdef CONF_BOARD_AT45DBX at45dbx_init(); if (at45dbx_mem_check() != true) { while (1) { } } #endif #ifdef CONF_BOARD_SD_MMC_HSMCI uint8_t slot = 0; sd_mmc_err_t err; sd_mmc_init(); if (slot == sd_mmc_nb_slot()) { slot = 0; } // Wait for a card and ready do { err = sd_mmc_check(slot); if ((SD_MMC_ERR_NO_CARD != err) && (SD_MMC_INIT_ONGOING != err) && (SD_MMC_OK != err)) { while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) { } } } while (SD_MMC_OK != err); #endif }
void MassStorage::Init() { hsmciPinsinit(); // Initialize SD MMC stack sd_mmc_init(); int sdPresentCount = 0; while ((CTRL_NO_PRESENT == sd_mmc_check(0)) && (sdPresentCount < 5)) { //platform->Message(HOST_MESSAGE, "Please plug in the SD card.\n"); //delay(1000); sdPresentCount++; } if(sdPresentCount >= 5) { platform->Message(HOST_MESSAGE, "Can't find the SD card.\n"); return; } //print card info // SerialUSB.print("sd_mmc_card->capacity: "); // SerialUSB.print(sd_mmc_get_capacity(0)); // SerialUSB.print(" bytes\n"); // SerialUSB.print("sd_mmc_card->clock: "); // SerialUSB.print(sd_mmc_get_bus_clock(0)); // SerialUSB.print(" Hz\n"); // SerialUSB.print("sd_mmc_card->bus_width: "); // SerialUSB.println(sd_mmc_get_bus_width(0)); memset(&fileSystem, 0, sizeof(FATFS)); //f_mount (LUN_ID_SD_MMC_0_MEM, NULL); //int mounted = f_mount(LUN_ID_SD_MMC_0_MEM, &fileSystem); int mounted = f_mount(0, &fileSystem); if (mounted != FR_OK) { platform->Message(HOST_MESSAGE, "Can't mount filesystem 0: code "); snprintf(scratchString, STRING_LENGTH, "%d", mounted); platform->Message(HOST_MESSAGE, scratchString); platform->Message(HOST_MESSAGE, "\n"); } }
void datalog_tasks_init(void) { uint8_t slot = 0; sd_mmc_err_t err; sd_mmc_init(); if (slot == sd_mmc_nb_slot()) { slot = 0; } // Wait for a card and ready do { err = sd_mmc_check(slot); if ((SD_MMC_ERR_NO_CARD != err) && (SD_MMC_INIT_ONGOING != err) && (SD_MMC_OK != err)) { while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) { } } } while (SD_MMC_OK != err); }
/** * \brief SD/MMC stack initialization test. * * \param test Current test case. */ static void run_sd_mmc_init_test(const struct test_case *test) { sd_mmc_err_t err; /* Initialize SD MMC stack */ sd_mmc_init(); /* Wait card connection */ do { err = sd_mmc_check(0); } while (SD_MMC_ERR_NO_CARD == err); /* Check if the first state is an initialization */ test_assert_true(test, err == SD_MMC_INIT_ONGOING, "No card initialization phase detected."); /* Check if the second step is an installation success */ test_assert_true(test, sd_mmc_check(0) == SD_MMC_OK, "SD/MMC card initialization failed."); }
void sd_open(struct memory_card *card) { int ret; struct aml_card_info *aml_card_info = card->card_plat_info; SD_MMC_Card_Info_t *sd_mmc_info = (SD_MMC_Card_Info_t *)card->card_info; if (aml_card_info->card_extern_init) aml_card_info->card_extern_init(); ret = sd_mmc_init(sd_mmc_info); card->capacity = sd_mmc_info->blk_nums; card->sdio_funcs = sd_mmc_info->sdio_function_nums; memcpy(card->raw_cid, &(sd_mmc_info->raw_cid), sizeof(card->raw_cid)); if(ret) card->unit_state = CARD_UNIT_READY; else card->unit_state = CARD_UNIT_PROCESSED; return; }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); /* Initialize ASF services */ sleepmgr_init(); sysclk_init(); board_init(); gfx_mono_init(); sd_mmc_init(); rtc_init(); stdio_usb_init(); /* Initialize STDIO and start USB */ udc_stop(); /* Stop USB by default */ main_introduction(); /* Initialize tasks */ app_touch_init(); app_cpu_load_init(); app_sampling_init(); /* The main loop */ while (true) { /* Enter in sleep mode */ app_cpu_load_enter_sleep(); sleepmgr_enter_sleep(); /* Execute tasks */ app_usb_task(); app_microsd_task(); app_sampling_task(); app_touch_task(); app_cpu_load_task(); } }
/** * \brief Show SD card status on the OLED screen. */ static void display_sd_info(void) { FRESULT res; uint8_t card_check; uint8_t sd_card_type; uint32_t sd_card_size; char size[64]; /* Is SD card present? */ if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false) { multi_language_show_no_sd_info(); } else { multi_language_show_sd_info(); sd_mmc_init(); card_check = sd_mmc_check(0); while (card_check != SD_MMC_OK) { card_check = sd_mmc_check(0); delay_ms(1); } if (card_check == SD_MMC_OK) { sd_card_type = sd_mmc_get_type(0); sd_card_size = sd_mmc_get_capacity(0); /* Card type */ switch (sd_card_type) { case CARD_TYPE_SD: multi_language_show_normal_card_info(); break; case CARD_TYPE_SDIO: break; case CARD_TYPE_HC: multi_language_show_high_capacity_card_info(); break; case CARD_TYPE_SD_COMBO: break; default: multi_language_show_unknow_card_info(); } multi_language_show_card_size_info(size, sd_card_size); /* Try to mount file system. */ memset(&fs, 0, sizeof(FATFS)); res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs); if (FR_INVALID_DRIVE == res) { multi_language_show_no_fatfs_info(); sd_fs_found = 0; } else { get_num_files_on_sd(); if (sd_num_files == 0) { multi_language_show_no_files_info(); sd_fs_found = 1; } else { multi_language_show_browse_info(); sd_fs_found = 1; } } } } }
void ZP_Init(void) { #ifdef DEBUG printf("Setting up system clock...\n"); #endif /* Setup SysTick Timer for 1 msec interrupts */ if (SysTick_Config(sysclk_get_cpu_hz() / 1000)) while (1) {} #ifdef DEBUG printf("ZP Init:\n"); printf("Setting up pins...\n"); #endif #ifdef DEBUG printf("Setting up SD stack...\n"); #endif /* Initialize SD MMC stack */ sd_mmc_init(); uint8_t sd_check = 0; /* Wait card present and ready */ do { #ifdef DEBUG if (sd_check == 1) { printf("Please plug an SD card in slot.\n"); sd_check = 2; } #endif status = sd_mmc_test_unit_ready(0); if (CTRL_FAIL == status) { printf("Card install FAIL\n\r"); printf("Please unplug and re-plug the card.\n\r"); while (CTRL_NO_PRESENT != sd_mmc_check(0)) { } } if (sd_check == 0) sd_check = 1; } while (CTRL_GOOD != status); #ifdef DEBUG printf("SD Card Found\n"); printf("Mounting disk..."); #endif memset(&fs, 0, sizeof(FATFS)); res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs); if (FR_INVALID_DRIVE == res) { printf("[FAIL] res %d\r\n", res); } #ifdef DEBUG printf("Disk mounted\n"); #endif TCHAR root_directory[3] = "0:"; root_directory[0] = '0' + LUN_ID_SD_MMC_0_MEM; file_name[0] = '0' + LUN_ID_SD_MMC_0_MEM; DIR dirs; res = f_opendir(&dirs, root_directory); if(f_opendir(&dir, "0:Scripts") == FR_NO_PATH) { res = f_mkdir("0:Scripts"); printf("Made Scripts folder\n"); } printf("res: %d\n", res); printf("Open Script\n"); //f_open(&f_script, "0:script.bin", FA_OPEN_EXISTING | FA_READ); }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); wdt_disable(WDT); // Initialize the sleep manager sleepmgr_init(); // Board initialization sysclk_init(); init_board(); init_pwm(); init_i2c(); // Module initialization init_module_peripherals_bp(); /* Initialize SD MMC stack */ delay_ms(200); sd_mmc_init(); // Start USB stack to authorize VBus monitoring udc_start(); // Init SCPI parser console_init(); // Enable 12v enable_12v(); #ifdef TEST_FW set_user_led_colour(100, 100, 100); #else set_user_led_colour(0, 100, 0); #endif while (true) { console_process(); if((get_ok_12v_status() == RETURN_OK) && (last_ok_12v_state == FALSE)) { #ifdef TEST_FW set_user_led_colour(300, 300, 300); #else set_user_led_colour(0, 100, 0); #endif last_ok_12v_state = TRUE; } else if((get_ok_12v_status() == RETURN_NOK) && (last_ok_12v_state == TRUE)) { set_user_led_colour(0, 100, 0); last_ok_12v_state = FALSE; } if(integrator_flag == TRUE) { integrator_flag = FALSE; ch0_integration_time_counter++; ch1_integration_time_counter++; ch0_counter_integrated += get_counter0_value(); ch1_counter_integrated += get_counter1_value(); if(ch0_integration_time_counter == ch0_integration_time_goal) { ch0_integration_time_counter = 0; if(meas_push_activated) { printf("Counter0 value: %llu\x0D", ch0_counter_integrated); } if(get_countera_en_status() == TRUE) { if(last_countera_en == FALSE) last_countera_en = TRUE; else add_new_countera_measurement_to_queue(ch0_counter_integrated); } else last_countera_en = FALSE; ch0_counter_integrated = 0; } if(ch1_integration_time_counter == ch1_integration_time_goal) { ch1_integration_time_counter = 0; if(meas_push_activated) { printf("Counter1 value: %llu\x0D", ch1_counter_integrated); } if(get_counterb_en_status() == TRUE) { if(last_counterb_en == FALSE) last_counterb_en = TRUE; else add_new_counterb_measurement_to_queue(ch1_counter_integrated); } else last_counterb_en = FALSE; ch1_counter_integrated = 0; } } if(second_flag == TRUE) { second_flag = FALSE; } if (main_b_msc_enable) { if (!udi_msc_process_trans()) { //sleepmgr_enter_sleep(); } } else { //sleepmgr_enter_sleep(); } } }
/** * \brief Main application */ int main(void) { char test_file_name[] = "0:sd_image.bin"; FRESULT res; FATFS fs; FIL file_object; uint32_t len=0; uint32_t curr_prog_addr=APP_START_ADDRESS; struct nvm_config config; UINT iRead=0; check_boot_mode(); system_init(); delay_init(); irq_initialize_vectors(); cpu_irq_enable(); /* Initialize SD MMC stack */ sd_mmc_init(); nvm_get_config_defaults(&config); nvm_set_config(&config); /* Turn ON LED */ port_pin_set_output_level(BOOT_LED, false); #ifdef __DEBUG_PRINT__ serial_port_init(); printf("\x0C\n\r-- SD/MMC Card FatFs Boot Loader --\n\r"); printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__); printf("Please plug an SD/MMC card in slot.\n\r"); #endif /* Wait card present and ready */ sd_mmc_ready(); memset(&fs, 0, sizeof(FATFS)); res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs); if (FR_INVALID_DRIVE == res) { #ifdef __DEBUG_PRINT__ printf("[FAIL] Mounting SD card failed result= %d\r\n", res); #endif } #ifdef __DEBUG_PRINT__ printf("Mounting the SD card successful...\r\n"); #endif res =f_open(&file_object,(const char *)test_file_name,FA_READ); if(res != FR_OK) error_fatal(FILE_OPEN_ERROR); do { if(file_object.fsize > MAX_CODE_SIZE) error_fatal(MAX_SIZE_ERROR); res = f_read(&file_object, (void *) buff, MAX_BUF_SIZE, &iRead); if(res != FR_OK) error_fatal(FILE_READ_ERROR); /* Program the read data into Flash */ if(iRead) { program_memory(curr_prog_addr, buff,iRead); #ifdef __DEBUG_PRINT__ printf("*"); #endif } /* Increment the current programming address */ curr_prog_addr += iRead; len += iRead; if(len > MAX_CODE_SIZE) error_fatal(MAX_SIZE_ERROR); /* Do this till end of file */ } while (iRead != 0); #ifdef __DEBUG_PRINT__ printf("\r\n[PROGRAMMING COMPLETED]..Resetting !!!!\r\n"); #endif // Intentionally not closing the file object to reduce code size !!!. start_application(); while(1); // Should have reset by now !!!. }
static int sd_request(struct memory_card *card, struct card_blk_request *brq) { SD_MMC_Card_Info_t *sd_mmc_info = (SD_MMC_Card_Info_t *)card->card_info; unsigned int lba, byte_cnt,ret; unsigned char *data_buf; struct card_host *host = card->host; struct memory_card *sdio_card; SD_MMC_Card_Info_t *sdio_info; lba = brq->card_data.lba; byte_cnt = brq->card_data.blk_size * brq->card_data.blk_nums; data_buf = brq->crq.buf; if(sd_mmc_info == NULL){ brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS; printk("[sd_request] sd_mmc_info == NULL, return SD_MMC_ERROR_NO_CARD_INS\n"); return 0; } if(!sd_mmc_info->blk_len){ card->card_io_init(card); card->card_detector(card); if(card->card_status == CARD_REMOVED){ brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS; return 0; } #if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 switch_mod_gate_by_type(MOD_SDIO,1); #endif ret = sd_mmc_init(sd_mmc_info); #if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 switch_mod_gate_by_type(MOD_SDIO,0); #endif if(ret){ brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS; return 0; } } #if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 switch_mod_gate_by_type(MOD_SDIO,1); #endif sdio_card = card_find_card(host, CARD_SDIO); if (sdio_card) { sdio_close_host_interrupt(SDIO_IF_INT); sdio_info = (SD_MMC_Card_Info_t *)sdio_card->card_info; sd_gpio_enable(sdio_info->io_pad_type); } sd_sdio_enable(sd_mmc_info->io_pad_type); if(brq->crq.cmd == READ) { brq->card_data.error = sd_mmc_read_data(sd_mmc_info, lba, byte_cnt, data_buf); } else if(brq->crq.cmd == WRITE) { brq->card_data.error = sd_mmc_write_data(sd_mmc_info, lba, byte_cnt, data_buf); } sd_gpio_enable(sd_mmc_info->io_pad_type); if(brq->card_data.error == SD_WAIT_FOR_COMPLETION_TIMEOUT) { printk("[sd_request] wait for completion timeout, reinit\n"); card->card_io_init(card); card->card_detector(card); if(card->card_status == CARD_REMOVED){ printk("[sd_request] card removed\n"); brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS; return 0; } sd_mmc_staff_init(sd_mmc_info); ret = sd_mmc_init(sd_mmc_info); if(ret){ printk("[sd_request] reinit fail %d\n", ret); brq->card_data.error = SD_MMC_ERROR_NO_CARD_INS; return 0; } sd_sdio_enable(sd_mmc_info->io_pad_type); if(brq->crq.cmd == READ) { brq->card_data.error = sd_mmc_read_data(sd_mmc_info, lba, byte_cnt, data_buf); } else if(brq->crq.cmd == WRITE) { brq->card_data.error = sd_mmc_write_data(sd_mmc_info, lba, byte_cnt, data_buf); } sd_gpio_enable(sd_mmc_info->io_pad_type); if(brq->card_data.error == SD_WAIT_FOR_COMPLETION_TIMEOUT) printk("[sd_request] after reinit still error \n"); } sdio_card = card_find_card(host, CARD_SDIO); if(sdio_card) { sdio_info = (SD_MMC_Card_Info_t *)sdio_card->card_info; sd_sdio_enable(sdio_info->io_pad_type); if (sdio_info->sd_save_hw_io_flag) { WRITE_CBUS_REG(SDIO_CONFIG, sdio_info->sd_save_hw_io_config); WRITE_CBUS_REG(SDIO_MULT_CONFIG, sdio_info->sd_save_hw_io_mult_config); } sdio_open_host_interrupt(SDIO_IF_INT); } #if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 switch_mod_gate_by_type(MOD_SDIO,0); #endif return 0; }
void memories_initialization(void) { //-- Hmatrix bus configuration // This improve speed performance #ifdef AVR32_HMATRIXB union { unsigned long scfg; avr32_hmatrixb_scfg_t SCFG; } u_avr32_hmatrixb_scfg; sysclk_enable_pbb_module(SYSCLK_HMATRIX); // For the internal-flash HMATRIX slave, use last master as default. u_avr32_hmatrixb_scfg.scfg = AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_FLASH]; u_avr32_hmatrixb_scfg.SCFG.defmstr_type = AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT; AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_FLASH] = u_avr32_hmatrixb_scfg.scfg; // For the internal-SRAM HMATRIX slave, use last master as default. u_avr32_hmatrixb_scfg.scfg = AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_SRAM]; u_avr32_hmatrixb_scfg.SCFG.defmstr_type = AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT; AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_SRAM] = u_avr32_hmatrixb_scfg.scfg; # ifdef AVR32_HMATRIXB_SLAVE_EBI // For the EBI HMATRIX slave, use last master as default. u_avr32_hmatrixb_scfg.scfg = AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_EBI]; u_avr32_hmatrixb_scfg.SCFG.defmstr_type = AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT; AVR32_HMATRIXB.scfg[AVR32_HMATRIXB_SLAVE_EBI] = u_avr32_hmatrixb_scfg.scfg; # endif #endif #ifdef AVR32_HMATRIX union { unsigned long scfg; avr32_hmatrix_scfg_t SCFG; } u_avr32_hmatrix_scfg; sysclk_enable_pbb_module(SYSCLK_HMATRIX); // For the internal-flash HMATRIX slave, use last master as default. u_avr32_hmatrix_scfg.scfg = AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_FLASH]; u_avr32_hmatrix_scfg.SCFG.defmstr_type = AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT; AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_FLASH] = u_avr32_hmatrix_scfg.scfg; // For the internal-SRAM HMATRIX slave, use last master as default. u_avr32_hmatrix_scfg.scfg = AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_SRAM]; u_avr32_hmatrix_scfg.SCFG.defmstr_type = AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT; AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_SRAM] = u_avr32_hmatrix_scfg.scfg; # ifdef AVR32_HMATRIX_SLAVE_EBI // For the EBI HMATRIX slave, use last master as default. u_avr32_hmatrix_scfg.scfg = AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_EBI]; u_avr32_hmatrix_scfg.SCFG.defmstr_type = AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT; AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_EBI] = u_avr32_hmatrix_scfg.scfg; # endif #endif #ifdef AVR32_HMATRIX_MASTER_USBB_DMA union { unsigned long mcfg; avr32_hmatrix_mcfg_t MCFG; } u_avr32_hmatrix_mcfg; // For the USBB DMA HMATRIX master, use infinite length burst. u_avr32_hmatrix_mcfg.mcfg = AVR32_HMATRIX.mcfg[AVR32_HMATRIX_MASTER_USBB_DMA]; u_avr32_hmatrix_mcfg.MCFG.ulbt = AVR32_HMATRIX_ULBT_INFINITE; AVR32_HMATRIX.mcfg[AVR32_HMATRIX_MASTER_USBB_DMA] = u_avr32_hmatrix_mcfg.mcfg; // For the USBB DPRAM HMATRIX slave, use the USBB DMA as fixed default master. u_avr32_hmatrix_scfg.scfg = AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_USBB_DPRAM]; u_avr32_hmatrix_scfg.SCFG.fixed_defmstr = AVR32_HMATRIX_MASTER_USBB_DMA; u_avr32_hmatrix_scfg.SCFG.defmstr_type = AVR32_HMATRIX_DEFMSTR_TYPE_FIXED_DEFAULT; AVR32_HMATRIX.scfg[AVR32_HMATRIX_SLAVE_USBB_DPRAM] = u_avr32_hmatrix_scfg.scfg; #endif #if (defined AT45DBX_MEM) && (AT45DBX_MEM == ENABLE) at45dbx_init(); #endif #if ((defined SD_MMC_0_MEM) && (SD_MMC_0_MEM == ENABLE)) \ || ((defined SD_MMC_1_MEM) && (SD_MMC_1_MEM == ENABLE)) sd_mmc_init(); #endif }
/** * \brief Application entry point. * * \return Unused (ANSI-C compatibility). */ int main(void) { uint8_t slot = 0; sd_mmc_err_t err; const usart_serial_options_t usart_serial_options = { .baudrate = CONF_TEST_BAUDRATE, .charlength = CONF_TEST_CHARLENGTH, .paritytype = CONF_TEST_PARITY, .stopbits = CONF_TEST_STOPBITS, }; irq_initialize_vectors(); cpu_irq_enable(); sysclk_init(); board_init(); stdio_serial_init(CONF_TEST_USART, &usart_serial_options); time_tick_init(); // Initialize SD MMC stack sd_mmc_init(); printf("\x0C\n\r-- SD/MMC/SDIO Card Example --\n\r"); printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__); while (1) { if (slot == sd_mmc_nb_slot()) { slot = 0; } printf("Please plug an SD, MMC or SDIO card in slot %d.\n\r", slot+1); // Wait for a card and ready do { err = sd_mmc_check(slot); if ((SD_MMC_ERR_NO_CARD != err) && (SD_MMC_INIT_ONGOING != err) && (SD_MMC_OK != err)) { printf("Card install FAILED\n\r"); printf("Please unplug and re-plug the card.\n\r"); while (SD_MMC_ERR_NO_CARD != sd_mmc_check(slot)) { } } } while (SD_MMC_OK != err); // Display basic card information main_display_info_card(slot); /* Test the card */ if (sd_mmc_get_type(slot) & CARD_TYPE_SDIO) { // Test CIA of SDIO card main_test_sdio(slot); } if (sd_mmc_get_type(slot) & (CARD_TYPE_SD | CARD_TYPE_MMC)) { // SD/MMC Card R/W main_test_memory(slot); } printf("Test finished, please unplugged the card.\n\r"); while (SD_MMC_OK == sd_mmc_check(slot)) { } slot++; } }
/** * \brief Application entry point. * * \return Unused (ANSI-C compatibility). */ int main(void) { char test_file_name[] = "0:sd_mmc_test.txt"; Ctrl_status status; FRESULT res; FATFS fs; FIL file_object; const usart_serial_options_t usart_serial_options = { .baudrate = CONF_TEST_BAUDRATE, .charlength = CONF_TEST_CHARLENGTH, .paritytype = CONF_TEST_PARITY, .stopbits = CONF_TEST_STOPBITS, }; irq_initialize_vectors(); cpu_irq_enable(); sysclk_init(); board_init(); stdio_serial_init(CONF_TEST_USART, &usart_serial_options); /* Initialize SD MMC stack */ sd_mmc_init(); printf("\x0C\n\r-- SD/MMC/SDIO Card Example on FatFs --\n\r"); printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__); while (1) { printf("Please plug an SD, MMC or SDIO card in slot.\n\r"); /* Wait card present and ready */ do { status = sd_mmc_test_unit_ready(0); if (CTRL_FAIL == status) { printf("Card install FAIL\n\r"); printf("Please unplug and re-plug the card.\n\r"); while (CTRL_NO_PRESENT != sd_mmc_check(0)) { } } } while (CTRL_GOOD != status); printf("Mount disk (f_mount)...\r\n"); memset(&fs, 0, sizeof(FATFS)); res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs); if (FR_INVALID_DRIVE == res) { printf("[FAIL] res %d\r\n", res); goto main_end_of_test; } printf("[OK]\r\n"); printf("Create a file (f_open)...\r\n"); test_file_name[0] = LUN_ID_SD_MMC_0_MEM + '0'; res = f_open(&file_object, (char const *)test_file_name, FA_CREATE_ALWAYS | FA_WRITE); if (res != FR_OK) { printf("[FAIL] res %d\r\n", res); goto main_end_of_test; } printf("[OK]\r\n"); printf("Write to test file (f_puts)...\r\n"); if (0 == f_puts("Test SD/MMC stack\n", &file_object)) { f_close(&file_object); printf("[FAIL]\r\n"); goto main_end_of_test; } printf("[OK]\r\n"); f_close(&file_object); printf("Test successfull.\n\r"); main_end_of_test: printf("Please unplug the card.\n\r"); while (CTRL_NO_PRESENT != sd_mmc_check(0)) { } } }
/*! \brief Main function. Execution starts here. */ int main(void) { irq_initialize_vectors(); cpu_irq_enable(); wdt_disable(WDT); // Initialize the sleep manager sleepmgr_init(); // Board initialization sysclk_init(); init_board(); init_pwm(); init_i2c(); // Module initialization init_module_peripherals_bp(); /* Initialize SD MMC stack */ delay_ms(200); sd_mmc_init(); // Start USB stack to authorize VBus monitoring udc_start(); // Init SCPI parser console_init(); // Enable 12V enable_12v(); while (true) { console_process(); if((get_ok_12v_status() == RETURN_OK) && (last_ok_12v_state == false)) { set_user_led_colour(0, 100, 0); last_ok_12v_state = true; } else if((get_ok_12v_status() == RETURN_NOK) && (last_ok_12v_state == true)) { set_user_led_colour(0, 0, 0); last_ok_12v_state = false; } // else if(get_sync_signal_status() == RETURN_OK) // set_user_led_colour(0, 0, 100); // else if(get_ok_12v_status() == RETURN_OK) // set_user_led_colour(100, 0, 0); // else // set_user_led_colour(0, 0, 0); if (main_b_msc_enable) { if (!udi_msc_process_trans()) { //sleepmgr_enter_sleep(); } } else { //sleepmgr_enter_sleep(); } } }
/** * \brief Show SD card status on the OLED screen. */ static void display_sd_info(void) { uint8_t card_check; uint8_t sd_card_type; uint8_t sd_card_version; uint32_t sd_card_size; uint8_t size[10]; // Is SD card present? if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false) { ssd1306_write_text("Please insert SD card..."); } else { ssd1306_write_text("SD card information:"); sd_mmc_init(); card_check = sd_mmc_check(0); while (card_check != SD_MMC_OK) { card_check = sd_mmc_check(0); delay_ms(1); } if (card_check == SD_MMC_OK) { sd_card_type = sd_mmc_get_type(0); sd_card_version = sd_mmc_get_version(0); sd_card_size = sd_mmc_get_capacity(0); ssd1306_set_page_address(1); ssd1306_set_column_address(0); // Card type switch(sd_card_type) { case CARD_TYPE_SD: ssd1306_write_text("- Type: Normal SD card"); break; case CARD_TYPE_SDIO: ssd1306_write_text("- Type: SDIO card"); break; case CARD_TYPE_HC: ssd1306_write_text("- Type: High Capacity card"); break; case CARD_TYPE_SD_COMBO: ssd1306_write_text("- Type: SDIO/Memory card"); break; default: ssd1306_write_text("- Type: unknown"); } ssd1306_set_page_address(2); ssd1306_set_column_address(0); // SD card version switch(sd_card_version) { case CARD_VER_SD_1_0: ssd1306_write_text("- Version: 1.0x"); break; case CARD_VER_SD_1_10: ssd1306_write_text("- Version: 1.10"); break; case CARD_VER_SD_2_0: ssd1306_write_text("- Version: 2.00"); break; case CARD_VER_SD_3_0: ssd1306_write_text("- Version: 3.0x"); break; default: ssd1306_write_text("- Version: unknown"); } ssd1306_set_page_address(3); ssd1306_set_column_address(0); sprintf(size, "- Total size: %lu KB", sd_card_size); ssd1306_write_text(size); } } }
/** * \brief Check for valid firmware in SD card. */ static void check_valid_firmware(void) { /* Check if the application bin in SD card */ uint32_t i; uint8_t card_check; FRESULT res; TCHAR path[3]; /* Init the path to "0:" */ path[0] = 0x0030; path[1] = 0x003A; path[2] = 0x0000; /* Is SD card present? */ if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false) { return; } sd_mmc_init(); card_check = sd_mmc_check(0); while (card_check != SD_MMC_OK) { card_check = sd_mmc_check(0); delay_ms(1); } /* Try to mount file system. */ memset(&fs, 0, sizeof(FATFS)); res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs); if (FR_INVALID_DRIVE == res) { return; } /* Test if the disk is formatted */ res = f_opendir(&dir, path); if (res != FR_OK) { return; } for (i = 0; i < LANGUAGE_NUMBER; i++) { /* Open the application bin file. */ res = f_open(&file_object, file_name_unicode[i], (FA_OPEN_EXISTING | FA_READ)); if (res != FR_OK) { continue; } /* Close the file*/ res = f_close(&file_object); if (res != FR_OK) { continue; } /* Set the firmware type */ firmware_type |= (0x01 << i); } if ((firmware_type & 0x1F) == 0) { return; } /* Show switch info */ multi_language_show_switch_info(); /* Wait 6 seconds to show above info. */ delay_s(6); /* Set the flag. */ valid_firmware_found = 1; }