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/srv.h>
#include <nn/applet.h>
#include <nn/fs/CTR/fs_ArchiveTypesForSystem.h>
#include <nn/fs/CTR/MPCore/fs_FileSystemBasePrivate.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];
bit64 s_TranferableId;
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::Result result;

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

    // ServiceManagerプロセスの初期化
    result = nn::srv::Initialize();
    HANDLE_ERROR(result);

    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);

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

    // NAND マウント
    // nand:/ro/ のマウント
    result = nn::fs::MountSpecialArchive("nandro:", nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND_RO);
    if ( result.IsFailure() )
    {
        NN_LOG_WARN("[CFG] Mount nand:/ro failed.\n");
        nn::dbg::PrintResult(result);
    }

    NN_LOG("Before %d, %d\n", s_LcdFlickerInfo.vcomTop, s_LcdFlickerInfo.vcomBottom);
    // 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);
    }

    // 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\n", fileSize);
    result = file.TrySetPosition(fileSize);
    HANDLE_ERROR(result);

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

    // シリアルナンバーの取得
    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;
    }

    // 移行可能IDの取得
    s_TranferableId = nn::cfg::CTR::GetTransferableId(0);

    if(s_LcdFlickerInfoIsValid)
    {
        s32 writeSize;
        char writeData[256];
        nn::nstd::TSNPrintf(writeData, sizeof(writeData), "%s, %llx, %0x, %0x\n", s_SerialNo, s_TranferableId,
                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();
    }
    NN_LOG("After %0x, %0x\n", s_LcdFlickerInfo.vcomTop, s_LcdFlickerInfo.vcomBottom);

    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, "TransferableId = %llx\n", s_TranferableId);
        s_RenderSystem.DrawText(0, 30, "calVersion = %d\n", s_CalVersion);
        s_RenderSystem.DrawText(0, 40, "Flicker = %0x, %0x", 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();
        }
    }

}