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; }