#include <PR/bcp.h>
#include <PR/R4300.h>
#include <PR/bbsim.h>
#include <PR/bbskapi.h>

#include <PR/os.h>
#include <PR/os_bb.h>
#include <PR/os_bbfs.h>
#include <PR/os_bbatb.h>
#include <PR/os_bbexec.h>
#include <PR/ramrom.h>

#include <libfb.h>
#include "rights.h"

#define HAS_SW_RIGHTS(a) (((SWRIGHTS) & (1<<(a)))!=0)
#define ALIGN_DCACHE __attribute__((aligned(DCACHE_LINESIZE)))

extern u32  __osBbHackFlags;

/*
 * debug print support
 */

#undef PRINTF

#ifdef DEBUG
#define	PRINTF	osSyncPrintf
#else
#define	PRINTF(format, args...)
#endif

#define fbhBlue         GPACK_RGBA5551(0,0,80,1)
#define fbhGreen        GPACK_RGBA5551(0,80,0,1)
#define fbhRed          GPACK_RGBA5551(80,0,0,1)
#define fbhYellow       GPACK_RGBA5551(80,80,0,1)
#define fbhMagenta      GPACK_RGBA5551(80,0,80,1)
#define fbhCyan         GPACK_RGBA5551(0,80,80,1)

#define fbLemonChiffon          GPACK_RGBA5551(255,250,205,1)
#define fbLightSlateBlue        GPACK_RGBA5551(132,112,255,1)
#define fbLightPink1            GPACK_RGBA5551(255,174,185,1)
#define fbThistle2              GPACK_RGBA5551(238,210,238,1)
#define fbSeaGreen4             GPACK_RGBA5551(105,139,105,1)
#define fbTomato1               GPACK_RGBA5551(255,99,71,1)
#define fbTurquoise2            GPACK_RGBA5551(0,229,238,1)
#define fbSienna4               GPACK_RGBA5551(139,71,38,1)


/*
 * Thread and stack structures
 */

char   bootStack[STACKSIZE] __attribute__ ((aligned (8)));

static OSThread idleThread;
static char     idleThreadStack[STACKSIZE] __attribute__ ((aligned (8)));

static OSThread mainThread;
static char     mainThreadStack[STACKSIZE] __attribute__ ((aligned (8)));

/* 
 * FS specific definitions
 */

static void	idleproc(char *);
static void	mainproc(char *);


#define DMA_QUEUE_SIZE	200

static OSMesg           PiMessages[DMA_QUEUE_SIZE];
static OSMesgQueue      PiMessageQ;

static OSMesg           SiMessages[DMA_QUEUE_SIZE];
static OSMesgQueue      SiMessageQ;


/*
 * simple graphics
 */

static OSMesgQueue      retraceMessageQ;
static OSMesg           dummyMessage, retraceMessageBuf;
static u16 cfb[320*240] __attribute__((aligned(64)));

/*
 * controller
 */
static OSMesgQueue      contMessageQ;
OSContStatus statusData[MAXCONTROLLERS];
OSContPad controllerData[MAXCONTROLLERS];
static u16 lastbutton[MAXCONTROLLERS];
static int no_controller = 1;

int gBeginTest = 0;

static void
initController(void)
{
    int i, c = 0;
    u8 pattern;

    if (__osBbIsBb<2)
        __osBbHackFlags = 1;
    else
        __osBbHackFlags = 0;

    osCreateMesgQueue(&contMessageQ, &dummyMessage, 1);
    osSetEventMesg(OS_EVENT_SI, &contMessageQ, (OSMesg) 0);

    osContInit(&contMessageQ, &pattern, &statusData[0]);

    for (i = 0; i < MAXCONTROLLERS; i++) {
        if ((pattern & (1 << i)) &&
            !(statusData[i].errno & CONT_NO_RESPONSE_ERROR)) {
            ++c;
            no_controller = 0;
        }
    }
}


static void
processButton(u16 button, int lastbutton)
{
    if (button & D_JPAD && !(lastbutton & D_JPAD)) {
        // pad down
    }

    if (button & U_JPAD && !(lastbutton & U_JPAD)) {
        // pad up
    }

    // output anything changing here

    if ((button & A_BUTTON && !(lastbutton & A_BUTTON)) ||
        (button & START_BUTTON && !(lastbutton & START_BUTTON))){
        // start or A button pressed
        gBeginTest = 1;
    }
}

static void
readControllers(void)
{
    int i;
    OSContPad *pad;

    osRecvMesg(&contMessageQ, &dummyMessage, OS_MESG_BLOCK);
    osContGetReadData(controllerData);

    for (i = 0; i < MAXCONTROLLERS; ++i) {
        pad = &controllerData[i];
        if (!pad->errno && pad->button != lastbutton[i]) {
            processButton(pad->button, lastbutton[i]);
            lastbutton[i] = pad->button;
        }
    }
}


