libmc.c

Go to the documentation of this file.

/*
# _____     ___ ____     ___ ____
#  ____|   |    ____|   |        | |____|
# |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
#-----------------------------------------------------------------------
# Copyright 2001-2004, ps2dev - http://www.ps2dev.org
# Licenced under Academic Free License version 2.0
# Review ps2sdk README & LICENSE files for further details.
*/
 
#include <tamtypes.h>
#include <kernel.h>
#include <sifrpc.h>
#include <string.h>
#include "libmc.h"
 
//#define MC_DEBUG
 
#ifdef MC_DEBUG
#include <stdio.h>
#endif
 
 
enum MC_RPCCMD_NUMBERS{
    MC_RPCCMD_INIT      = 0x00,
    MC_RPCCMD_GET_INFO,
    MC_RPCCMD_OPEN,
    MC_RPCCMD_CLOSE,
    MC_RPCCMD_SEEK,
    MC_RPCCMD_READ,
    MC_RPCCMD_WRITE,
    MC_RPCCMD_FLUSH,
    MC_RPCCMD_CH_DIR,
    MC_RPCCMD_GET_DIR,
    MC_RPCCMD_SET_INFO,
    MC_RPCCMD_DELETE,
    MC_RPCCMD_FORMAT,
    MC_RPCCMD_UNFORMAT,
    MC_RPCCMD_GET_ENT,
    MC_RPCCMD_CHG_PRITY,
    MC_RPCCMD_CHECK_BLOCK,
    MC_RPCCMD_ERASE_BLOCK   = 0x0E,
    MC_RPCCMD_READ_PAGE,
    MC_RPCCMD_WRITE_PAGE
};
 
static const int mcRpcCmd[2][17] =
{
    // MCMAN/MCSERV values
    {
    0x70,   // MC_RPCCMD_INIT
    0x78,   // MC_RPCCMD_GET_INFO
    0x71,   // MC_RPCCMD_OPEN
    0x72,   // MC_RPCCMD_CLOSE
    0x75,   // MC_RPCCMD_SEEK
    0x73,   // MC_RPCCMD_READ
    0x74,   // MC_RPCCMD_WRITE
    0x7A,   // MC_RPCCMD_FLUSH
    0x7B,   // MC_RPCCMD_CH_DIR
    0x76,   // MC_RPCCMD_GET_DIR
    0x7C,   // MC_RPCCMD_SET_INFO
    0x79,   // MC_RPCCMD_DELETE
    0x77,   // MC_RPCCMD_FORMAT
    0x80,   // MC_RPCCMD_UNFORMAT
    0x7D,   // MC_RPCCMD_ERASE_BLOCK (calls mcman_funcs: 39, 17, 20, 19, 30)
    0x7E,   // MC_RPCCMD_READ_PAGE
    0x7F,   // MC_RPCCMD_WRITE_PAGE (calls mcman_funcs: 20, 19)
    },
    // XMCMAN/XMCSERV values
    {
    0xFE,   // MC_RPCCMD_INIT
    0x01,   // MC_RPCCMD_GET_INFO
    0x02,   // MC_RPCCMD_OPEN
    0x03,   // MC_RPCCMD_CLOSE
    0x04,   // MC_RPCCMD_SEEK
    0x05,   // MC_RPCCMD_READ
    0x06,   // MC_RPCCMD_WRITE
    0x0A,   // MC_RPCCMD_FLUSH
    0x0C,   // MC_RPCCMD_CH_DIR
    0x0D,   // MC_RPCCMD_GET_DIR
    0x0E,   // MC_RPCCMD_SET_INFO
    0x0F,   // MC_RPCCMD_DELETE
    0x10,   // MC_RPCCMD_FORMAT
    0x11,   // MC_RPCCMD_UNFORMAT
    0x12,   // MC_RPCCMD_GET_ENT
    0x14,   // MC_RPCCMD_CHG_PRITY
    0x33,   // MC_RPCCMD_CHECK_BLOCK (calls xmcman_funcs: 45)
    }
};
 
