/*====================================================================
 * 
 * Copyright 1995, Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics,
 * Inc.; the contents of this file may not be disclosed to third
 * parties, copied or duplicated in any form, in whole or in part,
 * without the prior written permission of Silicon Graphics, Inc.
 *
 * RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to
 * restrictions as set forth in subdivision (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS
 * 252.227-7013, and/or in similar or successor clauses in the FAR,
 * DOD or NASA FAR Supplement. Unpublished - rights reserved under the
 * Copyright Laws of the United States.
 *====================================================================*/
 
#include <ultralog.h>
#include "sched.h"


/*
 * OSScTask->flags type identifier
 */
#define OS_SC_XBUS      (OS_SC_NEEDS_RSP | OS_SC_NEEDS_RDP)
#define OS_SC_DRAM      (OS_SC_NEEDS_RSP | OS_SC_NEEDS_RDP | OS_SC_DRAM_DLIST)
#define OS_SC_DP_XBUS   (OS_SC_NEEDS_RSP)
#define OS_SC_DP_DRAM   (OS_SC_NEEDS_RSP | OS_SC_DRAM_DLIST)
#define OS_SC_SP_XBUS   (OS_SC_NEEDS_RDP)
#define OS_SC_SP_DRAM   (OS_SC_NEEDS_RDP | OS_SC_DRAM_DLIST)

/*
 * private functions
 */
static void     __scMain(void *arg);
static void     __scHandleRSP(OSSched *s);
static void     __scHandleRDP(OSSched *s);
static void     __scCheckTasks(OSSched *sc);
static void     __scExecAudio(OSSched *sc);
static void     __scExecGFX(OSSched *sc);

static void     __scAppendList(OSSched *s, OSScTask *t);
OSScTask        *__scTaskReady(OSScTask *t);
static s32      __scTaskComplete(OSSched *s,OSScTask *t);
static void	__scYield(OSSched *s);


extern u32 dbgOn;
void sendDbg(u32 dbgVal);

/***********************************************************************
 * Scheduler API
 **********************************************************************/
void osCreateScheduler(OSSched *sc, void *stack, OSPri priority,
                       u8 mode, u8 numFields)
{
    sc->curRSPTask      = 0;
    sc->curRDPTask      = 0;
    sc->clientList      = 0;
    sc->audClient       = 0;
    sc->frameCount      = 0;
    sc->audioListHead   = 0;
    sc->gfxListHead     = 0;
    sc->audioListTail   = 0;
    sc->gfxListTail     = 0;
    sc->audioMsg.type   = OS_SC_AUDIO_MSG;
    sc->retraceMsg.type = OS_SC_RETRACE_MSG;  /* sent to apps */
    sc->prenmiMsg.type  = OS_SC_PRE_NMI_MSG;
    
    osCreateMesgQueue(&sc->interruptQ, sc->intBuf, OS_SC_MAX_MESGS);
    osCreateMesgQueue(&sc->cmdQ, sc->cmdMsgBuf, OS_SC_MAX_MESGS);

    /*
     * Set up video manager, listen for Video, RSP, and RDP interrupts
     */
    osCreateViManager(OS_PRIORITY_VIMGR);    
    osViSetMode(&osViModeTable[mode]);
    osViBlack(TRUE);
    osSetEventMesg(OS_EVENT_AI, &sc->interruptQ, (OSMesg)AUDIO_MSG);
    osSetEventMesg(OS_EVENT_SP, &sc->interruptQ, (OSMesg)RSP_DONE_MSG);
    osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, (OSMesg)RDP_DONE_MSG);    
    osSetEventMesg(OS_EVENT_PRENMI, &sc->interruptQ, (OSMesg)PRE_NMI_MSG);    

    osViSetEvent(&sc->interruptQ, (OSMesg)VIDEO_MSG, numFields);    

    osCreateThread(&sc->thread, 4, __scMain, (void *)sc, stack, priority);
    osStartThread(&sc->thread);
}

/*
 * Add a client to the scheduler.  Clients receive messages at retrace time
 */
void osScAddClient(OSSched *sc, OSScClient *c, OSMesgQueue *msgQ)
{
    OSIntMask mask;

    mask = osSetIntMask(OS_IM_NONE);

    c->msgQ = msgQ;
    c->next = sc->clientList;
    sc->clientList = c;

    osSetIntMask(mask);
}

