/*
 * 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.
 *
 * $Revision: 1.1.1.1 $
 */

#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <bstring.h>
#include <string.h>
#include <getopt.h>

#include <sys/u64gio.h>
#include <libaudio.h>
#include <ramrom.h>
#include <ultrahost.h> 
#include "GioMgr.h"
#include "Assets.h"
#include "Mgrs.h"

/* created by romcvt in rom.c */
extern int    gRomImageSize;
extern char   gRomImage[];


GioMgr::GioMgr()
{
    char  nstr[64];
    
    u64fd = 0;
    sprintf(nstr,"/tmp/AudioEditor.%d.key\n",getuid());
    gioarena = usinit(nstr);
    if(gioarena == NULL)
    {
	perror("Failure creating semaphore arena");
	giosema = 0;
    }
    else
    {
	giosema = usnewsema(gioarena,1);
	if(giosema == NULL)
	    perror("Failure creating semaphore");
    }
}

GioMgr::~GioMgr()
{
    if(u64fd != -1 && u64fd != 0)
    {
	if(close(u64fd) == 0)
	    printf("u64 closed successfully\n");
	else
	    perror("Failure closing u64Device\n");
    }

    if(giosema && gioarena)
	usfreesema(giosema,gioarena);
}

int GioMgr::LoadCode(void)
{
    unsigned int    romOffset = 0;      /* rom will internally offset game to 0x800 */
    u64_write_arg_t arg;

    uspsema(giosema);

    if ((u64fd = open(DEV_U64, O_RDWR | O_NOCTTY)) < 0)
    {
        perror("Unable to open /dev/u64");
	usvsema(giosema);
        return(-1);
    } 

    /* Assert RESET  */
    if ( ioctl(u64fd, U64_RESET, 1) < 0 )
    {
        perror("Error starting U64_RESET ioctl");
	usvsema(giosema);
        return(-1);
    } 

    /* Write the contents of the ROM file into ramrom first.   */
    if (gRomImageSize > RAMROM_SIZE)
    {
        fprintf(stderr, "Codesegment too big! %d bytes\n", gRomImageSize);
	usvsema(giosema);
        return(-1);
    }
    /* Tell the kernel to copyin our data into ramrom.   */
    arg.buffer = (void *)gRomImage;
    arg.ramrom_addr = romOffset;
    arg.nbytes = gRomImageSize;
    arg.value = 0xFFFFFFFF; /* Inhibits acknowledge cycle with game */

    if ( ioctl(u64fd, U64_WRITE, &arg) < 0 )
    {
        perror("Error after U64_WRITE ioctl");
	usvsema(giosema);
        return(-1);
    } 

    /* Release RESET; game will subsequently boot itself. */
    if ( ioctl(u64fd, U64_RESET, 0) < 0 )
    {
        perror("Error after U64_RESET ioctl");
	usvsema(giosema);
        return(-1);
    } 

    close(u64fd);
    usvsema(giosema);
    return (0);
}

int GioMgr::InitAudio(AudioConfig *audCnfg, u8 **bmemStart, u8 **bmemEnd, u8 **smemStart)
{
    CommPckt   commPckt;
    s32        *paramBuf;
    u32        paramSize = 0;
    u32        configSize;
    u8         *configAddr;
    u8         *paramAddr;
    u8         *codeEnd;
    u8         *bootRomEnd;
    u8         *rdramEnd;
    u8         *bankStart;
    int        numSections;
    AEReverb   *reverbAsset;
    int        heapSize;

    uspsema(giosema);
    if ((u64fd = uhOpenGame("/dev/u64")) == -1) 
    {
        perror("Unable to open /dev/u64");
	*bmemStart = (u8*)0;      /* set to some workable defaults */
	*bmemEnd = (u8*)0x1000000;
	*smemStart = (u8*)0;
	usvsema(giosema);
        return(-1);
    }

    _ReadValue((int*)&codeEnd);
    _ReadValue((int*)&bootRomEnd);
    _ReadValue((int*)&rdramEnd);

    rdramEnd += 0x80000000;  /* convert to virtual address */
    rdramEnd = (u8*)CACHE_ALIGN_DOWN((int)rdramEnd);
    codeEnd = (u8*)CACHE_ALIGN_DOWN((int)codeEnd);

    /* init the config, write it to rdram,  and send InitAudio message */
    if(audCnfg->synConfig.fxType == AL_FX_CUSTOM)
    {
	reverbAsset = theAssetMgr->GetReverb();
	if(!reverbAsset)
	{
	    printf("Custom reverb has no reverb asset!\n");
	    audCnfg->synConfig.fxType = AL_FX_NONE;
	}
	else
	{
	    paramBuf = reverbAsset->GetParamBuf();
	    if(!paramBuf)
	    {
		printf("Custom reverb has no params!\n");
		audCnfg->synConfig.fxType = AL_FX_NONE;
	    }
	    else
	    {
		numSections = paramBuf[0]; // get the number of reverb sections
		paramSize = sizeof(s32) * ((numSections*PARAMS_PER_SECTION) + 2);
		paramSize = CACHE_ALIGN_UP(paramSize);
		paramAddr = rdramEnd - paramSize;
		audCnfg->synConfig.params = (s32*)paramAddr;
		if(_loadblock(paramAddr, (u8*)paramBuf, paramSize) == -1)
		{
		    fprintf(stderr,"Failure loading FX params\n");
		    usvsema(giosema);
		    return(-1);
		}
	    }
	}
    }

    configSize = CACHE_ALIGN_UP(sizeof(AudioConfig));
    configAddr = rdramEnd - (configSize + paramSize);
    
    audCnfg->audioHeap = (char*)codeEnd;
    audCnfg->heapSize = (u32)(configAddr - codeEnd);

    if(_loadblock(configAddr, (u8*)audCnfg, sizeof(AudioConfig)))
    {
        fprintf(stderr,"Failure loading audio configuration block\n");
	usvsema(giosema);
        return(-1);
    }

    commPckt.pcktType = SYSEX_TYPE;
    commPckt.d.sysr.reqType = INIT_AUDIO;
    commPckt.d.sysr.offset = (u32)configAddr;

    if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
    {
        perror("Error sending _StartInit sysex request info");
	usvsema(giosema);
        return(-1);
    }
    
    _ReadValue((int*)&bankStart);

    bankStart = (u8*)CACHE_ALIGN_UP((int)bankStart);
    *bmemStart = bankStart;
    *bmemEnd = rdramEnd;
    *smemStart = bootRomEnd;

    printf("%d bytes used for audio heap\n", bankStart - codeEnd);
    usvsema(giosema);

    return(0);
}