typedef struct {            // size = 1044
    int port;           // 0
    int slot;           // 4
    int flags;          // 8
    int maxent;         // 12
    union {
        sceMcTblGetDir *mcT;    // 16
        char *curdir;
    };
    char name[1024];        // 20
} mcNameParam_t;
 
static mcNameParam_t g_nameParam __attribute__((aligned(64)));
 
static mcDescParam_t g_descParam __attribute__((aligned(64)));
 
// params sent with rpc commands
//static McRpcNameParam g_nameParam  __attribute__((aligned(64)));
//static McRpcDescParam g_descParam  __attribute__((aligned(64)));
//static unsigned int mcInfoCmd[12] __attribute__((aligned(64)));
 
extern int _iop_reboot_count;
 
static SifRpcClientData_t g_cdata __attribute__((aligned(64)));
 
#define RSIZE 2048
static union{
    s32 result;
    mcRpcStat_t rpcStat;
    u8 buffer[RSIZE];
} g_rdata __attribute__((aligned(64)));
 
static int* g_pType = NULL;
static int* g_pFree = NULL;
static int* g_pFormat = NULL;
 
static int  endParameter[48] __attribute__((aligned(64)));
static char curDir[1024] __attribute__((aligned(64)));
static sceMcTblGetDir g_fileInfoBuff __attribute__((aligned(64)));  // used by mcSetFileInfo and mcRename
 
 
static int g_mclibInited = 0;
 
static unsigned int g_currentCmd = 0;
 
static int g_mcType = MC_TYPE_MC;
 
 
static void mcGetInfoApdx(void* info)
{
    mcEndParam_t    *ptr    = (mcEndParam_t*)UNCACHED_SEG(info);
    mcEndParam2_t   *ptrNew = (mcEndParam2_t*)UNCACHED_SEG(info);
 
    // older MCSERV doesnt support retrieving whether card is formatted
    // so if a card is present, determine whether its formatted based on the return value from MCSERV
    if(g_mcType == MC_TYPE_MC)
    {
        if(g_pType != NULL)
            *g_pType = ptr->type;
 
        if(g_pFree != NULL)
            *g_pFree = ptr->free;
 
        if(g_pFormat != NULL)
            *g_pFormat = (ptr->type == MC_TYPE_NONE || g_rdata.result == -2) ? 0 : 1;
    } else {
        if(g_pType != NULL)
            *g_pType = ptrNew->type;
 
        if(g_pFree != NULL)
            *g_pFree = ptrNew->free;
 
        if(g_pFormat != NULL)
            *g_pFormat = ptrNew->formatted;
    }
}
 
static void mcReadFixAlign(void* data_raw)
{
    mcEndParam_t    *ptr    = (mcEndParam_t*)UNCACHED_SEG(data_raw);
    mcEndParam2_t   *ptrNew = (mcEndParam2_t*)UNCACHED_SEG(data_raw);
    u8 *dest;
    int i;
 
    if(g_mcType == MC_TYPE_MC)
    {
        for(i = 0,dest = (u8*)ptr->dest1; i < ptr->size1; i++)
            dest[i] = ptr->src1[i];
        for(i = 0,dest = (u8*)ptr->dest2; i < ptr->size2; i++)
            dest[i] = ptr->src2[i];
    } else {
        for(i = 0,dest = (u8*)ptrNew->dest1; i < ptrNew->size1; i++)
            dest[i] = ptrNew->src1[i];
        for(i = 0,dest = (u8*)ptrNew->dest2; i < ptrNew->size2; i++)
            dest[i] = ptrNew->src2[i];
    }
}
 
static void mcStoreDir(void* arg)
{
    int len;
    char *currentDir = UNCACHED_SEG(curDir);
    len = strlen(currentDir);
    if(len >= 1024)
        len = strlen(currentDir+1023);
    memcpy(arg, currentDir, len);
    *(currentDir+len) = 0;
}
 
