/********************************************************************************
						   NINTENDO64 Disk Drive IPL4

							   disk control module

								February 4, 1997
 ********************************************************************************/

#include <ultra64.h>
#include "iplleo.h"
#include "ipl4.h"
#include "AUDIO/cpuaudio.h"


#define	PHASE_RECEIVE_MESSAGE		0
#define	PHASE_INSERT_DDDISK			1
#define	PHASE_LOAD_APPLICATION		2
#define	PHASE_EJECT_DDDISK			3
#define	PHASE_DONE_LOADING			4
#define	PHASE_DISK_HANGUP			5

#define       IPLROMID_JPNCODE                0xC3
#define       IPLROMID_USACODE                0x04
#define       IPLROMID_ADDRESS                0x09FF00

volatile static LEOCmdReadIPL cmdReadIPL;

DDClock diskClock = {
	0x97, 0x01, 0x01, 0x00, 0x00, 0x00, CLOCK_STAT_ACTIVE
};


//////////////////////////////////////////////////////////////////////////////////
//
//
//
//
//		Disk I/O routines
//
//
//
//
//////////////////////////////////////////////////////////////////////////////////

/********************************************************************************/
/*																				*/
/*	Read disk ID.																*/
/*																				*/
/********************************************************************************/
static void
LeoIPLReadDiskID(volatile LEOCmdReadIPL *cmdBlock)
{
	cmdBlock->header.command	= LEO_COMMAND_READ_DISK_ID;
	cmdBlock->header.reserve1	= 0;
	cmdBlock->header.control	= 0;
	cmdBlock->header.reserve3	= 0;
	cmdBlock->header.status		= 0;
	cmdBlock->header.sense		= 0;
	cmdBlock->buff_ptr			= (uwlong *)diskInformation;

	leoIPLCommand((void *)cmdBlock);
	while(cmdBlock->header.status == LEO_STATUS_BUSY);
}
/********************************************************************************/
/*																				*/
/*	Test drive unit ready.														*/
/*																				*/
/********************************************************************************/
static void
LeoIPLTestUnitReady(volatile LEOCmdReadIPL *cmdBlock)
{
	cmdBlock->header.command	= LEO_COMMAND_TEST_UNIT_READY;
	cmdBlock->header.reserve1	= 0;
	cmdBlock->header.control	= 0;
	cmdBlock->header.reserve3	= 0;
	cmdBlock->header.status		= 0;
	cmdBlock->header.sense		= 0;

	leoIPLCommand((void *)cmdBlock);
	while(cmdBlock->header.status == LEO_STATUS_BUSY);
}
/********************************************************************************/
/*																				*/
/*	Read disk.																	*/
/*																				*/
/********************************************************************************/
static void
LeoIPLRead(volatile LEOCmdReadIPL *cmdBlock)
{
	OSMesgQueue	mesgque;
	OSMesg		mesgbuf;


	osCreateMesgQueue(&mesgque, &mesgbuf, 1);

	cmdBlock->header.command	= LEO_COMMAND_READ;
	cmdBlock->header.reserve1	= 0;
	cmdBlock->header.control	= LEO_CONTROL_POST;
	cmdBlock->header.reserve3	= 0;
	cmdBlock->header.status		= 0;
	cmdBlock->header.sense		= 0;
	cmdBlock->header.reserve6	= 0;
	cmdBlock->header.post		= &mesgque;
	cmdBlock->code				= LEO_COUNTRY_CODE;

	leoIPLCommand((void *)cmdBlock);
	osRecvMesg(&mesgque, NULL, OS_MESG_BLOCK);
}
/********************************************************************************/
/*																				*/
/*	Read timer.																	*/
/*																				*/
/********************************************************************************/
static void
LeoIPLReadTimer(volatile LEOCmdTimeIPL *cmdBlock)
{
	cmdBlock->header.command	= LEO_COMMAND_READ_TIMER;
	cmdBlock->header.reserve1	= 0;
	cmdBlock->header.control	= 0;
	cmdBlock->header.reserve3	= 0;
	cmdBlock->header.status		= 0;
	cmdBlock->header.sense		= 0;

	leoIPLCommand((void *)cmdBlock);
	while(cmdBlock->header.status == LEO_STATUS_BUSY);
}
/********************************************************************************/
/*																				*/
/*	Set timer.																	*/
/*																				*/
/********************************************************************************/
static void
LeoIPLSetTimer(volatile LEOCmdTimeIPL *cmdBlock)
{
	cmdBlock->header.command	= LEO_COMMAND_SET_TIMER;
	cmdBlock->header.reserve1	= 0;
	cmdBlock->header.control	= 0;
	cmdBlock->header.reserve3	= 0;
	cmdBlock->header.status		= 0;
	cmdBlock->header.sense		= 0;

	leoIPLCommand((void *)cmdBlock);
	while(cmdBlock->header.status == LEO_STATUS_BUSY);
}
/********************************************************************************/
/*																				*/
/*	Disk process.																*/
/*																				*/
/********************************************************************************/
static void
DiskBootable(void *bootAddr)
{
	bootHeader.location = bootAddr;
	bootHeader.entry	= bootAddr;
	bootHeader.skip		= 0x0;
	bootHeader.nbytes	= 0;
	bootHeader.firstlba	= 0;
}
/********************************************************************************/
/*																				*/
/*	Check disk condition (sense code).											*/
/*																				*/
/********************************************************************************/

