Merge pull request #106 from red031000/master

OS_spinLock + OS_vsnprintf

16 files changed, 600 insertions, 789 deletions

diff --git a/arm9/asm/CTRDG.s b/arm9/asm/CTRDG.s
index 242e18a4..fa0e2c4e 100644
--- a/arm9/asm/CTRDG.s
+++ b/arm9/asm/CTRDG.s
@@ -135,7 +135,7 @@ _020DB290:
 _020DB294:
 	ldr r0, _020DB2BC ; =UNK_021D6944
 	ldrh r0, [r0, #0x2]
-	bl OS_UnlockCartridge
+	bl OS_UnLockCartridge
 	bl CTRDG_IsExisting
 _020DB2A4: ; 0x020DB2A4
 	cmp r0, #0x0
@@ -248,7 +248,7 @@ _020DB3F0:
 _020DB404:
 	ldr r0, _020DB42C ; =UNK_021D6944
 	ldrh r0, [r0, #0x2]
-	bl OS_UnlockCartridge
+	bl OS_UnLockCartridge
 	bl CTRDG_IsExisting
 _020DB414: ; 0x020DB414
 	cmp r0, #0x0
@@ -362,7 +362,7 @@ CTRDGi_UnlockByProcessor: ; 0x020DB568
 	ldr r1, [r4, #0x0]
 	cmp r1, #0x0
 	bne _020DB580
-	bl OS_UnlockCartridge
+	bl OS_UnLockCartridge
 _020DB580:
 	ldr r0, [r4, #0x4]
 	bl OS_RestoreInterrupts
diff --git a/arm9/asm/CTRDG_backup.s b/arm9/asm/CTRDG_backup.s
index 0cafa0aa..f5ed989d 100644
--- a/arm9/asm/CTRDG_backup.s
+++ b/arm9/asm/CTRDG_backup.s
@@ -224,7 +224,7 @@ CTRDG_IdentifyAgbBackup: ; 0x020DBD50
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
 	ldreq r5, _020DBEEC ; =UNK_02103FE8
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	ldr r2, [r5, #0x0]
 	mov r0, #0x1
 	ldrh r1, [r2, #0x38]
diff --git a/arm9/asm/CTRDG_flash_AT29LV512.s b/arm9/asm/CTRDG_flash_AT29LV512.s
index 390d4293..33298e6c 100644
--- a/arm9/asm/CTRDG_flash_AT29LV512.s
+++ b/arm9/asm/CTRDG_flash_AT29LV512.s
@@ -287,7 +287,7 @@ _020DC92C:
 	orr r0, r0, r5
 	strh r0, [r3, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	add sp, sp, #0x24
 	ldmia sp!, {r4-r5,lr}
@@ -428,7 +428,7 @@ _020DCB18:
 	ldr r0, _020DCB84 ; =UNK_021D6B0C
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r5
 	add sp, sp, #0x24
 	ldmia sp!, {r4-r5,lr}
@@ -495,7 +495,7 @@ CTRDGi_EraseFlashChipCoreAT: ; 0x020DCBA0
 	orr r0, r0, r5
 	strh r0, [r3, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	add sp, sp, #0x4
 	ldmia sp!, {r4-r5,lr}
diff --git a/arm9/asm/CTRDG_flash_LE39FW512.s b/arm9/asm/CTRDG_flash_LE39FW512.s
index cb702648..77071a6d 100644
--- a/arm9/asm/CTRDG_flash_LE39FW512.s
+++ b/arm9/asm/CTRDG_flash_LE39FW512.s
@@ -122,7 +122,7 @@ CTRDGi_VerifyFlashErase: ; 0x020DCD94
 	orr r1, r1, r6
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	ldmia sp!, {r4-r6,lr}
 	bx lr
@@ -267,7 +267,7 @@ _020DCFD4:
 	orr r1, r1, r5
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r8
 	add sp, sp, #0x24
 	ldmia sp!, {r4-r9,lr}
@@ -379,7 +379,7 @@ CTRDGi_EraseFlashSectorCoreLE: ; 0x020DD098
 	orr r0, r0, r5
 	strh r0, [r3, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	add sp, sp, #0x28
 	ldmia sp!, {r4-r6,lr}
@@ -447,7 +447,7 @@ CTRDGi_EraseFlashChipCoreLE: ; 0x020DD1DC
 	orr r0, r0, r5
 	strh r0, [r3, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	add sp, sp, #0x4
 	ldmia sp!, {r4-r5,lr}
diff --git a/arm9/asm/CTRDG_flash_MX29L010.s b/arm9/asm/CTRDG_flash_MX29L010.s
index 1b566288..646121f3 100644
--- a/arm9/asm/CTRDG_flash_MX29L010.s
+++ b/arm9/asm/CTRDG_flash_MX29L010.s
@@ -183,7 +183,7 @@ _020DD4FC:
 	orr r1, r1, r7
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r6
 	add sp, sp, #0x28
 	ldmia sp!, {r4-r8,lr}
@@ -323,7 +323,7 @@ _020DD714:
 	orr r0, r3, r0
 	strh r0, [r2, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	ldr r0, [sp, #0x4]
 	add sp, sp, #0x34
 	ldmia sp!, {r4-r11,lr}
@@ -391,7 +391,7 @@ CTRDGi_EraseFlashChipCoreMX: ; 0x020DD76C
 	orr r0, r0, r5
 	strh r0, [r3, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	add sp, sp, #0x4
 	ldmia sp!, {r4-r5,lr}
diff --git a/arm9/asm/CTRDG_flash_MX29L512.s b/arm9/asm/CTRDG_flash_MX29L512.s
index 38b1f5bf..f075c9f0 100644
--- a/arm9/asm/CTRDG_flash_MX29L512.s
+++ b/arm9/asm/CTRDG_flash_MX29L512.s
@@ -109,7 +109,7 @@ _020DD9B8:
 	orr r1, r1, r7
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r6
 	add sp, sp, #0x28
 	ldmia sp!, {r4-r8,lr}
diff --git a/arm9/asm/CTRDG_flash_common.s b/arm9/asm/CTRDG_flash_common.s
index 374c532c..9d245806 100644
--- a/arm9/asm/CTRDG_flash_common.s
+++ b/arm9/asm/CTRDG_flash_common.s
@@ -217,7 +217,7 @@ _020DC0D4:
 	orr r0, r0, r7
 	strh r0, [r3, #0x0]
 	ldrh r0, [r1, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, r4
 	add sp, sp, #0x24
 	ldmia sp!, {r4-r7,lr}
@@ -306,7 +306,7 @@ _020DC22C:
 	orr r1, r1, r8
 	strh r1, [r2, #0x0]
 	ldrh r0, [r0, #0x0]
-	bl OS_UnlockCartridge2
+	bl OS_UnlockCartridge
 	mov r0, #0x0
 	add sp, sp, #0x28
 	ldmia sp!, {r4-r8,lr}
diff --git a/arm9/asm/OS_spinLock.s b/arm9/asm/OS_spinLock.s
deleted file mode 100644
index f60e8604..00000000
--- a/arm9/asm/OS_spinLock.s
+++ /dev/null
@@ -1,354 +0,0 @@
-    .include "asm/macros.inc"
-    .include "global.inc"
-
-	.section .bss
-	.global isInitialized
-isInitialized: ; 0x021D347C
-	.space 0x4
-
-    .text
-
-	arm_func_start OS_UnlockCartridge
-OS_UnlockCartridge: ; 0x020CA094
-	ldr r1, _020CA09C ; =OS_UnlockCartridge2
-	bx r1
-	.balign 4
-_020CA09C: .word OS_UnlockCartridge2
-
-	arm_func_start OS_GetLockID
-OS_GetLockID: ; 0x020CA0A0
-	ldr r3, _020CA0F0 ; =0x027FFFB0
-	ldr r1, [r3, #0x0]
-	clz r2, r1
-	cmp r2, #0x20
-	movne r0, #0x40
-	bne _020CA0D4
-	add r3, r3, #0x4
-	ldr r1, [r3, #0x0]
-	clz r2, r1
-	cmp r2, #0x20
-	ldr r0, _020CA0F4 ; =0xFFFFFFFD
-	bxeq lr
-	mov r0, #0x60
-_020CA0D4:
-	add r0, r0, r2
-	mov r1, #0x80000000
-	mov r1, r1, lsr r2
-	ldr r2, [r3, #0x0]
-	bic r2, r2, r1
-	str r2, [r3, #0x0]
-	bx lr
-	.balign 4
-_020CA0F0: .word 0x027FFFB0
-_020CA0F4: .word 0xFFFFFFFD
-
-	arm_func_start OS_ReleaseLockID
-OS_ReleaseLockID: ; 0x020CA0F8
-	ldr r3, _020CA124 ; =0x027FFFB0
-	cmp r0, #0x60
-	addpl r3, r3, #0x4
-	subpl r0, r0, #0x60
-	submi r0, r0, #0x40
-	mov r1, #0x80000000
-	mov r1, r1, lsr r0
-	ldr r2, [r3, #0x0]
-	orr r2, r2, r1
-	str r2, [r3, #0x0]
-	bx lr
-	.balign 4
-_020CA124: .word 0x027FFFB0
-
-	arm_func_start OS_ReadOwnerOfLockWord
-OS_ReadOwnerOfLockWord: ; 0x020CA128
-	ldrh r0, [r0, #0x4]
-	bx lr
-
-	arm_func_start OSi_FreeCardBus
-OSi_FreeCardBus: ; 0x020CA130
-	ldr r1, _020CA144 ; =0x04000204
-	ldrh r0, [r1, #0x0]
-	orr r0, r0, #0x800
-	strh r0, [r1, #0x0]
-	bx lr
-	.balign 4
-_020CA144: .word 0x04000204
-
-	arm_func_start OSi_AllocateCardBus
-OSi_AllocateCardBus: ; 0x020CA148
-	ldr r1, _020CA15C ; =0x04000204
-	ldrh r0, [r1, #0x0]
-	bic r0, r0, #0x800
-	strh r0, [r1, #0x0]
-	bx lr
-	.balign 4
-_020CA15C: .word 0x04000204
-
-	arm_func_start OS_UnlockCard
-OS_UnlockCard: ; 0x020CA160
-	ldr ip, _020CA170 ; =OS_UnlockByWord
-	ldr r1, _020CA174 ; =0x027FFFE0
-	ldr r2, _020CA178 ; =OSi_FreeCardBus
-	bx r12
-	.balign 4
-_020CA170: .word OS_UnlockByWord
-_020CA174: .word 0x027FFFE0
-_020CA178: .word OSi_FreeCardBus
-
-	arm_func_start OS_TryLockCard
-OS_TryLockCard: ; 0x020CA17C
-	ldr ip, _020CA18C ; =OS_TryLockByWord
-	ldr r1, _020CA190 ; =0x027FFFE0
-	ldr r2, _020CA194 ; =OSi_AllocateCardBus
-	bx r12
-	.balign 4
-_020CA18C: .word OS_TryLockByWord
-_020CA190: .word 0x027FFFE0
-_020CA194: .word OSi_AllocateCardBus
-
-	arm_func_start OSi_FreeCartridgeBus
-OSi_FreeCartridgeBus: ; 0x020CA198
-	ldr r1, _020CA1AC ; =0x04000204
-	ldrh r0, [r1, #0x0]
-	orr r0, r0, #0x80
-	strh r0, [r1, #0x0]
-	bx lr
-	.balign 4
-_020CA1AC: .word 0x04000204
-
-	arm_func_start OSi_AllocateCartridgeBus
-OSi_AllocateCartridgeBus: ; 0x020CA1B0
-	ldr r1, _020CA1C4 ; =0x04000204
-	ldrh r0, [r1, #0x0]
-	bic r0, r0, #0x80
-	strh r0, [r1, #0x0]
-	bx lr
-	.balign 4
-_020CA1C4: .word 0x04000204
-
-	arm_func_start OS_TryLockCartridge
-OS_TryLockCartridge: ; 0x020CA1C8
-	ldr ip, _020CA1DC ; =OSi_DoTryLockByWord
-	ldr r1, _020CA1E0 ; =0x027FFFE8
-	ldr r2, _020CA1E4 ; =OSi_AllocateCartridgeBus
-	mov r3, #0x1
-	bx r12
-	.balign 4
-_020CA1DC: .word OSi_DoTryLockByWord
-_020CA1E0: .word 0x027FFFE8
-_020CA1E4: .word OSi_AllocateCartridgeBus
-
-	arm_func_start OS_UnlockCartridge2
-OS_UnlockCartridge2: ; 0x020CA1E8
-	ldr ip, _020CA1FC ; =FUN_020CA2B8
-	ldr r1, _020CA200 ; =0x027FFFE8
-	ldr r2, _020CA204 ; =OSi_FreeCartridgeBus
-	mov r3, #0x1
-	bx r12
-	.balign 4
-_020CA1FC: .word FUN_020CA2B8
-_020CA200: .word 0x027FFFE8
-_020CA204: .word OSi_FreeCartridgeBus
-
-	arm_func_start OS_LockCartridge
-OS_LockCartridge: ; 0x020CA208
-	ldr ip, _020CA21C ; =FUN_020CA358
-	ldr r1, _020CA220 ; =0x027FFFE8
-	ldr r2, _020CA224 ; =OSi_AllocateCartridgeBus
-	mov r3, #0x1
-	bx r12
-	.balign 4
-_020CA21C: .word FUN_020CA358
-_020CA220: .word 0x027FFFE8
-_020CA224: .word OSi_AllocateCartridgeBus
-
-	arm_func_start OSi_DoTryLockByWord
-OSi_DoTryLockByWord:
-	stmdb sp!, {r4-r9,lr}
-	sub sp, sp, #0x4
-	movs r6, r3
-	mov r9, r0
-	mov r8, r1
-	mov r7, r2
-	beq _020CA250
-	bl OS_DisableInterrupts_IrqAndFiq
-	mov r5, r0
-	b _020CA258
-_020CA250:
-	bl OS_DisableInterrupts
-	mov r5, r0
-_020CA258:
-	mov r0, r9
-	mov r1, r8
-	bl MI_SwapWord
-	movs r4, r0
-	bne _020CA27C
-	cmp r7, #0x0
-	beq _020CA278
-	blx r7
-_020CA278:
-	strh r9, [r8, #0x4]
-_020CA27C:
-	cmp r6, #0x0
-	beq _020CA290
-	mov r0, r5
-	bl OS_RestoreInterrupts_IrqAndFiq
-	b _020CA298
-_020CA290:
-	mov r0, r5
-	bl OS_RestoreInterrupts
-_020CA298:
-	mov r0, r4
-	add sp, sp, #0x4
-	ldmia sp!, {r4-r9,lr}
-	bx lr
-
-	arm_func_start OS_UnlockByWord
-OS_UnlockByWord: ; 0x020CA2A8
-	ldr ip, _020CA2B4 ; =FUN_020CA2B8
-	mov r3, #0x0
-	bx r12
-	.balign 4
-_020CA2B4: .word FUN_020CA2B8
-
-	arm_func_start FUN_020CA2B8
-FUN_020CA2B8: ; 0x020CA2B8
-	stmdb sp!, {r4-r7,lr}
-	sub sp, sp, #0x4
-	mov r7, r1
-	ldrh r1, [r7, #0x4]
-	mov r6, r2
-	mov r5, r3
-	cmp r0, r1
-	addne sp, sp, #0x4
-	mvnne r0, #0x1
-	ldmneia sp!, {r4-r7,lr}
-	bxne lr
-	cmp r5, #0x0
-	beq _020CA2F8
-	bl OS_DisableInterrupts_IrqAndFiq
-	mov r4, r0
-	b _020CA300
-_020CA2F8:
-	bl OS_DisableInterrupts
-	mov r4, r0
-_020CA300:
-	mov r0, #0x0
-	strh r0, [r7, #0x4]
-	cmp r6, #0x0
-	beq _020CA314
-	blx r6
-_020CA314:
-	mov r0, #0x0
-	str r0, [r7, #0x0]
-	cmp r5, #0x0
-	beq _020CA330
-	mov r0, r4
-	bl OS_RestoreInterrupts_IrqAndFiq
-	b _020CA338
-_020CA330:
-	mov r0, r4
-	bl OS_RestoreInterrupts
-_020CA338:
-	mov r0, #0x0
-	add sp, sp, #0x4
-	ldmia sp!, {r4-r7,lr}
-	bx lr
-
-	arm_func_start OS_TryLockByWord
-OS_TryLockByWord: ; 0x020CA348
-	ldr ip, _020CA354 ; =FUN_020CA358
-	mov r3, #0x0
-	bx r12
-	.balign 4
-_020CA354: .word FUN_020CA358
-
-	arm_func_start FUN_020CA358
-FUN_020CA358: ; 0x020CA358
-	stmdb sp!, {r4-r8,lr}
-	mov r8, r0
-	mov r7, r1
-	mov r6, r2
-	mov r5, r3
-	bl OSi_DoTryLockByWord
-	cmp r0, #0x0
-	ldmleia sp!, {r4-r8,lr}
-	bxle lr
-	mov r4, #0x400
-_020CA380:
-	mov r0, r4
-	bl SVC_WaitByLoop
-	mov r0, r8
-	mov r1, r7
-	mov r2, r6
-	mov r3, r5
-	bl OSi_DoTryLockByWord
-	cmp r0, #0x0
-	bgt _020CA380
-	ldmia sp!, {r4-r8,lr}
-	bx lr
-
-	arm_func_start OS_InitLock
-OS_InitLock: ; 0x020CA3AC
-	stmdb sp!, {r4-r5,lr}
-	sub sp, sp, #0x4
-	ldr r0, _020CA484 ; =isInitialized
-	ldr r1, [r0, #0x0]
-	cmp r1, #0x0
-	addne sp, sp, #0x4
-	ldmneia sp!, {r4-r5,lr}
-	bxne lr
-	mov r2, #0x1
-	ldr r1, _020CA488 ; =0x027FFFF0
-	str r2, [r0, #0x0]
-	mov r2, #0x0
-	mov r0, #0x7e
-	str r2, [r1, #0x0]
-	bl OS_TryLockByWord
-	ldr r5, _020CA488 ; =0x027FFFF0
-	ldrh r0, [r5, #0x6]
-	cmp r0, #0x0
-	beq _020CA410
-	mov r4, #0x400
-_020CA3FC:
-	mov r0, r4
-	bl SVC_WaitByLoop
-	ldrh r0, [r5, #0x6]
-	cmp r0, #0x0
-	bne _020CA3FC
-_020CA410:
-	ldr r2, _020CA48C ; =0x027FFFB0
-	mvn r12, #0x0
-	mov r0, #0x10000
-	ldr r3, _020CA490 ; =0x027FFFB4
-	ldr r1, _020CA494 ; =0x027FFFC0
-	str r12, [r2, #0x0]
-	rsb r12, r0, #0x0
-	mov r0, #0x0
-	mov r2, #0x28
-	str r12, [r3, #0x0]
-	bl MIi_CpuClear32
-	ldr ip, _020CA498 ; =0x04000204
-	ldr r1, _020CA488 ; =0x027FFFF0
-	ldrh r3, [r12, #0x0]
-	mov r0, #0x7e
-	mov r2, #0x0
-	orr r3, r3, #0x800
-	strh r3, [r12, #0x0]
-	ldrh r3, [r12, #0x0]
-	orr r3, r3, #0x80
-	strh r3, [r12, #0x0]
-	bl OS_UnlockByWord
-	ldr r1, _020CA488 ; =0x027FFFF0
-	mov r0, #0x7f
-	mov r2, #0x0
-	bl OS_TryLockByWord
-	add sp, sp, #0x4
-	ldmia sp!, {r4-r5,lr}
-	bx lr
-	.balign 4
-_020CA484: .word isInitialized
-_020CA488: .word 0x027FFFF0
-_020CA48C: .word 0x027FFFB0
-_020CA490: .word 0x027FFFB4
-_020CA494: .word 0x027FFFC0
-_020CA498: .word 0x04000204
diff --git a/arm9/global.inc b/arm9/global.inc
index 2117f570..f130ad11 100644
--- a/arm9/global.inc
+++ b/arm9/global.inc
@@ -7163,12 +7163,14 @@
 .extern OS_SleepThread

 .extern OS_SpinWait

 .extern OS_Terminate

+.extern OS_TryLockByWord

 .extern OS_TryLockCard

 .extern OS_TryLockCartridge

 .extern OS_TryLockMutex

+.extern OS_UnlockByWord

 .extern OS_UnlockCard

+.extern OS_UnLockCartridge

 .extern OS_UnlockCartridge

-.extern OS_UnlockCartridge2

 .extern OS_UnlockMutex

 .extern OS_WaitIrq

 .extern OS_WaitVBlankIntr

@@ -7178,7 +7180,10 @@
 .extern OSi_AlarmQueue

 .extern OSi_CurrentThreadPtr

 .extern OSi_DebuggerHandler

+.extern OSi_DoLockByWord

 .extern OSi_DoResetSystem

+.extern OSi_DoTryLockByWord

+.extern OSi_DoUnlockByWord

 .extern OSi_EnterDmaCallback

 .extern OSi_EnterTimerCallback

 .extern OSi_ExContext

diff --git a/arm9/lib/include/MI_exMemory.h b/arm9/lib/include/MI_exMemory.h
index 4a8a10a8..8bd355ac 100644
--- a/arm9/lib/include/MI_exMemory.h
+++ b/arm9/lib/include/MI_exMemory.h
@@ -1,9 +1,23 @@
 #ifndef NITRO_MI_EXMEMORY_H_
 #define NITRO_MI_EXMEMORY_H_
 
+#include "consts.h"
+
 typedef enum {
     MI_PROCESSOR_ARM9 = 0,
     MI_PROCESSOR_ARM7 = 1
 } MIProcessor;
 
+static inline void MIi_SetCardProcessor(MIProcessor proc)
+{
+    reg_MI_EXMEMCNT =
+            (u16)((reg_MI_EXMEMCNT & ~0x0800) | (proc << 11));
+}
+
+static inline void MIi_SetCartridgeProcessor(MIProcessor proc)
+{
+    reg_MI_EXMEMCNT =
+            (u16)((reg_MI_EXMEMCNT & ~0x0080) | (proc << 7));
+}
+
 #endif //NITRO_MI_EXMEMORY_H_
diff --git a/arm9/lib/include/OS_init.h b/arm9/lib/include/OS_init.h
index a998b45e..69d21213 100644
--- a/arm9/lib/include/OS_init.h
+++ b/arm9/lib/include/OS_init.h
@@ -23,6 +23,7 @@
 #include "OS_terminate_proc.h"
 #include "OS_interrupt.h"
 #include "OS_reset.h"
+#include "OS_spinLock.h"
 
 void OS_Init();
 
diff --git a/arm9/lib/include/OS_spinLock.h b/arm9/lib/include/OS_spinLock.h
index 3bb8a1c2..eccc502b 100644
--- a/arm9/lib/include/OS_spinLock.h
+++ b/arm9/lib/include/OS_spinLock.h
@@ -5,12 +5,41 @@
 #ifndef POKEDIAMOND_OS_SPINLOCK_H
 #define POKEDIAMOND_OS_SPINLOCK_H
 
+#include "types.h"
+#include "syscall.h"
+
 typedef volatile struct OSLockWord {
     u32 lockFlag;
     u16 ownerID;
     u16 extension;
 } OSLockWord;
 
+static inline void OSi_WaitByLoop(void)
+{
+    SVC_WaitByLoop(0x1000 / 4);
+}
+
+void OS_InitLock(void);
+s32 OSi_DoLockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void),
+        BOOL disableFiq);
+s32 OS_TryLockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void));
+s32 OSi_DoUnlockByWord(u16 lockID, OSLockWord *lockp, void (*ctrlFuncp) (void),
+        BOOL disableFIQ);
+s32 OS_UnlockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void));
+s32 OSi_DoTryLockByWord(u16 lockID, OSLockWord *lockp, void (*ctrlFuncp) (void),
+        BOOL disableFiq);
+s32 OS_LockCartridge(u16 lockID);
+s32 OS_UnlockCartridge(u16 lockID);
+s32 OS_TryLockCartridge(u16 lockID);
+void OSi_AllocateCartridgeBus(void);
+void OSi_FreeCartridgeBus(void);
+s32 OS_TryLockCard(u16 lockID);
+s32 OS_UnlockCard(u16 lockID);
+void OSi_AllocateCardBus(void);
+void OSi_FreeCardBus(void);
+u16 OS_ReadOwnerOfLockWord(OSLockWord * lock);
+s32 OS_UnLockCartridge(u16 lockID);
 s32 OS_GetLockID(void);
+void OS_ReleaseLockID(register u16 lockID);
 
 #endif //POKEDIAMOND_OS_SPINLOCK_H
diff --git a/arm9/lib/include/mmap.h b/arm9/lib/include/mmap.h
index 27255115..207e0509 100644
--- a/arm9/lib/include/mmap.h
+++ b/arm9/lib/include/mmap.h
@@ -39,6 +39,11 @@ extern u32 SDK_AUTOLOAD_DTCM_START[];
 #define HW_DTCM_SVC_STACK       (HW_DTCM_SVC_STACK_END - HW_SVC_STACK_SIZE)
 #define HW_DTCM_IRQ_STACK_END   (HW_DTCM_SVC_STACK)
 
+#define HW_LOCK_ID_FLAG_MAIN    (HW_MAIN_MEM + 0x007fffb0)
+#define HW_SHARED_LOCK_BUF      (HW_MAIN_MEM + 0x007fffc0)
+#define HW_CARD_LOCK_BUF        (HW_MAIN_MEM + 0x007fffe0)
+#define HW_CTRDG_LOCK_BUF       (HW_MAIN_MEM + 0x007fffe8)
+
 #define HW_BUTTON_XY_BUF        (HW_MAIN_MEM + 0x007fffa8)
 
 #define OSi_MAIN_ARENA_HI_DEFAULT       (HW_MAIN_MEM_MAIN_END)
diff --git a/arm9/lib/src/OS_init.c b/arm9/lib/src/OS_init.c
index a1db8788..a34196f4 100644
--- a/arm9/lib/src/OS_init.c
+++ b/arm9/lib/src/OS_init.c
@@ -6,7 +6,6 @@
 #include "OS_init.h"
 
 extern void PXI_Init();
-extern void OS_InitLock();
 extern void OS_InitException();
 extern void MI_Init();
 extern void OS_InitVAlarm();
diff --git a/arm9/lib/src/OS_printf.c b/arm9/lib/src/OS_printf.c
index ba484df8..026bc2d7 100644
--- a/arm9/lib/src/OS_printf.c
+++ b/arm9/lib/src/OS_printf.c
@@ -1,12 +1,12 @@
 #include "global.h"
 #include "OS_printf.h"
 
-struct printfStr
+typedef struct printfStr
 {
     s32 spaceLeft;
     s8 *stringEnd;
     s8 *stringStart;
-};
+} printfStr;
 
 void string_put_char(struct printfStr *dest, s8 value);
 void string_fill_char(struct printfStr *dest, s8 value, s32 count);
@@ -722,525 +722,420 @@ ARM_FUNC s32 OS_SNPrintf(s8 *buffer, s32 bufsz, const s8 *format, ...)
 
 #ifdef NONMATCHING
 
-struct Unk
-{
-    s32 unk00;
-    s32 unk04;
-    s32 unk08;
-    s32 unk0C;
-    s32 unk10;
-    s32 unk14;
-    s32 unk18;
-    s32 unk1C;
-    s32 unk20;
-    s32 unk24;
-    s32 unk28;
-    s32 unk2C;
-    s32 unk30;
-    s32 unk34;
-    s8 unk38;
-    s8 unk39;
-    s8 unk3A;
-    // not sure about this struct's size or even if it's a single struct
-};
-
 #define va_arg(list, ty) *(ty *)((u32 *)(list = (void *)((u32 *)(list) + 1)) - 1)
 #define va_arg_64(list, sgn) *((sgn##64 *)(list = (void *)((sgn##64 *)(list) + 1)) - 1)
 
 ARM_FUNC s32 OS_VSNPrintf(s8 *buffer, s32 bufsz, const s8 *format, void *args)
 {
-    struct printfStr str;
-    struct Unk unk;
+    s8 buf[24];
+    s32 n_buf;
+    s8 prefix[2];
+    s32 n_prefix;
+
+    const s8 *s = format;
+
+    printfStr str;
     str.spaceLeft = bufsz;
     str.stringStart = buffer;
     str.stringEnd = buffer;
 
-    if (*format != 0)
+    while (*s)
     {
-        // these assignments are likely wrong
-        unk.unk04 = 0;
-        unk.unk0C = 10;
-        unk.unk1C = 32;
-        unk.unk20 = 48;
-        unk.unk08 = 0;
-        unk.unk10 = 87;
-        unk.unk14 = 8;
-        unk.unk18 = 55;
-        unk.unk24 = 16;
-        unk.unk28 = 1;
-        unk.unk34 = 43;
-        unk.unk30 = 45;
-        unk.unk2C = 2;
-        
-
-        do
+        // matches:
+        // binary range        (hex range) [dec range]
+        // 1000 0001-1001 1111 (0x81-0x9F) [129-159]
+        // 1110 0000-1111 1100 (0xE0-0xFC) [224-252]
+        if ((u32)(((u8)*s ^ 0x20) - 0xa1) < 0x3c)
         {
-            s8 c = *format;
-            u32 x = (u8)c;
-
-            // matches:
-            // binary range        (hex range) [dec range]
-            // 1000 0001-1001 1111 (0x81-0x9F) [129-159]
-            // 1110 0000-1111 1100 (0xE0-0xFC) [224-252]
-            if ((x ^ 0x20) - 0xa1 < 0x3c)
+            string_put_char(&str, *s++);
+            if (*s)
+            {
+                string_put_char(&str, *s++);
+            }
+        }
+        else if (*s != '%')
+        {
+            string_put_char(&str, *s++);
+        }
+        else
+        {
+            enum {
+                blank = 000001,
+                plus = 000002,
+                sharp = 000004,
+                minus = 000010,
+                zero = 000020,
+                l1 = 000040,
+                h1 = 000100,
+                l2 = 000200,
+                h2 = 000400,
+                usigned = 010000,
+                end
+            };
+            s32 flag = 0, width = 0, precision = -1, radix = 10;
+            s8 hex = 'a' - 10;
+            const s8 *p_start = s;
+            for (;;)
             {
-                string_put_char(&str, c);
-                c = *(++format);
-                if (c != 0)
+                switch (*++s)
                 {
-                    format++;
-                    string_put_char(&str, c);
+                case '+':
+                    if (s[-1] != ' ')
+                        break;
+                    flag |= plus;
+                    continue;
+                case ' ':
+                    flag |= blank;
+                    continue;
+                case '-':
+                    flag |= minus;
+                    continue;
+                case '0':
+                    flag |= zero;
+                    continue;
                 }
+                break;
             }
-            else if (c != '%')
+            if (*s == '*')
             {
-                format++;
-                string_put_char(&str, c);
+                ++s, width = va_arg(args, s32);
+                if (width < 0)
+                {
+                    width = -width, flag |= minus;
+                }
             }
             else
             {
-                s32 flags = unk.unk04;
-                s32 r5 = unk.unk08;
-                s32 r2 = unk.unk0C;
-                s32 r0 = unk.unk10;
-                s32 r10 = flags;
-                const s8 *r3 = format;
-                s8 r4;
-                while (1)
+                while ((*s >= '0') && (*s <= '9'))
                 {
-                    r4 = *(++format);
-                    switch (r4)
-                    {
-                    case '+':
-                        c = *(format - 1);
-                        if (c == ' ')
-                            goto post_padding;
-                        flags |= 0x2;
-                        break;
-                    case ' ':
-                        flags |= 0x1;
-                        break;
-                    case '-':
-                        flags |= 0x8;
-                        break;
-                    case '0':
-                        flags |= 0x10;
-                        break;
-                    default:
-                        goto post_padding;
-                    }
+                    width = (width * 10) + *s++ - '0';
                 }
-            post_padding:
-                if (r4 == '*')
+            }
+
+            if (*s == '.')
+            {
+                ++s, precision = 0;
+                if (*s == '*')
                 {
-                    u32 v = va_arg(args, u32);
-                    format++;
-                    if (v < 0)
+                    ++s, precision = va_arg(args, s32);
+                    if (precision < 0)
                     {
-                        r10 = -r10;
-                        flags |= 0x8;
+                        precision = -1;
                     }
                 }
                 else
                 {
-                    for (c = *format; c >= '0' && c <= '9'; c = *format)
+                    while ((*s >= '0') && (*s <= '9'))
                     {
-                        s8 d = *(format++);
-                        r10 = (r10 * 10 + d) - '0';
+                        precision = (precision * 10) + *s++ - '0';
                     }
                 }
+            }
 
-                c = *format;
-                if (c == '.')
-                {
-                    c = *(++format);
-                    r5 = unk.unk04;
-                    if (c == '*')
-                    {
-                        u32 v = va_arg(args, u32);
-                        format++;
-                        if (v < 0)
-                        {
-                            r5 = unk.unk08;
-                        }
-                    }
-                    for (c = *format; c >= '0' && c <= '9'; c = *format)
-                    {
-                        s8 d = *(format++);
-                        r5 = (r5 * 10 + d) - '0';
-                    }
+            switch (*s)
+            {
+            case 'h':
+                if (*++s != 'h') {
+                    flag |= h1;
+                }
+                else {
+                    ++s, flag |= h2;
+                }
+                break;
+            case 'l':
+                if (*++s != 'l') {
+                    flag |= l1;
                 }
+                else {
+                    ++s, flag |= l2;
+                }
+                break;
+            }
 
-                c = *format;
-                switch (c)
+            switch (*s)
+            {
+            case 'd':
+            case 'i':
+                goto put_int;
+            case 'o':
+                radix = 8;
+                flag |= usigned;
+                goto put_int;
+            case 'u':
+                flag |= usigned;
+                goto put_int;
+            case 'X':
+                hex = 'A' - 10;
+                goto put_hex;
+            case 'x':
+                goto put_hex;
+            case 'p':
+                flag |= sharp;
+                precision = 8;
+                goto put_hex;
+            case 'c':
+                if (precision >= 0)
+                    goto put_invalid;
                 {
-                case 'h':
-                    c = *format++;
-                    if (c != 'h')
+                    s32 v = va_arg(args, s32);
+                    width -= 1;
+                    if (flag & minus)
                     {
-                        flags |= 0x40;
-                        format++;
-                        flags |= 0x100;
+                        string_put_char(&str, (s8)v);
+                        string_fill_char(&str, ' ', width);
                     }
-                    break;
-                case 'l':
-                    c = *format++;
-                    if (c != 'l')
+                    else
                     {
-                        flags |= 0x20;
-                        format++;
-                        flags |= 0x80;
+                        s8 pad = (s8)((flag & zero) ? '0' : ' ');
+                        string_fill_char(&str, pad, width);
+                        string_put_char(&str, (s8)v);
                     }
-                    break;
+                    ++s;
                 }
-
-                c = *format;
-                switch (c)
+                break;
+            case 's':
+            {
+                s32 n_bufs = 0;
+                const s8 *p_bufs = va_arg(args, const s8 *);
+                if (precision < 0)
                 {
-                case 'o':
-                    r2 = unk.unk14;
-                    flags |= 0x1000;
-                    break;
-                case 'u':
-                    flags |= 0x1000;
-                    break;
-                case 'X':
-                    r0 = unk.unk18;
-                    goto case_x;
-                case 'p':
-                    flags |= 0x4;
-                    r5 = unk.unk14;
-                case 'c':
-                    if ((s32)r5 < 0)
+                    while (p_bufs[n_bufs])
                     {
-                        r0 = flags & 0x8;
-                        u32 v = va_arg(args, u32);
-                        if (r0)
-                        {
-                            string_put_char(&str, (s8)v);
-                            string_fill_char(&str, (s8)unk.unk1C, r10 - 1);
-                        }
-                        else
-                        {
-                            r0 = flags & 0x10;
-                            if (r0)
-                                r0 = unk.unk20;
-                            else
-                                r0 = unk.unk1C;
-                            string_fill_char(&str, (s8)r0, r10 - 1);
-                            string_put_char(&str, (s8)v);
-                        }
-                        format++;
+                        ++n_bufs;
                     }
-                    break;
-                case 's':
+                }
+                else
                 {
-                    s8 *v = *(((s8 **)args)++);
-                    s32 count = unk.unk04;
-                    if (r5 < 0)
+                    while (n_bufs < precision && p_bufs[n_bufs])
                     {
-                        while (v[count] != 0)
-                        {
-                            count++;
-                        }
+                        ++n_bufs;
                     }
-                    else
+                }
+                width -= n_bufs;
+                if (flag & minus)
+                {
+                    string_put_string(&str, p_bufs, n_bufs);
+                    string_fill_char(&str, ' ', width);
+                }
+                else
+                {
+                    s8 pad = (s8)((flag & zero) ? '0' : ' ');
+                    string_fill_char(&str, pad, width);
+                    string_put_string(&str, p_bufs, n_bufs);
+                }
+                ++s;
+            }
+            break;
+            case 'n':
+            {
+                s32 count = str.stringEnd - str.stringStart;
+                if (!(flag & h2))
+                {
+                    if (flag & h1)
                     {
-                        while (count < r5 && v[count] != 0)
-                        {
-                            count++;
-                        }
+                        *va_arg(args, s16 *) = (s16)count;
                     }
-                    r0 = flags & 0x8;
-                    r10 = r10 - count;
-                    if (r0)
+                    else if (flag & l2)
                     {
-                        string_put_string(&str, v, count);
-                        string_fill_char(&str, (s8)unk.unk1C, r10);
+                        *va_arg(args, u64 *) = (u64)count;
                     }
                     else
                     {
-                        r0 = flags & 0x10;
-                        if (r0)
-                            r0 = unk.unk20;
-                        else
-                            r0 = unk.unk1C;
-                        string_fill_char(&str, (s8)r0, r10 - 1);
-                        string_put_string(&str, v, count);
+                        *va_arg(args, s32 *) = count;
                     }
-                    format++;
-                    break;
                 }
-                case 'n':
+                ++format;
+            }
+            case '%':
+                if (p_start + 1 != s)
+                    goto put_invalid;
+                string_put_char(&str, *s++);
+                break;
+
+            default:
+                goto put_invalid;
+
+            put_invalid:
+                string_put_string(&str, p_start, s - p_start);
+                break;
+
+            put_hex:
+                radix = 16;
+                flag |= usigned;
+            put_int:
+            {
+                u64 value = 0;
+                n_prefix = 0;
+                if (flag & minus)
                 {
-                    r0 = flags & 0x100;
-                    s32 count = str.stringEnd - str.stringStart;
-                    if (!r0)
-                    {
-                        if (flags & 0x40)
-                        {
-                            s16 *v = va_arg(args, s16 *);
-                            *v = (s16)count;
-                        }
-                        else if (flags & 0x80)
-                        {
-                            s64 *v = va_arg(args, s64 *);
-                            *v = count;
-                        }
-                        else
-                        {
-                            s64 *v = va_arg(args, s64 *);
-                            *v = count;
-                        }
-                    }
-                    format++;
+                    flag &= ~zero;
                 }
-                case '%':
-                    if (r3 + 1 == format)
-                    {
-                        format++;
-                        string_put_char(&str, c);
-                        break;
-                    }
-                    else
+                if (precision >= 0)
+                {
+                    flag &= ~zero;
+                }
+                else
+                {
+                    precision = 1;
+                }
+                if (flag & usigned)
+                {
+                    if (flag & h2)
                     {
-                        string_put_string(&str, r3, format - r3);
-                        break;
+                        value = va_arg(args, u8);
                     }
-                case 'x':
-                case_x:
-                    r2 = unk.unk24;
-                    flags |= 0x1000;
-                case 'd':
-                case 'i':
-                    if (flags & 0x8)
+                    else if (flag & h1)
                     {
-                        flags = flags & ~0x10;
+                        value = va_arg(args, u16);
                     }
-                    if (r5 >= 0)
+                    else if (flag & l2)
                     {
-                        flags = flags & ~0x10;
+                        value = va_arg_64(args, u);
                     }
                     else
                     {
-                        r5 = unk.unk28;
+                        value = va_arg(args, u32);
                     }
-                    s32 r7 = unk.unk04;
-                    u64 value;
-                    if (flags & 0x1000)
+                    flag &= ~(plus | blank);
+                    if (flag & sharp)
                     {
-                        if (flags & 0x100)
-                        {
-                            value = va_arg(args, u8);
-                        }
-                        else if (flags & 0x40)
-                        {
-                            value = va_arg(args, u16);
-                        }
-                        else if (flags & 0x80)
+                        if (radix == 16)
                         {
-                            value = va_arg_64(args, u);
+                            if (value != 0)
+                            {
+                                prefix[0] = (s8)(hex + (10 - 'x' - 'a'));
+                                prefix[1] = '0';
+                                n_prefix = 2;
+                            }
                         }
                         else
                         {
-                            value = va_arg(args, u32);
-                        }
-                        flags = flags & ~0x3;
-                        if (flags & 0x4)
-                        {
-                            if (r2 == 0x10)
+                            if (radix == 8)
                             {
-                                if (value != 0)
-                                {
-                                    s32 something = unk.unk20;
-                                    s32 somethingElse = unk.unk2C;
-                                    unk.unk39 = (s8)something;
-                                    unk.unk38 = (s8)(something + 0x21);
-                                    // 0x21 could be 'a'-'A'+1
-                                }
-                            }
-                            else
-                            {
-                                if (r2 == 0x8)
-                                {
-                                    s32 something = unk.unk20;
-                                    r7 = unk.unk28;
-                                    unk.unk38 = (s8)(something);
-                                }
+                                prefix[0] = '0';
+                                n_prefix = 1;
                             }
                         }
                     }
-                    else
-                    {
-                        if (flags & 0x100)
-                        {
-                            s32 x = (s32)va_arg(args, s8);
-                            value = (u64)x;
-                        }
-                        else if (flags & 0x40)
-                        {
-                            s32 x = (s32)va_arg(args, s16);
-                            value = (u64)x;
-                        }
-                        else if (flags & 0x80)
-                        {
-                            s64 dWord = va_arg_64(args, s);
-                            value = (u64)dWord;
-                        }
-                        else
-                        {
-                            s32 x = va_arg(args, s32);
-                            value = (u64)value;
-                        }
+                }
+                else {
+                    if (flag & h2) {
+                        value = va_arg(args, s8);
+                    } else if (flag & h1) {
+                        value = va_arg(args, s16);
+                    } else if (flag & l2) {
+                        value = va_arg_64(args, u);
+                    } else {
+                        value = va_arg(args, s32);
+                    }
 
-                        if (value & 0x8000000000000000)
-                        {
-                            unk.unk38 = (s8)unk.unk30;
-                            value = ~value + 1;
-                            r7 = unk.unk28;
-                        }
-                        else
-                        {
-                            if (value || r5)
-                            {
-                                if (flags & 0x2)
-                                {
-                                    r7 = unk.unk28;
-                                    unk.unk38 = (s8)unk.unk34;
-                                }
-                                else if (flags & 0x1)
-                                {
-                                    r7 = unk.unk28;
-                                    unk.unk38 = (s8)unk.unk1C;
-                                }
+                    if ((value >> 32) & 0x80000000) {
+                        value = ~value + 1;
+                        prefix[0] = '-';
+                        n_prefix = 1;
+                    } else {
+                        if (value || precision) {
+                            if (flag & plus) {
+                                prefix[0] = '+';
+                                n_prefix = 1;
+                            } else if (flag & blank) {
+                                prefix[0] = ' ';
+                                n_prefix = 1;
                             }
                         }
-                        s32 r8 = flags;
-                        switch (r2)
-                        {
+                    }
+                    n_buf = 0;
+                    switch (radix) {
                         case 8:
-                            while (value != 0)
-                            {
-                                u32 octDig = ((u32)value & 0x7) + '0';
-                                s8 *p = &unk.unk3A;
-                                p[r8] = (s8)octDig;
-                                value = value >> 3;
-                                r8++;
+                            while (value != 0) {
+                                s32 octDig = (s32) (value & 0x7);
+                                value >>= 3;
+                                buf[n_buf++] = (s8) (octDig + '0');
                             }
                             break;
                         case 10:
-                            if (value >> 32 == 0)
-                            {
-                                u32 v = (u32)value;
-                                while (v)
-                                {
+                            if (value >> 32 == 0) {
+                                u32 v = (u32) value;
+                                while (v) {
                                     u32 div10 = v / 10;
-                                    u32 dig = v - div10;
+                                    s32 dig = (s32) (v - (div10 * 10));
                                     v = div10;
-                                    s8 *p = &unk.unk3A;
-                                    p[r8] = (s8)dig;
-                                    r8++;
+                                    buf[n_buf++] = (s8) (dig + '0');
                                 }
-                            }
-                            else
-                            {
-                                while (value)
-                                {
+                            } else {
+                                while (value) {
                                     u64 div10 = value / 10;
-                                    u32 dig = (u32)(value - div10);
+                                    s32 dig = (s32) (value - (div10 * 10));
                                     value = div10;
-                                    s8 *p = &unk.unk3A;
-                                    p[r8] = (s8)dig;
-                                    r8++;
+                                    buf[n_buf++] = (s8) (dig + '0');
                                 }
                             }
                             break;
                         case 16:
-                            while (value != 0)
-                            {
-                                u32 hexDig = ((u32)value & 0xf);
-                                value = value >> 4;
-                                if (hexDig < 10)
-                                    hexDig = hexDig + '0';
-                                else
-                                    hexDig = hexDig + r0;
-                                s8 *p = &unk.unk3A;
-                                p[r8] = (s8)hexDig;
-                                r8++;
+                            while (value != 0) {
+                                s32 hexDig = (s32) (value & 0xf);
+                                value >>= 4;
+                                buf[n_buf++] = (s8) ((hexDig < 10) ? (hexDig + '0') : (hexDig + hex));
                             }
                             break;
+                    }
+                    if (n_prefix > 0) {
+                        if (prefix[0] == '0') {
+                            n_prefix = 0;
+                            buf[n_buf++] = '0';
                         }
-                        if (r7 > 0)
+                    }
+                }
+                    goto put_to_stream;
+
+                    put_to_stream:
+                    {
+                        s32 n_pad = (s32)(precision - n_buf);
+                        if (flag & zero)
                         {
-                            if (unk.unk38 == '0')
-                            {
-                                s8 *p = &unk.unk3A;
-                                p[r8] = (s8)unk.unk20;
-                                r7 = flags;
-                                r8++;
-                            }
-                            r5 = r5 - r8;
-                            if (flags & 0x10)
-                            {
-                                if (r5 < r10 - r8 - r7)
-                                {
-                                    r5 = r10 - r8 - r7;
-                                }
-                            }
-                            if (r5 > 0)
+                            if (n_pad < width - n_buf - n_prefix)
                             {
-                                r10 = r10 - r5;
+                                n_pad = (s32)(width - n_buf - n_prefix);
                             }
+                        }
+                        if (n_pad > 0)
+                        {
+                            width -= n_pad;
+                        }
 
-                            r10 = r10 - (r7 + r8);
-                            flags = flags & 0x8;
-                            if (!flags)
-                            {
-                                string_fill_char(&str, (s8)unk.unk1C, r10);
-                            }
-                            s8 *x = &unk.unk38 + r7;
-                            while (r7 > 0)
-                            {
-                                s8 ch = *(x--);
-                                r7--;
-                                string_put_char(&str, ch);
-                            }
-                            string_fill_char(&str, (s8)unk.unk20, r5);
-                            x = &unk.unk3A + r8;
-                            while (r8 > 0)
-                            {
-                                s8 ch = *(x--);
-                                r8--;
-                                string_put_char(&str, ch);
-                            }
-                            if (flags)
-                            {
-                                string_fill_char(&str, (s8)unk.unk1C, r10);
-                            }
+                        width -= n_prefix + n_buf;
+                        if (!(flag & minus))
+                        {
+                            string_fill_char(&str, ' ', width);
                         }
+                        while (n_prefix > 0)
+                        {
+                            string_put_char(&str, prefix[--n_prefix]);
+                        }
+                        string_fill_char(&str, '0', n_pad);
+                        while (n_buf > 0)
+                        {
+                            string_put_char(&str, buf[--n_buf]);
+                        }
+                        if (flag & minus)
+                        {
+                            string_fill_char(&str, ' ', width);
+                        }
+                        ++s;
                     }
-                    format++;
-                    break;
-                }
-                if (str.spaceLeft != 0)
-                {
-                    *str.stringEnd = 0;
-                }
-                else if (unk.unk00 != 0)
-                {
-                    *(str.stringStart + unk.unk00 - 1) = 0;
                 }
+                break;
             }
-        } while (*format != 0);
+        }
     }
 
-    if (str.spaceLeft != 0)
+    if (str.spaceLeft > 0)
     {
-        *str.stringEnd = 0;
+        *str.stringEnd = '\0';
     }
-    else if (unk.unk00 != 0)
+    else if (bufsz > 0)
     {
-        str.stringStart[unk.unk00] = 0;
+        str.stringStart[bufsz - 1] = '\0';
     }
     return str.stringEnd - str.stringStart;
 }
diff --git a/arm9/lib/src/OS_spinLock.c b/arm9/lib/src/OS_spinLock.c
new file mode 100644
index 00000000..5050a7bd
--- /dev/null
+++ b/arm9/lib/src/OS_spinLock.c
@@ -0,0 +1,217 @@
+//
+// Created by red031000 on 2020-05-21.
+//
+
+#include "OS_spinLock.h"
+#include "OS_system.h"
+#include "function_target.h"
+#include "consts.h"
+#include "MI_exMemory.h"
+
+extern void MIi_CpuClear32(u32 param1, void * addr, u32 length); //not too sure about names
+extern u32 MI_SwapWord(u32 data, volatile u32* destp);
+
+ARM_FUNC void OS_InitLock(void)
+{
+    static BOOL isInitialized = FALSE;
+
+    if (isInitialized)
+    {
+        return;
+    }
+    isInitialized = TRUE;
+
+    OSLockWord* lockp = (OSLockWord *)0x027FFFF0;
+
+    lockp->lockFlag = 0;
+
+    (void)OS_TryLockByWord(0x7e, lockp, NULL);
+
+    while (lockp->extension)
+    {
+        OSi_WaitByLoop();
+    }
+
+    ((u32 *)HW_LOCK_ID_FLAG_MAIN)[0] = 0xffffffff;
+    ((u32 *)HW_LOCK_ID_FLAG_MAIN)[1] = 0xffff0000;
+
+    MIi_CpuClear32(0x0, (void *)HW_SHARED_LOCK_BUF, 0x28);
+
+    MIi_SetCardProcessor(MI_PROCESSOR_ARM7);
+
+    MIi_SetCartridgeProcessor(MI_PROCESSOR_ARM7);
+
+    (void)OS_UnlockByWord(0x7e, lockp, NULL);
+    (void)OS_TryLockByWord(0x7f, lockp, NULL);
+}
+
+ARM_FUNC s32 OSi_DoLockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void), //should be static
+                                     BOOL disableFiq)
+{
+    s32 lastLockFlag;
+    while ((lastLockFlag = OSi_DoTryLockByWord(lockId, lockp, ctrlFuncp, disableFiq)) > 0) {
+        OSi_WaitByLoop();
+    }
+
+    return lastLockFlag;
+}
+
+ARM_FUNC s32 OS_TryLockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void))
+{
+    return OSi_DoLockByWord(lockId, lockp, ctrlFuncp, FALSE);
+}
+
+ARM_FUNC s32 OSi_DoUnlockByWord(u16 lockID, OSLockWord *lockp, void (*ctrlFuncp) (void),
+                                        BOOL disableFIQ)
+{
+    if (lockID != lockp->ownerID)
+    {
+        return -2;
+    }
+
+    OSIntrMode lastIntrMode = (disableFIQ) ? OS_DisableInterrupts_IrqAndFiq() : OS_DisableInterrupts();
+    lockp->ownerID = 0;
+    if (ctrlFuncp)
+    {
+        ctrlFuncp();
+    }
+    lockp->lockFlag = 0;
+    if (disableFIQ)
+    {
+        (void)OS_RestoreInterrupts_IrqAndFiq(lastIntrMode);
+    }
+    else
+    {
+        (void)OS_RestoreInterrupts(lastIntrMode);
+    }
+    return 0;
+}
+
+ARM_FUNC s32 OS_UnlockByWord(u16 lockID, OSLockWord* lockp, void (*ctrlFuncp) (void))
+{
+    return OSi_DoUnlockByWord(lockID, lockp, ctrlFuncp, FALSE);
+}
+
+ARM_FUNC s32 OSi_DoTryLockByWord(u16 lockID, OSLockWord *lockp, void (*ctrlFuncp) (void),
+        BOOL disableFiq)
+{
+    OSIntrMode lastIntrMode = (disableFiq) ? OS_DisableInterrupts_IrqAndFiq() : OS_DisableInterrupts();
+
+    s32 lastLockFlag = (s32)MI_SwapWord(lockID, &lockp->lockFlag);
+
+    if (!lastLockFlag)
+    {
+        if (ctrlFuncp)
+        {
+            ctrlFuncp();
+        }
+        lockp->ownerID = lockID;
+    }
+
+    if (disableFiq)
+    {
+        (void)OS_RestoreInterrupts_IrqAndFiq(lastIntrMode);
+    }
+    else
+    {
+        (void)OS_RestoreInterrupts(lastIntrMode);
+    }
+
+    return lastLockFlag;
+}
+
+ARM_FUNC s32 OS_LockCartridge(u16 lockID)
+{
+    return OSi_DoLockByWord(lockID, (OSLockWord *)HW_CTRDG_LOCK_BUF, OSi_AllocateCartridgeBus, TRUE);
+}
+
+ARM_FUNC s32 OS_UnlockCartridge(u16 lockID)
+{
+    return OSi_DoUnlockByWord(lockID, (OSLockWord *)HW_CTRDG_LOCK_BUF, OSi_FreeCartridgeBus, TRUE);
+}
+
+ARM_FUNC s32 OS_TryLockCartridge(u16 lockID)
+{
+    return OSi_DoTryLockByWord(lockID, (OSLockWord *)HW_CTRDG_LOCK_BUF, OSi_AllocateCartridgeBus, TRUE);
+}
+
+ARM_FUNC void OSi_AllocateCartridgeBus(void)
+{
+    MIi_SetCartridgeProcessor(MI_PROCESSOR_ARM9);
+}
+
+ARM_FUNC void OSi_FreeCartridgeBus(void)
+{
+    MIi_SetCartridgeProcessor(MI_PROCESSOR_ARM7);
+}
+
+ARM_FUNC s32 OS_TryLockCard(u16 lockID)
+{
+    return OS_TryLockByWord(lockID, (OSLockWord *)HW_CARD_LOCK_BUF, OSi_AllocateCardBus);
+}
+
+ARM_FUNC s32 OS_UnlockCard(u16 lockID)
+{
+    return OS_UnlockByWord(lockID, (OSLockWord *)HW_CARD_LOCK_BUF, OSi_FreeCardBus);
+}
+
+ARM_FUNC void OSi_AllocateCardBus(void)
+{
+    MIi_SetCardProcessor(MI_PROCESSOR_ARM9);
+}
+
+ARM_FUNC void OSi_FreeCardBus(void)
+{
+    MIi_SetCardProcessor(MI_PROCESSOR_ARM7);
+}
+
+ARM_FUNC u16 OS_ReadOwnerOfLockWord(OSLockWord * lock)
+{
+    return lock->ownerID;
+}
+
+ARM_FUNC asm s32 OS_UnLockCartridge(u16 lockID)
+{
+    ldr r1, =OS_UnlockCartridge
+    bx r1
+}
+
+ARM_FUNC asm s32 OS_GetLockID(void)
+{
+    ldr r3, =HW_LOCK_ID_FLAG_MAIN
+    ldr r1, [r3, #0x0]
+    clz r2, r1
+    cmp r2, #0x20
+    movne r0, #0x40
+    bne _020CA0D4
+    add r3, r3, #0x4
+    ldr r1, [r3, #0x0]
+    clz r2, r1
+    cmp r2, #0x20
+    ldr r0, =0xFFFFFFFD
+    bxeq lr
+    mov r0, #0x60
+_020CA0D4:
+    add r0, r0, r2
+    mov r1, #0x80000000
+    mov r1, r1, lsr r2
+    ldr r2, [r3, #0x0]
+    bic r2, r2, r1
+    str r2, [r3, #0x0]
+    bx lr
+}
+
+ARM_FUNC asm void OS_ReleaseLockID(register u16 lockID)
+{
+    ldr r3, =HW_LOCK_ID_FLAG_MAIN
+    cmp r0, #0x60
+    addpl r3, r3, #0x4
+    subpl r0, r0, #0x60
+    submi r0, r0, #0x40
+    mov r1, #0x80000000
+    mov r1, r1, lsr r0
+    ldr r2, [r3, #0x0]
+    orr r2, r2, r1
+    str r2, [r3, #0x0]
+    bx lr
+}