rvtr/TwlIPL
1
Fork 0
mirror of https://github.com/rvtr/TwlIPL.git synced 2025-10-31 06:01:12 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

TwlIPLツリーのsettingsライブラリを削除し、TwlSDK側のlcfgライブラリを使用するよう変更。

Browse Source 
git-svn-id: file:///Users/lillianskinner/Downloads/platinum/twl/TwlIPL/trunk@490 b08762b0-b915-fc4b-9d8c-17b2551a87ff
This commit is contained in:
yosiokat 2008-01-21 02:38:41 +00:00
parent 84b8924e94
commit 76d8d20940
34 changed files with 195 additions and 3812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build/buildtools/commondefs.sysmenu
View File

@ -60,8 +60,8 @@ SYSMENU_LIBDIR := $(SYSMENU_ROOT)/lib/$(TWL_LIBTYPE)
ifeq ($(CODEGEN_PROC),ARM9)
SYSMENU_LIBS ?= \
liblcfg$(TWL_LIBSUFFIX).a \
libsysmenu$(TWL_LIBSUFFIX).a \
libsettings$(TWL_LIBSUFFIX).a \
libmbloader$(TWL_LIBSUFFIX).a \
libacsign$(TWL_LIBSUFFIX).a \
libboot$(TWL_LIBSUFFIX).a \

2
build/libraries_sysmenu/Makefile
View File

@ -22,7 +22,7 @@ include $(TWL_IPL_RED_ROOT)/build/buildtools/commondefs
#----------------------------------------------------------------------------
SUBDIRS_P = reloc_info sysmenu settings mb_loader acsign boot hotsw
SUBDIRS_P = reloc_info sysmenu mb_loader acsign boot hotsw
#----------------------------------------------------------------------------

51
build/libraries_sysmenu/settings/ARM9/Makefile
View File

@ -1,51 +0,0 @@
#! make -f
#----------------------------------------------------------------------------
# Project: TwlIPL
# File: Makefile
#
# Copyright 2007 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.
#
# $Date:: 2007-10-03#$
# $Rev: 1319 $
# $Author: kitase_hirotake $
#----------------------------------------------------------------------------
SUBDIRS =
MYSUBDIRS = ./
#----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU
TARGET_PLATFORM = TWL
TWL_ARCHGEN = LIMITED
TWL_PROC = ARM9
SRCS = NTRSettings.c TWLSettings.c \
TWLHWInfo.c TWLStoreFile.c
TARGET_LIB = libsettings$(TWL_LIBSUFFIX).a
include $(TWL_IPL_RED_ROOT)/build/buildtools/commondefs
INSTALL_TARGETS = $(TARGETS)
INSTALL_DIR = $(SYSMENU_INSTALL_LIBDIR)
LINCLUDES = $(ROOT)/build/libraries/spi/ARM9/include \
#----------------------------------------------------------------------------
do-build: $(MYSUBDIRS) $(TARGETS)
include $(TWL_IPL_RED_ROOT)/build/buildtools/modulerules
$(MYSUBDIRS)::
# $(MAKE) -C $@ -f MakeCrt0
#===== End of Makefile =====

545
build/libraries_sysmenu/settings/ARM9/src/NTRSettings.c
View File

@ -1,545 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: NTRSettings.c
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#include <twl.h>
#include <sysmenu/settings/common/NTRSettings.h>
#include "spi.h"
// define data----------------------------------------------------------
#if 0
#define DEBUG_Printf OS_TPrintf
#else
#define DEBUG_Printf(...) ((void)0)
#endif
#define SAVE_COUNT_MAX 0x0080 // NTRSettingsData.saveCountの最大値
#define SAVE_COUNT_MASK 0x007f // NTRSettingsData.saveCountの値の範囲をマスクする。(0x00-0x7f）
#define NSD_NOT_CORRECT 0x00ff // NTR設定データが読み出されていない or 有効なものがないことを示す。
#define NVRAM_RETRY_NUM 8 // NVRAMリトライ回数
// NVRAMステータスレジスタ値
#define SR_WIP 0x01 // 0:READY 1:ライト、イレース中
#define SR_WEN 0x02 // 0:ライト禁止 1:ライト許可
#define SR_EER 0x20 // 1:イレースエラー発生（SANYO製FLASHのみ）
#define READ_IPL2_HEADER_ADDR 0x18 // IPL2ヘッダのうち、読み込みが必要な部分の先頭アドレス
#define READ_IPL2_HEADER_SIZE 0x0a // IPL2ヘッダのうち、読み込みが必要なサイズ
#define NSD_ROM_ADDR_SHIFT 3
// NVRAM関連送信コマンドステート
static enum NvramCommState{
COMM_READY = 0,
COMM_RD,
COMM_WE,
COMM_WR,
COMM_RDSR_WE,
COMM_RDSR_WR,
COMM_SRST
}NvramCommState;
// IPL2ヘッダの一部（0x18からのデータ)
typedef struct IPL2HeaderPart {
struct {
u8 timestamp[5]; // NTR-IPL2タイムスタンプ [0]:分,[1]:時,[2]:日,[3]:月,[4]:年
u8 ipl2_type; // NTR-IPL2タイプ
u8 rsv[2];
} version;
u16 nsd_rom_addr;
u8 pad[ 0x16 ]; // ※キャッシュラインに合わせるためのパディング。本来は必要なし。
} IPL2HeaderPart; // 0x20bytes
// NTR各種設定データのNVRAM保存時フォーマット
typedef struct NSDStore{
NTRSettingsData nsd; // NTR各種設定データ
u16 saveCount; // 0x00-0x7fをループしてカウントし、カウント値が新しいデータが有効。
u16 crc16; // NTR各種設定データの16bitCRC
u8 pad[ 128 - sizeof(NTRSettingsData) - 4];
}NSDStore; // 128byte // ※本来なら、saveCountとcrc16は256byteの最後に付加して、間にパディングを埋める方がいい。
// NTR各種設定データEXのNVRAM保存時フォーマット（上記NCDStoreと互換をとるための無理やり拡張）
typedef struct NSDStoreEx{
NTRSettingsData nsd; // NTR各種設定データ
u16 saveCount; // 0x00-0x7fをループしてカウントし、カウント値が新しいデータが有効。
u16 crc16; // NTR各種設定データの16bitCRC
NTRSettingsDataEx nsd_ex;
u16 crc16_ex;
}NSDStoreEx; // 256byte // ※本来なら、saveCountとcrc16は256byteの最後に付加して、間にパディングを埋める方がいい。
// function's prototype-------------------------------------------------
u32 NSD_GetNSDRomAddr( void ); // NTRSettingデータのNVRAM格納アドレスを取得
u8 NSD_GetIPL2Type( void ); // NTR-IPL2タイプを取得
const u8 *NSD_GetIPL2Timestamp( void ); // NTR-IPL2のタイムスタンプを取得
static void NSDi_ReadIPL2Header( void );
static BOOL NSDi_CheckCorrectNSD( NSDStoreEx (*pNSDStoreExArray)[2], u32 validLangBitmap );
static BOOL NSDi_CheckDataValue( NSDStoreEx *pNSDStore, u32 validLangBitmap );
static BOOL NVRAMm_ExecuteCommand( int nvState, u32 addr, u16 size, u8 *pSrc );
static void Callback_NVRAM( PXIFifoTag tag, u32 data, BOOL err );
// static variables-----------------------------------------------------
static NSDStoreEx s_NSDStoreEx[ 2 ] ATTRIBUTE_ALIGN(32);
static IPL2HeaderPart s_IPL2Header ATTRIBUTE_ALIGN(32);
static BOOL s_isReadIPL2H = FALSE;
static volatile BOOL s_nvCbOccurred;
static volatile u16 s_nvResult;
static int s_indexNSD = NSD_NOT_CORRECT;
// global variables-----------------------------------------------------
NTRSettingsData *g_pNSD = &s_NSDStoreEx[ 0 ].nsd;
NTRSettingsDataEx *g_pNSDEx = &s_NSDStoreEx[ 0 ].nsd_ex;
// const data-----------------------------------------------------------
// function's description-----------------------------------------------
//----------------------------------------------------------------------
// IPL2ヘッダ情報の読み出し
//----------------------------------------------------------------------
// コンポーネント上での使用時
// IPL2ヘッダの読み出し
static void NSDi_ReadIPL2Header( void )
{
if( !s_isReadIPL2H ) {
OS_TPrintf( "IPL2Header:%x\n", sizeof(IPL2HeaderPart) );
DC_InvalidateRange( &s_IPL2Header, sizeof(IPL2HeaderPart) );
while( !NVRAMm_ExecuteCommand( COMM_RD, READ_IPL2_HEADER_ADDR, READ_IPL2_HEADER_SIZE, (u8 *)&s_IPL2Header ) ) {}
s_isReadIPL2H = TRUE;
}
}
// IPL2タイプの取得
u8 NSD_GetIPL2Type( void )
{
NSDi_ReadIPL2Header();
return s_IPL2Header.version.ipl2_type;
}
// IPL2タイムスタンプの取得
const u8 *NSD_GetIPL2Timestamp( void )
{
NSDi_ReadIPL2Header();
return s_IPL2Header.version.timestamp;
}
// NSD格納ROMアドレスの取得
u32 NSD_GetNSDRomAddr( void )
{
NSDi_ReadIPL2Header();
return (u32)( s_IPL2Header.nsd_rom_addr << NSD_ROM_ADDR_SHIFT );
}
//----------------------------------------------------------------------
// NTR設定データのリード
//----------------------------------------------------------------------
// NTR設定データリード済み
BOOL NSD_IsReadSettings( void )
{
return ( s_indexNSD != NSD_NOT_CORRECT );
}
BOOL NSD_ReadSettings( u32 validLangBitmap )
{
DC_InvalidateRange( s_NSDStoreEx, sizeof(NSDStoreEx) * 2 );
// フラッシュからニ重化されているNTR設定データを読み出す。
while( !NVRAMm_ExecuteCommand( COMM_RD, NSD_GetNSDRomAddr(), sizeof(NSDStoreEx), (u8 *)&s_NSDStoreEx[ 0 ] ) ) {}
while( !NVRAMm_ExecuteCommand( COMM_RD, NSD_GetNSDRomAddr() + SPI_NVRAM_PAGE_SIZE, sizeof(NSDStoreEx), (u8 *)&s_NSDStoreEx[ 1 ] ) ) {}
OS_TPrintf("NSD read addr=%08x\n", NSD_GetNSDRomAddr() );
// 読み出したデータのどちらが有効かを判定する。
if( NSDi_CheckCorrectNSD( &s_NSDStoreEx, validLangBitmap ) ) {
// 有効なNTR設定データを先頭要素にコピー
if( s_indexNSD == 1 ) {
MI_CpuCopyFast( (void *)&s_NSDStoreEx[ s_indexNSD ], (void *)&s_NSDStoreEx[ 0 ], sizeof(NSDStoreEx) );
}
}else {
// 有効なデータがないなら、バッファをクリアする
OS_TPrintf( "NSD clear.\n" );
NSD_ClearSettings();
return FALSE;
}
OS_TPrintf("Use NSD[%d] : saveCount = %d\n", s_indexNSD, s_NSDStoreEx[ 0 ].saveCount );
return TRUE;
}
//----------------------------------------------------------------------
// NTR設定データのライト
//----------------------------------------------------------------------
BOOL NSD_WriteSettings( void )
{
int retry;
u32 nvramAddr;
NSDStoreEx *pNSDStoreEx = &s_NSDStoreEx[ 0 ];
// まだNTR設定データがリードされていなければ、リードを行って必要な情報を取得する。
if( !NSD_IsReadSettings() ) {
OS_TPrintf( "ERROR: Need call NSD_ReadSetting.\n" );
return FALSE;
}
// NSD のCRC、セーブカウント値、ライトアドレスの算出。
pNSDStoreEx->nsd.version = NTR_SETTINGS_DATA_VERSION; // バージョンを現在のものに設定。
pNSDStoreEx->crc16 = SVC_GetCRC16( 0xffff, (const void *)&pNSDStoreEx->nsd, sizeof(NTRSettingsData) );
pNSDStoreEx->saveCount = (u8)( ( pNSDStoreEx->saveCount + 1 ) & SAVE_COUNT_MASK );
// NSD_EXのCRC算出。
pNSDStoreEx->nsd_ex.version = NTR_SETTINGS_DATA_EX_VERSION; // バージョンを現在のものに設定。
pNSDStoreEx->nsd_ex.valid_language_bitmap &= NTR_LANG_BITMAP_ALL; // NTR側は日英仏独伊西中韓のみ
pNSDStoreEx->nsd_ex.valid_language_bitmap |= ( 0x0001 << NTR_LANG_ENGLISH ); // 英語は強制ON(旧NTRアプリ対策）
pNSDStoreEx->crc16_ex = SVC_GetCRC16( 0xffff, (const void *)&pNSDStoreEx->nsd_ex, sizeof(NTRSettingsDataEx) );
// NTR設定データのライト
DC_FlushRange( pNSDStoreEx, sizeof(NSDStoreEx) );
retry = NVRAM_RETRY_NUM;
while( retry-- ) {
s_indexNSD ^= 0x01; // リトライの度に書き込みアドレスを切り替える。
nvramAddr = NSD_GetNSDRomAddr() + s_indexNSD * SPI_NVRAM_PAGE_SIZE;
OS_TPrintf("NSD write addr=%08x\n", nvramAddr );
if( NVRAMm_ExecuteCommand( COMM_WE, nvramAddr, sizeof(NSDStoreEx), (u8 *)pNSDStoreEx ) ) {
OS_TPrintf("NVRAM Write succeeded.\n");
break;
}
SVC_WaitByLoop( 0x4000 );
OS_TPrintf("NVRAM Write retry = %d.\n", NVRAM_RETRY_NUM - retry );
}
return TRUE;
}
//----------------------------------------------------------------------
// ミラーリングされているNTR設定データのどちらが有効かを判定
//----------------------------------------------------------------------
static BOOL NSDi_CheckCorrectNSD( NSDStoreEx (*pNSDStoreExArray)[2], u32 validLangBitmap )
{
NSDStoreEx *pNSDStoreEx = (NSDStoreEx *)pNSDStoreExArray;
u16 i;
u16 nsd_valid = 0;
// 各ミラーデータのCRC & saveCount正当性チェック
for( i = 0; i < 2; i++ ) {
u16 crc;
BOOL isInvalid = FALSE;
// NSD のCRCチェックを行う。
crc = SVC_GetCRC16( 0xffff, (const void *)&pNSDStoreEx[i].nsd, sizeof(NTRSettingsData) );
if( ( pNSDStoreEx[ i ].crc16 != crc ) // CRCが正しく、saveCount値が0x80以下で、かつバージョンが一致するデータを正当と判断。
|| ( pNSDStoreEx[ i ].nsd.version != NTR_SETTINGS_DATA_VERSION )
|| ( pNSDStoreEx[ i ].saveCount >= SAVE_COUNT_MAX ) ) {
OS_TPrintf("NSD crc error.\n");
isInvalid = TRUE;
}
// NSDEx のCRCチェックを行う。
crc = SVC_GetCRC16( 0xffff, (const void *)&pNSDStoreEx[i].nsd_ex, sizeof(NTRSettingsDataEx) );
if( ( pNSDStoreEx[ i ].crc16_ex != crc )
|| ( pNSDStoreEx[ i ].nsd_ex.version != NTR_SETTINGS_DATA_EX_VERSION ) ) {
OS_TPrintf("NSDEx crc error.\n");
isInvalid = TRUE;
}
// NSD, NSDExのCRCが正しいなら、データの中身をチェック。
if( !isInvalid ) {
if( NSDi_CheckDataValue( &pNSDStoreEx[ i ], validLangBitmap ) ) { // データがおかしい値でないかもチェック。
nsd_valid |= 0x01 << i; // "有効"フラグをセット
s_indexNSD = i; // NCDのインデックスも切り替え。
}else {
isInvalid = TRUE;
}
}
if( nsd_valid & ( 0x01 << i ) ) {
OS_TPrintf("NSD[%d] valid : saveCount = %d\n", i, pNSDStoreEx[i].saveCount);
}else {
OS_TPrintf("NSD[%d] invalid.\n", i);
}
}
if( nsd_valid == 0 ) {
s_indexNSD = 1; // 最初のWrite時に"0"になるように"1"にしておく
return FALSE;
}else if( nsd_valid == 0x03 ) {
// ミラーリングされたNSDが両方ともに正当な場合、セーブカウント値が大きい方を有効とする。
u16 saveCount = (u8)( ( pNSDStoreEx[ 0 ].saveCount + 1 ) & SAVE_COUNT_MASK );
s_indexNSD = ( saveCount == pNSDStoreEx[ 1 ].saveCount ) ? (u16)1 : (u16)0;
}
return TRUE;
}
// NTR設定データの値が正しい値かチェック。 // FALSE:正しくない。TRUE：正しい。
static BOOL NSDi_CheckDataValue( NSDStoreEx *pNSDStoreEx, u32 validLangBitmap )
{
NTRSettingsData *pNSD = &pNSDStoreEx->nsd;
NTRSettingsDataEx *pNSDEx = &pNSDStoreEx->nsd_ex;
// NTR標準6言語以外の言語に対応している場合は、対応言語に英語を追加する。(旧NTRアプリ対策）
if( validLangBitmap & ~NTR_LANG_BITMAP_WW ) {
validLangBitmap |= ( 0x0001 << NTR_LANG_ENGLISH );
}
//pNSD->option;
// NSDおよびNSDExのlanguageチェック
if( ( ~validLangBitmap & ( 0x0001 << pNSD->option.language ) ) ||
( ~validLangBitmap & ( 0x0001 << pNSDEx->language ) )
) {
OS_TPrintf("NSD: invalid language : org:%02d ex:%02d bitmap:%04x\n",
pNSD->option.language, pNSDEx->language, pNSDEx->valid_language_bitmap );
return FALSE;
}
//pNSD->owner;
// favoriteColorは4bitなので範囲外はない。
// birthday
if( pNSD->option.isSetBirthday ) {
if( ( pNSD->owner.birthday.month > 12 ) || ( pNSD->owner.birthday.day > 31 ) ) {
OS_TPrintf("NSD: invalid birthday : %02d/%02d\n", pNSD->owner.birthday.month, pNSD->owner.birthday.day );
return FALSE;
}
}
// nickname
if( pNSD->option.isSetNickname ) {
if( pNSD->owner.nickname.length > NTR_NICKNAME_LENGTH ) {
OS_TPrintf("NSD: invalid nickname length : %02d\n", pNSD->owner.nickname.length );
return FALSE;
}
}
// comment
if( pNSD->owner.comment.length > NTR_COMMENT_LENGTH ) {
OS_TPrintf("NSD: invalid comment length : %02d\n", pNSD->owner.comment.length );
return FALSE;
}
//pNSD->alarm;
if( ( pNSD->alarm.hour > 23 ) || ( pNSD->alarm.minute > 59 ) ) {
OS_TPrintf("NSD: invalid alarm time : %02d:%02d\n", pNSD->alarm.hour, pNSD->alarm.minute );
return FALSE;
}
//pNSD->tp;
// TPキャリブレーション値は、TP_CalcCalibrateParamで値のチェックをしているので、チェックしない。
// OS_TPrintf( "NSD: correct data.\n" );
return TRUE;
}
// NTR設定データのクリア
void NSD_ClearSettings( void )
{
NSDStoreEx *pNSDStoreEx = &s_NSDStoreEx[ 0 ];
s_indexNSD = 1; // ライト前に反転されるので、"0"側が選択されるように"1"にしておく
MI_CpuClear16( pNSDStoreEx, sizeof(NSDStoreEx) );
// 初期値が0以外のもの
pNSDStoreEx->nsd.version = NTR_SETTINGS_DATA_VERSION;
pNSDStoreEx->nsd_ex.version = NTR_SETTINGS_DATA_EX_VERSION;
pNSDStoreEx->nsd.owner.birthday.month = 1;
pNSDStoreEx->nsd.owner.birthday.day = 1;
OS_TPrintf( "NSDStoreEx cleared.\n" );
}
// NTR設定データのニックネーム・色・誕生日の初期化。
void NSD_ClearOwnerInfo( void )
{
MI_CpuClear16( &GetNSD()->owner, sizeof(NTROwnerInfo) );
GetNSD()->owner.birthday.month = 1;
GetNSD()->owner.birthday.day = 1;
GetNSD()->option.isSetBirthday = 0;
GetNSD()->option.isSetUserColor = 0;
GetNSD()->option.isSetNickname = 0;
}
//----------------------------------------------------------------------
// NVRAMへのアクセスルーチン本体 ( nvState <- COMM_RD or COMM_WE )
//----------------------------------------------------------------------
static BOOL NVRAMm_ExecuteCommand( int nvState, u32 addr, u16 size, u8 *pSrc )
{
static u8 sr_buf[ 32 ] ATTRIBUTE_ALIGN(32);
OSTick start;
BOOL isSending = FALSE;
u8 *pSR = (u8 *)sr_buf;
PXI_SetFifoRecvCallback( PXI_FIFO_TAG_NVRAM , Callback_NVRAM );
while( 1 ) {
//---------------------------------------
// NVRAMコマンドを発行する
//---------------------------------------
if( !isSending ) {
s_nvCbOccurred = FALSE;
switch( nvState ) {
case COMM_RD:
isSending = SPI_NvramReadDataBytes( addr, size, pSrc );
break;
case COMM_WE:
isSending = SPI_NvramWriteEnable();
break;
case COMM_WR:
isSending = SPI_NvramPageWrite( addr, size , pSrc );
start = OS_GetTick();
break;
case COMM_RDSR_WE:
case COMM_RDSR_WR:
isSending = SPI_NvramReadStatusRegister( pSR );
break;
case COMM_SRST:
isSending = SPI_NvramSoftwareReset();
break;
}
//---------------------------------------
// コマンド実行結果（コールバック発生）を待って結果を処理する
//---------------------------------------
}else { // isSending == TRUE
if( s_nvCbOccurred == TRUE ) { // コールバック発生を待つ。
isSending = FALSE;
if( s_nvResult == SPI_PXI_RESULT_SUCCESS ) {
switch( nvState ) {
case COMM_RD:
return TRUE;
case COMM_WE:
nvState = COMM_RDSR_WE;
break;
case COMM_WR:
nvState = COMM_RDSR_WR;
break;
case COMM_RDSR_WE:
case COMM_RDSR_WR:
DC_InvalidateRange( pSR, 1 );
if( nvState == COMM_RDSR_WE ) { // ライトイネーブル確認ステートなら
if( ( *pSR & SR_WEN ) ) {
nvState = COMM_WR;
}else {
OS_TPrintf("NVRAM ERR: Write Enable Invalid.\n");
return FALSE;
}
}else {
if( ( *pSR & SR_WIP ) == 0 ) { // ライト／イレース終了
return TRUE;
}else {
if( ( *pSR & SR_EER ) // SR_EERが立っていたらエラー
|| ( OS_TicksToMilliSeconds( OS_GetTick() - start ) > 4000 ) ) {
// コマンド発行から4秒経過したらエラー（※保険）
DEBUG_Printf( "NVRAM SR : %02x\n", *pSR );
nvState = COMM_SRST;
}else {
SVC_WaitByLoop( 0x4000 );
}
}
}
break;
case COMM_SRST:
OS_TPrintf("NVRAM ERR: PageErase Timeout and SoftReset.\n");
return FALSE;
}
}else { // s_nvResult != SPI_PXI_RESULT_SUCCESS
OS_TPrintf("NVRAM ERR: NVRAM PXI command failed.\n");
return FALSE;
}
}
}
}
}
//----------------------------------------------------------------------
// コールバック
//----------------------------------------------------------------------
static void Callback_NVRAM( PXIFifoTag tag, u32 data, BOOL err )
{
#pragma unused(tag)
u16 command = (u16)( ( ( data & SPI_PXI_DATA_MASK ) & 0x7f00 ) >> 8 );
s_nvResult = (u16)( data & 0x00ff );
s_nvCbOccurred = TRUE; // コールバック発生フラグTRUE
if( err ) {
OS_TPrintf("NVRAM-ARM9: Received PXI data is error.\n");
s_nvResult = 0x00ff;
}
switch(command){ // コマンド名表示
case SPI_PXI_COMMAND_NVRAM_READ:
DEBUG_Printf("NVRAM-ARM9:ReadDataBytes");
break;
case SPI_PXI_COMMAND_NVRAM_WREN:
DEBUG_Printf("NVRAM-ARM9:WriteEnable");
break;
case SPI_PXI_COMMAND_NVRAM_PW:
DEBUG_Printf("NVRAM-ARM9:PageWrite");
break;
case SPI_PXI_COMMAND_NVRAM_RDSR:
DEBUG_Printf("NVRAM-ARM9:ReadStatusRegister");
break;
case SPI_PXI_COMMAND_NVRAM_WRDI:
DEBUG_Printf("NVRAM-ARM9:WriteDisable");
break;
case SPI_PXI_COMMAND_NVRAM_PE:
DEBUG_Printf("NVRAM-ARM9:PageErase");
break;
case SPI_PXI_COMMAND_NVRAM_SR:
DEBUG_Printf("NVRAM-ARM9:SoftwareReset");
break;
default:
DEBUG_Printf("NVRAM-ARM9:?????");
break;
}
if( s_nvResult != SPI_PXI_RESULT_SUCCESS ) {
OS_TPrintf(" Error! ->%x", s_nvResult );
}
DEBUG_Printf("\n");
}

