/* SDEXT emulation currently excepts the cartridge area (segments 4-7) to be filled * with the FLASH ROM content. Even segment 7, which will be copied to the second 64K "hidden" * and pagable flash area of the SD cartridge. Currently, there is no support for the full * sized SDEXT flash image */ void sdext_init ( void ) { /* try to detect SDEXT ROM extension and only turn on emulation if it exists */ if (sdext_detect_rom()) { WARNING_WINDOW("No SD-card cartridge ROM code found in loaded ROM set. SD card hardware emulation has been disabled!"); *sdimg_path = 0; sdf = NULL; SD_DEBUG("SDEXT: init: REFUSE: no SD-card cartridge ROM code found in loaded ROM set." NL); return; } SD_DEBUG("SDEXT: init: cool, SD-card cartridge ROM code seems to be found in loaded ROM set, enabling SD card hardware emulation ..." NL); sdf = open_emu_file(config_getopt_str("sdimg"), "rb", sdimg_path); // open in read-only mode, to get the path if (sdf) { fclose(sdf); sdf = fopen(sdimg_path, "r+b"); if (sdf) { DEBUGPRINT("SDEXT: SD image file is re-open in read/write mode, good (fd=%d)." NL, fileno(sdf)); } else { sdf = fopen(sdimg_path, "rb"); DEBUGPRINT("SDEXT: SD image cannot be re-open in read-write mode, using read-only access (fd=%d)." NL, fileno(sdf)); } } if (!sdf) { WARNING_WINDOW("SD card image file \"%s\" cannot be open: %s. You can use Xep128 but SD card access won't work!", sdimg_path, ERRSTR()); *sdimg_path = 0; } else { sdfd = fileno(sdf); sd_card_size = lseek(sdfd, 0, SEEK_END); SD_DEBUG("SDEXT: SD card size is: %ld bytes" NL, sd_card_size); if (sd_card_size > MAX_CARD_SIZE || sd_card_size < MIN_CARD_SIZE) { fclose(sdf); sdf = NULL; ERROR_WINDOW("SD card image file \"%s\" is too small or large, valid range is %ld - %ld Mbytes, but this one is %ld bytes long (about %ld Mbytes). SD access has been disabled!", sdimg_path, MIN_CARD_SIZE >> 20, MAX_CARD_SIZE >> 20, sd_card_size, sd_card_size >> 20 ); *sdimg_path = 0; } }
/** * \ingroup sd_raw * Initializes memory card communication. * * \returns 0 on failure, 1 on success. */ uint8_t sd_raw_init(void) { _sd_infodirty = 1; /* enable inputs for reading card status */ configure_pin_available(); configure_pin_locked(); /* enable outputs for MOSI, SCK, SS, input for MISO */ configure_pin_mosi(); configure_pin_sck(); configure_pin_ss(); configure_pin_miso(); unselect_card(); /* initialize SPI with lowest frequency; max. 400kHz during identification mode of card */ SPCR = (0 << SPIE) | /* SPI Interrupt Enable */ (1 << SPE) | /* SPI Enable */ (0 << DORD) | /* Data Order: MSB first */ (1 << MSTR) | /* Master mode */ (0 << CPOL) | /* Clock Polarity: SCK low when idle */ (0 << CPHA) | /* Clock Phase: sample on rising SCK edge */ (1 << SPR1) | /* Clock Frequency: f_OSC / 128 */ (1 << SPR0); SPSR &= ~(1 << SPI2X); /* No doubled clock frequency */ /* initialization procedure */ sd_raw_card_type = 0; if(!sd_raw_available()) { SD_DEBUG("SD card not available"); return 0; } /* card needs 74 cycles minimum to start up */ uint16_t i; for(i = 0; i < 10; ++i) { /* wait 8 clock cycles */ sd_raw_rec_byte(); } /* address card */ select_card(); /* reset card */ uint8_t response; for(i = 0; ; ++i) { response = sd_raw_send_command(CMD_GO_IDLE_STATE, 0); if(response == (1 << R1_IDLE_STATE)) break; if(i == 0x1ff) { unselect_card(); SD_DEBUG("Some kind of error."); return 0; } } #if SD_RAW_SDHC /* check for version of SD card specification */ response = sd_raw_send_command(CMD_SEND_IF_COND, 0x100 /* 2.7V - 3.6V */ | 0xaa /* test pattern */); if((response & (1 << R1_ILL_COMMAND)) == 0) { sd_raw_rec_byte(); sd_raw_rec_byte(); if((sd_raw_rec_byte() & 0x01) == 0) { SD_DEBUG("Bad voltage"); return 0; /* card operation voltage range doesn't match */ } if(sd_raw_rec_byte() != 0xaa) { SD_DEBUG("Bad test pattern."); return 0; /* wrong test pattern */ } /* card conforms to SD 2 card specification */ sd_raw_card_type |= (1 << SD_RAW_SPEC_2); } else #endif { /* determine SD/MMC card type */ sd_raw_send_command(CMD_APP, 0); response = sd_raw_send_command(CMD_SD_SEND_OP_COND, 0); if((response & (1 << R1_ILL_COMMAND)) == 0) { /* card conforms to SD 1 card specification */ sd_raw_card_type |= (1 << SD_RAW_SPEC_1); } else { /* MMC card */ } } /* wait for card to get ready */ for(i = 0; ; ++i) { if(sd_raw_card_type & ((1 << SD_RAW_SPEC_1) | (1 << SD_RAW_SPEC_2))) { uint32_t arg = 0; #if SD_RAW_SDHC if(sd_raw_card_type & (1 << SD_RAW_SPEC_2)) arg = 0x40000000; #endif sd_raw_send_command(CMD_APP, 0); response = sd_raw_send_command(CMD_SD_SEND_OP_COND, arg); } else { response = sd_raw_send_command(CMD_SEND_OP_COND, 0); } if((response & (1 << R1_IDLE_STATE)) == 0) break; if(i == 0x7fff) { unselect_card(); SD_DEBUG("Some kind of error."); return 0; } } #if SD_RAW_SDHC if(sd_raw_card_type & (1 << SD_RAW_SPEC_2)) { if(sd_raw_send_command(CMD_READ_OCR, 0)) { unselect_card(); SD_DEBUG("Some kind of error."); return 0; } if(sd_raw_rec_byte() & 0x40) sd_raw_card_type |= (1 << SD_RAW_SPEC_SDHC); sd_raw_rec_byte(); sd_raw_rec_byte(); sd_raw_rec_byte(); } #endif /* set block size to 512 bytes */ if(sd_raw_send_command(CMD_SET_BLOCKLEN, 512)) { unselect_card(); SD_DEBUG("Some kind of error."); return 0; } /* deaddress card */ unselect_card(); /* switch to highest SPI frequency possible */ SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */ SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */ #if !SD_RAW_SAVE_RAM /* the first block is likely to be accessed first, so precache it here */ raw_block_address = (unsigned long) -1; #if SD_RAW_WRITE_BUFFERING raw_block_written = 1; #endif if(!sd_raw_read(0, raw_block, sizeof(raw_block))) { SD_DEBUG("Some kind of error."); return 0; } #endif return 1; }