/*
*
* Return the lowest number controller connected to system
*/
int
initControllers()
{
OSMesgQueue serialMsgQ;
OSMesg serialMsg;
int i;
u8 pattern;
resetControllers();
osCreateMesgQueue(&serialMsgQ, &serialMsg, 1);
osSetEventMesg(OS_EVENT_SI, &serialMsgQ, (OSMesg)1);
osContInit(&serialMsgQ, &pattern, &statusdata[0]);
osCreateMesgQueue(&controllerMsgQ, &controllerMsgBuf, 1);
osSetEventMesg(OS_EVENT_SI, &controllerMsgQ, (OSMesg)0);
for (i = 0; i < MAXCONTROLLERS; i++) {
if ((pattern & (1<<i)) &&
!(statusdata[i].errno & CONT_NO_RESPONSE_ERROR))
return i;
}
return -1;
}
/*
* initilize controller
*
* maxcontrollers: want controller max num
* return : useable controller num
*/
int controllerInit(int maxcontrollers)
{
int i;
u8 pattern;
OSMesgQueue serialMsgQ;
OSMesg serialMsg;
osCreateMesgQueue(&serialMsgQ, &serialMsg, 1);
osSetEventMesg(OS_EVENT_SI, &serialMsgQ, (OSMesg)0);
osContInit(&serialMsgQ, &pattern, &statusdata[0]);
osCreateMesgQueue(&controllerMsgQ, &controllerMsgBuf, 1);
osSetEventMesg(OS_EVENT_SI, &controllerMsgQ, (OSMesg)0);
for(i = 0; i < MAXCONTROLLERS; i++){
if((pattern & (1<<i)) &&
!(statusdata[i].errno & CONT_NO_RESPONSE_ERROR)) {
controllerdata_ptr[numControllers] = & controllerdata[i];
numControllers++;
if(numControllers == maxcontrollers){
return numControllers;
}
}
}
/* osContStartReadData(&controllerMsgQ); */
return numControllers;
}
static void gameproc(void *arg) {
char *rsp_static_addr; /* R4300 addr where rsp_static segment loaded */
char *rsp_static_end; /* R4300 addr+1 for end of the load region */
int rsp_static_len;
OSIoMesg dmaMb; /* Needed (empty) for call to osEPiStartDma */
/* Message Queue for OS messages indicating DMA completions */
osCreateMesgQueue(&DMAMessageQ, DMAMessages, DMA_MSGQUEUE_SIZE);
/* Message Queue for OS messages indicating RDP done */
osCreateMesgQueue(&RDPDoneMessageQ, RDPDoneMessages, RDPDONE_MSGQUEUE_SIZE);
osSetEventMesg(OS_EVENT_DP, &RDPDoneMessageQ, dummyMsg);
/* Message Queue for OS messages indicating vertical retrace */
osCreateMesgQueue(&RetraceMessageQ, RetraceMessages, RETRACE_MSGQUEUE_SIZE);
osViSetEvent(&RetraceMessageQ, dummyMsg, 1);
/*
* Load the 'rsp_static' segment from the cartridge
*/
rsp_static_len = _rsp_staticSegmentRomEnd - _rsp_staticSegmentRomStart;
/* Place it right after the code/data segment in the 3rd MB of memory.
* Will not collide with CFB's or the Z buffer. Because the texture loads
* are so frequent, this gives a significant performance enhancement.
*/
rsp_static_addr = _codeSegmentEnd; /* R4300 address for static segment */
rsp_static_end = _codeSegmentEnd + rsp_static_len;
#ifdef DEBUG
if (rsp_static_len > 0x00300000) {
osSyncPrintf("** Static Segment too large **\n");
}
#endif
/* Note: dmaMb is working space used by osEPiStartDma */
dmaMb.hdr.pri = OS_MESG_PRI_NORMAL;
dmaMb.hdr.retQueue = &DMAMessageQ;
dmaMb.dramAddr = rsp_static_addr;
dmaMb.devAddr = (u32)_rsp_staticSegmentRomStart;
dmaMb.size = rsp_static_len;
osEPiStartDma(handler, &dmaMb, OS_READ);
osRecvMesg(&DMAMessageQ, NULL, OS_MESG_BLOCK); /* Wait for completion */
/*
* Do the one-time setup
* (Build both display lists)
*/
makestuff();
/*
* Run the main loop of the game
*/
gameloop(rsp_static_addr);
} /* gameproc */
/*
* Conroller read thread
*/
void controllerProc(void *arg)
{
int i;
u16 button;
static u16 lastbutton[MAXCONTROLLERS];
static int cnt;
OSMesgQueue msgQ;
OSMesg msgbuf[MAX_MESGS];
NNScClient client;
/* create message queue */
osCreateMesgQueue(&msgQ, msgbuf, MAX_MESGS);
/* add client to scheduler */
nnScAddClient((NNSched*)arg, &client, &msgQ);
while(1){
(void)osRecvMesg(&msgQ,NULL, OS_MESG_BLOCK);
controllerReadStart();
(void)osRecvMesg(&controllerMsgQ, NULL, OS_MESG_BLOCK);
osContGetReadData(controllerdata);
for (i=0; i<numControllers; i++) {
button = controllerdata_ptr[i]->button;
controllerdataTriger[i].button =
button & (~lastbutton[i]);
lastbutton[i]=button;
}
}
}
/*-----------------------------------------------------------------------------
Graphic thread
-----------------------------------------------------------------------------*/
void gfxproc(void* arg)
{
short* msg_type = NULL;
pendingGFX = 0;
/* create message queue for VI retrace */
osCreateMesgQueue(&gfx_msgQ, gfx_msgbuf, GFX_MESGS_MAX);
nnScAddClient((NNSched*)arg, &gfx_client, &gfx_msgQ);
/* Get graphic message queue */
sched_gfxMQ = nnScGetGfxMQ((NNSched*)arg);
/*
Graphic process loop
The NMI(V-SYNC) process portion of SHVC
*/
while(1){
(void)osRecvMesg(&gfx_msgQ,(OSMesg *)&msg_type, OS_MESG_BLOCK);
switch(*msg_type){
case NN_SC_RETRACE_MSG: /* retrace message process */
switch(graphic_no){
case GFX_00: /*controller model screen */
if(pendingGFX <2){
graphic_00();
pendingGFX++;
}
break;
case GFX_01: /* fighter plane screen */
case GFX_10:
case GFX_20:
case GFX_30:
case GFX_NULL:
break;
}
break;
case NN_SC_DONE_MSG: /* end graphic task message */
pendingGFX--;
break;
case NN_SC_PRE_NMI_MSG: /* PRE NMI message */
/* please write a PRE NMI message process here */
/* !! Important !! Reset Y scale to 1.0 */
osViSetYScale(1.0);
/* so no task is created */
pendingGFX+=2;
break;
}
}
}
/*
* This is the main routine of the app.
*/
static void
mainproc(void *arg)
{
/*
* Setup the message queues
*/
osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, 1);
osCreateMesgQueue(&rspMessageQ, &rspMessageBuf, 1);
osSetEventMesg(OS_EVENT_SP, &rspMessageQ, NULL);
osCreateMesgQueue(&rdpMessageQ, &rdpMessageBuf, 1);
osSetEventMesg(OS_EVENT_DP, &rdpMessageQ, NULL);
osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
osViSetEvent(&retraceMessageQ, NULL, 1);
/*
* Stick the static segment right after the code/data segment
*/
staticSegment = _zbufferSegmentEnd;
osPiStartDma(&dmaIOMessageBuf, OS_MESG_PRI_NORMAL, OS_READ,
(u32) _staticSegmentRomStart, staticSegment,
(u32) _staticSegmentRomEnd - (u32) _staticSegmentRomStart,
&dmaMessageQ);
/*
* Wait for DMA to finish
*/
(void) osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);
freeSegment = staticSegment +
(u32) _staticSegmentRomEnd - (u32) _staticSegmentRomStart;
initControllers(MAXCONTROLLERS);
game();
}
/*---------------------------------------------------------------------*
* IDLE THREAD (Pri.= 0)
*---------------------------------------------------------------------*/
static void idle(void *arg)
{
/*
* Initialize Vi manager
*/
osCreateViManager(OS_PRIORITY_VIMGR);
osViSetMode(&osViModeTable[OS_VI_NTSC_HPF1]);
/*
* Initialize Pi manager
*/
osCreatePiManager((OSPri)OS_PRIORITY_PIMGR,
&PiMessageQ, PiMessages, NUM_PI_MSGS);
#ifdef _DEBUG
/*
* Create & start RMON thread
*/
osCreateThread(&rmonThread, 0, rmonMain, (void *)0,
(void *)(rmonThreadStack+RMON_STACKSIZE/8),
(OSPri)OS_PRIORITY_RMON );
osStartThread(&rmonThread);
#endif
/*
* Setup message queue
*/
osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
osViSetEvent(&retraceMessageQ, NULL, 1); /* retrace */
/*
* Create & start MAINPROC thread
*/
osCreateThread(&mainThread, TID_MAINPROC, mainproc, (void *)0,
(void *)(mainThreadStack+STACKSIZE/8), 10);
#ifndef DEBUG
osStartThread(&mainThread);
#endif
/*
* Now idling
*/
osSetThreadPri(0, 0);
for(;;);
}
/**********************************************************************
*
* Routine for initializing the controllers. After initialized, set the
* controller interrupt to be posted to the gfxFrameMsgQ, used by the
* gameproc in simple.c.
*
*********************************************************************/
void initCntrl(void)
{
OSMesgQueue serialMsgQ;
OSMesg serialMsg;
s32 i;
osCreateMesgQueue(&serialMsgQ, &serialMsg, 1);
osSetEventMesg(OS_EVENT_SI, &serialMsgQ, (OSMesg)1);
if((i = osContInit(&serialMsgQ, &validcontrollers, &statusdata[0])) != 0)
PRINTF("Failure initing controllers\n");
/**** Set up message and queue, for read completion notification ****/
controllermsg.type = SIMPLE_CONTROLLER_MSG;
osSetEventMesg(OS_EVENT_SI, &gfxFrameMsgQ, (OSMesg)&controllermsg);
}
void mainproc(void *arg)
{
/* Create Message Queue */
osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, 1);
osCreateMesgQueue(&rspMessageQ, &rspMessageBuf, 1);
osCreateMesgQueue(&rspBrkMessageQ, &rspBrkMessageBuf, 1);
osCreateMesgQueue(&rdpMessageQ, &rdpMessageBuf, 1);
osCreateMesgQueue(&siMessageQ, &siMessageBuf, 1);
osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
/* Connect Event to Message Queue */
osSetEventMesg(OS_EVENT_SP, &rspMessageQ, NULL);
osSetEventMesg(OS_EVENT_SP_BREAK, &rspBrkMessageQ, NULL);
osSetEventMesg(OS_EVENT_DP, &rdpMessageQ, NULL);
osSetEventMesg(OS_EVENT_SI, &siMessageQ, NULL);
osViSetEvent(&retraceMessageQ, NULL, 1);
/* Initialize Controller */
osContInit(&siMessageQ, &contExist, contStatus);
/* Call Main Function */
Main(arg);
}
/*--------------------------
main01 test stage
return: next stage no
--------------------------*/
int main01(NNSched* sched)
{
OSMesgQueue msgQ;
OSMesg msgbuf[MAX_MESGS];
NNScClient client;
u32 controller_num;
u32 endflag;
u32 cnt;
if(numControllers > 2){
controller_num = 2;
} else {
controller_num = numControllers;
}
/* create message queue for VI retrace */
osCreateMesgQueue(&msgQ, msgbuf, MAX_MESGS);
/* add client to scheduler */
nnScAddClient(sched, &client, &msgQ);
/* initialize game subject parameters */
InitFiter(&fiter[0]); /* #1 machine */
fiter[0].pos.x = 45.0;
fiter[0].dlist_ptr = fiter_1_dl; /*set display list */
fiter[0].dlist_buf = (Gfx*)gfx_dlist_buf[0]; /* display list buffer */
/* read display list */
auRomRead((u32)_fiter1SegmentRomStart, gfx_dlist_buf[0],
(u32)_fiter1SegmentRomEnd - (u32)_fiter1SegmentRomStart);
InitFiter(&fiter[1]); /* #2 machine */
fiter[1].pos.x = 360.0-45.0;
fiter[1].dlist_ptr = fiter_2_dl; /* set display list */
fiter[1].dlist_buf = (Gfx*)gfx_dlist_buf[1]; /* display list buffer */
/* read display list */
auRomRead((u32)_fiter2SegmentRomStart, gfx_dlist_buf[1],
(u32)_fiter2SegmentRomEnd - (u32)_fiter2SegmentRomStart);
/* viewpoint settings */
lookat.eye_x = 00.0;
lookat.eye_y = 0.0;
lookat.eye_z = -20.0;
lookat.at_x = 0.0;
lookat.at_y = 0.0;
lookat.at_z = 0.0;
lookat.up_x = 0.0;
lookat.up_y = 1.0;
lookat.up_z = 0.0;
lookat.pitch = 5.0;
lookat.yaw = 0.0;
lookat.roll = 0.0;
lookat.dist = -40.0;
/* read sequence data */
auSeqPlayerSetFile(1,0);
auSeqPlayerPlay(1);
/* start graphic display */
graphic_no = GFX_01;
endflag =0;
while(!endflag){
(void) osRecvMesg(&msgQ, NULL, OS_MESG_BLOCK);
for(cnt = 0; cnt < controller_num; cnt++){
fiter_move(&fiter[cnt],cnt);
lookat_move(cnt);
/* end on Start button push */
if(controllerdataTriger[cnt].button & START_BUTTON){
endflag++;
}
/* raise priority of graphic thread */
if(controllerdata_ptr[cnt]->button & Z_TRIG){
threadpri_flag = 1;
} else {
threadpri_flag = 0;
}
}
}
/* stop sequence */
auSeqPlayerStop(1);
graphic_no = GFX_NULL;
/* wait for end of graphic task /audio task */
while((auSeqPlayerState(0) != AL_STOPPED) || (pendingGFX != 0)){
(void) osRecvMesg(&msgQ, NULL, OS_MESG_BLOCK);
};
/* remove client to scheduler */
nnScRemoveClient(sched, &client);
return MAIN_00;
}
void
mainproc(void *arg)
{
int i, j;
int cont_no = 0;
int error, readerror;
u8 bitpattern;
u16 button = 0, oldbutton = 0, newbutton = 0;
u32 stat;
char console_text[50];
osCreateMesgQueue(&pifMesgQueue, pifMesgBuf, NUM_MESSAGE);
osSetEventMesg(OS_EVENT_SI, &pifMesgQueue, dummyMessage);
osContInit(&pifMesgQueue, &bitpattern, &contstat[0]);
for (i = 0; i < MAXCONTROLLERS; i++) {
if ((bitpattern & (1<<i)) &&
((contstat[i].type & CONT_TYPE_MASK) == CONT_TYPE_NORMAL)) {
controller[i] = CONT_VALID;
} else {
controller[i] = CONT_INVALID;
}
}
osCreateMesgQueue(&dmaMessageQ, dmaMessageBuf, 1);
pi_handle = osCartRomInit();
pi_ddrom_handle = osDriveRomInit();
bzero(blockData, 0x1000);
readerror = -1;
init_draw();
setcolor(0,255,0);
draw_puts("If you see this for a long period of time,\nsomething f****d up. Sorry.");
LeoCJCreateLeoManager((OSPri)OS_PRIORITY_LEOMGR-1, (OSPri)OS_PRIORITY_LEOMGR, LeoMessages, NUM_LEO_MESGS);
LeoResetClear();
setbgcolor(15,15,15);
clear_draw();
setcolor(0,255,0);
draw_puts("\f\n 64DD IPL dumper v0.01b by LuigiBlood & marshallh\n ----------------------------------------\n");
setcolor(255,255,255);
draw_puts(" PRESS START TO DUMP");
while(1) {
osContStartReadData(&pifMesgQueue);
osRecvMesg(&pifMesgQueue, NULL, OS_MESG_BLOCK);
osContGetReadData(&contdata[0]);
if (contdata[cont_no].errno & CONT_NO_RESPONSE_ERROR) {
button = oldbutton;
} else {
oldbutton = button;
button = contdata[cont_no].button;
}
newbutton = ~oldbutton & button;
if (newbutton & START_BUTTON)
{
//DUMP!!
//64drive, enable write to SDRAM/ROM
srand(osGetCount()); // necessary to generate unique short 8.3 filenames on memory card
ciEnableRomWrites();
draw_puts("\f\n\n\n\n\n Let's dump! Don't turn off the console!\n\n");
osInvalDCache((void *)&blockData, (s32) 0x1000);
dmaIoMesgBuf.hdr.pri = OS_MESG_PRI_NORMAL;
dmaIoMesgBuf.hdr.retQueue = &dmaMessageQ;
dmaIoMesgBuf.dramAddr = &blockData;
dmaIoMesgBuf.devAddr = IPLoffset;
dmaIoMesgBuf.size = 0x1000;
for (IPLoffset = 0; IPLoffset < 0x400000; IPLoffset += 0x1000)
{
//read 64DD IPL
osWritebackDCacheAll();
dmaIoMesgBuf.hdr.pri = OS_MESG_PRI_NORMAL;
dmaIoMesgBuf.hdr.retQueue = &dmaMessageQ;
dmaIoMesgBuf.dramAddr = (void *)&blockData;
dmaIoMesgBuf.devAddr = 0xA6000000 + IPLoffset;
dmaIoMesgBuf.size = 0x1000;
osEPiStartDma(pi_ddrom_handle, &dmaIoMesgBuf, OS_READ);
osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);
//Write to 64drive
osWritebackDCacheAll();
dmaIoMesgBuf.hdr.pri = OS_MESG_PRI_NORMAL;
dmaIoMesgBuf.hdr.retQueue = &dmaMessageQ;
dmaIoMesgBuf.dramAddr = (void *)&blockData;
dmaIoMesgBuf.devAddr = 0xB0000000 + IPLoffset;
dmaIoMesgBuf.size = 0x1000;
osEPiStartDma(pi_handle, &dmaIoMesgBuf, OS_WRITE);
osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);
}
//DONE!! NOW WRITE TO SD
fat_start();
draw_puts("\n - DONE !!\n");
for(;;);
}
}
}
/*
* This is the main routine of the app.
*/
static void
mainproc(void *arg)
{
#ifdef DEBUG
int i;
char *ap;
u32 *argp;
/*
* get arguments (options)
*/
argp = (u32 *) RAMROM_APP_WRITE_ADDR;
for (i = 0; i < sizeof(argbuf) / 4; i++, argp++) {
osEPiReadIo(handler, (u32) argp, &argbuf[i]); /* Assume no DMA */
}
((char *) argbuf)[sizeof(argbuf)-1] = '\0';
/*
* Parse the options
*/
ap = (char *) argbuf;
position_str = (char *) 0;
while (*ap != '\0') {
while (*ap == ' ')
ap++;
if (*ap == '-' && *(ap + 1) == 'r') {
rdp_flag = 1;
ap += 2;
} else if (*ap == '-' && *(ap + 1) == 'i') {
ap += 2;
position_str = ap;
break; /* -i must be last argument */
} else ap++;
}
#endif
/*
* Setup the message queues
*/
osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, 1);
osCreateMesgQueue(&rdpMessageQ, &rdpMessageBuf, 1);
osSetEventMesg(OS_EVENT_DP, &rdpMessageQ, NULL);
osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
osViSetEvent(&retraceMessageQ, NULL, 1);
/*
* Stick the static segment right after the code/data segment
*/
staticSegment = _zbufferSegmentEnd;
dmaIOMessageBuf.hdr.pri = OS_MESG_PRI_NORMAL;
dmaIOMessageBuf.hdr.retQueue = &dmaMessageQ;
dmaIOMessageBuf.dramAddr = staticSegment;
dmaIOMessageBuf.devAddr = (u32)_staticSegmentRomStart;
dmaIOMessageBuf.size = (u32)_staticSegmentRomEnd-(u32)_staticSegmentRomStart;
osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
/*
* Wait for DMA to finish
*/
(void) osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);
/*
* Stick the texture segment right after the static segment
*/
textureSegment = staticSegment +
(u32) _staticSegmentRomEnd - (u32) _staticSegmentRomStart;
dmaIOMessageBuf.hdr.pri = OS_MESG_PRI_NORMAL;
dmaIOMessageBuf.hdr.retQueue = &dmaMessageQ;
dmaIOMessageBuf.dramAddr = textureSegment;
dmaIOMessageBuf.devAddr = (u32)_textureSegmentRomStart;
dmaIOMessageBuf.size = (u32)_textureSegmentRomEnd-(u32)_textureSegmentRomStart;
osEPiStartDma(handler, &dmaIOMessageBuf, OS_READ);
/*
* Wait for DMA to finish
*/
(void) osRecvMesg(&dmaMessageQ, NULL, OS_MESG_BLOCK);
initControllers(MAXCONTROLLERS);
game();
}