418
build/libraries_sysmenu/settings/ARM9/src/TWLHWInfo.c
View File

@ -1,418 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: TWLHWInfo.c
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#include <twl.h>
#include <sysmenu/settings/common/TWLSettings.h>
#include <sysmenu/settings/common/TWLHWInfo.h>
// define data----------------------------------------------------------
//#define USE_SHA1_SIGNATURE // 署名内のハッシュにSHA1を使用（未定義ならHMAC-SHA1を使用）
// function's prototype-------------------------------------------------
static BOOL THWi_CalcSignature( void *pDstSign, const void *pSrc, u32 len, const u8 *pPrivKeyDER );
static BOOL THWi_CheckDigest( void *pTgt, u32 length, u8 *pDigest );
static BOOL THWi_CheckNormalInfoValue( const TWLHWNormalInfo *pSrcInfo );
static BOOL THWi_CheckSignature( void *pTgt, u32 length, u8 *pSignature );
static BOOL THWi_CheckSecureInfoValue( const TWLHWSecureInfo *pSecure );
static void DEBUG_PrintDigest( u8 *pDigest );
static void DEBUG_Dump( u8 *pSrc, u32 len );
static inline u16 SCFG_GetBondingOption(void)
{
return (u16)(*(u8*)(HW_SYS_CONF_BUF+HWi_WSYS08_OFFSET) & HWi_WSYS08_OP_OPT_MASK);
}
// static variables-----------------------------------------------------
TWLHWNormalInfo s_hwInfoN ATTRIBUTE_ALIGN(32);
TWLHWSecureInfo s_hwInfoS ATTRIBUTE_ALIGN(32);
static BOOL s_isReadNormal;
static BOOL s_isReadSecure;
static BOOL s_isSignCheck;
// global variables-----------------------------------------------------
// const data-----------------------------------------------------------
// ノーマル情報　デフォルト値
static TWLHWNormalInfo s_normalDefault = {
0x5a,
{ 0x00 },
};
// ノーマル情報　バージョン互換リスト
static const u8 s_normalVersionList[] = { 1, TSF_VERSION_TERMINATOR };
// ノーマル情報　TSFリードパラメータ
static const TSFParam s_normalParam = {
sizeof(TWLHWNormalInfo),
TWL_HWINFO_FILE_LENGTH,
s_normalVersionList,
(void (*)(void *))THW_ClearNormalInfoDirect,
THWi_CheckDigest,
(int (*)(void *))THWi_CheckNormalInfoValue,
};
// セキュア情報　デフォルト値
static TWLHWSecureInfo s_secureDefault = {
TWL_LANG_BITMAP_AMERICA,
TWL_REGION_AMERICA,
{ "0123456789A\0\0\0\0" },
};
// セキュア情報　バージョン互換リスト
static const u8 s_secureVersionList[] = { 1, TSF_VERSION_TERMINATOR };
// セキュア情報　TSFリードパラメータ
static const TSFParam s_secureParam = {
sizeof(TWLHWSecureInfo),
TWL_HWINFO_FILE_LENGTH,
s_secureVersionList,
(void (*)(void *))THW_ClearSecureInfoDirect,
THWi_CheckSignature,
(int (*)(void *))THWi_CheckSecureInfoValue,
};
// セキュア情報　公開鍵
static const u8 s_publicKey[ RSA_KEY_LENGTH ] = {
0xcf, 0x1a, 0xe0, 0xf7, 0xd1, 0x27, 0x59, 0xfb, 0x3a, 0x8c, 0xf5, 0x58, 0xc7, 0x17, 0xc1, 0xf2,
0xa9, 0x77, 0xbd, 0x53, 0x59, 0xe4, 0xd3, 0x01, 0x27, 0xca, 0xb7, 0xc9, 0x92, 0x32, 0x2e, 0xb5,
0xeb, 0x13, 0xbf, 0xca, 0xe2, 0x1b, 0xe7, 0x5c, 0xb0, 0x68, 0x5c, 0x58, 0x87, 0x84, 0x8c, 0x69,
0xb2, 0x59, 0x6b, 0x89, 0xd7, 0xa1, 0x89, 0x4c, 0x46, 0x36, 0xd8, 0xbb, 0xbd, 0xc8, 0x9d, 0xf5,
0xd2, 0x64, 0xb6, 0xeb, 0x71, 0x56, 0x2a, 0x69, 0xbd, 0x1d, 0xa3, 0xf6, 0xa1, 0x64, 0xe4, 0x8b,
0xda, 0x9b, 0xd2, 0x67, 0x19, 0xb5, 0xf0, 0xe0, 0xbb, 0xe3, 0x2c, 0xa9, 0xb4, 0x5c, 0xfb, 0x2c,
0x66, 0x61, 0xee, 0x18, 0x87, 0x23, 0x86, 0x34, 0xe7, 0xed, 0x1a, 0x75, 0x6e, 0x58, 0xb8, 0x81,
0x61, 0x4e, 0x9d, 0x4f, 0x12, 0x44, 0x27, 0xf4, 0x16, 0x65, 0xa8, 0x9e, 0x0c, 0x18, 0x34, 0x43,
};
// ---------------------------------------------------------------------
// HWノーマル情報
// ---------------------------------------------------------------------
// リード
TSFReadResult THW_ReadNormalInfo( void )
{
s_isReadNormal = TRUE;
return TSF_ReadFile( (char *)TWL_HWINFO_NORMAL_PATH, GetHWN(), &s_normalParam, NULL );
}
// ライト
BOOL THW_WriteNormalInfo( void )
{
if( !s_isReadNormal ) {
return FALSE;
}
return THW_WriteNormalInfoDirect( GetHWN() );
}
// 直接ライト
BOOL THW_WriteNormalInfoDirect( const TWLHWNormalInfo *pSrcInfo )
{
// ヘッダの作成
TSFHeader header;
MI_CpuClear8( &header, sizeof(TSFHeader) );
header.version = TWL_HWINFO_NORMAL_VERSION;
header.bodyLength = sizeof( TWLHWNormalInfo );
SVC_CalcSHA1( header.digest.sha1, pSrcInfo, sizeof(TWLHWNormalInfo) );
// ライト
if( !TSF_WriteFile( (char *)TWL_HWINFO_NORMAL_PATH,
&header,
(const void *)pSrcInfo,
NULL ) ) {
return FALSE;
}
// 未リード時、staticバッファへのコピーを行う
if( !s_isReadNormal ) {
s_isReadNormal = TRUE;
MI_CpuCopy8( pSrcInfo, GetHWN(), sizeof(TWLHWNormalInfo) );
}
return TRUE;
}
// ファイルのリカバリ
BOOL THW_RecoveryNormalInfo( TSFReadResult err )
{
return TSF_RecoveryFile( err, (char *)TWL_HWINFO_NORMAL_PATH, TWL_HWINFO_FILE_LENGTH );
}
// ダイジェストチェック
static BOOL THWi_CheckDigest( void *pTgt, u32 length, u8 *pDigest )
{
u8 digest[ SVC_SHA1_DIGEST_SIZE ];
SVC_CalcSHA1( digest, pTgt, length );
return SVC_CompareSHA1( digest, pDigest );
}
// 値チェック
static BOOL THWi_CheckNormalInfoValue( const TWLHWNormalInfo *pSrcInfo )
{
#pragma unused(pSrcInfo)
return TRUE;
}
// 新しいデフォルト値のセット
void THW_SetDefaultNormalInfo( const TWLHWNormalInfo *pSrcInfo )
{
MI_CpuCopy8( pSrcInfo, &s_normalDefault, sizeof(TWLHWNormalInfo) );
}
// 値のクリア
void THW_ClearNormalInfoDirect( TWLHWNormalInfo *pDstInfo )
{
MI_CpuCopy8( &s_normalDefault, pDstInfo, sizeof(TWLHWNormalInfo) );
}
// デフォルト値の取得
const TWLHWNormalInfo *THW_GetDefaultNormalInfo( void )
{
return &s_normalDefault;
}
// 現在値の取得
const TWLHWNormalInfo *THW_GetNormalInfo( void )
{
return GetHWN();
}
// ---------------------------------------------------------------------
// HWセキュア情報
// ---------------------------------------------------------------------
// リード
TSFReadResult THW_ReadSecureInfo( void )
{
s_isReadSecure = TRUE;
s_isSignCheck = TRUE;
return TSF_ReadFile( (char *)TWL_HWINFO_SECURE_PATH, GetHWS(), &s_secureParam, NULL );
}
// 署名ノーチェックリード
TSFReadResult THW_ReadSecureInfo_NoCheck( void )
{
s_isReadSecure = TRUE;
s_isSignCheck = FALSE;
return TSF_ReadFile( (char *)TWL_HWINFO_SECURE_PATH, GetHWS(), &s_secureParam, NULL );
}
// ライト
BOOL THW_WriteSecureInfo( const u8 *pPrivKeyDER )
{
if( !s_isReadSecure ) {
return FALSE;
}
return THW_WriteSecureInfoDirect( GetHWS(), pPrivKeyDER );
}
// 直接ライト
BOOL THW_WriteSecureInfoDirect( const TWLHWSecureInfo *pSrcInfo, const u8 *pPrivKeyDER )
{
// ヘッダの作成
TSFHeader header;
OSTick start = OS_GetTick();
MI_CpuClear8( &header, sizeof(TSFHeader) );
header.version = TWL_HWINFO_SECURE_VERSION;
header.bodyLength = sizeof( TWLHWSecureInfo );
if( !THWi_CalcSignature( (void *)header.digest.rsa,
(const void *)pSrcInfo,
sizeof(TWLHWSecureInfo),
pPrivKeyDER ) ) {
return FALSE;
}
// ライト
if( !TSF_WriteFile( (char *)TWL_HWINFO_SECURE_PATH,
&header,
(const void *)pSrcInfo,
NULL ) ) {
return FALSE;
}
OS_TPrintf( "RSA sign encrypt time = %dms\n", OS_TicksToMilliSeconds( OS_GetTick() - start ) );
// 未リード時、staticバッファへのコピーを行う
if( !s_isReadSecure ) {
s_isReadSecure = TRUE;
MI_CpuCopy8( pSrcInfo, GetHWS(), sizeof(TWLHWSecureInfo) );
}
return TRUE;
}
// 署名の算出
static BOOL THWi_CalcSignature( void *pDstSign, const void *pSrc, u32 len, const u8 *pPrivKeyDER )
{
#ifdef HW_SIGNATURE_ENABLE_
u8 digest[ SVC_SHA1_DIGEST_SIZE ];
u8 key[ SVC_SHA1_DIGEST_SIZE ];
u64 id = SCFG_ReadFuseData();
// 秘密鍵が指定されていない場合は署名なし。
if( !pPrivKeyDER ) {
return TRUE;
}
// 秘密鍵が指定された場合は、ボンディングオプションに関係なく署名付加を行う。
#ifdef USE_SHA1_SIGNATURE
SVC_CalcSHA1( digest, pSrc, len );
#else
SVC_CalcSHA1( key, &id, sizeof(u64) ); // idのSHA1ハッシュ値をキーとして使用
SVC_CalcHMACSHA1( digest, pSrc, len, key, SVC_SHA1_DIGEST_SIZE );
#endif
return ACSign_Encrypto( pDstSign,
pPrivKeyDER,
digest,
SVC_SHA1_DIGEST_SIZE );
#else // HW_SIGNATURE_ENABLE_
return TRUE;
#endif // HW_SIGNATURE_ENABLE_
}
// ファイルのリカバリ
BOOL THW_RecoverySecureInfo( TSFReadResult err )
{
return TSF_RecoveryFile( err, (char *)TWL_HWINFO_SECURE_PATH, TWL_HWINFO_FILE_LENGTH );
}
// 署名チェック
static BOOL THWi_CheckSignature( void *pTgt, u32 length, u8 *pSignature )
{
static u32 heap[ 4096 / sizeof(u32) ];
SVCSignHeapContext acmemoryPool;
u8 digest_sign[ SVC_SHA1_DIGEST_SIZE ];
u8 digest_calc[ SVC_SHA1_DIGEST_SIZE ];
u8 key[ SVC_SHA1_DIGEST_SIZE ];
u64 id = SCFG_ReadFuseData();
OSTick start = OS_GetTick();
#ifdef USE_SHA1_SIGNATURE
SVC_CalcSHA1( digest_calc, pTgt, length );
#else
SVC_CalcSHA1( key, &id, sizeof(u64) ); // idのSHA1ハッシュ値をキーとして使用
SVC_CalcHMACSHA1( digest_calc, pTgt, length, key, SVC_SHA1_DIGEST_SIZE );
#endif
SVC_InitSignHeap( &acmemoryPool, heap, 4096 );
SVC_DecryptSign( &acmemoryPool, digest_sign, pSignature, s_publicKey );
OS_TPrintf( "RSA sign decrypt time = %dms\n", OS_TicksToMilliSeconds( OS_GetTick() - start ) );
// 署名チェック
{
BOOL retval = SVC_CompareSHA1( digest_sign, digest_calc );
// ボンディングオプションが「製品版」の時のみ署名チェック結果を返す。
if( SCFG_GetBondingOption() == 0 ) {
return ( s_isSignCheck ) ? retval : TRUE;
}else {
OS_TPrintf( "Development Machine : signature check trough.\n" );
return TRUE;
}
}
}
// HW Secure情報 値チェック
static BOOL THWi_CheckSecureInfoValue( const TWLHWSecureInfo *pSrcInfo )
{
int serialNoLen = STD_StrLen( (const char *)pSrcInfo->serialNo );
if(
( pSrcInfo->region >= TWL_REGION_MAX ) ||
( serialNoLen < TWL_HWINFO_SERIALNO_LEN_AMERICA ) ||
( serialNoLen > TWL_HWINFO_SERIALNO_LEN_OTHERS )
) {
return FALSE;
}
return TRUE;
}
// 新しいデフォルト値のセット
void THW_SetDefaultSecureInfo( const TWLHWSecureInfo *pSrcInfo )
{
MI_CpuCopy8( pSrcInfo, &s_secureDefault, sizeof(TWLHWSecureInfo) );
}
// 値のクリア
void THW_ClearSecureInfoDirect( TWLHWSecureInfo *pDstInfo )
{
MI_CpuCopy8( &s_secureDefault, pDstInfo, sizeof(TWLHWSecureInfo) );
}
// デフォルト値の取得
const TWLHWSecureInfo *THW_GetDefaultSecureInfo( void )
{
return &s_secureDefault;
}
// 現在値の取得
const TWLHWSecureInfo *THW_GetSecureInfo( void )
{
return GetHWS();
}
// ---------------------------------------------------------------------
// デバッグ
// ---------------------------------------------------------------------
static void DEBUG_PrintDigest( u8 *pDigest )
{
int i;
for( i = 0; i < SVC_SHA1_DIGEST_SIZE; i++ ) {
OS_TPrintf( "%02x", *pDigest++ );
}
OS_TPrintf( "\n" );
}
static void DEBUG_Dump( u8 *pSrc, u32 len )
{
int i;
for( i = 0; i < len; i++ ) {
if( ( i & 0x0f ) == 0 ) {
OS_TPrintf( "\n" );
}
OS_TPrintf( "%02x ", *pSrc++ );
}
OS_TPrintf( "\n" );
}

316
build/libraries_sysmenu/settings/ARM9/src/TWLSettings.c
View File

@ -1,316 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: TWLSettings.c
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#include <twl.h>
#include <sysmenu/settings/common/NTRSettings.h>
#include <sysmenu/settings/common/TWLSettings.h>
#include <sysmenu/settings/common/TWLHWInfo.h>
// define data----------------------------------------------------------
#define TSD_FILE_MIRROR_NUM 2
#define TSD_NOT_CORRECT 0x00ff // TSD設定データが読み出されていない or 有効なものがないことを示す。
// function's prototype-------------------------------------------------
static BOOL TSDi_RecoveryFile( TSFReadResult err, char *pFilePath );
static BOOL TSDi_CheckDigest( void *pTgt, u32 length, u8 *pDigest );
static BOOL TSDi_CheckValue( const TWLSettingsData *pSecure );
static void TSDi_ClearSettingsDirect( TWLSettingsData *pTSD );
static BOOL TSDi_CheckDate( u8 month, u8 day );
static BOOL TSDi_CheckTime( u8 hour, u8 minute );
static BOOL TSDi_CheckString( const u16 *pStr, u8 maxLength );
// static variables-----------------------------------------------------
TWLSettingsData s_settings ATTRIBUTE_ALIGN(32);
static int s_indexTSD = TSD_NOT_CORRECT;
static u8 s_saveCount;
// global variables-----------------------------------------------------
// const data-----------------------------------------------------------
static const char *s_TSDPath[ TSD_FILE_MIRROR_NUM ] = {
(const char *)"nand:/shared1/TWLCFG0.dat",
(const char *)"nand:/shared1/TWLCFG1.dat",
};
// バージョン互換リスト
static const u8 s_settingsVersionList[] = { 1, TSF_VERSION_TERMINATOR };
// TSFリードパラメータ
static const TSFParam s_settingsParam = {
sizeof(TWLSettingsData),
TWL_SETTINGS_FILE_LENGTH,
s_settingsVersionList,
(void (*)(void *))TSDi_ClearSettingsDirect,
TSDi_CheckDigest,
(int (*)(void *))TSDi_CheckValue,
};
// 各リージョンでの国コード範囲リスト
static const u32 s_regionCountryList[ TWL_REGION_MAX ] = {
TWL_COUNTRY_MAPPING_JAPAN,
TWL_COUNTRY_MAPPING_AMERICA,
TWL_COUNTRY_MAPPING_EUROPE,
TWL_COUNTRY_MAPPING_AUSTRALIA,
TWL_COUNTRY_MAPPING_CHINA,
TWL_COUNTRY_MAPPING_KOREA,
};
// ---------------------------------------------------------------------
// TWL本体設定データ
// ---------------------------------------------------------------------
// ファイルから内部変数にリード
BOOL TSD_ReadSettings( void )
{
int i;
u8 saveCount[ TSD_FILE_MIRROR_NUM ];
TWLSettingsData settings[ TSD_FILE_MIRROR_NUM ];
BOOL retval = FALSE;
// リード
s_saveCount = 0;
s_indexTSD = TSD_NOT_CORRECT;
for( i = 0; i < TSD_FILE_MIRROR_NUM; i++ ) {
TSFReadResult rdResult = TSF_ReadFile( (char *)s_TSDPath[ i ],
&settings[ i ],
&s_settingsParam,
&saveCount[ i ] );
OS_TPrintf( "TSD[%d] saveCount = %d : ", i, saveCount[ i ] );
if( rdResult == TSF_READ_RESULT_SUCCEEDED ) {
OS_TPrintf( "enable.\n" );
// どちらのTSDを使用するか判定
if( s_indexTSD == TSD_NOT_CORRECT ) { // 最初に有効なTSDがあったら、まずはそれを使用することに。
s_indexTSD = i;
s_saveCount = saveCount[ i ];
}else { // もう１つも有効なら、saveCount値を比較して選択。
if( ( ( saveCount[ 0 ] + 1 ) & SAVE_COUNT_MASK ) == saveCount[ 1 ] ) {
s_indexTSD = 1;
s_saveCount = saveCount[ 1 ];
}
}
}else {
OS_TPrintf( "disable.\n" );
// リードに失敗した場合はファイルリカバリ
(void)TSDi_RecoveryFile( rdResult, (char *)s_TSDPath[ i ] );
(void)TSD_WriteSettingsDirect( &settings[ i ] );
}
}
// 有効なTSDを静的バッファにコピー
if( s_indexTSD != TSD_NOT_CORRECT ) {
MI_CpuCopyFast( &settings[ s_indexTSD ], GetTSD(), sizeof(TWLSettingsData) );
retval = TRUE;
}else {
// 有効なTSDがないなら静的バッファを初期化
TSDi_ClearSettingsDirect( GetTSD() );
s_indexTSD = 1;
}
OS_TPrintf( "TSD[%d] saveCount = %d : Use.\n", s_indexTSD, s_saveCount );
return retval;
}
// 内部変数の値をファイルにライト
BOOL TSD_WriteSettings( void )
{
if( s_indexTSD == TSD_NOT_CORRECT ) {
return FALSE;
}
return TSD_WriteSettingsDirect( GetTSD() );
}
// 指定データの値をファイルに直接ライト
BOOL TSD_WriteSettingsDirect( const TWLSettingsData *pSrcInfo )
{
// ヘッダの作成
TSFHeader header;
MI_CpuClear8( &header, sizeof(TSFHeader) );
header.version = TWL_SETTINGS_DATA_VERSION;
header.bodyLength = sizeof(TWLSettingsData);
SVC_CalcSHA1( header.digest.sha1, pSrcInfo, sizeof(TWLSettingsData) );
// まだ一度もリードされていないなら、staticバッファへのコピーを行う
if( s_indexTSD == TSD_NOT_CORRECT ) {
s_saveCount = 0;
s_indexTSD = 1;
MI_CpuCopy8( pSrcInfo, GetTSD(), sizeof(TWLSettingsData) );
}
// ファイルにライト
s_indexTSD ^= 0x01;
if( !TSF_WriteFile( (char *)s_TSDPath[ s_indexTSD ],
&header,
(const void *)pSrcInfo,
&s_saveCount ) ) {
return FALSE;
}
return TRUE;
}
// ファイルのリカバリ
static BOOL TSDi_RecoveryFile( TSFReadResult err, char *pFilePath )
{
return TSF_RecoveryFile( err, pFilePath, TWL_HWINFO_FILE_LENGTH );
}
// ダイジェストチェック
static BOOL TSDi_CheckDigest( void *pTgt, u32 length, u8 *pDigest )
{
u8 digest[ SVC_SHA1_DIGEST_SIZE ];
SVC_CalcSHA1( digest, pTgt, length );
return SVC_CompareSHA1( digest, pDigest );
}
// TWL設定データのクリア
void TSD_ClearSettings( void )
{
TSDi_ClearSettingsDirect( GetTSD() );
}
// TWL設定データの直接クリア
static void TSDi_ClearSettingsDirect( TWLSettingsData *pTSD )
{
int i;
MI_CpuClearFast( pTSD, sizeof(TWLSettingsData) );
// 初期値が"0"以外のもの
pTSD->backLightBrightness = TWL_BACKLIGHT_LEVEL_MAX;
pTSD->owner.birthday.month = 1;
pTSD->owner.birthday.day = 1;
// 言語コードはHW情報の言語ビットマップから算出
for( i = 0; i < TWL_LANG_CODE_MAX; i++ ) {
if( THW_GetValidLanguageBitmap() & ( 0x0001 << i ) ) {
pTSD->language = (TWLLangCode)i;
break;
}
}
}
// ---------------------------------------------------------------------
// 値チェック
// ---------------------------------------------------------------------
// 値チェック
static BOOL TSDi_CheckValue( const TWLSettingsData *pSrc )
{
// 国コード
if( pSrc->flags.isSetCountry ) {
u32 countryStart = (u32)( s_regionCountryList[ THW_GetRegion() ] >> 16 );
u32 countryEnd = (u32)( s_regionCountryList[ THW_GetRegion() ] & 0x0000ffff );
if( ( pSrc->country < countryStart ) ||
( pSrc->country > countryEnd ) ) {
return FALSE;
}
}else if( pSrc->country != TWL_COUNTRY_UNDEFINED ) {
return FALSE;
}
// 言語コード
if( pSrc->flags.isSetLanguage &&
!( THW_GetValidLanguageBitmap() & ( 0x0001 << pSrc->language ) )
) {
return FALSE;
}
// バックライト輝度
if( pSrc->backLightBrightness > TWL_BACKLIGHT_LEVEL_MAX ) {
return FALSE;
}
// u8 rtcLastSetYear; // RTCの前回設定年（チェックの必要なし）
// s64 rtcOffset; // RTC設定時のオフセット値（チェックの必要なし）
// オーナー情報
if( !TSDi_CheckDate( pSrc->owner.birthday.month, pSrc->owner.birthday.day ) ||
!TSDi_CheckString( pSrc->owner.nickname, TWL_NICKNAME_LENGTH ) ||
!TSDi_CheckString( pSrc->owner.comment, TWL_COMMENT_LENGTH ) ) {
return FALSE;
}
// アラーム
if( !TSDi_CheckTime( pSrc->alarm.hour, pSrc->alarm.minute ) ) {
return FALSE;
}
// TWLTPCalibData tp; // TP補正データ（チェックの必要なし。確認済み。）
// パレンタルコントロール
if( ( pSrc->parental.ogn >= TWL_RATING_OGN_MAX ) ||
( pSrc->parental.ratingAge > TWL_PARENTAL_CONTROL_RATING_AGE_MAX ) ||
// ( pSrc->parental.secretQuestion > TWL_PARENTAL_CONTROL_SECRET_QUESTION_MAX ) ||
// ( pSrc->parental.secretAnswerLength > TWL_PARENTAL_CONTROL_SECRET_ANSWER_LENGTH_MAX ) ||
( STD_StrLen( pSrc->parental.password ) > TWL_PARENTAL_CONTROL_PASSWORD_LENGTH ) ||
!TSDi_CheckString( pSrc->parental.secretAnswer, TWL_PARENTAL_CONTROL_SECRET_ANSWER_LENGTH_MAX ) ) {
return FALSE;
}
// インストール可能なNANDアプリ個数
if( pSrc->freeSoftBoxCount > TWL_FREE_SOFT_BOX_COUNT_MAX ) {
return FALSE;
}
return TRUE;
}
// 日付が正しいかチェック
static BOOL TSDi_CheckDate( u8 month, u8 day )
{
static const u8 dayNumList[ 12 ] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if( ( month < 1 ) ||
( month > 12 ) ||
( day < 1 ) ||
( day > dayNumList[ month - 1 ] ) ) {
return FALSE;
}
return TRUE;
}
// 時刻が正しいかチェック
static BOOL TSDi_CheckTime( u8 hour, u8 minute )
{
if( ( hour > 23 ) ||
( minute > 59 ) ) {
return FALSE;
}
return TRUE;
}
// 文字列長が正しいかチェック
static BOOL TSDi_CheckString( const u16 *pStr, u8 maxLength )
{
while( maxLength-- ) {
if( *pStr++ == 0 ) {
return TRUE;
}
}
return FALSE;
}