int GioMgr::SetBank(char *bnkfaddr, int bankNum)
{
    CommPckt    commPckt;
    u32   dbg;

    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = SET_BANK;
        commPckt.d.sysr.offset = (u32)bnkfaddr;
        commPckt.d.sysr.value = bankNum;

	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending SetBank sysex request info");
	    usvsema(giosema);
            return(-1);
        }

	usvsema(giosema);
    }
    return 0;
}

int GioMgr::StartAudio(void)
{
    CommPckt        commPckt;

    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = START_SEQUENCE;

	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending StartSequence sysex request info");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadMidi(CommPckt *commPckt)
{
    int dbg;
    if(u64fd != -1)
    {
	uspsema(giosema);
        if(uhWriteGame(u64fd,commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending midi block");
	    usvsema(giosema);
            return (-1);
        }
	usvsema(giosema);

    }
    return 0;
}

int GioMgr::LoadBlock(u8 *destAddr, u8 *data, u32 size)
{
    CommPckt        commPckt;

    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = WRITE_BLOCK;
        commPckt.d.sysr.offset = (u32)destAddr;
        commPckt.d.sysr.value = size;
    
	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending sysex request info");
	    usvsema(giosema);
            return (-1);
        }
        
        if(uhWriteGame(u64fd,data,size) == -1)
        {
            perror("Error sending sysex data");
	    usvsema(giosema);
            return (-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadSamples(u8 *addr,char *data, int numBytes)
{
    CommPckt        commPckt;

    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = WRITE_RAMROM;

	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending LoadRamRom sysex request info");
	    usvsema(giosema);
            return(-1);
        }
        
        if(uhWriteRamrom(u64fd,addr,data,numBytes) == -1)
        {
            perror("Error reported with uhWriteRamrom");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadInstVol(u8 *addr, int vol)
{
    CommPckt        commPckt;
    
    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = LOAD_INST_VOL;
        commPckt.d.sysr.offset = (u32)addr;
        commPckt.d.sysr.value = vol;
	
	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending LoadInstVol sysex request info");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadInstPan(u8 *addr, int pan)
{
    CommPckt        commPckt;
    
    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = LOAD_INST_PAN;
        commPckt.d.sysr.offset = (u32)addr;
        commPckt.d.sysr.value = pan;
	
	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending LoadInstPan sysex request info");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadInstPriority(u8 *addr, int priority)
{
    CommPckt        commPckt;
    
    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = LOAD_INST_PRIORITY;
        commPckt.d.sysr.offset = (u32)addr;
        commPckt.d.sysr.value = priority;
	
	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending LoadInstPriority sysex request info");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadInstBendRange(u8 *addr, int bendRange)
{
    CommPckt        commPckt;
    
    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = LOAD_INST_BENDRANGE;
        commPckt.d.sysr.offset = (u32)addr;
        commPckt.d.sysr.value = bendRange;
	
	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending LoadInstBendRange sysex request info");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

int GioMgr::LoadFXParam(int paramID, int paramVal)
{
    CommPckt        commPckt;
    
    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = SET_FX_PARAM;
        commPckt.d.sysr.offset = paramID;
        commPckt.d.sysr.value = paramVal;
	
	uspsema(giosema);
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending LoadFXParam sysex request info");
	    usvsema(giosema);
            return(-1);
        }
	usvsema(giosema);
    }
    return 0;
}

/*****************************************
 *
 *  CAUTION!! Thread should have control of
 *  semaphore before calling these routines!
 *
 *****************************************/
int GioMgr::_ReadValue(int *valPtr)
{
    if(u64fd != -1)
    {
        if(uhReadGame(u64fd, valPtr, 4) == -1)
        {
            perror("Unable to read value");
            return(-1);
        }
	
    }
    return 0;
}


int GioMgr::_loadblock(u8 *destAddr, u8 *data, u32 size)
{
    CommPckt        commPckt;
    int             tmp;

    if(u64fd != -1)
    {
        commPckt.pcktType = SYSEX_TYPE;
        commPckt.d.sysr.reqType = WRITE_BLOCK;
        commPckt.d.sysr.offset = (u32)destAddr;
        commPckt.d.sysr.value = size;
    
        if(uhWriteGame(u64fd,&commPckt,sizeof(CommPckt)) == -1)
        {
            perror("Error sending sysex request info");
            return (-1);
        }
        if(uhWriteGame(u64fd,data,size) == -1)
        {
            perror("Error sending sysex data");
            return (-1);
        }
    }
    return 0;
}