diff --git a/tags/0thNUP/CardCup/CardCup.bsf b/tags/0thNUP/CardCup/CardCup.bsf new file mode 100644 index 0000000..104a94d Binary files /dev/null and b/tags/0thNUP/CardCup/CardCup.bsf differ diff --git a/tags/0thNUP/CardCup/CardCup.rsf b/tags/0thNUP/CardCup/CardCup.rsf new file mode 100644 index 0000000..88792b8 --- /dev/null +++ b/tags/0thNUP/CardCup/CardCup.rsf @@ -0,0 +1,22 @@ +BasicInfo: + Title : CupCardDemo + BackupMemoryType : None + Logo: Nintendo + +TitleInfo: + Use: Evaluation + UniqueId: 0xf802a + Version: 0 + +SystemControlInfo: + AppType : System + Dependency: + - codec + - hid + - gsp + - dsp + +AccessControlInfo: + Priority: 48 + FileSystemAccess: + - CategorySystemApplication diff --git a/tags/0thNUP/CardCup/OMakefile b/tags/0thNUP/CardCup/OMakefile new file mode 100644 index 0000000..bb62ff4 --- /dev/null +++ b/tags/0thNUP/CardCup/OMakefile @@ -0,0 +1,46 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakefile +# +# Copyright (C)2009 Nintendo Co., Ltd. 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$ +#---------------------------------------------------------------------------- +CTR_APPTYPE=BOTH +CTR_MAKE_DEVELOPMENT_IMAGE = true + +SUPPORTED_TARGETS = CTR-T*.Process.MPCore.* + +SAMPLED_DEMOS_COMMON_INCLUDE_DIR = $(dir $(HORIZON_ROOT)/../CTR/SampleDemos/common/include) +INCLUDES += $(SAMPLED_DEMOS_COMMON_INCLUDE_DIR) + +SOURCES[] = + main.cpp + scrollBuffer.cpp + +LIBS += lib_demo \ + libnn_am \ + libnn_cup \ + libnn_ns \ + libnn_ps + + +DESCRIPTOR = $(HORIZON_ROOT)/resources/specfiles/HomeMenuTest.desc + +TARGET_PROGRAM = CardCup + +TITLE = CardCup +ROM_SPEC_FILE = CardCup.rsf + +CTR_BANNER_SPEC = $(TARGET_PROGRAM).bsf + +include $(ROOT_OMAKE)/modulerules + +build: $(DEFAULT_TARGETS) diff --git a/tags/0thNUP/CardCup/OMakeroot b/tags/0thNUP/CardCup/OMakeroot new file mode 100644 index 0000000..7ee1cb5 --- /dev/null +++ b/tags/0thNUP/CardCup/OMakeroot @@ -0,0 +1,73 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakeroot +# +# Copyright (C)2009 Nintendo Co., Ltd. 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:$ +#---------------------------------------------------------------------------- + +# ディレクトリレイアウトについての説明 +# +# a) ソースコードがルートディレクトリ直下に配置される場合 +# 例: +# /OMakeroot +# /foo/bar/OMakefile +# +# 結果: +# OMakefile と同じディレクトリ以下に objects や images が生成されます。 +# +# /foo/bar/objects/... +# /foo/bar/images/.. +# +# +# b) ソースコードが sources 以下に配置される場合 +# 例: +# /OMakeroot +# /sources/foo/bar/OMakefile +# +# 結果: +# ルートディレクトリ以下に objects や images が生成されます。 +# +# /objects/foo/bar/... +# /images/foo/bar/... +# +# + +# ルート環境変数の取得 +public.HORIZON_ROOT = +if $(defined-env HORIZON_ROOT) + HORIZON_ROOT = $(absname $(getenv HORIZON_ROOT)) + export + +if $(defined-env CTRSDK_ROOT) + CTRSDK_ROOT = $(absname $(getenv CTRSDK_ROOT)) + if $(and $(defined-env HORIZON_ROOT), $(not $(equal $(HORIZON_ROOT), $(CTRSDK_ROOT)))) + eprintln(HORIZON_ROOT と CTRSDK_ROOT が一致しません。同じパスを設定するか、どちらか一方だけを定義して下さい。) + exit(1) + HORIZON_ROOT = $(CTRSDK_ROOT) + export + +if $(not $(HORIZON_ROOT)) + eprintln($"$$CTRSDK_ROOT が定義されていません") + exit(1) + +include $(HORIZON_ROOT)/build/omake/commondefs + +DefineCommandVars() + +.PHONY: all build clean clobber +.PHONY: run run-scripts run-emumem + +# +# OMakefile の読み込み +# +.SUBDIRS: . + diff --git a/tags/0thNUP/CardCup/banner/model.cbmd b/tags/0thNUP/CardCup/banner/model.cbmd new file mode 100644 index 0000000..f1c7b62 Binary files /dev/null and b/tags/0thNUP/CardCup/banner/model.cbmd differ diff --git a/tags/0thNUP/CardCup/banner/sound.cbsd b/tags/0thNUP/CardCup/banner/sound.cbsd new file mode 100644 index 0000000..f1c7b62 Binary files /dev/null and b/tags/0thNUP/CardCup/banner/sound.cbsd differ diff --git a/tags/0thNUP/CardCup/banner/unknown24x24.ctpk b/tags/0thNUP/CardCup/banner/unknown24x24.ctpk new file mode 100644 index 0000000..794b136 --- /dev/null +++ b/tags/0thNUP/CardCup/banner/unknown24x24.ctpk @@ -0,0 +1 @@ +ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆ8ﾆ8ﾆﾞ銷ｽｽ8ﾆｽｽｽｽｽ釡ﾞﾆ鍄踟ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽyﾎｽyﾎｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ鍄ﾞyﾎYﾎｽﾛﾞﾛﾞｽｽﾆｽｽﾛﾞyﾎﾞｽyﾎ轌ﾎ釡ﾞｽｽｽｽYﾎ轌ﾎ銷ｽｽｽｽｽyﾎﾆﾛﾞ鍄躡ﾎyﾎｽｽｽyﾎｽｺﾖｽｽｽｽｽyﾎｽyﾎｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽyﾎ躡ﾎ銷ｽｽｽｽｽﾆｽｽ轌ﾎ8ﾆｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ \ No newline at end of file diff --git a/tags/0thNUP/CardCup/banner/unknown48x48.ctpk b/tags/0thNUP/CardCup/banner/unknown48x48.ctpk new file mode 100644 index 0000000..8c7da16 --- /dev/null +++ b/tags/0thNUP/CardCup/banner/unknown48x48.ctpk @@ -0,0 +1 @@ +ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽ8ﾆ8ﾆｽｽｽｺﾖ8ﾆｺﾖ釡ﾞ銷ｽｽｽｽｽｽｽｽｽｽ8ﾆ8ﾆｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ鍄逧ﾖﾆ銷ｽｽ墮ｽ逧ﾖ銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞｽﾛﾞｽｽｽｽｽ銷ｽﾞｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｺﾖｽｽｽｽｽｽｽｽｽｽ鍄8ﾆﾞﾛﾞｽｽ墮ｽYﾎｽｽｽｽｽ躡ﾎyﾎ轌ﾎﾆｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞﾛﾞ釡ﾞ踟ｽｽ躡ﾎ銷ｽｽｽｽｽﾛﾞｽﾛﾞ銷ｽｽYﾎﾞ墮釡ﾞｺﾖｽ墮ｽﾛﾞｽｽｽｽｽ踟ｽ踟ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞｽyﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽYﾎｽ墮銷ｽﾛﾞｽﾛﾞ銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｺﾖﾛﾞｽｽｽｽｽYﾎﾆyﾎ逧ﾖ郤ﾖｽYﾎｽ觝ﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞ墮ｽｽｽｽｽｽyﾎｽ鍄踟ｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ踟ｽ銷ｽﾞｽYﾎ鍄銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽ逧ﾖｽﾛﾞｽ釡ﾞ墮ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ \ No newline at end of file diff --git a/tags/0thNUP/CardCup/main.cpp b/tags/0thNUP/CardCup/main.cpp new file mode 100644 index 0000000..e0cb634 --- /dev/null +++ b/tags/0thNUP/CardCup/main.cpp @@ -0,0 +1,269 @@ +ｻｿ/*---------------------------------------------------------------------------* + Project: Horizon + File: main.cpp + + Copyright (C)2009 Nintendo Co., Ltd. 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "demo.h" +#include "scrollBuffer.h" + +namespace +{ + const int s_GxHeapSize=0x800000; + nn::fnd::ExpHeap s_appHeap; + uptr s_GxHeap; + + demo::RenderSystemDrawing s_RenderSystem; + ScrollBuffer s_scrollBufferInstance; + ScrollBuffer *s_scrollBuffer; + + char s_updaterBuffer[1<<20] NN_ATTRIBUTE_ALIGN(4096); + + // 繝繝｢縺ｮ蛻晄悄蛹 + void Initialize() + { + // os 縺ｮ蛻晄悄蛹 + nn::os::Initialize(); + + // NuiShell縺ｮ蛻晄悄蛹 (CUP縺ｫ蠢鬆) + NN_UTIL_PANIC_IF_FAILED(nn::ns::CTR::InitializeForShell()); + + // fs縺ｮ蛻晄悄蛹 (繧ｫ繝ｼ繝臥｢ｺ隱咲畑) + nn::fs::Initialize(); + + // applet縺ｮ蛻晄悄蛹 + //nn::applet::InitializeForSystem( nn::applet::PHOME_MENU_APPLET_ID, nn::applet::TYPE_SYS ); + //nn::applet::Initialize( nn::applet::TEST2_APPLET_ID); + //nn::applet::SetAppletMode(); + nn::applet::Enable(); + + // 繝繝舌う繧ｹ繝｡繝｢繝ｪ縺ｮ險ｭ螳 + const int DEVICE_MEMORY_SIZE = 12*1024 * 1024; + NN_UTIL_PANIC_IF_FAILED(nn::os::SetDeviceMemorySize(DEVICE_MEMORY_SIZE)); + + // 繝偵ｼ繝励ｮ蛻晄悄蛹 + s_appHeap.Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR); + + // 謠冗判繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ蛻晄悄蛹 + s_GxHeap = reinterpret_cast(s_appHeap.Allocate(s_GxHeapSize)); + s_RenderSystem.Initialize(s_GxHeap, s_GxHeapSize); + + // hid縺ｮ蛻晄悄蛹 + NN_UTIL_PANIC_IF_FAILED(nn::hid::Initialize()); + + // 謠冗判繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ蛻晄悄蛹 + s_scrollBufferInstance.Initialize(&s_RenderSystem); + s_scrollBuffer=&s_scrollBufferInstance; + + // GPU蛻ｩ逕ｨ螳｣險 + nn::applet::AssignGpuRight(); + } + + // 豸郁ｲｻ譎る俣蜿門ｾ礼畑髢｢謨ｰ鄒､ + s64 s_StartTick; + void SetTick() + { + s_StartTick=nn::os::Tick::GetSystemCurrent(); + } + s64 GetConsumedMillisec() + { + s64 endTick=nn::os::Tick::GetSystemCurrent(); + nn::os::Tick consumed(endTick-s_StartTick); + return ((nn::fnd::TimeSpan)consumed).GetMilliSeconds(); + } + + // 蜍輔＞縺ｦ縺繧九％縺ｨ繧堤衍繧峨○繧九◆繧√ｮ縲√￥繧九￥繧狗判髱｢陦ｨ遉ｺ蜿門ｾ礼畑繝｡繧ｽ繝繝 + const char s_progress[]="-\\|/"; + int s_progressIndex=0; + char GetProgressChar() + { + s_progressIndex=(s_progressIndex+1)%(sizeof(s_progress)-1); + return s_progress[s_progressIndex]; + } + + nn::Result UpdateCore() + { + nn::Result result; + nn::cup::ProgressInfo info; + + /********************** 繧｢繝繝励ョ繝ｼ繝*******************/ + SetTick(); + s_scrollBuffer->AppendText("Start Card Update")->Render(); + NN_UTIL_RETURN_IF_FAILED(nn::cup::CTR::DoUpdate()); + + // 繧ｹ繝繝ｼ繧ｿ繧ｹ縺郡tarted縺ｫ縺ｪ繧九∪縺ｧ縲√励Ο繧ｰ繝ｬ繧ｹ縺ｯ蜿門ｾ励〒縺阪↑縺 + s_scrollBuffer->AppendText(""); + do{ + s_scrollBuffer->ReplaceText(" %c Initializing", GetProgressChar())->Render(); + result = nn::cup::CTR::GetProgressInfo(&info); + NN_UTIL_RETURN_IF_FAILED(result); + nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromMilliSeconds(40)); + }while(info.state==nn::cup::CTR::UPDATE_STATE_INITIALIZING); + + // 謚懊¢縺滄圀縺ｮstate縺熊AILED縺九←縺縺狗｢ｺ隱 + if(info.state==nn::cup::CTR::UPDATE_STATE_FAILED){ + NN_UTIL_RETURN_IF_FAILED(info.lastResult); + } + s_scrollBuffer->ReplaceText(" - Initialized (%lldmsec)", GetConsumedMillisec()); + + /********************* 繧｢繝繝励ョ繝ｼ繝井ｸｭ ******************/ + SetTick(); + s_scrollBuffer->AppendText("")->Render(); + do{ + result = nn::cup::CTR::GetProgressInfo(&info); + NN_UTIL_RETURN_IF_FAILED(result); + s_scrollBuffer->ReplaceText(" %c Title %d/%d, size %lld/%lld", + GetProgressChar(), + info.numImportedTitles, info.numTotalTitles, + info.importedSize, info.totalSize)->Render(); + nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromMilliSeconds(40)); + + }while(info.state==nn::cup::CTR::UPDATE_STATE_STARTED); + // 謚懊¢縺滄圀縺ｮstate縺熊AILED縺九←縺縺狗｢ｺ隱 + if(info.state==nn::cup::CTR::UPDATE_STATE_FAILED){ + NN_UTIL_RETURN_IF_FAILED(info.lastResult); + } + s_scrollBuffer->AppendText(" - Imported (%lldmsec)", GetConsumedMillisec())->Render(); + + /***************** 繧｢繝繝励ョ繝ｼ繝育ｵゆｺ荳ｭ ******************/ + SetTick(); + s_scrollBuffer->AppendText("")->Render(); + do{ + result = nn::cup::CTR::GetProgressInfo(&info); + NN_UTIL_RETURN_IF_FAILED(result); + s_scrollBuffer->ReplaceText(" %c Update Finalizing", GetProgressChar())->Render(); + nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromMilliSeconds(40)); + }while(info.state==nn::cup::CTR::UPDATE_STATE_FINALIZING); + // 謚懊¢縺滄圀縺ｮstate縺熊AILED縺九←縺縺狗｢ｺ隱 + if(info.state==nn::cup::CTR::UPDATE_STATE_FAILED){ + NN_UTIL_RETURN_IF_FAILED(info.lastResult); + } + + /******************* 繧｢繝繝励ョ繝ｼ繝育ｵゆｺ *******************/ + s_scrollBuffer->AppendText(" - Finalized (%lldmsec)", GetConsumedMillisec())->Render(); + s_scrollBuffer->AppendText(""); + + return nn::ResultSuccess(); + } + + nn::Result UpdateSequence(bool *isHandledError) + { + nn::Result result; + nn::Result lastResult=nn::ResultSuccess(); + nn::hid::PadReader padReader; + + /********************* CUP縺ｮ蛻晄悄蛹 *******************/ + s_scrollBuffer->AppendText("Initializing Cup Library")->Render(); + SetTick(); // 蛻晄悄蛹夜幕蟋句燕縺ｮ譎る俣繧偵そ繝繝 + result=nn::cup::CTR::Initialize(s_updaterBuffer,sizeof(s_updaterBuffer)); + if(result==nn::cup::CTR::ResultUpdatePartitionNotFound()){ + s_scrollBuffer->AppendText(" - Update Partition Not Found (%lldmsec)", GetConsumedMillisec())->Render(); + s_scrollBuffer->AppendText("")->Render(); + *isHandledError=true; + return result; + } + if(result==nn::cup::CTR::ResultUpdateNotRequired()){ + s_scrollBuffer->AppendText(" - Already Updated (%lldmsec)", GetConsumedMillisec())->Render(); + s_scrollBuffer->AppendText("")->Render(); + *isHandledError=true; + return result; + } + if(result==nn::cup::CTR::ResultInvalidUpdatePartitionFormat()){ + s_scrollBuffer->AppendText(" - Invalid Update Partition (%lldmsec)", GetConsumedMillisec())->Render(); + s_scrollBuffer->AppendText("")->Render(); + *isHandledError=true; + return result; + } + NN_UTIL_RETURN_IF_FAILED(result); + + s_scrollBuffer->AppendText(" - Need Update (%lldmsec)", GetConsumedMillisec())->Render(); + s_scrollBuffer->AppendText("")->Render(); + + lastResult=UpdateCore(); + + // Initialize縺ｫ謌仙粥縺励◆蝣ｴ蜷医ｮ縺ｿ縲∝阪ｳInitialize縺吶ｋ縺溘ａ縺ｫFinalize縺悟ｿ隕 + SetTick(); + s_scrollBuffer->AppendText("Finalizing Cup Library")->Render(); + NN_UTIL_RETURN_IF_FAILED(nn::cup::CTR::Finalize()); + s_scrollBuffer->AppendText(" - Complete (%lldmsec)", GetConsumedMillisec())->Render(); + s_scrollBuffer->AppendText("")->Render(); + + return lastResult; + } +} + +extern "C" void nnMain() +{ + NN_LOG("Start cup demo\n"); + nn::Result result; + Initialize(); + + /******************** CUP縺ｮ螳溯｡ *******************/ + bool isHandledError = false; + result = UpdateSequence(&isHandledError); + if (isHandledError == false && result.IsFailure()) + { + { + // 縺昴ｌ莉･螟悶ｮ蝣ｴ蜷医ｯ縲ヽesult繧定｡ｨ遉ｺ + s_scrollBuffer->AppendText(" - Unhandled Error: 0x%08x", result.GetPrintableBits()); + s_scrollBuffer->AppendText("")->Render(); + } + } + + s_scrollBuffer->AppendText("")->Render(); + + for(;;) + { + s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY0); + if(result.IsSuccess() || result == nn::cup::CTR::ResultUpdateNotRequired()) + { + s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 0, 1, 0, 1); + } + else + { + s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 1, 0, 0, 1); + } + s_RenderSystem.Clear(); + s_RenderSystem.SwapBuffers(); + s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY1); + if(result.IsSuccess() || result == nn::cup::CTR::ResultUpdateNotRequired()) + { + s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 0, 1, 0, 1); + } + else + { + s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 1, 0, 0, 1); + } + s_scrollBuffer->ReplaceText("%c Finished", GetProgressChar())->Render(); + + if ( nn::applet::IsExpectedToCloseApplication() ) + { + nn::applet::PrepareToCloseApplication(); + nn::applet::CloseApplication(); + } + + } +} diff --git a/tags/0thNUP/CardCup/scrollBuffer.cpp b/tags/0thNUP/CardCup/scrollBuffer.cpp new file mode 100644 index 0000000..54de11e --- /dev/null +++ b/tags/0thNUP/CardCup/scrollBuffer.cpp @@ -0,0 +1,89 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: scrollBuffer.cpp + + Copyright (C)2009 Nintendo Co., Ltd. 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 +#include "scrollBuffer.h" + +using namespace std; + +char ScrollBuffer::s_buffers[MAX_BUFFER_LINE][MAX_BUFFER_CHARS]; + +char *ScrollBuffer::GetFormattedString(const char *fmt, va_list arg) +{ + static char formattedBuffer[MAX_BUFFER_CHARS]; + vsnprintf(formattedBuffer, MAX_BUFFER_CHARS, fmt, arg); + return formattedBuffer; +} + +ScrollBuffer *ScrollBuffer::Update() +{ + return this; +} + +ScrollBuffer *ScrollBuffer::AppendText(const char *fmt, ...) +{ + va_list vlist; + va_start(vlist, fmt); + + int nextPosition=(m_tail+1)%MAX_BUFFER_LINE; + if(nextPosition==m_head){ + // 繝倥ャ繝峨→繝薙Η繝ｼ縺ｮ遘ｻ蜍 + if(m_head==m_currentView){ + m_currentView=(m_head+1)%MAX_BUFFER_LINE; + } + m_head=(m_head+1)%MAX_BUFFER_LINE; + + } + strlcpy(s_buffers[m_tail], GetFormattedString(fmt, vlist), MAX_BUFFER_CHARS); + m_tail=nextPosition; + NN_LOG("cup: %s\n", GetFormattedString(fmt, vlist)); + + // 繝薙Η繝ｼ縺ｮ遘ｻ蜍 + if((m_currentView+MAX_DISPLAY_LINES)%MAX_BUFFER_LINE==m_tail){ + m_currentView=(m_currentView+1)%MAX_BUFFER_LINE; + } + + return this; +} +ScrollBuffer *ScrollBuffer::ReplaceText(const char *fmt, ...) +{ + va_list vlist; + va_start(vlist, fmt); + + NN_ASSERT(m_tail!=m_head); + strlcpy(s_buffers[(m_tail-1)%MAX_BUFFER_LINE], GetFormattedString(fmt, vlist), MAX_BUFFER_CHARS); + + return this; +} + +void ScrollBuffer::Render() +{ + // 謠冗判蜑榊ｦ逅 + m_render->SetRenderTarget(NN_GX_DISPLAY1); + m_render->Clear(); + m_render->SetColor(1.0f, 1.0f, 1.0f, 1.0f); + + // 繝ｪ繝ｳ繧ｰ繝舌ャ繝輔ぃ縺ｪ縺ｮ縺ｧ縲∫ｵらｫｯ譚｡莉ｶ繧定ｪｿ謨ｴ + int tail=(m_tailDrawText(0, (i-m_currentView)*FONT_SIZE, s_buffers[i%MAX_BUFFER_LINE]); + } + } + + // 謠冗判霆｢騾 + m_render->SwapBuffers(); +} diff --git a/tags/0thNUP/CardCup/scrollBuffer.h b/tags/0thNUP/CardCup/scrollBuffer.h new file mode 100644 index 0000000..1d3563a --- /dev/null +++ b/tags/0thNUP/CardCup/scrollBuffer.h @@ -0,0 +1,55 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: scrollBuffer.h + + Copyright (C)2009 Nintendo Co., Ltd. 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$ + *---------------------------------------------------------------------------*/ + +#ifndef SCROLL_BUFFER_H_ +#define SCROLL_BUFFER_H_ + +#include "demo.h" +class ScrollBuffer +{ +private: + enum + { + MAX_BUFFER_LINE=128, + MAX_BUFFER_CHARS=80, + MAX_DISPLAY_LINES=20, + FONT_SIZE=12 + }; + // 陦ｨ遉ｺ譁蟄励ｮ繝舌ャ繝輔ぃ (繝ｪ繝ｳ繧ｰ繝舌ャ繝輔ぃ) + static char s_buffers[MAX_BUFFER_LINE][MAX_BUFFER_CHARS]; + int m_head; + int m_tail; + int m_currentView; + + demo::RenderSystemDrawing *m_render; + + char *GetFormattedString(const char *fmt, va_list arg); + +public: + ScrollBuffer() : + m_head(0), m_tail(0), m_currentView(0) + {} + void Initialize(demo::RenderSystemDrawing *render) + { + m_render=render; + } + + ScrollBuffer *Update(); // 繧ｭ繝ｼ蜈･蜉帙ｒ蜿らｧ縺励※縲√せ繧ｯ繝ｭ繝ｼ繝ｫ縺吶ｋ + ScrollBuffer *AppendText(const char *fmt, ...); // 譁蟄怜励ｒ霑ｽ蜉縺吶ｋ + ScrollBuffer *ReplaceText(const char *fmt, ...); // 譛譁ｰ縺ｮ譁蟄怜励ｒ鄂ｮ謠帙☆繧 + void Render(); // 繝ｬ繝ｳ繝繝ｪ繝ｳ繧ｰ +}; + +#endif // SCROLL_BUFFER_H diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.bsf b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.bsf new file mode 100644 index 0000000..104a94d Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.bsf differ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.cpp new file mode 100644 index 0000000..fcdfb38 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.cpp @@ -0,0 +1,442 @@ +ｻｿ/*---------------------------------------------------------------------------* + Project: Horizon + File: ConsoleBackup.cpp + + Copyright (C)2009 Nintendo Co., Ltd. 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "demo.h" + +#include +#include + +#include "ConsoleBackup.h" +#include "DrawSystemState.h" +#include "FileName.h" +#include "Controller.h" +#include "SimplePlayer.h" +#include "Exporter.h" +#include "CommonLogger.h" +#include "SDMountManager.h" +#include "HeapManager.h" +#include "PlayHistoryManager.h" +#include "common_Types.h" +#include "VersionDetect.h" +#include "HardwareInfo.h" + +// svn繝ｪ繝薙ず繝ｧ繝ｳ蝓九ａ霎ｼ縺ｿ逕ｨ +#include "version.h" +#ifndef BACKUP_VERSION_NUM +#define BACKUP_VERSION_NUM 0 +#endif + +namespace { + +// 繧ｰ繝ｩ繝輔ぅ繝繧ｯ繧ｹ縺ｫ蜑ｲ繧雁ｽ薙※繧九Γ繝｢繝ｪ +const size_t s_GxHeapSize = 0x800000; + + +// 繝舌ャ繝繝ｪ谿矩 +u8 batteryRemain = 100; + +// 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ +u8 s_SerialNo[nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN]; + +// 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺瑚ｪｭ繧√ｋ縺九←縺縺 +bool s_CanReadSerialNumber = false; + +// IVS縺ｸ縺ｮ繝昴う繝ｳ繧ｿ +void* sp_Ivs; + +size_t s_SizeofIvs; + +// IVS縺瑚ｪｭ繧√ｋ縺九←縺縺 +bool s_CanReadIvs = false; + +// 繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ +common::VerDef s_VerData; + +nn::Handle s_McuSession; + +} // namespace + +namespace ConsoleBackup{ + +bool IsAdapterConnected() +{ + return nn::ptm::CTR::GetAdapterState() == nn::ptm::CTR::ADAPTERSTATE_CONNECTED; +} + +bool IsBatteryLower() +{ + return batteryRemain <= 10; +} + +bool CanReadIVS() +{ + return s_CanReadIvs; +} + +bool CanReadSerialNumber() +{ + return s_CanReadSerialNumber; +} + +void GetSerialNumber(u8** serial, size_t* size) +{ + *serial = s_SerialNo; + *size = nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN; +} + +void GetIvs(void** ivs, size_t* size) +{ + *ivs = sp_Ivs; + *size = s_SizeofIvs; +} + +void GetVersionData(common::VerDef* version) +{ + *version = s_VerData; +} + +nn::Handle GetMcuHandle() +{ + return s_McuSession; +} + + +extern "C" void nnMain(void) +{ + nn::Result result; + + // os 縺ｮ蛻晄悄蛹 + nn::os::Initialize(); + + // fs 縺ｮ蛻晄悄蛹 + nn::fs::Initialize(); + + // applet縺ｮ蛻晄悄蛹 + nn::applet::Enable( false ); + + // hid 縺ｮ蛻晄悄蛹 + result = nn::hid::Initialize(); + NN_UTIL_PANIC_IF_FAILED(result); + + // ndm縺ｮ蛻晄悄蛹 + result = nn::ndm::Initialize(); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + + // 繝繝ｼ繝｢繝ｳ縺ｮ閾ｪ蠕句虚菴懊ｒ蛛懈ｭ｢ + result = nn::ndm::Suspend(nn::ndm::DN_CEC); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + result = nn::ndm::Suspend(nn::ndm::DN_BOSS); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + result = nn::ndm::Suspend(nn::ndm::DN_FRIENDS); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + result = nn::ndm::Suspend(nn::ndm::DN_NIM); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + + // cfg 縺ｮ蛻晄悄蛹 + nn::cfg::CTR::init::Initialize(); + nn::cfg::CTR::system::Initialize(); + + // 譎りｨ郁ｨｭ螳夂畑ptm蛻晄悄蛹 + nn::ptm::CTR::InitializeForSystemMenu(); + + // ps 縺ｮ蛻晄悄蛹 + nn::ps::Initialize(); + + // friends縺ｮ蛻晄悄蛹 + result = nn::friends::detail::Initialize(); + + // mcu縺ｮ蛻晄悄蛹 + nn::mcu::CTR::InitializeHwCheck(&s_McuSession); + + nn::mcu::CTR::HwCheck mcu(s_McuSession); + + // 繝偵ｼ繝励ｮ遒ｺ菫 + common::HeapManager::GetHeap()->Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR); + + // RenderSystem 縺ｮ貅門ｙ + uptr heapForGx = reinterpret_cast(common::HeapManager::GetHeap()->Allocate(s_GxHeapSize)); + demo::RenderSystemDrawing s_RenderSystem; + s_RenderSystem.Initialize(heapForGx, s_GxHeapSize); + + // 繧ｵ繧ｦ繝ｳ繝峨せ繝ｬ繝繝峨ｮ襍ｷ蜍 + common::InitializeSimplePlayer(); + + // 繝ｭ繧ｰ謠冗判縺ｮ蛻晄悄蛹 + common::Logger::GetLoggerInstance()->Initialize(CONSOLE_WIDTH, CONSOLE_HEIGHT, CONSOLE_MAX_LINE, &s_RenderSystem); + + // RenderSystem繧剃ｽ懊▲縺ｦ縺九ｉ繝ｭ繧ｰ縺悟ｺ縺帙ｋ + common::Logger::InitializeEjectThread(); + common::Logger::SetEjectHandler(OnSdEjected); + // 襍ｷ蜍墓凾縺ｫ蜑企勁 + common::Logger::GetLoggerInstance()->ClearLog(); + + COMMON_LOGGER("\n"); + COMMON_LOGGER("CTR Console Backup start\n"); + + // 繝懊ち繝ｳ蜈･蜉 + nn::hid::PadReader s_PadReader; + nn::hid::PadStatus padStatus; + + // 繝繝ｼ繧ｿ縺ｮ貅門ｙ + + // 螳悟ｨ諤ｧ讀懆ｨｼSEED縺ｮ蜿門ｾ + result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); + if (result.IsSuccess()) + { + nn::fs::FileInputStream fis; + + result = fis.TryInitialize(common::IVS_NAND_PATHNAME); + if (result.IsSuccess()) + { + s64 fileSize = fis.GetSize(); + s32 ret; + void* addr = NULL; + addr = common::HeapManager::GetHeap()->Allocate(fileSize); + if (addr != NULL) + { + sp_Ivs = addr; + s_SizeofIvs = fileSize; + result = fis.TryRead(&ret, addr, fileSize); + if (result.IsSuccess()) + { + s_CanReadIvs = true; + } + // 蠕後〒IVS繧貞盾辣ｧ縺吶ｋ縺ｮ縺ｧFree縺励↑縺 + } + } + fis.Finalize(); + } + // 荳譌ｦ繧｢繝ｳ繝槭え繝ｳ繝医＠縺ｦ縺翫￥ + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + + // 繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ縺ｮ蜿門ｾ + nn::cfg::CTR::CfgRegionCode region; + region = nn::cfg::CTR::GetRegion(); + + // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺ｮ蜿門ｾ + std::memset(s_SerialNo, '\0', + nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN); + result = nn::cfg::CTR::system::GetSerialNo(s_SerialNo); + if(result.IsSuccess()) + { + s_CanReadSerialNumber = true; + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + common::HardwareInfo hwInfo; + hwInfo.AddCheckDigit(reinterpret_cast(s_SerialNo)); + + // 繝繝舌う繧ｹID縺ｮ蜿門ｾ + bit32 deviceId; + result = nn::ps::CTR::GetDeviceId(&deviceId); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + bit64 infraDeviceId; + result = nn::nim::CTR::InitializeForShop(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + result = nn::nim::CTR::Shop::GetInfraDeviceId(deviceId, &infraDeviceId); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + result = nn::nim::CTR::FinalizeForShop(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // MAC繧｢繝峨Ξ繧ｹ縺ｮ蜿門ｾ + nn::nwm::Mac mac; + char8 macAddress[nn::nwm::Mac::MAC_STRING_SIZE]; + + result = nn::nwm::GetMacAddress(mac); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + mac.GetString(macAddress); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // 繝輔Ξ繝ｳ繝峨さ繝ｼ繝峨ｮ蜿門ｾ + nn::friends::CTR::FriendKey friendKey; + result = nn::friends::CTR::GetMyFriendKey(&friendKey); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + u64 friendCode = nn::friends::CTR::FriendKeyToFriendCode(friendKey); + + // 繝舌ｼ繧ｸ繝ｧ繝ｳ縺ｮ蜿門ｾ + common::GetSystemVersion(&s_VerData, region); + + // 諠蝣ｱ蜃ｺ蜉 + COMMON_LOGGER("CTR Console Backup %s Rev.%s\n", __DATE__, BACKUP_VERSION_NUM); + COMMON_LOGGER("System Ver. %d.%d.%d-%d\n", s_VerData.cup.majorVersion, s_VerData.cup.minorVersion, s_VerData.cup.microVersion, + s_VerData.nup.majorVersion); + COMMON_LOGGER("System Region %s\n", nn::cfg::CTR::GetRegionCodeA3(region)); + COMMON_LOGGER("Serial Number %s\n", s_SerialNo); + COMMON_LOGGER("Device ID %llu\n", infraDeviceId); + COMMON_LOGGER("MAC Address %s\n", macAddress); + COMMON_LOGGER("Friend Code %04u-%04u-%04u\n", + static_cast(friendCode / 100000000ULL % 10000ULL), + static_cast(friendCode / 10000ULL % 10000ULL), + static_cast(friendCode % 10000ULL) ); + + + bool flip = false; + bool continueBackup = false; + + for(;;) + { + bool nextStep = false; + s_PadReader.ReadLatest(&padStatus); + + // A縺ｾ縺溘ｯSTART繝懊ち繝ｳ縺ｧ騾ｲ陦 + if(padStatus.trigger & nn::hid::BUTTON_A || + padStatus.trigger & nn::hid::BUTTON_START) + { + nextStep = true; + } + + // L縺ｾ縺溘ｯR繝懊ち繝ｳ縺ｧ荳贋ｸ狗判髱｢繝輔Μ繝繝 + if(padStatus.trigger & nn::hid::BUTTON_R || + padStatus.trigger & nn::hid::BUTTON_L) + { + flip = !flip; + } + + // 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ + if(padStatus.hold & nn::hid::BUTTON_UP) + { + common::Logger::GetLoggerInstance()->ScrollUp(); + } + + // 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ + if(padStatus.hold & nn::hid::BUTTON_DOWN) + { + common::Logger::GetLoggerInstance()->ScrollDown(); + } + + if(padStatus.hold & nn::hid::BUTTON_LEFT) + { + common::Logger::GetLoggerInstance()->ScrollToBegin(); + } + + if(padStatus.hold & nn::hid::BUTTON_RIGHT) + { + common::Logger::GetLoggerInstance()->ScrollToEnd(); + } + + + // 諠蝣ｱ譖ｴ譁ｰ + // 繝舌ャ繝繝ｪ + mcu.GetBatteryRemain(&batteryRemain); + // AC繧｢繝繝励ち + std::string adapterState; + if(IsAdapterConnected()) + { + adapterState += ::std::string("Connected"); + } + else + { + adapterState += ::std::string("Not Connected"); + } + + // 謫堺ｽ懃畑繝｡繝繧ｻ繝ｼ繧ｸ + // 騾ｲ謐礼｢ｺ隱阪Γ繝繧ｻ繝ｼ繧ｸ繧貞ｼ縺ｭ繧具ｼ + ::std::vector operationMessage; + + ControlState(operationMessage, nextStep, continueBackup); + + nn::util::FloatColor titleColor; + + titleColor.r = 0.3f; + titleColor.g = 0.f; + titleColor.b = 0.2f; + + // 荳顔判髱｢陦ｨ遉ｺ + common::DrawSystemState("CTR Console Backup", + s_RenderSystem, + titleColor, + flip, + adapterState, + BACKUP_VERSION_NUM, + &s_VerData, + batteryRemain, + infraDeviceId, + friendCode, + GetProgress(), + macAddress, + operationMessage, + region, + s_SerialNo + ); + + s_RenderSystem.SwapBuffers(); + + // 繝繝輔か繝ｫ繝医〒荳狗判髱｢縺ｫ謠冗判縺吶ｋ繧ゅｮ + s_RenderSystem.SetRenderTarget(common::GetRenderTarget(NN_GX_DISPLAY1, flip)); + if(IsBackupSucceeded()) + { + s_RenderSystem.SetClearColor(common::GetRenderTarget(NN_GX_DISPLAY1, flip), SUCCESS_COLOR); + } + if(IsBackupFailed()) + { + s_RenderSystem.SetClearColor(common::GetRenderTarget(NN_GX_DISPLAY1, flip), FAIL_COLOR); + } + s_RenderSystem.Clear(); + s_RenderSystem.SetColor(1.f, 1.f, 1.f); + + common::Logger::GetLoggerInstance()->DrawConsole(); + s_RenderSystem.SwapBuffers(); + + + s_RenderSystem.WaitVsync(NN_GX_DISPLAY_BOTH); + + // 髮ｻ貅宣聞謚ｼ縺励〒邨ゆｺ + if ( nn::applet::IsExpectedToCloseApplication()) + { + common::Logger::GetLoggerInstance()->Finalize(); + // 繧｢繝ｳ繝槭え繝ｳ繝 + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + nn::fs::Unmount(common::SDMC_ARCHIVE_NAME); + s_RenderSystem.Finalize(); + + nn::mcu::CTR::FinalizeHwCheck(&s_McuSession); + nn::friends::detail::Finalize(); + nn::ps::Finalize(); + nn::ptm::CTR::FinalizeForSystemMenu(); + nn::cfg::CTR::system::Finalize(); + nn::cfg::CTR::init::Finalize(); + nn::hid::Finalize(); + nn::fs::Finalize(); + + nn::applet::PrepareToCloseApplication(); + nn::applet::CloseApplication(); + } + } +} + + +} diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.h b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.h new file mode 100644 index 0000000..75f71c5 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.h @@ -0,0 +1,41 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: ConsoleBackup.h + + Copyright (C)2009 Nintendo Co., Ltd. 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$ + *---------------------------------------------------------------------------*/ + +#ifndef NN_CONSOLEBACKUP_H_ +#define NN_CONSOLEBACKUP_H_ + +#include +#include "VersionDetect.h" + +namespace ConsoleBackup +{ + +bool IsAdapterConnected(); +bool IsBatteryLower(); +bool CanReadIVS(); +bool CanReadSerialNumber(); +void GetSerialNumber(u8** serial, size_t* size); +void GetIvs(void** ivs, size_t* size); +nn::Handle GetMcuHandle(); +void GetVersionData(common::VerDef* version); + +const u32 CONSOLE_WIDTH = 38; +const u32 CONSOLE_HEIGHT = 24; +const u32 CONSOLE_MAX_LINE = 1000; + +} + +/* NN_CONSOLEBACKUP_H_ */ +#endif diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.rsf b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.rsf new file mode 100644 index 0000000..a30132a --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/ConsoleBackup.rsf @@ -0,0 +1,52 @@ +BasicInfo: + Title : ConsoleBackup + ProductCode: ConsoleBackup + BackupMemoryType: None + +TitleInfo: + Use: Evaluation + Category: Application + UniqueId: 0xf8021 + Version: 0 + +SystemControlInfo: + AppType : Application + StackSize : 0x4000 + Dependency : + - gpio + - pdn + - spi + - i2c + - mcu + - ptm + - codec + - cfg + - hid + - gsp + - friends + - nim + - ac + - ndm + +AccessControlInfo: + Priority : 16 + DisableDebug : true + + FileSystemAccess: + - DirectSdmc + - Debug + - Core + - CategoryFileSystemTool + + IoAccessControl: + - FsMountCardSpi + - FsMountNand + - FsMountTwln + +Option: + FreeProductCode: true + + +Rom: + # ROM 縺ｫ蜷ｫ繧√ｋ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｮ繝ｫ繝ｼ繝医ヱ繧ｹ繧呈欠螳壹＠縺ｾ縺吶 + HostRoot: "$(ROMFS_ROOT)" \ No newline at end of file diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Controller.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Controller.cpp new file mode 100644 index 0000000..32cd6b5 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Controller.cpp @@ -0,0 +1,313 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Controller.cpp + + Copyright 2009 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 "Controller.h" +#include "FileChecker.h" +#include "ConsoleBackup.h" +#include "Exporter.h" +#include "SimplePlayer.h" +#include "CommonLogger.h" + +#include + +namespace ConsoleBackup +{ + +namespace +{ + +typedef enum BackupState +{ + STARTUP, // 蛻晄悄蛟､ + EXPORT_TWL_SOUND, // TWL繧ｵ繧ｦ繝ｳ繝蛾伜沺縺ｮ蜷ｸ蜃ｺ縺嶺ｸｭ + EXPORT_TWL_PHOTO, // TWL蜀咏悄鬆伜沺縺ｮ蜷ｸ蜃ｺ縺嶺ｸｭ + EXPORT_CTR_NAND, // 蜷ｸ蜃ｺ縺嶺ｸｭ + DELETE_NIM, // nim縺ｮ繧ｷ繧ｹ繝繝繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ蜑企勁 + DONE, // 蜷ｸ蜃ｺ縺怜ｮ御ｺ + FINISHED, // SD繧ｫ繝ｼ繝画栢縺榊ｮ御ｺ + FAIL // 螟ｱ謨 +} BackupState; + + +// APSetting縺ｮ譖ｸ蠑上′辟｡縺隴ｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_ExistAPSettingAnnotation = false; +// SD縺ｫ譖ｸ縺崎ｾｼ縺ｿ縺ｧ縺阪↑縺隴ｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_SdWriteProetctAnnotation = false; + +BackupState s_BackupState = STARTUP; +bool s_PlayedStartCursor = false; +bool s_PlayedSdPullOutCursor = false; +bool s_PlayedFinishedSound = false; +bool s_PlayedFailSound = false; + +} // namespace + +bool NeedsAcAdateper() +{ + return IsBatteryLower() && !IsAdapterConnected(); +} + +void ControlState(::std::vector& operationMessage, bool& nextStep, bool& continueBackup) +{ + // 迥ｶ諷矩ｷ遘ｻController + switch (s_BackupState) + { + + // 襍ｷ蜍墓凾 + case STARTUP: + { + bool error = false; + // 螳悟ｨ諤ｧ讀懆ｨｼSEED繧定ｪｭ繧√ｋ縺具ｼ + if (CanReadIVS()) + { + // SD繧ｫ繝ｼ繝峨′謖ｿ蜈･縺輔ｌ縺ｦ縺繧九°ｼ + if (nn::fs::IsSdmcInserted()) + { + // SD繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ縺ｿ縺ｧ縺阪ｋ縺具ｼ + if (!nn::fs::IsSdmcWritable()) + { + if (!s_SdWriteProetctAnnotation) + { + s_SdWriteProetctAnnotation = true; + common::PlaySound(common::SOUND_ANNOTATION); + } + operationMessage.push_back(::std::string("Can*t Write SD Card!!\n")); + break; + } + + // 辟｡邱夊ｨｭ螳壹ヵ繧｡繧､繝ｫ縺後≠繧九°ｼ + if (common::ExistsAPSetting()) + { + // 譖ｸ縺崎ｾｼ縺ｿ荳ｭ縺ｫ謚懊°縺ｪ縺繧医≧縺ｫ + if (nextStep) + { + // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ繧定ｪｭ縺ｿ蜿悶ｌ繧九°ｼ + if (!CanReadSerialNumber()) + { + common::PlaySound(common::SOUND_ANNOTATION); + COMMON_LOGGER("Can't Read Serial Number\n"); + } + } + } + else + { + error = true; + if (!s_ExistAPSettingAnnotation) + { + s_ExistAPSettingAnnotation = true; + common::PlaySound(common::SOUND_ANNOTATION); + } + operationMessage.push_back(::std::string("Accsess_Point_Setting does not exist!")); + } + } + else + { + error = true; + operationMessage.push_back(::std::string("Insert SD Card!!")); + } + } + else + { + error = true; + operationMessage.push_back(::std::string("Can't Read IVS!!")); + } + + // AC繧｢繝繝励ち縺悟ｿ隕√°ｼ + if (NeedsAcAdateper()) + { + error = true; + operationMessage.push_back(::std::string("Connect AC Adapter!!")); + } + + // 繧ｨ繝ｩ繝ｼ縺檎┌縺代ｌ縺ｰ騾ｲ陦檎畑繝｡繝繧ｻ繝ｼ繧ｸ陦ｨ遉ｺ + if(!error) + { + operationMessage.push_back(::std::string("Push A or START Button")); + if(!s_PlayedStartCursor) + { + common::PlaySound(common::SOUND_CURSOR); + s_PlayedStartCursor = true; + } + } + + if (nextStep && !error) + { + COMMON_LOGGER("Start Export Data\n"); + s_BackupState = EXPORT_TWL_SOUND; + } + } + break; + + // TWL繧ｵ繧ｦ繝ｳ繝蛾伜沺縺ｮ蜷ｸ蜃ｺ縺嶺ｸｭ + case EXPORT_TWL_SOUND: + { + static bool init = true; + if(init) + { + // 繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧 + ExportTwlSoundData(); + init = false; + } + + // 蜃ｦ逅縺悟ｮ御ｺ縺励◆ + if (IsExportFinished()) + { + FinalizeExportThread(); + s_BackupState = EXPORT_TWL_PHOTO; + } + } + break; + + // TWL蜀咏悄鬆伜沺縺ｮ蜷ｸ蜃ｺ縺嶺ｸｭ + case EXPORT_TWL_PHOTO: + { + static bool init = true; + if(init) + { + // 繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧 + ExportTwlPhotoData(); + init = false; + } + + // 蜃ｦ逅縺悟ｮ御ｺ縺励◆ + if (IsExportFinished()) + { + FinalizeExportThread(); + s_BackupState = EXPORT_CTR_NAND; + } + } + break; + + // 蜷ｸ蜃ｺ縺嶺ｸｭ + case EXPORT_CTR_NAND: + { + continueBackup = true; + + // AC繧｢繝繝励ち縺悟ｿ隕√°ｼ + if (NeedsAcAdateper()) + { + continueBackup = false; + operationMessage.push_back(::std::string("Connect AC Adapter!!")); + } + + // 繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧 + ExportData(); + + // 蜃ｦ逅縺悟ｮ御ｺ縺励◆ + if (continueBackup && IsExportFinished()) + { + FinalizeExportThread(); + COMMON_LOGGER("Export NAND Data Finished.\n"); + + if(GetProgress() > 99) + { + s_BackupState = DELETE_NIM; + } + else + { + s_BackupState = FAIL; + } + + } + } + break; + + // nim縺ｮ繧ｷ繧ｹ繝繝繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ蜑企勁 + case DELETE_NIM: + { + DeleteNimSaveData(); + s_BackupState = DONE; + } + break; + + // 蜷ｸ蜃ｺ縺怜ｮ御ｺ + case DONE: + { + operationMessage.push_back(::std::string("Backup Done. Pull Out SD Card.")); + if(!s_PlayedSdPullOutCursor) + { + common::PlaySound(common::SOUND_CURSOR); + s_PlayedSdPullOutCursor = true; + } + } + break; + + // SD繧ｫ繝ｼ繝画栢縺榊ｮ御ｺ + case FINISHED: + { + operationMessage.push_back(::std::string("Backup Succeeded!!\n")); + if(!s_PlayedFinishedSound) + { + common::PlaySound(common::SOUND_OK); + s_PlayedFinishedSound = true; + } + } + break; + + // 蜷ｸ蜃ｺ縺怜､ｱ謨 + case FAIL: + { + operationMessage.push_back(::std::string("Backup Failed.")); + if(!s_PlayedFailSound) + { + common::PlaySound(common::SOUND_NG); + s_PlayedFailSound = true; + } + } + break; + + } +} + +bool InProgress() +{ + return s_BackupState == EXPORT_CTR_NAND; +} + +bool IsBackupSucceeded() +{ + return s_BackupState == FINISHED; +} + +bool IsBackupFailed() +{ + return s_BackupState == FAIL; +} + +void OnSdEjected() +{ + if(s_BackupState == DONE || s_BackupState == FINISHED) + { + s_BackupState = FINISHED; + } + else + { + common::InitializeFileCheck(); + InitializeState(); + } +} + +void InitializeState() +{ + s_BackupState = STARTUP; + s_PlayedFailSound = false; + s_PlayedFinishedSound = false; + s_ExistAPSettingAnnotation = false; + s_PlayedStartCursor = false; + s_PlayedSdPullOutCursor = false; + s_SdWriteProetctAnnotation = false; +} + +} // namespace ConsoleBackup diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Controller.h b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Controller.h new file mode 100644 index 0000000..d7f2cbf --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Controller.h @@ -0,0 +1,34 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Contoroller.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef CONTOROLLER_H_ +#define CONTOROLLER_H_ + +#include +#include + +namespace ConsoleBackup +{ + +void ControlState(::std::vector& operationMessage, bool& nextStep, bool& continueBackup); +bool InProgress(); +bool IsBackupSucceeded(); +bool IsBackupFailed(); +void OnSdEjected(); +void InitializeState(); + +} + +#endif /* CONTOROLLER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Exporter.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Exporter.cpp new file mode 100644 index 0000000..69778bd --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Exporter.cpp @@ -0,0 +1,558 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Exporter.cpp + + Copyright 2009 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 +#include +#include +#include +#include +#include +#include +#include +#include // cfg:nor縺ｮ蛻晄悄蛹悶↓蠢隕 +#include +#include +#include +#include +#include + +#include "Exporter.h" +#include "CommonLogger.h" +#include "SDMountManager.h" +#include "ConsoleBackup.h" +#include "HeapManager.h" +#include "SdReaderWriter.h" +#include "FileName.h" +#include "FileTransfer.h" +#include "common_Types.h" +#include "Aes_define.h" +#include "PlayHistoryManager.h" +#include "VersionDetect.h" + +namespace ConsoleBackup +{ + +namespace +{ + +common::SdReaderWriter s_SdWriter; +common::NtrNorData s_NtrNorData; +common::CfgCountryLanguage s_CountryLanguage; + +::std::string s_SysSaveRoot; + +const size_t EXPORT_THREAD_STACK_SIZE = 0x4000; +nn::os::Thread s_ExportThread; +nn::os::StackBuffer s_ExportThreadStack; + +wchar_t s_RootName[256]; + +} + +void DeleteTrash(std::wstring currentDirectory) +{ + // TODO: 繝ｪ繝ｼ繝峨が繝ｳ繝ｪ繝ｼ縺ｮ繝輔ぃ繧､繝ｫ縺梧ｶ亥悉縺ｧ縺阪↑縺 + + COMMON_LOGGER("Delete Trash.\n"); + + nn::fs::FileInputStream fis; + nn::fs::Directory dir; + nn::Result result; + std::vector entryList; //繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｨ繝ｳ繝医Μ荳隕ｧ繧呈ｼ邏 + std::vector::iterator entryIndex; + + common::SdMountManager::Mount(); + + result = dir.TryInitialize(currentDirectory.c_str()); + + if (result.IsSuccess()) + { + nn::fs::DirectoryEntry entry; + s32 numEntry; + for (;;) + { + result = dir.TryRead(&numEntry, &entry, 1); + if (result.IsFailure()) + { + dir.Finalize(); + } + if (numEntry == 0) + { + // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ繧帝哩縺倥ｋ + dir.Finalize(); + + // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蟄舌ｒ髢九￥ + for (entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++) + { + // 繝繧｣繝ｬ繧ｯ繝医Μ縺ｪ繧牙炎髯､縺吶ｋ + if (entryIndex->attributes.isDirectory) + { + NN_LOG("Try Delete %ls%ls/\n", currentDirectory.c_str(), entryIndex->entryName); + result = nn::fs::TryDeleteDirectoryRecursively((currentDirectory + ::std::wstring( + entryIndex->entryName)).c_str()); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + } + // 繝輔ぃ繧､繝ｫ縺ｪ繧峨Ο繧ｰ縺ｨAP險ｭ螳壻ｻ･螟悶ｯ蜑企勁縺吶ｋ + else + { + if (std::wcscmp(entryIndex->entryName, common::AP_SETTING_FILENAME) != 0 && std::wcscmp( + entryIndex->entryName, common::LOG_FILENAME) != 0) + { + NN_LOG("Try Delete %ls%ls\n", currentDirectory.c_str(), entryIndex->entryName); + result = nn::fs::TryDeleteFile( + (currentDirectory + ::std::wstring(entryIndex->entryName)).c_str()); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + } + } + + // 蜑企勁螳御ｺ + break; + } + else + { + // vector縺ｫ菫晏ｭ倥☆繧 + entryList.push_back(entry); + if (entry.attributes.isDirectory) + { + NN_LOG("%ls%ls/\n", currentDirectory.c_str(), entry.entryName); + } + else + { + NN_LOG("%ls%ls\n", currentDirectory.c_str(), entry.entryName); + } + } + } + } + else + { + NN_LOG("failed initialize directory\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + dir.Finalize(); + } + + common::SdMountManager::Unmount(); +} + +void WriteRegionData() +{ + COMMON_LOGGER("Export Region Data.\n"); + + nn::cfg::CTR::CfgRegionCode region; + region = nn::cfg::CTR::GetRegion(); + + s_SdWriter.WriteBuf(common::REGION_DATA_PATHNAME, ®ion, sizeof(nn::cfg::CTR::CfgRegionCode)); +} + +void WriteCountryLanguageData() +{ + COMMON_LOGGER("Export Country and Language Data.\n"); + + nn::Result result; + + nn::cfg::nor::CTR::Initialize(); + + // 蝗ｽ險ｭ螳 + s_CountryLanguage.country = nn::cfg::CTR::GetCountry(); + if (s_CountryLanguage.country != nn::cfg::CTR::CFG_COUNTRY_UNKNOWN) + { + // 險隱櫁ｨｭ螳 + s_CountryLanguage.language = nn::cfg::CTR::GetLanguage(); + + s_SdWriter.WriteBuf(common::COUNTRY_SETTING_PATHNAME, &s_CountryLanguage, sizeof(s_CountryLanguage)); + } +} + +void WriteNorData() +{ + COMMON_LOGGER("Export NOR Data.\n"); + + nn::Result result; + + nn::cfg::nor::CTR::Initialize(); + + NN_LOG("Get NTR User Setting\n"); + + // NTR險ｭ螳 + result = nn::cfg::nor::CTR::GetNtrSetting(&s_NtrNorData.ntrConfig.ncd, &s_NtrNorData.ntrConfig.ncd_ex); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // TWL WiFi險ｭ螳 + result = nn::cfg::nor::CTR::ReadTwlWifiSetting(0, s_NtrNorData.TwlWiFiSetting, common::TWL_WIFI_SETTING_SIZE); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // NTR WiFi險ｭ螳 + result = nn::cfg::nor::CTR::ReadNtrWifiSetting(0, s_NtrNorData.NtrWiFiSetting, common::NTR_WIFI_SETTING_SIZE); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + s_SdWriter.WriteBuf(common::NOR_PATHNAME, &s_NtrNorData, sizeof(common::NtrNorData)); +} + +void WriteSerialNumber() +{ + COMMON_LOGGER("Export Serial Number.\n"); + + u8* serial; + size_t size; + GetSerialNumber(&serial, &size); + + s_SdWriter.WriteBuf(common::SERIAL_PATHNAME, serial, size); +} + +void WriteIvs() +{ + COMMON_LOGGER("Export IVS.\n"); + + bit8 iv[AES_BLOCK_SIZE] = + { + 0xdf, 0x0f, 0xf9, 0x1b, 0x34, 0x47, 0x70, 0x7f, + 0x7d, 0x06, 0x85, 0xe6, 0xe7, 0xb6, 0x4e, 0xe9 + }; + + void* ivs; + size_t size; + GetIvs(&ivs, &size); + + void* enc; + nn::Result result; + enc = common::HeapManager::GetHeap()->Allocate(size); + if(enc != NULL) + { + // AES證怜捷蛹悶☆繧 + nn::crypto::Initialize(); + + nn::crypto::SwAesCtrContext swAesCtrContest; + + swAesCtrContest.Initialize(iv, common::key, sizeof(common::key)); + swAesCtrContest.Encrypt(enc, ivs, size); + + s_SdWriter.WriteBuf(common::IVS_PATHNAME, enc, size); + + common::HeapManager::GetHeap()->Free(enc); + } +} + +// IVS縺九ｉ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繝繧｣繝ｬ繧ｯ繝医Μ蜷阪ｒ逕滓舌☆繧 +void GetSaveDataDirectoryRoot() +{ + nn::Result result; + using namespace nn::dbg; + + const size_t SEED_SIZE = 16; + bit8 hash[nn::crypto::Sha256Context::HASH_SIZE]; + const size_t SYS_SAVE_ROOT_LENGTH = 16; + char rootHash[SYS_SAVE_ROOT_LENGTH]; + char rootStr[SYS_SAVE_ROOT_LENGTH * 2 + 1]; + + void* addr; + size_t size; + GetIvs(&addr, &size); + + // 譛蠕後ｮ16繝舌う繝医ｮ繝上ャ繧ｷ繝･繧剃ｽｿ縺 + nn::crypto::CalculateSha256(hash, &reinterpret_cast (addr)[size - SEED_SIZE], SEED_SIZE); + + for (u8 i = 0; i < SEED_SIZE / 4; i++) + { + for (u8 j = 0; j < SEED_SIZE / 4; j++) + { + rootHash[i * 4 + j] = hash[i * 4 + 3 - j]; + } + } + + // 蠕励ｉ繧後◆繝上ャ繧ｷ繝･縺九ｉ譁蟄怜励ｒ逕滓 + for (s32 k = 0; k < SEED_SIZE; k++) + { + for (s32 i = 6; i < 8; ++i) + { + bit32 n = (rootHash[k] >> ((7 - i) * 4)) & 0xf; + NN_TASSERT_(n < 16); + rootStr[i - 6 + k * 2] = static_cast (n < 10 ? '0' + n : 'a' + (n - 10)); + } + } + rootStr[SYS_SAVE_ROOT_LENGTH * 2] = '\0'; + + // 繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繝繧｣繝ｬ繧ｯ繝医Μ蜷阪ｒ菫晏ｭ倥☆繧 + s_SysSaveRoot = ::std::string(rootStr); + + NN_LOG("%s\n", s_SysSaveRoot.c_str()); +} + +void CreateTwlDirectory(enum common::TWL_PATH_INDEX path) +{ + NN_ASSERT(path < common::TWL_PATHNAME_MAX); + + s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + + std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str()); +} + +void WriteTwlData(enum common::TWL_PATH_INDEX path) +{ + NN_ASSERT(path < common::TWL_PATHNAME_MAX); + + nn::Result result; + + result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + result = common::SdMountManager::Mount(); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + u32 fileNum = 0; + u32 fileSize = 0; + common::CalculateFileNum(::std::wstring(common::NAND_TWL_ROOT_PATHNAME_WITH_SLASH_TABLE[path]), fileNum, fileSize); + + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + + NN_LOG("File Number = %d\n", fileNum); + NN_LOG("File Size = %d\n", fileSize); + // 騾ｲ謐苓｡ｨ遉ｺ逕ｨ + common::InitializeTransferProgress(fileSize); + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + wchar_t archiveName[256]; + ::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path], std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1); + std::wstring archiveString(archiveName); + common::CopyDirectory( + (archiveString + ::std::wstring(L"/")).c_str(), + (common::SDMC_ROOT_DIRECTORY_PATH + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(), + buf, bufSize); + + common::HeapManager::GetHeap()->Free(buf); + } + + common::SdMountManager::Unmount(); + nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]); + +} + +void WriteTwlPhotoData() +{ + COMMON_LOGGER("Export Twl Photo Data.\n"); + CreateTwlDirectory(common::TWL_PHOTO); + WriteTwlData(common::TWL_PHOTO); +} + +void WriteTwlSoundData() +{ + COMMON_LOGGER("Export Twl Sound Data.\n"); + CreateTwlDirectory(common::TWL_SOUND); + WriteTwlData(common::TWL_SOUND); +} + +void ExportTwlPhotoData() +{ + s_ExportThread.Start(WriteTwlPhotoData, s_ExportThreadStack); +} + +void ExportTwlSoundData() +{ + // 荳崎ｦ√↑繝繝ｼ繧ｿ繧貞炎髯､縺吶ｋ + DeleteTrash(common::SDMC_ROOT_DIRECTORY_PATH); + + s_ExportThread.Start(WriteTwlSoundData, s_ExportThreadStack); +} + + +void WriteMcuRtcData() +{ + COMMON_LOGGER("Export RTC Data.\n"); + nn::Result result; + nn::Handle handle = GetMcuHandle(); + + if(handle.IsValid()) + { + nn::mcu::CTR::HwCheck mcu(handle); + + nn::mcu::CTR::RtcData rtc; + result = mcu.GetRtcAll(&rtc); + NN_LOG("RTC = 20%02d/%02d/%02d %02d:%02d:%02d\n", rtc.m_Year, rtc.m_Month, rtc.m_Day, rtc.m_Hour, rtc.m_Minute, rtc.m_Second); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + s_SdWriter.WriteBuf(common::MCU_RTC_PATHNAME, &rtc, sizeof(rtc)); + } + else + { + NN_LOG("invalid handle\n"); + } +} + +void ExportThreadFunc() +{ + nn::Result result; + + result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + result = common::SdMountManager::Mount(); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + + common::CopyDirectory( + (::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str(), + (common::SDMC_ROOT_DIRECTORY_PATH + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str(), + buf, bufSize); + + common::HeapManager::GetHeap()->Free(buf); + } + + common::SdMountManager::Unmount(); + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + + NN_LOG("Export Thread Finalize\n"); +} + +nn::Result WriteSaveData() +{ + // NAND縺九ｉSD繧ｫ繝ｼ繝峨↓譖ｸ縺榊ｺ縺 + nn::Result result; + + result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + u32 fileNum = 0; + u32 fileSize = 0; + common::CalculateFileNum(::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH), fileNum, fileSize); + + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + + NN_LOG("File Number = %d\n", fileNum); + NN_LOG("File Size = %d\n", fileSize); + // 騾ｲ謐苓｡ｨ遉ｺ逕ｨ + common::InitializeTransferProgress(fileSize); + + ::std::mbstowcs(s_RootName, s_SysSaveRoot.c_str(), s_SysSaveRoot.size() + 1); + + NN_LOG("%ls\n", (::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str()); + + // 繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繝繧｣繝ｬ繧ｯ繝医Μ莉･荳九ｮ繝繝ｼ繧ｿ繧担D繧ｫ繝ｼ繝峨↓繧ｳ繝斐ｼ + // 繧ｳ繝斐ｼ逕ｨ繝繧｣繝ｬ繧ｯ繝医Μ菴懈 + s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring( + common::SD_SAVEDATA_ROOT_NAME)).c_str()); + s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring( + common::SD_SAVEDATA_ROOT_NAME) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str()); + + COMMON_LOGGER("Export NAND Data Start...\n"); + + // SD縺ｫ繧ｳ繝斐ｼ縺吶ｋ縺溘ａ縺ｮ繧ｹ繝ｬ繝繝峨ｮ菴懈 + s_ExportThread.Start(ExportThreadFunc, s_ExportThreadStack); + + return result; +} + +void FinalizeExportThread() +{ + s_ExportThread.Join(); + s_ExportThread.Finalize(); +} + +void WriteVersionData() +{ + COMMON_LOGGER("Export Version Data.\n"); + + common::VerDef versionData; + GetVersionData(&versionData); + + s_SdWriter.WriteBuf(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef)); +} + +void WritePlayHistory() +{ + common::PlayHistoryManager historyManager; + + COMMON_LOGGER("Export PlayHistory\n"); + historyManager.Export(); +} + +void DeleteNimSaveData() +{ + nn::Result result; + ::std::wstring nimSaveDataPath = + ::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME) + + ::std::wstring(s_RootName) + + ::std::wstring(L"/") + + std::wstring(common::NIM_SAVEDATA_DIRECTORY_NAME); + + common::SdMountManager::Mount(); + + NN_LOG("%ls\n", nimSaveDataPath.c_str()); + result = nn::fs::TryDeleteDirectoryRecursively(nimSaveDataPath.c_str()); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + common::SdMountManager::Unmount(); +} + + +void ExportData() +{ + static bool init = true; + + if (init) + { + // 繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ繝繝ｼ繧ｿ繧担D縺ｫ譖ｸ縺崎ｾｼ繧 + WriteRegionData(); + + // 蝗ｽ繝繝ｼ繧ｿ縺ｨ險隱槭ョ繝ｼ繧ｿ繧担D縺ｫ譖ｸ縺崎ｾｼ繧 + WriteCountryLanguageData(); + + // NOR繝繝ｼ繧ｿ繧担D繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ繧 + WriteNorData(); + + // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ繧担D繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ繧 + WriteSerialNumber(); + + // 螳悟ｨ諤ｧ讀懆ｨｼSEED繧担D繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ繧 + WriteIvs(); + + // IVS縺九ｉ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繝繧｣繝ｬ繧ｯ繝医Μ蜷阪ｒ險育ｮ + GetSaveDataDirectoryRoot(); + + // 繝励Ξ繧､螻･豁ｴ繧担D縺ｫ譖ｸ縺榊ｺ縺 + //WritePlayHistory(); + + // RTC繧担D縺ｫ譖ｸ縺榊ｺ縺 + WriteMcuRtcData(); + + // 繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ繧担D縺ｫ譖ｸ縺榊ｺ縺 + WriteVersionData(); + + // NAND縺ｮ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繧担D縺ｫ譖ｸ縺榊ｺ縺 + WriteSaveData(); + + init = false; + } +} + +u32 GetProgress() +{ + return common::GetProgress(); +} + +bool IsExportFinished() +{ + return !s_ExportThread.IsAlive(); +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Exporter.h b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Exporter.h new file mode 100644 index 0000000..216a277 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/Exporter.h @@ -0,0 +1,36 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Exporter.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef EXPORTER_H_ +#define EXPORTER_H_ + +#include + +namespace ConsoleBackup +{ + +void ExportTwlPhotoData(); +void ExportTwlSoundData(); +void ExportData(); +void DeleteNimSaveData(); + +u32 GetProgress(); +bool IsExportFinished(); +void FinalizeExportThread(); + + +} + +#endif /* EXPORTER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/OMakefile b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/OMakefile new file mode 100644 index 0000000..b152d3d --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/OMakefile @@ -0,0 +1,84 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakefile +# +# Copyright (C)2009 Nintendo Co., Ltd. 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$ +#---------------------------------------------------------------------------- +SUPPORTED_TARGETS = CTR-T*.Process.MPCore.* +#MAKECSU = true +#INSTALL_SDK_TOOL = true +CTR_APPTYPE = BOTH +CTR_MAKE_DEVELOPMENT_IMAGE = true + +TARGET_PROGRAM = ConsoleBackup + +SAMPLED_DEMOS_COMMON_INCLUDE_DIR = $(dir $(HORIZON_ROOT)/../CTR/SampleDemos/common/include) +INCLUDES += $(SAMPLED_DEMOS_COMMON_INCLUDE_DIR) \ + ../common + +SOURCES[] = + ConsoleBackup.cpp + Controller.cpp + Exporter.cpp + ../common/HardwareInfo.cpp + ../common/DrawSystemState.cpp + ../common/FileTransfer.cpp + ../common/FileChecker.cpp + ../common/SdReaderWriter.cpp + ../common/HeapManager.cpp + ../common/SdLogger.cpp + ../common/wave.cpp + ../common/SimplePlayer.cpp + ../common/LogConsole.cpp + ../common/CommonLogger.cpp + ../common/SdMountManager.cpp + ../common/PlayHistoryManager.cpp + ../common/VersionDetect.cpp + +CTR_BANNER_SPEC = $(TARGET_PROGRAM).bsf + +ROMFS_ROOT = ../common/romfiles + +LIBS += libnn_cfg \ + libnn_driversEeprom \ + libnn_driversi2c \ + libnn_driversCal \ + libnn_crypto \ + libnn_driversCodec \ + libnn_spi \ + libnn_gpio \ + libnn_pdn \ + libnn_mcu \ + libnn_i2c \ + libnn_driversCamera \ + libnn_ps \ + libnn_driversRsa \ + lib_demo \ + libnn_nwm \ + libnn_friends \ + libnn_nim \ + +INSTALL_SDK_TOOL = true + +ROM_SPEC_FILE = $(TARGET_PROGRAM).rsf +DESCRIPTOR = $(HORIZON_ROOT)/resources/specfiles/_private/RepairTool.desc + +include $(ROOT_OMAKE)/modulerules + +VERSION_H = $(file version.h) + +$(VERSION_H): $(SOURCES) + section + bash genversion.sh + +RequireSetup($(VERSION_H)) +build: $(VERSION_H) $(DEFAULT_TARGETS) diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/model.cbmd b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/model.cbmd new file mode 100644 index 0000000..f1c7b62 Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/model.cbmd differ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/sound.cbsd b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/sound.cbsd new file mode 100644 index 0000000..f1c7b62 Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/sound.cbsd differ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/unknown24x24.ctpk b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/unknown24x24.ctpk new file mode 100644 index 0000000..794b136 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/unknown24x24.ctpk @@ -0,0 +1 @@ +ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆ8ﾆ8ﾆﾞ銷ｽｽ8ﾆｽｽｽｽｽ釡ﾞﾆ鍄踟ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽyﾎｽyﾎｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ鍄ﾞyﾎYﾎｽﾛﾞﾛﾞｽｽﾆｽｽﾛﾞyﾎﾞｽyﾎ轌ﾎ釡ﾞｽｽｽｽYﾎ轌ﾎ銷ｽｽｽｽｽyﾎﾆﾛﾞ鍄躡ﾎyﾎｽｽｽyﾎｽｺﾖｽｽｽｽｽyﾎｽyﾎｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽyﾎ躡ﾎ銷ｽｽｽｽｽﾆｽｽ轌ﾎ8ﾆｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ \ No newline at end of file diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/unknown48x48.ctpk b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/unknown48x48.ctpk new file mode 100644 index 0000000..8c7da16 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/banner/unknown48x48.ctpk @@ -0,0 +1 @@ +ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽ8ﾆ8ﾆｽｽｽｺﾖ8ﾆｺﾖ釡ﾞ銷ｽｽｽｽｽｽｽｽｽｽ8ﾆ8ﾆｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ鍄逧ﾖﾆ銷ｽｽ墮ｽ逧ﾖ銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞｽﾛﾞｽｽｽｽｽ銷ｽﾞｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｺﾖｽｽｽｽｽｽｽｽｽｽ鍄8ﾆﾞﾛﾞｽｽ墮ｽYﾎｽｽｽｽｽ躡ﾎyﾎ轌ﾎﾆｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞﾛﾞ釡ﾞ踟ｽｽ躡ﾎ銷ｽｽｽｽｽﾛﾞｽﾛﾞ銷ｽｽYﾎﾞ墮釡ﾞｺﾖｽ墮ｽﾛﾞｽｽｽｽｽ踟ｽ踟ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞｽyﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽYﾎｽ墮銷ｽﾛﾞｽﾛﾞ銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｺﾖﾛﾞｽｽｽｽｽYﾎﾆyﾎ逧ﾖ郤ﾖｽYﾎｽ觝ﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞ墮ｽｽｽｽｽｽyﾎｽ鍄踟ｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ踟ｽ銷ｽﾞｽYﾎ鍄銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽ逧ﾖｽﾛﾞｽ釡ﾞ墮ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ \ No newline at end of file diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/genversion.sh b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/genversion.sh new file mode 100755 index 0000000..180bd87 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleBackup/genversion.sh @@ -0,0 +1,3 @@ +#!/bin/bash -f + +echo "#define BACKUP_VERSION_NUM \"`svnversion -n`\"" > version.h diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.bsf b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.bsf new file mode 100644 index 0000000..104a94d Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.bsf differ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.cpp new file mode 100644 index 0000000..4e5e69a --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.cpp @@ -0,0 +1,462 @@ +ｻｿ/*---------------------------------------------------------------------------* + Project: Horizon + File: ConsoleRestore.cpp + + Copyright (C)2009 Nintendo Co., Ltd. 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "demo.h" + +#include +#include + +#include "ConsoleRestore.h" +#include "DrawSystemState.h" +#include "Controller.h" +#include "SimplePlayer.h" +#include "CommonLogger.h" +#include "SDMountManager.h" +#include "HeapManager.h" +#include "VersionDetect.h" +#include "HardwareInfo.h" + +// svn繝ｪ繝薙ず繝ｧ繝ｳ蝓九ａ霎ｼ縺ｿ逕ｨ +#include "version.h" +#ifndef RESTORE_VERSION_NUM +#define RESOTRE_VERSION_NUM 0 +#endif + +namespace { + +// 繧ｰ繝ｩ繝輔ぅ繝繧ｯ繧ｹ縺ｫ蜑ｲ繧雁ｽ薙※繧九Γ繝｢繝ｪ +const size_t s_GxHeapSize = 0x800000; + +demo::RenderSystemDrawing s_RenderSystem; +nn::Handle s_McuSession; + +// 繝舌ャ繝繝ｪ谿矩 +u8 batteryRemain = 100; + +// 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ +u8 s_SerialNo[nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN]; + +// 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺瑚ｪｭ繧√ｋ縺九←縺縺 +bool s_CanReadSerialNumber = false; + +// IVS縺ｸ縺ｮ繝昴う繝ｳ繧ｿ +void* sp_Ivs; + +size_t s_SizeofIvs; + +// IVS縺瑚ｪｭ繧√ｋ縺九←縺縺 +bool s_CanReadIvs = false; + +// 繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ +common::VerDef s_VerData; + +} // namespace + +namespace ConsoleRestore{ + +bool IsAdapterConnected() +{ + return nn::ptm::CTR::GetAdapterState() == nn::ptm::CTR::ADAPTERSTATE_CONNECTED; +} + +bool IsBatteryLower() +{ + return batteryRemain <= 10; +} + +bool CanReadIVS() +{ + return s_CanReadIvs; +} + +bool CanReadSerialNumber() +{ + return s_CanReadSerialNumber; +} + +void GetSerialNumber(u8** serial, size_t* size) +{ + *serial = s_SerialNo; + *size = nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN; +} + +void GetIvs(void** ivs, size_t* size) +{ + *ivs = sp_Ivs; + *size = s_SizeofIvs; +} + +void GetVersionData(common::VerDef* version) +{ + *version = s_VerData; +} + +void FinalizeAll() +{ + common::Logger::GetLoggerInstance()->Finalize(); + // 繧｢繝ｳ繝槭え繝ｳ繝 + nn::fs::Unmount("nand:"); + nn::fs::Unmount("sdmc:"); + s_RenderSystem.Finalize(); + + nn::mcu::CTR::FinalizeHwCheck(&s_McuSession); + nn::friends::detail::Finalize(); + nn::ps::Finalize(); + nn::ptm::CTR::FinalizeForSystemMenu(); + nn::cfg::CTR::system::Finalize(); + nn::cfg::CTR::init::Finalize(); + nn::hid::Finalize(); + nn::fs::Finalize(); + + nn::applet::PrepareToCloseApplication(); + nn::applet::CloseApplication(); +} + +nn::Handle GetMcuHandle() +{ + return s_McuSession; +} + +extern "C" void nnMain(void) +{ + nn::Result result; + + // os 縺ｮ蛻晄悄蛹 + nn::os::Initialize(); + + // fs 縺ｮ蛻晄悄蛹 + nn::fs::Initialize(); + + // applet縺ｮ蛻晄悄蛹 + nn::applet::Enable( false ); + + // hid 縺ｮ蛻晄悄蛹 + result = nn::hid::Initialize(); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + + // ndm縺ｮ蛻晄悄蛹 + result = nn::ndm::Initialize(); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + + // 繝繝ｼ繝｢繝ｳ縺ｮ閾ｪ蠕句虚菴懊ｒ蛛懈ｭ｢ + result = nn::ndm::Suspend(nn::ndm::DN_CEC); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + result = nn::ndm::Suspend(nn::ndm::DN_BOSS); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + result = nn::ndm::Suspend(nn::ndm::DN_FRIENDS); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + result = nn::ndm::Suspend(nn::ndm::DN_NIM); + NN_ERR_THROW_FATAL_IF_FATAL_ONLY(result); + + // cfg 縺ｮ蛻晄悄蛹 + nn::cfg::CTR::init::Initialize(); + nn::cfg::CTR::system::Initialize(); + + // 譎りｨ郁ｨｭ螳夂畑ptm蛻晄悄蛹 + nn::ptm::CTR::InitializeForSystemMenu(); + + // ps 縺ｮ蛻晄悄蛹 + nn::ps::Initialize(); + + // friends縺ｮ蛻晄悄蛹 + result = nn::friends::detail::Initialize(); + + // mcu縺ｮ蛻晄悄蛹 + nn::mcu::CTR::InitializeHwCheck(&s_McuSession); + nn::mcu::CTR::HwCheck mcu(s_McuSession); + + // am縺ｮ蛻晄悄蛹 + nn::am::InitializeForSystemMenu(); + + // 繝偵ｼ繝励ｮ遒ｺ菫 + common::HeapManager::GetHeap()->Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR); + + // RenderSystem 縺ｮ貅門ｙ + uptr heapForGx = reinterpret_cast(common::HeapManager::GetHeap()->Allocate(s_GxHeapSize)); + s_RenderSystem.Initialize(heapForGx, s_GxHeapSize); + + // 繧ｵ繧ｦ繝ｳ繝峨せ繝ｬ繝繝峨ｮ襍ｷ蜍 + common::InitializeSimplePlayer(); + + // 繝ｭ繧ｰ謠冗判縺ｮ蛻晄悄蛹 + common::Logger::GetLoggerInstance()->Initialize(CONSOLE_WIDTH, CONSOLE_HEIGHT, CONSOLE_MAX_LINE, &s_RenderSystem); + + // RenderSystem繧剃ｽ懊▲縺ｦ縺九ｉ繝ｭ繧ｰ縺悟ｺ縺帙ｋ + common::Logger::InitializeEjectThread(); + common::Logger::SetEjectHandler(OnSdEjected); + COMMON_LOGGER("\n"); + COMMON_LOGGER("CTR Console Restore start\n"); + + // 繝懊ち繝ｳ蜈･蜉 + nn::hid::PadReader s_PadReader; + nn::hid::PadStatus padStatus; + + // 繝繝ｼ繧ｿ縺ｮ貅門ｙ + + // 螳悟ｨ諤ｧ讀懆ｨｼSEED縺ｮ蜿門ｾ + result = nn::fs::MountSpecialArchive("nand:", nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); + if (result.IsSuccess()) + { + nn::fs::FileInputStream fis; + + result = fis.TryInitialize(L"nand:/private/movable.sed"); + if (result.IsSuccess()) + { + s64 fileSize = fis.GetSize(); + s32 ret; + void* addr = NULL; + addr = common::HeapManager::GetHeap()->Allocate(fileSize); + if (addr != NULL) + { + sp_Ivs = addr; + s_SizeofIvs = fileSize; + result = fis.TryRead(&ret, addr, fileSize); + if (result.IsSuccess()) + { + s_CanReadIvs = true; + } + } + } + fis.Finalize(); + } + // 荳譌ｦ繧｢繝ｳ繝槭え繝ｳ繝医＠縺ｦ縺翫￥ + nn::fs::Unmount("nand:"); + + // 繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ縺ｮ蜿門ｾ + nn::cfg::CTR::CfgRegionCode region; + region = nn::cfg::CTR::GetRegion(); + + // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺ｮ蜿門ｾ + std::memset(s_SerialNo, '\0', + nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN); + result = nn::cfg::CTR::system::GetSerialNo(s_SerialNo); + common::HardwareInfo hwInfo; + hwInfo.AddCheckDigit(reinterpret_cast(s_SerialNo)); + if(result.IsSuccess()) + { + s_CanReadSerialNumber = true; + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // 繝繝舌う繧ｹID縺ｮ蜿門ｾ + bit32 deviceId; + result = nn::ps::CTR::GetDeviceId(&deviceId); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + bit64 infraDeviceId; + result = nn::nim::CTR::InitializeForShop(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + result = nn::nim::CTR::Shop::GetInfraDeviceId(deviceId, &infraDeviceId); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + result = nn::nim::CTR::FinalizeForShop(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // MAC繧｢繝峨Ξ繧ｹ縺ｮ蜿門ｾ + nn::nwm::Mac mac; + char8 macAddress[nn::nwm::Mac::MAC_STRING_SIZE]; + + result = nn::nwm::GetMacAddress(mac); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + mac.GetString(macAddress); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // 繝輔Ξ繝ｳ繝峨さ繝ｼ繝峨ｮ蜿門ｾ + nn::friends::CTR::FriendKey friendKey; + result = nn::friends::CTR::GetMyFriendKey(&friendKey); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + u64 friendCode = nn::friends::CTR::FriendKeyToFriendCode(friendKey); + + // 繝舌ｼ繧ｸ繝ｧ繝ｳ縺ｮ蜿門ｾ + common::GetSystemVersion(&s_VerData, region); + + // 諠蝣ｱ蜃ｺ蜉 + COMMON_LOGGER("CTR Console Restore %s Rev.%s\n", __DATE__, RESTORE_VERSION_NUM); + COMMON_LOGGER("System Ver. %d.%d.%d-%d\n", s_VerData.cup.majorVersion, s_VerData.cup.minorVersion, s_VerData.cup.microVersion, + s_VerData.nup.majorVersion); + COMMON_LOGGER("System Region %s\n", nn::cfg::CTR::GetRegionCodeA3(region)); + COMMON_LOGGER("Serial Number %s\n", s_SerialNo); + COMMON_LOGGER("Device ID %llu\n", infraDeviceId); + COMMON_LOGGER("MAC Address %s\n", macAddress); + COMMON_LOGGER("Friend Code %04u-%04u-%04u\n", + static_cast(friendCode / 100000000ULL % 10000ULL), + static_cast(friendCode / 10000ULL % 10000ULL), + static_cast(friendCode % 10000ULL) ); + + + bool flip = false; + bool continueRestore = false; + + for(;;) + { + bool nextStep = false; + + s_PadReader.ReadLatest(&padStatus); + + // A縺ｾ縺溘ｯSTART繝懊ち繝ｳ縺ｧ騾ｲ陦 + if(padStatus.trigger & nn::hid::BUTTON_A || + padStatus.trigger & nn::hid::BUTTON_START) + { + nextStep = true; + } + + // L縺ｾ縺溘ｯR繝懊ち繝ｳ縺ｧ荳贋ｸ狗判髱｢繝輔Μ繝繝 + if(padStatus.trigger & nn::hid::BUTTON_R || + padStatus.trigger & nn::hid::BUTTON_L) + { + flip = !flip; + } + + // 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ + if(padStatus.hold & nn::hid::BUTTON_UP) + { + common::Logger::GetLoggerInstance()->ScrollUp(); + } + + // 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ + if(padStatus.hold & nn::hid::BUTTON_DOWN) + { + common::Logger::GetLoggerInstance()->ScrollDown(); + } + + if(padStatus.hold & nn::hid::BUTTON_LEFT) + { + common::Logger::GetLoggerInstance()->ScrollToBegin(); + } + + if(padStatus.hold & nn::hid::BUTTON_RIGHT) + { + common::Logger::GetLoggerInstance()->ScrollToEnd(); + } + + // 諠蝣ｱ譖ｴ譁ｰ + // 繝舌ャ繝繝ｪ + mcu.GetBatteryRemain(&batteryRemain); + // AC繧｢繝繝励ち + std::string adapterState; + if(IsAdapterConnected()) + { + adapterState += ::std::string("Connected"); + } + else + { + adapterState += ::std::string("Not Connected"); + } + + // 謫堺ｽ懃畑繝｡繝繧ｻ繝ｼ繧ｸ + // 騾ｲ謐礼｢ｺ隱阪Γ繝繧ｻ繝ｼ繧ｸ繧貞ｼ縺ｭ繧具ｼ + ::std::vector operationMessage; + + ControlState(operationMessage, nextStep, continueRestore); + + nn::util::FloatColor titleColor; + + if(GetRestoreMode() == RESTORE_MODE_RESTORE) + { + titleColor.r = 0.1f; + titleColor.g = 0.25f; + titleColor.b = 0.1f; + } + else if(GetRestoreMode() == RESTORE_MODE_NUP_ONLY) + { + titleColor.r = 0.35f; + titleColor.g = 0.35f; + titleColor.b = 0.f; + } + + // 荳顔判髱｢陦ｨ遉ｺ + common::DrawSystemState("CTR Console Restore", + s_RenderSystem, + titleColor, + flip, + adapterState, + RESTORE_VERSION_NUM, + &s_VerData, + batteryRemain, + infraDeviceId, + friendCode, + GetProgress(), + macAddress, + operationMessage, + region, + s_SerialNo + ); + + if (GetRestoreMode() == RESTORE_MODE_NUP_ONLY) + { + const u8 spaceSize = 10; + const u8 lineBottom = 23; + const u32 screenWidth = 400; + + s_RenderSystem.SetColor(1.f, 1.f, 1.f); + s_RenderSystem.DrawText(0, lineBottom * spaceSize, "NUP-Only Mode"); + s_RenderSystem.SetColor(titleColor.r, titleColor.g, titleColor.b); + s_RenderSystem.FillRectangle(0, lineBottom * spaceSize, screenWidth, spaceSize); + s_RenderSystem.SetColor(1.f, 1.f, 1.f); + } + + s_RenderSystem.SwapBuffers(); + + // 繝繝輔か繝ｫ繝医〒荳狗判髱｢縺ｫ謠冗判縺吶ｋ繧ゅｮ + s_RenderSystem.SetRenderTarget(common::GetRenderTarget(NN_GX_DISPLAY1, flip)); + if(IsRestoreSucceeded()) + { + s_RenderSystem.SetClearColor(common::GetRenderTarget(NN_GX_DISPLAY1, flip), SUCCESS_COLOR); + } + else if(IsRestoreFailed()) + { + s_RenderSystem.SetClearColor(common::GetRenderTarget(NN_GX_DISPLAY1, flip), FAIL_COLOR); + } + else + { + s_RenderSystem.SetClearColor(common::GetRenderTarget(NN_GX_DISPLAY1, flip), NORMAL_COLOR); + } + s_RenderSystem.Clear(); + s_RenderSystem.SetColor(1.f, 1.f, 1.f); + + common::Logger::GetLoggerInstance()->DrawConsole(); + s_RenderSystem.SwapBuffers(); + + + s_RenderSystem.WaitVsync(NN_GX_DISPLAY_BOTH); + + // 髮ｻ貅宣聞謚ｼ縺励〒邨ゆｺ + if ( nn::applet::IsExpectedToCloseApplication()) + { + FinalizeAll(); + } + } +} + + +} diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.h b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.h new file mode 100644 index 0000000..2166c41 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.h @@ -0,0 +1,53 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: ConsoleRestore.h + + Copyright (C)2009 Nintendo Co., Ltd. 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$ + *---------------------------------------------------------------------------*/ + +#ifndef NN_CONSOLERESTORE_H_ +#define NN_CONSOLERESTORE_H_ + +#include +#include "VersionDetect.h" + +namespace ConsoleRestore +{ + +bool IsAdapterConnected(); +bool IsBatteryLower(); +bool CanReadIVS(); +bool CanReadSerialNumber(); +void GetSerialNumber(u8** serial, size_t* size); +void GetIvs(void** ivs, size_t* size); +nn::Handle GetMcuHandle(); +void GetVersionData(common::VerDef* version); + +void FinalizeAll(); + +const u32 CONSOLE_WIDTH = 38; +const u32 CONSOLE_HEIGHT = 24; +const u32 CONSOLE_MAX_LINE = 1000; + +} + +// 謠冗判濶ｲ縺ｮ螳夂ｾｩ +#define WHITE_COLOR 1.f, 1.f, 1.f, 1.f +#define GRAY_COLOR 0.5, 0.5, 0.5, 1.f +#define RED_COLOR 1.f, 0.f, 0.f, 1.f +#define GREEN_COLOR 0.f, 1.f, 0.f, 1.f +#define BLUE_COLOR 0.f, 0.f, 1.f, 1.f +#define SUCCESS_COLOR 0.f, 0.6f,0.f, 1.f +#define FAIL_COLOR 0.6f, 0.f,0.f, 1.f +#define NORMAL_COLOR 0.f, 0.f, 0.f, 1.f + +/* NN_CONSOLERESTORE_H_ */ +#endif diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.rsf b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.rsf new file mode 100644 index 0000000..be9685f --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/ConsoleRestore.rsf @@ -0,0 +1,52 @@ +BasicInfo: + Title : ConsoleRestore + ProductCode: ConsoleRestore + BackupMemoryType: None + +TitleInfo: + Use: Evaluation + Category: Application + UniqueId: 0xf8022 + Version: 0 + +SystemControlInfo: + AppType : Application + StackSize : 0x4000 + Dependency : + - gpio + - pdn + - spi + - i2c + - mcu + - ptm + - codec + - cfg + - hid + - gsp + - friends + - nim + - ac + - ndm + +AccessControlInfo: + Priority : 16 + DisableDebug : true + + FileSystemAccess: + - DirectSdmc + - Debug + - Core + - CategoryFileSystemTool + + IoAccessControl: + - FsMountCardSpi + - FsMountNand + - FsMountTwln + +Option: + FreeProductCode: true + + +Rom: + # ROM 縺ｫ蜷ｫ繧√ｋ繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｮ繝ｫ繝ｼ繝医ヱ繧ｹ繧呈欠螳壹＠縺ｾ縺吶 + HostRoot: "$(ROMFS_ROOT)" \ No newline at end of file diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Controller.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Controller.cpp new file mode 100644 index 0000000..8a5c3ea --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Controller.cpp @@ -0,0 +1,913 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Controller.cpp + + Copyright 2009 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 +#include +#include +#include +#include +#include +#include + +#include "Controller.h" +#include "FileChecker.h" +#include "ConsoleRestore.h" +#include "SimplePlayer.h" +#include "CommonLogger.h" +#include "Importer.h" +#include "Updater.h" +#include "NtpClient.h" + +namespace ConsoleRestore +{ + +namespace +{ + +typedef enum RestoreState +{ + STARTUP, // 蛻晄悄蛟､ + SERIAL_IS_NOT_IN_SD, // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ繝輔ぃ繧､繝ｫ縺郡D繧ｫ繝ｼ繝峨↓縺ｪ縺縺薙→繧定｡ｨ遉ｺ + SERIAL_IN_SD, // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺ｮ諠蝣ｱ繧定｡ｨ遉ｺ + UPDATE_IN_PROGRESS, // 繧｢繝繝励ョ繝ｼ繝井ｸｭ + UPDATE_DONE, // 繧｢繝繝励ョ繝ｼ繝亥ｮ御ｺ + NUP_ONLY_WAIT_SD_EJECT, // NUP_ONLY繝｢繝ｼ繝峨〒SD繧ｫ繝ｼ繝画栢縺榊ｾ縺｡ + NUP_ONLY_WAIT_NEXT, // NUP_ONLY繝｢繝ｼ繝峨〒繧ｭ繝ｼ蜈･蜉帛ｾ縺｡ + RESTORE_TWL_SOUND, // TWL繧ｵ繧ｦ繝ｳ繝峨ｮ譖ｸ縺崎ｾｼ縺ｿ荳ｭ + RESTORE_TWL_PHOTO, // TWL蜀咏悄縺ｮ譖ｸ縺崎ｾｼ縺ｿ荳ｭ + RESTORE_IN_PROGRESS, // 譖ｸ縺崎ｾｼ縺ｿ荳ｭ + POST_RESTORE, // 譖ｸ縺崎ｾｼ縺ｿ蠕後ｮ蜃ｦ逅 + RESTORE_DONE, // 譖ｸ縺崎ｾｼ縺ｿ螳御ｺ + REBOOTING, // 蜀崎ｵｷ蜍輔ｒ陦後≧ + ERASE, // 蜑企勁蜃ｦ逅繧定｡後≧ + HISTORY_RECOVER, // 繝励Ξ繧､螻･豁ｴ縺ｮ譖ｸ縺肴綾縺励ｒ陦後≧ + TIME_ADJUST, // 譎りｨ医≠繧上○繧定｡後≧ + WAIT_SD_EJECT, // SD繧ｫ繝ｼ繝峨〓縺榊ｾ縺｡ + ALL_DONE, // 縺吶∋縺ｦ螳御ｺ + SHUTDOWN, //縲繧ｷ繝｣繝繝医ム繧ｦ繝ｳ荳ｭ + FAIL // 螟ｱ謨 +} RestoreState; + +// Restore迥ｶ諷狗ｮ｡逅 +RestoreState s_RestoreState = STARTUP; +// Restore繝｢繝ｼ繝臥ｮ｡逅 +RestoreMode s_RestoreMode = RESTORE_MODE_RESTORE; + +// 繧､繝ｳ繧ｿ繝ｼ繝阪ャ繝郁ｨｭ螳壹ｒ隱ｭ繧薙□縺九←縺縺 +bool s_ReadSettingDone = false; +// 繧､繝ｳ繧ｿ繝ｼ繝阪ャ繝郁ｨｭ螳壹ｒ隱ｭ繧薙□邨先棡 +bool s_ReadSettingSuccess = false; +// NUP蟆ら畑繝｢繝ｼ繝峨°縺ｩ縺縺 +bool s_NupOnlyMode = false; + +// APSetting縺ｮ譖ｸ蠑上′辟｡縺隴ｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_ExistAPSettingAnnotation = false; +// APSetting縺ｮ譖ｸ蠑上′驕輔▲縺ｦ縺繧玖ｭｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_APSettingAnnotation = false; +// 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺後↑縺隴ｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_SerialNumberAnnotation = false; +// 螟ｱ謨励し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_PlayedFailSound = false; +// 謫堺ｽ憺幕蟋九し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_PlayedStartCursor = false; +// 繝ｪ繝悶ｼ繝磯幕蟋句燕繧ｵ繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_PlayedRebootCursor = false; +// SD謚懊″蜃ｺ縺怜燕繧ｵ繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_PlayedSdPullOutCursor = false; +// 繝舌ｼ繧ｸ繝ｧ繝ｳ繝繝ｼ繧ｿ縺檎┌縺隴ｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_ExistsVersionDataAnnotation = false; +// 繝舌ｼ繧ｸ繝ｧ繝ｳ繝繝ｼ繧ｿ繧定ｪｭ繧薙□縺九←縺縺 +bool s_ReadVersionDone = false; +// SD縺ｫ譖ｸ縺崎ｾｼ縺ｿ縺ｧ縺阪↑縺隴ｦ蜻翫し繧ｦ繝ｳ繝峨ｒ魑ｴ繧峨＠縺溘°縺ｩ縺縺 +bool s_SdWriteProetctAnnotation = false; + +// 繝阪ャ繝医Ρ繝ｼ繧ｯ繧｢繝繝励ョ繝ｼ繝医ｒ髢句ｧ九＠縺溘°縺ｩ縺縺 +bool s_ExecuteFgNup = false; +// FGNUP繧剃ｽ募屓繝ｪ繝医Λ繧､縺励◆縺 +u32 s_FgNupRetryCount = 0; + + +} // namespace + +bool NeedsAcAdater() +{ + return IsBatteryLower() && !IsAdapterConnected(); +} + +bool CheckAndReadAPSetting(::std::vector& operationMessage) +{ + using namespace common; + + if (!ExistsAPSetting()) + { + if(!s_ExistAPSettingAnnotation) + { + s_ExistAPSettingAnnotation = true; + common::PlaySound(common::SOUND_ANNOTATION); + } + operationMessage.push_back(::std::string("Accsess_Point_Setting does not exist!")); + return false; + } + + // 險ｭ螳壹ヵ繧｡繧､繝ｫ縺九ｉAP險ｭ螳壹ｒ隱ｭ縺ｿ霎ｼ繧 + if (!s_ReadSettingDone) + { + s_ReadSettingDone = true; + s_ReadSettingSuccess = ReadSetting(&s_NupOnlyMode); + } + + if(s_NupOnlyMode) + { + s_RestoreMode = RESTORE_MODE_NUP_ONLY; + } + + if (!s_ReadSettingSuccess) + { + operationMessage.push_back(::std::string("Invalid Accsess_Point_Setting format!")); + if(!s_APSettingAnnotation) + { + s_APSettingAnnotation = true; + common::PlaySound(common::SOUND_ANNOTATION); + } + + } + + return s_ReadSettingSuccess; +} + +bool CheckAndReadVersionData(::std::vector& operationMessage) +{ + using namespace common; + + if (!ExistsVersionData()) + { + if(!s_ExistsVersionDataAnnotation) + { + s_ExistsVersionDataAnnotation = true; + common::PlaySound(common::SOUND_ANNOTATION); + } + operationMessage.push_back(::std::string("Version Data does not exist!")); + return false; + } + + // 繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ繝輔ぃ繧､繝ｫ繧定ｪｭ縺ｿ霎ｼ繧 + if (!s_ReadVersionDone) + { + s_ReadVersionDone = true; + ReadVersionData(); + } + + return s_ReadSettingSuccess; +} + +void PutAliveMessage(::std::vector& operationMessage, const char* str) +{ + std::string message = std::string(str); + static u8 i = 0; + if (i < 0xff / 4) + { + operationMessage.push_back(message + std::string(" /")); + } + else if (i < 0xff * 2 / 4) + { + operationMessage.push_back(message + std::string(" |")); + } + else if (i < 0xff * 3 / 4) + { + operationMessage.push_back(message + std::string(" \\")); + } + else + { + operationMessage.push_back(message + std::string(" -")); + } + i += 4; +} + +void ExecSyncMcuRtc() +{ + if(!common::ExistsRtcSyncFinishedFile()) + { + ImportMcuRtc(); + // 譎りｨ医ｒ辟｡蜉ｹ蛹悶☆繧 + CreateRtcSyncFinishedFile(); + } +} + +// Zero NUP髯仙ｮ壹さ繝ｼ繝 +bool NeedsNup() +{ + if(AlreadyExecutedNup() || s_NupOnlyMode) + { + return !common::ExistsUpdateCheckedFile(); + } + else + { + return false; + } +} + +void ControlState(::std::vector& operationMessage, bool& nextStep, bool& continueRestore) +{ + using namespace common; + + // 迥ｶ諷矩ｷ遘ｻController + switch (s_RestoreState) + { + // 襍ｷ蜍墓凾 + case STARTUP: + { + bool error = false; + bool needsUpdate = false; + bool needsErase = false; + bool validApSetting = false; + + // SD繧ｫ繝ｼ繝峨′謖ｿ蜈･縺輔ｌ縺ｦ縺繧九°ｼ + if (nn::fs::IsSdmcInserted()) + { + // SD繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ縺ｿ縺ｧ縺阪ｋ縺具ｼ + if (!nn::fs::IsSdmcWritable()) + { + if (!s_SdWriteProetctAnnotation) + { + s_SdWriteProetctAnnotation = true; + PlaySound(SOUND_ANNOTATION); + } + operationMessage.push_back(::std::string("Can*t Write SD Card!!\n")); + break; + } + + CheckAndReadVersionData(operationMessage); + validApSetting = CheckAndReadAPSetting(operationMessage); + if (!validApSetting) + { + error = true; + } + else + { + // NUP縺悟ｿ隕√°ｼ + if (!NeedsNup()) + { + if (s_NupOnlyMode) + { + s_RestoreState = NUP_ONLY_WAIT_SD_EJECT; + + // 繝ｪ繧ｹ繝医い迥ｶ諷九メ繧ｧ繝繧ｯ繝輔ぃ繧､繝ｫ繧偵☆縺ｹ縺ｦ蜑企勁 + DeleteAllCheckFiles(); + + break; + } + + // SD繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ縺ｿ螳御ｺ繝輔ぃ繧､繝ｫ縺後≠繧九°ｼ + if (!ExistsWriteFinishedFile()) + { + // IVS繧定ｪｭ繧√ｋ縺具ｼ + if (CanReadIVS()) + { + // 譛ｬ菴灘晄悄蛹門ｮ御ｺ繝輔ぃ繧､繝ｫ縺後≠繧九°ｼ + if (ExistsConsoleInitializedFile()) + { + // SD繧ｫ繝ｼ繝峨↓繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺後≠繧九°ｼ + if (!ExistsSerialNumberFile()) + { + COMMON_LOGGER("Can't Read Serial Number in SD Card!!\n"); + error = true; + s_RestoreState = SERIAL_IS_NOT_IN_SD; + } + else + { + ::std::string serial(reinterpret_cast (ReadSerialNumber())); + operationMessage.push_back(::std::string("Serial Number in SD : ") + serial); + } + + + // SD繧ｫ繝ｼ繝峨↓繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ繝繝ｼ繧ｿ縺後≠繧九°ｼ + if (ExistsRegionData()) + { + // 繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ繝繝ｼ繧ｿ縺ｯ荳閾ｴ縺励※縺繧九°ｼ + if (!EqualsRegionDataandRegion()) + { + COMMON_LOGGER("Current Region and Region in SD differ!!\n"); + error = true; + s_RestoreState = FAIL; + } + } + else + { + // 遘ｻ陦御ｸ崎ｽ縺ｪ縺ｮ縺ｧFAIL + COMMON_LOGGER("Can't Read Region in SD Card!!\n"); + error = true; + s_RestoreState = FAIL; + } + + } + else + { + if (!ExistsIVSFile()) + { + // 遘ｻ陦御ｸ崎ｽ縺ｪ縺ｮ縺ｧFAIL + COMMON_LOGGER("Can't Read IVS in SD Card!!\n"); + error = true; + s_RestoreState = FAIL; + } + else + { + COMMON_LOGGER("Initialize Console\n"); + + // SD繧ｫ繝ｼ繝峨ｮIVS縺ｨ譛ｬ菴薙ｮIVS縺ｯ逡ｰ縺ｪ繧九°ｼ + if (EqualsIVSFileandIVS()) + { + // 蜷御ｸ譛ｬ菴薙↓譖ｸ縺肴綾縺昴≧縺ｨ縺励◆繝輔ぃ繧､繝ｫ繧剃ｽ懊ｋ + COMMON_LOGGER("Restore to the same console. Initialize.\n"); + CreateTryRestoreSameConsoleFile(); + } + else + { + // 譛ｬ菴灘晄悄蛹門ｮ御ｺ繝輔ぃ繧､繝ｫ繧剃ｽ懊ｋ + CreateConsoleInitializedFile(); + + } + + // 繝輔ぃ繧､繝ｫ繧ｷ繧ｹ繝繝縺ｮ蛻晄悄蛹悶ｒ陦後≧ + InitializeFileSystem(); + error = true; + s_RestoreState = REBOOTING; + } + } + } + else + { + error = true; + operationMessage.push_back(::std::string("Can't Read IVS!!")); + } + } + else + { + if (validApSetting) + { + // 蜑企勁蜃ｦ逅繧定｡後≧ + needsErase = true; + } + } + } + else + { + if (validApSetting) + { + // 繝阪ャ繝医Ρ繝ｼ繧ｯ繧｢繝繝励ョ繝ｼ繝医ｒ陦後≧ + needsUpdate = true; + } + } + + } + } + else + { + error = true; + operationMessage.push_back(::std::string("Insert SD Card!!")); + } + + // AC繧｢繝繝励ち縺悟ｿ隕√°ｼ + if (NeedsAcAdater()) + { + error = true; + operationMessage.push_back(::std::string("Connect AC Adapter!!")); + } + + // 繧ｨ繝ｩ繝ｼ縺檎┌縺代ｌ縺ｰ騾ｲ陦檎畑繝｡繝繧ｻ繝ｼ繧ｸ陦ｨ遉ｺ + if (!error) + { + operationMessage.push_back(::std::string("Push A or START Button")); + if(needsUpdate) + { + operationMessage.push_back(::std::string("Network Update Mode")); + } + else if(needsErase) + { + operationMessage.push_back(::std::string("Clock Sync Mode")); + } + else + { + operationMessage.push_back(::std::string("Import Data Mode")); + } + + if(!s_PlayedStartCursor) + { + PlaySound(SOUND_CURSOR); + s_PlayedStartCursor = true; + } + } + + if (nextStep && !error) + { + if (needsUpdate) + { + COMMON_LOGGER("Start Network Update\n"); + s_RestoreState = UPDATE_IN_PROGRESS; + } + else if(needsErase) + { + COMMON_LOGGER("Erase Trash\n"); + s_RestoreState = ERASE; + } + else + { + COMMON_LOGGER("Start Import Data\n"); + // Zero NUP髯仙ｮ + // RTC蜷梧悄繧定｡後≧ + // NUP縺輔ｌ縺ｪ縺蝣ｴ蜷医′縺ゅｋ縺ｮ縺ｧ縺薙％縺ｧ蜷梧悄 + ExecSyncMcuRtc(); + + s_RestoreState = RESTORE_TWL_SOUND; + } + + } + } + break; + + // 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ縺郡D繧ｫ繝ｼ繝峨↓縺ｪ縺縺薙→隴ｦ蜻 + case SERIAL_IS_NOT_IN_SD: + { + operationMessage.push_back(::std::string("Serial Number Is Not In SD Card")); + operationMessage.push_back(::std::string("Push A or START Button")); + operationMessage.push_back(::std::string("Import Data Mode")); + + if (!s_SerialNumberAnnotation) + { + s_SerialNumberAnnotation = true; + PlaySound(SOUND_ANNOTATION); + } + + if (nextStep) + { + s_RestoreState = RESTORE_TWL_SOUND; + } + } + break; + + // 繧｢繝繝励ョ繝ｼ繝井ｸｭ + case UPDATE_IN_PROGRESS: + { + continueRestore = true; + + // AC繧｢繝繝励ち縺悟ｿ隕√°ｼ + if (NeedsAcAdater()) + { + continueRestore = false; + operationMessage.push_back(::std::string("Connect AC Adapter!!")); + } + + // 繧｢繝繝励ョ繝ｼ繝医ｒ陦後≧ + if(!s_ExecuteFgNup) + { + ImportCountryLanguageData(); + StartFGNetworkUpdate(); + s_ExecuteFgNup = true; + } + + // 蜍輔＞縺ｦ縺繧九％縺ｨ繧定｡ｨ遉ｺ + { + PutAliveMessage(operationMessage, "Updating"); + } + + + if (IsNetworkUpdateFinished()) + { + FinishFGNetworkUpdate(); + // 繧ｨ繝ｩ繝ｼ縺後≠縺｣縺溘ｉ陦ｨ遉ｺ縺吶ｋ + if(GetUpdateResult().IsFailure()) + { + // AP縺瑚ｦ九▽縺九ｉ縺ｪ縺 + if(GetUpdateResult() == nn::ac::ResultNotFoundAccessPoint()) + { + COMMON_LOGGER("No Access Point Found!"); + } + } + + if (GetUpdateResult().IsSuccess()) + { + COMMON_LOGGER("Network Update Finished.\n"); + // 繧｢繝繝励ョ繝ｼ繝亥ｮ御ｺ繝輔ぃ繧､繝ｫ繧剃ｽ懈 + CreateUpdateFinishedFile(); + + s_RestoreState = UPDATE_DONE; + + } + else + { + if (s_FgNupRetryCount++ < RETRY_MAX) + { + // 繧ｨ繝ｩ繝ｼ縺ｮ縺溘ａ繧繧顔峩縺 + COMMON_LOGGER_RESULT_IF_FAILED(GetUpdateResult()); + COMMON_LOGGER("Network Update Failed. Retrying... %d\n", s_FgNupRetryCount); + + // FGNUP逕ｨ縺ｮ繧ｹ繝ｬ繝繝峨ｒ菴懊ｋ縺ｨ縺薙°繧峨ｄ繧顔峩縺 + s_ExecuteFgNup = false; + } + else + { + s_RestoreState = FAIL; + } + } + + } + } + break; + + // 繧｢繝繝励ョ繝ｼ繝亥ｮ御ｺ + case UPDATE_DONE: + { + operationMessage.push_back(::std::string("Network Update Done.")); + operationMessage.push_back(::std::string("Press A or START Button to Reboot")); + + if(!s_PlayedRebootCursor) + { + PlaySound(SOUND_CURSOR); + s_PlayedRebootCursor = true; + } + + if (nextStep) + { + s_RestoreState = REBOOTING; + } + } + break; + + + // TWL繧ｵ繧ｦ繝ｳ繝蛾伜沺縺ｮ譖ｸ縺崎ｾｼ縺ｿ荳ｭ + case RESTORE_TWL_SOUND: + { + static bool init = true; + if (init) + { + // 繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧 + ImportTwlSoundData(); + init = false; + } + + // 蜃ｦ逅縺悟ｮ御ｺ縺励◆ + if (IsImportFinished()) + { + FinalizeImportThread(); + s_RestoreState = RESTORE_TWL_PHOTO; + } + } + break; + + // TWL蜀咏悄鬆伜沺縺ｮ譖ｸ縺崎ｾｼ縺ｿ + case RESTORE_TWL_PHOTO: + { + static bool init = true; + if (init) + { + // 繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧 + ImportTwlPhotoData(); + init = false; + } + + // 蜃ｦ逅縺悟ｮ御ｺ縺励◆ + if (IsImportFinished()) + { + FinalizeImportThread(); + s_RestoreState = RESTORE_IN_PROGRESS; + } + } + break; + + + // 譖ｸ縺崎ｾｼ縺ｿ荳ｭ + case RESTORE_IN_PROGRESS: + { + continueRestore = true; + + // AC繧｢繝繝励ち縺悟ｿ隕√°ｼ + if (NeedsAcAdater()) + { + continueRestore = false; + operationMessage.push_back(::std::string("Connect AC Adapter!!")); + } + + // 繝繝ｼ繧ｿ繧定ｪｭ縺ｿ霎ｼ繧 + ImportData(); + + // 蜃ｦ逅縺悟ｮ御ｺ縺励◆ + if (continueRestore && IsImportFinished()) + { + COMMON_LOGGER("Import NAND Data Finished.\n"); + + if (GetProgress() > 99) + { + s_RestoreState = POST_RESTORE; + } + else + { + s_RestoreState = FAIL; + } + + } + } + break; + + // 繝ｪ繝悶ｼ繝井ｸｭ + case REBOOTING: + { + static bool init = true; + + if (init) + { + // ErrDisp縺九ｉ蠑慕畑 + // 讓ｩ髯舌ｒ繧ゅｉ縺医ｰ謌仙粥縺吶ｋ縺ｯ縺 + nn::Result result = nn::ns::CTR::InitializeForShell(); + if (result.IsSuccess()) + { + COMMON_LOGGER("System Reboot.\n"); + + nn::ns::CTR::HardwareResetAsync(nn::CTR::MEMORY_ARRANGE_NORMAL); + while (!nn::applet::IsExpectedToCloseApplication()) + { + nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromMilliSeconds(5)); + } + + nn::ns::CTR::FinalizeForShell(); + + // INFO: 繝ｪ繝悶ｼ繝医ｯ髱槫酔譛溘ｮ縺溘ａ蜃ｦ逅縺ｯ邯咏ｶ + } + init = false; + } + } + break; + + // 譖ｸ縺崎ｾｼ縺ｿ蠕後ｮ蜃ｦ逅 + case POST_RESTORE: + { + operationMessage.push_back(::std::string("Post Process...")); + // 譖ｸ縺崎ｾｼ縺ｿ螳御ｺ繝輔ぃ繧､繝ｫ繧剃ｽ懈 + CreateWriteFinishedFile(); + + s_RestoreState = RESTORE_DONE; + } + break; + + // 譖ｸ縺崎ｾｼ縺ｿ螳御ｺ + case RESTORE_DONE: + { + operationMessage.push_back(::std::string("Restore Done.")); + operationMessage.push_back(::std::string("Press A or START Button to Reboot")); + + if(!s_PlayedRebootCursor) + { + PlaySound(SOUND_CURSOR); + s_PlayedRebootCursor = true; + } + + if (nextStep) + { + s_RestoreState = REBOOTING; + } + } + break; + + // 蜑企勁蜃ｦ逅 + case ERASE: + { + Cleanup(); + s_RestoreState = HISTORY_RECOVER; + } + break; + + // 蜑企勁蜃ｦ逅 + case HISTORY_RECOVER: + { + static bool init = true; + if (init) + { + // ptm縺ｮ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ遘ｻ陦悟ｾ後↓譎りｨ医ｒ辟｡蜉ｹ蛹悶☆繧 + nn::ptm::CTR::InvalidateSystemTime(); + + // 蜷後§譛ｬ菴薙↓譖ｸ縺肴綾縺吝ｴ蜷医ｯ蛻晄悄蛹悶＠縺ｪ縺 + if (!ExistsTryRestoreSameConsoleFile()) + { + // cfg縺ｮ繝上ｼ繝峨え繧ｧ繧｢蝗ｺ譛画ュ蝣ｱ繧団al蛟､縺ｧ蛻晄悄蛹悶☆繧 + InitializeHardwareDependentSetting(); + } + + init = false; + } + + s_RestoreState = TIME_ADJUST; + } + + + // 譎りｨ医≠繧上○ + case TIME_ADJUST: + { + static bool init = true; + if(init) + { + COMMON_LOGGER("Adjust Time\n"); + AdjustTime(); + init = false; + } + + // 蜍輔＞縺ｦ縺繧九％縺ｨ繧定｡ｨ遉ｺ + { + PutAliveMessage(operationMessage, "Sync Clock"); + } + + if(IsTimeAdjustFinished()) + { + if(IsTimeAdjustSuccessed()) + { + s_RestoreState = WAIT_SD_EJECT; + } + else + { + s_RestoreState = FAIL; + } + + // 繝ｪ繧ｹ繝医い迥ｶ諷九メ繧ｧ繝繧ｯ繝輔ぃ繧､繝ｫ繧偵☆縺ｹ縺ｦ蜑企勁 + DeleteAllCheckFiles(); + } + } + break; + + // 縺吶∋縺ｦ螳御ｺ + case WAIT_SD_EJECT: + { + operationMessage.push_back(::std::string("ALL Done. Pull Out SD Card.")); + // SD繧ｫ繝ｼ繝画栢縺代ｮ縺ｿ縺ｧ谺｡縺ｮ迥ｶ諷九↓驕ｷ遘ｻ縺吶ｋ + + if (!s_PlayedSdPullOutCursor) + { + common::PlaySound(common::SOUND_CURSOR); + s_PlayedSdPullOutCursor = true; + } + + } + break; + + // 縺吶∋縺ｦ螳御ｺ + case ALL_DONE: + { + operationMessage.push_back(::std::string("Restore Succeeded!!")); + static bool init = true; + if (init) + { + PlaySound(SOUND_OK); + init = false; + } + } + break; + + // 譖ｸ縺崎ｾｼ縺ｿ螟ｱ謨 + case FAIL: + { + static bool init = true; + if(init) + { + // 迥ｶ諷句晄悄蛹 + DeleteAllCheckFiles(); + init = false; + } + + operationMessage.push_back(::std::string("Failed.")); + if (!s_PlayedFailSound) + { + PlaySound(SOUND_NG); + s_PlayedFailSound = true; + } + } + break; + + case NUP_ONLY_WAIT_SD_EJECT: + { + operationMessage.push_back(::std::string("Update Done. Pull Out SD Card.")); + + // SD繧ｫ繝ｼ繝画栢縺代ｮ縺ｿ縺ｧ谺｡縺ｮ迥ｶ諷九↓驕ｷ遘ｻ縺吶ｋ + if (!s_PlayedSdPullOutCursor) + { + common::PlaySound(common::SOUND_CURSOR); + s_PlayedSdPullOutCursor = true; + } + } + break; + + case NUP_ONLY_WAIT_NEXT: + { + operationMessage.push_back(::std::string("A or START Button to Shutdown.")); + + if(nextStep) + { + s_RestoreState = SHUTDOWN; + } + } + break; + + case SHUTDOWN: + { + // 譛ｬ菴灘晄悄蛹悶ｒ陦後≧ + InitializeFileSystem(); + + // 繧ｷ繝｣繝繝医ム繧ｦ繝ｳ縺吶ｋ + nn::ptm::CTR::ShutdownAsync(0, nn::fnd::TimeSpan::FromSeconds(0)); + } + break; + + } +} + +bool InProgress() +{ + return s_RestoreState == RESTORE_IN_PROGRESS; +} + +bool IsRestoreSucceeded() +{ + return s_RestoreState == ALL_DONE; +} + +bool IsRestoreFailed() +{ + return s_RestoreState == FAIL; +} + +void OnSdEjected() +{ + if(s_RestoreState == WAIT_SD_EJECT || s_RestoreState == ALL_DONE) + { + s_RestoreState = ALL_DONE; + } + else if(s_RestoreState == NUP_ONLY_WAIT_SD_EJECT || s_RestoreState == NUP_ONLY_WAIT_NEXT) + { + s_RestoreState = NUP_ONLY_WAIT_NEXT; + } + // FAIL縺ｮ縺ｨ縺阪ｯ荳譌ｦ髮ｻ貅舌ｒ蛻繧峨↑縺縺ｨ蜍輔°縺ｪ縺繧医≧縺ｫ縺励※縺翫￥ + else if(s_RestoreState != FAIL) + { + InitializeState(); + ClearFileReadResult(); + } +} + +void InitializeState() +{ + s_RestoreState = STARTUP; + s_RestoreMode = RESTORE_MODE_RESTORE; + + common::InitializeFileCheck(); + + s_ExistAPSettingAnnotation = false; + s_ReadSettingDone = false; + s_ReadSettingSuccess = false; + s_APSettingAnnotation = false; + s_SerialNumberAnnotation = false; + s_PlayedFailSound = false; + s_ExecuteFgNup = false; + s_FgNupRetryCount = 0; + s_PlayedStartCursor = false; + s_PlayedRebootCursor = false; + s_PlayedSdPullOutCursor = false; + s_NupOnlyMode = false; + s_ReadVersionDone = false; + s_SdWriteProetctAnnotation = false; +} + +u32 GetProgress() +{ + if(s_RestoreState == RESTORE_TWL_SOUND || + s_RestoreState == RESTORE_TWL_PHOTO || + s_RestoreState == RESTORE_IN_PROGRESS || + s_RestoreState == POST_RESTORE || + s_RestoreState == RESTORE_DONE) + { + return GetImportProgress(); + } + else if(s_RestoreState == UPDATE_IN_PROGRESS || + s_RestoreState == UPDATE_DONE) + { + return GetUpdateProgress(); + } + else + { + return 0; + } + +} + +RestoreMode GetRestoreMode() +{ + return s_RestoreMode; +} + +} // namespace ConsoleRestore diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Controller.h b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Controller.h new file mode 100644 index 0000000..d2b802b --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Controller.h @@ -0,0 +1,46 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Contoroller.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef CONTOROLLER_H_ +#define CONTOROLLER_H_ + +#include +#include +#include + +namespace ConsoleRestore +{ + +typedef enum RestoreMode +{ + RESTORE_MODE_RESTORE, + RESTORE_MODE_NUP_ONLY +} RestoreMode; + +const u32 RETRY_MAX = 3; + +void ControlState(::std::vector& operationMessage, bool& nextStep, bool& continueRestore); +bool InProgress(); +bool IsRestoreSucceeded(); +bool IsRestoreFailed(); +u32 GetProgress(); + +void OnSdEjected(); +void InitializeState(); +RestoreMode GetRestoreMode(); + +} + +#endif /* CONTOROLLER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Importer.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Importer.cpp new file mode 100644 index 0000000..0e81600 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Importer.cpp @@ -0,0 +1,1472 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Importer.cpp + + Copyright 2009 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 +#include +#include +#include +#include // cfg:nor縺ｮ蛻晄悄蛹悶↓蠢隕 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "FileName.h" +#include "Importer.h" +#include "SdMountManager.h" +#include "ConsoleRestore.h" +#include "HeapManager.h" +#include "SdReaderWriter.h" +#include "CommonLogger.h" +#include "FileTransfer.h" +#include "common_Types.h" +#include "Aes_define.h" +#include "configLoader.h" +#include "PlayHistoryManager.h" +#include "FileChecker.h" +#include "VersionDetect.h" + +#include +#include + +namespace ConsoleRestore +{ +namespace +{ +const size_t IMPORT_THREAD_STACK_SIZE = 0x4000; +nn::os::Thread s_ImportThread; +nn::os::StackBuffer s_ImportThreadStack; + +const size_t TIME_ZONE_LENGTH = 9; // "+23:45" +char s_TimeZoneStr[TIME_ZONE_LENGTH]; + +TimeZone s_TimeZone; +const size_t NTP_SERVER_NAME_LENGTH = 256; +char s_NtpServerName[NTP_SERVER_NAME_LENGTH]; + +bool s_CheckedEqualsIVSFileandIVS = false; +bool s_CheckedEqualsRegionDataandRegion = false; +bool s_ReadSerialNumber = false; + +// 繧ｷ繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ +u8 s_SerialNo[nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN]; + +// 遨ｺ縺ｮ繝輔ぃ繧､繝ｫ繧剃ｽ懈舌☆繧 +bool CreateEmptyFile(const wchar_t* path); +// SD縺九ｉNAND縺ｫ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繧偵さ繝斐ｼ縺吶ｋ +void ImportSaveData(); +// SD縺九ｉNOR縺ｫNOR繝繝ｼ繧ｿ繧偵さ繝斐ｼ縺吶ｋ +void ImportNorData(); + +// IVS蠕ｩ蜿ｷ蛹也畑IV +bit8 s_IvsDecryptIv[AES_BLOCK_SIZE] = +{ + 0xdf, 0x0f, 0xf9, 0x1b, 0x34, 0x47, 0x70, 0x7f, + 0x7d, 0x06, 0x85, 0xe6, 0xe7, 0xb6, 0x4e, 0xe9 +}; + +// SD繧ｫ繝ｼ繝峨↓菫晏ｭ倥＠縺ｦ縺ゅｋ繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ +common::VerDef s_SDVersionData; + +} + +CheckedNetworkSetting s_CurrentNetowrkSetting1; + +void ConvertTimeZoneString(const char* str) +{ + s_TimeZone.hour = 0; + s_TimeZone.minutes = 0; + s_TimeZone.isMinus = false; + + bool hour = true; + bool ten = true; + u32 count = 0; + for(u32 i = 0; i < TIME_ZONE_LENGTH && count < 2; i++) + { + switch (str[i]) + { + case ':': + { + hour = false; + } + break; + + case '"': + { + // 2蝗櫁ｪｭ繧薙□繧臥ｵゆｺ + count++; + } + break; + + case '+': + { + s_TimeZone.isMinus = false; + } + break; + + case '-': + { + s_TimeZone.isMinus = true; + } + break; + + default: + { + if(hour) + { + if(ten) + { + s_TimeZone.hour += (str[i] - '0') * 10; + ten = false; + } + else + { + s_TimeZone.hour += str[i] - '0'; + ten = true; + } + } + else + { + if(ten) + { + s_TimeZone.minutes += (str[i] - '0') * 10; + ten = false; + } + else + { + s_TimeZone.minutes += str[i] - '0'; + ten = true; + } + } + } + break; + } + } + + + NN_LOG("Converted TimeZone = "); + if(s_TimeZone.isMinus) + { + NN_LOG("-"); + } + NN_LOG("%02d:%02d\n", s_TimeZone.hour, s_TimeZone.minutes); + +} + +namespace +{ + +bool CreateEmptyFile(const wchar_t* path) +{ + nn::Result result; + bool create = false; + result = common::SdMountManager::Mount(); + + if (result.IsSuccess()) + { + nn::fs::FileOutputStream fos; + + result = fos.TryInitialize(path, true); + if(result.IsSuccess()) + { + fos.TryFlush(); + create = true; + } + fos.Finalize(); + } + + common::SdMountManager::Unmount(); + + return create; +} + +} + +u8* ReadSerialNumber() +{ + if(s_ReadSerialNumber) + { + return s_SerialNo; + } + + COMMON_LOGGER("Read Serial Number in SD.\n"); + + size_t size; + + common::SdReaderWriter sdReader; + sdReader.ReadBuf(common::SERIAL_PATHNAME, s_SerialNo, nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN, &size); + s_ReadSerialNumber = true; + return s_SerialNo; +} + +bool EqualsIVSFileandIVS() +{ + nn::Result result; + void* ivs; + size_t ivsSize; + size_t readSize; + static bool retval = false; + + if(s_CheckedEqualsIVSFileandIVS) + { + return retval; + } + + COMMON_LOGGER("Check IVS\n"); + + GetIvs(&ivs, &ivsSize); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize() / 2; + NN_LOG("AllocatableSize = %d\n", bufSize); + + void* enc = common::HeapManager::GetHeap()->Allocate(bufSize); + if (enc != NULL) + { + common::SdReaderWriter sdReader; + + result = sdReader.ReadBuf(common::IVS_PATHNAME, enc, bufSize, &readSize); + if(result.IsSuccess()) + { + void *dec = common::HeapManager::GetHeap()->Allocate(readSize); + if(dec != NULL) + { + // AES蠕ｩ蜿ｷ蛹悶☆繧 + nn::crypto::Initialize(); + nn::crypto::SwAesCtrContext swAesCtrContest; + + swAesCtrContest.Initialize(s_IvsDecryptIv, common::key, sizeof(common::key)); + swAesCtrContest.Decrypt(dec, enc, readSize); + + NN_LOG("readSize = %d, ivsSize = %d\n", readSize, ivsSize); + // 繧ｵ繧､繧ｺ荳閾ｴ縺九▽蜀螳ｹ荳閾ｴ縺ｧtrue + if (readSize == ivsSize && std::memcmp(ivs, dec, ivsSize) == 0) + { + retval = true; + } + + common::HeapManager::GetHeap()->Free(dec); + + } + else + { + NN_LOG("Failed Allocate Heap!! %s, %d", __FILE__, __LINE__); + } + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + s_CheckedEqualsIVSFileandIVS = true; + common::HeapManager::GetHeap()->Free(enc); + } + else + { + NN_LOG("Failed Allocate Heap!! %s, %d", __FILE__, __LINE__); + return retval; + } + + return retval; +} + +bool EqualsRegionDataandRegion() +{ + nn::Result result; + static bool retval = false; + + if(s_CheckedEqualsRegionDataandRegion) + { + return retval; + } + + COMMON_LOGGER("Check Region\n"); + + nn::cfg::CTR::CfgRegionCode region; + region = nn::cfg::CTR::GetRegion(); + + nn::cfg::CTR::CfgRegionCode sdRegion; + common::SdReaderWriter sdReader; + size_t dummy; + + result = sdReader.ReadBuf(common::REGION_DATA_PATHNAME, &sdRegion, sizeof(sdRegion), &dummy); + s_CheckedEqualsRegionDataandRegion = true; + if(result.IsSuccess()) + { + retval = (region == sdRegion); + return retval; + } + else + { + retval = false; + return retval; + } +} + +void SetCountry(nn::cfg::CTR::CfgCountryCode countryCode) +{ + using namespace nn::cfg::CTR; + using namespace nn::cfg::CTR::detail; + + SimpleAddressIdCfgData simpleAddressId; + TwlCountryCodeCfgData countryData; + + nn::cfg::CTR::system::Initialize(); + + NN_UTIL_PANIC_IF_FAILED(nn::cfg::CTR::system::GetConfig(&simpleAddressId, sizeof(SimpleAddressIdCfgData), GET_CFG_KEY(NN_CFG_SIMPLE_ADDRESS, NN_CFG_SIMPLE_ADDRESS_ID))); + NN_UTIL_PANIC_IF_FAILED(nn::cfg::CTR::system::GetConfig(&countryData, sizeof(TwlCountryCodeCfgData), GET_CFG_KEY(NN_CFG_TWL, NN_CFG_TWL_COUNTRY_CODE))); + nn::cfg::CTR::system::Finalize(); + + simpleAddressId.id = (countryCode << CFG_SIMPLE_ADDRESS_ID_COUNTRY_SHIFT) | (1 + << CFG_SIMPLE_ADDRESS_ID_REGION_SHIFT); + countryData.country = countryCode; + + nn::cfg::CTR::system::Initialize(); + NN_UTIL_PANIC_IF_FAILED(nn::cfg::CTR::system::SetConfig(GET_CFG_KEY(NN_CFG_SIMPLE_ADDRESS, NN_CFG_SIMPLE_ADDRESS_ID), &simpleAddressId, sizeof(SimpleAddressIdCfgData))); + NN_UTIL_PANIC_IF_FAILED(nn::cfg::CTR::system::SetConfig(GET_CFG_KEY(NN_CFG_TWL, NN_CFG_TWL_COUNTRY_CODE), &countryData, sizeof(TwlCountryCodeCfgData))); + nn::cfg::CTR::system::FlushConfig(); + nn::cfg::CTR::system::Finalize(); +} + +void SetLanguage(nn::cfg::CTR::CfgLanguageCode languageCode) +{ + NN_UTIL_PANIC_IF_FAILED(nn::cfg::CTR::init::SetConfig( + GET_CFG_KEY(nn::cfg::CTR::detail::NN_CFG_USER_INFO, + nn::cfg::CTR::detail::NN_CFG_USER_INFO_LANGUAGE), + &languageCode, + sizeof(nn::cfg::CTR::detail::LanguageCfgData))); + NN_UTIL_PANIC_IF_FAILED(nn::cfg::CTR::init::FlushConfig()); + nn::cfg::nor::CTR::Initialize(); + NN_UTIL_PANIC_IF_FAILED(nn::cfg::nor::CTR::SetLanguage(static_cast(languageCode))); + nn::cfg::nor::CTR::Finalize(); +} + +void ImportCountryLanguageData() +{ + nn::Result result; + + if (common::ExistsCountryLanguageFile()) + { + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::COUNTRY_SETTING_PATHNAME, buf, bufSize, &readSize); + if (result.IsSuccess()) + { + // SD縺九ｉ隱ｭ縺ｿ蜃ｺ縺玲仙粥 + SetCountry(reinterpret_cast (buf)->country); + + SetLanguage(reinterpret_cast (buf)->language); + } + else + { + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + common::HeapManager::GetHeap()->Free(buf); + } + } + else + { + // 繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ縺九ｉ驕ｩ蠖薙↑蝗ｽ繧呈欠螳壹☆繧 + nn::cfg::CTR::CfgRegionCode region; + region = nn::cfg::CTR::GetRegion(); + NN_LOG("Country Setting does not exist. Use Default Setting\n"); + switch(region) + { + case nn::cfg::CTR::CFG_REGION_JAPAN: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_JAPAN); + } + break; + + case nn::cfg::CTR::CFG_REGION_AMERICA: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_UNITED_STATES); + } + break; + + case nn::cfg::CTR::CFG_REGION_EUROPE: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_FRANCE); + } + break; + + case nn::cfg::CTR::CFG_REGION_AUSTRALIA: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_AUSTRALIA); + } + break; + + case nn::cfg::CTR::CFG_REGION_CHINA: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_CHINA); + } + break; + + case nn::cfg::CTR::CFG_REGION_KOREA: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_SOUTH_KOREA); + } + break; + + case nn::cfg::CTR::CFG_REGION_TAIWAN: + { + SetCountry(nn::cfg::CTR::CFG_COUNTRY_TAIWAN); + } + break; + } + + } +} + +inline u8 DecimalToBcd(u8 param) +{ + u8 theTen, theOne; + theTen = param / 10; + theOne = param - theTen * 10; + return (theTen << 4 | theOne); +} + +void ImportMcuRtc() +{ + COMMON_LOGGER("Import RTC Data.\n"); + nn::Result result; + nn::Handle handle = GetMcuHandle(); + + if(handle.IsValid()) + { + if (common::CheckFileExists(common::MCU_RTC_PATHNAME)) + { + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::MCU_RTC_PATHNAME, buf, bufSize, &readSize); + if (result.IsSuccess()) + { + // mcu繧剃ｽｿ縺｣縺ｦ繧ｻ繝繝医☆繧 + nn::mcu::CTR::HwCheck mcu(handle); + nn::mcu::CTR::RtcData* rtc = reinterpret_cast (buf); + NN_LOG("RTC = 20%02d/%02d/%02d %02d:%02d:%02d\n", rtc->m_Year, rtc->m_Month, rtc->m_Day, rtc->m_Hour, rtc->m_Minute, rtc->m_Second); + + // BCD螟画鋤縺悟ｿ隕 + + size_t RTC_PARAM_SIZE = sizeof(nn::mcu::CTR::RtcData); + u8 bcd[RTC_PARAM_SIZE]; + for (int i = 0; i < RTC_PARAM_SIZE; i++) + { + bcd[i] = DecimalToBcd(reinterpret_cast (rtc)[i]); + } + + result = mcu.WriteBySend(nn::drivers::mcu::CTR::MCU_RTC_SEC_ADDR, bcd, RTC_PARAM_SIZE); + + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + common::HeapManager::GetHeap()->Free(buf); + } + else + { + COMMON_LOGGER("Failed Allocate Heap!!\n"); + } + } + } +} + +void InitializeFileSystem() +{ + nn::Result result; + + for (u32 i = 0; i < common::TWL_PATHNAME_MAX; i++) + { + result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[i], common::TWL_FS_ARCHIVE_KIND[i]); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + if (result.IsSuccess()) + { + nn::fs::Directory dir; + std::vector entryList; //繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｨ繝ｳ繝医Μ荳隕ｧ繧呈ｼ邏 + std::vector::iterator entryIndex; + + std::wstring currentDirectory = common::NAND_TWL_ROOT_PATHNAME_WITH_SLASH_TABLE[i]; + result = dir.TryInitialize(currentDirectory.c_str()); + + nn::fs::DirectoryEntry entry; + s32 numEntry; + for (;;) + { + result = dir.TryRead(&numEntry, &entry, 1); + if (result.IsFailure()) + { + dir.Finalize(); + } + if (numEntry == 0) + { + // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ繧帝哩縺倥ｋ + dir.Finalize(); + + // 繝ｫ繝ｼ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蟄舌ｒ髢九￥ + for (entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++) + { + // 繝繧｣繝ｬ繧ｯ繝医Μ縺ｪ繧牙炎髯､縺吶ｋ + if (entryIndex->attributes.isDirectory) + { + NN_LOG("Try Delete %ls%ls/\n", currentDirectory.c_str(), entryIndex->entryName); + result = nn::fs::TryDeleteDirectoryRecursively((currentDirectory + ::std::wstring( + entryIndex->entryName)).c_str()); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + } + // 繝輔ぃ繧､繝ｫ縺ｪ繧牙炎髯､縺吶ｋ + else + { + NN_LOG("Try Delete %ls%ls\n", currentDirectory.c_str(), entryIndex->entryName); + result = nn::fs::TryDeleteFile( + (currentDirectory + ::std::wstring(entryIndex->entryName)).c_str()); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + } + + // 蜑企勁螳御ｺ + break; + } + else + { + // vector縺ｫ菫晏ｭ倥☆繧 + entryList.push_back(entry); + if (entry.attributes.isDirectory) + { + NN_LOG("%ls%ls/\n", currentDirectory.c_str(), entry.entryName); + } + else + { + NN_LOG("%ls%ls\n", currentDirectory.c_str(), entry.entryName); + } + } + } + } + nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[i]); + } + + nn::fs::InitializeCtrFileSystem(); +} + +void ImportIvs() +{ + nn::Result result; + nn::fs::FileOutputStream fos; + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize() / 2; + void* enc = common::HeapManager::GetHeap()->Allocate(bufSize); + if (enc != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::IVS_PATHNAME, enc, bufSize, &readSize); + if(result.IsSuccess()) + { + // SD縺九ｉ隱ｭ縺ｿ蜃ｺ縺玲仙粥 + result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); + if (result.IsSuccess()) + { + void *dec = common::HeapManager::GetHeap()->Allocate(readSize); + if (dec != NULL) + { + // AES蠕ｩ蜿ｷ蛹悶☆繧 + nn::crypto::Initialize(); + nn::crypto::SwAesCtrContext swAesCtrContest; + + swAesCtrContest.Initialize(s_IvsDecryptIv, common::key, sizeof(common::key)); + swAesCtrContest.Decrypt(dec, enc, readSize); + + // IVS譖ｸ縺崎ｾｼ縺ｿ + result = fos.TryInitialize(common::IVS_NAND_PATHNAME, true); + if (result.IsSuccess()) + { + if (result.IsSuccess()) + { + s32 writeSize; + result = fos.TryWrite(&writeSize, dec, readSize, true); + if (result.IsSuccess()) + { + COMMON_LOGGER("Import IVS.\n"); + } + } + } + common::HeapManager::GetHeap()->Free(dec); + } + else + { + COMMON_LOGGER("Failed Allocate Heap!!\n"); + } + + } + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + } + common::HeapManager::GetHeap()->Free(enc); + } + else + { + COMMON_LOGGER("Failed Allocate Heap!!\n"); + } +} + +void ImportThreadFunc() +{ + nn::Result result; + + result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + result = common::SdMountManager::Mount(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + + common::CopyDirectory( + (::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME)).c_str(), + common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH, + buf, bufSize); + + common::HeapManager::GetHeap()->Free(buf); + } + + common::SdMountManager::Unmount(); + nn::fs::Unmount(common::NAND_ARCHIVE_NAME); + + NN_LOG("Import Thread Finalize\n"); +} + +namespace +{ + +void ImportSaveData() +{ + // SD繧ｫ繝ｼ繝峨°繧丑AND縺ｫ隱ｭ縺ｿ霎ｼ縺ｿ + nn::Result result; + + // SD繧ｫ繝ｼ繝峨↓縺ゅｋ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繧ｵ繧､繧ｺ繧定ｨ育ｮ + u32 fileNum = 0; + u32 fileSize = 0; + + common::SdMountManager::Mount(); + common::CalculateFileNum(::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME), fileNum, fileSize); + common::SdMountManager::Unmount(); + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ險ｭ螳 + common::InitializeTransferProgress(fileSize); + + NN_LOG("File Number = %d\n", fileNum); + NN_LOG("File Size = %d\n", fileSize); + + // SD繧ｫ繝ｼ繝峨↓縺ゅｋ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繝繧｣繝ｬ繧ｯ繝医Μ莉･荳九ｮ繝繝ｼ繧ｿ繧誰AND縺ｫ繧ｳ繝斐ｼ + COMMON_LOGGER("Import NAND Data Start...\n"); + s_ImportThread.Start(ImportThreadFunc, s_ImportThreadStack); + +} + +void ImportNorData() +{ + COMMON_LOGGER("Import NOR Data.\n"); + + nn::Result result; + + nn::cfg::nor::CTR::Initialize(); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::NOR_PATHNAME, buf, bufSize, &readSize); + if(result.IsSuccess()) + { + // cfg繧剃ｽｿ縺｣縺ｦ繧ｻ繝繝医☆繧 + result = nn::cfg::nor::CTR::SetNtrSetting(&reinterpret_cast(buf)->ntrConfig.ncd, + &reinterpret_cast(buf)->ntrConfig.ncd_ex); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // TWL WiFi險ｭ螳 + result = nn::cfg::nor::CTR::WriteTwlWifiSetting(0, reinterpret_cast(buf)->TwlWiFiSetting, + common::TWL_WIFI_SETTING_SIZE); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // NTR WiFi險ｭ螳 + result = nn::cfg::nor::CTR::WriteNtrWifiSetting(0, reinterpret_cast(buf)->NtrWiFiSetting, + common::NTR_WIFI_SETTING_SIZE); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + common::HeapManager::GetHeap()->Free(buf); + } + else + { + COMMON_LOGGER("Failed Allocate Heap!!\n"); + } + +} + + +} + +void ReadVersionData() +{ + nn::Result result; + + std::memset(&s_SDVersionData, 0, sizeof(common::VerDef)); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::VERSION_DATA_PATHNAME, buf, bufSize, &readSize); + if(result.IsSuccess()) + { + // 繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ繧剃ｿ晄戟縺吶ｋ + std::memcpy(&s_SDVersionData, buf, readSize); + NN_LOG("SD Version = %02d.%02d.%02d-%02d\n", s_SDVersionData.cup.majorVersion, + s_SDVersionData.cup.minorVersion, + s_SDVersionData.cup.microVersion, + s_SDVersionData.nup.majorVersion); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + common::HeapManager::GetHeap()->Free(buf); + } + else + { + COMMON_LOGGER("Failed Allocate Heap!!\n"); + } +} + +bool AlreadyExecutedNup() +{ + return s_SDVersionData.nup.majorVersion != 0; +} + +void Cleanup() +{ + nn::Result result; + bool execCleanup; + + result = nn::am::NeedsCleanup(&execCleanup, nn::fs::MEDIA_TYPE_NAND); + if(result.IsSuccess()) + { + if(execCleanup) + { + COMMON_LOGGER("Cleanup NAND\n"); + nn::am::DoCleanup(nn::fs::MEDIA_TYPE_NAND); + } + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); +} + +void DeleteAllCheckFiles() +{ + nn::Result result; + common::SdMountManager::Mount(); + + for(u32 i = 0; i < sizeof(CHECK_FILENAME_TABLE) / sizeof(CHECK_FILENAME_TABLE[0]); i++) + { + if(common::CheckFileExists(CHECK_FILENAME_TABLE[i])) + { + result = nn::fs::TryDeleteFile(CHECK_FILENAME_TABLE[i]); + COMMON_LOGGER_RESULT_IF_FAILED(result); + } + } + common::SdMountManager::Unmount(); +} + +void FinalizeImportThread() +{ + s_ImportThread.Join(); + s_ImportThread.Finalize(); +} + +bool IsImportFinished() +{ + return !s_ImportThread.IsAlive(); +} + +void CreateWriteFinishedFile() +{ + CreateEmptyFile(common::WRITE_FINISHED_CHECK_PATHNAME); +} + +void CreateConsoleInitializedFile() +{ + CreateEmptyFile(common::INITIALIZED_CHECK_PATHNAME); +} + +void CreateUpdateFinishedFile() +{ + CreateEmptyFile(common::UPDATE_CHECK_PATHNAME); +} + +void CreateRtcSyncFinishedFile() +{ + CreateEmptyFile(common::RTC_SYNC_CHECK_PATHNAME); +} + +void CreateTryRestoreSameConsoleFile() +{ + CreateEmptyFile(common::TRY_RESTORE_SAME_CONSOLE_PATHNAME); +} + +u32 GetImportProgress() +{ + return common::GetProgress(); +} + +bool UpdateNetworkSetting(nn::ac::NetworkSetting& networkSetting) +{ + nn::Result result; + bool retval = true; + + result = nn::ac::InitializeInternal(); + if(result.IsFailure()) + { + retval = false; + COMMON_LOGGER("Error: nn::ac::InitializeInternal() failed\n"); + } + else + { + //迚ｹ縺ｫ蜈･蜉帙＆縺帙ｋ蠢隕√ｮ縺ｪ縺閾ｪ蜍輔〒險ｭ螳壹☆繧矩逶ｮ + networkSetting.wireless.enable = true; + networkSetting.wireless.multiSsid.enable = false; + networkSetting.ip.enableDHCP = true; + networkSetting.scanlessConnect.hasConnected = false; + networkSetting.proxy.enable = false; + networkSetting.other.enableUPnP = false; + + // 迴ｾ蝨ｨ縺ｮ繧､繝ｳ繧ｿ繝ｼ繝阪ャ繝郁ｨｭ螳1繧剃ｸ譎ら噪縺ｫ菫晄戟 + result = nn::ac::LoadNetworkSetting(0, s_CurrentNetowrkSetting1.setting); + if(result.IsSuccess()) + { + s_CurrentNetowrkSetting1.isValid = true; + } + else + { + s_CurrentNetowrkSetting1.isValid = false; + } + + result = nn::ac::UpdateNetworkSetting( 0, networkSetting ); + if(!result.IsSuccess()) + { + retval = false; + COMMON_LOGGER("Error: SetNetworkSetting (Update Error)\n"); + } + else + { + result = nn::ac::FinalizeInternal(); + if (!result.IsSuccess()) + { + retval = false; + COMMON_LOGGER("Error: SetNetworkSetting (Finalize Error)\n"); + } + } + } + + return retval; +} + +bool ReadSetting(bool* nupOnly) +{ + nn::Result result; + bool retval = true; + common::ConfigFileLoader configfileLoader; + + common::SdMountManager::Mount(); + size_t size = common::HeapManager::GetHeap()->GetAllocatableSize(); + void* heapAddr = common::HeapManager::GetHeap()->Allocate(size); + + if(heapAddr != NULL) + { + result = configfileLoader.Initialize(common::AP_SETTING_PATHNAME, heapAddr, size); + if (result.IsSuccess()) + { + nn::ac::NetworkSetting networkSetting; + + { + const char* ssid = configfileLoader.ReadAsChar(L"SSID"); // SSID + if(ssid == NULL) + { + COMMON_LOGGER("SSID: is missing\n"); + retval = false; + } + else + { + std::strncpy(reinterpret_cast (networkSetting.wireless.essidSecurity.ssid), ssid, 32); + networkSetting.wireless.essidSecurity.ssidLength = std::strlen(ssid) % 33; + COMMON_LOGGER("SSID = %s\n", networkSetting.wireless.essidSecurity.ssid); + } + } + + + { + const char* mode = configfileLoader.ReadAsChar(L"MODE"); // MODE + if(mode == NULL) + { + COMMON_LOGGER("MODE: is missing\n"); + retval = false; + } + else + { + if (std::strcmp(mode, "OPEN") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::OPEN; + } + else if (std::strcmp(mode, "WEP40") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WEP_40BIT; + } + else if (std::strcmp(mode, "WEP104") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WEP_104BIT; + } + else if (std::strcmp(mode, "WEP128") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WEP_128BIT; + } + else if (std::strcmp(mode, "WPA-TKIP") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WPA_TKIP; + } + else if (std::strcmp(mode, "WPA2-TKIP") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WPA2_TKIP; + } + else if (std::strcmp(mode, "WPA-AES") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WPA_AES; + } + else if (std::strcmp(mode, "WPA2-AES") == 0) + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::WPA2_AES; + } + else + { + networkSetting.wireless.essidSecurity.securityMode = nn::ac::OPEN; + } + + switch (networkSetting.wireless.essidSecurity.securityMode) + { + case nn::ac::OPEN: + { + COMMON_LOGGER("MODE = OPEN\n"); + } + break; + + case nn::ac::WEP_40BIT: + { + COMMON_LOGGER("MODE = WEP_40BIT\n"); + } + break; + + case nn::ac::WEP_104BIT: + { + COMMON_LOGGER("MODE = WEP_104BIT\n"); + } + break; + + case nn::ac::WEP_128BIT: + { + COMMON_LOGGER("MODE = WEP_128BIT\n"); + } + break; + + case nn::ac::WPA_TKIP: + { + COMMON_LOGGER("MODE = WPA_TKIP\n"); + } + break; + + case nn::ac::WPA2_TKIP: + { + COMMON_LOGGER("MODE = WPA2_TKIP\n"); + } + break; + + case nn::ac::WPA_AES: + { + COMMON_LOGGER("MODE = WPA_AES\n"); + } + break; + + case nn::ac::WPA2_AES: + { + COMMON_LOGGER("MODE = WPA2_AES\n"); + } + break; + + } + + } + } + + { + const char* pass = configfileLoader.ReadAsChar(L"PASS"); // PASS + if(pass == NULL) + { + COMMON_LOGGER("PASS: is missing\n"); + retval = false; + } + else + { + switch (networkSetting.wireless.essidSecurity.securityMode) + { + case nn::ac::WEP_40BIT: + case nn::ac::WEP_104BIT: + case nn::ac::WEP_128BIT: + { + std::strncpy(reinterpret_cast (networkSetting.wireless.essidSecurity.passphrase), + pass, 64); + std::memcpy(networkSetting.wireless.essidSecurity.key, + networkSetting.wireless.essidSecurity.passphrase, 64); + } + break; + + case nn::ac::WPA_TKIP: + case nn::ac::WPA2_TKIP: + case nn::ac::WPA_AES: + case nn::ac::WPA2_AES: + { + std::strncpy(reinterpret_cast (networkSetting.wireless.essidSecurity.passphrase), + pass, 64); + size_t phrase_size = std::strlen( + reinterpret_cast (networkSetting.wireless.essidSecurity.passphrase)); + + nn::nwm::Ssid ssid(reinterpret_cast (networkSetting.wireless.essidSecurity.ssid)); + nn::nwm::ConvertPasswordToPsk( + reinterpret_cast (networkSetting.wireless.essidSecurity.passphrase), + phrase_size, ssid, networkSetting.wireless.essidSecurity.key); + } + break; + + case nn::ac::OPEN: + default: + { + //do nothing + } + break; + } + } + } + + + { + s32 dnsAuto; // DNS_AUTO + if(configfileLoader.ReadAsChar(L"DNS_AUTO") == NULL) + { + COMMON_LOGGER("DNS_AUTO: is missing\n"); + retval = false; + } + else + { + dnsAuto = configfileLoader.ReadAsInteger(L"DNS_AUTO"); + if (dnsAuto == 1) + { + networkSetting.ip.autoDNSSetting = true; + } + else + { + networkSetting.ip.autoDNSSetting = false; + } + + COMMON_LOGGER("DNS_AUTO = %d\n", networkSetting.ip.autoDNSSetting); + + } + } + + { + const char* dnsPrimary = configfileLoader.ReadAsChar(L"DNS_PRI"); // 繝励Λ繧､繝槭ΜDNS + if(!networkSetting.ip.autoDNSSetting) + { + if (dnsPrimary == NULL) + { + COMMON_LOGGER("DNS_PRI: is missing\n"); + retval = false; + + } + else + { + u8 dns[4]; + nn::socket::InAddr addr; + if (1 == nn::socket::InetAtoN(dnsPrimary, &addr)) + { + dns[3] = (0xff & (addr.addr >> 24)); + dns[2] = (0xff & (addr.addr >> 16)); + dns[1] = (0xff & (addr.addr >> 8)); + dns[0] = (0xff & (addr.addr)); + } + std::memcpy(networkSetting.ip.dns[0], dns, 4); + COMMON_LOGGER("DNS_PRI = %03d.%03d.%03d.%03d\n", networkSetting.ip.dns[0][0], + networkSetting.ip.dns[0][1], + networkSetting.ip.dns[0][2], + networkSetting.ip.dns[0][3]); + + } + } + } + + { + const char* dnsSecondary = configfileLoader.ReadAsChar(L"DNS_SEC"); // 繧ｻ繧ｫ繝ｳ繝繝ｪDNS + if(!networkSetting.ip.autoDNSSetting) + { + if(dnsSecondary == NULL) + { + COMMON_LOGGER("DNS_SEC: is missing\n"); + retval = false; + } + else + { + u8 dns[4]; + nn::socket::InAddr addr; + if (1 == nn::socket::InetAtoN(dnsSecondary, &addr)) + { + dns[3] = (0xff & (addr.addr >> 24)); + dns[2] = (0xff & (addr.addr >> 16)); + dns[1] = (0xff & (addr.addr >> 8)); + dns[0] = (0xff & (addr.addr)); + } + std::memcpy(networkSetting.ip.dns[1], dns, 4); + COMMON_LOGGER("DNS_SEC = %03d.%03d.%03d.%03d\n", networkSetting.ip.dns[1][0], + networkSetting.ip.dns[1][1], + networkSetting.ip.dns[1][2], + networkSetting.ip.dns[1][3]); + + } + } + } + + { + const char* ntpServerName = configfileLoader.ReadAsChar(L"NTPSRV"); // NTP繧ｵ繝ｼ繝 + if(ntpServerName == NULL) + { + COMMON_LOGGER("NTPSRV: is missing\n"); + retval = false; + } + else + { + std::strlcpy(s_NtpServerName, ntpServerName, sizeof(s_NtpServerName)); + COMMON_LOGGER("NTPSRV = %s\n", s_NtpServerName); + } + + + } + + { + const char* timeZone = configfileLoader.ReadAsChar(L"TIMEZONE"); // 繧ｿ繧､繝繧ｾ繝ｼ繝ｳ + if(timeZone == NULL) + { + COMMON_LOGGER("TIMEZONE: is missing\n"); + retval = false; + } + else + { + std::strlcpy(s_TimeZoneStr, timeZone, sizeof(s_TimeZoneStr)); + COMMON_LOGGER("TIMEZONE = %s\n", s_TimeZoneStr); + ConvertTimeZoneString(s_TimeZoneStr); + } + + } + + { + NN_NULL_ASSERT(nupOnly); + if (configfileLoader.ReadAsChar(L"NUP_ONLY") != NULL) + { + s32 num = configfileLoader.ReadAsInteger(L"NUP_ONLY"); + if (num == 1) + { + *nupOnly = true; + COMMON_LOGGER("NUP Only Mode.\n"); + } + } + } + + configfileLoader.Finalize(); + + // 譖ｸ縺崎ｾｼ縺ｿ螳御ｺ縺励↑縺代ｌ縺ｰfalse + if(!UpdateNetworkSetting(networkSetting)) + { + retval = false; + } + + } + else + { + NN_LOG("configfileLoader Initialize Failed\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + retval = false; + } + common::HeapManager::GetHeap()->Free(heapAddr); + } + else + { + NN_LOG("Can't Allocate Heap\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + retval = false; + } + + common::SdMountManager::Unmount(); + return retval; +} + +char* GetNtpServerName() +{ + return s_NtpServerName; +} + +TimeZone GetTimeZone() +{ + return s_TimeZone; +} + +CheckedNetworkSetting* GetTempNetworkSetting() +{ + return &s_CurrentNetowrkSetting1; +} + +void ImportTwlData(enum common::TWL_PATH_INDEX path) +{ + NN_ASSERT(path < common::TWL_PATHNAME_MAX); + + nn::Result result; + + result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + result = common::SdMountManager::Mount(); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + NN_LOG("AllocatableSize = %d\n", bufSize); + + + u32 fileNum = 0; + u32 fileSize = 0; + + common::CalculateFileNum(::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring( + common::SD_TWL_ROOTNAME_TABLE[path]), fileNum, fileSize); + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ險ｭ螳 + common::InitializeTransferProgress(fileSize); + + NN_LOG("File Number = %d\n", fileNum); + NN_LOG("File Size = %d\n", fileSize); + + + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + wchar_t archiveName[256]; + ::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path], std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1); + std::wstring archiveString(archiveName); + common::CopyDirectory( + (::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(), + (archiveString + ::std::wstring(L"/")).c_str(), + buf, bufSize); + + common::HeapManager::GetHeap()->Free(buf); + } + + common::SdMountManager::Unmount(); + nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]); + +} + +void ImportTwlPhotoDataFunc() +{ + COMMON_LOGGER("Import Twl Photo Data.\n"); + ImportTwlData(common::TWL_PHOTO); +} + +void ImportTwlSoundDataFunc() +{ + COMMON_LOGGER("Import Twl Sound Data.\n"); + ImportTwlData(common::TWL_SOUND); +} + +void ImportTwlPhotoData() +{ + s_ImportThread.Start(ImportTwlPhotoDataFunc, s_ImportThreadStack); +} + +void ImportTwlSoundData() +{ + s_ImportThread.Start(ImportTwlSoundDataFunc, s_ImportThreadStack); +} + + +void ClearFileReadResult() +{ + s_CheckedEqualsIVSFileandIVS = false; + s_CheckedEqualsRegionDataandRegion = false; + s_ReadSerialNumber = false; +} + +void ImportPlayHistoryThreadFunc() +{ + common::PlayHistoryManager historyManager; + + COMMON_LOGGER("Import PlayHistory\n"); + historyManager.Import(); +} + +void ImportPlayHistory() +{ + s_ImportThread.Start(ImportPlayHistoryThreadFunc, s_ImportThreadStack); +} + +void ExportTouchPanelCfgData() +{ + using namespace nn::cfg::CTR::detail; + + nn::Result result; + nn::cfg::CTR::detail::TouchPanelCfgData touchPanelCfgData; + common::SdReaderWriter sdWriter; + + COMMON_LOGGER("Export TouchPanelData\n"); + + common::SdMountManager::Mount(); + + result = nn::cfg::CTR::init::GetConfig(&touchPanelCfgData, sizeof(TouchPanelCfgData), + GET_CFG_KEY(NN_CFG_HID, NN_CFG_HID_CAL_TOUCHPANEL)); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + if (result.IsSuccess()) + { + result = sdWriter.WriteBuf(common::TOUCH_PANEL_CALIBRATION_PATHNAME, &touchPanelCfgData, sizeof(touchPanelCfgData)); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + + common::SdMountManager::Unmount(); +} + +bool ImportTouchPanelCfgData(nn::cfg::CTR::detail::TouchPanelCfgData* data) +{ + using namespace nn::cfg::CTR::detail; + + nn::Result result; + bool retval = false; + + COMMON_LOGGER("Import TouchPanelData\n"); + + common::SdMountManager::Mount(); + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::TOUCH_PANEL_CALIBRATION_PATHNAME, buf, bufSize, &readSize); + if(result.IsSuccess()) + { + // SD縺九ｉ隱ｭ縺ｿ蜃ｺ縺玲仙粥 + std::memcpy(data, buf, readSize); + retval = true; + } + else + { + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + common::HeapManager::GetHeap()->Free(buf); + } + + common::SdMountManager::Unmount(); + return retval; +} + +void InitializeHardwareDependentSetting() +{ + using namespace nn::cfg::CTR::detail; + nn::Result result = nn::ResultSuccess(); + + nn::cfg::CTR::detail::TouchPanelCfgData touchPanelCfgData; + if(ImportTouchPanelCfgData(&touchPanelCfgData)) + { + result = nn::cfg::CTR::init::SetConfig(GET_CFG_KEY(NN_CFG_HID, NN_CFG_HID_CAL_TOUCHPANEL), &touchPanelCfgData, + sizeof(TouchPanelCfgData)); + } + + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + nn::cfg::CTR::init::ResetCameraCalibration(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + nn::cfg::CTR::init::ResetAnalogStickCalibration(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); +} + +void ImportData() +{ + static bool init = true; + if(init) + { + // NAND縺ｮ縺斐∩繧貞炎髯､縺吶ｋ + Cleanup(); + + // SD繧ｫ繝ｼ繝峨ｮIVS繝輔ぃ繧､繝ｫ繧呈嶌縺崎ｾｼ繧 + ImportIvs(); + + // NOR繝繝ｼ繧ｿ繧呈嶌縺崎ｾｼ繧 + ImportNorData(); + + // 繧ｿ繝繝√ヱ繝阪Ν繧ｭ繝｣繝ｪ繝悶Ξ繝ｼ繧ｷ繝ｧ繝ｳ繝繝ｼ繧ｿ繧担D繧ｫ繝ｼ繝峨↓蜃ｺ蜉帙☆繧 + // 譛ｬ菴灘晄悄蛹門ｾ後ｯcal蛟､縺瑚ｨｭ螳壹＆繧後※縺繧 + ExportTouchPanelCfgData(); + + // SD繧ｫ繝ｼ繝峨ｮ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ繧誰AND縺ｫ譖ｸ縺崎ｾｼ繧 + ImportSaveData(); + + init = false; + } + +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Importer.h b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Importer.h new file mode 100644 index 0000000..03f46d1 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Importer.h @@ -0,0 +1,97 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Importer.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef IMPORTER_H_ +#define IMPORTER_H_ + +#include +#include "FileName.h" +#include + +namespace ConsoleRestore +{ + +bool EqualsIVSFileandIVS(); +bool EqualsRegionDataandRegion(); +u8* ReadSerialNumber(); + +void FinalizeImportThread(); +bool IsImportFinished(); +void ImportTwlSoundData(); +void ImportTwlPhotoData(); +void ImportData(); +void CreateWriteFinishedFile(); +void CreateUpdateFinishedFile(); +void CreateConsoleInitializedFile(); +void CreateRtcSyncFinishedFile(); +void CreateTryRestoreSameConsoleFile(); +u32 GetImportProgress(); + +// NAND縺ｮ縺斐∩繧貞炎髯､縺吶ｋ +void Cleanup(); + +const wchar_t* const CHECK_FILENAME_TABLE[] = +{ + common::UPDATE_CHECK_PATHNAME, + common::INITIALIZED_CHECK_PATHNAME, + common::WRITE_FINISHED_CHECK_PATHNAME, + common::RTC_SYNC_CHECK_PATHNAME, + common::TRY_RESTORE_SAME_CONSOLE_PATHNAME +}; + +void DeleteAllCheckFiles(); + +struct TimeZone +{ + u32 hour; + u32 minutes; + bool isMinus; + NN_PADDING3; +}; + +bool ReadSetting(bool* nupOnly); +char* GetNtpServerName(); +TimeZone GetTimeZone(); + +struct CheckedNetworkSetting +{ + nn::ac::CTR::NetworkSetting setting; + bool isValid; + NN_PADDING3; +}; + +CheckedNetworkSetting* GetTempNetworkSetting(); +void ImportCountryLanguageData(); +void ImportMcuRtc(); + +// TWL蜀咏悄鬆伜沺繧貞晄悄蛹悶＠縺ｦ縺九ｉ譛ｬ菴灘晄悄蛹悶ｒ陦後≧ +void InitializeFileSystem(); + +void ClearFileReadResult(); + +// 繝励Ξ繧､螻･豁ｴ繧定ｪｭ縺ｿ霎ｼ縺ｿ縺ｾ縺吶Ｑtm縺ｮ繧ｻ繝ｼ繝悶ョ繝ｼ繧ｿ遘ｻ陦悟ｾ後↓蜻ｼ縺ｳ蜃ｺ縺吝ｿ隕√′縺ゅｊ縺ｾ縺 +void ImportPlayHistory(); + +// cfg縺ｮ繝上ｼ繝峨え繧ｧ繧｢蝗ｺ譛蛾伜沺繧団al蛟､縺ｧ蛻晄悄蛹悶＠縺ｾ縺 +void InitializeHardwareDependentSetting(); + +// SD繧ｫ繝ｼ繝我ｸ翫ｮ繝舌ｼ繧ｸ繝ｧ繝ｳ諠蝣ｱ繧定ｪｭ縺ｿ縺ｾ縺 +void ReadVersionData(); +// 遘ｻ陦悟譛ｬ菴薙′NUP貂医∩縺九←縺縺 +bool AlreadyExecutedNup(); + +} + +#endif /* IMPORTER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/NtpClient.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/NtpClient.cpp new file mode 100644 index 0000000..f2a5114 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/NtpClient.cpp @@ -0,0 +1,376 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: NtpClient.cpp + + Copyright 2009 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Importer.h" +#include "CommonLogger.h" + +namespace ConsoleRestore +{ + +namespace { + +const size_t NTP_THREAD_STACK_SIZE = 0x1000; +nn::os::Thread s_NtpThread; +nn::os::StackBuffer s_NtpThreadStack; +bool s_NtpSyncSuccessed = false; + + +struct NTP_Packet{ // NTP繝代こ繝繝 + u32 controlWord; + u32 rootDelay; + u32 rootDispersion; + u32 referenceId; + s64 referenceTimestamp; + s64 startTimestamp; + s64 receiveTimestamp; + u32 transmitTimestampSeconds; + u32 transmitTimestampFractions; +}; + +const size_t TIMEOUT_MILLISECOND = 5000; // 繧ｿ繧､繝繧｢繧ｦ繝 繝溘Μ遘呈焚 +NTP_Packet s_NTPSendPacket; // 騾∽ｿ｡縺吶ｋNTP繝代こ繝繝 +NTP_Packet s_NTPRecvPacket; // 蜿嶺ｿ｡縺吶ｋNTP繝代こ繝繝 +const u32 NTP_PORT_NUM = 123; + +nn::Result InitializeNetwork(void) +{ + nn::Result result; + nn::ac::Config config; + + result = nn::ac::Initialize(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + // 謗･邯夊ｦ∵ｱら畑縺ｮ繝代Λ繝｡繝ｼ繧ｿ繧剃ｽ懈 + result = nn::ac::CreateDefaultConfig(&config); + if (result.IsFailure()) + { + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + return result; + } + + // 繝繝舌ャ繧ｰ逕ｨ縺ｫ謗･邯壹ユ繧ｹ繝医ｒ辟｡蜉ｹ蛹 + nn::ac::DebugSetNetworkArea(&config, nn::ac::NETWORK_AREA_LAN); + + // 謗･邯夊ｦ∵ｱゅｒ逋ｺ陦 + result = nn::ac::ConnectWithoutEula(config); + if (result.IsFailure()) + { + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + return result; + } + + return nn::ResultSuccess(); +} + +nn::Result FinalizeNetwork(void) +{ + nn::Result result; + + // 謗･邯夊ｦ∵ｱら畑縺ｮ繝代Λ繝｡繝ｼ繧ｿ繧剃ｽ懈 + result = nn::ac::Close(); + NN_UTIL_RETURN_IF_FAILED(result); + + result = nn::ac::Finalize(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + return nn::ResultSuccess(); +} + +bool GetNtpTime(u32* ntpTime) +{ + nn::Result result; + + bool retval = true; + NN_LOG("Initializing network.\n"); + + // 譛ｬ菴薙↓譖ｸ縺崎ｾｼ縺ｾ繧後※縺繧九ロ繝繝医Ρ繝ｼ繧ｯ險ｭ螳壹ｒ菴ｿ縺｣縺ｦ繝阪ャ繝医Ρ繝ｼ繧ｯ謗･邯壹ｒ蛻晄悄蛹 + result = InitializeNetwork(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + { + NN_LOG("Initializing socket..\n"); + + // 荳縺､縺ｮ繧ｹ繝ｬ繝繝峨°繧峨た繧ｱ繝繝 API 繧貞茜逕ｨ縺吶ｋ + const s32 sessionCount = 1; + // 繧ｽ繧ｱ繝繝医ｮ騾∝女菫｡繝舌ャ繝輔ぃ縺ｨ縺励※ 64 KB 繧貞牡繧雁ｽ薙※ + const size_t bufferSizeForSockets = 65536; + // 繧ｽ繧ｱ繝繝医Λ繧､繝悶Λ繝ｪ縺ｫ蠢隕√↑繝ｯ繝ｼ繧ｯ繧ｵ繧､繧ｺ繧呈ｱゅａ繧 + const size_t workSizeForLibrary = nn::socket::GetRequiredMemorySize(bufferSizeForSockets, sessionCount); + + // 繝ｯ繝ｼ繧ｯ繝｡繝｢繝ｪ繧堤｢ｺ菫昴＠縺ｦ 4KB 縺ｫ繧｢繝ｩ繧､繝ｳ縺ｫ縺吶ｋ + u8* pWorkMemory = new u8[workSizeForLibrary + 4096]; + uptr workMemoryAddress = nn::math::RoundUp(reinterpret_cast (pWorkMemory), 4096); + + // 繧ｽ繧ｱ繝繝医Λ繧､繝悶Λ繝ｪ縺ｮ蛻晄悄蛹 + result = nn::socket::Initialize(workMemoryAddress, workSizeForLibrary, bufferSizeForSockets, sessionCount); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + { + s32 ret; + nn::socket::InAddr addr, netmask; + ret = nn::socket::GetPrimaryAddress(reinterpret_cast (&addr), reinterpret_cast (&netmask)); + NN_ASSERT(ret == 0); + COMMON_LOGGER("host : %s\n", nn::socket::InetNtoA(addr)); + COMMON_LOGGER("netmask : %s\n", nn::socket::InetNtoA(netmask)); + + nn::socket::InAddr dns1, dns2; + ret = nn::socket::GetResolver(reinterpret_cast (&dns1), reinterpret_cast (&dns2)); + if (ret == 0) + { + COMMON_LOGGER("dns1 : %s\n", nn::socket::InetNtoA(dns1)); + COMMON_LOGGER("dns2 : %s\n", nn::socket::InetNtoA(dns2)); + } + + nn::socket::InAddr gateway; + ret = nn::socket::GetDefaultGateway(reinterpret_cast (&gateway)); + if (ret == 0) + { + COMMON_LOGGER("gateway : %s\n", nn::socket::InetNtoA(gateway)); + } + + COMMON_LOGGER("\n"); +#ifndef NN_SWITCH_DISABLE_DEBUG_PRINT + nn::socket::DumpRoutingTable(); +#endif + } + + { + s32 socket = nn::socket::Socket(nn::socket::PF_INET, nn::socket::SOCK_DGRAM, 0); + NN_LOG("socket = %d\n", socket); + + // 繧ｯ繝ｩ繧､繧｢繝ｳ繝医い繝峨Ξ繧ｹ縺ｮ險ｭ螳 + nn::socket::SockAddrIn host_addr; + host_addr.len = sizeof(nn::socket::SockAddrIn); + host_addr.family = nn::socket::AF_INET; + host_addr.addr.addr = 0; + host_addr.port = nn::socket::HtoNs(NTP_PORT_NUM); + + // 繝ｭ繝ｼ繧ｫ繝ｫ繧｢繝峨Ξ繧ｹ繧偵ヰ繧､繝ｳ繝 + s32 ret = nn::socket::Bind(socket, &host_addr); + NN_LOG("bind = %d\n", ret); + + // ******************************************************************************** + // NTP繝代こ繝繝医ｒ逕滓舌＠縺ｦ騾√ｋ + // ******************************************************************************** + + // 繧ｵ繝ｼ繝舌い繝峨Ξ繧ｹ縺ｮ險ｭ螳 + nn::socket::SockAddrIn serverSockAddrIn; + serverSockAddrIn.len = sizeof(nn::socket::SockAddrIn); + serverSockAddrIn.family = nn::socket::AF_INET; + + // GetHostByName繧剃ｽｿ縺蝣ｴ蜷 + nn::socket::HostEnt* serverHostent; + u64 serveraddr = 0; + serverHostent = nn::socket::GetHostByName(GetNtpServerName()); + if (serverHostent == NULL) + { + COMMON_LOGGER("Error: GetHostByName %s\n", GetNtpServerName()); + retval = false; + } + else + { + // 繧ｵ繝ｼ繝舌ｮ繝帙せ繝域ュ蝣ｱ縺九ｉIP繧｢繝峨Ξ繧ｹ繧偵さ繝斐ｼ + serveraddr = *(reinterpret_cast (serverHostent->addrList[0])); + } + serverSockAddrIn.addr.addr = serveraddr; + COMMON_LOGGER("Destination address: %s\n", nn::socket::InetNtoA(serverSockAddrIn.addr)); + serverSockAddrIn.port = nn::socket::HtoNs(NTP_PORT_NUM); // 繝昴ｼ繝育分蜿ｷ + + // NTP繝代こ繝繝医ｒSNTP逕ｨ縺ｫ蛻晄悄蛹悶☆繧 + s_NTPSendPacket.controlWord = nn::socket::HtoNl(0x0B000000); + s_NTPSendPacket.rootDelay = 0; + s_NTPSendPacket.rootDispersion = 0; + s_NTPSendPacket.referenceId = 0; + s_NTPSendPacket.referenceTimestamp = 0; + s_NTPSendPacket.startTimestamp = 0; + s_NTPSendPacket.receiveTimestamp = 0; + s_NTPSendPacket.transmitTimestampSeconds = 0; + s_NTPSendPacket.transmitTimestampFractions = 0; + + // 繧ｵ繝ｼ繝舌ｒ謖螳壹＠縺ｦNTP繝代こ繝繝医ｒ騾∽ｿ｡縺吶ｋ + if ((ret = nn::socket::SendTo(socket, reinterpret_cast (&s_NTPSendPacket), sizeof(s_NTPSendPacket), 0, + &serverSockAddrIn)) < 0) + { + COMMON_LOGGER("Error: Failed Send to Server, %d\n", ret); + retval = false; + } + + NN_LOG("SendTo finished\n"); + + // 蜿嶺ｿ｡蠕縺｡ + nn::socket::PollFd pollFd; + pollFd.fd = socket; + pollFd.events = nn::socket::POLLRDNORM; + if ((ret = nn::socket::Poll(&pollFd, 1, TIMEOUT_MILLISECOND)) < 0) + { + COMMON_LOGGER("Error: recv error, %d\n", ret); + retval = false; + } + + NN_LOG("Poll Finished\n"); + + switch (pollFd.revents) + { + case nn::socket::POLLERR: // 繧ｽ繧ｱ繝繝医↓繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺ｾ縺励◆縲 + COMMON_LOGGER("Error: POLLERR %s %d\n", __FILE__, __LINE__); + retval = false; + break; + case nn::socket::POLLHUP: // 繧ｹ繝医Μ繝ｼ繝繝ｻ繧ｽ繧ｱ繝繝医′譛ｪ謗･邯壹〒縺吶 + COMMON_LOGGER("Error: POLLHUP %s %d\n", __FILE__, __LINE__); + retval = false; + break; + case nn::socket::POLLNVAL: // 荳肴ｭ｣縺ｪ繧ｽ繧ｱ繝繝郁ｨ倩ｿｰ蟄舌〒縺吶 + COMMON_LOGGER("Error: POLLNVAL %s %d\n", __FILE__, __LINE__); + retval = false; + break; + default: + break; + } + + // 繧ｵ繝ｼ繝舌°繧画凾蛻ｻ諠蝣ｱ繧貞女菫｡縺吶ｋ + // 繧ｵ繝ｼ繝舌ｒ謖螳壹＠縺ｦ蜿嶺ｿ｡繧定｡後≧ + // 蜿嶺ｿ｡縺吶ｋ縺ｾ縺ｧ蠕縺溘＆繧後ｋ + if ((ret = nn::socket::RecvFrom(socket, reinterpret_cast (&s_NTPRecvPacket), sizeof(s_NTPRecvPacket), nn::socket::MSG_DONTWAIT, + &serverSockAddrIn)) < 0) + { + COMMON_LOGGER("Error: RecvFrom, %d\n", ret); + retval = false; + } + + NN_LOG("RecvFrom finished\n"); + + // NTP繧ｵ繝ｼ繝舌°繧牙叙蠕励＠縺滓凾蛻ｻ繧堤樟蝨ｰ譎る俣縺ｫ螟画鋤縺吶ｋ + *ntpTime = nn::socket::NtoHl(s_NTPRecvPacket.transmitTimestampSeconds) - 2208988800; /* 1970/01/01 縺九ｉ縺ｮ遘呈焚縺ｫ螟画鋤 */ + NN_LOG("ntp_time = %d\n", ntpTime); + + nn::socket::Close(socket); + NN_UNUSED_VAR(ret); + } + + NN_LOG("Finalizing socket..\n"); + // 繧ｽ繧ｱ繝繝医Λ繧､繝悶Λ繝ｪ縺ｮ邨ゆｺ + result = nn::socket::Finalize(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + + NN_LOG("Finalizing network.\n"); + result = FinalizeNetwork(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + return retval; +} + +void RestoreCurrentInternetSetting() +{ + COMMON_LOGGER("Restore Current Internet Setting\n"); + nn::Result result; + if (GetTempNetworkSetting()->isValid) + { + result = nn::ac::CTR::UpdateNetworkSetting(0, GetTempNetworkSetting()->setting); + COMMON_LOGGER_RESULT_IF_FAILED(result); + } + else + { + // 辟｡蜉ｹ縺ｮ蝣ｴ蜷医ｯ豸亥悉縺励※縺翫￥ + result = nn::ac::CTR::RemoveNetworkSetting(0); + COMMON_LOGGER_RESULT_IF_FAILED(result); + } + + result = nn::ac::FlushNetworkSetting(); + COMMON_LOGGER_RESULT_IF_FAILED(result); + + result = nn::ac::FinalizeInternal(); + COMMON_LOGGER_RESULT_IF_FAILED(result); +} + +} + +void NtpThreadFunc() +{ + // NTP譎る俣繧貞叙蠕励☆繧 + u32 ntpTime; + if (GetNtpTime(&ntpTime)) + { + // 繧ｿ繧､繝繧ｾ繝ｼ繝ｳ繧定諷ｮ縺励※DateTime縺ｫ螟画鋤縺吶ｋ + TimeZone timeZone = GetTimeZone(); + + // 1970/01/01 + nn::fnd::DateTime utc = nn::fnd::DateTime(1970, 1, 1, 0, 0, 0, 0); + nn::fnd::DateTime current = utc + nn::fnd::TimeSpan::FromSeconds(ntpTime); + + if (timeZone.isMinus) + { + current -= (nn::fnd::TimeSpan::FromHours(timeZone.hour) + nn::fnd::TimeSpan::FromMinutes(timeZone.minutes)); + } + else + { + current += nn::fnd::TimeSpan::FromHours(timeZone.hour) + nn::fnd::TimeSpan::FromMinutes(timeZone.minutes); + } + + // SWC繧呈嶌縺崎ｾｼ繧 + nn::ptm::CTR::SetUserTime(current); + + COMMON_LOGGER("Set User Time %04d/%02d/%02d %02d:%02d:%02d\n", + current.GetYear(), current.GetMonth(), current.GetDay(), current.GetHour(), current.GetMinute(), current.GetSecond()); + + s_NtpSyncSuccessed = true; + } + else + { + COMMON_LOGGER("Failed Get Ntp Time\n"); + s_NtpSyncSuccessed = false; + } + + // 繧､繝ｳ繧ｿ繝ｼ繝阪ャ繝郁ｨｭ螳壹ｒ蜈縺ｫ謌ｻ縺 + RestoreCurrentInternetSetting(); +} + +bool IsTimeAdjustFinished() +{ + // Initialize貂医∩縺九▽邨ゆｺ + return s_NtpThread.IsValid() && !s_NtpThread.IsAlive(); +} + +bool IsTimeAdjustSuccessed() +{ + return s_NtpSyncSuccessed; +} + +void AdjustTime() +{ + nn::Result result; + + result = nn::ac::CTR::InitializeInternal(); + COMMON_LOGGER_RESULT_IF_FAILED(result); + + if(IsTimeAdjustFinished()) + { + s_NtpThread.Join(); + s_NtpThread.Finalize(); + } + s_NtpThread.Start( NtpThreadFunc, s_NtpThreadStack); +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/NtpClient.h b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/NtpClient.h new file mode 100644 index 0000000..7c7bcf1 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/NtpClient.h @@ -0,0 +1,28 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: NtpClient.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef NTPCLIENT_H_ +#define NTPCLIENT_H_ + +namespace ConsoleRestore +{ + +u32 AdjustTime(); +bool IsTimeAdjustFinished(); +bool IsTimeAdjustSuccessed(); + +} + +#endif /* NTPCLIENT_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/OMakefile b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/OMakefile new file mode 100644 index 0000000..90b2103 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/OMakefile @@ -0,0 +1,89 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakefile +# +# Copyright (C)2009 Nintendo Co., Ltd. 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$ +#---------------------------------------------------------------------------- +SUPPORTED_TARGETS = CTR-T*.Process.MPCore.* +#MAKECSU = true +#INSTALL_SDK_TOOL = true +CTR_APPTYPE = BOTH +CTR_MAKE_DEVELOPMENT_IMAGE = true + +TARGET_PROGRAM = ConsoleRestore + +SAMPLED_DEMOS_COMMON_INCLUDE_DIR = $(dir $(HORIZON_ROOT)/../CTR/SampleDemos/common/include) +INCLUDES += $(SAMPLED_DEMOS_COMMON_INCLUDE_DIR) \ + ../common + +SOURCES[] = + ConsoleRestore.cpp + Controller.cpp + Importer.cpp + Updater.cpp + Ntpclient.cpp + ../common/HardwareInfo.cpp + ../common/DrawSystemState.cpp + ../common/FileTransfer.cpp + ../common/FileChecker.cpp + ../common/SdReaderWriter.cpp + ../common/HeapManager.cpp + ../common/SdLogger.cpp + ../common/wave.cpp + ../common/SimplePlayer.cpp + ../common/LogConsole.cpp + ../common/CommonLogger.cpp + ../common/SdMountManager.cpp + ../common/configLoader.cpp + ../common/PlayHistoryManager.cpp + ../common/VersionDetect.cpp + +CTR_BANNER_SPEC = $(TARGET_PROGRAM).bsf + +ROMFS_ROOT = ../common/romfiles + +LIBS += libnn_cfg \ + libnn_driversEeprom \ + libnn_driversi2c \ + libnn_driversCal \ + libnn_crypto \ + libnn_driversCodec \ + libnn_spi \ + libnn_gpio \ + libnn_pdn \ + libnn_mcu \ + libnn_i2c \ + libnn_driversCamera \ + libnn_ps \ + libnn_driversRsa \ + lib_demo \ + libnn_nwm \ + libnn_friends \ + libnn_ns \ + libnn_am \ + libnn_nim \ + +INSTALL_SDK_TOOL = true + +ROM_SPEC_FILE = $(TARGET_PROGRAM).rsf +DESCRIPTOR = $(HORIZON_ROOT)/resources/specfiles/_private/RepairTool.desc + +include $(ROOT_OMAKE)/modulerules + +VERSION_H = $(file version.h) + +$(VERSION_H): $(SOURCES) + section + bash genversion.sh + +RequireSetup($(VERSION_H)) +build: version.h $(DEFAULT_TARGETS) diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Updater.cpp b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Updater.cpp new file mode 100644 index 0000000..5985375 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Updater.cpp @@ -0,0 +1,249 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Updater.cpp + + Copyright 2009 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 +#include +#include +#include +#include +#include +#include +#include + +#include "CommonLogger.h" + +namespace ConsoleRestore +{ + +using namespace ES_NAMESPACE; +using namespace EC_NAMESPACE; + +/* ------------------------------------------------------------------- + GetCustomerSupportCode +-------------------------------------------------------------------- */ +#define NIM_UPDATER_RESULT_CHECK(result) \ +do { \ + if (result.IsFailure()) \ + { \ + ECCustomerSupportCode csc; \ + NN_UTIL_PANIC_IF_FAILED( \ + nn::nim::Updater::GetCustomerSupportCode(&csc)); \ + COMMON_LOGGER("CSCode: %d\n", csc); \ + nn::dbg::PrintResult(result); \ + s_Result = result; \ + goto LABEL_FINALIZE; \ + } \ +} while(0) + +namespace +{ + +nn::Result s_Result = nn::ResultSuccess(); + +const size_t UPDATER_THREAD_STACK_SIZE = 0x1000; +nn::os::Thread s_UpdaterThread; +nn::os::StackBuffer s_UpdaterThreadStack; + +u64 s_Progress = 0; + +} + +nn::Result PrintNetworkSetting() +{ + nn::ac::NetworkSetting networkSetting; + NN_UTIL_RETURN_IF_FAILED(nn::ac::LoadNetworkSetting(0, networkSetting)); + COMMON_LOGGER("SSID: %s\n", networkSetting.wireless.essidSecurity.ssid); + COMMON_LOGGER("DNS : %d.%d.%d.%d\n", + networkSetting.ip.dns[0][0], networkSetting.ip.dns[0][1], + networkSetting.ip.dns[0][2], networkSetting.ip.dns[0][3]); + return nn::ResultSuccess(); +} + + +nn::Result ConnectNetwork() +{ + nn::Result result = nn::ResultSuccess(); + nn::ac::Config config; + + result = nn::ac::CreateDefaultConfig(&config); + NN_UTIL_RETURN_IF_FAILED(result); + + result = nn::ac::ConnectWithoutEula(config); + NN_UTIL_RETURN_IF_FAILED(result); + + NN_LOG("Success nn::ac::ConnectWithoutEula\n"); + + NN_UTIL_RETURN_IF_FAILED(PrintNetworkSetting()); + + return nn::ResultSuccess(); +} + +nn::Result InitializeInternal() +{ + nn::Result result = nn::ResultSuccess(); + + result = nn::ac::InitializeInternal(); + NN_UTIL_RETURN_IF_FAILED(result); + + result = ConnectNetwork(); + NN_UTIL_RETURN_IF_FAILED(result); + + return nn::ResultSuccess(); +} + +nn::Result FinalizeInternal() +{ + nn::Result result = nn::ResultSuccess(); + + nn::ac::CloseAll(); + + result = nn::ac::FinalizeInternal(); + NN_UTIL_RETURN_IF_FAILED(result); + + return nn::ResultSuccess(); +} + +void UpdateThreadFunc() +{ + nn::Result result; + + NN_LOG("********************UpdateThreadFunc Start********************\n"); + nn::cfg::CTR::init::Initialize(); + nn::cfg::CfgCountryCode country; + nn::cfg::CfgRegionCode region; + const char *regionStr; + const char *countryStr; + NN_UNUSED_VAR(regionStr); + NN_UNUSED_VAR(countryStr); + + country = nn::cfg::GetCountry(); + region = nn::cfg::GetRegion(); + countryStr = nn::cfg::GetCountryCodeA2(country); + regionStr = nn::cfg::GetRegionCodeA3(region); + + COMMON_LOGGER("[Updater] country:%2d:%s\n", country, countryStr); + COMMON_LOGGER("[Updater] region :%2d:%s\n", region, regionStr); + + /* ------------------------------------------------------------------- + Initialize + -------------------------------------------------------------------- */ + NN_LOG("[Updater] nn::nim::InitializeForUpdater\n"); + result = nn::nim::InitializeForUpdater(); + NIM_UPDATER_RESULT_CHECK(result); + + NN_LOG("[Updater] InitializeInternal\n"); + result = InitializeInternal(); + NIM_UPDATER_RESULT_CHECK(result); + + + /* ------------------------------------------------------------------- + StartNetworkUpdate + -------------------------------------------------------------------- */ + NN_LOG("[Updater] nn::nim::Updater::StartNetworkUpdate()\n"); + result = nn::nim::Updater::StartNetworkUpdate(); + NIM_UPDATER_RESULT_CHECK(result); + + /* ------------------------------------------------------------------- + GetProgress + -------------------------------------------------------------------- */ + NN_LOG("[Updater] nn::nim::Updater::GetProgress()\n"); + + while(true) + { + nn::nim::NetworkUpdateProgress progress; + NIM_UPDATER_RESULT_CHECK(nn::nim::Updater::GetProgress(&progress)); + NIM_UPDATER_RESULT_CHECK(progress.lastResult); + NN_LOG("\x1b[1A\x1b[K"); + NN_LOG("Downloading %2lld/%2lld %8lld/%8lld (%d)\n", + progress.downloadedTitleNum, + progress.totalTitleNum, + progress.currentDownloadedSize, + progress.currentTotalSize, + progress.state); + + // 繧ｼ繝ｭ髯､邂励ｒ髦ｲ縺 + if(progress.totalTitleNum == 0) + { + progress.totalTitleNum++; + progress.downloadedTitleNum++; + } + if(progress.state > nn::nim::CTR::NUP_STATE_CHECKING) + { + s_Progress = progress.downloadedTitleNum * 100 / progress.totalTitleNum; + } + + if (progress.state == nn::nim::NUP_STATE_NO_NEED) + { + COMMON_LOGGER("[Updater] No need to NetworkUpdate\n"); + s_Progress = 100; + break; + } + if (progress.state == nn::nim::NUP_STATE_FINISHED) + { + COMMON_LOGGER("[Updater] Finished NetworkUpdate\n"); + s_Progress = 100; + break; + } + + nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromMilliSeconds(300)); + } + + LABEL_FINALIZE: + + /* ------------------------------------------------------------------- + Finalize + -------------------------------------------------------------------- */ + NN_LOG("[Updater] nn::nim::FinalizeForUpdater\n"); + result = nn::nim::FinalizeForUpdater(); + NIM_UPDATER_RESULT_CHECK(result); + + result = FinalizeInternal(); + NIM_UPDATER_RESULT_CHECK(result); + + NN_LOG("[Updater] Finish nim Updater demo.\n"); + +} + +void StartFGNetworkUpdate() +{ + NN_LOG("Start FGNetworkUpdate\n"); + s_Result = nn::ResultSuccess(); + s_UpdaterThread.Start(UpdateThreadFunc, s_UpdaterThreadStack); +} + +void FinishFGNetworkUpdate() +{ + NN_LOG("Finalize FGNetworkUpdate\n"); + s_UpdaterThread.Join(); + s_UpdaterThread.Finalize(); +} + +bool IsNetworkUpdateFinished() +{ + return !s_UpdaterThread.IsAlive(); +} + +u32 GetUpdateProgress() +{ + return s_Progress; +} + +nn::Result GetUpdateResult() +{ + return s_Result; +} + + +} diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Updater.h b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Updater.h new file mode 100644 index 0000000..32e6798 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/Updater.h @@ -0,0 +1,32 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Updater.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef UPDATER_H_ +#define UPDATER_H_ + +#include + +namespace ConsoleRestore +{ + +void StartFGNetworkUpdate(); +void FinishFGNetworkUpdate(); +bool IsNetworkUpdateFinished(); +u32 GetUpdateProgress(); +nn::Result GetUpdateResult(); + +} + +#endif /* UPDATER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/model.cbmd b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/model.cbmd new file mode 100644 index 0000000..f1c7b62 Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/model.cbmd differ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/sound.cbsd b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/sound.cbsd new file mode 100644 index 0000000..f1c7b62 Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/sound.cbsd differ diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/unknown24x24.ctpk b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/unknown24x24.ctpk new file mode 100644 index 0000000..794b136 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/unknown24x24.ctpk @@ -0,0 +1 @@ +ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆ8ﾆ8ﾆﾞ銷ｽｽ8ﾆｽｽｽｽｽ釡ﾞﾆ鍄踟ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽyﾎｽyﾎｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ鍄ﾞyﾎYﾎｽﾛﾞﾛﾞｽｽﾆｽｽﾛﾞyﾎﾞｽyﾎ轌ﾎ釡ﾞｽｽｽｽYﾎ轌ﾎ銷ｽｽｽｽｽyﾎﾆﾛﾞ鍄躡ﾎyﾎｽｽｽyﾎｽｺﾖｽｽｽｽｽyﾎｽyﾎｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽyﾎ躡ﾎ銷ｽｽｽｽｽﾆｽｽ轌ﾎ8ﾆｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ \ No newline at end of file diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/unknown48x48.ctpk b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/unknown48x48.ctpk new file mode 100644 index 0000000..8c7da16 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/banner/unknown48x48.ctpk @@ -0,0 +1 @@ +ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽYﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽ8ﾆ8ﾆｽｽｽｺﾖ8ﾆｺﾖ釡ﾞ銷ｽｽｽｽｽｽｽｽｽｽ8ﾆ8ﾆｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ鍄逧ﾖﾆ銷ｽｽ墮ｽ逧ﾖ銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞｽﾛﾞｽｽｽｽｽ銷ｽﾞｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｺﾖｽｽｽｽｽｽｽｽｽｽ鍄8ﾆﾞﾛﾞｽｽ墮ｽYﾎｽｽｽｽｽ躡ﾎyﾎ轌ﾎﾆｽｽｽｽｽｽｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞﾛﾞ釡ﾞ踟ｽｽ躡ﾎ銷ｽｽｽｽｽﾛﾞｽﾛﾞ銷ｽｽYﾎﾞ墮釡ﾞｺﾖｽ墮ｽﾛﾞｽｽｽｽｽ踟ｽ踟ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞｽyﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽYﾎｽ墮銷ｽﾛﾞｽﾛﾞ銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｺﾖﾛﾞｽｽｽｽｽYﾎﾆyﾎ逧ﾖ郤ﾖｽYﾎｽ觝ﾎｽｽｽｽｽｽｽｽｽｽｽｽｽｽﾛﾞ墮ｽｽｽｽｽｽyﾎｽ鍄踟ｽｽﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ踟ｽ銷ｽﾞｽYﾎ鍄銷ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽ逧ﾖｽﾛﾞｽ釡ﾞ墮ｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ8ﾆｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽｽ \ No newline at end of file diff --git a/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/genversion.sh b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/genversion.sh new file mode 100755 index 0000000..f59c27a --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/ConsoleRestore/genversion.sh @@ -0,0 +1,3 @@ +#!/bin/bash -f + +echo "#define RESTORE_VERSION_NUM \"`svnversion -n`\"" > version.h diff --git a/tags/0thNUP/ConsoleDataMigration/OMakefile b/tags/0thNUP/ConsoleDataMigration/OMakefile new file mode 100644 index 0000000..203c656 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/OMakefile @@ -0,0 +1,24 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakefile +# +# Copyright (C)2009 Nintendo Co., Ltd. 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$ +#---------------------------------------------------------------------------- + +#.SUBDIRS: $(glob D, *) +.SUBDIRS: $(exist-dirs \ + common \ + ConsoleBackup \ + ConsoleRestore \ + ) + +DefineDefaultRules() diff --git a/tags/0thNUP/ConsoleDataMigration/OMakeroot b/tags/0thNUP/ConsoleDataMigration/OMakeroot new file mode 100644 index 0000000..7ee1cb5 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/OMakeroot @@ -0,0 +1,73 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakeroot +# +# Copyright (C)2009 Nintendo Co., Ltd. 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:$ +#---------------------------------------------------------------------------- + +# ディレクトリレイアウトについての説明 +# +# a) ソースコードがルートディレクトリ直下に配置される場合 +# 例: +# /OMakeroot +# /foo/bar/OMakefile +# +# 結果: +# OMakefile と同じディレクトリ以下に objects や images が生成されます。 +# +# /foo/bar/objects/... +# /foo/bar/images/.. +# +# +# b) ソースコードが sources 以下に配置される場合 +# 例: +# /OMakeroot +# /sources/foo/bar/OMakefile +# +# 結果: +# ルートディレクトリ以下に objects や images が生成されます。 +# +# /objects/foo/bar/... +# /images/foo/bar/... +# +# + +# ルート環境変数の取得 +public.HORIZON_ROOT = +if $(defined-env HORIZON_ROOT) + HORIZON_ROOT = $(absname $(getenv HORIZON_ROOT)) + export + +if $(defined-env CTRSDK_ROOT) + CTRSDK_ROOT = $(absname $(getenv CTRSDK_ROOT)) + if $(and $(defined-env HORIZON_ROOT), $(not $(equal $(HORIZON_ROOT), $(CTRSDK_ROOT)))) + eprintln(HORIZON_ROOT と CTRSDK_ROOT が一致しません。同じパスを設定するか、どちらか一方だけを定義して下さい。) + exit(1) + HORIZON_ROOT = $(CTRSDK_ROOT) + export + +if $(not $(HORIZON_ROOT)) + eprintln($"$$CTRSDK_ROOT が定義されていません") + exit(1) + +include $(HORIZON_ROOT)/build/omake/commondefs + +DefineCommandVars() + +.PHONY: all build clean clobber +.PHONY: run run-scripts run-emumem + +# +# OMakefile の読み込み +# +.SUBDIRS: . + diff --git a/tags/0thNUP/ConsoleDataMigration/Readme.txt b/tags/0thNUP/ConsoleDataMigration/Readme.txt new file mode 100644 index 0000000..2f2f0d5 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/Readme.txt @@ -0,0 +1,10 @@ +【ビルド環境】 + +・SDK +Horizon 0_14 branch r33437 + + Horizon trunk r33597のcfgライブラリの変更をマージ + + Horizon 1_0 branch r33839のRepairTool.descをマージ + +・cygwin +・svnversion + diff --git a/tags/0thNUP/ConsoleDataMigration/common/Aes_define.h b/tags/0thNUP/ConsoleDataMigration/common/Aes_define.h new file mode 100644 index 0000000..34436ec --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/Aes_define.h @@ -0,0 +1,28 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: Aes_define.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef AES_DEFINE_H_ +#define AES_DEFINE_H_ + +namespace common +{ + bit8 key[AES_KEY_SIZE] = + { + 0x81, 0x35, 0xc6, 0x54, 0x19, 0x1a, 0x47, 0x2a, + 0x6b, 0x78, 0xbe, 0x25, 0x90, 0xf6, 0xee, 0x74 + }; +} + +#endif /* AES_DEFINE_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/CommonLogger.cpp b/tags/0thNUP/ConsoleDataMigration/common/CommonLogger.cpp new file mode 100644 index 0000000..ffc63b1 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/CommonLogger.cpp @@ -0,0 +1,117 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: CommonLogger.cpp + + Copyright 2009 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 "CommonLogger.h" +#include "LogConsole_Private.h" + +namespace common +{ + +namespace Logger +{ + +namespace +{ + static CommonLogger s_CommonLogger; + +} + +CommonLogger::CommonLogger() +{ + // TODO 閾ｪ蜍慕函謌舌＆繧後◆繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ繝ｻ繧ｹ繧ｿ繝 + +} + +CommonLogger::~CommonLogger() +{ + // TODO Auto-generated destructor stub +} + +void CommonLogger::Initialize(u32 width, u32 height, u32 maxLine, demo::RenderSystemDrawing* renderSystem) +{ + m_CriticalSection.Initialize(); + GetConsoleInstance()->Initialize(width, height, maxLine, renderSystem); +} + +void CommonLogger::Finalize() +{ + +} + +void CommonLogger::Print(const char* fmt, ...) +{ + nn::os::CriticalSection::ScopedLock lock(m_CriticalSection); + va_list vlist; + + va_start(vlist, fmt); + + nn::dbg::detail::VPrintf(fmt, vlist); + GetSdInstance()->Print(fmt, vlist); + GetConsoleInstance()->AddText(fmt, vlist); + + va_end(vlist); +} + +void CommonLogger::PrintResult(const char* fmt, ...) +{ + nn::os::CriticalSection::ScopedLock lock(m_CriticalSection); + va_list vlist; + + va_start(vlist, fmt); + + GetSdInstance()->Print(fmt, vlist); + + va_end(vlist); +} + +void CommonLogger::ClearLog() +{ + nn::os::CriticalSection::ScopedLock lock(m_CriticalSection); + GetSdInstance()->Clear(); +} + +void CommonLogger::ScrollUp() +{ + GetConsoleInstance()->ScrollUp(); +} + +void CommonLogger::ScrollDown() +{ + GetConsoleInstance()->ScrollDown(); +} + +void CommonLogger::ScrollToBegin() +{ + GetConsoleInstance()->ScrollToBegin(); +} + +void CommonLogger::ScrollToEnd() +{ + GetConsoleInstance()->ScrollToEnd(); +} + +void CommonLogger::DrawConsole() +{ + GetConsoleInstance()->Print(); +} + +CommonLogger* GetLoggerInstance() +{ + return &s_CommonLogger; +} + +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/CommonLogger.h b/tags/0thNUP/ConsoleDataMigration/common/CommonLogger.h new file mode 100644 index 0000000..2105eae --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/CommonLogger.h @@ -0,0 +1,84 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: CommonLogger.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef COMMONLOGGER_H_ +#define COMMONLOGGER_H_ + +#include +#include "demo.h" + +#include "SdLogger.h" +#include "LogConsole.h" + +#define COMMON_LOGGER( ... ) (void)common::Logger::GetLoggerInstance()->Print(__VA_ARGS__) +#define COMMON_LOGGER_RESULT(result, func) \ + (void)nn::dbg::PrintResult(result); \ + (void)common::Logger::GetLoggerInstance()->PrintResult("Func = %s\n", func); \ + (void)common::Logger::GetLoggerInstance()->PrintResult("Result = %X\n", result.GetPrintableBits()); \ + +#define COMMON_LOGGER_RESULT_WITH_LINE(result, line, func) \ + (void)nn::dbg::detail::Printf("%s\n", func); \ + (void)nn::dbg::detail::Printf("%d\n", line); \ + (void)nn::dbg::PrintResult(result); \ + (void)common::Logger::GetLoggerInstance()->PrintResult("Func = %s\n", func); \ + (void)common::Logger::GetLoggerInstance()->PrintResult("line = %d\n", line); \ + (void)common::Logger::GetLoggerInstance()->PrintResult("Result = %X\n", result.GetPrintableBits()); \ + +#define COMMON_LOGGER_RESULT_IF_FAILED(result) \ + if(result.IsFailure()) \ + { \ + COMMON_LOGGER_RESULT(result, __func__); \ + } \ + +#define COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result) \ + if(result.IsFailure()) \ + { \ + COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \ + } \ + +namespace common +{ + +namespace Logger +{ + +class CommonLogger +{ +public: + CommonLogger(); + ~CommonLogger(); + + void Initialize(u32 width, u32 height, u32 maxLine, demo::RenderSystemDrawing* renderSystem); + void Finalize(); + + void Print(const char* fmt, ...); + void PrintResult(const char* fmt, ...); + void ClearLog(); + void ScrollUp(); + void ScrollDown(); + void ScrollToBegin(); + void ScrollToEnd(); + void DrawConsole(); +private: + nn::os::CriticalSection m_CriticalSection; +}; + +CommonLogger* GetLoggerInstance(); + +} + +} + +#endif /* COMMONLOGGER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/DrawSystemState.cpp b/tags/0thNUP/ConsoleDataMigration/common/DrawSystemState.cpp new file mode 100644 index 0000000..b0206a0 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/DrawSystemState.cpp @@ -0,0 +1,120 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: DrawSystemState.cpp + + Copyright 2009 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 "DrawSystemState.h" + +const u16 PROGRESS_MAX_LINES = 129; + +namespace common +{ + +u32 GetRenderTarget(u32 target, bool flip) +{ + if(flip) + { + if(target == NN_GX_DISPLAY0) + { + return NN_GX_DISPLAY1; + } + else + { + return NN_GX_DISPLAY0; + } + } + else + { + return target; + } +} + +void DrawSystemState +( + const char* toolName, + demo::RenderSystemDrawing& renderSystem, + nn::util::FloatColor titleColor, + bool flip, + std::string& adapterState, + const char* toolVersion, + common::VerDef* mVerData, + u8 batteryRemain, + u64 deviceId, + u64 friendCode, + u32 progress, + char8* macAddress, + ::std::vector& operationMessage, + nn::cfg::CTR::CfgRegionCode region, + u8* s_SerialNo +) +{ + // 繝繝輔か繝ｫ繝医〒荳顔判髱｢縺ｫ謠冗判縺吶ｋ繧ゅｮ + renderSystem.SetRenderTarget(GetRenderTarget(NN_GX_DISPLAY0, flip)); + renderSystem.SetClearColor(GetRenderTarget(NN_GX_DISPLAY0, flip), NORMAL_COLOR); + + + renderSystem.Clear(); + renderSystem.SetColor(1.f, 1.f, 1.f); + u32 line = 0; + + size_t fontSize = 8; + size_t spaceSize = fontSize + 2; + renderSystem.SetFontSize(fontSize); + + renderSystem.DrawText(0, line++ * spaceSize, "%s %s Rev.%s", toolName, __DATE__, toolVersion); + renderSystem.SetColor(titleColor.r, titleColor.g, titleColor.b); + renderSystem.FillRectangle(0, (line - 1) * spaceSize, 400, spaceSize); + renderSystem.SetColor(1.f, 1.f, 1.f); + renderSystem.DrawText(0, line++ * spaceSize, ""); + + fontSize += 2; + spaceSize = fontSize + 2; + renderSystem.SetFontSize(fontSize); + renderSystem.DrawText(0, line++ * spaceSize, "System Ver. %d.%d.%d-%d", mVerData->cup.majorVersion, mVerData->cup.minorVersion, mVerData->cup.microVersion, + mVerData->nup.majorVersion); + renderSystem.DrawText(0, line++ * spaceSize, "System Region %s", nn::cfg::CTR::GetRegionCodeA3(region)); + renderSystem.DrawText(0, line++ * spaceSize, "Serial No. %s", s_SerialNo); + renderSystem.DrawText(0, line++ * spaceSize, "Device ID %llu", deviceId); + renderSystem.DrawText(0, line++ * spaceSize, "MAC Address %s", macAddress); + renderSystem.DrawText(0, line++ * spaceSize, "Friend Code %04u-%04u-%04u", static_cast (friendCode + / 100000000ULL % 10000ULL), static_cast (friendCode / 10000ULL % 10000ULL), + static_cast (friendCode % 10000ULL)); + + renderSystem.DrawText(0, line++ * spaceSize, "Battery %d%%", batteryRemain); + renderSystem.DrawText(0, line++ * spaceSize, "AC Adaper %s", adapterState.c_str()); + renderSystem.DrawText(0, line++ * spaceSize, "Progress %02d%%", progress); + renderSystem.SetColor(0.f, 0.2f, 0.f); + renderSystem.DrawLine(19 * fontSize, (line - 1) * spaceSize, 19 * fontSize + PROGRESS_MAX_LINES, (line - 1) + * spaceSize); + renderSystem.DrawLine(19 * fontSize, (line - 1) * spaceSize, 19 * fontSize, (line) * spaceSize); + renderSystem.DrawLine(19 * fontSize, (line) * spaceSize, 19 * fontSize + PROGRESS_MAX_LINES, (line) * spaceSize); + renderSystem.DrawLine(19 * fontSize + PROGRESS_MAX_LINES, (line - 1) * spaceSize, 19 * fontSize + + PROGRESS_MAX_LINES, (line) * spaceSize + 1); + renderSystem.SetColor(0.f, 0.5f, 0.f); + renderSystem.FillRectangle(19 * fontSize, (line - 1) * spaceSize, progress * PROGRESS_MAX_LINES / 100 + 1, + spaceSize); + + renderSystem.SetColor(1.f, 1.f, 1.f); + renderSystem.DrawText(0, line++ * spaceSize, ""); + + ::std::vector::iterator it; + for (it = operationMessage.begin(); it != operationMessage.end(); it++) + { + renderSystem.DrawText(0, line++ * spaceSize, "%s", it->c_str()); + } + + fontSize -= 2; + renderSystem.SetFontSize(fontSize); +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/DrawSystemState.h b/tags/0thNUP/ConsoleDataMigration/common/DrawSystemState.h new file mode 100644 index 0000000..b1240a2 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/DrawSystemState.h @@ -0,0 +1,70 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: DrawSystemState.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef DRAWSYSTEMSTATE_H_ +#define DRAWSYSTEMSTATE_H_ + +#include +#include "demo.h" +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "common_Types.h" + +// 謠冗判濶ｲ縺ｮ螳夂ｾｩ +#define WHITE_COLOR 1.f, 1.f, 1.f, 1.f +#define GRAY_COLOR 0.5, 0.5, 0.5, 1.f +#define RED_COLOR 1.f, 0.f, 0.f, 1.f +#define GREEN_COLOR 0.f, 1.f, 0.f, 1.f +#define BLUE_COLOR 0.f, 0.f, 1.f, 1.f +#define SUCCESS_COLOR 0.f, 0.6f,0.f, 1.f +#define FAIL_COLOR 0.6f, 0.f,0.f, 1.f +#define NORMAL_COLOR 0.f, 0.f, 0.f, 1.f + +namespace common +{ + +u32 GetRenderTarget(u32 target, bool flip = false); + +void DrawSystemState +( + const char* toolName, + demo::RenderSystemDrawing& renderSystem, + nn::util::FloatColor titleColor, + bool flip, + std::string& adapterState, + const char* toolVersion, + common::VerDef* mVerData, + u8 batteryRemain, + u64 deviceId, + u64 friendCode, + u32 progress, + char8* macAddress, + ::std::vector& operationMessage, + nn::cfg::CTR::CfgRegionCode region, + u8* s_SerialNo +); + +} + + +#endif /* DRAWSYSTEMSTATE_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/FileChecker.cpp b/tags/0thNUP/ConsoleDataMigration/common/FileChecker.cpp new file mode 100644 index 0000000..c7e1f97 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/FileChecker.cpp @@ -0,0 +1,134 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: FileChecker.cpp + + Copyright 2009 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 +#include "FileChecker.h" +#include "SdMountManager.h" + +namespace common +{ + +bool s_FileExistsChecked[EXISTS_MAX]; +bool s_FileExistsCheckeResult[EXISTS_MAX]; + +bool CheckFileExists(const wchar_t* path) +{ + nn::Result result; + bool exist = false; + result = common::SdMountManager::Mount(); + + if (result.IsSuccess()) + { + nn::fs::FileInputStream fis; + + result = fis.TryInitialize(path); + if(result.IsSuccess()) + { + exist = true; + } + fis.Finalize(); + } + + common::SdMountManager::Unmount(); + + + return exist; +} + +bool ExistsFile(FileExistsCheck index) +{ + if(index > EXISTS_MAX) + { + NN_LOG("Invalid File index!!\n"); + return false; + } + + if(s_FileExistsChecked[index]) + { + return s_FileExistsCheckeResult[index]; + } + + s_FileExistsChecked[index] = true; + s_FileExistsCheckeResult[index] = CheckFileExists(FILENAME_TABLE[index]); + return s_FileExistsCheckeResult[index]; +} + +bool ExistsUpdateCheckedFile() +{ + return ExistsFile(EXISTS_UPDATE_FINISHED); +} + +bool ExistsSerialNumberFile() +{ + return ExistsFile(EXISTS_SERIAL_NUMBER); +} + +bool ExistsIVSFile() +{ + return ExistsFile(EXISTS_IVS); +} + +bool ExistsConsoleInitializedFile() +{ + // 縺ｩ縺｡繧峨°縺ｮ繝輔ぃ繧､繝ｫ縺後≠繧後ｰ蛻晄悄蛹匁ｸ医∩ + return ExistsFile(EXISTS_CONSOLE_INTIALIZED) || + ExistsFile(EXISTS_TRY_RESTORE_SAME_CONSOLE); +} + +bool ExistsWriteFinishedFile() +{ + return ExistsFile(EXISTS_WRITE_FINISHED); +} + +bool ExistsAPSetting() +{ + return ExistsFile(EXISTS_AP_SETTING); +} + +bool ExistsRtcSyncFinishedFile() +{ + return ExistsFile(EXISTS_RTC_SYNC_FINISHED); +} + +bool ExistsCountryLanguageFile() +{ + return ExistsFile(EXISTS_COUNTRY_LANGUAGE); +} + +bool ExistsTryRestoreSameConsoleFile() +{ + return ExistsFile(EXISTS_TRY_RESTORE_SAME_CONSOLE); +} + +bool ExistsVersionData() +{ + return ExistsFile(EXISTS_VERSION_DATA); +} + +bool ExistsRegionData() +{ + return ExistsFile(EXISTS_REGION_DATA); +} + +void InitializeFileCheck() +{ + for(u32 i = 0; i < EXISTS_MAX; i++) + { + s_FileExistsChecked[i] = false; + } +} + + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/FileChecker.h b/tags/0thNUP/ConsoleDataMigration/common/FileChecker.h new file mode 100644 index 0000000..fc1ac42 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/FileChecker.h @@ -0,0 +1,72 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: FileChecker.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef FILECHECKER_H_ +#define FILECHECKER_H_ + +#include "FileName.h" + +namespace common +{ + +typedef enum FILE_EXISTS_CHECK +{ + EXISTS_UPDATE_FINISHED, + EXISTS_SERIAL_NUMBER, + EXISTS_IVS, + EXISTS_CONSOLE_INTIALIZED, + EXISTS_WRITE_FINISHED, + EXISTS_AP_SETTING, + EXISTS_RTC_SYNC_FINISHED, + EXISTS_COUNTRY_LANGUAGE, + EXISTS_TRY_RESTORE_SAME_CONSOLE, + EXISTS_VERSION_DATA, + EXISTS_REGION_DATA, + EXISTS_MAX +} FileExistsCheck; + +const wchar_t* const FILENAME_TABLE[EXISTS_MAX] = +{ + common::UPDATE_CHECK_PATHNAME, + common::SERIAL_PATHNAME, + common::IVS_PATHNAME, + common::INITIALIZED_CHECK_PATHNAME, + common::WRITE_FINISHED_CHECK_PATHNAME, + common::AP_SETTING_PATHNAME, + common::RTC_SYNC_CHECK_PATHNAME, + common::COUNTRY_SETTING_PATHNAME, + common::TRY_RESTORE_SAME_CONSOLE_PATHNAME, + common::VERSION_DATA_PATHNAME, + common::REGION_DATA_PATHNAME +}; + +bool CheckFileExists(const wchar_t* path); +bool ExistsUpdateCheckedFile(); +bool ExistsSerialNumberFile(); +bool ExistsIVSFile(); +bool ExistsConsoleInitializedFile(); +bool ExistsWriteFinishedFile(); +bool ExistsAPSetting(); +bool ExistsRtcSyncFinishedFile(); +bool ExistsCountryLanguageFile(); +bool ExistsTryRestoreSameConsoleFile(); +bool ExistsVersionData(); +bool ExistsRegionData(); + +void InitializeFileCheck(); + +} + +#endif /* FILECHECKER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/FileName.h b/tags/0thNUP/ConsoleDataMigration/common/FileName.h new file mode 100644 index 0000000..531efee --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/FileName.h @@ -0,0 +1,92 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: FileName.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef FILENAME_H_ +#define FILENAME_H_ + +#include + +namespace common +{ + +const char* const NAND_ARCHIVE_NAME = "nand:"; +const char* const SDMC_ARCHIVE_NAME = "sdmc:"; +const char* const NAND_TWL_PHOTO_ARCHIVE_NAME = "twlp:"; +const char* const NAND_TWL_SOUND_ARCHIVE_NAME = "twls:"; + +const wchar_t* const LOG_ROOT_DIRECTORY_PATH = L"sdmc:/CTR_Console_Repair"; +const wchar_t* const SD_SAVEDATA_ROOT_NAME = L"CTR_Console_Repair/CTRBackup/"; +const wchar_t* const SD_SAVEDATA_TWL_PHOTO_ROOT_NAME = L"CTR_Console_Repair/TWLPhotoBackup/"; +const wchar_t* const SD_SAVEDATA_TWL_SOUND_ROOT_NAME = L"CTR_Console_Repair/TWLSoundBackup/"; +const wchar_t* const NIM_SAVEDATA_DIRECTORY_NAME = L"sysdata/0001002c"; +const wchar_t* const LOG_PATHNAME = L"CTR_Console_Repair/Migration_Log.txt"; +const wchar_t* const LOG_FILENAME = L"Migration_Log.txt"; +const wchar_t* const COUNTRY_SETTING_PATHNAME = L"sdmc:/CTR_Console_Repair/CountrySetting.bin"; +const wchar_t* const AP_SETTING_FILENAME = L"CTR_Repair_Accsess_Point_Setting.txt"; +const wchar_t* const AP_SETTING_PATHNAME = L"sdmc:/CTR_Repair_Accsess_Point_Setting.txt"; +const wchar_t* const NOR_PATHNAME = L"sdmc:/CTR_Console_Repair/NtrNorSetting.bin"; +const wchar_t* const SERIAL_PATHNAME = L"sdmc:/CTR_Console_Repair/serial.bin"; +const wchar_t* const MCU_RTC_PATHNAME = L"sdmc:/CTR_Console_Repair/rtc.bin"; +const wchar_t* const IVS_NAND_PATHNAME = L"nand:/private/movable.sed"; +const wchar_t* const IVS_PATHNAME = L"sdmc:/CTR_Console_Repair/movable.sed"; +const wchar_t* const NAND_DATA_ROOT_PATHNAME_WITH_SLASH = L"nand:/data/"; +const wchar_t* const NAND_TWL_PHOTO_DATA_ROOT_PATHNAME_WITH_SLASH = L"twlp:/"; +const wchar_t* const NAND_TWL_SOUND_DATA_ROOT_PATHNAME_WITH_SLASH = L"twls:/"; +const wchar_t* const SDMC_ROOT_DIRECTORY_PATH = L"sdmc:/"; +const wchar_t* const WRITE_FINISHED_CHECK_PATHNAME = L"sdmc:/CTR_Console_Repair/WriteFinished"; +const wchar_t* const UPDATE_CHECK_PATHNAME = L"sdmc:/CTR_Console_Repair/UpdateFinished"; +const wchar_t* const INITIALIZED_CHECK_PATHNAME = L"sdmc:/CTR_Console_Repair/ConsoleInitialized"; +const wchar_t* const TRY_RESTORE_SAME_CONSOLE_PATHNAME = L"sdmc:/CTR_Console_Repair/TryRestoreSameConsole"; +const wchar_t* const RTC_SYNC_CHECK_PATHNAME = L"sdmc:/CTR_Console_Repair/RtcSyncFinished"; +const wchar_t* const PLAYHISTORY_PATHNAME = L"sdmc:/CTR_Console_Repair/playhistory.bin"; +const wchar_t* const PLAYHISTORY_COUNT_PATHNAME = L"sdmc:/CTR_Console_Repair/playhistoryCount.bin"; +const wchar_t* const TOUCH_PANEL_CALIBRATION_PATHNAME = L"sdmc:/CTR_Console_Repair/tpCalibration.bin"; +const wchar_t* const VERSION_DATA_PATHNAME = L"sdmc:/CTR_Console_Repair/version.bin"; +const wchar_t* const REGION_DATA_PATHNAME = L"sdmc:/CTR_Console_Repair/Region.bin"; + +enum TWL_PATH_INDEX +{ + TWL_PHOTO = 0, + TWL_SOUND, + TWL_PATHNAME_MAX +}; + +const char* const TWL_ARCHIVE_NAME_TABLE[TWL_PATHNAME_MAX] = +{ + common::NAND_TWL_PHOTO_ARCHIVE_NAME, + common::NAND_TWL_SOUND_ARCHIVE_NAME +}; + +const wchar_t* const SD_TWL_ROOTNAME_TABLE[TWL_PATHNAME_MAX] = +{ + common::SD_SAVEDATA_TWL_PHOTO_ROOT_NAME, + common::SD_SAVEDATA_TWL_SOUND_ROOT_NAME +}; + +const wchar_t* const NAND_TWL_ROOT_PATHNAME_WITH_SLASH_TABLE[TWL_PATHNAME_MAX] = +{ + common::NAND_TWL_PHOTO_DATA_ROOT_PATHNAME_WITH_SLASH, + common::NAND_TWL_SOUND_DATA_ROOT_PATHNAME_WITH_SLASH +}; + +const u32 TWL_FS_ARCHIVE_KIND[TWL_PATHNAME_MAX] = +{ + nn::fs::CTR::ARCHIVE_TYPE_TWL_PHOTO, + nn::fs::CTR::ARCHIVE_TYPE_TWL_SOUND +}; + +} + +#endif /* FILENAME_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/FileTransfer.cpp b/tags/0thNUP/ConsoleDataMigration/common/FileTransfer.cpp new file mode 100644 index 0000000..7fad71d --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/FileTransfer.cpp @@ -0,0 +1,249 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: FileTransfer.cpp + + Copyright 2009 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 "FileTransfer.h" +#include + +namespace common +{ + +namespace +{ + +u64 s_TotalFileSize; +u64 s_FinishedFileSize = 0; +u64 s_Progress = 0; + +} + +nn::Result CalculateFileNum(std::wstring currentDirectory, u32& fileNum, u32& fileSize) +{ + nn::fs::FileInputStream fis; + nn::fs::Directory dir; + nn::Result result; + std::vector entryList; //繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ繧ｨ繝ｳ繝医Μ荳隕ｧ繧呈ｼ邏 + std::vector::iterator entryIndex; + + result = dir.TryInitialize(currentDirectory.c_str()); + + if(result.IsSuccess()) + { + nn::fs::DirectoryEntry entry; + s32 numEntry; + for(;;) + { + result = dir.TryRead(&numEntry, &entry, 1); + if(result.IsFailure()) + { + dir.Finalize(); + return result; + } + if(numEntry == 0) + { + // 繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ繧帝哩縺倥ｋ + dir.Finalize(); + + // 繧ｫ繝ｬ繝ｳ繝医ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蟄舌ｒ髢九￥ + for(entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++) + { + if(entryIndex->attributes.isDirectory) + { + CalculateFileNum(currentDirectory + std::wstring(entryIndex->entryName) + std::wstring(L"/"), fileNum, fileSize); + } + } + + return nn::ResultSuccess(); + } + + entryList.push_back(entry); + fileNum++; + fileSize+= entry.entrySize; + } + } + else + { + NN_LOG("failed initialize directory\n"); + dir.Finalize(); + return result; + } + +} + +// 繝繧｣繝ｬ繧ｯ繝医Μ髢薙ｮ繧ｳ繝斐ｼ +// 繧｢繝ｼ繧ｫ繧､繝冶ｶ翫＠縺ｮ繧ｳ繝斐ｼ縺悟庄閭ｽ +// 繧｢繝ｼ繧ｫ繧､繝悶↓繝槭え繝ｳ繝医＠縺溽憾諷九〒蜻ｼ縺ｳ蜃ｺ縺吝ｿ隕√≠繧 +// 譖ｸ縺崎ｾｼ縺ｿ蜈医ｮ繝繧｣繝ｬ繧ｯ繝医Μ縺ｯ縺ゅｉ縺九§繧∵ｶ亥悉縺励※縺翫￥縺薙→縲 +// 蠑墓焚縺ｯ繧ｹ繝ｩ繝繧ｷ繝･莉倥″ +bool CopyDirectory(const wchar_t * from_path, const wchar_t * to_path, void* buf, const size_t bufSize) +{ + nn::fs::Directory from_dir; + nn::fs::DirectoryEntry entry; + s32 numread = 0; + std::wostringstream target_from; + std::wostringstream target_to; + bool ret_value = true; + + nn::Result result = from_dir.TryInitialize(from_path); + + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + return false; + } + + while (1) + { + result = from_dir.TryRead(&numread, &entry, 1); + if (result.IsFailure() || numread != 1) + { + break; + } + + if (std::wcscmp(entry.entryName, L".") == 0 || std::wcscmp(entry.entryName, L"..") == 0) + { + continue; + } + + target_from.str(L""); + target_from.clear(std::stringstream::goodbit); + target_from << from_path << entry.entryName; + + target_to.str(L""); + target_to.clear(std::stringstream::goodbit); + target_to << to_path << entry.entryName; + + // 繝繧｣繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷 + if (entry.attributes.isDirectory) + { + // 繝繧｣繝ｬ繧ｯ繝医Μ菴懈 + NN_LOG("Create Directory %ls\n", target_to.str().c_str()); + result = nn::fs::TryCreateDirectory(target_to.str().c_str()); + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + } + else + { + target_from << L"/"; + target_to << L"/"; + // 蜀榊ｸｰ蜃ｦ逅 + if (!CopyDirectory(target_from.str().c_str(), target_to.str().c_str(), buf, bufSize)) + { + ret_value = false; + } + } + } + // 繝輔ぃ繧､繝ｫ縺ｮ蝣ｴ蜷 + else + { + // 繝輔ぃ繧､繝ｫ菴懈 + nn::fs::FileInputStream from_file; + nn::fs::FileOutputStream to_file; + s64 filesize; + s32 readsize; + s32 writesize; + + NN_LOG("Copy File %ls\n", target_from.str().c_str()); + + // 隱ｭ縺ｿ霎ｼ縺ｿ蟇ｾ雎｡繝輔ぃ繧､繝ｫ髢九￥ + result = from_file.TryInitialize(target_from.str().c_str()); + + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + } + else + { + // 隱ｭ縺ｿ霎ｼ縺ｿ蟇ｾ雎｡繝輔ぃ繧､繝ｫ縺ｮ繧ｵ繧､繧ｺ蜿門ｾ + result = from_file.TryGetSize(&filesize); + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + } + else + { + // 譖ｸ縺崎ｾｼ縺ｿ蟇ｾ雎｡繝輔ぃ繧､繝ｫ菴懈 + result = nn::fs::TryCreateFile(target_to.str().c_str(), filesize); + result = to_file.TryInitialize(target_to.str().c_str(), false); + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + } + else + { + while (1) + { + result = from_file.TryRead(&readsize, buf, bufSize); + + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + break; + } + else + { + if (readsize == 0) + { + result = to_file.TryFlush(); + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + } + break; + } + else + { + result = to_file.TryWrite(&writesize, buf, readsize, false); + s_FinishedFileSize += readsize; + s_Progress = s_FinishedFileSize * 100/ s_TotalFileSize; + NN_LOG("finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress); + if (result.IsFailure()) + { + nn::dbg::PrintResult(result); + ret_value = false; + } + } + } + } + } + to_file.Finalize(); + } + } + from_file.Finalize(); + } + } + + from_dir.Finalize(); + return ret_value; +} + +u32 GetProgress() +{ + return s_Progress; +} + +void InitializeTransferProgress(u64 totalSize) +{ + s_TotalFileSize = totalSize; + s_FinishedFileSize = 0; +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/FileTransfer.h b/tags/0thNUP/ConsoleDataMigration/common/FileTransfer.h new file mode 100644 index 0000000..cacddfb --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/FileTransfer.h @@ -0,0 +1,33 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: FileTransfer.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef FILETRANSFER_H_ +#define FILETRANSFER_H_ + +#include +#include +#include + +namespace common +{ + +nn::Result CalculateFileNum(std::wstring currentDirectory, u32& fileNum, u32& fileSize); +bool CopyDirectory(const wchar_t * from_path, const wchar_t * to_path, void* buf, const size_t bufSize); +u32 GetProgress(); +void InitializeTransferProgress(u64 totalSize); + +} + +#endif /* FILETRANSFER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/HardwareInfo.cpp b/tags/0thNUP/ConsoleDataMigration/common/HardwareInfo.cpp new file mode 100644 index 0000000..abf3edd --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/HardwareInfo.cpp @@ -0,0 +1,69 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: HardwareInfo.cpp + + Copyright 2009 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 +#include "HardwareInfo.h" + +#include + +namespace common +{ + +HardwareInfo::HardwareInfo() +{ + // TODO 閾ｪ蜍慕函謌舌＆繧後◆繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ繝ｻ繧ｹ繧ｿ繝 + +} + +HardwareInfo::~HardwareInfo() +{ + // TODO Auto-generated destructor stub +} + +// NULL邨らｫｯ縺輔ｌ縺溘す繝ｪ繧｢繝ｫ繝翫Φ繝舌ｼ繧貞女縺大叙繧 +// NULL邨らｫｯ縺輔ｌ縺溷ｴ謇縺ｫ繝√ぉ繝繧ｯ繝繧ｸ繝繝医ｒ莉伜刈縺励※譁ｰ縺溘↓NULL邨らｫｯ縺吶ｋ +void HardwareInfo::AddCheckDigit(char* serial) +{ + size_t len = std::strlen(serial); + + u8 digit = 0; + bool odd = true; + for(u8 i = len - 1; i > 0 && std::isdigit(serial[i]); i--) + { + if(odd) + { + digit += (serial[i] - '0') * 3; + } + else + { + digit += (serial[i] - '0'); + } + odd = !odd; + } + + if(digit % 10 != 0) + { + serial[len] = 10 - (digit % 10) + '0'; + } + else + { + serial[len] = '0'; + } + + serial[len + 1] = '\0'; +} + + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/HardwareInfo.h b/tags/0thNUP/ConsoleDataMigration/common/HardwareInfo.h new file mode 100644 index 0000000..e6406cf --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/HardwareInfo.h @@ -0,0 +1,33 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: HardwareInfo.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef HARDWAREINFO_H_ +#define HARDWAREINFO_H_ + +namespace common +{ + +class HardwareInfo +{ +public: + HardwareInfo(); + virtual ~HardwareInfo(); + + void AddCheckDigit(char* serial); +}; + +} + +#endif /* HARDWAREINFO_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/HeapManager.cpp b/tags/0thNUP/ConsoleDataMigration/common/HeapManager.cpp new file mode 100644 index 0000000..29f4367 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/HeapManager.cpp @@ -0,0 +1,39 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: HeapManager.cpp + + Copyright 2009 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 "HeapManager.h" + +namespace common +{ + +nn::fnd::ThreadSafeExpHeap HeapManager::s_AppHeap; + +HeapManager::HeapManager() +{ + // TODO 閾ｪ蜍慕函謌舌＆繧後◆繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ繝ｻ繧ｹ繧ｿ繝 + +} + +HeapManager::~HeapManager() +{ + // TODO Auto-generated destructor stub +} + +nn::fnd::ThreadSafeExpHeap* HeapManager::GetHeap() +{ + return &s_AppHeap; +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/HeapManager.h b/tags/0thNUP/ConsoleDataMigration/common/HeapManager.h new file mode 100644 index 0000000..b9fc469 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/HeapManager.h @@ -0,0 +1,40 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: HeapManager.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef HEAPMANAGER_H_ +#define HEAPMANAGER_H_ + +#include + +namespace common +{ + +class HeapManager +{ +public: + HeapManager(); + virtual ~HeapManager(); + + static nn::fnd::ThreadSafeExpHeap* GetHeap(); + +private: + // 繝繝舌う繧ｹ繝｡繝｢繝ｪ邂｡逅逕ｨ諡｡蠑ｵ繝偵ｼ繝 + static nn::fnd::ThreadSafeExpHeap s_AppHeap; + +}; + +} // namespace common + +#endif /* HEAPMANAGER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/LogConsole.cpp b/tags/0thNUP/ConsoleDataMigration/common/LogConsole.cpp new file mode 100644 index 0000000..b77d6d0 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/LogConsole.cpp @@ -0,0 +1,171 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: LogConsole.cpp + + Copyright 2009 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 "LogConsole.h" +#include + +namespace common +{ + +const size_t FONT_WIDTH = 8; +const size_t FONT_HEIGHT = 10; + +static LogConsole s_LogConsole; + +LogConsole* GetConsoleInstance() +{ + return &s_LogConsole; +} + +LogConsole::LogConsole() +{ + +} + +LogConsole::~LogConsole() +{ + +} + +void LogConsole::Initialize(u32 width, u32 height, u32 maxLine, demo::RenderSystemDrawing* renderSystem) +{ + m_Width = width; + m_Height = height; + m_MaxLine = maxLine; + m_RenderSystem = renderSystem; + m_CurrentViewLine = 0; + m_LineNum = 0; +} + +void LogConsole::AddText(const char* fmt, ::std::va_list arg) +{ + s32 stringSize; + const size_t STRING_BUFFER_SIZE = 256; + char formatStr[STRING_BUFFER_SIZE]; + + stringSize = nn::nstd::TVSNPrintf(formatStr, sizeof(formatStr), fmt, arg); + ::std::string str(formatStr); + + size_t addedText = 0; + while (addedText < stringSize) + { + if(m_LineNum >= m_MaxLine) + { + // 貅譚ｯ縺ｪ縺ｮ縺ｧ蜈磯ｭ繧貞炎髯､縺吶ｋ + ::std::vector::iterator it; + it = m_Log.begin(); + m_Log.erase(it); + m_LineNum--; + } + + // 驛ｨ蛻譁蟄怜励ｒ霑ｽ蜉 + AddWrapedText(str.substr(addedText, m_Width).c_str()); + m_LineNum++; + + // 逕ｻ髱｢鬆伜沺莉･荳願ｿｽ蜉縺励◆繧画忰蟆ｾ縺ｫ繧ｹ繧ｯ繝ｭ繝ｼ繝ｫ縺吶ｋ + if(m_LineNum > m_Height) + { + ScrollToEnd(); + } + + + if(stringSize - addedText > m_Width) + { + addedText += m_Width; + } + else + { + addedText += stringSize - addedText; + } + } +} + +void LogConsole::ScrollUp() +{ + if(m_CurrentViewLine > 0) + { + m_CurrentViewLine--; + } +} + + + +void LogConsole::ScrollDown() +{ + if (m_LineNum > m_Height) + { + if (m_CurrentViewLine < m_LineNum - m_Height) + { + m_CurrentViewLine++; + } + + } +} + +void LogConsole::ScrollToBegin() +{ + m_CurrentViewLine = 0; +} + +void LogConsole::ScrollToEnd() +{ + if(m_LineNum > m_Height) + { + m_CurrentViewLine = m_LineNum - m_Height; + } +} + + +void LogConsole::Print() +{ + ::std::vector::iterator it; + + it = m_Log.begin(); + it += m_CurrentViewLine; + + u32 count = 0; + for(; it != m_Log.end() && count < m_Height && count < m_MaxLine; it++) + { + m_RenderSystem->DrawText(0, count++ * 10, "%s", it->c_str()); + } + + if(m_LineNum > m_Height) + { + DrawScrollBar(); + } +} + + +void LogConsole::AddWrapedText(const char* str) +{ + m_Log.push_back(::std::string(str)); +} + +void LogConsole::DrawScrollBar() +{ + m_RenderSystem->SetColor(0.4f, 0.4f, 0.4f); + m_RenderSystem->DrawLine((m_Width + 1) * FONT_WIDTH, 0, (m_Width + 2) * FONT_WIDTH - 1, 0); + m_RenderSystem->DrawLine((m_Width + 1)* FONT_WIDTH, 0, (m_Width + 1)* FONT_WIDTH, m_Height * FONT_HEIGHT); + m_RenderSystem->DrawLine((m_Width + 2) * FONT_WIDTH - 1, 0, (m_Width + 2) * FONT_WIDTH - 1, m_Height * FONT_HEIGHT); + m_RenderSystem->DrawLine((m_Width + 1)* FONT_WIDTH, m_Height * FONT_HEIGHT - 1, (m_Width + 2) * FONT_WIDTH - 1, m_Height * FONT_HEIGHT - 1); + + u32 y = (m_Height * FONT_HEIGHT - 2) * m_CurrentViewLine / m_MaxLine; + m_RenderSystem->SetColor(0.7f, 0.7f, 0.7f); + m_RenderSystem->FillRectangle((m_Width + 1) * FONT_WIDTH, y + 1, FONT_WIDTH - 1, FONT_HEIGHT - 4); + + m_RenderSystem->SetColor(1.f, 1.f, 1.f); +} + +} //namespace ConsoleBackup diff --git a/tags/0thNUP/ConsoleDataMigration/common/LogConsole.h b/tags/0thNUP/ConsoleDataMigration/common/LogConsole.h new file mode 100644 index 0000000..b8a7d52 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/LogConsole.h @@ -0,0 +1,68 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: LogConsole.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef LOGCONSOLE_H_ +#define LOGCONSOLE_H_ + +#include +#include +#include +#include "demo.h" + +namespace common +{ + +//! @brief 逕ｻ髱｢縺ｫ繝繧ｭ繧ｹ繝医さ繝ｳ繧ｽ繝ｼ繝ｫ繧呈緒逕ｻ縺励∪縺 +class LogConsole +{ + +public: + LogConsole(); + ~LogConsole(); + + void Initialize(u32 width, u32 height, u32 maxLine, demo::RenderSystemDrawing* renderSystem); + + void AddText(const char* fmt, ::std::va_list arg); + void ScrollUp(); + void ScrollDown(); + void ScrollToBegin(); + void ScrollToEnd(); + void Print(); + +private: + void AddWrapedText(const char* str); + void DrawScrollBar(); + + ::std::vector m_Log; + + //! @brief 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ蛻玲焚 + u32 m_Width; + //! @brief 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ陦梧焚 + u32 m_Height; + //! @brief 繧ｳ繝ｳ繧ｽ繝ｼ繝ｫ縺ｮ繝ｭ繧ｰ縺ｮ譛螟ｧ陦梧焚 + u32 m_MaxLine; + //! @brief 謠冗判縺ｮ縺溘ａ縺ｮRenderSystemDrawing縺ｸ縺ｮ繝昴う繝ｳ繧ｿ + demo::RenderSystemDrawing* m_RenderSystem; + //! @brief 霑ｽ蜉縺励◆繝ｭ繧ｰ縺ｮ陦梧焚 + u32 m_LineNum; + //! @brief 陦ｨ遉ｺ繧帝幕蟋九☆繧九Ο繧ｰ縺ｮ陦梧焚 + u32 m_CurrentViewLine; + + +}; + +} + +#endif /* LOGCONSOLE_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/LogConsole_Private.h b/tags/0thNUP/ConsoleDataMigration/common/LogConsole_Private.h new file mode 100644 index 0000000..8fbdd42 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/LogConsole_Private.h @@ -0,0 +1,28 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: LogConsole_Private.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef LOGCONSOLE_PRIVATE_H_ +#define LOGCONSOLE_PRIVATE_H_ + +#include "LogConsole.h" + +namespace common +{ + +LogConsole* GetConsoleInstance(); + +} + +#endif /* LOGCONSOLE_PRIVATE_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/OMakefile b/tags/0thNUP/ConsoleDataMigration/common/OMakefile new file mode 100644 index 0000000..e874cbc --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/OMakefile @@ -0,0 +1,18 @@ +#!/usr/bin/env omake +#---------------------------------------------------------------------------- +# Project: Horizon +# File: OMakefile +# +# Copyright (C)2009 Nintendo Co., Ltd. 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 $(ROOT_OMAKE)/modulerules + +DefineDefaultRules() diff --git a/tags/0thNUP/ConsoleDataMigration/common/PlayHistoryManager.cpp b/tags/0thNUP/ConsoleDataMigration/common/PlayHistoryManager.cpp new file mode 100644 index 0000000..32c8f7e --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/PlayHistoryManager.cpp @@ -0,0 +1,218 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: PlayHistoryManager.cpp + + Copyright 2009 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 +#include + +#include "PlayHistoryManager.h" +#include "HeapManager.h" +#include "SdMountManager.h" +#include "SdReaderWriter.h" +#include "CommonLogger.h" +#include "FileName.h" +#include "ProgramId.h" + +namespace common +{ + +PlayHistoryManager::PlayHistoryManager() +{ + // TODO 閾ｪ蜍慕函謌舌＆繧後◆繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ繝ｻ繧ｹ繧ｿ繝 + +} + +PlayHistoryManager::~PlayHistoryManager() +{ + // TODO Auto-generated destructor stub +} + +void PlayHistoryManager::Export() +{ + nn::Result result; + SdMountManager::Mount(); + SdReaderWriter sd; + + size_t historyNum = nn::pl::CTR::GetPlayHistoryLength(); + if ( historyNum == 0) + { + NN_LOG("No Play Event\n"); + return; + } + + // SD縺ｫ譖ｸ縺崎ｾｼ繧 + result = sd.WriteBuf(common::PLAYHISTORY_COUNT_PATHNAME, reinterpret_cast(&historyNum), + sizeof(historyNum)); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + nn::pl::CTR::PlayEvent* pEvent; + pEvent = reinterpret_cast (HeapManager::GetHeap()->Allocate( + sizeof(nn::pl::CTR::PlayEvent) * historyNum)); + if ( pEvent == NULL ) + { + NN_LOG("Failed to Allocate Heap\n"); + return; + } + + // 荳逡ｪ蜿､縺繝繝ｼ繧ｿ縺九ｉ邏逶ｴ縺ｫ蜈ｨ驛ｨ隱ｭ縺ｿ霎ｼ繧 + nn::pl::CTR::GetPlayHistory(pEvent, 0, historyNum); + + // SD縺ｫ譖ｸ縺崎ｾｼ繧 + result = sd.WriteBuf(common::PLAYHISTORY_PATHNAME, reinterpret_cast(pEvent), + sizeof(nn::pl::CTR::PlayEvent) * historyNum); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + HeapManager::GetHeap()->Free(pEvent); + + SdMountManager::Unmount(); +} + +void PlayHistoryManager::GetPlayHistoryNums(size_t* nums) +{ + nn::Result result; + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::PLAYHISTORY_COUNT_PATHNAME, buf, bufSize, &readSize); + if (result.IsSuccess()) + { + *nums = *reinterpret_cast (buf); + } + } + HeapManager::GetHeap()->Free(buf); +} + +void PlayHistoryManager::Import() +{ + nn::Result result; + SdMountManager::Mount(); + SdReaderWriter sd; + + SdMountManager::Mount(); + + // 繝励Ξ繧､螻･豁ｴ縺ｮ莉ｶ謨ｰ繧貞叙蠕励☆繧 + size_t historyNum = 0; + + GetPlayHistoryNums(&historyNum); + + if(historyNum == 0) + { + NN_LOG("No PlayHistory found\n"); + return; + } + + size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); + void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); + if (buf != NULL) + { + common::SdReaderWriter sdReader; + + size_t readSize; + result = sdReader.ReadBuf(common::PLAYHISTORY_PATHNAME, buf, bufSize, &readSize); + if(result.IsSuccess()) + { + nn::pl::CTR::PlayEvent* pEvent = reinterpret_cast(buf); + NN_LOG("history num = %d\n", historyNum); + + // 繝励Ξ繧､螻･豁ｴ繧堤┌蜉ｹ蛹悶☆繧 + nn::pl::CTR::ClearPlayHistory(); + + // 繝繝ｼ繧ｿ遘ｻ陦後ヤ繝ｼ繝ｫ繧堤┌隕悶＠縺ｦ譖ｸ縺崎ｾｼ繧 + for(u32 i = 0; i < historyNum; i++) + { + COMMON_LOGGER("Importing PlayHistory %d/%d", i, historyNum); + if ((pEvent[i].GetProgramId() & WITHOUT_VALIATION_MASK) != CONSOLE_BACKUP_PROGRAM_ID + && (pEvent[i].GetProgramId() & WITHOUT_VALIATION_MASK) != CONSOLE_RESTORE_PROGRAM_ID) + { + NN_LOG("%05d 0x%16llx : %X : %d\n", i, pEvent[i].GetProgramId(), pEvent[i].GetEventType(), + pEvent[i].minutes); + + nn::pl::CTR::NotifyPlayEvent(pEvent[i].GetEventType(), pEvent[i].GetProgramId(), + pEvent[i].GetEventTime()); + } + else + { + NN_LOG("Skipped\n"); + } + } + + } + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + common::HeapManager::GetHeap()->Free(buf); + } + else + { + NN_LOG("Failed Allocate Heap!! %s, %d", __FILE__, __LINE__); + return; + } + + SdMountManager::Unmount(); +} + +void PlayHistoryManager::Dump() +{ + nn::Result result; + + s32 playEventLength = nn::pl::CTR::GetPlayHistoryLength(); + if ( playEventLength == 0 ) + { + NN_LOG("No Play Event\n"); + return; + } + + nn::pl::CTR::PlayEvent* playEvent = reinterpret_cast (HeapManager::GetHeap()->Allocate( + sizeof(nn::pl::CTR::PlayEvent) * playEventLength)); + if ( playEvent == NULL ) + { + NN_LOG("Failed to Allocate Heap\n"); + return; + } + + // 荳逡ｪ蜿､縺繝繝ｼ繧ｿ縺九ｉ邏逶ｴ縺ｫ蜈ｨ驛ｨ隱ｭ縺ｿ霎ｼ繧 + (void)nn::pl::CTR::GetPlayHistory(playEvent, 0, playEventLength); + + // 蜿門ｾ励＠縺溘ョ繝ｼ繧ｿ繧帝逡ｪ縺ｫ縺吶∋縺ｦ陦ｨ遉ｺ縺励※縺縺 + s32 restPlayEventLength = playEventLength; + s32 displayCount = 0; + + nn::pl::CTR::PlayEvent* pEvent; + while ( restPlayEventLength > 0 ) + { + // 荳豌励↓陦ｨ遉ｺ縺ｧ縺阪ｋ縺ｨ縺薙ｍ縺ｾ縺ｧ陦ｨ遉ｺ縺吶ｋ + int line; + for ( line = 0; line < 24; line++ ) + { + pEvent = &playEvent[displayCount]; + NN_LOG("0x%16llx : %X : %d\n", pEvent->GetProgramId(), pEvent->eventType, pEvent->minutes); + restPlayEventLength--; + displayCount++; + if(restPlayEventLength <= 0) + { + break; + } + } + } + NN_UNUSED_VAR(pEvent); + + HeapManager::GetHeap()->Free(playEvent); + return; +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/PlayHistoryManager.h b/tags/0thNUP/ConsoleDataMigration/common/PlayHistoryManager.h new file mode 100644 index 0000000..916741b --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/PlayHistoryManager.h @@ -0,0 +1,45 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: PlayHistoryManager.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef PLAYHISTORYMANAGER_H_ +#define PLAYHISTORYMANAGER_H_ + +namespace common +{ + +//! @brief 繝繝ｼ繧ｿ遘ｻ陦後ヤ繝ｼ繝ｫ縺ｮ螻･豁ｴ繧呈ｶ医＠縺ｪ縺後ｉ繝励Ξ繧､螻･豁ｴ繧堤ｧｻ陦後☆繧九◆繧√ｮ繧ｯ繝ｩ繧ｹ縺ｧ縺吶 +class PlayHistoryManager +{ +public: + PlayHistoryManager(); + virtual ~PlayHistoryManager(); + + //! @brief SD繧ｫ繝ｼ繝峨↓蜃ｺ蜉帙＠縺ｾ縺吶 + void Export(); + + //! @brief SD繧ｫ繝ｼ繝峨°繧峨励Ξ繧､螻･豁ｴ縺ｫ譖ｸ縺崎ｾｼ縺ｿ縺ｾ縺 + void Import(); + + //! @brief 繝繝舌ャ繧ｰ逕ｨ縲ゅ励Ξ繧､螻･豁ｴ繧偵ョ繝舌ャ繧ｰ蜃ｺ蜉帙＠縺ｾ縺吶 + void Dump(); + +private: + void GetPlayHistoryNums(size_t* nums); + +}; + +} + +#endif /* PLAYHISTORYMANAGER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/ProgramId.h b/tags/0thNUP/ConsoleDataMigration/common/ProgramId.h new file mode 100644 index 0000000..c565f11 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/ProgramId.h @@ -0,0 +1,28 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: ProgramId.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef PROGRAMID_H_ +#define PROGRAMID_H_ + +namespace common +{ + +const u64 CONSOLE_BACKUP_PROGRAM_ID = 0x000400000f802200L; +const u64 CONSOLE_RESTORE_PROGRAM_ID = 0x000400000f802300L; +const u64 WITHOUT_VALIATION_MASK = 0xffffffffffffff00L; + +} + +#endif /* PROGRAMID_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/SdLogger.cpp b/tags/0thNUP/ConsoleDataMigration/common/SdLogger.cpp new file mode 100644 index 0000000..5fb7068 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SdLogger.cpp @@ -0,0 +1,267 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SdLogger.cpp + + Copyright 2009 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 "SdLogger.h" +#include +#include "SDMountManager.h" +#include "FileName.h" + +namespace common +{ + +namespace Logger +{ + +static SdLogger s_SdLogger; +static nn::os::LightEvent s_SdEjectedEvent; +static nn::os::LightEvent s_SdInsertedEvent; + +const size_t SDMC_EVENT_THREAD_STACK_SIZE = 1024; +nn::os::Thread s_SdmcEjectedEventThread; +nn::os::StackBuffer s_SdmcEjectedEventThreadStack; + +nn::os::Thread s_SdmcInsertedEventThread; +nn::os::StackBuffer s_SdmcInsertedEventThreadStack; + +void (*s_SdEjectedEventFunc)() = NULL; +void (*s_SdInsertedEventFunc)() = NULL; + +void PrintResultIfFailed(nn::Result result, u32 line = 0) +{ + if (result.IsFailure()) + { + if(line != 0) + { + NN_LOG("%s, %d\n", __FILE__, line); + } + nn::dbg::PrintResult(result); + } +} + +void SdmcEjectedEventThreadFunc() +{ + NN_LOG("********************:SD Ejected Event Thread Start**********************\n"); + + for(;;) + { + s_SdEjectedEvent.Wait(); + NN_LOG("********************:SD Card Ejected**********************\n"); + + if(s_SdEjectedEventFunc != NULL) + { + s_SdEjectedEventFunc(); + } + SdMountManager::ForceUnmount(); + s_SdEjectedEvent.ClearSignal(); + s_SdLogger.Inactivate(); + } +} + +void SdmcInsertedEventThreadFunc() +{ + NN_LOG("********************:SD Inserted Event Thread Start**********************\n"); + + for(;;) + { + s_SdInsertedEvent.Wait(); + NN_LOG("********************:SD Card Inserted*********************\n"); + + if(s_SdInsertedEventFunc != NULL) + { + s_SdInsertedEventFunc(); + } + s_SdInsertedEvent.ClearSignal(); + } +} + +void InitializeEjectThread() +{ + s_SdEjectedEvent.Initialize(true); + s_SdInsertedEvent.Initialize(true); + nn::fs::RegisterSdmcEjectedEvent(&s_SdEjectedEvent); + nn::fs::RegisterSdmcInsertedEvent(&s_SdInsertedEvent); + + // SD繧ｫ繝ｼ繝画栢縺代ｒ讀懃衍縺吶ｋ縺溘ａ縺ｮ繧ｹ繝ｬ繝繝我ｽ懈 + s_SdmcEjectedEventThread.Start(SdmcEjectedEventThreadFunc, s_SdmcEjectedEventThreadStack); + + // SD繧ｫ繝ｼ繝画諺蜈･繧呈､懃衍縺吶ｋ縺溘ａ縺ｮ繧ｹ繝ｬ繝繝我ｽ懈 + s_SdmcInsertedEventThread.Start(SdmcInsertedEventThreadFunc, s_SdmcInsertedEventThreadStack); + +} +void SetEjectHandler(void (*func)()) +{ + s_SdEjectedEventFunc = func; +} + +void SetInsertHandler(void (*func)()) +{ + s_SdInsertedEventFunc = func; +} + +SdLogger::SdLogger() : m_TryActivate(false), m_Permitted(false) +{ + +} + +SdLogger* GetSdInstance() +{ + return &s_SdLogger; +} + +void SdLogger::Print(const char* fmt, ::std::va_list arg) +{ + Activate(); + if(!m_Permitted) + { + NN_LOG("SD Write Not Permitted\n"); + return; + } + + nn::Result result; + result = SdMountManager::Mount(); + if (result.IsFailure()) + { + PrintResultIfFailed(result, __LINE__); + } + + s32 stringSize; + const size_t STRING_BUFFER_SIZE = 256; + char str[STRING_BUFFER_SIZE]; + + stringSize = nn::nstd::TVSNPrintf(str, sizeof(str), fmt, arg); + + ::std::wstring log(common::SDMC_ROOT_DIRECTORY_PATH); + log += common::LOG_PATHNAME; + + // 繝繧｣繝ｬ繧ｯ繝医Μ縺檎┌縺代ｌ縺ｰ菴懊ｋ + nn::fs::Directory dir; + result = dir.TryInitialize(common::LOG_ROOT_DIRECTORY_PATH); + if(result.IsFailure()) + { + result = nn::fs::TryCreateDirectory(common::LOG_ROOT_DIRECTORY_PATH); + } + + result = sd.TryInitialize(log.c_str(), true); + if (result.IsSuccess()) + { + // 霑ｽ險倥☆繧 + // 繧ｵ繧､繧ｺ蜿門ｾ + s64 fileSize; + result = sd.TryGetSize(&fileSize); + if (result.IsSuccess()) + { + // 譛ｫ蟆ｾ縺ｫ遘ｻ蜍 + result = sd.TrySetPosition(fileSize); + if (result.IsSuccess()) + { + s32 writeSize; + result = sd.TryWrite(&writeSize, str, stringSize, true); + if (result.IsSuccess()) + { + result = sd.TryFlush(); + if (result.IsFailure()) + { + NN_LOG("SD TryFlush failed\n"); + PrintResultIfFailed(result, __LINE__); + } + } + else + { + NN_LOG("SD TryWrite failed\n"); + PrintResultIfFailed(result, __LINE__); + } + } + else + { + NN_LOG("SD TrySetPosition failed\n"); + PrintResultIfFailed(result, __LINE__); + } + } + else + { + NN_LOG("SD TryGetSize failed\n"); + PrintResultIfFailed(result, __LINE__); + } + } + else + { + NN_LOG("SD TryInitialize failed, %s, %d\n", __FILE__, __LINE__); + PrintResultIfFailed(result, __LINE__); + } + + dir.Finalize(); + sd.Finalize(); + SdMountManager::Unmount(); +} + +void SdLogger::Clear() +{ + Activate(); + if(!m_Permitted) + { + return; + } + + nn::Result result; + SdMountManager::Mount(); + + ::std::wstring log(common::SDMC_ROOT_DIRECTORY_PATH); + log += common::LOG_PATHNAME; + + result = nn::fs::TryDeleteFile(log.c_str()); + if(result.IsFailure()) + { + nn::dbg::PrintResult(result); + } + + SdMountManager::Unmount(); +} + +void SdLogger::Inactivate() +{ + m_TryActivate = false; + m_Permitted = false; +} + +void SdLogger::Activate() +{ + if(m_TryActivate) + { + return; + } + + nn::Result result; + result = common::SdMountManager::Mount(); + + if (result.IsSuccess()) + { + nn::fs::FileInputStream fis; + + result = fis.TryInitialize(common::AP_SETTING_PATHNAME); + if(result.IsSuccess()) + { + m_Permitted = true; + } + fis.Finalize(); + } + + common::SdMountManager::Unmount(); + m_TryActivate = true; +} + +} // namespace Logger +} // namespace ConsoleBackup + + diff --git a/tags/0thNUP/ConsoleDataMigration/common/SdLogger.h b/tags/0thNUP/ConsoleDataMigration/common/SdLogger.h new file mode 100644 index 0000000..2dc736f --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SdLogger.h @@ -0,0 +1,57 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SdLogger.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef SDLOGGER_H_ +#define SDLOGGER_H_ + +#include + +namespace common +{ + +namespace Logger +{ + +class SdLogger +{ +public: + SdLogger(); + ~SdLogger() {}; + + void Print(const char* fmt, ::std::va_list arg); + void Clear(); + void Inactivate(); + +private: + void Activate(); + + nn::fs::FileOutputStream sd; + bool m_TryActivate; + bool m_Permitted; + NN_PADDING2; + +}; + +void InitializeEjectThread(); +// SD繧ｫ繝ｼ繝峨′謚懊¢縺滓凾縺ｫ蜻ｼ縺ｰ繧後ｋ繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ +void SetEjectHandler(void (*func)()); +// SD繧ｫ繝ｼ繝峨′謖ｿ蜈･縺輔ｌ縺滓凾縺ｫ蜻ｼ縺ｰ繧後ｋ繧ｳ繝ｼ繝ｫ繝舌ャ繧ｯ +void SetInsertHandler(void (*func)()); +SdLogger* GetSdInstance(); + +} // namespace Logger +} // namespace ConsoleBackup + +#endif /* SDLOGGER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/SdMountManager.cpp b/tags/0thNUP/ConsoleDataMigration/common/SdMountManager.cpp new file mode 100644 index 0000000..336bebb --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SdMountManager.cpp @@ -0,0 +1,67 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SdMountManager.cpp + + Copyright 2009 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 +#include "SdMountManager.h" +#include "FileName.h" + +namespace common +{ + +u32 SdMountManager::m_MountCounter = 0; + +SdMountManager::SdMountManager() +{ + // TODO 閾ｪ蜍慕函謌舌＆繧後◆繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ繝ｻ繧ｹ繧ｿ繝 + +} + +SdMountManager::~SdMountManager() +{ + // TODO Auto-generated destructor stub +} + +nn::Result SdMountManager::Mount() +{ + nn::Result result = nn::ResultSuccess(); + + if(m_MountCounter == 0) + { + result = nn::fs::MountSdmc(); + } + m_MountCounter++; + + return result; +} + +nn::Result SdMountManager::Unmount() +{ + nn::Result result = nn::ResultSuccess(); + if(m_MountCounter != 0 && --m_MountCounter == 0) + { + result = nn::fs::Unmount(common::SDMC_ARCHIVE_NAME); + } + + return result; +} + +nn::Result SdMountManager::ForceUnmount() +{ + m_MountCounter = 0; + return nn::fs::Unmount(common::SDMC_ARCHIVE_NAME); +} + + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/SdMountManager.h b/tags/0thNUP/ConsoleDataMigration/common/SdMountManager.h new file mode 100644 index 0000000..c4db65b --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SdMountManager.h @@ -0,0 +1,42 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SdMountManager.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef SDMOUNTMANAGER_H_ +#define SDMOUNTMANAGER_H_ + +namespace common +{ + +//! @brief SD繧ｫ繝ｼ繝峨ｮMount迥ｶ諷九ｒ邂｡逅縺吶ｋ縺溘ａ縺ｮ繧ｯ繝ｩ繧ｹ縺ｧ縺 +class SdMountManager +{ +public: + SdMountManager(); + virtual ~SdMountManager(); + + //! @brief 繝槭え繝ｳ繝医′蠢隕√↑繧峨槭え繝ｳ繝医＠縺ｾ縺吶 + static nn::Result Mount(); + //! @brief 繧｢繝ｳ繝槭え繝ｳ繝医′蠢隕√↑繧峨い繝ｳ繝槭え繝ｳ繝医＠縺ｾ縺吶 + static nn::Result Unmount(); + //! @brief 蠑ｷ蛻ｶ逧縺ｫ繧｢繝ｳ繝槭え繝ｳ繝医＠縺ｾ縺吶 + static nn::Result ForceUnmount(); + +private: + static u32 m_MountCounter; +}; + +} + +#endif /* SDMOUNTMANAGER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/SdReaderWriter.cpp b/tags/0thNUP/ConsoleDataMigration/common/SdReaderWriter.cpp new file mode 100644 index 0000000..8164695 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SdReaderWriter.cpp @@ -0,0 +1,153 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SdReaderWriter.cpp + + Copyright 2009 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 "SdReaderWriter.h" +#include "SdMountManager.h" +#include "CommonLogger.h" + +namespace common +{ + +nn::Result SdReaderWriter::Initialize() +{ + nn::Result result; + + // 蛻晄悄蛹匁ｸ医∩縺ｪ繧我ｽ輔ｂ縺励↑縺 + if(m_IsInitialized) + { + return nn::ResultSuccess(); + } + + result = SdMountManager::Mount(); + if(result.IsSuccess()) + { + m_IsInitialized = true; + return nn::ResultSuccess(); + } + else + { + return result; + } +} + + +nn::Result SdReaderWriter::Finalize() +{ + nn::Result result; + result = SdMountManager::Unmount(); + + m_IsInitialized = false; + return result; +} + +nn::Result SdReaderWriter::WriteBuf(const wchar_t* path, void* buf, size_t size) +{ + NN_ASSERT(path != NULL); + NN_ASSERT(size > 0); + + nn::Result result; + result = Initialize(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + result = file.TryInitialize(path, nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE); + if (result.IsSuccess()) + { + s32 writeSize; + result = file.TryWrite(&writeSize, buf, size, true); + if (result.IsSuccess()) + { + result = file.TryFlush(); + if (result.IsFailure()) + { + NN_LOG("SD TryFlush failed\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + } + else + { + NN_LOG("SD TryWrite failed\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + } + else + { + NN_LOG("SD TryInitialize failed\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + + file.Finalize(); + + result = Finalize(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + return result; +} + +nn::Result SdReaderWriter::ReadBuf(const wchar_t* path, void* buf, size_t size, size_t* totalSize) +{ + NN_ASSERT(path != NULL); + NN_ASSERT(size > 0); + + nn::Result result; + if(!m_IsInitialized) + { + Initialize(); + } + + result = file.TryInitialize(path, nn::fs::OPEN_MODE_READ); + if (result.IsSuccess()) + { + s32 readSize; + result = file.TryRead(&readSize, buf, size); + if (result.IsSuccess()) + { + // TODO 繝舌ャ繝輔ぃ繧定ｶ縺医ｋ繧ｵ繧､繧ｺ縺ｮ繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ + *totalSize = readSize; + } + else + { + NN_LOG("SD TryRead failed\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + } + else + { + NN_LOG("SD TryInitialize failed\n"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + } + + file.Finalize(); + return result; +} + +void SdReaderWriter::CreateDirectory(const wchar_t* path) +{ + nn::Result result; + + if(!m_IsInitialized) + { + Initialize(); + } + + NN_LOG("Create Directory %ls\n", path); + result = nn::fs::TryCreateDirectory(path); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + result = Finalize(); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/SdReaderWriter.h b/tags/0thNUP/ConsoleDataMigration/common/SdReaderWriter.h new file mode 100644 index 0000000..dbb2772 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SdReaderWriter.h @@ -0,0 +1,64 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SdReaderWriter.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef SDWRITER_H_ +#define SDWRITER_H_ + +#include + +namespace common +{ + +//! @brief SD繧ｫ繝ｼ繝峨↓譖ｸ縺崎ｾｼ繧縺溘ａ縺ｮ繧ｯ繝ｩ繧ｹ縺ｧ縺吶 +class SdReaderWriter +{ +public : + SdReaderWriter() : m_IsInitialized(false) {}; + ~SdReaderWriter() {}; + + //! @brief 貂｡縺輔ｌ縺溘ヰ繝繝輔ぃ縺九ｉ繧ｵ繧､繧ｺ蛻謖螳壹＆繧後◆繝代せ蜷阪〒譖ｸ縺阪％縺ｿ縺ｾ縺 + //! @param[in] path sdmc:縺ｧ蟋九∪繧句ｺ蜉帙ヱ繧ｹ蜷阪ゆｺ医ａ繝繧｣繝ｬ繧ｯ繝医Μ繧剃ｽ懊▲縺ｦ縺翫￥蠢隕√′縺ゅｊ縺ｾ縺吶 + //! @param[in] buf 蜈･蜉帙ョ繝ｼ繧ｿ縺ｸ縺ｮ繝昴う繝ｳ繧ｿ + //! @param[in] size 蜈･蜉帙ョ繝ｼ繧ｿ縺ｮ繧ｵ繧､繧ｺ + nn::Result WriteBuf(const wchar_t* path, void* buf, size_t size); + + //! @brief 貂｡縺輔ｌ縺溘ヰ繝繝輔ぃ縺ｸ繧ｵ繧､繧ｺ蛻謖螳壹＆繧後◆繝代せ蜷阪°繧芽ｪｭ縺ｿ霎ｼ縺ｿ縺ｾ縺 + //! @param[in] path sdmc:縺ｧ蟋九∪繧句･蜉帙ヱ繧ｹ蜷 + //! @param[in] buf 蜃ｺ蜉帙ヰ繝繝輔ぃ縺ｸ縺ｮ繝昴う繝ｳ繧ｿ + //! @param[in] size 繝舌ャ繝輔ぃ繧ｵ繧､繧ｺ + //! @param[out] totalSize 隱ｭ縺ｿ霎ｼ繧薙□繝繝ｼ繧ｿ縺ｮ繧ｵ繧､繧ｺ + nn::Result ReadBuf(const wchar_t* path, void* buf, size_t size, size_t* totalSize); + + + //! @brief 貂｡縺輔ｌ縺溘ョ繧｣繝ｬ繧ｯ繝医Μ蜷阪ｮ繝繧｣繝ｬ繧ｯ繝医Μ繧剃ｽ懈舌＠縺ｾ縺 + void CreateDirectory(const wchar_t* path); + +private: + //! @brief 蛻晄悄蛹悶＠縺ｾ縺吶 + nn::Result Initialize(); + + //! @brief 邨ゆｺ縺励∪縺吶 + nn::Result Finalize(); + + nn::fs::FileStream file; + + NN_PADDING3; + bool m_IsInitialized; + +}; + +} + +#endif /* SDWRITER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/SimplePlayer.cpp b/tags/0thNUP/ConsoleDataMigration/common/SimplePlayer.cpp new file mode 100644 index 0000000..97e8a76 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SimplePlayer.cpp @@ -0,0 +1,240 @@ +ｻｿ/*---------------------------------------------------------------------------* + Project: Horizon + File: SimplePlayer.cpp + + Copyright (C)2009 Nintendo Co., Ltd. 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 +#include +#include +#include +#include +#include + +#include +#include "SimplePlayer.h" +#include "wave.h" +#include "HeapManager.h" + +namespace common +{ + +namespace +{ + const int nFiles = 4; // 菴ｿ逕ｨ縺ｧ縺阪ｋ voice 縺ｮ譛螟ｧ蛟､縺ｯ 24 + const char* apFileNames[nFiles] = + { + "rom:/ok.wav", + "rom:/ng.wav", + "rom:/cursor.wav", + "rom:/annotation.wav" + }; + + nn::snd::CTR::Voice* apVoice[nFiles]; + nn::snd::CTR::WaveBuffer aBuffer[nFiles]; + WaveFmt fmt[nFiles]; + WaveData data[nFiles]; + u8* apMemory[nFiles]; + + nn::os::CriticalSection s_CriticalSection; + bool s_SoundThreadInitialized = false; + + // 繧ｵ繧ｦ繝ｳ繝峨せ繝ｬ繝繝蛾未騾｣ + const int SOUND_THREAD_STACK_SIZE = 4096; + nn::os::StackBuffer s_SoundThreadStack; + nn::os::Thread threadSound; + bool threadSoundFlag; + void SoundThreadFunc() + { + // 繧ｵ繧ｦ繝ｳ繝牙ｺ蜉帙ｒ繧ｹ繝繝ｬ繧ｪ縺ｫ + nn::snd::SetSoundOutputMode(nn::snd::OUTPUT_MODE_STEREO); + + // 繝槭せ繧ｿ繝ｼ繝懊Μ繝･繝ｼ繝繧定ｨｭ螳 + nn::snd::SetMasterVolume( 1.0 ); + + NN_LOG("Loading wav files...\n"); + + // 繝輔ぃ繧､繝ｫ繧帝幕縺 + for (int i = 0; i < nFiles; i++) + { + if (apFileNames[i] == NULL) continue; + + nn::snd::Voice* pVoice = NULL; + + nn::fs::FileReader fileReader; + nn::Result result = fileReader.TryInitialize(apFileNames[i]); + NN_UTIL_PANIC_IF_FAILED(result); + if (::std::strcmp(::std::strrchr(apFileNames[i], '.'), ".wav") == false) + { + // 騾｣邯壹Γ繝｢繝ｪ鬆伜沺縺ｮ蜿門ｾ励∫｢ｺ隱 + apMemory[i] = reinterpret_cast(HeapManager::GetHeap()->Allocate(GetWaveLength(fileReader), 32)); + if (apMemory[i] == NULL) + { + NN_LOG("Failed to allocate continuous memory\n"); + continue; + } + + + // Wave 繝繝ｼ繧ｿ繧定ｪｭ縺ｿ霎ｼ縺ｿ縲√く繝｣繝繧ｷ繝･繧堤┌蜉ｹ縺ｫ + data[i].buf = apMemory[i]; + LoadWave(fileReader, &fmt[i], &data[i]); + nn::snd::FlushDataCache(reinterpret_cast(apMemory[i]), data[i].size); + + NN_LOG("%s (%1dch, %5dHz, %2d-bit wav file)\n", + apFileNames[i], fmt[i].channel, fmt[i].sample_rate, fmt[i].quantum_bits); + + pVoice = apVoice[i] = nn::snd::AllocVoice(128, NULL, NULL); + NN_TASSERT_(pVoice); + + nn::snd::SampleFormat format = (fmt[i].quantum_bits == 8) ? + nn::snd::SAMPLE_FORMAT_PCM8 : + nn::snd::SAMPLE_FORMAT_PCM16; + + pVoice->SetChannelCount( fmt[i].channel ); + pVoice->SetSampleFormat( format ); + + nn::snd::InitializeWaveBuffer(&aBuffer[i]); + aBuffer[i].bufferAddress = apMemory[i]; + aBuffer[i].sampleLength = nn::snd::GetSampleLength(data[i].size, format, fmt[i].channel); + aBuffer[i].loopFlag = false; + + fileReader.Finalize(); + + // 髻ｳ驥上ｮ險ｭ螳 + nn::snd::MixParam mix; + mix.mainBus[nn::snd::CHANNEL_INDEX_FRONT_LEFT ] = 0.707f; // 繝｡繧､繝ｳ繝懊Μ繝･繝ｼ繝 (L) + mix.mainBus[nn::snd::CHANNEL_INDEX_FRONT_RIGHT] = 0.707f; // 繝｡繧､繝ｳ繝懊Μ繝･繝ｼ繝 (R) + pVoice->SetMixParam(mix); + pVoice->SetVolume(1.0f); + + // pitch 縺ｮ險ｭ螳 + pVoice->SetSampleRate(fmt[i].sample_rate); + pVoice->SetPitch(1.0f); + + } + } + + // 蜀咲函髢句ｧ + for (int i = 0; i < nFiles; i++) + { + if (apFileNames[i] != NULL) + { + apVoice[i]->SetState( nn::snd::Voice::STATE_PLAY ); + } + } + + s_SoundThreadInitialized = true; + + threadSoundFlag = true; + while (threadSoundFlag) + { + nn::snd::WaitForDspSync(); // DSP 縺九ｉ縺ｮ繝繝ｼ繧ｿ蜿嶺ｿ｡繧貞ｾ縺､縲 + + + s_CriticalSection.Enter(); // 繝｡繧､繝ｳ繧ｹ繝ｬ繝繝峨→縺ｮ謗剃ｻ門宛蠕｡ + nn::snd::SendParameterToDsp(); // 繝代Λ繝｡繝ｼ繧ｿ繧 DSP 縺ｫ騾∽ｿ｡縲 + s_CriticalSection.Leave(); // 繝｡繧､繝ｳ繧ｹ繝ｬ繝繝峨→縺ｮ謗剃ｻ門宛蠕｡ + } + + // 蜀咲函邨ゆｺ + for (int i = 0; i < nFiles; i++) + { + if (apVoice[i]) + { + nn::snd::FreeVoice(apVoice[i]); + } + } + } +} + +void InitializeSimplePlayer() +{ + NN_LOG("Initialize SimplePlayer\n"); + + nn::Result result; + + const size_t ROMFS_BUFFER_SIZE = 1024 * 64; + static char buffer[ROMFS_BUFFER_SIZE]; + NN_UTIL_PANIC_IF_FAILED( + nn::fs::MountRom(16, 16, buffer, ROMFS_BUFFER_SIZE)); + + // dsp, snd 縺ｮ蛻晄悄蛹 + result = nn::dsp::Initialize(); + NN_UTIL_PANIC_IF_FAILED(result); + result = nn::dsp::LoadDefaultComponent(); + NN_UTIL_PANIC_IF_FAILED(result); + result = nn::snd::Initialize(); + NN_UTIL_PANIC_IF_FAILED(result); + + s_CriticalSection.Initialize(); + + // 繧ｵ繧ｦ繝ｳ繝峨せ繝ｬ繝繝峨ｒ襍ｷ蜍包ｼDSP 蜑ｲ繧願ｾｼ縺ｿ繧､繝吶Φ繝亥ｾ縺｡ｼ + threadSound.Start(SoundThreadFunc, s_SoundThreadStack); +} + +void PlaySound(u8 index) +{ + NN_ASSERT(index <= nFiles); + + while(!s_SoundThreadInitialized) + { + nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromMilliSeconds(1)); + } + + nn::snd::CTR::Voice* pVoice = apVoice[index]; + + if (!pVoice->IsPlaying()) + { + nn::snd::InitializeWaveBuffer(&aBuffer[index]); + aBuffer[index].bufferAddress = apMemory[index]; + nn::snd::SampleFormat format = (fmt[index].quantum_bits == 8) ? nn::snd::SAMPLE_FORMAT_PCM8 + : nn::snd::SAMPLE_FORMAT_PCM16; + + aBuffer[index].sampleLength = nn::snd::GetSampleLength(data[index].size, format, fmt[index].channel); + aBuffer[index].loopFlag = false; + + pVoice->AppendWaveBuffer(&aBuffer[index]); + NN_LOG("[voice%d] %s (pitch = %f)\n", + index, + (pVoice->GetState() == nn::snd::Voice::STATE_PAUSE ? "pause" : "play "), + pVoice->GetPitch()); + } +} + +void FinalizeSimplePlayer() +{ + nn::Result result; + + // 繧ｵ繧ｦ繝ｳ繝峨せ繝ｬ繝繝峨ｮ遐ｴ譽 + threadSoundFlag = false; + threadSound.Join(); + + // SND 縺ｮ邨ゆｺ蜃ｦ逅 + result = nn::snd::Finalize(); + NN_UTIL_PANIC_IF_FAILED(result); + + s_CriticalSection.Finalize(); + + // DSP 縺ｮ邨ゆｺ蜃ｦ逅 + result = nn::dsp::UnloadComponent(); + NN_UTIL_PANIC_IF_FAILED(result); + nn::dsp::Finalize(); + + + NN_LOG("Finalize SimplePlayer\n"); + +} + +} // namespace ConsoleBackup +/*---------------------------------------------------------------------------* + End of file + *---------------------------------------------------------------------------*/ diff --git a/tags/0thNUP/ConsoleDataMigration/common/SimplePlayer.h b/tags/0thNUP/ConsoleDataMigration/common/SimplePlayer.h new file mode 100644 index 0000000..b7fe76e --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/SimplePlayer.h @@ -0,0 +1,37 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: SimplePlayer.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef SIMPLEPLAYER_H_ +#define SIMPLEPLAYER_H_ + +namespace common +{ + +enum SoundEffect +{ + SOUND_OK, + SOUND_NG, + SOUND_CURSOR, + SOUND_ANNOTATION +}; + +void InitializeSimplePlayer(); +void FinalizeSimplePlayer(); +void PlaySound(u8 index); + +} // namespace ConsoleBackup + + +#endif /* SIMPLEPLAYER_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/VersionDetect.cpp b/tags/0thNUP/ConsoleDataMigration/common/VersionDetect.cpp new file mode 100644 index 0000000..f028569 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/VersionDetect.cpp @@ -0,0 +1,120 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: VersionDetect.cpp + + Copyright 2009 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 +#include +#include + +#include "VersionDetect.h" +#include "HeapManager.h" +#include "CommonLogger.h" + +namespace common +{ + +void GetCupVersion(nn::pl::CTR::CardUpdateVersion* cup, nn::cfg::CTR::CfgRegionCode region) +{ + nn::Result result; + const size_t BUF_SIZE = 1024; + u8 buf[BUF_SIZE]; + // CUP繝舌ｼ繧ｸ繝ｧ繝ｳ + { + result = nn::fs::MountContent("cver:", nn::fs::MEDIA_TYPE_NAND, common::cCupVerId[region], 0, 1, 1, buf, + BUF_SIZE); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + nn::fs::FileInputStream fis; + + result = fis.TryInitialize(L"cver:/version.bin"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + if (result.IsSuccess()) + { + s64 fileSize = fis.GetSize(); + NN_LOG("version.bin size = %lld\n", fileSize); + s32 ret; + void* addr = NULL; + addr = common::HeapManager::GetHeap()->Allocate(fileSize); + if (addr != NULL) + { + result = fis.TryRead(&ret, addr, fileSize); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + if (result.IsSuccess()) + { + nn::pl::CTR::CardUpdateVersion* ver_buf = reinterpret_cast (addr); + + std::memcpy(cup, ver_buf, sizeof(nn::pl::CTR::CardUpdateVersion)); + } + common::HeapManager::GetHeap()->Free(addr); + } + } + fis.Finalize(); + + nn::fs::Unmount("cver:"); + } + +} + +void GetNupVersion(nn::pl::CTR::NetworkUpdateVersion* nup, nn::cfg::CTR::CfgRegionCode region) +{ + nn::Result result; + const size_t BUF_SIZE = 1024; + u8 buf[BUF_SIZE]; + + // NUP繝舌ｼ繧ｸ繝ｧ繝ｳ + { + result = nn::fs::MountContent("nver:", nn::fs::MEDIA_TYPE_NAND, common::cNupVerId[region], 0, 1, 1, buf, + BUF_SIZE); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + + nn::fs::FileInputStream fis; + + result = fis.TryInitialize(L"nver:/version.bin"); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + if (result.IsSuccess()) + { + s64 fileSize = fis.GetSize(); + NN_LOG("version.bin size = %lld\n", fileSize); + s32 ret; + void* addr = NULL; + addr = common::HeapManager::GetHeap()->Allocate(fileSize); + if (addr != NULL) + { + result = fis.TryRead(&ret, addr, fileSize); + COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); + if (result.IsSuccess()) + { + nn::pl::CTR::NetworkUpdateVersion* ver_buf = + reinterpret_cast (addr); + + std::memcpy(nup, ver_buf, sizeof(nn::pl::CTR::NetworkUpdateVersion)); + } + common::HeapManager::GetHeap()->Free(addr); + } + } + + fis.Finalize(); + nn::fs::Unmount("nver:"); + } + +} + +void GetSystemVersion(common::VerDef* mVerData, nn::cfg::CTR::CfgRegionCode region) +{ + GetCupVersion(&mVerData->cup, region); + GetNupVersion(&mVerData->nup, region); +} + +} + diff --git a/tags/0thNUP/ConsoleDataMigration/common/VersionDetect.h b/tags/0thNUP/ConsoleDataMigration/common/VersionDetect.h new file mode 100644 index 0000000..652ed09 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/VersionDetect.h @@ -0,0 +1,30 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: VersionDetect.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef VERSIONDETECT_H_ +#define VERSIONDETECT_H_ + +#include +#include "common_Types.h" + +namespace common +{ + +void GetSystemVersion(common::VerDef* mVerData, nn::cfg::CTR::CfgRegionCode region); + +} + + +#endif /* VERSIONDETECT_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/common_Types.h b/tags/0thNUP/ConsoleDataMigration/common/common_Types.h new file mode 100644 index 0000000..9c7f50d --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/common_Types.h @@ -0,0 +1,70 @@ +/*---------------------------------------------------------------------------* + Project: Horizon + File: common_Types.h + + Copyright 2009 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$ + *---------------------------------------------------------------------------*/ + +#ifndef COMMON_TYPES_H_ +#define COMMON_TYPES_H_ + +#include +#include +#include +#include +#include + +namespace common +{ + +const u32 NTR_WIFI_SETTING_SIZE = 0x400; // NTR Wifi 險ｭ螳壹ｮ繧ｵ繧､繧ｺ +const u32 TWL_WIFI_SETTING_SIZE = 0x600; // TWL Wifi 險ｭ螳壹ｮ繧ｵ繧､繧ｺ + + +// NOR鬆伜沺縺ｮ縺ｿ縺ｫ縺ゅｋ險ｭ螳壹ョ繝ｼ繧ｿ逕ｨ讒矩菴 +struct NtrNorData +{ + nn::cfg::CTR::NtrConfig ntrConfig; + u8 TwlWiFiSetting[TWL_WIFI_SETTING_SIZE]; + u8 NtrWiFiSetting[NTR_WIFI_SETTING_SIZE]; +}; + +struct CfgCountryLanguage +{ + enum nn::cfg::CTR::CfgCountryCode country; + enum nn::cfg::CTR::CfgLanguageCode language; + NN_PADDING1; +}; + +struct VerDef +{ + nn::pl::CTR::CardUpdateVersion cup; + nn::pl::CTR::NetworkUpdateVersion nup; +}; + +// TODO:繝ｪ繝ｼ繧ｸ繝ｧ繝ｳ霑ｽ蜉譎ゅ↓遽蝗ｲ螟悶い繧ｯ繧ｻ繧ｹ縺ｫ縺ｪ繧峨↑縺繧医≧豕ｨ諢 +const nn::ProgramId cCupVerId[] = +{ + nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_JP, + nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_US, + nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_EU, +}; + +const nn::ProgramId cNupVerId[] = +{ + nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_JP, + nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_US, + nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_EU, +}; + +} + +#endif /* COMMON_TYPES_H_ */ diff --git a/tags/0thNUP/ConsoleDataMigration/common/configLoader.cpp b/tags/0thNUP/ConsoleDataMigration/common/configLoader.cpp new file mode 100644 index 0000000..c32c04a --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/configLoader.cpp @@ -0,0 +1,180 @@ +#include +#include +#include +#include "configLoader.h" + +namespace common +{ + +Result ConfigFileLoader::Initialize(const wchar_t* fileName, void* buffer, const size_t bufferSize) +{ + s64 fileSize; + FileInputStream fi; + NN_UTIL_RETURN_IF_FAILED(fi.TryInitialize(fileName)); + NN_UTIL_RETURN_IF_FAILED(fi.TryGetSize(&fileSize)); + + // NULL邨らｫｯ縺ｶ繧楢ｪｭ繧√ｋ繧ｵ繧､繧ｺ繧呈ｸ帙ｉ縺 + if (fileSize > bufferSize - 2) + { + NN_TLOG_("Too Large File\n"); + return Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_OUT_OF_RESOURCE, nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_TOO_LARGE); + } + + m_Buffer = static_cast(buffer); + NN_UTIL_RETURN_IF_FAILED(fi.TryRead(&m_UsedBufferSize, m_Buffer, fileSize)); + + return ParseData(); +} + +void ConfigFileLoader::Finalize() +{ + m_Buffer = 0; + m_ParamNum = 0; +} + +Result ConfigFileLoader::ParseData() +{ + if (!m_Buffer) + { + return Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_INVALID_STATE, nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_NOT_INITIALIZED); + } + + int pos = 0; + + // 繝薙ャ繧ｰ繧ｨ繝ｳ繝繧｣繧｢繝ｳ縺ｧ縺ｪ縺縺薙→繧堤｢ｺ隱 + NN_ASSERTMSG(m_Buffer[0] != 0xfffe, "Invalid Config File's Endian\n"); + + if (m_Buffer[0] == 0xfeff) + { + // UTF-16 BOM縺ｮ隱ｿ謨ｴ + pos++; + } + + m_ParamNum = 0; + m_ParamName[m_ParamNum] = &(m_Buffer[pos]); + m_ParamValue[m_ParamNum] = L'\0'; + + // 繝繝悶Ν繧ｯ繧ｦ繧ｩ繝ｼ繝井ｸｭ縺ｪ繧 : 繧よ枚蟄励→縺励※隱ｭ縺ｿ蜿悶ｋ + bool inEscape = false; + // # 縺ｧ陦梧忰縺ｾ縺ｧ繧ｳ繝｡繝ｳ繝 + bool inComment = false; + // : 縺ｧ陦碁ｭ縺九ｉ:縺ｾ縺ｧ縺渓ey縲:縺九ｉ陦梧忰縺ｾ縺ｧ縺計alue + bool inSettingKeyValue = false; + + while (pos < m_UsedBufferSize / sizeof(m_Buffer[0])) + { + switch (m_Buffer[pos]) + { + case L'"': + { + inEscape = !inEscape; + } + break; + + case L'#': + { + inComment = true; + } + break; + + case L':': + { + if (inEscape || inComment) + { + break; + } + + if (inSettingKeyValue) + { + break; + } + else + { + inSettingKeyValue = true; + } + m_Buffer[pos] = L'\0'; + m_ParamValue[m_ParamNum++] = &(m_Buffer[pos + 1]); + + } + + break; + case L'\r': + case L'\n': + { + if (inComment) + { + inComment = false; + } + if (inSettingKeyValue) + { + inSettingKeyValue = false; + } + + m_Buffer[pos] = L'\0'; + m_ParamName[m_ParamNum] = &(m_Buffer[pos + 1]); + m_ParamValue[m_ParamNum] = L'\0'; + } + break; + + } + + if (PARAM_MAX_NUM <= m_ParamNum) + { + NN_TLOG_("Too Many Params\n"); + return Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_OUT_OF_RESOURCE, nn::Result::MODULE_COMMON, + nn::Result::DESCRIPTION_TOO_LARGE); + } + pos++; + } + + return ResultSuccess(); +} + +s32 ConfigFileLoader::SearchParamName(const wchar_t *paramName) +{ + if (!m_Buffer) + { + NN_TLOG_("ConfigFileLoader not initialized.\n"); + return -1; + } + + for (s32 i = 0; i < m_ParamNum; i++) + { + if (wcscmp(m_ParamName[i], paramName) == 0) + { + return i; + } + } + return -1; +} + +const wchar_t *ConfigFileLoader::ReadAsWChar(const wchar_t *paramName) +{ + s32 idx = SearchParamName(paramName); + if (idx < 0) + { + NN_LOG("Unknown Parameter Name %ls\n", paramName); + } + return (idx < 0) ? L'\0' : m_ParamValue[idx]; +} + +const char *ConfigFileLoader::ReadAsChar(const wchar_t *paramName) +{ + memset(m_ReadCharBuffer, 0, sizeof(m_ReadCharBuffer)); + const wchar_t *value = ReadAsWChar(paramName); + if(value == L'\0') + { + return NULL; + } + wcstombs(m_ReadCharBuffer, value, sizeof(m_ReadCharBuffer)); + // NULL邨らｫｯ縺吶ｋ + m_ReadCharBuffer[sizeof(m_ReadCharBuffer) - 1] = '\0'; + return m_ReadCharBuffer; +} + +int ConfigFileLoader::ReadAsInteger(const wchar_t *paramName) +{ + return atoi(ReadAsChar(paramName)); +} + +} diff --git a/tags/0thNUP/ConsoleDataMigration/common/configLoader.h b/tags/0thNUP/ConsoleDataMigration/common/configLoader.h new file mode 100644 index 0000000..67e1edf --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/configLoader.h @@ -0,0 +1,78 @@ +#ifndef NN_CONFIG_LOADER_H_ +#define NN_CONFIG_LOADER_H_ + + +namespace common +{ + using namespace nn; + using namespace nn::fs; + using namespace std; + +class ConfigFileLoader +{ +private: + static const int PARAM_VALUE_MAX_STRING_LENGTH = 128; + static const int PARAM_MAX_NUM = 64; + + char m_ReadCharBuffer[PARAM_VALUE_MAX_STRING_LENGTH]; + wchar_t *m_ParamName[PARAM_MAX_NUM]; + wchar_t *m_ParamValue[PARAM_MAX_NUM]; + wchar_t *m_Buffer; + + s32 m_UsedBufferSize; + s32 m_ParamNum; + +public: + ConfigFileLoader() : m_Buffer(0), m_UsedBufferSize(0), m_ParamNum(0) + { + } + +/* + @brief ConfigFileLoader 繧貞晄悄蛹悶＠縺ｾ縺呻ｼ + + 菴ｿ逕ｨ縺吶ｋ繝輔ぃ繧､繝ｫ縺悟ｭ伜惠縺吶ｋ繧｢繝ｼ繧ｫ繧､繝悶ｯｼ後≠繧峨°縺倥ａ繝槭え繝ｳ繝医＠縺ｦ縺翫￥蠢隕√′縺ゅｊ縺ｾ縺呻ｼ + 隱ｭ縺ｿ霎ｼ縺ｿ縺ｫ菴ｿ逕ｨ縺吶ｋ繝舌ャ繝輔ぃ繧堤｢ｺ菫昴＠ｼ悟ｼ墓焚 buffer 縺ｫ荳弱∴繧句ｿ隕√′縺ゅｊ縺ｾ縺呻ｼ + Finalize 繧貞他縺ｶ縺ｾ縺ｧ縺薙ｮ繝舌ャ繝輔ぃ縺ｯ髢区叛縺励↑縺縺ｧ縺上□縺輔＞ｼ + + 隱ｭ縺ｿ霎ｼ縺ｾ縺帙ｋ縺薙→縺ｮ縺ｧ縺阪ｋ繝輔か繝ｼ繝槭ャ繝 + 繝ｻ繧ｨ繝ｳ繧ｳ繝ｼ繝繧｣繝ｳ繧ｰｼ啅TF-16 + 繝ｻ繝舌う繝医が繝ｼ繝縲縲ｼ壹Μ繝医Ν繧ｨ繝ｳ繝繧｣繧｢繝ｳ + 繝ｻ謾ｹ陦瑚ｨ伜捷縲縲縲縲ｼ壻ｸ榊撫 + + 蜊願ｧ偵さ繝ｭ繝ｳ繧貞性繧陦後ｮ縺ｿ繝代Λ繝｡繝ｼ繧ｿ險倩ｿｰ陦後→縺励※隱ｭ縺ｿ霎ｼ縺ｿｼ悟性縺ｾ縺ｪ縺陦後ｯ辟｡隕悶＠縺ｾ縺呻ｼ + 蜊願ｧ偵さ繝ｭ繝ｳ繧医ｊ蜑阪ｮ譁蟄励ｯ縺吶∋縺ｦ繝代Λ繝｡繝ｼ繧ｿ蜷阪→縺励※蜿門ｾ励＠ｼ + 蜊願ｧ偵さ繝ｭ繝ｳ繧医ｊ蠕後ｮ譁蟄励ｯ縺吶∋縺ｦ繝代Λ繝｡繝ｼ繧ｿ縺ｮ蛟､縺ｨ縺励※蜿門ｾ励＠縺ｾ縺呻ｼ + ParameterName : ParameterValue; + 縺ｨ險倩ｿｰ縺吶ｋ縺ｨ + 繝代Λ繝｡繝ｼ繧ｿ蜷阪ｯ L"ParameterName " + 繝代Λ繝｡繝ｼ繧ｿ蛟､縺ｯ L" ParameterValue;" + 縺ｨ縺ｪ繧翫∪縺呻ｼ + + @param[in] fileName 險ｭ螳壹ヵ繧｡繧､繝ｫ蜷 + @param[in] buffer 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ逕ｨ縺ｮ繝舌ャ繝輔ぃ + @param[in] bufferSize 荳願ｨ buffer 縺ｮ螟ｧ縺阪＆ + + @return 邨先棡繧定ｿ斐＠縺ｾ縺呻ｼ + +*/ + Result Initialize(const wchar_t* fileName, void* buffer, const size_t bufferSize); + void Finalize(); + + // 繧ｹ繝ｬ繝繝峨そ繝ｼ繝輔〒縺呻ｼ + const wchar_t *ReadAsWChar(const wchar_t *paramName); + + // 繧ｹ繝ｬ繝繝峨そ繝ｼ繝輔〒縺ｯ縺ゅｊ縺ｾ縺帙ｓｼ + const char *ReadAsChar(const wchar_t *paramName); + + // 繧ｹ繝ｬ繝繝峨そ繝ｼ繝輔〒縺呻ｼ + int ReadAsInteger(const wchar_t *paramName); + +private: + Result ParseData(); + s32 SearchParamName(const wchar_t *paramName); +}; + +} + + +#endif // NN_CONFIG_LOADER_H_ diff --git a/tags/0thNUP/ConsoleDataMigration/common/romfiles/annotation.wav b/tags/0thNUP/ConsoleDataMigration/common/romfiles/annotation.wav new file mode 100644 index 0000000..b64f77b Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/common/romfiles/annotation.wav differ diff --git a/tags/0thNUP/ConsoleDataMigration/common/romfiles/cursor.wav b/tags/0thNUP/ConsoleDataMigration/common/romfiles/cursor.wav new file mode 100644 index 0000000..85765b3 Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/common/romfiles/cursor.wav differ diff --git a/tags/0thNUP/ConsoleDataMigration/common/romfiles/ng.wav b/tags/0thNUP/ConsoleDataMigration/common/romfiles/ng.wav new file mode 100644 index 0000000..dc2f3ef Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/common/romfiles/ng.wav differ diff --git a/tags/0thNUP/ConsoleDataMigration/common/romfiles/ok.wav b/tags/0thNUP/ConsoleDataMigration/common/romfiles/ok.wav new file mode 100644 index 0000000..bf5149f Binary files /dev/null and b/tags/0thNUP/ConsoleDataMigration/common/romfiles/ok.wav differ diff --git a/tags/0thNUP/ConsoleDataMigration/common/wave.cpp b/tags/0thNUP/ConsoleDataMigration/common/wave.cpp new file mode 100644 index 0000000..a897109 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/wave.cpp @@ -0,0 +1,150 @@ +ｻｿ/*---------------------------------------------------------------------------* + Project: Horizon + File: wave.c + + Copyright (C)2009 Nintendo Co., Ltd. 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$ + *---------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------*/ +/* includes */ +#include "wave.h" + +/*---------------------------------------------------------------------------*/ +/* functions */ + +/*---------------------------------------------------------------------------* + Name: LoadWave + + Description: Wave 繝繝ｼ繧ｿ繧定ｪｭ縺ｿ霎ｼ繧. + + Arguments: filepath : 繝輔ぃ繧､繝ｫ繝代せ + fmt : Wave 繝繝ｼ繧ｿ縺ｮ fmt 繝√Ε繝ｳ繧ｯ繧呈ｼ邏 + data : Wave 繝繝ｼ繧ｿ縺ｮ data 繝√Ε繝ｳ繧ｯ繧呈ｼ邏 + + Returns: None. + *---------------------------------------------------------------------------*/ +void LoadWaveCore(nn::fs::FileReader& reader, WaveFmt * fmt, WaveData * data, bool isSizeOnly) +{ + reader.SetPosition(0); + + WaveRiff riff; // RIFF 繝倥ャ繝 + WaveChunk chunk; // CHUNK + u32 readbyte = 0; // 繝輔ぃ繧､繝ｫ隱ｭ縺ｿ霎ｼ縺ｿ縺ｮ蛻､螳壹↓菴ｿ逕ｨ + u32 fsize = reader.GetSize(); + + // RIFF 繝倥ャ繝隱ｭ縺ｿ霎ｼ縺ｿ + reader.Read((u8*)&riff, sizeof(WaveRiff)); + + // 繧ｵ繧､繧ｺ繧堤ｩ咲ｮ + readbyte += sizeof(WaveRiff); + + // "RIFF" 縺ｨ縺ｮ荳閾ｴ繧堤｢ｺ隱 + if (riff.tag != MAKE_WAVE_TAG_VALUE('R','I','F','F')) + { + NN_PANIC("Not RIFF format.\n"); + } + // "WAVE" 縺ｨ縺ｮ荳閾ｴ繧堤｢ｺ隱 + if ( riff.type != MAKE_WAVE_TAG_VALUE('W','A','V','E') ) + { + NN_PANIC("Not Wave format.\n"); + } + + // 繝輔ぃ繧､繝ｫ繧ｵ繧､繧ｺ繧医ｊ螟ｧ縺阪￥縺ｪ繧九∪縺ｧ隱ｭ縺ｿ霎ｼ繧 + while(fsize > readbyte) + { + // CHUNK 縺ｮ隱ｭ縺ｿ霎ｼ縺ｿ + reader.Read((u8*)&chunk, sizeof(WaveChunk)); + readbyte += sizeof(WaveChunk); + + // "fmt " + if (chunk.tag == MAKE_WAVE_TAG_VALUE('f','m','t',' ')) + { + reader.Read((u8*)fmt, sizeof(WaveFmt)); + readbyte += sizeof(WaveFmt); + + // 諡｡蠑ｵ鬆伜沺縺後≠繧後ｰ隱ｭ縺ｿ謐ｨ縺ｦ + if (chunk.size > sizeof(WaveFmt)) + { + u16 ext_size; + + reader.Read((u8*)&ext_size, sizeof(ext_size)); + readbyte += sizeof(ext_size); + + readbyte += chunk.size; + if (readbyte == fsize) break; + + reader.Seek(ext_size, nn::fs::POSITION_BASE_CURRENT); + } + } + // "data" + else if (chunk.tag == MAKE_WAVE_TAG_VALUE('d','a','t','a')) + { + data->size = chunk.size; + + if (isSizeOnly) + { + return; + } + else + { + reader.Read((u8*)data->buf, data->size); + // 8-bit wav 繝輔ぃ繧､繝ｫ縺ｮ蝣ｴ蜷医ｯ unsigned -> signed 縺ｮ螟画鋤縺悟ｿ隕 + if (fmt->quantum_bits == 8) + { + s8* p = (s8*)data->buf; + for (int i = 0; i < data->size; i++) + { + p[i] -= 128; + } + } + } + readbyte += chunk.size; + } + // 縺昴ｌ莉･螟 + else + { + readbyte += chunk.size; + if (readbyte == fsize) break; + + // 隱ｭ縺ｿ鬟帙ｰ縺 + reader.Seek(chunk.size, nn::fs::POSITION_BASE_CURRENT); + } + } +} + +#ifndef NN_BUILD_RELEASE // Release 繝薙Ν繝峨〒縺ｯ HostIO 縺ｯ菴ｿ縺医∪縺帙ｓ縲 +void WriteWaveHeader(nn::hio::CTR::HostFile& hostFile, WaveFmt* fmt, s32 size) +{ + WaveRiff riff; + riff.tag = MAKE_WAVE_TAG_VALUE('R','I','F','F'); + riff.size = + + sizeof(WaveRiff) // riff header + + sizeof(WaveChunk) + sizeof(WaveFmt) // wave fmt header + + sizeof(WaveChunk) + size // wave data + - 8; + riff.type = MAKE_WAVE_TAG_VALUE('W','A','V','E'); + hostFile.Write(&riff, sizeof(WaveRiff)); + + WaveChunk chunk; + chunk.tag = MAKE_WAVE_TAG_VALUE('f','m','t',' '); + chunk.size = sizeof(WaveFmt); + hostFile.Write(&chunk, sizeof(WaveChunk)); + hostFile.Write(fmt, sizeof(WaveFmt)); + + chunk.tag = MAKE_WAVE_TAG_VALUE('d','a','t','a'); + chunk.size = size; + hostFile.Write(&chunk, sizeof(WaveChunk)); +} +#endif // NN_BUILD_RELEASE + +/*---------------------------------------------------------------------------*/ +/* end of file */ +/*---------------------------------------------------------------------------*/ diff --git a/tags/0thNUP/ConsoleDataMigration/common/wave.h b/tags/0thNUP/ConsoleDataMigration/common/wave.h new file mode 100644 index 0000000..cbaf2f3 --- /dev/null +++ b/tags/0thNUP/ConsoleDataMigration/common/wave.h @@ -0,0 +1,148 @@ +ｻｿ/*---------------------------------------------------------------------------* + Project: Horizon + File: wave.h + + Copyright (C)2009 Nintendo Co., Ltd. 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$ + *---------------------------------------------------------------------------*/ + +#ifndef __WAVE_HEADER__ +#define __WAVE_HEADER__ + +/*---------------------------------------------------------------------------*/ +/* includes */ +#include +#include +#ifndef NN_BUILD_RELEASE // Release 繝薙Ν繝峨〒縺ｯ HostIO 縺ｯ菴ｿ縺医∪縺帙ｓ縲 +#include +#endif // NN_BUILD_RELEASE + +/*---------------------------------------------------------------------------*/ +/* constants */ + +#define MAKE_WAVE_TAG_VALUE(c1, c2, c3, c4) \ + ( c1 | (c2<<8) | (c3<<16) | (c4<<24) ) + +#define MAKE_WAVE_TAG_STRING(str, val) \ + { \ + str[3] = (char) ( (val>>24)&0xff ) ; \ + str[2] = (char) ( (val>>16)&0xff ) ; \ + str[1] = (char) ( (val>> 8)&0xff ) ; \ + str[0] = (char) ( (val )&0xff ) ; \ + str[4] = (char) ( 0 ) ; \ + } + +#define MAKE_FMT_CHUNK(ch, s) \ + { \ + ch.tag = MAKE_WAVE_TAG_VALUE('f', 'm', 't', ' '); \ + ch.size = s; \ + } + +#define MAKE_DATA_CHUNK(ch, s) \ + { \ + ch.tag = MAKE_WAVE_TAG_VALUE('d', 'a', 't', 'a'); \ + ch.size = s; \ + } + +#define saturate(v, min, max) \ + { \ + if ( v < min ) {v = min;} \ + else if ( v > max ) {v = max;} \ + } + +#define swap(v,t) swap_##t##_(v) + +#define swap_u16_(v) \ + { \ + v = (u16)(((v)>> 8)&0x00ff | \ + ((v)<< 8)&0xff00); \ + } + +#define swap_s16_(v) \ + { \ + v = (s16)(((v)>> 8)&0x00ff | \ + ((v)<< 8)&0xff00); \ + } + +#define swap_u32_(v) \ + { \ + v = (u32)(((v)>>24)&0x000000ff | \ + ((v)>> 8)&0x0000ff00 | \ + ((v)<< 8)&0x00ff0000 | \ + ((v)<<24)&0xff000000); \ + } + +#define swap_s32_(v) \ + { \ + v = (s32)(((v)>>24)&0x000000ff | \ + ((v)>> 8)&0x0000ff00 | \ + ((v)<< 8)&0x00ff0000 | \ + ((v)<<24)&0xff000000); \ + } + +/*---------------------------------------------------------------------------*/ +/* typedef */ +typedef struct _riff +{ + u32 tag; + u32 size; + u32 type; +} +WaveRiff; + +typedef struct _chunk +{ + u32 tag; + u32 size; +} +WaveChunk; + +typedef struct _fmt +{ + u16 fmt_id; + u16 channel; + u32 sample_rate; + u32 trans_rate; + u16 block_size; + u16 quantum_bits; +} +WaveFmt; + +typedef struct _data +{ + u32 size; + u8* buf; +} +WaveData; + +/*---------------------------------------------------------------------------*/ +/* prototype */ + +void LoadWaveCore(nn::fs::FileReader&, WaveFmt*, WaveData*, bool); +static inline void LoadWave(nn::fs::FileReader& reader, WaveFmt* fmt, WaveData* data) +{ + LoadWaveCore(reader, fmt, data, false); +} +static inline int GetWaveLength(nn::fs::FileReader& reader) +{ + WaveFmt fmt; + WaveData data; + LoadWaveCore(reader, &fmt, &data, true); + return data.size; +} +#ifndef NN_BUILD_RELEASE // Release 繝薙Ν繝峨〒縺ｯ HostIO 縺ｯ菴ｿ縺医∪縺帙ｓ縲 +void WriteWaveHeader(nn::hio::CTR::HostFile& hostFile, WaveFmt* fmt, s32 size); +#endif // NN_BUILD_RELEASE + +#endif // __WAVE_HEADER__ + +/*---------------------------------------------------------------------------*/ +/* end of file */ +/*---------------------------------------------------------------------------*/