/*
 * gload.c: game loader for Ultra64 development system.
 *
 * 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 <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 <ramrom.h>

#include "gload.h"



static void usage(void);
static int readNverify(int u64fd, unsigned int ramromOffset, int bufSize, 
			unsigned char *buf, int verbose);
static int writeNverify(int u64fd, unsigned int ramromOffset, int bufSize, 
			unsigned char *buf, int verbose);

char *progName;

char *defaultRomName = "rom";

int Verify = 0;

main(int argc, char *argv[])
{
    int romFd;
    char errMessage[256];
    char appargs[256];
    char *fmtFileName, *romFileName;
    int u64fd, retval;
    struct stat buf;
    unsigned char *romBuf;
    int c, error;
    int romWordAlignedByteSize, appargWordAlignedByteSize;
    unsigned int romOffset;
    int romOffsetEntered = 0;
    int bootObjSize;
    int silent = 0;
    int verbose = 0;
    int errorsFound = 0;
    int noRom = 0;

    fmtFileName = NULL;
    progName = argv[0];

    strcpy(appargs, "\0");
    while ((c = getopt(argc, argv, "a:f:no:sVv")) != EOF) {
	switch (c) {
	    case 'a':
		strcpy(appargs, optarg);
		break;
	    case 'f':
		fmtFileName = optarg;
		break;
	    case 'n':
		noRom = 1;
		break;
	    case 'o':
		romOffset = strtol(optarg, NULL, 0);
		romOffsetEntered = 1;
		break;
	    case 's':
		silent = 1;
		break;
	    case 'V':
		Verify = 1;
		break;
	    case 'v':
		verbose = 1;
		break;
	    case '?':
		usage();
		exit(1);
       }
    }

    if(!noRom)
    {
	if (!romOffsetEntered) {
	    romOffset = 0;  /* rom will internally offset game to RAMROM_GAME_OFFSET */
	}

	/*
         * Last arg is our rom filename; provide a default if none was provided.
         */
	if ((argc - optind) != 1) {
	    romFileName = defaultRomName;
	} else {
	    romFileName = argv[optind];
	}

	if ((romFd = open(romFileName, O_RDONLY | O_NOCTTY)) < 0) {
	    sprintf(errMessage, "%s: unable to open %s", progName, romFileName);
	    perror(errMessage);
	    exit(1);
	}

	if ((u64fd = open(DEV_U64, O_RDWR | O_NOCTTY)) < 0) {
	    sprintf(errMessage, "%s unable to open %s", progName, DEV_U64);
	    perror(errMessage);
	    close(romFd);
	    exit(1);
	} 

	/*
         * Assert RESET
         */
	if ( (retval = ioctl(u64fd, U64_RESET, 1) ) < 0 ) {
	    sprintf(errMessage, "%s after U64_RESET ioctl", progName);
	    perror(errMessage);
	    close(romFd);
	    exit(1);
	} 
    }
    /*
     * If gload is going to act as a print/log server, then make sure that
     * it can listen to the events before we start loading the ramrom.
     */
    if (!silent) {
	if (printServerInit(fmtFileName) < 0) {
	    close(romFd);
    	    exit(1);
	}
    }


    if(!noRom)
    {
	/*
     * Load the ROM
     */
	if (fstat(romFd, &buf) < 0) {
	    sprintf(errMessage, "%s unable to stat %s", progName, romFileName);
	    perror(errMessage);
	    close(romFd);
	    exit(1);
	}
	romWordAlignedByteSize = buf.st_size;

	romBuf = malloc(romWordAlignedByteSize);
	if (romBuf == NULL) {
	    fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n", 
		    progName, romWordAlignedByteSize);
	    close(romFd);
	    exit(1);
	}

	retval = read(romFd, (void *)romBuf, romWordAlignedByteSize);

	if (retval != romWordAlignedByteSize) {
	    fprintf(stderr, "%s: short read from %s.\n", progName, romFileName);
	    free(romBuf);
	    close(romFd);
	    exit(1);
	}

	/*
     * Write the contents of the ROM file into ramrom first.
     */
	if (writeNverify(u64fd, romOffset, romWordAlignedByteSize, romBuf, 
			 verbose) > 0) {
	    fprintf(stderr, "gload: write & readback of rom image failed.\n");
	    free(romBuf);
	    close(romFd);
	    close(u64fd);
	    exit(1);
	}
	close(romFd);

    /*
     * Write the application arguments into the app-to-indy comm buffer, if
     * any.
     */
	appargWordAlignedByteSize = strlen(appargs) +1;
    
	/* 
     * We must transfer an integral number of words.  Doesn't hurt to 
     * transfer a couple of extra bytes of crap.
     */
    
	if (appargWordAlignedByteSize & 3){
	    appargWordAlignedByteSize += 4;
	    appargWordAlignedByteSize &= ~(3);
	}
    
	if (writeNverify(u64fd, RAMROM_APP_WRITE_ADDR, 
			 appargWordAlignedByteSize, appargs, verbose) > 0) {
	    fprintf(stderr, "gload: write & readback of appargs failed.\n");
	    close(u64fd);
	    exit(1);
	}

	/*
     * Go back one more time & verify.  If the romoffset is zero, we will 
     * assume that this is the standard game rom that was loaded, and thus
     * we check RAMROM_GAME_OFFSET bytes into the rom (since we purposefully overwrote 
     * that portion of the rom).
     */
	if (romOffset == 0) {
	    romOffset = RAMROM_GAME_OFFSET;
	    if (retval = readNverify(u64fd, romOffset,
				     (romWordAlignedByteSize - romOffset), 
				     ( (unsigned char *)( ((int)romBuf) + romOffset ) ), 
				     verbose) != 0) {
		errorsFound = retval;
		fprintf(stderr, 
			"gload: final rom readback failed (%d errors).\n",
			retval);
	    }
	} else {
	    if (readNverify(u64fd, romOffset, romWordAlignedByteSize, 
			    romBuf, verbose) != 0) {
		errorsFound += retval;
		fprintf(stderr, 
			"gload: final rom comparison failed (%d errors).\n",
			retval);
	    }
	}

	/* if (readNverify(u64fd, RAMROM_BOOTSTRAP_OFFSET, bootWordAlignedByteSize, 
      bootBuf, verbose) != 0) {
	errorsFound += retval;
	fprintf(stderr, 
	  "gload: final bootstrap readback failed (%d errors).\n",
	  retval);
    }

    if (readNverify(u64fd, RAMROM_PIF2BOOTSTRAP_OFFSET, 
      pif2bootWordAlignedByteSize, pif2bootBuf, verbose) != 0) {
	errorsFound += retval;
	fprintf(stderr, 
	  "gload: final pif2 bootstrap readback failed (%d errors).\n",
	  retval);
    } */

	if (readNverify(u64fd, RAMROM_APP_WRITE_ADDR, appargWordAlignedByteSize,
			appargs, verbose) != 0) {
	    errorsFound += retval;
	    fprintf(stderr, 
		    "gload: final appargs readback failed (%d errors).\n",
		    retval);
	}

	/*
     * Do the romheader last; it leaves the dram page pointer parked at
     * page 0.  For now, this is just a placeholder!
     */
	if (readNverify(u64fd, 0x0, 4, romBuf, verbose) != 0) {
	    errorsFound += retval;
	    fprintf(stderr, 
		    "gload: final romheader readback failed (%d errors).\n",
		    retval);
	}


	/*
     * Release RESET; game will subsequently boot itself.
     */
	if ( (retval = ioctl(u64fd, U64_RESET, 0) ) < 0 ) {
	    sprintf(errMessage, "%s after U64_RESET ioctl", progName);
	    perror(errMessage);
	    close(u64fd);
	    exit(1);
	} 

	if (romBuf)
	    free(romBuf);
    }

    if (!silent) {
	if (printServer() < 0)
		errorsFound += 1;
    }

    close(u64fd);
    printServerClose();

    if (errorsFound)
	exit(1);
    else
	exit(0);
}

