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

・TWL設定データおよびNTR設定データライブラリの実装。

Browse Source 
・MachineSettingsでの設定がTWL/NTR設定データの両方に反映されるよう変更。

git-svn-id: file:///Users/lillianskinner/Downloads/platinum/twl/TwlIPL/trunk@103 b08762b0-b915-fc4b-9d8c-17b2551a87ff
This commit is contained in:
yosiokat 2007-11-06 07:56:02 +00:00
parent 1815111691
commit d30ef9bd0b
20 changed files with 1008 additions and 922 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,7 +24,7 @@ SUBDIRS =
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU TARGET_FIRM = SYSTEMMENU
TARGET_PLATFORM = TWL TARGET_PLATFORM = TWL
TWL_ARCHGEN = LIMITED #TWL_ARCHGEN = LIMITED
TWL_PROC = ARM9 TWL_PROC = ARM9
INCDIR = include \ INCDIR = include \

2
build/libraries_sysmenu/mb_loader/ARM7/Makefile
View File

@ -21,7 +21,7 @@ SUBDIRS =
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU TARGET_FIRM = SYSTEMMENU
TARGET_PLATFORM = TWL TARGET_PLATFORM = TWL
TWL_ARCHGEN = LIMITED #TWL_ARCHGEN = LIMITED
TWL_PROC = ARM7 TWL_PROC = ARM7
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------

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

@ -21,7 +21,7 @@ SUBDIRS =
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU TARGET_FIRM = SYSTEMMENU
TARGET_PLATFORM = TWL TARGET_PLATFORM = TWL
TWL_ARCHGEN = LIMITED #TWL_ARCHGEN = LIMITED
TWL_PROC = ARM9 TWL_PROC = ARM9
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------

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

@ -23,11 +23,11 @@ MYSUBDIRS = ./
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU TARGET_FIRM = SYSTEMMENU
TARGET_PLATFORM = TWL TARGET_PLATFORM = TWL
TWL_ARCHGEN = LIMITED #TWL_ARCHGEN = LIMITED
TWL_PROC = ARM9 TWL_PROC = ARM9
SRCS = sysmenu_lib.c sysmenu_card.c sysmenu_util.c gameBoot.c ninLogoFunc.c cmn.c \ SRCS = sysmenu_lib.c sysmenu_card.c sysmenu_util.c gameBoot.c ninLogoFunc.c cmn.c \
nitroSettingsEx.c nitroSettingsEx.c TWLSettings.c settingsAPI.c
TARGET_LIB = libsysmenu$(TWL_LIBSUFFIX).a TARGET_LIB = libsysmenu$(TWL_LIBSUFFIX).a

584
build/libraries_sysmenu/sysmenu/ARM9/src/nitroSettingsEx.c
View File