void osScRemoveClient(OSSched *sc, OSScClient *c)
{
    OSScClient *client = sc->clientList; 
    OSScClient *prev   = 0;
    OSIntMask  mask;

    mask = osSetIntMask(OS_IM_NONE);
    
    while (client != 0) {
        if (client == c) {
	    if(prev)
		prev->next = c->next;
	    else
		sc->clientList = c->next;
            break;
        }
        prev   = client;
        client = client->next;
    }

    osSetIntMask(mask);
}

void osScAddAudioClient(OSSched *sc, OSScClient *c, OSMesgQueue *msgQ)
{
    OSIntMask mask;

    mask = osSetIntMask(OS_IM_NONE);

    c->msgQ = msgQ;
    c->next = sc->audClient;
    sc->audClient = c;

    osSetIntMask(mask);
}

void osScRemoveAudioClient(OSSched *sc, OSScClient *c)
{
    OSScClient *client = sc->audClient; 
    OSScClient *prev   = 0;
    OSIntMask  mask;

    mask = osSetIntMask(OS_IM_NONE);
    
    while (client != 0) {
        if (client == c) {
	    if(prev)
		prev->next = c->next;
	    else
		sc->audClient = c->next;
            break;
        }
        prev   = client;
        client = client->next;
    }

    osSetIntMask(mask);
}

OSMesgQueue *osScGetCmdQ(OSSched *sc)
{
    return &sc->cmdQ;
}

OSMesgQueue *osScGetIntQ(OSSched *sc)
{
    return &sc->interruptQ;
}

/***********************************************************************
 * Scheduler implementation
 **********************************************************************/
static void __scMain(void *arg)
{
    OSScTask    *rspTask;
    OSMesg      msg;
    OSSched *sc = (OSSched *)arg;
    OSScClient  *client;
    
    while (1) {
        
	
        osRecvMesg(&sc->interruptQ, (OSMesg *)&msg, OS_MESG_BLOCK);

	if((int)msg == RSP_DONE_MSG)
	    __scHandleRSP(sc);

	else if((int)msg == RDP_DONE_MSG)
	    __scHandleRDP(sc);

	/* Read the task command queue and schedule tasks */
	while (osRecvMesg(&sc->cmdQ, (OSMesg *)&rspTask, OS_MESG_NOBLOCK) != -1)
	    __scAppendList(sc, rspTask);

	__scCheckTasks(sc);
	if((int)msg == AUDIO_MSG)
	    for (client = sc->audClient; client != 0; client = client->next) 
		osSendMesg(client->msgQ, (OSMesg) &sc->audioMsg, OS_MESG_NOBLOCK);
	else if((int)msg == VIDEO_MSG)
	    for (client = sc->clientList; client != 0; client = client->next) 
		osSendMesg(client->msgQ, (OSMesg) &sc->retraceMsg, OS_MESG_NOBLOCK);
	else if((int)msg == PRE_NMI_MSG)
	{
	    for (client = sc->audClient; client != 0; client = client->next) 
		osSendMesg(client->msgQ, (OSMesg) &sc->prenmiMsg, OS_MESG_NOBLOCK);
	    for (client = sc->clientList;client != 0;client = client->next) 
		osSendMesg(client->msgQ, (OSMesg) &sc->prenmiMsg, OS_MESG_NOBLOCK);
        }
    }
}


/***********************************************************************
 * Check to see if you can execute a task
 ***********************************************************************/
void __scCheckTasks(OSSched *sc)
{
    if (sc->doAudio)  /* if there is an audio task pending */
    {
	if(!sc->curRSPTask) /* and the rsp is available */
	    __scExecAudio(sc);
	else
	    __scYield(sc); 
    } 
    else 
    {
	if(!sc->curRSPTask && !sc->curRDPTask)
            __scExecGFX(sc);
    }
}

/*
 * __scHandleRSP is called when an RSP task signals that it has
 * finished or yielded (at the hosts request)
 */
void __scHandleRSP(OSSched *sc)
{
    OSScTask *t;

    t = sc->curRSPTask;
    sc->curRSPTask = 0;
    
    if ((t->state & OS_SC_YIELD) && osSpTaskYielded(&t->list)) 
    {
	t->d.gd.endTicks += osGetTime() - t->d.gd.startTicks; 
	sc->curRDPTask = 0; /* mark it zero, easier for restarting test */
        t->state |= OS_SC_YIELDED;

	/* push the task back on the list */
	t->next = sc->gfxListHead;
	sc->gfxListHead = t;
	if (sc->gfxListTail == 0)
	    sc->gfxListTail = t;

    } 
    else 
    {
         t->state &= ~OS_SC_NEEDS_RSP;
        __scTaskComplete(sc, t);
    }

}