static void
usage(void)
{
    fprintf(stderr, 
"usage:\tgload\t[-a ""app args""] [-o rom offset within ramrom]\n");
    fprintf(stderr, 
"\t\t[-f log format file] [-V] [-v] [-s] [romfile]\n");
    exit(1);
}

/*
 * Returns number of errors encountered.
 */
int
writeNverify(int u64fd, unsigned int ramromOffset, int bufSize, 
	unsigned char *buf, int verbose)
{
    char errMessage[256];
    unsigned char *readBuf, *pSrc, *pDst;
    u64_write_arg_t arg;
    int retval, i, error;

    if ((ramromOffset + bufSize) > RAMROM_SIZE) {
	fprintf(stderr, 
	  "%s: (ramrom offset 0x%x) + (buffer size 0x%x) = 0x%x > 0x%x\n", 
	  ramromOffset, bufSize, (ramromOffset + bufSize), RAMROM_SIZE);
	return(1);
    }

    /*
     * Tell the kernel to copyin our data into ramrom.
     */
    arg.buffer = (void *)buf;
    arg.ramrom_addr = ramromOffset;
    arg.nbytes = bufSize;

    if ( (retval = ioctl(u64fd, U64_WRITE, &arg) ) < 0 ) {
	sprintf(errMessage, "%s after U64_WRITE ioctl, return value %d", 
	  progName, retval);
	perror(errMessage);
	return(1);
    } 

    if (!Verify) {
	return(0);
    }

    /*
     * Read back & verify, to ensure our load worked.
     */
    readBuf = malloc(bufSize);
    if (readBuf == NULL) {
	fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n", 
	  progName, bufSize);
	return(1);
    }
    /*
     * Tell the kernel to copyout ramrom data into our buffer.
     */
    arg.buffer = (void *)readBuf;
    arg.ramrom_addr = ramromOffset;
    arg.nbytes = bufSize;

    if ( (retval = ioctl(u64fd, U64_READ, &arg) ) < 0 ) {
	sprintf(errMessage, "%s after U64_READ ioctl, return value %d", 
	  progName, retval);
	perror(errMessage);
	return(1);
    } 

    for (i = 0, error = 0, pSrc = buf, pDst = readBuf; 
      i < bufSize; i++) {
	if (*pSrc != *pDst) {
	    if (verbose) {
		fprintf(stderr, "Error (byte %d): read 0x%x, exp 0x%x\n", 
		  i, *pDst, *pSrc);
	    }
	    error++;
	}
	pSrc++;
	pDst++;
    }
    if (error > 0) {
	return(error);
    }

    return(0);
}