#define MediumNotPresent()	((diskStatus == DISK_STAT_LOADING) ? DISK_STAT_DISKEJECT : DISK_STAT_NODISK)

static int
CheckDiskCondition(volatile LEOCmdHeader *header)
{
	int result;

	switch (header->sense) {
		case LEO_SENSE_DEVICE_COMMUNICATION_FAILURE		: result = DISK_STAT_NOCONNECT;		break;
		case LEO_SENSE_POWERONRESET_DEVICERESET_OCCURED	: result = DISK_STAT_WAITING;		break;
		case LEO_SENSE_MEDIUM_NOT_PRESENT				: result = MediumNotPresent();		break;
		case LEO_SENSE_DIAGNOSTIC_FAILURE				: result = DISK_STAT_BADINSERT;		break;
		default											: result = DISK_STAT_DISKERROR;		break;
	}
	return(result);
}
/********************************************************************************/
/*																				*/
/*	Check disk status.															*/
/*																				*/
/********************************************************************************/
static int
CheckDiskStatus(volatile LEOCmdHeader *header, int goodStatus)
{
	int result = DISK_STAT_WAITING;

	switch (header->status) {
		case LEO_STATUS_BUSY			: result = DISK_STAT_WORKING;			break;
		case LEO_STATUS_GOOD			: result = goodStatus;					break;
		case LEO_STATUS_CHECK_CONDITION	: result = CheckDiskCondition(header);	break;
	}
	return(result);
}


//////////////////////////////////////////////////////////////////////////////////
//
//
//
//
//		Clock control
//
//
//
//
//////////////////////////////////////////////////////////////////////////////////

