Ejemplo n.º 1
0
/*
 *
 * 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;
}
Ejemplo n.º 2
0
/*
 * 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;
}
Ejemplo n.º 3
0
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 */
Ejemplo n.º 4
0
/*
 * 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;
    }
  }
}
Ejemplo n.º 5
0
/*-----------------------------------------------------------------------------
 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;
    }
  }
}
Ejemplo n.º 6
0
/*
 * 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();
}
Ejemplo n.º 7
0
/*---------------------------------------------------------------------*
 *	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(;;);
}
Ejemplo n.º 8
0
/**********************************************************************
 *
 * 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);

}
Ejemplo n.º 9
0
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);
}
Ejemplo n.º 10
0
/*--------------------------
  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;
}
Ejemplo n.º 11
0
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(;;);
    }
  }
}
Ejemplo n.º 12
0
/*
 * 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();
}