int main(void)
{
u32 queuehandle;
s32 ret;
/* Avoid GCC optimizations */
exe_mem[0] = 0;
/* Print info */
write("$IOSVersion: MLOAD: " __DATE__ " " __TIME__ " 64M$\n");
/* Initialize module */
ret = __MLoad_Initialize(&queuehandle);
if (ret < 0)
return ret;
// Debug_SetMode(2);
/* Initialize stuff */
Epic_Init(queuehandle);
/* Main loop */
while (1) {
ipcmessage *message = NULL;
/* Wait for message */
os_message_queue_receive(queuehandle, (void *)&message, 0);
/* Epic stuff */
if ((u32)message == EPIC_MESSAGE) {
Epic_Main();
continue;
}
switch (message->command) {
case IOS_OPEN: {
u64 tid;
/* Get title ID */
ret = ES_GetTitleID(&tid);
/* Check title ID */
if (ret >= 0) {
write("MLOAD: Title identified. Blocking opening request.\n");
ret = IPC_ENOENT;
break;
}
/* Check device path */
if (!strcmp(message->open.device, DEVICE_NAME))
ret = message->open.resultfd;
else
ret = IPC_ENOENT;
break;
}
case IOS_CLOSE: {
/* Do nothing */
break;
}
case IOS_READ: {
void *dst = message->read.data;
void *src = (void *)offset;
u32 len = message->read.length;
/* Read data */
Swi_uMemcpy(dst, src, len);
/* Update offset */
offset += len;
}
case IOS_WRITE: {
void *dst = (void *)offset;
void *src = message->write.data;
u32 len = message->write.length;
/* Write data */
Swi_Memcpy(dst, src, len);
/* Update offset */
offset += len;
}
case IOS_SEEK: {
s32 whence = message->seek.origin;
s32 where = message->seek.offset;
/* Update offset */
switch (whence) {
case SEEK_SET:
offset = where;
break;
case SEEK_CUR:
offset += where;
break;
case SEEK_END:
offset = -where;
break;
}
/* Return offset */
ret = offset;
break;
}
case IOS_IOCTLV: {
ioctlv *vector = message->ioctlv.vector;
u32 inlen = message->ioctlv.num_in;
u32 iolen = message->ioctlv.num_io;
u32 cmd = message->ioctlv.command;
/* Parse IOCTLV */
ret = __MLoad_Ioctlv(cmd, vector, inlen, iolen);
break;
}
default:
/* Unknown command */
ret = IPC_EINVAL;
}
/* Acknowledge message */
os_message_queue_ack(message, ret);
}
return 0;
}
int main(void)
{
int fd,n,mounted=0;
int inited=0;
ipcmessage* message;
memset(&my_reent, 0, sizeof(struct _reent));
memset(my_filestr, 0, sizeof(FILE_STRUCT)*5);
memset(file_table, 0, 4*2*5);
memset(&dir_state_internal,0,sizeof(DIR_STATE_STRUCT));
dir_internal.device=0;
dir_internal.dirStruct=&dir_state_internal;
heaphandle = os_heap_create(heapspace, sizeof(heapspace));
void* queuespace = os_heap_alloc(heaphandle, 0x20);
queuehandle = os_message_queue_create(queuespace, 8);
void* timer1_queuespace = os_heap_alloc(heaphandle, 0x40);
timer1_queuehandle = os_message_queue_create(timer1_queuespace, 16);
timer1_id=os_create_timer(1000*1000, 1, timer1_queuehandle, 0x666);
os_stop_timer(timer1_id);
extern DISC_INTERFACE __io_wiisd;
inited=__io_wiisd.startup();
msleep(100);
os_device_register(DEVICE, queuehandle);
while(1)
{
int result = 1;
int ack = 1;
os_message_queue_receive(queuehandle,(void *) &message, 0);
switch( message->command )
{
case IOS_OPEN:
{
result = -6;
//debug_printf("%s try open %sfor fd %d\n",DEVICE,message->open.device,message->open.resultfd);
// Checking device name
if (0 == strcmp(message->open.device, DEVICE))
{
result = message->open.resultfd;
}
else
if (0 == strcmp(message->open.device, DEVICE"/log"))
{
if(inited && !mounted)
mounted=fatMountSimple("sd", &__io_wiisd);
if(mounted)
{
static char log_name[]="sd:/log000.txt";
for(n=0;n<5;n++) if(my_filestr[n].inUse==0) break;
fd=-1;
if(n!=5)
{
my_reent._errno=0;
fd=_FAT_open_r(&my_reent, &my_filestr[n], log_name, O_CREAT | O_TRUNC | O_RDWR, 0);
log_name[9]++;
if(log_name[9]>='9') {log_name[9]='0';log_name[8]++;}
if(log_name[8]>='9') {log_name[8]='0';log_name[7]++;}
if(log_name[7]>='9') {log_name[7]='0';log_name[8]='0';log_name[9]='0';}
}
if(fd<0) result=-1;
else
{
result=file_table[n][0]=message->open.resultfd;
file_table[n][1]= fd;
}
}
}
else if (0 == memcmp(message->open.device, DEVICE"/", sizeof(DEVICE)))
{
if(inited && !mounted)
mounted=fatMountSimple("sd", &__io_wiisd);
if(mounted)
{
for(n=0;n<5;n++) if(my_filestr[n].inUse==0) break;
fd=-1;
if(n!=5)
{
my_reent._errno=0;
fd=_FAT_open_r(&my_reent, &my_filestr[n], message->open.device+sizeof(DEVICE),
message->open.mode, 0);
}
if(fd<0) result=-1;
else
{
result=file_table[n][0]=message->open.resultfd;
file_table[n][1]= fd;
}
}
}
}
break;
case IOS_IOCTLV:
{
result = -1;
ioctlv *vec = message->ioctlv.vector;
int i,in = message->ioctlv.num_in,io= message->ioctlv.num_io;
os_sync_before_read( vec, (in+io)*sizeof(ioctlv));
for(i=0;i<in+io;i++){
os_sync_before_read( vec[i].data, vec[i].len);
}
#if 0
// list the directory content to directory.txt
switch(message->ioctl.command )
{
case 0xcacafea:
if(inited && !mounted)
mounted=fatMountSimple("sd", &__io_wiisd);
if(mounted)
{
my_reent._errno=0;
result=-666;
if(_FAT_diropen_r(&my_reent, &dir_internal, "sd:/"))
{
static char log_name2[]="sd:/directory.txt";
char filename[768];
result = 0;
my_reent._errno=0;
fd=_FAT_open_r(&my_reent, &my_filestr[4], log_name2, O_CREAT | O_TRUNC | O_RDWR, 0);
my_reent._errno=0;
while(!_FAT_dirnext_r (&my_reent, &dir_internal, filename, &filestat))
{
my_reent._errno=0;
if(fd>=0)
{
if(filestat.st_mode & S_IFDIR)_FAT_write_r (&my_reent, fd, "[", 1); // es directorio
_FAT_write_r (&my_reent, fd, filename, strlen(filename));
if(filestat.st_mode & S_IFDIR)_FAT_write_r (&my_reent, fd, "]", 1); // es directorio
_FAT_write_r (&my_reent, fd, "\n", 1);
}
}
my_reent._errno=0;
if(fd>=0) _FAT_close_r (&my_reent, fd);fd=-1;
_FAT_dirclose_r(&my_reent, &dir_internal);
}
}
break;
}
#endif
for(i=in;i<in+io;i++){
os_sync_after_write( vec[i].data, vec[i].len);
}
}
break;
case IOS_CLOSE:
{
result = -1;
if(mounted)
{
my_reent._errno=0;
for(n=0;n<5;n++)
{
if(message->fd==file_table[n][0])
{
fd=file_table[n][1];
file_table[n][0]=file_table[n][1]=0;
_FAT_close_r (&my_reent, fd);
result = 0;
break;
}
}
for(n=0;n<5;n++) if(my_filestr[n].inUse!=0) break;
if(n==5) {fatUnmount ("sd");mounted=0;}
}
else result=-6;
}
break;
case IOS_READ:
{
result=-1;
if(mounted)
{
my_reent._errno=0;
for(n=0;n<5;n++)
{
if(message->fd==file_table[n][0])
{
fd=file_table[n][1];
result=_FAT_read_r (&my_reent, fd, message->write.data, message->write.length);
}
}
}
os_sync_after_write( message->write.data, message->write.length);
}
break;
case IOS_WRITE:
{
os_sync_before_read( message->write.data, message->write.length);
result=-1;
if(mounted)
{
my_reent._errno=0;
for(n=0;n<5;n++)
{
if(message->fd==file_table[n][0])
{
fd=file_table[n][1];
result=_FAT_write_r (&my_reent, fd, message->write.data, message->write.length);
}
}
}
}
break;
case IOS_SEEK:
{
result=-1;
if(mounted)
{
my_reent._errno=0;
for(n=0;n<5;n++)
{
if(message->fd==file_table[n][0])
{
fd=file_table[n][1];
result=_FAT_seek_r (&my_reent, fd, message->seek.offset, message->seek.origin);
}
}
}
}
break;
default:
result=-1;
break;
}
if (ack)
os_message_queue_ack( (void*)message, result );
}
return 0;
}
int main(void)
{
u32 queuehandle;
s32 ret;
/* Print info */
svc_write("$IOSVersion: FAT: " __DATE__ " " __TIME__ " 64M$\n");
/* Create blinker thread */
Led_CreateBlinkThread();
/* Initialize module */
ret = __FAT_Initialize(&queuehandle);
if (ret < 0)
return ret;
/* Main loop */
while (1) {
ipcmessage *message = NULL;
/* Wait for message */
ret = os_message_queue_receive(queuehandle, (void *)&message, 0);
if (ret)
continue;
switch (message->command) {
case IOS_OPEN: {
char *devpath = message->open.device;
u32 mode = message->open.mode;
if (*devpath == '$') {
char path[256];
/* Build absolute path to emu nand */
strcpy(path, emuNandPath);
FAT_Escape(path+emuNandPathLen, devpath+1);
dbg_printf("FAT: IOS_OPEN: Opening relative file %s\n", devpath);
/* Open file */
ret = FAT_Open(path, mode);
dbg_printf("FAT: IOS_OPEN: ret = %d\n", ret);
}
else if (!strcmp(devpath, DEVICE_FAT)) {
/* Open module */
dbg_printf("FAT: IOS_OPEN: Opening FAT module\n");
ret = 0;
dbg_printf("FAT: IOS_OPEN: ret = %d\n", ret);
}
else if (!strncmp(devpath, DEVICE_FAT, DEVICE_FAT_LEN)) {
/* Open file */
dbg_printf("FAT: IOS_OPEN: Opening absolute file %s\n", devpath + DEVICE_FAT_LEN);
ret = FAT_Open(devpath + DEVICE_FAT_LEN, mode);
dbg_printf("FAT: IOS_OPEN: ret = %d\n", ret);
}
else {
dbg_printf("FAT: IOS_OPEN: Unknown device path %s\n", devpath);
/* Error */
ret = IPC_EINVAL;
}
break;
}
case IOS_CLOSE: {
ret = 0;
// FIX d2x v7 beta1
// Check added because the fd might represent the module,
// see IOS_OPEN.
// Tipically a fd representing a module is far lower than 32,
// while a fd representing a file is an address 32 byte aligned.
if(message->fd != 0 && (message->fd % 32) == 0) {
dbg_printf("FAT: IOS_CLOSE: Closing file... fd = %d\n", message->fd);
/* Close file */
ret = FAT_Close(message->fd);
}
#ifdef DEBUG
else {
dbg_printf("FAT: IOS_CLOSE: Closing FAT module...\n");
}
#endif
dbg_printf("FAT: IOS_CLOSE: ret = %d\n", ret);
break;
}
case IOS_READ: {
void *buffer = message->read.data;
u32 len = message->read.length;
dbg_printf("FAT: IOS_READ: fd = %d, buffer = %x, len = %d\n", message->fd, buffer, len);
/* Read file */
ret = FAT_Read(message->fd, buffer, len);
/* Flush cache */
os_sync_after_write(buffer, len);
dbg_printf("FAT: IOS_READ: ret = %d\n", ret);
break;
}
case IOS_WRITE: {
void *buffer = message->write.data;
u32 len = message->write.length;
dbg_printf("FAT: IOS_WRITE: fd = %d, buffer = %x, len = %d\n", message->fd, buffer, len);
/* Invalidate cache */
os_sync_before_read(buffer, len);
/* Sart blinking */
Led_BlinkOn();
/* Write file */
ret = FAT_Write(message->fd, buffer, len);
dbg_printf("FAT: IOS_WRITE: ret = %d\n", ret);
/* Stop blinking */
Led_BlinkOff();
break;
}
case IOS_SEEK: {
s32 where = message->seek.offset;
s32 whence = message->seek.origin;
dbg_printf("FAT: IOS_SEEK: fd = %d, where = %d, whence = %d\n", message->fd, where, whence);
/* Seek file */
ret = FAT_Seek(message->fd, where, whence);
dbg_printf("FAT: IOS_SEEK: ret = %d\n", ret);
break;
}
case IOS_IOCTL: {
void *inbuf = message->ioctl.buffer_in;
void *iobuf = message->ioctl.buffer_io;
u32 inlen = message->ioctl.length_in;
u32 iolen = message->ioctl.length_io;
u32 cmd = message->ioctl.command;
/* Parse IOCTL */
ret = __FAT_Ioctl(message->fd, cmd, inbuf, inlen, iobuf, iolen);
break;
}
case IOS_IOCTLV: {
ioctlv *vector = message->ioctlv.vector;
u32 inlen = message->ioctlv.num_in;
u32 iolen = message->ioctlv.num_io;
u32 cmd = message->ioctlv.command;
/* Parse IOCTLV */
ret = __FAT_Ioctlv(message->fd, cmd, vector, inlen, iolen);
break;
}
default:
/* Unknown command */
ret = IPC_EINVAL;
}
/* Acknowledge message */
os_message_queue_ack((void *)message, ret);
}
return 0;
}
int main(void)
{
u32 queuehandle;
s32 ret;
/* Print info */
write("$IOSVersion: SDHC: " __DATE__ " " __TIME__ " 64M$\n");
/* Initialize module */
ret = __SDHC_Initialize(&queuehandle);
if (ret < 0)
return ret;
/* Main loop */
while (1) {
ipcmessage *message = NULL;
/* Wait for message */
os_message_queue_receive(queuehandle, (void *)&message, 0);
switch (message->command) {
case IOS_OPEN: {
/* Check device path */
if (!strcmp(message->open.device, DEVICE_NAME))
ret = message->open.resultfd;
else
ret = IPC_ENOENT;
break;
}
case IOS_CLOSE: {
/* Close SDIO */
ret = !sdio_Shutdown();
break;
}
case IOS_IOCTLV: {
ioctlv *vector = message->ioctlv.vector;
u32 inlen = message->ioctlv.num_in;
u32 iolen = message->ioctlv.num_io;
u32 cmd = message->ioctlv.command;
/* Parse IOCTLV message */
ret = __SDHC_Ioctlv(cmd, vector, inlen, iolen);
break;
}
default:
/* Unknown command */
ret = IPC_EINVAL;
}
/* Acknowledge message */
os_message_queue_ack(message, ret);
}
return 0;
}
int main(void)
{
u32 queuehandle;
s32 ret;
/* Print info */
write("$IOSVersion: FAT: " __DATE__ " " __TIME__ " 64M$\n");
/* Initialize module */
ret = __FAT_Initialize(&queuehandle);
if (ret < 0)
return ret;
/* Main loop */
while (1) {
ipcmessage *message = NULL;
/* Wait for message */
os_message_queue_receive(queuehandle, (void *)&message, 0);
switch (message->command) {
case IOS_OPEN: {
char *devpath = message->open.device;
u32 mode = message->open.mode;
/* FAT device */
if (!strcmp(devpath, DEVICE_FAT)) {
ret = 0;
break;
}
/* Open file */
ret = FAT_Open(devpath, mode);
break;
}
case IOS_CLOSE: {
/* Close file */
ret = FAT_Close(message->fd);
break;
}
case IOS_READ: {
void *buffer = message->read.data;
u32 len = message->read.length;
/* Read file */
ret = FAT_Read(message->fd, buffer, len);
break;
}
case IOS_WRITE: {
void *buffer = message->write.data;
u32 len = message->write.length;
/* Write file */
ret = FAT_Write(message->fd, buffer, len);
break;
}
case IOS_SEEK: {
u32 where = message->seek.offset;
u32 whence = message->seek.origin;
/* Seek file */
ret = FAT_Seek(message->fd, where, whence);
break;
}
case IOS_IOCTL: {
void *inbuf = message->ioctl.buffer_in;
u32 inlen = message->ioctl.length_in;
void *iobuf = message->ioctl.buffer_io;
u32 iolen = message->ioctl.length_io;
u32 cmd = message->ioctl.command;
/* Parse IOCTL message */
ret = FAT_Ioctl(message->fd, cmd, inbuf, inlen, iobuf, iolen);
break;
}
case IOS_IOCTLV: {
ioctlv *vector = message->ioctlv.vector;
u32 inlen = message->ioctlv.num_in;
u32 iolen = message->ioctlv.num_io;
u32 cmd = message->ioctlv.command;
/* Parse IOCTLV message */
ret = FAT_Ioctlv(message->fd, cmd, vector, inlen, iolen);
break;
}
default:
/* Unknown command */
ret = IPC_EINVAL;
}
/* Acknowledge message */
os_message_queue_ack((void *)message, ret);
}
return 0;
}