257
build/libraries_sysmenu/settings/ARM9/src/TWLStoreFile.c
View File

@ -1,257 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: TWLHWInfo.c
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#include <twl.h>
#include <sysmenu/settings/common/TWLStoreFile.h>
// define data----------------------------------------------------------
// function's prototype-------------------------------------------------
// static variables-----------------------------------------------------
// global variables-----------------------------------------------------
// const data-----------------------------------------------------------
// function's description-----------------------------------------------
// TSFファイルの読み出し
TSFReadResult TSF_ReadFile( char *pPath, void *pDstBody, const TSFParam *pParam, u8 *pSaveCount )
{
TSFHeader header;
TSFReadResult retval;
FSFile file;
FS_InitFile( &file );
// ヘッダ用バッファのクリア
MI_CpuClear8( &header, sizeof(TSFHeader) );
// ボディ用バッファのクリア
if( pParam->pClearFunc ) {
// クリア用関数ありの時は、バージョン下位互換の場合を考慮して、デフォルト値をセットしておく
pParam->pClearFunc( pDstBody );
}else {
// そうでない場合は、リードバッファをクリア
MI_CpuClear8( pDstBody, pParam->dataLength );
}
// ファイルオープン
if( !FS_OpenFileEx( &file, pPath, FS_FILEMODE_R ) ) {
OS_TPrintf( "Read : file open error. %s\n", pPath );
retval = TSF_READ_RESULT_ERROR_FILE_EXIST;
goto END2;
}
// ファイル長チェック
if( FS_GetFileLength( &file ) != pParam->fileLength ) {
OS_TPrintf( "Read : file length error. : %s length = %d\n", pPath, FS_GetFileLength( &file ) );
retval = TSF_READ_RESULT_ERROR_FILE_LENGTH;
goto END;
}
// ヘッダリード
if( FS_ReadFile( &file, &header, sizeof(TSFHeader) ) < sizeof(TSFHeader) ) {
OS_TPrintf( "Read : file read error. %s\n", pPath );
retval = TSF_READ_RESULT_ERROR_DATA;
goto END;
}
// ヘッダチェック
if( header.bodyLength > pParam->dataLength ) {
OS_TPrintf( "Read : file header error. %s\n", pPath );
retval = TSF_READ_RESULT_ERROR_DATA;
goto END;
}
// ボディリード
if( FS_ReadFile( &file, pDstBody, (long)header.bodyLength ) < pParam->dataLength ) {
OS_TPrintf( "Read : file read error. %s\n", pPath );
retval = TSF_READ_RESULT_ERROR_DATA;
goto END;
}
// データのダイジェストチェック
if( pParam->pCheckDigestFunc &&
!pParam->pCheckDigestFunc( pDstBody, header.bodyLength, header.digest.dst ) ) {
OS_TPrintf( "Read : file digest error. %s\n", pPath );
retval = TSF_READ_RESULT_ERROR_DATA;
goto END;
}
// データの値チェック
if( pParam->pCheckValueFunc &&
!pParam->pCheckValueFunc( pDstBody ) ) {
OS_TPrintf( "Read : file data value error. %s\n", pPath );
retval = TSF_READ_RESULT_ERROR_DATA;
goto END;
}
// バージョン互換チェック
if( pParam->conpatibleVerList ) {
const u8 *pVersion = pParam->conpatibleVerList;
while( *pVersion++ != TSF_VERSION_TERMINATOR ) {
if( *pVersion == header.version ) {
break; //　互換あり
}
}
if( *pVersion == TSF_VERSION_TERMINATOR ) {
retval = TSF_READ_RESULT_ERROR_DATA;
goto END;
}
}
if( pSaveCount ) {
*pSaveCount = header.saveCount;
}
retval = TSF_READ_RESULT_SUCCEEDED;
END:
// ファイルクローズ
FS_CloseFile( &file );
END2:
if( retval != TSF_READ_RESULT_SUCCEEDED ) {
// ボディ用バッファのクリア
if( pParam->pClearFunc ) {
// クリア用関数ありの時は、バージョン下位互換の場合を考慮して、デフォルト値をセットしておく
pParam->pClearFunc( pDstBody );
}else {
// そうでない場合は、リードバッファをクリア
MI_CpuClear8( pDstBody, pParam->dataLength );
}
}
return retval;
}
// TWLファイルのライト
BOOL TSF_WriteFile( char *pPath, TSFHeader *pHeader, const void *pSrcBody, u8 *pSaveCount )
{
BOOL retval = FALSE;
FSFile file;
FS_InitFile( &file );
if( pSaveCount ) {
*pSaveCount = (u8)( ( *pSaveCount + 1 ) & SAVE_COUNT_MASK );
pHeader->saveCount = *pSaveCount;
}else {
pHeader->saveCount = 0;
}
OS_TPrintf( "Write > %s : %d\n", pPath, pHeader->saveCount );
// ファイルオープン
if( !FS_OpenFileEx( &file, pPath, FS_FILEMODE_R | FS_FILEMODE_W ) ) { // R|Wモードで開くと、既存ファイルを残したまま更新。
OS_TPrintf( "Write : file open error. %s\n", pPath );
return FALSE;
}
// ライト
if( FS_WriteFile( &file, pHeader, sizeof(TSFHeader) ) < sizeof(TSFHeader) ) {
OS_TPrintf( "Write : file header write error. %s\n", pPath );
goto END;
}
if( FS_WriteFile( &file, pSrcBody, (long)pHeader->bodyLength ) < pHeader->bodyLength ) {
OS_TPrintf( "Write : file body write error. %s\n", pPath );
goto END;
}
retval = TRUE;
END:
// ファイルクローズ
FS_CloseFile( &file );
return retval;
}
// TWLファイルのリカバリ
BOOL TSF_RecoveryFile( TSFReadResult err, char *pPath, u32 fileLength )
{
#define INITIAL_DATA_PATTERN 0xffffffff
#define READ_SIZE 1024
u32 buffer[ READ_SIZE / sizeof(u32) ];
u32 length;
BOOL retval = FALSE;
BOOL isWrite = FALSE;
FSFile file;
FS_InitFile( &file );
if( err == TSF_READ_RESULT_SUCCEEDED ) {
return TRUE;
}
// ファイル生成
if( err == TSF_READ_RESULT_ERROR_FILE_EXIST ) {
if( !FS_CreateFile( pPath, FS_PERMIT_R | FS_PERMIT_W ) ) {
OS_TPrintf( "Recovery: create file error. %s\n", pPath );
goto END2;
}
}
// ファイルオープン
if( !FS_OpenFileEx( &file, pPath, FS_FILEMODE_R | FS_FILEMODE_W ) ) {
OS_TPrintf( "Recovery : file open error. %s\n", pPath );
goto END2;
}
// ファイル長変更
if( ( err == TSF_READ_RESULT_ERROR_FILE_EXIST ) ||
( err == TSF_READ_RESULT_ERROR_FILE_LENGTH ) ) {
if( FS_SetFileLength( &file, fileLength ) != FS_RESULT_SUCCESS ) {
OS_TPrintf( "Recovery : set file length error. %s\n", pPath );
goto END;
}
}
// データベリファイ
MI_CpuFillFast( buffer, INITIAL_DATA_PATTERN, sizeof(buffer) );
length = fileLength;
while( length ) {
int i;
u32 rdSize = ( length > READ_SIZE ) ? READ_SIZE : length;
FS_ReadFile( &file, buffer, (s32)rdSize );
for( i = 0; i < rdSize / sizeof(u32); i++ ) {
if( buffer[ i ] != INITIAL_DATA_PATTERN ) {
isWrite = TRUE;
goto NEXT;
}
}
length -= rdSize;
}
NEXT:
// ベリファイエラーの場合は、ファイル内データ初期化（0xff埋め）
if( isWrite ) {
FS_SeekFile( &file, 0, FS_SEEK_SET );
length = fileLength;
while( length ) {
u32 wrSize = ( length > READ_SIZE ) ? READ_SIZE : length;
if( FS_WriteFile( &file, buffer, (s32)wrSize ) < wrSize ) {
OS_TPrintf( "Recovery : write error. %s\n", pPath );
goto END;
}
length -= wrSize;
}
}
retval = TRUE;
END:
// ファイルクローズ
FS_CloseFile( &file );
END2:
return retval;
}

33
build/libraries_sysmenu/settings/Makefile
View File

@ -1,33 +0,0 @@
#! make -f
#----------------------------------------------------------------------------
# Project: TwlIPL
# File: Makefile
#
# Copyright 2007 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.
#
# $Date:: 2007-10-03#$
# $Rev: 1319 $
# $Author: kitase_hirotake $
#----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU
include $(TWL_IPL_RED_ROOT)/build/buildtools/commondefs
#----------------------------------------------------------------------------
SUBDIRS = ARM9
#----------------------------------------------------------------------------
include $(TWL_IPL_RED_ROOT)/build/buildtools/modulerules
#===== End of Makefile =====

2
build/libraries_sysmenu/sysmenu/ARM9/Makefile
View File

@ -27,7 +27,7 @@ TWL_ARCHGEN = LIMITED
TWL_PROC = ARM9
SRCS = sysmenu_lib.c sysmenu_card.c sysmenu_util.c ninLogoFunc.c \
settingsAPI.c mountInfo.c
mountInfo.c
TARGET_LIB = libsysmenu$(TWL_LIBSUFFIX).a

286
build/libraries_sysmenu/sysmenu/ARM9/src/settingsAPI.c
View File

@ -1,286 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: settingsAPI.c
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#include <twl.h>
#include <sysmenu.h>
// define data----------------------------------------------------------
// function's prototype-------------------------------------------------
BOOL SYSMi_VerifyNTRSettings( void );
static BOOL VerifyData( const void *pTgt1, const void *pTgt2, u32 size );
void SYSMi_ConvertTWL2NTRSettings( void );
static u8 MY_StrLen( const u16 *pStr );
// global variables-----------------------------------------------------
// static variables-----------------------------------------------------
// const data-----------------------------------------------------------
// function's description-----------------------------------------------
// TWL設定データファイルのリード
BOOL SYSM_ReadTWLSettingsFile( void )
{
BOOL retval;
// TWL設定データのリード
retval = TSD_ReadSettings();
// NTR設定データのリード
if( !NSD_IsReadSettings() ) {
(void)NSD_ReadSettings( THW_GetValidLanguageBitmap() );
#ifndef SDK_FINALROM
(void)SYSMi_VerifyNTRSettings(); // デバッグ用ベリファイ
#endif
}
SYSM_SetValidTSD( retval );
return retval;
}
// TWL設定データファイルへのライト
BOOL SYSM_WriteTWLSettingsFile( void )
{
BOOL retval;
// TWL設定データのライト
retval = TSD_WriteSettings();
if( retval ) {
// ライトに成功したら、TWL設定データを有効にする。
SYSM_SetValidTSD( TRUE );
// NTR設定データに反映する値が変化していたら、NTR設定データを書き込み。
if( !SYSMi_VerifyNTRSettings() ) {
SYSMi_ConvertTWL2NTRSettings();
(void)NSD_WriteSettings();
}
}
return retval;
}
// NTR設定とTWL設定をベリファイして、不一致があれば、NTR設定を更新
void SYSM_VerifyAndRecoveryNTRSettings( void )
{
BOOL isRecovery = FALSE;
// NVRAMからNTR設定データをロードして、TWL設定データとベリファイ
if( !NSD_ReadSettings( THW_GetValidLanguageBitmap() ) ||
!SYSMi_VerifyNTRSettings()
) {
// ロード or ベリファイ失敗なら、TWL設定データからNTR設定データを生成して、書き込み
SYSMi_ConvertTWL2NTRSettings();
NSD_WriteSettings();
}
}
// NTR設定とTWL設定をベリファイ
BOOL SYSMi_VerifyNTRSettings( void )
{
BOOL isFailed = FALSE;
u32 twlValidLangBitmap;
// 値が一致する必要があるもの
if( // NTR設定データバージョン
( NSD_GetVersion() != NTR_SETTINGS_DATA_VERSION ) ||
( NSD_GetExVersion() != NTR_SETTINGS_DATA_EX_VERSION ) ||
// オーナー情報
( NSD_GetUserColor() != TSD_GetUserColor() ) ||
!VerifyData( NSD_GetBirthdayPtr(), TSD_GetBirthdayPtr(), sizeof(NTRDate) ) ||
!VerifyData( NSD_GetNicknamePtr()->buffer, TSD_GetNicknamePtr(), NTR_NICKNAME_LENGTH ) ||
( NSD_GetNicknamePtr()->length != MY_StrLen( TSD_GetNicknamePtr() ) ) ||
!VerifyData( NSD_GetCommentPtr()->buffer, TSD_GetCommentPtr(), NTR_COMMENT_LENGTH ) ||
( NSD_GetCommentPtr()->length != MY_StrLen( TSD_GetCommentPtr() ) ) ||
// アラーム
!VerifyData( NSD_GetAlarmDataPtr(), TSD_GetAlarmDataPtr(), sizeof(NTRAlarm) ) ||
// TP情報
!VerifyData( NSD_GetTPCalibrationPtr(), TSD_GetTPCalibrationPtr(), sizeof(NTRTPCalibData) )
) {
OS_TPrintf( "VERSION : %d\n", ( NSD_GetVersion() != NTR_SETTINGS_DATA_VERSION ) );
OS_TPrintf( "VERSION EX: %d\n", ( NSD_GetExVersion() != NTR_SETTINGS_DATA_EX_VERSION ) );
OS_TPrintf( "UserColor : %d\n", ( NSD_GetUserColor() != TSD_GetUserColor() ) );
OS_TPrintf( "Birthday : %d\n", !VerifyData( NSD_GetBirthdayPtr(), TSD_GetBirthdayPtr(), sizeof(NTRDate) ) );
OS_TPrintf( "Nickname : %d\n", !VerifyData( NSD_GetNicknamePtr()->buffer, TSD_GetNicknamePtr(), NTR_NICKNAME_LENGTH ) );
OS_TPrintf( " length : %d\n", ( NSD_GetNicknamePtr()->length != MY_StrLen( TSD_GetNicknamePtr() ) ) );
OS_TPrintf( "Comment : %d\n", !VerifyData( NSD_GetCommentPtr()->buffer, TSD_GetCommentPtr(), NTR_COMMENT_LENGTH ) );
OS_TPrintf( " length : %d\n", ( NSD_GetCommentPtr()->length != MY_StrLen( TSD_GetCommentPtr() ) ) );
OS_TPrintf( "Alarm : %d\n", !VerifyData( NSD_GetAlarmDataPtr(), TSD_GetAlarmDataPtr(), sizeof(NTRAlarm) ) );
OS_TPrintf( "TP : %d\n", !VerifyData( NSD_GetTPCalibrationPtr(), TSD_GetTPCalibrationPtr(), sizeof(NTRTPCalibData) ) );
isFailed = TRUE;
}
// オプション
// "0"であるべきものチェック
if( (
NSD_IsGBUseTopLCD() |
NSD_IsAutoBoot() |
NSD_IsBacklightOff() |
NSD_IsInitialSequence() |
NSD_GetRTCClockAdjust()
) != 0 ) {
isFailed = TRUE;
}
// "1"であるべきものチェック"
if( ( NSD_IsSetBirthday() &
NSD_IsSetUserColor() &
NSD_IsSetTP() &
NSD_IsSetLanguage() &
NSD_IsSetDateTime() &
NSD_IsSetNickname()
) == 0 ) {
isFailed = TRUE;
}
// 値が一致する必要があるもの
if( ( NSD_GetRTCLastSetYear() != TSD_GetRTCLastSetYear() ) ||
( NSD_GetRTCOffset() != TSD_GetRTCOffset() )
) {
isFailed = TRUE;
}
// SystemMenuのリージョンによって、ちょっと特殊な処理が必要なもの
twlValidLangBitmap = ( THW_GetValidLanguageBitmap() & NTR_LANG_BITMAP_ALL ) | ( 0x0001 << NTR_LANG_ENGLISH );
OS_TPrintf( "%08x %08x\n", twlValidLangBitmap, NSD_GetValidLanguageBitmap() );
if( twlValidLangBitmap != NSD_GetValidLanguageBitmap() ) {
// 対応言語ビットマップ不一致
isFailed = TRUE;
}else if( !( twlValidLangBitmap & ( 0x0001 << NSD_GetLanguage() ) & ( 0x0001 << NSD_GetLanguageEx() ) ) ) {
// NSD側が対応言語ビットマップ外の値になっている
isFailed = TRUE;
}else if( TSD_GetLanguage() < NTR_LANG_CODE_MAX_WW ) {
if( ( NSD_GetLanguage() >= NTR_LANG_CODE_MAX_WW ) ||
( NSD_GetLanguageEx() >= NTR_LANG_CODE_MAX_WW ) ) {
isFailed = TRUE;
}
}else if( TSD_GetLanguage() <= NTR_LANG_KOREAN ) {
if( ( NSD_GetLanguage() != NTR_LANG_ENGLISH ) ||
( NSD_GetLanguageEx() > NTR_LANG_KOREAN ) ) {
isFailed = TRUE;
}
}else {
if( ( NSD_GetLanguage() != NTR_LANG_ENGLISH ) ||
( NSD_GetLanguageEx() != NTR_LANG_ENGLISH ) ) {
isFailed = TRUE;
}
}
// 値が何でも問題ないもの
// NSD_GetBacklightBrightness();
OS_TPrintf( "TSD & NSD verify %s.\n", isFailed ? "NG" : "OK" );
return !isFailed;
}
// 指定サイズのベリファイ
static BOOL VerifyData( const void *pTgt1, const void *pTgt2, u32 size )
{
u8 *p1 = (u8 *)pTgt1;
u8 *p2 = (u8 *)pTgt2;
while( size-- ) {
if( *p1++ != *p2++ ) {
return FALSE;
}
}
return TRUE;
}
// TWL設定データ -> NTR設定データのコンバート
void SYSMi_ConvertTWL2NTRSettings( void )
{
SVC_CpuClearFast( 0x0000, GetNSD(), sizeof(NTRSettingsData) );
SVC_CpuClearFast( 0x0000, GetNSDEx(), sizeof(NTRSettingsDataEx) );
// NTR設定データバージョン
NSD_SetVersion ( NTR_SETTINGS_DATA_VERSION );
NSD_SetExVersion( NTR_SETTINGS_DATA_EX_VERSION );
// オーナー情報
NSD_SetUserColor( TSD_GetUserColor() );
NSD_SetBirthday( TSD_GetBirthdayPtr() );
MI_CpuCopy16( TSD_GetNicknamePtr(), NSD_GetNicknamePtr()->buffer, NTR_NICKNAME_BUFFERSIZE );
NSD_GetNicknamePtr()->length = MY_StrLen( TSD_GetNicknamePtr() );
MI_CpuCopy16( TSD_GetCommentPtr(), NSD_GetCommentPtr()->buffer, NTR_COMMENT_BUFFERSIZE );
NSD_GetCommentPtr()->length = MY_StrLen( TSD_GetCommentPtr() );
// アラーム
NSD_SetAlarmData( TSD_GetAlarmDataPtr() );
// TPキャリブレーション
NSD_SetTPCalibration( &TSD_GetTPCalibrationPtr()->data );
// オプション
// "0"であるべきもの
NSD_SetFlagGBUseTopLCD( FALSE );
NSD_SetFlagAutoBoot( FALSE );
NSD_SetFlagBacklightOff( FALSE );
NSD_SetFlagInitialSequence( FALSE );
NSD_SetRTCClockAdjust( 0 );
// "1"であるべきもの
NSD_SetFlagBirthday( TRUE );
NSD_SetFlagUserColor( TRUE );
NSD_SetFlagTP( TRUE );
NSD_SetFlagLanguage( TRUE );
NSD_SetFlagDateTime( TRUE );
NSD_SetFlagNickname( TRUE );
// 値が一致する必要があるもの
NSD_SetRTCLastSetYear( TSD_GetRTCLastSetYear() );
NSD_SetRTCOffset( TSD_GetRTCOffset() );
// SystemMenuのリージョンによって、ちょっと特殊な処理が必要なもの
if( TSD_GetLanguage() < NTR_LANG_CODE_MAX_WW ) {
// TSD側がNTR標準６言語の時、TSD側 == NSD側
NSD_SetLanguage ( (NTRLangCode)TSD_GetLanguage() );
NSD_SetLanguageEx( (NTRLangCode)TSD_GetLanguage() );
}else if( TSD_GetLanguage() <= TWL_LANG_KOREAN ) {
// TSD側がNTR標準６言語以外の中国・韓国語の時、NSD側のlanguageは強制ENGLISH（NCDEx側にちゃんとした値が入る）
NSD_SetLanguage ( NTR_LANG_ENGLISH );
NSD_SetLanguageEx( (NTRLangCode)TSD_GetLanguage() );
}else {
// それ以外の時は強制ENGLISH
NSD_SetLanguage ( NTR_LANG_ENGLISH );
NSD_SetLanguageEx( NTR_LANG_ENGLISH );
}
// 言語ビットマップ
{
u16 validLangBitmap = (u16)( ( THW_GetValidLanguageBitmap() & NTR_LANG_BITMAP_ALL ) | ( 0x0001 << NTR_LANG_ENGLISH ) );
NSD_SetValidLanguageBitmap( validLangBitmap ); // ライト関数内部でもマスクされるが、ここでもしておく。
}
// 値が何でも問題ないもの
NSD_SetBacklightBrightness( TSD_GetBacklightBrightness() & 0x03 );
// [TODO:] TWL側のバックライト輝度レベルが４段階でない時は、変換が必要。
}
// UTF16の文字列長のチェック
static u8 MY_StrLen( const u16 *pStr )
{
u8 len = 0;
while( *pStr++ ) {
++len;
if( len == 255 ) {
break;
}
}
return len;
}

