ctr_Repair/trunk/FlickerCalCollector/main.cpp

/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     main.cpp

  Copyright 2009-2011 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.

  $Rev$
 *---------------------------------------------------------------------------*/

#include <nn.h>
#include <nn/applet.h>
#include <nn/drivers/cal/CTR/cal_Api.h>
#include <nn/cfg.h>
#include <nn/cfg/CTR/cfg_Api.h>
#include <nn/cfg/CTR/cfg_ApiInit.h>
#include <nn/cfg/CTR/cfg_ApiSys.h>
#include <nn/cfg/CTR/detail/cfg_SecureInfo.h>
#include <nn/nstd.h>

#include "demo.h"

#define HANDLE_ERROR(result)           \
    if(result.IsFailure())              \
    {                                   \
        DrawError(result, __LINE__);    \
    }                                   \

namespace
{

nn::drivers::cal::CTR::LcdFlickerInfo        s_LcdFlickerInfo;
bool s_LcdFlickerInfoIsValid = false;
u8 s_SerialNo[nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN];
bool s_CanReadSerialNumber = false;
u32 s_CalVersion = 0;

void* heapForGx;
nn::fnd::ExpHeap s_AppHeap;
demo::RenderSystemDrawing s_RenderSystem;

const wchar_t LOG_FILE_PATH[] = L"sdmc:/FlickerCalCollector.csv";

}

void DrawError(nn::Result result, s32 line)
{
    s_RenderSystem.SetColor(1, 0, 0);
    for(;;)
    {
        s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY0);
        s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 0, 0, 0, 1);
        s_RenderSystem.Clear();
        s_RenderSystem.DrawText(0, 0, "line %d: Error = %X", line, result.GetPrintableBits());
        s_RenderSystem.SwapBuffers();


        s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY1);
        s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 1, 0, 0, 1);
        s_RenderSystem.Clear();
        s_RenderSystem.SwapBuffers();

        nngxWaitVSync(NN_GX_DISPLAY_BOTH);
    }
}

void Finalize()
{
    s_RenderSystem.Finalize();
    s_AppHeap.Free(heapForGx);
    s_AppHeap.Finalize();

    nn::applet::DisableSleep();
    nn::cfg::init::Finalize();
    nn::fs::Unmount("sdmc:");
    nn::fs::Finalize();
}

extern "C" void nnMain()
{
    nn::applet::Enable();

    NN_LOG("FlickerCalCollector start\n");

    const u32 s_GxHeapSize = 0x800000;

    // ヒープの確保
    s_AppHeap.Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR);

    // RenderSystem の準備
    heapForGx = s_AppHeap.Allocate(s_GxHeapSize);
    s_RenderSystem.Initialize(reinterpret_cast<uptr>(heapForGx), s_GxHeapSize);
    s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 0, 0, 0, 1);
    s_RenderSystem.SetColor(1, 1, 1);

    nn::Result result;

    // fs の初期化
    nn::fs::Initialize();

    // cfg の初期化
    nn::cfg::CTR::init::Initialize();

    // SDカードマウント
    result = nn::fs::MountSdmc();
    HANDLE_ERROR(result);
    nn::fs::FileOutputStream file;

    result = file.TryInitialize(LOG_FILE_PATH, true);
    HANDLE_ERROR(result);

    s64 fileSize;
    fileSize = file.GetSize();
    NN_LOG("fileSize = %lld", fileSize);
    result = file.TrySetPosition(fileSize);
    HANDLE_ERROR(result);

    // シリアルナンバーの取得
    std::memset(s_SerialNo, '\0',
        nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN);
    result = nn::cfg::CTR::init::GetSerialNo(s_SerialNo);
    HANDLE_ERROR(result);
    if(result.IsSuccess())
    {
        s_CanReadSerialNumber = true;
    }

    // cal の情報取得
    {
        nn::drivers::cal::CTR::Calibration calibration;
        nn::drivers::cal::CTR::Type currentCalType;

        // Cal の初期化
        calibration.Initialize();

        //----- バージョンを取得
        s_CalVersion = calibration.GetVersion();

        //----- LCD FLICKER
        currentCalType = nn::drivers::cal::CTR::CAL_DATA_LCD_FLICKER;
        s_LcdFlickerInfoIsValid = calibration.Get(&s_LcdFlickerInfo, currentCalType);
    }

    if(s_LcdFlickerInfoIsValid)
    {
        s32 writeSize;
        char writeData[256];
        nn::nstd::TSNPrintf(writeData, sizeof(writeData), "%s, %d, %d\n", s_SerialNo, s_LcdFlickerInfo.vcomTop, s_LcdFlickerInfo.vcomBottom);
        NN_LOG("%s", writeData);
        // SD書き込み
        result = file.TryWrite(&writeSize, writeData, std::strlen(writeData), true);
        HANDLE_ERROR(result);
        result = file.TryFlush();
        HANDLE_ERROR(result);

        file.Finalize();
    }

    u32 count = 0;
    for (;;)
    {
        s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY0);
        s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 0, 0, 0, 1);
        s_RenderSystem.Clear();

        s_RenderSystem.DrawText(0, 0, "count = %d", count++);
        if(s_CanReadSerialNumber)
        {
            s_RenderSystem.DrawText(0, 10, "serial = %s", s_SerialNo);
        }
        s_RenderSystem.DrawText(0, 20, "calVersion = %d\n", s_CalVersion);
        s_RenderSystem.DrawText(0, 30, "Flicker = %d, %d", s_LcdFlickerInfo.vcomTop, s_LcdFlickerInfo.vcomBottom);
        s_RenderSystem.SwapBuffers();

        s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY1);
        s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 0, 1, 0, 1);
        s_RenderSystem.Clear();


        s_RenderSystem.SwapBuffers();
        nngxWaitVSync(NN_GX_DISPLAY_BOTH);

        //POWER ボタン対応
        if ( nn::applet::IsExpectedToCloseApplication())
        {
            nn::applet::PrepareToCloseApplication();
            nn::applet::CloseApplication();
        }
    }

}