@ -20,14 +20,15 @@
#include "spi.h" #include "spi.h"
// define data---------------------------------------------------------- // define data----------------------------------------------------------
#if 0
#define DEBUG_Printf OS_TPrintf
#else
#define DEBUG_Printf(...) ((void)0)
#endif
#define NCD_EX_FORCE_ENABLE // このスイッチを定義すると、SYSMバージョンに関わらず強制的にNitroConfigDataExが有効になる。 #define SAVE_COUNT_MAX 0x0080 // NTRSettingsData.saveCountの最大値
// ※実機上では、このフラグのON,OFFに関係なく正常動作するが、アプリビルドをデバッガや他実機で動作させる際に、ここがONでないとダメ。 #define SAVE_COUNT_MASK 0x007f // NTRSettingsData.saveCountの値の範囲をマスクする。(0x00-0x7f）
// 読み込まれていないNCDEXをリードして死亡してしまうので注意。 #define NSD_NOT_CORRECT 0x00ff // NTR設定データが読み出されていない or 有効なものがないことを示す。
#define SAVE_COUNT_MAX 0x0080 // NitroConfigData.saveCountの最大値
#define SAVE_COUNT_MASK 0x007f // NitroConfigData.saveCountの値の範囲をマスクする。(0x00-0x7f）
#define NCD_NOT_CORRECT 0x00ff // NITRO設定データが読み出されていない or 有効なものがないことを示す。
#define NVRAM_RETRY_NUM 8 // NVRAMリトライ回数 #define NVRAM_RETRY_NUM 8 // NVRAMリトライ回数
// NVRAMステータスレジスタ値 // NVRAMステータスレジスタ値
@ -37,7 +38,7 @@
#define READ_IPL2_HEADER_ADDR 0x18 // IPL2ヘッダのうち、読み込みが必要な部分の先頭アドレス #define READ_IPL2_HEADER_ADDR 0x18 // IPL2ヘッダのうち、読み込みが必要な部分の先頭アドレス
#define READ_IPL2_HEADER_SIZE 0x0a // IPL2ヘッダのうち、読み込みが必要なサイズ #define READ_IPL2_HEADER_SIZE 0x0a // IPL2ヘッダのうち、読み込みが必要なサイズ
#define NCD_ROM_ADDR_SHIFT 3 #define NSD_ROM_ADDR_SHIFT 3
// NVRAM関連送信コマンドステート // NVRAM関連送信コマンドステート
static enum NvramCommState{ static enum NvramCommState{
@ -54,38 +55,50 @@ static enum NvramCommState{
// IPL2ヘッダの一部（0x18からのデータ) // IPL2ヘッダの一部（0x18からのデータ)
typedef struct IPL2HeaderPart { typedef struct IPL2HeaderPart {
struct { struct {
u8 timestamp[5]; // IPL2タイムスタンプ [0]:分,[1]:時,[2]:日,[3]:月,[4]:年 u8 timestamp[5]; // NTR-IPL2タイムスタンプ [0]:分,[1]:時,[2]:日,[3]:月,[4]:年
u8 ipl2_type; // IPL2タイプ(nitroConfigData.hで定義のIPL2_TYPE...） u8 ipl2_type; // NTR-IPL2タイプ
u8 rsv[2]; u8 rsv[2];
} version; } version;
u16 ncd_rom_addr; u16 nsd_rom_addr;
u8 pad[ 0x16 ]; // ※キャッシュラインに合わせるためのパディング。本来は必要なし。 u8 pad[ 0x16 ]; // ※キャッシュラインに合わせるためのパディング。本来は必要なし。
} IPL2HeaderPart; // 0x20bytes } IPL2HeaderPart; // 0x20bytes
// function's prototype------------------------------------------------- // function's prototype-------------------------------------------------
static void NCD_ReadIPL2Header( void ); u32 NSD_GetNSDRomAddr( void ); // NTRSettingデータのNVRAM格納アドレスを取得
static int NVRAMm_checkCorrectNCD(NCDStoreEx *ncdsp); u8 NSD_GetIPL2Type( void ); // NTR-IPL2タイプを取得
static BOOL NCD_CheckDataValue( NCDStoreEx *ncdsp ); const u8 *NSD_GetIPL2Timestamp( void ); // NTR-IPL2のタイムスタンプを取得
static BOOL NVRAMm_ExecuteCommand( int nv_state, u32 addr, u16 size, u8 *srcp );
static void Callback_NVRAM(PXIFifoTag tag, u32 data, BOOL err);
// const data----------------------------------------------------------- static void NSDi_ReadIPL2Header( void );
static BOOL NSDi_CheckCorrectNSD( NSDStoreEx (*pNSDStoreExArray)[2], u8 region );
// global variables----------------------------------------------------- static BOOL NSDi_CheckDataValue( NSDStoreEx *pNSDStore, u8 region );
NitroConfigDataEx ncdEx; 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 variables-----------------------------------------------------
static volatile BOOL nv_cb_occurred; static NSDStoreEx s_NSDStoreEx ATTRIBUTE_ALIGN(32);
static volatile u16 nv_result; static IPL2HeaderPart s_IPL2Header ATTRIBUTE_ALIGN(32);
static u16 ena_ncd_num = NCD_NOT_CORRECT; static BOOL s_isReadIPL2H = FALSE;
static u16 next_saveCount; static volatile BOOL s_nvCbOccurred;
static NCDStoreEx ncds[2] ATTRIBUTE_ALIGN(32); static volatile u16 s_nvResult;
static int s_indexNSD = NSD_NOT_CORRECT;
#ifndef SDK_FINALROM
static NSDStoreEx (*s_pNSDStoreExArray)[2];
#endif
// global variables-----------------------------------------------------
NTRSettingsData *g_pNSD = &s_NSDStoreEx.nsd;
NTRSettingsDataEx *g_pNSDEx = &s_NSDStoreEx.nsd_ex;
// const data-----------------------------------------------------------
static const u16 s_validLangBitmapList[] = {
NTR_LANG_BITMAP_WW,
NTR_LANG_BITMAP_CHINA,
NTR_LANG_BITMAP_KOREA,
};
static IPL2HeaderPart ipl2Header ATTRIBUTE_ALIGN(32);
static BOOL read_ipl2h = FALSE;
// function's description----------------------------------------------- // function's description-----------------------------------------------
@ -95,268 +108,287 @@ static BOOL read_ipl2h = FALSE;
// コンポーネント上での使用時 // コンポーネント上での使用時
// IPL2ヘッダの読み出し // IPL2ヘッダの読み出し
static void NCD_ReadIPL2Header( void ) static void NSDi_ReadIPL2Header( void )
{ {
if( !read_ipl2h ) { if( !s_isReadIPL2H ) {
OS_TPrintf( "IPL2Header:%x\n", sizeof(IPL2HeaderPart) ); OS_TPrintf( "IPL2Header:%x\n", sizeof(IPL2HeaderPart) );
DC_InvalidateRange( &ipl2Header, sizeof(IPL2HeaderPart) ); DC_InvalidateRange( &s_IPL2Header, sizeof(IPL2HeaderPart) );
while( !NVRAMm_ExecuteCommand( COMM_RD, READ_IPL2_HEADER_ADDR, READ_IPL2_HEADER_SIZE, (u8 *)&ipl2Header ) ) {} while( !NVRAMm_ExecuteCommand( COMM_RD, READ_IPL2_HEADER_ADDR, READ_IPL2_HEADER_SIZE, (u8 *)&s_IPL2Header ) ) {}
read_ipl2h = TRUE; s_isReadIPL2H = TRUE;
} }
} }
// IPL2タイプの取得 // IPL2タイプの取得
u8 NCD_GetIPL2Type( void ) u8 NSD_GetIPL2Type( void )
{ {
NCD_ReadIPL2Header(); NSDi_ReadIPL2Header();
return ipl2Header.version.ipl2_type; return s_IPL2Header.version.ipl2_type;
} }
// IPL2バージョンの取得 // IPL2タイムスタンプの取得
u8 *NCD_GetIPL2Version( void ) const u8 *NSD_GetIPL2Timestamp( void )
{ {
NCD_ReadIPL2Header(); NSDi_ReadIPL2Header();
return ipl2Header.version.timestamp; return s_IPL2Header.version.timestamp;
} }
// NCD格納ROMアドレスの取得 // NSD格納ROMアドレスの取得
u32 NCD_GetNCDRomAddr( void ) u32 NSD_GetNSDRomAddr( void )
{ {
NCD_ReadIPL2Header(); NSDi_ReadIPL2Header();
return (u32)( ipl2Header.ncd_rom_addr << NCD_ROM_ADDR_SHIFT ); return (u32)( s_IPL2Header.nsd_rom_addr << NSD_ROM_ADDR_SHIFT );
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// NITRO設定データのリード // NTR設定データのリード
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int NVRAMm_ReadNitroConfigData(NitroConfigData *dstp)
// NTR設定データリード済み
BOOL NSD_IsReadSettings( void )
{ {
int result = 0; return ( s_indexNSD != NSD_NOT_CORRECT );
NCDStoreEx *ncdsp = &ncds[ 0 ]; }
BOOL NSD_ReadSettings( u8 region, NSDStoreEx (*pTempBuffer)[2] )
{
NSDStoreEx *pNSDStoreEx = (NSDStoreEx *)pTempBuffer;
#ifndef SDK_FINALROM
s_pNSDStoreExArray = pTempBuffer;
OS_TPrintf( "NSDStoreBuff : %08x %08x\n", &(*s_pNSDStoreExArray)[ 0 ], &(*s_pNSDStoreExArray)[ 1 ] );
#endif
DC_InvalidateRange( ncdsp, sizeof(NCDStoreEx) * 2 ); DC_InvalidateRange( pNSDStoreEx, sizeof(NSDStoreEx) * 2 );
// フラッシュからニ重化されているNITRO設定データを読み出す。 // フラッシュからニ重化されているNTR設定データを読み出す。
while( !NVRAMm_ExecuteCommand( COMM_RD, NCD_GetNCDRomAddr(), sizeof(NCDStoreEx), (u8 *)&ncdsp[0]) ) {} while( !NVRAMm_ExecuteCommand( COMM_RD, NSD_GetNSDRomAddr(), sizeof(NSDStoreEx), (u8 *)&pNSDStoreEx[ 0 ] ) ) {}
while( !NVRAMm_ExecuteCommand( COMM_RD, NCD_GetNCDRomAddr() + SPI_NVRAM_PAGE_SIZE, sizeof(NCDStoreEx), (u8 *)&ncdsp[1]) ) {} while( !NVRAMm_ExecuteCommand( COMM_RD, NSD_GetNSDRomAddr() + SPI_NVRAM_PAGE_SIZE, sizeof(NSDStoreEx), (u8 *)&pNSDStoreEx[ 1 ] ) ) {}
OS_TPrintf("NCD read addr=%08x\n", NCD_GetNCDRomAddr() ); OS_TPrintf("NSD read addr=%08x\n", NSD_GetNSDRomAddr() );
// 読み出したデータのどちらが有効かを判定する。 // 読み出したデータのどちらが有効かを判定する。
if(NVRAMm_checkCorrectNCD(ncdsp)) { if( NSDi_CheckCorrectNSD( pTempBuffer, region ) ) {
next_saveCount = 1; // 有効なNTR設定データを静的バッファに転送
result = 1; MI_CpuCopyFast( (void *)&pNSDStoreEx[ s_indexNSD ], (void *)&s_NSDStoreEx, sizeof(NSDStoreEx) );
goto END; // 有効なデータがなければエラー終了。 }else {
} // 有効なデータがないなら、バッファをクリアする
next_saveCount = (u8)((ncdsp[ena_ncd_num].saveCount + 1) & SAVE_COUNT_MASK); OS_TPrintf( "NSD clear.\n" );
NSD_ClearSettings();
// 有効なNITRO設定データをバッファに転送 return FALSE;
if( dstp != NULL ) {
SVC_CpuCopy( (void *)&ncdsp[ ena_ncd_num ].ncd, (void *)dstp, sizeof(NitroConfigData), 16);
SVC_CpuCopy( (void *)&ncdsp[ ena_ncd_num ].ncd_ex, (void *)&ncdEx, sizeof(NitroConfigDataEx), 16);
} }
END: OS_TPrintf("Use NSD[%d] : saveCount = %d\n", s_indexNSD, s_NSDStoreEx.saveCount);
return result;
return TRUE;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// NITRO設定データのライト // NTR設定データのライト
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void NVRAMm_WriteNitroConfigData( NitroConfigData *srcp ) BOOL NSD_WriteSettings( u8 region )
{ {
NCDStoreEx *ncdsp = &ncds[ 0 ]; int retry;
u16 size = sizeof(NCDStore); u32 nvramAddr;
u32 flash_addr;
int retry;
// まだNITRO設定データがリードされていなければ、リードを行って必要な情報を取得する。 // まだNTR設定データがリードされていなければ、リードを行って必要な情報を取得する。
if( ena_ncd_num == NCD_NOT_CORRECT ) { if( !NSD_IsReadSettings() ) {
if( NVRAMm_ReadNitroConfigData( NULL ) ) { OS_TPrintf( "ERROR: Need call NSD_ReadSetting.\n" );
ena_ncd_num = 0; // 有効なデータがなければ"0"側にライトする。 return FALSE;
}
} }
// NCD のCRC、セーブカウント値、ライトアドレスの算出。 // NSD のCRC、セーブカウント値、ライトアドレスの算出。
ncdsp->ncd = *srcp; // *GetNCDWork();　でも一緒やん。 s_NSDStoreEx.nsd.version = NTR_SETTINGS_DATA_VERSION; // バージョンを現在のものに設定。
ncdsp->ncd.version = NITRO_CONFIG_DATA_VERSION; // バージョンを現在のものに設定。 s_NSDStoreEx.crc16 = SVC_GetCRC16( 0xffff, (const void *)&s_NSDStoreEx.nsd, sizeof(NTRSettingsData) );
ncdsp->crc16 = SVC_GetCRC16( 0xffff, (const void *)&ncdsp->ncd, sizeof(NitroConfigData) ); s_NSDStoreEx.saveCount = (u8)( ( s_NSDStoreEx.saveCount + 1 ) & SAVE_COUNT_MASK );
ncdsp->saveCount = next_saveCount;
next_saveCount = (u8)( ( next_saveCount + 1 ) & SAVE_COUNT_MASK );
// NCD_EXのCRC算出。 // NSD_EXのCRC算出。
#ifndef NCD_EX_FORCE_ENABLE s_NSDStoreEx.nsd_ex.version = NTR_SETTINGS_DATA_EX_VERSION; // バージョンを現在のものに設定。
if( ( NCD_GetIPL2Type() != IPL2_TYPE_NTR_WW ) && ( NCD_GetIPL2Type() & IPL2_TYPE_NCD_EX_FLAG ) ) s_NSDStoreEx.nsd_ex.valid_language_bitmap = s_validLangBitmapList[ region & 0x03 ]; // ※WW,中,韓の３つのみにとりあえず対応
#endif s_NSDStoreEx.crc16_ex = SVC_GetCRC16( 0xffff, (const void *)&s_NSDStoreEx.nsd_ex, sizeof(NTRSettingsDataEx) );
{
ncdsp->ncd_ex = *GetNCDExWork();
ncdsp->ncd_ex.version = NITRO_CONFIG_DATA_EX_VERSION; // バージョンを現在のものに設定。
ncdsp->ncd_ex.valid_language_bitmap = VALID_LANG_BITMAP;
ncdsp->crc16_ex = SVC_GetCRC16( 0xffff, (const void *)&ncdsp->ncd_ex, sizeof(NitroConfigDataEx) );
size = sizeof(NCDStoreEx); // ※書き込みサイズをNCDStoreExに拡張。
}
// NITRO設定データのライト // NTR設定データのライト
DC_FlushRange(ncdsp, sizeof(NCDStoreEx)); DC_FlushRange( &s_NSDStoreEx, sizeof(NSDStoreEx) );
retry = NVRAM_RETRY_NUM; retry = NVRAM_RETRY_NUM;
while( retry-- ) { while( retry-- ) {
ena_ncd_num ^= 0x01; // リトライの度に書き込みアドレスを切り替える。 s_indexNSD ^= 0x01; // リトライの度に書き込みアドレスを切り替える。
flash_addr = NCD_GetNCDRomAddr() + ena_ncd_num * SPI_NVRAM_PAGE_SIZE; nvramAddr = NSD_GetNSDRomAddr() + s_indexNSD * SPI_NVRAM_PAGE_SIZE;
OS_TPrintf("NCD write addr=%08x\n", flash_addr ); OS_TPrintf("NSD write addr=%08x\n", nvramAddr );
if( NVRAMm_ExecuteCommand( COMM_WE, flash_addr, size, (u8 *)ncdsp) ) { if( NVRAMm_ExecuteCommand( COMM_WE, nvramAddr, sizeof(NSDStoreEx), (u8 *)&s_NSDStoreEx ) ) {
OS_TPrintf("NVRAM Write succeeded.\n"); OS_TPrintf("NVRAM Write succeeded.\n");
break; break;
} }
SVC_WaitByLoop( 0x4000 ); SVC_WaitByLoop( 0x4000 );
OS_TPrintf("NVRAM Write retry = %d.\n", NVRAM_RETRY_NUM - retry ); OS_TPrintf("NVRAM Write retry = %d.\n", NVRAM_RETRY_NUM - retry );
} }
}
//----------------------------------------------------------------------
// ミラーリングされているNITRO設定データのどちらが有効かを判定
//----------------------------------------------------------------------
static int NVRAMm_checkCorrectNCD(NCDStoreEx *ncdsp)
{
u16 i;
u16 ncd_valid = 0;
// 各ミラーデータのCRC & saveCount正当性チェック
for(i = 0; i < 2; i++) {
u16 crc;
BOOL invalid = FALSE;
crc = SVC_GetCRC16( 0xffff, (const void *)&ncdsp[i].ncd, sizeof(NitroConfigData) );
if( ( ncdsp[ i ].crc16 != crc ) // CRCが正しく、saveCount値が0x80以下で、かつバージョンが一致するデータを正当と判断。
|| ( ncdsp[ i ].ncd.version != NITRO_CONFIG_DATA_VERSION )
|| ( ncdsp[ i ].saveCount >= SAVE_COUNT_MAX ) ) {
OS_TPrintf("NCD crc error.\n");
invalid = TRUE;
}
// NCDExが有効なIPL2Typeならば、NCDExのCRCチェックを行う。
#ifndef NCD_EX_FORCE_ENABLE
if( ( NCD_GetIPL2Type() != IPL2_TYPE_NTR_WW ) && ( NCD_GetIPL2Type() & IPL2_TYPE_NCD_EX_FLAG ) )
#endif
{
crc = SVC_GetCRC16( 0xffff, (const void *)&ncdsp[i].ncd_ex, sizeof(NitroConfigDataEx) );
if( ( ncdsp[ i ].crc16_ex != crc )
|| ( ncdsp[ i ].ncd_ex.version != NITRO_CONFIG_DATA_EX_VERSION ) ) {
OS_TPrintf("NCDEx crc error.\n");
invalid = TRUE;
}
}
// NCD, NCDExのCRCが正しいなら、データの中身をチェック。
if( !invalid ) {
if( NCD_CheckDataValue( &ncdsp[ i ] ) ) {
ncd_valid |= 0x01 << i; // データがおかしい値でないかもチェック。
ena_ncd_num = i; // 有効なNCDのインデックスを切り替える。
}else {
invalid = TRUE;
}
}
if( ncd_valid & ( 0x01 << i ) ) {
OS_TPrintf("NCD mirror%d is valid.:saveCount = %d\n", i, ncdsp[i].saveCount);
}else {
OS_TPrintf("NCD mirror%d is invalid.\n", i);
}
}
if( ncd_valid == 0 ) {
return 1;
}else if( ncd_valid == 0x03 ) {
// ミラーリングされたNCDが両方ともに正当な場合、セーブカウント値が大きい方を有効とする。
u16 saveCount = (u8)( ( ncdsp[ 0 ].saveCount + 1 ) & SAVE_COUNT_MASK );
if( saveCount != ncdsp[ 1 ].saveCount ) {
ena_ncd_num = 0;
}
}
OS_TPrintf("use NCD mirror%d.:saveCount = %d\n", ena_ncd_num, ncdsp[ena_ncd_num].saveCount);
return 0;
}
// NITRO設定データの値が正しい値かチェック。 // FALSE:正しくない。TRUE：正しい。
static BOOL NCD_CheckDataValue( NCDStoreEx *ncdsp )
{
NitroConfigData *ncdp = &ncdsp->ncd;
NitroConfigDataEx *ncdexp = &ncdsp->ncd_ex;
//ncdp->option;
// NCDのlanguageチェック
if( ~( LANG_BITMAP_WW & VALID_LANG_BITMAP ) & ( 0x0001 << ncdp->option.language ) ) {
OS_TPrintf("NCD: invalid language : org:%02d ex:%02d bitmap:%04x\n",
ncdp->option.language, ncdexp->language, ncdexp->valid_language_bitmap );
return FALSE;
}
// NCDExのlanguageチェック（NCDExが有効なのは、下記のIPL2タイプのもの）
#ifndef NCD_EX_FORCE_ENABLE
if( ( NCD_GetIPL2Type() != IPL2_TYPE_NTR_WW ) && ( NCD_GetIPL2Type() & IPL2_TYPE_NCD_EX_FLAG ) )
#endif
{
if( ( ~VALID_LANG_BITMAP & ( 0x0001 << ncdexp->language ) )
|| ( ncdexp->valid_language_bitmap != VALID_LANG_BITMAP ) ) {
OS_TPrintf("NCDEx: invalid language : org:%02d ex:%02d bitmap:%04x\n",
ncdp->option.language, ncdexp->language, ncdexp->valid_language_bitmap );
return FALSE;
}
}
//ncdp->owner;
// favoriteColorは4bitなので範囲外はない。
// birthday
if( ncdp->option.input_birthday ) {
if( ( ncdp->owner.birthday.month > 12 ) || ( ncdp->owner.birthday.day > 31 ) ) {
OS_TPrintf("NCD: invalid birthday : %02d/%02d\n", ncdp->owner.birthday.month, ncdp->owner.birthday.day );
return FALSE;
}
}
// nickname
if( ncdp->option.input_nickname ) {
if( ncdp->owner.nickname.length > NCD_NICKNAME_LENGTH ) {
OS_TPrintf("NCD: invalid nickname length : %02d\n", ncdp->owner.nickname.length );
return FALSE;
}
}
// comment
if( ncdp->owner.comment.length > NCD_COMMENT_LENGTH ) {
OS_TPrintf("NCD: invalid comment length : %02d\n", ncdp->owner.comment.length );
return FALSE;
}
//ncdp->alarm;
if( ( ncdp->alarm.hour > 23 ) || ( ncdp->alarm.minute > 59 ) ) {
OS_TPrintf("NCD: invalid alarm time : %02d:%02d\n", ncdp->alarm.hour, ncdp->alarm.minute );
return FALSE;
}
//ncdp->tp;
// TPキャリブレーション値は、TP_CalcCalibrateParamで値のチェックをしているので、チェックしない。
OS_TPrintf( "NCD: correct data.\n" );
return TRUE; return TRUE;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// NVRAMへのアクセスルーチン本体 ( nv_state <- COMM_RD or COMM_WE ) // ミラーリングされているNTR設定データのどちらが有効かを判定
//---------------------------------------------------------------------- //----------------------------------------------------------------------
static BOOL NVRAMm_ExecuteCommand( int nv_state, u32 addr, u16 size, u8 *srcp )
static BOOL NSDi_CheckCorrectNSD( NSDStoreEx (*pNSDStoreExArray)[2], u8 region )
{ {
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 ], region ) ) { // データがおかしい値でないかもチェック。
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, u8 region )
{
NTRSettingsData *pNSD = &pNSDStoreEx->nsd;
NTRSettingsDataEx *pNSDEx = &pNSDStoreEx->nsd_ex;
u16 validLangBitmap = s_validLangBitmapList[ region & 0x03 ]; // ※WW,中,韓の３つのみにとりあえず対応
//pNSD->option;
// NSDのlanguageチェック（ NSD側のlanguageは、日・英・独・仏・伊・西の６言語のうちの、対応言語のみの値となる。）
if( ~( NTR_LANG_BITMAP_WW & validLangBitmap ) & ( 0x0001 << pNSD->option.language ) ) {
OS_TPrintf("NSD: invalid language : org:%02d ex:%02d bitmap:%04x\n",
pNSD->option.language, pNSDEx->language, pNSDEx->valid_language_bitmap );
return FALSE;
}
// NSDExのlanguageチェック（こちらには、中・韓も入る）
if( ( ~validLangBitmap & ( 0x0001 << pNSDEx->language ) ) ||
( pNSDEx->valid_language_bitmap != validLangBitmap ) ) {
OS_TPrintf("NSDEx: 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;
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; OSTick start;
BOOL nv_sending = FALSE; BOOL isSending = FALSE;
u8 *nvram_srp = (u8 *)&ncds[1]; u8 *pSR = (u8 *)sr_buf;
PXI_SetFifoRecvCallback( PXI_FIFO_TAG_NVRAM , Callback_NVRAM ); PXI_SetFifoRecvCallback( PXI_FIFO_TAG_NVRAM , Callback_NVRAM );
@ -364,75 +396,75 @@ static BOOL NVRAMm_ExecuteCommand( int nv_state, u32 addr, u16 size, u8 *srcp )
//--------------------------------------- //---------------------------------------
// NVRAMコマンドを発行する // NVRAMコマンドを発行する
//--------------------------------------- //---------------------------------------
if( !nv_sending ) { if( !isSending ) {
nv_cb_occurred = FALSE; s_nvCbOccurred = FALSE;
switch( nv_state ) { switch( nvState ) {
case COMM_RD: case COMM_RD:
nv_sending = SPI_NvramReadDataBytes( addr, size, srcp ); isSending = SPI_NvramReadDataBytes( addr, size, pSrc );
break; break;
case COMM_WE: case COMM_WE:
nv_sending = SPI_NvramWriteEnable(); isSending = SPI_NvramWriteEnable();
break; break;
case COMM_WR: case COMM_WR:
nv_sending = SPI_NvramPageWrite( addr, size , srcp ); isSending = SPI_NvramPageWrite( addr, size , pSrc );
start = OS_GetTick(); start = OS_GetTick();
break; break;
case COMM_RDSR_WE: case COMM_RDSR_WE:
case COMM_RDSR_WR: case COMM_RDSR_WR:
nv_sending = SPI_NvramReadStatusRegister( nvram_srp ); isSending = SPI_NvramReadStatusRegister( pSR );
break; break;
case COMM_SRST: case COMM_SRST:
nv_sending = SPI_NvramSoftwareReset(); isSending = SPI_NvramSoftwareReset();
break; break;
} }
//--------------------------------------- //---------------------------------------
// コマンド実行結果（コールバック発生）を待って結果を処理する // コマンド実行結果（コールバック発生）を待って結果を処理する
//--------------------------------------- //---------------------------------------
}else { // nv_sending == TRUE }else { // isSending == TRUE
if( nv_cb_occurred == TRUE ) { // コールバック発生を待つ。 if( s_nvCbOccurred == TRUE ) { // コールバック発生を待つ。
nv_sending = FALSE; isSending = FALSE;
if( nv_result == SPI_PXI_RESULT_SUCCESS ) { if( s_nvResult == SPI_PXI_RESULT_SUCCESS ) {
switch( nv_state ) { switch( nvState ) {
case COMM_RD: case COMM_RD:
return TRUE; return TRUE;
case COMM_WE: case COMM_WE:
nv_state = COMM_RDSR_WE; nvState = COMM_RDSR_WE;
break; break;
case COMM_WR: case COMM_WR:
nv_state = COMM_RDSR_WR; nvState = COMM_RDSR_WR;
break; break;
case COMM_RDSR_WE: case COMM_RDSR_WE:
case COMM_RDSR_WR: case COMM_RDSR_WR:
DC_InvalidateRange( nvram_srp, 1 ); DC_InvalidateRange( pSR, 1 );
if( nv_state == COMM_RDSR_WE ) { // ライトイネーブル確認ステートなら if( nvState == COMM_RDSR_WE ) { // ライトイネーブル確認ステートなら
if( ( *nvram_srp & SR_WEN ) ) { if( ( *pSR & SR_WEN ) ) {
nv_state = COMM_WR; nvState = COMM_WR;
}else { }else {
OS_TPrintf("NVRAM ERR: Write Enable Invalid.\n"); OS_TPrintf("NVRAM ERR: Write Enable Invalid.\n");
return FALSE; return FALSE;
} }
}else { }else {
if( ( *nvram_srp & SR_WIP ) == 0 ) { // ライト／イレース終了 if( ( *pSR & SR_WIP ) == 0 ) { // ライト／イレース終了
return TRUE; return TRUE;
}else { }else {
if( ( *nvram_srp & SR_EER ) // SR_EERが立っていたらエラー if( ( *pSR & SR_EER ) // SR_EERが立っていたらエラー
|| ( OS_TicksToMilliSeconds( OS_GetTick() - start ) > 4000 ) ) { || ( OS_TicksToMilliSeconds( OS_GetTick() - start ) > 4000 ) ) {
// コマンド発行から4秒経過したらエラー（※保険） // コマンド発行から4秒経過したらエラー（※保険）
OS_TPrintf( "NVRAM SR : %02x\n", *nvram_srp ); DEBUG_Printf( "NVRAM SR : %02x\n", *pSR );
nv_state = COMM_SRST; nvState = COMM_SRST;
}else { }else {
SVC_WaitByLoop( 0x4000 ); SVC_WaitByLoop( 0x4000 );
} }
@ -444,7 +476,7 @@ static BOOL NVRAMm_ExecuteCommand( int nv_state, u32 addr, u16 size, u8 *srcp )
OS_TPrintf("NVRAM ERR: PageErase Timeout and SoftReset.\n"); OS_TPrintf("NVRAM ERR: PageErase Timeout and SoftReset.\n");
return FALSE; return FALSE;
} }
}else { // nv_result != SPI_PXI_RESULT_SUCCESS }else { // s_nvResult != SPI_PXI_RESULT_SUCCESS
OS_TPrintf("NVRAM ERR: NVRAM PXI command failed.\n"); OS_TPrintf("NVRAM ERR: NVRAM PXI command failed.\n");
return FALSE; return FALSE;
} }
@ -463,43 +495,43 @@ static void Callback_NVRAM( PXIFifoTag tag, u32 data, BOOL err )
u16 command = (u16)( ( ( data & SPI_PXI_DATA_MASK ) & 0x7f00 ) >> 8 ); u16 command = (u16)( ( ( data & SPI_PXI_DATA_MASK ) & 0x7f00 ) >> 8 );
nv_result = (u16)( data & 0x00ff ); s_nvResult = (u16)( data & 0x00ff );
nv_cb_occurred = TRUE; // コールバック発生フラグTRUE s_nvCbOccurred = TRUE; // コールバック発生フラグTRUE
if( err ) { if( err ) {
OS_TPrintf("NVRAM-ARM9: Received PXI data is error.\n"); OS_TPrintf("NVRAM-ARM9: Received PXI data is error.\n");
nv_result = 0x00ff; s_nvResult = 0x00ff;
} }
switch(command){ // コマンド名表示 switch(command){ // コマンド名表示
case SPI_PXI_COMMAND_NVRAM_READ: case SPI_PXI_COMMAND_NVRAM_READ:
OS_TPrintf("NVRAM-ARM9:ReadDataBytes"); DEBUG_Printf("NVRAM-ARM9:ReadDataBytes");
break; break;
case SPI_PXI_COMMAND_NVRAM_WREN: case SPI_PXI_COMMAND_NVRAM_WREN:
OS_TPrintf("NVRAM-ARM9:WriteEnable"); DEBUG_Printf("NVRAM-ARM9:WriteEnable");
break; break;
case SPI_PXI_COMMAND_NVRAM_PW: case SPI_PXI_COMMAND_NVRAM_PW:
OS_TPrintf("NVRAM-ARM9:PageWrite"); DEBUG_Printf("NVRAM-ARM9:PageWrite");
break; break;
case SPI_PXI_COMMAND_NVRAM_RDSR: case SPI_PXI_COMMAND_NVRAM_RDSR:
OS_TPrintf("NVRAM-ARM9:ReadStatusRegister"); DEBUG_Printf("NVRAM-ARM9:ReadStatusRegister");
break; break;
case SPI_PXI_COMMAND_NVRAM_WRDI: case SPI_PXI_COMMAND_NVRAM_WRDI:
OS_TPrintf("NVRAM-ARM9:WriteDisable"); DEBUG_Printf("NVRAM-ARM9:WriteDisable");
break; break;
case SPI_PXI_COMMAND_NVRAM_PE: case SPI_PXI_COMMAND_NVRAM_PE:
OS_TPrintf("NVRAM-ARM9:PageErase"); DEBUG_Printf("NVRAM-ARM9:PageErase");
break; break;
case SPI_PXI_COMMAND_NVRAM_SR: case SPI_PXI_COMMAND_NVRAM_SR:
OS_TPrintf("NVRAM-ARM9:SoftwareReset"); DEBUG_Printf("NVRAM-ARM9:SoftwareReset");
break; break;
default: default:
OS_TPrintf("NVRAM-ARM9:?????"); DEBUG_Printf("NVRAM-ARM9:?????");
break; break;
} }
if( nv_result != SPI_PXI_RESULT_SUCCESS ) { if( s_nvResult != SPI_PXI_RESULT_SUCCESS ) {
OS_TPrintf(" Error! ->%x", nv_result ); OS_TPrintf(" Error! ->%x", s_nvResult );
} }
OS_TPrintf("\n"); DEBUG_Printf("\n");
} }

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

@ -55,22 +55,15 @@ void SYSM_RebootTitle( u64 titleID );
static void INTR_SubpIRQ( void ); static void INTR_SubpIRQ( void );
static void SYSMi_CheckCardLoadAddressAndSize( void );
static void LoadRomRegSizeAdjust( CARDRomRegion *romRegp, u32 load_limit_lo, u32 load_limit_hi ); static void LoadRomRegSizeAdjust( CARDRomRegion *romRegp, u32 load_limit_lo, u32 load_limit_hi );
static void SYSMi_ReadyBootNitroGame( void ); static void SYSMi_ReadyBootNitroGame( void );
static BOOL SYSMi_CheckARM7LoadNITROCard( void );
static void SYSMi_MainpRegisterAndRamClear( BOOL isPlatformTWL ); static void SYSMi_MainpRegisterAndRamClear( BOOL isPlatformTWL );
static void ClearMemory( int addr1, int addr2 ); static void ClearMemory( int addr1, int addr2 );
static void SYSMi_CopyInfoFromIPL1( void ); static void SYSMi_CopyInfoFromIPL1( void );
static void SYSMi_ReadNTRSetting( void );
static void SYSMi_ReadTWLSetting( void );
static void SYSMi_VerifyNTRSetting( void );
static BOOL SYSMi_CheckEntryAddress( void );
static void SYSMi_WriteAdjustRTC( void ); static void SYSMi_WriteAdjustRTC( void );
static BOOL SYSMi_SendMessageToARM7( u32 msg ); static BOOL SYSMi_SendMessageToARM7( u32 msg );
static BOOL SYSMi_CheckNitroCardRightly( void );
static int SYSMi_ExistCard( void ); static int SYSMi_ExistCard( void );
static u32 SYSMi_SelectBootType( void ); static u32 SYSMi_SelectBootType( void );
static void SYSMi_DispInitialDebugData( void ); static void SYSMi_DispInitialDebugData( void );
@ -79,10 +72,16 @@ static void SYSMi_DispDebugData( void );
static void DispSingleColorScreen( int mode ); static void DispSingleColorScreen( int mode );
static void SYSMi_ReadCardBannerFile( void ); static void SYSMi_ReadCardBannerFile( void );
static void SYSMi_CheckCardCloneBoot( void );
static BOOL SYSMi_CheckEntryAddress( void );
static BOOL SYSMi_CheckARM7LoadNITROCard( void );
static void SYSMi_CheckCardCloneBoot( void );
static void SYSMi_CheckRTC( void );
// global variable------------------------------------------------------------- // global variable-------------------------------------------------------------
void *(*SYSM_Alloc)( u32 size );
void (*SYSM_Free )( void *ptr );
#ifdef __SYSM_DEBUG #ifdef __SYSM_DEBUG
SharedWork *swp; // デバッガでのIPL1SharedWorkのウォッチ用 SharedWork *swp; // デバッガでのIPL1SharedWorkのウォッチ用
SYSM_work *pSysm; // デバッガでのSYSMワークのウォッチ用 SYSM_work *pSysm; // デバッガでのSYSMワークのウォッチ用
@ -134,7 +133,7 @@ void SYSM_Init( void )
{ {
#ifdef __SYSM_DEBUG #ifdef __SYSM_DEBUG
pSysm = GetSYSMWork(); pSysm = GetSYSMWork();
ncdp = GetNCDWork(); ncdp = GetTSD();
// SYSMi_DispInitialDebugData(); // 初期デバッグ情報表示 // SYSMi_DispInitialDebugData(); // 初期デバッグ情報表示
#endif /* __SYSM_DEBUG */ #endif /* __SYSM_DEBUG */
@ -156,6 +155,13 @@ void SYSM_Init( void )
MI_CpuClearFast(old_titleIdArray, sizeof(old_titleIdArray) ); MI_CpuClearFast(old_titleIdArray, sizeof(old_titleIdArray) );
} }
// システムメニューライブラリ用メモリアロケータの設定
void SYSM_SetAllocFunc( void *(*pAlloc)(u32), void (*pFree)(void*) )
{
SYSM_Alloc = pAlloc;
SYSM_Free = pFree;
}
// ARM7側の初期化待ち // ARM7側の初期化待ち
static void SYSMi_WaitInitARM7( void ) static void SYSMi_WaitInitARM7( void )
@ -166,14 +172,15 @@ static void SYSMi_WaitInitARM7( void )
*/ */
reg_OS_PAUSE |= REG_OS_PAUSE_CHK_MASK; // PAUSEレジスタのチェックフラグのセット reg_OS_PAUSE |= REG_OS_PAUSE_CHK_MASK; // PAUSEレジスタのチェックフラグのセット
SYSMi_ReadTWLSetting(); // NANDからTWL本体設定データをリード // SYSM_ReadHWInfo(); // NANDからHW情報をリード
PMm_SetBackLightBrightness(); SYSM_ReadTWLSettingsFile(); // NANDからTWL本体設定データをリード
SYSMi_ReadNTRSetting(); // NOR からNTR本体設定データをリード
SYSMi_VerifyNTRSetting(); // NVRAMのNTR本体設定データをリードし、不一致箇所があればNTR側をリカバリ。
SYSM_SetBackLightBrightness(); // 読み出したTWL本体設定データをもとにバックライト輝度設定
SYSM_CaribrateTP(); // 読み出したTWL本体設定データをもとにTPキャリブレーション。 SYSM_CaribrateTP(); // 読み出したTWL本体設定データをもとにTPキャリブレーション。
SYSMi_WriteAdjustRTC(); // 読み出したTWL本体設定データをもとにRTCクロック補正値をセット。 SYSMi_WriteAdjustRTC(); // 読み出したTWL本体設定データをもとにRTCクロック補正値をセット。
SYSMi_CheckRTC();
SYSM_VerifyAndRecoveryNTRSettings(); // NTR設定データを読み出して、TWL設定データとベリファイし、必要ならリカバリ
SYSMi_CheckCardCloneBoot(); // カードがクローンブートかチェック SYSMi_CheckCardCloneBoot(); // カードがクローンブートかチェック
SYSMi_ReadCardBannerFile(); // カードバナーファイルの読み出し。 SYSMi_ReadCardBannerFile(); // カードバナーファイルの読み出し。
@ -481,41 +488,6 @@ static void INTR_SubpIRQ( void )
// アプリ起動処理 // アプリ起動処理
// ============================================================================ // ============================================================================
// エントリアドレスの正当性チェック
static BOOL SYSMi_CheckEntryAddress( void )
{
// エントリアドレスがROM内登録エリアかAGBカートリッジエリアなら、無限ループに入る。
if( !( ( (u32)GetRomHeaderAddr()->main_entry_address >= HW_MAIN_MEM )
&& ( (u32)GetRomHeaderAddr()->main_entry_address < SYSM_ARM9_MMEM_ENTRY_ADDR_LIMIT ) )
|| !( ( ( (u32)GetRomHeaderAddr()->sub_entry_address >= HW_MAIN_MEM )
&& ( (u32)GetRomHeaderAddr()->sub_entry_address < SYSM_ARM7_LOAD_MMEM_LAST_ADDR ) )
|| ( ( (u32)GetRomHeaderAddr()->sub_entry_address >= HW_WRAM )
&& ( (u32)GetRomHeaderAddr()->sub_entry_address < SYSM_ARM7_LOAD_WRAM_LAST_ADDR ) ) ) )
{
OS_TPrintf("entry address invalid.\n");
#ifdef __DEBUG_SECURITY_CODE
DispSingleColorScreen( SCREEN_YELLOW );
#endif
return FALSE;
}
OS_TPrintf("entry address valid.\n");
return TRUE;
}
// ARM7によるNITROゲームのロード完了を確認する。
static BOOL SYSMi_CheckARM7LoadNITROCard( void )
{
if( SYSMi_ExistCard()
// && !( SYSM_GetBootFlag() & BFLG_LOAD_CARD_COMPLETED )
) {
return FALSE;
}
return TRUE;
}
// SystemMenuで使用したレジスタ＆メモリのクリア // SystemMenuで使用したレジスタ＆メモリのクリア
static void SYSMi_MainpRegisterAndRamClear( BOOL isPlatformTWL ) static void SYSMi_MainpRegisterAndRamClear( BOOL isPlatformTWL )
{ {
@ -579,80 +551,6 @@ static BOOL SYSMi_IsDebuggerBannerViewMode( void )
} }
// NITRO設定データの読み出し。
static void SYSMi_ReadNTRSetting( void )
{
RTCDate date;
RTCTime time;
GetSYSMWork()->ncd_invalid = NVRAMm_ReadNitroConfigData( GetNCDWork() );
// NVRAMからNITRO設定データをロード。
if( GetSYSMWork()->ncd_invalid ) { // リードしたNITRO設定データが無効だったら、0クリアしたものを使用。
OS_TPrintf(" NCD destroyed.\n" );
SVC_CpuClearFast( 0x0000, GetNCDExWork(), sizeof(NitroConfigDataEx) );
GetNCDExWork()->version = NITRO_CONFIG_DATA_EX_VERSION;
GetNCDWork()->option.backLightBrightness= 2; // 出荷時と同じ値に。
GetNCDWork()->option.language = LANG_ENGLISH; // プリセットが必要なデータはプリセットしておく
GetNCDWork()->option.destroyFlashFlag = 1;
GetNCDWork()->owner.birthday.month = 1;
GetNCDWork()->owner.birthday.day = 1;
GetNCDExWork()->valid_language_bitmap = VALID_LANG_BITMAP;
}
// RTCのリセット or おかしい値を検出した場合は初回起動シーケンスへ。
( void )RTC_GetDateTime( &date, &time );
if( !SYSM_CheckRTCDate( &date ) ||
!SYSM_CheckRTCTime( &time )
#ifndef __IS_DEBUGGER_BUILD // 青デバッガではRTCの電池がないので、毎回ここにひっかかって設定データが片方クリアされてしまう。これを防ぐスイッチ。
|| ( GetSYSMWork()->rtcStatus & 0x01 )
#endif
) { // RTCの異常を検出したら、rtc入力フラグ＆rtcOffsetを0にしてNVRAMに書き込み。
OS_TPrintf("\"RTC reset\" or \"Illegal RTC data\" detect!\n");
GetNCDWork()->option.input_rtc = 0;
GetNCDWork()->option.rtcOffset = 0;
GetNCDWork()->option.rtcLastSetYear = 0;
( void )NVRAMm_WriteNitroConfigData( GetNCDWork() );
}
}
// TWL設定データの読み出し
static void SYSMi_ReadTWLSetting( void )
{
}
// NTR設定とTWL設定をベリファイして、不一致があれば、NTR設定を更新
static void SYSMi_VerifyNTRSetting( void )
{
}
// RTCの日付が正しいかチェック
BOOL SYSM_CheckRTCDate( RTCDate *datep )
{
if( ( datep->year >= 100 )
|| ( datep->month < 1 ) || ( datep->month > 12 )
|| ( datep->day < 1 ) || ( datep->day > 31 )
|| ( datep->week >= RTC_WEEK_MAX ) ) {
return FALSE;
}
return TRUE;
}
// RTCの時刻が正しいかチェック
BOOL SYSM_CheckRTCTime( RTCTime *timep )
{
if( ( timep->hour > 23 )
|| ( timep->minute > 59 )
|| ( timep->second > 59 ) ) {
return FALSE;
}
return TRUE;
}
// バナーファイルの読み込みの実体 // バナーファイルの読み込みの実体
static void SYSMi_ReadCardBannerFile( void ) static void SYSMi_ReadCardBannerFile( void )
@ -702,6 +600,137 @@ static void SYSMi_ReadCardBannerFile( void )
} }
// タッチパネルキャリブレーション
void SYSM_CaribrateTP( void )
{
#ifndef __TP_OFF
TPCalibrateParam calibrate;
( void )TP_CalcCalibrateParam( &calibrate, // タッチパネル初期化
GetTSD()->tp.data.raw_x1, GetTSD()->tp.data.raw_y1, (u16)GetTSD()->tp.data.dx1, (u16)GetTSD()->tp.data.dy1,
GetTSD()->tp.data.raw_x2, GetTSD()->tp.data.raw_y2, (u16)GetTSD()->tp.data.dx2, (u16)GetTSD()->tp.data.dy2 );
TP_SetCalibrateParam( &calibrate );
OS_Printf("TP_calib: %4d %4d %4d %4d %4d %4d\n",
GetTSD()->tp.data.raw_x1, GetTSD()->tp.data.raw_y1, (u16)GetTSD()->tp.data.dx1, (u16)GetTSD()->tp.data.dy1,
GetTSD()->tp.data.raw_x2, GetTSD()->tp.data.raw_y2, (u16)GetTSD()->tp.data.dx2, (u16)GetTSD()->tp.data.dy2 );
#endif
}
// RTCクロック補正値をセット
static void SYSMi_WriteAdjustRTC( void )
{
// ※TWLの時は、NANDの"/sys/HWINFO.dat"ファイルから該当する情報を取得する。
#if 0
FS_OpenFile( "/sys/HWINFO.dat" );
FS_ReadFile( xxxx );
raw = xxxx.rtcRaw;
( void )RTCi_SetRegAdjust( &raw );
#endif
#ifndef __IS_DEBUGGER_BUILD // デバッガ用ビルド時は補正しない。
RTCRawAdjust raw;
raw.adjust = 0;
// raw.adjust = GetTSD()->rtcClockAdjust; // ncd_invalid時にはrtcClockAdjustは
// 0クリアされているため補正機能は使用されない
( void )RTCi_SetRegAdjust( &raw );
#endif /* __IS_DEBUGGER_BUILD */
}
// FIFO経由でARM7にメッセージ通知。※PXI_FIFO_TAG_USER_1を使用。
static BOOL SYSMi_SendMessageToARM7(u32 msg)
{
#pragma unused(msg)
return TRUE;
}
// NTR,TWLカード存在チェック 「リターン　1：カード認識　0：カードなし」
static int SYSMi_ExistCard( void )
{
if( ( GetRomHeaderAddr()->nintendo_logo_crc16 == 0xcf56 ) &&
( GetRomHeaderAddr()->header_crc16 == GetSYSMWork()->cardHeaderCrc16) ) {
return TRUE; // NTR,TWLカードあり（NintendoロゴCRC、カードヘッダCRCが正しい場合）
// ※Nintendoロゴデータのチェックは、特許の都合上、ロゴ表示ルーチン起動後に行います。
}else {
return FALSE; // NTR,TWLカードなし
}
}
// スリープモードへの遷移
void SYSM_GoSleepMode( void )
{
#ifndef __IS_DEBUGGER_BUILD // デバッガ用ビルド時はスリープしない。
PM_GoSleepMode( (PMWakeUpTrigger)( (PAD_DetectFold() ? PM_TRIGGER_COVER_OPEN : 0) | PM_TRIGGER_RTC_ALARM ),
0,
0 );
#endif /* __IS_DEBUGGER_BUILD */
}
// バックライト輝度調整
void SYSM_SetBackLightBrightness( void )
{
( void )PMi_WriteRegister( 4, (u16)TSD_GetBacklightBrightness() );
( void )PM_SetBackLight( PM_LCD_ALL, PM_BACKLIGHT_ON );
}
//======================================================================
// 各種チェック
//======================================================================
// Nintendoロゴチェック 「リターン　1:Nintendoロゴ認識成功　0：失敗」
BOOL SYSM_CheckNinLogo(u16 *logo_cardp)
{
u16 *logo_orgp = (u16 *)SYSROM9_NINLOGO_ADR; // ARM9のシステムROMのロゴデータとカートリッジ内のものを比較
u16 length = NINTENDO_LOGO_LENGTH >> 1;
while(length--) {
if(*logo_orgp++ != *logo_cardp++) return FALSE;
}
return TRUE;
}
// エントリアドレスの正当性チェック
static BOOL SYSMi_CheckEntryAddress( void )
{
// エントリアドレスがROM内登録エリアかAGBカートリッジエリアなら、無限ループに入る。
if( !( ( (u32)GetRomHeaderAddr()->main_entry_address >= HW_MAIN_MEM )
&& ( (u32)GetRomHeaderAddr()->main_entry_address < SYSM_ARM9_MMEM_ENTRY_ADDR_LIMIT ) )
|| !( ( ( (u32)GetRomHeaderAddr()->sub_entry_address >= HW_MAIN_MEM )
&& ( (u32)GetRomHeaderAddr()->sub_entry_address < SYSM_ARM7_LOAD_MMEM_LAST_ADDR ) )
|| ( ( (u32)GetRomHeaderAddr()->sub_entry_address >= HW_WRAM )
&& ( (u32)GetRomHeaderAddr()->sub_entry_address < SYSM_ARM7_LOAD_WRAM_LAST_ADDR ) ) ) )
{
OS_TPrintf("entry address invalid.\n");
#ifdef __DEBUG_SECURITY_CODE
DispSingleColorScreen( SCREEN_YELLOW );
#endif
return FALSE;
}
OS_TPrintf("entry address valid.\n");
return TRUE;
}
// ARM7によるNITROゲームのロード完了を確認する。
static BOOL SYSMi_CheckARM7LoadNITROCard( void )
{
if( SYSMi_ExistCard()
// && !( SYSM_GetBootFlag() & BFLG_LOAD_CARD_COMPLETED )
) {
return FALSE;
}
return TRUE;
}
// クローンブート判定 // クローンブート判定
static void SYSMi_CheckCardCloneBoot( void ) static void SYSMi_CheckCardCloneBoot( void )
{ {
@ -731,91 +760,32 @@ static void SYSMi_CheckCardCloneBoot( void )
} }
// タッチパネルキャリブレーション // 起動時のRTCチェック
void SYSM_CaribrateTP( void ) static void SYSMi_CheckRTC( void )
{ {
#ifndef __TP_OFF RTCDate date;
TPCalibrateParam calibrate; RTCTime time;
( void )TP_CalcCalibrateParam( &calibrate, // タッチパネル初期化 // RTCのリセット or おかしい値を検出した場合は初回起動シーケンスへ。
GetNCDWork()->tp.raw_x1, GetNCDWork()->tp.raw_y1, (u16)GetNCDWork()->tp.dx1, (u16)GetNCDWork()->tp.dy1, ( void )RTC_GetDateTime( &date, &time );
GetNCDWork()->tp.raw_x2, GetNCDWork()->tp.raw_y2, (u16)GetNCDWork()->tp.dx2, (u16)GetNCDWork()->tp.dy2 ); if( !SYSM_CheckRTCDate( &date ) ||
TP_SetCalibrateParam( &calibrate ); !SYSM_CheckRTCTime( &time )
OS_Printf("TP_calib: %4d %4d %4d %4d %4d %4d\n", #ifndef __IS_DEBUGGER_BUILD // 青デバッガではRTCの電池がないので、毎回ここにひっかかって設定データが片方クリアされてしまう。これを防ぐスイッチ。
GetNCDWork()->tp.raw_x1, GetNCDWork()->tp.raw_y1, (u16)GetNCDWork()->tp.dx1, (u16)GetNCDWork()->tp.dy1, || ( GetSYSMWork()->rtcStatus & 0x01 )
GetNCDWork()->tp.raw_x2, GetNCDWork()->tp.raw_y2, (u16)GetNCDWork()->tp.dx2, (u16)GetNCDWork()->tp.dy2 );
#endif #endif
} ) { // RTCの異常を検出したら、rtc入力フラグ＆rtcOffsetを0にしてNVRAMに書き込み。
OS_TPrintf("\"RTC reset\" or \"Illegal RTC data\" detect!\n");
GetTSD()->flags.isSetDateTime = 0;
// RTCクロック補正値をセット GetTSD()->rtcOffset = 0;
static void SYSMi_WriteAdjustRTC( void ) GetTSD()->rtcLastSetYear = 0;
{ // ※※ライトする？
#ifndef __IS_DEBUGGER_BUILD // デバッガ用ビルド時は補正しない。 SYSM_WriteTWLSettingsFile();
RTCRawAdjust raw;
raw.adjust = GetNCDWork()->option.rtcClockAdjust; // ncd_invalid時にはrtcClockAdjustは
// 0クリアされているため補正機能は使用されない
( void )RTCi_SetRegAdjust( &raw );
#endif /* __IS_DEBUGGER_BUILD */
}
// FIFO経由でARM7にメッセージ通知。※PXI_FIFO_TAG_USER_1を使用。
static BOOL SYSMi_SendMessageToARM7(u32 msg)
{
#pragma unused(msg)
return TRUE;
}
// NTR,TWLカード存在チェック 「リターン　1：カード認識　0：カードなし」
static int SYSMi_ExistCard( void )
{
if( ( GetRomHeaderAddr()->nintendo_logo_crc16 == 0xcf56 ) &&
( GetRomHeaderAddr()->header_crc16 == GetSYSMWork()->cardHeaderCrc16) ) {
return TRUE; // NTR,TWLカードあり（NintendoロゴCRC、カードヘッダCRCが正しい場合）
// ※Nintendoロゴデータのチェックは、特許の都合上、ロゴ表示ルーチン起動後に行います。
}else {
return FALSE; // NTR,TWLカードなし
} }
} }
// Nintendoロゴチェック 「リターン　1:Nintendoロゴ認識成功　0：失敗」
BOOL SYSM_CheckNinLogo(u16 *logo_cardp)
{
u16 *logo_orgp = (u16 *)SYSROM9_NINLOGO_ADR; // ARM9のシステムROMのロゴデータとカートリッジ内のものを比較
u16 length = NINTENDO_LOGO_LENGTH >> 1;
while(length--) {
if(*logo_orgp++ != *logo_cardp++) return FALSE;
}
return TRUE;
}
// スリープモードへの遷移
void SYSM_GoSleepMode( void )
{
#ifndef __IS_DEBUGGER_BUILD // デバッガ用ビルド時はスリープしない。
PM_GoSleepMode( (PMWakeUpTrigger)( (PAD_DetectFold() ? PM_TRIGGER_COVER_OPEN : 0) | PM_TRIGGER_RTC_ALARM ),
0,
0 );
#endif /* __IS_DEBUGGER_BUILD */
}
// バックライト輝度調整
void PMm_SetBackLightBrightness( void )
{
( void )PMi_WriteRegister( 4, (u16)NCD_GetBackLightBrightness() );
( void )PM_SetBackLight( PM_LCD_ALL, PM_BACKLIGHT_ON );
}
//====================================================================== //======================================================================
// デバッグ関数 // デバッグ
//====================================================================== //======================================================================
// 初期データのデバッグ表示 // 初期データのデバッグ表示

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

@ -23,7 +23,7 @@
// extern data------------------------------------------ // extern data------------------------------------------
// function's prototype declaration--------------------- // function's prototype declaration---------------------
static s64 SYSMi_CalcRtcSecOffset( RTCDate *datep, RTCTime *timep ); static s64 SYSMi_CalcRTCSecOffset( RTCDate *datep, RTCTime *timep );
// global variable ------------------------------------- // global variable -------------------------------------
@ -33,30 +33,12 @@ static s64 SYSMi_CalcRtcSecOffset( RTCDate *datep, RTCTime *timep );
// function's description------------------------------- // function's description-------------------------------
//======================================================================
// NITRO設定データ　ワーク制御
//======================================================================
// NITRO設定データのニックネーム・色・誕生日の初期化。
void NCD_ClearOwnerInfo( void )
{
NitroConfigData *ncdp = GetNCDWork();
MI_CpuClear16( &ncdp->owner, sizeof(NvOwnerInfo) );
ncdp->owner.birthday.month = 1;
ncdp->owner.birthday.day = 1;
ncdp->option.input_birthday = 0;
ncdp->option.input_favoriteColor = 0;
ncdp->option.input_nickname = 0;
}
//====================================================================== //======================================================================
// RTCオフセット制御 // RTCオフセット制御
//====================================================================== //======================================================================
// RTCに新しい設定値をセットして、その値をもとにrtcOffset値を算出する。 // RTCに新しい設定値をセットして、その値をもとにrtcOffset値を算出する。
s64 SYSM_CalcRtcOffsetAndSetDateTime( RTCDate *newDatep, RTCTime *newTimep ) s64 SYSM_CalcRTCOffsetAndSetDateTime( RTCDate *newDatep, RTCTime *newTimep )
{ {
RTCDate oldDate; RTCDate oldDate;
RTCTime oldTime; RTCTime oldTime;
@ -70,14 +52,14 @@ s64 SYSM_CalcRtcOffsetAndSetDateTime( RTCDate *newDatep, RTCTime *newTimep )
oldTime.second = 0; oldTime.second = 0;
// RTC設定時は、今回の設定でどれだけRTC値が変化したか（秒オフセット単位）を算出。 // RTC設定時は、今回の設定でどれだけRTC値が変化したか（秒オフセット単位）を算出。
if( ( oldDate.year < NCD_GetRtcLastSetYear() ) && ( NCD_GetInputRTC() ) ) { if( ( oldDate.year < TSD_GetRTCLastSetYear() ) && ( TSD_IsSetDateTime() ) ) {
oldDate.year += 100; // 前回の設定～今回の設定の間にRTCが一周してしまったら、yearは100を加算してoffsetを計算する。 oldDate.year += 100; // 前回の設定～今回の設定の間にRTCが一周してしまったら、yearは100を加算してoffsetを計算する。
} }
NCD_SetRtcLastSetYear( (u8)newDatep->year ); TSD_SetRTCLastSetYear( (u8)newDatep->year );
offset0 = SYSMi_CalcRtcSecOffset( &oldDate, &oldTime ); // 設定直前のRTC値のオフセットを算出 offset0 = SYSMi_CalcRTCSecOffset( &oldDate, &oldTime ); // 設定直前のRTC値のオフセットを算出
offset1 = SYSMi_CalcRtcSecOffset( newDatep, newTimep ); // 新しくセットされたRTC値のオフセットを算出 offset1 = SYSMi_CalcRTCSecOffset( newDatep, newTimep ); // 新しくセットされたRTC値のオフセットを算出
offset = NCD_GetRtcOffset() + offset1 - offset0; // 新RTC_ofs と 現在のRTC_ofs の差分の値を加算してリターン。 offset = 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", OS_Printf ("Now Date = year:%3d month:%3d date:%3d hour:%3d minute:%3d second:%3d\n",
oldDate.year, oldDate.month, oldDate.day, oldDate.year, oldDate.month, oldDate.day,
@ -95,7 +77,7 @@ s64 SYSM_CalcRtcOffsetAndSetDateTime( RTCDate *newDatep, RTCTime *newTimep )
// RTCオフセット値の算出 // RTCオフセット値の算出
#define SECOND_OFFSET #define SECOND_OFFSET
static s64 SYSMi_CalcRtcSecOffset( RTCDate *datep, RTCTime *timep ) static s64 SYSMi_CalcRTCSecOffset( RTCDate *datep, RTCTime *timep )
{ {
u32 i; u32 i;
int uruu = 0; int uruu = 0;
@ -160,6 +142,7 @@ u32 SYSM_GetDayNum( u32 year, u32 month )
} }
*/ */
// 簡易うるう年の判定 (うるう年：1、通常の年：0）※RTCのとりうる範2000～2100年に限定する。 // 簡易うるう年の判定 (うるう年：1、通常の年：0）※RTCのとりうる範2000～2100年に限定する。
BOOL SYSM_IsLeapYear100( u32 year ) BOOL SYSM_IsLeapYear100( u32 year )
{ {
@ -170,3 +153,28 @@ BOOL SYSM_IsLeapYear100( u32 year )
} }
} }
// RTCの日付が正しいかチェック
BOOL SYSM_CheckRTCDate( RTCDate *datep )
{
if( ( datep->year >= 100 )
|| ( datep->month < 1 ) || ( datep->month > 12 )
|| ( datep->day < 1 ) || ( datep->day > 31 )
|| ( datep->week >= RTC_WEEK_MAX ) ) {
return FALSE;
}
return TRUE;
}
// RTCの時刻が正しいかチェック
BOOL SYSM_CheckRTCTime( RTCTime *timep )
{
if( ( timep->hour > 23 )
|| ( timep->minute > 59 )
|| ( timep->second > 59 ) ) {
return FALSE;
}
return TRUE;
}

4
build/systemMenu_RED/MachineSettings/ARM9/Makefile
View File

@ -16,13 +16,13 @@
# $Author: $ # $Author: $
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
SUBDIRS = SUBDIRS = ../../../libraries_sysmenu/sysmenu
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
TARGET_FIRM = SYSTEMMENU TARGET_FIRM = SYSTEMMENU
TARGET_PLATFORM = TWL TARGET_PLATFORM = TWL
TWL_ARCHGEN = LIMITED #TWL_ARCHGEN = LIMITED
TARGET_BIN = main.srl TARGET_BIN = main.srl

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

@ -55,7 +55,7 @@ static const u16 *s_pStrSetting[ SETTING_MENU_ELEMENT_NUM ]; //
//=============================================== //===============================================
// mainMenu.c // mainMenu.c
//=============================================== //===============================================
static const u16 *const s_pStrSettingElemTbl[ SETTING_MENU_ELEMENT_NUM ][ LANG_CODE_MAX ] = { static const u16 *const s_pStrSettingElemTbl[ SETTING_MENU_ELEMENT_NUM ][ TWL_LANG_CODE_MAX ] = {
{ {
(const u16 *)L"言語", (const u16 *)L"言語",
(const u16 *)L"LANGUAGE", (const u16 *)L"LANGUAGE",
@ -126,13 +126,10 @@ void MachineSettingInit( void )
NNS_G2dCharCanvasClear( &gCanvas, TXT_COLOR_WHITE ); NNS_G2dCharCanvasClear( &gCanvas, TXT_COLOR_WHITE );
PutStringUTF16( 0, 0, TXT_COLOR_BLUE, (const u16 *)L"MACHINE SETTINGS" ); PutStringUTF16( 0, 0, TXT_COLOR_BLUE, (const u16 *)L"MACHINE SETTINGS" );
#ifdef __NCD_CLEAR_ENABLE
(void)PutStringUTF16( 18 * 8, 21 * 8, TXT_COLOR_BLACK, (const u16 *)L"[START]:NCD clear.");
#endif /* __NCD_CLEAR_ENABLE */
// NITRO設定データのlanguageに応じたメインメニュー構成言語の切り替え // NITRO設定データのlanguageに応じたメインメニュー構成言語の切り替え
for( i = 0; i < SETTING_MENU_ELEMENT_NUM; i++ ) { for( i = 0; i < SETTING_MENU_ELEMENT_NUM; i++ ) {
s_pStrSetting[ i ] = s_pStrSettingElemTbl[ i ][ GetNCDWork()->option.language ]; s_pStrSetting[ i ] = s_pStrSettingElemTbl[ i ][ TSD_GetLanguage() ];
} }
DrawMenu( s_csr, &s_settingParam ); DrawMenu( s_csr, &s_settingParam );
@ -194,22 +191,6 @@ int MachineSettingMain( void )
} }
} }
#ifdef __NCD_CLEAR_ENABLE
if( pad.trg & PAD_BUTTON_START ) {
SVC_CpuClearFast( 0x0000, GetNCDWork(), sizeof(NitroConfigData) );
(void)SPI_NvramWriteEnable();
SVC_WaitVBlankIntr();
(void)SPI_NvramPageErase( 0x3fe00 );
SVC_WaitVBlankIntr();
(void)SPI_NvramWriteEnable();
SVC_WaitVBlankIntr();
(void)SPI_NvramPageErase( 0x3ff00 );
SVC_WaitVBlankIntr();
(void)SPI_NvramWriteDisable();
OS_TPrintf("NitroConfigData zero clear!!\n");
}
#endif /* __NCD_CLEAR_ENABLE */
return 0; return 0;
} }
@ -242,27 +223,27 @@ void CheckOKCancelButton(BOOL *tp_ok, BOOL *tp_cancel)
static BOOL InitialSetting( void ) static BOOL InitialSetting( void )
{ {
#if 0 #if 0
if(GetNCDWork()->option.input_language == 0) { // 言語設定がまだ。 if( !TSD_GetFlagLanguage() ) { // 言語設定がまだ。
g_initialSet = TRUE; g_initialSet = TRUE;
s_csr = 2; s_csr = 2;
SelectLangageInit(); SelectLangageInit();
g_pNowProcess = SelectLanguageMain; g_pNowProcess = SelectLanguageMain;
return TRUE; return TRUE;
}else if(GetNCDWork()->option.input_tp == 0) { // TPキャリブレーションがまだ。 }else if( !TSD_GetFlagTP() ) { // TPキャリブレーションがまだ。
g_initialSet = TRUE; g_initialSet = TRUE;
s_csr = 3; s_csr = 3;
TP_CalibrationInit(); TP_CalibrationInit();
g_pNowProcess = TP_CalibrationMain; g_pNowProcess = TP_CalibrationMain;
return TRUE; return TRUE;
}else if(GetNCDWork()->option.input_rtc == 0) { // RTC設定がまだ。 }else if( !TSD_GetFlagDateTime() ) { // RTC設定がまだ。
ClearRTC(); ClearRTC();
g_initialSet = TRUE; g_initialSet = TRUE;
s_csr = 1; s_csr = 1;
SetRTCInit(); SetRTCInit();
g_pNowProcess = SetRTCMain; g_pNowProcess = SetRTCMain;
return TRUE; return TRUE;
}else if( (GetNCDWork()->option.input_nickname == 0) // ニックネームまたは好きな色入力がまだ。 }else if( !TSD_GetFlagNickname() || // ニックネームまたは好きな色入力がまだ。
|| (GetNCDWork()->option.input_favoriteColor == 0) ) { !TSD_GetFlagUserColor() ) {
/* g_initialSet = TRUE; /* g_initialSet = TRUE;
s_csr = 0; s_csr = 0;
SetOwnerInfoInit(); SetOwnerInfoInit();

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

@ -71,6 +71,7 @@ typedef struct CalibWork {
u16 last_y; u16 last_y;
TPData sample[2]; TPData sample[2];
TPCalibrateParam calibrate; TPCalibrateParam calibrate;
TWLTPCalibData calibData;
}CalibWork; }CalibWork;
// extern data------------------------------------------ // extern data------------------------------------------
@ -406,20 +407,23 @@ int TP_CalibrationMain( void )
} }
if( ( pad.trg & PAD_BUTTON_A ) || tp_ok ) { if( ( pad.trg & PAD_BUTTON_A ) || tp_ok ) {
GetSYSMWork()->ncd_invalid = 0; GetSYSMWork()->ncd_invalid = 0;
GetNCDWork()->option.input_tp = 1; // タッチパネル入力フラグを立てる。
GetNCDWork()->tp.raw_x1 = s_pCw->sample[0].x; s_pCw->calibData.data.raw_x1 = s_pCw->sample[0].x;
GetNCDWork()->tp.raw_y1 = s_pCw->sample[0].y; s_pCw->calibData.data.raw_y1 = s_pCw->sample[0].y;
GetNCDWork()->tp.dx1 = 32; s_pCw->calibData.data.dx1 = 32;
GetNCDWork()->tp.dy1 = 32; s_pCw->calibData.data.dy1 = 32;
GetNCDWork()->tp.raw_x2 = s_pCw->sample[1].x; s_pCw->calibData.data.raw_x2 = s_pCw->sample[1].x;
GetNCDWork()->tp.raw_y2 = s_pCw->sample[1].y; s_pCw->calibData.data.raw_y2 = s_pCw->sample[1].y;
GetNCDWork()->tp.dx2 = DISP_X_SIZE - 32; s_pCw->calibData.data.dx2 = DISP_X_SIZE - 32;
GetNCDWork()->tp.dy2 = DISP_Y_SIZE - 32; s_pCw->calibData.data.dy2 = DISP_Y_SIZE - 32;
TSD_SetTPCalibration( &s_pCw->calibData );
TSD_SetFlagTP( TRUE ); // タッチパネル入力フラグを立てる。
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData( GetNCDWork() ); (void)SYSM_WriteTWLSettingsFile();
ReturnMenu(); ReturnMenu();
return 0; return 0;
@ -438,8 +442,8 @@ int TP_CalibrationMain( void )
if( ( pad.trg & PAD_BUTTON_B ) || tp_cancel ){ if( ( pad.trg & PAD_BUTTON_B ) || tp_cancel ){
(void)TP_CalcCalibrateParam( (void)TP_CalcCalibrateParam(
&s_pCw->calibrate, &s_pCw->calibrate,
GetNCDWork()->tp.raw_x1, GetNCDWork()->tp.raw_y1, (u16)GetNCDWork()->tp.dx1, (u16)GetNCDWork()->tp.dy1, s_pCw->calibData.data.raw_x1, s_pCw->calibData.data.raw_y1, (u16)s_pCw->calibData.data.dx1, (u16)s_pCw->calibData.data.dy1,
GetNCDWork()->tp.raw_x2, GetNCDWork()->tp.raw_y2, (u16)GetNCDWork()->tp.dx2, (u16)GetNCDWork()->tp.dy2 ); s_pCw->calibData.data.raw_x2, s_pCw->calibData.data.raw_y2, (u16)s_pCw->calibData.data.dx2, (u16)s_pCw->calibData.data.dy2 );
TP_SetCalibrateParam( &s_pCw->calibrate ); TP_SetCalibrateParam( &s_pCw->calibrate );
ReturnMenu(); ReturnMenu();
return 0; return 0;
@ -452,7 +456,7 @@ int TP_CalibrationMain( void )
// ƒ<>ƒjƒ…<C692>[‚É–ß‚é // ƒ<>ƒjƒ…<C692>[‚É–ß‚é
static void ReturnMenu( void ) static void ReturnMenu( void )
{ {
NNS_FndFreeToAllocator( &g_allocator, s_pCw ); // キャリブレーション用変数の開放 Free( s_pCw ); // キャリブレーション用変数の開放
s_pCw = NULL; s_pCw = NULL;
OS_Printf("Free :CalibWork\n"); OS_Printf("Free :CalibWork\n");
MachineSettingInit(); MachineSettingInit();
@ -474,7 +478,7 @@ void TP_CalibrationInit( void )
DisplayInit(); DisplayInit();
s_pCw = NNS_FndAllocFromAllocator( &g_allocator, sizeof(CalibWork) ); // キャリブレーション用変数の確保 s_pCw = Alloc( sizeof(CalibWork) ); // キャリブレーション用変数の確保
if( s_pCw == NULL ) { if( s_pCw == NULL ) {
OS_Panic("ARM9- Fail to allocate memory...\n"); OS_Panic("ARM9- Fail to allocate memory...\n");
} }

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

@ -24,12 +24,9 @@
// define data----------------------------------------------------------------- // define data-----------------------------------------------------------------
// function's prototype------------------------------------------------------- // function's prototype-------------------------------------------------------
static void InitAllocator( NNSFndAllocator* pAllocator );
static void InitAllocSystem( void );
static void INTR_VBlank( void ); static void INTR_VBlank( void );
// global variable------------------------------------------------------------- // global variable-------------------------------------------------------------
NNSFndAllocator g_allocator;
int (*g_pNowProcess)( void ); int (*g_pNowProcess)( void );
RTCDrawProperty g_rtcDraw = { RTCDrawProperty g_rtcDraw = {
TRUE, RTC_DATE_TOP_X, RTC_DATE_TOP_Y, RTC_TIME_TOP_X, RTC_TIME_TOP_Y TRUE, RTC_DATE_TOP_X, RTC_DATE_TOP_Y, RTC_TIME_TOP_X, RTC_TIME_TOP_Y
@ -54,6 +51,7 @@ void TwlMain(void)
GX_Init(); GX_Init();
GX_SetPower(GX_POWER_ALL); // 各ロジック パワーON GX_SetPower(GX_POWER_ALL); // 各ロジック パワーON
FS_Init( 3 );
// 割り込み許可---------------------------- // 割り込み許可----------------------------
(void)OS_SetIrqFunction(OS_IE_V_BLANK, INTR_VBlank); (void)OS_SetIrqFunction(OS_IE_V_BLANK, INTR_VBlank);
@ -65,12 +63,16 @@ void TwlMain(void)
(void)RTC_Init(); (void)RTC_Init();
// システムの初期化------------------ // システムの初期化------------------
InitAllocator( &g_allocator ); InitAllocator();
CMN_InitFileSystem( &g_allocator ); SYSM_SetAllocFunc( Alloc, Free );
// NitroConfigDataのリード // ※本来ならランチャーからのパラメータチェックを行い、
(void)NVRAMm_ReadNitroConfigData( GetNCDWork() ); // 初回起動シーケンスに入るパスがある
SYSM_CaribrateTP();
// TWL設定のリード
if( SYSM_ReadTWLSettingsFile() ) {
SYSM_CaribrateTP();
}
InitBG(); InitBG();
GetAndDrawRTCData( &g_rtcDraw, TRUE ); GetAndDrawRTCData( &g_rtcDraw, TRUE );
@ -88,23 +90,6 @@ void TwlMain(void)
} }
// アロケータの初期化
static void InitAllocator( NNSFndAllocator* pAllocator )
{
u32 arenaLow = MATH_ROUNDUP ( (u32)OS_GetMainArenaLo(), 16 );
u32 arenaHigh = MATH_ROUNDDOWN( (u32)OS_GetMainArenaHi(), 16 );
u32 heapSize = arenaHigh - arenaLow;
void* heapMemory = OS_AllocFromMainArenaLo( heapSize, 16 );
NNSFndHeapHandle heapHandle;
SDK_NULL_ASSERT( pAllocator );
heapHandle = NNS_FndCreateExpHeap( heapMemory, heapSize );
SDK_ASSERT( heapHandle != NNS_FND_HEAP_INVALID_HANDLE );
NNS_FndInitAllocatorForExpHeap( pAllocator, heapHandle, 4 );
}
// ============================================================================ // ============================================================================
// 割り込み処理 // 割り込み処理
// ============================================================================ // ============================================================================

47
build/systemMenu_RED/MachineSettings/ARM9/src/misc.c
View File

@ -80,9 +80,9 @@ static void InitScreen( void );
static void InitCanvas( void ); static void InitCanvas( void );
// global variable------------------------------------------------------------- // global variable-------------------------------------------------------------
KeyWork pad; // キーパッド入力データ KeyWork pad; // キーパッド入力データ
TpWork tpd; // タッチパネル入力データ TpWork tpd; // タッチパネル入力データ
NNSFndAllocator g_allocator; // メモリアロケータ
NNSG2dFont gFont; // フォント NNSG2dFont gFont; // フォント
NNSG2dCharCanvas gCanvas; // CharCanvas NNSG2dCharCanvas gCanvas; // CharCanvas
NNSG2dTextCanvas gTextCanvas; // TextCanvas NNSG2dTextCanvas gTextCanvas; // TextCanvas
@ -112,8 +112,45 @@ const u8 *const g_strWeek[] ATTRIBUTE_ALIGN(2) = {
(const u8 *)"SAT", (const u8 *)"SAT",
}; };
// ============================================================================ // ============================================================================
// function's description // メモリ管理
// ============================================================================
// アロケータの初期化
void InitAllocator( void )
{
NNSFndAllocator *pAllocator = &g_allocator;
u32 arenaLow = MATH_ROUNDUP ( (u32)OS_GetMainArenaLo(), 16 );
u32 arenaHigh = MATH_ROUNDDOWN( (u32)OS_GetMainArenaHi(), 16 );
u32 heapSize = arenaHigh - arenaLow;
void* heapMemory = OS_AllocFromMainArenaLo( heapSize, 16 );
NNSFndHeapHandle heapHandle;
SDK_NULL_ASSERT( pAllocator );
heapHandle = NNS_FndCreateExpHeap( heapMemory, heapSize );
SDK_ASSERT( heapHandle != NNS_FND_HEAP_INVALID_HANDLE );
NNS_FndInitAllocatorForExpHeap( pAllocator, heapHandle, 32 );
}
// メモリ割り当て
void *Alloc( u32 size )
{
return NNS_FndAllocFromAllocator( &g_allocator, size );
}
// メモリ解放
void Free( void *pBuffer )
{
NNS_FndFreeToAllocator( &g_allocator, pBuffer );
}
// ============================================================================
// 画面設定
// ============================================================================ // ============================================================================
// BG初期化 // BG初期化
@ -198,6 +235,8 @@ static void InitScreen( void )
// 文字列描画の初期化 // 文字列描画の初期化
static void InitCanvas( void ) static void InitCanvas( void )
{ {
CMN_InitFileSystem( &g_allocator );
// フォントを読み込みます // フォントを読み込みます
{ {
void* pFontFile; void* pFontFile;

19
build/systemMenu_RED/MachineSettings/ARM9/src/misc.h
View File

@ -134,17 +134,20 @@ typedef struct RTCDrawProperty {
}RTCDrawProperty; }RTCDrawProperty;
// global variables-------------------------------------------------- // global variables--------------------------------------------------
extern TpWork tpd; // タッチパネルデータ extern TpWork tpd; // タッチパネルデータ
extern KeyWork pad; // キーパッド入力データ extern KeyWork pad; // キーパッド入力データ
extern const u8 *const g_strWeek[ 7 ]; // 曜日文字列 extern const u8 *const g_strWeek[ 7 ]; // 曜日文字列
extern RTCDrawProperty g_rtcDraw; extern RTCDrawProperty g_rtcDraw;
extern NNSFndAllocator g_allocator; // メモリアロケータ extern NNSFndAllocator g_allocator; // メモリアロケータ
extern NNSG2dFont gFont; // フォント extern NNSG2dFont gFont; // フォント
extern NNSG2dCharCanvas gCanvas; // CharCanvas extern NNSG2dCharCanvas gCanvas; // CharCanvas
extern NNSG2dTextCanvas gTextCanvas; // TextCanvas extern NNSG2dTextCanvas gTextCanvas; // TextCanvas
// function------------------------------------------------------------- // function-------------------------------------------------------------
void InitAllocator( void );
void *Alloc( u32 size );
void Free( void *pBuffer );
void InitBG( void ); void InitBG( void );
int GetPrintfWidth( const NNSG2dTextCanvas *pCanvas, const char *fmt, ... ); int GetPrintfWidth( const NNSG2dTextCanvas *pCanvas, const char *fmt, ... );
void PutStringUTF16 ( int x, int y, int color, const u16 *strUTF16 ); void PutStringUTF16 ( int x, int y, int color, const u16 *strUTF16 );

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

@ -32,7 +32,7 @@
// global variable ------------------------------------- // global variable -------------------------------------
// static variable ------------------------------------- // static variable -------------------------------------
static NvLangCode s_langCode; // 言語コード static TWLLangCode s_langCode; // 言語コード
// const data ----------------------------------------- // const data -----------------------------------------
static const u16 *const s_pStrLanguage[] = { static const u16 *const s_pStrLanguage[] = {
@ -81,10 +81,10 @@ void SelectLanguageInit( void )
} }
if( ( GetSYSMWork()->ncd_invalid ) || if( ( GetSYSMWork()->ncd_invalid ) ||
( GetNCDWork()->option.language >= LANG_CODE_MAX ) ) { ( TSD_GetLanguage() >= TWL_LANG_CODE_MAX ) ) {
s_langCode = LANG_ENGLISH; s_langCode = TWL_LANG_ENGLISH;
}else { }else {
s_langCode = (NvLangCode)GetNCDWork()->option.language; s_langCode = TSD_GetLanguage();
} }
DrawMenu( (u16)s_langCode, &langSel ); DrawMenu( (u16)s_langCode, &langSel );
@ -109,13 +109,13 @@ int SelectLanguageMain( void )
// キー入力処理 // キー入力処理
//-------------------------------------- //--------------------------------------
if( pad.trg & PAD_KEY_DOWN ) { // カーソルの移動 if( pad.trg & PAD_KEY_DOWN ) { // カーソルの移動
if( ++s_langCode == LANG_CODE_MAX ) { if( ++s_langCode == TWL_LANG_CODE_MAX ) {
s_langCode = (NvLangCode)0; s_langCode = (TWLLangCode)0;
} }
} }
if( pad.trg & PAD_KEY_UP ) { if( pad.trg & PAD_KEY_UP ) {
if( --s_langCode < 0 ) { if( --s_langCode < 0 ) {
s_langCode = (NvLangCode)( LANG_CODE_MAX - 1 ); s_langCode = (TWLLangCode)( TWL_LANG_CODE_MAX - 1 );
} }
} }
tp_select = SelectMenuByTP( (u16 *)&s_langCode, &langSel ); tp_select = SelectMenuByTP( (u16 *)&s_langCode, &langSel );
@ -129,12 +129,14 @@ int SelectLanguageMain( void )
if( ( pad.trg & PAD_BUTTON_A ) || tp_select ) { // メニュー項目への分岐 if( ( pad.trg & PAD_BUTTON_A ) || tp_select ) { // メニュー項目への分岐
GetSYSMWork()->ncd_invalid = 0; GetSYSMWork()->ncd_invalid = 0;
GetNCDWork()->option.input_language = 1; // 言語入力フラグを立てる
GetNCDWork()->option.language = s_langCode; TSD_SetLanguage( s_langCode );
TSD_SetFlagLanguage( TRUE ); // 言語入力フラグを立てる
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData( GetNCDWork() ); (void)SYSM_WriteTWLSettingsFile();
MachineSettingInit(); MachineSettingInit();
return 0; return 0;
}else if( ( pad.trg & PAD_BUTTON_B ) || tp_cancel ) { }else if( ( pad.trg & PAD_BUTTON_B ) || tp_cancel ) {

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

@ -80,7 +80,7 @@ typedef struct Nickname {
u8 change_flag; // 変更フラグ u8 change_flag; // 変更フラグ
u8 length; // 文字数 u8 length; // 文字数
u8 pad; u8 pad;
u16 str[NCD_NICKNAME_LENGTH + 1]; // ニックネームコード u16 str[TWL_NICKNAME_LENGTH + 1]; // ニックネームコード
}Nickname; }Nickname;
// カーソルX,Y位置（キャラ単位） // カーソルX,Y位置（キャラ単位）
@ -189,7 +189,7 @@ static const u16 *str_button[] = { NULL,
void SEQ_OwnerInfo_init(void) void SEQ_OwnerInfo_init(void)
{ {
u16 x,y; u16 x,y;
u16 temp[NCD_NICKNAME_LENGTH + 1]; u16 temp[TWL_NICKNAME_LENGTH + 1];
GXS_SetVisiblePlane(GX_PLANEMASK_NONE); GXS_SetVisiblePlane(GX_PLANEMASK_NONE);
@ -202,7 +202,7 @@ void SEQ_OwnerInfo_init(void)
(void)DrawStringSJIS( RETURN_BUTTON_LT_X, RETURN_BUTTON_LT_Y,HIGHLIGHT_C, (const u8 *)" RETURN "); (void)DrawStringSJIS( RETURN_BUTTON_LT_X, RETURN_BUTTON_LT_Y,HIGHLIGHT_C, (const u8 *)" RETURN ");
if(ow == NULL) { if(ow == NULL) {
ow = NNS_FndAllocFromAllocator( &g_allocator, sizeof(OwnerWork) ); // オーナー情報編集用ワークの確保 ow = Alloc( sizeof(OwnerWork) ); // オーナー情報編集用ワークの確保
#ifdef __SYSM_DEBUG #ifdef __SYSM_DEBUG
if(ow == NULL) OS_Panic("ARM9- Fail to allocate memory...\n"); if(ow == NULL) OS_Panic("ARM9- Fail to allocate memory...\n");
#endif /* __SYSM_DEBUG */ #endif /* __SYSM_DEBUG */
@ -214,19 +214,21 @@ void SEQ_OwnerInfo_init(void)
{ {
u32 dayNum; u32 dayNum;
if(GetNCDWork()->owner.nickname.length > NCD_NICKNAME_LENGTH) { if( TSD_GetNickname()->length > TWL_NICKNAME_LENGTH) {
GetNCDWork()->owner.nickname.length = 0; TSD_GetNickname()->length = 0;
SVC_CpuClear(0x0000, GetNCDWork()->owner.nickname.str, NCD_NICKNAME_LENGTH * 2, 16); SVC_CpuClear( 0x0000, TSD_GetNickname().buffer, TWL_NICKNAME_BUFFERSIZE, 16 );
} }
if((GetNCDWork()->owner.birthday.month == 0) || (GetNCDWork()->owner.birthday.month > 12)) { if( ( TSD_GetBirthday()->month == 0) ||
GetNCDWork()->owner.birthday.month = 1; ( TSD_GetBirthday()->month > 12 ) ) {
TSD_GetBirthday()->month = 1;
} }
dayNum = SYSM_GetDayNum( 0, (u32)GetNCDWork()->owner.birthday.month ); dayNum = SYSM_GetDayNum( 0, (u32)TSD_GetBirthday()->month );
if((GetNCDWork()->owner.birthday.day == 0) || (GetNCDWork()->owner.birthday.day > dayNum)) { if( ( TSD_GetBirthday()->day == 0) ||
GetNCDWork()->owner.birthday.day = 1; ( TSD_GetBirthday()->day > dayNum ) ) {
TSD_GetBirthday()->day = 1;
} }
if( GetNCDWork()->owner.favoriteColor >= NCD_FAVORITE_COLOR_MAX_NUM ) { if( TSD_GetUserColor() >= TWL_FAVORITE_COLOR_MAX_NUM ) {
GetNCDWork()->owner.favoriteColor = 0; TSD_SetUserColor( 0 );
} }
} }
@ -234,16 +236,16 @@ void SEQ_OwnerInfo_init(void)
x = (u16)(ownerInfoSel.pos_x+13); x = (u16)(ownerInfoSel.pos_x+13);
y = (u16)ownerInfoSel.pos_y; y = (u16)ownerInfoSel.pos_y;
SVC_CpuClear(0x0000, temp, sizeof(temp), 16); SVC_CpuClear(0x0000, temp, sizeof(temp), 16);
ExUTF16_LEtoSJIS_BE( (u8 *)temp, GetNCDWork()->owner.nickname.str, GetNCDWork()->owner.nickname.length); ExUTF16_LEtoSJIS_BE( (u8 *)temp, TSD_GetNickname()->buffer, TSD_GetNickname()->length );
(void)DrawStringSJIS ( x, y, LIGHTGREEN, temp); (void)DrawStringSJIS ( x, y, LIGHTGREEN, temp);
DrawBirthday ( x, (u16)(y + OWNER_INFO_CSR_NEXT_Y_NUM * 1), LIGHTGREEN, &GetNCDWork()->owner.birthday); DrawBirthday ( x, (u16)(y + OWNER_INFO_CSR_NEXT_Y_NUM * 1), LIGHTGREEN, TSD_GetBirthday() );
ow->favoriteColor = GetNCDWork()->owner.favoriteColor; ow->favoriteColor = TSD_GetUserColor();
(void)DrawDecimalSJIS( x, (u16)(y + OWNER_INFO_CSR_NEXT_Y_NUM * 2), LIGHTGREEN, &ow->favoriteColor, 2, 1); (void)DrawDecimalSJIS( x, (u16)(y + OWNER_INFO_CSR_NEXT_Y_NUM * 2), LIGHTGREEN, &ow->favoriteColor, 2, 1 );
DrawMenu(ow->sel, &ownerInfoSel); DrawMenu( ow->sel, &ownerInfoSel );
SVC_CpuClear(0x0000, &tpd, sizeof(TpWork), 16); SVC_CpuClear( 0x0000, &tpd, sizeof(TpWork), 16 );
GXS_SetVisiblePlane(GX_PLANEMASK_OBJ | GX_PLANEMASK_BG1); GXS_SetVisiblePlane( GX_PLANEMASK_OBJ | GX_PLANEMASK_BG1 );
} }
@ -265,18 +267,18 @@ int SEQ_OwnerInfo(void)
pad.trg = 0; pad.trg = 0;
if(GetNCDWork()->option.input_nickname == 0) { if( !TSD_GetFlagNickname() ) {
ow->sel = 0; ow->sel = 0;
pad.trg |= PAD_BUTTON_A; pad.trg |= PAD_BUTTON_A;
}else if(GetNCDWork()->option.input_favoriteColor == 0) { }else if( !TSD_GetFlagUserColor() ) {
ow->sel = 2; ow->sel = 2;
pad.trg |= PAD_BUTTON_A; pad.trg |= PAD_BUTTON_A;
}else if(GetNCDWork()->option.input_birthday == 0) { }else if( !TSD_GetFlagBirthday() ) {
ow->sel = 1; ow->sel = 1;
pad.trg |= PAD_BUTTON_A; pad.trg |= PAD_BUTTON_A;
}else if ( GetNCDWork()->option.input_nickname }else if ( TSD_GetFlagNickname() ||
|| GetNCDWork()->option.input_favoriteColor TSD_GetFlagUserColor() ||
|| GetNCDWork()->option.input_birthday ) { TSD_GetFlagBirthday() ) {
pad.trg |= PAD_BUTTON_B; // メニューに戻らす pad.trg |= PAD_BUTTON_B; // メニューに戻らす
} }
} }
@ -313,7 +315,7 @@ int SEQ_OwnerInfo(void)
break; break;
} }
}else if((pad.trg & PAD_BUTTON_B) || (tp_return)) { // メニューに戻る }else if((pad.trg & PAD_BUTTON_B) || (tp_return)) { // メニューに戻る
NNS_FndFreeToAllocator( &g_allocator, ow ); // ワークの解放 Free( ow ); // ワークの解放
ow = NULL; ow = NULL;
OS_Printf("Free :OwnerWork\n"); OS_Printf("Free :OwnerWork\n");
SEQ_MainMenu_init(); SEQ_MainMenu_init();
@ -331,10 +333,10 @@ int SEQ_OwnerInfo(void)
static void SEQ_InputBirthday_init(void) static void SEQ_InputBirthday_init(void)
{ {
// 生年月日の表示 // 生年月日の表示
DrawBirthday((u16)(ownerInfoSel.pos_x + 13), (u16)(ownerInfoSel.pos_y + OWNER_INFO_CSR_NEXT_Y_NUM * 1), WHITE, &GetNCDWork()->owner.birthday); DrawBirthday((u16)(ownerInfoSel.pos_x + 13), (u16)(ownerInfoSel.pos_y + OWNER_INFO_CSR_NEXT_Y_NUM * 1), WHITE, TSD_GetBirthday() );
// 生年月日情報のロード // 生年月日情報のロード
ow->birthday.month = (int)GetNCDWork()->owner.birthday.month; ow->birthday.month = (int)TSD_GetBirthday()->month;
ow->birthday.day = (int)GetNCDWork()->owner.birthday.day; ow->birthday.day = (int)TSD_GetBirthday()->day;
SVC_CpuClear(0x0000, &tpd, sizeof(TpWork), 16); SVC_CpuClear(0x0000, &tpd, sizeof(TpWork), 16);
ow->seq = 0; ow->seq = 0;
} }
@ -444,18 +446,18 @@ static int SEQ_InputBirthday(void)
break; break;
case SEQ_END: case SEQ_END:
GetNCDWork()->owner.birthday.month = (u8 )ow->birthday.month; GetSYSMWork()->ncd_invalid = 0;
GetNCDWork()->owner.birthday.day = (u8 )ow->birthday.day; TSD_GetBirthday()->month = (u8 )ow->birthday.month;
GetNCDWork()->option.input_birthday = 1; TSD_GetBirthday()->day = (u8 )ow->birthday.day;
GetSYSMWork()->ncd_invalid = 0; TSD_SetFlagBirthday( TRUE );
if ( GetNCDWork()->option.destroyFlashFlag ) { if( TSD_IsInitialSequence() ) {
GetNCDWork()->option.destroyFlashFlag = 0; TSD_SetFlagInitialSequence( FALSE );
} }
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData (GetNCDWork()); (void)SYSM_WriteTWLSettingsFile();
// SEQ_ENDの時はこのままリターンする。 // SEQ_ENDの時はこのままリターンする。
@ -501,9 +503,9 @@ static void DrawBirthday(u16 x, u16 y, u16 color, NvDate *birthp)
static void SEQ_InputFavoriteColor_init(void) static void SEQ_InputFavoriteColor_init(void)
{ {
// 好きな色のロード // 好きな色のロード
ow->favoriteColor = (int)GetNCDWork()->owner.favoriteColor; ow->favoriteColor = TSD_GetUserColor();
// 好きな色の表示 // 好きな色の表示
SVC_CpuClear(0x0000, &tpd, sizeof(TpWork), 16); SVC_CpuClear( 0x0000, &tpd, sizeof(TpWork), 16 );
ow->seq = 0; ow->seq = 0;
if( g_initialSet ) { if( g_initialSet ) {
@ -558,7 +560,7 @@ static int SEQ_InputFavoriteColor(void)
ow->inp.pos_x = FCOLOR_LT_X; ow->inp.pos_x = FCOLOR_LT_X;
ow->inp.pos_y = FCOLOR_LT_Y; ow->inp.pos_y = FCOLOR_LT_Y;
ow->inp.keta_max = 2; ow->inp.keta_max = 2;
ow->inp.value_max = NCD_FAVORITE_COLOR_MAX_NUM - 1; ow->inp.value_max = TWL_FAVORITE_COLOR_MAX_NUM - 1;
ow->inp.value_min = 0; ow->inp.value_min = 0;
ow->inp.y_offset = 0; ow->inp.y_offset = 0;
ow->tgtp = (int *)&ow->favoriteColor; ow->tgtp = (int *)&ow->favoriteColor;
@ -569,14 +571,14 @@ static int SEQ_InputFavoriteColor(void)
break; break;
case SEQ_END: case SEQ_END:
GetNCDWork()->option.input_favoriteColor = 1;
GetNCDWork()->owner.favoriteColor = (u8 )ow->favoriteColor;
GetSYSMWork()->ncd_invalid = 0; GetSYSMWork()->ncd_invalid = 0;
TSD_SetUserColor( (u8 )ow->favoriteColor );
TSD_SetFlagUserColor( TRUE );
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData (GetNCDWork()); (void)SYSM_WriteTWLSettingsFile();
// SEQ_ENDの時はこのままリターンする。 // SEQ_ENDの時はこのままリターンする。
@ -619,10 +621,10 @@ static void SEQ_InputNickname_init(void)
} }
// ニックネームをUTF16からSJISに変換してコピー // ニックネームをUTF16からSJISに変換してコピー
SVC_CpuClear(CHAR_USCORE, ow->nickname.str, NCD_NICKNAME_LENGTH * 2, 16); SVC_CpuClear(CHAR_USCORE, ow->nickname.str, TWL_NICKNAME_LENGTH * 2, 16);
if(GetSYSMWork()->ncd_invalid == 0) { if(GetSYSMWork()->ncd_invalid == 0) {
ExUTF16_LEtoSJIS_BE( (u8 *)ow->nickname.str, GetNCDWork()->owner.nickname.str, GetNCDWork()->owner.nickname.length); ExUTF16_LEtoSJIS_BE( (u8 *)ow->nickname.str, TSD_GetNickname()->buffer, TSD_GetNickname()->length );
ow->nickname.length = GetNCDWork()->owner.nickname.length; ow->nickname.length = TSD_GetNickname()->length;
ow->nickname.input_flag = 1; ow->nickname.input_flag = 1;
} }
ow->nickname.change_flag = 0; ow->nickname.change_flag = 0;
@ -744,7 +746,7 @@ static int SEQ_InputNickname(void)
}else if(charCode == DEL_BUTTON_) { // １文字削除 }else if(charCode == DEL_BUTTON_) { // １文字削除
DeleteName1Char(); DeleteName1Char();
}else { }else {
if(ow->nickname.length < NCD_NICKNAME_LENGTH) { // 一文字入力 if( ow->nickname.length < TWL_NICKNAME_LENGTH ) { // 一文字入力
ow->nickname.str[ow->nickname.length] = (u16)((charCode >> 8) | (charCode << 8)); ow->nickname.str[ow->nickname.length] = (u16)((charCode >> 8) | (charCode << 8));
// SJIS･ASCII混載文字列の際にこれらを判別できるよう、SJISをHi,Loの順で格納。 // SJIS･ASCII混載文字列の際にこれらを判別できるよう、SJISをHi,Loの順で格納。
ow->nickname.length++; ow->nickname.length++;
@ -771,18 +773,18 @@ static void ReturnMenu(int save_flag)
if((save_flag)&&(ow->nickname.change_flag)) { if((save_flag)&&(ow->nickname.change_flag)) {
GetSYSMWork()->ncd_invalid = 0; GetSYSMWork()->ncd_invalid = 0;
GetNCDWork()->option.input_nickname = 1; // ニックネーム入力フラグを立てる。 TSD_SetFlagNickname( TRUE ); // ニックネーム入力フラグを立てる。
ExSJIS_BEtoUTF16_LE( (u8 *)ow->nickname.str, GetNCDWork()->owner.nickname.str, ow->nickname.length); ExSJIS_BEtoUTF16_LE( (u8 *)ow->nickname.str, TSD_GetNickname()->buffer, ow->nickname.length);
// 入力されたネームをSJISからUTF16へ変換する。 // 入力されたネームをSJISからUTF16へ変換する。
GetNCDWork()->owner.nickname.length = ow->nickname.length; TSD_GetNickname()->length = ow->nickname.length;
for(i = ow->nickname.length; i < NCD_NICKNAME_LENGTH; i++) {// 入力された名前以降を0x0000で埋める。 for(i = ow->nickname.length; i < TWL_NICKNAME_LENGTH; i++) {// 入力された名前以降を0x0000で埋める。
GetNCDWork()->owner.nickname.str[i] = 0x0000; TSD_GetNickname()->buffer[ i ] = 0x0000;
} }
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData(GetNCDWork()); (void)SYSM_WriteTWLSettingsFile();
} }
SEQ_OwnerInfo_init(); SEQ_OwnerInfo_init();
g_pNowProcess = SEQ_OwnerInfo; // オーナー情報編集に戻る g_pNowProcess = SEQ_OwnerInfo; // オーナー情報編集に戻る

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

@ -121,7 +121,7 @@ void SetRTCInit( void )
} }
} }
s_pWork = NNS_FndAllocFromAllocator( &g_allocator, sizeof(SetRtcWork) ); // RTC設定用ワークの確保 s_pWork = Alloc( sizeof(SetRtcWork) ); // RTC設定用ワークの確保
if( s_pWork == NULL ) { if( s_pWork == NULL ) {
OS_Panic( "ARM9- Fail to allocate memory...\n" ); OS_Panic( "ARM9- Fail to allocate memory...\n" );
} }
@ -176,7 +176,7 @@ int SetRTCMain( void )
tp_return = WithinRangeTP( RETURN_BUTTON_TOP_X, RETURN_BUTTON_TOP_Y, tp_return = WithinRangeTP( RETURN_BUTTON_TOP_X, RETURN_BUTTON_TOP_Y,
RETURN_BUTTON_BOTTOM_X, RETURN_BUTTON_BOTTOM_Y, &tpd.disp ); RETURN_BUTTON_BOTTOM_X, RETURN_BUTTON_BOTTOM_Y, &tpd.disp );
} }
if( g_initialSet && !GetNCDWork()->option.input_rtc ) { if( g_initialSet && !TSD_IsSetDateTime() ) {
tp_set = TRUE; tp_set = TRUE;
} }
//-------------------------------------- //--------------------------------------
@ -186,7 +186,7 @@ int SetRTCMain( void )
InputRtcDateTimeInit( 1 ); InputRtcDateTimeInit( 1 );
g_pNowProcess = InputRtcDateTimeMain; g_pNowProcess = InputRtcDateTimeMain;
}else if( ( pad.trg & PAD_BUTTON_B ) || tp_return ) { // メニューに戻る }else if( ( pad.trg & PAD_BUTTON_B ) || tp_return ) { // メニューに戻る
NNS_FndFreeToAllocator( &g_allocator, s_pWork ); // RTC設定用ワークの解放 Free( s_pWork ); // RTC設定用ワークの解放
s_pWork = NULL; s_pWork = NULL;
MachineSettingInit(); MachineSettingInit();
} }
@ -377,15 +377,15 @@ static int InputRtcDateTimeMain( void )
MI_CpuCopy32( &s_pWork->dtp.Date, &date, sizeof(RTCDate) ); MI_CpuCopy32( &s_pWork->dtp.Date, &date, sizeof(RTCDate) );
date.year -= 2000; date.year -= 2000;
(void)RTC_SetDateTime( &date, &s_pWork->dtp.Time ); (void)RTC_SetDateTime( &date, &s_pWork->dtp.Time );
NCD_SetRtcOffset( SYSM_CalcRtcOffsetAndSetDateTime( &date, &s_pWork->dtp.Time ) ); TSD_SetRTCOffset( SYSM_CalcRTCOffsetAndSetDateTime( &date, &s_pWork->dtp.Time ) );
} }
GetSYSMWork()->ncd_invalid = 0; GetSYSMWork()->ncd_invalid = 0;
GetNCDWork()->option.input_rtc = 1; // RTC入力フラグを立てる。 TSD_SetFlagDateTime( TRUE ); // RTC入力フラグを立てる。
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData( GetNCDWork() ); (void)SYSM_WriteTWLSettingsFile();
// 上画面の表示更新 // 上画面の表示更新
GetAndDrawRTCData( &g_rtcDraw, TRUE ); GetAndDrawRTCData( &g_rtcDraw, TRUE );
@ -542,16 +542,14 @@ void InputDecimal( int *pTgt, InputNumParam *pInp )
// RTC設定のクリア // RTC設定のクリア
void ClearRTC( void ) void ClearRTC( void )
{ {
SVC_CpuClear( 0x0000, &GetSYSMWork()->rtc[0].Time, sizeof(RTCTime), 16 ); RTCDate date = { 0, 1, 1, RTC_WEEK_SUNDAY };
GetSYSMWork()->rtc[0].Date.year = 0; RTCTime time = { 0, 0, 0 };
GetSYSMWork()->rtc[0].Date.month = 1; (void)RTC_SetDateTime( &date, &time );
GetSYSMWork()->rtc[0].Date.day = 1; TSD_SetFlagDateTime( TRUE );
(void)RTC_SetDateTime( &GetSYSMWork()->rtc[0].Date, &GetSYSMWork()->rtc[0].Time ); TSD_SetRTCOffset( 0 );
GetNCDWork()->option.input_rtc = 0; TSD_SetRTCLastSetYear( 0 );
GetNCDWork()->option.rtcOffset = 0; // ::::::::::::::::::::::::::::::::::::::::::::::
NCD_SetRtcLastSetYear( 0 ); // TWL設定データファイルへの書き込み
// :::::::::::::::::::::::::::::::::::::::::::::: // ::::::::::::::::::::::::::::::::::::::::::::::
// NVRAMへの書き込み (void)SYSM_WriteTWLSettingsFile();
// ::::::::::::::::::::::::::::::::::::::::::::::
(void)NVRAMm_WriteNitroConfigData( GetNCDWork() );
} }

