libcdvd.c

Go to the documentation of this file.

/*
# _____     ___ ____     ___ ____
#  ____|   |    ____|   |        | |____|
# |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
#-----------------------------------------------------------------------
# (C) 2002 Nicholas Van Veen (nickvv@xtra.co.nz)
#     2003 loser (loser@internalreality.com)
# (c) 2004 Marcus R. Brown <mrbrown@0xd6.org>
# Licenced under Academic Free License version 2.0
# Review ps2sdk README & LICENSE files for further details.
*/
 
#include <stdio.h>
#include <tamtypes.h>
#include <kernel.h>
#include <sifrpc.h>
#include <string.h>
#include <libcdvd.h>
#include <stdarg.h>
 
#include "internal.h"
 
// rpc bind values
#define CD_SERVER_INIT                  0x80000592
#define CD_SERVER_SEARCHFILE            0x80000597
#define CD_SERVER_DISKREADY             0x8000059A
#define CD_SERVER_POFF                  0x80000596
 
extern void *_gp;
 
// prototypes
void _CdSemaExit(void);
 
typedef struct {
        u8 padding[32];
        char name[256];
        void *dest;
} SearchFilePkt;
 
#ifdef F__libcdvd_internals
// bind variables
int bindInit = -1;
int bindDiskReady = -1;
int bindSearchFile = -1;
// rpc binded client data
SifRpcClientData_t clientInit __attribute__ ((aligned(64)));
SifRpcClientData_t clientDiskReady __attribute__ ((aligned(64)));
SifRpcClientData_t clientSearchFile __attribute__ ((aligned(64)));
 
int CdDebug = 0;
 
// semaphore ids
int callbackSemaId = -1;
volatile int cbSema = 0;
 
// callbacks
volatile int CdCallbackNum;
volatile sceCdCBFunc sceCdCallbackFunc;
 
// threads
int CdThreadId = 0;
ee_thread_status_t CdThreadParam;
int callbackThreadId = 0;
ee_thread_t callbackThreadParam;
 
// current command variables
 
s32 diskReadyMode __attribute__ ((aligned(64)));
s32 trayReqData __attribute__ ((aligned(64)));
u32 initMode __attribute__ ((aligned(64)));
 
// searchfile stuff
SearchFilePkt searchFileSendBuff __attribute__ ((aligned(64)));
u32 searchFileRecvBuff __attribute__ ((aligned(64)));
#endif
 
// Prototypes for multimodule
extern int bindInit;
extern int bindDiskReady;
extern int bindSearchFile;
extern SifRpcClientData_t clientInit;
extern SifRpcClientData_t clientDiskReady;
extern SifRpcClientData_t clientSearchFile;
extern int CdDebug;
extern int callbackSemaId;
extern volatile int cbSema;
extern volatile int CdCallbackNum;
extern volatile sceCdCBFunc sceCdCallbackFunc;
extern int CdThreadId;
extern ee_thread_status_t CdThreadParam;
extern int callbackThreadId;
extern ee_thread_t callbackThreadParam;
extern s32 diskReadyMode;
extern s32 trayReqData;
extern u32 initMode;
extern SearchFilePkt searchFileSendBuff;
extern u32 searchFileRecvBuff;
 
/* Other Functions */
 
#ifdef F_sceCdInit
s32 sceCdInit(s32 mode)
{
        if (_CdSyncS(1))
                return 0;
        SifInitRpc(0);
        CdThreadId = GetThreadId();
        bindSearchFile = -1;
        bindNCmd = -1;
        bindSCmd = -1;
        bindDiskReady = -1;
        bindInit = -1;
 
        while (1) {
                if (SifBindRpc(&clientInit, CD_SERVER_INIT, 0) < 0) {
                        if (CdDebug > 0)
                                printf("Libcdvd bind err CD_Init\n");
                } else if (clientInit.server != 0)
                        break;
 
                nopdelay();
        }
 
        bindInit = 0;
        initMode = mode;
        if (SifCallRpc(&clientInit, 0, 0, &initMode, 4, 0, 0, 0, 0) < 0)
                return 0;
        if (mode == SCECdEXIT) {
                if (CdDebug > 0)
                        printf("Libcdvd Exit\n");
                _CdSemaExit();
                nCmdSemaId = -1;
                sCmdSemaId = -1;
                callbackSemaId = -1;
        } else {
                _CdSemaInit();
        }
 
        return 1;
}
#endif
 