void  __osBbVideoPllInit(u32);
void boot()
{
    /* Init the video PLL */
    __osBbVideoPllInit(OS_TV_NTSC);

    osInitialize();

    osCreateThread(&idleThread, 1, (void(*)(void *))idleproc, (void *)0,
                   idleThreadStack+STACKSIZE, 8);
    osStartThread(&idleThread);
}


static void
idleproc(char *argv)		/* priority 8 */
{
    osCreateViManager(OS_PRIORITY_VIMGR);
    fbInit(FB_LOW_RES);

#ifdef DEBUG
    /* should allow usb printing */
    osBbUsbInit();
#endif

    /*
     * Start PI Mgr for access to cartridge - start before the debugger
     */
    osCreatePiManager((OSPri) OS_PRIORITY_PIMGR, &PiMessageQ, PiMessages,
            DMA_QUEUE_SIZE);

    osCreateMesgQueue(&SiMessageQ, SiMessages, DMA_QUEUE_SIZE);
    osSetEventMesg(OS_EVENT_SI, &SiMessageQ, (OSMesg)DMA_QUEUE_SIZE);

    /*
     * The main thread's priority must be the same or lower than the original
     * idle's thread priority. This allows the idle thread to change its
     * priority to 0 before the main thread starts execution.
     */
    osCreateThread(&mainThread, 3, (void(*)(void *))mainproc, argv,
           mainThreadStack+STACKSIZE/8, (OSPri)7);
    osStartThread(&mainThread);

    osSetThreadPri(0, OS_PRIORITY_IDLE);

    for(;;){}
}

void pause()
{
    fbPrintf(fbWhite, 5, 4, "Press A to move to next test");
    osWritebackDCacheAll();

    gBeginTest=0;
    do {
        osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
        osContStartReadData(&contMessageQ);
        readControllers();
    }while(!gBeginTest);
    fbPrintf(fbWhite, 5, 4, "performing test             ");
}


void reportResult(int pass)
{
    if(pass){
        fbPrintf(fbhGreen, 10, 8, "PASS");
    }
    else{
        fbPrintf(fbhRed, 10, 8, "FAIL");
    }
    osWritebackDCacheAll();
}

