static int storage_init(fat16_read_t *read_p, fat16_write_t *write_p, void **arg_pp) { std_printf(FSTR("SD storage.\r\n")); std_printf(FSTR("spi bitrate = %lu kbps\r\n"), 2 * 16 * SAMPLES_PER_SOCOND / 1024); /* Initialize SPI for the SD card. */ spi_init(&spi, &spi_device[0], &pin_d53_dev, SPI_MODE_MASTER, SPI_SPEED_2MBPS, 0, 1); sd_init(&sd, &spi); if (sd_start(&sd) != 0) { return (-1); } std_printf(FSTR("sd card started\r\n")); *read_p = (fat16_read_t)sd_read_block; *write_p = (fat16_write_t)sd_write_block; *arg_pp = &sd; return (0); }
/* init mmc/sd card we assume that the card is in the slot */ static int mmc_init(unsigned int msc_clkrt_val) { int retries, ret; u8 *resp; //unsigned int msc_clk_div = (__cpm_get_pllout())/24000000; __msc_reset(); mmc_init_gpio(); REG_MSC_IMASK = 0xffff; REG_MSC_IREG = 0xffff; REG_MSC_CLKRT = 6; //200k /* just for reading and writing, suddenly it was reset, and the power of sd card was not broken off */ resp = mmc_cmd(12, 0, 0x41, MSC_CMDAT_RESPONSE_R1); /* reset */ resp = mmc_cmd(0, 0, 0x80, 0); resp = mmc_cmd(8, 0x1aa, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(55, 0, 0x1, MSC_CMDAT_RESPONSE_R1); if(resp[5] == 0x37) { resp = mmc_cmd(41, 0x40ff8000, 0x3, MSC_CMDAT_RESPONSE_R3); if(resp[5] == 0x3f) ret = sd_init(msc_clkrt_val); return ret; } ret = mmc_found(msc_clkrt_val); return ret; }
master* master_init() { //init sd sd_init(); //allocates memory master* m = (master*)malloc(sizeof(master)); m->l = malloc(sizeof(level)); m->c = malloc(sizeof(charac)); //m->o = malloc(sizeof(object)); m->o = &box; m->co = &co; m->spikes = &spikes; m->box_3 = &box_3; m->box_1 = &box_1; m->flag = &flag; srand(time(NULL)); m->ab = malloc(sizeof(audio_buffer)); //audio init av_config_setup(); m->ab->audio_dev = alt_up_audio_open_dev(AUDIO_NAME); //audio setup reset_audio_buffer(m->ab); //init circular buffer preload_sfx(SFX, m->ab); //preloads sfx //TODO: fix sfx preload_sfx1("coin.wav", m->ab); alt_irq_register(AUDIO_IRQ,m->ab,(alt_isr_func)audio_isr); return m; }
int init_soc(int soc_type) { switch(soc_type) { case MCIMX233: init_all_pins(); //base on board layout init_clock_power(); //init_dma(); serial_init(); //heading by serial_ means this function is from serial.c printf("INIT: \n<..uart..>\n"); printf("INIT: sdram...\n"); init_sdram(); //gpmi_init(); //heading by gpmi_ means this function is from gpmi.c printf("INIT: sd card...\n"); sd_init(); printf("INIT: dm9k...\n"); dm9000_initialize(); printf("INIT: tag-list...\n"); // init_taglist(0x40000000); printf("INIT: booting...\n"); break; } return 0; }
int test_init(struct harness_t *harness_p) { #if defined(ARCH_LINUX) /* Create an empty sd card file. */ system("../../create_sdcard_linux.sh"); file_p = fopen("sdcard", "r+b"); BTASSERT(fat16_init(&fs, linux_read_block, linux_write_block, file_p, 0) == 0); #else BTASSERT(spi_init(&spi, &spi_device[0], &pin_d6_dev, SPI_MODE_MASTER, SPI_SPEED_500KBPS, 0, 0) == 0); BTASSERT(sd_init(&sd, &spi) == 0); BTASSERT(sd_start(&sd) == 0); BTASSERT(fat16_init(&fs, (fat16_read_t)sd_read_block, (fat16_write_t)sd_write_block, &sd, 0) == 0); #endif return (0); }
void storage_switch_sd_ide(UINT8 sd_active, BOOL first) { if (sd_active) { if (!first) { #ifdef IDE_SUPPORT ide_disable(); #endif } #ifdef SDIO_SUPPORT sd_enable(SDIO_GPIO_CS, SDIO_GPIO_CS_POLOR, SDIO_GPIO_DETECT, SDIO_GPIO_LOCK); sd_init(); #endif DM_DEBUG("storage device : sdio active\n"); } else { if (!first) { #ifdef SDIO_SUPPORT sd_disable(); #endif } #ifdef IDE_SUPPORT ide_enable(25, 1); ide_init(); #endif DM_DEBUG("storage device : hdd(ide) active\n"); } }
int emmc_boot(void) { int ret; current_boot = EMMC_BOOT; ctl_num = 0; sd_init(); REG_MSC_CLKRT(ctl_num) = 1; REG_MSC_LPM(ctl_num) = 1; /* cmd12 reset when we reading or writing from the card, send this cmd */ mmc_cmd(12, 0, 0x1, MSC_CMDAT_RESPONSE_R1); mmc_cmd(0, 0xf0f0f0f0, 0x80, MSC_CMDAT_RESPONSE_NONE); REG_MSC_BLKLEN(ctl_num) = 0x200; REG_MSC_NOB(ctl_num) = (SPL_SIZE + redundancy_size) / 512; mmc_cmd(0, 0xfffffffa, ((MSC_CMDAT_INIT) | (MSC_CMDAT_EXP_BOOT_ACK) | (MSC_CMDAT_BOOT_MODE_A) | (MSC_CMDAT_DATA_EN)), MSC_CMDAT_RESPONSE_NONE); ret = mmc_block_readp(SPL_SIZE + redundancy_size, (u32 *)start_addr); if(!ret){ mmc_cmd(0, 0, 0x0, MSC_CMDAT_RESPONSE_NONE); if (!(REG32(start_addr) == 0x4d53504c)){ return sd_boot(1); } return xfer_d2i(start_addr + jump_offset, SPL_SIZE); }else{ return error_handler(current_boot); } }
__attribute__((no_instrument_function)) void not_main(void) { unsigned int ra; serial_init(); print_s("\n\rTesting SD CARD INITIALIZATION\n\r"); sd_init(); // list_root_directory(); FILE *fd; fd = fopen("TORNADO.JPG"); fwrite(fd,"Yaaayie",10); unsigned char *test = (unsigned char*)malloc(sizeof(unsigned char)*6); fread(fd,test,10); print_s("\n\rContents: "); for(int i=0;i<10;i++) print_ch(test[i]); free(test); free(fd); return; }
PXA2xxMMCIState *pxa2xx_mmci_init(MemoryRegion *sysmem, hwaddr base, BlockBackend *blk, qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma) { PXA2xxMMCIState *s; s = (PXA2xxMMCIState *) g_malloc0(sizeof(PXA2xxMMCIState)); s->irq = irq; s->rx_dma = rx_dma; s->tx_dma = tx_dma; memory_region_init_io(&s->iomem, NULL, &pxa2xx_mmci_ops, s, "pxa2xx-mmci", 0x00100000); memory_region_add_subregion(sysmem, base, &s->iomem); /* Instantiate the actual storage */ s->card = sd_init(blk, false); if (s->card == NULL) { exit(1); } register_savevm(NULL, "pxa2xx_mmci", 0, 0, pxa2xx_mmci_save, pxa2xx_mmci_load, s); return s; }
void setup() { ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_FPULazyStackingEnable(); ROM_FPUEnable(); uart_setup(); sd_init(); dac_setup(); keycontrol_setup(); initConfig(); tick_setup(); soundoutcontrol_setup(); setupADC(); setupUSBStore(); initSampleBlocks(); ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); ROM_IntMasterEnable(); DEBUG_PRINT("Setup complete\n", NULL); }
int main(void) { MCUSR &= ~(1 << WDRF); wdt_disable(); // led SETUPRED(); SETUPGREEN(); GREENON(); REDON(); uint8_t bootloader_version[5] = "b002"; eeprom_update_block((void *)&bootloader_version, BOOTLOADER_VERSION_ADDR, 4); sd_disk sd; _delay_ms(250); uint16_t flash = 0; if (!sd_init(&sd) && disk_init(&sd)) { if (!find_and_load_bootfile(&sd)) { flash = 4*3; } } GREENOFF(); REDOFF(); for (int i=0; i<flash; i++) { REDTOGGLE(); _delay_ms(250); } REDOFF(); __asm__("jmp 0000"); sd_write_block(0,0); }
/* * Checks if the given EXI device is a MMC/SD card and makes it available * if true. */ static int sd_probe(struct exi_device *exi_device) { struct sd_host *host; int retval; /* don't try to drive a device which already has a real identifier */ if (exi_device->eid.id != EXI_ID_NONE) return -ENODEV; host = kzalloc(sizeof(*host), GFP_KERNEL); if (!host) return -ENOMEM; host->exi_device = exi_device_get(exi_device); WARN_ON(exi_get_drvdata(exi_device)); exi_set_drvdata(exi_device, host); retval = sd_init(host); if (retval) { exi_set_drvdata(exi_device, NULL); host->exi_device = NULL; kfree(host); exi_device_put(exi_device); } return retval; }
void handle_sdcard() { DEBUG_PUTS("[Card inserted]\n"); if (sd_init()) if (fatfs_mount()) if (find_imgfile()) if (imgfile_init()) { set_disk_type(imgheader.disk_type); PORTA = fatfs_filenumber; fatfs_next_filename(); } else { fatfs_reset_filename(); PORTA = ~0; } while (SDCARD_INSERTED) { service_ide(); service_cdda(); } DEBUG_PUTS("[Card extracted]\n"); cdda_stop(); set_disk_type(0xff); }
void scsi_sd_init(uint8_t lun) { const sdio_t* sdio = (const sdio_t*)scsi_lun[lun].info; if (sd_init(*sdio) != SD_NO_ERROR) { log_error("MSC sd_init() error"); } }
static void nm_session_monitor_init (NMSessionMonitor *monitor) { #ifdef SESSION_TRACKING_SYSTEMD sd_init (monitor); #endif #ifdef SESSION_TRACKING_CONSOLEKIT ck_init (monitor); #endif }
/* init mmc/sd card we assume that the card is in the slot */ static int mmc_init(void) { int retries; u8 *resp; __gpio_as_msc(); __msc_reset(); MMC_IRQ_MASK(); REG_CPM_MSCCDR = __cpm_get_pllout2()%24000000 ? __cpm_get_pllout2()/24000000 : __cpm_get_pllout2()/24000000 - 1; REG_CPM_CPCCR |= CPM_CPCCR_CE; REG_MSC_CLKRT = 7; //250k REG_MSC_RDTO = 0xffffffff; resp = mmc_cmd(12, 0, 0x41, MSC_CMDAT_RESPONSE_R1); /* reset */ resp = mmc_cmd(0, 0, 0x80, 0); resp = mmc_cmd(8, 0x1aa, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(55, 0, 0x1, MSC_CMDAT_RESPONSE_R1); if(!(resp[0] & 0x20) && (resp[5] != 0x37)) { resp = mmc_cmd(1, 0x40ff8000, 0x3, MSC_CMDAT_RESPONSE_R3); retries = 500; while (retries-- && resp && !(resp[4] & 0x80)) { resp = mmc_cmd(1, 0x40300000, 0x3, MSC_CMDAT_RESPONSE_R3); udelay(1000); udelay(1000); } if ((resp[4] & 0x80 ) == 0x80) serial_puts("MMC init ok\n"); else serial_puts("MMC init fail\n"); if((resp[4] & 0x60) == 0x40) highcap = 1; else highcap = 0; /* try to get card id */ resp = mmc_cmd(2, 0, 0x2, MSC_CMDAT_RESPONSE_R2); resp = mmc_cmd(3, 0x10, 0x1, MSC_CMDAT_RESPONSE_R1); REG_MSC_CLKRT = 2; /* 16/1 MHz */ resp = mmc_cmd(7, 0x10, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(6, 0x3b70101, 0x441, MSC_CMDAT_RESPONSE_R1); while(!(REG_MSC_STAT & MSC_STAT_PRG_DONE)) ; REG_MSC_IREG |= MSC_IREG_PRG_DONE; } else sd_init(); return 0; }
static int accounts_settings_init(void) { g_accounts.current_uid = get_active_seat_uid(); /* Register for login changes */ sd_init(&g_accounts); /* Get property values for current user */ get_user_settings(&g_accounts); return ofono_system_settings_driver_register(&accounts_settings_driver); }
DSTATUS disk_initialize (BYTE drv) { s32 r; if(drv != 0) return RES_PARERR; r = sd_init(); if(r == 0) return RES_OK; else return RES_NOTRDY; }
void sdtest_init() { BaseType_t ret; struct sd_setting setting = { .clock = 400000, .wide = SD_BusWide_1b, .mode = SD_SD, }; sd = sd_init(SDIO_ID, &setting); CONFIG_ASSERT(sd != NULL); ret = OS_CREATE_TASK(sdtest_task, "SD Test Task", 512, NULL, 1, sdTask); CONFIG_ASSERT(ret == pdPASS); }
static int pl181_init(SysBusDevice *dev) { pl181_state *s = FROM_SYSBUS(pl181_state, dev); DriveInfo *dinfo; memory_region_init_io(&s->iomem, OBJECT(s), &pl181_ops, s, "pl181", 0x1000); sysbus_init_mmio(dev, &s->iomem); sysbus_init_irq(dev, &s->irq[0]); sysbus_init_irq(dev, &s->irq[1]); qdev_init_gpio_out(&s->busdev.qdev, s->cardstatus, 2); dinfo = drive_get_next(IF_SD); s->card = sd_init(dinfo ? dinfo->bdrv : NULL, false); return 0; }
static void init(void) { usart1_init(115200, buf_in, ARR_LEN(buf_in), buf_out, ARR_LEN(buf_out)); sei(); printf("Running init\n"); int rc = sd_init(); if (rc == 0) { puts_P(PSTR("Init complete\n\n")); } else { puts_P(PSTR("\n\n\nInit failed\n\n")); // Hard_reset(); } }
int securid_setup(struct passwd *pw, char **promptp, sudo_auth *auth) { struct SD_CLIENT *sd = (struct SD_CLIENT *) auth->data; /* Re-initialize SecurID every time. */ if (sd_init(sd) == 0) { /* The programmer's guide says username is 32 bytes */ strlcpy(sd->username, pw->pw_name, 32); return AUTH_SUCCESS; } else { warningx(_("unable to contact the SecurID server")); return AUTH_FATAL; } }
static int milkymist_memcard_init(SysBusDevice *dev) { MilkymistMemcardState *s = FROM_SYSBUS(typeof(*s), dev); DriveInfo *dinfo; dinfo = drive_get_next(IF_SD); s->card = sd_init(dinfo ? dinfo->bdrv : NULL, 0); s->enabled = dinfo ? bdrv_is_inserted(dinfo->bdrv) : 0; memory_region_init_io(&s->regs_region, &memcard_mmio_ops, s, "milkymist-memcard", R_MAX * 4); sysbus_init_mmio(dev, &s->regs_region); return 0; }
/* init mmc/sd card we assume that the card is in the slot */ int mmc_init(void) { int retries, wait; u8 *resp; __gpio_as_msc(); __msc_reset(); MMC_IRQ_MASK(); REG_MSC_CLKRT = 7; //250k REG_MSC_RDTO = 0xffffffff; serial_puts("\n\nMMC/SD INIT\n"); /* reset */ resp = mmc_cmd(0, 0, 0x80, 0); resp = mmc_cmd(8, 0x1aa, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(55, 0, 0x1, MSC_CMDAT_RESPONSE_R1); if(!(resp[0] & 0x20) && (resp[5] != 0x37)) { serial_puts("MMC card found!\n"); resp = mmc_cmd(1, 0x40ff8000, 0x3, MSC_CMDAT_RESPONSE_R3); retries = 100; while (retries-- && resp && !(resp[4] & 0x80)) { resp = mmc_cmd(1, 0x40300000, 0x3, MSC_CMDAT_RESPONSE_R3); sd_mdelay(10); } if ((resp[4] & 0x80) == 0x80) serial_puts("MMC init ok\n"); else serial_puts("MMC init fail\n"); if((resp[4] & 0x60) == 0x40) highcap = 1; else highcap = 0; /* try to get card id */ resp = mmc_cmd(2, 0, 0x2, MSC_CMDAT_RESPONSE_R2); resp = mmc_cmd(3, 0x10, 0x1, MSC_CMDAT_RESPONSE_R1); REG_MSC_CLKRT = 0; /* 16/1 MHz */ resp = mmc_cmd(7, 0x10, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(6, 0x3b70101, 0x441, MSC_CMDAT_RESPONSE_R1); } else sd_init(); return 0; }
static void ronaldo_sdhci_realize(DeviceState *dev, Error **errp) { DeviceClass *dc_parent = DEVICE_CLASS(RONALDO_SDHCI_PARENT_CLASS); RonaldoSDHCIState *s = RONALDO_SDHCI(dev); DriveInfo *di_sd; DriveInfo *di_mmc; di_sd = drive_get_by_index(IF_SD , s->drive_index); di_mmc = drive_get_by_index(IF_SD, (s->drive_index + 2)); s->sd_card = sd_init(di_sd ? blk_by_legacy_dinfo(di_sd) : NULL, false); s->mmc_card = mmc_init(di_mmc ? blk_by_legacy_dinfo(di_mmc) : NULL); dc_parent->realize(dev, errp); qdev_init_gpio_in_named(dev, ronaldo_sdhci_slottype_handler, "SLOTTYPE", 1); }
/** * Create a new Sd object. */ static mp_obj_t class_sd_make_new(const mp_obj_type_t *type_p, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args_p) { static const mp_arg_t allowed_args[] = { { MP_QSTR_spi, MP_ARG_REQUIRED | MP_ARG_OBJ } }; struct class_sd_t *self_p; mp_map_t kwargs; mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; struct class_spi_t *spi_p; mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true); /* Parse the arguments. */ mp_map_init(&kwargs, 0); mp_arg_parse_all(n_args, args_p, &kwargs, MP_ARRAY_SIZE(allowed_args), allowed_args, args); /* Validate SPI driver argument. */ spi_p = args[0].u_obj; if (spi_p->base.type != &module_drivers_class_spi) { nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "expected spi driver")); } /* Create a new SD object. */ self_p = m_new_obj(struct class_sd_t); self_p->base.type = &module_drivers_class_sd; self_p->spi_p = spi_p; if (sd_init(&self_p->drv, &spi_p->drv) != 0) { nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "sd_init() failed")); } return (self_p); }
int try_sd_load(void) { int err; err = sd_init(); if (err) { printf("SD card not found (%d)\n", err); return err; } err = fat_init(); if (err == 0) printf("SD card detected\n"); else { printf("SD card not detected (%d)\n", err); return err; } // if (usbgecko_checkgecko()) // printf("USBGecko serial interface detected\n"); // else // printf("USBGecko serial interface not detected\n"); printf("Opening boot.elf:\n"); err = fat_open("boot.elf"); if (err) { printf("boot.elf not found (%d)\n", err); return err; } extern u32 fat_file_size; printf("reading %d bytes...\n", fat_file_size); err = fat_read(code_buffer, fat_file_size); if (err) { printf("Error %d reading file\n", err); return err; } printf("Done.\n"); return 0; }
int main() { char c; char block[512]; int i; uart_init(); /* version = get_master_version(); */ /* uart_print_str("0x"); */ /* uart_print_hex8(version); */ /* uart_print_str("\n"); */ if (!sd_init()) uart_print_str("sd card initialized!"); else uart_print_str("sd card initialisation fails!"); uart_print_str("\n"); uart_print_str("Before: RX FIFO entries:"); while(1) c = REG8(SPI_MASTER_BASE+RX_FIFO_DATA_COUNT_MSB); uart_print_hex8(c); c = REG8(SPI_MASTER_BASE+RX_FIFO_DATA_COUNT_LSB); uart_print_hex8(c); uart_print_str("\n"); /* if (!sd_block_write()) */ /* uart_print_str("sd card write succeeds!"); */ /* else uart_print_str("sd card write fails!"); */ /* uart_print_str("\n"); */ /* if (!sd_block_read()) */ /* uart_print_str("sd card read succeeds!"); */ /* else uart_print_str("sd card read fails!"); */ /* uart_print_str("\n"); */ /* for (i=0;i<512;i++) */ /* { */ /* uart_print_hex8(block[i]); */ /* uart_print_str("."); */ /* } */ uart_print_str("\n"); return 0; }
/* init mmc/sd card we assume that the card is in the slot */ static int mmc_init(void) { int retries; u8 *resp; __gpio_as_msc(); __msc_reset(); MMC_IRQ_MASK(); __cpm_select_msc_clk(0,1); REG_MSC_CLKRT = 7; //250k resp = mmc_cmd(12, 0, 0x41, MSC_CMDAT_RESPONSE_R1); /* reset */ resp = mmc_cmd(0, 0, 0x80, 0); resp = mmc_cmd(8, 0x1aa, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(55, 0, 0x1, MSC_CMDAT_RESPONSE_R1); if(!(resp[0] & 0x20) && (resp[5] != 0x37)) { resp = mmc_cmd(1, 0xff8000, 0x3, MSC_CMDAT_RESPONSE_R3); retries = 500; while (retries-- && resp && !(resp[4] & 0x80)) { resp = mmc_cmd(1, 0x40300000, 0x3, MSC_CMDAT_RESPONSE_R3); udelay(1000); udelay(1000); } if (resp[4]== 0x80) serial_puts("MMC init ok\n"); else serial_puts("MMC init fail\n"); /* try to get card id */ resp = mmc_cmd(2, 0, 0x2, MSC_CMDAT_RESPONSE_R2); resp = mmc_cmd(3, 0x10, 0x1, MSC_CMDAT_RESPONSE_R1); REG_MSC_CLKRT = 2; /* 16/1 MHz */ resp = mmc_cmd(7, 0x10, 0x1, MSC_CMDAT_RESPONSE_R1); resp = mmc_cmd(6, 0x3b70101, 0x401, MSC_CMDAT_RESPONSE_R1); } else sd_init(); return 0; }
DSTATUS disk_initialize ( BYTE pdrv /* Physical drive nmuber (0..) */ ) { //tty_printf("Disk init called %d\n\r", pdrv); DSTATUS stat; switch (pdrv) { case ATA : return STA_NODISK; case MMC : stat = sd_init(); return stat; case USB : return STA_NODISK; } return STA_NOINIT; }