#ifdef F_sceCdIntToPos
sceCdlLOCCD *sceCdIntToPos(u32 i, sceCdlLOCCD * p)
{
        p->minute = (((((i + 150) / 75) / 60) / 10) * 16) + ((((i + 150) / 75) / 60) % 10);
        p->second = (((((i + 150) / 75) % 60) / 10) * 16) + ((((i + 150) / 75) % 60) % 10);
        p->sector = ((((i + 150) % 75) / 10) * 16) + (((i + 150) % 75) % 10);
        return p;
}
#endif
 
#ifdef F_sceCdPosToInt
u32 sceCdPosToInt(sceCdlLOCCD * p)
{
        return ((((p->minute / 16) * 10) + (p->minute & 0xF)) * 60 + ((p->second / 16) * 10) + (p->second & 0xF)
            ) * 75 + (p->sector / 16) * 10 + (p->sector & 0xF) - 150;
}
#endif
 
#ifdef F_sceCdSearchFile
s32 sceCdSearchFile(sceCdlFILE * file, const char *name)
{
        _CdSemaInit();
        if (PollSema(nCmdSemaId) != nCmdSemaId)
                return 0;
        nCmdNum = CD_SERVER_SEARCHFILE;
        ReferThreadStatus(CdThreadId, &CdThreadParam);
        if (sceCdSync(1)) {
                SignalSema(nCmdSemaId);
                return 0;
        }
        SifInitRpc(0);
        if (bindSearchFile < 0) {
                while (1) {
                        if (SifBindRpc(&clientSearchFile, CD_SERVER_SEARCHFILE, 0) < 0) {
                                if (CdDebug > 0)
                                        printf("libsceCdvd bind err sceCdSearchFile\n");
                        }
                        if (clientSearchFile.server != 0)
                                break;
 
                        nopdelay();
                }
                bindSearchFile = 0;
        }
 
        strncpy(searchFileSendBuff.name, name, 255);
        searchFileSendBuff.name[255] = '\0';
        searchFileSendBuff.dest = &searchFileSendBuff;
 
        if (CdDebug > 0)
                printf("ee call cmd search %s\n", searchFileSendBuff.name);
        if (SifCallRpc(&clientSearchFile, 0, 0, &searchFileSendBuff, sizeof(SearchFilePkt), nCmdRecvBuff, 4, NULL, NULL) < 0) {
                SignalSema(nCmdSemaId);
                return 0;
        }
 
        memcpy(file, UNCACHED_SEG(&searchFileSendBuff), 32);
 
        if (CdDebug > 0) {
                printf("search name %s\n", file->name);
                printf("search size %d\n", file->size);
                printf("search loc lnn %d\n", file->lsn);
                printf("search loc date %02X %02X %02X %02X %02X %02X %02X %02X\n",
                       file->date[0], file->date[1], file->date[2], file->date[3],
                       file->date[4], file->date[5], file->date[6], file->date[7]);
                printf("search loc date %02d %02d %02d %02d %02d %02d %02d %02d\n",
                       file->date[0], file->date[1], file->date[2], file->date[3],
                       file->date[4], file->date[5], file->date[6], file->date[7]);
        }
 
        SignalSema(nCmdSemaId);
        return *(s32*)UNCACHED_SEG(nCmdRecvBuff);
}
#endif
 
