Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-04-26 00:32:20 -05:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Match all of NNS/gfd

Browse Source
This commit is contained in:
Nomura 2023-01-09 11:37:39 +01:00
parent afca00a398
commit b60aec17e2
24 changed files with 1794 additions and 1913 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
lib/NitroSystem/asm/gfd/gfd_frameplttvramman.s
View File

@ -1,174 +0,0 @@
.include "macros/function.inc"
.include "include/gfd_frameplttvramman.inc"
.extern Unk_021C3AB4
.extern NNS_GfdDefaultFuncAllocPlttVram
.extern NNS_GfdDefaultFuncFreePlttVram
.text
arm_func_start NNS_GfdInitFrmPlttVramManager
NNS_GfdInitFrmPlttVramManager: ; 0x020A5D88
stmfd sp!, {r4, lr}
ldr r2, _020A5DC0 ; =0x021C3AB4
mov r4, r1
str r0, [r2, #8]
bl NNS_GfdResetFrmPlttVramState
cmp r4, #0
ldmeqia sp!, {r4, pc}
ldr r3, _020A5DC4 ; =NNS_GfdAllocFrmPlttVram
ldr r1, _020A5DC8 ; =0x02100DF4
ldr r2, _020A5DCC ; =NNS_GfdFreeFrmPlttVram
ldr r0, _020A5DD0 ; =0x02100DF8
str r3, [r1, #0]
str r2, [r0, #0]
ldmia sp!, {r4, pc}
; .align 2, 0
_020A5DC0: .word Unk_021C3AB4
_020A5DC4: .word NNS_GfdAllocFrmPlttVram
_020A5DC8: .word NNS_GfdDefaultFuncAllocPlttVram
_020A5DCC: .word NNS_GfdFreeFrmPlttVram
_020A5DD0: .word NNS_GfdDefaultFuncFreePlttVram
arm_func_end NNS_GfdInitFrmPlttVramManager
arm_func_start NNS_GfdAllocFrmPlttVram
NNS_GfdAllocFrmPlttVram: ; 0x020A5DD4
stmfd sp!, {r4, lr}
cmp r0, #0
moveq r0, #8
addne r0, r0, #7
ldr ip, _020A5F08 ; =0x0007FFF8
bicne r0, r0, #7
cmp r0, ip
mov r3, #0
movhs r0, #0
ldmhsia sp!, {r4, pc}
cmp r2, #1
bne _020A5E80
ldr r2, _020A5F0C ; =0x021C3AB4
cmp r1, #0
ldr lr, [r2]
andeq r2, lr, #0xf
rsbeq r2, r2, #0x10
andeq r4, r2, #0xf
beq _020A5E2C
and r2, lr, #7
rsb r2, r2, #8
and r4, r2, #7
_020A5E2C:
ldr r2, _020A5F0C ; =0x021C3AB4
add ip, r0, r4
ldr r2, [r2, #4]
sub r2, r2, lr
cmp r2, ip
blo _020A5E78
cmp r1, #0
add r1, lr, ip
beq _020A5E5C
cmp r1, #0x10000
movhi lr, #0
bhi _020A5EE8
_020A5E5C:
ldr r1, _020A5F0C ; =0x021C3AB4
add r3, lr, r4
ldr r2, [r1, #0]
mov lr, #1
add r2, r2, ip
str r2, [r1, #0]
b _020A5EE8
_020A5E78:
mov lr, #0
b _020A5EE8
_020A5E80:
ldr r2, _020A5F0C ; =0x021C3AB4
ldr lr, [r2, #4]
cmp lr, r0
blo _020A5EE4
sub r2, lr, r0
cmp r1, #0
andne r4, r2, #7
andeq r4, r2, #0xf
ldr r2, _020A5F0C ; =0x021C3AB4
add ip, r0, r4
ldr r2, [r2, #0]
sub r2, lr, r2
cmp r2, ip
blo _020A5EE4
cmp r1, #0
beq _020A5ECC
cmp lr, #0x10000
movhi lr, #0
bhi _020A5EE8
_020A5ECC:
ldr r1, _020A5F0C ; =0x021C3AB4
mov lr, #1
ldr r2, [r1, #4]
sub r3, r2, ip
str r3, [r1, #4]
b _020A5EE8
_020A5EE4:
mov lr, #0
_020A5EE8:
cmp lr, #0
moveq r0, #0
ldmeqia sp!, {r4, pc}
mov r1, r3, lsl #0xd
mov r2, r0, lsr #3
mov r0, r1, lsr #0x10
orr r0, r0, r2, lsl #16
ldmia sp!, {r4, pc}
; .align 2, 0
_020A5F08: .word 0x0007FFF8
_020A5F0C: .word Unk_021C3AB4
arm_func_end NNS_GfdAllocFrmPlttVram
arm_func_start NNS_GfdFreeFrmPlttVram
NNS_GfdFreeFrmPlttVram: ; 0x020A5F10
mov r0, #0
bx lr
arm_func_end NNS_GfdFreeFrmPlttVram
arm_func_start NNS_GfdGetFrmPlttVramState
NNS_GfdGetFrmPlttVramState: ; 0x020A5F18
ldr r1, _020A5F30 ; =0x021C3AB4
ldr r2, [r1, #0]
str r2, [r0, #0]
ldr r1, [r1, #4]
str r1, [r0, #4]
bx lr
; .align 2, 0
_020A5F30: .word Unk_021C3AB4
arm_func_end NNS_GfdGetFrmPlttVramState
arm_func_start NNS_GfdSetFrmPlttVramState
NNS_GfdSetFrmPlttVramState: ; 0x020A5F34
ldr r2, [r0, #0]
ldr r1, _020A5F4C ; =0x021C3AB4
str r2, [r1, #0]
ldr r0, [r0, #4]
str r0, [r1, #4]
bx lr
; .align 2, 0
_020A5F4C: .word Unk_021C3AB4
arm_func_end NNS_GfdSetFrmPlttVramState
arm_func_start NNS_GfdResetFrmPlttVramState
NNS_GfdResetFrmPlttVramState: ; 0x020A5F50
ldr r0, _020A5F68 ; =0x021C3AB4
mov r1, #0
str r1, [r0, #0]
ldr r1, [r0, #8]
str r1, [r0, #4]
bx lr
; .align 2, 0
_020A5F68: .word Unk_021C3AB4
arm_func_end NNS_GfdResetFrmPlttVramState
.bss
.global Unk_021C3AB4
Unk_021C3AB4: ; 0x021C3AB4
.space 0xC

290
lib/NitroSystem/asm/gfd/gfd_frametexvramman.s
View File

@ -1,290 +0,0 @@
.include "macros/function.inc"
.include "include/gfd_frametexvramman.inc"
.extern NNS_GfdDefaultFuncAllocTexVram
.extern NNS_GfdDefaultFuncFreeTexVram
.text
arm_func_start NNSi_GfdSetTexNrmSearchArray
NNSi_GfdSetTexNrmSearchArray: ; 0x020A5A4C
stmfd sp!, {r4, r5, r6, lr}
ldr r5, _020A5A8C ; =0x02100E18
mov ip, #0x18
mla r6, r0, ip, r5
ldr lr, [sp, #0x10]
ldr r0, _020A5A90 ; =0x02100DFC
mla r4, r1, ip, r5
str r6, [r0, #8]
mla r1, r2, ip, r5
str r4, [r0, #0xc]
mla r2, r3, ip, r5
str r1, [r0, #0x10]
mla r1, lr, ip, r5
str r2, [r0, #0x14]
str r1, [r0, #0x18]
ldmia sp!, {r4, r5, r6, pc}
; .align 2, 0
_020A5A8C: .word Unk_02100E18
_020A5A90: .word Unk_02100DFC
arm_func_end NNSi_GfdSetTexNrmSearchArray
arm_func_start NNS_GfdInitFrmTexVramManager
NNS_GfdInitFrmTexVramManager: ; 0x020A5A94
stmfd sp!, {r3, r4, r5, lr}
mov r5, r0
mov r4, r1
cmp r5, #2
mov ip, #1
mov r0, #4
mov r1, #3
bhi _020A5AC8
mov r2, #2
mov r3, #0
str ip, [sp]
bl NNSi_GfdSetTexNrmSearchArray
b _020A5AD8
_020A5AC8:
mov r2, #0
mov r3, #2
str ip, [sp]
bl NNSi_GfdSetTexNrmSearchArray
_020A5AD8:
ldr r0, _020A5B08 ; =0x021C3AB0
strh r5, [r0]
bl NNS_GfdResetFrmTexVramState
cmp r4, #0
ldmeqia sp!, {r3, r4, r5, pc}
ldr r3, _020A5B0C ; =NNS_GfdAllocFrmTexVram
ldr r1, _020A5B10 ; =0x02100DEC
ldr r2, _020A5B14 ; =NNS_GfdFreeFrmTexVram
ldr r0, _020A5B18 ; =0x02100DF0
str r3, [r1, #0]
str r2, [r0, #0]
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020A5B08: .word Unk_021C3AB0
_020A5B0C: .word NNS_GfdAllocFrmTexVram
_020A5B10: .word NNS_GfdDefaultFuncAllocTexVram
_020A5B14: .word NNS_GfdFreeFrmTexVram
_020A5B18: .word NNS_GfdDefaultFuncFreeTexVram
arm_func_end NNS_GfdInitFrmTexVramManager
arm_func_start NNS_GfdResetFrmTexVramState
NNS_GfdResetFrmTexVramState: ; 0x020A5B1C
stmfd sp!, {r3, r4, r5, r6, r7, lr}
ldr r0, _020A5B88 ; =0x021C3AB0
mov r5, #0
ldrh r7, [r0]
ldr r6, _020A5B8C ; =0x02100E18
mov lr, r5
cmp r7, #1
addhi r7, r7, #1
mov r4, #1
mov r1, r5
mov r0, #0x20000
mov r3, r5
mov r2, #0x10000
_020A5B50:
cmp r5, r7
strlt r4, [r6, #8]
strge lr, [r6, #8]
ldr ip, [r6, #0xc]
add r5, r5, #1
cmp ip, #0
strne r3, [r6]
strne r2, [r6, #4]
streq r1, [r6]
streq r0, [r6, #4]
cmp r5, #5
add r6, r6, #0x18
blt _020A5B50
ldmia sp!, {r3, r4, r5, r6, r7, pc}
; .align 2, 0
_020A5B88: .word Unk_021C3AB0
_020A5B8C: .word Unk_02100E18
arm_func_end NNS_GfdResetFrmTexVramState
arm_func_start NNS_GfdAllocFrmTexVram
NNS_GfdAllocFrmTexVram: ; 0x020A5B90
stmfd sp!, {r3, r4, r5, r6, r7, r8, sb, lr}
cmp r0, #0
moveq r3, #0x10
addne r0, r0, #0xf
bicne r3, r0, #0xf
ldr r0, _020A5CEC ; =0x0007FFF0
cmp r3, r0
movhs r0, #0
ldmhsia sp!, {r3, r4, r5, r6, r7, r8, sb, pc}
cmp r1, #0
beq _020A5C74
mov r4, #0
ldr r8, _020A5CF0 ; =0x02100E48
ldr sb, _020A5CF4 ; =0x02100E30
ldr r0, _020A5CF8 ; =0x02100DFC
mov r7, r4
_020A5BD0:
ldr lr, [r0, r4, lsl #2]
ldr r5, [lr, #8]
cmp r5, #0
beq _020A5C60
ldmia lr, {r5, r6}
sub r5, r6, r5
cmp r5, r3
blo _020A5C60
ldrh r5, [lr, #0x10]
cmp r5, #0
beq _020A5C08
cmp r5, #3
beq _020A5C10
b _020A5C18
_020A5C08:
mov ip, sb
b _020A5C1C
_020A5C10:
mov ip, r8
b _020A5C1C
_020A5C18:
mov ip, r7
_020A5C1C:
ldr r5, [ip, #8]
cmp r5, #0
beq _020A5C60
ldmia ip, {r5, r6}
sub r5, r6, r5
cmp r5, r3, lsr #1
blo _020A5C60
ldr r4, [lr]
mov r0, #1
add r2, r4, r3
str r2, [lr]
ldr r2, [ip]
add r2, r2, r3, lsr #1
str r2, [ip]
ldr r2, [lr, #0x14]
add r2, r4, r2
b _020A5CC8
_020A5C60:
add r4, r4, #1
cmp r4, #2
blt _020A5BD0
mov r0, #0
b _020A5CC8
_020A5C74:
ldr lr, _020A5CFC ; =0x02100E04
mov r5, #0
_020A5C7C:
ldr ip, [lr, r5, lsl #2]
ldr r0, [ip, #8]
cmp r0, #0
beq _020A5CB8
ldmia ip, {r0, r4}
sub r0, r4, r0
cmp r0, r3
blo _020A5CB8
ldr r2, [ip, #4]
mov r0, #1
sub r4, r2, r3
str r4, [ip, #4]
ldr r2, [ip, #0x14]
add r2, r4, r2
b _020A5CC8
_020A5CB8:
add r5, r5, #1
cmp r5, #5
blt _020A5C7C
mov r0, #0
_020A5CC8:
cmp r0, #0
moveq r0, #0
ldmeqia sp!, {r3, r4, r5, r6, r7, r8, sb, pc}
mov r0, r2, lsl #0xd
mov r2, r3, lsr #4
mov r0, r0, lsr #0x10
orr r0, r0, r2, lsl #16
orr r0, r0, r1, lsl #31
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, pc}
; .align 2, 0
_020A5CEC: .word 0x0007FFF0
_020A5CF0: .word 0x02100E48
_020A5CF4: .word 0x02100E30
_020A5CF8: .word Unk_02100DFC
_020A5CFC: .word Unk_02100E04
arm_func_end NNS_GfdAllocFrmTexVram
arm_func_start NNS_GfdFreeFrmTexVram
NNS_GfdFreeFrmTexVram: ; 0x020A5D00
mov r0, #0
bx lr
arm_func_end NNS_GfdFreeFrmTexVram
arm_func_start NNS_GfdGetFrmTexVramState
NNS_GfdGetFrmTexVramState: ; 0x020A5D08
stmfd sp!, {r3, lr}
mov r3, #0
ldr ip, _020A5D44 ; =0x02100E18
mov lr, r3
_020A5D18:
ldr r1, [ip]
add r3, r3, #1
str r1, [r0, lr, lsl #2]
ldr r2, [ip, #4]
add r1, r0, lr, lsl #2
str r2, [r1, #4]
cmp r3, #5
add ip, ip, #0x18
add lr, lr, #2
blt _020A5D18
ldmia sp!, {r3, pc}
; .align 2, 0
_020A5D44: .word Unk_02100E18
arm_func_end NNS_GfdGetFrmTexVramState
arm_func_start NNS_GfdSetFrmTexVramState
NNS_GfdSetFrmTexVramState: ; 0x020A5D48
stmfd sp!, {r3, lr}
mov r3, #0
ldr lr, _020A5D84 ; =0x02100E18
mov ip, r3
_020A5D58:
ldr r2, [r0, ip, lsl #2]
add r1, r0, ip, lsl #2
str r2, [lr]
ldr r1, [r1, #4]
add r3, r3, #1
str r1, [lr, #4]
cmp r3, #5
add ip, ip, #2
add lr, lr, #0x18
blt _020A5D58
ldmia sp!, {r3, pc}
; .align 2, 0
_020A5D84: .word Unk_02100E18
arm_func_end NNS_GfdSetFrmTexVramState
.data
.global Unk_02100DFC
Unk_02100DFC: ; 0x02100DFC
.incbin "incbin/arm9_data.bin", 0x211C, 0x2124 - 0x211C
.global Unk_02100E04
Unk_02100E04: ; 0x02100E04
.incbin "incbin/arm9_data.bin", 0x2124, 0x2138 - 0x2124
.global Unk_02100E18
Unk_02100E18: ; 0x02100E18
.incbin "incbin/arm9_data.bin", 0x2138, 0x78
.bss
.global Unk_021C3AB0
Unk_021C3AB0: ; 0x021C3AB0
.space 0x2

156
lib/NitroSystem/asm/gfd/gfd_linkedlistplttvramman.s
View File

@ -1,156 +0,0 @@
.include "macros/function.inc"
.include "include/gfd_linkedlistplttvramman.inc"
.extern NNS_GfdDefaultFuncAllocPlttVram
.extern NNS_GfdDefaultFuncFreePlttVram
.text
arm_func_start NNS_GfdGetLnkPlttVramManagerWorkSize
NNS_GfdGetLnkPlttVramManagerWorkSize: ; 0x020A6B84
mov r0, r0, lsl #4
bx lr
arm_func_end NNS_GfdGetLnkPlttVramManagerWorkSize
arm_func_start NNS_GfdInitLnkPlttVramManager
NNS_GfdInitLnkPlttVramManager: ; 0x020A6B8C
stmfd sp!, {r4, lr}
ldr ip, _020A6BCC ; =0x021C3AF0
mov r4, r3
str r0, [ip, #8]
str r1, [ip, #0xc]
str r2, [ip, #0x10]
bl NNS_GfdResetLnkPlttVramState
cmp r4, #0
ldmeqia sp!, {r4, pc}
ldr r3, _020A6BD0 ; =NNS_GfdAllocLnkPlttVram
ldr r1, _020A6BD4 ; =0x02100DF4
ldr r2, _020A6BD8 ; =NNS_GfdFreeLnkPlttVram
ldr r0, _020A6BDC ; =0x02100DF8
str r3, [r1, #0]
str r2, [r0, #0]
ldmia sp!, {r4, pc}
; .align 2, 0
_020A6BCC: .word Unk_021C3AF0
_020A6BD0: .word NNS_GfdAllocLnkPlttVram
_020A6BD4: .word NNS_GfdDefaultFuncAllocPlttVram
_020A6BD8: .word NNS_GfdFreeLnkPlttVram
_020A6BDC: .word NNS_GfdDefaultFuncFreePlttVram
arm_func_end NNS_GfdInitLnkPlttVramManager
arm_func_start NNS_GfdAllocLnkPlttVram
NNS_GfdAllocLnkPlttVram: ; 0x020A6BE0
stmfd sp!, {r4, lr}
sub sp, sp, #8
cmp r0, #0
moveq r4, #8
addne r0, r0, #7
bicne r4, r0, #7
ldr r0, _020A6CA0 ; =0x0007FFF8
cmp r4, r0
addhs sp, sp, #8
movhs r0, #0
ldmhsia sp!, {r4, pc}
cmp r1, #0
add r2, sp, #4
beq _020A6C5C
mov ip, #8
ldr r0, _020A6CA4 ; =0x021C3AF0
ldr r1, _020A6CA8 ; =0x021C3AF4
mov r3, r4
str ip, [sp]
bl NNSi_GfdAllocLnkVramAligned
ldr r2, [sp, #4]
add r1, r2, r4
cmp r1, #0x10000
bls _020A6C74
ldr r0, _020A6CA4 ; =0x021C3AF0
ldr r1, _020A6CA8 ; =0x021C3AF4
mov r3, r4
bl NNSi_GfdFreeLnkVram
add sp, sp, #8
mov r0, #0
ldmia sp!, {r4, pc}
_020A6C5C:
ldr r0, _020A6CA4 ; =0x021C3AF0
mov ip, #0x10
ldr r1, _020A6CA8 ; =0x021C3AF4
mov r3, r4
str ip, [sp]
bl NNSi_GfdAllocLnkVramAligned
_020A6C74:
cmp r0, #0
addeq sp, sp, #8
moveq r0, #0
ldmeqia sp!, {r4, pc}
ldr r0, [sp, #4]
mov r1, r4, lsr #3
mov r0, r0, lsl #0xd
mov r0, r0, lsr #0x10
orr r0, r0, r1, lsl #16
add sp, sp, #8
ldmia sp!, {r4, pc}
; .align 2, 0
_020A6CA0: .word 0x0007FFF8
_020A6CA4: .word Unk_021C3AF0
_020A6CA8: .word 0x021C3AF4
arm_func_end NNS_GfdAllocLnkPlttVram
arm_func_start NNS_GfdFreeLnkPlttVram
NNS_GfdFreeLnkPlttVram: ; 0x020A6CAC
stmfd sp!, {r3, lr}
mov r1, #0x10000
rsb r1, r1, #0
and r1, r0, r1
mov r2, r0, lsl #0x10
mov r3, r1, lsr #0x10
ldr r0, _020A6CE8 ; =0x021C3AF0
ldr r1, _020A6CEC ; =0x021C3AF4
mov r2, r2, lsr #0xd
mov r3, r3, lsl #3
bl NNSi_GfdFreeLnkVram
cmp r0, #0
moveq r0, #1
movne r0, #0
ldmia sp!, {r3, pc}
; .align 2, 0
_020A6CE8: .word Unk_021C3AF0
_020A6CEC: .word 0x021C3AF4
arm_func_end NNS_GfdFreeLnkPlttVram
arm_func_start NNS_GfdResetLnkPlttVramState
NNS_GfdResetLnkPlttVramState: ; 0x020A6CF0
stmfd sp!, {r3, lr}
ldr r0, _020A6D40 ; =0x021C3AF0
ldr r1, [r0, #0x10]
ldr r0, [r0, #0xc]
mov r1, r1, lsr #4
bl NNSi_GfdInitLnkVramBlockPool
ldr r1, _020A6D40 ; =0x021C3AF0
str r0, [r1, #4]
ldr r0, _020A6D44 ; =0x021C3AF0
bl NNSi_GfdInitLnkVramMan
ldr r1, _020A6D40 ; =0x021C3AF0
ldr r0, _020A6D44 ; =0x021C3AF0
ldr r3, [r1, #8]
ldr r1, _020A6D48 ; =0x021C3AF4
mov r2, #0
bl NNSi_GfdAddNewFreeBlock
ldr r0, _020A6D44 ; =0x021C3AF0
ldr r1, _020A6D48 ; =0x021C3AF4
bl NNSi_GfdMergeAllFreeBlocks
ldmia sp!, {r3, pc}
; .align 2, 0
_020A6D40: .word Unk_021C3AF0
_020A6D44: .word Unk_021C3AF0
_020A6D48: .word 0x021C3AF4
arm_func_end NNS_GfdResetLnkPlttVramState
.bss
.global Unk_021C3AF0
Unk_021C3AF0: ; 0x021C3AF0
.space 0x14

280
lib/NitroSystem/asm/gfd/gfd_linkedlisttexvramman.s
View File

@ -1,280 +0,0 @@
.include "macros/function.inc"
.include "include/gfd_linkedlisttexvramman.inc"
.extern NNS_GfdDefaultFuncAllocTexVram
.extern NNS_GfdDefaultFuncFreeTexVram
.text
arm_func_start NNS_GfdGetLnkTexVramManagerWorkSize
NNS_GfdGetLnkTexVramManagerWorkSize: ; 0x020A6824
mov r0, r0, lsl #4
bx lr
arm_func_end NNS_GfdGetLnkTexVramManagerWorkSize
arm_func_start NNS_GfdInitLnkTexVramManager
NNS_GfdInitLnkTexVramManager: ; 0x020A682C
stmfd sp!, {r3, lr}
ldr ip, _020A6870 ; =0x021C3AD4
str r0, [ip, #0xc]
str r1, [ip, #0x10]
str r2, [ip, #0x14]
str r3, [ip, #0x18]
bl NNS_GfdResetLnkTexVramState
ldr r0, [sp, #8]
cmp r0, #0
ldmeqia sp!, {r3, pc}
ldr r3, _020A6874 ; =NNS_GfdAllocLnkTexVram
ldr r1, _020A6878 ; =0x02100DEC
ldr r2, _020A687C ; =NNS_GfdFreeLnkTexVram
ldr r0, _020A6880 ; =0x02100DF0
str r3, [r1, #0]
str r2, [r0, #0]
ldmia sp!, {r3, pc}
; .align 2, 0
_020A6870: .word Unk_021C3AD4
_020A6874: .word NNS_GfdAllocLnkTexVram
_020A6878: .word NNS_GfdDefaultFuncAllocTexVram
_020A687C: .word NNS_GfdFreeLnkTexVram
_020A6880: .word NNS_GfdDefaultFuncFreeTexVram
arm_func_end NNS_GfdInitLnkTexVramManager
arm_func_start NNS_GfdAllocLnkTexVram
NNS_GfdAllocLnkTexVram: ; 0x020A6884
stmfd sp!, {r3, r4, r5, lr}
cmp r0, #0
moveq r5, #0x10
addne r0, r0, #0xf
bicne r5, r0, #0xf
ldr r0, _020A6904 ; =0x0007FFF0
mov r4, r1
cmp r5, r0
movhs r0, #0
ldmhsia sp!, {r3, r4, r5, pc}
cmp r4, #0
add r2, sp, #0
beq _020A68CC
ldr r0, _020A6908 ; =0x021C3AD8
ldr r1, _020A690C ; =0x021C3ADC
mov r3, r5
bl NNSi_GfdAllocLnkVram
b _020A68DC
_020A68CC:
ldr r0, _020A6910 ; =0x021C3AD4
ldr r1, _020A690C ; =0x021C3ADC
mov r3, r5
bl NNSi_GfdAllocLnkVram
_020A68DC:
cmp r0, #0
moveq r0, #0
ldmeqia sp!, {r3, r4, r5, pc}
ldr r0, [sp]
mov r1, r5, lsr #4
mov r0, r0, lsl #0xd
mov r0, r0, lsr #0x10
orr r0, r0, r1, lsl #16
orr r0, r0, r4, lsl #31
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020A6904: .word 0x0007FFF0
_020A6908: .word 0x021C3AD8
_020A690C: .word 0x021C3ADC
_020A6910: .word Unk_021C3AD4
arm_func_end NNS_GfdAllocLnkTexVram
arm_func_start NNS_GfdFreeLnkTexVram
NNS_GfdFreeLnkTexVram: ; 0x020A6914
stmfd sp!, {r3, lr}
ldr r1, _020A6978 ; =0x7FFF0000
mov r2, r0, lsl #0x10
and r1, r0, r1
mov r1, r1, lsr #0x10
and r0, r0, #0x80000000
mov r2, r2, lsr #0xd
movs r3, r1, lsl #4
mov r0, r0, lsr #0x1f
beq _020A6970
cmp r0, #0
beq _020A6954
ldr r0, _020A697C ; =0x021C3AD8
ldr r1, _020A6980 ; =0x021C3ADC
bl NNSi_GfdFreeLnkVram
b _020A6960
_020A6954:
ldr r0, _020A6984 ; =0x021C3AD4
ldr r1, _020A6980 ; =0x021C3ADC
bl NNSi_GfdFreeLnkVram
_020A6960:
cmp r0, #0
movne r0, #0
moveq r0, #1
ldmia sp!, {r3, pc}
_020A6970:
mov r0, #2
ldmia sp!, {r3, pc}
; .align 2, 0
_020A6978: .word 0x7FFF0000
_020A697C: .word 0x021C3AD8
_020A6980: .word 0x021C3ADC
_020A6984: .word Unk_021C3AD4
arm_func_end NNS_GfdFreeLnkTexVram
arm_func_start NNS_GfdResetLnkTexVramState
NNS_GfdResetLnkTexVramState: ; 0x020A6988
stmfd sp!, {r4, lr}
sub sp, sp, #0x30
ldr lr, _020A6B70 ; =0x020F9600
add r4, sp, #0
ldmia lr!, {r0, r1, r2, r3}
mov ip, r4
stmia r4!, {r0, r1, r2, r3}
ldmia lr!, {r0, r1, r2, r3}
stmia r4!, {r0, r1, r2, r3}
ldmia lr, {r0, r1, r2, r3}
stmia r4, {r0, r1, r2, r3}
ldr r0, _020A6B74 ; =0x021C3AD4
mov r3, #0
ldr r2, [r0, #0x10]
ldr r1, [r0, #0xc]
add r0, r2, r2, lsr #1
mov r4, r2, lsr #1
sub r1, r1, r0
_020A69D0:
cmp r3, #0
cmpne r3, #2
bne _020A6A10
ldr lr, [ip]
cmp lr, #0
cmpne r2, #0
beq _020A6A10
ldr r0, [ip, #8]
cmp lr, r2
movhi lr, r2
add r0, r0, lr
str r0, [ip, #8]
ldr r0, [ip]
sub r2, r2, lr
sub r0, r0, lr
str r0, [ip]
_020A6A10:
add r3, r3, #1
cmp r3, #4
add ip, ip, #0xc
blo _020A69D0
ldr r0, [sp, #0xc]
add r2, sp, #0
sub r0, r0, r4
str r0, [sp, #0xc]
mov r3, #0
_020A6A34:
ldr ip, [r2]
cmp ip, #0
cmpne r1, #0
beq _020A6A68
ldr r0, [r2, #4]
cmp ip, r1
movhi ip, r1
add r0, r0, ip
str r0, [r2, #4]
ldr r0, [r2, #0]
sub r1, r1, ip
sub r0, r0, ip
str r0, [r2, #0]
_020A6A68:
add r3, r3, #1
cmp r3, #4
add r2, r2, #0xc
blo _020A6A34
ldr r0, _020A6B78 ; =0x021C3AD4
bl NNSi_GfdInitLnkVramMan
ldr r0, _020A6B7C ; =0x021C3AD8
bl NNSi_GfdInitLnkVramMan
ldr r0, _020A6B74 ; =0x021C3AD4
ldr r1, [r0, #0x18]
ldr r0, [r0, #0x14]
mov r1, r1, lsr #4
bl NNSi_GfdInitLnkVramBlockPool
ldr r3, [sp, #8]
ldr r1, _020A6B74 ; =0x021C3AD4
cmp r3, #0
str r0, [r1, #8]
beq _020A6AC0
ldr r0, _020A6B7C ; =0x021C3AD8
ldr r1, _020A6B80 ; =0x021C3ADC
mov r2, #0
bl NNSi_GfdAddNewFreeBlock
_020A6AC0:
ldr r3, [sp, #4]
ldr r2, [sp, #8]
cmp r3, #0
beq _020A6ADC
ldr r0, _020A6B78 ; =0x021C3AD4
ldr r1, _020A6B80 ; =0x021C3ADC
bl NNSi_GfdAddNewFreeBlock
_020A6ADC:
ldr r3, [sp, #0x20]
cmp r3, #0
beq _020A6AF8
ldr r0, _020A6B7C ; =0x021C3AD8
ldr r1, _020A6B80 ; =0x021C3ADC
mov r2, #0x40000
bl NNSi_GfdAddNewFreeBlock
_020A6AF8:
ldr r3, [sp, #0x1c]
ldr r2, [sp, #0x20]
cmp r3, #0
beq _020A6B18
ldr r0, _020A6B78 ; =0x021C3AD4
ldr r1, _020A6B80 ; =0x021C3ADC
add r2, r2, #0x40000
bl NNSi_GfdAddNewFreeBlock
_020A6B18:
ldr r3, [sp, #0x28]
cmp r3, #0
beq _020A6B34
ldr r0, _020A6B78 ; =0x021C3AD4
ldr r1, _020A6B80 ; =0x021C3ADC
mov r2, #0x60000
bl NNSi_GfdAddNewFreeBlock
_020A6B34:
ldr r3, [sp, #0x10]
cmp r3, #0
beq _020A6B50
ldr r0, _020A6B78 ; =0x021C3AD4
ldr r1, _020A6B80 ; =0x021C3ADC
add r2, r4, #0x20000
bl NNSi_GfdAddNewFreeBlock
_020A6B50:
ldr r0, _020A6B78 ; =0x021C3AD4
ldr r1, _020A6B80 ; =0x021C3ADC
bl NNSi_GfdMergeAllFreeBlocks
ldr r0, _020A6B7C ; =0x021C3AD8
ldr r1, _020A6B80 ; =0x021C3ADC
bl NNSi_GfdMergeAllFreeBlocks
add sp, sp, #0x30
ldmia sp!, {r4, pc}
; .align 2, 0
_020A6B70: .word Unk_020F9600
_020A6B74: .word Unk_021C3AD4
_020A6B78: .word Unk_021C3AD4
_020A6B7C: .word 0x021C3AD8
_020A6B80: .word 0x021C3ADC
arm_func_end NNS_GfdResetLnkTexVramState
.rodata
.global Unk_020F9600
Unk_020F9600: ; 0x020F9600
.incbin "incbin/arm9_rodata.bin", 0x149C0, 0x30
.bss
.global Unk_021C3AD4
Unk_021C3AD4: ; 0x021C3AD4
.space 0x1C

30
lib/NitroSystem/asm/gfd/gfd_plttvramman.s
View File

@ -1,30 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start AllocPlttVram_
AllocPlttVram_: ; 0x020A5A3C
mov r0, #0
bx lr
arm_func_end AllocPlttVram_
arm_func_start FreePlttVram_
FreePlttVram_: ; 0x020A5A44
mvn r0, #0
bx lr
arm_func_end FreePlttVram_
.data
.global NNS_GfdDefaultFuncAllocPlttVram
NNS_GfdDefaultFuncAllocPlttVram: ; 0x02100DF4
.word AllocPlttVram_
.global NNS_GfdDefaultFuncFreePlttVram
NNS_GfdDefaultFuncFreePlttVram: ; 0x02100DF8
.word FreePlttVram_

30
lib/NitroSystem/asm/gfd/gfd_texvramman.s
View File

@ -1,30 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start AllocTexVram_
AllocTexVram_: ; 0x020A5A2C
mov r0, #0
bx lr
arm_func_end AllocTexVram_
arm_func_start FreeTexVram_
FreeTexVram_: ; 0x020A5A34
mvn r0, #0
bx lr
arm_func_end FreeTexVram_
.data
.global NNS_GfdDefaultFuncAllocTexVram
NNS_GfdDefaultFuncAllocTexVram: ; 0x02100DEC
.word AllocTexVram_
.global NNS_GfdDefaultFuncFreeTexVram
NNS_GfdDefaultFuncFreeTexVram: ; 0x02100DF0
.word FreeTexVram_

551
lib/NitroSystem/asm/gfd/gfd_vramtransfermanager.s
View File

@ -1,551 +0,0 @@
.include "macros/function.inc"
.include "include/gfd_vramtransfermanager.inc"
.text
arm_func_start GetNextIndex_
GetNextIndex_: ; 0x020A5F6C
stmfd sp!, {r3, lr}
mov r2, r0
add r0, r1, #1
ldr r1, [r2, #4]
bl _u32_div_f
mov r0, r1, lsl #0x10
mov r0, r0, lsr #0x10
ldmia sp!, {r3, pc}
arm_func_end GetNextIndex_
arm_func_start IsVramTransferTaskQueueFull_
IsVramTransferTaskQueueFull_: ; 0x020A5F8C
ldrh r1, [r0, #0xc]
ldr r0, [r0, #4]
cmp r1, r0
moveq r0, #1
movne r0, #0
bx lr
arm_func_end IsVramTransferTaskQueueFull_
arm_func_start IsVramTransferTaskQueueEmpty_
IsVramTransferTaskQueueEmpty_: ; 0x020A5FA4
ldrh r0, [r0, #0xc]
cmp r0, #0
moveq r0, #1
movne r0, #0
bx lr
arm_func_end IsVramTransferTaskQueueEmpty_
arm_func_start DoTransfer3dTex
DoTransfer3dTex: ; 0x020A5FB8
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl GX_BeginLoadTex
mov r0, r6
mov r1, r5
mov r2, r4
bl GX_LoadTex
bl GX_EndLoadTex
ldmia sp!, {r4, r5, r6, pc}
arm_func_end DoTransfer3dTex
arm_func_start DoTransfer3dTexPltt
DoTransfer3dTexPltt: ; 0x020A5FE4
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl GX_BeginLoadTexPltt
mov r0, r6
mov r1, r5
mov r2, r4
bl GX_LoadTexPltt
bl GX_EndLoadTexPltt
ldmia sp!, {r4, r5, r6, pc}
arm_func_end DoTransfer3dTexPltt
arm_func_start DoTransfer3dClearImageColor
DoTransfer3dClearImageColor: ; 0x020A6010
stmfd sp!, {r3, r4, r5, lr}
mov r5, r0
mov r4, r2
bl GX_BeginLoadClearImage
mov r0, r5
mov r1, r4
bl GX_LoadClearImageColor
bl GX_EndLoadClearImage
ldmia sp!, {r3, r4, r5, pc}
arm_func_end DoTransfer3dClearImageColor
arm_func_start DoTransfer3dClearImageDepth
DoTransfer3dClearImageDepth: ; 0x020A6034
stmfd sp!, {r3, r4, r5, lr}
mov r5, r0
mov r4, r2
bl GX_BeginLoadClearImage
mov r0, r5
mov r1, r4
bl GX_LoadClearImageDepth
bl GX_EndLoadClearImage
ldmia sp!, {r3, r4, r5, pc}
arm_func_end DoTransfer3dClearImageDepth
arm_func_start DoTransfer2dBG0CharMain
DoTransfer2dBG0CharMain: ; 0x020A6058
ldr ip, _020A6060 ; =GX_LoadBG0Char
bx ip
; .align 2, 0
_020A6060: .word GX_LoadBG0Char
arm_func_end DoTransfer2dBG0CharMain
arm_func_start DoTransfer2dBG1CharMain
DoTransfer2dBG1CharMain: ; 0x020A6064
ldr ip, _020A606C ; =GX_LoadBG1Char
bx ip
; .align 2, 0
_020A606C: .word GX_LoadBG1Char
arm_func_end DoTransfer2dBG1CharMain
arm_func_start DoTransfer2dBG2CharMain
DoTransfer2dBG2CharMain: ; 0x020A6070
ldr ip, _020A6078 ; =GX_LoadBG2Char
bx ip
; .align 2, 0
_020A6078: .word GX_LoadBG2Char
arm_func_end DoTransfer2dBG2CharMain
arm_func_start DoTransfer2dBG3CharMain
DoTransfer2dBG3CharMain: ; 0x020A607C
ldr ip, _020A6084 ; =GX_LoadBG3Char
bx ip
; .align 2, 0
_020A6084: .word GX_LoadBG3Char
arm_func_end DoTransfer2dBG3CharMain
arm_func_start DoTransfer2dBG0ScrMain
DoTransfer2dBG0ScrMain: ; 0x020A6088
ldr ip, _020A6090 ; =GX_LoadBG0Scr
bx ip
; .align 2, 0
_020A6090: .word GX_LoadBG0Scr
arm_func_end DoTransfer2dBG0ScrMain
arm_func_start DoTransfer2dBG1ScrMain
DoTransfer2dBG1ScrMain: ; 0x020A6094
ldr ip, _020A609C ; =GX_LoadBG1Scr
bx ip
; .align 2, 0
_020A609C: .word GX_LoadBG1Scr
arm_func_end DoTransfer2dBG1ScrMain
arm_func_start DoTransfer2dBG2ScrMain
DoTransfer2dBG2ScrMain: ; 0x020A60A0
ldr ip, _020A60A8 ; =GX_LoadBG2Scr
bx ip
; .align 2, 0
_020A60A8: .word GX_LoadBG2Scr
arm_func_end DoTransfer2dBG2ScrMain
arm_func_start DoTransfer2dBG3ScrMain
DoTransfer2dBG3ScrMain: ; 0x020A60AC
ldr ip, _020A60B4 ; =GX_LoadBG3Scr
bx ip
; .align 2, 0
_020A60B4: .word GX_LoadBG3Scr
arm_func_end DoTransfer2dBG3ScrMain
arm_func_start DoTransfer2dBG2BmpMain
DoTransfer2dBG2BmpMain: ; 0x020A60B8
ldr ip, _020A60C0 ; =GX_LoadBG2Scr
bx ip
; .align 2, 0
_020A60C0: .word GX_LoadBG2Scr
arm_func_end DoTransfer2dBG2BmpMain
arm_func_start DoTransfer2dBG3BmpMain
DoTransfer2dBG3BmpMain: ; 0x020A60C4
ldr ip, _020A60CC ; =GX_LoadBG3Scr
bx ip
; .align 2, 0
_020A60CC: .word GX_LoadBG3Scr
arm_func_end DoTransfer2dBG3BmpMain
arm_func_start DoTransfer2dObjPlttMain
DoTransfer2dObjPlttMain: ; 0x020A60D0
ldr ip, _020A60D8 ; =GX_LoadOBJPltt
bx ip
; .align 2, 0
_020A60D8: .word GX_LoadOBJPltt
arm_func_end DoTransfer2dObjPlttMain
arm_func_start DoTransfer2dBGPlttMain
DoTransfer2dBGPlttMain: ; 0x020A60DC
ldr ip, _020A60E4 ; =GX_LoadBGPltt
bx ip
; .align 2, 0
_020A60E4: .word GX_LoadBGPltt
arm_func_end DoTransfer2dBGPlttMain
arm_func_start DoTransfer2dObjExtPlttMain
DoTransfer2dObjExtPlttMain: ; 0x020A60E8
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl GX_BeginLoadOBJExtPltt
mov r0, r6
mov r1, r5
mov r2, r4
bl GX_LoadOBJExtPltt
bl GX_EndLoadOBJExtPltt
ldmia sp!, {r4, r5, r6, pc}
arm_func_end DoTransfer2dObjExtPlttMain
arm_func_start DoTransfer2dBGExtPlttMain
DoTransfer2dBGExtPlttMain: ; 0x020A6114
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl GX_BeginLoadBGExtPltt
mov r0, r6
mov r1, r5
mov r2, r4
bl GX_LoadBGExtPltt
bl GX_EndLoadBGExtPltt
ldmia sp!, {r4, r5, r6, pc}
arm_func_end DoTransfer2dBGExtPlttMain
arm_func_start DoTransfer2dObjOamMain
DoTransfer2dObjOamMain: ; 0x020A6140
ldr ip, _020A6148 ; =GX_LoadOAM
bx ip
; .align 2, 0
_020A6148: .word GX_LoadOAM
arm_func_end DoTransfer2dObjOamMain
arm_func_start DoTransfer2dObjCharMain
DoTransfer2dObjCharMain: ; 0x020A614C
ldr ip, _020A6154 ; =GX_LoadOBJ
bx ip
; .align 2, 0
_020A6154: .word GX_LoadOBJ
arm_func_end DoTransfer2dObjCharMain
arm_func_start DoTransfer2dBG0CharSub
DoTransfer2dBG0CharSub: ; 0x020A6158
ldr ip, _020A6160 ; =GXS_LoadBG0Char
bx ip
; .align 2, 0
_020A6160: .word GXS_LoadBG0Char
arm_func_end DoTransfer2dBG0CharSub
arm_func_start DoTransfer2dBG1CharSub
DoTransfer2dBG1CharSub: ; 0x020A6164
ldr ip, _020A616C ; =GXS_LoadBG1Char
bx ip
; .align 2, 0
_020A616C: .word GXS_LoadBG1Char
arm_func_end DoTransfer2dBG1CharSub
arm_func_start DoTransfer2dBG2CharSub
DoTransfer2dBG2CharSub: ; 0x020A6170
ldr ip, _020A6178 ; =GXS_LoadBG2Char
bx ip
; .align 2, 0
_020A6178: .word GXS_LoadBG2Char
arm_func_end DoTransfer2dBG2CharSub
arm_func_start DoTransfer2dBG3CharSub
DoTransfer2dBG3CharSub: ; 0x020A617C
ldr ip, _020A6184 ; =GXS_LoadBG3Char
bx ip
; .align 2, 0
_020A6184: .word GXS_LoadBG3Char
arm_func_end DoTransfer2dBG3CharSub
arm_func_start DoTransfer2dBG0ScrSub
DoTransfer2dBG0ScrSub: ; 0x020A6188
ldr ip, _020A6190 ; =GXS_LoadBG0Scr
bx ip
; .align 2, 0
_020A6190: .word GXS_LoadBG0Scr
arm_func_end DoTransfer2dBG0ScrSub
arm_func_start DoTransfer2dBG1ScrSub
DoTransfer2dBG1ScrSub: ; 0x020A6194
ldr ip, _020A619C ; =GXS_LoadBG1Scr
bx ip
; .align 2, 0
_020A619C: .word GXS_LoadBG1Scr
arm_func_end DoTransfer2dBG1ScrSub
arm_func_start DoTransfer2dBG2ScrSub
DoTransfer2dBG2ScrSub: ; 0x020A61A0
ldr ip, _020A61A8 ; =GXS_LoadBG2Scr
bx ip
; .align 2, 0
_020A61A8: .word GXS_LoadBG2Scr
arm_func_end DoTransfer2dBG2ScrSub
arm_func_start DoTransfer2dBG3ScrSub
DoTransfer2dBG3ScrSub: ; 0x020A61AC
ldr ip, _020A61B4 ; =GXS_LoadBG3Scr
bx ip
; .align 2, 0
_020A61B4: .word GXS_LoadBG3Scr
arm_func_end DoTransfer2dBG3ScrSub
arm_func_start DoTransfer2dBG2BmpSub
DoTransfer2dBG2BmpSub: ; 0x020A61B8
ldr ip, _020A61C0 ; =GXS_LoadBG2Scr
bx ip
; .align 2, 0
_020A61C0: .word GXS_LoadBG2Scr
arm_func_end DoTransfer2dBG2BmpSub
arm_func_start DoTransfer2dBG3BmpSub
DoTransfer2dBG3BmpSub: ; 0x020A61C4
ldr ip, _020A61CC ; =GXS_LoadBG3Scr
bx ip
; .align 2, 0
_020A61CC: .word GXS_LoadBG3Scr
arm_func_end DoTransfer2dBG3BmpSub
arm_func_start DoTransfer2dObjPlttSub
DoTransfer2dObjPlttSub: ; 0x020A61D0
ldr ip, _020A61D8 ; =GXS_LoadOBJPltt
bx ip
; .align 2, 0
_020A61D8: .word GXS_LoadOBJPltt
arm_func_end DoTransfer2dObjPlttSub
arm_func_start DoTransfer2dBGPlttSub
DoTransfer2dBGPlttSub: ; 0x020A61DC
ldr ip, _020A61E4 ; =GXS_LoadBGPltt
bx ip
; .align 2, 0
_020A61E4: .word GXS_LoadBGPltt
arm_func_end DoTransfer2dBGPlttSub
arm_func_start DoTransfer2dObjExtPlttSub
DoTransfer2dObjExtPlttSub: ; 0x020A61E8
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl GXS_BeginLoadOBJExtPltt
mov r0, r6
mov r1, r5
mov r2, r4
bl GXS_LoadOBJExtPltt
bl GXS_EndLoadOBJExtPltt
ldmia sp!, {r4, r5, r6, pc}
arm_func_end DoTransfer2dObjExtPlttSub
arm_func_start DoTransfer2dBGExtPlttSub
DoTransfer2dBGExtPlttSub: ; 0x020A6214
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl GXS_BeginLoadBGExtPltt
mov r0, r6
mov r1, r5
mov r2, r4
bl GXS_LoadBGExtPltt
bl GXS_EndLoadBGExtPltt
ldmia sp!, {r4, r5, r6, pc}
arm_func_end DoTransfer2dBGExtPlttSub
arm_func_start DoTransfer2dObjOamSub
DoTransfer2dObjOamSub: ; 0x020A6240
ldr ip, _020A6248 ; =GXS_LoadOAM
bx ip
; .align 2, 0
_020A6248: .word GXS_LoadOAM
arm_func_end DoTransfer2dObjOamSub
arm_func_start DoTransfer2dObjCharSub
DoTransfer2dObjCharSub: ; 0x020A624C
ldr ip, _020A6254 ; =GXS_LoadOBJ
bx ip
; .align 2, 0
_020A6254: .word GXS_LoadOBJ
arm_func_end DoTransfer2dObjCharSub
arm_func_start DoTransfer_
DoTransfer_: ; 0x020A6258
stmfd sp!, {r3, r4, r5, lr}
mov r5, r0
ldr r3, [r5, #0]
ldr r2, _020A6284 ; =0x020F9570
ldr r0, [r5, #4]
ldr r1, [r5, #0xc]
ldr r4, [r2, r3, lsl #2]
bl DC_FlushRange
ldmib r5, {r0, r1, r2}
blx r4
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020A6284: .word Unk_020F9570
arm_func_end DoTransfer_
arm_func_start ResetTaskQueue_
ResetTaskQueue_: ; 0x020A6288
mov r1, #0
strh r1, [r0, #0xa]
strh r1, [r0, #8]
strh r1, [r0, #0xc]
str r1, [r0, #0x10]
bx lr
arm_func_end ResetTaskQueue_
arm_func_start NNSi_GfdPushVramTransferTaskQueue
NNSi_GfdPushVramTransferTaskQueue: ; 0x020A62A0
stmfd sp!, {r4, lr}
mov r4, r0
bl IsVramTransferTaskQueueFull_
cmp r0, #0
movne r0, #0
ldmneia sp!, {r4, pc}
ldrh r1, [r4, #0xa]
mov r0, r4
bl GetNextIndex_
strh r0, [r4, #0xa]
ldrh r1, [r4, #0xc]
mov r0, #1
add r1, r1, #1
strh r1, [r4, #0xc]
ldmia sp!, {r4, pc}
arm_func_end NNSi_GfdPushVramTransferTaskQueue
arm_func_start NNSi_GfdGetFrontVramTransferTaskQueue
NNSi_GfdGetFrontVramTransferTaskQueue: ; 0x020A62DC
ldrh r1, [r0, #8]
ldr r0, [r0, #0]
add r0, r0, r1, lsl #4
bx lr
arm_func_end NNSi_GfdGetFrontVramTransferTaskQueue
arm_func_start NNSi_GfdGetEndVramTransferTaskQueue
NNSi_GfdGetEndVramTransferTaskQueue: ; 0x020A62EC
ldrh r1, [r0, #0xa]
ldr r0, [r0, #0]
add r0, r0, r1, lsl #4
bx lr
arm_func_end NNSi_GfdGetEndVramTransferTaskQueue
arm_func_start NNSi_GfdPopVramTransferTaskQueue
NNSi_GfdPopVramTransferTaskQueue: ; 0x020A62FC
stmfd sp!, {r4, lr}
mov r4, r0
bl IsVramTransferTaskQueueEmpty_
cmp r0, #0
movne r0, #0
ldmneia sp!, {r4, pc}
ldrh r1, [r4, #8]
mov r0, r4
bl GetNextIndex_
strh r0, [r4, #8]
ldrh r1, [r4, #0xc]
mov r0, #1
sub r1, r1, #1
strh r1, [r4, #0xc]
ldmia sp!, {r4, pc}
arm_func_end NNSi_GfdPopVramTransferTaskQueue
arm_func_start NNS_GfdInitVramTransferManager
NNS_GfdInitVramTransferManager: ; 0x020A6338
ldr r2, _020A6350 ; =0x021C3AC0
ldr ip, _020A6354 ; =ResetTaskQueue_
str r0, [r2, #0]
ldr r0, _020A6358 ; =0x021C3AC0
str r1, [r2, #4]
bx ip
; .align 2, 0
_020A6350: .word Unk_021C3AC0
_020A6354: .word ResetTaskQueue_
_020A6358: .word Unk_021C3AC0
arm_func_end NNS_GfdInitVramTransferManager
arm_func_start NNS_GfdDoVramTransfer
NNS_GfdDoVramTransfer: ; 0x020A635C
stmfd sp!, {r3, r4, r5, lr}
ldr r4, _020A63B8 ; =0x021C3AC0
mov r0, r4
bl NNSi_GfdGetFrontVramTransferTaskQueue
mov r5, r0
mov r0, r4
bl NNSi_GfdPopVramTransferTaskQueue
cmp r0, #0
ldmeqia sp!, {r3, r4, r5, pc}
_020A6380:
mov r0, r5
bl DoTransfer_
ldr r2, [r4, #0x10]
ldr r1, [r5, #0xc]
mov r0, r4
sub r1, r2, r1
str r1, [r4, #0x10]
bl NNSi_GfdGetFrontVramTransferTaskQueue
mov r5, r0
mov r0, r4
bl NNSi_GfdPopVramTransferTaskQueue
cmp r0, #0
bne _020A6380
ldmia sp!, {r3, r4, r5, pc}
; .align 2, 0
_020A63B8: .word Unk_021C3AC0
arm_func_end NNS_GfdDoVramTransfer
arm_func_start NNS_GfdRegisterNewVramTransferTask
NNS_GfdRegisterNewVramTransferTask: ; 0x020A63BC
stmfd sp!, {r3, r4, r5, r6, r7, r8, sb, lr}
ldr r5, _020A6420 ; =0x021C3AC0
mov sb, r0
mov r0, r5
mov r8, r1
mov r7, r2
mov r6, r3
bl IsVramTransferTaskQueueFull_
cmp r0, #0
movne r0, #0
ldmneia sp!, {r3, r4, r5, r6, r7, r8, sb, pc}
mov r0, r5
bl NNSi_GfdGetEndVramTransferTaskQueue
mov r4, r0
str sb, [r4]
stmib r4, {r7, r8}
mov r0, r5
str r6, [r4, #0xc]
bl NNSi_GfdPushVramTransferTaskQueue
ldr r2, [r5, #0x10]
ldr r1, [r4, #0xc]
mov r0, #1
add r1, r2, r1
str r1, [r5, #0x10]
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, pc}
; .align 2, 0
_020A6420: .word Unk_021C3AC0
arm_func_end NNS_GfdRegisterNewVramTransferTask
.rodata
.global Unk_020F9570
Unk_020F9570: ; 0x020F9570
.incbin "incbin/arm9_rodata.bin", 0x14930, 0x90
.bss
.global Unk_021C3AC0
Unk_021C3AC0: ; 0x021C3AC0
.space 0x14

310
lib/NitroSystem/asm/gfd/gfdi_linkedlistvramman.s
View File

@ -1,310 +0,0 @@
.include "macros/function.inc"
.include "include/gfdi_linkedlistvramman.inc"
.text
arm_func_start TryToMergeBlockRegion_
TryToMergeBlockRegion_: ; 0x020A6424
stmfd sp!, {r4, r5, r6, r7, r8, lr}
ldr r3, [r0, #0]
mov lr, #0
cmp r3, #0
beq _020A6500
mov r8, lr
mov r4, lr
_020A6440:
ldr r6, [r3, #0]
ldr r5, [r2, #4]
ldr ip, [r3, #0xc]
cmp r6, r5
bne _020A649C
ldr r5, [r3, #4]
orr lr, lr, #1
add r5, r6, r5
str r5, [r2, #4]
ldr r6, [r3, #8]
ldr r5, [r3, #0xc]
cmp r6, #0
strne r5, [r6, #0xc]
streq r5, [r0]
cmp r5, #0
strne r6, [r5, #8]
ldr r5, [r1, #0]
cmp r5, #0
strne r3, [r5, #8]
ldr r5, [r1, #0]
str r5, [r3, #0xc]
str r8, [r3, #8]
str r3, [r1, #0]
_020A649C:
ldr r7, [r3, #0]
ldr r5, [r3, #4]
ldr r6, [r2, #0]
add r5, r7, r5
cmp r6, r5
bne _020A64F4
str r7, [r2, #0]
ldr r6, [r3, #8]
ldr r5, [r3, #0xc]
cmp r6, #0
strne r5, [r6, #0xc]
streq r5, [r0]
cmp r5, #0
strne r6, [r5, #8]
ldr r5, [r1, #0]
orr lr, lr, #1
cmp r5, #0
strne r3, [r5, #8]
ldr r5, [r1, #0]
str r5, [r3, #0xc]
str r4, [r3, #8]
str r3, [r1, #0]
_020A64F4:
mov r3, ip
cmp ip, #0
bne _020A6440
_020A6500:
mov r0, lr
ldmia sp!, {r4, r5, r6, r7, r8, pc}
arm_func_end TryToMergeBlockRegion_
arm_func_start NNSi_GfdInitLnkVramMan
NNSi_GfdInitLnkVramMan: ; 0x020A6508
mov r1, #0
str r1, [r0, #0]
bx lr
arm_func_end NNSi_GfdInitLnkVramMan
arm_func_start NNSi_GfdInitLnkVramBlockPool
NNSi_GfdInitLnkVramBlockPool: ; 0x020A6514
stmfd sp!, {r4, lr}
subs lr, r1, #1
mov r2, #0
beq _020A654C
mov r4, r0
_020A6528:
add r3, r2, #1
add r2, r0, r2, lsl #4
add ip, r0, r3, lsl #4
str ip, [r2, #0xc]
str r4, [r2, #0x18]
mov r2, r3
cmp r3, lr
add r4, r4, #0x10
blo _020A6528
_020A654C:
mov r2, #0
str r2, [r0, #8]
add r1, r0, r1, lsl #4
str r2, [r1, #-4]
ldmia sp!, {r4, pc}
arm_func_end NNSi_GfdInitLnkVramBlockPool
arm_func_start NNSi_GfdAddNewFreeBlock
NNSi_GfdAddNewFreeBlock: ; 0x020A6560
stmfd sp!, {r3, lr}
ldr lr, [r1]
cmp lr, #0
ldrne ip, [lr, #0xc]
strne ip, [r1]
cmp lr, #0
beq _020A65B4
stmia lr, {r2, r3}
mov r1, #0
str r1, [lr, #8]
str r1, [lr, #0xc]
ldr r1, [r0, #0]
cmp r1, #0
strne lr, [r1, #8]
ldr r2, [r0, #0]
mov r1, #0
str r2, [lr, #0xc]
str r1, [lr, #8]
str lr, [r0]
mov r0, #1
ldmia sp!, {r3, pc}
_020A65B4:
mov r0, #0
ldmia sp!, {r3, pc}
arm_func_end NNSi_GfdAddNewFreeBlock
arm_func_start NNSi_GfdAllocLnkVram
NNSi_GfdAllocLnkVram: ; 0x020A65BC
stmfd sp!, {r3, lr}
mov ip, #0
str ip, [sp]
bl NNSi_GfdAllocLnkVramAligned
ldmia sp!, {r3, pc}
arm_func_end NNSi_GfdAllocLnkVram
arm_func_start NNSi_GfdAllocLnkVramAligned
NNSi_GfdAllocLnkVramAligned: ; 0x020A65D0
stmfd sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, lr}
ldr r7, [r0, #0]
ldr sb, [sp, #0x28]
cmp r7, #0
mov r6, #0
beq _020A6638
sub ip, sb, #1
mvn r8, ip
mov fp, r6
_020A65F4:
cmp sb, #1
ldrls lr, [r7]
movls r5, fp
movls r4, r3
bls _020A661C
ldr r5, [r7, #0]
add r4, r5, ip
and lr, r8, r4
sub r5, lr, r5
add r4, r3, r5
_020A661C:
ldr sl, [r7, #4]
cmp sl, r4
movhs r6, r7
bhs _020A6638
ldr r7, [r7, #0xc]
cmp r7, #0
bne _020A65F4
_020A6638:
cmp r6, #0
beq _020A6704
cmp r5, #0
beq _020A6698
ldr r8, [r1]
cmp r8, #0
ldrne r3, [r8, #0xc]
strne r3, [r1]
cmp r8, #0
beq _020A6704
ldr r7, [r6, #0]
mov r3, #0
str r7, [r8]
str r5, [r8, #4]
str r3, [r8, #8]
str r3, [r8, #0xc]
ldr r3, [r0, #0]
cmp r3, #0
strne r8, [r3, #8]
ldr r5, [r0, #0]
mov r3, #0
str r5, [r8, #0xc]
str r3, [r8, #8]
str r8, [r0]
_020A6698:
ldr r3, [r6, #4]
sub r3, r3, r4
str r3, [r6, #4]
ldr r3, [r6, #0]
add r3, r3, r4
str r3, [r6, #0]
ldr r3, [r6, #4]
cmp r3, #0
bne _020A66F8
ldr r4, [r6, #8]
ldr r3, [r6, #0xc]
cmp r4, #0
strne r3, [r4, #0xc]
streq r3, [r0]
cmp r3, #0
strne r4, [r3, #8]
ldr r0, [r1, #0]
cmp r0, #0
strne r6, [r0, #8]
ldr r3, [r1, #0]
mov r0, #0
str r3, [r6, #0xc]
str r0, [r6, #8]
str r6, [r1, #0]
_020A66F8:
str lr, [r2]
mov r0, #1
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
_020A6704:
mov r0, #0
str r0, [r2, #0]
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
arm_func_end NNSi_GfdAllocLnkVramAligned
arm_func_start NNSi_GfdMergeAllFreeBlocks
NNSi_GfdMergeAllFreeBlocks: ; 0x020A6710
stmfd sp!, {r3, r4, r5, r6, r7, lr}
sub sp, sp, #8
mov r7, r0
ldr r5, [r7, #0]
mov r6, r1
cmp r5, #0
addeq sp, sp, #8
ldmeqia sp!, {r3, r4, r5, r6, r7, pc}
add r4, sp, #0
_020A6734:
ldr r1, [r5, #0]
mov r0, r7
str r1, [sp]
ldr r3, [r5, #0]
ldr r2, [r5, #4]
mov r1, r6
add r3, r3, r2
mov r2, r4
str r3, [sp, #4]
bl TryToMergeBlockRegion_
cmp r0, #0
ldreq r5, [r5, #0xc]
beq _020A6784
ldr r0, [sp]
str r0, [r5, #0]
ldr r1, [sp, #4]
ldr r0, [sp]
sub r0, r1, r0
str r0, [r5, #4]
ldr r5, [r7, #0]
_020A6784:
cmp r5, #0
bne _020A6734
add sp, sp, #8
ldmia sp!, {r3, r4, r5, r6, r7, pc}
arm_func_end NNSi_GfdMergeAllFreeBlocks
arm_func_start NNSi_GfdFreeLnkVram
NNSi_GfdFreeLnkVram: ; 0x020A6794
stmfd sp!, {r3, r4, r5, lr}
sub sp, sp, #8
add r3, r2, r3
str r2, [sp]
add r2, sp, #0
mov r5, r1
str r3, [sp, #4]
mov r4, r0
bl TryToMergeBlockRegion_
ldr r3, [r5, #0]
cmp r3, #0
ldrne r0, [r3, #0xc]
strne r0, [r5]
cmp r3, #0
addeq sp, sp, #8
mov r0, #0
ldmeqia sp!, {r3, r4, r5, pc}
ldr r1, [sp]
str r1, [r3, #0]
ldr r2, [sp, #4]
ldr r1, [sp]
sub r1, r2, r1
str r1, [r3, #4]
str r0, [r3, #8]
str r0, [r3, #0xc]
ldr r0, [r4, #0]
cmp r0, #0
strne r3, [r0, #8]
ldr r1, [r4, #0]
mov r0, #0
str r1, [r3, #0xc]
str r0, [r3, #8]
str r3, [r4, #0]
mov r0, #1
add sp, sp, #8
ldmia sp!, {r3, r4, r5, pc}
arm_func_end NNSi_GfdFreeLnkVram

3
lib/NitroSystem/asm/gfd/include/gfd_frameplttvramman.inc
View File

@ -1,3 +0,0 @@
.public NNS_GfdAllocFrmPlttVram
.public NNS_GfdFreeFrmPlttVram
.public NNS_GfdResetFrmPlttVramState

4
lib/NitroSystem/asm/gfd/include/gfd_frametexvramman.inc
View File

@ -1,4 +0,0 @@
.public NNSi_GfdSetTexNrmSearchArray
.public NNS_GfdResetFrmTexVramState
.public NNS_GfdAllocFrmTexVram
.public NNS_GfdFreeFrmTexVram

9
lib/NitroSystem/asm/gfd/include/gfd_linkedlistplttvramman.inc
View File

@ -1,9 +0,0 @@
.public NNSi_GfdInitLnkVramMan
.public NNSi_GfdInitLnkVramBlockPool
.public NNSi_GfdAddNewFreeBlock
.public NNSi_GfdAllocLnkVramAligned
.public NNSi_GfdMergeAllFreeBlocks
.public NNSi_GfdFreeLnkVram
.public NNS_GfdAllocLnkPlttVram
.public NNS_GfdFreeLnkPlttVram
.public NNS_GfdResetLnkPlttVramState

9
lib/NitroSystem/asm/gfd/include/gfd_linkedlisttexvramman.inc
View File

@ -1,9 +0,0 @@
.public NNSi_GfdInitLnkVramMan
.public NNSi_GfdInitLnkVramBlockPool
.public NNSi_GfdAddNewFreeBlock
.public NNSi_GfdAllocLnkVram
.public NNSi_GfdMergeAllFreeBlocks
.public NNSi_GfdFreeLnkVram
.public NNS_GfdAllocLnkTexVram
.public NNS_GfdFreeLnkTexVram
.public NNS_GfdResetLnkTexVramState

57
lib/NitroSystem/asm/gfd/include/gfd_vramtransfermanager.inc
View File

@ -1,57 +0,0 @@
.public GetNextIndex_
.public IsVramTransferTaskQueueFull_
.public IsVramTransferTaskQueueEmpty_
.public DoTransfer_
.public ResetTaskQueue_
.public NNSi_GfdPushVramTransferTaskQueue
.public NNSi_GfdGetFrontVramTransferTaskQueue
.public NNSi_GfdGetEndVramTransferTaskQueue
.public NNSi_GfdPopVramTransferTaskQueue
.public GX_LoadBGPltt
.public GXS_LoadBGPltt
.public GX_LoadOBJPltt
.public GXS_LoadOBJPltt
.public GX_LoadOAM
.public GXS_LoadOAM
.public GX_LoadOBJ
.public GXS_LoadOBJ
.public GX_LoadBG0Scr
.public GXS_LoadBG0Scr
.public GX_LoadBG1Scr
.public GXS_LoadBG1Scr
.public GX_LoadBG2Scr
.public GXS_LoadBG2Scr
.public GX_LoadBG3Scr
.public GXS_LoadBG3Scr
.public GX_LoadBG0Char
.public GXS_LoadBG0Char
.public GX_LoadBG1Char
.public GXS_LoadBG1Char
.public GX_LoadBG2Char
.public GXS_LoadBG2Char
.public GX_LoadBG3Char
.public GXS_LoadBG3Char
.public GX_BeginLoadBGExtPltt
.public GX_LoadBGExtPltt
.public GX_EndLoadBGExtPltt
.public GX_BeginLoadOBJExtPltt
.public GX_LoadOBJExtPltt
.public GX_EndLoadOBJExtPltt
.public GXS_BeginLoadBGExtPltt
.public GXS_LoadBGExtPltt
.public GXS_EndLoadBGExtPltt
.public GXS_BeginLoadOBJExtPltt
.public GXS_LoadOBJExtPltt
.public GXS_EndLoadOBJExtPltt
.public GX_BeginLoadTex
.public GX_LoadTex
.public GX_EndLoadTex
.public GX_BeginLoadTexPltt
.public GX_LoadTexPltt
.public GX_EndLoadTexPltt
.public GX_BeginLoadClearImage
.public GX_LoadClearImageColor
.public GX_LoadClearImageDepth
.public GX_EndLoadClearImage
.public DC_FlushRange
.public _u32_div_f

2
lib/NitroSystem/asm/gfd/include/gfdi_linkedlistvramman.inc
View File

@ -1,2 +0,0 @@
.public TryToMergeBlockRegion_
.public NNSi_GfdAllocLnkVramAligned

209
lib/NitroSystem/src/gfd/gfd_FramePlttVramMan.c Normal file
View File

@ -0,0 +1,209 @@
#include <nnsys/gfd/gfd_common.h>
#include <nnsys/gfd/VramManager/gfd_VramMan.h>
#include <nnsys/gfd/VramManager/gfd_FramePlttVramMan.h>
#define NNS_GFD_TEXPLTT_BASE_ADDR 0x00000
#define NNS_GFD_TEXPLTT_MAX_ADDR 0x18000
typedef struct NNSGfdFramPlttVramManager {
u32 loAddr;
u32 hiAddr;
u32 szTotal;
} NNSGfdFrmPlttVramManager;
static NNSGfdFrmPlttVramManager s_managerState_ = {0, 0, 0};
static NNS_GFD_INLINE u32 GetUpperSideAlignmentSize_ (u32 addr, BOOL b4Pltt) {
if (b4Pltt) {
return 0x07 & (0x08 - (addr & 0x07));
} else {
return 0x0F & (0x10 - (addr & 0x0F));
}
}
static NNS_GFD_INLINE u32 GetLowerSideAlignmentSize_ (u32 addr, BOOL b4Pltt) {
if (b4Pltt) {
return addr & 0x07;
} else {
return addr & 0x0F;
}
}
static BOOL IsVramManagerValid_ ( ) {
if ((s_managerState_.loAddr <= s_managerState_.hiAddr) &&
s_managerState_.szTotal != 0) {
return TRUE;
} else {
return FALSE;
}
}
static NNS_GFD_INLINE u32 GetCapacity_ () {
NNS_GFD_ASSERT(IsVramManagerValid_( ));
return (u32)(s_managerState_.hiAddr - s_managerState_.loAddr);
}
static NNS_GFD_INLINE BOOL AllocFromLo_ (u32 szByte, BOOL b4Pltt, u32 * pResAddr) {
const u32 addr = s_managerState_.loAddr;
const u32 alignment = GetUpperSideAlignmentSize_(addr, b4Pltt);
const u32 increase = szByte + alignment;
NNS_GFD_ASSERT(szByte != 0);
NNS_GFD_ASSERT(IsVramManagerValid_( ));
if (GetCapacity_() >= increase) {
const u32 tail = s_managerState_.loAddr + increase;
if (b4Pltt) {
if (tail > NNS_GFD_4PLTT_MAX_ADDR) {
return FALSE;
}
}
*pResAddr = s_managerState_.loAddr + alignment;
s_managerState_.loAddr += increase;
return TRUE;
} else {
return FALSE;
}
}
static NNS_GFD_INLINE BOOL AllocFromHi_ (u32 szByte, BOOL b4Pltt, u32 * pResAddr) {
NNS_GFD_ASSERT(szByte != 0);
NNS_GFD_ASSERT(IsVramManagerValid_( ));
if (s_managerState_.hiAddr >= szByte) {
const u32 addr = (u32)(s_managerState_.hiAddr - szByte);
const u32 alignment = GetLowerSideAlignmentSize_(addr, b4Pltt);
const u32 increase = szByte + alignment;
if (GetCapacity_() >= increase) {
const u32 tail = s_managerState_.hiAddr;
if (b4Pltt) {
if (tail > NNS_GFD_4PLTT_MAX_ADDR) {
return FALSE;
}
}
s_managerState_.hiAddr -= increase;
*pResAddr = s_managerState_.hiAddr;
return TRUE;
}
}
return FALSE;
}
static void FrmPlttVramDebugDumpCallBack_ (u32 loAddr, u32 hiAddr, u32 szFree, u32 szTotal) {
#ifdef SDK_FINALROM
#pragma unused(loAddr)
#pragma unused(hiAddr)
#pragma unused(szFree)
#pragma unused(szTotal)
#endif
OS_Printf("===== NNS_Gfd FrmPlttVramManager Dump ====\n");
OS_Printf("head-Addr : tail-addr : free-size \n");
OS_Printf("0x%08x : 0x%08x : 0x%08x \n", loAddr, hiAddr, szFree);
OS_Printf(
" %08d / %08d bytes (%6.2f%%) used \n", szTotal - szFree, szTotal,
100.0f * (szTotal - szFree) / szTotal
);
OS_Printf("==========================================\n");
}
void NNS_GfdDumpFrmPlttVramManager () {
NNS_GfdDumpFrmPlttVramManagerEx(FrmPlttVramDebugDumpCallBack_);
}
void NNS_GfdDumpFrmPlttVramManagerEx (NNSGfdFrmPlttVramDebugDumpCallBack pFunc) {
NNS_GFD_NULL_ASSERT(pFunc);
(*pFunc)(
s_managerState_.loAddr,
s_managerState_.hiAddr,
s_managerState_.hiAddr - s_managerState_.loAddr,
s_managerState_.szTotal
);
}
void NNS_GfdInitFrmPlttVramManager (u32 szByte, BOOL useAsDefault) {
NNS_GFD_MINMAX_ASSERT(szByte, 0, NNS_GFD_TEXPLTT_MAX_ADDR);
s_managerState_.szTotal = szByte;
NNS_GfdResetFrmPlttVramState();
NNS_GFD_ASSERT(IsVramManagerValid_( ));
if (useAsDefault) {
NNS_GfdDefaultFuncAllocPlttVram = NNS_GfdAllocFrmPlttVram;
NNS_GfdDefaultFuncFreePlttVram = NNS_GfdFreeFrmPlttVram;
}
}
NNSGfdPlttKey NNS_GfdAllocFrmPlttVram (u32 szByte, BOOL bPltt4, u32 allocFrom) {
u32 addr = 0x0;
BOOL result = FALSE;
NNS_GFD_ASSERT(IsVramManagerValid_( ));
{
szByte = NNSi_GfdGetPlttKeyRoundupSize(szByte);
if (szByte >= NNS_GFD_PLTTSIZE_MAX) {
NNS_GFD_WARNING("Allocation size is too big. : NNS_GfdAllocLnkPlttVram()");
return NNS_GFD_ALLOC_ERROR_PLTTKEY;
}
NNS_GFD_MINMAX_ASSERT(szByte, NNS_GFD_PLTTSIZE_MIN, NNS_GFD_PLTTSIZE_MAX);
}
if (allocFrom == NNS_GFD_ALLOC_FROM_LOW) {
result = AllocFromLo_(szByte, bPltt4, &addr);
} else {
result = AllocFromHi_(szByte, bPltt4, &addr);
}
if (result) {
return NNS_GfdMakePlttKey(addr, szByte);
}
NG_CASE:
NNS_GFD_WARNING("failure in Vram Allocation. : NNS_GfdPlttFrmTexAlloc()");
return NNS_GFD_ALLOC_ERROR_PLTTKEY;
}
int NNS_GfdFreeFrmPlttVram (NNSGfdPlttKey plttKey) {
#pragma unused(plttKey)
return 0;
}
void NNS_GfdGetFrmPlttVramState (NNSGfdFrmPlttVramState * pState) {
NNS_GFD_NULL_ASSERT(pState);
NNS_GFD_ASSERT(IsVramManagerValid_( ));
pState->address[0] = s_managerState_.loAddr;
pState->address[1] = s_managerState_.hiAddr;
}
void NNS_GfdSetFrmPlttVramState (const NNSGfdFrmPlttVramState * pState) {
NNS_GFD_NULL_ASSERT(pState);
s_managerState_.loAddr = pState->address[0];
s_managerState_.hiAddr = pState->address[1];
}
void NNS_GfdResetFrmPlttVramState () {
s_managerState_.loAddr = NNS_GFD_TEXPLTT_BASE_ADDR;
s_managerState_.hiAddr = s_managerState_.szTotal;
}

381
lib/NitroSystem/src/gfd/gfd_FrameTexVramMan.c Normal file
View File

@ -0,0 +1,381 @@
#include <nnsys/gfd/gfd_common.h>
#include <nnsys/gfd/VramManager/gfd_VramMan.h>
#include <nnsys/gfd/VramManager/gfd_FrameTexVramMan.h>
#define NNS_GFD_TEX_SLOT_SIZE 0x20000
#define NNS_GFD_NUM_TEX_VRAM_REGION 5
#define NNS_GFD_NUM_TEX_VRAM_REGION_4x4 2
#define NNS_GFD_INVALID_ADDR 0xFFFFFFFF
typedef struct NNSGfdFrmTexRegionState {
u32 head;
u32 tail;
BOOL bActive;
const BOOL bHalfSize;
const u16 index;
const u16 pad16_;
const u32 baseAddress;
} NNSGfdFrmTexRegionState;
typedef struct NNSGfdFrmTexVramMnager {
u16 numSlot;
} NNSGfdFrmTexVramMnager;
static NNSGfdFrmTexVramMnager frmExVramMan_;
static NNSGfdFrmTexRegionState vramRegions_[NNS_GFD_NUM_TEX_VRAM_REGION] = {
{NNS_GFD_INVALID_ADDR, NNS_GFD_INVALID_ADDR, FALSE, FALSE, 0, 0xFFFF, 0x0},
{NNS_GFD_INVALID_ADDR, NNS_GFD_INVALID_ADDR, FALSE, TRUE, 1, 0xFFFF, (u32)NNS_GFD_TEX_SLOT_SIZE},
{NNS_GFD_INVALID_ADDR, NNS_GFD_INVALID_ADDR, FALSE, TRUE, 2, 0xFFFF, (u32)(NNS_GFD_TEX_SLOT_SIZE + NNS_GFD_TEX_SLOT_SIZE / 2)},
{NNS_GFD_INVALID_ADDR, NNS_GFD_INVALID_ADDR, FALSE, FALSE, 3, 0xFFFF, (u32)(NNS_GFD_TEX_SLOT_SIZE * 2)},
{NNS_GFD_INVALID_ADDR, NNS_GFD_INVALID_ADDR, FALSE, FALSE, 4, 0xFFFF, (u32)(NNS_GFD_TEX_SLOT_SIZE * 3)}
};
static NNSGfdFrmTexRegionState * texNrmSearchArray_[NNS_GFD_NUM_TEX_VRAM_REGION] = {
&vramRegions_[4],
&vramRegions_[3],
&vramRegions_[0],
&vramRegions_[2],
&vramRegions_[1]
};
static NNSGfdFrmTexRegionState * tex4x4SearchArray_[NNS_GFD_NUM_TEX_VRAM_REGION_4x4] = {
&vramRegions_[0],
&vramRegions_[3]
};
typedef struct NNSiGfdDefaultDebugContext {
u32 szTotalFree;
u32 szTotalReserved;
} NNSiGfdDefaultDebugContext;
static NNS_GFD_INLINE BOOL IsSlotNumValid_ (u16 numSlot) {
if (numSlot > 0 && numSlot <= 4) {
return TRUE;
} else {
return FALSE;
}
}
static NNS_GFD_INLINE void ResetRegionNormal_ (NNSGfdFrmTexRegionState * pRegion) {
NNS_GFD_NULL_ASSERT(pRegion);
pRegion->head = 0x0;
pRegion->tail = NNS_GFD_TEX_SLOT_SIZE;
}
static NNS_GFD_INLINE void ResetRegionHalf_ (NNSGfdFrmTexRegionState * pRegion) {
NNS_GFD_NULL_ASSERT(pRegion);
pRegion->head = 0x0;
pRegion->tail = NNS_GFD_TEX_SLOT_SIZE / 2;
}
static NNS_GFD_INLINE BOOL IsRegionStateValid_ (const NNSGfdFrmTexRegionState * pRegion) {
NNS_GFD_NULL_ASSERT(pRegion);
if (pRegion->head != NNS_GFD_INVALID_ADDR &&
pRegion->tail != NNS_GFD_INVALID_ADDR) {
if (pRegion->head <= pRegion->tail) {
return TRUE;
}
}
return FALSE;
}
static NNS_GFD_INLINE BOOL IsVramManagerValid_ ( ) {
int i;
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION; i++ ) {
if (!IsRegionStateValid_(&vramRegions_[i])) {
return FALSE;
}
}
return TRUE;
}
static NNS_GFD_INLINE u32 GetReagionCapacity_ (const NNSGfdFrmTexRegionState * pRegion) {
NNS_GFD_NULL_ASSERT(pRegion);
NNS_GFD_ASSERT(IsRegionStateValid_(pRegion));
return (u32)(pRegion->tail - pRegion->head);
}
static NNS_GFD_INLINE u32 AllocFromReagionHead_ (NNSGfdFrmTexRegionState * pRegion, u32 szByte) {
NNS_GFD_NULL_ASSERT(pRegion);
NNS_GFD_ASSERT(IsRegionStateValid_(pRegion));
NNS_GFD_ASSERT(GetReagionCapacity_(pRegion) >= szByte);
{
const u32 result = pRegion->head;
pRegion->head += szByte;
return result;
}
}
static NNS_GFD_INLINE u32 AllocFromReagionTail_ (NNSGfdFrmTexRegionState * pRegion, u32 szByte) {
NNS_GFD_NULL_ASSERT(pRegion);
NNS_GFD_ASSERT(IsRegionStateValid_(pRegion));
NNS_GFD_ASSERT(GetReagionCapacity_(pRegion) >= szByte);
{
pRegion->tail -= szByte;
return pRegion->tail;
}
}
static NNS_GFD_INLINE NNSGfdFrmTexRegionState * Get4x4IdxRegion_ (const NNSGfdFrmTexRegionState * pRegion) {
NNS_GFD_NULL_ASSERT(pRegion);
switch (pRegion->index) {
case 0: return &vramRegions_[1];
case 3: return &vramRegions_[2];
default: NNS_GFD_WARNING("Invalid region is detected. in Get4x4IdxRegion_(). "); break;
}
return NULL;
}
static NNS_GFD_INLINE BOOL DoAlloc4x4_ (u32 szByte, u32 * addr) {
NNS_GFD_NULL_ASSERT(addr);
NNS_GFD_ASSERTMSG(IsVramManagerValid_(), "Make sure to Initialize the manager.");
{
int i;
NNSGfdFrmTexRegionState * pRegion = NULL;
NNSGfdFrmTexRegionState * pPltRegion = NULL;
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION_4x4; i++ ) {
pRegion = tex4x4SearchArray_[i];
if (pRegion->bActive &&
GetReagionCapacity_(pRegion) >= szByte) {
pPltRegion = Get4x4IdxRegion_(pRegion);
if (pPltRegion->bActive &&
GetReagionCapacity_(pPltRegion) >= szByte / 2) {
*addr = AllocFromReagionHead_(pRegion, szByte);
(void)AllocFromReagionHead_(pPltRegion, szByte / 2);
*addr += pRegion->baseAddress;
return TRUE;
}
}
}
NNS_GFD_WARNING("We have no memory for 4x4 Tex.");
return FALSE;
}
}
static NNS_GFD_INLINE BOOL DoAllocNrm_ (u32 szByte, u32 * addr) {
NNS_GFD_NULL_ASSERT(addr);
NNS_GFD_ASSERTMSG(IsVramManagerValid_(), "Make sure to Initialize the manager.");
{
int i;
NNSGfdFrmTexRegionState * pRegion = NULL;
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION; i++ ) {
pRegion = texNrmSearchArray_[i];
if (pRegion->bActive) {
if (GetReagionCapacity_(pRegion) >= szByte) {
*addr = AllocFromReagionTail_(pRegion, szByte);
*addr += pRegion->baseAddress;
return TRUE;
}
}
}
NNS_GFD_WARNING("We have no memory for Nrm Tex.");
return FALSE;
}
}
static void DefaultDebugDumpFunc_ (int index, u32 startAddr, u32 endAddr, u32 blockMax, BOOL bActive, void * pUserContext) {
#ifdef SDK_FINALROM
#pragma unused(index)
#endif
NNSiGfdDefaultDebugContext * pContext = (NNSiGfdDefaultDebugContext *)pUserContext;
NNS_GFD_NULL_ASSERT(pContext);
if (bActive) {
OS_Printf(
"%02d : 0x%08x : 0x%08x : 0x%08x \n",
index,
startAddr,
endAddr,
endAddr - startAddr
);
pContext->szTotalFree += endAddr - startAddr;
pContext->szTotalReserved += blockMax;
} else {
OS_Printf("%02d : ---------- : ---------- : ---------- \n", index);
}
}
void NNSi_GfdSetTexNrmSearchArray (int idx1st, int idx2nd, int idx3rd, int idx4th, int idx5th) {
NNS_GFD_MINMAX_ASSERT(idx1st, 0, NNS_GFD_NUM_TEX_VRAM_REGION - 1);
NNS_GFD_MINMAX_ASSERT(idx2nd, 0, NNS_GFD_NUM_TEX_VRAM_REGION - 1);
NNS_GFD_MINMAX_ASSERT(idx3rd, 0, NNS_GFD_NUM_TEX_VRAM_REGION - 1);
NNS_GFD_MINMAX_ASSERT(idx4th, 0, NNS_GFD_NUM_TEX_VRAM_REGION - 1);
NNS_GFD_MINMAX_ASSERT(idx5th, 0, NNS_GFD_NUM_TEX_VRAM_REGION - 1);
texNrmSearchArray_[0] = &vramRegions_[idx1st];
texNrmSearchArray_[1] = &vramRegions_[idx2nd];
texNrmSearchArray_[2] = &vramRegions_[idx3rd];
texNrmSearchArray_[3] = &vramRegions_[idx4th];
texNrmSearchArray_[4] = &vramRegions_[idx5th];
}
void NNS_GfdDumpFrmTexVramManager () {
const NNSGfdFrmTexRegionState * pState = NULL;
NNSiGfdDefaultDebugContext context = {0, 0};
OS_Printf("===== NNS_Gfd FrmTexVramManager Dump =====\n");
OS_Printf("index : head-Addr : tail-addr : free-size \n");
NNS_GfdDumpFrmTexVramManagerEx(DefaultDebugDumpFunc_, &context);
OS_Printf(
" %08d / %08d bytes (%6.2f%%) used \n",
context.szTotalReserved - context.szTotalFree,
context.szTotalReserved,
100.0f * (context.szTotalReserved - context.szTotalFree) / context.szTotalReserved
);
OS_Printf("==========================================\n");
}
void NNS_GfdDumpFrmTexVramManagerEx (NNSGfdFrmTexVramDebugDumpCallBack pFunc, void * pUserContext) {
int i;
const NNSGfdFrmTexRegionState * pState = NULL;
NNS_GFD_NULL_ASSERT(pFunc);
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION; i++ ) {
pState = &vramRegions_[i];
(*pFunc)(
i,
pState->head + pState->baseAddress,
pState->tail + pState->baseAddress,
(pState->bHalfSize) ? (u32)(NNS_GFD_TEX_SLOT_SIZE / 2) : NNS_GFD_TEX_SLOT_SIZE,
pState->bActive,
pUserContext
);
}
}
void NNS_GfdInitFrmTexVramManager (u16 numSlot, BOOL useAsDefault) {
NNS_GFD_ASSERT(IsSlotNumValid_(numSlot));
if (numSlot <= 2) {
NNSi_GfdSetTexNrmSearchArray(4, 3, 2, 0, 1);
} else {
NNSi_GfdSetTexNrmSearchArray(4, 3, 0, 2, 1);
}
frmExVramMan_.numSlot = numSlot;
NNS_GfdResetFrmTexVramState();
if (useAsDefault) {
NNS_GfdDefaultFuncAllocTexVram = NNS_GfdAllocFrmTexVram;
NNS_GfdDefaultFuncFreeTexVram = NNS_GfdFreeFrmTexVram;
}
}
void NNS_GfdResetFrmTexVramState () {
int i;
u16 numSlot = frmExVramMan_.numSlot;
const numRegion = (numSlot > 1) ? numSlot + 1 : numSlot + 0;
NNS_GFD_ASSERT(IsSlotNumValid_(numSlot));
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION; i++ ) {
if (i < numRegion) {
vramRegions_[i].bActive = TRUE;
} else {
vramRegions_[i].bActive = FALSE;
}
if (vramRegions_[i].bHalfSize) {
ResetRegionHalf_(&vramRegions_[i]);
} else {
ResetRegionNormal_(&vramRegions_[i]);
}
}
}
NNSGfdTexKey NNS_GfdAllocFrmTexVram (u32 szByte, BOOL is4x4comp, u32 opt) {
#pragma unused(opt)
u32 addr;
BOOL result;
NNS_GFD_ASSERTMSG(IsVramManagerValid_(), "Make sure to Initialize the manager.");
{
szByte = NNSi_GfdGetTexKeyRoundupSize(szByte);
if (szByte >= NNS_GFD_TEXSIZE_MAX) {
NNS_GFD_WARNING("Allocation size is too big. : NNS_GfdAllocFrmTexVram()");
return NNS_GFD_ALLOC_ERROR_TEXKEY;
}
NNS_GFD_MINMAX_ASSERT(szByte, NNS_GFD_TEXSIZE_MIN, NNS_GFD_TEXSIZE_MAX);
}
if (is4x4comp) {
result = DoAlloc4x4_(szByte, &addr);
} else {
result = DoAllocNrm_(szByte, &addr);
}
if (result) {
return NNS_GfdMakeTexKey(addr, szByte, is4x4comp);
} else {
NNS_GFD_WARNING("failure in Vram Allocation. : NNS_GfdAllocFrmTexVram()");
return NNS_GFD_ALLOC_ERROR_TEXKEY;
}
}
int NNS_GfdFreeFrmTexVram (NNSGfdTexKey texKey) {
#pragma unused(texKey)
NNS_GFD_ASSERTMSG(IsVramManagerValid_(), "Make sure to Initialize the manager.");
return 0;
}
void NNS_GfdGetFrmTexVramState (NNSGfdFrmTexVramState * pState) {
int i;
NNS_GFD_NULL_ASSERT(pState);
NNS_GFD_ASSERTMSG(IsVramManagerValid_(), "Make sure to Initialize the manager.");
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION; i++ ) {
pState->address[i * 2 + 0] = vramRegions_[i].head;
pState->address[i * 2 + 1] = vramRegions_[i].tail;
}
}
void NNS_GfdSetFrmTexVramState (const NNSGfdFrmTexVramState * pState) {
int i;
NNS_GFD_NULL_ASSERT(pState);
NNS_GFD_ASSERTMSG(IsVramManagerValid_(), "Make sure to Initialize the manager.");
for ( i = 0; i < NNS_GFD_NUM_TEX_VRAM_REGION; i++ ) {
vramRegions_[i].head = pState->address[i * 2 + 0];
vramRegions_[i].tail = pState->address[i * 2 + 1];
}
}

155
lib/NitroSystem/src/gfd/gfd_LinkedListPlttVramMan.c Normal file
View File

@ -0,0 +1,155 @@
#include <nnsys/gfd/gfd_common.h>
#include <nnsys/gfd/VramManager/gfd_LinkedListPlttVramMan.h>
#include "include/gfdi_LinkedListVramMan_Common.h"
#define GFD_SLOT_SIZE 0x18000
#define NNS_GFD_BARPLTT_FREE_ERROR_INVALID_SIZE 1
typedef struct NNS_GfdLnkPlttVramManager {
NNSiGfdLnkVramMan mgr;
NNSiGfdLnkVramBlock * pBlockPoolList;
u32 szByte;
NNSiGfdLnkVramBlock * pWorkHead;
u32 szByteManagementWork;
} NNS_GfdLnkPlttVramManager;
static NNS_GfdLnkPlttVramManager mgr_;
void NNS_GfdDumpLnkPlttVramManager () {
OS_Printf("=== NNS_Gfd LnkPlttVramManager Dump ===\n");
OS_Printf(" address: size \n");
OS_Printf("=======================================\n");
OS_Printf("------ Free Blocks -----\n");
NNSi_GfdDumpLnkVramManFreeListInfo(mgr_.mgr.pFreeList, mgr_.szByte);
OS_Printf("=======================================\n");
}
void NNS_GfdDumpLnkPlttVramManagerEx (NNSGfdLnkDumpCallBack pFunc, void * pUserData) {
NNS_GFD_NULL_ASSERT(pFunc);
NNSi_GfdDumpLnkVramManFreeListInfoEx(mgr_.mgr.pFreeList, pFunc, pUserData);
}
u32 NNS_GfdGetLnkPlttVramManagerWorkSize (u32 numMemBlk) {
return numMemBlk * sizeof(NNSiGfdLnkVramBlock);
}
void NNS_GfdInitLnkPlttVramManager (u32 szByte, void * pManagementWork, u32 szByteManagementWork, BOOL useAsDefault) {
NNS_GFD_ASSERT(szByte <= GFD_SLOT_SIZE);
NNS_GFD_NULL_ASSERT(pManagementWork);
NNS_GFD_ASSERT(szByteManagementWork != 0);
{
mgr_.szByte = szByte;
mgr_.pWorkHead = pManagementWork;
mgr_.szByteManagementWork = szByteManagementWork;
NNS_GfdResetLnkPlttVramState();
if (useAsDefault) {
NNS_GfdDefaultFuncAllocPlttVram = NNS_GfdAllocLnkPlttVram;
NNS_GfdDefaultFuncFreePlttVram = NNS_GfdFreeLnkPlttVram;
}
}
}
NNSGfdPlttKey NNS_GfdAllocLnkPlttVram (u32 szByte, BOOL b4Pltt, u32 opt) {
#pragma unused(opt)
u32 addr;
BOOL result;
{
szByte = NNSi_GfdGetPlttKeyRoundupSize(szByte);
if (szByte >= NNS_GFD_PLTTSIZE_MAX) {
NNS_GFD_WARNING("Allocation size is too big. : NNS_GfdAllocLnkPlttVram()");
return NNS_GFD_ALLOC_ERROR_PLTTKEY;
}
NNS_GFD_MINMAX_ASSERT(szByte, NNS_GFD_PLTTSIZE_MIN, NNS_GFD_PLTTSIZE_MAX);
}
if (b4Pltt) {
result = NNSi_GfdAllocLnkVramAligned(
&mgr_.mgr,
&mgr_.pBlockPoolList,
&addr,
szByte,
0x08
);
if (addr + szByte > NNS_GFD_4PLTT_MAX_ADDR) {
if (!NNSi_GfdFreeLnkVram(
&mgr_.mgr,
&mgr_.pBlockPoolList,
addr,
szByte
)) {
}
return NNS_GFD_ALLOC_ERROR_PLTTKEY;
}
} else {
result = NNSi_GfdAllocLnkVramAligned(
&mgr_.mgr,
&mgr_.pBlockPoolList,
&addr,
szByte,
0x10
);
}
if (result) {
return NNS_GfdMakePlttKey(addr, szByte);
} else {
NNS_GFD_WARNING("failure in Vram Allocation. : NNS_GfdAllocLnkPlttVram()");
return NNS_GFD_ALLOC_ERROR_PLTTKEY;
}
}
int NNS_GfdFreeLnkPlttVram (NNSGfdPlttKey plttKey) {
const u32 addr = NNS_GfdGetPlttKeyAddr(plttKey);
const u32 szByte = NNS_GfdGetPlttKeySize(plttKey);
const BOOL result = NNSi_GfdFreeLnkVram(
&mgr_.mgr,
&mgr_.pBlockPoolList,
addr,
szByte
);
if (result) {
return 0;
} else {
return NNS_GFD_BARPLTT_FREE_ERROR_INVALID_SIZE;
}
}
void NNS_GfdResetLnkPlttVramState (void) {
mgr_.pBlockPoolList
= NNSi_GfdInitLnkVramBlockPool(
(NNSiGfdLnkVramBlock *)mgr_.pWorkHead,
mgr_.szByteManagementWork / sizeof(NNSiGfdLnkVramBlock)
);
{
BOOL result;
NNSi_GfdInitLnkVramMan(&mgr_.mgr);
result = NNSi_GfdAddNewFreeBlock(
&mgr_.mgr,
&mgr_.pBlockPoolList,
0,
mgr_.szByte
);
NNS_GFD_ASSERT(result);
}
NNSi_GfdMergeAllFreeBlocks(&mgr_.mgr, &mgr_.pBlockPoolList);
}

267
lib/NitroSystem/src/gfd/gfd_LinkedListTexVramMan.c Normal file
View File

@ -0,0 +1,267 @@
#include <nnsys/gfd/gfd_common.h>
#include <nnsys/gfd/VramManager/gfd_LinkedListTexVramMan.h>
#include "include/gfdi_LinkedListVramMan_Common.h"
#define GFD_SLOT_SIZE 0x20000
#define GFD_SLOT0_BASEADDR 0x00000
#define GFD_SLOT1_BASEADDR 0x20000
#define GFD_SLOT2_BASEADDR 0x40000
#define GFD_SLOT3_BASEADDR 0x60000
#define NNS_GFD_LNK_FREE_ERROR_INVALID_SIZE 2
typedef struct NNS_GfdLnkTexVramManager {
NNSiGfdLnkVramMan mgrNrm;
NNSiGfdLnkVramMan mgr4x4;
NNSiGfdLnkVramBlock * pBlockPoolList;
u32 szByte;
u32 szByteFor4x4;
NNSiGfdLnkVramBlock * pWorkHead;
u32 szByteManagementWork;
} NNS_GfdLnkTexVramManager;
typedef struct SlotData {
u32 szFree;
u32 szNrm;
u32 sz4x4;
} SlotData;
static NNS_GfdLnkTexVramManager mgr_;
static u32 Dbg_GetVramManTotalFreeBlockSize_ (const NNSiGfdLnkVramMan * pMgr) {
u32 total = 0;
const NNSiGfdLnkVramBlock * pBlk = pMgr->pFreeList;
while (pBlk) {
total += pBlk->szByte;
pBlk = pBlk->pBlkNext;
}
return total;
}
static BOOL Dbg_IsInitializeSizeParamsValid_ (u32 szByte, u32 szByteFor4x4) {
if (szByte > 0 && szByteFor4x4 <= GFD_SLOT_SIZE * 2) {
if (szByteFor4x4 > 0) {
if (szByteFor4x4 <= GFD_SLOT_SIZE) {
return (BOOL)(szByte >= GFD_SLOT1_BASEADDR + szByteFor4x4 / 2);
} else {
return (BOOL)(szByte >= szByteFor4x4 + GFD_SLOT_SIZE);
}
} else {
return (BOOL)(szByte <= GFD_SLOT_SIZE * 4);
}
} else {
return FALSE;
}
}
static NNS_GFD_INLINE BOOL InitSlotFreeBlock_ (NNSiGfdLnkVramMan * pMgr, NNSiGfdLnkVramBlock * * pPoolList, u32 baseAddr, u32 size) {
NNS_GFD_NULL_ASSERT(pMgr);
NNS_GFD_NULL_ASSERT(pPoolList);
NNS_GFD_ASSERT(GFD_SLOT_SIZE >= size);
{
BOOL result = TRUE;
if (size > 0) {
result &= NNSi_GfdAddNewFreeBlock(pMgr, pPoolList, baseAddr, size);
}
return result;
}
}
void NNS_GfdDumpLnkTexVramManager () {
OS_Printf("=== NNS_Gfd LnkTexVramManager Dump ====\n");
OS_Printf(" address: size \n");
OS_Printf("=======================================\n");
OS_Printf("------ Normal Texture Free Blocks -----\n");
NNSi_GfdDumpLnkVramManFreeListInfo(mgr_.mgrNrm.pFreeList, mgr_.szByte);
OS_Printf("------ 4x4 Texture Free Blocks -----\n");
if (mgr_.szByteFor4x4 != 0) {
NNSi_GfdDumpLnkVramManFreeListInfo(mgr_.mgr4x4.pFreeList, mgr_.szByteFor4x4);
}
OS_Printf("=======================================\n");
}
void NNS_GfdDumpLnkTexVramManagerEx (NNSGfdLnkDumpCallBack pFuncForNrm, NNSGfdLnkDumpCallBack pFuncFor4x4, void * pUserData) {
NNS_GFD_ASSERT(pFuncForNrm != NULL || pFuncFor4x4 != NULL);
if (pFuncForNrm != NULL) {
NNSi_GfdDumpLnkVramManFreeListInfoEx(mgr_.mgrNrm.pFreeList, pFuncForNrm, pUserData);
}
if (mgr_.szByteFor4x4 != 0 && pFuncFor4x4 != NULL) {
NNSi_GfdDumpLnkVramManFreeListInfoEx(mgr_.mgr4x4.pFreeList, pFuncFor4x4, pUserData);
}
}
u32 NNS_GfdGetLnkTexVramManagerWorkSize (u32 numMemBlk) {
return numMemBlk * sizeof(NNSiGfdLnkVramBlock);
}
void NNS_GfdInitLnkTexVramManager (u32 szByte, u32 szByteFor4x4, void * pManagementWork, u32 szByteManagementWork, BOOL useAsDefault) {
NNS_GFD_ASSERT(Dbg_IsInitializeSizeParamsValid_(szByte, szByteFor4x4));
NNS_GFD_NULL_ASSERT(pManagementWork);
NNS_GFD_ASSERT(szByteManagementWork != 0);
{
mgr_.szByte = szByte;
mgr_.szByteFor4x4 = szByteFor4x4;
mgr_.pWorkHead = pManagementWork;
mgr_.szByteManagementWork = szByteManagementWork;
NNS_GfdResetLnkTexVramState();
NNS_GFD_ASSERT(
mgr_.szByte - (mgr_.szByteFor4x4 + mgr_.szByteFor4x4 / 2)
== Dbg_GetVramManTotalFreeBlockSize_(&mgr_.mgrNrm)
);
NNS_GFD_ASSERT(
mgr_.szByteFor4x4
== Dbg_GetVramManTotalFreeBlockSize_(&mgr_.mgr4x4)
);
if (useAsDefault) {
NNS_GfdDefaultFuncAllocTexVram = NNS_GfdAllocLnkTexVram;
NNS_GfdDefaultFuncFreeTexVram = NNS_GfdFreeLnkTexVram;
}
}
}
NNSGfdTexKey NNS_GfdAllocLnkTexVram (u32 szByte, BOOL is4x4comp, u32 opt) {
#pragma unused(opt)
u32 addr;
BOOL result;
{
szByte = NNSi_GfdGetTexKeyRoundupSize(szByte);
if (szByte >= NNS_GFD_TEXSIZE_MAX) {
NNS_GFD_WARNING("Allocation size is too big. : NNS_GfdAllocLnkTexVram()");
return NNS_GFD_ALLOC_ERROR_TEXKEY;
}
NNS_GFD_MINMAX_ASSERT(szByte, NNS_GFD_TEXSIZE_MIN, NNS_GFD_TEXSIZE_MAX);
}
if (is4x4comp) {
result = NNSi_GfdAllocLnkVram(&mgr_.mgr4x4, &mgr_.pBlockPoolList, &addr, szByte);
} else {
result = NNSi_GfdAllocLnkVram(&mgr_.mgrNrm, &mgr_.pBlockPoolList, &addr, szByte);
}
if (result) {
return NNS_GfdMakeTexKey(addr, szByte, is4x4comp);
} else {
NNS_GFD_WARNING("failure in Vram Allocation. : NNS_GfdAllocLnkTexVram()");
return NNS_GFD_ALLOC_ERROR_TEXKEY;
}
}
int NNS_GfdFreeLnkTexVram (NNSGfdTexKey memKey) {
BOOL result;
const u32 addr = NNS_GfdGetTexKeyAddr(memKey);
const u32 szByte = NNS_GfdGetTexKeySize(memKey);
const BOOL b4x4 = NNS_GfdGetTexKey4x4Flag(memKey);
if (szByte != 0) {
if (b4x4) {
result = NNSi_GfdFreeLnkVram(&mgr_.mgr4x4, &mgr_.pBlockPoolList, addr, szByte);
} else {
result = NNSi_GfdFreeLnkVram(&mgr_.mgrNrm, &mgr_.pBlockPoolList, addr, szByte);
}
if (result) {
return 0;
} else {
return 1;
}
} else {
return NNS_GFD_LNK_FREE_ERROR_INVALID_SIZE;
}
}
void NNS_GfdResetLnkTexVramState (void) {
SlotData sd[4] = {
{0x20000, 0, 0},
{0x20000, 0, 0},
{0x20000, 0, 0},
{0x20000, 0, 0}
};
const u32 szIndexTbl = mgr_.szByteFor4x4 / 2;
u32 restNrm = mgr_.szByte - (mgr_.szByteFor4x4 + szIndexTbl);
u32 rest4x4 = mgr_.szByteFor4x4;
u32 slotNo;
u32 val;
for ( slotNo = 0; slotNo < 4; slotNo++ ) {
if (slotNo == 0 || slotNo == 2) {
if (sd[slotNo].szFree > 0 && rest4x4 > 0) {
if (sd[slotNo].szFree > rest4x4) {
val = rest4x4;
} else {
val = sd[slotNo].szFree;
}
sd[slotNo].sz4x4 += val;
sd[slotNo].szFree -= val;
rest4x4 -= val;
}
}
}
{
sd[1].szFree -= szIndexTbl;
}
for ( slotNo = 0; slotNo < 4; slotNo++ ) {
if (sd[slotNo].szFree > 0 && restNrm > 0) {
if (sd[slotNo].szFree > restNrm) {
val = restNrm;
} else {
val = sd[slotNo].szFree;
}
sd[slotNo].szNrm += val;
sd[slotNo].szFree -= val;
restNrm -= val;
}
}
{
BOOL result = TRUE;
NNSi_GfdInitLnkVramMan(&mgr_.mgrNrm);
NNSi_GfdInitLnkVramMan(&mgr_.mgr4x4);
mgr_.pBlockPoolList = NNSi_GfdInitLnkVramBlockPool(
(NNSiGfdLnkVramBlock *)mgr_.pWorkHead,
mgr_.szByteManagementWork / sizeof(NNSiGfdLnkVramBlock)
);
{
result &= InitSlotFreeBlock_(&mgr_.mgr4x4, &mgr_.pBlockPoolList, GFD_SLOT0_BASEADDR, sd[0].sz4x4);
result &= InitSlotFreeBlock_(&mgr_.mgrNrm, &mgr_.pBlockPoolList, GFD_SLOT0_BASEADDR + sd[0].sz4x4, sd[0].szNrm);
result &= InitSlotFreeBlock_(&mgr_.mgr4x4, &mgr_.pBlockPoolList, GFD_SLOT2_BASEADDR, sd[2].sz4x4);
result &= InitSlotFreeBlock_(&mgr_.mgrNrm, &mgr_.pBlockPoolList, GFD_SLOT2_BASEADDR + sd[2].sz4x4, sd[2].szNrm);
NNS_GFD_ASSERT(sd[3].sz4x4 == 0);
result &= InitSlotFreeBlock_(&mgr_.mgrNrm, &mgr_.pBlockPoolList, GFD_SLOT3_BASEADDR, sd[3].szNrm);
result &= InitSlotFreeBlock_(&mgr_.mgrNrm, &mgr_.pBlockPoolList, GFD_SLOT1_BASEADDR + szIndexTbl, sd[1].szNrm);
}
NNS_GFD_ASSERT(result);
}
NNSi_GfdMergeAllFreeBlocks(&mgr_.mgrNrm, &mgr_.pBlockPoolList);
NNSi_GfdMergeAllFreeBlocks(&mgr_.mgr4x4, &mgr_.pBlockPoolList);
}

19
lib/NitroSystem/src/gfd/gfd_PlttVramMan.c Normal file
View File

@ -0,0 +1,19 @@
#include <nnsys/gfd/VramManager/gfd_VramMan.h>
#include <nnsys/gfd/VramManager/gfd_PlttVramMan_Types.h>
static NNSGfdPlttKey AllocPlttVram_(u32 szByte, BOOL b4Pltt, u32 bAllocFromLo);
static int FreePlttVram_(NNSGfdPlttKey key);
NNSGfdFuncAllocPlttVram NNS_GfdDefaultFuncAllocPlttVram = AllocPlttVram_;
NNSGfdFuncFreePlttVram NNS_GfdDefaultFuncFreePlttVram = FreePlttVram_;
static NNSGfdPlttKey AllocPlttVram_ (u32, BOOL, u32) {
NNS_GFD_WARNING("no default AllocPlttVram function.");
return NNS_GFD_ALLOC_ERROR_PLTTKEY;
}
static int FreePlttVram_ (NNSGfdPlttKey) {
NNS_GFD_WARNING("no default FreePlttVram function.");
return -1;
}

19
lib/NitroSystem/src/gfd/gfd_TexVramMan.c Normal file
View File

@ -0,0 +1,19 @@
#include <nnsys/gfd/VramManager/gfd_VramMan.h>
#include <nnsys/gfd/VramManager/gfd_TexVramMan_Types.h>
static NNSGfdTexKey AllocTexVram_(u32 szByte, BOOL is4x4comp, u32 opt);
static int FreeTexVram_(NNSGfdTexKey memKey);
NNSGfdFuncAllocTexVram NNS_GfdDefaultFuncAllocTexVram = AllocTexVram_;
NNSGfdFuncFreeTexVram NNS_GfdDefaultFuncFreeTexVram = FreeTexVram_;
static NNSGfdTexKey AllocTexVram_ (u32, BOOL, u32) {
NNS_GFD_WARNING("no default AllocTexVram function.");
return NNS_GFD_ALLOC_ERROR_TEXKEY;
}
static int FreeTexVram_ (NNSGfdTexKey) {
NNS_GFD_WARNING("no default FreeTexVram function.");
return -1;
}

327
lib/NitroSystem/src/gfd/gfd_VramTransferManager.c Normal file
View File

@ -0,0 +1,327 @@
#include <nnsys/gfd/VramTransferMan/gfd_VramTransferManager.h>
static NNSGfdVramTransferManager s_VramTransferManager;
typedef void (* TransferFunc)(const void *, u32, u32);
static u16 GetNextIndex_ (const NNSGfdVramTransferTaskQueue * pQueue, u16 idx) {
return (u16)((idx + 1) % pQueue->lengthOfArray);
}
static BOOL IsVramTransferTaskQueueFull_ (const NNSGfdVramTransferTaskQueue * pQueue) {
return (pQueue->numTasks == pQueue->lengthOfArray) ? TRUE: FALSE;
}
static BOOL IsVramTransferTaskQueueEmpty_ (const NNSGfdVramTransferTaskQueue * pQueue) {
return (pQueue->numTasks == 0) ? TRUE: FALSE;
}
static void DoTransfer3dTex (const void * pSrc, u32 offset, u32 szByte) {
GX_BeginLoadTex();
GX_LoadTex(pSrc, offset, szByte);
GX_EndLoadTex();
}
static void DoTransfer3dTexPltt (const void * pSrc, u32 offset, u32 szByte) {
GX_BeginLoadTexPltt();
GX_LoadTexPltt(pSrc, offset, szByte);
GX_EndLoadTexPltt();
}
static void DoTransfer3dClearImageColor (const void * pSrc, u32, u32 szByte) {
GX_BeginLoadClearImage();
GX_LoadClearImageColor(pSrc, szByte);
GX_EndLoadClearImage();
}
static void DoTransfer3dClearImageDepth (const void * pSrc, u32, u32 szByte) {
GX_BeginLoadClearImage();
GX_LoadClearImageDepth(pSrc, szByte);
GX_EndLoadClearImage();
}
static void DoTransfer2dBG0CharMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG0Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG1CharMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG1Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG2CharMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG2Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG3CharMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG3Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG0ScrMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG0Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG1ScrMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG1Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG2ScrMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG2Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG3ScrMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG3Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG2BmpMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG2Bmp(pSrc, offset, szByte);
}
static void DoTransfer2dBG3BmpMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBG3Bmp(pSrc, offset, szByte);
}
static void DoTransfer2dObjPlttMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadOBJPltt(pSrc, offset, szByte);
}
static void DoTransfer2dBGPlttMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadBGPltt(pSrc, offset, szByte);
}
static void DoTransfer2dObjExtPlttMain (const void * pSrc, u32 offset, u32 szByte) {
GX_BeginLoadOBJExtPltt();
GX_LoadOBJExtPltt(pSrc, offset, szByte);
GX_EndLoadOBJExtPltt();
}
static void DoTransfer2dBGExtPlttMain (const void * pSrc, u32 offset, u32 szByte) {
GX_BeginLoadBGExtPltt();
GX_LoadBGExtPltt(pSrc, offset, szByte);
GX_EndLoadBGExtPltt();
}
static void DoTransfer2dObjOamMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadOAM(pSrc, offset, szByte);
}
static void DoTransfer2dObjCharMain (const void * pSrc, u32 offset, u32 szByte) {
GX_LoadOBJ(pSrc, offset, szByte);
}
static void DoTransfer2dBG0CharSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG0Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG1CharSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG1Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG2CharSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG2Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG3CharSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG3Char(pSrc, offset, szByte);
}
static void DoTransfer2dBG0ScrSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG0Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG1ScrSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG1Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG2ScrSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG2Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG3ScrSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG3Scr(pSrc, offset, szByte);
}
static void DoTransfer2dBG2BmpSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG2Bmp(pSrc, offset, szByte);
}
static void DoTransfer2dBG3BmpSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBG3Bmp(pSrc, offset, szByte);
}
static void DoTransfer2dObjPlttSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadOBJPltt(pSrc, offset, szByte);
}
static void DoTransfer2dBGPlttSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadBGPltt(pSrc, offset, szByte);
}
static void DoTransfer2dObjExtPlttSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_BeginLoadOBJExtPltt();
GXS_LoadOBJExtPltt(pSrc, offset, szByte);
GXS_EndLoadOBJExtPltt();
}
static void DoTransfer2dBGExtPlttSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_BeginLoadBGExtPltt();
GXS_LoadBGExtPltt(pSrc, offset, szByte);
GXS_EndLoadBGExtPltt();
}
static void DoTransfer2dObjOamSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadOAM(pSrc, offset, szByte);
}
static void DoTransfer2dObjCharSub (const void * pSrc, u32 offset, u32 szByte) {
GXS_LoadOBJ(pSrc, offset, szByte);
}
static void DoTransfer_ (const NNSGfdVramTransferTask * pTask) {
const static TransferFunc transFunc[NNS_GFD_DST_MAX] = {
DoTransfer3dTex,
DoTransfer3dTexPltt,
DoTransfer3dClearImageColor,
DoTransfer3dClearImageDepth,
DoTransfer2dBG0CharMain,
DoTransfer2dBG1CharMain,
DoTransfer2dBG2CharMain,
DoTransfer2dBG3CharMain,
DoTransfer2dBG0ScrMain,
DoTransfer2dBG1ScrMain,
DoTransfer2dBG2ScrMain,
DoTransfer2dBG3ScrMain,
DoTransfer2dBG2BmpMain,
DoTransfer2dBG3BmpMain,
DoTransfer2dObjPlttMain,
DoTransfer2dBGPlttMain,
DoTransfer2dObjExtPlttMain,
DoTransfer2dBGExtPlttMain,
DoTransfer2dObjOamMain,
DoTransfer2dObjCharMain,
DoTransfer2dBG0CharSub,
DoTransfer2dBG1CharSub,
DoTransfer2dBG2CharSub,
DoTransfer2dBG3CharSub,
DoTransfer2dBG0ScrSub,
DoTransfer2dBG1ScrSub,
DoTransfer2dBG2ScrSub,
DoTransfer2dBG3ScrSub,
DoTransfer2dBG2BmpSub,
DoTransfer2dBG3BmpSub,
DoTransfer2dObjPlttSub,
DoTransfer2dBGPlttSub,
DoTransfer2dObjExtPlttSub,
DoTransfer2dBGExtPlttSub,
DoTransfer2dObjOamSub,
DoTransfer2dObjCharSub,
};
TransferFunc doTransfer;
NNS_GFD_NULL_ASSERT(pTask);
SDK_MINMAX_ASSERT(pTask->type, 0, NNS_GFD_DST_MAX - 1);
doTransfer = transFunc[pTask->type];
DC_FlushRange(pTask->pSrc, pTask->szByte);
doTransfer(pTask->pSrc, pTask->dstAddr, pTask->szByte);
}
static void ResetTaskQueue_ (NNSGfdVramTransferTaskQueue * pQueue) {
NNS_GFD_NULL_ASSERT(pQueue);
pQueue->idxFront = pQueue->idxRear = 0;
pQueue->numTasks = 0;
pQueue->totalSize = 0;
}
BOOL NNSi_GfdPushVramTransferTaskQueue (NNSGfdVramTransferTaskQueue * pQueue) {
NNS_GFD_NULL_ASSERT(pQueue);
if (!IsVramTransferTaskQueueFull_(pQueue)) {
pQueue->idxRear = GetNextIndex_(pQueue, pQueue->idxRear);
pQueue->numTasks++;
return TRUE;
} else {
return FALSE;
}
}
NNSGfdVramTransferTask * NNSi_GfdGetFrontVramTransferTaskQueue (NNSGfdVramTransferTaskQueue * pQueue) {
NNS_GFD_NULL_ASSERT(pQueue);
return &pQueue->pTaskArray[pQueue->idxFront];
}
NNSGfdVramTransferTask * NNSi_GfdGetEndVramTransferTaskQueue (NNSGfdVramTransferTaskQueue * pQueue) {
NNS_GFD_NULL_ASSERT(pQueue);
return &pQueue->pTaskArray[pQueue->idxRear];
}
BOOL NNSi_GfdPopVramTransferTaskQueue (NNSGfdVramTransferTaskQueue * pQueue) {
NNS_GFD_NULL_ASSERT(pQueue);
if (!IsVramTransferTaskQueueEmpty_(pQueue)) {
pQueue->idxFront = GetNextIndex_(pQueue, pQueue->idxFront);
pQueue->numTasks--;
return TRUE;
} else {
return FALSE;
}
}
void NNS_GfdInitVramTransferManager (NNSGfdVramTransferTask * pTaskArray, u32 lengthOfArray) {
NNS_GFD_NULL_ASSERT(pTaskArray);
NNS_GFD_NON_ZERO_ASSERT(lengthOfArray);
{
NNSGfdVramTransferManager * pMan = &s_VramTransferManager;
pMan->taskQueue.pTaskArray = pTaskArray;
pMan->taskQueue.lengthOfArray = lengthOfArray;
ResetTaskQueue_(&pMan->taskQueue);
}
}
void NNS_GfdClearVramTransferManagerTask ( ) {
ResetTaskQueue_(&s_VramTransferManager.taskQueue);
}
void NNS_GfdDoVramTransfer ( ) {
NNSGfdVramTransferManager * pMan = &s_VramTransferManager;
NNSGfdVramTransferTask * pTask
= NNSi_GfdGetFrontVramTransferTaskQueue(&pMan->taskQueue);
while (NNSi_GfdPopVramTransferTaskQueue(&pMan->taskQueue)) {
DoTransfer_(pTask);
pMan->taskQueue.totalSize -= pTask->szByte;
pTask = NNSi_GfdGetFrontVramTransferTaskQueue(&pMan->taskQueue);
}
}
BOOL NNS_GfdRegisterNewVramTransferTask (NNS_GFD_DST_TYPE type, u32 dstAddr, void * pSrc, u32 szByte) {
NNSGfdVramTransferManager * pMan = &s_VramTransferManager;
if (!IsVramTransferTaskQueueFull_(&pMan->taskQueue)) {
NNSGfdVramTransferTask * pTask =
NNSi_GfdGetEndVramTransferTaskQueue(&pMan->taskQueue);
pTask->type = type;
pTask->pSrc = pSrc;
pTask->dstAddr = dstAddr;
pTask->szByte = szByte;
(void)NNSi_GfdPushVramTransferTaskQueue(&pMan->taskQueue);
pMan->taskQueue.totalSize += pTask->szByte;
return TRUE;
}
return FALSE;
}
u32 NNS_GfdGetVramTransferTaskTotalSize () {
return s_VramTransferManager.taskQueue.totalSize;
}

322
lib/NitroSystem/src/gfd/gfdi_LinkedListVramMan_Common.c Normal file
View File

@ -0,0 +1,322 @@
#include <nnsys/gfd/gfd_common.h>
#include "include/gfdi_LinkedListVramMan_Common.h"
static NNS_GFD_INLINE void GetRegionOfMemBlock_ (NNSiGfdLnkMemRegion * pRegion, const NNSiGfdLnkVramBlock * pBlk) {
NNS_GFD_NULL_ASSERT(pBlk);
NNS_GFD_NON_ZERO_ASSERT(pBlk->szByte);
pRegion->start = pBlk->addr;
pRegion->end = pBlk->addr + pBlk->szByte;
NNS_GFD_ASSERT(pRegion->end > pRegion->start);
}
static NNS_GFD_INLINE void InitBlockFromRegion_ (NNSiGfdLnkVramBlock * pBlk, const NNSiGfdLnkMemRegion * pRegion) {
NNS_GFD_NULL_ASSERT(pBlk);
NNS_GFD_ASSERT(pRegion->end > pRegion->start);
pBlk->addr = pRegion->start;
pBlk->szByte = (u32)(pRegion->end - pRegion->start);
pBlk->pBlkPrev = NULL;
pBlk->pBlkNext = NULL;
}
static NNS_GFD_INLINE void InitBlockFromPrams_ (NNSiGfdLnkVramBlock * pBlk, u32 addr, u32 szByte) {
NNS_GFD_NULL_ASSERT(pBlk);
NNS_GFD_NON_ZERO_ASSERT(szByte);
pBlk->addr = addr;
pBlk->szByte = szByte;
pBlk->pBlkPrev = NULL;
pBlk->pBlkNext = NULL;
}
static NNS_GFD_INLINE void InsertBlock_ (NNSiGfdLnkVramBlock * * pListHead, NNSiGfdLnkVramBlock * prev) {
NNS_GFD_NULL_ASSERT(prev);
if ((*pListHead) != NULL) {
(*pListHead)->pBlkPrev = prev;
}
prev->pBlkNext = *pListHead;
prev->pBlkPrev = NULL;
*pListHead = prev;
}
static NNS_GFD_INLINE void RemoveBlock_ (NNSiGfdLnkVramBlock * * pListHead, NNSiGfdLnkVramBlock * pBlk) {
NNS_GFD_NULL_ASSERT(pBlk);
{
NNSiGfdLnkVramBlock * const pPrev = pBlk->pBlkPrev;
NNSiGfdLnkVramBlock * const pNext = pBlk->pBlkNext;
if (pPrev) {
pPrev->pBlkNext = pNext;
} else {
*pListHead = pNext;
}
if (pNext) {
pNext->pBlkPrev = pPrev;
}
}
}
static NNS_GFD_INLINE NNSiGfdLnkVramBlock * GetNewBlock_ (NNSiGfdLnkVramBlock * * ppBlockPoolList) {
NNS_GFD_NULL_ASSERT(ppBlockPoolList);
{
NNSiGfdLnkVramBlock * pNew = *ppBlockPoolList;
if (pNew) {
*ppBlockPoolList = pNew->pBlkNext;
}
return pNew;
}
}
static NNS_GFD_INLINE u32 GetBlockEndAddr_ (NNSiGfdLnkVramBlock * pBlk) {
NNS_GFD_NULL_ASSERT(pBlk);
return (u32)(pBlk->addr + pBlk->szByte);
}
static void DefaultDumpCallBack_ (u32 addr, u32 szByte, void * pUserData) {
#ifdef SDK_FINALROM
#pragma unused(addr)
#endif
if (szByte != 0) {
u32 * pszFreeTotal = (u32 *)pUserData;
OS_Printf("0x%08x: 0x%08x \n", addr, szByte);
(*pszFreeTotal) += szByte;
}
}
static BOOL TryToMergeBlockRegion_ (NNSiGfdLnkVramMan * pMan, NNSiGfdLnkVramBlock * * ppBlockPoolList, NNSiGfdLnkMemRegion * pRegion) {
NNS_GFD_NULL_ASSERT(pMan);
NNS_GFD_NULL_ASSERT(ppBlockPoolList);
NNS_GFD_NULL_ASSERT(pRegion);
{
NNSiGfdLnkVramBlock * pCursor = pMan->pFreeList;
NNSiGfdLnkVramBlock * pNext = NULL;
BOOL bMerged = FALSE;
while (pCursor) {
pNext = pCursor->pBlkNext;
if (pCursor->addr == pRegion->end) {
pRegion->end = GetBlockEndAddr_(pCursor);
RemoveBlock_(&pMan->pFreeList, pCursor);
InsertBlock_(ppBlockPoolList, pCursor);
bMerged |= TRUE;
}
if (GetBlockEndAddr_(pCursor) == pRegion->start) {
pRegion->start = pCursor->addr;
RemoveBlock_(&pMan->pFreeList, pCursor);
InsertBlock_(ppBlockPoolList, pCursor);
bMerged |= TRUE;
}
pCursor = pNext;
}
return bMerged;
}
}
void NNSi_GfdDumpLnkVramManFreeListInfo (const NNSiGfdLnkVramBlock * pFreeListHead, u32 szReserved) {
u32 szFreeTotal = 0;
const NNSiGfdLnkVramBlock * pBlk = pFreeListHead;
NNSi_GfdDumpLnkVramManFreeListInfoEx(pBlk, DefaultDumpCallBack_, &szFreeTotal);
if (szFreeTotal == 0) {
OS_Printf("0x--------: 0x-------- \n");
}
{
const u32 szUsedTotal = (szReserved - szFreeTotal);
OS_Printf(
" %08d / %08d bytes (%6.2f%%) used \n",
szUsedTotal, szReserved, 100.f * szUsedTotal / szReserved
);
}
}
void NNSi_GfdDumpLnkVramManFreeListInfoEx (const NNSiGfdLnkVramBlock * pFreeListHead, NNSGfdLnkDumpCallBack pFunc, void * pUserData) {
const NNSiGfdLnkVramBlock * pBlk = pFreeListHead;
NNS_GFD_NULL_ASSERT(pFunc);
while (pBlk) {
(*pFunc)(pBlk->addr, pBlk->szByte, pUserData);
pBlk = pBlk->pBlkNext;
}
}
void NNSi_GfdInitLnkVramMan (NNSiGfdLnkVramMan * pMgr) {
NNS_GFD_NULL_ASSERT(pMgr);
pMgr->pFreeList = NULL;
}
NNSiGfdLnkVramBlock * NNSi_GfdInitLnkVramBlockPool (NNSiGfdLnkVramBlock * pArrayHead, u32 lengthOfArray) {
NNS_GFD_NULL_ASSERT(pArrayHead);
NNS_GFD_NON_ZERO_ASSERT(lengthOfArray);
{
int i;
for ( i = 0; i < lengthOfArray - 1; i++ ) {
pArrayHead[i].pBlkNext = &pArrayHead[i + 1];
pArrayHead[i + 1].pBlkPrev = &pArrayHead[i];
}
pArrayHead[0].pBlkPrev = NULL;
pArrayHead[lengthOfArray - 1].pBlkNext = NULL;
}
return &pArrayHead[0];
}
BOOL NNSi_GfdAddNewFreeBlock (NNSiGfdLnkVramMan * pMan, NNSiGfdLnkVramBlock * * ppBlockPoolList, u32 baseAddr, u32 szByte) {
NNS_GFD_NULL_ASSERT(pMan);
NNS_GFD_NULL_ASSERT(ppBlockPoolList);
NNS_GFD_NON_ZERO_ASSERT(szByte);
{
NNSiGfdLnkVramBlock * pNew = GetNewBlock_(ppBlockPoolList);
if (pNew) {
InitBlockFromPrams_(pNew, baseAddr, szByte);
InsertBlock_(&pMan->pFreeList, pNew);
return TRUE;
} else {
return FALSE;
}
}
}
BOOL NNSi_GfdAllocLnkVram (NNSiGfdLnkVramMan * pMan, NNSiGfdLnkVramBlock * * ppBlockPoolList, u32 * pRetAddr, u32 szByte) {
return NNSi_GfdAllocLnkVramAligned(pMan, ppBlockPoolList, pRetAddr, szByte, 0);
}
BOOL NNSi_GfdAllocLnkVramAligned (NNSiGfdLnkVramMan * pMan, NNSiGfdLnkVramBlock * * ppBlockPoolList, u32 * pRetAddr, u32 szByte, u32 alignment) {
NNS_GFD_NULL_ASSERT(pMan);
NNS_GFD_NULL_ASSERT(pRetAddr);
NNS_GFD_NON_ZERO_ASSERT(szByte);
{
u32 alignedAddr;
u32 szNeeded;
u32 difference;
NNSiGfdLnkVramBlock * pBlkFound = NULL;
NNSiGfdLnkVramBlock * pBlk = pMan->pFreeList;
while (pBlk) {
if (alignment > 1) {
alignedAddr = (u32)((pBlk->addr + (alignment - 1)) & ~(alignment - 1));
difference = (alignedAddr - pBlk->addr);
szNeeded = szByte + difference;
} else {
alignedAddr = pBlk->addr;
difference = 0;
szNeeded = szByte;
}
if (pBlk->szByte >= szNeeded) {
pBlkFound = pBlk;
break;
}
pBlk = pBlk->pBlkNext;
}
if (pBlkFound) {
if (difference > 0) {
NNSiGfdLnkVramBlock * pNewFreeBlk = GetNewBlock_(ppBlockPoolList);
if (pNewFreeBlk) {
InitBlockFromPrams_(pNewFreeBlk, pBlkFound->addr, difference);
InsertBlock_(&pMan->pFreeList, pNewFreeBlk);
} else {
goto NG_CASE;
}
}
{
pBlkFound->szByte -= szNeeded;
pBlkFound->addr += szNeeded;
if (pBlkFound->szByte == 0) {
RemoveBlock_(&pMan->pFreeList, pBlkFound);
InsertBlock_(ppBlockPoolList, pBlkFound);
}
}
*pRetAddr = alignedAddr;
return TRUE;
}
NG_CASE:
*pRetAddr = 0;
return FALSE;
}
}
void NNSi_GfdMergeAllFreeBlocks (NNSiGfdLnkVramMan * pMan, NNSiGfdLnkVramBlock * * ppBlockPoolList) {
NNSiGfdLnkMemRegion region;
NNSiGfdLnkVramBlock * pCursor = pMan->pFreeList;
while (pCursor) {
region.start = pCursor->addr;
region.end = pCursor->addr + pCursor->szByte;
if (TryToMergeBlockRegion_(pMan, ppBlockPoolList, &region)) {
pCursor->addr = region.start;
pCursor->szByte = region.end - region.start;
pCursor = pMan->pFreeList;
} else {
pCursor = pCursor->pBlkNext;
}
}
}
BOOL NNSi_GfdFreeLnkVram (NNSiGfdLnkVramMan * pMan, NNSiGfdLnkVramBlock * * ppBlockPoolList, u32 addr, u32 szByte) {
NNS_GFD_NULL_ASSERT(pMan);
NNS_GFD_NON_ZERO_ASSERT(szByte);
{
{
NNSiGfdLnkMemRegion region;
region.start = addr;
region.end = addr + szByte;
NNS_GFD_NULL_ASSERT(pMan);
NNS_GFD_NULL_ASSERT(ppBlockPoolList);
{
(void)TryToMergeBlockRegion_(pMan, ppBlockPoolList, &region);
{
NNSiGfdLnkVramBlock * pNewFreeBlk = GetNewBlock_(ppBlockPoolList);
if (pNewFreeBlk == NULL) {
return FALSE;
} else {
InitBlockFromRegion_(pNewFreeBlk, &region);
InsertBlock_(&pMan->pFreeList, pNewFreeBlk);
}
}
return TRUE;
}
}
}
}

87
lib/NitroSystem/src/gfd/include/gfdi_LinkedListVramMan_Common.h Normal file
View File

@ -0,0 +1,87 @@
#ifndef NNS_GFDI_LINKEDLISTVRAMMAN_COMMON_H_
#define NNS_GFDI_LINKEDLISTVRAMMAN_COMMON_H_
#include <nnsys/gfd.h>
typedef struct NNSiGfdLnkVramBlock NNSiGfdLnkVramBlock;
struct NNSiGfdLnkVramBlock {
u32 addr;
u32 szByte;
NNSiGfdLnkVramBlock * pBlkPrev;
NNSiGfdLnkVramBlock * pBlkNext;
};
typedef struct NNSiGfdLnkMemRegion {
u32 start;
u32 end;
} NNSiGfdLnkMemRegion;
typedef struct NNSiGfdLnkVramMan {
NNSiGfdLnkVramBlock * pFreeList;
} NNSiGfdLnkVramMan;
void NNSi_GfdDumpLnkVramManFreeListInfo
(
const NNSiGfdLnkVramBlock * pFreeListHead,
u32 szReserved
);
void NNSi_GfdDumpLnkVramManFreeListInfoEx(
const NNSiGfdLnkVramBlock * pFreeListHead,
NNSGfdLnkDumpCallBack pFunc,
void * pUserData);
void
NNSi_GfdInitLnkVramMan(NNSiGfdLnkVramMan * pMgr);
NNSiGfdLnkVramBlock *
NNSi_GfdInitLnkVramBlockPool
(
NNSiGfdLnkVramBlock * pArrayHead,
u32 lengthOfArray
);
BOOL
NNSi_GfdAddNewFreeBlock
(
NNSiGfdLnkVramMan * pMan,
NNSiGfdLnkVramBlock ** ppBlockPoolList,
u32 baseAddr,
u32 szByte
);
BOOL
NNSi_GfdAllocLnkVram
(
NNSiGfdLnkVramMan * pMan,
NNSiGfdLnkVramBlock ** ppBlockPoolList,
u32 * pRetAddr,
u32 szByte
);
BOOL
NNSi_GfdAllocLnkVramAligned
(
NNSiGfdLnkVramMan * pMan,
NNSiGfdLnkVramBlock ** ppBlockPoolList,
u32 * pRetAddr,
u32 szByte,
u32 alignment
);
void NNSi_GfdMergeAllFreeBlocks(
NNSiGfdLnkVramMan * pMan,
NNSiGfdLnkVramBlock ** ppBlockPoolList
);
BOOL NNSi_GfdFreeLnkVram
(
NNSiGfdLnkVramMan * pMan,
NNSiGfdLnkVramBlock ** ppBlockPoolList,
u32 addr,
u32 szByte
);
#endif

16
main.lsf
View File

@ -385,14 +385,14 @@ Static main
Object lib/NitroSystem/src/fnd/frameheap.o
Object lib/NitroSystem/src/fnd/unitheap.o
Object lib/NitroSystem/src/fnd/allocator.o
Object lib/NitroSystem/asm/gfd/gfd_texvramman.o
Object lib/NitroSystem/asm/gfd/gfd_plttvramman.o
Object lib/NitroSystem/asm/gfd/gfd_frametexvramman.o
Object lib/NitroSystem/asm/gfd/gfd_frameplttvramman.o
Object lib/NitroSystem/asm/gfd/gfd_vramtransfermanager.o
Object lib/NitroSystem/asm/gfd/gfdi_linkedlistvramman.o
Object lib/NitroSystem/asm/gfd/gfd_linkedlisttexvramman.o
Object lib/NitroSystem/asm/gfd/gfd_linkedlistplttvramman.o
Object lib/NitroSystem/src/gfd/gfd_TexVramMan.o
Object lib/NitroSystem/src/gfd/gfd_PlttVramMan.o
Object lib/NitroSystem/src/gfd/gfd_FrameTexVramMan.o
Object lib/NitroSystem/src/gfd/gfd_FramePlttVramMan.o
Object lib/NitroSystem/src/gfd/gfd_VramTransferManager.o
Object lib/NitroSystem/src/gfd/gfdi_LinkedListVramMan_Common.o
Object lib/NitroSystem/src/gfd/gfd_LinkedListTexVramMan.o
Object lib/NitroSystem/src/gfd/gfd_LinkedListPlttVramMan.o
Object lib/NitroSystem/asm/g2d/g2d_nan_load.o
Object lib/NitroSystem/asm/g2d/g2d_nob_load.o
Object lib/NitroSystem/asm/g2d/g2d_nmc_load.o