22
build/systemMenu_RED/PictoChat/ARM9/src/main.c
View File

@ -24,12 +24,9 @@
// define data----------------------------------------------------------------- // define data-----------------------------------------------------------------
// function's prototype------------------------------------------------------- // function's prototype-------------------------------------------------------
static void InitAllocator( NNSFndAllocator* pAllocator );
static void InitAllocSystem( void );
static void INTR_VBlank( void ); static void INTR_VBlank( void );
// global variable------------------------------------------------------------- // global variable-------------------------------------------------------------
NNSFndAllocator g_allocator;
// static variable------------------------------------------------------------- // static variable-------------------------------------------------------------
@ -61,7 +58,7 @@ void TwlMain(void)
(void)RTC_Init(); (void)RTC_Init();
// システムの初期化------------------ // システムの初期化------------------
InitAllocator( &g_allocator ); InitAllocator();
CMN_InitFileSystem( &g_allocator ); CMN_InitFileSystem( &g_allocator );
InitBG(); InitBG();
@ -78,23 +75,6 @@ void TwlMain(void)
} }
// ƒAƒ<41>ƒP<C692>[ƒ^‚Ì<E2809A>‰Šú‰»
static void InitAllocator( NNSFndAllocator* pAllocator )
{
u32 arenaLow = MATH_ROUNDUP ((u32)OS_GetMainArenaLo(), 16);
u32 arenaHigh = MATH_ROUNDDOWN((u32)OS_GetMainArenaHi(), 16);
u32 heapSize = arenaHigh - arenaLow;
void* heapMemory = OS_AllocFromMainArenaLo(heapSize, 16);
NNSFndHeapHandle heapHandle;
SDK_NULL_ASSERT( pAllocator );
heapHandle = NNS_FndCreateExpHeap(heapMemory, heapSize);
SDK_ASSERT( heapHandle != NNS_FND_HEAP_INVALID_HANDLE );
NNS_FndInitAllocatorForExpHeap(pAllocator, heapHandle, 4);
}
// ============================================================================ // ============================================================================
// 割り込み処理 // 割り込み処理
// ============================================================================ // ============================================================================

