int setup_waveform_file(void)
{
#ifdef CONFIG_WAVEFORM_FILE_IN_MMC
int mmc_dev = mmc_get_env_devno();
ulong offset = CONFIG_WAVEFORM_FILE_OFFSET;
ulong size = CONFIG_WAVEFORM_FILE_SIZE;
ulong addr = CONFIG_WAVEFORM_BUF_ADDR;
struct mmc *mmc = find_mmc_device(mmc_dev);
uint blk_start, blk_cnt, n;
if (!mmc) {
printf("MMC Device %d not found\n", mmc_dev);
return -1;
}
if (mmc_init(mmc)) {
puts("MMC init failed\n");
return -1;
}
blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
n = mmc->block_dev.block_read(mmc_dev, blk_start,
blk_cnt, (u_char *)addr);
flush_cache((ulong)addr, blk_cnt * mmc->read_bl_len);
return (n == blk_cnt) ? 0 : -1;
#else
return -1;
#endif
}
int get_mmc_block_count(char *device_name)
{
int rv;
struct mmc *mmc;
int block_count = 0;
int dev_num;
dev_num = simple_strtoul(device_name, NULL, 0);
mmc = find_mmc_device(dev_num);
if (!mmc)
{
printf("mmc/sd device is NOT founded.\n");
return -1;
}
rv = mmc_init(mmc);
if (rv)
{
printf("mmc/sd device's initialization is failed.\n");
return -1;
}
block_count = mmc->capacity;
// printf("block_count = %d\n", block_count);
return block_count;
}
static int init_mmc_for_env(struct mmc *mmc)
{
if (!mmc) {
puts("No MMC card found\n");
return -1;
}
if (mmc_init(mmc)) {
puts("MMC init failed\n");
return -1;
}
#ifdef CONFIG_SYS_MMC_ENV_PART
if (CONFIG_SYS_MMC_ENV_PART != mmc->part_num) {
int mmc_env_devno = mmc_get_env_devno();
if (mmc_switch_part(mmc_env_devno,
CONFIG_SYS_MMC_ENV_PART)) {
puts("MMC partition switch failed\n");
return -1;
}
}
#endif
return 0;
}
int sunxi_flash_handle_init(void){
sunxi_flash_read = sunxi_flash_null_read;
sunxi_flash_write = sunxi_flash_null_write;
sunxi_flash_get_size = sunxi_flash_null_get_size;
sunxi_flash_exit = sunxi_flash_null_exit;
if(storage_type == 0){
sunxi_flash_read = sunxi_flash_nand_read;
sunxi_flash_write = sunxi_flash_nand_write;
sunxi_flash_get_size = sunxi_flash_nand_get_size;
sunxi_flash_exit = sunxi_flash_nand_exit;
}
else if((storage_type == 1) || (storage_type == 2)){
mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
if(!mmc){
printf("fail to find one useful mmc card\n");
return -1;
}
if (mmc_init(mmc)) {
puts("MMC init failed\n");
return -1;
}
sunxi_flash_read = sunxi_flash_mmc_read;
sunxi_flash_write = sunxi_flash_mmc_write;
sunxi_flash_get_size = sunxi_flash_mmc_get_size;
sunxi_flash_exit = sunxi_flash_mmc_exit;
}
return 0;
}
static void mmc_load_image(void)
{
struct mmc *mmc;
int err;
u32 boot_mode;
mmc_initialize(gd->bd);
/* We register only one device. So, the dev id is always 0 */
mmc = find_mmc_device(0);
if (!mmc) {
puts("spl: mmc device not found!!\n");
hang();
}
err = mmc_init(mmc);
if (err) {
printf("spl: mmc init failed: err - %d\n", err);
hang();
}
boot_mode = omap_boot_mode();
if (boot_mode == MMCSD_MODE_RAW) {
debug("boot mode - RAW\n");
mmc_load_image_raw(mmc);
} else if (boot_mode == MMCSD_MODE_FAT) {
debug("boot mode - FAT\n");
mmc_load_image_fat(mmc);
} else {
puts("spl: wrong MMC boot mode\n");
hang();
}
}
int skymedi_cid_program(struct mmc *mmc)
{
int ret;
struct mmc_cmd cmd;
card_power_off_on();
mmc->has_init = 0;
mmc->init_in_progress = 0;
ret = mmc_init(mmc);
if (ret)
return ret;
ret = skymedi_set_func(mmc, 0x00000055);
if (ret)
return ret;
ret = skymedi_set_func(mmc, 0x00000057);
if (ret)
return ret;
ret = skymedi_write_file(mmc, 0x80000014, "ERASE.bin", 3000);
if (ret == 0)
return -1;
ret = skymedi_set_func(mmc, 0x00000056);
if (ret)
return ret;
cmd.cmdidx = 32;
cmd.resp_type = MMC_RSP_R1;
cmd.cmdarg = 0x00000001;
ret = mmc_send_cmd(mmc, &cmd, NULL);
if (ret)
return ret;
ret = skymedi_write_file(mmc, 0x80000001, "CID.bin", 3000);
if (ret == 0)
return -1;
return 0;
}
int stm32_sdmmc2_mmc_init(struct stm32_sdmmc2_params *params)
{
int ret;
assert((params != NULL) &&
((params->reg_base & MMC_BLOCK_MASK) == 0U) &&
((params->bus_width == MMC_BUS_WIDTH_1) ||
(params->bus_width == MMC_BUS_WIDTH_4) ||
(params->bus_width == MMC_BUS_WIDTH_8)));
memcpy(&sdmmc2_params, params, sizeof(struct stm32_sdmmc2_params));
if (stm32_sdmmc2_dt_get_config() != 0) {
ERROR("%s: DT error\n", __func__);
return -ENOMEM;
}
ret = stm32mp1_clk_enable(sdmmc2_params.clock_id);
if (ret != 0) {
ERROR("%s: clock %d failed\n", __func__,
sdmmc2_params.clock_id);
return ret;
}
stm32mp1_reset_assert(sdmmc2_params.reset_id);
udelay(2);
stm32mp1_reset_deassert(sdmmc2_params.reset_id);
mdelay(1);
sdmmc2_params.clk_rate = stm32mp1_clk_get_rate(sdmmc2_params.clock_id);
return mmc_init(&stm32_sdmmc2_ops, sdmmc2_params.clk_rate,
sdmmc2_params.bus_width, sdmmc2_params.flags,
sdmmc2_params.device_info);
}
DSTATUS diskInitialize (BYTE drv __attribute__ ((unused)))
{
//
// Media Init
//
SPI_Init();
switch (mmc_init ())
{
case 0 :
{
mediaStatus.statusCode = DSC_COMMANDPASS;
mediaStatus.mediaChanged = 1;
gDiskStatus = 0;
//printf("\nMMC INIT OK\n");
}
break;
default:
{
mediaStatus.statusCode = DSC_NOTPRESENT;
gDiskStatus = DSTATUS_NODISK;
}
break;
}
return gDiskStatus;
}
//=======================================================================
int sdcard_post_test(int flags)
{
struct mmc *mmc;
int dev_num;
dev_num = simple_strtoul("mmcinfo", NULL, 0);
mmc = find_mmc_device(dev_num);
if (mmc) {
mmc_init(mmc);
if((mmc->tran_speed == 0) || (mmc->read_bl_len == 0) || (mmc->capacity == 0)) {
post_log("<%d>%s:%d: SDCARD: %s\n", SYSTEST_INFO_L2, __FUNCTION__, __LINE__, "no MMC device available.");
return -1;
}
post_log("<%d>SDCARD: Device: %s\n", SYSTEST_INFO_L2, mmc->name);
post_log("<%d>SDCARD: Manufacturer ID: %x\n", SYSTEST_INFO_L2, mmc->cid[0] >> 24);
post_log("<%d>SDCARD: OEM: %x\n", SYSTEST_INFO_L2, (mmc->cid[0] >> 8) & 0xffff);
//post_log("<%d>SDCARD: Name: %c%c%c%c%c\n",SYSTEST_INFO_L2, mmc->cid[0] & 0xff,
// (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
// (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
post_log("<%d>SDCARD: Tran Speed: %d\n", SYSTEST_INFO_L2, mmc->tran_speed);
post_log("<%d>SDCARD: Rd Block Len: %d\n", SYSTEST_INFO_L2, mmc->read_bl_len);
post_log("<%d>SDCARD: %s version %d.%d\n", SYSTEST_INFO_L2, IS_SD(mmc) ? "SD" : "MMC",
(mmc->version >> 4) & 0xf, mmc->version & 0xf);
post_log("<%d>SDCARD: High Capacity: %s\n", SYSTEST_INFO_L2, mmc->high_capacity ? "Yes" : "No");
post_log("<%d>SDCARD: Capacity: %lld\n", SYSTEST_INFO_L2, mmc->capacity);
post_log("<%d>SDCARD: Bus Width: %d-bit\n", SYSTEST_INFO_L2, mmc->bus_width);
}
else {
uint32_t fs_sd_init ()
{
int status;
if (0 > enable_vaux3()) {
dprintf (CRITICAL, "Failed to init VAUX3 for SD-card\n");
}
/* wait for SD card */
if(!mmc_sd_detected()) {
printf ("Crash handling: Please insert SD card\n");
do {
putc('.');
thread_sleep(1000); /* ms */
} while(!mmc_sd_detected());
putc('\n');
}
/* Init internal L/S for SDMMC0 */
if (mmc_sd_set_startup_iosv() < 0)
return 1;
sd = mmc_init (U8500_SDI0_BASE, &status, EXPECT_SD);
dprintf (INFO, "fs_sd_mount: mmc_init status %d\n", status);
if (MMC_OK == status) {
return 0;
}
return 1;
}
int put_mmc_mbr(unsigned char *mbr, char *device_name)
{
int rv;
struct mmc *mmc;
int dev_num;
dev_num = simple_strtoul(device_name, NULL, 0);
mmc = find_mmc_device(dev_num);
if (!mmc)
{
printf("mmc/sd device is NOT founded.\n");
return -1;
}
rv = mmc_init(mmc);
if (rv)
{
printf("mmc/sd device's initialization is failed.\n");
return -1;
}
rv = mmc->block_dev.block_write(dev_num, 0, 1, mbr);
if(rv == 1)
return 0;
else
return -1;
}
int skymedi_verify_llf_and_fw(struct mmc *mmc)
{
int ret;
card_power_off_on();
mmc->has_init = 0;
mmc->init_in_progress = 0;
ret = mmc_init(mmc);
if (ret)
return ret;
mmc_set_bus_width(mmc, 1);
ret = skymedi_set_func(mmc, 0x00000055);
if (ret)
return ret;
ret = skymedi_set_func(mmc, 0x00000057);
if (ret)
return ret;
ret = skymedi_write_file(mmc, 0x80000014, "ERASE.bin", 3000);
if (ret == 0)
return -1;
ret = skymedi_set_func(mmc, 0x00000056);
if (ret)
return ret;
ret = skymedi_read_blocks(mmc, sector_buff, 0xFFFFFF47, 512 / 512);
if (ret == 0)
return -1;
//check version ???
//compare test from address 0 at least 10 sectors data ????
return 0;
}
static void
disc_install(MFS_descriptor_t *dir)
{
MFS_descriptor_t *mmc;
mmc = MFS_directory_create (dir, "mmc");
MFS_descriptor_t *desc = MFS_block_create (mmc, "cfg", &mmc_desc_op, &mmc_block_op, (MFS_represent_t *) &d1_p1, MFS_DISK);
mmc_init(desc, LA2_PARTITION_1_START, LA2_PARTITION_1_END, LA2_MMC_BLOCK_SIZE);
desc = MFS_block_create (mmc, "tst", &mmc_desc_op, &mmc_block_op, (MFS_represent_t *) &d1_p2, MFS_DISK);
mmc_init(desc, LA2_PARTITION_2_START, LA2_PARTITION_2_END, LA2_MMC_BLOCK_SIZE);
desc = MFS_block_create (mmc, "sfs", &mmc_desc_op, &mmc_block_op, (MFS_represent_t *) &d1_p3, MFS_DISK);
mmc_init(desc, LA2_PARTITION_3_START, LA2_PARTITION_3_END, LA2_MMC_BLOCK_SIZE);
USO_buf_pool_init (&get_pool, get_bufs, LA2_GET_BUFS, LA2_MMC_BLOCK_SIZE);
}
static int upgrade_sd_dect(void)
{
struct mmc *mmc = find_mmc_device(0);
sd_dect_flag = 1;
unsigned ret = mmc_init(mmc);
sd_dect_flag = 0;
return ret;
}
int
main(void) {
dma_init();
mmc_init(mainMMC_PRIORITY);
usb_init(mainUSB_PRIORITY);
/* Start the scheduler. */
vTaskStartScheduler();
}
void app_start(int argc, char *argv[])
{
tp_out("TinkerPal Application - FAT MMC Test\n");
mmc_init(&board.mmc_params);
cli_start(&fat_mmc_test_cli_client);
}
int do_mmc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
if (mmc_init (1) != 0) {
printf ("No MMC card found\n");
return 1;
}
return 0;
}
//Initialize igordev
void mmcdevice_init()
{
igordev_mmc.read_status = igordev_mmc.write_status = IDEV_STATUS_OK;
igordev_mmc.id = (CAN_READ | CAN_WRITE | ADDR_READ | ADDR_WRITE |
(DEVTYPE_STORAGE << DEVTYPE_OFFSET));
mmc_init();
}
void Task2()
{
int16_t cnt;
int8_t val;
uint32_t sector = 0;
nrk_sem_t *radio_sem;
while(1) nrk_wait_until_next_period();
radio_sem= rf_get_sem();
if(radio_sem==NULL) nrk_kprintf( PSTR("radio sem failed!\r\n" ));
printf( "Task2 PID=%u\r\n",nrk_get_pid());
cnt=0;
val=mmc_init();
if(val!=0 ) {
printf( "val=%d\r\n",val );
nrk_kprintf( PSTR("card init failed\r\n") );
while(1);
}
while(1) {
nrk_sem_pend (radio_sem);
printf("\nsector %lu\n\r",sector); // show sector number
val=mmc_readsector(sector,sectorbuffer); // read a data sector
printf( "readsector returned %d\n",val );
for(cnt=0; cnt<32; cnt++ )
printf( "%d ",sectorbuffer[cnt] );
printf( "\n\r" );
val=sectorbuffer[0];
val++;
for(cnt=0; cnt<512; cnt++ )
{
sectorbuffer[cnt]=val;
}
nrk_kprintf( PSTR("Writting\r\n") );
val=mmc_writesector(sector,sectorbuffer); // read a data sector
printf( "writesector returned %d\n",val );
printf( "After write:\r\n" );
val=mmc_readsector(sector,sectorbuffer); // read a data sector
nrk_sem_post(radio_sem);
printf( "readsector returned %d\n",val );
if(val==0)
{
for(cnt=0; cnt<32; cnt++ )
printf( "%d ",sectorbuffer[cnt] );
nrk_kprintf( PSTR("\n\r") );
}
sector++;
// nrk_led_toggle(RED_LED);
// printf( "Task2 signed cnt=%d\r\n",cnt );
nrk_wait_until_next_period();
cnt--;
}
}
int board_late_init(void)
{
if (mmc_init(1)) {
printf("mmc init failed?\n");
return 1;
}
printf("\nefi partition table:\n");
return load_ptbl();
}
/*
* initializes sd card and reads config file
*/
void initSDCard()
{
int retVal=0;
int timeout = 0;
DWORD P1;
// if(sdcInitDone) //init procedure already started
// return; // Thread wird sowieso beendet
curFileID=-99;
//Set output Pins for LEDs
DDR03_D7 = 1; //Read (Pin 16)
DDR03_D6 = 1; //Write (Pin 15)
PDR03_P7 = 1;
PDR03_P6 = 1;
mmc_initPorts();
// Seg_Hex(0xC);
//wait for card to be inserted
while(mmc_getCardStatus() > 0) //it is 0 if we have a card
{
//return after 10 sec
if(timeout > 20)
return;
#ifdef SDCARD_DEBUG
printf("waiting for card.. \r\n");
#endif
os_wait(500);
timeout++;
}
// Seg_Hex(0xF);
os_wait(200);
//initialize card
retVal=mmc_init();
os_wait(200);
//mount FAT file system
P1=0;
f_mount((BYTE)P1, &fatfs[P1]);
if(curFileID==-99) //has not been set
SetCurrentFileID(1,1);
sdcInitDone=1;
//read configuration file from sd card
readConfigFromFile();
Seg_Hex(0x00);
}
int32 readfat(int32 fatoffset){
int16 temp;
int32 tempb;
char los;
temp=0;
fatoffset=fatoffset*2;
los = *(((char*)&fatoffset)+0); //the bottom byte of the address goes directly to a word in the FAT
fatoffset=fatoffset / 256;
fatoffset+=fatstart;
if(mmc_open_block(fatoffset)==1){
//putc('^');
// printf("fat retry...");
if(mmc_open_block(fatoffset)==1){
//putc('&');
mmc_init(0);
// printf("fat RETRY...");
if(mmc_open_block(fatoffset)==1){
//putc('*');
mmc_init(0);
// printf("fat LOOKS BAD...");
if(mmc_open_block(fatoffset)==1){
//printf("problem reading fat table, quitting chain. Sorry!");
error=7;
return 0xffffffff;
}
}
}
}
mmc_skip(los);
mmc_read();
temp = ((int16) data_hi * 256)+ (int16) data_lo;
mmc_read();//for fat32, four bytes per entry
tempb=0;
tempb = ((int16) data_hi * 256)+ (int16) data_lo;
tempb=tempb<<16;
tempb=tempb+(int32) temp;
mmc_skip(255-(los));//trouble???
mmc_read();
mmc_read();
mmc_close_block();
return tempb;
}
/*
* Load kernel image from MMC/SD into RAM
*/
int msc_read(ulong start_byte, u8 *dst, size_t len)
{
int start_sect;
start_sect = start_byte / 512;
mmc_init();
mmc_block_readm(start_sect, len, dst);
return 0;
}
static int emmc_init(void)
{
int ret = -1;
struct mmc *mmc = NULL;
mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
if (mmc) {
ret = mmc_init(mmc); // init eMMC/tSD+
}
return ret;
}
void env_relocate_spec(void)
{
#if !defined(ENV_IS_EMBEDDED)
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
mmc_init(mmc);
mmc->block_dev.block_read(CONFIG_SYS_MMC_ENV_DEV, CONFIG_MMC_ENV_BLOCK_OFFSET, CONFIG_MMC_ENV_BLOCK_COUNT, (u_char *)env_ptr);
#endif
}
int saveenv(void)
{
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
mmc_init(mmc);
printf("Writing to MMC(%d)... ", CONFIG_SYS_MMC_ENV_DEV);
mmc->block_dev.block_write(CONFIG_SYS_MMC_ENV_DEV, CONFIG_MMC_ENV_BLOCK_OFFSET, CONFIG_MMC_ENV_BLOCK_COUNT, (u_char *)env_ptr);
puts("done\n");
return 0;
}
/**
* load_dev_tree(void) - Load the device tree if found.
*
* If a device tree is found within a partition then it is loaded into
* the device tree load address.
*
* The load address depends on the partition it was found in:
* Default is #define DEVICE_TREE for device_tree partition
* where the device tree is just the compiled binary or undefined.
* Otherwise the address is read from the associated header.
*
* Returns the load addres in memory of the device tree.
**/
u32 load_dev_tree(u32 atag_load_addr)
{
int ret = 0;
int sector;
int num_sectors;
int sector_sz = 0;
u32 dt_load_addr = 0;
struct mmc* mmc = NULL;
int status;
ret = find_dev_tree();
if (ret < 0) {
printf("%s: Device tree not supported\n", __func__);
dt_data->dev_tree_load_addr = atag_load_addr;
goto out;
}
mmc = find_mmc_device(1);
if (mmc == NULL) {
goto out;
}
status = mmc_init(mmc);
if (status != 0) {
printf("mmc init failed\n");
goto out;
}
sector_sz = mmc->block_dev.blksz;
sector = dt_data->pte->start;
num_sectors = (dt_data->dev_tree_sz/sector_sz);
if (num_sectors <= (dt_data->dev_tree_sz / sector_sz))
num_sectors = (dt_data->dev_tree_sz / sector_sz);
status = mmc->block_dev.block_read(1, sector, num_sectors,
(void *)dt_data->dev_tree_load_addr);
if (status < 0) {
printf("mmc read failed\n");
goto out;
}
DBG("dev_tree @ %08x (%d)\n",
dt_data->dev_tree_load_addr,
dt_data->dev_tree_sz);
out:
if (dt_data->dev_tree_load_addr) {
dt_load_addr = dt_data->dev_tree_load_addr;
}
free(dt_data);
return dt_load_addr;
}
static target_mmc_sdhci_init()
{
struct mmc_config_data config;
uint32_t soc_ver = 0;
/* Enable sdhci mode */
sdhci_mode_enable(1);
soc_ver = board_soc_version();
/*
* 8974 v1 fluid devices, have a hardware bug
* which limits the bus width to 4 bit.
*/
switch(board_hardware_id())
{
case HW_PLATFORM_FLUID:
if (soc_ver >= BOARD_SOC_VERSION2)
config.bus_width = DATA_BUS_WIDTH_8BIT;
else
config.bus_width = DATA_BUS_WIDTH_4BIT;
break;
default:
config.bus_width = DATA_BUS_WIDTH_8BIT;
};
config.max_clk_rate = MMC_CLK_200MHZ;
/* Trying Slot 1*/
config.slot = 1;
config.base = mmc_sdhci_base[config.slot - 1];
if (!(dev = mmc_init(&config))) {
/* Trying Slot 2 next */
config.slot = 2;
config.base = mmc_sdhci_base[config.slot - 1];
if (!(dev = mmc_init(&config))) {
dprintf(CRITICAL, "mmc init failed!");
ASSERT(0);
}
}
}
DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber (0..) */
)
{
if (drv)
return STA_NOINIT;
mmc_init();
SD_STATUS &= ~STA_NODISK;
SD_STATUS &= ~STA_NOINIT;
return SD_STATUS; /* TODO: verify if this is success */
}
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize(BYTE drv /* Physical drive nmuber (0..) */
)
{
DSTATUS stat;
int result;
switch (drv) {
case SD:
result = mmc_init();
return result;
}
return STA_NOINIT;
}