int mcInit(int type)
{
    int ret=0;
    int err=0;
    mcRpcStat_t *rpcStat = (mcRpcStat_t*)UNCACHED_SEG(&g_rdata.rpcStat);
    static int _rb_count = 0;
 
    (void)type;
    if(_rb_count != _iop_reboot_count)
    {
        _rb_count = _iop_reboot_count;
        mcReset();
    }
 
    if(g_mclibInited)
        return -1;
 
    sceSifInitRpc(0);
 
    // bind to mc rpc on iop
    do
    {
        if((ret=sceSifBindRpc(&g_cdata, 0x80000400, 0)) < 0)
        {
            #ifdef MC_DEBUG
                printf("libmc: bind error\n");
            #endif
 
            return ret;
        }
        if(g_cdata.server == NULL)
            nopdelay();
    }
    while (g_cdata.server == NULL);
 
    // for some reason calling this init sif function with 'mcserv' makes all other
    // functions not work properly. although NOT calling it means that detecting
    // whether or not cards are formatted doesnt seem to work :P
 
    // Start with calling flush with an invalid fd (so it sets the return value to
    // sceMcResDeniedPermit, which MC_RPCCMD_INIT will not return)
    g_descParam.fd = 0xFFFFFFFF;
    sceSifCallRpc(&g_cdata, mcRpcCmd[MC_TYPE_XMC][MC_RPCCMD_FLUSH], 0, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL);
    sceSifCallRpc(&g_cdata, mcRpcCmd[MC_TYPE_MC][MC_RPCCMD_FLUSH], 0, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL);
#ifdef MC_DEBUG
    printf("libmc: using XMCMAN & XMCSERV\n");
#endif
 
    // Try XMCSERV RPC
    g_mcType = MC_TYPE_XMC;
    // call init function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_INIT], 0, &g_descParam, sizeof(g_descParam), &g_rdata, 12, NULL, NULL)) < 0)
    {
        // init error
#ifdef MC_DEBUG
        printf("libmc: initialisation error\n");
#endif
        err = ret - 100;
    }
 
    // If result was sceMcResDeniedPermit, RPC was unhandled
    if (!err && rpcStat->result == sceMcResDeniedPermit)
    {
        err = -122;
    }
 
    if (!err)
    {
        // check if old version of mcserv loaded
        if (rpcStat->mcserv_version < 0x205)
        {
#ifdef MC_DEBUG
            printf("libmc: mcserv is too old (%x)\n", rpcStat->mcserv_version);
#endif
            err = -120;
        }
 
        // check if old version of mcman loaded
        if (rpcStat->mcman_version < 0x206)
        {
#ifdef MC_DEBUG
            printf("libmc: mcman is too old (%x)\n", rpcStat->mcman_version);
#endif
            err = -121;
        }
    }
 
    if (!err)
    {
        ret = rpcStat->result;
    }
 
    if (err && rpcStat->result == sceMcResDeniedPermit)
    {
        err = 0;
 
        // Try MCSERV RPC
        g_mcType = MC_TYPE_MC;
#ifdef MC_DEBUG
        printf("libmc: using MCMAN & MCSERV\n");
#endif
 
        g_descParam.offset = -217;
 
        // call init function
        if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_INIT], 0, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) < 0)
        {
            // init error
#ifdef MC_DEBUG
            printf("libmc: initialisation error\n");
#endif
            err = ret - 100;
        }
 
        // If result was sceMcResDeniedPermit, RPC was unhandled
        if (!err && rpcStat->result == sceMcResDeniedPermit)
        {
            err = -122;
        }
 
        if (!err)
        {
            ret = g_rdata.result;
        }
    }
 
    if (err)
    {
        g_mclibInited = 0;
        return err;
    }
 
    // successfully inited
    g_mclibInited = 1;
    g_currentCmd = 0;
    return ret;
}
 