44
build/libraries_sysmenu/sysmenu/ARM9/src/sysmenu_lib.c
View File

@ -30,6 +30,8 @@ typedef struct BannerCheckParam {
}BannerCheckParam;
// extern data-----------------------------------------------------------------
extern void LCFG_VerifyAndRecoveryNTRSettings( void );
extern void SYSMi_SetLauncherMountInfo( void );
extern void SYSM_SetBootAppMountInfo( TitleProperty *pBootTitle ); // マウント情報のセット
@ -114,7 +116,7 @@ void SYSM_SetAllocFunc( void *(*pAlloc)(u32), void (*pFree)(void*) )
TitleProperty *SYSM_ReadParameters( void )
{
TitleProperty *pBootTitle = NULL;
u8 brightness = TWL_BACKLIGHT_LEVEL_MAX;
u8 brightness = LCFG_TWL_BACKLIGHT_LEVEL_MAX;
// ARM7のリセットパラメータ取得が完了するのを待つ
while( !SYSMi_GetWork()->isARM9Start ) {
@ -153,12 +155,12 @@ TitleProperty *SYSM_ReadParameters( void )
// HW情報のリード
//-----------------------------------------------------
// ノーマル情報リード
if( THW_ReadNormalInfo() != TSF_READ_RESULT_SUCCEEDED ) {
if( LCFG_ReadHWNormalInfo() != LCFG_TSF_READ_RESULT_SUCCEEDED ) {
OS_TPrintf( "HW Normal Info Broken!\n" );
SYSMi_GetWork()->isBrokenHWNormalInfo = TRUE;
}
// セキュア情報リード
if( THW_ReadSecureInfo() != TSF_READ_RESULT_SUCCEEDED ) {
if( LCFG_ReadHWSecureInfo() != LCFG_TSF_READ_RESULT_SUCCEEDED ) {
OS_TPrintf( "HW Secure Info Broken!\n" );
SYSMi_GetWork()->isBrokenHWSecureInfo = TRUE;
}
@ -166,9 +168,9 @@ TitleProperty *SYSM_ReadParameters( void )
//-----------------------------------------------------
// 本体設定データのリード
//-----------------------------------------------------
if( SYSM_ReadTWLSettingsFile() ) { // NANDからTWL本体設定データをリード
if( LCFG_ReadTWLSettingsFile() ) { // NANDからTWL本体設定データをリード
SYSM_CaribrateTP(); // 読み出したTWL本体設定データをもとにTPキャリブレーション。
brightness = (u8)TSD_GetBacklightBrightness();
brightness = (u8)LCFG_TSD_GetBacklightBrightness();
}
//-----------------------------------------------------
@ -181,7 +183,7 @@ TitleProperty *SYSM_ReadParameters( void )
// RTC値のチェック
SYSMi_CheckRTC();
SYSM_VerifyAndRecoveryNTRSettings(); // NTR設定データを読み出して、TWL設定データとベリファイし、必要ならリカバリ
LCFG_VerifyAndRecoveryNTRSettings(); // NTR設定データを読み出して、TWL設定データとベリファイし、必要ならリカバリ
//NAMの初期化
NAM_Init( SYSM_Alloc, SYSM_Free );
@ -225,11 +227,11 @@ static TitleProperty *SYSMi_CheckShortcutBoot( void )
//-----------------------------------------------------
#if 0
#ifdef ENABLE_INITIAL_SETTINGS_
if( !TSD_IsSetTP() ||
!TSD_IsSetLanguage() ||
!TSD_IsSetDateTime() ||
!TSD_IsSetUserColor() ||
!TSD_IsSetNickname() ) {
if( !LCFG_TSD_IsSetTP() ||
!LCFG_TSD_IsSetLanguage() ||
!LCFG_TSD_IsSetDateTime() ||
!LCFG_TSD_IsSetUserColor() ||
!LCFG_TSD_IsSetNickname() ) {
s_bootTitle.titleID = TITLE_ID_MACHINE_SETTINGS;
s_bootTitle.flags.bootType = OS_BOOTTYPE_NAND;
s_bootTitle.flags.isValid = TRUE;
@ -862,25 +864,25 @@ u32 PMi_WriteRegister(u16 registerAddr, u16 data)
// バックライト輝度調整
void SYSM_SetBackLightBrightness( u8 brightness )
{
if( brightness > TWL_BACKLIGHT_LEVEL_MAX ) {
if( brightness > LCFG_TWL_BACKLIGHT_LEVEL_MAX ) {
OS_Panic( "Backlight brightness over : %d\n", brightness );
}
( void )PMi_WriteRegister( 0x20, (u16)brightness );
TSD_SetBacklightBrightness( brightness );
LCFG_TSD_SetBacklightBrightness( brightness );
// [TODO:] バックライト輝度は毎回セーブせずに、アプリ起動やリセット、電源OFF時に値が変わっていたらセーブするようにする。
SYSM_WriteTWLSettingsFile();
LCFG_WriteTWLSettingsFile();
}
// タッチパネルキャリブレーション
void SYSM_CaribrateTP( void )
{
TWLTPCalibData store;
LCFGTWLTPCalibData store;
TPCalibrateParam calibParam;
// 本体設定データからキャリブレーション情報を取得
TSD_GetTPCalibration( &store );
LCFG_TSD_GetTPCalibration( &store );
// TPキャリブレーション
( void )TP_CalcCalibrateParam( &calibParam, // タッチパネル初期化
@ -897,7 +899,7 @@ void SYSM_CaribrateTP( void )
static void SYSMi_WriteAdjustRTC( void )
{
RTCRawAdjust raw;
raw.adjust = THW_GetRTCAdjust();
raw.adjust = LCFG_THW_GetRTCAdjust();
( void )RTCi_SetRegAdjust( &raw );
}
@ -1088,10 +1090,10 @@ static void SYSMi_CheckRTC( void )
#endif
) { // RTCの異常を検出したら、rtc入力フラグ＆rtcOffsetを0にしてNVRAMに書き込み。
OS_TPrintf("\"RTC reset\" or \"Illegal RTC data\" detect!\n");
TSD_SetFlagDateTime( FALSE );
TSD_SetRTCOffset( 0 );
TSD_SetRTCLastSetYear( 0 );
SYSM_WriteTWLSettingsFile();
LCFG_TSD_SetFlagDateTime( FALSE );
TSD_SetRTCOffset( 0 ); // [TODO:]本来は、LCFG_TSD_SetRTCOffset( 0 ); SDK_5_00pr2では間違っている。
LCFG_TSD_SetRTCLastSetYear( 0 );
LCFG_WriteTWLSettingsFile();
}
}

6
build/libraries_sysmenu/sysmenu/ARM9/src/sysmenu_util.c
View File

@ -51,14 +51,14 @@ s64 SYSM_CalcRTCOffset( RTCDate *newDatep, RTCTime *newTimep )
oldTime.second = 0;
// RTC設定時は、今回の設定でどれだけRTC値が変化したか（秒オフセット単位）を算出。
if( ( oldDate.year < TSD_GetRTCLastSetYear() ) && ( TSD_IsSetDateTime() ) ) {
if( ( oldDate.year < LCFG_TSD_GetRTCLastSetYear() ) && ( LCFG_TSD_IsSetDateTime() ) ) {
oldDate.year += 100; // 前回の設定～今回の設定の間にRTCが一周してしまったら、yearは100を加算してoffsetを計算する。
}
TSD_SetRTCLastSetYear( (u8)newDatep->year );
LCFG_TSD_SetRTCLastSetYear( (u8)newDatep->year );
offset0 = SYSMi_CalcRTCSecOffset( &oldDate, &oldTime ); // 設定直前のRTC値のオフセットを算出
offset1 = SYSMi_CalcRTCSecOffset( newDatep, newTimep ); // 新しくセットされたRTC値のオフセットを算出
offset = TSD_GetRTCOffset() + offset1 - offset0; // 新RTC_ofs と 現在のRTC_ofs の差分の値を加算してリターン。
offset = LCFG_TSD_GetRTCOffset() + offset1 - offset0; // 新RTC_ofs と 現在のRTC_ofs の差分の値を加算してリターン。
OS_Printf ("Now Date = year:%3d month:%3d date:%3d hour:%3d minute:%3d second:%3d\n",
oldDate.year, oldDate.month, oldDate.day,

6
build/systemMenu_RED/HWInfoWriter/ARM9/Makefile
View File

@ -17,8 +17,7 @@
#----------------------------------------------------------------------------
SUBDIRS = \
# ../../../libraries_sysmenu/sysmenu \
# ../../../libraries_sysmenu/settings
# ../../../libraries_sysmenu/sysmenu
#----------------------------------------------------------------------------
@ -38,7 +37,8 @@ MISC_DIR = ../../misc
SRCS = main.c HWInfoWriter.c \
$(MISC_DIR)/src/misc.c $(MISC_DIR)/src/cmn.c
LINCLUDES = $(MISC_DIR)/include
LINCLUDES = $(MISC_DIR)/include \
$(ROOT)/build/libraries/lcfg/ARM9.TWL/include
LLIBRARIES = libacsign_enc$(TWL_LIBSUFFIX).a
MAKEROM_FLAGS += -DTITLEID_LO='$(TITLEID_LO)'

110
build/systemMenu_RED/HWInfoWriter/ARM9/src/HWInfoWriter.c
View File

@ -17,6 +17,8 @@
#include <twl.h>
#include <sysmenu.h>
#include "TWLHWInfo_api.h"
#include "TWLSettings_api.h"
#include "misc.h"
#include "HWInfoWriter.h"
@ -26,10 +28,10 @@
#define MSG_Y 19
// extern data------------------------------------------
const TWLHWNormalInfo *THW_GetDefaultNormalInfo( void );
const TWLHWSecureInfo *THW_GetDefaultSecureInfo( void );
const TWLHWNormalInfo *THW_GetNormalInfo( void );
const TWLHWSecureInfo *THW_GetSecureInfo( void );
const LCFGTWLHWNormalInfo *LCFG_THW_GetDefaultNormalInfo( void );
const LCFGTWLHWSecureInfo *LCFG_THW_GetDefaultSecureInfo( void );
const LCFGTWLHWNormalInfo *LCFG_THW_GetNormalInfo( void );
const LCFGTWLHWSecureInfo *LCFG_THW_GetSecureInfo( void );
// function's prototype declaration---------------------
static void ReadTWLSettings( void );
@ -52,7 +54,7 @@ RTCDrawProperty g_rtcDraw = {
// static variable -------------------------------------
static u16 s_csr;
static u8 *s_pPrivKeyBuffer = NULL;
static TSFReadResult (*s_pReadSecureInfoFunc)( void );
static LCFGReadResult (*s_pReadSecureInfoFunc)( void );
static BOOL s_isReadTSD;
static u8 s_region_old;
@ -87,13 +89,13 @@ static const MenuParam s_writerParam = {
(const u16 **)&s_pStrWriter,
};
static const u32 s_langBitmapList[ TWL_REGION_MAX ] = {
TWL_LANG_BITMAP_JAPAN,
TWL_LANG_BITMAP_AMERICA,
TWL_LANG_BITMAP_EUROPE,
TWL_LANG_BITMAP_AUSTRALIA,
TWL_LANG_BITMAP_CHINA,
TWL_LANG_BITMAP_KOREA,
static const u32 s_langBitmapList[ LCFG_TWL_REGION_MAX ] = {
LCFG_TWL_LANG_BITMAP_JAPAN,
LCFG_TWL_LANG_BITMAP_AMERICA,
LCFG_TWL_LANG_BITMAP_EUROPE,
LCFG_TWL_LANG_BITMAP_AUSTRALIA,
LCFG_TWL_LANG_BITMAP_CHINA,
LCFG_TWL_LANG_BITMAP_KOREA,
};
static char *strLanguage[] = {
@ -138,10 +140,10 @@ void HWInfoWriterInit( void )
ReadPrivateKey();
ReadHWInfoFile();
// VerifyHWInfo();
OS_TPrintf( "region = %d\n", THW_GetRegion() );
PrintfSJISSub( 2 * 8, 18 * 8, TXT_COLOR_BLACK, "Region = %s", strRegion[ THW_GetRegion() ] );
PrintfSJISSub( 2 * 8, 20 * 8, TXT_COLOR_BLACK, "SerialNo = %s", THW_GetSerialNoPtr() );
s_region_old = THW_GetRegion();
OS_TPrintf( "region = %d\n", LCFG_THW_GetRegion() );
PrintfSJISSub( 2 * 8, 18 * 8, TXT_COLOR_BLACK, "Region = %s", strRegion[ LCFG_THW_GetRegion() ] );
PrintfSJISSub( 2 * 8, 20 * 8, TXT_COLOR_BLACK, "SerialNo = %s", LCFG_THW_GetSerialNoPtr() );
s_region_old = LCFG_THW_GetRegion();
s_csr = 0;
DrawMenu( s_csr, &s_writerParam );
@ -185,7 +187,7 @@ void HWInfoWriterMain( void )
// TWL設定データのリード
static void ReadTWLSettings( void )
{
s_isReadTSD = TSD_ReadSettings();
s_isReadTSD = LCFGi_TSD_ReadSettings();
if( s_isReadTSD ) {
OS_TPrintf( "TSD read succeeded.\n" );
}else {
@ -198,7 +200,7 @@ static void ReadTWLSettings( void )
static void ModifyLanguage( u8 region )
{
u32 langBitmap = s_langBitmapList[ region ];
u8 nowLanguage = TSD_GetLanguage();
u8 nowLanguage = LCFG_TSD_GetLanguage();
// TSDが読み込めていないなら、何もせずリターン
if( !s_isReadTSD ) {
@ -209,17 +211,17 @@ static void ModifyLanguage( u8 region )
OS_TPrintf( "Language no change.\n" );
}else {
int i;
for( i = 0; i < TWL_LANG_CODE_MAX; i++ ) {
for( i = 0; i < LCFG_TWL_LANG_CODE_MAX; i++ ) {
if( langBitmap & ( 0x0001 << i ) ) {
break;
}
}
TSD_SetLanguage( (TWLLangCode)i );
TSD_SetFlagCountry( FALSE ); // ※ついでに国コードもクリアしておく。
TSD_SetCountry( TWL_COUNTRY_UNDEFINED );
TSD_WriteSettings();
LCFG_TSD_SetLanguage( (LCFGTWLLangCode)i );
LCFG_TSD_SetFlagCountry( FALSE ); // ※ついでに国コードもクリアしておく。
LCFG_TSD_SetCountry( LCFG_TWL_COUNTRY_UNDEFINED );
LCFGi_TSD_WriteSettings();
OS_TPrintf( "Language Change \"%s\" -> \"%s\"\n",
strLanguage[ nowLanguage ], strLanguage[ TSD_GetLanguage() ] );
strLanguage[ nowLanguage ], strLanguage[ LCFG_TSD_GetLanguage() ] );
}
}
@ -257,10 +259,10 @@ static void ReadPrivateKey( void )
if( s_pPrivKeyBuffer ) {
// 秘密鍵が有効なら、署名ありのアクセス
s_pReadSecureInfoFunc = THW_ReadSecureInfo;
s_pReadSecureInfoFunc = LCFGi_THW_ReadSecureInfo;
}else {
// 秘密鍵が無効なら、署名なしのアクセス
s_pReadSecureInfoFunc = THW_ReadSecureInfo_NoCheck;
s_pReadSecureInfoFunc = LCFGi_THW_ReadSecureInfo_NoCheck;
PutStringUTF16( 14 * 8, 0 * 8, TXT_COLOR_RED, (const u16 *)L"[No Signature MODE]" );
}
}
@ -269,11 +271,11 @@ static void ReadPrivateKey( void )
// HW情報全体のリード
static void ReadHWInfoFile( void )
{
TSFReadResult retval;
LCFGReadResult retval;
OSTick start = OS_GetTick();
retval = THW_ReadNormalInfo();
if( retval == TSF_READ_RESULT_SUCCEEDED ) {
retval = LCFGi_THW_ReadNormalInfo();
if( retval == LCFG_TSF_READ_RESULT_SUCCEEDED ) {
OS_TPrintf( "HW Normal Info read succeeded.\n" );
}else {
OS_TPrintf( "HW Normal Info read failed.\n" );
@ -283,7 +285,7 @@ static void ReadHWInfoFile( void )
start = OS_GetTick();
retval = s_pReadSecureInfoFunc();
if( retval == TSF_READ_RESULT_SUCCEEDED ) {
if( retval == LCFG_TSF_READ_RESULT_SUCCEEDED ) {
OS_TPrintf( "HW Secure Info read succeeded.\n" );
}else {
OS_TPrintf( "HW Secure Info read failed.\n" );
@ -326,8 +328,8 @@ static void WriteHWInfoFile( u8 region )
MSG_X * 8 , MSG_Y * 8, ( 32 - MSG_X ) * 8, ( MSG_Y + 4 ) * 8 );
PrintfSJISSub( 2 * 8, 18 * 8, TXT_COLOR_WHITE, "Region = %s", strRegion[ s_region_old ] );
PrintfSJISSub( 2 * 8, 18 * 8, TXT_COLOR_BLACK, "Region = %s", strRegion[ THW_GetRegion() ] );
s_region_old = THW_GetRegion();
PrintfSJISSub( 2 * 8, 18 * 8, TXT_COLOR_BLACK, "Region = %s", strRegion[ LCFG_THW_GetRegion() ] );
s_region_old = LCFG_THW_GetRegion();
}
@ -335,17 +337,17 @@ static void WriteHWInfoFile( u8 region )
static BOOL WriteHWNormalInfoFile( void )
{
BOOL isWrite = TRUE;
TSFReadResult result;
LCFGReadResult result;
result = THW_ReadNormalInfo();
if( result != TSF_READ_RESULT_SUCCEEDED ) {
if( !THW_RecoveryNormalInfo( result ) ) {
result = LCFGi_THW_ReadNormalInfo();
if( result != LCFG_TSF_READ_RESULT_SUCCEEDED ) {
if( !LCFGi_THW_RecoveryNormalInfo( result ) ) {
OS_TPrintf( "HW Normal Info Recovery failed.\n" );
isWrite = FALSE;
}
}
if( isWrite &&
!THW_WriteNormalInfo() ) {
!LCFGi_THW_WriteNormalInfo() ) {
OS_TPrintf( "HW Normal Info Write failed.\n" );
}
@ -357,24 +359,24 @@ static BOOL WriteHWNormalInfoFile( void )
static BOOL WriteHWSecureInfoFile( u8 region )
{
BOOL isWrite = TRUE;
TSFReadResult result;
LCFGReadResult result;
// ファイルのリード
result = s_pReadSecureInfoFunc();
// リードに失敗したらリカバリ
if( result != TSF_READ_RESULT_SUCCEEDED ) {
if( !THW_RecoverySecureInfo( result ) ) {
if( result != LCFG_TSF_READ_RESULT_SUCCEEDED ) {
if( !LCFGi_THW_RecoverySecureInfo( result ) ) {
OS_TPrintf( "HW Secure Info Recovery failed.\n" );
isWrite = FALSE;
}
}
// リージョンのセット
THW_SetRegion( region );
LCFG_THW_SetRegion( region );
// 対応言語ビットマップのセット
THW_SetValidLanguageBitmap( s_langBitmapList[ region ] );
LCFG_THW_SetValidLanguageBitmap( s_langBitmapList[ region ] );
// [TODO:]量産工程でないとシリアルNo.は用意できないので、ここではMACアドレスをもとに適当な値をセットする。
// シリアルNo.のセット
@ -382,8 +384,8 @@ static BOOL WriteHWSecureInfoFile( u8 region )
u8 buffer[ 12 ] = "SERIAL"; // 適当な文字列をMACアドレスと結合してSHA1を取り、仮SerialNoとする。
u8 serialNo[ SVC_SHA1_DIGEST_SIZE ];
int i;
int len = ( THW_GetRegion() == TWL_REGION_AMERICA ) ?
TWL_HWINFO_SERIALNO_LEN_AMERICA : TWL_HWINFO_SERIALNO_LEN_OTHERS;
int len = ( LCFG_THW_GetRegion() == LCFG_TWL_REGION_AMERICA ) ?
LCFG_TWL_HWINFO_SERIALNO_LEN_AMERICA : LCFG_TWL_HWINFO_SERIALNO_LEN_OTHERS;
OS_GetMacAddress( buffer + 6 );
SVC_CalcSHA1( serialNo, buffer, sizeof(buffer) );
for( i = 3; i < SVC_SHA1_DIGEST_SIZE; i++ ) {
@ -392,12 +394,12 @@ static BOOL WriteHWSecureInfoFile( u8 region )
MI_CpuCopy8( "SRN", serialNo, 3 );
MI_CpuClear8( &serialNo[ len ], sizeof(serialNo) - len );
OS_TPrintf( "serialNo : %s\n", serialNo );
THW_SetSerialNo( serialNo );
LCFG_THW_SetSerialNo( serialNo );
}
// ライト
if( isWrite &&
!THW_WriteSecureInfo( s_pPrivKeyBuffer ) ) {
!LCFGi_THW_WriteSecureInfo( s_pPrivKeyBuffer ) ) {
isWrite = FALSE;
OS_TPrintf( "HW Secure Info Write failed.\n" );
}
@ -416,21 +418,21 @@ static void DeleteHWInfoFile( void )
// ノーマルファイル
(void)PutStringUTF16( MSG_X * 8, MSG_Y * 8, TXT_COLOR_BLACK, pMsgNormalDeleting );
if( FS_DeleteFile( (char *)TWL_HWINFO_NORMAL_PATH ) ) {
OS_TPrintf( "%s delete succeeded.\n", (char *)TWL_HWINFO_NORMAL_PATH );
if( FS_DeleteFile( (char *)LCFG_TWL_HWINFO_NORMAL_PATH ) ) {
OS_TPrintf( "%s delete succeeded.\n", (char *)LCFG_TWL_HWINFO_NORMAL_PATH );
(void)PutStringUTF16( ( MSG_X + 19 ) * 8, MSG_Y * 8, TXT_COLOR_BLUE, pMsgSucceeded );
}else {
OS_TPrintf( "%s delete failed.\n", (char *)TWL_HWINFO_NORMAL_PATH );
OS_TPrintf( "%s delete failed.\n", (char *)LCFG_TWL_HWINFO_NORMAL_PATH );
(void)PutStringUTF16( ( MSG_X + 19 ) * 8, MSG_Y * 8, TXT_COLOR_RED, pMsgFailed );
}
// セキュアファイル
(void)PutStringUTF16( MSG_X * 8, ( MSG_Y + 2 ) * 8, TXT_COLOR_BLACK, pMsgSecureDeleting );
if( FS_DeleteFile( (char *)TWL_HWINFO_SECURE_PATH ) ) {
OS_TPrintf( "%s delete succeeded.\n", (char *)TWL_HWINFO_SECURE_PATH );
if( FS_DeleteFile( (char *)LCFG_TWL_HWINFO_SECURE_PATH ) ) {
OS_TPrintf( "%s delete succeeded.\n", (char *)LCFG_TWL_HWINFO_SECURE_PATH );
(void)PutStringUTF16( ( MSG_X + 19 ) * 8, ( MSG_Y + 2 ) * 8, TXT_COLOR_BLUE, pMsgSucceeded );
}else {
OS_TPrintf( "%s delete failed.\n", (char *)TWL_HWINFO_SECURE_PATH );
OS_TPrintf( "%s delete failed.\n", (char *)LCFG_TWL_HWINFO_SECURE_PATH );
(void)PutStringUTF16( ( MSG_X + 19 ) * 8, ( MSG_Y + 2 ) * 8, TXT_COLOR_RED, pMsgFailed );
}
DispMessage( 0, 0, TXT_COLOR_NULL, NULL );
@ -442,12 +444,12 @@ static void DeleteHWInfoFile( void )
// HWInfoファイルのベリファイ
static void VerifyHWInfo( void )
{
if( VerifyData( (const u8 *)THW_GetNormalInfo(), (const u8 *)THW_GetDefaultNormalInfo(), sizeof(TWLHWNormalInfo) ) ) {
if( VerifyData( (const u8 *)LCFG_THW_GetNormalInfo(), (const u8 *)LCFG_THW_GetDefaultNormalInfo(), sizeof(LCFGTWLHWNormalInfo) ) ) {
OS_TPrintf( "HW normal Info verify succeeded.\n" );
}else {
OS_TPrintf( "HW normal Info verify failed.\n" );
}
if( VerifyData( (const u8 *)THW_GetSecureInfo(), (const u8 *)THW_GetDefaultSecureInfo(), sizeof(TWLHWSecureInfo) ) ) {
if( VerifyData( (const u8 *)LCFG_THW_GetSecureInfo(), (const u8 *)LCFG_THW_GetDefaultSecureInfo(), sizeof(LCFGTWLHWSecureInfo) ) ) {
OS_TPrintf( "HW secure Info verify succeeded.\n" );
}else {
OS_TPrintf( "HW secure Info verify failed.\n" );

7
build/systemMenu_RED/Launcher/ARM9/Makefile
View File

@ -17,11 +17,10 @@
#----------------------------------------------------------------------------
SUBDIRS = \
../../../libraries_sysmenu/hotsw \
../../../libraries_sysmenu/sysmenu \
../../../components/hyena.TWL
# ../../../libraries_sysmenu/hotsw \
# ../../../libraries_sysmenu/sysmenu \
# ../../../components/hyena.TWL
# ../../../libraries_sysmenu/reloc_info \
# ../../../libraries_sysmenu/settings \
# ../../../libraries_sysmenu/boot \
#----------------------------------------------------------------------------

14
build/systemMenu_RED/Launcher/ARM9/src/launcher.c
View File

@ -317,7 +317,7 @@ static void BannerDraw(int cursor, int selected, TitleProperty *titleprop)
// アプリ名表示
if(selected != old_selected)
{
NNSG2dChar *str = ((TWLBannerFile *)titleprop[selected].pBanner)->v1.comment[ TSD_GetLanguage() ];
NNSG2dChar *str = ((TWLBannerFile *)titleprop[selected].pBanner)->v1.comment[ LCFG_TSD_GetLanguage() ];
NNSG2dTextRect rect = NNS_G2dTextCanvasGetTextRect( &gTextCanvas, str );
NNS_G2dCharCanvasClearArea( &gCanvas, TXT_COLOR_NULL, 0, 24, WINDOW_WIDTH, 32 );
PutStringUTF16( (WINDOW_WIDTH-rect.width)>>1, TITLE_V_CENTER - (rect.height>>1), TXT_COLOR_BLACK, str );
@ -343,7 +343,7 @@ void LauncherInit( TitleProperty *pTitleList )
GX_DispOff();
GXS_DispOff();
ChangeUserColor( TSD_GetUserColor() );
ChangeUserColor( LCFG_TSD_GetUserColor() );
NNS_G2dCharCanvasClear( &gCanvas, TXT_COLOR_NULL );
// BGデータのロード処理
@ -485,17 +485,17 @@ static void ProcessBackLightPads( void )
}
if( (pad.trg & PAD_BUTTON_START) || up_bl_trg ) {
brightness = TSD_GetBacklightBrightness() + 1;
if( brightness > TWL_BACKLIGHT_LEVEL_MAX ) {
brightness = LCFG_TSD_GetBacklightBrightness() + 1;
if( brightness > LCFG_TWL_BACKLIGHT_LEVEL_MAX ) {
brightness = 0;
}
SYSM_SetBackLightBrightness( (u8)brightness );
DrawBackLightSwitch();
}
if( ( pad.trg & PAD_BUTTON_SELECT) || dw_bl_trg ) {
brightness = TSD_GetBacklightBrightness() - 1;
brightness = LCFG_TSD_GetBacklightBrightness() - 1;
if( brightness < 0 ) {
brightness = TWL_BACKLIGHT_LEVEL_MAX;
brightness = LCFG_TWL_BACKLIGHT_LEVEL_MAX;
}
SYSM_SetBackLightBrightness( (u8)brightness );
DrawBackLightSwitch();
@ -692,5 +692,5 @@ static void DrawBackLightSwitch(void)
PutStringUTF16( B_LIGHT_DW_BUTTON_TOP_X, B_LIGHT_DW_BUTTON_TOP_Y, TXT_COLOR_RED,
L"\xE01c\xE01b" );
PrintfSJIS( B_LIGHT_DW_BUTTON_TOP_X + 24, B_LIGHT_DW_BUTTON_TOP_Y, TXT_COLOR_RED,
"BL:%d\n", TSD_GetBacklightBrightness() );
"BL:%d\n", LCFG_TSD_GetBacklightBrightness() );
}

14
build/systemMenu_RED/MachineSettings/ARM9/src/CountryNameMappingData.c
View File

@ -291,12 +291,12 @@ const u16 *const s_pStrCountryName[] = {
(const u16 *)L"UNKNOWN"
};
const u32 region_country_mapping[TWL_REGION_MAX] =
const u32 region_country_mapping[LCFG_TWL_REGION_MAX] =
{
TWL_COUNTRY_MAPPING_JAPAN,
TWL_COUNTRY_MAPPING_AMERICA,
TWL_COUNTRY_MAPPING_EUROPE,
TWL_COUNTRY_MAPPING_AUSTRALIA,
TWL_COUNTRY_MAPPING_CHINA,
TWL_COUNTRY_MAPPING_KOREA
LCFG_TWL_COUNTRY_MAPPING_JAPAN,
LCFG_TWL_COUNTRY_MAPPING_AMERICA,
LCFG_TWL_COUNTRY_MAPPING_EUROPE,
LCFG_TWL_COUNTRY_MAPPING_AUSTRALIA,
LCFG_TWL_COUNTRY_MAPPING_CHINA,
LCFG_TWL_COUNTRY_MAPPING_KOREA
};

6
build/systemMenu_RED/MachineSettings/ARM9/src/MachineSetting.c
View File

@ -57,7 +57,7 @@ static const u16 *s_pStrSetting[ SETTING_MENU_ELEMENT_NUM ]; //
//===============================================
// mainMenu.c
//===============================================
static const u16 *const s_pStrSettingElemTbl[ SETTING_MENU_ELEMENT_NUM ][ TWL_LANG_CODE_MAX ] = {
static const u16 *const s_pStrSettingElemTbl[ SETTING_MENU_ELEMENT_NUM ][ LCFG_TWL_LANG_CODE_MAX ] = {
{
(const u16 *)L"言語",
(const u16 *)L"LANGUAGE",
@ -167,10 +167,10 @@ void MachineSettingInit( void )
// NITRO設定データのlanguageに応じたメインメニュー構成言語の切り替え
for( i = 0; i < SETTING_MENU_ELEMENT_NUM; i++ ) {
s_pStrSetting[ i ] = s_pStrSettingElemTbl[ i ][ TSD_GetLanguage() ];
s_pStrSetting[ i ] = s_pStrSettingElemTbl[ i ][ LCFG_TSD_GetLanguage() ];
}
ChangeUserColor( TSD_GetUserColor() );
ChangeUserColor( LCFG_TSD_GetUserColor() );
DrawMenu( s_csr, &s_settingParam );
SVC_CpuClear( 0x0000, &tpd, sizeof(TpWork), 16 );

10
build/systemMenu_RED/MachineSettings/ARM9/src/calibrationTP.c
View File

@ -70,7 +70,7 @@ typedef struct CalibWork {
u16 last_x;
u16 last_y;
TPData sample[2];
TWLTPCalibData calibTemp;
LCFGTWLTPCalibData calibTemp;
}CalibWork;
// extern data------------------------------------------
@ -417,12 +417,12 @@ int TP_CalibrationMain( void )
s_pTPC->calibTemp.data.dx2 = DISP_X_SIZE - 32;
s_pTPC->calibTemp.data.dy2 = DISP_Y_SIZE - 32;
TSD_SetTPCalibration( &s_pTPC->calibTemp );
TSD_SetFlagTP( TRUE ); // タッチパネル入力フラグを立てる。
LCFG_TSD_SetTPCalibration( &s_pTPC->calibTemp );
LCFG_TSD_SetFlagTP( TRUE ); // タッチパネル入力フラグを立てる。
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();
(void)LCFG_WriteTWLSettingsFile();
ReturnMenu();
return 0;
@ -442,7 +442,7 @@ int TP_CalibrationMain( void )
// キャリブレーションを設定前の状態に戻す。
{
TPCalibrateParam calibrate;
TSD_GetTPCalibration( &s_pTPC->calibTemp );
LCFG_TSD_GetTPCalibration( &s_pTPC->calibTemp );
(void)TP_CalcCalibrateParam(
&calibrate,
s_pTPC->calibTemp.data.raw_x1, s_pTPC->calibTemp.data.raw_y1, (u16)s_pTPC->calibTemp.data.dx1, (u16)s_pTPC->calibTemp.data.dy1,

4
build/systemMenu_RED/MachineSettings/ARM9/src/main.c
View File

@ -76,8 +76,8 @@ void TwlMain(void)
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルの読み込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)THW_ReadSecureInfo();
g_isValidTSD = SYSM_ReadTWLSettingsFile();
(void)LCFG_ReadHWSecureInfo();
g_isValidTSD = LCFG_ReadTWLSettingsFile();
if( g_isValidTSD ) {
SYSM_CaribrateTP();
}

28
build/systemMenu_RED/MachineSettings/ARM9/src/selectCountry.c
View File

@ -50,8 +50,8 @@
// global variable -------------------------------------
// static variable -------------------------------------
static TWLCountryCode s_countryCode; // 国コード
static TWLRegion s_regionCode; // リージョン
static LCFGTWLCountryCode s_countryCode; // 国コード
static LCFGTWLRegion s_regionCode; // リージョン
static u16 s_list_start, s_list_end;
static u16 s_menu_display_start;
@ -64,7 +64,7 @@ static double s_dots_per_item;
// const data -----------------------------------------
extern const u16 *const s_pStrCountryName[];
extern const u32 region_country_mapping[TWL_REGION_MAX];
extern const u32 region_country_mapping[LCFG_TWL_REGION_MAX];
static MenuPos s_countryPos[MENU_DISPLAY_SIZE] = {
{ TRUE, 4 * 8, 6 * 8 },
@ -106,7 +106,7 @@ static void InitScrollMenuList( void )
// 設定されていた国名コードがリスト範囲に入っていなければデフォルト値にする
if(s_countryCode < s_list_start || s_list_end < s_countryCode)
{
s_countryCode = (TWLCountryCode)s_list_start;
s_countryCode = (LCFGTWLCountryCode)s_list_start;
}
// 実際に表示する範囲の調整
@ -148,13 +148,13 @@ void SelectCountryInit( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// 設定済みリージョンと国名コードの取得
s_regionCode = (TWLRegion)THW_GetRegion();
s_regionCode = (LCFGTWLRegion)LCFG_THW_GetRegion();
if( !g_isValidTSD ||
( TSD_GetCountry() >= TWL_COUNTRY_MAX ) ) {
s_countryCode = (TWLCountryCode)0;
( LCFG_TSD_GetCountry() >= LCFG_TWL_COUNTRY_MAX ) ) {
s_countryCode = (LCFGTWLCountryCode)0;
}else {
s_countryCode = TSD_GetCountry();
s_countryCode = LCFG_TSD_GetCountry();
}
// スクロールメニューの初期化
@ -259,8 +259,8 @@ static void MoveCursorByScrollBar( void )
// タッチパッドによるスクロール後、表示される項目の調整
if( s_menu_display_start + countrySel.num - 1 > s_list_end ) s_menu_display_start = (u16)(s_list_end - countrySel.num + 1);
if( s_menu_display_start < s_list_start ) s_menu_display_start = s_list_start;
if( s_countryCode < s_menu_display_start ) s_countryCode = (TWLCountryCode)s_menu_display_start;
else if( s_menu_display_start + countrySel.num - 1 < s_countryCode ) s_countryCode = (TWLCountryCode)(s_menu_display_start + countrySel.num - 1);
if( s_countryCode < s_menu_display_start ) s_countryCode = (LCFGTWLCountryCode)s_menu_display_start;
else if( s_menu_display_start + countrySel.num - 1 < s_countryCode ) s_countryCode = (LCFGTWLCountryCode)(s_menu_display_start + countrySel.num - 1);
}
// 国選択画面の描画処理
@ -306,7 +306,7 @@ int SelectCountryMain( void )
// タッチパッドによるメニュー項目の選択
selecteditem = (u16)(s_countryCode - s_menu_display_start);
tp_select = SelectMenuByTP( (u16 *)&selecteditem, &countrySel );
s_countryCode = (TWLCountryCode)(s_menu_display_start + selecteditem);
s_countryCode = (LCFGTWLCountryCode)(s_menu_display_start + selecteditem);
// 描画
DrawCountryMain();
@ -318,12 +318,12 @@ int SelectCountryMain( void )
}
if( ( pad.trg & PAD_BUTTON_A ) || tp_select ) { // メニュー項目への分岐
TSD_SetCountry( s_countryCode ); // 国コード設定
TSD_SetFlagCountry( TRUE ); // 国コード入力フラグを立てる
LCFG_TSD_SetCountry( s_countryCode ); // 国コード設定
LCFG_TSD_SetFlagCountry( TRUE ); // 国コード入力フラグを立てる
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();
(void)LCFG_WriteTWLSettingsFile();
MachineSettingInit();
return 0;

48
build/systemMenu_RED/MachineSettings/ARM9/src/selectLanguage.c
View File

@ -33,23 +33,23 @@
// static variable -------------------------------------
static int s_lang; // 言語選択肢の何番目を選択しているか
static TWLRegion s_regionCode; // リージョンコード
static LCFGTWLRegion s_regionCode; // リージョンコード
static const u16* s_pStrLanguage[TWL_LANG_CODE_MAX];
static TWLLangCode s_langCodeList[TWL_LANG_CODE_MAX];
static const u16* s_pStrLanguage[LCFG_TWL_LANG_CODE_MAX];
static LCFGTWLLangCode s_langCodeList[LCFG_TWL_LANG_CODE_MAX];
// const data -----------------------------------------
static const u16 region_lang_Mapping[TWL_REGION_MAX] =
static const u16 region_lang_Mapping[LCFG_TWL_REGION_MAX] =
{
TWL_LANG_BITMAP_JAPAN,
TWL_LANG_BITMAP_AMERICA,
TWL_LANG_BITMAP_EUROPE,
TWL_LANG_BITMAP_AUSTRALIA,
TWL_LANG_BITMAP_CHINA,
TWL_LANG_BITMAP_KOREA
LCFG_TWL_LANG_BITMAP_JAPAN,
LCFG_TWL_LANG_BITMAP_AMERICA,
LCFG_TWL_LANG_BITMAP_EUROPE,
LCFG_TWL_LANG_BITMAP_AUSTRALIA,
LCFG_TWL_LANG_BITMAP_CHINA,
LCFG_TWL_LANG_BITMAP_KOREA
};
static const u16 *const s_pStrLanguageData[TWL_LANG_CODE_MAX] = {
static const u16 *const s_pStrLanguageData[LCFG_TWL_LANG_CODE_MAX] = {
(const u16 *)L"日本語",
(const u16 *)L"English ",
(const u16 *)L"Francais",
@ -60,7 +60,7 @@ static const u16 *const s_pStrLanguageData[TWL_LANG_CODE_MAX] = {
(const u16 *)L"韓国語（仮）"
};
static MenuPos s_languagePos[TWL_LANG_CODE_MAX] = {
static MenuPos s_languagePos[LCFG_TWL_LANG_CODE_MAX] = {
{ TRUE, 4 * 8, 6 * 8 },
{ TRUE, 4 * 8, 8 * 8 },
{ TRUE, 4 * 8, 10 * 8 },
@ -72,7 +72,7 @@ static MenuPos s_languagePos[TWL_LANG_CODE_MAX] = {
};
static MenuParam langSel = {
TWL_LANG_CODE_MAX,
LCFG_TWL_LANG_CODE_MAX,
TXT_COLOR_BLACK,
TXT_COLOR_GREEN,
TXT_COLOR_RED,
@ -107,24 +107,24 @@ void SelectLanguageInit( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// リージョンの取得
s_regionCode = (TWLRegion)THW_GetRegion();
s_regionCode = (LCFGTWLRegion)LCFG_THW_GetRegion();
// 言語の取得
if( !g_isValidTSD ||
( TSD_GetLanguage() >= TWL_LANG_CODE_MAX ) ) {
temp_langCode = TWL_LANG_ENGLISH;
( LCFG_TSD_GetLanguage() >= LCFG_TWL_LANG_CODE_MAX ) ) {
temp_langCode = LCFG_TWL_LANG_ENGLISH;
}else {
temp_langCode = TSD_GetLanguage();
temp_langCode = LCFG_TSD_GetLanguage();
}
// リージョン-言語マッピング情報から、現在のリージョンで選択できる言語をリストアップ
s_lang = 0;
for(l=0; l<TWL_LANG_CODE_MAX; l++)
for(l=0; l<LCFG_TWL_LANG_CODE_MAX; l++)
{
if( ( 0x0001 << l ) & region_lang_Mapping[s_regionCode] )
{
s_pStrLanguage[lang_count] = s_pStrLanguageData[l];
s_langCodeList[lang_count] = (TWLLangCode)l;
s_langCodeList[lang_count] = (LCFGTWLLangCode)l;
if(temp_langCode == l)
{
s_lang = lang_count;
@ -158,12 +158,12 @@ int SelectLanguageMain( void )
//--------------------------------------
if( pad.trg & PAD_KEY_DOWN ) { // カーソルの移動
if( ++s_lang == langSel.num ) {
s_lang = (TWLLangCode)0;
s_lang = (LCFGTWLLangCode)0;
}
}
if( pad.trg & PAD_KEY_UP ) {
if( --s_lang < 0 ) {
s_lang = (TWLLangCode)( langSel.num - 1 );
s_lang = (LCFGTWLLangCode)( langSel.num - 1 );
}
}
tp_select = SelectMenuByTP( (u16 *)&s_lang, &langSel );
@ -176,12 +176,12 @@ int SelectLanguageMain( void )
}
if( ( pad.trg & PAD_BUTTON_A ) || tp_select ) { // メニュー項目への分岐
TSD_SetLanguage( s_langCodeList[s_lang] );
TSD_SetFlagLanguage( TRUE ); // 言語入力フラグを立てる
LCFG_TSD_SetLanguage( s_langCodeList[s_lang] );
LCFG_TSD_SetFlagLanguage( TRUE ); // 言語入力フラグを立てる
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();
(void)LCFG_WriteTWLSettingsFile();
MachineSettingInit();
return 0;

68
build/systemMenu_RED/MachineSettings/ARM9/src/setOwnerInfo.c
View File

@ -97,16 +97,16 @@ static int s_char_mode = 0;
static u16 s_key_csr = 0;
static u8 s_color_csr = 0;
static BOOL s_birth_csr = FALSE;
static TWLDate s_temp_birthday;
static u16 s_temp_name[ TWL_NICKNAME_LENGTH + 1 ];
static u16 s_temp_comment[ TWL_COMMENT_LENGTH + 1 ];
static LCFGTWLDate s_temp_birthday;
static u16 s_temp_name[ LCFG_TWL_NICKNAME_LENGTH + 1 ];
static u16 s_temp_comment[ LCFG_TWL_COMMENT_LENGTH + 1 ];
static u8 s_temp_name_length;
static u8 s_temp_comment_length;
// const data-----------------------------------
static const u16 char_tbl[CHAR_LIST_MODE_NUM][CHAR_LIST_CHAR_NUM];
static const u16 *const s_pStrSettingElemTbl[ USER_INFO_MENU_ELEMENT_NUM ][ TWL_LANG_CODE_MAX ] = {
static const u16 *const s_pStrSettingElemTbl[ USER_INFO_MENU_ELEMENT_NUM ][ LCFG_TWL_LANG_CODE_MAX ] = {
{
(const u16 *)L"ユーザーネーム",
(const u16 *)L"NICKNAME",
@ -221,7 +221,7 @@ static BOOL SelectOKFunc( u16 *csr, TPData *tgt )
static void DrawOwnerInfoMenuScene( void )
{
u16 tempbuf[TWL_COMMENT_LENGTH+2];
u16 tempbuf[LCFG_TWL_COMMENT_LENGTH+2];
u8 color;
NNS_G2dCharCanvasClear( &gCanvas, TXT_COLOR_NULL );
PutStringUTF16( 0, 0, TXT_COLOR_BLUE, (const u16 *)L"USER INFORMATION" );
@ -232,17 +232,17 @@ static void DrawOwnerInfoMenuScene( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得して表示
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// ニックネーム
PutStringUTF16( 128 , 8*8, TXT_UCOLOR_G0, TSD_GetNicknamePtr() );
PutStringUTF16( 128 , 8*8, TXT_UCOLOR_G0, LCFG_TSD_GetNicknamePtr() );
// 誕生日
PrintfSJIS( 128, 10*8, TXT_UCOLOR_G0, "%d／%d", TSD_GetBirthdayPtr()->month, TSD_GetBirthdayPtr()->day);
PrintfSJIS( 128, 10*8, TXT_UCOLOR_G0, "%d／%d", LCFG_TSD_GetBirthdayPtr()->month, LCFG_TSD_GetBirthdayPtr()->day);
// カラー
color = TSD_GetUserColor();
color = LCFG_TSD_GetUserColor();
PutStringUTF16( 128 , 12*8, TXT_UCOLOR_G0, L"■" );
// コメント
SVC_CpuCopy( TSD_GetCommentPtr(), tempbuf, 13 * 2, 16 );
SVC_CpuCopy( LCFG_TSD_GetCommentPtr(), tempbuf, 13 * 2, 16 );
*(tempbuf+13)='\n';
SVC_CpuCopy( TSD_GetCommentPtr()+13, tempbuf+14, 13 * 2, 16 );
*(tempbuf+TWL_COMMENT_LENGTH+1)=0;
SVC_CpuCopy( LCFG_TSD_GetCommentPtr()+13, tempbuf+14, 13 * 2, 16 );
*(tempbuf+LCFG_TWL_COMMENT_LENGTH+1)=0;
PutStringUTF16( 128-78 , 16*8 , TXT_UCOLOR_G0, tempbuf );
}
@ -253,7 +253,7 @@ void SetOwnerInfoInit( void )
// NITRO設定データのlanguageに応じたメインメニュー構成言語の切り替え
for( i = 0; i < USER_INFO_MENU_ELEMENT_NUM; i++ ) {
s_pStrSetting[ i ] = s_pStrSettingElemTbl[ i ][ TSD_GetLanguage() ];
s_pStrSetting[ i ] = s_pStrSettingElemTbl[ i ][ LCFG_TSD_GetLanguage() ];
}
// BGデータのロード処理
@ -391,13 +391,13 @@ static void PushKeys( u16 code, NameOrComment noc )
{
buf = s_temp_name;
length = &s_temp_name_length;
max_length = TWL_NICKNAME_LENGTH;
setflag = TSD_SetFlagNickname;
max_length = LCFG_TWL_NICKNAME_LENGTH;
setflag = LCFG_TSD_SetFlagNickname;
}else if(noc == NOC_COMMENT)
{
buf = s_temp_comment;
length = &s_temp_comment_length;
max_length = TWL_COMMENT_LENGTH;
max_length = LCFG_TWL_COMMENT_LENGTH;
// setflag = TSD_SetFlagComment;
setflag = NULL;
}else
@ -425,14 +425,14 @@ static void PushKeys( u16 code, NameOrComment noc )
if(setflag) setflag(TRUE);// 設定完了フラグを立てておく
SVC_CpuClear(0, buf + *length, (max_length - *length) * 2, 16);// ゼロクリア
if(noc == NOC_NAME) {
TSD_SetNickname( buf );
LCFG_TSD_SetNickname( buf );
}else if(noc == NOC_COMMENT) {
TSD_SetComment( buf );
LCFG_TSD_SetComment( buf );
}
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();// ファイルへ書き込み
(void)LCFG_WriteTWLSettingsFile();// ファイルへ書き込み
// セーブ後にキャンセル処理と合流
case CANCEL_BUTTON_:
SetOwnerInfoInit();
@ -580,11 +580,11 @@ static void SetNicknameInit( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// ニックネーム用テンポラリバッファの初期化
TSD_GetNickname( s_temp_name );
LCFG_TSD_GetNickname( s_temp_name );
s_temp_name_length = MY_StrLen( s_temp_name );
if( s_temp_name_length < TWL_NICKNAME_LENGTH ) {
if( s_temp_name_length < LCFG_TWL_NICKNAME_LENGTH ) {
SVC_CpuClear(CHAR_USCORE, &s_temp_name[ s_temp_name_length ],
( TWL_NICKNAME_LENGTH - s_temp_name_length ) * 2, 16);
( LCFG_TWL_NICKNAME_LENGTH - s_temp_name_length ) * 2, 16);
}
DrawSetNicknameScene();
@ -651,7 +651,7 @@ static void SetBirthdayInit( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// 誕生日
TSD_GetBirthday( &s_temp_birthday );
LCFG_TSD_GetBirthday( &s_temp_birthday );
// BGデータのロード処理
GX_LoadBG1Char(bg_char_data, 0, sizeof(bg_char_data));
@ -763,12 +763,12 @@ static int SetBirthdayMain( void )
DrawSetBirthdayScene();
if( pad.trg & PAD_BUTTON_A || (tp_touch && temp_ok_cancel == KEY_OK) ) {
TSD_SetBirthday(&s_temp_birthday);
TSD_SetFlagBirthday( TRUE );
LCFG_TSD_SetBirthday(&s_temp_birthday);
LCFG_TSD_SetFlagBirthday( TRUE );
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();// ファイルへ書き込み
(void)LCFG_WriteTWLSettingsFile();// ファイルへ書き込み
SetOwnerInfoInit();
g_pNowProcess = SetOwnerInfoMain;
return 0;
@ -842,7 +842,7 @@ static void SetUserColorInit( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// ユーザーカラー
s_color_csr = TSD_GetUserColor();
s_color_csr = LCFG_TSD_GetUserColor();
GX_SetVisiblePlane ( GX_PLANEMASK_BG0 | GX_PLANEMASK_BG1);
GXS_SetVisiblePlane( GX_PLANEMASK_BG0 );
@ -885,16 +885,16 @@ static int SetUserColorMain( void )
}
if( ( pad.trg & PAD_BUTTON_A ) || (tp_touch && temp_csr == KEY_OK) ) { // 色決定
TSD_SetUserColor( (u8 )s_color_csr );
LCFG_TSD_SetUserColor( (u8 )s_color_csr );
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();// ファイルへ書き込み
(void)LCFG_WriteTWLSettingsFile();// ファイルへ書き込み
SetOwnerInfoInit();
g_pNowProcess = SetOwnerInfoMain;
return 0;
}else if( ( pad.trg & PAD_BUTTON_B ) || (tp_touch && temp_csr == KEY_CANCEL) ) {
ChangeUserColor( TSD_GetUserColor() ); // パレット色を元にもどす
ChangeUserColor( LCFG_TSD_GetUserColor() ); // パレット色を元にもどす
SetOwnerInfoInit();
g_pNowProcess = SetOwnerInfoMain;
return 0;
@ -909,13 +909,13 @@ static int SetUserColorMain( void )
// コメント編集画面の描画処理
static void DrawSetCommentScene( void )
{
u16 tempbuf[TWL_COMMENT_LENGTH+2];
u16 tempbuf[LCFG_TWL_COMMENT_LENGTH+2];
NNS_G2dCharCanvasClear( &gCanvas, TXT_COLOR_NULL );
PutStringUTF16( 0, 0, TXT_COLOR_BLUE, (const u16 *)L"COMMENT" );
SVC_CpuCopy( s_temp_comment, tempbuf, 13 * 2, 16 );
*(tempbuf+13)='\n';
SVC_CpuCopy( s_temp_comment+13, tempbuf+14, 13 * 2, 16 );
*(tempbuf+TWL_COMMENT_LENGTH+1)=0;
*(tempbuf+LCFG_TWL_COMMENT_LENGTH+1)=0;
PutStringUTF16( 128-78 , 15 , TXT_UCOLOR_G0, tempbuf );
DrawCharKeys();
}
@ -930,11 +930,11 @@ static void SetCommentInit( void )
// あらかじめTWL設定データファイルから読み込み済みの設定を取得
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// コメント用テンポラリバッファの初期化
TSD_GetComment( s_temp_comment );
LCFG_TSD_GetComment( s_temp_comment );
s_temp_comment_length = MY_StrLen( s_temp_comment );
if( s_temp_comment_length < TWL_COMMENT_LENGTH ) {
if( s_temp_comment_length < LCFG_TWL_COMMENT_LENGTH ) {
SVC_CpuClear(CHAR_USCORE, &s_temp_comment[ s_temp_comment_length ],
( TWL_COMMENT_LENGTH - s_temp_comment_length ) * 2, 16);
( LCFG_TWL_COMMENT_LENGTH - s_temp_comment_length ) * 2, 16);
}
DrawSetCommentScene();

14
build/systemMenu_RED/MachineSettings/ARM9/src/setRTC.c
View File

@ -175,7 +175,7 @@ int SetRTCMain( void )
tp_return = WithinRangeTP( RETURN_BUTTON_TOP_X, RETURN_BUTTON_TOP_Y,
RETURN_BUTTON_BOTTOM_X, RETURN_BUTTON_BOTTOM_Y, &tpd.disp );
}
if( g_initialSet && !TSD_IsSetDateTime() ) {
if( g_initialSet && !LCFG_TSD_IsSetDateTime() ) {
tp_set = TRUE;
}
//--------------------------------------
@ -379,11 +379,11 @@ static int InputRtcDateTimeMain( void )
TSD_SetRTCOffset( SYSM_CalcRTCOffset( &date, &s_pWork->dtp.Time ) );
}
TSD_SetFlagDateTime( TRUE ); // RTC入力フラグを立てる。
LCFG_TSD_SetFlagDateTime( TRUE ); // RTC入力フラグを立てる。
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();
(void)LCFG_WriteTWLSettingsFile();
// 上画面の表示更新
GetAndDrawRTCData( &g_rtcDraw, TRUE );
@ -543,11 +543,11 @@ void ClearRTC( void )
RTCDate date = { 0, 1, 1, RTC_WEEK_SUNDAY };
RTCTime time = { 0, 0, 0 };
(void)RTC_SetDateTime( &date, &time );
TSD_SetFlagDateTime( TRUE );
TSD_SetRTCOffset( 0 );
TSD_SetRTCLastSetYear( 0 );
LCFG_TSD_SetFlagDateTime( TRUE );
TSD_SetRTCOffset( 0 ); // [TODO:]SDKの関数名が間違っている
LCFG_TSD_SetRTCLastSetYear( 0 );
// ::::::::::::::::::::::::::::::::::::::::::::::
// TWL設定データファイルへの書き込み
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)SYSM_WriteTWLSettingsFile();
(void)LCFG_WriteTWLSettingsFile();
}

BIN
doc/mb_childメモリマップ.vsd
View File

Binary file not shown.

BIN
doc/開発用各種本体とアプリバイナリ仕様.vsd
View File

Binary file not shown.

3
include/sysmenu.h
View File

@ -26,11 +26,10 @@
#include <twl.h>
#include <twl/os/common/format_rom.h>
#include <twl/hw/common/mmap_parameter.h>
#include <twl/lcfg.h>
#include <sysmenu/sysmenu_lib.h>
#include <sysmenu/banner.h>
#include <sysmenu/boot.h>
#include <sysmenu/settings.h>
#include <sysmenu/memorymap.h>
#include <sysmenu/hotsw.h>
#include <sysmenu/acsign.h>

35
include/sysmenu/settings.h
View File

@ -1,35 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: settings.h
Copyright 2007 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.
$Date:: 2007-09-06$
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#ifndef SYSM_MACHINE_SETTINGS_H_
#define SYSM_MACHINE_SETTINGS_H_
#include <sysmenu/settings/common/TWLStoreFile.h>
#include <sysmenu/settings/common/TWLHWInfo.h>
#include <sysmenu/settings/common/NTRSettings.h>
#include <sysmenu/settings/common/TWLSettings.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
} /* extern "C" */
#endif
/* SYSM_MACHINE_SETTINGS_H_ */
#endif

578
include/sysmenu/settings/common/NTRSettings.h
View File

@ -1,578 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: NTRSettings.c
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#ifndef NTR_SETTINGS_H_
#define NTR_SETTINGS_H_
#if defined(SDK_CW) // NTRConfigDataにビットフィールドを使っているので、コンパイラ依存で不具合が発生する可能性がある。
// よって、CW以外のコンパイラの場合は、このヘッダを無効にしてエラーを出させるようにして再確認する。
#include <twl.h>
#ifdef __cplusplus
extern "C" {
#endif
// define data ------------------------------------
#define NTR_SETTINGS_DATA_VERSION 5 // NTR設定データフォーマットバージョン
#define NTR_SETTINGS_DATA_EX_VERSION 1 // 拡張NTR設定データフォーマットバージョン
#define NTR_NICKNAME_LENGTH 10 // ニックネーム長
#define NTR_NICKNAME_BUFFERSIZE ( NTR_NICKNAME_LENGTH * 2 ) // ニックネームバッファサイズ
#define NTR_COMMENT_LENGTH 26 // コメント長
#define NTR_COMMENT_BUFFERSIZE ( NTR_COMMENT_LENGTH * 2 )
#define NTR_USER_COLOR_MAX_NUM 16 // ユーザーカラーの最大数
// 言語設定コード
typedef enum NTRLangCode{
NTR_LANG_JAPANESE = 0, // 日本語
NTR_LANG_ENGLISH = 1, // 英語
NTR_LANG_FRENCH = 2, // フランス語
NTR_LANG_GERMAN = 3, // ドイツ語
NTR_LANG_ITALIAN = 4, // イタリア語
NTR_LANG_SPANISH = 5, // スペイン語
NTR_LANG_CHINESE = 6, // 中国語
NTR_LANG_KOREAN = 7, // 韓国語
NTR_LANG_CODE_MAX
}NTRLangCode;
#define NTR_LANG_CODE_MAX_WW ( NTR_LANG_SPANISH + 1 )
#define NTR_LANG_BITMAP_WW ( ( 0x0001 << NTR_LANG_JAPANESE ) | \
( 0x0001 << NTR_LANG_ENGLISH ) | \
( 0x0001 << NTR_LANG_FRENCH ) | \
( 0x0001 << NTR_LANG_GERMAN ) | \
( 0x0001 << NTR_LANG_ITALIAN ) | \
( 0x0001 << NTR_LANG_SPANISH ) ) // NTR-IPL2-WW版での対応言語ビットマップ
#define NTR_LANG_BITMAP_CHINA ( ( 0x0001 << NTR_LANG_CHINESE ) | \
( 0x0001 << NTR_LANG_ENGLISH ) | \
( 0x0001 << NTR_LANG_FRENCH ) | \
( 0x0001 << NTR_LANG_GERMAN ) | \
( 0x0001 << NTR_LANG_ITALIAN ) | \
( 0x0001 << NTR_LANG_SPANISH ) ) // NTR-IPL2-CN版での対応言語ビットマップ
#define NTR_LANG_BITMAP_KOREA ( ( 0x0001 << NTR_LANG_KOREAN ) | \
( 0x0001 << NTR_LANG_JAPANESE ) | \
( 0x0001 << NTR_LANG_ENGLISH ) | \
( 0x0001 << NTR_LANG_FRENCH ) | \
( 0x0001 << NTR_LANG_GERMAN ) | \
( 0x0001 << NTR_LANG_SPANISH ) ) // NTR-IPL2-KR版での対応言語ビットマップ
#define NTR_LANG_BITMAP_ALL ( ( 0x0001 << NTR_LANG_JAPANESE ) | \
( 0x0001 << NTR_LANG_ENGLISH ) | \
( 0x0001 << NTR_LANG_FRENCH ) | \
( 0x0001 << NTR_LANG_GERMAN ) | \
( 0x0001 << NTR_LANG_ITALIAN ) | \
( 0x0001 << NTR_LANG_SPANISH ) | \
( 0x0001 << NTR_LANG_CHINESE ) | \
( 0x0001 << NTR_LANG_KOREAN ) ) // NTR-IPL2全体での対応言語ビットマップ
// 日付データ
typedef struct NTRDate{
u8 month; // 月:01～12
u8 day; // 日:01～31
}NTRDate; // 2byte
// ニックネーム
typedef struct NTRNickname{
u16 buffer[ NTR_NICKNAME_LENGTH ]; // ニックネーム（Unicode(UTF16)で最大10文字、終端コードなし）
u8 length; // 文字数
u8 rsv;
}NTRNickname; // 22byte
// コメント
typedef struct NTRComment{
u16 buffer[ NTR_COMMENT_LENGTH ]; //コメント（Unicode(UTF16)で最大26文字、終端コードなし）
u8 length; // 文字数
u8 rsv;
}NTRComment; // 54byte
// オーナー情報
typedef struct NTROwnerInfo{
u8 userColor : 4; // ユーザーカラー
u8 rsv : 4; // 予約。
NTRDate birthday; // 生年月日
u8 pad;
NTRNickname nickname; // ニックネーム
NTRComment comment; // コメント
}NTROwnerInfo; // 80byte
// IPL用目覚まし時計データ
typedef struct NTRAlarm{
u8 hour; // アラーム時:00～23
u8 minute; // アラーム分:00～59
u8 rsv1; // 予約
u8 pad;
u16 alarmOn : 1; // アラームON,OFF（0:OFF, 1:ON）
u16 rsv2 : 15; // 予約
}NTRAlarm; // 6byte
// タッチパネルキャリブレーションデータ
typedef struct NTRTPCalibData{
u16 raw_x1; // 第１キャリブレーション点のTP取得値X
u16 raw_y1; // 　　　　〃　　　　　　　　TP取得値Y
u8 dx1; // 　　　　〃　　　　　　　　LCD座標 X
u8 dy1; // 　　　　〃　　　　　　　　LCD座標 Y
u16 raw_x2; // 第２キャリブレーション点のTP取得値X
u16 raw_y2; // 　　　　〃　　　　　　　　TP取得値Y
u8 dx2; // 　　　　〃　　　　　　　　LCD座標 X
u8 dy2; // 　　　　〃　　　　　　　　LCD座標 Y
}NTRTPCalibData; // 12byte
// オプション情報
typedef struct NTROption{
u16 language : 3; // 言語コード（NTR_LANG_SPANISHまでの標準言語コードが入る）
u16 isGBUseTopLCD : 1; // AGBモードで起動する時にどちらのLCDで起動するか？（0:TOP,1:BOTTOM）
u16 backlightBrightness : 2; // バックライト輝度データ
u16 isAutoBoot : 1; // 起動シーケンスで、メニュー停止なしで自動起動するかどうか？(0:OFF, 1:ON)
u16 isBacklightOff : 1; // バックライトON,OFFフラグ（0:ON, 1:OFF）
u16 rsv2 : 1; // 予約
u16 initialSequence : 1; // 初回起動シーケンス中フラグ
u16 isSetBirthday : 1; // 誕生日が入力されたか？
u16 isSetUserColor : 1; // ユーザーカラーが入力されたか？
u16 isSetTP : 1; // タッチパネルがキャリブレーションされたか？（ 〃 )
u16 isSetLanguage : 1; // 言語入力がされたか？　 (0:未設定, 1:設定済み)
u16 isSetDateTime : 1; // 日付・時刻設定がされたか？ ( 〃　　　　　 )
u16 isSetNickname : 1; // ニックネームが入力されたか？ ( 〃　　　　　 )
u8 rtcLastSetYear; // RTCの前回設定年
u8 rtcClockAdjust; // RTCクロック調整値
s64 rtcOffset; // RTC設定時のオフセット値（ユーザーがRTC設定を変更する度にその値に応じて増減します。）
}NTROption; // 12byte
// NTR各種設定データ
typedef struct NTRSettingsData{
u8 version; // フラッシュ格納データフォーマットのバージョン
u8 pad;
NTROwnerInfo owner; // オーナー情報
NTRAlarm alarm; // IPL用目覚まし時計データ
NTRTPCalibData tp; // タッチパネルキャリブレーションデータ
NTROption option; // オプション
}NTRSettingsData; // 112byte
// 拡張NTR設定データ
typedef struct NTRSettingsDataEx{
u8 version; // バージョン
u8 language; // 言語コード（NTR_LANG_CHINESE以降に拡張された値が入る。）
u16 valid_language_bitmap; // 本IPL2で有効な言語コードを示したビットマップ
u8 pad[ 256 - sizeof(NTRSettingsData) - 4 - 4 - 2 ]; // 4:saveCount+crc16, 2:NSDEx.version+NSDEx.language, 2:crc16_ex
}NTRSettingsDataEx; // 138bytes
#ifdef SDK_ARM9
//=========================================================
// NVRAMへのリードライト関数
//=========================================================
extern void NSD_ClearSettings( void );
extern BOOL NSD_IsReadSettings( void );
extern BOOL NSD_ReadSettings( u32 validLangBitmap );
extern BOOL NSD_WriteSettings( void ); // 先にNSD_ReadSettingsを実行しておく必要がある。
//=========================================================
// グローバル変数
//=========================================================
extern NTRSettingsData *g_pNSD;
extern NTRSettingsDataEx *g_pNSDEx;
#define GetNSD() ( g_pNSD )
#define GetNSDEx() ( g_pNSDEx )
//=========================================================
// データ取得（NSD_ReadSettingsで内部ワークに読み出した情報の取得）
//=========================================================
// バージョンの取得。
static inline u8 NSD_GetVersion( void )
{
return (u8)GetNSD()->version;
}
// EXバージョンの取得。
static inline u8 NSD_GetExVersion( void )
{
return (u8)GetNSDEx()->version;
}
// オーナー情報全体へのポインタの取得。
static inline NTROwnerInfo *NSD_GetOwnerInfoPtr( void )
{
return &GetNSD()->owner;
}
// オーナー情報全体の取得。
static inline void NSD_GetOwnerInfo( NTROwnerInfo *pDst )
{
MI_CpuCopy8( &GetNSD()->owner, pDst, sizeof(NTROwnerInfo) );
}
// ユーザーカラーの取得。
static inline u8 NSD_GetUserColor( void )
{
return (u8)GetNSD()->owner.userColor;
}
// 誕生日へのポインタの取得。
static inline NTRDate *NSD_GetBirthdayPtr( void )
{
return &GetNSD()->owner.birthday;
}
// 誕生日の取得。
static inline void NSD_GetBirthday( NTRDate *pDst )
{
MI_CpuCopy8( &GetNSD()->owner.birthday, pDst, sizeof(NTRDate) );
}
// ニックネームへのポインタの取得。
static inline NTRNickname *NSD_GetNicknamePtr( void )
{
return &GetNSD()->owner.nickname;
}
// ニックネームの取得。
static inline void NSD_GetNickname( NTRNickname *pDst )
{
MI_CpuCopy8( &GetNSD()->owner.nickname, pDst, sizeof(NTRNickname) );
}
// コメントへのポインタの取得。
static inline NTRComment *NSD_GetCommentPtr( void )
{
return &GetNSD()->owner.comment;
}
// コメントの取得。
static inline void NSD_GetComment( NTRComment *pDst )
{
MI_CpuCopy8( &GetNSD()->owner.comment, pDst, sizeof(NTRComment) );
}
// アラーム情報へのポインタの取得。
static inline NTRAlarm *NSD_GetAlarmDataPtr( void )
{
return &GetNSD()->alarm;
}
// アラーム情報の取得。
static inline void NSD_GetAlarmData( NTRAlarm *pDst )
{
MI_CpuCopy8( &GetNSD()->alarm, pDst, sizeof(NTRAlarm) );
}
// タッチパネルキャリブレーションデータへのポインタの取得。
static inline NTRTPCalibData *NSD_GetTPCalibrationPtr( void )
{
return &GetNSD()->tp;
}
// タッチパネルキャリブレーションデータの取得。
static inline void NSD_GetTPCalibration( NTRTPCalibData *pDst )
{
MI_CpuCopy8( &GetNSD()->tp, pDst, sizeof(NTRTPCalibData) );
}
// 言語コードの取得
static inline NTRLangCode NSD_GetLanguage( void )
{
return (NTRLangCode)GetNSD()->option.language;
}
static inline NTRLangCode NSD_GetLanguageEx( void )
{
return (NTRLangCode)GetNSDEx()->language;
}
// 対応言語ビットマップの取得
static inline u16 NSD_GetValidLanguageBitmap( void )
{
return GetNSDEx()->valid_language_bitmap;
}
// RTCオフセット値の取得
static inline s64 NSD_GetRTCOffset( void )
{
return GetNSD()->option.rtcOffset;
}
// RTCクロック調整値の取得
static inline u8 NSD_GetRTCClockAdjust( void )
{
return GetNSD()->option.rtcClockAdjust;
}
// RTCの前回セットした年の取得
static inline u8 NSD_GetRTCLastSetYear( void )
{
return GetNSD()->option.rtcLastSetYear;
}
// 起動シーケンスの自動起動ONか？（0:OFF, 1:ON）
static inline int NSD_IsAutoBoot( void )
{
return (int)GetNSD()->option.isAutoBoot;
}
// バックライト輝度取得（0-3）
static inline BOOL NSD_IsBacklightOff( void )
{
return (BOOL)GetNSD()->option.isBacklightOff;
}
// バックライト輝度取得（0-3）
static inline int NSD_GetBacklightBrightness( void )
{
return (int)GetNSD()->option.backlightBrightness;
}
// フラッシュ壊れシーケンス中かどうか？
static inline BOOL NSD_IsInitialSequence( void )
{
return (int)GetNSD()->option.initialSequence;
}
// 誕生日データがセットされているか？
static inline BOOL NSD_IsSetBirthday( void )
{
return (int)GetNSD()->option.isSetBirthday;
}
// ユーザーカラーデータがセットされているか？
static inline int NSD_IsSetUserColor( void )
{
return (int)GetNSD()->option.isSetUserColor;
}
// TPキャリブレーションデータがセットされているか？
static inline int NSD_IsSetTP( void )
{
return (int)GetNSD()->option.isSetTP;
}
// 言語コードがセットされているか？
static inline int NSD_IsSetLanguage( void )
{
return (int)GetNSD()->option.isSetLanguage;
}
// 日付・時刻がセットされているか？
static inline int NSD_IsSetDateTime( void )
{
return (int)GetNSD()->option.isSetDateTime;
}
// オーナー情報のニックネームがセットされているか？
static inline int NSD_IsSetNickname( void )
{
return (int)GetNSD()->option.isSetNickname;
}
// GBアプリなど１画面ソフトが使うのは上画面？
static inline BOOL NSD_IsGBUseTopLCD( void )
{
return (BOOL)GetNSD()->option.isGBUseTopLCD;
}
//=========================================================
// データセット
//=========================================================
// バージョンのセット。
static inline void NSD_SetVersion( u8 version )
{
GetNSD()->version = version;
}
// バージョンEXのセット。
static inline void NSD_SetExVersion( u8 version )
{
GetNSDEx()->version = version;
}
// オーナー情報のクリア
extern void NSD_ClearOwnerInfo( void );
// オーナー情報全体のセット。
static inline void NSD_SetOwnerInfo( const NTROwnerInfo *pOwner )
{
MI_CpuCopy16( pOwner, &GetNSD()->owner, sizeof(NTROwnerInfo) );
}
// ユーザーカラーのセット。
static inline void NSD_SetUserColor( u8 userColor )
{
GetNSD()->owner.userColor = userColor;
}
// 誕生日のセット。
static inline void NSD_SetBirthday( const NTRDate *pBirthday )
{
GetNSD()->owner.birthday.month = pBirthday->month;
GetNSD()->owner.birthday.day = pBirthday->day;
}
// ニックネームのセット。
static inline void NSD_SetNickname( const NTRNickname *pName )
{
MI_CpuCopy16( pName, &GetNSD()->owner.nickname, sizeof(NTRNickname) );
}
// コメントのセット。
static inline void NSD_SetComment( const NTRComment *pComment )
{
MI_CpuCopy16( pComment, &GetNSD()->owner.comment, sizeof(NTRComment) );
}
// アラーム情報のセット。
static inline void NSD_SetAlarmData( const NTRAlarm *pAlarm )
{
MI_CpuCopy16( pAlarm, &GetNSD()->alarm, sizeof(NTRAlarm) );
}
// タッチパネルキャリブレーションデータのセット。
static inline void NSD_SetTPCalibration( const NTRTPCalibData *pTPCalib )
{
MI_CpuCopy16( pTPCalib, &GetNSD()->tp, sizeof(NTRTPCalibData) );
}
// 言語コードのセット
#if 0
static inline void NSD_SetLanguage( NTRLangCode language )
{
GetNSDEx()->language = language;
if( language >= NTR_LANG_CODE_MAX_WW ) {
GetNSD()->option.language = NTR_LANG_ENGLISH;
}else {
GetNSD()->option.language = language;
}
}
#else
static inline void NSD_SetLanguage( NTRLangCode language )
{
GetNSD()->option.language = language;
}
static inline void NSD_SetLanguageEx( NTRLangCode language )
{
GetNSDEx()->language = language;
}
#endif
// 対応言語ビットマップのセット
static inline void NSD_SetValidLanguageBitmap( u16 valid_language_bitmap )
{
GetNSDEx()->valid_language_bitmap = valid_language_bitmap;
}
// RTCオフセット値のセット
static inline void NSD_SetRTCOffset( s64 rtcOffset )
{
GetNSD()->option.rtcOffset = rtcOffset;
}
// RTCクロック調整値のセット
static inline void NSD_SetRTCClockAdjust( u8 rtcClockAdjust )
{
GetNSD()->option.rtcClockAdjust = rtcClockAdjust;
}
// RTCのLastSetYearへのセット
static inline void NSD_SetRTCLastSetYear( u8 rtcLastSetYear )
{
GetNSD()->option.rtcLastSetYear = rtcLastSetYear;
}
// 起動シーケンスの自動起動ON,OFFフラグをセット。
static inline void NSD_SetFlagAutoBoot( BOOL set )
{
GetNSD()->option.isAutoBoot = (u16)set;
}
// バックライトON/OFFをセット。
static inline void NSD_SetFlagBacklightOff( BOOL set )
{
GetNSD()->option.isBacklightOff = (u16)set;
}
// バックライト輝度情報をセット。
static inline void NSD_SetBacklightBrightness( BOOL backlightBrightness )
{
GetNSD()->option.backlightBrightness = (u16)backlightBrightness;
}
// 初回起動シーケンス中かどうかのフラグセット。
static inline void NSD_SetFlagInitialSequence( BOOL set )
{
GetNSD()->option.initialSequence = (u16)set;
}
// 誕生日データの入力済みフラグセット。
static inline void NSD_SetFlagBirthday( BOOL set )
{
GetNSD()->option.isSetBirthday = (u16)set;
}
// ユーザーカラーの入力済みフラグセット。
static inline void NSD_SetFlagUserColor( BOOL set )
{
GetNSD()->option.isSetUserColor = (u16)set;
}
// TPキャリブレーションデータの入力済みフラグセット。
static inline void NSD_SetFlagTP( BOOL set )
{
GetNSD()->option.isSetTP = (u16)set;
}
// 言語コードの入力済みフラグセット。
static inline void NSD_SetFlagLanguage( BOOL set )
{
GetNSD()->option.isSetLanguage = (u16)set;
}
// 日付・時刻入力済みフラグセット。
static inline void NSD_SetFlagDateTime( BOOL set )
{
GetNSD()->option.isSetDateTime = (u16)set;
}
// オーナー情報のニックネームの入力済みフラグセット。
static inline void NSD_SetFlagNickname( BOOL set )
{
GetNSD()->option.isSetNickname = (u16)set;
}
// GBアプリなど１画面ソフトが使う画面フラグをセット
static inline void NSD_SetFlagGBUseTopLCD( BOOL set )
{
GetNSD()->option.isGBUseTopLCD = (u32)set;
}
#endif // SDK_ARM9
#ifdef __cplusplus
}
#endif
#endif // SDK_CW
#endif // NTR_SETTINGS_H_

243
include/sysmenu/settings/common/TWLHWInfo.h
View File

@ -1,243 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: HWInfo.h
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#ifndef TWL_HW_INFO_H_
#define TWL_HW_INFO_H_
#define HW_SIGNATURE_ENABLE_ // HWセキュア情報の署名処理有効コンパイルスイッチ
#include <twl.h>
#include <sysmenu/settings/common/TWLStoreFile.h>
#ifdef HW_SIGNATURE_ENABLE_
#include <sysmenu/acsign.h>
#endif // HW_SIGNATURE_ENABLE_
#ifdef __cplusplus
extern "C" {
#endif
// define data ------------------------------------
#define TWL_HWINFO_FILE_LENGTH ( 16 * 1024 )
#define TWL_HWINFO_NORMAL_PATH "nand:/sys/HWINFO_N.dat"
#define TWL_HWINFO_SECURE_PATH "nand:/sys/HWINFO_S.dat"
#define TWL_HWINFO_NORMAL_VERSION 1 // HW情報フォーマットバージョン(開始No.:1)
#define TWL_HWINFO_SECURE_VERSION 1 // HW情報フォーマットバージョン(開始No.:1)
#define TWL_HWINFO_SERIALNO_LEN_AMERICA 11 // 本体シリアルNo.長Max（北米向けは11桁）
#define TWL_HWINFO_SERIALNO_LEN_OTHERS 12 // 本体シリアルNo.長Max
#define TWL_HWINFO_SERIALNO_LEN_MAX 15 // 本体シリアルNo.長Max(終端付きなので、14bytesまで拡張可)
#define TWL_HWINFO_CAMERA_LEN 1024 // カメラ情報 [TODO]サイズ未定
// リージョンコード（販社別になる見込み）
typedef enum TWLRegionCode {
TWL_REGION_JAPAN = 0, // NCL
TWL_REGION_AMERICA = 1, // NOA
TWL_REGION_EUROPE = 2, // NOE
TWL_REGION_AUSTRALIA = 3, // NAL
TWL_REGION_CHINA = 4, // IQue
TWL_REGION_KOREA = 5, // NOK
TWL_REGION_MAX
}TWLRegion;
#define TWL_LANG_BITMAP_JAPAN ( ( 0x0001 << TWL_LANG_JAPANESE ) ) // JPN版での対応言語ビットマップ
#define TWL_LANG_BITMAP_AMERICA ( ( 0x0001 << TWL_LANG_ENGLISH ) | \
( 0x0001 << TWL_LANG_FRENCH ) | \
( 0x0001 << TWL_LANG_SPANISH ) ) // AME版での対応言語ビットマップ
#define TWL_LANG_BITMAP_EUROPE ( ( 0x0001 << TWL_LANG_ENGLISH ) | \
( 0x0001 << TWL_LANG_FRENCH ) | \
( 0x0001 << TWL_LANG_GERMAN ) | \
( 0x0001 << TWL_LANG_ITALIAN ) | \
( 0x0001 << TWL_LANG_SPANISH ) ) // EUR版での対応言語ビットマップ
#define TWL_LANG_BITMAP_AUSTRALIA ( ( 0x0001 << TWL_LANG_ENGLISH ) ) // AUS版での対応言語ビットマップ
#define TWL_LANG_BITMAP_CHINA ( ( 0x0001 << TWL_LANG_SIMP_CHINESE ) ) // CHI版での対応言語ビットマップ
#define TWL_LANG_BITMAP_KOREA ( ( 0x0001 << TWL_LANG_KOREAN ) ) // KOR版での対応言語ビットマップ
// TWL_HWノーマル情報設定データ（署名で改ざん保護する必要がないもの）
// ※基本、過去ver互換を考慮して、追加しかしない方針で。
typedef struct TWLHWNormalInfo{
u8 rtcAdjust; // RTC調整値
u8 camera[ TWL_HWINFO_CAMERA_LEN ]; // カメラ情報
}TWLHWNormalInfo; // 1025byte
// TWL_HWセキュア情報設定データ（署名で改ざん保護する必要があるもの）
// ※基本、過去ver互換を考慮して、追加しかしない方針で。
// ※SystemShared領域にロードしているので、サイズが変わった時は注意する。
typedef struct TWLHWSecureInfo{
u32 validLanguageBitmap; // 本体で有効な言語コードをビット列で表現
u8 region; // リージョン
u8 serialNo[ TWL_HWINFO_SERIALNO_LEN_MAX ]; // シリアルNo.（終端付きASCII文字列）
//-------------------------------------------------------------
// [TODO:]ここまでの20bytesをランチャーでSystemSharedにロードする。
//-------------------------------------------------------------
u8 launcherTitleID_Lo[ 4 ];
}TWLHWSecureInfo; // 24bytes
#ifdef SDK_ARM9
//=========================================================
// HW情報リードライト関数
//=========================================================
// Normal情報
// 内部変数へのリード
extern TSFReadResult THW_ReadNormalInfo( void );
// 内部変数の値をライト（先にリードしておく必要がある）
extern BOOL THW_WriteNormalInfo( void );
// 直接値を指定してのライト（開発用）
extern BOOL THW_WriteNormalInfoDirect( const TWLHWNormalInfo *pSrcInfo );
// ファイルリカバリー
extern BOOL THW_RecoveryNormalInfo( TSFReadResult err );
// 上記Read,Write関数で使用されるデフォルト値のセット（開発用）
extern void THW_SetDefaultNormalInfo( const TWLHWNormalInfo *pSrcInfo );
extern void THW_ClearNormalInfoDirect( TWLHWNormalInfo *pDstInfo );
extern const TWLHWNormalInfo *THW_GetDefaultNormalInfo( void );
extern const TWLHWNormalInfo *THW_GetNormalInfo( void );
// Secure情報
// 内部変数へのリード
extern TSFReadResult THW_ReadSecureInfo( void );
extern TSFReadResult THW_ReadSecureInfo_NoCheck( void ); // 署名ノーチェックでリード
// 内部変数の値をライト（先にリードしておく必要がある）
extern BOOL THW_WriteSecureInfo( const u8 *pPrivKeyDER ); // pPrivKeyDERがNULLなら署名なしでライト
// 直接値を指定してのライト（開発用）
extern BOOL THW_WriteSecureInfoDirect( const TWLHWSecureInfo *pSrcInfo, const u8 *pPrivKeyDER ); // pPrivKeyDERがNULLなら署名なしでライト
// ファイルリカバリー
extern BOOL THW_RecoverySecureInfo( TSFReadResult err );
// 上記Read,Write関数で使用されるデフォルト値のセット（開発用）
extern void THW_SetDefaultSecureInfo( const TWLHWSecureInfo *pSrcInfo );
extern void THW_ClearSecureInfoDirect( TWLHWSecureInfo *pDstInfo );
extern const TWLHWSecureInfo *THW_GetDefaultSecureInfo( void );
extern const TWLHWSecureInfo *THW_GetSecureInfo( void );
//=========================================================
// （下記アクセス関数が使用するstatic変数）
//=========================================================
extern TWLHWNormalInfo s_hwInfoN;
extern TWLHWSecureInfo s_hwInfoS;
#define GetHWN() ( &s_hwInfoN )
#define GetHWS() ( &s_hwInfoS )
//=========================================================
// データ取得（THW_ReadNormalInfo, THW_ReadSecureInfoで内部ワークに読み出した情報の取得）
//=========================================================
// RTCオフセット値の取得
static inline u8 THW_GetRTCAdjust( void )
{
return GetHWN()->rtcAdjust;
}
// カメラ情報の取得
static inline void THW_GetCameraInfo( u8 *pDst )
{
MI_CpuCopy8( GetHWN()->camera, pDst, TWL_HWINFO_CAMERA_LEN );
}
// カメラ情報へのポインタの取得
static inline const u8 *THW_GetCameraInfoPtr( void )
{
return (const u8 *)GetHWN()->camera;
}
// 言語ビットマップ値の取得
static inline u32 THW_GetValidLanguageBitmap( void )
{
return GetHWS()->validLanguageBitmap;
}
// リージョンの取得。
static inline u8 THW_GetRegion( void )
{
return (u8)GetHWS()->region;
}
// 本体シリアルNo.の取得
static inline void THW_GetSerialNo( u8 *pDst )
{
MI_CpuCopy8( &GetHWS()->serialNo, pDst, TWL_HWINFO_SERIALNO_LEN_MAX );
}
// 本体シリアルNo.へのポインタの取得
static inline const u8 *THW_GetSerialNoPtr( void )
{
return (const u8 *)&GetHWS()->serialNo;
}
//=========================================================
// データセット（TSD_ReadSettingsで内部ワークに読み出した情報への値セット）
//=========================================================
// RTCオフセット値のセット
static inline void THW_SetRTCAdjust( u8 adjust )
{
GetHWN()->rtcAdjust = adjust;
}
// カメラ情報のセット
static inline void THW_SetCameraInfo( const u8 *pCamera )
{
MI_CpuCopy8( pCamera, GetHWN()->camera, TWL_HWINFO_CAMERA_LEN );
}
// 言語ビットマップ値のセット
static inline void THW_SetValidLanguageBitmap( u32 langBitmap )
{
GetHWS()->validLanguageBitmap = langBitmap;
}
// リージョンのセット。
static inline void THW_SetRegion( u8 region )
{
GetHWS()->region = region;
}
// 本体シリアルNo.のセット
static inline void THW_SetSerialNo( const u8 *pSrc )
{
MI_CpuCopy8( pSrc, &GetHWS()->serialNo, TWL_HWINFO_SERIALNO_LEN_MAX );
}
#endif // SDK_ARM9
#ifdef __cplusplus
}
#endif
#endif // TWL_HWINFO_H_

560
include/sysmenu/settings/common/TWLSettings.h
View File

@ -1,560 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: TWLSettings.h
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#ifndef TWL_SETTINGS_H_
#define TWL_SETTINGS_H_
#if defined(SDK_CW) // TWLSettingsDataにビットフィールドを使っているので、コンパイラ依存で不具合が発生する可能性がある。
// よって、CW以外のコンパイラの場合は、このヘッダを無効にしてエラーを出させるようにして再確認する。
#include <twl.h>
#include <sysmenu/settings/common/countryCode.h>
#include <sysmenu/settings/common/NTRSettings.h>
#ifdef __cplusplus
extern "C" {
#endif
// define data ------------------------------------
#define TWL_SETTINGS_FILE_LENGTH ( 16 * 1024 )
#define TWL_SETTINGS_DATA_VERSION 1 // TWL設定データフォーマットバージョン(開始No.:1)
// オーナー情報
#define TWL_NICKNAME_LENGTH NTR_NICKNAME_LENGTH // ニックネーム長
#define TWL_NICKNAME_BUFFERSIZE ( ( TWL_NICKNAME_LENGTH + 1 ) * 2 ) // ニックネームバッファサイズ
#define TWL_COMMENT_LENGTH NTR_COMMENT_LENGTH // コメント長
#define TWL_COMMENT_BUFFERSIZE ( ( TWL_COMMENT_LENGTH + 1 ) * 2 ) // コメントバッファサイズ
#define TWL_FAVORITE_COLOR_MAX_NUM NTR_FAVORITE_COLOR_MAX_NUM // 好きな色の最大数
// バックライト輝度
#define TWL_BACKLIGHT_LEVEL_MAX 31 // TWLバックライト最大輝度レベル [TODO:]最終的には22にする予定。
// ペアレンタルコントロール
#define TWL_PARENTAL_CONTROL_RATING_AGE_MAX 31
#define TWL_PARENTAL_CONTROL_PASSWORD_LENGTH 4 // 暗証番号の桁数
#define TWL_PARENTAL_CONTROL_PASSWORD_DEFAULT "0000" // デフォルト暗証番号
#define TWL_PARENTAL_CONTROL_SECRET_ANSWER_LENGTH_MIN 6 // 秘密の質問の回答、UTF-16で最小 MIN 文字
#define TWL_PARENTAL_CONTROL_SECRET_ANSWER_LENGTH_MAX 32 // 秘密の質問の回答、UTF-16で最大 MAX 文字
// インストール・ソフト数
#define TWL_FREE_SOFT_BOX_COUNT_MAX 35 // NANDアプリの最大空きBox数, これ - freeSoftBoxCountでインストールSoft数
// 言語コード
// 欧州と北米の表示テキストの違いは、リージョンと言語コードを併せて判断
typedef enum TWLLangCode{
TWL_LANG_JAPANESE = 0, // 日本語
TWL_LANG_ENGLISH = 1, // 英語
TWL_LANG_FRENCH = 2, // フランス語
TWL_LANG_GERMAN = 3, // ドイツ語
TWL_LANG_ITALIAN = 4, // イタリア語
TWL_LANG_SPANISH = 5, // スペイン語
TWL_LANG_SIMP_CHINESE = 6, // 中国語（簡体字）
TWL_LANG_KOREAN = 7, // 韓国語
// TWL_LANG_DUTCH = 8, // オランダ語（Wiiでは存在）
// TWL_LANG_TRAD_CHINESE = 9, // 台湾語（繁体字）（Wiiでは存在）
TWL_LANG_CODE_MAX
}TWLLangCode;
// 日付
#define TWLDate NTRDate
// アラーム
#define TWLAlarm NTRAlarm
// TPキャリブレーション（NTRとの違いは、予約領域あり）
typedef struct TWLTPCalibData {
NTRTPCalibData data; // TPキャリブレーションデータ
u8 rsv[ 8 ];
}TWLTPCalibData;
// オーナー情報
typedef struct TWLOwnerInfo{
u8 userColor : 4; // 好きな色
u8 rsv : 4; // 予約。
u8 pad; // パディング
TWLDate birthday; // 生年月日
u16 nickname[ TWL_NICKNAME_LENGTH + 1 ]; // ニックネーム（終端あり）
u16 comment[ TWL_COMMENT_LENGTH + 1 ]; // コメント（終端あり）
}TWLOwnerInfo; // 80byte
// ペアレンタルコントロール
// 審査団体
typedef enum TWLRatingOgn {
TWL_RATING_OGN_CERO = 0, // 日本
TWL_RATING_OGN_ESRB = 1, // アメリカ
TWL_RATING_OGN_USK = 2, // ドイツ
TWL_RATING_OGN_PEGI_GENERAL = 3, // 欧州
TWL_RATING_OGN_PEGI_PORTUGAL = 4, // ポルトガル
TWL_RATING_OGN_PEGI_BBFC = 5, // イギリス
TWL_RATING_OGN_AGCB = 6, // オーストラリア
TWL_RATING_OGN_OFLC = 7, // ニュージーランド
TWL_RATING_OGN_GRB = 8, // 韓国
TWL_RATING_OGN_MAX = 8
}TWLRatingOgn;
// データ
typedef struct TWLParentalControl {
TWLRatingOgn ogn; // 審査団体
// u8 flags; // Wiiでは、PARENTAL_CONTROL_USEフラグのみ --> isSetParentalControl があるので現状必要なし
u8 ratingAge; // レーティング（年齢）値
char password[ TWL_PARENTAL_CONTROL_PASSWORD_LENGTH + 1 ]; // 暗証番号、終端コードあり
u8 secretQuestion; // 秘密の質問文 ID
u8 rsv_A;
u16 secretAnswer[ TWL_PARENTAL_CONTROL_SECRET_ANSWER_LENGTH_MAX + 1 ]; // UTF16,秘密の質問への回答、終端コードあり
u16 secretAnswerLength; // 秘密の質問への回答文字数（Wiiでu16,LENGTH_MAX が保持できるからu8でもいいのでは？）
// u8 rsv_B[ 16 ]; // 削除予定（16バイトのレーティング情報を持つのはアプリ側のROMヘッダ）
}TWLParentalControl;
// TWL設定データ（基本、過去ver互換を考慮して、追加しかしない方針で。）
typedef struct TWLSettingsData{
struct flags {
u32 initialSequence : 1; // 初回起動シーケンス中？
u32 isSetCountry : 1; // 国コード設定済み？
u32 isSetLanguage : 1; // 言語設定済み？
u32 isSetDateTime : 1; // 日付・時刻設定済み？
u32 isSetNickname : 1; // ニックネーム設定済み？
u32 isSetUserColor : 1; // ユーザーカラー設定済み？
u32 isSetBirthday : 1; // 誕生日設定済み？
u32 isSetTP : 1; // TP設定済み？
u32 isSetParentalControl : 1; // パレンタルコントロール設定済み？
// u32 isSetBrowserRestriction : 1; // Wiiで存在。フルブラウザを制限するかどうか。TWLでは検討中。
u32 isAgreeEURA : 1; // EURA同意済み？
// WiFi設定は別データなので、ここに設定済みフラグは用意しない。
u32 isGBUseTopLCD : 1; // １画面のGBゲーム時に上画面を使う？
u32 isAvailableWireless : 1; // 無線モジュールのRFユニットの有効化／無効化
u32 isAvailableBatteryExtension : 1; // バッテリエクステンションモードの有効化／無効化
u32 rsv : 19;
}flags;
u8 rsv2[ 2 ]; // 予約
u8 country; // 国コード
u8 language; // 言語(NTRとの違いは、データサイズ8bit)
u8 backLightBrightness; // バックライト輝度(NTRとの違いは、データサイズ8bit)
u8 lastTimeBootSoftIndex; // 前回起動したソフトのインデックス番号
u8 freeSoftBoxCount; // インストール可能なNANDアプリ個数
u8 rtcLastSetYear; // RTCの前回設定年
s64 rtcOffset; // RTC設定時のオフセット値（ユーザーがRTC設定を変更する度にその値に応じて増減します。）
TWLOwnerInfo owner; // オーナー情報
TWLAlarm alarm; // アラーム
TWLTPCalibData tp; // タッチパネルキャリブレーションデータ
TWLParentalControl parental;
}TWLSettingsData; // xxbyte
#ifdef SDK_ARM9
//=========================================================
// グローバル変数
//=========================================================
extern TWLSettingsData s_settings;
#define GetTSD() ( &s_settings )
//=========================================================
// NANDファイルへのリードライト関数
//=========================================================
// 内部変数へのリード
extern BOOL TSD_ReadSettings( void );
// 内部変数の値のライト（先にリードしておく必要がある）
extern BOOL TSD_WriteSettings( void );
// 直接値を指定してのライト（開発用）
extern BOOL TSD_WriteSettingsDirect( const TWLSettingsData *pSrc );
// 内部変数の値のクリア
extern void TSD_ClearSettings( void );
//=========================================================
// データ取得（TSD_ReadSettingsで内部ワークに読み出した情報の取得）
//=========================================================
// 国コードの取得。
static inline TWLCountryCode TSD_GetCountry( void )
{
return (TWLCountryCode)GetTSD()->country;
}
// 言語コードの取得
static inline TWLLangCode TSD_GetLanguage( void )
{
return (TWLLangCode)GetTSD()->language;
}
// バックライト輝度取得
static inline int TSD_GetBacklightBrightness( void )
{
return (int)GetTSD()->backLightBrightness;
}
// 前回起動したソフトのインデックスの取得
static inline u8 TSD_GetLastTimeBootSoftIndex( void )
{
return GetTSD()->lastTimeBootSoftIndex;
}
// フリーソフトBOX数の取得
static inline u8 TSD_GetFreeSoftBoxCount( void )
{
return GetTSD()->freeSoftBoxCount;
}
// RTCの前回セットした年の取得
static inline u8 TSD_GetRTCLastSetYear( void )
{
return GetTSD()->rtcLastSetYear;
}
// RTCオフセット値の取得
static inline s64 TSD_GetRTCOffset( void )
{
return GetTSD()->rtcOffset;
}
// オーナー情報全体の取得。
static inline void TSD_GetOwnerInfo( TWLOwnerInfo *pDst )
{
MI_CpuCopy8( &GetTSD()->owner, pDst, sizeof(TWLOwnerInfo) );
}
// オーナー情報全体へのポインタの取得。
static inline const TWLOwnerInfo *TSD_GetOwnerInfoPtr( void )
{
return (const TWLOwnerInfo *)&GetTSD()->owner;
}
// 好きな色の取得。
static inline u8 TSD_GetUserColor( void )
{
return (u8)GetTSD()->owner.userColor;
}
// 誕生日の取得。
static inline void TSD_GetBirthday( TWLDate *pDst )
{
MI_CpuCopy8( &GetTSD()->owner.birthday, pDst, sizeof(TWLDate) );
}
// 誕生日へのポインタの取得。
static inline const TWLDate *TSD_GetBirthdayPtr( void )
{
return (const TWLDate *)&GetTSD()->owner.birthday;
}
// ニックネームの取得。
static inline void TSD_GetNickname( u16 *pDst )
{
MI_CpuCopy16( GetTSD()->owner.nickname, pDst, TWL_NICKNAME_BUFFERSIZE );
}
// ニックネームへのポインタの取得。
static inline const u16 *TSD_GetNicknamePtr( void )
{
return (const u16 *)&GetTSD()->owner.nickname;
}
// コメントの取得。
static inline void TSD_GetComment( u16 *pDst )
{
MI_CpuCopy16( GetTSD()->owner.comment, pDst, TWL_COMMENT_BUFFERSIZE );
}
// コメントへのポインタの取得。
static inline const u16 *TSD_GetCommentPtr( void )
{
return (const u16 *)&GetTSD()->owner.comment;
}
// アラーム情報の取得。
static inline void TSD_GetAlarmData( TWLAlarm *pAlarm )
{
MI_CpuCopy8( &GetTSD()->alarm, pAlarm, sizeof(TWLAlarm) );
}
// アラーム情報へのポインタの取得。
static inline const TWLAlarm *TSD_GetAlarmDataPtr( void )
{
return (const TWLAlarm *)&GetTSD()->alarm;
}
// タッチパネルキャリブレーションデータの取得。
static inline void TSD_GetTPCalibration( TWLTPCalibData *pDst )
{
MI_CpuCopy8( &GetTSD()->tp, pDst, sizeof(TWLTPCalibData) );
}
// タッチパネルキャリブレーションデータへのポインタの取得。
static inline const TWLTPCalibData *TSD_GetTPCalibrationPtr( void )
{
return (const TWLTPCalibData *)&GetTSD()->tp;
}
// 初回起動シーケンス中？
static inline BOOL TSD_IsInitialSequence( void )
{
return (BOOL)GetTSD()->flags.initialSequence;
}
// 国コード入力済み？
static inline BOOL TSD_IsSetCountry( void )
{
return (BOOL)GetTSD()->flags.isSetCountry;
}
// 言語コード入力済み？
static inline BOOL TSD_IsSetLanguage( void )
{
return (BOOL)GetTSD()->flags.isSetLanguage;
}
// 日付・時刻データ入力済み？
static inline BOOL TSD_IsSetDateTime( void )
{
return (BOOL)GetTSD()->flags.isSetDateTime;
}
// ニックネーム入力済み？
static inline BOOL TSD_IsSetNickname( void )
{
return (BOOL)GetTSD()->flags.isSetNickname;
}
// ユーザーカラー入力済み？
static inline BOOL TSD_IsSetUserColor( void )
{
return (BOOL)GetTSD()->flags.isSetUserColor;
}
// 誕生日入力済み？
static inline BOOL TSD_IsSetBirthday( void )
{
return (BOOL)GetTSD()->flags.isSetBirthday;
}
// TPキャリブレーションデータ入力済み？
static inline BOOL TSD_IsSetTP( void )
{
return (BOOL)GetTSD()->flags.isSetTP;
}
// パレンタルコントロール入力済み？
static inline BOOL TSD_IsSetParentalControl( void )
{
return (BOOL)GetTSD()->flags.isSetParentalControl;
}
// EURAビューア同意済み？
static inline BOOL TSD_IsAgreeEURA( void )
{
return (BOOL)GetTSD()->flags.isAgreeEURA;
}
// GBアプリなど１画面ソフトが使うのは上画面？
static inline BOOL TSD_IsGBUseTopLCD( void )
{
return (BOOL)GetTSD()->flags.isGBUseTopLCD;
}
// 無線使用可能？
static inline BOOL TSD_IsAvailableWireless( void )
{
return (BOOL)GetTSD()->flags.isAvailableWireless;
}
// バッテリエクステンションモード有効？
static inline BOOL TSD_IsAvailableBatteryExtension( void )
{
return (BOOL)GetTSD()->flags.isAvailableBatteryExtension;
}
//=========================================================
// データセット（TSD_ReadSettingsで内部ワークに読み出した情報への値セット）
//=========================================================
// 国コードのセット。
static inline void TSD_SetCountry( TWLCountryCode country )
{
GetTSD()->country = (u8)country;
}
// 言語コードのセット
static inline void TSD_SetLanguage( TWLLangCode language )
{
GetTSD()->language = language;
}
// バックライト輝度情報をセット。
static inline void TSD_SetBacklightBrightness( u8 backLightBrightness )
{
GetTSD()->backLightBrightness = backLightBrightness;
}
// 前回起動したソフトのインデックスをセット
static inline void TSD_SetLastTimeBootSoftIndex( u8 index )
{
GetTSD()->lastTimeBootSoftIndex = index;
}
// フリーソフトBOX数のセット
static inline void TSD_SetFreeSoftBoxCount( u8 count )
{
GetTSD()->freeSoftBoxCount = count;
}
// RTCのLastSetYearへのセット
static inline void TSD_SetRTCLastSetYear( u8 rtcLastSetYear )
{
GetTSD()->rtcLastSetYear = rtcLastSetYear;
}
// RTCオフセット値のセット
static inline void TSD_SetRTCOffset( s64 rtcOffset )
{
GetTSD()->rtcOffset = rtcOffset;
}
// オーナー情報全体のセット。
static inline void TSD_SetOwnerInfo( const TWLOwnerInfo *pOwner )
{
MI_CpuCopy16( pOwner, &GetTSD()->owner, sizeof(TWLOwnerInfo) );
}
// ユーザーカラーのセット。
static inline void TSD_SetUserColor( u8 userColor )
{
GetTSD()->owner.userColor = userColor;
}
// 誕生日のセット。
static inline void TSD_SetBirthday( const TWLDate *pSrc )
{
MI_CpuCopy8( pSrc, &GetTSD()->owner.birthday, sizeof(TWLDate) );
}
// ニックネームのセット。
static inline void TSD_SetNickname( const u16 *pSrc )
{
MI_CpuCopy16( pSrc, GetTSD()->owner.nickname, TWL_NICKNAME_BUFFERSIZE );
}
// コメントのセット。
static inline void TSD_SetComment( const u16 *pSrc )
{
MI_CpuCopy16( pSrc, GetTSD()->owner.comment, TWL_COMMENT_BUFFERSIZE );
}
// アラーム情報のセット。
static inline void TSD_SetAlarmData( const TWLAlarm *pAlarm )
{
MI_CpuCopy16( pAlarm, &GetTSD()->alarm, sizeof(TWLAlarm) );
}
// タッチパネルキャリブレーションデータのセット。
static inline void TSD_SetTPCalibration( const TWLTPCalibData *pTPCalib )
{
MI_CpuCopy16( pTPCalib, &GetTSD()->tp, sizeof(TWLTPCalibData) );
}
// 初回起動シーケンス中かどうかのフラグセット。
static inline void TSD_SetFlagInitialSequence( BOOL initialSequence )
{
GetTSD()->flags.initialSequence = (u32)initialSequence;
}
// 国コードの入力済みフラグセット。
static inline void TSD_SetFlagCountry( BOOL set )
{
GetTSD()->flags.isSetCountry = (u32)set;
}
// 言語コードの入力済みフラグセット。
static inline void TSD_SetFlagLanguage( BOOL set )
{
GetTSD()->flags.isSetLanguage = (u32)set;
}
// 日付・時刻の入力済みフラグセット。
static inline void TSD_SetFlagDateTime( BOOL set )
{
GetTSD()->flags.isSetDateTime = (u32)set;
}
// ニックネームの入力済みフラグセット。
static inline void TSD_SetFlagNickname( BOOL set )
{
GetTSD()->flags.isSetNickname = (u32)set;
}
// ユーザーカラーの入力済みフラグセット。
static inline void TSD_SetFlagUserColor( BOOL set )
{
GetTSD()->flags.isSetUserColor = (u32)set;
}
// 誕生日データの入力済みフラグセット。
static inline void TSD_SetFlagBirthday( BOOL set )
{
GetTSD()->flags.isSetBirthday = (u32)set;
}
// TPキャリブレーションの入力済みフラグセット。
static inline void TSD_SetFlagTP( BOOL set )
{
GetTSD()->flags.isSetTP = (u32)set;
}
// パレンタルコントロールの入力済みフラグセット。
static inline void TSD_SetFlagParentalControl( BOOL set )
{
GetTSD()->flags.isSetNickname = (u32)set;
}
// EURAビューア同意済みフラグセット。
static inline void TSD_SetFlagAgreeEURA( BOOL set )
{
GetTSD()->flags.isSetNickname = (u32)set;
}
// GBアプリなど１画面ソフトが使う画面フラグをセット
static inline void TSD_SetFlagGBUseTopLCD( BOOL set )
{
GetTSD()->flags.isGBUseTopLCD = (u32)set;
}
// 無線使用可否フラグをセット
static inline void TSD_SetFlagAvailableWireless( BOOL set )
{
GetTSD()->flags.isAvailableWireless = set;
}
// バッテリエクステンションモード有効／無効フラグをセット
static inline void TSD_SetFlagAvailableBatteryExtension( BOOL set )
{
GetTSD()->flags.isAvailableBatteryExtension = set;
}
#endif // SDK_ARM9
#ifdef __cplusplus
}
#endif
#endif // SDK_CW
#endif // TWL_SETTINGS_H_

93
include/sysmenu/settings/common/TWLStoreFile.h
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: TWLFileStore.h
Copyright 2007 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.
$Date:: $
$Rev$
$Author$
*---------------------------------------------------------------------------*/
#ifndef TWL_STORE_FILE_H_
#define TWL_STORE_FILE_H_
#if defined(SDK_CW)
#include <twl.h>
#include <twl/os/common/format_rom.h>
#ifdef __cplusplus
extern "C" {
#endif
// define data ------------------------------------
#define TSF_VERSION_TERMINATOR 0xff // version終端
#define SAVE_COUNT_MAX 0x80 // saveCountの最大値
#define SAVE_COUNT_MASK 0x7f // saveCountの値の範囲をマスクする。(0x00-0x7f）
// TSFリード結果
typedef enum TSFReadResult {
TSF_READ_RESULT_SUCCEEDED = 0,
TSF_READ_RESULT_ERROR_FILE_EXIST = 1,
TSF_READ_RESULT_ERROR_FILE_LENGTH = 2,
TSF_READ_RESULT_ERROR_DATA = 3
}TSFReadResult;
// TSFアクセス用パラメータ
typedef struct TSFParam { // TSF ( TWL Store File )
u32 dataLength; // 保存するデータ長
u32 fileLength; // 保存するファイル長
const u8 *conpatibleVerList; // 過去ver.の互換ver.リスト。TSF_VERSION_TERMINATORで終端。
void (*pClearFunc)( void *pDst ); // 保存するデータの値クリア関数
BOOL (*pCheckDigestFunc)( void *pTgt, u32 len, u8 *pDigest ); // ダイジェストチェック関数へのポインタ
BOOL (*pCheckValueFunc)( void *pTgt ); // 値チェック関数へのポインタ
}TSFParam;
// TSFヘッダ
typedef struct TSFHeader{
union digest {
u8 sha1[ SVC_SHA1_DIGEST_SIZE ]; // SHA-1ダイジェスト
u8 rsa[ RSA_KEY_LENGTH ]; // RSA署名
u8 dst[ RSA_KEY_LENGTH ]; // 転送用の最大サイズ要素
}digest;
u8 version; // データver.
u8 saveCount; // セーブカウント（ミラーリングしないファイルは使用しない）
u8 rsv[2]; // 予約
u32 bodyLength; // データ長
}TSFHeader; // 134bytes
// ※「TSFHeader+データ本体」の形でファイルに保存されます。
#ifdef SDK_ARM9
//=========================================================
// NANDファイルへのリードライト関数
//=========================================================
// TSFフォーマットのファイルのリード
extern TSFReadResult TSF_ReadFile ( char *pPath, void *pDstBody, const TSFParam *pParam, u8 *pSaveCount );
// TSFフォーマットのファイルのライト（pSaveCountにNULLを与えた場合は、saveCountを"0"固定にします。）
extern BOOL TSF_WriteFile( char *pPath, TSFHeader *pHeader, const void *pSrcBody, u8 *pSaveCount );
// TSFフォーマットのファイルのリカバリ
extern BOOL TSF_RecoveryFile( TSFReadResult err, char *pPath, u32 fileLength );
#endif // SDK_ARM9
#ifdef __cplusplus
}
#endif
#endif // SDK_CW
#endif // TWL_STORE_FILE_H_

198
include/sysmenu/settings/common/countryCode.h
View File

@ -1,198 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlIPL
File: countryCode.c
Copyright 2007 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.
$Date:: 2007-11-06#$
$Rev: 104 $
$Author: yosiokat $
*---------------------------------------------------------------------------*/
#ifndef COUNTRY_CODE_H_
#define COUNTRY_CODE_H_
#if defined(SDK_CW) // NTRConfigDataにビットフィールドを使っているので、コンパイラ依存で不具合が発生する可能性がある。
// よって、CW以外のコンパイラの場合は、このヘッダを無効にしてエラーを出させるようにして再確認する。
#include <twl.h>
#ifdef __cplusplus
extern "C" {
#endif
// define data ------------------------------------
// 言語設定コード
typedef enum TWLCountryCode{
TWL_COUNTRY_UNDEFINED = 0, // 未設定
// JPNリージョン
TWL_COUNTRY_JAPAN = 1, // 日本
// USAリージョン
TWL_COUNTRY_Anguilla = 8, // アンギラ
TWL_COUNTRY_ANTIGUA_AND_BARBUDA, // アンティグア・バーブーダ
TWL_COUNTRY_ARGENTINA = 10, // アルゼンチン
TWL_COUNTRY_ARUBA, // アルバ
TWL_COUNTRY_BAHAMAS, // バハマ
TWL_COUNTRY_BARBADOS, // バルバドス
TWL_COUNTRY_BELIZE, // ベリーズ
TWL_COUNTRY_BOLIVIA, // ボリビア
TWL_COUNTRY_BRAZIL, // ブラジル
TWL_COUNTRY_BRITISH_VIRGIN_ISLANDS, // 英領ヴァージン諸島
TWL_COUNTRY_CANADA, // カナダ
TWL_COUNTRY_CAYMAN_ISLANDS, // ケイマン諸島
TWL_COUNTRY_CHILE = 20, // チリ
TWL_COUNTRY_COLOMBIA, // コロンビア
TWL_COUNTRY_COSTA_RICA, // コスタリカ
TWL_COUNTRY_DOMINICA, // ドミニカ国
TWL_COUNTRY_DOMINICAN_REPUBLIC, // ドミニカ共和国
TWL_COUNTRY_ECUADOR, // エクアドル
TWL_COUNTRY_EL_SALVADOR, // エルサルバドル
TWL_COUNTRY_FRENCH_GUIANA, // フランス領ギアナ
TWL_COUNTRY_GRENADA, // グレナダ
TWL_COUNTRY_GUADELOUPE, // グアドループ
TWL_COUNTRY_GUATEMALA = 30, // グアテマラ
TWL_COUNTRY_GUYANA, // ガイアナ
TWL_COUNTRY_HAITI, // ハイチ
TWL_COUNTRY_HONDURAS, // ホンジュラス
TWL_COUNTRY_JAMAICA, // ジャマイカ
TWL_COUNTRY_MARTINIQUE, // マルティニーク
TWL_COUNTRY_MEXICO, // メキシコ
TWL_COUNTRY_MONTSERRAT, // モントセラト
TWL_COUNTRY_NETHERLANDS_ANTILLES, // オランダ領アンティル
TWL_COUNTRY_NICARAGUA, // ニカラグア
TWL_COUNTRY_PANAMA = 40, // パナマ
TWL_COUNTRY_PARAGUAY, // パラグアイ
TWL_COUNTRY_PERU, // ペルー
TWL_COUNTRY_ST_KITTS_AND_NEVIS, // セントキッツ・ネイビス
TWL_COUNTRY_ST_LUCIA, // セントルシア
TWL_COUNTRY_ST_VINCENT_AND_THE_GRENADINES, // セントビンセント・グレナディーン
TWL_COUNTRY_SURINAME, // スリナム
TWL_COUNTRY_TRINIDAD_AND_TOBAGO, // トリニダード・トバゴ
TWL_COUNTRY_TURKS_AND_CAICOS_ISLANDS, // タークス・カイコス諸島
TWL_COUNTRY_UNITED_STATES, // アメリカ
TWL_COUNTRY_URUGUAY = 50, // ウルグアイ
TWL_COUNTRY_US_VIRGIN_ISLANDS, // 米領バージン諸島
TWL_COUNTRY_VENEZUELA, // ベネズエラ
// EUR, NAL リージョン
TWL_COUNTRY_ALBANIA = 64, // アルバニア
TWL_COUNTRY_AUSTRALIA, // オーストラリア
TWL_COUNTRY_AUSTRIA, // オーストリア
TWL_COUNTRY_BELGIUM, // ベルギー
TWL_COUNTRY_BOSNIA_AND_HERZEGOVINA, // ボスニア・ヘルツェゴビナ
TWL_COUNTRY_BOTSWANA, // ボツワナ
TWL_COUNTRY_BULGARIA = 70, // ブルガリア
TWL_COUNTRY_CROATIA, // クロアチア
TWL_COUNTRY_CYPRUS, // キプロス
TWL_COUNTRY_CZECH_REPUBLIC, // チェコ
TWL_COUNTRY_DENMARK, // デンマーク
TWL_COUNTRY_ESTONIA, // エストニア
TWL_COUNTRY_FINLAND, // フィンランド
TWL_COUNTRY_FRANCE, // フランス
TWL_COUNTRY_GERMANY, // ドイツ
TWL_COUNTRY_GREECE, // ギリシャ
TWL_COUNTRY_HUNGARY = 80, // ハンガリー
TWL_COUNTRY_ICELAND, // アイスランド
TWL_COUNTRY_IRELAND, // アイルランド
TWL_COUNTRY_ITALY, // イタリア
TWL_COUNTRY_LATVIA, // ラトビア
TWL_COUNTRY_LESOTHO, // レソト
TWL_COUNTRY_LIECHTENSTEIN, // リヒテンシュタイン
TWL_COUNTRY_LITHUANIA, // リトアニア
TWL_COUNTRY_LUXEMBOURG, // ルクセンブルク
TWL_COUNTRY_MACEDONIA, // マケドニア
TWL_COUNTRY_MALTA = 90, // マルタ
TWL_COUNTRY_MONTENEGRO, // モンテネグロ
TWL_COUNTRY_MOZAMBIQUE, // モザンビーク
TWL_COUNTRY_NAMIBIA, // ナミビア
TWL_COUNTRY_NETHERLANDS, // オランダ
TWL_COUNTRY_NEW_ZEALAND, // ニュージーランド
TWL_COUNTRY_NORWAY, // ノルウェー
TWL_COUNTRY_POLAND, // ポーランド
TWL_COUNTRY_PORTUGAL, // ポルトガル
TWL_COUNTRY_ROMANIA, // ルーマニア
TWL_COUNTRY_RUSSIA = 100, // ロシア
TWL_COUNTRY_SERBIA, // セルビア
TWL_COUNTRY_SLOVAKIA, // スロバキア
TWL_COUNTRY_SLOVENIA, // スロベニア
TWL_COUNTRY_SOUTH_AFRICA, // 南アフリカ
TWL_COUNTRY_SPAIN, // スペイン
TWL_COUNTRY_SWAZILAND, // スワジランド
TWL_COUNTRY_SWEDEN, // スウェーデン
TWL_COUNTRY_SWITZERLAND, // スイス
TWL_COUNTRY_TURKEY, // トルコ
TWL_COUNTRY_UNITED_KINGDOM = 110, // イギリス
TWL_COUNTRY_ZAMBIA, // ザンビア
TWL_COUNTRY_ZIMBABWE, // ジンバブエ
// TWNリージョン
TWL_COUNTRY_TAIWAN = 128, // 台湾
// KORリージョン
TWL_COUNTRY_SOUTH_KOREA = 136, // 韓国
// HKGリージョン（Wiiの国リストに存在）
TWL_COUNTRY_HONG_KONG = 144, // ホンコン
TWL_COUNTRY_MACAU, // マカオ
// ASIリージョン（Wiiの国リストに存在）
TWL_COUNTRY_INDONESIA = 152, // インドネシア
// USAリージョン
TWL_COUNTRY_SINGAPORE = 153, // シンガポール
// ASIリージョン（再び）
TWL_COUNTRY_THAILAND = 154, // タイ
TWL_COUNTRY_PHILIPPINES, // フィリピン
TWL_COUNTRY_MALAYSIA, // マレーシア
// 未定義リージョン（IQueリージョン？）
TWL_COUNTRY_CHINA = 160, // 中国
// USAリージョン
TWL_COUNTRY_UAE = 168, // アラブ首長国連邦
// 未定義リージョン
TWL_COUNTRY_INDIA = 169, // インド
TWL_COUNTRY_EGYPT = 170, // エジプト
TWL_COUNTRY_OMAN, // オマーン
TWL_COUNTRY_QATAR, // カタール
TWL_COUNTRY_KUWAIT, // クウェート
TWL_COUNTRY_SAUDI_ARABIA, // サウジアラビア
TWL_COUNTRY_SYRIA, // シリア
TWL_COUNTRY_BAHRAIN, // バーレーン
TWL_COUNTRY_JORDAN, // ヨルダン
TWL_COUNTRY_OTHERS = 254,
TWL_COUNTRY_UNKNOWN = 255,
TWL_COUNTRY_MAX
}TWLCountryCode;
// 対応カントリーコード。開始位置を16ビット左シフトしたものと終了位置をorでまとめたもの
#define TWL_COUNTRY_MAPPING_JAPAN (u32)( TWL_COUNTRY_JAPAN << 16| TWL_COUNTRY_JAPAN ) // JPN版での対応カントリーコード
#define TWL_COUNTRY_MAPPING_AMERICA (u32)( TWL_COUNTRY_Anguilla << 16| TWL_COUNTRY_VENEZUELA ) // AME版での対応カントリーコード
#define TWL_COUNTRY_MAPPING_EUROPE (u32)( TWL_COUNTRY_ALBANIA << 16| TWL_COUNTRY_ZIMBABWE ) // EUR版での対応カントリーコード
#define TWL_COUNTRY_MAPPING_AUSTRALIA (u32)( TWL_COUNTRY_ALBANIA << 16| TWL_COUNTRY_ZIMBABWE ) // AUS版での対応カントリーコード
#define TWL_COUNTRY_MAPPING_CHINA (u32)( TWL_COUNTRY_CHINA << 16| TWL_COUNTRY_CHINA ) // CHI版での対応カントリーコード
#define TWL_COUNTRY_MAPPING_KOREA (u32)( TWL_COUNTRY_SOUTH_KOREA << 16| TWL_COUNTRY_SOUTH_KOREA ) // KOR版での対応カントリーコード
#ifdef __cplusplus
}
#endif
#endif // SDK_CW
#endif // COUNTRY_CODE_H_

6
include/sysmenu/sysmenu_lib/ARM9/sysmenu_api.h
View File

@ -22,7 +22,6 @@
#include <twl/nam.h>
#include <twl/os/common/format_rom.h>
#include <sysmenu/banner.h>
#include <sysmenu/settings.h>
#include <sysmenu/sysmenu_lib/common/sysmenu_work.h>
#include <sysmenu/reloc_info/common/reloc_info.h>
@ -104,11 +103,6 @@ extern BOOL SYSM_IsValidTSD( void ); // TWL
extern void SYSM_SetValidTSD( BOOL valid ); // TWL設定データの有効／無効フラグを設定する。
extern const LauncherParamBody *SYSM_GetLauncherParamBody( void ); // リセットパラメータの取得
// 本体設定データアクセス
extern BOOL SYSM_ReadTWLSettingsFile( void ); // TWL設定データのリード
extern BOOL SYSM_WriteTWLSettingsFile( void ); // TWL設定データのライト
extern void SYSM_VerifyAndRecoveryNTRSettings( void );
// Nintendoロゴ制御
extern BOOL SYSM_CheckNintendoLogo( u16 *pLogoData ); // Nintendoロゴデータのチェック
extern void SYSM_LoadNintendoLogo2D( u16 *pLogoData, u16 *pDst, int paletteColorIndex ); // NintendoロゴデータをOBJ_2D形式でロード（pTempBufferには0x700bytes必要)