/** * \brief Performs a memory initialization on the SD/MMC card * * This function will simply test the output of the function * \ref sd_mmc_spi_mem_check and returns an error in case of failure. * * \param test Current test case. */ static void run_memory_check_test(const struct test_case *test) { bool status; status = sd_mmc_spi_mem_check(); test_assert_true(test, status == true, "Error memory initialization failed"); }
/*! \brief Initializes SD/MMC resources: GPIO, SPI and SD/MMC. */ static void sd_mmc_resources_init(void) { // GPIO pins used for SD/MMC interface static const gpio_map_t SD_MMC_SPI_GPIO_MAP = { {SD_MMC_SPI_SCK_PIN, SD_MMC_SPI_SCK_FUNCTION }, // SPI Clock. {SD_MMC_SPI_MISO_PIN, SD_MMC_SPI_MISO_FUNCTION}, // MISO. {SD_MMC_SPI_MOSI_PIN, SD_MMC_SPI_MOSI_FUNCTION}, // MOSI. {SD_MMC_SPI_NPCS_PIN, SD_MMC_SPI_NPCS_FUNCTION} // Chip Select NPCS. }; // SPI options. spi_options_t spiOptions = { .reg = SD_MMC_SPI_NPCS, .baudrate = SD_MMC_SPI_MASTER_SPEED, // Defined in conf_sd_mmc_spi.h. .bits = SD_MMC_SPI_BITS, // Defined in conf_sd_mmc_spi.h. .spck_delay = 0, .trans_delay = 0, .stay_act = 1, .spi_mode = 0, .modfdis = 1 }; // Assign I/Os to SPI. gpio_enable_module(SD_MMC_SPI_GPIO_MAP, sizeof(SD_MMC_SPI_GPIO_MAP) / sizeof(SD_MMC_SPI_GPIO_MAP[0])); // Initialize as master. spi_initMaster(SD_MMC_SPI, &spiOptions); // Set SPI selection mode: variable_ps, pcs_decode, delay. spi_selectionMode(SD_MMC_SPI, 0, 0, 0); // Enable SPI module. spi_enable(SD_MMC_SPI); // Initialize SD/MMC driver with SPI clock (PBA). sd_mmc_spi_init(spiOptions, PBA_HZ); } /*! \brief Initialize PDCA (Peripheral DMA Controller A) resources for the SPI transfer and start a dummy transfer */ void local_pdca_init(void) { // this PDCA channel is used for data reception from the SPI pdca_channel_options_t pdca_options_SPI_RX ={ // pdca channel options .addr = ram_buffer, // memory address. We take here the address of the string dummy_data. This string is located in the file dummy.h .size = 512, // transfer counter: here the size of the string .r_addr = NULL, // next memory address after 1st transfer complete .r_size = 0, // next transfer counter not used here .pid = AVR32_PDCA_CHANNEL_USED_RX, // select peripheral ID - data are on reception from SPI1 RX line .transfer_size = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer: 8,16,32 bits }; // this channel is used to activate the clock of the SPI by sending a dummy variables pdca_channel_options_t pdca_options_SPI_TX ={ // pdca channel options .addr = (void *)&dummy_data, // memory address. // We take here the address of the string dummy_data. // This string is located in the file dummy.h .size = 512, // transfer counter: here the size of the string .r_addr = NULL, // next memory address after 1st transfer complete .r_size = 0, // next transfer counter not used here .pid = AVR32_PDCA_CHANNEL_USED_TX, // select peripheral ID - data are on reception from SPI1 RX line .transfer_size = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer: 8,16,32 bits }; // Init PDCA transmission channel pdca_init_channel(AVR32_PDCA_CHANNEL_SPI_TX, &pdca_options_SPI_TX); // Init PDCA Reception channel pdca_init_channel(AVR32_PDCA_CHANNEL_SPI_RX, &pdca_options_SPI_RX); //! \brief Enable pdca transfer interrupt when completed INTC_register_interrupt(&pdca_int_handler, AVR32_PDCA_IRQ_0, AVR32_INTC_INT1); // pdca_channel_spi1_RX = 0 } /*! \brief Main function. Execution starts here. */ int main(void) { int i, j; // Switch the main clock to the external oscillator 0 pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP); // Initialize debug RS232 with PBA clock init_dbg_rs232(PBA_HZ); //start test print_dbg("\r\nInit SD/MMC Driver"); print_dbg("\r\nInsert SD/MMC..."); // Initialize Interrupt Controller INTC_init_interrupts(); // Initialize SD/MMC driver resources: GPIO, SPI and SD/MMC. sd_mmc_resources_init(); // Wait for a card to be inserted while (!sd_mmc_spi_mem_check()); print_dbg("\r\nCard detected!"); // Read Card capacity sd_mmc_spi_get_capacity(); print_dbg("Capacity = "); print_dbg_ulong(capacity >> 20); print_dbg(" MBytes"); // Enable all interrupts. Enable_global_interrupt(); // Initialize PDCA controller before starting a transfer local_pdca_init(); // Read the first sectors number 1, 2, 3 of the card for(j = 1; j <= 3; j++) { // Configure the PDCA channel: the address of memory ram_buffer to receive the data at sector address j pdca_load_channel( AVR32_PDCA_CHANNEL_SPI_RX, &ram_buffer, 512); pdca_load_channel( AVR32_PDCA_CHANNEL_SPI_TX, (void *)&dummy_data, 512); //send dummy to activate the clock end_of_transfer = false; // open sector number j if(sd_mmc_spi_read_open_PDCA (j)) { print_dbg("\r\nFirst 512 Bytes of Transfer number "); print_dbg_ulong(j); print_dbg(" :\r\n"); spi_write(SD_MMC_SPI,0xFF); // Write a first dummy data to synchronize transfer pdca_enable_interrupt_transfer_complete(AVR32_PDCA_CHANNEL_SPI_RX); pdca_channelrx =(volatile avr32_pdca_channel_t*) pdca_get_handler(AVR32_PDCA_CHANNEL_SPI_RX); // get the correct PDCA channel pointer pdca_channeltx =(volatile avr32_pdca_channel_t*) pdca_get_handler(AVR32_PDCA_CHANNEL_SPI_TX); // get the correct PDCA channel pointer pdca_channelrx->cr = AVR32_PDCA_TEN_MASK; // Enable RX PDCA transfer first pdca_channeltx->cr = AVR32_PDCA_TEN_MASK; // and TX PDCA transfer while(!end_of_transfer); // Display the first 2O bytes of the ram_buffer content for( i = 0; i < 20; i++) { print_dbg_char_hex( (U8)(*(ram_buffer + i))); } } else { print_dbg("\r\n! Unable to open memory \r\n"); } } print_dbg("\r\nEnd of the example.\r\n"); while (1); }
//int main(void) { ////main function int main (void) { u32 waitForCard = 0; // set up avr32 hardware and peripherals init_avr32(); print_dbg("\r\n SRAM size: 0x"); print_dbg_hex(smc_get_cs_size(1)); cpu_irq_disable(); /// test the SRAM sram_test(); cpu_irq_enable(); //memory manager init_mem(); print_dbg("\r\n init_mem"); // wait for sdcard print_dbg("\r\n SD check... "); while (!sd_mmc_spi_mem_check()) { waitForCard++; } print_dbg("\r\nfound SD card. "); // intialize the FAT filesystem print_dbg("\r\n init fat"); fat_init(); // setup control logic print_dbg("\r\n init ctl"); init_ctl(); /* // initialize the application */ /* app_init(); */ /* print_dbg("\r\n init app"); */ // initialize flash: firstrun = init_flash(); print_dbg("r\n init flash, firstrun: "); print_dbg_ulong(firstrun); screen_startup(); // find and load dsp from sdcard files_search_dsp(); print_dbg("\r\n starting event loop.\r\n"); // dont do startup startup = 0; while(1) { check_events(); } }
Ctrl_status sd_mmc_spi_test_unit_ready(void) { Sd_mmc_spi_access_signal_on(); switch (sd_mmc_spi_presence_status) { case SD_MMC_REMOVED: sd_mmc_spi_init_done = false; if (sd_mmc_spi_mem_check()) { sd_mmc_spi_presence_status = SD_MMC_INSERTED; Sd_mmc_spi_access_signal_off(); return CTRL_BUSY; } Sd_mmc_spi_access_signal_off(); return CTRL_NO_PRESENT; case SD_MMC_INSERTED: if (!sd_mmc_spi_mem_check()) { sd_mmc_spi_presence_status = SD_MMC_REMOVING; sd_mmc_spi_init_done = false; Sd_mmc_spi_access_signal_off(); return CTRL_BUSY; } Sd_mmc_spi_access_signal_off(); return CTRL_GOOD; case SD_MMC_REMOVING: sd_mmc_spi_presence_status = SD_MMC_REMOVED; Sd_mmc_spi_access_signal_off(); return CTRL_NO_PRESENT; default: sd_mmc_spi_presence_status = SD_MMC_REMOVED; Sd_mmc_spi_access_signal_off(); return CTRL_BUSY; } /* if (sd_mmc_spi_mem_check()) { if (!sd_mmc_spi_status_changed) { sd_mmc_spi_status_changed = true; return CTRL_BUSY; // BUSY token must be returned to indicate a status change ! } else return CTRL_GOOD; // the 2nd time the host will ask for unit_ready, we can answer GOOD if we have returned BUSY first ! } else { if (sd_mmc_spi_status_changed) { sd_mmc_spi_status_changed = false; return CTRL_BUSY; // BUSY token must be returned to indicate a status change ! } else return CTRL_NO_PRESENT; } */ }
// this is called from the event queue to start the app // return >0 if there is an error doing firstrun init u8 app_launch(u8 firstrun) { u32 waitForCard; print_dbg("\r\n app launch"); print_dbg("\r\n firstrun: "); print_dbg_ulong(firstrun); if(firstrun) { // it is the first run. // need to copy audio module binary from sdcard to internal flash. render_boot("first run. waiting for SDcard..."); render_update(); print_dbg("\r\n SD check... "); while (!sd_mmc_spi_mem_check()) { waitForCard++; } print_dbg("\r\nfound SD card. "); render_boot("found sdcard.. reading DSP..."); render_update(); // search for our dsp and load it // return success (0 == fail) if( files_search_dsp() ) { ;; } else { screen_clear(); return 0; } } else { // firstrun pattern was set, so there should be a blackfin executable in flash. // read from flash to RAM render_boot("loading flash to RAM..."); render_update(); flash_read_ldr(); render_boot( "booting DSP from flash..."); render_update(); // reboot DSP from RAM bfin_load_buf(); } render_boot("waiting for bfin init... "); render_update(); bfin_wait_ready(); // set encoder sensitivity set_enc_thresh(3, 16); delay_ms(20); // enable audio render_boot("run "); render_update(); bfin_enable(); // enable timers init_app_timers(); render_startup(); render_update(); // set app event handlers mix_assign_event_handlers(); return 1; }
// this is called from main event handler u8 app_launch(u8 firstrun) { print_dbg("\r\n launching app with firstrun: "); print_dbg_ulong(firstrun); // net_print(); render_boot("BEES"); render_boot(versionString); while (!sd_mmc_spi_mem_check()) { render_boot("waiting for SD card..."); } if(firstrun) { render_boot("launching app, first run"); print_dbg("\r\n first run, writing nonvolatile data..."); ///... write param scaler data // this is done at firstrun instead of being linked statically, // so that users can tune scaler data offline without recompiling render_boot("init param scaling data..."); flash_init_scaler_data(); print_dbg("\r\n first run, try and load default DSP"); render_boot("launching default DSP"); //// startup using default DSP name files_load_dsp_name(DEFAULT_LDR); render_boot("waiting for DSP init..."); bfin_wait_ready(); // print_dbg("\r\n enable DSP audio..."); render_boot("enabling audio"); bfin_enable(); } else { app_pause(); /// blackfin should clear ready pin ASAP on boot. /// but give it a moment to accomplish that. delay_ms(2); /// read the default scene from sd card /// this also attempts to load associated .ldr render_boot("reading default scene"); print_dbg("\r\n loading default scene. current module name from sceneData: "); print_dbg(sceneData->desc.moduleName); scene_read_default(); delay_ms(2); app_resume(); } // init pages (fill graphics buffers) render_boot("initializing gfx"); print_dbg("\r\n pages_init..."); pages_init(); print_dbg("\r\n play_init..."); play_init(); // enable timers print_dbg("\r\n enable app timers..."); render_boot("enabling app timers"); init_app_timers(); // pull up power control pin, enabling soft-powerdown // gpio_set_gpio_pin(POWER_CTL_PIN); // assign app event handlers print_dbg("\r\n assigning handlers... "); render_boot("assigning UI handlers"); assign_bees_event_handlers(); // update page rendering and handlers... pages_reselect(); // start in play mode if not firstrun if(!firstrun) pages_toggle_play(); return 1; }