#ifdef F_sceCdDiskReady
s32 sceCdDiskReady(s32 mode)
{
        if (CdDebug > 0)
                printf("DiskReady 0\n");
 
        _CdSemaInit();
        if (PollSema(sCmdSemaId) != sCmdSemaId)
                return SCECdNotReady;
        if (_CdSyncS(1)) {
                SignalSema(sCmdSemaId);
                return SCECdNotReady;
        }
 
        SifInitRpc(0);
        if (bindDiskReady < 0) {
                while (1) {
                        if (SifBindRpc(&clientDiskReady, CD_SERVER_DISKREADY, 0) < 0) {
                                if (CdDebug > 0)
                                        printf("Libcdvd bind err CdDiskReady\n");
                        }
                        if (clientDiskReady.server != 0)
                                break;
 
                        nopdelay();
                }
        }
        bindDiskReady = 0;
        diskReadyMode = mode;
 
        if (SifCallRpc(&clientDiskReady, 0, 0, &diskReadyMode, 4, sCmdRecvBuff, 4, NULL, NULL) < 0) {
                SignalSema(sCmdSemaId);
                return 6;
        }
        if (CdDebug > 0)
                printf("DiskReady ended\n");
 
        SignalSema(sCmdSemaId);
        return *(s32 *) UNCACHED_SEG(sCmdRecvBuff);
}
#endif
 
#ifdef F__CdSemaInit
void _CdSemaInit(void)
{
        struct t_ee_sema semaParam;
 
        // return if both semaphores are already inited
        if (nCmdSemaId != -1 && sCmdSemaId != -1)
                return;
 
        semaParam.init_count = 1;
        semaParam.max_count = 1;
        semaParam.option = 0;
        nCmdSemaId = CreateSema(&semaParam);
        sCmdSemaId = CreateSema(&semaParam);
 
        semaParam.init_count = 0;
        callbackSemaId = CreateSema(&semaParam);
 
        cbSema = 0;
}
#endif
 
#ifdef F__CdSemaExit
void _CdSemaExit(void)
{
        if (callbackThreadId) {
                CdCallbackNum = -1;
                SignalSema(callbackSemaId);
        }
        DeleteSema(nCmdSemaId);
        DeleteSema(sCmdSemaId);
        DeleteSema(callbackSemaId);
}
#endif
 
#ifdef F_sceCdInitEeCB
static void _CdCallbackLoop(void);
s32 sceCdInitEeCB(s32 priority, void *stackAddr, s32 stackSize)
{
        // if callback thread has already been initialised, just change its priority
        if (callbackThreadId != 0) {
                ChangeThreadPriority(callbackThreadId, priority);
                return 0;
        }
        // initialise callback thread
        CdThreadId = GetThreadId();
        ReferThreadStatus(CdThreadId, &CdThreadParam);
        callbackThreadParam.stack_size = stackSize;
        callbackThreadParam.gp_reg = &_gp;
        callbackThreadParam.func = &_CdCallbackLoop;
        callbackThreadParam.stack = stackAddr;
        callbackThreadParam.initial_priority = priority;
        callbackThreadId = CreateThread(&callbackThreadParam);
        StartThread(callbackThreadId, NULL);
 
        return 1;
}
#endif
 
#ifdef F_sceCdCallback
sceCdCBFunc sceCdCallback(sceCdCBFunc newFunc)
{
        sceCdCBFunc oldFunc = sceCdCallbackFunc;
 
        if (sceCdSync(1))
                return 0;
 
        sceCdCallbackFunc = newFunc;
        return oldFunc;
}
#endif
 
/* Util Functions */
 
 
#ifdef F_sceCdInitEeCB
static void _CdCallbackLoop(void)
{
        while (1) {
                WaitSema(callbackSemaId);
 
                // if callback number if -1, stop callbck thread loop
                if (CdCallbackNum == -1)
                        ExitThread();
 
                if (CdDebug > 0)
                        printf("sceCdCallbackFunc = %08X   CdCallbackNum = %d\n", (u32) sceCdCallbackFunc, CdCallbackNum);
 
                // if callback function number and 'custom callback function' pointer are valid, do callback
                if (sceCdCallbackFunc && CdCallbackNum)
                        sceCdCallbackFunc(CdCallbackNum);
 
                cbSema = 0;
        }
}
#endif
 
#ifdef F__CdGenericCallbackFunction
void _CdGenericCallbackFunction(void *funcNum)
{
        // set the currently executing function num
        CdCallbackNum = *(s32*) funcNum;
        iSignalSema(nCmdSemaId);
        
        // check if user callback is registered
        if (callbackThreadId)
        {
                if (sceCdCallbackFunc)
                {
                        iSignalSema(callbackSemaId);
                        return;
                }
        }
        
        // clear the currently executing function num
        cbSema = 0;
        CdCallbackNum = 0;
}
#endif