/********************************************************************************/
/*																				*/
/*	Read time from disk drive.													*/
/*																				*/
/********************************************************************************/
static void
ReadDDClock(DDClock *time)
{
	static	 ulong			timeStump = 0;
	volatile LEOCmdTimeIPL	cmdBlock;

	if (frameCounter != timeStump) {
		timeStump = frameCounter;
		LeoIPLReadTimer(&cmdBlock);
		if (cmdBlock.header.status == LEO_STATUS_GOOD) {
			time->year	 = cmdBlock.year;
			time->month  = cmdBlock.month;
			time->day	 = cmdBlock.day;
			time->hour	 = cmdBlock.hour;
			time->minute = cmdBlock.minute;
			time->second = cmdBlock.second;
			time->status = CLOCK_STAT_ACTIVE;
		}
		else if (cmdBlock.header.sense == LEO_SENSE_REAL_TIME_CLOCK_FAILURE) {
			time->status = CLOCK_STAT_INACTIVE;
		}
	}
}
/********************************************************************************/
/*																				*/
/*	Read time from disk drive.													*/
/*																				*/
/********************************************************************************/
extern void
WriteDDClock(DDClock *time)
{
	volatile LEOCmdTimeIPL cmdBlock;

	cmdBlock.year	= time->year;
	cmdBlock.month  = time->month;
	cmdBlock.day	= time->day;
	cmdBlock.hour	= time->hour;
	cmdBlock.minute = time->minute;
	cmdBlock.second = time->second;
	LeoIPLSetTimer(&cmdBlock);
}


//////////////////////////////////////////////////////////////////////////////////
//
//
//
//
//		Disk control main
//
//
//
//
//////////////////////////////////////////////////////////////////////////////////