int mcGetInfo(int port, int slot, int* type, int* free, int* format)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    if(g_mcType == MC_TYPE_MC)
    {
        g_descParam.port    = port;
        g_descParam.slot    = slot;
        g_descParam.size    = (type)    ? 1 : 0;
        g_descParam.offset  = (free)    ? 1 : 0;
        g_descParam.origin  = (format)  ? 1 : 0;
        g_descParam.param   = endParameter;
    }
    else
    {
        g_descParam.port    = port;
        g_descParam.slot    = slot;
        g_descParam.size    = (format)  ? 1 : 0;
        g_descParam.offset  = (free)    ? 1 : 0;
        g_descParam.origin  = (type)    ? 1 : 0;
        g_descParam.param   = endParameter;
    }
    g_pType     = type;
    g_pFree     = free;
    g_pFormat   = format;
    sceSifWriteBackDCache(endParameter, 192);
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_GET_INFO], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, (SifRpcEndFunc_t)mcGetInfoApdx, endParameter)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_GET_INFO;
    return ret;
}
 
int mcOpen(int port, int slot, const char *name, int mode)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port        = port;
    g_nameParam.slot        = slot;
    g_nameParam.flags       = mode;
    strncpy(g_nameParam.name, name, 1023);
    g_nameParam.name[1023] = 0;
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_OPEN], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_OPEN;
    return ret;
}
 
int mcClose(int fd)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.fd  = fd;
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_CLOSE], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_CLOSE;
    return ret;
}
 
int mcSeek(int fd, int offset, int origin)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.fd      = fd;
    g_descParam.offset  = offset;
    g_descParam.origin  = origin;
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_SEEK], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_SEEK;
    return ret;
}
 
int mcRead(int fd, void *buffer, int size)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.fd      = fd;
    g_descParam.size    = size;
    g_descParam.buffer  = buffer;
    g_descParam.param   = endParameter;
    sceSifWriteBackDCache(buffer, size);
    sceSifWriteBackDCache(endParameter, 192);
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_READ], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, (SifRpcEndFunc_t)mcReadFixAlign, endParameter)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_READ;
    return ret;
}
 
int mcWrite(int fd, const void *buffer, int size)
{
    int i, ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.fd  = fd;
    if(size < 17)
    {
        g_descParam.size    = 0;
        g_descParam.origin  = size;
        g_descParam.buffer  = 0;
    }
    else
    {
        g_descParam.size    = size        - ( ((int)((const u8 *)buffer-1) & 0xFFFFFFF0) - (int)((const u8 *)buffer-16) );
        g_descParam.origin  =               ( ((int)((const u8 *)buffer-1) & 0xFFFFFFF0) - (int)((const u8 *)buffer-16) );
        g_descParam.buffer  = (void*)((int)(const u8 *)buffer + ( ((int)((const u8 *)buffer-1) & 0xFFFFFFF0) - (int)((const u8 *)buffer-16) ));
    }
    for(i=0; i<g_descParam.origin; i++)
    {
        g_descParam.data[i] = *(char*)((const u8 *)buffer+i);
    }
    FlushCache(0);
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_WRITE], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_WRITE;
    return ret;
}
 
int mcFlush(int fd)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.fd  = fd;
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_FLUSH], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_FLUSH;
    return ret;
}
 
int mcMkDir(int port, int slot, const char* name)
{
    int ret = mcOpen(port, slot, name, 0x40);
 
    if(ret != 0)
        g_currentCmd = MC_FUNC_MK_DIR;
    return ret;
}
 
int mcChdir(int port, int slot, const char* newDir, char* currentDir)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port        = port;
    g_nameParam.slot        = slot;
    g_nameParam.curdir      = curDir;
    strncpy(g_nameParam.name, newDir, 1023);
    g_nameParam.name[1023] = 0;
    sceSifWriteBackDCache(curDir, 1024);
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_CH_DIR], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, (SifRpcEndFunc_t)mcStoreDir, currentDir)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_CH_DIR;
    return ret;
}
 
int mcGetDir(int port, int slot, const char *name, unsigned mode, int maxent, sceMcTblGetDir* table)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port    = port;
    g_nameParam.slot    = slot;
    g_nameParam.flags   = mode;
    g_nameParam.maxent  = maxent;
    g_nameParam.mcT     = table;
    strncpy(g_nameParam.name, name, 1023);
    g_nameParam.name[1023] = 0;
    sceSifWriteBackDCache(table, maxent * sizeof(sceMcTblGetDir));
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_GET_DIR], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_GET_DIR;
    return ret;
}
 
