/**
* \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;
}