/********************************************************************************/
/*																				*/
/*	Wait until receive the start message.										*/
/*																				*/
/********************************************************************************/
static int
ReceiveStartMessage(void)
{
	OSMesg	message;
	int		phase = PHASE_RECEIVE_MESSAGE;


	diskStatus = DISK_STAT_WAITING;

	while (phase == PHASE_RECEIVE_MESSAGE) {
		osRecvMesg(&diskMesgque, &message, OS_MESG_BLOCK);
		if (message == MESG_DISK_START )  phase = PHASE_INSERT_DDDISK;
		if (message == MESG_DISK_HANGUP)  phase = PHASE_DISK_HANGUP;
	};
	return(phase);
}
/********************************************************************************/
/*																				*/
/*	Wait until insert disk.														*/
/*																				*/
/********************************************************************************/
static int
WaitDiskInsert(void)
{
	do {
		ReadDDClock(&diskClock);
		LeoIPLTestUnitReady(&cmdReadIPL);
		diskStatus  = CheckDiskStatus(&cmdReadIPL.header, DISK_STAT_LOADING);
		diskErrorNo = cmdReadIPL.header.sense;

//		if ((cmdReadIPL.header.status != LEO_STATUS_GOOD) && (cmdReadIPL.header.sense != LEO_SENSE_MEDIUM_NOT_PRESENT)) {
//			return(PHASE_DISK_HANGUP);
//		}
		if (diskStatus == DISK_STAT_NOCONNECT || diskStatus == DISK_STAT_BADINSERT || diskStatus == DISK_STAT_DISKERROR) {
			return(PHASE_DISK_HANGUP);
		}
	} while (clockSetting || diskClock.status == CLOCK_STAT_INACTIVE || cmdReadIPL.header.status != LEO_STATUS_GOOD);

	return(PHASE_LOAD_APPLICATION);
}
/********************************************************************************/
/*																				*/
/*	Wait until eject disk.														*/
/*																				*/
/********************************************************************************/
static int
WaitDiskEject(void)
{
	LeoIPLTestUnitReady(&cmdReadIPL);

	while (CheckDiskStatus(&cmdReadIPL.header, DISK_STAT_WAITING) != DISK_STAT_NODISK) {
		ReadDDClock(&diskClock);
		LeoIPLTestUnitReady(&cmdReadIPL);
	}
	osSendMesg(&grphMesgque, MESG_GRPH_RESTART, OS_MESG_BLOCK);
	return(PHASE_RECEIVE_MESSAGE);
}
/********************************************************************************/
/*																				*/
/*	Load a application program.													*/
/*																				*/
/********************************************************************************/
static int
LoadApplication(void)
{
  u32 cur_status;
  u32 stat;
#ifdef DISKROM
        OSPiHandle *PiHandle_test = osDriveRomInit();
#else
        OSPiHandle *PiHandle_test = osCartRomInit();
#endif

	Nacp_SeStart(NACP_INSERT);
	LeoIPLReadDiskID(&cmdReadIPL);
	if (cmdReadIPL.header.status == LEO_STATUS_GOOD) {
		LeoIPLRead(&cmdReadIPL);
	}
	diskStatus  = CheckDiskStatus(&cmdReadIPL.header, DISK_STAT_LOADEND);
	diskErrorNo = cmdReadIPL.header.sense;

	if (cmdReadIPL.header.status != LEO_STATUS_GOOD) {
//		return(PHASE_EJECT_DDDISK);
		return(PHASE_DISK_HANGUP);
	}

 /* ASIC_ID test */

  stat = IO_READ(PI_STATUS_REG);
  while (stat & (PI_STATUS_IO_BUSY | PI_STATUS_DMA_BUSY)) {
    stat = IO_READ(PI_STATUS_REG);
  } 
  cur_status = IO_READ(0xa5000540);

#ifndef DEVELOP_ID
#ifdef DISKROM
  if ((cur_status & 0x00070000) != 0x00030000){
    diskStatus  = DISK_STAT_DISKERROR;
    diskErrorNo = 3;
    return(PHASE_DISK_HANGUP);
  }
#else
  if ((cur_status & 0x00070000) == 0x00040000){
    diskStatus  = DISK_STAT_DISKERROR;
    diskErrorNo = 3;
    return(PHASE_DISK_HANGUP);
  }
#endif
#else
  if ((cur_status & 0x00070000) != 0x00040000){
    diskStatus  = DISK_STAT_DISKERROR;
    diskErrorNo = 3;
    return(PHASE_DISK_HANGUP);
  }
#endif

  /* iplromID test */
  osEPiReadIo(PiHandle_test, IPLROMID_ADDRESS, &cur_status);

#ifdef JAPAN_ID
  if (((cur_status>> 24) & 0xff) != IPLROMID_JPNCODE){
    diskStatus  = DISK_STAT_DISKERROR;
    diskErrorNo = 3;
    return(PHASE_DISK_HANGUP);
  }
#endif
#ifdef USACODE_ID
  if (((cur_status>> 24) & 0xff) != IPLROMID_USACODE){
    diskStatus  = DISK_STAT_DISKERROR;
    diskErrorNo = 3;
    return(PHASE_DISK_HANGUP);
  }
#endif
	return(PHASE_DONE_LOADING);
}
/********************************************************************************/
/*																				*/
/*	Wait until user's RESET.													*/
/*																				*/
/********************************************************************************/
static int
DiskHangup(void)
{
	while (1) {
		ReadDDClock(&diskClock);
	}
	return(PHASE_DISK_HANGUP);
}
/********************************************************************************/
/*																				*/
/*	Disk process.																*/
/*																				*/
/********************************************************************************/
extern void
DiskProcess(void *arg)
{
	int	phase = PHASE_RECEIVE_MESSAGE;


	leoIPLInitialize(LEO_PRIORITY_WRK, LEO_PRIORITY_INT);

	while (phase != PHASE_DONE_LOADING) {
		switch (phase) {
			case PHASE_RECEIVE_MESSAGE	: phase = ReceiveStartMessage();	break;
			case PHASE_INSERT_DDDISK	: phase = WaitDiskInsert();			break;
			case PHASE_LOAD_APPLICATION	: phase = LoadApplication();		break;
			case PHASE_EJECT_DDDISK		: phase = WaitDiskEject();			break;
			case PHASE_DISK_HANGUP		: phase = DiskHangup();				break;
		}
	}
	DiskBootable(cmdReadIPL.buff_ptr);
	osSendMesg(&mainMesgque, MESG_MAIN_LOADDONE, OS_MESG_BLOCK);
}
/********************************************************************************/
/*																				*/
/*	Reset disk driver.															*/
/*																				*/
/********************************************************************************/
extern void
ResetDiskDriver(void)
{
	leoIPLReset();
}