diff options
| -rw-r--r-- | backends/platform/ds/arm9/makefile | 10 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/blitters.cpp | 76 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/dsmain.cpp | 16 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/fat/gba_nds_fat.c | 4 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/fat/io_m3sd.c | 781 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/fat/io_m3sd.h | 54 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/fat/io_scsd.c | 11 | ||||
| -rw-r--r-- | backends/platform/ds/arm9/source/gbampsave.cpp | 12 |
8 files changed, 415 insertions, 549 deletions
diff --git a/backends/platform/ds/arm9/makefile b/backends/platform/ds/arm9/makefile index c17693b148..fee64198b6 100644 --- a/backends/platform/ds/arm9/makefile +++ b/backends/platform/ds/arm9/makefile @@ -41,6 +41,7 @@ ifdef DS_BUILD_A DISABLE_LURE = 1 DISABLE_CINE = 1 DISABLE_AGI = 1 + DISABLE_TOUCHE = 1 BUILD=scummvm-A endif @@ -61,6 +62,7 @@ ifdef DS_BUILD_B DISABLE_LURE = 1 DISABLE_CINE = 1 DISABLE_AGI = 1 + DISABLE_TOUCHE = 1 BUILD=scummvm-B endif @@ -81,6 +83,7 @@ ifdef DS_BUILD_C DISABLE_LURE = 1 DISABLE_CINE = 1 DISABLE_AGI = 1 + DISABLE_TOUCHE = 1 BUILD=scummvm-C endif @@ -164,13 +167,12 @@ FAT_OBJS := $(portdir)/source/fat/disc_io.o $(portdir)/source/fat/gba_nds_fat.o $(portdir)/source/fat/io_mpcf.o $(portdir)/source/fat/io_sccf.o\ $(portdir)/source/fat/io_m3sd.o\ $(portdir)/source/fat/io_nmmc.o $(portdir)/source/fat/io_scsd.o \ - $(portdir)/source/fat/io_m3sd_asm.o $(portdir)/source/fat/io_scsd_asm.o \ + $(portdir)/source/fat/io_scsd_asm.o \ $(portdir)/source/fat/io_njsd.o \ $(portdir)/source/fat/io_mmcf.o \ $(portdir)/source/fat/io_sd_common.o \ - $(portdir)/source/fat/io_m3_common.o - - + $(portdir)/source/fat/io_m3_common.o \ + $(portdir)/source/fat/m3sd.o # $(portdir)/source/fat/io_cf_common.o $(portdir)/source/fat/io_m3_common.o\ # $(portdir)/source/fat/io_sd_common.o $(portdir)/source/fat/io_scsd_s.o \ diff --git a/backends/platform/ds/arm9/source/blitters.cpp b/backends/platform/ds/arm9/source/blitters.cpp index cba8b6fda8..a2e24623ab 100644 --- a/backends/platform/ds/arm9/source/blitters.cpp +++ b/backends/platform/ds/arm9/source/blitters.cpp @@ -138,52 +138,52 @@ void asmCopy8Col(byte* dst, int dstPitch, const byte* src, int height) { static inline void RescaleBlock_5x1555_To_4x1555( u16 s0, u16 s1, u16 s2, u16 s3, u16 s4, u16* dest) { - u16 rs0 = s0 & 0x1F; - u16 rs1 = s1 & 0x1F; - u16 rs2 = s2 & 0x1F; - u16 rs3 = s3 & 0x1F; - u16 rs4 = s4 & 0x1F; + u32 rs0 = s0 & 0x1F; + u32 rs1 = s1 & 0x1F; + u32 rs2 = s2 & 0x1F; + u32 rs3 = s3 & 0x1F; + u32 rs4 = s4 & 0x1F; - u16 gs0 = (s0 >> 5) & 0x1F; - u16 gs1 = (s1 >> 5) & 0x1F; - u16 gs2 = (s2 >> 5) & 0x1F; - u16 gs3 = (s3 >> 5) & 0x1F; - u16 gs4 = (s4 >> 5) & 0x1F; + u32 gs0 = (s0 >> 5) & 0x1F; + u32 gs1 = (s1 >> 5) & 0x1F; + u32 gs2 = (s2 >> 5) & 0x1F; + u32 gs3 = (s3 >> 5) & 0x1F; + u32 gs4 = (s4 >> 5) & 0x1F; - u16 bs0 = (s0 >> 10) & 0x1F; - u16 bs1 = (s1 >> 10) & 0x1F; - u16 bs2 = (s2 >> 10) & 0x1F; - u16 bs3 = (s3 >> 10) & 0x1F; - u16 bs4 = (s4 >> 10) & 0x1F; + u32 bs0 = (s0 >> 10) & 0x1F; + u32 bs1 = (s1 >> 10) & 0x1F; + u32 bs2 = (s2 >> 10) & 0x1F; + u32 bs3 = (s3 >> 10) & 0x1F; + u32 bs4 = (s4 >> 10) & 0x1F; - u16 rd0 = 4*rs0 + rs1; - u16 rd1 = 3*rs1 + 2*rs2; - u16 rd2 = 2*rs2 + 3*rs3; - u16 rd3 = rs3 + 4*rs4; + u32 rd0 = 4*rs0 + rs1; + u32 rd1 = 3*rs1 + 2*rs2; + u32 rd2 = 2*rs2 + 3*rs3; + u32 rd3 = rs3 + 4*rs4; - u16 gd0 = 4*gs0 + gs1; - u16 gd1 = 3*gs1 + 2*gs2; - u16 gd2 = 2*gs2 + 3*gs3; - u16 gd3 = gs3 + 4*gs4; + u32 gd0 = 4*gs0 + gs1; + u32 gd1 = 3*gs1 + 2*gs2; + u32 gd2 = 2*gs2 + 3*gs3; + u32 gd3 = gs3 + 4*gs4; - u16 bd0 = 4*bs0 + bs1; - u16 bd1 = 3*bs1 + 2*bs2; - u16 bd2 = 2*bs2 + 3*bs3; - u16 bd3 = bs3 + 4*bs4; + u32 bd0 = 4*bs0 + bs1; + u32 bd1 = 3*bs1 + 2*bs2; + u32 bd2 = 2*bs2 + 3*bs3; + u32 bd3 = bs3 + 4*bs4; // Offsetting for correct rounding rd0 = rd0*2+5; rd1 = rd1*2+5; rd2 = rd2*2+5; rd3 = rd3*2+5; gd0 = gd0*2+5; gd1 = gd1*2+5; gd2 = gd2*2+5; gd3 = gd3*2+5; bd0 = bd0*2+5; bd1 = bd1*2+5; bd2 = bd2*2+5; bd3 = bd3*2+5; + + rd0 = (rd0 * 25) >> 8; rd1 = (rd1 * 25) >> 8; rd2 = (rd2 * 25) >> 8; rd3 = (rd3 * 25) >> 8; + gd0 = (gd0 * 25) >> 8; gd1 = (gd1 * 25) >> 8; gd2 = (gd2 * 25) >> 8; gd3 = (gd3 * 25) >> 8; + bd0 = (bd0 * 25) >> 8; bd1 = (bd1 * 25) >> 8; bd2 = (bd2 * 25) >> 8; bd3 = (bd3 * 25) >> 8; - rd0 /= 10; rd1 /= 10; rd2 /= 10; rd3 /= 10; - gd0 /= 10; gd1 /= 10; gd2 /= 10; gd3 /= 10; - bd0 /= 10; bd1 /= 10; bd2 /= 10; bd3 /= 10; - - u16 d0 = 0x8000 | (bd0 << 10) | (gd0 << 5) | rd0; - u16 d1 = 0x8000 | (bd1 << 10) | (gd1 << 5) | rd1; - u16 d2 = 0x8000 | (bd2 << 10) | (gd2 << 5) | rd2; - u16 d3 = 0x8000 | (bd3 << 10) | (gd3 << 5) | rd3; + u32 d0 = 0x8000 | (bd0 << 10) | (gd0 << 5) | rd0; + u32 d1 = 0x8000 | (bd1 << 10) | (gd1 << 5) | rd1; + u32 d2 = 0x8000 | (bd2 << 10) | (gd2 << 5) | rd2; + u32 d3 = 0x8000 | (bd3 << 10) | (gd3 << 5) | rd3; dest[0] = d0; dest[1] = d1; @@ -224,9 +224,13 @@ void Rescale_320x1555Scanline_To_256x1555Scanline(u16* dest, const u16* src) void Rescale_320x256xPAL8_To_256x256x1555(u16* dest, const u8* src, const u16* palette, int destStride, int srcStride) { + u16* fastRam = (u16 *) (0x37F8000 + 16384); + + memcpy(fastRam, palette, 256 * 2); + for(size_t i=0; i<200; ++i) { - Rescale_320xPAL8Scanline_To_256x1555Scanline(dest + i*destStride, src + i *srcStride, palette); + Rescale_320xPAL8Scanline_To_256x1555Scanline(dest + i*destStride, src + i *srcStride, fastRam); } } diff --git a/backends/platform/ds/arm9/source/dsmain.cpp b/backends/platform/ds/arm9/source/dsmain.cpp index d2e8a162d0..63c69fc727 100644 --- a/backends/platform/ds/arm9/source/dsmain.cpp +++ b/backends/platform/ds/arm9/source/dsmain.cpp @@ -32,7 +32,17 @@ // - Remove scummconsole.c // - Delete files -// - Fatlib conversion +// - Fatlib conversion? + +// - libcartreset +// - Alternative controls - tap for left click, double for right +// - Inherit the Earth? +// - New Supercard, M3 drivers? +// - Stereo audio? +// - Delete saves? +// - Software scaler? +// - 100% scale + #include <nds.h> @@ -2045,7 +2055,9 @@ int main(void) initHardware(); #ifdef USE_DEBUGGER - swiWaitForVBlank(); + for (int r = 0; r < 150; r++) { + swiWaitForVBlank(); + } if (!(keysHeld() & KEY_Y)) { initDebugger(); } diff --git a/backends/platform/ds/arm9/source/fat/gba_nds_fat.c b/backends/platform/ds/arm9/source/fat/gba_nds_fat.c index 5a44e2dbd9..21c55cc92b 100644 --- a/backends/platform/ds/arm9/source/fat/gba_nds_fat.c +++ b/backends/platform/ds/arm9/source/fat/gba_nds_fat.c @@ -825,9 +825,9 @@ bool FAT_InitFiles (void) // Make sure it is a valid MBR or boot sector - if ( (globalBuffer[0x1FE] != 0x55) || (globalBuffer[0x1FF] != 0xAA)) { +/* if ( (globalBuffer[0x1FE] != 0x55) || (globalBuffer[0x1FF] != 0xAA)) { return false; - } + }*/ diff --git a/backends/platform/ds/arm9/source/fat/io_m3sd.c b/backends/platform/ds/arm9/source/fat/io_m3sd.c index 26f249279a..fba264a438 100644 --- a/backends/platform/ds/arm9/source/fat/io_m3sd.c +++ b/backends/platform/ds/arm9/source/fat/io_m3sd.c @@ -1,526 +1,381 @@ -/* - io_m3sd.c - - Hardware Routines for reading a Secure Digital card - using the M3 SD - - Some code based on M3 SD drivers supplied by M3Adapter. - Some code written by SaTa may have been unknowingly used. - - Copyright (c) 2006 Michael "Chishm" Chisholm - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation and/or - other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products derived - from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, - EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - 2006-07-25 - Chishm - * Improved startup function that doesn't delay hundreds of seconds - before reporting no card inserted. - * Fixed writeData function to timeout on error - * writeSectors function now wait until the card is ready before continuing with a transfer - - 2006-08-05 - Chishm - * Tries multiple times to get a Relative Card Address at startup - - 2006-08-07 - Chishm - * Moved the SD initialization to a common function -*/ +#define io_M3SD_c #include "io_m3sd.h" -#include "io_sd_common.h" -#include "io_m3_common.h" -//#include "common.h" -#include "disc_io.h" -#include <stdio.h> - -#define BYTES_PER_READ 512 - -//--------------------------------------------------------------- -// M3SD register addresses - -#define REG_M3SD_DIR (*(vu16*)0x08800000) // direction control register -#define REG_M3SD_DAT (*(vu16*)0x09000000) // SD data line, 8 bits at a time -#define REG_M3SD_CMD (*(vu16*)0x09200000) // SD command byte -#define REG_M3SD_ARGH (*(vu16*)0x09400000) // SD command argument, high halfword -#define REG_M3SD_ARGL (*(vu16*)0x09600000) // SD command argument, low halfword -#define REG_M3SD_STS (*(vu16*)0x09800000) // command and status register - -//--------------------------------------------------------------- -// Send / receive timeouts, to stop infinite wait loops -#define NUM_STARTUP_CLOCKS 100 // Number of empty (0xFF when sending) bytes to send/receive to/from the card -#define TRANSMIT_TIMEOUT 20000 // Time to wait for the M3 to respond to transmit or receive requests -#define RESPONSE_TIMEOUT 256 // Number of clocks sent to the SD card before giving up -#define WRITE_TIMEOUT 3000 // Time to wait for the card to finish writing - -//--------------------------------------------------------------- -// Variables required for tracking SD state -static u32 _M3SD_relativeCardAddress = 0; // Preshifted Relative Card Address - -//--------------------------------------------------------------- -// Internal M3 SD functions - -static inline void _M3SD_unlock (void) { - _M3_changeMode (M3_MODE_MEDIA); -} -static inline bool _M3SD_waitOnBusy (void) { - int i = 0; - while ( (REG_M3SD_STS & 0x01) == 0x00) { - i++; - if (i >= TRANSMIT_TIMEOUT) { - return false; - } - } - return true; -} +//M3-SD interface SD card. -static inline bool _M3SD_waitForDataReady (void) { - int i = 0; - while ( (REG_M3SD_STS & 0x40) == 0x00) { - i++; - if (i >= TRANSMIT_TIMEOUT) { - return false; - } - } - return true; -} +#define DMA3SAD *(volatile u32*)0x040000D4 +#define DMA3DAD *(volatile u32*)0x040000D8 +#define DMA3CNT *(volatile u32*)0x040000DC +#define DMA3CR *(volatile u16*)0x040000DE +//SD dir control bit cmddir=bit0 clken=bit1 +//output +#define SDDIR (*(volatile u16*)0x8800000) -static bool _M3SD_sendCommand (u16 command, u32 argument) { - REG_M3SD_STS = 0x8; - REG_M3SD_CMD = 0x40 + command; // Include the start bit - REG_M3SD_ARGH = argument >> 16; - REG_M3SD_ARGL = argument; - // The CRC7 of the command is calculated by the M3 - - REG_M3SD_DIR=0x29; - if (!_M3SD_waitOnBusy()) { - REG_M3SD_DIR=0x09; - return false; - } - REG_M3SD_DIR=0x09; - return true; -} +//SD send get control bit send=bit0 get=bit1 +//output +#define SDCON (*(volatile u16*)0x9800000) -static bool _M3SD_sendByte (u8 byte) { - int i = 0; - REG_M3SD_DAT = byte; - REG_M3SD_DIR = 0x03; - REG_M3SD_STS = 0x01; - while ((REG_M3SD_STS & 0x04) == 0) { - i++; - if (i >= TRANSMIT_TIMEOUT) { - return false; - } - } - return true; -} +//SD output data obyte[7:0]=AD[7:0] +//output +#define SDODA (*(volatile u16*)0x9000000) -static u8 _M3SD_getByte (void) { - int i; - // Request 8 bits of data from the SD's CMD pin - REG_M3SD_DIR = 0x02; - REG_M3SD_STS = 0x02; - // Wait for the data to be ready - i = 0; - while ((REG_M3SD_STS & 0x08) == 0) { - i++; - if (i >= TRANSMIT_TIMEOUT) { - // Return an empty byte if a timeout occurs - return 0xFF; - } - } - i = 0; - while ((REG_M3SD_STS & 0x08) != 0) { - i++; - if (i >= TRANSMIT_TIMEOUT) { - // Return an empty byte if a timeout occurs - return 0xFF; - } - } - // Return the data - return (REG_M3SD_DAT & 0xff); -} +//SD input data AD[7:0]=ibyte[7:0] +//input +#define SDIDA (*(volatile u16*)0x9000000) -// Returns the response from the SD card to a previous command. -static bool _M3SD_getResponse (u8* dest, u32 length) { - u32 i; - u8 dataByte; - int shiftAmount; - - // Wait for the card to be non-busy - for (i = 0; i < RESPONSE_TIMEOUT; i++) { - dataByte = _M3SD_getByte(); - if (dataByte != SD_CARD_BUSY) { - break; - } - } - - if (dest == NULL) { - return true; - } - - // Still busy after the timeout has passed - if (dataByte == 0xff) { - return false; - } - - // Read response into buffer - for ( i = 0; i < length; i++) { - dest[i] = dataByte; - dataByte = _M3SD_getByte(); - } - // dataByte will contain the last piece of the response - - // Send 16 more clocks, 8 more than the delay required between a response and the next command - i = _M3SD_getByte(); - i = _M3SD_getByte(); - - // Shift response so that the bytes are correctly aligned - // The register may not contain properly aligned data - for (shiftAmount = 0; ((dest[0] << shiftAmount) & 0x80) != 0x00; shiftAmount++) { - if (shiftAmount >= 7) { - return false; - } - } - - for (i = 0; i < length - 1; i++) { - dest[i] = (dest[i] << shiftAmount) | (dest[i+1] >> (8-shiftAmount)); - } - // Get the last piece of the response from dataByte - dest[i] = (dest[i] << shiftAmount) | (dataByte >> (8-shiftAmount)); +//readsector data1 +#define SDIDA1 (*(volatile u16*)0x9200000) - return true; -} +//readsector data2 +#define SDIDA2 (*(volatile u16*)0x9400000) +//readsector data3 +#define SDIDA3 (*(volatile u16*)0x9600000) -static inline bool _M3SD_getResponse_R1 (u8* dest) { - return _M3SD_getResponse (dest, 6); -} +//SD stutas cmdneg=bit0 cmdpos=bit1 issend=bit2 isget=bit3 +//input +#define SDSTA (*(volatile u16*)0x9800000) -static inline bool _M3SD_getResponse_R1b (u8* dest) { - return _M3SD_getResponse (dest, 6); -} +#define M3_REG_STS *(vu16*)(0x09800000) // Status of the CF Card / Device control +#define M3_DATA (vu16*)(0x08800000) // Pointer to buffer of CF data transered from card -static inline bool _M3SD_getResponse_R2 (u8* dest) { - return _M3SD_getResponse (dest, 17); -} +// CF Card status +#define CF_STS_INSERTED1 0x20 +#define CF_STS_INSERTED2 0x30 +#define CF_STS_INSERTED3 0x22 +#define CF_STS_INSERTED4 0x32 +#define isM3ins(sta) ((sta==CF_STS_INSERTED1) || (sta==CF_STS_INSERTED2) || (sta==CF_STS_INSERTED3) || (sta==CF_STS_INSERTED4)) -static inline bool _M3SD_getResponse_R3 (u8* dest) { - return _M3SD_getResponse (dest, 6); -} -static inline bool _M3SD_getResponse_R6 (u8* dest) { - return _M3SD_getResponse (dest, 6); -} +#define CARD_TIMEOUT 400000 // Updated due to suggestion from SaTa, otherwise card will timeout sometimes on a write +//#define CARD_TIMEOUT (500*100) // M3SD timeout nomal:500 -static void _M3SD_sendClocks (u32 numClocks) { - while (numClocks--) { - _M3SD_sendByte(0xff); - } -} +void SendCommand(u16 command, u32 sectorn); +void PassRespond(u32 num); +void SD_crc16(u16* buff,u16 num,u16* crc16buff); +void SD_data_write(u16 *buff,u16* crc16buff); +u16 M3_SetChipReg(u32 Data); -static void _M3SD_getClocks (u32 numClocks) { - while (numClocks--) { - _M3SD_getByte(); - } -} +//========================================================= +u16 M3_SetChipReg(u32 Data) +{ + u16 i,j; -bool _M3SD_cmd_6byte_response (u8* responseBuffer, u8 command, u32 data) { - _M3SD_sendCommand (command, data); - return _M3SD_getResponse (responseBuffer, 6); -} + i = *(volatile u16*)(0x700001*2+0x8000000); -bool _M3SD_cmd_17byte_response (u8* responseBuffer, u8 command, u32 data) { - _M3SD_sendCommand (command, data); - return _M3SD_getResponse (responseBuffer, 17); -} + i = *(volatile u16*)(0x000007*2+0x8000000); + i = *(volatile u16*)(0x400ffe*2+0x8000000); + i = *(volatile u16*)(0x000825*2+0x8000000); -static bool _M3SD_initCard (void) { - // Give the card time to stabilise - _M3SD_sendClocks (NUM_STARTUP_CLOCKS); - - // Reset the card - if (!_M3SD_sendCommand (GO_IDLE_STATE, 0)) { - return false; - } + i = *(volatile u16*)(0x400309*2+0x8000000); + i = *(volatile u16*)(0x000000*2+0x8000000); + i = *(volatile u16*)(0x400db3*2+0x8000000); - _M3SD_getClocks (NUM_STARTUP_CLOCKS); + i = *(volatile u16*)((Data*2)+0x8000000); - // Card is now reset, including it's address - _M3SD_relativeCardAddress = 0; - - // Init the card - return _SD_InitCard (_M3SD_cmd_6byte_response, - _M3SD_cmd_17byte_response, - true, - &_M3SD_relativeCardAddress); + j = *(volatile u16*)(0x000407*2+0x8000000); + i = *(volatile u16*)(0x000000*2+0x8000000); + + return j; } -static bool _M3SD_readData (void* buffer) { - u32 i; - u8* buff_u8 = (u8*)buffer; - u16* buff = (u16*)buffer; - u16 temp; +void M3_SelectSaver(u8 Bank) +{ + u16 i; + + i = *(volatile u16*)(0x700001*2+0x8000000); + + i = *(volatile u16*)(0x000007*2+0x8000000); + i = *(volatile u16*)(0x400FFE*2+0x8000000); + i = *(volatile u16*)(0x000825*2+0x8000000); - REG_M3SD_DIR = 0x49; - if (!_M3SD_waitForDataReady()) { - REG_M3SD_DIR = 0x09; - return false; + i = *(volatile u16*)(0x400309*2+0x8000000); + i = *(volatile u16*)(0x000000*2+0x8000000); + i = *(volatile u16*)(0x400db3*2+0x8000000); + + i = *(volatile u16*)((Bank<<4)*2+0x8000000); + + i = *(volatile u16*)(0x000407*2+0x8000000); + i = *(volatile u16*)(0x000000*2+0x8000000); +} + +void DMA3(u32 src, u32 dst, u32 cnt) +{ + u16 i,j,cnttmp; + + cnttmp = (cnt&0xffff); + if( ((dst&0x03) == 0) + &&((cnttmp&0x0f) == 0) + &&(cnttmp>0)) + { + DC_FlushRange(dst,cnttmp*2); + DMA3CR &= (~0x3a00); + DMA3CR &= (~0x8000); + i = DMA3CR; + j = DMA3CR; + + DMA3SAD=src; + DMA3DAD=dst; + DMA3CNT=cnt; } - REG_M3SD_DIR = 0x09; - - REG_M3SD_DIR = 0x8; - REG_M3SD_STS = 0x4; - - i = REG_M3SD_DIR; - // Read data - i=256; - if ((u32)buff_u8 & 0x01) { - while(i--) + else + { + for(j=0;j<cnttmp;j++) { - temp = REG_M3SD_DIR; - *buff_u8++ = temp & 0xFF; - *buff_u8++ = temp >> 8; + *(u16*)(dst+j*2) = *(u16*)(src+j*2); } - } else { - while(i--) - *buff++ = REG_M3SD_DIR; } - // Read end checksum - i = REG_M3SD_DIR + REG_M3SD_DIR + REG_M3SD_DIR + REG_M3SD_DIR; - - return true; } -static void _M3SD_clkout (void) { - REG_M3SD_DIR = 0x4; - REG_M3SD_DIR = 0xc; -/* __asm volatile ( - "ldr r1, =0x08800000 \n" - "mov r0, #0x04 \n" - "strh r0, [r1] \n" - "mov r0, r0 \n" - "mov r0, r0 \n" - "mov r0, #0x0c \n" - "strh r0, [r1] \n" - : // Outputs - : // Inputs - : "r0", "r1" // Clobber list - );*/ -} +void SendCommand(u16 command, u32 sectorn) +{ + SDCON=0x8; + SDIDA1=0x40+command; + SDIDA2=(sectorn>>7); + SDIDA3=(sectorn<<9); -static void _M3SD_clkin (void) { - REG_M3SD_DIR = 0x0; - REG_M3SD_DIR = 0x8; -/* __asm volatile ( - "ldr r1, =0x08800000 \n" - "mov r0, #0x00 \n" - "strh r0, [r1] \n" - "mov r0, r0 \n" - "mov r0, r0 \n" - "mov r0, #0x08 \n" - "strh r0, [r1] \n" - : // Outputs - : // Inputs - : "r0", "r1" // Clobber list - );*/ + SDDIR=0x29; + while ((SDSTA&0x01) != 0x01); + SDDIR=0x09; } -static bool _M3SD_writeData (u8* data, u8* crc) { - int i; - u8 temp; +void PassRespond(u32 num) +{ + u32 i,j,dmanum; - do { - _M3SD_clkin(); - } while ((REG_M3SD_DAT & 0x100) == 0); - - REG_M3SD_DAT = 0; // Start bit - - _M3SD_clkout(); - - for (i = 0; i < BYTES_PER_READ; i++) { - temp = (*data++); - REG_M3SD_DAT = temp >> 4; - _M3SD_clkout(); - REG_M3SD_DAT = temp; - _M3SD_clkout(); - } - - if (crc != NULL) { - for (i = 0; i < 8; i++) { - temp = (*crc++); - REG_M3SD_DAT = temp >> 4; - _M3SD_clkout(); - REG_M3SD_DAT = temp; - _M3SD_clkout(); - } - } + dmanum=(64+(num<<3))>>2; + SDDIR=0x8; + SDCON=0x4; - i = 32; - while (i--) { - temp += 2; // a NOP to stop the compiler optimising out the loop - } - - for (i = 0; i < 32; i++) { - REG_M3SD_DAT = 0xff; - _M3SD_clkout(); + for(j=0;j<dmanum;j++) + { + i = SDDIR; } - - do { - _M3SD_clkin(); - } while ((REG_M3SD_DAT & 0x100) == 0); - - return true; } -//--------------------------------------------------------------- -// Functions needed for the external interface +//read multi sectors function +void readsectors(u16 * p,u32 sectorn,u16 number) +{ + u32 i,j; + + SendCommand(18,sectorn); + for(i=0;i<number;i++,p+=0x100) + { + SDDIR=0x49; + while ( (SDSTA&0x40) !=0x40); + SDDIR=0x09; + + SDDIR=0x8; + SDCON=0x4; + j = *(volatile u16*)0x8800000; + DMA3(0x8800000,(u32)p,0x80000100); + j = *(volatile u16*)0x8800000; + j = *(volatile u16*)0x8800000; + j = *(volatile u16*)0x8800000; + j = *(volatile u16*)0x8800000; + + SDCON=0x8; + } -bool _M3SD_startUp (void) { - _M3SD_unlock(); - return _M3SD_initCard(); + SendCommand(12,sectorn); + PassRespond(6); } -bool _M3SD_isInserted (void) { - u8 responseBuffer [6]; - // Make sure the card receives the command - if (!_M3SD_sendCommand (SEND_STATUS, 0)) { - return false; - } - // Make sure the card responds - if (!_M3SD_getResponse_R1 (responseBuffer)) { - return false; - } - // Make sure the card responded correctly - if (responseBuffer[0] != SEND_STATUS) { - return false; - } - return true; -} +//write one sector function +void M3SD_writesector(u16 * p,u32 sectorn) +{ + u16 crc[4]; + u16* check = (u16 *) malloc(512); + u16* data = (u16 *) malloc(512); + memcpy(data, p, 512); -bool _M3SD_readSectors (u32 sector, u32 numSectors, void* buffer) { - u32 i; - u8* dest = (u8*) buffer; - u8 responseBuffer[6]; - - if (numSectors == 1) { - // If it's only reading one sector, use the (slightly faster) READ_SINGLE_BLOCK - if (!_M3SD_sendCommand (READ_SINGLE_BLOCK, sector * BYTES_PER_READ)) { - return false; - } + int verify = 0; + int tries = 0; + do { + SendCommand(24,sectorn); + PassRespond(6); - if (!_M3SD_readData (buffer)) { - return false; - } + SDDIR=0x4; + SDCON=0x0; - } else { - // Stream the required number of sectors from the card - if (!_M3SD_sendCommand (READ_MULTIPLE_BLOCK, sector * BYTES_PER_READ)) { - return false; - } - - for(i=0; i < numSectors; i++, dest+=BYTES_PER_READ) { - if (!_M3SD_readData(dest)) { - return false; + SD_crc16(data,512,crc); + SD_data_write(data,crc); + + readsectors(check, sectorn, 1); + + int r; + verify = 0; + for (r = 0; r < 256; r++) { + if (check[r] != data[r]) { + verify++; } - REG_M3SD_STS = 0x8; } + + if (verify > 0) { + tries++; + } + + } while ((verify > 0) && (tries < 16)); - // Stop the streaming - _M3SD_sendCommand (STOP_TRANSMISSION, 0); - _M3SD_getResponse_R1b (responseBuffer); + free(data); + free(check); +} // */ + +/*----------------------------------------------------------------- +M3SD_IsInserted +Is a compact flash card inserted? +bool return OUT: true if a CF card is inserted +-----------------------------------------------------------------*/ +bool M3SD_IsInserted (void) +{ + u16 sta; + bool i; + + M3_SetChipReg(0x400003); + M3_REG_STS = CF_STS_INSERTED1; + sta=M3_REG_STS; + i = ( isM3ins(sta) ); + + M3_SetChipReg(0x400002); + return i; +} + +/*----------------------------------------------------------------- +M3SD_ClearStatus +Tries to make the CF card go back to idle mode +bool return OUT: true if a CF card is idle +-----------------------------------------------------------------*/ +bool M3SD_ClearStatus (void) +{ + int i; + u16 sta; + + M3_SetChipReg(0x400003); + i = 0; + M3_REG_STS = CF_STS_INSERTED1; + while (i < CARD_TIMEOUT) + { + sta=M3_REG_STS; + if( isM3ins(sta) )break; + i++; } + M3_SetChipReg(0x400002); + if (i >= CARD_TIMEOUT) return false; + return true; } -bool _M3SD_writeSectors (u32 sector, u32 numSectors, const void* buffer) { - u8 crc[8]; - u8 responseBuffer[6]; - u32 offset = sector * BYTES_PER_READ; - u8* data = (u8*) buffer; +/*----------------------------------------------------------------- +M3SD_ReadSectors +Read 512 byte sector numbered "sector" into "buffer" +u32 sector IN: address of first 512 byte sector on CF card to read +u8 numSecs IN: number of 512 byte sectors to read, + 1 to 256 sectors can be read, 0 = 256 +void* buffer OUT: pointer to 512 byte buffer to store data in +bool return OUT: true if successful +-----------------------------------------------------------------*/ +bool M3SD_ReadSectors(u32 sector, u8 numSecs, void* buffer) +{ + //read multi sectors function + M3_SetChipReg(0x400003); + readsectors((u16*)buffer,sector,numSecs); + M3_SetChipReg(0x400002); + return true; // */ +} +/*----------------------------------------------------------------- +M3SD_WriteSectors +Write 512 byte sector numbered "sector" from "buffer" +u32 sector IN: address of 512 byte sector on CF card to read +u8 numSecs IN: number of 512 byte sectors to read, + 1 to 256 sectors can be read, 0 = 256 +void* buffer IN: pointer to 512 byte buffer to read data from +bool return OUT: true if successful +-----------------------------------------------------------------*/ +bool M3SD_WriteSectors (u32 sector, u8 numSecs, void* buffer) +{ + bool r=true; int i; - // Precalculate the data CRC - _SD_CRC16 ( data, BYTES_PER_READ, crc); - - while (numSectors--) { - // Send a single sector write command - _M3SD_sendCommand (WRITE_BLOCK, offset); - if (!_M3SD_getResponse_R1 (responseBuffer)) { - return false; - } - - REG_M3SD_DIR = 0x4; - REG_M3SD_STS = 0x0; - - // Send the data - if (! _M3SD_writeData( data, crc)) { - return false; - } - - if (numSectors > 0) { - offset += BYTES_PER_READ; - data += BYTES_PER_READ; - // Calculate the next CRC while waiting for the card to finish writing - _SD_CRC16 ( data, BYTES_PER_READ, crc); - } - - // Wait for the card to be ready for the next transfer - i = WRITE_TIMEOUT; - responseBuffer[3] = 0; - do { - _M3SD_sendCommand (SEND_STATUS, _M3SD_relativeCardAddress); - _M3SD_getResponse_R1 (responseBuffer); - i--; - if (i <= 0) { - return false; - } - } while (((responseBuffer[3] & 0x1f) != ((SD_STATE_TRAN << 1) | READY_FOR_DATA))); + M3_SetChipReg(0x400003); + for(i=0;i<numSecs;i++) + { + M3SD_writesector((u16*)((u32)buffer+512*i),sector+i); } - - return true; - + M3_SetChipReg(0x400002); + return r; } -bool _M3SD_clearStatus (void) { - return _M3SD_initCard (); +/*----------------------------------------------------------------- +M3_Unlock +Returns true if M3 was unlocked, false if failed +Added by MightyMax +-----------------------------------------------------------------*/ +bool M3SD_Unlock(void) +{ + vu16 sta; + bool i; + + // run unlock sequence + volatile unsigned short tmp; + + M3_SetChipReg(0x400003); + tmp = *(volatile unsigned short *)0x08000000 ; + tmp = *(volatile unsigned short *)0x08E00002 ; + tmp = *(volatile unsigned short *)0x0800000E ; + tmp = *(volatile unsigned short *)0x08801FFC ; + tmp = *(volatile unsigned short *)0x0800104A ; + tmp = *(volatile unsigned short *)0x08800612 ; + tmp = *(volatile unsigned short *)0x08000000 ; + tmp = *(volatile unsigned short *)0x08801B66 ; + tmp = *(volatile unsigned short *)0x08800006 ; + tmp = *(volatile unsigned short *)0x08000000 ; + + // test that we have register access + sta=M3_REG_STS; + sta=M3_REG_STS; + if( isM3ins(sta) ) + { + i = true; + } + else + { + i = false; + } + + M3_SetChipReg(0x400002); + return i; } -bool _M3SD_shutdown (void) { - _M3_changeMode (M3_MODE_ROM); - return true; +bool M3SD_Shutdown(void) +{ + return M3SD_ClearStatus() ; } -IO_INTERFACE _io_m3sd = { - DEVICE_TYPE_M3SD, - FEATURE_MEDIUM_CANREAD | FEATURE_MEDIUM_CANWRITE | FEATURE_SLOT_GBA, - (FN_MEDIUM_STARTUP)&_M3SD_startUp, - (FN_MEDIUM_ISINSERTED)&_M3SD_isInserted, - (FN_MEDIUM_READSECTORS)&_M3SD_readSectors, - (FN_MEDIUM_WRITESECTORS)&_M3SD_writeSectors, - (FN_MEDIUM_CLEARSTATUS)&_M3SD_clearStatus, - (FN_MEDIUM_SHUTDOWN)&_M3SD_shutdown -} ; - -LPIO_INTERFACE M3SD_GetInterface(void) { - return &_io_m3sd ; -} ; +bool M3SD_StartUp(void) +{ + vu16* waitCr = (vu16*)0x4000204; + + *waitCr |= 0x6000; +// *(vu16*)0x4000204=0x6000; + // Try unlocking 3 times, because occationally it fails to detect the reader. + return M3SD_Unlock() | M3SD_Unlock() | M3SD_Unlock(); +} +IO_INTERFACE io_m3sd = +{ + 0x4453334D, // 'M3SD' + FEATURE_MEDIUM_CANREAD | FEATURE_MEDIUM_CANWRITE, + (FN_MEDIUM_STARTUP)&M3SD_StartUp, + (FN_MEDIUM_ISINSERTED)&M3SD_IsInserted, + (FN_MEDIUM_READSECTORS)&M3SD_ReadSectors, + (FN_MEDIUM_WRITESECTORS)&M3SD_WriteSectors, + (FN_MEDIUM_CLEARSTATUS)&M3SD_ClearStatus, + (FN_MEDIUM_SHUTDOWN)&M3SD_Shutdown +}; + +LPIO_INTERFACE M3SD_GetInterface(void) +{ + return &io_m3sd ; +} diff --git a/backends/platform/ds/arm9/source/fat/io_m3sd.h b/backends/platform/ds/arm9/source/fat/io_m3sd.h index 34d8cdbdeb..0723a2f468 100644 --- a/backends/platform/ds/arm9/source/fat/io_m3sd.h +++ b/backends/platform/ds/arm9/source/fat/io_m3sd.h @@ -1,49 +1,25 @@ /* - io_m3sd.h - - Hardware Routines for reading a Secure Digital card - using the M3 SD - - Some code based on M3 SD drivers supplied by M3Adapter. - Some code written by SaTa may have been unknowingly used. - - Copyright (c) 2006 Michael "Chishm" Chisholm - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation and/or - other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products derived - from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, - EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - 2006-07-11 - Chishm - * Original release + io_m3sd.h by SaTa. + + Hardware Routines for reading a compact flash card + using the GBA Movie Player + + 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. */ #ifndef IO_M3SD_H #define IO_M3SD_H -// 'M3SD' -#define DEVICE_TYPE_M3SD 0x4453334D - #include "disc_io.h" +u16 M3_SetChipReg(u32 Data); +void M3_SelectSaver(u8 Bank); + // export interface -//extern const IO_INTERFACE _io_m3sd ; -LPIO_INTERFACE M3SD_GetInterface(void); +extern LPIO_INTERFACE M3SD_GetInterface(void) ; -#endif // define IO_M3SD_H +#endif diff --git a/backends/platform/ds/arm9/source/fat/io_scsd.c b/backends/platform/ds/arm9/source/fat/io_scsd.c index b7449bb828..9904a0ac28 100644 --- a/backends/platform/ds/arm9/source/fat/io_scsd.c +++ b/backends/platform/ds/arm9/source/fat/io_scsd.c @@ -71,7 +71,16 @@ bool SCSD_ReadSectors (u32 sector, u8 ReadNumber, void* buff) bool SCSD_WriteSectors (u32 sector, u8 writeNumber, void* buff) { - WriteSector((u16 *)buff,sector,writeNumber); + u16* alignedBuffer = (u16 *) malloc(512); + int r; + + for (r = 0; r < writeNumber; r++) + { + memcpy(alignedBuffer, buff, 512); + WriteSector(((u16 *)(buff)) + (r * 256), sector + r, 1); + } + + free(alignedBuffer); return true; } diff --git a/backends/platform/ds/arm9/source/gbampsave.cpp b/backends/platform/ds/arm9/source/gbampsave.cpp index d2dfc910f4..8fb5d99f16 100644 --- a/backends/platform/ds/arm9/source/gbampsave.cpp +++ b/backends/platform/ds/arm9/source/gbampsave.cpp @@ -55,7 +55,7 @@ void GBAMPSaveFile::skip(uint32 bytes) { void GBAMPSaveFile::flushSaveBuffer() { if (bufferPos != 0) { -// consolePrintf("Flushing %d bytes\n", bufferPos); + consolePrintf("Flushing %d bytes from %x\n", bufferPos, buffer); flushed += bufferPos; DS::std_fwrite(buffer, 1, bufferPos, handle); bufferPos = 0; @@ -83,7 +83,15 @@ uint32 GBAMPSaveFile::write(const void *buf, uint32 size) { if (bufferPos + size > SAVE_BUFFER_SIZE) { flushSaveBuffer(); saveSize += size; - DS::std_fwrite(buf, 1, size, handle); +// consolePrintf("Writing %d bytes from %x", size, buf); +// DS::std_fwrite(buf, 1, size, handle); + + memcpy(buffer + bufferPos, buf, size); + bufferPos += size; + + saveSize += size; + + /* int pos = 0; int rest = SAVE_BUFFER_SIZE - bufferPos; |