int mcSetFileInfo(int port, int slot, const char* name, const sceMcTblGetDir* info, unsigned flags)
{
    int ret;
 
    // check mc lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port    = port;
    g_nameParam.slot    = slot;
    g_nameParam.flags   = flags;    // NOTE: this was ANDed with 7 so that u cant turn off copy protect! :)
    g_nameParam.mcT     = &g_fileInfoBuff;
    memcpy(&g_fileInfoBuff, info, sizeof(sceMcTblGetDir));
 
    strncpy(g_nameParam.name, name, 1023);
    g_nameParam.name[1023] = 0;
    FlushCache(0);
 
    // send sif command
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_SET_INFO], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_SET_INFO;
    return ret;
}
 
int mcDelete(int port, int slot, const char *name)
{
    int ret;
 
    // check lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port = port;
    g_nameParam.slot = slot;
    g_nameParam.flags = 0;
    strncpy(g_nameParam.name, name, 1023);
    g_nameParam.name[1023] = 0;
 
    // call delete function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_DELETE], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_DELETE;
    return ret;
}
 
int mcFormat(int port, int slot)
{
    int ret;
 
    // check lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.port = port;
    g_descParam.slot = slot;
 
    // call format function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_FORMAT], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_FORMAT;
    return ret;
}
 
int mcUnformat(int port, int slot)
{
    int ret;
 
    // check lib is inited
    if(!g_mclibInited)
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_descParam.port = port;
    g_descParam.slot = slot;
 
    // call unformat function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_UNFORMAT], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_UNFORMAT;
    return ret;
}
 
int mcGetEntSpace(int port, int slot, const char* path)
{
    int ret;
 
    // check lib is inited
    if((!g_mclibInited)||(g_mcType==MC_TYPE_MC))
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port = port;
    g_nameParam.slot = slot;
    strncpy(g_nameParam.name, path, 1023);
    g_nameParam.name[1023] = 0;
 
    // call sif function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_GET_ENT], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_GET_ENT;
    return ret;
}
 
int mcRename(int port, int slot, const char* oldName, const char* newName)
{
    int ret;
 
    // check lib is inited
    if((!g_mclibInited)||(g_mcType==MC_TYPE_MC))    //I don't think that the old MCSERV module supports this because the v1.00 and v1.01 OSDSYS doesn't seem to have the sceMcRename function at all and the sceMcRename function was only introduced with SCE PS2SDK v1.50. I see that it doesn't work with rom0:MCSERV either way...
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
    g_nameParam.port = port;
    g_nameParam.slot = slot;
    g_nameParam.flags = 0x10;
    g_nameParam.mcT = &g_fileInfoBuff;
    strncpy(g_nameParam.name, oldName, 1023);
    g_nameParam.name[1023] = 0;
    strncpy((char*)g_fileInfoBuff.EntryName, newName, 31);
    g_fileInfoBuff.EntryName[31] = 0;
    FlushCache(0);
 
    // call sif function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_SET_INFO], SIF_RPC_M_NOWAIT, &g_nameParam, sizeof(g_nameParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_RENAME;
    return ret;
}
 
int mcEraseBlock(int port, int slot, int block, int mode){
    int result;
 
    // check lib is inited
    if((!g_mclibInited)||(g_mcType==MC_TYPE_XMC))
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    g_descParam.port=port;
    g_descParam.slot=slot;
    g_descParam.offset=block;
    g_descParam.origin=mode;
 
    if((result = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_ERASE_BLOCK], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL))==0){
        g_currentCmd = MC_FUNC_ERASE_BLOCK;
    }
 
    return result;
}
 
struct libmc_PageReadAlignData{
    unsigned int size1;
    unsigned int size2;
    void *dest1;
    void *dest2;
    unsigned char data1[16];
    unsigned char data2[16];
    unsigned char padding[16];
};
 
static struct libmc_PageReadAlignData libmc_ReadPageAlignData __attribute__((aligned(64)));
 