void mainproc(char *argv)
{
    int hasPerm,hasAccess;
    
    /* setup text output to screen */
    osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
    osViSetEvent(&retraceMessageQ, dummyMessage, 1);
    osViBlack(1);
    osViSwapBuffer(cfb);
    fbSetBg(fbBlack);
    fbClear();
    osViBlack(0);
    osWritebackDCacheAll();
    osViSwapBuffer(cfb);
    fbClear();
    initController();

    fbPrintf(fbWhite, 3, 2, "HW Rights Test: 0x%08x",HWRIGHTS);
    osWritebackDCacheAll();

    pause();

    /* attempt to write to buffer */
    hasPerm = (HWRIGHTS & PI_ACCESS_BUFFER)!=0;
    fbPrintf(fbWhite, 5, 6, "Buffer test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(PI_BUFFER_BASE_REG,0xf0f0f0f0);
    hasAccess = 0;
    if(IO_READ(PI_BUFFER_BASE_REG) == 0xf0f0f0f0){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* attempt to write to flash address reg */
    hasPerm = (HWRIGHTS & PI_ACCESS_FLASH)!=0;
    fbPrintf(fbWhite, 5, 6, "Flash  test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(PI_FLASH_ADDR_REG,0xf0f0f0f0);
    hasAccess = 0;
    if((0x3fffffff&IO_READ(PI_FLASH_ADDR_REG)) == 0x30f0f0f0){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* attempt to write to atb reg */
    hasPerm = (HWRIGHTS & PI_ACCESS_ATB)!=0;
    fbPrintf(fbWhite, 5, 6, "ATB    test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(PI_ATB_BUFFER_LO_REG,0xf0f0f0f0);
    hasAccess = 0;
    if(IO_READ(PI_ATB_BUFFER_LO_REG) == 0xf0f0f0f0){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* attempt to write to aes reg */
    hasPerm = (HWRIGHTS & PI_ACCESS_AES)!=0;
    fbPrintf(fbWhite, 5, 6, "AES    test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(PI_AES_INIT_REG,0xf0f0f0f0);
    hasAccess = 0;
    if(IO_READ(PI_AES_INIT_REG) == 0xf0f0f0f0){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* attempt to write to pierror[30] reg */
    hasPerm = (HWRIGHTS & PI_ACCESS_ERROR)!=0;
    fbPrintf(fbWhite, 5, 6, "Error  test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(PI_ERROR_REG,PI_ERROR_SYS_INTR);
    hasAccess = 0;
    if(IO_READ(PI_ERROR_REG)&PI_ERROR_SYS_INTR){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* attempt to write to usb reg */
    hasPerm = (HWRIGHTS & BB_CMD_HWAR_USB_MASK)!=0;
    fbPrintf(fbWhite, 5, 6, "USB    test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(USB0_BDT_SRAM,0xf0f0f0f0);
    hasAccess = 0;
    if(IO_READ(USB0_BDT_SRAM) == 0xf0f0f0f0){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* attempt to write iram */
    hasPerm = (HWRIGHTS & BB_CMD_HWAR_IRAM_MASK)!=0;
    fbPrintf(fbWhite, 5, 6, "IRAM   test, access = %d",hasPerm);
    osWritebackDCacheAll();
    IO_WRITE(INTERNAL_RAM_START,0xf0f0f0f0);
    hasAccess = 0;
    if(IO_READ(INTERNAL_RAM_START) == 0xf0f0f0f0){
        hasAccess = 1;
    }
    reportResult(hasPerm==hasAccess);

    pause();

    /* SW rights: 
     *   if no rights, SK_API_NO_ENTRY_FOUND
     *   else, some other success or failure.
     *
     *   SK_API_CALL_GET_ID
     *   SK_API_CALL_LAUNCH_SETUP
     *   SK_API_CALL_LAUNCH
     *   SK_API_CALL_LIST_VALID
     *   SK_API_CALL_RECRYPT_BEGIN
     *   SK_API_CALL_RECRYPT_DATA
     *   SK_API_CALL_RECRYPT_STATE
     *   SK_API_CALL_RECRYPT_END
     *   SK_API_CALL_SIGN_HASH
     *   SK_API_CALL_VERIFY_HASH
     *   SK_API_CALL_GET_CONSUMPTION
     *   SK_API_CALL_ADVANCE_TICKET_WINDOW
     */

    fbPrintf(fbWhite, 3, 2, "SW Rights Test: 0x%08x",SWRIGHTS);
    osWritebackDCacheAll();

#define SW_ACCESS_TEST(_indx,_call,args...) \
    hasPerm = HAS_SW_RIGHTS((_indx)); \
    fbPrintf(fbWhite, 5, 6, "                                     "); \
    fbPrintf(fbWhite, 5, 6, #_call ", access = %d",hasPerm);     \
    osWritebackDCacheAll();                                      \
    hasAccess = !(_call(args)==SK_API_NO_ENTRY_FOUND);           \
    reportResult(hasPerm==hasAccess)
#define SW_ACCESS_TEST_PAUSE(_indx,_call,args...) \
    SW_ACCESS_TEST(_indx,_call,args); pause()

    SW_ACCESS_TEST_PAUSE(SK_API_CALL_GET_ID,skGetId,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_LAUNCH_SETUP,skLaunchSetup,NULL,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_LAUNCH,skLaunch,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_LIST_VALID,skRecryptListValid,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_RECRYPT_BEGIN,skRecryptBegin,NULL,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_RECRYPT_DATA,skRecryptData,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_RECRYPT_STATE,skRecryptComputeState,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_RECRYPT_END,skRecryptEnd,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_SIGN_HASH,skSignHash,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_VERIFY_HASH,skVerifyHash,NULL,NULL,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_GET_CONSUMPTION,skGetConsumption,NULL,NULL);

    SW_ACCESS_TEST_PAUSE(SK_API_CALL_ADVANCE_TICKET_WINDOW,skAdvanceTicketWindow);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_SET_LIMIT,skSetLimit,NULL,NULL);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_EXIT,skExit);
    SW_ACCESS_TEST_PAUSE(SK_API_CALL_KEEP_ALIVE,skKeepAlive);

    /* now test for out-of-bound indices */
    /* NOTE: hard coded so must have access to call indx 14, matching
     *       the index for the last (non-development build) sk api call.
     */
    fbPrintf(fbWhite, 5, 6, "                                     "); \
    fbPrintf(fbWhite, 5, 6, "valid index sanity check, have access" );
    asm("li $2, 14;move $4, $0;move $5, $0;move $6, $0;move $7, $0;"
        "li $8, 0xa4300014;lw $9, ($8); move %0, $2;"
            : "=r" (hasAccess):);
    reportResult(hasAccess!=SK_API_NO_ENTRY_FOUND);
    PRINTF("hasAccess = %08x\n",hasAccess);

    pause();

    fbPrintf(fbWhite, 5, 6, "                                     "); \
    fbPrintf(fbWhite, 5, 6, "invalid index (one too big)          " );
    asm("li $2, 15;li $8, 0xa4300014;lw $9, ($8); move %0, $2;"
            : "=r" (hasAccess):);
    reportResult(hasAccess==SK_API_NO_ENTRY_FOUND);
    PRINTF("hasAccess = %08x\n",hasAccess);

    fbPrintf(fbWhite, 5, 4, "                            ");
    fbPrintf(fbWhite, 3, 11, "All tests complete          ");
    osWritebackDCacheAll();
    while(1){}
    return;
}