3
include/sysmenu/machineSettings.h
View File

@ -19,6 +19,7 @@
#define SYSM_MACHINE_SETTINGS_H_ #define SYSM_MACHINE_SETTINGS_H_
#include <sysmenu/machineSettings/common/nitroSettings.h> #include <sysmenu/machineSettings/common/nitroSettings.h>
#include <sysmenu/machineSettings/common/TWLSettings.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -28,5 +29,5 @@ extern "C" {
} /* extern "C" */ } /* extern "C" */
#endif #endif
/* SYSM_MACHINE_SETTINGs_H_ */ /* SYSM_MACHINE_SETTINGS_H_ */
#endif #endif

519
include/sysmenu/machineSettings/common/nitroSettings.h
View File

@ -1,6 +1,6 @@
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Project: TwlIPL Project: TwlIPL
File: NitroSettings.c File: NTRSettings.c
Copyright 2007 Nintendo. All rights reserved. Copyright 2007 Nintendo. All rights reserved.
@ -16,9 +16,9 @@
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
#ifndef NITRO_SETTINGS_H_ #ifndef NTR_SETTINGS_H_
#define NITRO_SETTINGS_H_ #define NTR_SETTINGS_H_
#if defined(SDK_CW) // NitroConfigDataにビットフィールドを使っているので、コンパイラ依存で不具合が発生する可能性がある。 #if defined(SDK_CW) // NTRConfigDataにビットフィールドを使っているので、コンパイラ依存で不具合が発生する可能性がある。
// よって、CW以外のコンパイラの場合は、このヘッダを無効にしてエラーを出させるようにして再確認する。 // よって、CW以外のコンパイラの場合は、このヘッダを無効にしてエラーを出させるようにして再確認する。
#include <twl.h> #include <twl.h>
@ -29,78 +29,96 @@ extern "C" {
// define data ------------------------------------ // define data ------------------------------------
#define NITRO_CONFIG_DATA_VERSION 5 // NITRO設定データフォーマットバージョン #define NTR_SETTINGS_DATA_VERSION 5 // NTR設定データフォーマットバージョン
#define NITRO_CONFIG_DATA_EX_VERSION 1 // 拡張NITRO設定データフォーマットバージョン #define NTR_SETTINGS_DATA_EX_VERSION 1 // 拡張NTR設定データフォーマットバージョン
#define NCD_NICKNAME_LENGTH 10 // ニックネーム長 #define NTR_NICKNAME_LENGTH 10 // ニックネーム長
#define NCD_COMMENT_LENGTH 26 // コメント長 #define NTR_NICKNAME_BUFFERSIZE ( NTR_NICKNAME_LENGTH * 2 ) // ニックネームバッファサイズ
#define NCD_FAVORITE_COLOR_MAX_NUM 16 // 好きな色の最大数 #define NTR_COMMENT_LENGTH 26 // コメント長
#define NTR_COMMENT_BUFFERSIZE ( NTR_COMMENT_LENGTH * 2 )
#define NTR_USER_COLOR_MAX_NUM 16 // ユーザーカラーの最大数
#define NSD_TEMP_BUFFER_SIZE ( sizeof(NSDStoreEx) * 2 ) // NSD_ReadSettingsで必要なTempBufferサイズ
// 言語設定コード // 言語設定コード
typedef enum NvLangCode{ typedef enum NTRLangCode{
LANG_JAPANESE =0, // 日本語 NTR_LANG_JAPANESE = 0, // 日本語
LANG_ENGLISH =1, // 英語 NTR_LANG_ENGLISH = 1, // 英語
LANG_FRENCH =2, // フランス語 NTR_LANG_FRENCH = 2, // フランス語
LANG_GERMAN =3, // ドイツ語 NTR_LANG_GERMAN = 3, // ドイツ語
LANG_ITALIAN =4, // イタリア語 NTR_LANG_ITALIAN = 4, // イタリア語
LANG_SPANISH =5, // スペイン語 NTR_LANG_SPANISH = 5, // スペイン語
LANG_CHINESE =6, // 中国語 NTR_LANG_CHINESE = 6, // 中国語
LANG_HANGUL =7, // 韓国語 NTR_LANG_KOREAN = 7, // 韓国語
LANG_CODE_MAX NTR_LANG_CODE_MAX
}NvLangCode; }NTRLangCode;
#define LANG_CODE_MAX_WW ( LANG_SPANISH + 1 ) #define NTR_LANG_CODE_MAX_WW ( NTR_LANG_SPANISH + 1 )
#define LANG_BITMAP_WW ( ( 0x0001 << LANG_JAPANESE ) \
| ( 0x0001 << LANG_ENGLISH ) \
| ( 0x0001 << LANG_FRENCH ) \
| ( 0x0001 << LANG_GERMAN ) \
| ( 0x0001 << LANG_ITALIAN ) \
| ( 0x0001 << LANG_SPANISH ) ) // 通常版での対応言語ビットマップ
#define VALID_LANG_BITMAP LANG_BITMAP_WW // 本IPL2の対応言語ビットマップ #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 ) ) // SystemMenu-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 ) ) // SystemMenu-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 ) ) // SystemMenu-KR版での対応言語ビットマップ
// 日付データ // 日付データ
typedef struct NvDate{ typedef struct NTRDate{
u8 month; // 月:01～12 u8 month; // 月:01～12
u8 day; // 日:01～31 u8 day; // 日:01～31
}NvDate; // 2byte }NTRDate; // 2byte
// ニックネーム // ニックネーム
typedef struct NvNickname{ typedef struct NTRNickname{
u16 str[NCD_NICKNAME_LENGTH]; // ニックネーム（Unicode(UTF16)で最大10文字、終端コードなし） u16 buffer[ NTR_NICKNAME_LENGTH ]; // ニックネーム（Unicode(UTF16)で最大10文字、終端コードなし）
u8 length; // 文字数 u8 length; // 文字数
u8 rsv; u8 rsv;
}NvNickname; // 22byte }NTRNickname; // 22byte
// コメント // コメント
typedef struct NvComment{ typedef struct NTRComment{
u16 str[NCD_COMMENT_LENGTH]; //コメント（Unicode(UTF16)で最大26文字、終端コードなし） u16 buffer[ NTR_COMMENT_LENGTH ]; //コメント（Unicode(UTF16)で最大26文字、終端コードなし）
u8 length; // 文字数 u8 length; // 文字数
u8 rsv; u8 rsv;
}NvComment; // 54byte }NTRComment; // 54byte
// オーナー情報 // オーナー情報
typedef struct NvOwnerInfo{ typedef struct NTROwnerInfo{
u8 favoriteColor : 4; // 好きな色 u8 userColor : 4; // ユーザーカラー
u8 rsv : 4; // 予約。 u8 rsv : 4; // 予約。
NvDate birthday; // 生年月日 NTRDate birthday; // 生年月日
u8 pad; u8 pad;
NvNickname nickname; // ニックネーム NTRNickname nickname; // ニックネーム
NvComment comment; // コメント NTRComment comment; // コメント
}NvOwnerInfo; // 80byte }NTROwnerInfo; // 80byte
// IPL用目覚まし時計データ // IPL用目覚まし時計データ
typedef struct NvAlarm{ typedef struct NTRAlarm{
u8 hour; // アラーム時:00～23 u8 hour; // アラーム時:00～23
u8 minute; // アラーム分:00～59 u8 minute; // アラーム分:00～59
u8 rsv1; // 予約 u8 rsv1; // 予約
u8 pad; u8 pad;
u16 alarmOn : 1; // アラームON,OFF（0:OFF, 1:ON） u16 alarmOn : 1; // アラームON,OFF（0:OFF, 1:ON）
u16 rsv2 : 15; // 予約 u16 rsv2 : 15; // 予約
}NvAlarm; // 6byte }NTRAlarm; // 6byte
// タッチパネルキャリブレーションデータ // タッチパネルキャリブレーションデータ
typedef struct NvTpCalibData{ typedef struct NTRTPCalibData{
u16 raw_x1; // 第１キャリブレーション点のTP取得値X u16 raw_x1; // 第１キャリブレーション点のTP取得値X
u16 raw_y1; // 　　　　〃　　　　　　　　TP取得値Y u16 raw_y1; // 　　　　〃　　　　　　　　TP取得値Y
u8 dx1; // 　　　　〃　　　　　　　　LCD座標 X u8 dx1; // 　　　　〃　　　　　　　　LCD座標 X
@ -109,370 +127,423 @@ typedef struct NvTpCalibData{
u16 raw_y2; // 　　　　〃　　　　　　　　TP取得値Y u16 raw_y2; // 　　　　〃　　　　　　　　TP取得値Y
u8 dx2; // 　　　　〃　　　　　　　　LCD座標 X u8 dx2; // 　　　　〃　　　　　　　　LCD座標 X
u8 dy2; // 　　　　〃　　　　　　　　LCD座標 Y u8 dy2; // 　　　　〃　　　　　　　　LCD座標 Y
}NvTpCalibData; // 12byte }NTRTPCalibData; // 12byte
// オプション情報 // オプション情報
typedef struct NvOption{ typedef struct NTROption{
u16 language : 3; // 言語コード（LANG_SPANISHまでの標準言語コードが入る） u16 language : 3; // 言語コード（NTR_LANG_SPANISHまでの標準言語コードが入る）
u16 agbLcd : 1; // AGBモードで起動する時にどちらのLCDで起動するか？（0:TOP,1:BOTTOM） u16 isGBUseTopLCD : 1; // AGBモードで起動する時にどちらのLCDで起動するか？（0:TOP,1:BOTTOM）
u16 backLightBrightness : 2; // バックライト輝度データ u16 backlightBrightness : 2; // バックライト輝度データ
u16 autoBootFlag : 1; // 起動シーケンスで、メニュー停止なしで自動起動するかどうか？(0:OFF, 1:ON) u16 isAutoBoot : 1; // 起動シーケンスで、メニュー停止なしで自動起動するかどうか？(0:OFF, 1:ON)
u16 backLightOffFlag : 1; // バックライトON,OFFフラグ（0:ON, 1:OFF） u16 isBacklightOff : 1; // バックライトON,OFFフラグ（0:ON, 1:OFF）
u16 rsv2 : 1; // 予約 u16 rsv2 : 1; // 予約
u16 destroyFlashFlag : 1; // フラッシュ壊れシーケンス中フラグ u16 initialSequence : 1; // 初回起動シーケンス中フラグ
u16 input_birthday : 1; // 誕生日が入力されたか？ u16 isSetBirthday : 1; // 誕生日が入力されたか？
u16 input_favoriteColor : 1; // 好きな色が入力されたか？ u16 isSetUserColor : 1; // ユーザーカラーが入力されたか？
u16 input_tp : 1; // タッチパネルがキャリブレーションされたか？（ 〃 ) u16 isSetTP : 1; // タッチパネルがキャリブレーションされたか？（ 〃 )
u16 input_language : 1; // 言語入力がされたか？　 (0:未設定, 1:設定済み) u16 isSetLanguage : 1; // 言語入力がされたか？　 (0:未設定, 1:設定済み)
u16 input_rtc : 1; // RTC設定がされたか？ ( 〃　　　　　 ) u16 isSetDateTime : 1; // 日付・時刻設定がされたか？ ( 〃　　　　　 )
u16 input_nickname : 1; // ニックネームが入力されたか？ ( 〃　　　　　 ) u16 isSetNickname : 1; // ニックネームが入力されたか？ ( 〃　　　　　 )
u8 rtcLastSetYear; // RTCの前回設定年 u8 rtcLastSetYear; // RTCの前回設定年
u8 rtcClockAdjust; // RTCクロック調整値 u8 rtcClockAdjust; // RTCクロック調整値
s64 rtcOffset; // RTC設定時のオフセット値（ユーザーがRTC設定を変更する度にその値に応じて増減します。） s64 rtcOffset; // RTC設定時のオフセット値（ユーザーがRTC設定を変更する度にその値に応じて増減します。）
}NvOption; // 12byte }NTROption; // 12byte
// NITRO各種設定データ
typedef struct NitroConfigData{ // NTR各種設定データ
typedef struct NTRSettingsData{
u8 version; // フラッシュ格納データフォーマットのバージョン u8 version; // フラッシュ格納データフォーマットのバージョン
u8 pad; u8 pad;
NvOwnerInfo owner; // オーナー情報 NTROwnerInfo owner; // オーナー情報
NvAlarm alarm; // IPL用目覚まし時計データ NTRAlarm alarm; // IPL用目覚まし時計データ
NvTpCalibData tp; // タッチパネルキャリブレーションデータ NTRTPCalibData tp; // タッチパネルキャリブレーションデータ
NvOption option; // オプション NTROption option; // オプション
}NitroConfigData; // 112byte }NTRSettingsData; // 112byte
// NITRO各種設定データのNVRAM保存時フォーマット
typedef struct NCDStore{
NitroConfigData ncd; // NITRO各種設定データ
u16 saveCount; // 0x00-0x7fをループしてカウントし、カウント値が新しいデータが有効。
u16 crc16; // NITRO各種設定データの16bitCRC
u8 pad[ 128 - sizeof(NitroConfigData) - 4];
}NCDStore; // 128byte // ※本来なら、saveCountとcrc16は256byteの最後に付加して、間にパディングを埋める方がいい。
//---------------------------------------------- // 拡張NTR設定データ
// IPL2中国・韓国版での拡張フォーマット typedef struct NTRSettingsDataEx{
//----------------------------------------------
// 拡張NITRO設定データ
typedef struct NitroConfigDataEx{
u8 version; // バージョン u8 version; // バージョン
u8 language; // 言語コード（LANG_CHINESE以降に拡張された値が入る。） u8 language; // 言語コード（NTR_LANG_CHINESE以降に拡張された値が入る。）
u16 valid_language_bitmap; // 本IPL2で有効な言語コードを示したビットマップ u16 valid_language_bitmap; // 本IPL2で有効な言語コードを示したビットマップ
u8 pad[ 256 - sizeof(NitroConfigData) - 4 - 4 - 2 ]; // 4:saveCount+crc16, 2:NCDEx.version+NCDEx.language, 2:crc16_ex u8 pad[ 256 - sizeof(NTRSettingsData) - 4 - 4 - 2 ]; // 4:saveCount+crc16, 2:NSDEx.version+NSDEx.language, 2:crc16_ex
}NitroConfigDataEx; // 138bytes }NTRSettingsDataEx; // 138bytes
// NITRO各種設定データのNVRAM保存時フォーマット
typedef struct NCDStoreEx{ // NTR各種設定データのNVRAM保存時フォーマット
NitroConfigData ncd; // NITRO各種設定データ typedef struct NSDStore{
u16 saveCount; // 0x00-0x7fをループしてカウントし、カウント値が新しいデータが有効。 NTRSettingsData nsd; // NTR各種設定データ
u16 crc16; // NITRO各種設定データの16bitCRC u16 saveCount; // 0x00-0x7fをループしてカウントし、カウント値が新しいデータが有効。
NitroConfigDataEx ncd_ex; 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; u16 crc16_ex;
}NCDStoreEx; // 256byte // ※本来なら、saveCountとcrc16は256byteの最後に付加して、間にパディングを埋める方がいい。 }NSDStoreEx; // 256byte // ※本来なら、saveCountとcrc16は256byteの最後に付加して、間にパディングを埋める方がいい。
#ifdef SDK_ARM9
//=========================================================
// グローバル変数
//=========================================================
extern NTRSettingsData *g_pNSD;
extern NTRSettingsDataEx *g_pNSDEx;
#define GetNSD() ( g_pNSD )
#define GetNSDEx() ( g_pNSDEx )
//========================================================= //=========================================================
// NVRAMへのリードライト関数 // NVRAMへのリードライト関数
//========================================================= //=========================================================
#ifdef SDK_ARM9 extern void NSD_ClearSettings( void );
extern int NVRAMm_ReadNitroConfigData (NitroConfigData *dstp); extern BOOL NSD_IsReadSettings( void );
extern void NVRAMm_WriteNitroConfigData(NitroConfigData *dstp); extern BOOL NSD_ReadSettings( u8 region, NSDStoreEx (*pTempBuffer)[2] ); // NSD_TEMP_BUFFER_SIZEのpTempBufferが必要。
#endif extern BOOL NSD_WriteSettings( u8 region ); // 先にNSD_ReadSettingsを実行しておく必要がある。
//========================================================= //=========================================================
// NITRO設定データへのアクセス関数 // データ取得（NSD_ReadSettingsで内部ワークに読み出した情報の取得）
//=========================================================
extern NitroConfigDataEx ncdEx;
#define GetNCDWork() ( (NitroConfigData *)( HW_NVRAM_USER_INFO ) )
#define GetNCDExWork() ( &ncdEx )
// NITRO設定データ領域のアドレス獲得
extern void NCD_ClearOwnerInfo( void ); // ニックネーム・誕生日・好きな色のクリア
extern u8 NCD_GetIPL2Type( void );
extern u8 *NCD_GetIPL2Version( void );
extern u32 NCD_GetNCDRomAddr( void );
//=========================================================
// データ取得
//========================================================= //=========================================================
//----------------------------------- // バージョンの取得。
// オーナー情報全体の取得。 static inline u8 NSD_GetVersion( void )
static inline NvOwnerInfo *NCD_GetOwnerInfo(void)
{ {
return &GetNCDWork()->owner; return (u8)GetNSD()->version;
} }
// 好きな色の取得。 // EXバージョンの取得。
static inline u8 NCD_GetFavoriteColor(void) static inline u8 NSD_GetExVersion( void )
{ {
return (u8)GetNCDWork()->owner.favoriteColor; return (u8)GetNSDEx()->version;
}
// オーナー情報全体の取得。
static inline NTROwnerInfo *NSD_GetOwnerInfo( void )
{
return &GetNSD()->owner;
}
// ユーザーカラーの取得。
static inline u8 NSD_GetUserColor( void )
{
return (u8)GetNSD()->owner.userColor;
} }
// 誕生日の取得。 // 誕生日の取得。
static inline NvDate *NCD_GetBirthday(void) static inline NTRDate *NSD_GetBirthday( void )
{ {
return &GetNCDWork()->owner.birthday; return &GetNSD()->owner.birthday;
} }
// ニックネームの取得。 // ニックネームの取得。
static inline NvNickname *NCD_GetNickname(void) static inline NTRNickname *NSD_GetNickname( void )
{ {
return &GetNCDWork()->owner.nickname; return &GetNSD()->owner.nickname;
} }
// コメントの取得。 // コメントの取得。
static inline NvComment *NCD_GetComment(void) static inline NTRComment *NSD_GetComment( void )
{ {
return &GetNCDWork()->owner.comment; return &GetNSD()->owner.comment;
} }
//-----------------------------------
// アラーム情報の取得。 // アラーム情報の取得。
static inline NvAlarm *NCD_GetAlarmData(void) static inline NTRAlarm *NSD_GetAlarmData( void )
{ {
return &GetNCDWork()->alarm; return &GetNSD()->alarm;
} }
//-----------------------------------
// タッチパネルキャリブレーションデータの取得。 // タッチパネルキャリブレーションデータの取得。
static inline NvTpCalibData *NCD_GetTPCalibration(void) static inline NTRTPCalibData *NSD_GetTPCalibration( void )
{ {
return &GetNCDWork()->tp; return &GetNSD()->tp;
} }
//-----------------------------------
// オプション情報の取得。
// 言語コードの取得 // 言語コードの取得
static inline NvLangCode NCD_GetLanguage(void) static inline NTRLangCode NSD_GetLanguage( void )
{ {
return (NvLangCode)GetNCDExWork()->language; return (NTRLangCode)GetNSD()->option.language;
} }
static inline NvLangCode NCD_GetLanguageOrg(void) static inline NTRLangCode NSD_GetLanguageEx( void )
{ {
return (NvLangCode)GetNCDWork()->option.language; return (NTRLangCode)GetNSDEx()->language;
}
// 対応言語ビットマップの取得
static inline u16 NSD_GetLanguageBitmap( void )
{
return GetNSDEx()->valid_language_bitmap;
} }
// RTCオフセット値の取得 // RTCオフセット値の取得
static inline s64 NCD_GetRtcOffset(void) static inline s64 NSD_GetRTCOffset( void )
{ {
return GetNCDWork()->option.rtcOffset; return GetNSD()->option.rtcOffset;
} }
// RTCクロック調整値の取得 // RTCクロック調整値の取得
static inline u8 NCD_GetRtcClockAdjust(void) static inline u8 NSD_GetRTCClockAdjust( void )
{ {
return GetNCDWork()->option.rtcClockAdjust; return GetNSD()->option.rtcClockAdjust;
} }
// RTCの前回セットした年の取得 // RTCの前回セットした年の取得
static inline u8 NCD_GetRtcLastSetYear(void) static inline u8 NSD_GetRTCLastSetYear( void )
{ {
return GetNCDWork()->option.rtcLastSetYear; return GetNSD()->option.rtcLastSetYear;
} }
// 起動シーケンスの自動起動ONか？（0:OFF, 1:ON） // 起動シーケンスの自動起動ONか？（0:OFF, 1:ON）
static inline int NCD_GetAutoBootFlag(void) static inline int NSD_IsAutoBoot( void )
{ {
return (int)GetNCDWork()->option.autoBootFlag; return (int)GetNSD()->option.isAutoBoot;
} }
// バックライト輝度取得（0-3） // バックライト輝度取得（0-3）
static inline int NCD_GetBackLightBrightness(void) static inline BOOL NSD_IsBacklightOff( void )
{ {
return (int)GetNCDWork()->option.backLightBrightness; return (BOOL)GetNSD()->option.isBacklightOff;
}
// バックライト輝度取得（0-3）
static inline int NSD_GetBacklightBrightness( void )
{
return (int)GetNSD()->option.backlightBrightness;
} }
// フラッシュ壊れシーケンス中かどうか？ // フラッシュ壊れシーケンス中かどうか？
static inline int NCD_GetDestroyFlash(void) static inline BOOL NSD_IsInitialSequence( void )
{ {
return (int)GetNCDWork()->option.destroyFlashFlag; return (int)GetNSD()->option.initialSequence;
} }
// 誕生日データがセットされているか？ // 誕生日データがセットされているか？
static inline int NCD_GetInputBirthday(void) static inline BOOL NSD_IsSetBirthday( void )
{ {
return (int)GetNCDWork()->option.input_birthday; return (int)GetNSD()->option.isSetBirthday;
} }
// 好きな色データがセットされているか？ // ユーザーカラーデータがセットされているか？
static inline int NCD_GetInputFavoriteColor(void) static inline int NSD_IsSetUserColor( void )
{ {
return (int)GetNCDWork()->option.input_favoriteColor; return (int)GetNSD()->option.isSetUserColor;
} }
// TPキャリブレーションデータがセットされているか？ // TPキャリブレーションデータがセットされているか？
static inline int NCD_GetInputTP(void) static inline int NSD_IsSetTP( void )
{ {
return (int)GetNCDWork()->option.input_tp; return (int)GetNSD()->option.isSetTP;
} }
// 言語コードがセットされているか？ // 言語コードがセットされているか？
static inline int NCD_GetInputLanguage(void) static inline int NSD_IsSetLanguage( void )
{ {
return (int)GetNCDWork()->option.input_language; return (int)GetNSD()->option.isSetLanguage;
} }
// RTCデータがセットされているか？ // 日付・時刻がセットされているか？
static inline int NCD_GetInputRTC(void) static inline int NSD_IsSetDateTime( void )
{ {
return (int)GetNCDWork()->option.input_rtc; return (int)GetNSD()->option.isSetDateTime;
} }
// オーナー情報のニックネームがセットされているか？ // オーナー情報のニックネームがセットされているか？
static inline int NCD_GetInputNickname(void) static inline int NSD_IsSetNickname( void )
{ {
return (int)GetNCDWork()->option.input_nickname; return (int)GetNSD()->option.isSetNickname;
}
// GBアプリなど１画面ソフトが使うのは上画面？
static inline BOOL NSD_IsGBUseTopLCD( void )
{
return (BOOL)GetNSD()->option.isGBUseTopLCD;
} }
//========================================================= //=========================================================
// データセット // データセット
//========================================================= //=========================================================
//-----------------------------------
// オーナー情報全体のセット。 // バージョンのセット。
static inline void NCD_SetOwnerInfo(NvOwnerInfo *owinfop) static inline void NSD_SetVersion( u8 version )
{ {
SVC_CpuCopy( owinfop, &GetNCDWork()->owner, sizeof(NvOwnerInfo), 16); GetNSD()->version = version;
} }
// 好きな色のセット。 // バージョンEXのセット。
static inline void NCD_SetFavoriteColor(u8 favoriteColor) static inline void NSD_SetExVersion( u8 version )
{ {
GetNCDWork()->owner.favoriteColor = favoriteColor; GetNSDEx()->version = version;
}
// オーナー情報のクリア
extern void NSD_ClearOwnerInfo( void );
// オーナー情報全体のセット。
static inline void NSD_SetOwnerInfo( NTROwnerInfo *pOwner )
{
MI_CpuCopy16( pOwner, &GetNSD()->owner, sizeof(NTROwnerInfo) );
}
// ユーザーカラーのセット。
static inline void NSD_SetUserColor( u8 userColor )
{
GetNSD()->owner.userColor = userColor;
} }
// 誕生日のセット。 // 誕生日のセット。
static inline void NCD_SetBirthday(NvDate *birthp) static inline void NSD_SetBirthday( NTRDate *pBirthday )
{ {
GetNCDWork()->owner.birthday.month = birthp->month; GetNSD()->owner.birthday.month = pBirthday->month;
GetNCDWork()->owner.birthday.day = birthp->day; GetNSD()->owner.birthday.day = pBirthday->day;
} }
// ニックネームのセット。 // ニックネームのセット。
static inline void NCD_SetNickname(NvNickname *namep) static inline void NSD_SetNickname( NTRNickname *pName )
{ {
SVC_CpuCopy( namep, &GetNCDWork()->owner.nickname, sizeof(NvNickname), 16); MI_CpuCopy16( pName, &GetNSD()->owner.nickname, sizeof(NTRNickname) );
} }
// コメントのセット。 // コメントのセット。
static inline void NCD_SetComment(NvComment *commentp) static inline void NSD_SetComment( NTRComment *pComment )
{ {
SVC_CpuCopy( commentp, &GetNCDWork()->owner.comment, sizeof(NvComment), 16); MI_CpuCopy16( pComment, &GetNSD()->owner.comment, sizeof(NTRComment) );
} }
//-----------------------------------
// アラーム情報のセット。 // アラーム情報のセット。
static inline void NCD_SetAlarmData(NvAlarm *alarmp) static inline void NSD_SetAlarmData( NTRAlarm *pAlarm )
{ {
SVC_CpuCopy( alarmp, &GetNCDWork()->alarm, sizeof(NvAlarm), 16); MI_CpuCopy16( pAlarm, &GetNSD()->alarm, sizeof(NTRAlarm) );
} }
//-----------------------------------
// タッチパネルキャリブレーションデータのセット。 // タッチパネルキャリブレーションデータのセット。
static inline void NCD_SetTPCalibration(NvTpCalibData *tp_calibp) static inline void NSD_SetTPCalibration( NTRTPCalibData *pTPCalib )
{ {
SVC_CpuCopy( tp_calibp, &GetNCDWork()->tp, sizeof(NvTpCalibData), 16); MI_CpuCopy16( pTPCalib, &GetNSD()->tp, sizeof(NTRTPCalibData) );
} }
//-----------------------------------
// オプション情報のセット。
// 言語コードのセット // 言語コードのセット
static inline void NCD_SetLanguage(NvLangCode language) #if 0
static inline void NSD_SetLanguage( NTRLangCode language )
{ {
GetNCDExWork()->language = language; GetNSDEx()->language = language;
if( language >= LANG_CODE_MAX_WW ) { if( language >= NTR_LANG_CODE_MAX_WW ) {
GetNCDWork()->option.language = LANG_ENGLISH; GetNSD()->option.language = NTR_LANG_ENGLISH;
}else { }else {
GetNCDWork()->option.language = language; 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_SetLanguageBitmap( u16 valid_language_bitmap )
{
GetNSDEx()->valid_language_bitmap = valid_language_bitmap;
}
// RTCオフセット値のセット // RTCオフセット値のセット
static inline void NCD_SetRtcOffset(s64 rtcOffset) static inline void NSD_SetRTCOffset( s64 rtcOffset )
{ {
GetNCDWork()->option.rtcOffset = rtcOffset; GetNSD()->option.rtcOffset = rtcOffset;
} }
// RTCクロック調整値のセット // RTCクロック調整値のセット
static inline void NCD_SetRtcClockAdjust(u8 rtcClockAdjust) static inline void NSD_SetRTCClockAdjust( u8 rtcClockAdjust )
{ {
GetNCDWork()->option.rtcClockAdjust = rtcClockAdjust; GetNSD()->option.rtcClockAdjust = rtcClockAdjust;
} }
// RTCのLastSetYearへのセット // RTCのLastSetYearへのセット
static inline void NCD_SetRtcLastSetYear(u8 rtcLastSetYear) static inline void NSD_SetRTCLastSetYear( u8 rtcLastSetYear )
{ {
GetNCDWork()->option.rtcLastSetYear = rtcLastSetYear; GetNSD()->option.rtcLastSetYear = rtcLastSetYear;
} }
// 起動シーケンスの自動起動ON,OFFフラグをセット。 // 起動シーケンスの自動起動ON,OFFフラグをセット。
static inline void NCD_SetAutoBootFlag(BOOL autoBootFlag) static inline void NSD_SetFlagAutoBoot( BOOL set )
{ {
GetNCDWork()->option.autoBootFlag = (u16)autoBootFlag; GetNSD()->option.isAutoBoot = (u16)set;
}
// バックライトON/OFFをセット。
static inline void NSD_SetFlagBacklightOff( BOOL set )
{
GetNSD()->option.isBacklightOff = (u16)set;
} }
// バックライト輝度情報をセット。 // バックライト輝度情報をセット。
static inline void NCD_SetBackLightBrightness(BOOL backLightBrightness ) static inline void NSD_SetBacklightBrightness( BOOL backlightBrightness )
{ {
GetNCDWork()->option.backLightBrightness = (u16)backLightBrightness; GetNSD()->option.backlightBrightness = (u16)backlightBrightness;
} }
// フラッシュ壊れシーケンス中かどうかのフラグセット。 // 初回起動シーケンス中かどうかのフラグセット。
static inline void NCD_SetDestroyFlash(BOOL destroy) static inline void NSD_SetFlagInitialSequence( BOOL set )
{ {
GetNCDWork()->option.destroyFlashFlag = (u16)destroy; GetNSD()->option.initialSequence = (u16)set;
} }
// 誕生日データの入力済みフラグセット。 // 誕生日データの入力済みフラグセット。
static inline void NCD_SetInputBirthday(BOOL input) static inline void NSD_SetFlagBirthday( BOOL set )
{ {
GetNCDWork()->option.input_birthday = (u16)input; GetNSD()->option.isSetBirthday = (u16)set;
} }
// 好きな色データの入力済みフラグセット。 // ユーザーカラーの入力済みフラグセット。
static inline void NCD_SetInputFavoriteColor(BOOL input) static inline void NSD_SetFlagUserColor( BOOL set )
{ {
GetNCDWork()->option.input_favoriteColor = (u16)input; GetNSD()->option.isSetUserColor = (u16)set;
} }
// TPキャリブレーションデータの入力済みフラグセット。 // TPキャリブレーションデータの入力済みフラグセット。
static inline void NCD_SetInputTP(BOOL input) static inline void NSD_SetFlagTP( BOOL set )
{ {
GetNCDWork()->option.input_tp = (u16)input; GetNSD()->option.isSetTP = (u16)set;
} }
// 言語コードの入力済みフラグセット。 // 言語コードの入力済みフラグセット。
static inline void NCD_SetInputLanguage(BOOL input) static inline void NSD_SetFlagLanguage( BOOL set )
{ {
GetNCDWork()->option.input_language = (u16)input; GetNSD()->option.isSetLanguage = (u16)set;
} }
// RTCデータの入力済みフラグセット。 // 日付・時刻入力済みフラグセット。
static inline void NCD_SetInputRTC(BOOL input) static inline void NSD_SetFlagDateTime( BOOL set )
{ {
GetNCDWork()->option.input_rtc = (u16)input; GetNSD()->option.isSetDateTime = (u16)set;
} }
// オーナー情報のニックネームの入力済みフラグセット。 // オーナー情報のニックネームの入力済みフラグセット。
static inline void NCD_SetInputNickname(BOOL input) static inline void NSD_SetFlagNickname( BOOL set )
{ {
GetNCDWork()->option.input_nickname = (u16)input; GetNSD()->option.isSetNickname = (u16)set;
} }
// GBアプリなど１画面ソフトが使う画面フラグをセット
static inline void NSD_SetFlagGBUseTopLCD( BOOL set )
{
GetNSD()->option.isGBUseTopLCD = (u32)set;
}
#endif // SDK_ARM9
#ifdef __cplusplus #ifdef __cplusplus
@ -480,4 +551,4 @@ static inline void NCD_SetInputNickname(BOOL input)
#endif #endif
#endif // SDK_CW #endif // SDK_CW
#endif // NITRO_SETTINGS_H_ #endif // NTR_SETTINGS_H_

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

@ -22,6 +22,7 @@
#include <sysmenu/rom_header.h> #include <sysmenu/rom_header.h>
#include <sysmenu/banner.h> #include <sysmenu/banner.h>
#include <sysmenu/sysmenu_work.h> #include <sysmenu/sysmenu_work.h>
#include <sysmenu/machineSettings.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -56,9 +57,13 @@ typedef enum AuthResult {
// global variable------------------------------------------------------ // global variable------------------------------------------------------
extern void *(*SYSM_Alloc)( u32 size );
extern void (*SYSM_Free)( void *ptr );
// function------------------------------------------------------------- // function-------------------------------------------------------------
extern void SYSM_Init( void ); extern void SYSM_Init( void );
extern void SYSM_SetAllocFunc( void *(*pAlloc)(u32), void (*pFree)(void*) );
extern BOOL SYSM_IsLogoDemoSkip( void ); extern BOOL SYSM_IsLogoDemoSkip( void );
extern void SYSM_CaribrateTP( void ); extern void SYSM_CaribrateTP( void );
extern int SYSM_GetCardTitleList( TitleProperty *pTitleList_Card ); extern int SYSM_GetCardTitleList( TitleProperty *pTitleList_Card );
@ -66,6 +71,12 @@ extern int SYSM_GetNandTitleList( TitleProperty *pTitleList_Nand, int size );
extern AuthResult SYSM_LoadAndAuthenticateTitle( TitleProperty *pBootTitle ); extern AuthResult SYSM_LoadAndAuthenticateTitle( TitleProperty *pBootTitle );
extern void SYSM_Finalize( void ); extern void SYSM_Finalize( void );
extern BOOL SYSM_ReadTWLSettingsFile( void );
extern BOOL SYSM_WriteTWLSettingsFile( void );
extern void SYSM_VerifyAndRecoveryNTRSettings( void );
extern void SYSM_SetBackLightBrightness( void );
extern void SYSM_PermitToBootSelectedTarget( void ); extern void SYSM_PermitToBootSelectedTarget( void );
extern void SYSM_LoadSYSMData( void ); extern void SYSM_LoadSYSMData( void );
extern BOOL SYSM_BootNITRO( void ); extern BOOL SYSM_BootNITRO( void );
@ -85,13 +96,12 @@ extern void SYSM_ClearBootFlag( u32 value );
extern void SYSM_GoSleepMode( void ); extern void SYSM_GoSleepMode( void );
extern void PMm_SetBackLightBrightness( void );
extern void NCD_ClearOwnerInfo( void ); // ニックネーム・誕生日・好きな色のクリア extern void NCD_ClearOwnerInfo( void ); // ニックネーム・誕生日・好きな色のクリア
extern BOOL SYSM_CheckRTCDate( RTCDate *datep ); extern BOOL SYSM_CheckRTCDate( RTCDate *datep );
extern BOOL SYSM_CheckRTCTime( RTCTime *timep ); extern BOOL SYSM_CheckRTCTime( RTCTime *timep );
extern s64 SYSM_CalcRtcOffsetAndSetDateTime( RTCDate *newDate, RTCTime *newTime ); extern s64 SYSM_CalcRTCOffsetAndSetDateTime( RTCDate *newDate, RTCTime *newTime );
extern u32 SYSM_GetDayNum( u32 year, u32 month ); extern u32 SYSM_GetDayNum( u32 year, u32 month );
extern BOOL SYSM_IsLeapYear100( u32 year ); extern BOOL SYSM_IsLeapYear100( u32 year );