static void libmc_ReadAlignFunction(struct libmc_PageReadAlignData *data){
    unsigned int misaligned;
 
    if((misaligned=(unsigned int)data->dest1&0xF)!=0){
        memcpy(UNCACHED_SEG(data->dest1), UNCACHED_SEG(data->data1), 16-misaligned);
        memcpy(UNCACHED_SEG((unsigned int)data->dest1+(16-misaligned)), UNCACHED_SEG((unsigned int)data->data1+(16-misaligned)+0x1F0), misaligned);
    }
}
 
int mcReadPage(int port, int slot, unsigned int page, void *buffer){
    int result;
 
    // check lib is inited
    if((!g_mclibInited)||(g_mcType==MC_TYPE_XMC))
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    g_descParam.fd=page;
    g_descParam.port=port;
    g_descParam.slot=slot;
    g_descParam.buffer=buffer;
    g_descParam.param=&libmc_ReadPageAlignData;
 
    sceSifWriteBackDCache(buffer, 0x200);
 
    if((result = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_READ_PAGE], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, (void*)&libmc_ReadAlignFunction, UNCACHED_SEG(&libmc_ReadPageAlignData)))==0){
        g_currentCmd = MC_FUNC_READ_PAGE;
    }
 
    return result;
}
 
int mcWritePage(int port, int slot, int page, const void *buffer){
    int result, misaligned;
 
    // check lib is inited
    if((!g_mclibInited)||(g_mcType==MC_TYPE_XMC))
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    g_descParam.fd=page;
    g_descParam.port=port;
    g_descParam.slot=slot;
    g_descParam.buffer=(void*)buffer;
 
    sceSifWriteBackDCache((void*)buffer, 512);
 
    if((misaligned=(unsigned int)buffer&0xF)!=0){
        memcpy(g_descParam.data, buffer, 16-misaligned);
        memcpy((void*)(g_descParam.data+(16-misaligned)), (void*)((const u8 *)buffer+(16-misaligned)+0x1F0), misaligned);
    }
 
    if((result = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_WRITE_PAGE], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL))==0){
        g_currentCmd = MC_FUNC_WRITE_PAGE;
    }
 
    return result;
}
 
int mcChangeThreadPriority(int level)
{
    int ret;
 
    (void)level;
 
    // check lib is inited
    if((!g_mclibInited)||(g_mcType==MC_TYPE_MC))
        return -1;
    // check nothing else is processing
    if(g_currentCmd != MC_FUNC_NONE)
        return g_currentCmd;
 
    // set global variables
//  *(u32*)mcCmd.name = level;
 
    // call sif function
    if((ret = sceSifCallRpc(&g_cdata, mcRpcCmd[g_mcType][MC_RPCCMD_CHG_PRITY], SIF_RPC_M_NOWAIT, &g_descParam, sizeof(g_descParam), &g_rdata, 4, NULL, NULL)) != 0)
        return ret;
    g_currentCmd = MC_FUNC_CHG_PRITY;
    return ret;
}
 
int mcSync(int mode, int *cmd, int *result)
{
    int funcIsExecuting;
 
    // check if any functions are registered
    if(g_currentCmd == MC_FUNC_NONE)
        return -1;
 
    // check if function is still processing
    funcIsExecuting = sceSifCheckStatRpc(&g_cdata);
 
    // if mode = 0, wait for function to finish
    if(mode == 0)
    {
        while(sceSifCheckStatRpc(&g_cdata))
        {
            int i;
            for(i=0; i<100000; i++)
                ;
        }
        // function has finished
        funcIsExecuting = 0;
    }
 
    // get the function that just finished
    if(cmd)
        *cmd = g_currentCmd;
 
    // if function is still processing, return 0
    if(funcIsExecuting == 1)
        return 0;
 
    // function has finished, so clear last command
    g_currentCmd = 0;
 
    // get result
    if(result)
        *result = g_rdata.result;
 
    return 1;
}
 
int mcReset(void)
{
    g_mclibInited = 0;
    g_cdata.server = NULL;
    return 0;
}