/*---------------------------------------------------------------------------*
  Project:      Sample demo program for NAND library
  File:         async.c
  Programmer:   HIRATSU Daisuke

  Copyright (C) 2006 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Log: async.c,v $
  Revision 1.4  06/05/2006 13:07:26  hiratsu
  Removed NANDFinalize().

  Revision 1.3  05/09/2006 09:09:51  hiratsu
  Added new tutorial code.

  Revision 1.2  05/04/2006 04:49:33  hiratsu
  Redesigned.  Implemented chain of callback.

  Revision 1.1  05/03/2006 09:08:54  hiratsu
  Initial check-in.  This is a sample code to use async NAND APIs.

 *---------------------------------------------------------------------------*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <revolution.h>
#include <revolution/nand.h>

#include "util.h"

#define PATH "/tmp/nanddemo.dat"
#define PERM (NAND_PERM_OWNER_READ | NAND_PERM_OWNER_WRITE)    // Owner can read/write
#define ATTR 0x00                                              // No attributes.
#define DATA_SIZE 1024*1024

static NANDCommandBlock s_block;
static NANDFileInfo s_info;
static u8 s_data[DATA_SIZE] ATTRIBUTE_ALIGN(32);
static volatile BOOL s_finished_flag = FALSE;

struct UserDataType
{
    BOOL finished_flag;
    s32  resultCode;
};

static void callback(s32 result, NANDCommandBlock *block);

static void sample1(void);
static void create (void);
static void openCallback  (s32 result, NANDCommandBlock *block);
static void writeCallback (s32 result, NANDCommandBlock *block);
static void closeCallback (s32 result, NANDCommandBlock *block);
static void deleteCallback(s32 result, NANDCommandBlock *block);
static void finishCallback(s32 result, NANDCommandBlock *block);

static void sample2(void);


int main(void)
{
    if(NANDInit()!=NAND_RESULT_OK)
    {
        OSHalt("NANDInit() failed.");
    }

    sample1();

    sample2();

    OSHalt("Finished with success");
    return EXIT_SUCCESS;     // Never reach here.
}


static void callback(s32 result, NANDCommandBlock *block)
{
    ((struct UserDataType*)NANDGetUserData(block))->finished_flag = TRUE;
    ((struct UserDataType*)NANDGetUserData(block))->resultCode = result;
}


static void sample1(void)
{
    memset(s_data, 'A', DATA_SIZE);
    create();
    while(!s_finished_flag)
      ;
    OSReport("sample1() finished.\n");
}


static void create(void)
{
    s32 ret = NANDCreateAsync(PATH, PERM, ATTR, openCallback, &s_block);
    if(ret != NAND_RESULT_OK)
    {
        printErrMsg(ret);
        OSHalt("NANDCreateAsync() failed.\n");
    }
}


static void openCallback(s32 result, NANDCommandBlock*)
{
    if(result==NAND_RESULT_OK)
    {
        s32 ret = NANDOpenAsync(PATH, &s_info, NAND_ACCESS_WRITE | NAND_ACCESS_READ, writeCallback, &s_block);
        if(ret != NAND_RESULT_OK)
        {
            printErrMsg(ret);
            OSHalt("NANDOpenAsync() failed.");
        }
    }
    else
    {
        OSHalt("NANDCreateAsync() failed.");
    }
}


static void writeCallback(s32 result, NANDCommandBlock*)
{
    if(result==NAND_RESULT_OK)
    {    s32 ret =NANDWriteAsync(&s_info, s_data, DATA_SIZE, closeCallback, &s_block);
        if(ret != NAND_RESULT_OK)
        {
            printErrMsg(ret);
            OSHalt("NANDWriteAsync() failed.");
        }
    }
    else
    {
        OSHalt("NANDOpenAsync() failed.");
    }

}

static void closeCallback(s32 result, NANDCommandBlock*)
{
    if(result==DATA_SIZE)
    {
        s32 ret = NANDCloseAsync(&s_info, deleteCallback, &s_block);
        if(ret != NAND_RESULT_OK)
        {
            printErrMsg(ret);
            OSHalt("NANDCloseAsync() failed.");
        }
    }
    else
    {
        OSHalt("NANDWriteAsync() failed.");
    }
}


static void deleteCallback(s32 result, NANDCommandBlock*)
{
    if(result==NAND_RESULT_OK)
    {
        s32 ret = NANDDeleteAsync(PATH, finishCallback, &s_block);
        if(ret != NAND_RESULT_OK)
        {
            printErrMsg(ret);
            OSHalt("NANDDeleteAsync() failed.");
        }
    }
    else
    {
        OSHalt("NANDCloseAsync() failed.");
    }
}


static void finishCallback(s32 result, NANDCommandBlock*)
{
    if(result==NAND_RESULT_OK)
    {
        s_finished_flag = TRUE;
    }
    else
    {
        OSHalt("NANDDeleteAsync() failed.");
    }
}


#define ASYNC_CALLS 8

static void sample2(void)
{
    volatile struct UserDataType userData[ASYNC_CALLS];
    NANDCommandBlock block[ASYNC_CALLS];
    int i = 0;

    // Start async calls.
    for(i = 0; i<ASYNC_CALLS; ++i)
    {
        s32 result = NAND_RESULT_FATAL_ERROR;
        char path[NAND_MAX_PATH];
        userData[i].finished_flag = FALSE;
        userData[i].resultCode = NAND_RESULT_FATAL_ERROR;
        NANDSetUserData(&block[i], (void*)&userData[i]);
        sprintf(path, "/tmp/async%d.tmp", i);
        result = NANDCreateAsync(path, PERM, ATTR, callback, &block[i]);
        if(result != NAND_RESULT_OK)
        {
            userData[i].finished_flag = TRUE;
            userData[i].resultCode = result;
        }
    }

    // Wait async calls to be finished.
    while(1)
    {
        BOOL finished_all_flag = TRUE;
        for(i=0; i<ASYNC_CALLS; ++i)
        {
            finished_all_flag = finished_all_flag & userData[i].finished_flag;
        }
        if(finished_all_flag)
        {
            break;
        }
    }

    // Report results
    for(i = 0; i<ASYNC_CALLS; ++i)
    {
        if(userData[i].resultCode == NAND_RESULT_OK)
        {
            OSReport("Async call [%d]...success\n", i);
        }
        else
        {
            OSReport("Async call [%d]...failed : result code (%d)\n", i, userData[i].resultCode);
            OSHalt("sample2() failed.");
        }
    }

    OSReport("sample2() finished.\n");
}