358 lines
8.7 KiB
C
358 lines
8.7 KiB
C
/*
|
|
io_nmmc.c
|
|
|
|
Hardware Routines for reading an SD or MMC card using
|
|
a Neoflash MK2 or MK3.
|
|
|
|
Written by www.neoflash.com
|
|
|
|
Submit bug reports for this device to the NeoFlash forums
|
|
|
|
This software is completely free. No warranty is provided.
|
|
If you use it, please give me credit and email me about your
|
|
project at chishm@hotmail.com
|
|
|
|
See gba_nds_fat.txt for help and license details.
|
|
|
|
2006-02-09 - www.neoflash.com:
|
|
* First stable release
|
|
|
|
2006-02-13 - Chishm
|
|
* Added ReadMK2Config function
|
|
* Added read config test to init function so no unnecessary card commands are sent
|
|
* Changed data read and write functions to use multiple block commands
|
|
*/
|
|
|
|
#include "io_nmmc.h"
|
|
|
|
#ifdef SUPPORT_NMMC
|
|
|
|
#include <nds/card.h>
|
|
|
|
int spi_freq = 3;
|
|
|
|
#define MK2_CONFIG_ZIP_RAM_CLOSE (1 << 5)
|
|
#define MK2_CONFIG_GAME_FLASH_CLOSE ((1 << 4) | (1 << 0))
|
|
//#define MK2_CONFIG_ZIP_RAM_CLOSE ((1 << 5) | (1 << 1))
|
|
//#define MK2_CONFIG_GAME_FLASH_CLOSE (1 << 4)
|
|
|
|
#define MMC_READ_MULTIPLE_BLOCK 18
|
|
#define MMC_READ_BLOCK 17
|
|
#define MMC_WRITE_MULTIPLE_BLOCK 25
|
|
#define MMC_WRITE_BLOCK 24
|
|
#define MMC_STOP_TRANSMISSION 12
|
|
#define MMC_SET_BLOCKLEN 16
|
|
#define MMC_SET_BLOCK_COUNT 23
|
|
#define MMC_SEND_CSD 9
|
|
|
|
// SPI functions
|
|
|
|
static inline void Neo_OpenSPI( u8 frequency )
|
|
{
|
|
CARD_CR1 = 0x0000A040 | frequency;
|
|
}
|
|
|
|
static inline u8 Neo_SPI( u8 dataByte )
|
|
{
|
|
CARD_EEPDATA = dataByte;
|
|
while (CARD_CR1 & 0x80); // card busy
|
|
return CARD_EEPDATA;
|
|
}
|
|
|
|
static inline void Neo_CloseSPI ( void )
|
|
{
|
|
CARD_CR1 = 0;
|
|
}
|
|
|
|
static inline void Neo_MK2GameMode() {
|
|
Neo_OpenSPI(spi_freq); // Enable DS Card's SPI port
|
|
Neo_SPI(0xF1); // Switch to game mode
|
|
Neo_CloseSPI(); // Disable DS Card's SPI port
|
|
}
|
|
|
|
static inline void Neo_EnableEEPROM( bool enable ) {
|
|
Neo_OpenSPI(spi_freq);
|
|
if(enable) Neo_SPI(0x06);
|
|
else Neo_SPI(0x0E);
|
|
Neo_CloseSPI();
|
|
}
|
|
|
|
void Neo_WriteMK2Config(u8 config) {
|
|
Neo_EnableEEPROM(true);
|
|
Neo_OpenSPI(spi_freq);
|
|
Neo_SPI(0xFA); // Send mem conf write command
|
|
Neo_SPI(0x01); // Send high byte (0x01)
|
|
Neo_SPI(config); // Send low byte
|
|
Neo_CloseSPI();
|
|
Neo_EnableEEPROM(false);
|
|
}
|
|
|
|
u8 Neo_ReadMK2Config(void)
|
|
{
|
|
u8 config;
|
|
Neo_EnableEEPROM(true);
|
|
Neo_OpenSPI(spi_freq);
|
|
Neo_SPI(0xf8); // Send mem conf read command
|
|
Neo_SPI(0x01); // Send high byte
|
|
config = Neo_SPI(0x00); // Get low byte
|
|
Neo_CloseSPI();
|
|
Neo_EnableEEPROM(false);
|
|
return config;
|
|
}
|
|
|
|
// Low level functions
|
|
|
|
u8 selectMMC_command [8] = {0xFF, 0x00, 0x6A, 0xDF, 0x37, 0x59, 0x33, 0xA3};
|
|
|
|
void Neo_SelectMMC (u8 dataByte)
|
|
{
|
|
selectMMC_command[1] = dataByte; // Set enable / disable byte
|
|
cardWriteCommand (selectMMC_command); // Send "5. Use the EEPROM CS to access the MK2 MMC/SD card"
|
|
CARD_CR2 = CARD_ACTIVATE | CARD_nRESET;
|
|
while (CARD_CR2 & CARD_BUSY);
|
|
return;
|
|
}
|
|
|
|
void Neo_EnableMMC( bool enable )
|
|
{
|
|
if ( enable == false) {
|
|
Neo_CloseSPI ();
|
|
Neo_SelectMMC (0);
|
|
Neo_SelectMMC (0);
|
|
} else {
|
|
Neo_SelectMMC (1);
|
|
Neo_SelectMMC (1);
|
|
Neo_OpenSPI (spi_freq);
|
|
}
|
|
return;
|
|
}
|
|
|
|
void Neo_SendMMCCommand( u8 command, u32 argument )
|
|
{
|
|
Neo_SPI (0xFF);
|
|
Neo_SPI (command | 0x40);
|
|
Neo_SPI ((argument >> 24) & 0xff);
|
|
Neo_SPI ((argument >> 16) & 0xff);
|
|
Neo_SPI ((argument >> 8) & 0xff) ;
|
|
Neo_SPI (argument & 0xff);
|
|
Neo_SPI (0x95);
|
|
Neo_SPI (0xFF);
|
|
return;
|
|
}
|
|
|
|
bool Neo_CheckMMCResponse( u8 response, u8 mask ) {
|
|
u32 i;
|
|
for(i=0;i<256;i++) {
|
|
if( ( Neo_SPI( 0xFF ) & mask ) == response )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Neo MMC functions
|
|
|
|
bool Neo_InitMMC() {
|
|
Neo_MK2GameMode();
|
|
Neo_WriteMK2Config( MK2_CONFIG_ZIP_RAM_CLOSE | MK2_CONFIG_GAME_FLASH_CLOSE);
|
|
|
|
// Make sure the configuration was accepted
|
|
if (Neo_ReadMK2Config() != (MK2_CONFIG_ZIP_RAM_CLOSE | MK2_CONFIG_GAME_FLASH_CLOSE)) {
|
|
return false; // If not, then it wasn't initialised properly
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Neo MMC driver functions
|
|
|
|
bool NMMC_IsInserted(void) {
|
|
int i;
|
|
|
|
Neo_EnableMMC( true ); // Open SPI port to MMC card
|
|
Neo_SendMMCCommand(MMC_SEND_CSD, 0);
|
|
if( Neo_CheckMMCResponse( 0x00, 0xFF ) == false ) { // Make sure no errors occured
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
if( Neo_CheckMMCResponse( 0xFE, 0xFF ) == false ) { // Check for Start Block token
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
|
|
// consume data from card, and send clocks.
|
|
for (i = 0; i < 28; i++) {
|
|
Neo_SPI(0xff);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool NMMC_ClearStatus (void) {
|
|
u32 i;
|
|
|
|
Neo_EnableMMC( true ); // Open SPI port to MMC card
|
|
for (i = 0; i < 10; i++) {
|
|
Neo_SPI(0xFF); // Send 10 0xFF bytes to MMC card
|
|
}
|
|
Neo_SendMMCCommand(0, 0); // Send GO_IDLE_STATE command
|
|
if( Neo_CheckMMCResponse( 0x01, 0xFF ) == false ) { // Check that it replied with 0x01 (not idle, no other error)
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
for(i=0;i<256;i++) {
|
|
Neo_SendMMCCommand(1, 0); // Poll with SEND_OP_COND
|
|
if( Neo_CheckMMCResponse( 0x00, 0x01 ) == true ) { // Check for idle state
|
|
Neo_EnableMMC( false ); // Close SPI port to MMC card
|
|
return true; // Card is now idle
|
|
}
|
|
}
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
|
|
bool NMMC_Shutdown(void) {
|
|
return NMMC_ClearStatus();
|
|
}
|
|
|
|
bool NMMC_StartUp(void) {
|
|
int i;
|
|
int transSpeed;
|
|
if (Neo_InitMMC() == false) {
|
|
return false;
|
|
}
|
|
if (NMMC_ClearStatus() == false) {
|
|
return false;
|
|
}
|
|
Neo_EnableMMC( true ); // Open SPI port to MMC card
|
|
|
|
// Set block length
|
|
Neo_SendMMCCommand(MMC_SET_BLOCKLEN, BYTE_PER_READ );
|
|
if( Neo_CheckMMCResponse( 0x00, 0xFF ) == false ) { // Make sure no errors occured
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
|
|
// Check if we can use a higher SPI frequency
|
|
Neo_SendMMCCommand(MMC_SEND_CSD, 0);
|
|
if( Neo_CheckMMCResponse( 0x00, 0xFF ) == false ) { // Make sure no errors occured
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
if( Neo_CheckMMCResponse( 0xFE, 0xFF ) == false ) { // Check for Start Block token
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
for (i = 0; i < 3; i++) {
|
|
Neo_SPI(0xFF);
|
|
}
|
|
transSpeed = Neo_SPI (0xFF);
|
|
for (i = 0; i < 24; i++) {
|
|
Neo_SPI(0xFF);
|
|
}
|
|
if ((transSpeed & 0xf0) >= 0x30) {
|
|
spi_freq = 0;
|
|
}
|
|
|
|
Neo_EnableMMC( false );
|
|
return true;
|
|
}
|
|
|
|
|
|
bool NMMC_WriteSectors (u32 sector, u8 numSecs, void* buffer)
|
|
{
|
|
u32 i;
|
|
u8 *p=buffer;
|
|
|
|
int totalSecs = (numSecs == 0) ? 256 : numSecs;
|
|
sector *= BYTE_PER_READ;
|
|
|
|
Neo_EnableMMC( true ); // Open SPI port to MMC card
|
|
Neo_SendMMCCommand( 25, sector );
|
|
if( Neo_CheckMMCResponse( 0x00, 0xFF ) == false ) { // Make sure no errors occured
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
|
|
while (totalSecs--) {
|
|
Neo_SPI( 0xFC ); // Send Start Block token
|
|
for( i = 0; i < BYTE_PER_READ; i++ ) // Send a block of data
|
|
Neo_SPI( *p++ );
|
|
Neo_SPI( 0xFF ); // Send fake CRC16
|
|
Neo_SPI( 0xFF ); // Send fake CRC16
|
|
|
|
if( ( Neo_SPI( 0xFF ) & 0x0F ) != 0x05 ) { // Make sure the block was accepted
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
while( Neo_SPI( 0xFF ) == 0x00 ); // Wait for the block to be written
|
|
}
|
|
|
|
// Stop transmission block
|
|
Neo_SPI( 0xFD ); // Send Stop Transmission Block token
|
|
for( i = 0; i < BYTE_PER_READ; i++ ) // Send a block of fake data
|
|
Neo_SPI( 0xFF );
|
|
Neo_SPI( 0xFF ); // Send fake CRC16
|
|
Neo_SPI( 0xFF ); // Send fake CRC16
|
|
|
|
Neo_SPI (0xFF); // Send 8 clocks
|
|
while( Neo_SPI( 0xFF ) == 0x00 ); // Wait for the busy signal to clear
|
|
|
|
|
|
for ( i = 0; i < 0x10; i++) {
|
|
Neo_SPI (0xFF); // Send clocks for the MMC card to finish what it's doing
|
|
}
|
|
|
|
Neo_EnableMMC( false ); // Close SPI port to MMC card
|
|
return true;
|
|
}
|
|
|
|
bool NMMC_ReadSectors (u32 sector, u8 numSecs, void* buffer)
|
|
{
|
|
u32 i;
|
|
u8 *p=buffer;
|
|
|
|
int totalSecs = (numSecs == 0) ? 256 : numSecs;
|
|
sector *= BYTE_PER_READ;
|
|
|
|
Neo_EnableMMC( true ); // Open SPI port to MMC card
|
|
|
|
while (totalSecs--) {
|
|
Neo_SendMMCCommand(MMC_READ_BLOCK, sector );
|
|
if( Neo_CheckMMCResponse( 0x00, 0xFF ) == false ) { // Make sure no errors occured
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
|
|
if( Neo_CheckMMCResponse( 0xFE, 0xFF ) == false ) { // Check for Start Block token
|
|
Neo_EnableMMC( false );
|
|
return false;
|
|
}
|
|
for( i = 0; i < BYTE_PER_READ; i++ ) // Read in a block of data
|
|
*p++ = Neo_SPI( 0xFF );
|
|
Neo_SPI( 0xFF ); // Ignore CRC16
|
|
Neo_SPI( 0xFF ); // Ignore CRC16
|
|
sector += BYTE_PER_READ;
|
|
}
|
|
|
|
Neo_EnableMMC( false ); // Close SPI port to MMC card
|
|
return true;
|
|
}
|
|
|
|
|
|
IO_INTERFACE io_nmmc = {
|
|
DEVICE_TYPE_NMMC,
|
|
FEATURE_MEDIUM_CANREAD | FEATURE_MEDIUM_CANWRITE,
|
|
(FN_MEDIUM_STARTUP)&NMMC_StartUp,
|
|
(FN_MEDIUM_ISINSERTED)&NMMC_IsInserted,
|
|
(FN_MEDIUM_READSECTORS)&NMMC_ReadSectors,
|
|
(FN_MEDIUM_WRITESECTORS)&NMMC_WriteSectors,
|
|
(FN_MEDIUM_CLEARSTATUS)&NMMC_ClearStatus,
|
|
(FN_MEDIUM_SHUTDOWN)&NMMC_Shutdown
|
|
} ;
|
|
|
|
|
|
LPIO_INTERFACE NMMC_GetInterface(void) {
|
|
return &io_nmmc ;
|
|
}
|
|
|
|
#endif // #ifdef SUPPORT_NMMC
|