The-Homebrew-Cloud/fceugx
2
0
Fork 0
mirror of https://github.com/dborth/fceugx.git synced 2024-12-04 22:34:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

wiisd support files

Browse Source
This commit is contained in:
dsbomb 2008-04-28 03:26:13 +00:00
parent 1f4f8e07af
commit cf054d59d6
7 changed files with 2529 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
source/drivers/gamecube/wiisd/diskio.c Normal file
View File

@ -0,0 +1,137 @@
/*
* Copyright (C) 2008 svpe, #wiidev at efnet
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <gccore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "sdio.h"
#include "diskio.h"
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;
}
DSTATUS disk_status ( BYTE drv )
{
return RES_OK;
}
DRESULT disk_read (
BYTE drv, /* Physical drive nmuber (0) */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector number (LBA) */
BYTE count /* Sector count (1..255) */
)
{
s32 r = -1;
u32 i;
for(i = 0; i < count; i++)
{
r = sd_read(sector + i, buff + (0x200 * i));
if(r < 0)
return RES_NOTRDY;
}
return RES_OK;
}
DRESULT disk_write (
BYTE drv, /* Physical drive nmuber (0) */
const BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector number (LBA) */
BYTE count /* Sector count (1..255) */
)
{
s32 r = -1;
u32 i;
for(i = 0; i < count; i++)
{
r = sd_write(sector + i, buff + (0x200 * i));
if(r < 0)
return RES_NOTRDY;
}
return RES_OK;
}
DRESULT disk_ioctl (
BYTE drv, /* Physical drive nmuber */
BYTE ctrl, /* Control code */
void *buff /* Buffer to send/receive data block */
)
{
return RES_OK;
}
u32 get_fattime( void )
{
int nday[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
time_t now;
int sec, min, hour, day, month, year;
u32 ret;
time(&now);
sec = now % 60;
now -= sec;
now /= 60;
min = now % 60;
now -= min;
now /= 60;
hour = now % 24;
now -= hour;
day = (int)now / 24;
for(year=1970; day>366; year++){
if((year%4==0 && year%100!=0) || year%400==0)
day -= 366;
else
day -= 365;
}
day++;
if((year%4==0 && year%100!=0) || year%400==0)
nday[1]++;
for(month=0; month<12; month++){
if(day <= nday[month])
break;
day -= nday[month];
}
month++;
ret = ((year-1980)<<25) | (month<<21) | (day<<16) | (hour<<11) |
(min<<5) | (sec>>1);
return ret;
}

63
source/drivers/gamecube/wiisd/diskio.h Normal file
View File

@ -0,0 +1,63 @@
/*-----------------------------------------------------------------------
/ Low level disk interface modlue include file R0.04a (C)ChaN, 2007
/-----------------------------------------------------------------------*/
#ifndef _DISKIO
#define _READONLY 0 /* 1: Read-only mode */
#include "integer.h"
/* Status of Disk Functions */
typedef BYTE DSTATUS;
/* Results of Disk Functions */
typedef enum {
RES_OK = 0, /* 0: Successful */
RES_ERROR, /* 1: R/W Error */
RES_WRPRT, /* 2: Write Protected */
RES_NOTRDY, /* 3: Not Ready */
RES_PARERR /* 4: Invalid Parameter */
} DRESULT;
/*---------------------------------------*/
/* Prototypes for disk control functions */
DSTATUS disk_initialize (BYTE);
DSTATUS disk_status (BYTE);
DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
#if _READONLY == 0
DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
#endif
DRESULT disk_ioctl (BYTE, BYTE, void*);
void disk_timerproc (void);
/* Disk Status Bits (DSTATUS) */
#define STA_NOINIT 0x01 /* Drive not initialized */
#define STA_NODISK 0x02 /* No medium in the drive */
#define STA_PROTECT 0x04 /* Write protected */
/* Command code for disk_ioctrl() */
#define GET_SECTOR_COUNT 1
#define GET_SECTOR_SIZE 2
#define CTRL_SYNC 3
#define CTRL_POWER 4
#define CTRL_LOCK 5
#define CTRL_EJECT 6
#define MMC_GET_CSD 10
#define MMC_GET_CID 11
#define MMC_GET_OCR 12
#define ATA_GET_REV 20
#define ATA_GET_MODEL 21
#define ATA_GET_SN 22
#define _DISKIO
#endif

25
source/drivers/gamecube/wiisd/integer.h Normal file
View File

@ -0,0 +1,25 @@
#ifndef _INTEGER
typedef signed int INT;
typedef unsigned int UINT;
/* These types are assumed as 8-bit integer */
typedef signed char CHAR;
typedef unsigned char UCHAR;
typedef unsigned char BYTE;
/* These types are assumed as 16-bit integer */
typedef signed short SHORT;
typedef unsigned short USHORT;
typedef unsigned short WORD;
/* These types are assumed as 32-bit integer */
typedef signed long LONG;
typedef unsigned long ULONG;
typedef unsigned long DWORD;
/* Boolean type */
//typedef enum { FALSE = 0, TRUE } BOOL;
#define _INTEGER
#endif

294
source/drivers/gamecube/wiisd/sdio.c Normal file
View File

@ -0,0 +1,294 @@
/*
* Copyright (C) 2008 svpe, #wiidev at efnet
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
// pretty much everything here has been reversed from the twilight hack elf loader
// my implementation is *really* bad and will fail fail in random situations.
// it should not be used anywhere else. i recommend waiting for the libogc update.
// you have been warned....
#include <gccore.h>
#include <ogc/ipc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static s32 sd_fd = -1;
static u32 status __attribute__((aligned(32)));
s32 sd_send_cmd(u32 cmd, u32 type, u32 resp, u32 arg, u32 blocks, u32 bsize, u32 addr)
{
static u32 request[9] __attribute__((aligned(32)));
static u32 reply[4] __attribute__((aligned(32)));
u32 r;
memset(request, 0, sizeof(request));
memset(reply, 0, sizeof(reply));
request[0] = cmd;
request[1] = type;
request[2] = resp;
request[3] = arg;
request[4] = blocks;
request[5] = bsize;
request[6] = addr;
request[7] = 0;
request[8] = 0;
r = IOS_Ioctl(sd_fd, 7, (u8 *)request, 36, (u8 *)reply, 0x10);
printf("sd_send_cmd(%x, %x, %x, %x, %x, %x, %x) = %d", cmd, type, resp, arg, blocks, bsize, addr, r);
printf(" -> %x %x %x %x\n", reply[0], reply[1], reply[2], reply[3]); // TODO: add some argument for this reply
return r;
}
s32 sd_reset()
{
s32 r;
r = IOS_Ioctl(sd_fd, 4, 0, 0, (u8 *)&status, 4);
printf("sd_reset(): r = %d; status = %d\n", r, status);
return r;
}
s32 sd_select()
{
s32 r;
r = sd_send_cmd(7, 3, 2, status & 0xFFFF0000, 0, 0, 0);
printf("sd_select(): r = %d\n", r);
return r;
}
s32 sd_deselect()
{
s32 r;
r = sd_send_cmd(7, 3, 2, 0, 0, 0, 0);
printf("sd_deselect(): r = %d\n", r);
return r;
}
s32 sd_set_blocklen(u32 len)
{
s32 r;
r = sd_send_cmd(0x10, 3, 1, len, 0, 0, 0);
printf("sd_set_blocklen(%x) = %d\n", len, r);
return r;
}
u8 sd_get_hcreg()
{
s32 r;
static u32 data __attribute__((aligned(32)));
static u32 query[6] __attribute__((aligned(32)));
memset(&data, 0, 4);
memset(query, 0, 0x18);
query[0] = 0x28;
query[3] = 1;
query[4] = 0;
r = IOS_Ioctl(sd_fd, 2, (u8 *)query, 0x18, (u8 *)&data, 4);
printf("sd_get_hcreg() = %d; r = %d\n", data & 0xFF, r);
return data & 0xFF;
}
s32 sd_set_hcreg(u8 value)
{
s32 r;
static u32 query[6] __attribute__((aligned(32)));
memset(query, 0, 0x18);
query[0] = 0x28;
query[3] = 1;
query[4] = value;
r = IOS_Ioctl(sd_fd, 1, (u8 *)query, 0x18, 0, 0);
printf("sd_set_hcreg(%d) = %d\n", value, r);
return r;
}
s32 sd_set_buswidth(u8 w)
{
s32 r;
u8 reg;
r = sd_send_cmd(0x37, 3, 1, status & 0xFFFF0000, 0, 0, 0);
if(r < 0)
return r;
r = sd_send_cmd(6, 3, 1, (w == 4 ? 2 : 0), 0, 0, 0);
if(r < 0)
return r;
reg = sd_get_hcreg();
reg &= ~2;
if(w == 4)
reg |= 2;
return sd_set_hcreg(reg);
}
s32 sd_clock()
{
s32 r;
static u32 c __attribute__((aligned(32)));
c = 1;
r = IOS_Ioctl(sd_fd, 6, &c, 4, 0, 0);
printf("sd_clock() = %d\n", r);
return r;
}
s32 sd_read(u32 n, u8 *buf)
{
s32 r;
static u8 buffer[0x200] __attribute__((aligned(32)));
static u32 query[9] __attribute__((aligned(32)));
static u32 res[4] __attribute__((aligned(32)));
static ioctlv v[3] __attribute__((aligned(32)));
// printf("sd_read(%d) called\n", n);
memset(buffer, 0xAA, 0x200); // why is this buffer filled with 0xAA? is this really needed?
memset(query, 0, 0x24);
memset(res, 0, 0x10);
query[0] = 0x12;
query[1] = 3;
query[2] = 1;
query[3] = n * 0x200; // arg
query[4] = 1; // block_count
query[5] = 0x200; // sector size
query[6] = (u32)buffer; // buffer
query[7] = 1; // ?
query[8] = 0; // ?
v[0].data = (u32 *)query;
v[0].len = 0x24;
v[1].data =(u32 *)buffer;
v[1].len = 0x200;
v[2].data = (u32 *)res;
v[2].len = 0x10;
// FIXME: is this really needed? twilight hack loader does it.
DCFlushRange(buffer, 0x200);
DCInvalidateRange(buffer, 0x200);
r = IOS_Ioctlv(sd_fd, 7, 2, 1, v);
if(r != 0)
{
printf("sd_read() = %d\n", r);
printf(" %x %x %x %x\n", res[0], res[1], res[2], res[3]);
return r;
}
memcpy(buf, buffer, 0x200);
return 0;
}
s32 sd_write(u32 n, const u8 *buf)
{
s32 r;
static u8 buffer[0x200] __attribute__((aligned(32)));
static u32 query[9] __attribute__((aligned(32)));
static u32 res[4] __attribute__((aligned(32)));
static ioctlv v[3] __attribute__((aligned(32)));
// printf("sd_write(%d) called\n", n);
memcpy(buffer, buf, 0x200);
memset(query, 0, 0x24);
memset(res, 0, 0x10);
query[0] = 0x19;
query[1] = 3;
query[2] = 1;
query[3] = n * 0x200; // arg
query[4] = 1; // block_count
query[5] = 0x200; // sector size
query[6] = (u32)buffer; // buffer
query[7] = 1; // ?
query[8] = 0; // ?
v[0].data = (u32 *)query;
v[0].len = 0x24;
v[1].data =(u32 *)buffer;
v[1].len = 0x200;
v[2].data = (u32 *)res;
v[2].len = 0x10;
r = IOS_Ioctlv(sd_fd, 7, 2, 1, v);
if(r != 0)
{
printf("sd_write() = %d\n", r);
printf(" %x %x %x %x\n", res[0], res[1], res[2], res[3]);
return r;
}
return 0;
}
s32 sd_init()
{
s32 r;
if(sd_fd > 0)
{
printf("sd_init() called more than once. using old sd_fd: %d\n", sd_fd);
return 0;
}
sd_fd = IOS_Open("/dev/sdio/slot0", 0);
printf("sd_fd = %d\n", sd_fd);
if(sd_fd < 0)
return sd_fd;
// TODO: close sd_fd on failure and do proper error check here
r = sd_reset();
if(r < 0)
return r;
sd_select();
r = sd_set_blocklen(0x200);
if(r < 0)
return sd_fd;
r = sd_set_buswidth(4);
if(r < 0)
return sd_fd;
r = sd_clock();
if(r < 0)
return sd_fd;
return 0;
}
s32 sd_deinit()
{
sd_deselect();
return IOS_Close(sd_fd);
}

5
source/drivers/gamecube/wiisd/sdio.h Normal file
View File

@ -0,0 +1,5 @@
extern s32 sd_read(u32 n, u8 *buf);
extern s32 sd_write(u32 n, const u8 *buf);
extern s32 sd_init();
extern s32 sd_deinit();

1706
source/drivers/gamecube/wiisd/tff.c Normal file
View File

File diff suppressed because it is too large Load Diff

299
source/drivers/gamecube/wiisd/tff.h Normal file
View File

@ -0,0 +1,299 @@
/*--------------------------------------------------------------------------/
/ Tiny-FatFs - FAT file system module include file R0.04b (C)ChaN, 2007
/---------------------------------------------------------------------------/
/ FatFs module is an experimenal project to implement FAT file system to
/ cheap microcontrollers. This is a free software and is opened for education,
/ research and development under license policy of following trems.
/
/ Copyright (C) 2007, ChaN, all right reserved.
/
/ * The FatFs module is a free software and there is no warranty.
/ * You can use, modify and/or redistribute it for personal, non-profit or
/ profit use without any restriction under your responsibility.
/ * Redistributions of source code must retain the above copyright notice.
/
/---------------------------------------------------------------------------*/
#ifndef _FATFS
#define _MCU_ENDIAN 2
/* The _MCU_ENDIAN defines which access method is used to the FAT structure.
/ 1: Enable word access.
/ 2: Disable word access and use byte-by-byte access instead.
/ When the architectural byte order of the MCU is big-endian and/or address
/ miss-aligned access is prohibited, the _MCU_ENDIAN must be set to 2.
/ If it is not the case, it can be set to 1 for good code efficiency. */
#define _FS_READONLY 0
/* Setting _FS_READONLY to 1 defines read only configuration. This removes
/ writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename
/ and useless f_getfree. */
#define _FS_MINIMIZE 0
/* The _FS_MINIMIZE option defines minimization level to remove some functions.
/ 0: Full function.
/ 1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod and f_rename are removed.
/ 2: f_opendir and f_readdir are removed in addition to level 1.
/ 3: f_lseek is removed in addition to level 2. */
#define _FAT32 1
/* To enable FAT32 support in addition of FAT12/16, set _FAT32 to 1. */
#define _USE_FSINFO 0
/* To enable FSInfo support on FAT32 volume, set _USE_FSINFO to 1. */
#define _USE_SJIS 0
/* When _USE_SJIS is set to 1, Shift-JIS code transparency is enabled, otherwise
/ only US-ASCII(7bit) code can be accepted as file/directory name. */
#define _USE_NTFLAG 0
/* When _USE_NTFLAG is set to 1, upper/lower case of the file name is preserved.
/ Note that the files are always accessed in case insensitive. */
#include "integer.h"
/* Type definition for cluster number */
#if _FAT32
typedef DWORD CLUST;
#else
typedef WORD CLUST;
#undef _USE_FSINFO
#define _USE_FSINFO 0
#endif
/* File system object structure */
typedef struct _FATFS
{
WORD id; /* File system mount ID */
WORD n_rootdir; /* Number of root directory entries */
DWORD winsect; /* Current sector appearing in the win[] */
DWORD fatbase; /* FAT start sector */
DWORD dirbase; /* Root directory start sector */
DWORD database; /* Data start sector */
CLUST sects_fat; /* Sectors per fat */
CLUST max_clust; /* Maximum cluster# + 1 */
#if !_FS_READONLY
CLUST last_clust; /* Last allocated cluster */
CLUST free_clust; /* Number of free clusters */
#if _USE_FSINFO
DWORD fsi_sector; /* fsinfo sector */
BYTE fsi_flag; /* fsinfo dirty flag (1:must be written back) */
BYTE pad1;
#endif
#endif
BYTE fs_type; /* FAT sub type */
BYTE sects_clust; /* Sectors per cluster */
BYTE n_fats; /* Number of FAT copies */
BYTE winflag; /* win[] dirty flag (1:must be written back) */
BYTE win[512]; /* Disk access window for Directory/FAT/File */
}
FATFS;
/* Directory object structure */
typedef struct _DIRECTORY
{
WORD id; /* Owner file system mount ID */
WORD index; /* Current index */
FATFS* fs; /* Pointer to the owner file system object */
CLUST sclust; /* Start cluster */
CLUST clust; /* Current cluster */
DWORD sect; /* Current sector */
}
DIRECTORY;
/* File object structure */
typedef struct _FIL
{
WORD id; /* Owner file system mount ID */
BYTE flag; /* File status flags */
BYTE sect_clust; /* Left sectors in cluster */
FATFS* fs; /* Pointer to owner file system */
DWORD fptr; /* File R/W pointer */
DWORD fsize; /* File size */
CLUST org_clust; /* File start cluster */
CLUST curr_clust; /* Current cluster */
DWORD curr_sect; /* Current sector */
#if !_FS_READONLY
DWORD dir_sect; /* Sector containing the directory entry */
BYTE* dir_ptr; /* Ponter to the directory entry in the window */
#endif
}
FIL;
/* File status structure */
typedef struct _FILINFO
{
DWORD fsize; /* Size */
WORD fdate; /* Date */
WORD ftime; /* Time */
BYTE fattrib; /* Attribute */
char fname[8+1+3+1]; /* Name (8.3 format) */
}
FILINFO;
/* File function return code (FRESULT) */
typedef enum {
FR_OK = 0, /* 0 */
FR_NOT_READY, /* 1 */
FR_NO_FILE, /* 2 */
FR_NO_PATH, /* 3 */
FR_INVALID_NAME, /* 4 */
FR_INVALID_DRIVE, /* 5 */
FR_DENIED, /* 6 */
FR_EXIST, /* 7 */
FR_RW_ERROR, /* 8 */
FR_WRITE_PROTECTED, /* 9 */
FR_NOT_ENABLED, /* 10 */
FR_NO_FILESYSTEM, /* 11 */
FR_INVALID_OBJECT /* 12 */
} FRESULT;
/*-----------------------------------------------------*/
/* FatFs module application interface */
FRESULT f_mount (BYTE, FATFS*); /* Mount/Unmount a logical drive */
FRESULT f_open (FIL*, const char*, BYTE); /* Open or create a file */
FRESULT f_read (FIL*, BYTE*, WORD, WORD*); /* Read data from a file */
FRESULT f_write (FIL*, const void*, WORD, WORD*); /* Write data to a file */
FRESULT f_lseek (FIL*, DWORD); /* Move file pointer of a file object */
FRESULT f_close (FIL*); /* Close an open file object */
FRESULT f_opendir (DIRECTORY*, const char*); /* Open an existing directory */
FRESULT f_readdir (DIRECTORY*, FILINFO*); /* Read a directory item */
FRESULT f_stat (const char*, FILINFO*); /* Get file status */
FRESULT f_getfree (const char*, DWORD*, FATFS**); /* Get number of free clusters on the drive */
FRESULT f_sync (FIL*); /* Flush cached data of a writing file */
FRESULT f_unlink (const char*); /* Delete an existing file or directory */
FRESULT f_mkdir (const char*); /* Create a new directory */
FRESULT f_chmod (const char*, BYTE, BYTE); /* Change file/dir attriburte */
FRESULT f_rename (const char*, const char*); /* Rename/Move a file or directory */
/* User defined function to give a current time to fatfs module */
DWORD get_fattime (void); /* 31-25: Year(0-127 +1980), 24-21: Month(1-12), 20-16: Day(1-31) */
/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
/* File access control and file status flags (FIL.flag) */
#define FA_READ 0x01
#define FA_OPEN_EXISTING 0x00
#if !_FS_READONLY
#define FA_WRITE 0x02
#define FA_CREATE_NEW 0x04
#define FA_CREATE_ALWAYS 0x08
#define FA_OPEN_ALWAYS 0x10
#define FA__WRITTEN 0x20
#endif
#define FA__ERROR 0x80
/* FAT sub type (FATFS.fs_type) */
#define FS_FAT12 1
#define FS_FAT16 2
#define FS_FAT32 3
/* File attribute bits for directory entry */
#define AM_RDO 0x01 /* Read only */
#define AM_HID 0x02 /* Hidden */
#define AM_SYS 0x04 /* System */
#define AM_VOL 0x08 /* Volume label */
#define AM_LFN 0x0F /* LFN entry */
#define AM_DIR 0x10 /* Directory */
#define AM_ARC 0x20 /* Archive */
/* Offset of FAT structure members */
#define BS_jmpBoot 0
#define BS_OEMName 3
#define BPB_BytsPerSec 11
#define BPB_SecPerClus 13
#define BPB_RsvdSecCnt 14
#define BPB_NumFATs 16
#define BPB_RootEntCnt 17
#define BPB_TotSec16 19
#define BPB_Media 21
#define BPB_FATSz16 22
#define BPB_SecPerTrk 24
#define BPB_NumHeads 26
#define BPB_HiddSec 28
#define BPB_TotSec32 32
#define BS_55AA 510
#define BS_DrvNum 36
#define BS_BootSig 38
#define BS_VolID 39
#define BS_VolLab 43
#define BS_FilSysType 54
#define BPB_FATSz32 36
#define BPB_ExtFlags 40
#define BPB_FSVer 42
#define BPB_RootClus 44
#define BPB_FSInfo 48
#define BPB_BkBootSec 50
#define BS_DrvNum32 64
#define BS_BootSig32 66
#define BS_VolID32 67
#define BS_VolLab32 71
#define BS_FilSysType32 82
#define FSI_LeadSig 0
#define FSI_StrucSig 484
#define FSI_Free_Count 488
#define FSI_Nxt_Free 492
#define MBR_Table 446
#define DIR_Name 0
#define DIR_Attr 11
#define DIR_NTres 12
#define DIR_CrtTime 14
#define DIR_CrtDate 16
#define DIR_FstClusHI 20
#define DIR_WrtTime 22
#define DIR_WrtDate 24
#define DIR_FstClusLO 26
#define DIR_FileSize 28
/* Multi-byte word access macros */
#if _MCU_ENDIAN == 1 /* Use word access */
#define LD_WORD(ptr) (WORD)(*(WORD*)(BYTE*)(ptr))
#define LD_DWORD(ptr) (DWORD)(*(DWORD*)(BYTE*)(ptr))
#define ST_WORD(ptr,val) *(WORD*)(BYTE*)(ptr)=(WORD)(val)
#define ST_DWORD(ptr,val) *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
#else
#if _MCU_ENDIAN == 2 /* Use byte-by-byte access */
#define LD_WORD(ptr) (WORD)(((WORD)*(BYTE*)((ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
#define LD_DWORD(ptr) (DWORD)(((DWORD)*(BYTE*)((ptr)+3)<<24)|((DWORD)*(BYTE*)((ptr)+2)<<16)|((WORD)*(BYTE*)((ptr)+1)<<8)|*(BYTE*)(ptr))
#define ST_WORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)
#define ST_DWORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)
#else
#error Do not forget to set _MCU_ENDIAN properly!
#endif
#endif
#define _FATFS
#endif /* _FATFS */