/*
 * Returns number of errors encountered.
 */
int
readNverify(int u64fd, unsigned int ramromOffset, int bufSize, 
	unsigned char *buf, int verbose)
{
    char errMessage[256];
    unsigned char *readBuf, *pSrc, *pDst;
    u64_write_arg_t arg;
    int retval, i, error;

    if (!Verify) {
	return(0);
    }

    if ((ramromOffset + bufSize) > RAMROM_SIZE) {
	fprintf(stderr, 
	  "%s: (ramrom offset 0x%x) + (buffer size 0x%x) = 0x%x > 0x%x\n", 
	  ramromOffset, bufSize, (ramromOffset + bufSize), RAMROM_SIZE);
	return(1);
    }

    /*
     * Read back & verify, to ensure our load worked.
     */
    readBuf = malloc(bufSize);
    if (readBuf == NULL) {
	fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n", 
	  progName, bufSize);
	return(1);
    }
    /*
     * Tell the kernel to copyout ramrom data into our buffer.
     */
    arg.buffer = (void *)readBuf;
    arg.ramrom_addr = ramromOffset;
    arg.nbytes = bufSize;

    if ( (retval = ioctl(u64fd, U64_READ, &arg) ) < 0 ) {
	sprintf(errMessage, "%s after U64_READ ioctl, return value %d", 
	  progName, retval);
	perror(errMessage);
	return(1);
    } 

    for (i = 0, error = 0, pSrc = buf, pDst = readBuf; 
      i < bufSize; i++) {
	if (*pSrc != *pDst) {
	    if (verbose) {
		fprintf(stderr, "Error (byte %d): read 0x%x, exp 0x%x\n", 
		  i, *pDst, *pSrc);
	    }
	    error++;
	}
	pSrc++;
	pDst++;
    }
    if (error > 0) {
	return(error);
    }
    return(0);
}