/*
 * __scHandleRDP is called when an RDP task signals that it has
 * finished
 */
void __scHandleRDP(OSSched *sc)
{
    OSScTask *t; 

    t = sc->curRDPTask;
    sc->curRDPTask = 0;
    
    if(t)
    {
	t->state &= ~OS_SC_NEEDS_RDP;
	__scTaskComplete(sc, t);
    }
    else  /* task was yielded with only gSPEndDisplayList left */
    {     /* go ahead and mark it complete */
	t = sc->gfxListHead;
	if(t)
	{
	    sc->gfxListHead = t->next;
	    if(!t->next)
		sc->gfxListTail = 0;
	    t->state = 0;
	    __scTaskComplete(sc,t);
	}
    }
}

/*
 * __scTaskComplete checks to see if the task is complete (all RCP
 * operations have been performed) and sends the done message to the
 * client if it is.
 */
s32 __scTaskComplete(OSSched *sc, OSScTask *t) 
{
    int rv;
    static int firstTime = 1;

    if ((t->state & OS_SC_RCP_MASK) == 0)  /* none of the needs bits set */
    {
	t->d.ud.endTicks += osGetTime() - t->d.ud.startTicks;
        rv = osSendMesg(t->msgQ, t->msg, OS_MESG_BLOCK);

	if (t->list.t.type == M_GFXTASK) 
	{
            if ((t->flags & OS_SC_SWAPBUFFER) && (t->flags & OS_SC_LAST_TASK))
	    {
		if(firstTime)
		{
		    osViBlack(FALSE);
		    firstTime = 0;
		}
                osViSwapBuffer(t->framebuffer);
	    }
	}
        return 1;
    }
    
    return 0;
}



/*
 * Place task on either the audio or graphics queue
 */
void __scAppendList(OSSched *sc, OSScTask *t) 
{
    long type = t->list.t.type;
    
    if (type == M_AUDTASK) 
    {
        if (sc->audioListTail)
            sc->audioListTail->next = t;
        else
            sc->audioListHead = t;
            
        sc->audioListTail = t;
        sc->doAudio++; 
    } 
    else 
    {
	
        if (sc->gfxListTail)
            sc->gfxListTail->next = t;
        else
            sc->gfxListHead = t;
        
	sc->gfxListTail = t;

    }
    
    t->next = NULL;
    t->state = t->flags & OS_SC_RCP_MASK;    
}


static void __scYield(OSSched *sc) 
{
    OSScTask *t = sc->curRSPTask;
    
    if(t)
    {
	if (t->list.t.type == M_GFXTASK) 
	{

	    if(!(t->state & OS_SC_YIELD)) /* don't yield already yielded task */
	    {
		t->state |= OS_SC_YIELD;
		osSpTaskYield();
	    }
	}
    }
}


/*
 * __scTaskReady checks to see if there is a pending video swap
 * if there is, it bails
 */
OSScTask *__scTaskReady(OSScTask *t) 
{
    void *a;
    void *b;    

    if (t) 
    {    
        if ((a=osViGetCurrentFramebuffer()) != (b=osViGetNextFramebuffer())) 
            return 0;
	else
	    return t;
    }

    return 0;
}


void __scExecAudio(OSSched *sc)
{
    OSScTask *t = sc->audioListHead; 

    sc->doAudio--;
    sc->audioListHead = t->next;
    sc->curRSPTask = t; 
    if(t == sc->audioListTail)
	sc->audioListTail = NULL;
    t->state = OS_SC_NEEDS_RSP;

    t->d.ad.startTicks = osGetTime();
    osWritebackDCacheAll();
    osSpTaskLoad(&t->list); 
    osSpTaskStartGo(&t->list); 

}

void __scExecGFX(OSSched *sc)
{	
    OSScTask *t = sc->gfxListHead;

    if(t)
    {
	if(__scTaskReady(t))
	{
	    t->state &= ~(OS_SC_YIELD | OS_SC_YIELDED);
	    t->d.gd.startTicks = osGetTime();
	    sc->curRSPTask = t;
	    sc->curRDPTask = t;
	    sc->gfxListHead = t->next;
	    if(t == sc->gfxListTail)
		sc->gfxListTail = NULL;
	    osSpTaskLoad(&t->list);
	    osSpTaskStartGo(&t->list);

	}
    }
}