From 030a8a12905e020f078e5d087f66683ff3dbe49b Mon Sep 17 00:00:00 2001 From: Jon Lin Date: Tue, 17 May 2022 18:11:25 +0800 Subject: [PATCH] rkflash: Add clang compile version Change-Id: I04cadb7734604cb63460af465462f192bb67d5b5 Signed-off-by: Jon Lin --- drivers/rkflash/Makefile | 11 + drivers/rkflash/rk_sftl_arm_v8_clang.S | 22650 +++++++++++++++++++++++ 2 files changed, 22661 insertions(+) create mode 100644 drivers/rkflash/rk_sftl_arm_v8_clang.S diff --git a/drivers/rkflash/Makefile b/drivers/rkflash/Makefile index f59991e5e933..319656b66ef0 100644 --- a/drivers/rkflash/Makefile +++ b/drivers/rkflash/Makefile @@ -8,9 +8,20 @@ obj-$(CONFIG_RK_SFC_NOR_MTD) += sfc_nor_mtd.o obj-$(CONFIG_RK_SFTL) += rksftl.o +ifdef CONFIG_CC_IS_CLANG +ifdef CONFIG_THUMB2_KERNEL +rksftl-$(CONFIG_THUMB2_KERNEL) += rk_sftl_arm_v7_thumb.o +else +rksftl-$(CONFIG_ARM64) += rk_sftl_arm_v8_clang.o +rksftl-$(CONFIG_ARM) += rk_sftl_arm_v7.o +endif + +else + ifdef CONFIG_THUMB2_KERNEL rksftl-$(CONFIG_THUMB2_KERNEL) += rk_sftl_arm_v7_thumb.o else rksftl-$(CONFIG_ARM64) += rk_sftl_arm_v8.o rksftl-$(CONFIG_ARM) += rk_sftl_arm_v7.o endif +endif diff --git a/drivers/rkflash/rk_sftl_arm_v8_clang.S b/drivers/rkflash/rk_sftl_arm_v8_clang.S new file mode 100644 index 000000000000..3cb18a673dd5 --- /dev/null +++ b/drivers/rkflash/rk_sftl_arm_v8_clang.S @@ -0,0 +1,22650 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +/* Copyright (c) 2018-2021 Rockchip Electronics Co. Ltd. + * date: 2022-05-18 + */ + .text + .section .note.gnu.property,"a",@note + .p2align 3 + .word 4 + .word 16 + .word 5 + .asciz "GNU" + .word 3221225472 + .word 4 + .word 3 + .word 0 +.Lsec_end0: + .text + .file "rk_sftl.c" + .globl ftl_print_sblk_info // -- Begin function ftl_print_sblk_info + .p2align 2 + .type ftl_print_sblk_info,@function +ftl_print_sblk_info: // @ftl_print_sblk_info +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x0, .L.str + adrp x1, .L.str.1 + add x0, x0, :lo12:.L.str + add x1, x1, :lo12:.L.str.1 + str x19, [sp, #16] // 8-byte Folded Spill + mov x29, sp + bl sftl_printk + adrp x8, g_active_superblock + add x8, x8, :lo12:g_active_superblock + adrp x19, p_valid_page_count_table + ldrh w1, [x8] + ldr x9, [x19, :lo12:p_valid_page_count_table] + ldrh w2, [x8, #2] + ldrb w3, [x8, #6] + ldrb w4, [x8, #8] + ldrh w5, [x8, #4] + ldrh w6, [x9, x1, lsl #1] + adrp x0, .L.str.2 + add x0, x0, :lo12:.L.str.2 + // kill: def $w1 killed $w1 killed $x1 + bl sftl_printk + adrp x8, g_buffer_superblock + add x8, x8, :lo12:g_buffer_superblock + ldrh w1, [x8] + ldr x9, [x19, :lo12:p_valid_page_count_table] + ldrh w2, [x8, #2] + ldrb w3, [x8, #6] + ldrb w4, [x8, #8] + ldrh w5, [x8, #4] + ldrh w6, [x9, x1, lsl #1] + adrp x0, .L.str.3 + add x0, x0, :lo12:.L.str.3 + // kill: def $w1 killed $w1 killed $x1 + bl sftl_printk + adrp x8, g_gc_temp_superblock + add x8, x8, :lo12:g_gc_temp_superblock + ldrh w1, [x8] + ldr x9, [x19, :lo12:p_valid_page_count_table] + ldrh w2, [x8, #2] + ldrb w3, [x8, #6] + ldrb w4, [x8, #8] + ldrh w5, [x8, #4] + ldrh w6, [x9, x1, lsl #1] + adrp x0, .L.str.4 + add x0, x0, :lo12:.L.str.4 + // kill: def $w1 killed $w1 killed $x1 + bl sftl_printk + adrp x8, g_gc_superblock + add x8, x8, :lo12:g_gc_superblock + ldrh w1, [x8] + ldr x9, [x19, :lo12:p_valid_page_count_table] + ldrh w2, [x8, #2] + ldrb w3, [x8, #6] + ldrb w4, [x8, #8] + ldrh w5, [x8, #4] + ldrh w6, [x9, x1, lsl #1] + adrp x0, .L.str.5 + add x0, x0, :lo12:.L.str.5 + // kill: def $w1 killed $w1 killed $x1 + bl sftl_printk + adrp x8, g_num_free_superblocks + adrp x9, g_gc_next_blk + adrp x10, g_gc_next_blk_1 + ldrh w1, [x8, :lo12:g_num_free_superblocks] + ldrh w2, [x9, :lo12:g_gc_next_blk] + ldrh w3, [x10, :lo12:g_gc_next_blk_1] + adrp x0, .L.str.6 + add x0, x0, :lo12:.L.str.6 + bl sftl_printk + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end0: + .size ftl_print_sblk_info, .Lfunc_end0-ftl_print_sblk_info + // -- End function + .globl FtlPrintInfo2buf // -- Begin function FtlPrintInfo2buf + .p2align 2 + .type FtlPrintInfo2buf,@function +FtlPrintInfo2buf: // @FtlPrintInfo2buf +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + adrp x8, .L.str.7 + add x8, x8, :lo12:.L.str.7 + ldur x9, [x8, #5] + ldr x8, [x8] + stp x20, x19, [sp, #80] // 16-byte Folded Spill + add x20, x0, #12 // =12 + stur x9, [x0, #5] + str x8, [x0] + adrp x8, DeviceCapacity + ldr w3, [x8, :lo12:DeviceCapacity] + adrp x2, .L.str.8 + mov x19, x0 + add x2, x2, :lo12:.L.str.8 + mov w1, #64 + mov x0, x20 + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + mov x29, sp + bl snprintf + adrp x8, .L.str.9 + add x8, x8, :lo12:.L.str.9 + ldr x8, [x8] + mov w10, #14927 + add x9, x20, w0, sxtw + movk w10, #10, lsl #16 + str x8, [x9] + stur w10, [x9, #7] + adrp x8, g_MaxLpn + ldr w3, [x8, :lo12:g_MaxLpn] + add x20, x9, #10 // =10 + adrp x2, .L.str.10 + add x2, x2, :lo12:.L.str.10 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_VaildLpn + ldr w3, [x8, :lo12:g_VaildLpn] + add x20, x20, w0, sxtw + adrp x2, .L.str.11 + add x2, x2, :lo12:.L.str.11 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_read_page_count + ldr w3, [x8, :lo12:g_totle_read_page_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.12 + add x2, x2, :lo12:.L.str.12 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_discard_page_count + ldr w3, [x8, :lo12:g_totle_discard_page_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.13 + add x2, x2, :lo12:.L.str.13 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_write_page_count + ldr w3, [x8, :lo12:g_totle_write_page_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.14 + add x2, x2, :lo12:.L.str.14 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_cache_write_count + ldr w3, [x8, :lo12:g_totle_cache_write_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.15 + add x2, x2, :lo12:.L.str.15 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_l2p_write_count + ldr w3, [x8, :lo12:g_totle_l2p_write_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.16 + add x2, x2, :lo12:.L.str.16 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_gc_page_count + ldr w3, [x8, :lo12:g_totle_gc_page_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.17 + add x2, x2, :lo12:.L.str.17 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_write_sector + ldr w8, [x8, :lo12:g_totle_write_sector] + add x20, x20, w0, sxtw + adrp x2, .L.str.18 + add x2, x2, :lo12:.L.str.18 + lsr w3, w8, #11 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_read_sector + ldr w8, [x8, :lo12:g_totle_read_sector] + add x20, x20, w0, sxtw + adrp x2, .L.str.19 + add x2, x2, :lo12:.L.str.19 + lsr w3, w8, #11 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_GlobalSysVersion + ldr w3, [x8, :lo12:g_GlobalSysVersion] + add x20, x20, w0, sxtw + adrp x2, .L.str.20 + add x2, x2, :lo12:.L.str.20 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_GlobalDataVersion + ldr w3, [x8, :lo12:g_GlobalDataVersion] + add x20, x20, w0, sxtw + adrp x2, .L.str.21 + add x2, x2, :lo12:.L.str.21 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x22, gBbtInfo + add x22, x22, :lo12:gBbtInfo + ldrh w3, [x22, #6] + add x20, x20, w0, sxtw + adrp x2, .L.str.22 + add x2, x2, :lo12:.L.str.22 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x21, g_num_free_superblocks + ldrh w3, [x21, :lo12:g_num_free_superblocks] + add x20, x20, w0, sxtw + adrp x2, .L.str.23 + add x2, x2, :lo12:.L.str.23 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_mlc_erase_count + ldr w3, [x8, :lo12:g_totle_mlc_erase_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.24 + add x2, x2, :lo12:.L.str.24 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_slc_erase_count + ldr w3, [x8, :lo12:g_totle_slc_erase_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.25 + add x2, x2, :lo12:.L.str.25 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_avg_erase_count + ldr w3, [x8, :lo12:g_totle_avg_erase_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.26 + add x2, x2, :lo12:.L.str.26 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_totle_sys_slc_erase_count + ldr w3, [x8, :lo12:g_totle_sys_slc_erase_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.27 + add x2, x2, :lo12:.L.str.27 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_max_erase_count + ldr w3, [x8, :lo12:g_max_erase_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.28 + add x2, x2, :lo12:.L.str.28 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_min_erase_count + ldr w3, [x8, :lo12:g_min_erase_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.29 + add x2, x2, :lo12:.L.str.29 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x23, g_sys_save_data+28 + add x23, x23, :lo12:g_sys_save_data+28 + ldrh w3, [x23, #2] + add x20, x20, w0, sxtw + adrp x2, .L.str.30 + add x2, x2, :lo12:.L.str.30 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x23] + add x20, x20, w0, sxtw + adrp x2, .L.str.31 + add x2, x2, :lo12:.L.str.31 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_MaxLbaSector + ldr w3, [x8, :lo12:g_MaxLbaSector] + add x20, x20, w0, sxtw + adrp x2, .L.str.32 + add x2, x2, :lo12:.L.str.32 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, c_ftl_nand_init_sys_blks_per_plane + ldr w3, [x8, :lo12:c_ftl_nand_init_sys_blks_per_plane] + add x20, x20, w0, sxtw + adrp x2, .L.str.33 + add x2, x2, :lo12:.L.str.33 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, c_ftl_nand_sys_blks_per_plane + ldr w3, [x8, :lo12:c_ftl_nand_sys_blks_per_plane] + add x20, x20, w0, sxtw + adrp x2, .L.str.34 + add x2, x2, :lo12:.L.str.34 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, gSysFreeQueue+6 + ldrh w3, [x8, :lo12:gSysFreeQueue+6] + add x20, x20, w0, sxtw + adrp x2, .L.str.35 + add x2, x2, :lo12:.L.str.35 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, c_ftl_nand_data_blks_per_plane + ldrh w3, [x8, :lo12:c_ftl_nand_data_blks_per_plane] + add x20, x20, w0, sxtw + adrp x2, .L.str.36 + add x2, x2, :lo12:.L.str.36 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, c_ftl_nand_data_op_blks_per_plane + ldrh w3, [x8, :lo12:c_ftl_nand_data_op_blks_per_plane] + add x20, x20, w0, sxtw + adrp x2, .L.str.37 + add x2, x2, :lo12:.L.str.37 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, c_ftl_nand_max_data_blks + ldr w3, [x8, :lo12:c_ftl_nand_max_data_blks] + add x20, x20, w0, sxtw + adrp x2, .L.str.38 + add x2, x2, :lo12:.L.str.38 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, gSysInfo + ldrh w3, [x8, :lo12:gSysInfo] + add x20, x20, w0, sxtw + adrp x2, .L.str.39 + add x2, x2, :lo12:.L.str.39 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.40 + add x2, x2, :lo12:.L.str.40 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x22, g_active_superblock + add x22, x22, :lo12:g_active_superblock + ldrh w3, [x22, #2] + add x20, x20, w0, sxtw + adrp x2, .L.str.41 + add x2, x2, :lo12:.L.str.41 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #6] + add x20, x20, w0, sxtw + adrp x2, .L.str.42 + add x2, x2, :lo12:.L.str.42 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.43 + add x2, x2, :lo12:.L.str.43 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #8] + add x20, x20, w0, sxtw + adrp x2, .L.str.44 + add x2, x2, :lo12:.L.str.44 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22, #4] + add x20, x20, w0, sxtw + adrp x2, .L.str.45 + add x2, x2, :lo12:.L.str.45 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x23, p_valid_page_count_table + ldr x8, [x23, :lo12:p_valid_page_count_table] + ldrh w9, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.46 + add x2, x2, :lo12:.L.str.46 + ldrh w3, [x8, x9, lsl #1] + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x22, g_buffer_superblock + add x22, x22, :lo12:g_buffer_superblock + ldrh w3, [x22, #2] + add x20, x20, w0, sxtw + adrp x2, .L.str.47 + add x2, x2, :lo12:.L.str.47 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #6] + add x20, x20, w0, sxtw + adrp x2, .L.str.48 + add x2, x2, :lo12:.L.str.48 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.49 + add x2, x2, :lo12:.L.str.49 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #8] + add x20, x20, w0, sxtw + adrp x2, .L.str.50 + add x2, x2, :lo12:.L.str.50 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22, #4] + add x20, x20, w0, sxtw + adrp x2, .L.str.51 + add x2, x2, :lo12:.L.str.51 + mov w1, #64 + mov x0, x20 + bl snprintf + ldr x8, [x23, :lo12:p_valid_page_count_table] + ldrh w9, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.52 + add x2, x2, :lo12:.L.str.52 + ldrh w3, [x8, x9, lsl #1] + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x22, g_gc_temp_superblock + add x22, x22, :lo12:g_gc_temp_superblock + ldrh w3, [x22, #2] + add x20, x20, w0, sxtw + adrp x2, .L.str.53 + add x2, x2, :lo12:.L.str.53 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #6] + add x20, x20, w0, sxtw + adrp x2, .L.str.54 + add x2, x2, :lo12:.L.str.54 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.55 + add x2, x2, :lo12:.L.str.55 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #8] + add x20, x20, w0, sxtw + adrp x2, .L.str.56 + add x2, x2, :lo12:.L.str.56 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22, #4] + add x20, x20, w0, sxtw + adrp x2, .L.str.57 + add x2, x2, :lo12:.L.str.57 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x22, g_gc_superblock + add x22, x22, :lo12:g_gc_superblock + ldrh w3, [x22, #2] + add x20, x20, w0, sxtw + adrp x2, .L.str.58 + add x2, x2, :lo12:.L.str.58 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #6] + add x20, x20, w0, sxtw + adrp x2, .L.str.59 + add x2, x2, :lo12:.L.str.59 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.60 + add x2, x2, :lo12:.L.str.60 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrb w3, [x22, #8] + add x20, x20, w0, sxtw + adrp x2, .L.str.61 + add x2, x2, :lo12:.L.str.61 + mov w1, #64 + mov x0, x20 + bl snprintf + ldrh w3, [x22, #4] + add x20, x20, w0, sxtw + adrp x2, .L.str.62 + add x2, x2, :lo12:.L.str.62 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x22, g_sys_ext_data+72 + add x22, x22, :lo12:g_sys_ext_data+72 + ldp w3, w4, [x22, #8] + ldr w5, [x22, #4] + add x20, x20, w0, sxtw + adrp x2, .L.str.63 + add x2, x2, :lo12:.L.str.63 + mov w1, #64 + mov x0, x20 + bl snprintf + ldr w3, [x22] + add x20, x20, w0, sxtw + adrp x2, .L.str.64 + add x2, x2, :lo12:.L.str.64 + mov w1, #64 + mov x0, x20 + bl snprintf + ldr w3, [x22, #24] + add x20, x20, w0, sxtw + adrp x2, .L.str.65 + add x2, x2, :lo12:.L.str.65 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_gc_free_blk_threshold + ldrh w3, [x8, :lo12:g_gc_free_blk_threshold] + add x20, x20, w0, sxtw + adrp x2, .L.str.66 + add x2, x2, :lo12:.L.str.66 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_gc_merge_free_blk_threshold + ldrh w3, [x8, :lo12:g_gc_merge_free_blk_threshold] + add x20, x20, w0, sxtw + adrp x2, .L.str.67 + add x2, x2, :lo12:.L.str.67 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_gc_skip_write_count + ldr w3, [x8, :lo12:g_gc_skip_write_count] + add x20, x20, w0, sxtw + adrp x2, .L.str.68 + add x2, x2, :lo12:.L.str.68 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, g_gc_blk_index + ldrh w3, [x8, :lo12:g_gc_blk_index] + add x20, x20, w0, sxtw + adrp x2, .L.str.69 + add x2, x2, :lo12:.L.str.69 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x26, p_free_data_block_list_head + ldr x8, [x26, :lo12:p_free_data_block_list_head] + add x20, x20, w0, sxtw + adrp x24, p_data_block_list_table + adrp x25, p_erase_count_table + cbz x8, .LBB1_2 +// %bb.1: + ldr w9, [x24, :lo12:p_data_block_list_table] + ldr x10, [x25, :lo12:p_erase_count_table] + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and x8, x8, #0xffff + ldrh w3, [x10, x8, lsl #1] + b .LBB1_3 +.LBB1_2: + mov w3, wzr +.LBB1_3: + adrp x2, .L.str.70 + add x2, x2, :lo12:.L.str.70 + mov w1, #64 + mov x0, x20 + bl snprintf + ldr x9, [x26, :lo12:p_free_data_block_list_head] + add x20, x20, w0, sxtw + cbz x9, .LBB1_8 +// %bb.4: + ldrh w10, [x21, :lo12:g_num_free_superblocks] + ldr x8, [x24, :lo12:p_data_block_list_table] + lsl w11, w10, #3 + sub x9, x9, x8 + sub w11, w11, w10 + lsr x12, x9, #1 + lsr w9, w11, #3 + cmp w9, w10 + csel w9, w9, w10, lo + mov w10, #43691 + movk w10, #43690, lsl #16 + mul w12, w12, w10 + cbz w9, .LBB1_9 +// %bb.5: + mov w10, wzr + mov w11, #6 + mov w13, #65535 +.LBB1_6: // =>This Inner Loop Header: Depth=1 + and x14, x12, #0xffff + mul x14, x14, x11 + ldrh w14, [x8, x14] + mov w15, w12 + cmp w14, w13 + b.eq .LBB1_10 +// %bb.7: // in Loop: Header=BB1_6 Depth=1 + add w10, w10, #1 // =1 + and w12, w10, #0xffff + cmp w12, w9, uxth + mov w12, w14 + mov w15, w14 + b.lo .LBB1_6 + b .LBB1_10 +.LBB1_8: + mov w3, wzr + b .LBB1_11 +.LBB1_9: + mov w15, w12 +.LBB1_10: + ldr x8, [x25, :lo12:p_erase_count_table] + and x9, x15, #0xffff + ldrh w3, [x8, x9, lsl #1] +.LBB1_11: + adrp x2, .L.str.71 + add x2, x2, :lo12:.L.str.71 + mov w1, #64 + mov x0, x20 + bl snprintf + adrp x8, gFtlInitStatus + ldr w8, [x8, :lo12:gFtlInitStatus] + add x20, x20, w0, sxtw + cmp w8, #1 // =1 + b.ne .LBB1_24 +// %bb.12: + adrp x8, g_gc_superblock + ldrh w8, [x8, :lo12:g_gc_superblock] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB1_14 +// %bb.13: + ldr x9, [x23, :lo12:p_valid_page_count_table] + adrp x2, .L.str.72 + add x2, x2, :lo12:.L.str.72 + mov w1, #64 + ldrh w3, [x9, x8, lsl #1] + mov x0, x20 + bl snprintf + add x20, x20, w0, sxtw +.LBB1_14: + adrp x8, p_data_block_list_head + ldr x8, [x8, :lo12:p_data_block_list_head] + cbz x8, .LBB1_19 +// %bb.15: + ldr x9, [x24, :lo12:p_data_block_list_table] + sub x8, x8, x9 + mov w9, #43691 + lsr x8, x8, #1 + movk w9, #43690, lsl #16 + mul w9, w8, w9 + mvn w8, w9 + tst w8, #0xffff + b.eq .LBB1_19 +// %bb.16: + ldr x8, [x24, :lo12:p_data_block_list_table] + adrp x22, .L.str.73 + mov w21, wzr + add x22, x22, :lo12:.L.str.73 + mov w27, #65535 +.LBB1_17: // =>This Inner Loop Header: Depth=1 + and x11, x9, #0xffff + ldr x10, [x23, :lo12:p_valid_page_count_table] + ldr x12, [x25, :lo12:p_erase_count_table] + lsl x13, x11, #1 + add x11, x13, x11 + lsl x28, x11, #1 + add x8, x8, x28 + ldrh w5, [x10, x13] + ldrh w6, [x8, #4] + ldrh w7, [x12, x13] + and w4, w9, #0xffff + mov w1, #64 + mov x0, x20 + mov x2, x22 + mov w3, w21 + bl snprintf + ldr x8, [x24, :lo12:p_data_block_list_table] + cmp w21, #14 // =14 + add x20, x20, w0, sxtw + b.hi .LBB1_20 +// %bb.18: // in Loop: Header=BB1_17 Depth=1 + ldrh w9, [x8, x28] + add w21, w21, #1 // =1 + cmp w9, w27 + b.ne .LBB1_17 + b .LBB1_20 +.LBB1_19: + ldr x8, [x24, :lo12:p_data_block_list_table] +.LBB1_20: + ldr x9, [x26, :lo12:p_free_data_block_list_head] + mov w10, #43691 + movk w10, #43690, lsl #16 + sub x9, x9, x8 + lsr x9, x9, #1 + mul w9, w9, w10 + mvn w10, w9 + tst w10, #0xffff + b.eq .LBB1_24 +// %bb.21: + adrp x22, .L.str.74 + mov w21, wzr + add x22, x22, :lo12:.L.str.74 + mov w23, #65535 +.LBB1_22: // =>This Inner Loop Header: Depth=1 + and x10, x9, #0xffff + ldr x11, [x25, :lo12:p_erase_count_table] + lsl x12, x10, #1 + add x10, x12, x10 + lsl x26, x10, #1 + add x8, x8, x26 + ldrh w5, [x8, #4] + ldrh w6, [x11, x12] + and w4, w9, #0xffff + mov w1, #64 + mov x0, x20 + mov x2, x22 + mov w3, w21 + bl snprintf + cmp w21, #2 // =2 + add x20, x20, w0, sxtw + b.hi .LBB1_24 +// %bb.23: // in Loop: Header=BB1_22 Depth=1 + ldr x8, [x24, :lo12:p_data_block_list_table] + add w21, w21, #1 // =1 + ldrh w9, [x8, x26] + cmp w9, w23 + b.ne .LBB1_22 +.LBB1_24: + sub w0, w20, w19 + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end1: + .size FtlPrintInfo2buf, .Lfunc_end1-FtlPrintInfo2buf + // -- End function + .globl GetFreeBlockMinEraseCount // -- Begin function GetFreeBlockMinEraseCount + .p2align 2 + .type GetFreeBlockMinEraseCount,@function +GetFreeBlockMinEraseCount: // @GetFreeBlockMinEraseCount +// %bb.0: + hint #25 + adrp x8, p_free_data_block_list_head + ldr x8, [x8, :lo12:p_free_data_block_list_head] + cbz x8, .LBB2_2 +// %bb.1: + adrp x9, p_data_block_list_table + ldr w9, [x9, :lo12:p_data_block_list_table] + adrp x10, p_erase_count_table + ldr x10, [x10, :lo12:p_erase_count_table] + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and x8, x8, #0xffff + ldrh w0, [x10, x8, lsl #1] + hint #29 + ret +.LBB2_2: + mov w0, wzr + hint #29 + ret +.Lfunc_end2: + .size GetFreeBlockMinEraseCount, .Lfunc_end2-GetFreeBlockMinEraseCount + // -- End function + .globl GetFreeBlockMaxEraseCount // -- Begin function GetFreeBlockMaxEraseCount + .p2align 2 + .type GetFreeBlockMaxEraseCount,@function +GetFreeBlockMaxEraseCount: // @GetFreeBlockMaxEraseCount +// %bb.0: + hint #25 + adrp x8, p_free_data_block_list_head + ldr x9, [x8, :lo12:p_free_data_block_list_head] + cbz x9, .LBB3_5 +// %bb.1: + adrp x8, g_num_free_superblocks + adrp x10, p_data_block_list_table + ldrh w11, [x8, :lo12:g_num_free_superblocks] + ldr x8, [x10, :lo12:p_data_block_list_table] + mov w12, #43691 + movk w12, #43690, lsl #16 + lsl w10, w11, #3 + sub x9, x9, x8 + sub w10, w10, w11 + lsr x11, x9, #1 + lsr w9, w10, #3 + cmp w9, w0, uxth + csel w9, w9, w0, lo + and w10, w9, #0xffff + mul w12, w11, w12 + cbz w10, .LBB3_6 +// %bb.2: + mov w10, wzr + mov w11, #6 + mov w13, #65535 +.LBB3_3: // =>This Inner Loop Header: Depth=1 + and x14, x12, #0xffff + mul x14, x14, x11 + ldrh w14, [x8, x14] + mov w15, w12 + cmp w14, w13 + b.eq .LBB3_7 +// %bb.4: // in Loop: Header=BB3_3 Depth=1 + add w10, w10, #1 // =1 + and w12, w10, #0xffff + cmp w12, w9, uxth + mov w12, w14 + mov w15, w14 + b.lo .LBB3_3 + b .LBB3_7 +.LBB3_5: + mov w0, wzr + hint #29 + ret +.LBB3_6: + mov w15, w12 +.LBB3_7: + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + and x9, x15, #0xffff + ldrh w0, [x8, x9, lsl #1] + hint #29 + ret +.Lfunc_end3: + .size GetFreeBlockMaxEraseCount, .Lfunc_end3-GetFreeBlockMaxEraseCount + // -- End function + .globl List_get_gc_head_node // -- Begin function List_get_gc_head_node + .p2align 2 + .type List_get_gc_head_node,@function +List_get_gc_head_node: // @List_get_gc_head_node +// %bb.0: + hint #25 + adrp x8, p_data_block_list_head + ldr x8, [x8, :lo12:p_data_block_list_head] + cbz x8, .LBB4_6 +// %bb.1: + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + tst w0, #0xffff + b.eq .LBB4_5 +// %bb.2: + mov w10, #6 +.LBB4_3: // =>This Inner Loop Header: Depth=1 + ldrh w11, [x8] + mov w8, #65535 + cmp x11, x8 + b.eq .LBB4_7 +// %bb.4: // in Loop: Header=BB4_3 Depth=1 + sub w0, w0, #1 // =1 + tst w0, #0xffff + madd x8, x11, x10, x9 + b.ne .LBB4_3 +.LBB4_5: + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and w8, w8, #0xffff + b .LBB4_7 +.LBB4_6: + mov w8, #65535 +.LBB4_7: + mov w0, w8 + hint #29 + ret +.Lfunc_end4: + .size List_get_gc_head_node, .Lfunc_end4-List_get_gc_head_node + // -- End function + .globl rknand_proc_ftlread // -- Begin function rknand_proc_ftlread + .p2align 2 + .type rknand_proc_ftlread,@function +rknand_proc_ftlread: // @rknand_proc_ftlread +// %bb.0: + hint #34 + cmp w0, #2048 // =2048 + b.ge .LBB5_2 +// %bb.1: + mov w0, wzr + ret +.LBB5_2: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + mov x19, x1 + adrp x2, .L.str.75 + adrp x3, .L.str.1 + add x2, x2, :lo12:.L.str.75 + add x3, x3, :lo12:.L.str.1 + mov w1, #64 + mov x0, x19 + mov x29, sp + bl snprintf + add x20, x19, w0, sxtw + mov x0, x20 + bl FtlPrintInfo2buf + add w8, w20, w0 + sub w0, w8, w19 + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end5: + .size rknand_proc_ftlread, .Lfunc_end5-rknand_proc_ftlread + // -- End function + .globl Ftl_log2 // -- Begin function Ftl_log2 + .p2align 2 + .type Ftl_log2,@function +Ftl_log2: // @Ftl_log2 +// %bb.0: + hint #25 + cbz w0, .LBB6_3 +// %bb.1: + mov w10, wzr + mov w9, #1 +.LBB6_2: // =>This Inner Loop Header: Depth=1 + lsl w9, w9, #1 + mov w8, w10 + cmp w9, w0 + add w10, w10, #1 // =1 + b.ls .LBB6_2 + b .LBB6_4 +.LBB6_3: + mov w8, #65535 +.LBB6_4: + mov w0, w8 + hint #29 + ret +.Lfunc_end6: + .size Ftl_log2, .Lfunc_end6-Ftl_log2 + // -- End function + .globl FtlPrintInfo // -- Begin function FtlPrintInfo + .p2align 2 + .type FtlPrintInfo,@function +FtlPrintInfo: // @FtlPrintInfo +// %bb.0: + hint #25 + hint #29 + ret +.Lfunc_end7: + .size FtlPrintInfo, .Lfunc_end7-FtlPrintInfo + // -- End function + .globl FtlSysBlkNumInit // -- Begin function FtlSysBlkNumInit + .p2align 2 + .type FtlSysBlkNumInit,@function +FtlSysBlkNumInit: // @FtlSysBlkNumInit +// %bb.0: + hint #25 + and w8, w0, #0xffff + adrp x9, c_ftl_nand_blk_pre_plane + cmp w8, #24 // =24 + ldrh w8, [x9, :lo12:c_ftl_nand_blk_pre_plane] + mov w9, #24 + csel w9, w0, w9, hi + adrp x10, c_ftl_nand_data_blks_per_plane + sub w8, w8, w9 + strh w8, [x10, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x8, c_ftl_nand_sys_blks_per_plane + adrp x10, c_ftl_nand_planes_num + and w9, w9, #0xffff + ldrh w10, [x10, :lo12:c_ftl_nand_planes_num] + str w9, [x8, :lo12:c_ftl_nand_sys_blks_per_plane] + adrp x8, c_ftl_nand_totle_phy_blks + ldr w8, [x8, :lo12:c_ftl_nand_totle_phy_blks] + mul w9, w10, w9 + adrp x10, c_ftl_nand_max_sys_blks + str w9, [x10, :lo12:c_ftl_nand_max_sys_blks] + sub w8, w8, w9 + adrp x9, c_ftl_nand_max_data_blks + str w8, [x9, :lo12:c_ftl_nand_max_data_blks] + mov w0, wzr + hint #29 + ret +.Lfunc_end8: + .size FtlSysBlkNumInit, .Lfunc_end8-FtlSysBlkNumInit + // -- End function + .globl FtlConstantsInit // -- Begin function FtlConstantsInit + .p2align 2 + .type FtlConstantsInit,@function +FtlConstantsInit: // @FtlConstantsInit +// %bb.0: + hint #25 + ldrh w12, [x0] + adrp x8, c_ftl_nand_type + adrp x14, c_ftl_nand_planes_per_die + adrp x13, c_ftl_nand_blk_pre_plane + strh w12, [x8, :lo12:c_ftl_nand_type] + ldrh w10, [x0, #2] + adrp x8, c_ftl_nand_die_num + adrp x15, c_ftl_nand_sec_pre_page + strh w10, [x8, :lo12:c_ftl_nand_die_num] + ldrh w11, [x0, #4] + strh w11, [x14, :lo12:c_ftl_nand_planes_per_die] + ldrh w8, [x0, #6] + strh w8, [x13, :lo12:c_ftl_nand_blk_pre_plane] + ldrh w9, [x0, #14] + cmp w9, #8 // =8 + strh w9, [x15, :lo12:c_ftl_nand_sec_pre_page] + b.eq .LBB9_3 +// %bb.1: + cmp w9, #4 // =4 + b.ne .LBB9_6 +// %bb.2: + lsr w8, w8, #1 + mov w9, #8 + strh w8, [x13, :lo12:c_ftl_nand_blk_pre_plane] + strh w9, [x15, :lo12:c_ftl_nand_sec_pre_page] + b .LBB9_6 +.LBB9_3: + cmp w11, #1 // =1 + b.ne .LBB9_5 +// %bb.4: + lsr w8, w8, #1 + mov w11, #2 + strh w8, [x13, :lo12:c_ftl_nand_blk_pre_plane] + strh w11, [x14, :lo12:c_ftl_nand_planes_per_die] +.LBB9_5: + mov w9, #8 +.LBB9_6: + mov x15, #256 + mov x16, #2312 + mov x17, #4368 + mov x18, #6424 + movk x15, #770, lsl #16 + movk x16, #2826, lsl #16 + movk x17, #4882, lsl #16 + movk x18, #6938, lsl #16 + adrp x14, p_plane_order_table + movk x15, #1284, lsl #32 + movk x16, #3340, lsl #32 + movk x17, #5396, lsl #32 + movk x18, #7452, lsl #32 + add x14, x14, :lo12:p_plane_order_table + movk x15, #1798, lsl #48 + movk x16, #3854, lsl #48 + movk x17, #5910, lsl #48 + movk x18, #7966, lsl #48 + adrp x13, c_mlc_erase_count_value + mov w1, #5 + adrp x2, c_ftl_nand_ext_blk_pre_plane + cmp w12, #1 // =1 + stp x15, x16, [x14] + stp x17, x18, [x14, #16] + strh w1, [x13, :lo12:c_mlc_erase_count_value] + strh wzr, [x2, :lo12:c_ftl_nand_ext_blk_pre_plane] + b.ne .LBB9_8 +// %bb.7: + strh w12, [x13, :lo12:c_mlc_erase_count_value] +.LBB9_8: + mul w12, w11, w10 + adrp x10, c_ftl_nand_planes_num + mul w11, w8, w11 + adrp x13, c_ftl_vendor_part_size + mov w14, #640 + adrp x15, c_ftl_nand_blks_per_die + strh w12, [x10, :lo12:c_ftl_nand_planes_num] + ands w10, w11, #0xffff + strh w14, [x13, :lo12:c_ftl_vendor_part_size] + strh w11, [x15, :lo12:c_ftl_nand_blks_per_die] + b.eq .LBB9_11 +// %bb.9: + mov w14, wzr + mov w13, #1 +.LBB9_10: // =>This Inner Loop Header: Depth=1 + lsl w13, w13, #1 + mov w11, w14 + cmp w13, w10 + add w14, w14, #1 // =1 + b.ls .LBB9_10 + b .LBB9_12 +.LBB9_11: + mov w11, #65535 +.LBB9_12: + adrp x10, c_ftl_nand_blks_per_die_shift + strh w11, [x10, :lo12:c_ftl_nand_blks_per_die_shift] + ldrh w10, [x0, #12] + adrp x11, c_ftl_nand_page_pre_blk + adrp x13, c_ftl_nand_page_pre_slc_blk + strh w10, [x11, :lo12:c_ftl_nand_page_pre_blk] + strh w10, [x13, :lo12:c_ftl_nand_page_pre_slc_blk] + mul w11, w10, w12 + adrp x13, c_ftl_nand_page_pre_super_blk + strh w11, [x13, :lo12:c_ftl_nand_page_pre_super_blk] + cbz w9, .LBB9_15 +// %bb.13: + mov w14, wzr + mov w13, #1 +.LBB9_14: // =>This Inner Loop Header: Depth=1 + lsl w13, w13, #1 + mov w11, w14 + cmp w13, w9 + add w14, w14, #1 // =1 + b.ls .LBB9_14 + b .LBB9_16 +.LBB9_15: + mov w11, #65535 +.LBB9_16: + adrp x14, c_ftl_nand_sec_pre_page_shift + lsl w13, w9, #9 + adrp x15, c_ftl_nand_byte_pre_page + ubfiz w16, w9, #1, #7 + adrp x17, c_ftl_nand_byte_pre_oob + strh w13, [x15, :lo12:c_ftl_nand_byte_pre_page] + strh w16, [x17, :lo12:c_ftl_nand_byte_pre_oob] + adrp x17, c_ftl_nand_l2pmap_ram_region_num + strh w11, [x14, :lo12:c_ftl_nand_sec_pre_page_shift] + mov w14, #32 + ldrh w18, [x0, #20] + strh w14, [x17, :lo12:c_ftl_nand_l2pmap_ram_region_num] + mov w14, #640 + lsr w14, w14, w11 + and w12, w12, #0xffff + adrp x17, c_ftl_nand_vendor_region_num + add w14, w14, #2 // =2 + mul w9, w9, w10 + strh w14, [x17, :lo12:c_ftl_nand_vendor_region_num] + mul w14, w8, w12 + mul w17, w9, w14 + adrp x16, DeviceCapacity + asr w17, w17, #11 + str w17, [x16, :lo12:DeviceCapacity] + mov w16, #5120 + sdiv w9, w16, w9 + and w16, w9, #0xffff + mov w17, #4 + cmp w16, #5 // =5 + adrp x15, c_ftl_nand_reserved_blks + and w11, w11, #0xffff + csel w9, w17, w9, lo + strh w18, [x15, :lo12:c_ftl_nand_reserved_blks] + lsl w15, w8, #6 + add w17, w9, #3 // =3 + add w11, w11, #9 // =9 + and w9, w9, #0xffff + lsr w15, w15, w11 + udiv w9, w9, w12 + adrp x16, c_ftl_nand_max_vendor_blks + add w9, w15, w9 + strh w17, [x16, :lo12:c_ftl_nand_max_vendor_blks] + cmp w12, #1 // =1 + add w17, w9, #8 // =8 + add w9, w9, #12 // =12 + csel w9, w9, w17, eq + and w17, w9, #0xffff + mov w16, #24 + cmp w17, #24 // =24 + adrp x18, c_ftl_nand_map_blks_per_plane + csel w9, w9, w16, hi + adrp x16, c_ftl_nand_data_blks_per_plane + sub w8, w8, w9 + strh w15, [x18, :lo12:c_ftl_nand_map_blks_per_plane] + orr w18, wzr, #0x3 + and w9, w9, #0xffff + strh w8, [x16, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x8, c_ftl_nand_max_sys_blks + madd w15, w15, w12, w18 + mul w12, w9, w12 + adrp x16, c_ftl_nand_max_data_blks + str w12, [x8, :lo12:c_ftl_nand_max_sys_blks] + sub w8, w14, w12 + str w8, [x16, :lo12:c_ftl_nand_max_data_blks] + mul w8, w10, w8 + adrp x13, c_ftl_nand_totle_phy_blks + lsl w8, w8, #2 + adrp x17, c_ftl_nand_sys_blks_per_plane + str w14, [x13, :lo12:c_ftl_nand_totle_phy_blks] + adrp x13, g_MaxLbaSector + lsr w8, w8, w11 + str wzr, [x13, :lo12:g_MaxLbaSector] + adrp x13, c_ftl_nand_init_sys_blks_per_plane + adrp x18, c_ftl_nand_map_region_num + str w9, [x17, :lo12:c_ftl_nand_sys_blks_per_plane] + adrp x17, c_ftl_nand_max_map_blks + add w8, w8, #2 // =2 + str w9, [x13, :lo12:c_ftl_nand_init_sys_blks_per_plane] + strh w8, [x18, :lo12:c_ftl_nand_map_region_num] + str w15, [x17, :lo12:c_ftl_nand_max_map_blks] + mov w0, wzr + hint #29 + ret +.Lfunc_end9: + .size FtlConstantsInit, .Lfunc_end9-FtlConstantsInit + // -- End function + .globl FtlMemInit // -- Begin function FtlMemInit + .p2align 2 + .type FtlMemInit,@function +FtlMemInit: // @FtlMemInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + adrp x9, g_gc_head_data_block + mov w10, #65535 + adrp x8, g_GlobalSysVersion + str w10, [x9, :lo12:g_gc_head_data_block] + adrp x9, g_gc_next_blk + strh w10, [x9, :lo12:g_gc_next_blk] + adrp x9, g_gc_next_blk_1 + str wzr, [x8, :lo12:g_GlobalSysVersion] + adrp x8, g_totle_write_page_count + strh w10, [x9, :lo12:g_gc_next_blk_1] + adrp x9, g_gc_free_blk_threshold + mov w10, #32 + str wzr, [x8, :lo12:g_totle_write_page_count] + adrp x8, g_totle_l2p_write_count + strh w10, [x9, :lo12:g_gc_free_blk_threshold] + adrp x9, g_gc_merge_free_blk_threshold + mov w10, #128 + str wzr, [x8, :lo12:g_totle_l2p_write_count] + adrp x8, g_totle_slc_erase_count + strh w10, [x9, :lo12:g_gc_merge_free_blk_threshold] + adrp x9, g_GlobalDataVersion + str wzr, [x8, :lo12:g_totle_slc_erase_count] + adrp x8, g_min_erase_count + str wzr, [x9, :lo12:g_GlobalDataVersion] + adrp x9, g_totle_discard_page_count + str wzr, [x8, :lo12:g_min_erase_count] + adrp x8, g_gc_head_data_block_count + stp x20, x19, [sp, #80] // 16-byte Folded Spill + adrp x10, g_totle_gc_page_count + str wzr, [x9, :lo12:g_totle_discard_page_count] + adrp x9, g_totle_read_page_count + str wzr, [x8, :lo12:g_gc_head_data_block_count] + adrp x8, g_gc_blk_index + adrp x19, c_ftl_nand_page_pre_super_blk + str wzr, [x10, :lo12:g_totle_gc_page_count] + adrp x10, g_totle_cache_write_count + str wzr, [x9, :lo12:g_totle_read_page_count] + adrp x9, g_totle_sys_slc_erase_count + strh wzr, [x8, :lo12:g_gc_blk_index] + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk] + str wzr, [x10, :lo12:g_totle_cache_write_count] + adrp x10, g_totle_mlc_erase_count + str wzr, [x9, :lo12:g_totle_sys_slc_erase_count] + adrp x9, g_in_gc_progress + str wzr, [x10, :lo12:g_totle_mlc_erase_count] + adrp x10, g_max_erase_count + str wzr, [x9, :lo12:g_in_gc_progress] + adrp x9, g_gc_skip_write_count + str wzr, [x10, :lo12:g_max_erase_count] + adrp x10, g_in_swl_replace + str wzr, [x9, :lo12:g_gc_skip_write_count] + adrp x9, g_gc_bad_block_temp_num + str wzr, [x10, :lo12:g_in_swl_replace] + adrp x10, g_cur_erase_blk + strh wzr, [x9, :lo12:g_gc_bad_block_temp_num] + adrp x9, g_gc_bad_block_gc_index + lsl w0, w8, #1 + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + mov x29, sp + str wzr, [x10, :lo12:g_cur_erase_blk] + strh wzr, [x9, :lo12:g_gc_bad_block_gc_index] + bl ftl_malloc + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk] + adrp x9, p_gc_blk_tbl + str x0, [x9, :lo12:p_gc_blk_tbl] + add w8, w8, w8, lsl #1 + lsl w0, w8, #2 + bl ftl_malloc + adrp x21, c_ftl_nand_planes_num + ldrh w8, [x21, :lo12:c_ftl_nand_planes_num] + adrp x9, p_gc_page_info + str x0, [x9, :lo12:p_gc_page_info] + lsl w20, w8, #7 + mov w0, w20 + lsl w19, w8, #5 + bl ftl_malloc + adrp x8, req_read + str x0, [x8, :lo12:req_read] + mov w0, w19 + bl ftl_malloc + adrp x8, req_gc_dst + str x0, [x8, :lo12:req_gc_dst] + mov w0, w20 + bl ftl_malloc + adrp x8, req_prgm + str x0, [x8, :lo12:req_prgm] + mov w0, w19 + bl ftl_malloc + adrp x8, req_erase + str x0, [x8, :lo12:req_erase] + mov w0, w19 + bl ftl_malloc + adrp x20, c_ftl_nand_byte_pre_page + ldrh w8, [x21, :lo12:c_ftl_nand_planes_num] + ldrh w19, [x20, :lo12:c_ftl_nand_byte_pre_page] + adrp x10, req_gc + mov w9, #1 + str x0, [x10, :lo12:req_gc] + bfi w9, w8, #1, #16 + adrp x22, c_gc_page_buf_num + mov w0, w19 + mov w25, #1 + str w9, [x22, :lo12:c_gc_page_buf_num] + bl ftl_malloc + adrp x8, p_sys_data_buf + str x0, [x8, :lo12:p_sys_data_buf] + mov w0, w19 + bl ftl_malloc + adrp x8, p_sys_data_buf_1 + str x0, [x8, :lo12:p_sys_data_buf_1] + mov w0, w19 + bl ftl_malloc + ldr w8, [x22, :lo12:c_gc_page_buf_num] + adrp x9, p_vendor_data_buf + str x0, [x9, :lo12:p_vendor_data_buf] + mul w0, w8, w19 + bl ftl_malloc + adrp x8, p_gc_data_buf + str x0, [x8, :lo12:p_gc_data_buf] + mov w0, w19 + bl ftl_malloc + adrp x8, p_io_data_buf_0 + str x0, [x8, :lo12:p_io_data_buf_0] + mov w0, w19 + bl ftl_malloc + ldr w8, [x22, :lo12:c_gc_page_buf_num] + adrp x9, p_io_data_buf_1 + str x0, [x9, :lo12:p_io_data_buf_1] + add w8, w8, w8, lsl #1 + lsl w0, w8, #3 + bl ftl_malloc + adrp x8, gp_gc_page_buf_info + str x0, [x8, :lo12:gp_gc_page_buf_info] + mov w0, w19 + bl ftl_malloc + adrp x8, sftl_nand_check_buf + str x0, [x8, :lo12:sftl_nand_check_buf] + mov w0, w19 + bl ftl_malloc + adrp x8, c_ftl_nand_sec_pre_page + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page] + adrp x9, sftl_temp_buf + str x0, [x9, :lo12:sftl_temp_buf] + lsl w0, w8, #2 + bl ftl_malloc + adrp x23, c_ftl_nand_byte_pre_oob + ldrh w8, [x23, :lo12:c_ftl_nand_byte_pre_oob] + ldrh w9, [x21, :lo12:c_ftl_nand_planes_num] + adrp x10, sftl_nand_check_spare_buf + str x0, [x10, :lo12:sftl_nand_check_spare_buf] + mul w19, w9, w8 + mov w0, w19 + bl ftl_malloc + adrp x8, p_sys_spare_buf + str x0, [x8, :lo12:p_sys_spare_buf] + lsl w0, w19, #2 + bl ftl_malloc + ldrh w8, [x23, :lo12:c_ftl_nand_byte_pre_oob] + ldr w9, [x22, :lo12:c_gc_page_buf_num] + adrp x10, p_io_spare_buf + str x0, [x10, :lo12:p_io_spare_buf] + mul w0, w9, w8 + bl ftl_malloc + adrp x23, c_ftl_nand_blk_pre_plane + ldrh w8, [x23, :lo12:c_ftl_nand_blk_pre_plane] + adrp x9, p_gc_spare_buf + adrp x19, g_ect_tbl_info_size + str x0, [x9, :lo12:p_gc_spare_buf] + lsl w8, w8, #1 + and w0, w8, #0xfffe + strh w8, [x19, :lo12:g_ect_tbl_info_size] + bl ftl_malloc + ldrh w8, [x19, :lo12:g_ect_tbl_info_size] + adrp x9, p_swl_mul_table + str x0, [x9, :lo12:p_swl_mul_table] + add w8, w8, #547 // =547 + lsr w9, w8, #9 + and w0, w8, #0x1fe00 + strh w9, [x19, :lo12:g_ect_tbl_info_size] + bl ftl_malloc + ldrh w9, [x23, :lo12:c_ftl_nand_blk_pre_plane] + adrp x8, gp_ect_tbl_info + str x0, [x8, :lo12:gp_ect_tbl_info] + add x8, x0, #32 // =32 + lsl w19, w9, #1 + adrp x10, p_erase_count_table + mov w0, w19 + str x8, [x10, :lo12:p_erase_count_table] + bl ftl_malloc + adrp x8, p_valid_page_count_check_table + str x0, [x8, :lo12:p_valid_page_count_check_table] + mov w0, w19 + bl ftl_malloc + adrp x21, c_ftl_nand_max_map_blks + ldr w8, [x21, :lo12:c_ftl_nand_max_map_blks] + adrp x9, p_valid_page_count_table + str x0, [x9, :lo12:p_valid_page_count_table] + lsl w19, w8, #1 + mov w0, w19 + bl ftl_malloc + adrp x26, p_map_block_table + str x0, [x26, :lo12:p_map_block_table] + mov w0, w19 + bl ftl_malloc + adrp x19, c_ftl_nand_max_vendor_blks + ldrh w8, [x19, :lo12:c_ftl_nand_max_vendor_blks] + adrp x22, p_map_block_valid_page_count + str x0, [x22, :lo12:p_map_block_valid_page_count] + lsl w0, w8, #1 + bl ftl_malloc + ldrh w8, [x19, :lo12:c_ftl_nand_max_vendor_blks] + adrp x9, p_vendor_block_table + str x0, [x9, :lo12:p_vendor_block_table] + lsl w0, w8, #1 + bl ftl_malloc + ldrh w8, [x19, :lo12:c_ftl_nand_max_vendor_blks] + adrp x9, p_vendor_block_valid_page_count + str x0, [x9, :lo12:p_vendor_block_valid_page_count] + lsl w0, w8, #2 + bl ftl_malloc + adrp x19, c_ftl_nand_vendor_region_num + ldrh w8, [x19, :lo12:c_ftl_nand_vendor_region_num] + adrp x9, p_vendor_block_ver_table + str x0, [x9, :lo12:p_vendor_block_ver_table] + lsl w0, w8, #2 + bl ftl_malloc + ldrh w8, [x19, :lo12:c_ftl_nand_vendor_region_num] + adrp x9, p_vendor_region_ppn_table + mov w1, wzr + str x0, [x9, :lo12:p_vendor_region_ppn_table] + lsl x2, x8, #2 + bl memset + adrp x8, c_ftl_nand_map_region_num + ldrh w8, [x8, :lo12:c_ftl_nand_map_region_num] + lsl w0, w8, #2 + bl ftl_malloc + ldr w8, [x21, :lo12:c_ftl_nand_max_map_blks] + adrp x21, p_map_region_ppn_table + str x0, [x21, :lo12:p_map_region_ppn_table] + lsl w0, w8, #2 + bl ftl_malloc + adrp x24, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num] + adrp x19, p_map_block_ver_table + str x0, [x19, :lo12:p_map_block_ver_table] + lsl w0, w8, #4 + bl ftl_malloc + ldrh w8, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num] + ldrh w9, [x20, :lo12:c_ftl_nand_byte_pre_page] + adrp x20, p_l2p_ram_map + str x0, [x20, :lo12:p_l2p_ram_map] + mul w0, w9, w8 + bl ftl_malloc + ldrh w8, [x23, :lo12:c_ftl_nand_blk_pre_plane] + adrp x24, p_l2p_map_buf + str x0, [x24, :lo12:p_l2p_map_buf] + add w8, w8, w8, lsl #1 + lsl w0, w8, #1 + bl ftl_malloc + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x27, c_ftl_nand_die_num + ldrh w9, [x27, :lo12:c_ftl_nand_die_num] + adrp x28, c_ftl_nand_bbm_buf_size + add w8, w8, #31 // =31 + lsr w8, w8, #5 + adrp x23, p_data_block_list_table + strh w8, [x28, :lo12:c_ftl_nand_bbm_buf_size] + mul w8, w9, w8 + str x0, [x23, :lo12:p_data_block_list_table] + lsl w0, w8, #2 + bl ftl_malloc + ldrh w9, [x27, :lo12:c_ftl_nand_die_num] + adrp x8, gBbtInfo + adrp x27, gBbtInfo+32 + add x8, x8, :lo12:gBbtInfo + cmp w9, #2 // =2 + str x0, [x27, :lo12:gBbtInfo+32] + b.lo .LBB10_9 +// %bb.1: + ldrh w10, [x28, :lo12:c_ftl_nand_bbm_buf_size] + cmp w9, #2 // =2 + mov w11, #2 + csel w25, w9, w11, hi + sub x12, x25, #1 // =1 + cmp x12, #2 // =2 + lsl x9, x10, #2 + b.hs .LBB10_3 +// %bb.2: + mov w11, #1 + b .LBB10_6 +.LBB10_3: + and x13, x12, #0xfffffffffffffffe + adrp x15, gBbtInfo+48 + orr x11, x12, #0x1 + lsl x14, x10, #3 + add x15, x15, :lo12:gBbtInfo+48 + mov x16, x13 + mov x17, x0 +.LBB10_4: // =>This Inner Loop Header: Depth=1 + add x18, x17, x9 + add x17, x17, x14 + subs x16, x16, #2 // =2 + stp x18, x17, [x15, #-8] + add x15, x15, #16 // =16 + b.ne .LBB10_4 +// %bb.5: + cmp x12, x13 + b.eq .LBB10_8 +.LBB10_6: + add x12, x8, x11, lsl #3 + mul x13, x11, x10 + add x10, x12, #32 // =32 + add x12, x0, x13, lsl #2 + sub x11, x25, x11 +.LBB10_7: // =>This Inner Loop Header: Depth=1 + str x12, [x10], #8 + subs x11, x11, #1 // =1 + add x12, x12, x9 + b.ne .LBB10_7 +.LBB10_8: + cmp w25, #7 // =7 + b.hi .LBB10_10 +.LBB10_9: + add x8, x8, w25, uxtw #3 + mov w9, #7 + add x0, x8, #32 // =32 + sub w8, w9, w25 + lsl x8, x8, #3 + add x2, x8, #8 // =8 + mov w1, wzr + bl memset +.LBB10_10: + ldr x8, [x26, :lo12:p_map_block_table] + cbz x8, .LBB10_43 +// %bb.11: + ldr x8, [x22, :lo12:p_map_block_valid_page_count] + cbz x8, .LBB10_43 +// %bb.12: + ldr x8, [x21, :lo12:p_map_region_ppn_table] + cbz x8, .LBB10_43 +// %bb.13: + ldr x8, [x19, :lo12:p_map_block_ver_table] + cbz x8, .LBB10_43 +// %bb.14: + ldr x8, [x20, :lo12:p_l2p_ram_map] + cbz x8, .LBB10_43 +// %bb.15: + ldr x8, [x24, :lo12:p_l2p_map_buf] + cbz x8, .LBB10_43 +// %bb.16: + ldr x8, [x23, :lo12:p_data_block_list_table] + cbz x8, .LBB10_43 +// %bb.17: + ldr x8, [x27, :lo12:gBbtInfo+32] + cbz x8, .LBB10_43 +// %bb.18: + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + cbz x8, .LBB10_43 +// %bb.19: + adrp x8, p_gc_blk_tbl + ldr x8, [x8, :lo12:p_gc_blk_tbl] + cbz x8, .LBB10_43 +// %bb.20: + adrp x8, p_gc_page_info + ldr x8, [x8, :lo12:p_gc_page_info] + cbz x8, .LBB10_43 +// %bb.21: + adrp x8, req_read + ldr x8, [x8, :lo12:req_read] + cbz x8, .LBB10_43 +// %bb.22: + adrp x8, req_prgm + ldr x8, [x8, :lo12:req_prgm] + cbz x8, .LBB10_43 +// %bb.23: + adrp x8, req_erase + ldr x8, [x8, :lo12:req_erase] + cbz x8, .LBB10_43 +// %bb.24: + adrp x8, req_gc + ldr x8, [x8, :lo12:req_gc] + cbz x8, .LBB10_43 +// %bb.25: + adrp x8, req_gc_dst + ldr x8, [x8, :lo12:req_gc_dst] + cbz x8, .LBB10_43 +// %bb.26: + adrp x8, p_sys_data_buf + ldr x8, [x8, :lo12:p_sys_data_buf] + cbz x8, .LBB10_43 +// %bb.27: + adrp x8, p_sys_data_buf_1 + ldr x8, [x8, :lo12:p_sys_data_buf_1] + cbz x8, .LBB10_43 +// %bb.28: + adrp x8, p_vendor_data_buf + ldr x8, [x8, :lo12:p_vendor_data_buf] + cbz x8, .LBB10_43 +// %bb.29: + adrp x8, p_gc_data_buf + ldr x8, [x8, :lo12:p_gc_data_buf] + cbz x8, .LBB10_43 +// %bb.30: + adrp x8, p_io_data_buf_0 + ldr x8, [x8, :lo12:p_io_data_buf_0] + cbz x8, .LBB10_43 +// %bb.31: + adrp x8, p_io_data_buf_1 + ldr x8, [x8, :lo12:p_io_data_buf_1] + cbz x8, .LBB10_43 +// %bb.32: + adrp x8, gp_gc_page_buf_info + ldr x8, [x8, :lo12:gp_gc_page_buf_info] + cbz x8, .LBB10_43 +// %bb.33: + adrp x8, p_sys_spare_buf + ldr x8, [x8, :lo12:p_sys_spare_buf] + cbz x8, .LBB10_43 +// %bb.34: + adrp x8, p_io_spare_buf + ldr x8, [x8, :lo12:p_io_spare_buf] + cbz x8, .LBB10_43 +// %bb.35: + adrp x8, p_gc_spare_buf + ldr x8, [x8, :lo12:p_gc_spare_buf] + cbz x8, .LBB10_43 +// %bb.36: + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + cbz x8, .LBB10_43 +// %bb.37: + adrp x8, p_swl_mul_table + ldr x8, [x8, :lo12:p_swl_mul_table] + cbz x8, .LBB10_43 +// %bb.38: + adrp x8, p_vendor_block_table + ldr x8, [x8, :lo12:p_vendor_block_table] + cbz x8, .LBB10_43 +// %bb.39: + adrp x8, p_vendor_block_valid_page_count + ldr x8, [x8, :lo12:p_vendor_block_valid_page_count] + cbz x8, .LBB10_43 +// %bb.40: + adrp x8, p_vendor_block_ver_table + ldr x8, [x8, :lo12:p_vendor_block_ver_table] + cbz x8, .LBB10_43 +// %bb.41: + adrp x8, p_vendor_region_ppn_table + ldr x8, [x8, :lo12:p_vendor_region_ppn_table] + cbz x8, .LBB10_43 +// %bb.42: + mov w0, wzr + b .LBB10_44 +.LBB10_43: + adrp x0, .L.str.76 + adrp x1, .L__func__.FtlMemInit + add x0, x0, :lo12:.L.str.76 + add x1, x1, :lo12:.L__func__.FtlMemInit + bl sftl_printk + mov w0, #-1 +.LBB10_44: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end10: + .size FtlMemInit, .Lfunc_end10-FtlMemInit + // -- End function + .globl ftl_malloc // -- Begin function ftl_malloc + .p2align 2 + .type ftl_malloc,@function +ftl_malloc: // @ftl_malloc +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + // kill: def $w0 killed $w0 def $x0 + mov w1, #3265 + sxtw x0, w0 + mov x29, sp + bl __kmalloc + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end11: + .size ftl_malloc, .Lfunc_end11-ftl_malloc + // -- End function + .globl ftl_memset // -- Begin function ftl_memset + .p2align 2 + .type ftl_memset,@function +ftl_memset: // @ftl_memset +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + mov w2, w2 + str x19, [sp, #16] // 8-byte Folded Spill + mov x29, sp + mov x19, x0 + bl memset + mov x0, x19 + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end12: + .size ftl_memset, .Lfunc_end12-ftl_memset + // -- End function + .globl FtlVariablesInit // -- Begin function FtlVariablesInit + .p2align 2 + .type FtlVariablesInit,@function +FtlVariablesInit: // @FtlVariablesInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + adrp x9, g_recovery_page_min_ver + mov w10, #-1 + str w10, [x9, :lo12:g_recovery_page_min_ver] + adrp x9, g_totle_swl_count + stp x20, x19, [sp, #48] // 16-byte Folded Spill + adrp x8, g_tmp_data_superblock_id + mov w19, #65535 + str wzr, [x9, :lo12:g_totle_swl_count] + adrp x9, c_ftl_nand_max_vendor_blks + strh w19, [x8, :lo12:g_tmp_data_superblock_id] + adrp x8, p_vendor_block_table + ldrh w9, [x9, :lo12:c_ftl_nand_max_vendor_blks] + ldr x0, [x8, :lo12:p_vendor_block_table] + adrp x10, ftl_gc_temp_power_lost_recovery_flag + adrp x8, g_totle_vendor_block + lsl x2, x9, #1 + mov w1, wzr + stp x24, x23, [sp, #16] // 16-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + mov x29, sp + str wzr, [x10, :lo12:ftl_gc_temp_power_lost_recovery_flag] + strh wzr, [x8, :lo12:g_totle_vendor_block] + bl memset + adrp x20, c_ftl_nand_blk_pre_plane + adrp x8, p_erase_count_table + ldrh w9, [x20, :lo12:c_ftl_nand_blk_pre_plane] + ldr x0, [x8, :lo12:p_erase_count_table] + mov w1, wzr + lsl x2, x9, #1 + bl memset + adrp x8, p_swl_mul_table + ldrh w9, [x20, :lo12:c_ftl_nand_blk_pre_plane] + ldr x0, [x8, :lo12:p_swl_mul_table] + mov w1, wzr + lsl x2, x9, #1 + bl memset + adrp x8, g_sys_save_data + adrp x0, g_sys_ext_data + add x8, x8, :lo12:g_sys_save_data + add x0, x0, :lo12:g_sys_ext_data + mov w2, #512 + mov w1, wzr + stp xzr, xzr, [x8] + stp xzr, xzr, [x8, #16] + stp xzr, xzr, [x8, #32] + bl memset + bl FtlGcBufInit + adrp x21, c_ftl_nand_max_map_blks + adrp x20, p_map_block_valid_page_count + ldr w8, [x21, :lo12:c_ftl_nand_max_map_blks] + ldr x0, [x20, :lo12:p_map_block_valid_page_count] + mov w1, wzr + lsl w2, w8, #1 + bl memset + adrp x23, c_ftl_nand_byte_pre_page + adrp x24, c_ftl_nand_l2pmap_ram_region_num + adrp x22, p_l2p_map_buf + ldrh w8, [x23, :lo12:c_ftl_nand_byte_pre_page] + ldrh w9, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num] + ldr x0, [x22, :lo12:p_l2p_map_buf] + mov w1, #255 + mul x2, x9, x8 + bl memset + ldrh w8, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB13_3 +// %bb.1: + mov x8, xzr + mov x9, xzr + mov x10, xzr + adrp x11, p_l2p_ram_map + mov x12, #4294967296 +.LBB13_2: // =>This Inner Loop Header: Depth=1 + ldr x13, [x11, :lo12:p_l2p_ram_map] + add x10, x10, #1 // =1 + add x13, x13, x8 + str wzr, [x13, #4] + ldr x13, [x11, :lo12:p_l2p_ram_map] + strh w19, [x13, x8] + ldrh w13, [x23, :lo12:c_ftl_nand_byte_pre_page] + ldr x14, [x22, :lo12:p_l2p_map_buf] + ldr x15, [x11, :lo12:p_l2p_ram_map] + mul x13, x9, x13 + asr x13, x13, #32 + and x13, x13, #0xfffffffffffffffc + add x13, x14, x13 + add x14, x15, x8 + str x13, [x14, #8] + ldrh w13, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num] + add x9, x9, x12 + add x8, x8, #16 // =16 + cmp x10, x13 + b.lo .LBB13_2 +.LBB13_3: + adrp x8, gL2pMapInfo + add x8, x8, :lo12:gL2pMapInfo + mov w9, #-255655937 + stur w9, [x8, #2] + adrp x9, g_totle_map_block + adrp x11, c_ftl_nand_map_region_num + ldr w10, [x21, :lo12:c_ftl_nand_max_map_blks] + ldrh w9, [x9, :lo12:g_totle_map_block] + ldrh w11, [x11, :lo12:c_ftl_nand_map_region_num] + ldr x12, [x20, :lo12:p_map_block_valid_page_count] + strh w10, [x8, #10] + adrp x10, p_map_block_table + strh w9, [x8, #8] + adrp x9, p_map_block_ver_table + strh w11, [x8, #6] + adrp x11, p_map_region_ppn_table + ldr x10, [x10, :lo12:p_map_block_table] + ldr x9, [x9, :lo12:p_map_block_ver_table] + ldr x11, [x11, :lo12:p_map_region_ppn_table] + strh w19, [x8] + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldp x24, x23, [sp, #16] // 16-byte Folded Reload + stp x10, x9, [x8, #16] + stp x12, x11, [x8, #32] + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end13: + .size FtlVariablesInit, .Lfunc_end13-FtlVariablesInit + // -- End function + .globl FtlGcBufInit // -- Begin function FtlGcBufInit + .p2align 2 + .type FtlGcBufInit,@function +FtlGcBufInit: // @FtlGcBufInit +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_planes_num + ldrh w9, [x8, :lo12:c_ftl_nand_planes_num] + adrp x10, g_gc_num_req + str wzr, [x10, :lo12:g_gc_num_req] + cbz w9, .LBB14_4 +// %bb.1: + mov x9, xzr + mov x10, xzr + mov x11, xzr + adrp x12, gp_gc_page_buf_info + mov w13, #1 + adrp x14, p_gc_data_buf + adrp x15, c_ftl_nand_byte_pre_page + adrp x16, p_gc_spare_buf + adrp x17, c_ftl_nand_byte_pre_oob + adrp x18, req_gc +.LBB14_2: // =>This Inner Loop Header: Depth=1 + ldr x0, [x12, :lo12:gp_gc_page_buf_info] + add x0, x0, x10 + str w13, [x0, #16] + ldrh w0, [x15, :lo12:c_ftl_nand_byte_pre_page] + ldr x1, [x14, :lo12:p_gc_data_buf] + ldr x2, [x12, :lo12:gp_gc_page_buf_info] + mul w0, w11, w0 + add w3, w0, #3 // =3 + cmp w0, #0 // =0 + csel w0, w3, w0, lt + asr w0, w0, #2 + add x0, x1, w0, sxtw #2 + str x0, [x2, x10] + ldrh w0, [x17, :lo12:c_ftl_nand_byte_pre_oob] + ldr x1, [x16, :lo12:p_gc_spare_buf] + ldr x2, [x12, :lo12:gp_gc_page_buf_info] + mul w0, w11, w0 + add w3, w0, #3 // =3 + cmp w0, #0 // =0 + csel w0, w3, w0, lt + asr w0, w0, #2 + add x2, x2, x10 + add x0, x1, w0, sxtw #2 + str x0, [x2, #8] + ldr x0, [x12, :lo12:gp_gc_page_buf_info] + ldr x1, [x18, :lo12:req_gc] + add x11, x11, #1 // =1 + ldr x0, [x0, x10] + add x1, x1, x9 + str x0, [x1, #8] + ldr x0, [x12, :lo12:gp_gc_page_buf_info] + ldr x1, [x18, :lo12:req_gc] + add x0, x0, x10 + ldr x0, [x0, #8] + add x1, x1, x9 + add x10, x10, #24 // =24 + add x9, x9, #32 // =32 + str x0, [x1, #16] + ldrh w0, [x8, :lo12:c_ftl_nand_planes_num] + cmp x11, x0 + b.lo .LBB14_2 +// %bb.3: + mov w8, w0 + b .LBB14_5 +.LBB14_4: + mov w8, wzr +.LBB14_5: + adrp x9, c_gc_page_buf_num + ldr w10, [x9, :lo12:c_gc_page_buf_num] + cmp w10, w8 + b.ls .LBB14_8 +// %bb.6: + adrp x10, gp_gc_page_buf_info + adrp x11, p_gc_data_buf + adrp x12, c_ftl_nand_byte_pre_page + adrp x13, p_gc_spare_buf + adrp x14, c_ftl_nand_byte_pre_oob +.LBB14_7: // =>This Inner Loop Header: Depth=1 + ldr x15, [x10, :lo12:gp_gc_page_buf_info] + and x16, x8, #0xffff + add x16, x16, w8, uxth #1 + lsl x16, x16, #3 + add x15, x15, x16 + str wzr, [x15, #16] + ldrh w15, [x12, :lo12:c_ftl_nand_byte_pre_page] + ldr x17, [x11, :lo12:p_gc_data_buf] + ldr x18, [x10, :lo12:gp_gc_page_buf_info] + mul w15, w8, w15 + add w0, w15, #3 // =3 + cmp w15, #0 // =0 + csel w15, w0, w15, lt + asr w15, w15, #2 + add x15, x17, w15, sxtw #2 + str x15, [x18, x16] + ldrh w15, [x14, :lo12:c_ftl_nand_byte_pre_oob] + ldr x17, [x13, :lo12:p_gc_spare_buf] + ldr x18, [x10, :lo12:gp_gc_page_buf_info] + mul w15, w8, w15 + add w0, w15, #3 // =3 + cmp w15, #0 // =0 + csel w15, w0, w15, lt + asr w15, w15, #2 + add x15, x17, w15, sxtw #2 + add x16, x18, x16 + str x15, [x16, #8] + ldr w15, [x9, :lo12:c_gc_page_buf_num] + add w8, w8, #1 // =1 + and w8, w8, #0xffff + cmp w15, w8 + b.hi .LBB14_7 +.LBB14_8: + hint #29 + ret +.Lfunc_end14: + .size FtlGcBufInit, .Lfunc_end14-FtlGcBufInit + // -- End function + .globl FtlL2PDataInit // -- Begin function FtlL2PDataInit + .p2align 2 + .type FtlL2PDataInit,@function +FtlL2PDataInit: // @FtlL2PDataInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + adrp x20, c_ftl_nand_max_map_blks + adrp x19, p_map_block_valid_page_count + ldr w8, [x20, :lo12:c_ftl_nand_max_map_blks] + ldr x0, [x19, :lo12:p_map_block_valid_page_count] + mov w1, wzr + str x23, [sp, #16] // 8-byte Folded Spill + lsl w2, w8, #1 + stp x22, x21, [sp, #32] // 16-byte Folded Spill + mov x29, sp + bl memset + adrp x22, c_ftl_nand_byte_pre_page + adrp x23, c_ftl_nand_l2pmap_ram_region_num + adrp x21, p_l2p_map_buf + ldrh w8, [x22, :lo12:c_ftl_nand_byte_pre_page] + ldrh w9, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num] + ldr x0, [x21, :lo12:p_l2p_map_buf] + mov w1, #255 + mul x2, x9, x8 + bl memset + ldrh w8, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB15_3 +// %bb.1: + mov x8, xzr + mov x9, xzr + mov x10, xzr + adrp x11, p_l2p_ram_map + mov w12, #65535 + mov x13, #4294967296 +.LBB15_2: // =>This Inner Loop Header: Depth=1 + ldr x14, [x11, :lo12:p_l2p_ram_map] + add x10, x10, #1 // =1 + add x14, x14, x9 + str wzr, [x14, #4] + ldr x14, [x11, :lo12:p_l2p_ram_map] + strh w12, [x14, x9] + ldrh w14, [x22, :lo12:c_ftl_nand_byte_pre_page] + ldr x15, [x21, :lo12:p_l2p_map_buf] + ldr x16, [x11, :lo12:p_l2p_ram_map] + mul x14, x8, x14 + asr x14, x14, #32 + and x14, x14, #0xfffffffffffffffc + add x14, x15, x14 + add x15, x16, x9 + str x14, [x15, #8] + ldrh w14, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num] + add x9, x9, #16 // =16 + add x8, x8, x13 + cmp x10, x14 + b.lo .LBB15_2 +.LBB15_3: + adrp x8, gL2pMapInfo + add x8, x8, :lo12:gL2pMapInfo + mov w9, #-255655937 + mov w10, #65535 + stur w9, [x8, #2] + adrp x9, g_totle_map_block + strh w10, [x8] + adrp x10, c_ftl_nand_map_region_num + ldr w11, [x20, :lo12:c_ftl_nand_max_map_blks] + ldrh w9, [x9, :lo12:g_totle_map_block] + ldrh w10, [x10, :lo12:c_ftl_nand_map_region_num] + ldr x12, [x19, :lo12:p_map_block_valid_page_count] + strh w11, [x8, #10] + adrp x11, p_map_block_table + strh w9, [x8, #8] + adrp x9, p_map_block_ver_table + strh w10, [x8, #6] + adrp x10, p_map_region_ppn_table + ldr x11, [x11, :lo12:p_map_block_table] + ldr x9, [x9, :lo12:p_map_block_ver_table] + ldr x10, [x10, :lo12:p_map_region_ppn_table] + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + stp x11, x9, [x8, #16] + stp x12, x10, [x8, #32] + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end15: + .size FtlL2PDataInit, .Lfunc_end15-FtlL2PDataInit + // -- End function + .globl IsBlkInVendorPart // -- Begin function IsBlkInVendorPart + .p2align 2 + .type IsBlkInVendorPart,@function +IsBlkInVendorPart: // @IsBlkInVendorPart +// %bb.0: + hint #25 + adrp x8, g_totle_vendor_block + ldrh w9, [x8, :lo12:g_totle_vendor_block] + mov w8, wzr + cbz w9, .LBB16_7 +// %bb.1: + adrp x9, c_ftl_nand_max_vendor_blks + ldrh w9, [x9, :lo12:c_ftl_nand_max_vendor_blks] + cbz w9, .LBB16_7 +// %bb.2: + adrp x8, p_vendor_block_table + ldr x8, [x8, :lo12:p_vendor_block_table] + cmp w9, #1 // =1 + csinc w9, w9, wzr, hi +.LBB16_3: // =>This Inner Loop Header: Depth=1 + ldrh w10, [x8] + cmp w10, w0, uxth + b.eq .LBB16_6 +// %bb.4: // in Loop: Header=BB16_3 Depth=1 + subs x9, x9, #1 // =1 + add x8, x8, #2 // =2 + b.ne .LBB16_3 +// %bb.5: + mov w8, wzr + b .LBB16_7 +.LBB16_6: + mov w8, #1 +.LBB16_7: + mov w0, w8 + hint #29 + ret +.Lfunc_end16: + .size IsBlkInVendorPart, .Lfunc_end16-IsBlkInVendorPart + // -- End function + .globl FtlLowFormatEraseBlock // -- Begin function FtlLowFormatEraseBlock + .p2align 2 + .type FtlLowFormatEraseBlock,@function +FtlLowFormatEraseBlock: // @FtlLowFormatEraseBlock +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x17, c_ftl_nand_planes_num + ldrh w8, [x17, :lo12:c_ftl_nand_planes_num] + and w9, w0, #0xffff + adrp x10, g_cur_erase_blk + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + str w9, [x10, :lo12:g_cur_erase_blk] + cbz w8, .LBB17_35 +// %bb.1: + adrp x18, p_plane_order_table + adrp x23, gBbtInfo + mov w19, w1 + mov w20, w0 + mov x8, xzr + mov w21, wzr + mov w24, wzr + adrp x25, req_erase + add x18, x18, :lo12:p_plane_order_table + adrp x16, c_ftl_nand_planes_per_die + adrp x27, c_ftl_nand_blks_per_die + add x23, x23, :lo12:gBbtInfo + adrp x0, p_io_data_buf_1 + adrp x9, p_io_spare_buf + adrp x1, c_ftl_nand_byte_pre_oob + adrp x2, g_totle_vendor_block + adrp x3, c_ftl_nand_max_vendor_blks + adrp x4, p_vendor_block_table + b .LBB17_5 +.LBB17_2: // in Loop: Header=BB17_5 Depth=1 + and w12, w11, #0xffff + and w13, w10, #0xffff + udiv w13, w12, w13 + add x14, x23, w13, uxtw #3 + ldr x14, [x14, #32] + msub w10, w13, w10, w11 + lsr w11, w10, #3 + and x11, x11, #0x1ffc + ldr w11, [x14, x11] + lsr w10, w11, w10 + tbz w10, #0, .LBB17_11 +// %bb.3: // in Loop: Header=BB17_5 Depth=1 + add w24, w24, #1 // =1 +.LBB17_4: // in Loop: Header=BB17_5 Depth=1 + ldrh w10, [x17, :lo12:c_ftl_nand_planes_num] + add x8, x8, #1 // =1 + cmp x8, x10 + b.hs .LBB17_12 +.LBB17_5: // =>This Loop Header: Depth=1 + // Child Loop BB17_9 Depth 2 + ldr x10, [x25, :lo12:req_erase] + lsl x11, x8, #5 + tst w19, #0xff + str wzr, [x10, x11] + ldrb w11, [x18, x8] + ldrh w12, [x16, :lo12:c_ftl_nand_planes_per_die] + ldrh w10, [x27, :lo12:c_ftl_nand_blks_per_die] + and w13, w11, #0xffff + and w14, w12, #0xffff + mul w15, w12, w20 + udiv w13, w13, w14 + madd w14, w10, w13, w15 + msub w11, w13, w12, w11 + add w11, w14, w11 + b.eq .LBB17_2 +// %bb.6: // in Loop: Header=BB17_5 Depth=1 + ldrh w12, [x2, :lo12:g_totle_vendor_block] + cbz w12, .LBB17_2 +// %bb.7: // in Loop: Header=BB17_5 Depth=1 + ldrh w13, [x3, :lo12:c_ftl_nand_max_vendor_blks] + cbz w13, .LBB17_2 +// %bb.8: // in Loop: Header=BB17_5 Depth=1 + ldr x12, [x4, :lo12:p_vendor_block_table] + cmp w13, #1 // =1 + csinc w13, w13, wzr, hi +.LBB17_9: // Parent Loop BB17_5 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w14, [x12] + cmp w14, w11, uxth + b.eq .LBB17_4 +// %bb.10: // in Loop: Header=BB17_9 Depth=2 + subs x13, x13, #1 // =1 + add x12, x12, #2 // =2 + b.ne .LBB17_9 + b .LBB17_2 +.LBB17_11: // in Loop: Header=BB17_5 Depth=1 + ldr x10, [x25, :lo12:req_erase] + lsl w11, w12, #10 + and x12, x21, #0xffff + lsl x12, x12, #5 + add x10, x10, x12 + str w11, [x10, #4] + ldr x10, [x25, :lo12:req_erase] + ldr x11, [x0, :lo12:p_io_data_buf_1] + and w13, w21, #0xffff + add w21, w21, #1 // =1 + add x10, x10, x12 + str x11, [x10, #8] + ldrh w10, [x1, :lo12:c_ftl_nand_byte_pre_oob] + ldr x11, [x25, :lo12:req_erase] + mul w10, w10, w13 + ldr x13, [x9, :lo12:p_io_spare_buf] + add x11, x11, x12 + add w12, w10, #3 // =3 + cmp w10, #0 // =0 + csel w10, w12, w10, lt + asr w10, w10, #2 + add x10, x13, w10, sxtw #2 + str x10, [x11, #16] + b .LBB17_4 +.LBB17_12: + tst w21, #0xffff + b.eq .LBB17_36 +// %bb.13: + ldr x0, [x25, :lo12:req_erase] + and w2, w21, #0xffff + bl FlashEraseBlocks + // kill: def $w21 killed $w21 killed $x21 def $x21 + and x8, x21, #0xffff + adrp x22, .L.str.82 + mov x26, xzr + mov w21, #1 + lsl x28, x8, #5 + add x22, x22, :lo12:.L.str.82 + b .LBB17_15 +.LBB17_14: // in Loop: Header=BB17_15 Depth=1 + add x26, x26, #32 // =32 + cmp x28, x26 + b.eq .LBB17_17 +.LBB17_15: // =>This Inner Loop Header: Depth=1 + ldr x8, [x25, :lo12:req_erase] + ldr w9, [x8, x26] + cmn w9, #1 // =1 + b.ne .LBB17_14 +// %bb.16: // in Loop: Header=BB17_15 Depth=1 + add x8, x8, x26 + ldr w8, [x8, #4] + ldrh w9, [x27, :lo12:c_ftl_nand_blks_per_die] + mov x0, x22 + add w24, w24, #1 // =1 + ubfx w1, w8, #10, #16 + udiv w2, w1, w9 + lsr w10, w8, #10 + add x8, x23, w2, uxtw #3 + ldr x8, [x8, #32] + msub w9, w2, w9, w10 + ubfx w10, w9, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x8, x10] + and w3, w9, #0xffff + lsl w9, w21, w9 + orr w4, w9, w11 + str w4, [x8, x10] + bl sftl_printk + ldrh w8, [x23, #6] + add w8, w8, #1 // =1 + strh w8, [x23, #6] + b .LBB17_14 +.LBB17_17: + adrp x8, c_ftl_nand_page_pre_slc_blk + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_slc_blk] + tst w19, #0xff + mov w9, #2 + adrp x22, .L.str.82 + mov w5, wzr + adrp x6, p_io_data_buf_0 + cset w10, ne + csel w8, w9, w8, eq + add x22, x22, :lo12:.L.str.82 + adrp x16, c_ftl_nand_planes_per_die + stp w8, w10, [sp, #4] // 8-byte Folded Spill + b .LBB17_19 +.LBB17_18: // in Loop: Header=BB17_19 Depth=1 + ldur w5, [x29, #-4] // 4-byte Folded Reload + ldr w8, [sp, #4] // 4-byte Folded Reload + adrp x16, c_ftl_nand_planes_per_die + adrp x6, p_io_data_buf_0 + add w5, w5, #1 // =1 + cmp w8, w5, uxth + b.ls .LBB17_37 +.LBB17_19: // =>This Loop Header: Depth=1 + // Child Loop BB17_23 Depth 2 + // Child Loop BB17_27 Depth 3 + // Child Loop BB17_33 Depth 2 + adrp x17, c_ftl_nand_planes_num + ldrh w8, [x17, :lo12:c_ftl_nand_planes_num] + cbz w8, .LBB17_36 +// %bb.20: // in Loop: Header=BB17_19 Depth=1 + adrp x18, p_plane_order_table + mov x8, xzr + mov w26, wzr + and w9, w5, #0xffff + add x18, x18, :lo12:p_plane_order_table + adrp x0, p_io_data_buf_1 + adrp x1, c_ftl_nand_byte_pre_oob + adrp x2, g_totle_vendor_block + adrp x3, c_ftl_nand_max_vendor_blks + adrp x4, p_vendor_block_table + b .LBB17_23 +.LBB17_21: // in Loop: Header=BB17_23 Depth=2 + and w12, w11, #0xffff + and w13, w10, #0xffff + udiv w13, w12, w13 + add x14, x23, w13, uxtw #3 + ldr x14, [x14, #32] + msub w10, w13, w10, w11 + lsr w11, w10, #3 + and x11, x11, #0x1ffc + ldr w11, [x14, x11] + lsr w10, w11, w10 + tbz w10, #0, .LBB17_29 +.LBB17_22: // in Loop: Header=BB17_23 Depth=2 + ldrh w10, [x17, :lo12:c_ftl_nand_planes_num] + add x8, x8, #1 // =1 + cmp x8, x10 + b.hs .LBB17_30 +.LBB17_23: // Parent Loop BB17_19 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB17_27 Depth 3 + ldr x10, [x25, :lo12:req_erase] + lsl x11, x8, #5 + tst w19, #0xff + str wzr, [x10, x11] + ldrb w11, [x18, x8] + ldrh w12, [x16, :lo12:c_ftl_nand_planes_per_die] + ldrh w10, [x27, :lo12:c_ftl_nand_blks_per_die] + and w13, w11, #0xffff + and w14, w12, #0xffff + mul w15, w12, w20 + udiv w13, w13, w14 + madd w14, w10, w13, w15 + msub w11, w13, w12, w11 + add w11, w14, w11 + b.eq .LBB17_21 +// %bb.24: // in Loop: Header=BB17_23 Depth=2 + ldrh w12, [x2, :lo12:g_totle_vendor_block] + cbz w12, .LBB17_21 +// %bb.25: // in Loop: Header=BB17_23 Depth=2 + ldrh w13, [x3, :lo12:c_ftl_nand_max_vendor_blks] + cbz w13, .LBB17_21 +// %bb.26: // in Loop: Header=BB17_23 Depth=2 + ldr x12, [x4, :lo12:p_vendor_block_table] + cmp w13, #1 // =1 + csinc w13, w13, wzr, hi +.LBB17_27: // Parent Loop BB17_19 Depth=1 + // Parent Loop BB17_23 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrh w14, [x12] + cmp w14, w11, uxth + b.eq .LBB17_22 +// %bb.28: // in Loop: Header=BB17_27 Depth=3 + subs x13, x13, #1 // =1 + add x12, x12, #2 // =2 + b.ne .LBB17_27 + b .LBB17_21 +.LBB17_29: // in Loop: Header=BB17_23 Depth=2 + ldr x10, [x25, :lo12:req_erase] + add w11, w9, w12, lsl #10 + and x12, x26, #0xffff + lsl x12, x12, #5 + add x10, x10, x12 + str w11, [x10, #4] + ldr x10, [x25, :lo12:req_erase] + ldr x11, [x6, :lo12:p_io_data_buf_0] + and w13, w26, #0xffff + add w26, w26, #1 // =1 + add x10, x10, x12 + str x11, [x10, #8] + ldrh w10, [x1, :lo12:c_ftl_nand_byte_pre_oob] + ldr x11, [x25, :lo12:req_erase] + mul w10, w10, w13 + ldr x13, [x0, :lo12:p_io_data_buf_1] + add x11, x11, x12 + add w12, w10, #3 // =3 + cmp w10, #0 // =0 + csel w10, w12, w10, lt + asr w10, w10, #2 + add x10, x13, w10, sxtw #2 + str x10, [x11, #16] + b .LBB17_22 +.LBB17_30: // in Loop: Header=BB17_19 Depth=1 + ands w1, w26, #0xffff + b.eq .LBB17_36 +// %bb.31: // in Loop: Header=BB17_19 Depth=1 + ldr x0, [x25, :lo12:req_erase] + ldr w2, [sp, #8] // 4-byte Folded Reload + stur w5, [x29, #-4] // 4-byte Folded Spill + str w1, [sp] // 4-byte Folded Spill + bl FlashProgPages + mov w8, w26 + and x8, x8, #0xffff + mov x28, xzr + lsl x21, x8, #5 + b .LBB17_33 +.LBB17_32: // in Loop: Header=BB17_33 Depth=2 + add x28, x28, #32 // =32 + cmp x21, x28 + b.eq .LBB17_18 +.LBB17_33: // Parent Loop BB17_19 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x8, [x25, :lo12:req_erase] + ldr w9, [x8, x28] + cbz w9, .LBB17_32 +// %bb.34: // in Loop: Header=BB17_33 Depth=2 + add x8, x8, x28 + ldr w8, [x8, #4] + ldrh w9, [x27, :lo12:c_ftl_nand_blks_per_die] + mov w12, #1 + mov x0, x22 + ubfx w1, w8, #10, #16 + udiv w2, w1, w9 + lsr w10, w8, #10 + add x8, x23, w2, uxtw #3 + ldr x8, [x8, #32] + msub w9, w2, w9, w10 + ubfx w10, w9, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x8, x10] + and w3, w9, #0xffff + lsl w9, w12, w9 + add w24, w24, #1 // =1 + orr w4, w9, w11 + str w4, [x8, x10] + bl sftl_printk + ldrh w8, [x23, #6] + add w8, w8, #1 // =1 + strh w8, [x23, #6] + b .LBB17_32 +.LBB17_35: + mov w24, wzr +.LBB17_36: + and w0, w24, #0xffff + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.LBB17_37: + and w8, w26, #0xffff + cmp w8, #1 // =1 + csinc w8, w26, wzr, hi + and x8, x8, #0xffff + mov x21, xzr + mov w12, #65535 + adrp x23, gSysFreeQueue+6 + lsl x26, x8, #5 + b .LBB17_39 +.LBB17_38: // in Loop: Header=BB17_39 Depth=1 + add x21, x21, #32 // =32 + cmp x26, x21 + b.eq .LBB17_45 +.LBB17_39: // =>This Inner Loop Header: Depth=1 + tst w19, #0xff + b.eq .LBB17_38 +// %bb.40: // in Loop: Header=BB17_39 Depth=1 + ldr x8, [x25, :lo12:req_erase] + ldr w9, [x8, x21] + cbnz w9, .LBB17_38 +// %bb.41: // in Loop: Header=BB17_39 Depth=1 + add x9, x8, x21 + ldr w10, [x9, #4] + ubfx w9, w10, #10, #16 + cbz w9, .LBB17_38 +// %bb.42: // in Loop: Header=BB17_39 Depth=1 + cmp w9, w12 + b.eq .LBB17_38 +// %bb.43: // in Loop: Header=BB17_39 Depth=1 + ldrh w11, [x23, :lo12:gSysFreeQueue+6] + cmp w11, #1024 // =1024 + b.eq .LBB17_38 +// %bb.44: // in Loop: Header=BB17_39 Depth=1 + lsr w28, w10, #10 + ldrh w11, [x27, :lo12:c_ftl_nand_blks_per_die] + and w10, w10, #0x3fffc00 + ldrh w12, [x16, :lo12:c_ftl_nand_planes_per_die] + str w10, [x8, #4] + ldr x0, [x25, :lo12:req_erase] + udiv w8, w9, w11 + msub w8, w8, w11, w9 + mov w2, #1 + udiv w22, w8, w12 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x22, #1 + adrp x11, g_totle_sys_slc_erase_count + adrp x14, gSysFreeQueue + ldrh w10, [x8, x9] + add x14, x14, :lo12:gSysFreeQueue + mov w12, #65535 + adrp x16, c_ftl_nand_planes_per_die + add w10, w10, #1 // =1 + strh w10, [x8, x9] + ldr w8, [x11, :lo12:g_totle_sys_slc_erase_count] + ldrh w9, [x14, #6] + ldrh w10, [x14, #4] + add w8, w8, #1 // =1 + add w9, w9, #1 // =1 + str w8, [x11, :lo12:g_totle_sys_slc_erase_count] + add x8, x14, x10, lsl #1 + add w10, w10, #1 // =1 + strh w9, [x14, #6] + strh w28, [x8, #8] + and w8, w10, #0x3ff + strh w8, [x14, #4] + b .LBB17_38 +.LBB17_45: + and w8, w20, #0xffff + cmp w8, #64 // =64 + b.lo .LBB17_47 +// %bb.46: + tst w19, #0xff + b.eq .LBB17_36 +.LBB17_47: + ldr x0, [x25, :lo12:req_erase] + ldr w2, [sp] // 4-byte Folded Reload + bl FlashEraseBlocks + b .LBB17_36 +.Lfunc_end17: + .size FtlLowFormatEraseBlock, .Lfunc_end17-FtlLowFormatEraseBlock + // -- End function + .globl V2P_block // -- Begin function V2P_block + .p2align 2 + .type V2P_block,@function +V2P_block: // @V2P_block +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_planes_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_planes_per_die] + adrp x10, c_ftl_nand_blks_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_blks_per_die] + and w9, w0, #0xffff + and w11, w8, #0xffff + mul w12, w8, w1 + udiv w9, w9, w11 + madd w10, w10, w9, w12 + msub w8, w9, w8, w0 + add w0, w10, w8 + hint #29 + ret +.Lfunc_end18: + .size V2P_block, .Lfunc_end18-V2P_block + // -- End function + .globl FtlBbmIsBadBlock // -- Begin function FtlBbmIsBadBlock + .p2align 2 + .type FtlBbmIsBadBlock,@function +FtlBbmIsBadBlock: // @FtlBbmIsBadBlock +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + and w9, w0, #0xffff + and w10, w8, #0xffff + udiv w9, w9, w10 + adrp x10, gBbtInfo + add x10, x10, :lo12:gBbtInfo + add x10, x10, w9, uxtw #3 + ldr x10, [x10, #32] + msub w8, w9, w8, w0 + lsr w9, w8, #3 + and x9, x9, #0x1ffc + ldr w9, [x10, x9] + hint #29 + lsr w8, w9, w8 + and w0, w8, #0x1 + ret +.Lfunc_end19: + .size FtlBbmIsBadBlock, .Lfunc_end19-FtlBbmIsBadBlock + // -- End function + .globl FlashEraseBlocks // -- Begin function FlashEraseBlocks + .p2align 2 + .type FlashEraseBlocks,@function +FlashEraseBlocks: // @FlashEraseBlocks +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + str x0, [sp] // 8-byte Folded Spill + cbz w2, .LBB20_17 +// %bb.1: + adrp x8, g_nand_phy_info+12 + ldrh w23, [x8, :lo12:g_nand_phy_info+12] + ldr x19, [sp] // 8-byte Folded Reload + adrp x24, g_nand_phy_info+8 + mov w22, w2 + add x24, x24, :lo12:g_nand_phy_info+8 + adrp x25, g_nand_ops+8 + adrp x26, g_nand_phy_info+14 + lsl w27, w23, #3 + mov w28, #-1 + str x22, [sp, #8] // 8-byte Folded Spill + b .LBB20_3 +.LBB20_2: // in Loop: Header=BB20_3 Depth=1 + subs x22, x22, #1 // =1 + add x19, x19, #32 // =32 + b.eq .LBB20_17 +.LBB20_3: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x24, #6] + ldr w9, [x19, #4] + ldrh w10, [x24] + ldrh w11, [x24, #2] + cmp w8, #4 // =4 + cset w12, eq + ubfx w8, w9, #10, #16 + lsr w10, w10, w12 + lsl w11, w11, w12 + udiv w21, w8, w10 + and w9, w9, #0x3ff + and w11, w11, #0xffff + msub w12, w10, w21, w8 + cmp w10, w8 + madd w20, w12, w11, w9 + b.ls .LBB20_5 +// %bb.4: // in Loop: Header=BB20_3 Depth=1 + cmp w20, w27 + b.lo .LBB20_8 +.LBB20_5: // in Loop: Header=BB20_3 Depth=1 + ldr x8, [x25, :lo12:g_nand_ops+8] + mov w0, w21 + mov w1, w20 + blr x8 + cmp w0, #0 // =0 + csetm w8, ne + str w8, [x19] + ldrh w8, [x26, :lo12:g_nand_phy_info+14] + cmp w8, #4 // =4 + b.ne .LBB20_2 +// %bb.6: // in Loop: Header=BB20_3 Depth=1 + ldr x8, [x25, :lo12:g_nand_ops+8] + add w1, w20, w23 + mov w0, w21 + blr x8 + cbz w0, .LBB20_2 +// %bb.7: // in Loop: Header=BB20_3 Depth=1 + str w28, [x19] + b .LBB20_2 +.LBB20_8: + ldr x22, [sp] // 8-byte Folded Reload + adrp x23, .L.str.116 + adrp x24, .L.str.124 + adrp x25, .L.str.117 + adrp x26, .L.str.120 + mov x27, xzr + add x23, x23, :lo12:.L.str.116 + add x24, x24, :lo12:.L.str.124 + add x25, x25, :lo12:.L.str.117 + add x26, x26, :lo12:.L.str.120 + b .LBB20_10 +.LBB20_9: // in Loop: Header=BB20_10 Depth=1 + mov x0, x26 + bl sftl_printk + add x8, x22, x27, lsl #5 + ldr x21, [x8, #16] + adrp x1, .L.str.125 + mov x0, x23 + add x1, x1, :lo12:.L.str.125 + mov x2, x21 + mov w3, wzr + bl sftl_printk + ldr w1, [x21] + mov x0, x25 + bl sftl_printk + ldr w1, [x21, #4] + mov x0, x25 + bl sftl_printk + ldr w1, [x21, #8] + mov x0, x25 + bl sftl_printk + ldr w1, [x21, #12] + mov x0, x25 + bl sftl_printk + mov x0, x26 + bl sftl_printk + ldr x8, [sp, #8] // 8-byte Folded Reload + add x27, x27, #1 // =1 + cmp x27, x8 + b.eq .LBB20_16 +.LBB20_10: // =>This Loop Header: Depth=1 + // Child Loop BB20_13 Depth 2 + adrp x0, .L.str.123 + adrp x1, .L__func__.FlashEraseBlocks + add x19, x22, x27, lsl #5 + mov w8, #-1 + add x0, x0, :lo12:.L.str.123 + add x1, x1, :lo12:.L__func__.FlashEraseBlocks + mov w2, w20 + str w8, [x19] + bl sftl_printk + ldr x21, [x19, #8] + mov x28, xzr + mov w19, wzr + b .LBB20_13 +.LBB20_11: // in Loop: Header=BB20_13 Depth=2 + ldr w1, [x21, x28] + mov x0, x25 + bl sftl_printk + add w19, w19, #1 // =1 + cmp w19, #16 // =16 + b.hs .LBB20_15 +.LBB20_12: // in Loop: Header=BB20_13 Depth=2 + add x28, x28, #4 // =4 + cmp x28, #64 // =64 + b.eq .LBB20_9 +.LBB20_13: // Parent Loop BB20_10 Depth=1 + // => This Inner Loop Header: Depth=2 + cbnz w19, .LBB20_11 +// %bb.14: // in Loop: Header=BB20_13 Depth=2 + mov x0, x23 + mov x1, x24 + mov x2, x21 + mov w3, w28 + bl sftl_printk + b .LBB20_11 +.LBB20_15: // in Loop: Header=BB20_13 Depth=2 + mov x0, x26 + bl sftl_printk + mov w19, wzr + b .LBB20_12 +.LBB20_16: + bl dump_stack +.LBB20_17: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.Lfunc_end20: + .size FlashEraseBlocks, .Lfunc_end20-FlashEraseBlocks + // -- End function + .globl FtlBbmMapBadBlock // -- Begin function FtlBbmMapBadBlock + .p2align 2 + .type FtlBbmMapBadBlock,@function +FtlBbmMapBadBlock: // @FtlBbmMapBadBlock +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + str x19, [sp, #16] // 8-byte Folded Spill + and w1, w0, #0xffff + adrp x19, gBbtInfo + udiv w2, w1, w8 + add x19, x19, :lo12:gBbtInfo + add x9, x19, w2, uxtw #3 + ldr x9, [x9, #32] + msub w8, w2, w8, w0 + ubfx w10, w8, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x9, x10] + mov w12, #1 + lsl w12, w12, w8 + adrp x0, .L.str.82 + and w3, w8, #0xffff + orr w4, w12, w11 + add x0, x0, :lo12:.L.str.82 + mov x29, sp + str w4, [x9, x10] + bl sftl_printk + ldrh w8, [x19, #6] + mov w0, wzr + add w8, w8, #1 // =1 + strh w8, [x19, #6] + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end21: + .size FtlBbmMapBadBlock, .Lfunc_end21-FtlBbmMapBadBlock + // -- End function + .globl FlashProgPages // -- Begin function FlashProgPages + .p2align 2 + .type FlashProgPages,@function +FlashProgPages: // @FlashProgPages +// %bb.0: + hint #25 + sub sp, sp, #160 // =160 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #64] // 16-byte Folded Spill + add x29, sp, #64 // =64 + stp x28, x27, [sp, #80] // 16-byte Folded Spill + stp x26, x25, [sp, #96] // 16-byte Folded Spill + stp x24, x23, [sp, #112] // 16-byte Folded Spill + stp x22, x21, [sp, #128] // 16-byte Folded Spill + stp x20, x19, [sp, #144] // 16-byte Folded Spill + stur x8, [x29, #-8] + cbz w1, .LBB22_39 +// %bb.1: + adrp x8, g_nand_phy_info+12 + ldrh w8, [x8, :lo12:g_nand_phy_info+12] + mov w21, w1 + adrp x26, .L.str.78 + adrp x22, .L__func__.FlashProgPages + adrp x24, g_nand_phy_info+8 + mov x19, x0 + add x27, x0, #16 // =16 + add x26, x26, :lo12:.L.str.78 + add x22, x22, :lo12:.L__func__.FlashProgPages + add x24, x24, :lo12:g_nand_phy_info+8 + adrp x28, sftl_nand_check_buf + stp w1, w8, [sp, #4] // 8-byte Folded Spill + lsl w8, w8, #3 + mov x20, x21 + str w8, [sp, #12] // 4-byte Folded Spill + str x21, [sp, #16] // 8-byte Folded Spill + b .LBB22_4 +.LBB22_2: // in Loop: Header=BB22_4 Depth=1 + mov w8, #-1 + stur w8, [x27, #-16] +.LBB22_3: // in Loop: Header=BB22_4 Depth=1 + adrp x24, g_nand_phy_info+8 + subs x20, x20, #1 // =1 + add x27, x27, #32 // =32 + add x24, x24, :lo12:g_nand_phy_info+8 + b.eq .LBB22_16 +.LBB22_4: // =>This Inner Loop Header: Depth=1 + ldur x8, [x27, #-8] + cbz x8, .LBB22_6 +// %bb.5: // in Loop: Header=BB22_4 Depth=1 + ldr x8, [x27] + cbnz x8, .LBB22_7 +.LBB22_6: // in Loop: Header=BB22_4 Depth=1 + mov w2, #148 + mov x0, x26 + mov x1, x22 + bl sftl_printk +.LBB22_7: // in Loop: Header=BB22_4 Depth=1 + ldrh w9, [x24, #6] + ldrh w11, [x24] + ldur w8, [x27, #-12] + cmp w9, #4 // =4 + cset w10, eq + lsr w9, w11, w10 + ubfx w11, w8, #10, #16 + udiv w23, w11, w9 + cmp w23, #4 // =4 + b.hs .LBB22_2 +// %bb.8: // in Loop: Header=BB22_4 Depth=1 + ldrh w12, [x24, #2] + msub w11, w9, w23, w11 + and w13, w8, #0x3ff + lsr w8, w8, #10 + lsl w10, w12, w10 + and w10, w10, #0xffff + cmp w9, w8, uxth + madd w24, w11, w10, w13 + b.ls .LBB22_10 +// %bb.9: // in Loop: Header=BB22_4 Depth=1 + ldr w8, [sp, #12] // 4-byte Folded Reload + cmp w24, w8 + b.lo .LBB22_30 +.LBB22_10: // in Loop: Header=BB22_4 Depth=1 + ldur x25, [x27, #-8] + tst x25, #0x3f + b.eq .LBB22_14 +// %bb.11: // in Loop: Header=BB22_4 Depth=1 + mov x8, x28 + mov x28, x26 + ldr x26, [x8, :lo12:sftl_nand_check_buf] + mov x21, x22 + mov x22, x8 + cmp x25, x26 + b.eq .LBB22_13 +// %bb.12: // in Loop: Header=BB22_4 Depth=1 + adrp x8, c_ftl_nand_sec_pre_page + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page] + mov x0, x26 + mov x1, x25 + lsl x2, x8, #9 + bl memcpy + mov x25, x26 +.LBB22_13: // in Loop: Header=BB22_4 Depth=1 + mov x26, x28 + mov x28, x22 + mov x22, x21 + ldr x21, [sp, #16] // 8-byte Folded Reload +.LBB22_14: // in Loop: Header=BB22_4 Depth=1 + adrp x8, g_nand_ops+16 + ldr x8, [x8, :lo12:g_nand_ops+16] + ldr x3, [x27] + mov w0, w23 + mov w1, w24 + mov x2, x25 + blr x8 + cmp w0, #0 // =0 + csetm w8, ne + stur w8, [x27, #-16] + adrp x8, g_nand_phy_info+14 + ldrh w8, [x8, :lo12:g_nand_phy_info+14] + cmp w8, #4 // =4 + b.ne .LBB22_3 +// %bb.15: // in Loop: Header=BB22_4 Depth=1 + ldr x8, [x27] + adrp x9, g_nand_ops+16 + ldr w10, [sp, #8] // 4-byte Folded Reload + ldr x9, [x9, :lo12:g_nand_ops+16] + add x2, x25, #2048 // =2048 + add x3, x8, #8 // =8 + add w1, w24, w10 + mov w0, w23 + blr x9 + cbnz w0, .LBB22_2 + b .LBB22_3 +.LBB22_16: + ldr w8, [sp, #4] // 4-byte Folded Reload + cbz w8, .LBB22_39 +// %bb.17: + adrp x24, .L.str.126 + adrp x22, .L.str.129 + adrp x20, .L.str.128 + adrp x26, .L.str.127 + adrp x23, sftl_nand_check_spare_buf + add x24, x24, :lo12:.L.str.126 + add x22, x22, :lo12:.L.str.129 + mov w25, #-1 + add x20, x20, :lo12:.L.str.128 + add x26, x26, :lo12:.L.str.127 + b .LBB22_19 +.LBB22_18: // in Loop: Header=BB22_19 Depth=1 + subs x21, x21, #1 // =1 + add x19, x19, #32 // =32 + b.eq .LBB22_39 +.LBB22_19: // =>This Inner Loop Header: Depth=1 + ldr x8, [x28, :lo12:sftl_nand_check_buf] + add x0, sp, #24 // =24 + mov w1, #1 + str wzr, [x8] + ldr x8, [x23, :lo12:sftl_nand_check_spare_buf] + str wzr, [x8] + ldr w8, [x19, #4] + ldr x9, [x28, :lo12:sftl_nand_check_buf] + ldr x10, [x23, :lo12:sftl_nand_check_spare_buf] + str w8, [sp, #28] + stp x9, x10, [sp, #32] + bl FlashReadPages + ldr w27, [sp, #24] + cmn w27, #1 // =1 + b.eq .LBB22_22 +// %bb.20: // in Loop: Header=BB22_19 Depth=1 + cmp w27, #256 // =256 + b.ne .LBB22_24 +// %bb.21: // in Loop: Header=BB22_19 Depth=1 + mov x0, x26 + b .LBB22_23 +.LBB22_22: // in Loop: Header=BB22_19 Depth=1 + mov x0, x24 +.LBB22_23: // in Loop: Header=BB22_19 Depth=1 + ldr w1, [x19, #4] + bl sftl_printk + str w27, [x19] +.LBB22_24: // in Loop: Header=BB22_19 Depth=1 + ldr x8, [x19, #16] + cbz x8, .LBB22_27 +// %bb.25: // in Loop: Header=BB22_19 Depth=1 + ldr x9, [x23, :lo12:sftl_nand_check_spare_buf] + ldr w2, [x8] + ldr w3, [x9] + cmp w2, w3 + b.eq .LBB22_27 +// %bb.26: // in Loop: Header=BB22_19 Depth=1 + ldr w1, [x19, #4] + mov x0, x20 + bl sftl_printk + str w25, [x19] +.LBB22_27: // in Loop: Header=BB22_19 Depth=1 + ldr x8, [x19, #8] + cbz x8, .LBB22_18 +// %bb.28: // in Loop: Header=BB22_19 Depth=1 + ldr x9, [x28, :lo12:sftl_nand_check_buf] + ldr w2, [x8] + ldr w3, [x9] + cmp w2, w3 + b.eq .LBB22_18 +// %bb.29: // in Loop: Header=BB22_19 Depth=1 + ldr w1, [x19, #4] + mov x0, x22 + bl sftl_printk + str w25, [x19] + b .LBB22_18 +.LBB22_30: + adrp x22, .L.str.116 + adrp x23, .L.str.124 + adrp x24, .L.str.117 + adrp x25, .L.str.120 + mov x20, xzr + add x22, x22, :lo12:.L.str.116 + add x23, x23, :lo12:.L.str.124 + add x24, x24, :lo12:.L.str.117 + add x25, x25, :lo12:.L.str.120 + b .LBB22_32 +.LBB22_31: // in Loop: Header=BB22_32 Depth=1 + mov x0, x25 + bl sftl_printk + add x8, x19, x20, lsl #5 + ldr x27, [x8, #16] + adrp x1, .L.str.125 + mov x0, x22 + add x1, x1, :lo12:.L.str.125 + mov x2, x27 + mov w3, wzr + bl sftl_printk + ldr w1, [x27] + mov x0, x24 + bl sftl_printk + ldr w1, [x27, #4] + mov x0, x24 + bl sftl_printk + ldr w1, [x27, #8] + mov x0, x24 + bl sftl_printk + ldr w1, [x27, #12] + mov x0, x24 + bl sftl_printk + mov x0, x25 + bl sftl_printk + add x20, x20, #1 // =1 + cmp x20, x21 + b.eq .LBB22_38 +.LBB22_32: // =>This Loop Header: Depth=1 + // Child Loop BB22_35 Depth 2 + add x26, x19, x20, lsl #5 + ldr w2, [x26, #4] + adrp x0, .L.str.123 + adrp x1, .L__func__.FlashProgPages + mov w8, #-1 + add x0, x0, :lo12:.L.str.123 + add x1, x1, :lo12:.L__func__.FlashProgPages + str w8, [x26] + bl sftl_printk + ldr x28, [x26, #8] + mov x27, xzr + mov w26, wzr + b .LBB22_35 +.LBB22_33: // in Loop: Header=BB22_35 Depth=2 + ldr w1, [x28, x27] + mov x0, x24 + bl sftl_printk + add w26, w26, #1 // =1 + cmp w26, #16 // =16 + b.hs .LBB22_37 +.LBB22_34: // in Loop: Header=BB22_35 Depth=2 + add x27, x27, #4 // =4 + cmp x27, #64 // =64 + b.eq .LBB22_31 +.LBB22_35: // Parent Loop BB22_32 Depth=1 + // => This Inner Loop Header: Depth=2 + cbnz w26, .LBB22_33 +// %bb.36: // in Loop: Header=BB22_35 Depth=2 + mov x0, x22 + mov x1, x23 + mov x2, x28 + mov w3, w27 + bl sftl_printk + b .LBB22_33 +.LBB22_37: // in Loop: Header=BB22_35 Depth=2 + mov x0, x25 + bl sftl_printk + mov w26, wzr + b .LBB22_34 +.LBB22_38: + bl dump_stack +.LBB22_39: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB22_41 +// %bb.40: + ldp x20, x19, [sp, #144] // 16-byte Folded Reload + ldp x22, x21, [sp, #128] // 16-byte Folded Reload + ldp x24, x23, [sp, #112] // 16-byte Folded Reload + ldp x26, x25, [sp, #96] // 16-byte Folded Reload + ldp x28, x27, [sp, #80] // 16-byte Folded Reload + ldp x29, x30, [sp, #64] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #160 // =160 + hint #29 + ret +.LBB22_41: + bl __stack_chk_fail +.Lfunc_end22: + .size FlashProgPages, .Lfunc_end22-FlashProgPages + // -- End function + .globl FtlFreeSysBlkQueueIn // -- Begin function FtlFreeSysBlkQueueIn + .p2align 2 + .type FtlFreeSysBlkQueueIn,@function +FtlFreeSysBlkQueueIn: // @FtlFreeSysBlkQueueIn +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + ands w8, w0, #0xffff + str x21, [sp, #16] // 8-byte Folded Spill + stp x20, x19, [sp, #32] // 16-byte Folded Spill + mov x29, sp + b.eq .LBB23_6 +// %bb.1: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB23_6 +// %bb.2: + adrp x20, gSysFreeQueue+6 + ldrh w9, [x20, :lo12:gSysFreeQueue+6] + cmp w9, #1024 // =1024 + b.eq .LBB23_6 +// %bb.3: + mov w19, w0 + tst w1, #0xffff + b.eq .LBB23_5 +// %bb.4: + adrp x11, req_erase + ldr x12, [x11, :lo12:req_erase] + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x13, c_ftl_nand_planes_per_die + lsl w8, w8, #10 + ldrh w13, [x13, :lo12:c_ftl_nand_planes_per_die] + str w8, [x12, #4] + ldr x0, [x11, :lo12:req_erase] + and w10, w19, #0xffff + udiv w8, w10, w9 + msub w8, w8, w9, w10 + mov w2, #1 + udiv w21, w8, w13 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x21, #1 + ldrh w10, [x8, x9] + add w10, w10, #1 // =1 + strh w10, [x8, x9] + adrp x8, g_totle_sys_slc_erase_count + ldr w10, [x8, :lo12:g_totle_sys_slc_erase_count] + ldrh w9, [x20, :lo12:gSysFreeQueue+6] + add w10, w10, #1 // =1 + str w10, [x8, :lo12:g_totle_sys_slc_erase_count] +.LBB23_5: + adrp x8, gSysFreeQueue + add x8, x8, :lo12:gSysFreeQueue + ldrh w10, [x8, #4] + add w9, w9, #1 // =1 + strh w9, [x8, #6] + add x9, x8, x10, lsl #1 + add w10, w10, #1 // =1 + strh w19, [x9, #8] + and w9, w10, #0x3ff + strh w9, [x8, #4] +.LBB23_6: + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldr x21, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end23: + .size FtlFreeSysBlkQueueIn, .Lfunc_end23-FtlFreeSysBlkQueueIn + // -- End function + .globl ftl_low_format // -- Begin function ftl_low_format + .p2align 2 + .type ftl_low_format,@function +ftl_low_format: // @ftl_low_format +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + adrp x8, g_GlobalDataVersion + adrp x25, c_ftl_nand_max_sys_blks + str wzr, [x8, :lo12:g_GlobalDataVersion] + ldr w8, [x25, :lo12:c_ftl_nand_max_sys_blks] + stp x22, x21, [sp, #64] // 16-byte Folded Spill + adrp x21, gSysFreeQueue + add x21, x21, :lo12:gSysFreeQueue + adrp x10, g_GlobalSysVersion + adrp x9, g_totle_avg_erase_count + add x0, x21, #8 // =8 + mov w2, #2048 + mov w1, wzr + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + mov x29, sp + str wzr, [x10, :lo12:g_GlobalSysVersion] + str wzr, [x9, :lo12:g_totle_avg_erase_count] + stur wzr, [x21, #2] + strh wzr, [x21, #6] + strh w8, [x21] + bl memset + bl FtlLoadBbt + cbz w0, .LBB24_2 +// %bb.1: + bl FtlMakeBbt +.LBB24_2: + adrp x22, c_ftl_nand_sec_pre_page + ldrh w8, [x22, :lo12:c_ftl_nand_sec_pre_page] + cbz w8, .LBB24_5 +// %bb.3: + mov w11, #23752 + mov w8, wzr + adrp x9, p_io_data_buf_0 + adrp x10, p_io_data_buf_1 + movk w11, #2575, lsl #16 +.LBB24_4: // =>This Inner Loop Header: Depth=1 + ldr x13, [x9, :lo12:p_io_data_buf_0] + mvn w12, w8 + and x14, x8, #0xffff + orr w12, w8, w12, lsl #16 + lsl x14, x14, #2 + str w12, [x13, x14] + ldr x12, [x10, :lo12:p_io_data_buf_1] + add w8, w8, #1 // =1 + and w8, w8, #0xffff + str w11, [x12, x14] + ldrh w12, [x22, :lo12:c_ftl_nand_sec_pre_page] + cmp w8, w12, lsl #7 + b.lo .LBB24_4 +.LBB24_5: + adrp x24, c_ftl_nand_data_blks_per_plane + adrp x23, c_ftl_nand_blk_pre_plane + ldrh w19, [x24, :lo12:c_ftl_nand_data_blks_per_plane] + ldrh w28, [x23, :lo12:c_ftl_nand_blk_pre_plane] + cmp w19, w28 + b.hs .LBB24_8 +// %bb.6: + mov w20, wzr +.LBB24_7: // =>This Inner Loop Header: Depth=1 + mov w1, #1 + mov w0, w19 + bl FtlLowFormatEraseBlock + ldrh w28, [x23, :lo12:c_ftl_nand_blk_pre_plane] + add w8, w0, w20 + add w19, w19, #1 // =1 + and w20, w8, #0xffff + cmp w28, w19, uxth + b.hi .LBB24_7 + b .LBB24_9 +.LBB24_8: + mov w20, wzr +.LBB24_9: + adrp x26, c_ftl_nand_planes_num + ldrh w8, [x26, :lo12:c_ftl_nand_planes_num] + sub w9, w20, #3 // =3 + adrp x27, c_ftl_nand_max_data_blks + cmp w9, w8, lsl #1 + b.ge .LBB24_14 +.LBB24_10: + ldrh w8, [x24, :lo12:c_ftl_nand_data_blks_per_plane] + cbz w8, .LBB24_16 +// %bb.11: + mov w25, wzr + mov w19, wzr +.LBB24_12: // =>This Inner Loop Header: Depth=1 + mov w0, w19 + mov w1, wzr + bl FtlLowFormatEraseBlock + ldrh w8, [x24, :lo12:c_ftl_nand_data_blks_per_plane] + add w9, w0, w25 + add w19, w19, #1 // =1 + and w25, w9, #0xffff + cmp w8, w19, uxth + b.hi .LBB24_12 +// %bb.13: + ldrh w28, [x23, :lo12:c_ftl_nand_blk_pre_plane] + b .LBB24_17 +.LBB24_14: + adrp x9, c_ftl_nand_init_sys_blks_per_plane + ldrh w9, [x9, :lo12:c_ftl_nand_init_sys_blks_per_plane] + udiv w10, w20, w8 + mov w11, #24 + add x0, x21, #8 // =8 + add w9, w10, w9 + and w10, w9, #0xffff + cmp w10, #24 // =24 + csel w9, w9, w11, hi + adrp x10, c_ftl_nand_sys_blks_per_plane + and w11, w9, #0xffff + str w11, [x10, :lo12:c_ftl_nand_sys_blks_per_plane] + adrp x10, c_ftl_nand_totle_phy_blks + ldr w10, [x10, :lo12:c_ftl_nand_totle_phy_blks] + mul w8, w11, w8 + sub w19, w28, w9 + mov w2, #2048 + sub w9, w10, w8 + mov w1, wzr + stur wzr, [x21, #2] + strh wzr, [x21, #6] + strh w19, [x24, :lo12:c_ftl_nand_data_blks_per_plane] + str w8, [x25, :lo12:c_ftl_nand_max_sys_blks] + str w9, [x27, :lo12:c_ftl_nand_max_data_blks] + strh w8, [x21] + bl memset + cmp w28, w19, uxth + b.ls .LBB24_10 +.LBB24_15: // =>This Inner Loop Header: Depth=1 + mov w1, #1 + mov w0, w19 + bl FtlLowFormatEraseBlock + ldrh w28, [x23, :lo12:c_ftl_nand_blk_pre_plane] + add w19, w19, #1 // =1 + cmp w28, w19, uxth + b.hi .LBB24_15 + b .LBB24_10 +.LBB24_16: + mov w25, wzr +.LBB24_17: + ldrh w8, [x26, :lo12:c_ftl_nand_planes_num] + ldr w10, [x27, :lo12:c_ftl_nand_max_data_blks] + adrp x9, g_cur_erase_blk + str w28, [x9, :lo12:g_cur_erase_blk] + add w9, w8, w8, lsl #1 + cmp w25, w9, lsl #3 + udiv w9, w10, w8 + b.ls .LBB24_19 +// %bb.18: + sub w10, w10, w25 + udiv w11, w10, w8 + lsr w10, w11, #5 + add w10, w10, #24 // =24 + b .LBB24_20 +.LBB24_19: + lsr w10, w9, #5 + add w10, w10, #36 // =36 + mov w11, w9 +.LBB24_20: + adrp x12, c_ftl_nand_ext_blk_pre_plane + ldrh w13, [x12, :lo12:c_ftl_nand_ext_blk_pre_plane] + adrp x12, c_ftl_nand_data_op_blks_per_plane + strh w10, [x12, :lo12:c_ftl_nand_data_op_blks_per_plane] + cbz w13, .LBB24_23 +// %bb.21: + mul w14, w13, w8 + add w10, w10, w13, lsr #1 + cmp w14, w25 + adrp x25, g_GlobalSysVersion + strh w10, [x12, :lo12:c_ftl_nand_data_op_blks_per_plane] + b.le .LBB24_24 +// %bb.22: + add w10, w13, w9, lsr #5 + add w10, w10, #32 // =32 + mov w11, w9 + strh w10, [x12, :lo12:c_ftl_nand_data_op_blks_per_plane] + b .LBB24_24 +.LBB24_23: + adrp x25, g_GlobalSysVersion +.LBB24_24: + sub w9, w11, w10, uxth + adrp x10, c_ftl_nand_page_pre_blk + ldrh w10, [x10, :lo12:c_ftl_nand_page_pre_blk] + ldrh w12, [x22, :lo12:c_ftl_nand_sec_pre_page] + adrp x24, g_MaxLbn + mul w8, w9, w8 + adrp x11, g_MaxLpn + str w8, [x24, :lo12:g_MaxLbn] + mul w8, w8, w10 + str w8, [x11, :lo12:g_MaxLpn] + mul w8, w8, w12 + adrp x9, g_MaxLbaSector + str w8, [x9, :lo12:g_MaxLbaSector] + bl FtlBbmTblFlush + adrp x22, p_valid_page_count_table + ldrh w8, [x23, :lo12:c_ftl_nand_blk_pre_plane] + ldr x0, [x22, :lo12:p_valid_page_count_table] + mov w1, wzr + lsl x2, x8, #1 + bl memset + adrp x9, g_gc_superblock + adrp x19, g_active_superblock + adrp x8, g_VaildLpn + add x9, x9, :lo12:g_gc_superblock + mov w20, #65535 + add x19, x19, :lo12:g_active_superblock + mov w23, #1 + str wzr, [x8, :lo12:g_VaildLpn] + str w20, [x9] + strb wzr, [x9, #6] + strb wzr, [x9, #8] + strb wzr, [x19, #6] + str wzr, [x19] + strb w23, [x19, #8] +.LBB24_25: // =>This Inner Loop Header: Depth=1 + mov x0, x19 + bl make_superblock + ldrb w8, [x19, #7] + cbnz w8, .LBB24_27 +// %bb.26: // in Loop: Header=BB24_25 Depth=1 + ldr x8, [x22, :lo12:p_valid_page_count_table] + ldrh w9, [x19] + strh w20, [x8, x9, lsl #1] + ldrh w8, [x19] + add w8, w8, #1 // =1 + strh w8, [x19] + b .LBB24_25 +.LBB24_27: + ldr w8, [x25, :lo12:g_GlobalSysVersion] + ldrh w9, [x19, #4] + ldr x10, [x22, :lo12:p_valid_page_count_table] + ldrh w11, [x19] + str w8, [x19, #12] + add w8, w8, #1 // =1 + str w8, [x25, :lo12:g_GlobalSysVersion] + strh w9, [x10, x11, lsl #1] + ldrh w8, [x19] + adrp x19, g_buffer_superblock + add x19, x19, :lo12:g_buffer_superblock + mov x0, x19 + add w8, w8, #1 // =1 + strh wzr, [x19, #2] + strb wzr, [x19, #6] + strh w8, [x19] + strb w23, [x19, #8] + bl make_superblock + ldrb w8, [x19, #7] + cbnz w8, .LBB24_30 +// %bb.28: + mov w20, #65535 +.LBB24_29: // =>This Inner Loop Header: Depth=1 + ldr x8, [x22, :lo12:p_valid_page_count_table] + ldrh w9, [x19] + mov x0, x19 + strh w20, [x8, x9, lsl #1] + ldrh w8, [x19] + add w8, w8, #1 // =1 + strh w8, [x19] + bl make_superblock + ldrb w8, [x19, #7] + cbz w8, .LBB24_29 +.LBB24_30: + ldr w8, [x25, :lo12:g_GlobalSysVersion] + ldrh w9, [x19, #4] + ldr x10, [x22, :lo12:p_valid_page_count_table] + ldrh w11, [x19] + str w8, [x19, #12] + add w8, w8, #1 // =1 + str w8, [x25, :lo12:g_GlobalSysVersion] + strh w9, [x10, x11, lsl #1] + adrp x22, gSysFreeQueue+6 + ldrh w8, [x22, :lo12:gSysFreeQueue+6] + adrp x9, g_gc_temp_superblock + mov w20, #65535 + strh w20, [x9, :lo12:g_gc_temp_superblock] + cbz w8, .LBB24_36 +// %bb.31: + ldrh w9, [x21, #2] + sub w8, w8, #1 // =1 + mov w2, #1 + add x10, x21, x9, lsl #1 + ldrh w19, [x10, #8] + strh w8, [x21, #6] + adrp x8, req_erase + ldr x10, [x8, :lo12:req_erase] + add w9, w9, #1 // =1 + and w9, w9, #0x3ff + strh w9, [x21, #2] + lsl w9, w19, #10 + str w9, [x10, #4] + ldr x0, [x8, :lo12:req_erase] + bl FlashEraseBlocks + adrp x8, g_totle_sys_slc_erase_count + ldr w9, [x8, :lo12:g_totle_sys_slc_erase_count] + cmp w19, w20 + add w9, w9, #1 // =1 + str w9, [x8, :lo12:g_totle_sys_slc_erase_count] + b.eq .LBB24_37 +// %bb.32: + cbz w19, .LBB24_37 +// %bb.33: + ldr w10, [x24, :lo12:g_MaxLbn] + ldr w11, [x25, :lo12:g_GlobalSysVersion] + adrp x8, gSysInfo + add x8, x8, :lo12:gSysInfo + mov w9, #-65536 + strh w19, [x8] + stur w9, [x8, #2] + strh w10, [x8, #6] + str w11, [x8, #8] + add w8, w11, #1 // =1 + str w8, [x25, :lo12:g_GlobalSysVersion] + bl FtlVpcTblFlush + bl FtlSysBlkInit + cbnz w0, .LBB24_35 +// %bb.34: + adrp x8, gFtlInitStatus + mov w9, #1 + str w9, [x8, :lo12:gFtlInitStatus] +.LBB24_35: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.LBB24_36: + mov w19, #65535 +.LBB24_37: + ldrh w2, [x22, :lo12:gSysFreeQueue+6] + adrp x0, .L.str.86 + add x0, x0, :lo12:.L.str.86 + mov w1, w19 + bl sftl_printk +.LBB24_38: // =>This Inner Loop Header: Depth=1 + b .LBB24_38 +.Lfunc_end24: + .size ftl_low_format, .Lfunc_end24-ftl_low_format + // -- End function + .globl FtlFreeSysBlkQueueInit // -- Begin function FtlFreeSysBlkQueueInit + .p2align 2 + .type FtlFreeSysBlkQueueInit,@function +FtlFreeSysBlkQueueInit: // @FtlFreeSysBlkQueueInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + adrp x8, gSysFreeQueue + add x8, x8, :lo12:gSysFreeQueue + strh w0, [x8] + add x0, x8, #8 // =8 + mov w2, #2048 + mov w1, wzr + mov x29, sp + stur wzr, [x8, #2] + strh wzr, [x8, #6] + bl memset + mov w0, wzr + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end25: + .size FtlFreeSysBlkQueueInit, .Lfunc_end25-FtlFreeSysBlkQueueInit + // -- End function + .globl FtlLoadBbt // -- Begin function FtlLoadBbt + .p2align 2 + .type FtlLoadBbt,@function +FtlLoadBbt: // @FtlLoadBbt +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + stp x24, x23, [sp, #16] // 16-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + adrp x21, p_sys_data_buf + adrp x8, p_sys_spare_buf + adrp x24, c_ftl_nand_blks_per_die + stp x20, x19, [sp, #48] // 16-byte Folded Spill + adrp x20, gBbtInfo + ldr x10, [x21, :lo12:p_sys_data_buf] + ldr x22, [x8, :lo12:p_sys_spare_buf] + ldrh w8, [x24, :lo12:c_ftl_nand_blks_per_die] + add x20, x20, :lo12:gBbtInfo + mov w9, #65535 + strh w9, [x20] + adrp x9, req_sys+8 + add x9, x9, :lo12:req_sys+8 + stp x10, x22, [x9] + sub w9, w8, #1 // =1 + sub w8, w8, #16 // =16 + and w23, w9, #0xffff + cmp w8, w23 + mov x8, #-1 + mov x29, sp + strh wzr, [x20, #6] + stur x8, [x20, #12] + stur x8, [x20, #20] + b.ge .LBB26_19 +// %bb.1: + adrp x19, req_sys + add x19, x19, :lo12:req_sys + b .LBB26_4 +.LBB26_2: // in Loop: Header=BB26_4 Depth=1 + ldrsh w8, [x22] + cmn w8, #3887 // =3887 + b.eq .LBB26_7 +.LBB26_3: // in Loop: Header=BB26_4 Depth=1 + ldrh w8, [x24, :lo12:c_ftl_nand_blks_per_die] + sub w9, w23, #1 // =1 + and w23, w9, #0xffff + sub w8, w8, #16 // =16 + cmp w8, w23 + b.ge .LBB26_6 +.LBB26_4: // =>This Inner Loop Header: Depth=1 + lsl w8, w23, #10 + mov w1, #1 + mov x0, x19 + str w8, [x19, #4] + bl FlashReadPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.ne .LBB26_2 +// %bb.5: // in Loop: Header=BB26_4 Depth=1 + ldr w8, [x19, #4] + mov w1, #1 + mov x0, x19 + add w8, w8, #1 // =1 + str w8, [x19, #4] + bl FlashReadPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.ne .LBB26_2 + b .LBB26_3 +.LBB26_6: + adrp x8, gBbtInfo + ldrh w23, [x8, :lo12:gBbtInfo] + b .LBB26_8 +.LBB26_7: + strh w23, [x20] + ldr w8, [x22, #4] + str w8, [x20, #8] + ldrh w8, [x22, #8] + strh w8, [x20, #4] +.LBB26_8: + mvn w8, w23 + tst w8, #0xffff + b.eq .LBB26_19 +// %bb.9: + adrp x8, gBbtInfo+4 + ldrh w8, [x8, :lo12:gBbtInfo+4] + mov w9, #65535 + cmp w8, w9 + b.eq .LBB26_14 +// %bb.10: + lsl w8, w8, #10 + mov w1, #1 + mov x0, x19 + str w8, [x19, #4] + bl FlashReadPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.eq .LBB26_14 +// %bb.11: + ldrsh w8, [x22] + cmn w8, #3887 // =3887 + b.ne .LBB26_14 +// %bb.12: + adrp x9, gBbtInfo+8 + ldr w8, [x22, #4] + ldr w9, [x9, :lo12:gBbtInfo+8] + cmp w8, w9 + b.ls .LBB26_14 +// %bb.13: + ldrh w9, [x20, #4] + str w8, [x20, #8] + strh w9, [x20] + ldrh w8, [x22, #8] + strh w8, [x20, #4] +.LBB26_14: + ldrh w0, [x20] + mov w1, #1 + bl FtlGetLastWrittenPage + add w8, w0, #1 // =1 + strh w8, [x20, #2] + tbnz w0, #15, .LBB26_20 +// %bb.15: + and w23, w0, #0xffff + adrp x24, gBbtInfo + b .LBB26_17 +.LBB26_16: // in Loop: Header=BB26_17 Depth=1 + cmp w23, #0 // =0 + sub w23, w23, #1 // =1 + b.le .LBB26_20 +.LBB26_17: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x24, :lo12:gBbtInfo] + ldr x9, [x21, :lo12:p_sys_data_buf] + mov w1, #1 + mov x0, x19 + orr w8, w23, w8, lsl #10 + str w8, [x19, #4] + str x9, [x19, #8] + bl FlashReadPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.eq .LBB26_16 +// %bb.18: // in Loop: Header=BB26_17 Depth=1 + ldrsh w8, [x22] + cmn w8, #3887 // =3887 + b.ne .LBB26_16 + b .LBB26_21 +.LBB26_19: + mov w0, #-1 + b .LBB26_30 +.LBB26_20: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlLoadBbt + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlLoadBbt + mov w2, #251 + bl sftl_printk +.LBB26_21: + ldrh w8, [x22, #10] + adrp x9, gBbtInfo+6 + strh w8, [x9, :lo12:gBbtInfo+6] + ldrh w9, [x22, #12] + mov w8, #65535 + cmp w9, w8 + b.eq .LBB26_26 +// %bb.22: + adrp x8, c_ftl_nand_sys_blks_per_plane + ldr w11, [x8, :lo12:c_ftl_nand_sys_blks_per_plane] + cmp w11, w9 + b.eq .LBB26_26 +// %bb.23: + adrp x10, c_ftl_nand_blk_pre_plane + ldrh w10, [x10, :lo12:c_ftl_nand_blk_pre_plane] + lsr w12, w10, #2 + cmp w9, w12 + b.hs .LBB26_26 +// %bb.24: + cmp w11, w12 + b.hs .LBB26_26 +// %bb.25: + cmp w9, #24 // =24 + mov w11, #24 + csel w9, w9, w11, hi + adrp x11, c_ftl_nand_data_blks_per_plane + sub w10, w10, w9 + strh w10, [x11, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x10, c_ftl_nand_planes_num + adrp x11, c_ftl_nand_totle_phy_blks + ldrh w10, [x10, :lo12:c_ftl_nand_planes_num] + ldr w11, [x11, :lo12:c_ftl_nand_totle_phy_blks] + str w9, [x8, :lo12:c_ftl_nand_sys_blks_per_plane] + adrp x8, c_ftl_nand_max_sys_blks + mul w9, w10, w9 + str w9, [x8, :lo12:c_ftl_nand_max_sys_blks] + sub w8, w11, w9 + adrp x9, c_ftl_nand_max_data_blks + str w8, [x9, :lo12:c_ftl_nand_max_data_blks] +.LBB26_26: + adrp x19, c_ftl_nand_die_num + ldrh w8, [x19, :lo12:c_ftl_nand_die_num] + cbz w8, .LBB26_29 +// %bb.27: + mov x21, xzr + adrp x22, req_sys+8 + adrp x23, c_ftl_nand_bbm_buf_size +.LBB26_28: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x23, :lo12:c_ftl_nand_bbm_buf_size] + ldr x9, [x22, :lo12:req_sys+8] + add x10, x20, x21, lsl #3 + ldr x0, [x10, #32] + mul w10, w21, w8 + add x1, x9, w10, uxtw #2 + lsl x2, x8, #2 + bl memcpy + ldrh w8, [x19, :lo12:c_ftl_nand_die_num] + add x21, x21, #1 // =1 + cmp x21, x8 + b.lo .LBB26_28 +.LBB26_29: + mov w0, wzr +.LBB26_30: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldp x24, x23, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end26: + .size FtlLoadBbt, .Lfunc_end26-FtlLoadBbt + // -- End function + .globl FtlMakeBbt // -- Begin function FtlMakeBbt + .p2align 2 + .type FtlMakeBbt,@function +FtlMakeBbt: // @FtlMakeBbt +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + adrp x25, gBbtInfo + stp x28, x27, [sp, #16] // 16-byte Folded Spill + add x25, x25, :lo12:gBbtInfo + mov x8, #-1 + adrp x28, p_sys_data_buf + adrp x9, p_sys_spare_buf + adrp x27, c_ftl_nand_die_num + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stur x8, [x25, #12] + stur x8, [x25, #20] + ldr x8, [x28, :lo12:p_sys_data_buf] + ldr x21, [x9, :lo12:p_sys_spare_buf] + ldrh w9, [x27, :lo12:c_ftl_nand_die_num] + adrp x10, req_sys+8 + stp x20, x19, [sp, #80] // 16-byte Folded Spill + mov w20, #65535 + add x10, x10, :lo12:req_sys+8 + adrp x26, c_ftl_nand_blks_per_die + stp x24, x23, [sp, #48] // 16-byte Folded Spill + mov x29, sp + strh w20, [x25] + strh wzr, [x25, #6] + stp x8, x21, [x10] + cbz w9, .LBB27_34 +// %bb.1: + adrp x19, req_sys + mov x22, xzr + add x19, x19, :lo12:req_sys + b .LBB27_3 +.LBB27_2: // in Loop: Header=BB27_3 Depth=1 + ldrh w8, [x27, :lo12:c_ftl_nand_die_num] + add x22, x22, #1 // =1 + cmp x22, x8 + b.hs .LBB27_8 +.LBB27_3: // =>This Loop Header: Depth=1 + // Child Loop BB27_5 Depth 2 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + add x23, x25, x22, lsl #1 + strh w20, [x23, #12]! + sub w9, w8, #1 // =1 + and w24, w9, #0xffff + sub w9, w8, #16 // =16 + cmp w9, w24 + b.lt .LBB27_5 + b .LBB27_2 +.LBB27_4: // in Loop: Header=BB27_5 Depth=2 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + sub w9, w24, #1 // =1 + and w24, w9, #0xffff + sub w9, w8, #16 // =16 + cmp w9, w24 + b.ge .LBB27_2 +.LBB27_5: // Parent Loop BB27_3 Depth=1 + // => This Inner Loop Header: Depth=2 + madd w8, w8, w22, w24 + lsl w8, w8, #10 + mov w1, #1 + mov x0, x19 + str w8, [x19, #4] + bl FlashReadPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.eq .LBB27_4 +// %bb.6: // in Loop: Header=BB27_5 Depth=2 + ldrsh w8, [x21] + cmn w8, #3872 // =3872 + b.ne .LBB27_4 +// %bb.7: // in Loop: Header=BB27_3 Depth=1 + strh w24, [x23] + b .LBB27_2 +.LBB27_8: + cbz w8, .LBB27_34 +// %bb.9: + mov x20, xzr + b .LBB27_12 +.LBB27_10: // in Loop: Header=BB27_12 Depth=1 + ldrh w9, [x26, :lo12:c_ftl_nand_blks_per_die] + mov w1, #1 + mov x0, x19 + madd w23, w20, w9, w8 + lsl w8, w23, #10 + str w8, [x19, #4] + bl FlashReadPages + ldrh w9, [x26, :lo12:c_ftl_nand_blks_per_die] + add x8, x25, x20, lsl #3 + ldr x0, [x8, #32] + ldr x1, [x19, #8] + add x8, x9, #7 // =7 + lsr x2, x8, #3 + bl memcpy +.LBB27_11: // in Loop: Header=BB27_12 Depth=1 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + and w1, w23, #0xffff + mov w12, #1 + adrp x0, .L.str.82 + udiv w2, w1, w8 + add x9, x25, w2, uxtw #3 + ldr x9, [x9, #32] + msub w8, w2, w8, w23 + ubfx w10, w8, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x9, x10] + and w3, w8, #0xffff + lsl w8, w12, w8 + add x0, x0, :lo12:.L.str.82 + orr w4, w8, w11 + adrp x21, c_ftl_nand_die_num + str w4, [x9, x10] + bl sftl_printk + ldrh w8, [x25, #6] + ldrh w9, [x21, :lo12:c_ftl_nand_die_num] + add x20, x20, #1 // =1 + add w8, w8, #1 // =1 + cmp x20, x9 + strh w8, [x25, #6] + b.hs .LBB27_34 +.LBB27_12: // =>This Loop Header: Depth=1 + // Child Loop BB27_20 Depth 2 + // Child Loop BB27_23 Depth 2 + // Child Loop BB27_26 Depth 2 + // Child Loop BB27_30 Depth 2 + // Child Loop BB27_31 Depth 3 + adrp x8, p_sys_spare_buf + ldr x24, [x28, :lo12:p_sys_data_buf] + ldr x27, [x8, :lo12:p_sys_spare_buf] + adrp x8, req_sys+8 + add x8, x8, :lo12:req_sys+8 + add x22, x25, x20, lsl #1 + stp x24, x27, [x8] + ldrh w8, [x22, #12]! + mov w9, #65535 + cmp w8, w9 + b.ne .LBB27_10 +// %bb.13: // in Loop: Header=BB27_12 Depth=1 + mov x21, #-1 + stp x21, x21, [x24, #240] + stp x21, x21, [x24, #224] + stp x21, x21, [x24, #208] + stp x21, x21, [x24, #192] + stp x21, x21, [x24, #176] + stp x21, x21, [x24, #160] + stp x21, x21, [x24, #144] + stp x21, x21, [x24, #128] + stp x21, x21, [x24, #112] + stp x21, x21, [x24, #96] + stp x21, x21, [x24, #80] + stp x21, x21, [x24, #64] + stp x21, x21, [x24, #48] + stp x21, x21, [x24, #32] + stp x21, x21, [x24, #16] + stp x21, x21, [x24] + adrp x8, g_nand_ops + ldr x8, [x8, :lo12:g_nand_ops] + mov x0, x24 + mov w1, w20 + blr x8 + and w8, w0, #0xffff + cmp w8, #51 // =51 + b.lo .LBB27_15 +// %bb.14: // in Loop: Header=BB27_12 Depth=1 + stp x21, x21, [x24, #240] + stp x21, x21, [x24, #224] + stp x21, x21, [x24, #208] + stp x21, x21, [x24, #192] + stp x21, x21, [x24, #176] + stp x21, x21, [x24, #160] + stp x21, x21, [x24, #144] + stp x21, x21, [x24, #128] + stp x21, x21, [x24, #112] + stp x21, x21, [x24, #96] + stp x21, x21, [x24, #80] + stp x21, x21, [x24, #64] + stp x21, x21, [x24, #48] + stp x21, x21, [x24, #32] + stp x21, x21, [x24, #16] + stp x21, x21, [x24] + b .LBB27_24 +.LBB27_15: // in Loop: Header=BB27_12 Depth=1 + tst w0, #0xffff + b.eq .LBB27_24 +// %bb.16: // in Loop: Header=BB27_12 Depth=1 + adrp x9, g_nand_phy_info+14 + ldrh w9, [x9, :lo12:g_nand_phy_info+14] + cmp w9, #4 // =4 + b.ne .LBB27_24 +// %bb.17: // in Loop: Header=BB27_12 Depth=1 + cmp w8, #2 // =2 + mov w8, w8 + b.hs .LBB27_19 +// %bb.18: // in Loop: Header=BB27_12 Depth=1 + mov x9, xzr + b .LBB27_22 +.LBB27_19: // in Loop: Header=BB27_12 Depth=1 + and x9, x8, #0xfffe + add x10, x24, #2 // =2 + mov x11, x9 +.LBB27_20: // Parent Loop BB27_12 Depth=1 + // => This Inner Loop Header: Depth=2 + ldurh w12, [x10, #-2] + ldrh w13, [x10] + subs x11, x11, #2 // =2 + lsr w12, w12, #1 + lsr w13, w13, #1 + sturh w12, [x10, #-2] + strh w13, [x10], #4 + b.ne .LBB27_20 +// %bb.21: // in Loop: Header=BB27_12 Depth=1 + cmp x9, x8 + b.eq .LBB27_24 +.LBB27_22: // in Loop: Header=BB27_12 Depth=1 + sub x8, x8, x9 + add x9, x24, x9, lsl #1 +.LBB27_23: // Parent Loop BB27_12 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w10, [x9] + subs x8, x8, #1 // =1 + lsr w10, w10, #1 + strh w10, [x9], #2 + b.ne .LBB27_23 +.LBB27_24: // in Loop: Header=BB27_12 Depth=1 + adrp x8, req_sys+8 + ldr x23, [x8, :lo12:req_sys+8] + add x21, x25, x20, lsl #3 + adrp x8, c_ftl_nand_bbm_buf_size + ldr x24, [x21, #32]! + ldrh w8, [x8, :lo12:c_ftl_nand_bbm_buf_size] + mov w1, wzr + mov x0, x24 + lsl x2, x8, #2 + bl memset + mov x28, xzr + b .LBB27_26 +.LBB27_25: // in Loop: Header=BB27_26 Depth=2 + lsr w9, w8, #3 + and x9, x9, #0x1ffc + ldr w10, [x24, x9] + mov w11, #1 + lsl w8, w11, w8 + add x28, x28, #2 // =2 + orr w8, w8, w10 + cmp x28, #1024 // =1024 + str w8, [x24, x9] + b.eq .LBB27_29 +.LBB27_26: // Parent Loop BB27_12 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w8, [x23, x28] + mov w9, #65535 + cmp w8, w9 + b.eq .LBB27_29 +// %bb.27: // in Loop: Header=BB27_26 Depth=2 + ldrh w9, [x26, :lo12:c_ftl_nand_blks_per_die] + cmp w8, w9 + b.lo .LBB27_25 +// %bb.28: // in Loop: Header=BB27_26 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlBbt2Bitmap + mov w2, #74 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlBbt2Bitmap + bl sftl_printk + ldrh w8, [x23, x28] + b .LBB27_25 +.LBB27_29: // in Loop: Header=BB27_12 Depth=1 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + adrp x28, p_sys_data_buf + sub w24, w8, #1 // =1 +.LBB27_30: // Parent Loop BB27_12 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB27_31 Depth 3 + mul w9, w8, w20 + mov w10, w24 +.LBB27_31: // Parent Loop BB27_12 Depth=1 + // Parent Loop BB27_30 Depth=2 + // => This Inner Loop Header: Depth=3 + mov w24, w10 + add w10, w9, w10 + and w11, w10, #0xffff + and w12, w8, #0xffff + udiv w11, w11, w12 + add x12, x25, w11, uxtw #3 + ldr x12, [x12, #32] + msub w10, w11, w8, w10 + lsr w11, w10, #3 + and x11, x11, #0x1ffc + ldr w11, [x12, x11] + lsr w11, w11, w10 + sub w10, w24, #1 // =1 + tbnz w11, #0, .LBB27_31 +// %bb.32: // in Loop: Header=BB27_30 Depth=2 + adrp x8, p_sys_spare_buf + ldr x8, [x8, :lo12:p_sys_spare_buf] + strh w24, [x22] + mov w2, #4096 + mov w1, wzr + stp xzr, xzr, [x8] + ldr x0, [x28, :lo12:p_sys_data_buf] + bl memset + mov w8, #61664 + strh w8, [x27] + str wzr, [x27, #4] + ldrh w8, [x22] + adrp x10, c_ftl_nand_bbm_buf_size + strh w8, [x27, #2] + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + ldrh w9, [x22] + ldrh w10, [x10, :lo12:c_ftl_nand_bbm_buf_size] + ldr x0, [x19, #8] + ldr x1, [x21] + madd w23, w20, w8, w9 + lsl w8, w23, #10 + lsl x2, x10, #2 + str w8, [x19, #4] + bl memcpy + mov w2, #1 + mov x0, x19 + bl FlashEraseBlocks + mov w1, #1 + mov w2, #1 + mov x0, x19 + bl FlashProgPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.ne .LBB27_11 +// %bb.33: // in Loop: Header=BB27_30 Depth=2 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + and w1, w23, #0xffff + mov w12, #1 + adrp x0, .L.str.82 + udiv w2, w1, w8 + add x9, x25, w2, uxtw #3 + ldr x9, [x9, #32] + msub w8, w2, w8, w23 + ubfx w10, w8, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x9, x10] + and w3, w8, #0xffff + lsl w8, w12, w8 + add x0, x0, :lo12:.L.str.82 + orr w4, w8, w11 + str w4, [x9, x10] + bl sftl_printk + ldrh w9, [x25, #6] + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + add w9, w9, #1 // =1 + strh w9, [x25, #6] + b .LBB27_30 +.LBB27_34: + adrp x21, c_ftl_nand_reserved_blks + ldrh w8, [x21, :lo12:c_ftl_nand_reserved_blks] + cbz w8, .LBB27_37 +// %bb.35: + adrp x20, .L.str.82 + mov w19, wzr + mov w22, #1 + add x20, x20, :lo12:.L.str.82 +.LBB27_36: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + and w9, w19, #0xffff + mov x0, x20 + mov w1, w19 + udiv w2, w9, w8 + add x9, x25, w2, uxtw #3 + mul w8, w2, w8 + ldr x9, [x9, #32] + sub w3, w19, w8, uxth + lsr w8, w3, #5 + lsl x8, x8, #2 + ldr w10, [x9, x8] + lsl w11, w22, w3 + orr w4, w11, w10 + str w4, [x9, x8] + bl sftl_printk + ldrh w8, [x25, #6] + ldrh w9, [x21, :lo12:c_ftl_nand_reserved_blks] + add w19, w19, #1 // =1 + add w8, w8, #1 // =1 + cmp w19, w9 + strh w8, [x25, #6] + b.lo .LBB27_36 +.LBB27_37: + adrp x22, gBbtInfo+12 + ldrh w8, [x22, :lo12:gBbtInfo+12] + sub w9, w8, #1 // =1 + and w21, w9, #0xffff + sub w8, w8, #48 // =48 + cmp w8, w21 + b.ge .LBB27_46 +// %bb.38: + adrp x20, .L.str.82 + adrp x23, gBbtInfo + mov w24, #1 + add x20, x20, :lo12:.L.str.82 + mov w19, w21 + b .LBB27_41 +.LBB27_39: // in Loop: Header=BB27_41 Depth=1 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + and w9, w19, #0xffff + mov x0, x20 + mov w1, w21 + udiv w2, w9, w8 + add x9, x25, w2, uxtw #3 + ldr x9, [x9, #32] + msub w8, w2, w8, w19 + ubfx w10, w8, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x9, x10] + and w3, w8, #0xffff + lsl w8, w24, w8 + orr w4, w8, w11 + str w4, [x9, x10] + bl sftl_printk + ldrh w8, [x25, #6] + add w8, w8, #1 // =1 + strh w8, [x25, #6] +.LBB27_40: // in Loop: Header=BB27_41 Depth=1 + ldrh w8, [x22, :lo12:gBbtInfo+12] + sub w19, w19, #1 // =1 + and w21, w19, #0xffff + sub w8, w8, #48 // =48 + cmp w8, w21 + b.ge .LBB27_46 +.LBB27_41: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + and w10, w19, #0xffff + and w9, w8, #0xffff + udiv w9, w10, w9 + add x10, x25, w9, uxtw #3 + ldr x10, [x10, #32] + msub w8, w9, w8, w19 + lsr w9, w8, #3 + and x9, x9, #0x1ffc + ldr w9, [x10, x9] + lsr w8, w9, w8 + tbnz w8, #0, .LBB27_40 +// %bb.42: // in Loop: Header=BB27_41 Depth=1 + mov w0, w19 + bl FlashTestBlk + cbnz w0, .LBB27_39 +// %bb.43: // in Loop: Header=BB27_41 Depth=1 + ldrsh w8, [x23, :lo12:gBbtInfo] + cmn w8, #1 // =1 + b.ne .LBB27_45 +// %bb.44: // in Loop: Header=BB27_41 Depth=1 + strh w19, [x23, :lo12:gBbtInfo] + b .LBB27_40 +.LBB27_45: + adrp x8, gBbtInfo+4 + strh w19, [x8, :lo12:gBbtInfo+4] +.LBB27_46: + ldrh w8, [x25] + adrp x9, req_erase + ldr x10, [x9, :lo12:req_erase] + strh wzr, [x25, #2] + lsl w8, w8, #10 + str wzr, [x25, #8] + str w8, [x10, #4] + ldrh w8, [x25, #4] + ldr x10, [x9, :lo12:req_erase] + mov w2, #2 + lsl w8, w8, #10 + str w8, [x10, #36] + ldr x0, [x9, :lo12:req_erase] + bl FlashEraseBlocks + ldrh w1, [x25] + ldrh w8, [x26, :lo12:c_ftl_nand_blks_per_die] + add x20, x25, #32 // =32 + mov w21, #1 + adrp x19, .L.str.82 + udiv w2, w1, w8 + ldr x9, [x20, w2, uxtw #3] + msub w8, w2, w8, w1 + ubfx w10, w8, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x9, x10] + and w3, w8, #0xffff + lsl w8, w21, w8 + add x19, x19, :lo12:.L.str.82 + orr w4, w8, w11 + mov x0, x19 + str w4, [x9, x10] + bl sftl_printk + ldrh w8, [x25, #6] + ldrh w1, [x25, #4] + ldrh w9, [x26, :lo12:c_ftl_nand_blks_per_die] + mov x0, x19 + add w8, w8, #1 // =1 + strh w8, [x25, #6] + udiv w2, w1, w9 + ldr x8, [x20, w2, uxtw #3] + msub w9, w2, w9, w1 + ubfx w10, w9, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x8, x10] + and w3, w9, #0xffff + lsl w9, w21, w9 + orr w4, w9, w11 + str w4, [x8, x10] + bl sftl_printk + ldrh w8, [x25, #6] + add w8, w8, #1 // =1 + strh w8, [x25, #6] + bl FtlBbmTblFlush + ldr w8, [x25, #8] + ldrh w9, [x25, #4] + ldrh w10, [x25] + strh wzr, [x25, #2] + add w8, w8, #1 // =1 + strh w9, [x25] + str w8, [x25, #8] + strh w10, [x25, #4] + bl FtlBbmTblFlush + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end27: + .size FtlMakeBbt, .Lfunc_end27-FtlMakeBbt + // -- End function + .globl FtlBbmTblFlush // -- Begin function FtlBbmTblFlush + .p2align 2 + .type FtlBbmTblFlush,@function +FtlBbmTblFlush: // @FtlBbmTblFlush +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x9, p_sys_data_buf + adrp x10, p_sys_spare_buf + adrp x8, c_ftl_nand_byte_pre_page + ldr x0, [x9, :lo12:p_sys_data_buf] + ldr x9, [x10, :lo12:p_sys_spare_buf] + ldrh w2, [x8, :lo12:c_ftl_nand_byte_pre_page] + adrp x8, req_sys+8 + add x8, x8, :lo12:req_sys+8 + mov w1, wzr + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + stp x0, x9, [x8] + bl memset + adrp x19, c_ftl_nand_die_num + ldrh w8, [x19, :lo12:c_ftl_nand_die_num] + adrp x24, gBbtInfo + add x24, x24, :lo12:gBbtInfo + cbz w8, .LBB28_3 +// %bb.1: + mov x20, xzr + adrp x21, req_sys+8 + adrp x22, c_ftl_nand_bbm_buf_size +.LBB28_2: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x22, :lo12:c_ftl_nand_bbm_buf_size] + ldr x9, [x21, :lo12:req_sys+8] + add x10, x24, x20, lsl #3 + ldr x1, [x10, #32] + mul w10, w20, w8 + add x0, x9, w10, sxtw #2 + lsl x2, x8, #2 + bl memcpy + ldrh w8, [x19, :lo12:c_ftl_nand_die_num] + add x20, x20, #1 // =1 + cmp x20, x8 + b.lo .LBB28_2 +.LBB28_3: + adrp x8, req_sys+16 + ldr x27, [x8, :lo12:req_sys+16] + mov x8, #-1 + mov w9, #61649 + adrp x10, g_totle_avg_erase_count + str x8, [x27, #8] + stur x8, [x27, #2] + strh w9, [x27] + ldr w8, [x24, #8] + adrp x9, c_ftl_nand_sys_blks_per_plane + adrp x19, req_sys + adrp x20, .L.str.83 + str w8, [x27, #4] + ldrh w8, [x24] + adrp x21, .L.str.84 + mov w12, wzr + mov w11, wzr + strh w8, [x27, #2] + ldrh w8, [x24, #4] + add x19, x19, :lo12:req_sys + add x20, x20, :lo12:.L.str.83 + adrp x26, c_ftl_nand_page_pre_slc_blk + strh w8, [x27, #8] + ldrh w8, [x24, #6] + adrp x25, gBbtInfo+2 + adrp x28, req_sys+4 + add x21, x21, :lo12:.L.str.84 + strh w8, [x27, #10] + ldr w8, [x9, :lo12:c_ftl_nand_sys_blks_per_plane] + adrp x22, req_erase + strh w8, [x27, #12] + ldr w8, [x10, :lo12:g_totle_avg_erase_count] + strh w8, [x27, #14] +.LBB28_4: // =>This Loop Header: Depth=1 + // Child Loop BB28_5 Depth 2 + mov w23, w11 + stur w12, [x29, #-4] // 4-byte Folded Spill + str w11, [sp, #8] // 4-byte Folded Spill +.LBB28_5: // Parent Loop BB28_4 Depth=1 + // => This Inner Loop Header: Depth=2 + adrp x8, p_sys_data_buf + adrp x9, p_sys_spare_buf + ldr x8, [x8, :lo12:p_sys_data_buf] + ldr x9, [x9, :lo12:p_sys_spare_buf] + ldrh w1, [x24] + ldrh w2, [x24, #2] + ldrh w3, [x24, #4] + stp x8, x9, [x19, #8] + mov x0, x20 + orr w8, w2, w1, lsl #10 + stp wzr, w8, [x19] + ldrh w4, [x27, #10] + bl sftl_printk + ldrh w8, [x26, :lo12:c_ftl_nand_page_pre_slc_blk] + ldrh w9, [x24, #2] + sub w8, w8, #1 // =1 + cmp w8, w9 + b.gt .LBB28_7 +// %bb.6: // in Loop: Header=BB28_5 Depth=2 + ldr w8, [x24, #8] + mov w2, #1 + add w8, w8, #1 // =1 + str w8, [x24, #8] + str w8, [x27, #4] + ldrh w8, [x24] + strh w8, [x27, #8] + ldrh w9, [x24, #4] + strh w8, [x24, #4] + ldr x8, [x22, :lo12:req_erase] + strh wzr, [x24, #2] + strh w9, [x24] + lsl w9, w9, #10 + str w9, [x28, :lo12:req_sys+4] + str w9, [x8, #4] + ldr x0, [x22, :lo12:req_erase] + bl FlashEraseBlocks +.LBB28_7: // in Loop: Header=BB28_5 Depth=2 + mov w1, #1 + mov w2, #1 + mov x0, x19 + bl FlashProgPages + ldrh w9, [x25, :lo12:gBbtInfo+2] + ldr w8, [x19] + add w9, w9, #1 // =1 + cmn w8, #1 // =1 + strh w9, [x25, :lo12:gBbtInfo+2] + b.ne .LBB28_9 +// %bb.8: // in Loop: Header=BB28_5 Depth=2 + ldr w1, [x28, :lo12:req_sys+4] + mov x0, x21 + bl sftl_printk + add w23, w23, #1 // =1 + and w8, w23, #0xffff + cmp w8, #4 // =4 + b.lo .LBB28_5 + b .LBB28_12 +.LBB28_9: // in Loop: Header=BB28_4 Depth=1 + ldur w12, [x29, #-4] // 4-byte Folded Reload + mov w11, w23 + add w12, w12, #1 // =1 + cmp w12, #2 // =2 + b.lt .LBB28_4 +// %bb.10: // in Loop: Header=BB28_4 Depth=1 + cmp w8, #256 // =256 + mov w11, w23 + b.eq .LBB28_4 +// %bb.11: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.LBB28_12: + ldr w9, [sp, #8] // 4-byte Folded Reload + ldr w1, [x28, :lo12:req_sys+4] + adrp x0, .L.str.85 + add x0, x0, :lo12:.L.str.85 + add w8, w9, #1 // =1 + and w8, w8, #0xffff + cmp w8, #4 // =4 + mov w8, #4 + csinc w8, w8, w9, ls + and w2, w8, #0xffff + bl sftl_printk +.LBB28_13: // =>This Inner Loop Header: Depth=1 + b .LBB28_13 +.Lfunc_end28: + .size FtlBbmTblFlush, .Lfunc_end28-FtlBbmTblFlush + // -- End function + .globl make_superblock // -- Begin function make_superblock + .p2align 2 + .type make_superblock,@function +make_superblock: // @make_superblock +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x9, c_ftl_nand_data_blks_per_plane + ldrh w8, [x0] + ldrh w9, [x9, :lo12:c_ftl_nand_data_blks_per_plane] + str x19, [sp, #16] // 8-byte Folded Spill + mov x19, x0 + mov x29, sp + cmp w8, w9 + b.lo .LBB29_2 +// %bb.1: + adrp x0, .L.str.78 + adrp x1, .L__func__.make_superblock + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.make_superblock + mov w2, #2157 + bl sftl_printk +.LBB29_2: + strh wzr, [x19, #4] + strb wzr, [x19, #7] + adrp x10, c_ftl_nand_planes_num + ldrh w9, [x10, :lo12:c_ftl_nand_planes_num] + ldrh w8, [x19] + cbz w9, .LBB29_7 +// %bb.3: + adrp x13, p_plane_order_table + adrp x17, gBbtInfo + mov w9, wzr + mov x11, xzr + add x12, x19, #16 // =16 + add x13, x13, :lo12:p_plane_order_table + adrp x14, c_ftl_nand_planes_per_die + adrp x15, c_ftl_nand_blks_per_die + mov w16, #65535 + add x17, x17, :lo12:gBbtInfo + b .LBB29_5 +.LBB29_4: // in Loop: Header=BB29_5 Depth=1 + ldrh w18, [x10, :lo12:c_ftl_nand_planes_num] + add x11, x11, #1 // =1 + cmp x11, x18 + b.hs .LBB29_7 +.LBB29_5: // =>This Inner Loop Header: Depth=1 + ldrb w18, [x13, x11] + ldrh w0, [x14, :lo12:c_ftl_nand_planes_per_die] + ldrh w1, [x15, :lo12:c_ftl_nand_blks_per_die] + strh w16, [x12, x11, lsl #1] + and w2, w18, #0xffff + and w3, w0, #0xffff + udiv w2, w2, w3 + mul w3, w0, w8 + madd w1, w1, w2, w3 + ldrh w3, [x15, :lo12:c_ftl_nand_blks_per_die] + msub w18, w2, w0, w18 + add w18, w1, w18 + and w0, w18, #0xffff + and w1, w3, #0xffff + udiv w0, w0, w1 + add x1, x17, w0, uxtw #3 + ldr x1, [x1, #32] + msub w0, w0, w3, w18 + lsr w2, w0, #3 + and x2, x2, #0x1ffc + ldr w1, [x1, x2] + lsr w0, w1, w0 + tbnz w0, #0, .LBB29_4 +// %bb.6: // in Loop: Header=BB29_5 Depth=1 + add w9, w9, #1 // =1 + strh w18, [x12, x11, lsl #1] + strb w9, [x19, #7] + b .LBB29_4 +.LBB29_7: + adrp x10, c_ftl_nand_page_pre_blk + ldrh w10, [x10, :lo12:c_ftl_nand_page_pre_blk] + and w9, w9, #0xff + strb wzr, [x19, #9] + mov w0, wzr + mul w9, w10, w9 + strh w9, [x19, #4] + adrp x9, p_erase_count_table + ldr x9, [x9, :lo12:p_erase_count_table] + ldrh w8, [x9, x8, lsl #1] + mov w9, #10000 + cmp w8, w9 + cset w8, hi + strb w8, [x19, #9] + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end29: + .size make_superblock, .Lfunc_end29-make_superblock + // -- End function + .globl FtlFreeSysBlkQueueOut // -- Begin function FtlFreeSysBlkQueueOut + .p2align 2 + .type FtlFreeSysBlkQueueOut,@function +FtlFreeSysBlkQueueOut: // @FtlFreeSysBlkQueueOut +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + stp x20, x19, [sp, #32] // 16-byte Folded Spill + adrp x20, gSysFreeQueue+6 + ldrh w8, [x20, :lo12:gSysFreeQueue+6] + str x21, [sp, #16] // 8-byte Folded Spill + mov w21, #65535 + mov x29, sp + cbz w8, .LBB30_4 +// %bb.1: + adrp x9, gSysFreeQueue + add x9, x9, :lo12:gSysFreeQueue + ldrh w10, [x9, #2] + sub w8, w8, #1 // =1 + mov w2, #1 + add x11, x9, x10, lsl #1 + ldrh w19, [x11, #8] + strh w8, [x9, #6] + adrp x8, req_erase + ldr x11, [x8, :lo12:req_erase] + add w10, w10, #1 // =1 + and w10, w10, #0x3ff + strh w10, [x9, #2] + lsl w9, w19, #10 + str w9, [x11, #4] + ldr x0, [x8, :lo12:req_erase] + bl FlashEraseBlocks + adrp x8, g_totle_sys_slc_erase_count + ldr w9, [x8, :lo12:g_totle_sys_slc_erase_count] + cmp w19, w21 + add w9, w9, #1 // =1 + str w9, [x8, :lo12:g_totle_sys_slc_erase_count] + b.eq .LBB30_5 +// %bb.2: + cbz w19, .LBB30_5 +// %bb.3: + mov w0, w19 + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldr x21, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.LBB30_4: + mov w19, #65535 +.LBB30_5: + ldrh w2, [x20, :lo12:gSysFreeQueue+6] + adrp x0, .L.str.86 + add x0, x0, :lo12:.L.str.86 + mov w1, w19 + bl sftl_printk +.LBB30_6: // =>This Inner Loop Header: Depth=1 + b .LBB30_6 +.Lfunc_end30: + .size FtlFreeSysBlkQueueOut, .Lfunc_end30-FtlFreeSysBlkQueueOut + // -- End function + .globl FtlVpcTblFlush // -- Begin function FtlVpcTblFlush + .p2align 2 + .type FtlVpcTblFlush,@function +FtlVpcTblFlush: // @FtlVpcTblFlush +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x15, gSysInfo + stp x22, x21, [sp, #80] // 16-byte Folded Spill + adrp x21, p_sys_data_buf + adrp x22, p_sys_spare_buf + add x15, x15, :lo12:gSysInfo + ldr x12, [x21, :lo12:p_sys_data_buf] + ldr x17, [x22, :lo12:p_sys_spare_buf] + ldrh w13, [x15] + stp x20, x19, [sp, #96] // 16-byte Folded Spill + adrp x19, req_sys+8 + add x19, x19, :lo12:req_sys+8 + mov w8, #61604 + stp x12, x17, [x19] + strh w13, [x17, #2] + strh w8, [x17] + ldr w8, [x15, #8] + mov x9, #19539 + movk x9, #18004, lsl #16 + adrp x20, g_sys_save_data + movk x9, #86, lsl #32 + add x20, x20, :lo12:g_sys_save_data + movk x9, #20480, lsl #48 + adrp x10, c_ftl_nand_die_num + str xzr, [x17, #8] + str w8, [x17, #4] + ldrh w8, [x15, #6] + str x9, [x20] + ldrb w9, [x10, :lo12:c_ftl_nand_die_num] + adrp x11, g_active_superblock + add x11, x11, :lo12:g_active_superblock + ldrh w10, [x11] + strh w8, [x20, #8] + ldrh w8, [x11, #2] + strb w9, [x20, #10] + ldrb w9, [x11, #6] + ldrb w11, [x11, #8] + adrp x14, g_buffer_superblock + add x14, x14, :lo12:g_buffer_superblock + strh w10, [x20, #14] + ldrh w10, [x14] + orr w8, w9, w8, lsl #6 + ldrh w9, [x14, #2] + strb w11, [x20, #11] + ldrb w11, [x14, #6] + ldrb w13, [x14, #8] + adrp x12, g_gc_temp_superblock + add x12, x12, :lo12:g_gc_temp_superblock + strh w10, [x20, #18] + ldrh w10, [x12] + orr w9, w11, w9, lsl #6 + ldrh w11, [x12, #2] + strb w13, [x20, #12] + ldrb w13, [x12, #6] + ldrb w12, [x12, #8] + stp x24, x23, [sp, #64] // 16-byte Folded Spill + adrp x16, g_GlobalSysVersion + orr w11, w13, w11, lsl #6 + adrp x13, g_totle_mlc_erase_count + strb w12, [x20, #13] + adrp x12, g_GlobalDataVersion + adrp x23, c_ftl_nand_byte_pre_page + strh w10, [x20, #22] + ldr w14, [x16, :lo12:g_GlobalSysVersion] + ldr w10, [x13, :lo12:g_totle_mlc_erase_count] + ldr w12, [x12, :lo12:g_GlobalDataVersion] + ldr x0, [x19] + ldrh w2, [x23, :lo12:c_ftl_nand_byte_pre_page] + mov w1, #255 + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + add x29, sp, #16 // =16 + str x17, [sp, #8] // 8-byte Folded Spill + strh w8, [x20, #16] + strh w9, [x20, #20] + strh w11, [x20, #24] + str w10, [x20, #32] + stp w12, w14, [x20, #36] + bl memset + ldr x8, [x19] + ldp x9, x10, [x20] + adrp x19, p_valid_page_count_table + add x0, x8, #48 // =48 + stp x9, x10, [x8] + ldp x9, x10, [x20, #32] + ldp x11, x12, [x20, #16] + adrp x20, c_ftl_nand_data_blks_per_plane + stp x9, x10, [x8, #32] + stp x11, x12, [x8, #16] + ldrh w9, [x20, :lo12:c_ftl_nand_data_blks_per_plane] + ldr x1, [x19, :lo12:p_valid_page_count_table] + lsl x2, x9, #1 + bl memcpy + adrp x9, FtlUpdateVaildLpnCount + ldrh w8, [x9, :lo12:FtlUpdateVaildLpnCount] + add w10, w8, #1 // =1 + cmp w8, #5 // =5 + strh w10, [x9, :lo12:FtlUpdateVaildLpnCount] + b.lo .LBB31_6 +// %bb.1: + ldrh w8, [x20, :lo12:c_ftl_nand_data_blks_per_plane] + strh wzr, [x9, :lo12:FtlUpdateVaildLpnCount] + adrp x9, g_VaildLpn + str wzr, [x9, :lo12:g_VaildLpn] + cbz x8, .LBB31_6 +// %bb.2: + ldr x11, [x19, :lo12:p_valid_page_count_table] + mov w10, wzr + mov w12, #65535 + b .LBB31_4 +.LBB31_3: // in Loop: Header=BB31_4 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB31_6 +.LBB31_4: // =>This Inner Loop Header: Depth=1 + ldrh w13, [x11] + cmp w13, w12 + b.eq .LBB31_3 +// %bb.5: // in Loop: Header=BB31_4 Depth=1 + add w10, w10, w13 + str w10, [x9, :lo12:g_VaildLpn] + b .LBB31_3 +.LBB31_6: + adrp x25, gSysInfo+2 + ldrh w8, [x25, :lo12:gSysInfo+2] + adrp x24, req_sys+4 + adrp x26, req_sys + mov w10, wzr + add x24, x24, :lo12:req_sys+4 + adrp x27, gSysInfo + adrp x19, c_ftl_nand_page_pre_slc_blk + add x26, x26, :lo12:req_sys + mov w28, #65535 +.LBB31_7: // =>This Loop Header: Depth=1 + // Child Loop BB31_8 Depth 2 + // Child Loop BB31_15 Depth 3 + str w10, [sp, #4] // 4-byte Folded Spill +.LBB31_8: // Parent Loop BB31_7 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB31_15 Depth 3 + ldrh w12, [x19, :lo12:c_ftl_nand_page_pre_slc_blk] + ldr x11, [x22, :lo12:p_sys_spare_buf] + ldrh w10, [x27, :lo12:gSysInfo] + ldr x9, [x21, :lo12:p_sys_data_buf] + and w8, w8, #0xffff + sub w12, w12, #1 // =1 + stur x11, [x24, #12] + orr w11, w8, w10, lsl #10 + cmp w12, w8 + stur x9, [x24, #4] + str w11, [x24] + b.gt .LBB31_13 +// %bb.9: // in Loop: Header=BB31_8 Depth=2 + adrp x9, gSysInfo+2 + adrp x8, gSysFreeQueue+6 + add x9, x9, :lo12:gSysInfo+2 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + ldrh w28, [x9, #2] + strh w10, [x9, #2] + strh wzr, [x9] + cbz w8, .LBB31_31 +// %bb.10: // in Loop: Header=BB31_8 Depth=2 + adrp x11, gSysFreeQueue + add x11, x11, :lo12:gSysFreeQueue + ldrh w9, [x11, #2] + mov x24, x26 + mov x26, x19 + mov x19, x25 + add x10, x11, x9, lsl #1 + mov x25, x22 + sub w8, w8, #1 // =1 + ldrh w22, [x10, #8] + adrp x10, req_erase + strh w8, [x11, #6] + add w8, w9, #1 // =1 + ldr x9, [x10, :lo12:req_erase] + mov x20, x23 + mov x23, x21 + and w8, w8, #0x3ff + lsl w21, w22, #10 + strh w8, [x11, #2] + str w21, [x9, #4] + ldr x0, [x10, :lo12:req_erase] + mov w2, #1 + bl FlashEraseBlocks + adrp x9, g_totle_sys_slc_erase_count + ldr w8, [x9, :lo12:g_totle_sys_slc_erase_count] + mov w10, #65535 + cmp w22, w10 + add w8, w8, #1 // =1 + str w8, [x9, :lo12:g_totle_sys_slc_erase_count] + b.eq .LBB31_32 +// %bb.11: // in Loop: Header=BB31_8 Depth=2 + cbz w22, .LBB31_32 +// %bb.12: // in Loop: Header=BB31_8 Depth=2 + adrp x10, g_GlobalSysVersion + ldr w8, [x10, :lo12:g_GlobalSysVersion] + adrp x9, gSysInfo + add x9, x9, :lo12:gSysInfo + strh w22, [x9] + str w8, [x9, #8] + add w9, w8, #1 // =1 + str w9, [x10, :lo12:g_GlobalSysVersion] + ldr x9, [sp, #8] // 8-byte Folded Reload + adrp x11, req_sys+4 + str w21, [x11, :lo12:req_sys+4] + mov x21, x23 + str w8, [x9, #4] + strh w22, [x9, #2] + ldr x9, [x23, :lo12:p_sys_data_buf] + mov x22, x25 + mov x25, x19 + mov x19, x26 + mov x26, x24 + adrp x24, req_sys+4 + mov x23, x20 + add x24, x24, :lo12:req_sys+4 +.LBB31_13: // in Loop: Header=BB31_8 Depth=2 + ldrh w8, [x23, :lo12:c_ftl_nand_byte_pre_page] + mov w10, #42982 + movk w10, #18374, lsl #16 + cbz x8, .LBB31_16 +// %bb.14: // in Loop: Header=BB31_8 Depth=2 + mov w10, #42982 + movk w10, #18374, lsl #16 +.LBB31_15: // Parent Loop BB31_7 Depth=1 + // Parent Loop BB31_8 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrb w11, [x9], #1 + lsr w12, w10, #2 + add w12, w12, w10, lsl #5 + subs x8, x8, #1 // =1 + add w11, w12, w11 + eor w10, w11, w10 + b.ne .LBB31_15 +.LBB31_16: // in Loop: Header=BB31_8 Depth=2 + ldr x8, [sp, #8] // 8-byte Folded Reload + mov w1, #1 + mov w2, #1 + mov x0, x26 + str w10, [x8, #12] + bl FlashProgPages + ldrh w9, [x25, :lo12:gSysInfo+2] + ldr w10, [x26] + add w8, w9, #1 // =1 + cmn w10, #1 // =1 + strh w8, [x25, :lo12:gSysInfo+2] + b.eq .LBB31_19 +// %bb.17: // in Loop: Header=BB31_8 Depth=2 + cbz w9, .LBB31_8 +// %bb.18: // in Loop: Header=BB31_8 Depth=2 + cmp w10, #256 // =256 + b.eq .LBB31_8 + b .LBB31_26 +.LBB31_19: // in Loop: Header=BB31_7 Depth=1 + cbnz w9, .LBB31_21 +// %bb.20: // in Loop: Header=BB31_7 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlVpcTblFlush + mov w2, #1145 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlVpcTblFlush + bl sftl_printk + ldrh w8, [x25, :lo12:gSysInfo+2] +.LBB31_21: // in Loop: Header=BB31_7 Depth=1 + and w9, w8, #0xffff + cmp w9, #1 // =1 + b.ne .LBB31_23 +// %bb.22: // in Loop: Header=BB31_7 Depth=1 + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_slc_blk] + sub w8, w8, #1 // =1 + strh w8, [x25, :lo12:gSysInfo+2] +.LBB31_23: // in Loop: Header=BB31_7 Depth=1 + ldr w10, [sp, #4] // 4-byte Folded Reload + and w9, w10, #0xffff + add w10, w10, #1 // =1 + cmp w9, #3 // =3 + b.lo .LBB31_7 +// %bb.24: + adrp x8, req_sys+4 + ldr w1, [x8, :lo12:req_sys+4] + adrp x0, .L.str.95 + add x0, x0, :lo12:.L.str.95 + mov w2, #4 + bl sftl_printk +.LBB31_25: // =>This Inner Loop Header: Depth=1 + b .LBB31_25 +.LBB31_26: + mvn w8, w28 + tst w8, #0xffff + b.eq .LBB31_30 +// %bb.27: + tst w28, #0xffff + b.eq .LBB31_30 +// %bb.28: + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + cmp w8, #1024 // =1024 + b.eq .LBB31_30 +// %bb.29: + adrp x13, req_erase + ldr x10, [x13, :lo12:req_erase] + and w8, w28, #0xffff + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x11, c_ftl_nand_planes_per_die + lsl w12, w8, #10 + ldrh w11, [x11, :lo12:c_ftl_nand_planes_per_die] + str w12, [x10, #4] + ldr x0, [x13, :lo12:req_erase] + udiv w10, w8, w9 + msub w8, w10, w9, w8 + mov w2, #1 + udiv w19, w8, w11 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x19, #1 + adrp x12, g_totle_sys_slc_erase_count + adrp x11, gSysFreeQueue + ldrh w10, [x8, x9] + add x11, x11, :lo12:gSysFreeQueue + add w10, w10, #1 // =1 + strh w10, [x8, x9] + ldr w8, [x12, :lo12:g_totle_sys_slc_erase_count] + ldrh w9, [x11, #6] + ldrh w10, [x11, #4] + add w8, w8, #1 // =1 + add w9, w9, #1 // =1 + str w8, [x12, :lo12:g_totle_sys_slc_erase_count] + add x8, x11, x10, lsl #1 + add w10, w10, #1 // =1 + strh w9, [x11, #6] + strh w28, [x8, #8] + and w8, w10, #0x3ff + strh w8, [x11, #4] +.LBB31_30: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.LBB31_31: + mov w22, #65535 +.LBB31_32: + adrp x8, gSysFreeQueue+6 + ldrh w2, [x8, :lo12:gSysFreeQueue+6] + adrp x0, .L.str.86 + add x0, x0, :lo12:.L.str.86 + mov w1, w22 + bl sftl_printk +.LBB31_33: // =>This Inner Loop Header: Depth=1 + b .LBB31_33 +.Lfunc_end31: + .size FtlVpcTblFlush, .Lfunc_end31-FtlVpcTblFlush + // -- End function + .globl FtlSysBlkInit // -- Begin function FtlSysBlkInit + .p2align 2 + .type FtlSysBlkInit,@function +FtlSysBlkInit: // @FtlSysBlkInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_max_sys_blks + ldr w8, [x8, :lo12:c_ftl_nand_max_sys_blks] + adrp x9, gSysFreeQueue + add x9, x9, :lo12:gSysFreeQueue + stp x20, x19, [sp, #48] // 16-byte Folded Spill + adrp x20, g_power_lost_recovery_flag + add x0, x9, #8 // =8 + mov w2, #2048 + mov w1, wzr + stp x24, x23, [sp, #16] // 16-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + mov x29, sp + strh wzr, [x20, :lo12:g_power_lost_recovery_flag] + stur wzr, [x9, #2] + strh wzr, [x9, #6] + strh w8, [x9] + bl memset + bl FtlScanSysBlk + adrp x8, gSysInfo + ldrsh w8, [x8, :lo12:gSysInfo] + cmn w8, #1 // =1 + b.eq .LBB32_2 +// %bb.1: + bl FtlLoadSysInfo + cbz w0, .LBB32_3 +.LBB32_2: + mov w0, #-1 + b .LBB32_48 +.LBB32_3: + mov w21, #19539 + movk w21, #18004, lsl #16 + bl FtlLoadMapInfo + adrp x8, c_ftl_nand_max_vendor_blks + adrp x10, g_totle_vendor_block + adrp x11, c_ftl_nand_vendor_region_num + ldrh w8, [x8, :lo12:c_ftl_nand_max_vendor_blks] + ldrh w10, [x10, :lo12:g_totle_vendor_block] + ldrh w11, [x11, :lo12:c_ftl_nand_vendor_region_num] + adrp x0, gVendorBlkInfo + add x0, x0, :lo12:gVendorBlkInfo + mov w9, #61574 + strh w9, [x0, #4] + adrp x9, p_vendor_block_table + strh w8, [x0, #10] + adrp x8, p_vendor_block_ver_table + strh w10, [x0, #8] + adrp x10, p_vendor_block_valid_page_count + strh w11, [x0, #6] + adrp x11, p_vendor_region_ppn_table + ldr x9, [x9, :lo12:p_vendor_block_table] + ldr x8, [x8, :lo12:p_vendor_block_ver_table] + ldr x10, [x10, :lo12:p_vendor_block_valid_page_count] + ldr x11, [x11, :lo12:p_vendor_region_ppn_table] + stp x9, x8, [x0, #16] + stp x10, x11, [x0, #32] + bl FtlMapTblRecovery + adrp x19, g_sys_ext_data + add x19, x19, :lo12:g_sys_ext_data + mov w1, #1 + mov w0, wzr + mov x2, x19 + bl FtlVendorPartRead + ldr w8, [x19] + cmp w8, w21 + b.ne .LBB32_5 +// %bb.4: + adrp x11, g_sys_ext_data+8 + add x11, x11, :lo12:g_sys_ext_data+8 + ldp w0, w18, [x11, #80] + ldp w17, w16, [x11] + ldp w15, w14, [x11, #8] + ldp w8, w13, [x11, #20] + ldp w12, w9, [x11, #28] + ldp w10, w11, [x11, #36] + b .LBB32_6 +.LBB32_5: + add x0, x19, #4 // =4 + mov w2, #508 + mov w1, wzr + bl memset + mov w11, wzr + mov w10, wzr + mov w9, wzr + mov w12, wzr + mov w13, wzr + mov w8, wzr + mov w14, wzr + mov w15, wzr + mov w16, wzr + mov w17, wzr + mov w18, wzr + mov w0, wzr + str w21, [x19] +.LBB32_6: + adrp x1, g_totle_write_sector + str w0, [x1, :lo12:g_totle_write_sector] + adrp x0, g_totle_read_sector + adrp x1, g_totle_gc_page_count + str w18, [x0, :lo12:g_totle_read_sector] + adrp x18, g_totle_write_page_count + adrp x0, g_totle_read_page_count + str w17, [x1, :lo12:g_totle_gc_page_count] + adrp x17, g_totle_l2p_write_count + str w16, [x18, :lo12:g_totle_write_page_count] + adrp x16, g_totle_sys_slc_erase_count + str w15, [x0, :lo12:g_totle_read_page_count] + adrp x15, g_totle_cache_write_count + adrp x0, g_max_erase_count + str w14, [x17, :lo12:g_totle_l2p_write_count] + adrp x17, g_totle_mlc_erase_count + str w13, [x16, :lo12:g_totle_sys_slc_erase_count] + adrp x13, c_mlc_erase_count_value + adrp x14, g_min_erase_count + adrp x21, c_ftl_nand_data_blks_per_plane + str w9, [x15, :lo12:g_totle_cache_write_count] + str w10, [x0, :lo12:g_max_erase_count] + ldr w9, [x17, :lo12:g_totle_mlc_erase_count] + ldrh w10, [x13, :lo12:c_mlc_erase_count_value] + adrp x1, g_totle_slc_erase_count + adrp x19, g_ect_tbl_info_size + adrp x22, gp_ect_tbl_info + str w11, [x14, :lo12:g_min_erase_count] + ldrh w11, [x21, :lo12:c_ftl_nand_data_blks_per_plane] + str w8, [x1, :lo12:g_totle_slc_erase_count] + ldrh w1, [x19, :lo12:g_ect_tbl_info_size] + ldr x2, [x22, :lo12:gp_ect_tbl_info] + madd w8, w9, w10, w8 + adrp x18, g_totle_discard_page_count + udiv w8, w8, w11 + adrp x9, g_totle_avg_erase_count + mov w0, #64 + str w12, [x18, :lo12:g_totle_discard_page_count] + str w8, [x9, :lo12:g_totle_avg_erase_count] + bl FtlVendorPartRead + ldr x8, [x22, :lo12:gp_ect_tbl_info] + mov w9, #17221 + movk w9, #16980, lsl #16 + ldr w8, [x8] + cmp w8, w9 + b.eq .LBB32_8 +// %bb.7: + adrp x0, .L.str.75 + adrp x1, .L.str.96 + add x0, x0, :lo12:.L.str.75 + add x1, x1, :lo12:.L.str.96 + bl sftl_printk + ldrh w8, [x19, :lo12:g_ect_tbl_info_size] + ldr x0, [x22, :lo12:gp_ect_tbl_info] + mov w1, wzr + lsl x2, x8, #9 + bl memset +.LBB32_8: + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + adrp x19, g_sys_save_data+28 + cbz w8, .LBB32_13 +// %bb.9: + ldrh w8, [x19, :lo12:g_sys_save_data+28] + and w8, w8, #0x1f + cbz w8, .LBB32_13 +// %bb.10: + adrp x9, gSysFreeQueue+2 + add x9, x9, :lo12:gSysFreeQueue+2 + ldrh w13, [x9] + ldrh w11, [x9, #2] + adrp x12, gSysFreeQueue+8 + mov w10, wzr + add x12, x12, :lo12:gSysFreeQueue+8 +.LBB32_11: // =>This Inner Loop Header: Depth=1 + and x14, x13, #0xffff + ldrh w14, [x12, x14, lsl #1] + add w13, w13, #1 // =1 + and x15, x11, #0xffff + add w11, w11, #1 // =1 + add w10, w10, #1 // =1 + and w13, w13, #0x3ff + cmp w8, w10, uxth + and w11, w11, #0x3ff + strh w14, [x12, x15, lsl #1] + b.hi .LBB32_11 +// %bb.12: + strh w13, [x9] + strh w11, [x9, #2] +.LBB32_13: + bl SupperBlkListInit + bl FtlPowerLostRecovery + ldrh w8, [x21, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x9, FtlUpdateVaildLpnCount + strh wzr, [x9, :lo12:FtlUpdateVaildLpnCount] + adrp x9, g_VaildLpn + adrp x22, p_valid_page_count_table + str wzr, [x9, :lo12:g_VaildLpn] + cbz x8, .LBB32_18 +// %bb.14: + ldr x11, [x22, :lo12:p_valid_page_count_table] + mov w10, wzr + mov w12, #65535 + b .LBB32_16 +.LBB32_15: // in Loop: Header=BB32_16 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB32_18 +.LBB32_16: // =>This Inner Loop Header: Depth=1 + ldrh w13, [x11] + cmp w13, w12 + b.eq .LBB32_15 +// %bb.17: // in Loop: Header=BB32_16 Depth=1 + add w10, w10, w13 + str w10, [x9, :lo12:g_VaildLpn] + b .LBB32_15 +.LBB32_18: + adrp x21, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB32_22 +// %bb.19: + adrp x9, p_l2p_ram_map + ldr x11, [x9, :lo12:p_l2p_ram_map] + cmp w8, #1 // =1 + mov x10, xzr + csinc w9, w8, wzr, hi + add x11, x11, #4 // =4 +.LBB32_20: // =>This Inner Loop Header: Depth=1 + ldr w12, [x11] + tbnz w12, #31, .LBB32_23 +// %bb.21: // in Loop: Header=BB32_20 Depth=1 + add x10, x10, #1 // =1 + cmp x9, x10 + add x11, x11, #16 // =16 + b.ne .LBB32_20 + b .LBB32_24 +.LBB32_22: + mov w9, wzr + b .LBB32_24 +.LBB32_23: + mov w9, w10 +.LBB32_24: + ldrh w10, [x19, :lo12:g_sys_save_data+28] + cmp w9, w8 + add w8, w10, #1 // =1 + strh w8, [x19, :lo12:g_sys_save_data+28] + adrp x19, g_active_superblock + add x19, x19, :lo12:g_active_superblock + b.lo .LBB32_26 +// %bb.25: + ldrh w8, [x20, :lo12:g_power_lost_recovery_flag] + cbz w8, .LBB32_32 +.LBB32_26: + mov x0, x19 + bl FtlSuperblockPowerLostFix + adrp x20, g_buffer_superblock + add x20, x20, :lo12:g_buffer_superblock + mov x0, x20 + bl FtlSuperblockPowerLostFix + ldrh w8, [x19] + ldr x9, [x22, :lo12:p_valid_page_count_table] + ldrh w10, [x19, #4] + lsl x8, x8, #1 + ldrh w11, [x9, x8] + sub w10, w11, w10 + adrp x11, c_ftl_nand_page_pre_blk + strh w10, [x9, x8] + ldrh w8, [x11, :lo12:c_ftl_nand_page_pre_blk] + ldrh w9, [x20] + ldr x10, [x22, :lo12:p_valid_page_count_table] + strb wzr, [x19, #6] + strh wzr, [x19, #4] + strh w8, [x19, #2] + lsl x8, x9, #1 + ldrh w12, [x20, #4] + ldrh w9, [x10, x8] + sub w9, w9, w12 + adrp x12, g_sys_save_data+30 + strh w9, [x10, x8] + ldrh w8, [x11, :lo12:c_ftl_nand_page_pre_blk] + ldrh w9, [x12, :lo12:g_sys_save_data+30] + strb wzr, [x20, #6] + strh wzr, [x20, #4] + strh w8, [x20, #2] + add w8, w9, #1 // =1 + strh w8, [x12, :lo12:g_sys_save_data+30] + bl FtlWriteDump_data + ldrh w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB32_31 +// %bb.27: + adrp x20, gL2pMapInfo + mov x22, xzr + mov x23, xzr + adrp x24, p_l2p_ram_map + add x20, x20, :lo12:gL2pMapInfo + b .LBB32_29 +.LBB32_28: // in Loop: Header=BB32_29 Depth=1 + add x23, x23, #1 // =1 + cmp x23, w8, uxth + add x22, x22, #16 // =16 + b.hs .LBB32_31 +.LBB32_29: // =>This Inner Loop Header: Depth=1 + ldr x9, [x24, :lo12:p_l2p_ram_map] + add x9, x9, x22 + ldr w10, [x9, #4] + tbz w10, #31, .LBB32_28 +// %bb.30: // in Loop: Header=BB32_29 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x20 + bl FtlMapWritePage + ldr x8, [x24, :lo12:p_l2p_ram_map] + add x8, x8, x22 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB32_28 +.LBB32_31: + bl FtlVpcTblFlush + bl FtlVpcTblFlush +.LBB32_32: + ldrh w20, [x19] + mov w8, #65535 + cmp w20, w8 + b.eq .LBB32_47 +// %bb.33: + adrp x9, g_buffer_superblock+4 + ldrh w8, [x19, #4] + ldrh w9, [x9, :lo12:g_buffer_superblock+4] + orr w8, w9, w8 + tst w8, #0xffff + b.ne .LBB32_47 +// %bb.34: + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w20 + bl sftl_printk + adrp x22, g_gc_next_blk + ldrh w8, [x22, :lo12:g_gc_next_blk] + adrp x21, g_gc_next_blk_1 + cmp w8, w20 + b.eq .LBB32_40 +// %bb.35: + ldrh w9, [x21, :lo12:g_gc_next_blk_1] + cmp w9, w20 + b.eq .LBB32_40 +// %bb.36: + mov w10, #65535 + cmp w8, w10 + b.eq .LBB32_39 +// %bb.37: + cmp w9, w10 + b.ne .LBB32_40 +// %bb.38: + strh w20, [x21, :lo12:g_gc_next_blk_1] + b .LBB32_40 +.LBB32_39: + strh w20, [x22, :lo12:g_gc_next_blk] +.LBB32_40: + adrp x8, g_buffer_superblock + ldrh w19, [x8, :lo12:g_buffer_superblock] + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w19 + bl sftl_printk + ldrh w8, [x22, :lo12:g_gc_next_blk] + cmp w8, w19 + b.eq .LBB32_46 +// %bb.41: + ldrh w9, [x21, :lo12:g_gc_next_blk_1] + cmp w9, w19 + b.eq .LBB32_46 +// %bb.42: + mov w10, #65535 + cmp w8, w10 + b.eq .LBB32_45 +// %bb.43: + cmp w9, w10 + b.ne .LBB32_46 +// %bb.44: + strh w19, [x21, :lo12:g_gc_next_blk_1] + b .LBB32_46 +.LBB32_45: + strh w19, [x22, :lo12:g_gc_next_blk] +.LBB32_46: + bl FtlVpcTblFlush + adrp x0, g_active_superblock + add x0, x0, :lo12:g_active_superblock + bl allocate_new_data_superblock + adrp x0, g_buffer_superblock + add x0, x0, :lo12:g_buffer_superblock + bl allocate_new_data_superblock +.LBB32_47: + bl FtlVpcCheckAndModify + mov w0, wzr +.LBB32_48: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldp x24, x23, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end32: + .size FtlSysBlkInit, .Lfunc_end32-FtlSysBlkInit + // -- End function + .globl sftl_init // -- Begin function sftl_init + .p2align 2 + .type sftl_init,@function +sftl_init: // @sftl_init +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x0, .L.str.75 + adrp x1, .L.str.1 + str x19, [sp, #16] // 8-byte Folded Spill + adrp x19, gFtlInitStatus + mov w8, #-1 + add x0, x0, :lo12:.L.str.75 + add x1, x1, :lo12:.L.str.1 + mov x29, sp + str w8, [x19, :lo12:gFtlInitStatus] + bl sftl_printk + adrp x0, g_nand_phy_info + add x0, x0, :lo12:g_nand_phy_info + bl FtlConstantsInit + bl FtlMemInit + bl FtlVariablesInit + adrp x8, c_ftl_nand_max_sys_blks + ldr w8, [x8, :lo12:c_ftl_nand_max_sys_blks] + adrp x9, gSysFreeQueue + add x9, x9, :lo12:gSysFreeQueue + add x0, x9, #8 // =8 + mov w2, #2048 + mov w1, wzr + stur wzr, [x9, #2] + strh wzr, [x9, #6] + strh w8, [x9] + bl memset + bl FtlLoadBbt + cbnz w0, .LBB33_5 +// %bb.1: + bl FtlSysBlkInit + cbnz w0, .LBB33_5 +// %bb.2: + adrp x8, g_num_free_superblocks + ldrh w8, [x8, :lo12:g_num_free_superblocks] + mov w9, #1 + str w9, [x19, :lo12:gFtlInitStatus] + cmp w8, #15 // =15 + b.hi .LBB33_5 +// %bb.3: + mov w19, #8129 +.LBB33_4: // =>This Inner Loop Header: Depth=1 + mov w0, wzr + bl rk_ftl_garbage_collect + subs w19, w19, #1 // =1 + b.ne .LBB33_4 +.LBB33_5: + ldr x19, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end33: + .size sftl_init, .Lfunc_end33-sftl_init + // -- End function + .globl rk_ftl_garbage_collect // -- Begin function rk_ftl_garbage_collect + .p2align 2 + .type rk_ftl_garbage_collect,@function +rk_ftl_garbage_collect: // @rk_ftl_garbage_collect +// %bb.0: + hint #25 + sub sp, sp, #144 // =144 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #48] // 16-byte Folded Spill + add x29, sp, #48 // =48 + stp x28, x27, [sp, #64] // 16-byte Folded Spill + stp x26, x25, [sp, #80] // 16-byte Folded Spill + stp x24, x23, [sp, #96] // 16-byte Folded Spill + stp x22, x21, [sp, #112] // 16-byte Folded Spill + stp x20, x19, [sp, #128] // 16-byte Folded Spill + stur x8, [x29, #-8] + adrp x24, g_in_gc_progress + ldr w8, [x24, :lo12:g_in_gc_progress] + mov w20, wzr + cbnz w8, .LBB34_187 +// %bb.1: + adrp x8, g_num_data_superblocks + ldrh w8, [x8, :lo12:g_num_data_superblocks] + cmp w8, #48 // =48 + b.lo .LBB34_187 +// %bb.2: + adrp x8, ftl_gc_temp_block_bops_scan_page_addr + ldrsh w8, [x8, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + mov w22, w0 + cmn w8, #1 // =1 + b.eq .LBB34_5 +// %bb.3: + adrp x8, g_gc_temp_superblock + ldrh w8, [x8, :lo12:g_gc_temp_superblock] + mov w9, #65535 + cmp w8, w9 + b.eq .LBB34_5 +// %bb.4: + mov w0, #1 + mov w20, #1 + bl FtlGcFreeTempBlock + cbnz w0, .LBB34_187 +.LBB34_5: + adrp x20, g_gc_next_blk_1 + ldrh w8, [x20, :lo12:g_gc_next_blk_1] + mov w28, #65535 + adrp x19, g_gc_next_blk + cmp w8, w28 + b.eq .LBB34_8 +// %bb.6: + ldrh w9, [x19, :lo12:g_gc_next_blk] + cmp w9, w28 + b.ne .LBB34_8 +// %bb.7: + strh w8, [x19, :lo12:g_gc_next_blk] + mov w8, #65535 + strh w8, [x20, :lo12:g_gc_next_blk_1] +.LBB34_8: + bl FtlReadRefresh + adrp x27, g_gc_superblock + adrp x10, g_gc_temp_superblock + adrp x8, g_gc_skip_write_count + ldrh w10, [x10, :lo12:g_gc_temp_superblock] + ldrh w12, [x27, :lo12:g_gc_superblock] + ldr w11, [x8, :lo12:g_gc_skip_write_count] + ldrh w21, [x19, :lo12:g_gc_next_blk] + mov w9, #1 + bfi w9, w22, #7, #25 + and w10, w10, w12 + add w9, w11, w9 + cmp w10, w28 + adrp x25, g_num_free_superblocks + str w9, [x8, :lo12:g_gc_skip_write_count] + b.ne .LBB34_35 +// %bb.9: + mov w10, #65535 + cmp w21, w10 + b.ne .LBB34_35 +// %bb.10: + ldrh w10, [x25, :lo12:g_num_free_superblocks] + mov w11, #1024 + cmp w10, #24 // =24 + mov w10, #5120 + csel w10, w10, w11, lo + cmp w9, w10 + b.ls .LBB34_13 +// %bb.11: + str wzr, [x8, :lo12:g_gc_skip_write_count] + adrp x8, gc_ink_free_return_value + strh wzr, [x8, :lo12:gc_ink_free_return_value] + bl GetSwlReplaceBlock + ldrh w2, [x25, :lo12:g_num_free_superblocks] + mvn w8, w0 + mov w28, w0 + tst w8, #0xffff + b.eq .LBB34_14 +.LBB34_12: + adrp x8, p_valid_page_count_table + adrp x10, p_erase_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldr x10, [x10, :lo12:p_erase_count_table] + and x9, x28, #0xffff + adrp x11, g_gc_free_blk_threshold + lsl x9, x9, #1 + ldrh w3, [x8, x9] + ldrh w4, [x10, x9] + ldrh w5, [x11, :lo12:g_gc_free_blk_threshold] + adrp x0, .L.str.115 + and w1, w28, #0xffff + add x0, x0, :lo12:.L.str.115 + bl sftl_printk + b .LBB34_24 +.LBB34_13: + mov w21, #65535 + mov w28, #65535 + b .LBB34_35 +.LBB34_14: + adrp x8, g_gc_merge_free_blk_threshold + ldrh w9, [x8, :lo12:g_gc_merge_free_blk_threshold] + cmp w2, w9 + b.hs .LBB34_21 +// %bb.15: + adrp x9, p_data_block_list_head + ldr x9, [x9, :lo12:p_data_block_list_head] + cbz x9, .LBB34_23 +// %bb.16: + adrp x10, p_data_block_list_table + ldr x10, [x10, :lo12:p_data_block_list_table] + mov w11, #64 + mov w12, #6 + mov x14, x9 +.LBB34_17: // =>This Inner Loop Header: Depth=1 + ldrh w13, [x14] + mov w14, #65535 + cmp x13, x14 + b.eq .LBB34_199 +// %bb.18: // in Loop: Header=BB34_17 Depth=1 + sub w11, w11, #1 // =1 + tst w11, #0xffff + madd x14, x13, x12, x10 + b.ne .LBB34_17 +// %bb.19: + adrp x11, p_valid_page_count_table + ldr x11, [x11, :lo12:p_valid_page_count_table] + ldrh w11, [x11, x13, lsl #1] + cmp w11, #8 // =8 + b.hs .LBB34_203 +// %bb.20: + sub x9, x9, x10 + mov w10, #43691 + movk w10, #43690, lsl #16 + lsr x9, x9, #1 + mul w28, w9, w10 + mvn w9, w28 + tst w9, #0xffff + mov w9, #128 + strh w9, [x8, :lo12:g_gc_merge_free_blk_threshold] + b.ne .LBB34_12 + b .LBB34_23 +.LBB34_21: + mov w9, #80 +.LBB34_22: + strh w9, [x8, :lo12:g_gc_merge_free_blk_threshold] +.LBB34_23: + mov w28, #65535 +.LBB34_24: + adrp x8, g_gc_bad_block_temp_num + ldrh w9, [x8, :lo12:g_gc_bad_block_temp_num] + ldrh w21, [x19, :lo12:g_gc_next_blk] + cbz w9, .LBB34_35 +// %bb.25: + mov w8, #65535 + cmp w21, w8 + b.ne .LBB34_35 +// %bb.26: + mov w23, w22 + adrp x22, g_gc_bad_block_gc_index + ldrh w8, [x22, :lo12:g_gc_bad_block_gc_index] + cmp w8, w9 + b.lo .LBB34_28 +// %bb.27: + mov w8, wzr + strh wzr, [x22, :lo12:g_gc_bad_block_gc_index] +.LBB34_28: + adrp x9, g_gc_bad_block_temp_tbl + add x9, x9, :lo12:g_gc_bad_block_temp_tbl + adrp x10, c_ftl_nand_blks_per_die + ldrh w8, [x9, w8, uxtw #1] + ldrh w9, [x10, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x0, .L.str.112 + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w21, w8, w10 + add x0, x0, :lo12:.L.str.112 + mov w1, w21 + bl sftl_printk + ldrh w8, [x19, :lo12:g_gc_next_blk] + cmp w8, w21 + b.eq .LBB34_34 +// %bb.29: + ldrh w9, [x20, :lo12:g_gc_next_blk_1] + cmp w9, w21, uxth + b.eq .LBB34_33 +// %bb.30: + mov w10, #65535 + cmp w8, w10 + b.eq .LBB34_200 +// %bb.31: + cmp w9, w10 + b.ne .LBB34_33 +// %bb.32: + strh w21, [x20, :lo12:g_gc_next_blk_1] +.LBB34_33: + mov w21, w8 +.LBB34_34: + ldrh w8, [x22, :lo12:g_gc_bad_block_gc_index] + add w8, w8, #1 // =1 + strh w8, [x22, :lo12:g_gc_bad_block_gc_index] + mov w22, w23 +.LBB34_35: + adrp x12, g_in_swl_replace + cbnz w22, .LBB34_39 +// %bb.36: + mvn w8, w28 + tst w8, #0xffff + b.ne .LBB34_39 +// %bb.37: + ldrh w9, [x25, :lo12:g_num_free_superblocks] + cmp w9, #24 // =24 + b.ls .LBB34_47 +// %bb.38: + mov w10, #1 + b .LBB34_52 +.LBB34_39: + adrp x8, g_gc_temp_superblock + ldrh w9, [x8, :lo12:g_gc_temp_superblock] + ldrh w8, [x27, :lo12:g_gc_superblock] + mov w26, #1 + and w10, w21, w9 + mov w9, #65535 + cmp w10, w9 + b.ne .LBB34_74 +// %bb.40: + and w10, w8, w28 + cmp w10, w9 + b.ne .LBB34_74 +// %bb.41: + adrp x21, g_gc_free_blk_threshold + ldrh w8, [x25, :lo12:g_num_free_superblocks] + ldrh w9, [x21, :lo12:g_gc_free_blk_threshold] + mov x23, x12 + adrp x20, gc_ink_free_return_value + str wzr, [x12, :lo12:g_in_swl_replace] + cmp w8, w9 + b.ls .LBB34_63 +// %bb.42: + ldrh w8, [x20, :lo12:gc_ink_free_return_value] + cbnz w8, .LBB34_44 +// %bb.43: + adrp x9, g_MaxLpn + adrp x8, g_VaildLpn + ldr w9, [x9, :lo12:g_MaxLpn] + ldr w8, [x8, :lo12:g_VaildLpn] + add w9, w9, w9, lsl #1 + cmp w8, w9, lsr #2 + b.hs .LBB34_189 +.LBB34_44: + adrp x8, c_ftl_nand_data_op_blks_per_plane + ldrh w8, [x8, :lo12:c_ftl_nand_data_op_blks_per_plane] + add w8, w8, w8, lsl #1 + lsr w8, w8, #2 +.LBB34_45: + strh w8, [x21, :lo12:g_gc_free_blk_threshold] + bl FtlReadRefresh + adrp x8, p_data_block_list_head + ldr x8, [x8, :lo12:p_data_block_list_head] + cbz x8, .LBB34_60 +// %bb.46: + adrp x9, p_data_block_list_table + ldr w9, [x9, :lo12:p_data_block_list_table] + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and x8, x8, #0xffff + b .LBB34_61 +.LBB34_47: + adrp x8, c_ftl_nand_page_pre_blk + cmp w9, #17 // =17 + b.lo .LBB34_49 +// %bb.48: + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_blk] + lsr w10, w8, #5 + b .LBB34_52 +.LBB34_49: + cmp w9, #13 // =13 + b.lo .LBB34_51 +// %bb.50: + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_blk] + lsr w10, w8, #4 + b .LBB34_52 +.LBB34_51: + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_blk] + cmp w9, #8 // =8 + lsr w10, w8, #2 + csel w10, w10, w8, hi +.LBB34_52: + adrp x8, g_gc_free_blk_threshold + ldrh w11, [x8, :lo12:g_gc_free_blk_threshold] + cmp w9, w11 + b.ls .LBB34_55 +// %bb.53: + adrp x9, g_gc_temp_superblock + ldrh w9, [x9, :lo12:g_gc_temp_superblock] + mov w11, #65535 + and w9, w21, w9 + cmp w9, w11 + b.eq .LBB34_56 +// %bb.54: + adrp x9, c_ftl_nand_data_op_blks_per_plane + ldrh w9, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane] + add w9, w9, w9, lsl #1 + lsr w9, w9, #2 + strh w9, [x8, :lo12:g_gc_free_blk_threshold] +.LBB34_55: + adrp x8, g_gc_bad_block_temp_num + ldrh w8, [x8, :lo12:g_gc_bad_block_temp_num] + add w9, w10, #32 // =32 + cmp w8, #0 // =0 + csel w26, w10, w9, eq + b .LBB34_73 +.LBB34_56: + adrp x9, gc_ink_free_return_value + ldrh w20, [x9, :lo12:gc_ink_free_return_value] + mov x11, x12 + cbnz w20, .LBB34_58 +// %bb.57: + adrp x10, g_MaxLpn + adrp x9, g_VaildLpn + ldr w10, [x10, :lo12:g_MaxLpn] + ldr w9, [x9, :lo12:g_VaildLpn] + add w10, w10, w10, lsl #1 + cmp w9, w10, lsr #2 + b.hs .LBB34_195 +.LBB34_58: + adrp x9, c_ftl_nand_data_op_blks_per_plane + ldrh w9, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane] + add w9, w9, w9, lsl #1 + lsr w9, w9, #2 +.LBB34_59: + strh w9, [x8, :lo12:g_gc_free_blk_threshold] + str wzr, [x11, :lo12:g_in_swl_replace] + b .LBB34_187 +.LBB34_60: + mov w8, #65535 +.LBB34_61: + adrp x9, p_valid_page_count_table + ldr x9, [x9, :lo12:p_valid_page_count_table] + ldrh w8, [x9, x8, lsl #1] + cmp w8, #5 // =5 + b.lo .LBB34_63 +// %bb.62: + ldrh w20, [x20, :lo12:gc_ink_free_return_value] + b .LBB34_187 +.LBB34_63: + ldrh w8, [x20, :lo12:gc_ink_free_return_value] + cbz w8, .LBB34_65 +// %bb.64: + mov w26, #1 + b .LBB34_72 +.LBB34_65: + adrp x8, c_ftl_nand_data_op_blks_per_plane + ldrh w8, [x8, :lo12:c_ftl_nand_data_op_blks_per_plane] + mov w13, w22 + adrp x22, p_data_block_list_head + ldr x9, [x22, :lo12:p_data_block_list_head] + add w10, w8, w8, lsl #1 + lsr w10, w10, #2 + strh w10, [x21, :lo12:g_gc_free_blk_threshold] + cbz x9, .LBB34_67 +// %bb.66: + adrp x10, p_data_block_list_table + ldr w10, [x10, :lo12:p_data_block_list_table] + sub w9, w9, w10 + mov w10, #43691 + lsr w9, w9, #1 + movk w10, #43690, lsl #16 + mul w9, w9, w10 + and x9, x9, #0xffff + b .LBB34_68 +.LBB34_67: + mov w9, #65535 +.LBB34_68: + adrp x21, p_valid_page_count_table + adrp x10, c_ftl_nand_page_pre_slc_blk + ldr x11, [x21, :lo12:p_valid_page_count_table] + adrp x12, c_ftl_nand_planes_num + ldrh w10, [x10, :lo12:c_ftl_nand_page_pre_slc_blk] + ldrh w12, [x12, :lo12:c_ftl_nand_planes_num] + ldrh w9, [x11, x9, lsl #1] + mul w10, w12, w10 + cmp w10, #0 // =0 + cinc w10, w10, lt + cmp w9, w10, asr #1 + b.le .LBB34_70 +// %bb.69: + ldrh w10, [x25, :lo12:g_num_free_superblocks] + sub w8, w8, #1 // =1 + cmp w8, w10 + b.le .LBB34_196 +.LBB34_70: + cbz w9, .LBB34_190 +// %bb.71: + mov w26, #1 + mov w22, w13 +.LBB34_72: + mov x12, x23 +.LBB34_73: + ldrh w8, [x27, :lo12:g_gc_superblock] +.LBB34_74: + mov w9, #65535 + adrp x10, g_gc_superblock+8 + cmp w8, w9 + adrp x23, g_gc_cur_blk_max_valid_pages + b.ne .LBB34_90 +// %bb.75: + mvn w8, w28 + tst w8, #0xffff + b.eq .LBB34_83 +// %bb.76: + strh w28, [x27, :lo12:g_gc_superblock] + mov w8, w28 +.LBB34_77: + adrp x9, g_gc_blk_num + ldrh w9, [x9, :lo12:g_gc_blk_num] + strb wzr, [x10, :lo12:g_gc_superblock+8] + cbz x9, .LBB34_82 +// %bb.78: + adrp x10, p_gc_blk_tbl + ldr x10, [x10, :lo12:p_gc_blk_tbl] +.LBB34_79: // =>This Inner Loop Header: Depth=1 + ldrh w11, [x10] + cmp w11, w8, uxth + b.eq .LBB34_86 +// %bb.80: // in Loop: Header=BB34_79 Depth=1 + subs x9, x9, #1 // =1 + add x10, x10, #2 // =2 + b.ne .LBB34_79 +// %bb.81: + mvn w8, w8 + tst w8, #0xffff + b.eq .LBB34_88 +.LBB34_82: + adrp x19, g_gc_superblock + add x19, x19, :lo12:g_gc_superblock + mov x0, x19 + mov x20, x12 + bl make_superblock + adrp x8, p_valid_page_count_table + ldr x9, [x8, :lo12:p_valid_page_count_table] + ldrh w8, [x19] + adrp x10, g_gc_cur_blk_valid_pages + strh wzr, [x19, #2] + strb wzr, [x19, #6] + strh wzr, [x10, :lo12:g_gc_cur_blk_valid_pages] + ldrh w9, [x9, x8, lsl #1] + mov x12, x20 + strh w9, [x23, :lo12:g_gc_cur_blk_max_valid_pages] + b .LBB34_90 +.LBB34_83: + ldrh w8, [x19, :lo12:g_gc_next_blk] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB34_87 +// %bb.84: + adrp x9, p_valid_page_count_table + ldr x9, [x9, :lo12:p_valid_page_count_table] + ldrh w9, [x9, x8, lsl #1] + cbz w9, .LBB34_89 +// %bb.85: + mov w9, #65535 + strh w8, [x27, :lo12:g_gc_superblock] + strh w9, [x19, :lo12:g_gc_next_blk] + b .LBB34_77 +.LBB34_86: + mov w8, #65535 + strh w8, [x27, :lo12:g_gc_superblock] + b .LBB34_90 +.LBB34_87: + strb wzr, [x10, :lo12:g_gc_superblock+8] +.LBB34_88: + mov w8, #65535 + b .LBB34_90 +.LBB34_89: + adrp x9, g_gc_superblock + mov w8, #65535 + add x9, x9, :lo12:g_gc_superblock + strh w8, [x9] + strh w8, [x19, :lo12:g_gc_next_blk] + strb wzr, [x9, #8] +.LBB34_90: + adrp x9, g_active_superblock + ldrh w9, [x9, :lo12:g_active_superblock] + str x28, [sp, #16] // 8-byte Folded Spill + cmp w8, w9 + adrp x9, g_buffer_superblock + b.eq .LBB34_93 +// %bb.91: + ldrh w9, [x9, :lo12:g_buffer_superblock] + cmp w8, w9 + b.eq .LBB34_93 +// %bb.92: + adrp x9, g_gc_temp_superblock + ldrh w9, [x9, :lo12:g_gc_temp_superblock] + cmp w8, w9 + b.ne .LBB34_94 +.LBB34_93: + mov w8, #65535 + strh w8, [x27, :lo12:g_gc_superblock] +.LBB34_94: + mov w18, #65535 + adrp x17, c_ftl_nand_planes_num + mov w20, #6 + adrp x13, g_gc_superblock+2 + adrp x28, req_gc + mov w23, #24 + // kill: def $w8 killed $w8 killed $x8 def $x8 +.LBB34_95: // =>This Loop Header: Depth=1 + // Child Loop BB34_125 Depth 2 + // Child Loop BB34_127 Depth 3 + // Child Loop BB34_132 Depth 3 + // Child Loop BB34_101 Depth 2 + // Child Loop BB34_104 Depth 3 + // Child Loop BB34_111 Depth 3 + // Child Loop BB34_118 Depth 4 + // Child Loop BB34_161 Depth 2 + // Child Loop BB34_168 Depth 2 + mvn w9, w8 + tst w9, #0xffff + b.eq .LBB34_123 +.LBB34_96: // in Loop: Header=BB34_95 Depth=1 + adrp x9, c_ftl_nand_page_pre_blk + ldrh w11, [x9, :lo12:c_ftl_nand_page_pre_blk] + mov w9, #1 + str w9, [x24, :lo12:g_in_gc_progress] + cbz w22, .LBB34_98 +// %bb.97: // in Loop: Header=BB34_95 Depth=1 + adrp x9, p_valid_page_count_table + ldr x9, [x9, :lo12:p_valid_page_count_table] + // kill: def $w8 killed $w8 killed $x8 def $x8 + and x8, x8, #0xffff + ldrh w8, [x9, x8, lsl #1] + ldrh w9, [x17, :lo12:c_ftl_nand_planes_num] + neg w8, w8 + madd w8, w9, w11, w8 + add w9, w8, #3 // =3 + cmp w8, #0 // =0 + csel w8, w9, w8, lt + add w26, w26, w8, lsr #2 +.LBB34_98: // in Loop: Header=BB34_95 Depth=1 + ldrh w8, [x13, :lo12:g_gc_superblock+2] + add w9, w8, w26, uxth + sub w10, w11, w8 + cmp w9, w11 + csel w9, w10, w26, hi + tst w9, #0xffff + b.eq .LBB34_153 +// %bb.99: // in Loop: Header=BB34_95 Depth=1 + stp w11, w22, [sp, #8] // 8-byte Folded Spill + mov w22, wzr + and w8, w9, #0xffff + str w9, [sp, #4] // 4-byte Folded Spill + stur w8, [x29, #-20] // 4-byte Folded Spill + b .LBB34_101 +.LBB34_100: // in Loop: Header=BB34_101 Depth=2 + ldur w8, [x29, #-20] // 4-byte Folded Reload + add w22, w22, #1 // =1 + adrp x17, c_ftl_nand_planes_num + adrp x13, g_gc_superblock+2 + cmp w22, w8 + mov w18, #65535 + b.eq .LBB34_152 +.LBB34_101: // Parent Loop BB34_95 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB34_104 Depth 3 + // Child Loop BB34_111 Depth 3 + // Child Loop BB34_118 Depth 4 + ldrh w9, [x17, :lo12:c_ftl_nand_planes_num] + cbz w9, .LBB34_106 +// %bb.102: // in Loop: Header=BB34_101 Depth=2 + adrp x14, g_gc_superblock + mov x8, xzr + mov w20, wzr + add x14, x14, :lo12:g_gc_superblock + b .LBB34_104 +.LBB34_103: // in Loop: Header=BB34_104 Depth=3 + add x8, x8, #1 // =1 + cmp x8, w9, uxth + b.hs .LBB34_107 +.LBB34_104: // Parent Loop BB34_95 Depth=1 + // Parent Loop BB34_101 Depth=2 + // => This Inner Loop Header: Depth=3 + add x10, x14, x8, lsl #1 + ldrh w10, [x10, #16] + cmp w10, w18 + b.eq .LBB34_103 +// %bb.105: // in Loop: Header=BB34_104 Depth=3 + ldrh w9, [x13, :lo12:g_gc_superblock+2] + ldr x11, [x28, :lo12:req_gc] + and x12, x20, #0xffff + add w20, w20, #1 // =1 + add w9, w22, w9 + orr w9, w9, w10, lsl #10 + add x10, x11, x12, lsl #5 + str w9, [x10, #4] + ldrh w9, [x17, :lo12:c_ftl_nand_planes_num] + b .LBB34_103 +.LBB34_106: // in Loop: Header=BB34_101 Depth=2 + mov w20, wzr +.LBB34_107: // in Loop: Header=BB34_101 Depth=2 + ldr x0, [x28, :lo12:req_gc] + and w26, w20, #0xffff + mov w1, w26 + bl FlashReadPages + cbz w26, .LBB34_100 +// %bb.108: // in Loop: Header=BB34_101 Depth=2 + // kill: def $w20 killed $w20 killed $x20 def $x20 + mov x24, xzr + and x20, x20, #0xffff + b .LBB34_111 +.LBB34_109: // in Loop: Header=BB34_111 Depth=3 + bl Ftl_gc_temp_data_write_back + cbnz w0, .LBB34_186 +.LBB34_110: // in Loop: Header=BB34_111 Depth=3 + add x24, x24, #1 // =1 + cmp x24, x20 + b.eq .LBB34_100 +.LBB34_111: // Parent Loop BB34_95 Depth=1 + // Parent Loop BB34_101 Depth=2 + // => This Loop Header: Depth=3 + // Child Loop BB34_118 Depth 4 + ldr x8, [x28, :lo12:req_gc] + add x8, x8, x24, lsl #5 + ldr w9, [x8] + cmn w9, #1 // =1 + b.eq .LBB34_110 +// %bb.112: // in Loop: Header=BB34_111 Depth=3 + ldr x27, [x8, #16] + ldrsh w8, [x27] + cmn w8, #3947 // =3947 + b.ne .LBB34_110 +// %bb.113: // in Loop: Header=BB34_111 Depth=3 + ldr w26, [x27, #8] + cmn w26, #1 // =1 + b.ne .LBB34_115 +// %bb.114: // in Loop: Header=BB34_111 Depth=3 + adrp x0, .L.str.78 + adrp x1, .L__func__.rk_ftl_garbage_collect + mov w2, #753 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect + bl sftl_printk +.LBB34_115: // in Loop: Header=BB34_111 Depth=3 + sub x1, x29, #12 // =12 + mov w0, w26 + mov w2, wzr + bl log2phys + ldr x8, [x28, :lo12:req_gc] + ldur w26, [x29, #-12] + add x9, x8, x24, lsl #5 + ldr w9, [x9, #4] + cmp w26, w9 + b.ne .LBB34_110 +// %bb.116: // in Loop: Header=BB34_111 Depth=3 + adrp x11, g_gc_cur_blk_valid_pages + ldrh w9, [x11, :lo12:g_gc_cur_blk_valid_pages] + lsl x19, x24, #5 + adrp x25, req_gc_dst + adrp x21, g_gc_num_req + add w9, w9, #1 // =1 + ldr x10, [x25, :lo12:req_gc_dst] + add x8, x8, x19 + strh w9, [x11, :lo12:g_gc_cur_blk_valid_pages] + ldr w9, [x21, :lo12:g_gc_num_req] + ldr w8, [x8, #24] + add x9, x10, x9, lsl #5 + str w8, [x9, #24] + bl Ftl_get_new_temp_ppa + ldr x8, [x25, :lo12:req_gc_dst] + ldr w9, [x21, :lo12:g_gc_num_req] + add x8, x8, x9, lsl #5 + str w0, [x8, #4] + ldr x8, [x28, :lo12:req_gc] + ldr w10, [x21, :lo12:g_gc_num_req] + ldr x9, [x25, :lo12:req_gc_dst] + add x8, x8, x19 + ldr x8, [x8, #8] + lsl x10, x10, #5 + add x9, x9, x10 + str x8, [x9, #8] + ldr x8, [x28, :lo12:req_gc] + ldr x9, [x25, :lo12:req_gc_dst] + add x8, x8, x19 + ldr x8, [x8, #16] + add x9, x9, x10 + str x8, [x9, #16] + str w26, [x27, #12] + adrp x8, g_gc_temp_superblock + ldrh w8, [x8, :lo12:g_gc_temp_superblock] + adrp x9, c_gc_page_buf_num + strh w8, [x27, #2] + adrp x8, g_GlobalDataVersion + ldr w8, [x8, :lo12:g_GlobalDataVersion] + str w8, [x27, #4] + ldr w8, [x21, :lo12:g_gc_num_req] + ldr w10, [x9, :lo12:c_gc_page_buf_num] + add w8, w8, #1 // =1 + str w8, [x21, :lo12:g_gc_num_req] + cbz w10, .LBB34_121 +// %bb.117: // in Loop: Header=BB34_111 Depth=3 + adrp x11, gp_gc_page_buf_info + ldr x9, [x28, :lo12:req_gc] + ldr x11, [x11, :lo12:gp_gc_page_buf_info] + mov w12, wzr +.LBB34_118: // Parent Loop BB34_95 Depth=1 + // Parent Loop BB34_101 Depth=2 + // Parent Loop BB34_111 Depth=3 + // => This Inner Loop Header: Depth=4 + and x13, x12, #0xffff + madd x13, x13, x23, x11 + ldr w14, [x13, #16]! + cbz w14, .LBB34_120 +// %bb.119: // in Loop: Header=BB34_118 Depth=4 + add w12, w12, #1 // =1 + cmp w10, w12, uxth + b.hi .LBB34_118 + b .LBB34_121 +.LBB34_120: // in Loop: Header=BB34_111 Depth=3 + mov w8, #1 + str w8, [x13] + adrp x11, gp_gc_page_buf_info + ldr x8, [x11, :lo12:gp_gc_page_buf_info] + // kill: def $w12 killed $w12 killed $x12 def $x12 + and x10, x12, #0xffff + add x10, x10, w12, uxth #1 + lsl x10, x10, #3 + ldr x8, [x8, x10] + add x9, x9, x24, lsl #5 + str x8, [x9, #8] + ldr x8, [x11, :lo12:gp_gc_page_buf_info] + add x8, x8, x10 + ldr x8, [x8, #8] + str x8, [x9, #16] + adrp x8, g_gc_num_req + ldr w8, [x8, :lo12:g_gc_num_req] +.LBB34_121: // in Loop: Header=BB34_111 Depth=3 + adrp x9, g_gc_temp_superblock+4 + add x9, x9, :lo12:g_gc_temp_superblock+4 + ldrb w9, [x9, #3] + cmp w8, w9 + b.eq .LBB34_109 +// %bb.122: // in Loop: Header=BB34_111 Depth=3 + adrp x8, g_gc_temp_superblock+4 + add x8, x8, :lo12:g_gc_temp_superblock+4 + ldrh w8, [x8] + cbnz w8, .LBB34_110 + b .LBB34_109 +.LBB34_123: // in Loop: Header=BB34_95 Depth=1 + adrp x8, p_data_block_list_head + ldr x8, [x8, :lo12:p_data_block_list_head] + str wzr, [x12, :lo12:g_in_swl_replace] + cbz x8, .LBB34_184 +// %bb.124: // in Loop: Header=BB34_95 Depth=1 + adrp x9, g_gc_blk_index + ldrh w10, [x9, :lo12:g_gc_blk_index] + mov x25, x12 +.LBB34_125: // Parent Loop BB34_95 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB34_127 Depth 3 + // Child Loop BB34_132 Depth 3 + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + tst w10, #0xffff + mov x12, x8 + b.eq .LBB34_129 +// %bb.126: // in Loop: Header=BB34_125 Depth=2 + mov x12, x8 + mov w11, w10 +.LBB34_127: // Parent Loop BB34_95 Depth=1 + // Parent Loop BB34_125 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrh w12, [x12] + cmp x12, x18 + b.eq .LBB34_184 +// %bb.128: // in Loop: Header=BB34_127 Depth=3 + sub w11, w11, #1 // =1 + tst w11, #0xffff + madd x12, x12, x20, x9 + b.ne .LBB34_127 +.LBB34_129: // in Loop: Header=BB34_125 Depth=2 + sub x9, x12, x9 + mov x11, #-6148914691236517206 + asr x9, x9, #1 + movk x11, #43691 + mul x9, x9, x11 + and x11, x9, #0xffff + cmp x11, x18 + strh w9, [x27, :lo12:g_gc_superblock] + b.eq .LBB34_185 +// %bb.130: // in Loop: Header=BB34_125 Depth=2 + adrp x12, g_gc_blk_num + ldrh w13, [x12, :lo12:g_gc_blk_num] + cbz x13, .LBB34_134 +// %bb.131: // in Loop: Header=BB34_125 Depth=2 + adrp x12, p_gc_blk_tbl + ldr x12, [x12, :lo12:p_gc_blk_tbl] + mov x14, x13 +.LBB34_132: // Parent Loop BB34_95 Depth=1 + // Parent Loop BB34_125 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrh w15, [x12] + cmp w15, w9, uxth + b.eq .LBB34_147 +// %bb.133: // in Loop: Header=BB34_132 Depth=3 + subs x14, x14, #1 // =1 + add x12, x12, #2 // =2 + b.ne .LBB34_132 +.LBB34_134: // in Loop: Header=BB34_125 Depth=2 + adrp x12, p_valid_page_count_table + ldr x15, [x12, :lo12:p_valid_page_count_table] + adrp x12, c_ftl_nand_page_pre_blk + ldrh w12, [x12, :lo12:c_ftl_nand_page_pre_blk] + ldrh w16, [x17, :lo12:c_ftl_nand_planes_num] + add w14, w10, #1 // =1 + adrp x10, g_gc_blk_index + strh w14, [x10, :lo12:g_gc_blk_index] + ldrh w10, [x15, x11, lsl #1] + mul w12, w16, w12 + cmp w12, #0 // =0 + cinc w16, w12, lt + cmp w10, w16, asr #1 + b.gt .LBB34_138 +// %bb.135: // in Loop: Header=BB34_125 Depth=2 + cmp w13, #35 // =35 + b.hi .LBB34_139 +// %bb.136: // in Loop: Header=BB34_125 Depth=2 + and w13, w14, #0xffff + cmp w13, #49 // =49 + b.lo .LBB34_139 +// %bb.137: // in Loop: Header=BB34_125 Depth=2 + cmp w10, #9 // =9 + b.lo .LBB34_139 +.LBB34_138: // in Loop: Header=BB34_125 Depth=2 + adrp x10, g_gc_blk_index + strh wzr, [x10, :lo12:g_gc_blk_index] + ldrh w10, [x15, x11, lsl #1] + mov w14, wzr +.LBB34_139: // in Loop: Header=BB34_125 Depth=2 + and w11, w14, #0xffff + cmp w11, #3 // =3 + b.hi .LBB34_142 +// %bb.140: // in Loop: Header=BB34_125 Depth=2 + ldr x11, [sp, #16] // 8-byte Folded Reload + mvn w11, w11 + tst w11, #0xffff + b.ne .LBB34_142 +// %bb.141: // in Loop: Header=BB34_125 Depth=2 + cmp w12, w10 + b.le .LBB34_197 +.LBB34_142: // in Loop: Header=BB34_125 Depth=2 + cbnz w10, .LBB34_175 +// %bb.143: // in Loop: Header=BB34_125 Depth=2 + adrp x9, g_tmp_data_superblock_id + ldrh w0, [x9, :lo12:g_tmp_data_superblock_id] + mov x19, x17 + cmp w0, w18 + b.eq .LBB34_148 +// %bb.144: // in Loop: Header=BB34_125 Depth=2 + mov x20, x9 + bl update_vpc_list + adrp x8, p_data_block_list_head + adrp x9, p_data_block_list_table + ldr x8, [x8, :lo12:p_data_block_list_head] + ldr w9, [x9, :lo12:p_data_block_list_table] + adrp x10, p_valid_page_count_table + ldr x10, [x10, :lo12:p_valid_page_count_table] + mov w11, #43691 + sub w9, w8, w9 + lsr w9, w9, #1 + movk w11, #43690, lsl #16 + mov w18, #65535 + mul w9, w9, w11 + strh w18, [x20, :lo12:g_tmp_data_superblock_id] + and x9, x9, #0xffff + ldrh w10, [x10, x9, lsl #1] + cbnz w10, .LBB34_149 +// %bb.145: // in Loop: Header=BB34_125 Depth=2 + cmp x9, x18 + mov w20, #6 + b.eq .LBB34_150 +// %bb.146: // in Loop: Header=BB34_125 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.decrement_vpc_count + mov w2, #2869 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.decrement_vpc_count + bl sftl_printk + adrp x8, p_data_block_list_head + ldr x8, [x8, :lo12:p_data_block_list_head] + mov w18, #65535 + b .LBB34_150 +.LBB34_147: // in Loop: Header=BB34_125 Depth=2 + adrp x9, g_gc_blk_index + b .LBB34_151 +.LBB34_148: // in Loop: Header=BB34_125 Depth=2 + strh w18, [x9, :lo12:g_tmp_data_superblock_id] + b .LBB34_150 +.LBB34_149: // in Loop: Header=BB34_125 Depth=2 + mov w20, #6 +.LBB34_150: // in Loop: Header=BB34_125 Depth=2 + adrp x9, g_gc_blk_index + ldrh w10, [x9, :lo12:g_gc_blk_index] + mov x17, x19 +.LBB34_151: // in Loop: Header=BB34_125 Depth=2 + add w10, w10, #1 // =1 + strh w10, [x9, :lo12:g_gc_blk_index] + cbnz x8, .LBB34_125 + b .LBB34_184 +.LBB34_152: // in Loop: Header=BB34_95 Depth=1 + ldrh w8, [x13, :lo12:g_gc_superblock+2] + ldp w11, w22, [sp, #8] // 8-byte Folded Reload + ldr w9, [sp, #4] // 4-byte Folded Reload + adrp x24, g_in_gc_progress + adrp x12, g_in_swl_replace + mov w20, #6 +.LBB34_153: // in Loop: Header=BB34_95 Depth=1 + add w8, w8, w9 + cmp w11, w8, uxth + adrp x27, g_gc_superblock + strh w8, [x13, :lo12:g_gc_superblock+2] + b.hi .LBB34_173 +// %bb.154: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_gc_num_req + ldr w8, [x8, :lo12:g_gc_num_req] + mov x19, x17 + cbz w8, .LBB34_156 +// %bb.155: // in Loop: Header=BB34_95 Depth=1 + mov x21, x12 + bl Ftl_gc_temp_data_write_back + mov x12, x21 + mov w18, #65535 + cbnz w0, .LBB34_204 +.LBB34_156: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_gc_cur_blk_valid_pages + ldrh w8, [x8, :lo12:g_gc_cur_blk_valid_pages] + adrp x13, g_gc_superblock+2 + cbnz w8, .LBB34_172 +// %bb.157: // in Loop: Header=BB34_95 Depth=1 + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldrh w9, [x27, :lo12:g_gc_superblock] + ldrh w8, [x8, x9, lsl #1] + cbz w8, .LBB34_172 +// %bb.158: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_MaxLpn + ldr w8, [x8, :lo12:g_MaxLpn] + cbz w8, .LBB34_165 +// %bb.159: // in Loop: Header=BB34_95 Depth=1 + mov x21, x12 + mov w26, wzr + b .LBB34_161 +.LBB34_160: // in Loop: Header=BB34_161 Depth=2 + adrp x8, g_MaxLpn + ldr w8, [x8, :lo12:g_MaxLpn] + add w26, w26, #1 // =1 + cmp w26, w8 + b.hs .LBB34_164 +.LBB34_161: // Parent Loop BB34_95 Depth=1 + // => This Inner Loop Header: Depth=2 + sub x1, x29, #16 // =16 + mov w0, w26 + mov w2, wzr + bl log2phys + ldur w8, [x29, #-16] + cmn w8, #1 // =1 + b.eq .LBB34_160 +// %bb.162: // in Loop: Header=BB34_161 Depth=2 + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + ubfx w8, w8, #10, #16 + ldrh w11, [x27, :lo12:g_gc_superblock] + udiv w12, w8, w9 + msub w8, w12, w9, w8 + udiv w8, w8, w10 + cmp w8, w11 + b.ne .LBB34_160 +// %bb.163: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_MaxLpn + ldr w8, [x8, :lo12:g_MaxLpn] +.LBB34_164: // in Loop: Header=BB34_95 Depth=1 + adrp x13, g_gc_superblock+2 + mov x12, x21 + cmp w26, w8 + b.lo .LBB34_171 +.LBB34_165: // in Loop: Header=BB34_95 Depth=1 + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldrh w9, [x27, :lo12:g_gc_superblock] + mov w26, w22 + strh wzr, [x8, x9, lsl #1] + ldrh w0, [x27, :lo12:g_gc_superblock] + bl update_vpc_list + bl FtlWriteDump_data + adrp x8, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x8, :lo12:c_ftl_nand_l2pmap_ram_region_num] + adrp x11, p_l2p_ram_map + cbz w8, .LBB34_170 +// %bb.166: // in Loop: Header=BB34_95 Depth=1 + mov x20, xzr + mov x22, xzr + b .LBB34_168 +.LBB34_167: // in Loop: Header=BB34_168 Depth=2 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x20, x20, #16 // =16 + b.hs .LBB34_170 +.LBB34_168: // Parent Loop BB34_95 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x9, [x11, :lo12:p_l2p_ram_map] + add x9, x9, x20 + ldr w10, [x9, #4] + tbz w10, #31, .LBB34_167 +// %bb.169: // in Loop: Header=BB34_168 Depth=2 + ldrh w1, [x9] + ldr x2, [x9, #8] + adrp x0, gL2pMapInfo + add x0, x0, :lo12:gL2pMapInfo + bl FtlMapWritePage + adrp x11, p_l2p_ram_map + ldr x8, [x11, :lo12:p_l2p_ram_map] + add x8, x8, x20 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + adrp x8, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x8, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB34_167 +.LBB34_170: // in Loop: Header=BB34_95 Depth=1 + bl FtlVpcTblFlush + mov w22, w26 + adrp x12, g_in_swl_replace + mov w20, #6 + adrp x13, g_gc_superblock+2 +.LBB34_171: // in Loop: Header=BB34_95 Depth=1 + mov w18, #65535 +.LBB34_172: // in Loop: Header=BB34_95 Depth=1 + mov x17, x19 + strh w18, [x27, :lo12:g_gc_superblock] +.LBB34_173: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_num_free_superblocks + ldrh w8, [x8, :lo12:g_num_free_superblocks] + str wzr, [x24, :lo12:g_in_gc_progress] + cmp w8, #2 // =2 + b.hi .LBB34_198 +// %bb.174: // in Loop: Header=BB34_95 Depth=1 + adrp x8, c_ftl_nand_page_pre_blk + ldrh w26, [x8, :lo12:c_ftl_nand_page_pre_blk] + ldrh w8, [x27, :lo12:g_gc_superblock] + b .LBB34_95 +.LBB34_175: // in Loop: Header=BB34_95 Depth=1 + mvn w8, w9 + tst w8, #0xffff + adrp x8, g_gc_superblock+8 + strb wzr, [x8, :lo12:g_gc_superblock+8] + b.ne .LBB34_177 +// %bb.176: // in Loop: Header=BB34_95 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.rk_ftl_garbage_collect + mov w2, #716 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect + mov x19, x17 + bl sftl_printk + ldrh w9, [x27, :lo12:g_gc_superblock] + mov x17, x19 +.LBB34_177: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_active_superblock + ldrh w8, [x8, :lo12:g_active_superblock] + mov x19, x17 + cmp w8, w9, uxth + b.ne .LBB34_179 +// %bb.178: // in Loop: Header=BB34_95 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.rk_ftl_garbage_collect + mov w2, #717 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect + bl sftl_printk + ldrh w9, [x27, :lo12:g_gc_superblock] +.LBB34_179: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_buffer_superblock + ldrh w8, [x8, :lo12:g_buffer_superblock] + cmp w8, w9, uxth + b.ne .LBB34_181 +// %bb.180: // in Loop: Header=BB34_95 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.rk_ftl_garbage_collect + mov w2, #718 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect + bl sftl_printk + ldrh w9, [x27, :lo12:g_gc_superblock] +.LBB34_181: // in Loop: Header=BB34_95 Depth=1 + adrp x8, g_gc_temp_superblock + ldrh w8, [x8, :lo12:g_gc_temp_superblock] + cmp w8, w9, uxth + b.ne .LBB34_183 +// %bb.182: // in Loop: Header=BB34_95 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.rk_ftl_garbage_collect + mov w2, #719 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect + bl sftl_printk +.LBB34_183: // in Loop: Header=BB34_95 Depth=1 + adrp x21, g_gc_superblock + add x21, x21, :lo12:g_gc_superblock + mov x0, x21 + bl make_superblock + adrp x8, p_valid_page_count_table + ldr x9, [x8, :lo12:p_valid_page_count_table] + ldrh w8, [x21] + adrp x10, g_gc_cur_blk_valid_pages + strh wzr, [x10, :lo12:g_gc_cur_blk_valid_pages] + adrp x10, g_gc_cur_blk_max_valid_pages + ldrh w9, [x9, x8, lsl #1] + mov x17, x19 + adrp x13, g_gc_superblock+2 + mov w18, #65535 + mov x12, x25 + strh wzr, [x21, #2] + strh w9, [x10, :lo12:g_gc_cur_blk_max_valid_pages] + strb wzr, [x21, #6] + b .LBB34_96 +.LBB34_184: + mov w8, #65535 + strh w8, [x27, :lo12:g_gc_superblock] +.LBB34_185: + adrp x8, g_gc_blk_index + strh wzr, [x8, :lo12:g_gc_blk_index] + mov w20, #8 + b .LBB34_187 +.LBB34_186: + adrp x8, gc_ink_free_return_value + ldrh w20, [x8, :lo12:gc_ink_free_return_value] + adrp x8, g_in_gc_progress + str wzr, [x8, :lo12:g_in_gc_progress] + mov w8, #65535 + adrp x9, g_gc_superblock + str w8, [x9, :lo12:g_gc_superblock] +.LBB34_187: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB34_205 +// %bb.188: + mov w0, w20 + ldp x20, x19, [sp, #128] // 16-byte Folded Reload + ldp x22, x21, [sp, #112] // 16-byte Folded Reload + ldp x24, x23, [sp, #96] // 16-byte Folded Reload + ldp x26, x25, [sp, #80] // 16-byte Folded Reload + ldp x28, x27, [sp, #64] // 16-byte Folded Reload + ldp x29, x30, [sp, #48] // 16-byte Folded Reload + add sp, sp, #144 // =144 + hint #29 + ret +.LBB34_189: + mov w8, #18 + b .LBB34_45 +.LBB34_190: + adrp x19, g_tmp_data_superblock_id + ldrh w0, [x19, :lo12:g_tmp_data_superblock_id] + mov w20, #65535 + cmp w0, w20 + b.eq .LBB34_201 +// %bb.191: + bl update_vpc_list + adrp x9, p_data_block_list_table + ldr w8, [x22, :lo12:p_data_block_list_head] + ldr w9, [x9, :lo12:p_data_block_list_table] + ldr x10, [x21, :lo12:p_valid_page_count_table] + strh w20, [x19, :lo12:g_tmp_data_superblock_id] + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and x8, x8, #0xffff + ldrh w9, [x10, x8, lsl #1] + cbnz w9, .LBB34_194 +// %bb.192: + mov w9, #65535 + cmp x8, x9 + b.eq .LBB34_194 +// %bb.193: + adrp x0, .L.str.78 + adrp x1, .L__func__.decrement_vpc_count + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.decrement_vpc_count + mov w2, #2869 + bl sftl_printk +.LBB34_194: + ldrh w8, [x25, :lo12:g_num_free_superblocks] + b .LBB34_202 +.LBB34_195: + mov w9, #18 + b .LBB34_59 +.LBB34_196: + bl FtlReadRefresh + ldrh w20, [x20, :lo12:gc_ink_free_return_value] + b .LBB34_187 +.LBB34_197: + adrp x8, gc_ink_free_return_value + ldrh w20, [x8, :lo12:gc_ink_free_return_value] + mov w8, #65535 + strh w8, [x27, :lo12:g_gc_superblock] + adrp x8, g_gc_blk_index + strh wzr, [x8, :lo12:g_gc_blk_index] + b .LBB34_187 +.LBB34_198: + adrp x9, gc_ink_free_return_value + ldrh w20, [x9, :lo12:gc_ink_free_return_value] + cbnz w20, .LBB34_187 + b .LBB34_202 +.LBB34_199: + mov w28, w14 + b .LBB34_24 +.LBB34_200: + strh w21, [x19, :lo12:g_gc_next_blk] + b .LBB34_34 +.LBB34_201: + ldrh w8, [x25, :lo12:g_num_free_superblocks] + strh w20, [x19, :lo12:g_tmp_data_superblock_id] +.LBB34_202: + add w20, w8, #1 // =1 + b .LBB34_187 +.LBB34_203: + mov w9, #64 + b .LBB34_22 +.LBB34_204: + adrp x8, gc_ink_free_return_value + ldrh w20, [x8, :lo12:gc_ink_free_return_value] + str wzr, [x24, :lo12:g_in_gc_progress] + b .LBB34_187 +.LBB34_205: + bl __stack_chk_fail +.Lfunc_end34: + .size rk_ftl_garbage_collect, .Lfunc_end34-rk_ftl_garbage_collect + // -- End function + .globl FtlSysFlush // -- Begin function FtlSysFlush + .p2align 2 + .type FtlSysFlush,@function +FtlSysFlush: // @FtlSysFlush +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + str x23, [sp, #16] // 8-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x29, sp + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB35_5 +// %bb.1: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB35_3 +.LBB35_2: // in Loop: Header=BB35_3 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB35_5 +.LBB35_3: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB35_2 +// %bb.4: // in Loop: Header=BB35_3 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB35_2 +.LBB35_5: + mov w0, #1 + bl FtlEctTblFlush + bl FtlVpcTblFlush + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end35: + .size FtlSysFlush, .Lfunc_end35-FtlSysFlush + // -- End function + .globl FtlCacheWriteBack // -- Begin function FtlCacheWriteBack + .p2align 2 + .type FtlCacheWriteBack,@function +FtlCacheWriteBack: // @FtlCacheWriteBack +// %bb.0: + hint #25 + mov w0, wzr + hint #29 + ret +.Lfunc_end36: + .size FtlCacheWriteBack, .Lfunc_end36-FtlCacheWriteBack + // -- End function + .globl l2p_flush // -- Begin function l2p_flush + .p2align 2 + .type l2p_flush,@function +l2p_flush: // @l2p_flush +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + str x23, [sp, #16] // 8-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x29, sp + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB37_5 +// %bb.1: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB37_3 +.LBB37_2: // in Loop: Header=BB37_3 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB37_5 +.LBB37_3: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB37_2 +// %bb.4: // in Loop: Header=BB37_3 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB37_2 +.LBB37_5: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end37: + .size l2p_flush, .Lfunc_end37-l2p_flush + // -- End function + .globl FtlEctTblFlush // -- Begin function FtlEctTblFlush + .p2align 2 + .type FtlEctTblFlush,@function +FtlEctTblFlush: // @FtlEctTblFlush +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + adrp x8, g_ect_tbl_power_up_flush + ldrh w9, [x8, :lo12:g_ect_tbl_power_up_flush] + mov x29, sp + cmp w9, #31 // =31 + b.hi .LBB38_2 +// %bb.1: + add w9, w9, #1 // =1 + strh w9, [x8, :lo12:g_ect_tbl_power_up_flush] + mov w9, #1 + b .LBB38_3 +.LBB38_2: + mov w9, #32 +.LBB38_3: + adrp x8, gp_ect_tbl_info + ldr x10, [x8, :lo12:gp_ect_tbl_info] + ldr w11, [x10, #16] + cbnz w0, .LBB38_5 +// %bb.4: + ldr w12, [x10, #20] + add w9, w12, w9 + cmp w11, w9 + b.lo .LBB38_7 +.LBB38_5: + mov w9, #17221 + movk w9, #16980, lsl #16 + str w11, [x10, #20] + str w9, [x10] + ldr x9, [x8, :lo12:gp_ect_tbl_info] + adrp x10, g_ect_tbl_info_size + ldrh w1, [x10, :lo12:g_ect_tbl_info_size] + mov w0, #64 + ldr w10, [x9, #8] + str wzr, [x9, #4] + lsl w11, w1, #9 + add w10, w10, #1 // =1 + stp w10, w11, [x9, #8] + ldr x2, [x8, :lo12:gp_ect_tbl_info] + bl FtlVendorPartWrite + adrp x8, g_sys_ext_data + ldr w8, [x8, :lo12:g_sys_ext_data] + mov w9, #19539 + movk w9, #18004, lsl #16 + cmp w8, w9 + b.ne .LBB38_7 +// %bb.6: + adrp x9, g_totle_write_sector + adrp x10, g_totle_read_sector + ldr w9, [x9, :lo12:g_totle_write_sector] + ldr w10, [x10, :lo12:g_totle_read_sector] + adrp x2, g_sys_ext_data + add x2, x2, :lo12:g_sys_ext_data + adrp x11, g_totle_gc_page_count + adrp x12, g_totle_write_page_count + adrp x13, g_totle_read_page_count + stp w9, w10, [x2, #88] + ldr w10, [x11, :lo12:g_totle_gc_page_count] + ldr w11, [x12, :lo12:g_totle_write_page_count] + ldr w12, [x13, :lo12:g_totle_read_page_count] + mov w8, #86 + movk w8, #20480, lsl #16 + adrp x14, g_totle_l2p_write_count + adrp x15, g_totle_slc_erase_count + adrp x9, g_totle_sys_slc_erase_count + stp w8, w10, [x2, #4] + ldr w10, [x14, :lo12:g_totle_l2p_write_count] + stp w11, w12, [x2, #12] + ldr w12, [x15, :lo12:g_totle_slc_erase_count] + ldr w9, [x9, :lo12:g_totle_sys_slc_erase_count] + adrp x8, g_totle_discard_page_count + adrp x11, g_totle_cache_write_count + str w10, [x2, #20] + adrp x10, g_max_erase_count + stp w12, w9, [x2, #28] + adrp x9, g_min_erase_count + ldr w8, [x8, :lo12:g_totle_discard_page_count] + ldr w11, [x11, :lo12:g_totle_cache_write_count] + ldr w10, [x10, :lo12:g_max_erase_count] + ldr w9, [x9, :lo12:g_min_erase_count] + mov w1, #1 + mov w0, wzr + stp w8, w11, [x2, #36] + stp w10, w9, [x2, #44] + bl FtlVendorPartWrite +.LBB38_7: + mov w0, wzr + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end38: + .size FtlEctTblFlush, .Lfunc_end38-FtlEctTblFlush + // -- End function + .globl sftl_deinit // -- Begin function sftl_deinit + .p2align 2 + .type sftl_deinit,@function +sftl_deinit: // @sftl_deinit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + adrp x8, gFtlInitStatus + ldr w8, [x8, :lo12:gFtlInitStatus] + str x23, [sp, #16] // 8-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + cmp w8, #1 // =1 + mov x29, sp + b.ne .LBB39_7 +// %bb.1: + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB39_6 +// %bb.2: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB39_4 +.LBB39_3: // in Loop: Header=BB39_4 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB39_6 +.LBB39_4: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB39_3 +// %bb.5: // in Loop: Header=BB39_4 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB39_3 +.LBB39_6: + mov w0, #1 + bl FtlEctTblFlush + bl FtlVpcTblFlush +.LBB39_7: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end39: + .size sftl_deinit, .Lfunc_end39-sftl_deinit + // -- End function + .globl FtlRead // -- Begin function FtlRead + .p2align 2 + .type FtlRead,@function +FtlRead: // @FtlRead +// %bb.0: + hint #25 + sub sp, sp, #176 // =176 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + and w9, w0, #0xff + stp x29, x30, [sp, #80] // 16-byte Folded Spill + stp x22, x21, [sp, #144] // 16-byte Folded Spill + stp x20, x19, [sp, #160] // 16-byte Folded Spill + add x29, sp, #80 // =80 + mov x19, x3 + mov w21, w1 + cmp w9, #16 // =16 + stp x28, x27, [sp, #96] // 16-byte Folded Spill + stp x26, x25, [sp, #112] // 16-byte Folded Spill + stp x24, x23, [sp, #128] // 16-byte Folded Spill + stur x8, [x29, #-8] + b.ne .LBB40_2 +// %bb.1: + add w0, w21, #256 // =256 + mov w1, w2 + mov x2, x19 + bl FtlVendorPartRead + b .LBB40_12 +.LBB40_2: + adrp x8, g_MaxLbaSector + ldr w8, [x8, :lo12:g_MaxLbaSector] + mov w0, #-1 + cmp w8, w21 + b.ls .LBB40_12 +// %bb.3: + cmp w8, w2 + b.lo .LBB40_12 +// %bb.4: + add w9, w2, w21 + cmp w9, w8 + mov w0, #-1 + stur w9, [x29, #-16] // 4-byte Folded Spill + b.hi .LBB40_12 +// %bb.5: + adrp x8, gFtlInitStatus + ldr w8, [x8, :lo12:gFtlInitStatus] + cmn w8, #1 // =1 + b.eq .LBB40_12 +// %bb.6: + adrp x10, c_ftl_nand_sec_pre_page + ldur w8, [x29, #-16] // 4-byte Folded Reload + ldrh w10, [x10, :lo12:c_ftl_nand_sec_pre_page] + adrp x9, g_totle_read_sector + adrp x11, g_totle_read_page_count + ldr w12, [x9, :lo12:g_totle_read_sector] + sub w8, w8, #1 // =1 + ldr w13, [x11, :lo12:g_totle_read_page_count] + udiv w24, w21, w10 + udiv w23, w8, w10 + sub w10, w23, w24 + add w8, w12, w2 + adds w25, w10, #1 // =1 + str w8, [x9, :lo12:g_totle_read_sector] + add w8, w13, w25 + str w8, [x11, :lo12:g_totle_read_page_count] + b.lo .LBB40_14 +// %bb.7: + stur wzr, [x29, #-20] // 4-byte Folded Spill +.LBB40_8: + adrp x8, g_gc_bad_block_temp_num + ldrh w8, [x8, :lo12:g_gc_bad_block_temp_num] + cbnz w8, .LBB40_10 +// %bb.9: + adrp x8, g_num_free_superblocks + ldrh w8, [x8, :lo12:g_num_free_superblocks] + cmp w8, #31 // =31 + b.hi .LBB40_11 +.LBB40_10: + mov w0, wzr + bl rk_ftl_garbage_collect +.LBB40_11: + ldur w0, [x29, #-20] // 4-byte Folded Reload +.LBB40_12: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB40_56 +// %bb.13: + ldp x20, x19, [sp, #160] // 16-byte Folded Reload + ldp x22, x21, [sp, #144] // 16-byte Folded Reload + ldp x24, x23, [sp, #128] // 16-byte Folded Reload + ldp x26, x25, [sp, #112] // 16-byte Folded Reload + ldp x28, x27, [sp, #96] // 16-byte Folded Reload + ldp x29, x30, [sp, #80] // 16-byte Folded Reload + add sp, sp, #176 // =176 + hint #29 + ret +.LBB40_14: + mov w27, wzr + adrp x26, req_read + adrp x28, g_sys_ext_data+72 + mov w20, w24 + str w2, [sp, #12] // 4-byte Folded Spill + str xzr, [sp, #16] // 8-byte Folded Spill + str wzr, [sp, #24] // 4-byte Folded Spill + stur wzr, [x29, #-20] // 4-byte Folded Spill + b .LBB40_17 +.LBB40_15: // in Loop: Header=BB40_17 Depth=1 + ldr w25, [sp, #28] // 4-byte Folded Reload + mov w27, wzr +.LBB40_16: // in Loop: Header=BB40_17 Depth=1 + add w20, w20, #1 // =1 + cbz w25, .LBB40_8 +.LBB40_17: // =>This Loop Header: Depth=1 + // Child Loop BB40_24 Depth 2 + // Child Loop BB40_39 Depth 2 + sub x1, x29, #12 // =12 + mov w0, w20 + mov w2, wzr + bl log2phys + ldur w9, [x29, #-12] + cmn w9, #1 // =1 + b.eq .LBB40_21 +// %bb.18: // in Loop: Header=BB40_17 Depth=1 + ldr x10, [x26, :lo12:req_read] + mov w8, w27 + cmp w20, w24 + add x10, x10, x8, lsl #5 + str w9, [x10, #4] + b.ne .LBB40_27 +// %bb.19: // in Loop: Header=BB40_17 Depth=1 + ldr x9, [x26, :lo12:req_read] + adrp x10, p_io_data_buf_0 + ldr x10, [x10, :lo12:p_io_data_buf_0] + ldr w11, [sp, #12] // 4-byte Folded Reload + add x9, x9, x8, lsl #5 + str x10, [x9, #8] + adrp x9, c_ftl_nand_sec_pre_page + ldrh w9, [x9, :lo12:c_ftl_nand_sec_pre_page] + udiv w10, w21, w9 + msub w10, w10, w9, w21 + str w10, [sp, #20] // 4-byte Folded Spill + sub w10, w9, w10 + cmp w10, w11 + csel w10, w11, w10, hi + cmp w10, w9 + str w10, [sp, #24] // 4-byte Folded Spill + b.ne .LBB40_33 +// %bb.20: // in Loop: Header=BB40_17 Depth=1 + ldr x10, [x26, :lo12:req_read] + str w9, [sp, #24] // 4-byte Folded Spill + add x10, x10, x8, lsl #5 + str x19, [x10, #8] + b .LBB40_33 +.LBB40_21: // in Loop: Header=BB40_17 Depth=1 + adrp x8, c_ftl_nand_sec_pre_page + ldrh w22, [x8, :lo12:c_ftl_nand_sec_pre_page] + cbz w22, .LBB40_31 +// %bb.22: // in Loop: Header=BB40_17 Depth=1 + stur w27, [x29, #-32] // 4-byte Folded Spill + str w25, [sp, #28] // 4-byte Folded Spill + mov x25, x19 + mov w27, wzr + mul w19, w20, w22 + b .LBB40_24 +.LBB40_23: // in Loop: Header=BB40_24 Depth=2 + add w27, w27, #1 // =1 + cmp w27, w22 + b.hs .LBB40_30 +.LBB40_24: // Parent Loop BB40_17 Depth=1 + // => This Inner Loop Header: Depth=2 + add w9, w19, w27 + subs w8, w9, w21 + b.lo .LBB40_23 +// %bb.25: // in Loop: Header=BB40_24 Depth=2 + ldur w10, [x29, #-16] // 4-byte Folded Reload + cmp w9, w10 + b.hs .LBB40_23 +// %bb.26: // in Loop: Header=BB40_24 Depth=2 + lsl w8, w8, #9 + add x0, x25, x8 + mov w2, #512 + mov w1, wzr + bl memset + b .LBB40_23 +.LBB40_27: // in Loop: Header=BB40_17 Depth=1 + cmp w20, w23 + b.ne .LBB40_32 +// %bb.28: // in Loop: Header=BB40_17 Depth=1 + ldr x9, [x26, :lo12:req_read] + adrp x10, p_io_data_buf_1 + ldr x10, [x10, :lo12:p_io_data_buf_1] + ldur w11, [x29, #-16] // 4-byte Folded Reload + add x9, x9, x8, lsl #5 + str x10, [x9, #8] + adrp x9, c_ftl_nand_sec_pre_page + ldrh w9, [x9, :lo12:c_ftl_nand_sec_pre_page] + mul w10, w23, w9 + sub w11, w11, w10 + cmp w11, w9 + str w11, [sp, #16] // 4-byte Folded Spill + b.ne .LBB40_33 +// %bb.29: // in Loop: Header=BB40_17 Depth=1 + ldr x11, [x26, :lo12:req_read] + sub w10, w10, w21 + lsl w10, w10, #9 + add x10, x19, x10 + add x11, x11, x8, lsl #5 + str x10, [x11, #8] + str w9, [sp, #16] // 4-byte Folded Spill + b .LBB40_33 +.LBB40_30: // in Loop: Header=BB40_17 Depth=1 + mov x19, x25 + ldr w25, [sp, #28] // 4-byte Folded Reload + ldur w27, [x29, #-32] // 4-byte Folded Reload +.LBB40_31: // in Loop: Header=BB40_17 Depth=1 + subs w25, w25, #1 // =1 + b.ne .LBB40_34 + b .LBB40_35 +.LBB40_32: // in Loop: Header=BB40_17 Depth=1 + adrp x9, c_ftl_nand_sec_pre_page + ldrh w9, [x9, :lo12:c_ftl_nand_sec_pre_page] + ldr x11, [x26, :lo12:req_read] + neg w10, w21 + madd w9, w20, w9, w10 + lsl w9, w9, #9 + add x9, x19, x9 + add x10, x11, x8, lsl #5 + str x9, [x10, #8] +.LBB40_33: // in Loop: Header=BB40_17 Depth=1 + adrp x9, c_ftl_nand_byte_pre_oob + ldrh w9, [x9, :lo12:c_ftl_nand_byte_pre_oob] + adrp x11, p_io_spare_buf + ldr x10, [x26, :lo12:req_read] + ldr x11, [x11, :lo12:p_io_spare_buf] + mul w9, w27, w9 + lsl x8, x8, #5 + and w9, w9, #0xfffffffc + add x10, x10, x8 + add x9, x11, x9 + str x9, [x10, #16] + ldr x9, [x26, :lo12:req_read] + add w27, w27, #1 // =1 + add x8, x9, x8 + str w20, [x8, #24] + subs w25, w25, #1 // =1 + b.eq .LBB40_35 +.LBB40_34: // in Loop: Header=BB40_17 Depth=1 + adrp x8, c_ftl_nand_planes_num + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + cmp w27, w8, lsl #2 + b.ne .LBB40_16 +.LBB40_35: // in Loop: Header=BB40_17 Depth=1 + cbz w27, .LBB40_16 +// %bb.36: // in Loop: Header=BB40_17 Depth=1 + ldr x0, [x26, :lo12:req_read] + mov w1, w27 + str w25, [sp, #28] // 4-byte Folded Spill + bl FlashReadPages + ldr w8, [sp, #16] // 4-byte Folded Reload + mov x22, xzr + lsl w8, w8, #9 + str x8, [sp, #32] // 8-byte Folded Spill + ldr w8, [sp, #20] // 4-byte Folded Reload + lsl w8, w8, #9 + stur x8, [x29, #-32] // 8-byte Folded Spill + ldr w8, [sp, #24] // 4-byte Folded Reload + lsl w8, w8, #9 + str x8, [sp, #40] // 8-byte Folded Spill + mov w8, w27 + lsl x27, x8, #5 + b .LBB40_39 +.LBB40_37: // in Loop: Header=BB40_39 Depth=2 + adrp x8, g_gc_next_blk + strh w25, [x8, :lo12:g_gc_next_blk] +.LBB40_38: // in Loop: Header=BB40_39 Depth=2 + add x22, x22, #32 // =32 + cmp x27, x22 + b.eq .LBB40_15 +.LBB40_39: // Parent Loop BB40_17 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x8, [x26, :lo12:req_read] + add x9, x8, x22 + ldr w10, [x9, #24] + cmp w10, w24 + b.ne .LBB40_42 +// %bb.40: // in Loop: Header=BB40_39 Depth=2 + ldr x8, [x9, #8] + adrp x9, p_io_data_buf_0 + ldr x9, [x9, :lo12:p_io_data_buf_0] + cmp x8, x9 + b.ne .LBB40_46 +// %bb.41: // in Loop: Header=BB40_39 Depth=2 + ldur x9, [x29, #-32] // 8-byte Folded Reload + ldr x2, [sp, #40] // 8-byte Folded Reload + mov x0, x19 + add x1, x8, x9 + b .LBB40_45 +.LBB40_42: // in Loop: Header=BB40_39 Depth=2 + cmp w10, w23 + b.ne .LBB40_46 +// %bb.43: // in Loop: Header=BB40_39 Depth=2 + add x8, x8, x22 + ldr x1, [x8, #8] + adrp x8, p_io_data_buf_1 + ldr x8, [x8, :lo12:p_io_data_buf_1] + cmp x1, x8 + b.ne .LBB40_46 +// %bb.44: // in Loop: Header=BB40_39 Depth=2 + adrp x8, c_ftl_nand_sec_pre_page + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page] + neg w9, w21 + ldr x2, [sp, #32] // 8-byte Folded Reload + madd w8, w23, w8, w9 + lsl w8, w8, #9 + add x0, x19, x8 +.LBB40_45: // in Loop: Header=BB40_39 Depth=2 + bl memcpy +.LBB40_46: // in Loop: Header=BB40_39 Depth=2 + ldr x8, [x26, :lo12:req_read] + add x9, x8, x22 + ldr x10, [x9, #16] + ldr w9, [x9, #24] + ldr w10, [x10, #8] + cmp w9, w10 + b.eq .LBB40_48 +// %bb.47: // in Loop: Header=BB40_39 Depth=2 + ldr w9, [x28, :lo12:g_sys_ext_data+72] + add w9, w9, #1 // =1 + str w9, [x28, :lo12:g_sys_ext_data+72] +.LBB40_48: // in Loop: Header=BB40_39 Depth=2 + ldr w9, [x8, x22] + cmn w9, #1 // =1 + b.eq .LBB40_50 +// %bb.49: // in Loop: Header=BB40_39 Depth=2 + cmp w9, #256 // =256 + b.ne .LBB40_38 + b .LBB40_51 +.LBB40_50: // in Loop: Header=BB40_39 Depth=2 + ldr w9, [x28, :lo12:g_sys_ext_data+72] + mov w10, #-1 + stur w10, [x29, #-20] // 4-byte Folded Spill + add w9, w9, #1 // =1 + str w9, [x28, :lo12:g_sys_ext_data+72] + ldr w9, [x8, x22] + cmp w9, #256 // =256 + b.ne .LBB40_38 +.LBB40_51: // in Loop: Header=BB40_39 Depth=2 + add x8, x8, x22 + ldr w8, [x8, #4] + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + ubfx w8, w8, #10, #16 + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w25, w8, w10 + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w25 + bl sftl_printk + adrp x8, g_gc_next_blk + ldrh w8, [x8, :lo12:g_gc_next_blk] + cmp w8, w25 + b.eq .LBB40_38 +// %bb.52: // in Loop: Header=BB40_39 Depth=2 + adrp x9, g_gc_next_blk_1 + ldrh w9, [x9, :lo12:g_gc_next_blk_1] + cmp w9, w25, uxth + b.eq .LBB40_38 +// %bb.53: // in Loop: Header=BB40_39 Depth=2 + mov w10, #65535 + cmp w8, w10 + mov w8, #65535 + b.eq .LBB40_37 +// %bb.54: // in Loop: Header=BB40_39 Depth=2 + cmp w9, w8 + b.ne .LBB40_38 +// %bb.55: // in Loop: Header=BB40_39 Depth=2 + adrp x8, g_gc_next_blk_1 + strh w25, [x8, :lo12:g_gc_next_blk_1] + b .LBB40_38 +.LBB40_56: + bl __stack_chk_fail +.Lfunc_end40: + .size FtlRead, .Lfunc_end40-FtlRead + // -- End function + .globl FtlVendorPartRead // -- Begin function FtlVendorPartRead + .p2align 2 + .type FtlVendorPartRead,@function +FtlVendorPartRead: // @FtlVendorPartRead +// %bb.0: + hint #25 + sub sp, sp, #208 // =208 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #112] // 16-byte Folded Spill + add x29, sp, #112 // =112 + stp x28, x27, [sp, #128] // 16-byte Folded Spill + stp x26, x25, [sp, #144] // 16-byte Folded Spill + stp x24, x23, [sp, #160] // 16-byte Folded Spill + stp x22, x21, [sp, #176] // 16-byte Folded Spill + stp x20, x19, [sp, #192] // 16-byte Folded Spill + stur x8, [x29, #-8] + adrp x8, c_ftl_vendor_part_size + ldrh w8, [x8, :lo12:c_ftl_vendor_part_size] + add w9, w1, w0 + cmp w9, w8 + b.ls .LBB41_2 +// %bb.1: + mov w19, #-1 + b .LBB41_11 +.LBB41_2: + mov w20, w1 + cbz w1, .LBB41_10 +// %bb.3: + adrp x8, c_ftl_nand_sec_pre_page_shift + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page_shift] + mov w21, w0 + mov x22, x2 + mov w19, wzr + adrp x28, c_ftl_nand_sec_pre_page + adrp x23, p_vendor_data_buf + lsr w24, w0, w8 + b .LBB41_6 +.LBB41_4: // in Loop: Header=BB41_6 Depth=1 + ldr x8, [x23, :lo12:p_vendor_data_buf] + mov w10, w25 + lsl w9, w27, #7 + and x10, x10, #0xffff + add x1, x8, w9, uxtw #2 + lsl x2, x10, #9 + mov x0, x22 + bl memcpy +.LBB41_5: // in Loop: Header=BB41_6 Depth=1 + and w8, w25, #0xffff + subs w20, w20, w8 + add w21, w21, w8 + and x8, x25, #0xffff + add w24, w24, #1 // =1 + add x22, x22, x8, lsl #9 + b.eq .LBB41_11 +.LBB41_6: // =>This Inner Loop Header: Depth=1 + adrp x8, p_vendor_region_ppn_table + ldr x8, [x8, :lo12:p_vendor_region_ppn_table] + ldrh w9, [x28, :lo12:c_ftl_nand_sec_pre_page] + ldr w26, [x8, w24, uxtw #2] + udiv w8, w21, w9 + msub w27, w8, w9, w21 + sub w8, w9, w27 + cmp w20, w8, uxth + csel w25, w20, w8, lo + cbz w26, .LBB41_9 +// %bb.7: // in Loop: Header=BB41_6 Depth=1 + ldr x9, [x23, :lo12:p_vendor_data_buf] + add x8, sp, #40 // =40 + add x0, sp, #8 // =8 + mov w1, #1 + str w26, [sp, #12] + stp x9, x8, [sp, #16] + bl FlashReadPages + ldr w8, [sp, #8] + adrp x9, req_sys + ldr w9, [x9, :lo12:req_sys] + cmn w8, #1 // =1 + csinv w19, w19, wzr, ne + cmp w9, #256 // =256 + b.ne .LBB41_4 +// %bb.8: // in Loop: Header=BB41_6 Depth=1 + adrp x0, .L.str.94 + add x0, x0, :lo12:.L.str.94 + mov w1, w24 + mov w2, w26 + bl sftl_printk + ldr x2, [x23, :lo12:p_vendor_data_buf] + adrp x0, gVendorBlkInfo + add x0, x0, :lo12:gVendorBlkInfo + mov w1, w24 + bl FtlMapWritePage + b .LBB41_4 +.LBB41_9: // in Loop: Header=BB41_6 Depth=1 + mov w8, w25 + and x8, x8, #0xffff + lsl x2, x8, #9 + mov x0, x22 + mov w1, wzr + bl memset + b .LBB41_5 +.LBB41_10: + mov w19, wzr +.LBB41_11: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB41_13 +// %bb.12: + mov w0, w19 + ldp x20, x19, [sp, #192] // 16-byte Folded Reload + ldp x22, x21, [sp, #176] // 16-byte Folded Reload + ldp x24, x23, [sp, #160] // 16-byte Folded Reload + ldp x26, x25, [sp, #144] // 16-byte Folded Reload + ldp x28, x27, [sp, #128] // 16-byte Folded Reload + ldp x29, x30, [sp, #112] // 16-byte Folded Reload + add sp, sp, #208 // =208 + hint #29 + ret +.LBB41_13: + bl __stack_chk_fail +.Lfunc_end41: + .size FtlVendorPartRead, .Lfunc_end41-FtlVendorPartRead + // -- End function + .globl log2phys // -- Begin function log2phys + .p2align 2 + .type log2phys,@function +log2phys: // @log2phys +// %bb.0: + hint #25 + stp x29, x30, [sp, #-80]! // 16-byte Folded Spill + stp x24, x23, [sp, #32] // 16-byte Folded Spill + adrp x23, g_MaxLpn + ldr w8, [x23, :lo12:g_MaxLpn] + adrp x9, c_ftl_nand_sec_pre_page_shift + stp x22, x21, [sp, #48] // 16-byte Folded Spill + ldrh w22, [x9, :lo12:c_ftl_nand_sec_pre_page_shift] + stp x20, x19, [sp, #64] // 16-byte Folded Spill + mov w20, w2 + mov w21, w0 + cmp w8, w0 + mov x19, x1 + stp x26, x25, [sp, #16] // 16-byte Folded Spill + mov x29, sp + b.hi .LBB42_2 +// %bb.1: + adrp x0, .L.str.78 + adrp x1, .L__func__.log2phys + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.log2phys + mov w2, #820 + bl sftl_printk + ldr w8, [x23, :lo12:g_MaxLpn] +.LBB42_2: + cmp w8, w21 + b.ls .LBB42_17 +// %bb.3: + add x8, x22, #7 // =7 + mov x9, #-1 + adrp x10, c_ftl_nand_l2pmap_ram_region_num + lsl x11, x9, x8 + ldrh w9, [x10, :lo12:c_ftl_nand_l2pmap_ram_region_num] + mov w24, w21 + mvn w25, w11 + lsr w21, w21, w8 + adrp x23, p_l2p_ram_map + cbz x9, .LBB42_19 +// %bb.4: + ldr x8, [x23, :lo12:p_l2p_ram_map] + mov x22, xzr +.LBB42_5: // =>This Inner Loop Header: Depth=1 + ldrh w10, [x8] + cmp w10, w21, uxth + b.eq .LBB42_21 +// %bb.6: // in Loop: Header=BB42_5 Depth=1 + add x22, x22, #1 // =1 + cmp x9, x22 + add x8, x8, #16 // =16 + b.ne .LBB42_5 +// %bb.7: + ldr x8, [x23, :lo12:p_l2p_ram_map] + mov x22, xzr + mov x10, x8 +.LBB42_8: // =>This Inner Loop Header: Depth=1 + ldrsh w11, [x10] + cmn w11, #1 // =1 + b.eq .LBB42_23 +// %bb.9: // in Loop: Header=BB42_8 Depth=1 + add x22, x22, #1 // =1 + cmp x9, x22 + add x10, x10, #16 // =16 + b.ne .LBB42_8 +// %bb.10: + mov x10, xzr + mov w11, #-2147483648 + mov w12, #4 + mov w22, w9 +.LBB42_11: // =>This Inner Loop Header: Depth=1 + ldr w13, [x8, x12] + add x12, x12, #16 // =16 + cmp w13, #0 // =0 + cset w14, ge + cmp w13, w11 + cset w15, lo + tst w14, w15 + csel w22, w10, w22, ne + add x10, x10, #1 // =1 + csel w11, w13, w11, ne + cmp x9, x10 + b.ne .LBB42_11 +// %bb.12: + cmp w9, w22, uxth + b.hi .LBB42_25 +// %bb.13: + adrp x11, g_l2p_last_update_region_id + ldrh w11, [x11, :lo12:g_l2p_last_update_region_id] + mov x10, xzr + add x12, x8, #4 // =4 + mov w13, #-1 + mov w22, w9 + b .LBB42_15 +.LBB42_14: // in Loop: Header=BB42_15 Depth=1 + add x10, x10, #1 // =1 + cmp x9, x10 + add x12, x12, #16 // =16 + b.eq .LBB42_24 +.LBB42_15: // =>This Inner Loop Header: Depth=1 + ldr w14, [x12] + cmp w14, w13 + b.hs .LBB42_14 +// %bb.16: // in Loop: Header=BB42_15 Depth=1 + ldurh w15, [x12, #-4] + cmp w11, w15 + csel w22, w22, w10, eq + csel w13, w13, w14, eq + b .LBB42_14 +.LBB42_17: + mov w0, #-1 + cbnz w20, .LBB42_33 +// %bb.18: + str w0, [x19] + b .LBB42_33 +.LBB42_19: + mov w22, wzr +.LBB42_20: + adrp x0, .L.str.78 + adrp x1, .L__func__.select_l2p_ram_region + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.select_l2p_ram_region + mov w2, #796 + bl sftl_printk + ldr x8, [x23, :lo12:p_l2p_ram_map] + b .LBB42_25 +.LBB42_21: + // kill: def $w22 killed $w22 killed $x22 def $x22 + and x9, x25, x24 + cbnz w20, .LBB42_29 +.LBB42_22: + ldr x8, [x23, :lo12:p_l2p_ram_map] + // kill: def $w22 killed $w22 killed $x22 def $x22 + and x9, x9, #0xffff + add x8, x8, w22, uxth #4 + ldr x8, [x8, #8] + ldr w9, [x8, x9, lsl #2] + and x8, x22, #0xffff + str w9, [x19] + b .LBB42_30 +.LBB42_23: + // kill: def $w22 killed $w22 killed $x22 def $x22 + b .LBB42_25 +.LBB42_24: + cmp w9, w22, uxth + b.ls .LBB42_20 +.LBB42_25: + and x9, x22, #0xffff + lsl x26, x9, #4 + ldrh w1, [x8, x26] + mov w10, #65535 + cmp w1, w10 + b.eq .LBB42_28 +// %bb.26: + add x9, x8, x9, lsl #4 + ldr w9, [x9, #4] + tbz w9, #31, .LBB42_28 +// %bb.27: + add x8, x8, x26 + ldr x2, [x8, #8] + adrp x0, gL2pMapInfo + add x0, x0, :lo12:gL2pMapInfo + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x26 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] +.LBB42_28: + mov w0, w21 + mov w1, w22 + bl load_l2p_region + and x9, x25, x24 + cbz w20, .LBB42_22 +.LBB42_29: + ldr x10, [x23, :lo12:p_l2p_ram_map] + // kill: def $w22 killed $w22 killed $x22 def $x22 + and x8, x22, #0xffff + lsl x12, x8, #4 + ldr w11, [x19] + add x10, x10, x12 + ldr x10, [x10, #8] + and x9, x9, #0xffff + str w11, [x10, x9, lsl #2] + ldr x9, [x23, :lo12:p_l2p_ram_map] + adrp x11, g_l2p_last_update_region_id + add x9, x9, x12 + ldr w10, [x9, #4] + orr w10, w10, #0x80000000 + str w10, [x9, #4] + strh w21, [x11, :lo12:g_l2p_last_update_region_id] +.LBB42_30: + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x8, x9, x8, lsl #4 + ldr w9, [x8, #4]! + cmn w9, #1 // =1 + b.eq .LBB42_32 +// %bb.31: + mov w0, wzr + add w9, w9, #1 // =1 + str w9, [x8] + b .LBB42_33 +.LBB42_32: + mov w0, wzr +.LBB42_33: + ldp x20, x19, [sp, #64] // 16-byte Folded Reload + ldp x22, x21, [sp, #48] // 16-byte Folded Reload + ldp x24, x23, [sp, #32] // 16-byte Folded Reload + ldp x26, x25, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #80 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end42: + .size log2phys, .Lfunc_end42-log2phys + // -- End function + .globl FlashReadPages // -- Begin function FlashReadPages + .p2align 2 + .type FlashReadPages,@function +FlashReadPages: // @FlashReadPages +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + cbz w1, .LBB43_26 +// %bb.1: + adrp x8, g_nand_phy_info+12 + ldrh w8, [x8, :lo12:g_nand_phy_info+12] + adrp x20, .L__func__.FlashReadPages + adrp x22, g_nand_phy_info+8 + adrp x24, .L.str.117 + mov w26, w1 + add x21, x0, #16 // =16 + add x20, x20, :lo12:.L__func__.FlashReadPages + add x22, x22, :lo12:g_nand_phy_info+8 + adrp x25, sftl_nand_check_buf + adrp x19, g_nand_ops+24 + add x24, x24, :lo12:.L.str.117 + stur w8, [x29, #-4] // 4-byte Folded Spill + b .LBB43_4 +.LBB43_2: // in Loop: Header=BB43_4 Depth=1 + mov w8, #-1 + stur w8, [x21, #-16] +.LBB43_3: // in Loop: Header=BB43_4 Depth=1 + subs x26, x26, #1 // =1 + add x21, x21, #32 // =32 + b.eq .LBB43_26 +.LBB43_4: // =>This Inner Loop Header: Depth=1 + ldur x8, [x21, #-8] + cbz x8, .LBB43_6 +// %bb.5: // in Loop: Header=BB43_4 Depth=1 + ldr x8, [x21] + cbnz x8, .LBB43_7 +.LBB43_6: // in Loop: Header=BB43_4 Depth=1 + adrp x0, .L.str.78 + mov w2, #96 + add x0, x0, :lo12:.L.str.78 + mov x1, x20 + bl sftl_printk +.LBB43_7: // in Loop: Header=BB43_4 Depth=1 + ldrh w8, [x22, #6] + ldrh w10, [x22] + ldur w9, [x21, #-12] + cmp w8, #4 // =4 + cset w8, eq + lsr w10, w10, w8 + ubfx w11, w9, #10, #16 + udiv w23, w11, w10 + cmp w23, #4 // =4 + b.hs .LBB43_2 +// %bb.8: // in Loop: Header=BB43_4 Depth=1 + ldrh w12, [x22, #2] + msub w10, w10, w23, w11 + ldp x11, x3, [x21, #-8] + ldr x13, [x25, :lo12:sftl_nand_check_buf] + ldr x14, [x19, :lo12:g_nand_ops+24] + lsl w8, w12, w8 + and w9, w9, #0x3ff + tst x11, #0x3f + and w8, w8, #0xffff + madd w28, w10, w8, w9 + csel x27, x11, x13, eq + mov w0, w23 + mov w1, w28 + mov x2, x27 + blr x14 + stur w0, [x21, #-16] + adrp x8, g_nand_phy_info+14 + ldrh w8, [x8, :lo12:g_nand_phy_info+14] + cmp w8, #4 // =4 + b.ne .LBB43_23 +// %bb.9: // in Loop: Header=BB43_4 Depth=1 + ldr x8, [x21] + ldur w10, [x29, #-4] // 4-byte Folded Reload + ldr x9, [x19, :lo12:g_nand_ops+24] + add x2, x27, #2048 // =2048 + add x3, x8, #8 // =8 + add w1, w28, w10 + mov w0, w23 + blr x9 + cmn w0, #1 // =1 + b.eq .LBB43_13 +// %bb.10: // in Loop: Header=BB43_4 Depth=1 + ldr x8, [x21] + ldr w9, [x8, #12] + cmn w9, #1 // =1 + b.ne .LBB43_14 +// %bb.11: // in Loop: Header=BB43_4 Depth=1 + ldr w9, [x8, #8] + cmn w9, #1 // =1 + b.ne .LBB43_14 +// %bb.12: // in Loop: Header=BB43_4 Depth=1 + ldr w8, [x8] + cmn w8, #1 // =1 + b.eq .LBB43_14 +.LBB43_13: // in Loop: Header=BB43_4 Depth=1 + mov w3, #-1 + stur w3, [x21, #-16] + b .LBB43_19 +.LBB43_14: // in Loop: Header=BB43_4 Depth=1 + ldur w3, [x21, #-16] + cmp w0, #256 // =256 + b.ne .LBB43_17 +// %bb.15: // in Loop: Header=BB43_4 Depth=1 + cmn w3, #1 // =1 + b.eq .LBB43_17 +// %bb.16: // in Loop: Header=BB43_4 Depth=1 + mov w3, #256 + stur w3, [x21, #-16] + b .LBB43_19 +.LBB43_17: // in Loop: Header=BB43_4 Depth=1 + cmp w3, #256 // =256 + b.eq .LBB43_19 +// %bb.18: // in Loop: Header=BB43_4 Depth=1 + cmn w3, #1 // =1 + b.ne .LBB43_23 +.LBB43_19: // in Loop: Header=BB43_4 Depth=1 + ldur w1, [x21, #-12] + adrp x0, .L.str.121 + add x0, x0, :lo12:.L.str.121 + mov w2, w28 + bl sftl_printk + ldur x23, [x21, #-8] + cbz x23, .LBB43_21 +// %bb.20: // in Loop: Header=BB43_4 Depth=1 + adrp x0, .L.str.116 + adrp x1, .L.str.122 + add x0, x0, :lo12:.L.str.116 + add x1, x1, :lo12:.L.str.122 + mov x2, x23 + mov w3, wzr + bl sftl_printk + ldr w1, [x23] + mov x0, x24 + bl sftl_printk + ldr w1, [x23, #4] + mov x0, x24 + bl sftl_printk + ldr w1, [x23, #8] + mov x0, x24 + bl sftl_printk + ldr w1, [x23, #12] + mov x0, x24 + bl sftl_printk + adrp x0, .L.str.120 + add x0, x0, :lo12:.L.str.120 + bl sftl_printk +.LBB43_21: // in Loop: Header=BB43_4 Depth=1 + ldr x23, [x21] + cbz x23, .LBB43_23 +// %bb.22: // in Loop: Header=BB43_4 Depth=1 + adrp x0, .L.str.116 + adrp x1, .L.str.88 + add x0, x0, :lo12:.L.str.116 + add x1, x1, :lo12:.L.str.88 + mov x2, x23 + mov w3, wzr + bl sftl_printk + ldr w1, [x23] + mov x0, x24 + bl sftl_printk + ldr w1, [x23, #4] + mov x0, x24 + bl sftl_printk + ldr w1, [x23, #8] + mov x0, x24 + bl sftl_printk + ldr w1, [x23, #12] + mov x0, x24 + bl sftl_printk + adrp x0, .L.str.120 + add x0, x0, :lo12:.L.str.120 + bl sftl_printk +.LBB43_23: // in Loop: Header=BB43_4 Depth=1 + ldr x8, [x25, :lo12:sftl_nand_check_buf] + cmp x27, x8 + b.ne .LBB43_3 +// %bb.24: // in Loop: Header=BB43_4 Depth=1 + ldur x0, [x21, #-8] + cmp x27, x0 + b.eq .LBB43_3 +// %bb.25: // in Loop: Header=BB43_4 Depth=1 + adrp x8, c_ftl_nand_sec_pre_page + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page] + mov x1, x27 + lsl x2, x8, #9 + bl memcpy + b .LBB43_3 +.LBB43_26: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.Lfunc_end43: + .size FlashReadPages, .Lfunc_end43-FlashReadPages + // -- End function + .globl ftl_memcpy // -- Begin function ftl_memcpy + .p2align 2 + .type ftl_memcpy,@function +ftl_memcpy: // @ftl_memcpy +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + mov w2, w2 + str x19, [sp, #16] // 8-byte Folded Spill + mov x29, sp + mov x19, x0 + bl memcpy + mov x0, x19 + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end44: + .size ftl_memcpy, .Lfunc_end44-ftl_memcpy + // -- End function + .globl P2V_block_in_plane // -- Begin function P2V_block_in_plane + .p2align 2 + .type P2V_block_in_plane,@function +P2V_block_in_plane: // @P2V_block_in_plane +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x9, c_ftl_nand_planes_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_planes_per_die] + and w10, w0, #0xffff + udiv w11, w10, w8 + msub w8, w11, w8, w10 + udiv w0, w8, w9 + hint #29 + ret +.Lfunc_end45: + .size P2V_block_in_plane, .Lfunc_end45-P2V_block_in_plane + // -- End function + .globl FtlGcRefreshBlock // -- Begin function FtlGcRefreshBlock + .p2align 2 + .type FtlGcRefreshBlock,@function +FtlGcRefreshBlock: // @FtlGcRefreshBlock +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + mov w19, w0 + and w20, w0, #0xffff + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w20 + mov x29, sp + bl sftl_printk + adrp x8, g_gc_next_blk + ldrh w10, [x8, :lo12:g_gc_next_blk] + cmp w10, w20 + b.eq .LBB46_6 +// %bb.1: + adrp x9, g_gc_next_blk_1 + ldrh w11, [x9, :lo12:g_gc_next_blk_1] + cmp w11, w19, uxth + b.eq .LBB46_6 +// %bb.2: + mov w12, #65535 + cmp w10, w12 + b.eq .LBB46_5 +// %bb.3: + cmp w11, w12 + b.ne .LBB46_6 +// %bb.4: + strh w19, [x9, :lo12:g_gc_next_blk_1] + b .LBB46_6 +.LBB46_5: + strh w19, [x8, :lo12:g_gc_next_blk] +.LBB46_6: + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end46: + .size FtlGcRefreshBlock, .Lfunc_end46-FtlGcRefreshBlock + // -- End function + .globl FtlProgPages // -- Begin function FtlProgPages + .p2align 2 + .type FtlProgPages,@function +FtlProgPages: // @FtlProgPages +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + mov w2, wzr + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + mov x19, x3 + mov w21, w1 + mov x20, x0 + str x8, [sp, #8] + bl FlashProgPages + adrp x26, c_ftl_nand_planes_num + cbz w21, .LBB47_15 +// %bb.1: + mov w28, w21 + adrp x21, .L.str.77 + mov x27, xzr + add x21, x21, :lo12:.L.str.77 + adrp x22, c_ftl_nand_blks_per_die + adrp x23, c_ftl_nand_planes_per_die + b .LBB47_4 +.LBB47_2: // in Loop: Header=BB47_4 Depth=1 + mov w0, w25 + bl decrement_vpc_count +.LBB47_3: // in Loop: Header=BB47_4 Depth=1 + add x27, x27, #1 // =1 + cmp x27, x28 + b.eq .LBB47_15 +.LBB47_4: // =>This Loop Header: Depth=1 + // Child Loop BB47_7 Depth 2 + add x25, x20, x27, lsl #5 + add x24, x25, #4 // =4 + b .LBB47_7 +.LBB47_5: // in Loop: Header=BB47_7 Depth=2 + ldr w1, [x24] + mov x0, x21 + bl sftl_printk + ldr w8, [x24] + ldrh w9, [x22, :lo12:c_ftl_nand_blks_per_die] + ldrh w10, [x23, :lo12:c_ftl_nand_planes_per_die] + ubfx w8, w8, #10, #16 + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w0, w8, w10 + bl decrement_vpc_count + ldrh w8, [x19, #4] + cbz w8, .LBB47_9 +.LBB47_6: // in Loop: Header=BB47_7 Depth=2 + mov x0, x19 + bl get_new_active_ppa + str w0, [x24] + mov w1, #1 + mov x0, x25 + mov w2, wzr + bl FlashProgPages +.LBB47_7: // Parent Loop BB47_4 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr w2, [x25] + cmp w2, #256 // =256 + b.eq .LBB47_5 +// %bb.8: // in Loop: Header=BB47_7 Depth=2 + cmn w2, #1 // =1 + b.eq .LBB47_5 + b .LBB47_10 +.LBB47_9: // in Loop: Header=BB47_7 Depth=2 + mov x0, x19 + bl allocate_new_data_superblock + b .LBB47_6 +.LBB47_10: // in Loop: Header=BB47_4 Depth=1 + ldrb w8, [x19, #6] + ldrh w9, [x26, :lo12:c_ftl_nand_planes_num] + cmp w9, w8 + b.hi .LBB47_12 +// %bb.11: // in Loop: Header=BB47_4 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlProgPages + mov w2, #985 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlProgPages + bl sftl_printk +.LBB47_12: // in Loop: Header=BB47_4 Depth=1 + ldr w8, [x24] + add x24, x20, x27, lsl #5 + add x1, sp, #4 // =4 + mov w2, #1 + str w8, [sp, #4] + ldr w0, [x24, #24] + bl log2phys + ldr x8, [x24, #16] + ldr w8, [x8, #12] + cmn w8, #1 // =1 + b.eq .LBB47_3 +// %bb.13: // in Loop: Header=BB47_4 Depth=1 + ldrh w9, [x22, :lo12:c_ftl_nand_blks_per_die] + ldrh w10, [x23, :lo12:c_ftl_nand_planes_per_die] + adrp x11, p_valid_page_count_table + ubfx w8, w8, #10, #16 + ldr x11, [x11, :lo12:p_valid_page_count_table] + udiv w12, w8, w9 + msub w8, w12, w9, w8 + udiv w25, w8, w10 + ldrh w8, [x11, w25, uxtw #1] + cbnz w8, .LBB47_2 +// %bb.14: // in Loop: Header=BB47_4 Depth=1 + adrp x0, .L.str.79 + and w1, w25, #0xffff + add x0, x0, :lo12:.L.str.79 + mov w2, wzr + bl sftl_printk + b .LBB47_2 +.LBB47_15: + ldrb w8, [x19, #6] + ldrh w9, [x26, :lo12:c_ftl_nand_planes_num] + cmp w9, w8 + b.hi .LBB47_17 +// %bb.16: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlProgPages + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlProgPages + mov w2, #1000 + bl sftl_printk +.LBB47_17: + adrp x9, __stack_chk_guard + ldr x8, [sp, #8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB47_19 +// %bb.18: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.LBB47_19: + bl __stack_chk_fail +.Lfunc_end47: + .size FtlProgPages, .Lfunc_end47-FtlProgPages + // -- End function + .globl decrement_vpc_count // -- Begin function decrement_vpc_count + .p2align 2 + .type decrement_vpc_count,@function +decrement_vpc_count: // @decrement_vpc_count +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + stp x20, x19, [sp, #32] // 16-byte Folded Spill + and w19, w0, #0xffff + mov w8, #65535 + mov w20, w0 + cmp w19, w8 + stp x22, x21, [sp, #16] // 16-byte Folded Spill + mov x29, sp + b.eq .LBB48_3 +// %bb.1: + adrp x22, p_valid_page_count_table + ldr x9, [x22, :lo12:p_valid_page_count_table] + and x21, x20, #0xffff + ldrh w10, [x9, x21, lsl #1] + cbz w10, .LBB48_9 +// %bb.2: + sub w10, w10, #1 // =1 + strh w10, [x9, x21, lsl #1] +.LBB48_3: + adrp x22, g_tmp_data_superblock_id + ldrh w0, [x22, :lo12:g_tmp_data_superblock_id] + cmp w0, w8 + b.eq .LBB48_8 +// %bb.4: + cmp w0, w20, uxth + b.eq .LBB48_11 +// %bb.5: + bl update_vpc_list + adrp x8, p_data_block_list_head + adrp x9, p_data_block_list_table + ldr x8, [x8, :lo12:p_data_block_list_head] + ldr x9, [x9, :lo12:p_data_block_list_table] + adrp x10, p_valid_page_count_table + ldr x10, [x10, :lo12:p_valid_page_count_table] + strh w20, [x22, :lo12:g_tmp_data_superblock_id] + sub x8, x8, x9 + mov x9, #-6148914691236517206 + asr x8, x8, #1 + movk x9, #43691 + mul x8, x8, x9 + and x9, x8, #0xffff + ldrh w9, [x10, x9, lsl #1] + cmp w0, #0 // =0 + cset w21, ne + cbnz w9, .LBB48_12 +// %bb.6: + cmp w19, w8, uxth + b.eq .LBB48_12 +// %bb.7: + adrp x0, .L.str.78 + adrp x1, .L__func__.decrement_vpc_count + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.decrement_vpc_count + mov w2, #2869 + bl sftl_printk + b .LBB48_12 +.LBB48_8: + mov w21, wzr + strh w20, [x22, :lo12:g_tmp_data_superblock_id] + b .LBB48_12 +.LBB48_9: + adrp x0, .L.str.110 + add x0, x0, :lo12:.L.str.110 + mov w1, w19 + mov w2, wzr + bl sftl_printk + ldr x8, [x22, :lo12:p_valid_page_count_table] + ldrh w8, [x8, x21, lsl #1] + mov w21, wzr + cbnz w8, .LBB48_12 +// %bb.10: + adrp x0, .L.str.78 + adrp x1, .L__func__.decrement_vpc_count + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.decrement_vpc_count + mov w2, #2853 + bl sftl_printk +.LBB48_11: + mov w21, wzr +.LBB48_12: + mov w0, w21 + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldp x22, x21, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end48: + .size decrement_vpc_count, .Lfunc_end48-decrement_vpc_count + // -- End function + .globl allocate_new_data_superblock // -- Begin function allocate_new_data_superblock + .p2align 2 + .type allocate_new_data_superblock,@function +allocate_new_data_superblock: // @allocate_new_data_superblock +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + adrp x22, c_ftl_nand_data_blks_per_plane + stp x20, x19, [sp, #48] // 16-byte Folded Spill + ldrh w20, [x0] + ldrh w8, [x22, :lo12:c_ftl_nand_data_blks_per_plane] + mov x19, x0 + str x23, [sp, #16] // 8-byte Folded Spill + mov x29, sp + cmp w20, w8 + b.ls .LBB49_2 +// %bb.1: + adrp x0, .L.str.78 + adrp x1, .L__func__.allocate_new_data_superblock + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.allocate_new_data_superblock + mov w2, #2766 + bl sftl_printk +.LBB49_2: + mov w21, #65535 + cmp w20, w21 + b.eq .LBB49_7 +// %bb.3: + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldrh w8, [x8, x20, lsl #1] + cbz w8, .LBB49_6 +// %bb.4: + mov w0, w20 + bl insert_data_list + adrp x8, g_num_data_superblocks + ldrh w9, [x8, :lo12:g_num_data_superblocks] + ldrh w10, [x22, :lo12:c_ftl_nand_data_blks_per_plane] + add w9, w9, #1 // =1 + cmp w10, w9, uxth + strh w9, [x8, :lo12:g_num_data_superblocks] + b.hs .LBB49_7 +// %bb.5: + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + mov w2, #214 + bl sftl_printk + b .LBB49_7 +.LBB49_6: + mov w0, w20 + bl INSERT_FREE_LIST +.LBB49_7: + mov w8, #1 + strb w8, [x19, #8] + adrp x22, g_tmp_data_superblock_id + ldrh w0, [x22, :lo12:g_tmp_data_superblock_id] + cmp w0, w21 + b.eq .LBB49_12 +// %bb.8: + cmp w20, w0 + b.ne .LBB49_10 +// %bb.9: + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldrh w8, [x8, x20, lsl #1] + cbz w8, .LBB49_11 +.LBB49_10: + bl update_vpc_list +.LBB49_11: + mov w8, #65535 + strh w8, [x22, :lo12:g_tmp_data_superblock_id] +.LBB49_12: + mov x0, x19 + bl allocate_data_superblock + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB49_17 +// %bb.13: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB49_15 +.LBB49_14: // in Loop: Header=BB49_15 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB49_17 +.LBB49_15: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB49_14 +// %bb.16: // in Loop: Header=BB49_15 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB49_14 +.LBB49_17: + mov w0, wzr + bl FtlEctTblFlush + bl FtlVpcTblFlush + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end49: + .size allocate_new_data_superblock, .Lfunc_end49-allocate_new_data_superblock + // -- End function + .globl get_new_active_ppa // -- Begin function get_new_active_ppa + .p2align 2 + .type get_new_active_ppa,@function +get_new_active_ppa: // @get_new_active_ppa +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + ldrsh w8, [x0] + stp x20, x19, [sp, #16] // 16-byte Folded Spill + mov x19, x0 + mov x29, sp + cmn w8, #1 // =1 + b.ne .LBB50_2 +// %bb.1: + adrp x0, .L.str.78 + adrp x1, .L__func__.get_new_active_ppa + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.get_new_active_ppa + mov w2, #2792 + bl sftl_printk +.LBB50_2: + adrp x20, c_ftl_nand_page_pre_blk + ldrh w8, [x19, #2] + ldrh w9, [x20, :lo12:c_ftl_nand_page_pre_blk] + cmp w8, w9 + b.ne .LBB50_4 +// %bb.3: + adrp x0, .L.str.78 + adrp x1, .L__func__.get_new_active_ppa + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.get_new_active_ppa + mov w2, #2793 + bl sftl_printk +.LBB50_4: + ldrh w8, [x19, #4] + cbnz w8, .LBB50_6 +// %bb.5: + adrp x0, .L.str.78 + adrp x1, .L__func__.get_new_active_ppa + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.get_new_active_ppa + mov w2, #2794 + bl sftl_printk +.LBB50_6: + ldrb w8, [x19, #6] + strb wzr, [x19, #10] + add x9, x19, x8, lsl #1 + ldrh w12, [x9, #16] + mov w9, #65535 + // kill: def $w8 killed $w8 killed $x8 def $x8 + cmp w12, w9 + b.ne .LBB50_12 +// %bb.7: + adrp x10, c_ftl_nand_planes_num + ldrh w10, [x10, :lo12:c_ftl_nand_planes_num] + b .LBB50_9 +.LBB50_8: // in Loop: Header=BB50_9 Depth=1 + add x11, x19, w8, uxtb #1 + ldrh w12, [x11, #16] + cmp w12, w9 + b.ne .LBB50_11 +.LBB50_9: // =>This Inner Loop Header: Depth=1 + add w8, w8, #1 // =1 + cmp w10, w8, uxtb + b.ne .LBB50_8 +// %bb.10: // in Loop: Header=BB50_9 Depth=1 + ldrh w11, [x19, #2] + mov w8, wzr + add w11, w11, #1 // =1 + strh w11, [x19, #2] + b .LBB50_8 +.LBB50_11: + strb w8, [x19, #6] +.LBB50_12: + ldrh w10, [x19, #2] + ldrh w9, [x20, :lo12:c_ftl_nand_page_pre_blk] + cmp w10, w9 + b.hs .LBB50_17 +// %bb.13: + ldrh w11, [x19, #4] + adrp x13, c_ftl_nand_planes_num + // kill: def $w8 killed $w8 killed $x8 def $x8 + sub w11, w11, #1 // =1 + strh w11, [x19, #4] + ldrh w14, [x13, :lo12:c_ftl_nand_planes_num] + lsl w13, w12, #10 + mov w12, w10 + b .LBB50_15 +.LBB50_14: // in Loop: Header=BB50_15 Depth=1 + add x15, x19, w8, uxtb #1 + ldrsh w15, [x15, #16] + cmn w15, #1 // =1 + b.ne .LBB50_18 +.LBB50_15: // =>This Inner Loop Header: Depth=1 + add w8, w8, #1 // =1 + cmp w14, w8, uxtb + b.ne .LBB50_14 +// %bb.16: // in Loop: Header=BB50_15 Depth=1 + mov w8, wzr + add w12, w12, #1 // =1 + strh w12, [x19, #2] + b .LBB50_14 +.LBB50_17: + mov w20, #65535 + b .LBB50_21 +.LBB50_18: + orr w20, w13, w10 + tst w11, #0xffff + strb w8, [x19, #6] + b.eq .LBB50_21 +// %bb.19: + cmp w9, w12, uxth + b.ne .LBB50_21 +// %bb.20: + adrp x0, .L.str.78 + adrp x1, .L__func__.get_new_active_ppa + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.get_new_active_ppa + mov w2, #2817 + bl sftl_printk +.LBB50_21: + mov w0, w20 + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end50: + .size get_new_active_ppa, .Lfunc_end50-get_new_active_ppa + // -- End function + .globl FtlWrite // -- Begin function FtlWrite + .p2align 2 + .type FtlWrite,@function +FtlWrite: // @FtlWrite +// %bb.0: + hint #25 + sub sp, sp, #192 // =192 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + and w9, w0, #0xff + stp x29, x30, [sp, #96] // 16-byte Folded Spill + add x29, sp, #96 // =96 + cmp w9, #16 // =16 + stp x28, x27, [sp, #112] // 16-byte Folded Spill + stp x26, x25, [sp, #128] // 16-byte Folded Spill + stp x24, x23, [sp, #144] // 16-byte Folded Spill + stp x22, x21, [sp, #160] // 16-byte Folded Spill + stp x20, x19, [sp, #176] // 16-byte Folded Spill + stur x8, [x29, #-8] + b.ne .LBB51_2 +// %bb.1: + add w0, w1, #256 // =256 + mov w1, w2 + mov x2, x3 + bl FtlVendorPartWrite + b .LBB51_21 +.LBB51_2: + adrp x8, g_MaxLbaSector + ldr w8, [x8, :lo12:g_MaxLbaSector] + mov w0, #-1 + cmp w8, w1 + b.ls .LBB51_21 +// %bb.3: + cmp w8, w2 + b.lo .LBB51_21 +// %bb.4: + add w9, w2, w1 + cmp w9, w8 + mov w0, #-1 + str w9, [sp, #24] // 4-byte Folded Spill + b.hi .LBB51_21 +// %bb.5: + adrp x8, gFtlInitStatus + ldr w8, [x8, :lo12:gFtlInitStatus] + cmn w8, #1 // =1 + b.eq .LBB51_21 +// %bb.6: + adrp x11, g_totle_write_sector + ldr w12, [x11, :lo12:g_totle_write_sector] + adrp x8, g_ftl_nand_free_count + mov w9, #2048 + adrp x13, c_ftl_nand_sec_pre_page + ldr w10, [sp, #24] // 4-byte Folded Reload + str w9, [x8, :lo12:g_ftl_nand_free_count] + ldrh w9, [x13, :lo12:c_ftl_nand_sec_pre_page] + adrp x8, g_totle_write_page_count + add w12, w12, w2 + sub w10, w10, #1 // =1 + str w12, [x11, :lo12:g_totle_write_sector] + ldr w11, [x8, :lo12:g_totle_write_page_count] + udiv w24, w1, w9 + udiv w9, w10, w9 + stp w9, w1, [sp, #32] // 8-byte Folded Spill + sub w9, w9, w24 + adds w20, w9, #1 // =1 + add w9, w11, w20 + str x3, [sp, #40] // 8-byte Folded Spill + str w2, [sp, #20] // 4-byte Folded Spill + str w9, [x8, :lo12:g_totle_write_page_count] + b.lo .LBB51_23 +.LBB51_7: + mov w0, wzr + bl rk_ftl_garbage_collect + adrp x21, g_num_free_superblocks + ldrh w8, [x21, :lo12:g_num_free_superblocks] + mov w0, wzr + cmp w8, #5 // =5 + b.hi .LBB51_21 +// %bb.8: + mov w8, #255 + adrp x22, g_gc_superblock + adrp x23, g_gc_next_blk + mov w24, #65535 + adrp x26, g_gc_merge_free_blk_threshold + mov w27, #128 + adrp x28, g_gc_free_blk_threshold +.LBB51_9: // =>This Inner Loop Header: Depth=1 + ldrh w9, [x22, :lo12:g_gc_superblock] + ldrh w10, [x23, :lo12:g_gc_next_blk] + mov w25, w8 + and w9, w10, w9 + cmp w9, w24 + b.ne .LBB51_19 +// %bb.10: // in Loop: Header=BB51_9 Depth=1 + adrp x8, p_data_block_list_head + ldr x8, [x8, :lo12:p_data_block_list_head] + cbz x8, .LBB51_12 +// %bb.11: // in Loop: Header=BB51_9 Depth=1 + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + sub x8, x8, x9 + mov w9, #43691 + lsr x8, x8, #1 + movk w9, #43690, lsl #16 + mul w19, w8, w9 + b .LBB51_13 +.LBB51_12: // in Loop: Header=BB51_9 Depth=1 + mov w19, #65535 +.LBB51_13: // in Loop: Header=BB51_9 Depth=1 + and w20, w19, #0xffff + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w20 + bl sftl_printk + ldrh w8, [x23, :lo12:g_gc_next_blk] + cmp w8, w20 + b.eq .LBB51_19 +// %bb.14: // in Loop: Header=BB51_9 Depth=1 + adrp x9, g_gc_next_blk_1 + ldrh w9, [x9, :lo12:g_gc_next_blk_1] + cmp w9, w19, uxth + b.eq .LBB51_19 +// %bb.15: // in Loop: Header=BB51_9 Depth=1 + cmp w8, w24 + b.eq .LBB51_18 +// %bb.16: // in Loop: Header=BB51_9 Depth=1 + cmp w9, w24 + b.ne .LBB51_19 +// %bb.17: // in Loop: Header=BB51_9 Depth=1 + adrp x8, g_gc_next_blk_1 + strh w19, [x8, :lo12:g_gc_next_blk_1] + b .LBB51_19 +.LBB51_18: // in Loop: Header=BB51_9 Depth=1 + strh w19, [x23, :lo12:g_gc_next_blk] +.LBB51_19: // in Loop: Header=BB51_9 Depth=1 + mov w0, #1 + strh w27, [x26, :lo12:g_gc_merge_free_blk_threshold] + strh w27, [x28, :lo12:g_gc_free_blk_threshold] + bl rk_ftl_garbage_collect + mov w0, wzr + bl rk_ftl_garbage_collect + ldrh w8, [x21, :lo12:g_num_free_superblocks] + mov w0, wzr + cmp w8, #2 // =2 + b.hi .LBB51_21 +// %bb.20: // in Loop: Header=BB51_9 Depth=1 + sub w8, w25, #1 // =1 + cbnz w25, .LBB51_9 +.LBB51_21: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB51_70 +// %bb.22: + ldp x20, x19, [sp, #176] // 16-byte Folded Reload + ldp x22, x21, [sp, #160] // 16-byte Folded Reload + ldp x24, x23, [sp, #144] // 16-byte Folded Reload + ldp x26, x25, [sp, #128] // 16-byte Folded Reload + ldp x28, x27, [sp, #112] // 16-byte Folded Reload + ldp x29, x30, [sp, #96] // 16-byte Folded Reload + add sp, sp, #192 // =192 + hint #29 + ret +.LBB51_23: + adrp x10, g_active_superblock + add x10, x10, :lo12:g_active_superblock + adrp x9, power_up_flag + ldrh w8, [x10, #4] + ldr w9, [x9, :lo12:power_up_flag] + adrp x11, g_buffer_superblock + add x11, x11, :lo12:g_buffer_superblock + cmp w8, #0 // =0 + ccmp w9, #0, #4, eq + mov w19, wzr + adrp x22, req_prgm + csel x28, x11, x10, ne + mov w21, w24 + str wzr, [sp, #28] // 4-byte Folded Spill + b .LBB51_25 +.LBB51_24: // in Loop: Header=BB51_25 Depth=1 + subs w20, w20, w23 + b.eq .LBB51_7 +.LBB51_25: // =>This Loop Header: Depth=1 + // Child Loop BB51_41 Depth 2 + adrp x9, c_ftl_nand_planes_num + ldrb w8, [x28, #6] + ldrh w9, [x9, :lo12:c_ftl_nand_planes_num] + cmp w9, w8 + b.hi .LBB51_27 +// %bb.26: // in Loop: Header=BB51_25 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlWrite + mov w2, #1041 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlWrite + bl sftl_printk +.LBB51_27: // in Loop: Header=BB51_25 Depth=1 + ldrh w8, [x28, #4] + cbnz w8, .LBB51_36 +// %bb.28: // in Loop: Header=BB51_25 Depth=1 + adrp x8, g_active_superblock + add x8, x8, :lo12:g_active_superblock + cmp x28, x8 + b.ne .LBB51_33 +// %bb.29: // in Loop: Header=BB51_25 Depth=1 + adrp x8, g_buffer_superblock+4 + ldrh w8, [x8, :lo12:g_buffer_superblock+4] + mov w25, w21 + cbnz w8, .LBB51_31 +// %bb.30: // in Loop: Header=BB51_25 Depth=1 + adrp x0, g_buffer_superblock + add x0, x0, :lo12:g_buffer_superblock + bl allocate_new_data_superblock + adrp x8, power_up_flag + str wzr, [x8, :lo12:power_up_flag] +.LBB51_31: // in Loop: Header=BB51_25 Depth=1 + adrp x21, g_active_superblock + add x21, x21, :lo12:g_active_superblock + mov x0, x21 + bl allocate_new_data_superblock + adrp x8, power_up_flag + ldr w8, [x8, :lo12:power_up_flag] + cmp w8, #0 // =0 + adrp x8, g_buffer_superblock + add x8, x8, :lo12:g_buffer_superblock + csel x23, x21, x8, eq + mov w21, w25 + ldrh w8, [x23, #4] + cbnz w8, .LBB51_35 +.LBB51_32: // in Loop: Header=BB51_25 Depth=1 + mov x0, x23 + bl allocate_new_data_superblock + ldrh w8, [x23, #4] + b .LBB51_35 +.LBB51_33: // in Loop: Header=BB51_25 Depth=1 + adrp x23, g_active_superblock + add x23, x23, :lo12:g_active_superblock + ldrh w8, [x23, #4] + adrp x9, power_up_flag + str wzr, [x9, :lo12:power_up_flag] + cbz w8, .LBB51_69 +// %bb.34: // in Loop: Header=BB51_25 Depth=1 + ldrh w8, [x23, #4] + cbz w8, .LBB51_32 +.LBB51_35: // in Loop: Header=BB51_25 Depth=1 + mov x28, x23 +.LBB51_36: // in Loop: Header=BB51_25 Depth=1 + ldrb w9, [x28, #7] + adrp x11, c_ftl_nand_planes_num + ldrb w10, [x28, #6] + ldrh w11, [x11, :lo12:c_ftl_nand_planes_num] + lsl w9, w9, #2 + cmp w20, w9 + csel w9, w9, w20, hi + cmp w9, w8 + csel w23, w8, w9, hi + cmp w11, w10 + b.hi .LBB51_38 +// %bb.37: // in Loop: Header=BB51_25 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlWrite + mov w2, #1074 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlWrite + bl sftl_printk +.LBB51_38: // in Loop: Header=BB51_25 Depth=1 + cbz w23, .LBB51_67 +// %bb.39: // in Loop: Header=BB51_25 Depth=1 + mov w8, w23 + str w8, [sp, #8] // 4-byte Folded Spill + mov w8, w8 + stp w21, w20, [sp, #12] // 8-byte Folded Spill + mov x25, xzr + mov x23, xzr + lsl x20, x8, #5 + mov w21, w21 + b .LBB51_41 +.LBB51_40: // in Loop: Header=BB51_41 Depth=2 + mov w8, #61589 + strh w8, [x26] + adrp x10, g_GlobalDataVersion + ldr w8, [x10, :lo12:g_GlobalDataVersion] + add x25, x25, #32 // =32 + add x23, x23, #1 // =1 + add w9, w8, #1 // =1 + cmn w9, #1 // =1 + stp w8, w27, [x26, #4] + csinc w8, wzr, w8, eq + str w8, [x10, :lo12:g_GlobalDataVersion] + ldur w8, [x29, #-12] + cmp x20, x25 + str w8, [x26, #12] + ldrh w8, [x28] + strh w8, [x26, #2] + b.eq .LBB51_66 +.LBB51_41: // Parent Loop BB51_25 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w8, [x28, #4] + cbz w8, .LBB51_65 +// %bb.42: // in Loop: Header=BB51_41 Depth=2 + add x27, x21, x23 + sub x1, x29, #12 // =12 + mov w0, w27 + mov w2, wzr + bl log2phys + mov x0, x28 + bl get_new_active_ppa + ldr x8, [x22, :lo12:req_prgm] + adrp x11, c_ftl_nand_byte_pre_oob + adrp x9, p_io_spare_buf + mov w1, wzr + add x8, x8, x25 + str w0, [x8, #4] + ldrh w8, [x11, :lo12:c_ftl_nand_byte_pre_oob] + ldr x9, [x9, :lo12:p_io_spare_buf] + ldr x10, [x22, :lo12:req_prgm] + mul w8, w23, w8 + and w8, w8, #0xfffffffc + add x8, x9, x8 + add x9, x10, x25 + str x8, [x9, #16] + ldr x8, [x22, :lo12:req_prgm] + add x8, x8, x25 + str w27, [x8, #24] + ldr x8, [x22, :lo12:req_prgm] + ldrh w2, [x11, :lo12:c_ftl_nand_byte_pre_oob] + add x8, x8, x25 + ldr x26, [x8, #16] + mov x0, x26 + bl memset + adrp x8, c_ftl_nand_sec_pre_page + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page] + cmp w27, w24 + b.eq .LBB51_45 +// %bb.43: // in Loop: Header=BB51_41 Depth=2 + ldr w9, [sp, #32] // 4-byte Folded Reload + cmp w27, w9 + b.eq .LBB51_45 +// %bb.44: // in Loop: Header=BB51_41 Depth=2 + ldr w9, [sp, #36] // 4-byte Folded Reload + ldr x10, [x22, :lo12:req_prgm] + neg w9, w9 + madd w8, w27, w8, w9 + ldr x9, [sp, #40] // 8-byte Folded Reload + lsl w8, w8, #9 + add x8, x9, x8 + add x9, x10, x25 + str x8, [x9, #8] + b .LBB51_63 +.LBB51_45: // in Loop: Header=BB51_41 Depth=2 + cmp w27, w24 + b.ne .LBB51_48 +// %bb.46: // in Loop: Header=BB51_41 Depth=2 + ldr w10, [sp, #36] // 4-byte Folded Reload + udiv w9, w10, w8 + msub w9, w9, w8, w10 + ldr w10, [sp, #20] // 4-byte Folded Reload + str w9, [sp, #28] // 4-byte Folded Spill + sub w9, w8, w9 + cmp w9, w10 + csel w19, w10, w9, hi + cmp w19, w8 + b.ne .LBB51_50 +// %bb.47: // in Loop: Header=BB51_41 Depth=2 + ldr x9, [x22, :lo12:req_prgm] + ldr x10, [sp, #40] // 8-byte Folded Reload + mov w19, w8 + add x9, x9, x25 + str x10, [x9, #8] + b .LBB51_63 +.LBB51_48: // in Loop: Header=BB51_41 Depth=2 + ldp w11, w10, [sp, #28] // 8-byte Folded Reload + mul w9, w27, w8 + cmp w27, w10 + ldr w10, [sp, #24] // 4-byte Folded Reload + csel w11, wzr, w11, eq + str w11, [sp, #28] // 4-byte Folded Spill + sub w10, w10, w9 + and w10, w10, #0xffff + csel w19, w10, w19, eq + cmp w19, w8 + b.ne .LBB51_51 +// %bb.49: // in Loop: Header=BB51_41 Depth=2 + ldr w11, [sp, #36] // 4-byte Folded Reload + ldr x10, [x22, :lo12:req_prgm] + mov w19, w8 + sub w9, w9, w11 + ldr x11, [sp, #40] // 8-byte Folded Reload + lsl w9, w9, #9 + add x10, x10, x25 + add x9, x11, x9 + str x9, [x10, #8] + b .LBB51_63 +.LBB51_50: // in Loop: Header=BB51_41 Depth=2 + adrp x8, p_io_data_buf_0 + add x8, x8, :lo12:p_io_data_buf_0 + b .LBB51_52 +.LBB51_51: // in Loop: Header=BB51_41 Depth=2 + adrp x8, p_io_data_buf_1 + add x8, x8, :lo12:p_io_data_buf_1 +.LBB51_52: // in Loop: Header=BB51_41 Depth=2 + ldr x9, [x22, :lo12:req_prgm] + ldr x8, [x8] + add x9, x9, x25 + str x8, [x9, #8] + ldur w8, [x29, #-12] + cmn w8, #1 // =1 + b.eq .LBB51_57 +// %bb.53: // in Loop: Header=BB51_41 Depth=2 + ldr x9, [x22, :lo12:req_prgm] + str w8, [sp, #52] + str w27, [sp, #72] + add x0, sp, #48 // =48 + add x8, x9, x25 + ldp x9, x8, [x8, #8] + mov w1, #1 + stp x9, x8, [sp, #56] + bl FlashReadPages + ldr w8, [sp, #48] + cmn w8, #1 // =1 + b.eq .LBB51_58 +// %bb.54: // in Loop: Header=BB51_41 Depth=2 + ldr w8, [x26, #8] + cmp w27, w8 + b.eq .LBB51_59 +// %bb.55: // in Loop: Header=BB51_41 Depth=2 + adrp x9, g_sys_ext_data+72 + ldr w8, [x9, :lo12:g_sys_ext_data+72] + adrp x0, .L.str.81 + add x0, x0, :lo12:.L.str.81 + mov w2, w27 + add w8, w8, #1 // =1 + str w8, [x9, :lo12:g_sys_ext_data+72] + ldr w1, [x26, #8] + bl sftl_printk + ldr w8, [x26, #8] + cmp w27, w8 + b.eq .LBB51_59 +// %bb.56: // in Loop: Header=BB51_41 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlWrite + mov w2, #1128 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlWrite + bl sftl_printk + b .LBB51_59 +.LBB51_57: // in Loop: Header=BB51_41 Depth=2 + ldr x8, [x22, :lo12:req_prgm] + mov w1, wzr + add x8, x8, x25 + ldr x0, [x8, #8] + adrp x8, c_ftl_nand_byte_pre_page + ldrh w2, [x8, :lo12:c_ftl_nand_byte_pre_page] + bl memset + b .LBB51_59 +.LBB51_58: // in Loop: Header=BB51_41 Depth=2 + adrp x9, g_sys_ext_data+72 + ldr w8, [x9, :lo12:g_sys_ext_data+72] + adrp x0, .L.str.80 + mov w3, #-1 + add x0, x0, :lo12:.L.str.80 + add w8, w8, #1 // =1 + str w8, [x9, :lo12:g_sys_ext_data+72] + ldr w1, [x26, #8] + mov w2, w27 + bl sftl_printk +.LBB51_59: // in Loop: Header=BB51_41 Depth=2 + ldr x8, [x22, :lo12:req_prgm] + cmp w27, w24 + add x8, x8, x25 + ldr x0, [x8, #8] + b.ne .LBB51_61 +// %bb.60: // in Loop: Header=BB51_41 Depth=2 + ldr w8, [sp, #28] // 4-byte Folded Reload + ldr x1, [sp, #40] // 8-byte Folded Reload + lsl w2, w19, #9 + lsl w8, w8, #9 + add x0, x0, x8 + b .LBB51_62 +.LBB51_61: // in Loop: Header=BB51_41 Depth=2 + adrp x8, c_ftl_nand_sec_pre_page + ldr w9, [sp, #36] // 4-byte Folded Reload + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page] + lsl w2, w19, #9 + neg w9, w9 + madd w8, w27, w8, w9 + ldr x9, [sp, #40] // 8-byte Folded Reload + lsl w8, w8, #9 + add x1, x9, x8 +.LBB51_62: // in Loop: Header=BB51_41 Depth=2 + bl memcpy +.LBB51_63: // in Loop: Header=BB51_41 Depth=2 + adrp x9, c_ftl_nand_planes_num + ldrb w8, [x28, #6] + ldrh w9, [x9, :lo12:c_ftl_nand_planes_num] + cmp w9, w8 + b.hi .LBB51_40 +// %bb.64: // in Loop: Header=BB51_41 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlWrite + mov w2, #1143 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlWrite + bl sftl_printk + b .LBB51_40 +.LBB51_65: // in Loop: Header=BB51_25 Depth=1 + ldp w21, w20, [sp, #12] // 8-byte Folded Reload + add w21, w21, w23 + // kill: def $w23 killed $w23 killed $x23 + b .LBB51_67 +.LBB51_66: // in Loop: Header=BB51_25 Depth=1 + ldp w21, w20, [sp, #12] // 8-byte Folded Reload + add w21, w21, w23 + ldr w23, [sp, #8] // 4-byte Folded Reload +.LBB51_67: // in Loop: Header=BB51_25 Depth=1 + ldr x0, [x22, :lo12:req_prgm] + mov w1, w23 + mov x3, x28 + bl FtlProgPages + cmp w20, w23 + b.hs .LBB51_24 +// %bb.68: // in Loop: Header=BB51_25 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlWrite + mov w2, #1152 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlWrite + bl sftl_printk + b .LBB51_24 +.LBB51_69: // in Loop: Header=BB51_25 Depth=1 + mov x0, x28 + bl allocate_new_data_superblock + mov x23, x28 + ldrh w8, [x23, #4] + cbnz w8, .LBB51_35 + b .LBB51_32 +.LBB51_70: + bl __stack_chk_fail +.Lfunc_end51: + .size FtlWrite, .Lfunc_end51-FtlWrite + // -- End function + .globl FtlVendorPartWrite // -- Begin function FtlVendorPartWrite + .p2align 2 + .type FtlVendorPartWrite,@function +FtlVendorPartWrite: // @FtlVendorPartWrite +// %bb.0: + hint #25 + sub sp, sp, #208 // =208 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #112] // 16-byte Folded Spill + add x29, sp, #112 // =112 + stp x28, x27, [sp, #128] // 16-byte Folded Spill + stp x26, x25, [sp, #144] // 16-byte Folded Spill + stp x24, x23, [sp, #160] // 16-byte Folded Spill + stp x22, x21, [sp, #176] // 16-byte Folded Spill + stp x20, x19, [sp, #192] // 16-byte Folded Spill + stur x8, [x29, #-8] + adrp x8, c_ftl_vendor_part_size + ldrh w8, [x8, :lo12:c_ftl_vendor_part_size] + add w9, w1, w0 + cmp w9, w8 + b.ls .LBB52_2 +// %bb.1: + mov w0, #-1 + b .LBB52_10 +.LBB52_2: + mov w19, w1 + cbz w1, .LBB52_9 +// %bb.3: + adrp x8, c_ftl_nand_sec_pre_page_shift + ldrh w8, [x8, :lo12:c_ftl_nand_sec_pre_page_shift] + adrp x22, gVendorBlkInfo + mov w20, w0 + mov x21, x2 + adrp x25, p_vendor_region_ppn_table + adrp x26, c_ftl_nand_sec_pre_page + adrp x27, p_vendor_data_buf + add x22, x22, :lo12:gVendorBlkInfo + lsr w23, w0, w8 + b .LBB52_6 +.LBB52_4: // in Loop: Header=BB52_6 Depth=1 + adrp x8, c_ftl_nand_byte_pre_page + ldr x0, [x27, :lo12:p_vendor_data_buf] + ldrh w2, [x8, :lo12:c_ftl_nand_byte_pre_page] + mov w1, wzr + bl memset +.LBB52_5: // in Loop: Header=BB52_6 Depth=1 + ldr x8, [x27, :lo12:p_vendor_data_buf] + and x10, x24, #0xffff + lsl w9, w28, #7 + and w28, w24, #0xffff + lsl x24, x10, #9 + add x0, x8, w9, uxtw #2 + mov x1, x21 + mov x2, x24 + bl memcpy + ldr x2, [x27, :lo12:p_vendor_data_buf] + mov x0, x22 + mov w1, w23 + bl FtlMapWritePage + add w23, w23, #1 // =1 + subs w19, w19, w28 + add w20, w20, w28 + add x21, x21, x24 + b.eq .LBB52_9 +.LBB52_6: // =>This Inner Loop Header: Depth=1 + ldrh w9, [x26, :lo12:c_ftl_nand_sec_pre_page] + ldr x8, [x25, :lo12:p_vendor_region_ppn_table] + udiv w10, w20, w9 + ldr w8, [x8, w23, uxtw #2] + msub w28, w10, w9, w20 + sub w10, w9, w28 + cmp w19, w10, uxth + csel w24, w19, w10, lo + cbz w8, .LBB52_4 +// %bb.7: // in Loop: Header=BB52_6 Depth=1 + cmp w9, w24, uxth + b.eq .LBB52_4 +// %bb.8: // in Loop: Header=BB52_6 Depth=1 + ldr x9, [x27, :lo12:p_vendor_data_buf] + str w8, [sp, #12] + add x8, sp, #40 // =40 + add x0, sp, #8 // =8 + mov w1, #1 + stp x9, x8, [sp, #16] + bl FlashReadPages + b .LBB52_5 +.LBB52_9: + mov w0, wzr +.LBB52_10: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB52_12 +// %bb.11: + ldp x20, x19, [sp, #192] // 16-byte Folded Reload + ldp x22, x21, [sp, #176] // 16-byte Folded Reload + ldp x24, x23, [sp, #160] // 16-byte Folded Reload + ldp x26, x25, [sp, #144] // 16-byte Folded Reload + ldp x28, x27, [sp, #128] // 16-byte Folded Reload + ldp x29, x30, [sp, #112] // 16-byte Folded Reload + add sp, sp, #208 // =208 + hint #29 + ret +.LBB52_12: + bl __stack_chk_fail +.Lfunc_end52: + .size FtlVendorPartWrite, .Lfunc_end52-FtlVendorPartWrite + // -- End function + .globl sftl_discard // -- Begin function sftl_discard + .p2align 2 + .type sftl_discard,@function +sftl_discard: // @sftl_discard +// %bb.0: + hint #25 + sub sp, sp, #96 // =96 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + str x8, [sp, #8] + adrp x8, g_MaxLbaSector + ldr w9, [x8, :lo12:g_MaxLbaSector] + add w10, w1, w0 + mov w8, w0 + mov w0, #-1 + cmp w10, w9 + add x29, sp, #16 // =16 + b.hi .LBB53_19 +// %bb.1: + cmp w9, w8 + b.ls .LBB53_19 +// %bb.2: + mov w19, w1 + cmp w9, w1 + b.lo .LBB53_19 +// %bb.3: + cmp w19, #32 // =32 + b.lo .LBB53_18 +// %bb.4: + adrp x21, c_ftl_nand_sec_pre_page + ldrh w9, [x21, :lo12:c_ftl_nand_sec_pre_page] + udiv w20, w8, w9 + msub w8, w20, w9, w8 + ands w8, w8, #0xffff + b.eq .LBB53_6 +// %bb.5: + sub w8, w9, w8 + cmp w8, w19 + csel w8, w8, w19, lo + add w20, w20, #1 // =1 + sub w19, w19, w8, uxth +.LBB53_6: + mov w8, #-1 + cmp w19, w9 + adrp x22, gc_discard_updated + str w8, [sp] + b.hs .LBB53_13 +.LBB53_7: + ldr w8, [x22, :lo12:gc_discard_updated] + cmp w8, #33 // =33 + b.lo .LBB53_18 +// %bb.8: + str wzr, [x22, :lo12:gc_discard_updated] + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB53_17 +// %bb.9: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB53_11 +.LBB53_10: // in Loop: Header=BB53_11 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB53_17 +.LBB53_11: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB53_10 +// %bb.12: // in Loop: Header=BB53_11 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB53_10 +.LBB53_13: + adrp x23, g_totle_discard_page_count + adrp x24, c_ftl_nand_blks_per_die + adrp x25, c_ftl_nand_planes_per_die + b .LBB53_15 +.LBB53_14: // in Loop: Header=BB53_15 Depth=1 + ldrh w8, [x21, :lo12:c_ftl_nand_sec_pre_page] + add w20, w20, #1 // =1 + sub w19, w19, w8 + cmp w19, w8 + b.lo .LBB53_7 +.LBB53_15: // =>This Inner Loop Header: Depth=1 + add x1, sp, #4 // =4 + mov w0, w20 + mov w2, wzr + bl log2phys + ldr w26, [sp, #4] + cmn w26, #1 // =1 + b.eq .LBB53_14 +// %bb.16: // in Loop: Header=BB53_15 Depth=1 + ldr w8, [x22, :lo12:gc_discard_updated] + ldr w9, [x23, :lo12:g_totle_discard_page_count] + mov x1, sp + mov w2, #1 + add w8, w8, #1 // =1 + add w9, w9, #1 // =1 + mov w0, w20 + str w8, [x22, :lo12:gc_discard_updated] + str w9, [x23, :lo12:g_totle_discard_page_count] + bl log2phys + ldrh w8, [x24, :lo12:c_ftl_nand_blks_per_die] + ldrh w9, [x25, :lo12:c_ftl_nand_planes_per_die] + ubfx w10, w26, #10, #16 + udiv w11, w10, w8 + msub w8, w11, w8, w10 + udiv w0, w8, w9 + bl decrement_vpc_count + b .LBB53_14 +.LBB53_17: + bl FtlVpcTblFlush +.LBB53_18: + mov w0, wzr +.LBB53_19: + adrp x9, __stack_chk_guard + ldr x8, [sp, #8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB53_21 +// %bb.20: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #96 // =96 + hint #29 + ret +.LBB53_21: + bl __stack_chk_fail +.Lfunc_end53: + .size sftl_discard, .Lfunc_end53-sftl_discard + // -- End function + .globl sftl_read // -- Begin function sftl_read + .p2align 2 + .type sftl_read,@function +sftl_read: // @sftl_read +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + mov x3, x2 + mov w2, w1 + mov w1, w0 + mov w0, wzr + mov x29, sp + bl FtlRead + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end54: + .size sftl_read, .Lfunc_end54-sftl_read + // -- End function + .globl sftl_write // -- Begin function sftl_write + .p2align 2 + .type sftl_write,@function +sftl_write: // @sftl_write +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + str x21, [sp, #16] // 8-byte Folded Spill + stp x20, x19, [sp, #32] // 16-byte Folded Spill + mov x29, sp + mov x19, x2 + mov w20, w1 + mov w21, w0 + bl FtlWriteToIDB + mov w0, wzr + mov w1, w21 + mov w2, w20 + mov x3, x19 + bl FtlWrite + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldr x21, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end55: + .size sftl_write, .Lfunc_end55-sftl_write + // -- End function + .globl FtlWriteToIDB // -- Begin function FtlWriteToIDB + .p2align 2 + .type FtlWriteToIDB,@function +FtlWriteToIDB: // @FtlWriteToIDB +// %bb.0: + hint #25 + sub sp, sp, #208 // =208 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #112] // 16-byte Folded Spill + add x29, sp, #112 // =112 + cmp w0, #575 // =575 + stp x28, x27, [sp, #128] // 16-byte Folded Spill + stp x26, x25, [sp, #144] // 16-byte Folded Spill + stp x24, x23, [sp, #160] // 16-byte Folded Spill + stp x22, x21, [sp, #176] // 16-byte Folded Spill + stp x20, x19, [sp, #192] // 16-byte Folded Spill + stur x8, [x29, #-8] + b.hi .LBB56_6 +// %bb.1: + add w23, w1, w0 + sub w24, w23, #1 // =1 + mov w20, w1 + mov w21, w0 + cmp w24, #63 // =63 + b.ls .LBB56_6 +// %bb.2: + mov x19, x2 + cmp w21, #64 // =64 + b.ne .LBB56_12 +// %bb.3: + mov w0, #262144 + mov w1, #3265 + mov w2, #6 + bl kmalloc_order + adrp x25, idb_buf + str x0, [x25, :lo12:idb_buf] + mov w0, #262144 + mov w1, #3265 + mov w2, #6 + bl kmalloc_order + adrp x8, gp_flash_check_buf + str x0, [x8, :lo12:gp_flash_check_buf] + cbz x0, .LBB56_15 +// %bb.4: + ldr x22, [x25, :lo12:idb_buf] + cbz x22, .LBB56_15 +// %bb.5: + adrp x8, idb_need_write_back + mov w9, #1 + mov w2, #262144 + mov x0, x22 + mov w1, wzr + strb w9, [x8, :lo12:idb_need_write_back] + bl memset + b .LBB56_17 +.LBB56_6: + adrp x19, idb_need_write_back + ldrb w8, [x19, :lo12:idb_need_write_back] + cmp w8, #1 // =1 + b.ne .LBB56_19 +// %bb.7: + adrp x20, idb_buf + ldr x21, [x20, :lo12:idb_buf] + mov w9, #35899 + movk w9, #64732, lsl #16 + ldr w8, [x21] + cmp w8, w9 + b.ne .LBB56_52 +// %bb.8: + adrp x8, g_nand_phy_info+10 + ldrh w8, [x8, :lo12:g_nand_phy_info+10] + mov w9, wzr + mov w11, #65150 + mov w10, #262140 + lsl w8, w8, #2 +.LBB56_9: // =>This Inner Loop Header: Depth=1 + sub w12, w11, #127 // =127 + ldr w12, [x21, w12, uxtw #2] + cbnz w12, .LBB56_20 +// %bb.10: // in Loop: Header=BB56_9 Depth=1 + ldr w12, [x21, w9, uxtw #2] + add w13, w9, #1 // =1 + sub w14, w11, #128 // =128 + cmp w13, #1, lsl #12 // =4096 + sub w11, w11, #1 // =1 + csinc w9, wzr, w9, hi + cmp w14, #1, lsl #12 // =4096 + str w12, [x21, x10] + sub x10, x10, #4 // =4 + b.hi .LBB56_9 +// %bb.11: + mov w22, #512 + b .LBB56_21 +.LBB56_12: + adrp x8, idb_need_write_back + ldrb w8, [x8, :lo12:idb_need_write_back] + tbz w8, #0, .LBB56_19 +// %bb.13: + adrp x8, idb_buf + ldr x22, [x8, :lo12:idb_buf] + cmp w21, #63 // =63 + b.hi .LBB56_17 +// %bb.14: + mov w8, #64 + sub w8, w8, w21 + sub w20, w20, w8 + lsl w8, w8, #7 + add x19, x19, w8, uxtw #2 + b .LBB56_18 +.LBB56_15: + adrp x0, .L.str.130 + adrp x1, .L__func__.FtlWriteToIDB + add x0, x0, :lo12:.L.str.130 + add x1, x1, :lo12:.L__func__.FtlWriteToIDB + bl sftl_printk + adrp x8, idb_need_write_back + ldrb w8, [x8, :lo12:idb_need_write_back] + cmp w8, #1 // =1 + b.ne .LBB56_19 +// %bb.16: + ldr x22, [x25, :lo12:idb_buf] +.LBB56_17: + lsl w8, w21, #7 + sub w8, w8, #2, lsl #12 // =8192 + add x22, x22, w8, uxtw #2 +.LBB56_18: + mov w8, #64960 + movk w8, #127, lsl #16 + add w8, w23, w8 + cmp w24, #575 // =575 + csel w8, w8, wzr, hi + sub w8, w20, w8 + lsl w2, w8, #9 + mov x0, x22 + mov x1, x19 + bl memcpy +.LBB56_19: + mov w22, wzr + b .LBB56_54 +.LBB56_20: + lsr w22, w11, #7 +.LBB56_21: + add w9, w22, #4 // =4 + and w8, w8, #0xffff + udiv w27, w9, w8 + add w26, w27, #1 // =1 + adrp x0, .L.str.132 + add x0, x0, :lo12:.L.str.132 + mov w1, w22 + mov w2, w26 + bl sftl_printk + cmp w27, #7 // =7 + b.hi .LBB56_52 +// %bb.22: + mov w9, wzr + lsl w25, w22, #7 + adrp x20, g_nand_ops+8 + mov w8, w26 + stp w22, wzr, [sp, #20] // 8-byte Folded Spill + str w26, [sp, #36] // 4-byte Folded Spill + str x25, [sp, #8] // 8-byte Folded Spill + b .LBB56_25 +.LBB56_23: // in Loop: Header=BB56_25 Depth=1 + ldr w8, [sp, #24] // 4-byte Folded Reload + add w8, w8, #1 // =1 + cmp w8, #5 // =5 + str w8, [sp, #24] // 4-byte Folded Spill + b.hi .LBB56_56 +.LBB56_24: // in Loop: Header=BB56_25 Depth=1 + ldp w9, w26, [sp, #32] // 8-byte Folded Reload + add w8, w9, w26 + cmp w8, #9 // =9 + b.hs .LBB56_51 +.LBB56_25: // =>This Loop Header: Depth=1 + // Child Loop BB56_26 Depth 2 + // Child Loop BB56_33 Depth 2 + // Child Loop BB56_42 Depth 2 + // Child Loop BB56_48 Depth 2 + adrp x10, gp_flash_check_buf + ldr x0, [x10, :lo12:gp_flash_check_buf] + mov w2, #512 + mov w1, wzr + mov w23, w9 + str w8, [sp, #32] // 4-byte Folded Spill + bl memset + adrp x8, g_nand_phy_info+10 + ldrh w19, [x8, :lo12:g_nand_phy_info+10] + adrp x8, g_nand_ops+32 + add x8, x8, :lo12:g_nand_ops+32 + ldp x28, x25, [x8] + mov w22, wzr + str w23, [sp, #28] // 4-byte Folded Spill + mul w23, w23, w19 + mov w24, #-1 +.LBB56_26: // Parent Loop BB56_25 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x8, [x20, :lo12:g_nand_ops+8] + madd w1, w22, w19, w23 + mov w0, wzr + blr x8 + add w24, w24, #1 // =1 + cmp w24, w27 + add w22, w22, #1 // =1 + b.ne .LBB56_26 +// %bb.27: // in Loop: Header=BB56_25 Depth=1 + cmp x25, #0 // =0 + cset w8, ne + cmp x28, #0 // =0 + cset w9, ne + and w22, w9, w8 + cmp w22, #1 // =1 + b.ne .LBB56_29 +// %bb.28: // in Loop: Header=BB56_25 Depth=1 + adrp x8, gp_flash_check_buf + ldr x24, [x8, :lo12:gp_flash_check_buf] + mov w2, #1016 + mov w1, wzr + add x0, x24, #8 // =8 + bl memset + mov w8, #18766 + movk w8, #17998, lsl #16 + str w8, [x24] + mov w8, #12 + str w8, [x24, #4] + mov w8, #1024 + str wzr, [x24, #12] + strh w8, [x24, #16] + adrp x8, g_nand_phy_info+10 + ldrh w8, [x8, :lo12:g_nand_phy_info+10] + mov w9, #4096 + str w9, [x24, #20] + mov w9, #47602 + movk w9, #65230, lsl #16 + mov w10, #17225 + add w9, w9, w8, uxtb + movk w10, #44697, lsl #16 + eor w9, w9, w10 + lsl w10, w9, #5 + strh w8, [x24, #18] + add w8, w10, w8, lsr #8 + add w8, w8, w9, lsr #2 + eor w8, w8, w9 + lsr w9, w8, #2 + add w9, w9, w8, lsl #5 + eor w8, w9, w8 + mov w9, #16 + bfi w9, w8, #5, #27 + add w9, w9, w8, lsr #2 + eor w8, w9, w8 + lsr w9, w8, #2 + add w9, w9, w8, lsl #5 + eor w8, w9, w8 + lsr w9, w8, #2 + add w9, w9, w8, lsl #5 + eor w8, w9, w8 + str w8, [x24, #8] + mul w19, w26, w19 + cbnz w19, .LBB56_30 + b .LBB56_38 +.LBB56_29: // in Loop: Header=BB56_25 Depth=1 + mov x24, xzr + mul w19, w26, w19 + cbz w19, .LBB56_38 +.LBB56_30: // in Loop: Header=BB56_25 Depth=1 + cmp x28, #0 // =0 + cset w8, eq + cmp x25, #0 // =0 + cset w9, eq + mov w26, wzr + orr w28, w8, w9 + mov x25, x21 + b .LBB56_33 +.LBB56_31: // in Loop: Header=BB56_33 Depth=2 + adrp x26, g_nand_ops+16 + add x26, x26, :lo12:g_nand_ops+16 + ldr x8, [x26, #16] + mov w0, #70 + blr x8 + ldr x8, [x26] + add x3, sp, #40 // =40 + mov w0, wzr + mov w1, w23 + mov x2, x24 + blr x8 + adrp x8, g_nand_phy_info+22 + ldrb w8, [x8, :lo12:g_nand_phy_info+22] + ldr x9, [x26, #16] + mov w26, w0 + mov w0, w8 + blr x9 + cmn w26, #1 // =1 + b.eq .LBB56_38 +// %bb.32: // in Loop: Header=BB56_33 Depth=2 + mov w26, #1 + cmp w26, w19 + b.eq .LBB56_38 +.LBB56_33: // Parent Loop BB56_25 Depth=1 + // => This Inner Loop Header: Depth=2 + tbz w22, #0, .LBB56_35 +// %bb.34: // in Loop: Header=BB56_33 Depth=2 + cmp w26, #0 // =0 + cset w9, ne + add w10, w26, #1 // =1 + orr w9, w9, w28 + mov w8, #61424 + stp w10, w8, [sp, #40] + tbz w9, #0, .LBB56_31 + b .LBB56_36 +.LBB56_35: // in Loop: Header=BB56_33 Depth=2 + lsl w9, w26, #2 + mov w8, #61424 + stp w9, w8, [sp, #40] +.LBB56_36: // in Loop: Header=BB56_33 Depth=2 + adrp x8, g_nand_ops+16 + ldr x8, [x8, :lo12:g_nand_ops+16] + add w1, w26, w23 + add x3, sp, #40 // =40 + mov w0, wzr + mov x2, x25 + blr x8 + cmn w0, #1 // =1 + b.eq .LBB56_38 +// %bb.37: // in Loop: Header=BB56_33 Depth=2 + add x25, x25, #2048 // =2048 + add w26, w26, #1 // =1 + cmp w26, w19 + b.ne .LBB56_33 +.LBB56_38: // in Loop: Header=BB56_25 Depth=1 + adrp x8, g_nand_phy_info+10 + add x8, x8, :lo12:g_nand_phy_info+10 + ldrh w8, [x8] + ldr w9, [sp, #36] // 4-byte Folded Reload + mul w22, w9, w8 + cbz w22, .LBB56_46 +// %bb.39: // in Loop: Header=BB56_25 Depth=1 + adrp x10, g_nand_ops+32 + adrp x9, gp_flash_check_buf + add x10, x10, :lo12:g_nand_ops+32 + adrp x11, g_nand_phy_info+10 + ldr x23, [x9, :lo12:gp_flash_check_buf] + ldp x10, x9, [x10] + add x11, x11, :lo12:g_nand_phy_info+10 + ldrh w24, [x11, #4] + ldr w11, [sp, #28] // 4-byte Folded Reload + cmp x9, #0 // =0 + mov w26, wzr + mul w25, w11, w8 + cset w8, eq + cmp x10, #0 // =0 + cset w9, eq + orr w19, w8, w9 + b .LBB56_42 +.LBB56_40: // in Loop: Header=BB56_42 Depth=2 + adrp x28, g_nand_ops+24 + add x28, x28, :lo12:g_nand_ops+24 + ldr x8, [x28, #8] + mov w0, #70 + blr x8 + ldr x8, [x28, #16] + mov w0, #2 + blr x8 + ldr x8, [x28] + add x3, sp, #40 // =40 + mov w0, wzr + mov w1, w25 + mov x2, x23 + blr x8 + ldr x8, [x28, #16] + mov w0, w24 + blr x8 + adrp x9, g_nand_phy_info+22 + ldr x8, [x28, #8] + ldrb w0, [x9, :lo12:g_nand_phy_info+22] + blr x8 + ldr w8, [x23] + mov w9, #18766 + movk w9, #17998, lsl #16 + cmp w8, w9 + b.ne .LBB56_46 +.LBB56_41: // in Loop: Header=BB56_42 Depth=2 + add w26, w26, #1 // =1 + cmp w26, w22 + b.eq .LBB56_46 +.LBB56_42: // Parent Loop BB56_25 Depth=1 + // => This Inner Loop Header: Depth=2 + cmp w26, #0 // =0 + cset w8, ne + orr w8, w19, w8 + tbz w8, #0, .LBB56_40 +// %bb.43: // in Loop: Header=BB56_42 Depth=2 + adrp x8, g_nand_ops+24 + ldr x8, [x8, :lo12:g_nand_ops+24] + add w1, w26, w25 + add x3, sp, #40 // =40 + mov w0, wzr + mov x2, x23 + blr x8 + cmn w0, #1 // =1 + b.eq .LBB56_46 +// %bb.44: // in Loop: Header=BB56_42 Depth=2 + ldr w8, [sp, #44] + mov w9, #61424 + cmp w8, w9 + b.ne .LBB56_46 +// %bb.45: // in Loop: Header=BB56_42 Depth=2 + add x23, x23, #2048 // =2048 + b .LBB56_41 +.LBB56_46: // in Loop: Header=BB56_25 Depth=1 + ldr w22, [sp, #20] // 4-byte Folded Reload + ldr x25, [sp, #8] // 8-byte Folded Reload + cbz w22, .LBB56_23 +// %bb.47: // in Loop: Header=BB56_25 Depth=1 + adrp x8, gp_flash_check_buf + ldr x24, [x8, :lo12:gp_flash_check_buf] + mov x23, xzr +.LBB56_48: // Parent Loop BB56_25 Depth=1 + // => This Inner Loop Header: Depth=2 + lsl x19, x23, #2 + ldr w8, [x24, x19] + ldr w9, [x21, x19] + cmp w8, w9 + b.ne .LBB56_50 +// %bb.49: // in Loop: Header=BB56_48 Depth=2 + add x23, x23, #1 // =1 + cmp x25, x23 + b.ne .LBB56_48 + b .LBB56_23 +.LBB56_50: // in Loop: Header=BB56_25 Depth=1 + mov w2, #512 + mov x0, x24 + mov w1, wzr + bl memset + ldr w2, [x24, x19] + ldr w3, [x21, x19] + ldr w19, [sp, #28] // 4-byte Folded Reload + adrp x0, .L.str.133 + add x0, x0, :lo12:.L.str.133 + mov w4, w23 + mov w1, w19 + bl sftl_printk + adrp x8, g_nand_phy_info+10 + ldrh w8, [x8, :lo12:g_nand_phy_info+10] + ldr x9, [x20, :lo12:g_nand_ops+8] + mov w0, wzr + mul w1, w19, w8 + blr x9 + b .LBB56_24 +.LBB56_51: + ldr w8, [sp, #24] // 4-byte Folded Reload + adrp x19, idb_need_write_back + adrp x20, idb_buf + cbnz w8, .LBB56_53 +.LBB56_52: + mov w22, #-1 +.LBB56_53: + ldr x0, [x20, :lo12:idb_buf] + strb wzr, [x19, :lo12:idb_need_write_back] + bl kfree + adrp x8, gp_flash_check_buf + ldr x0, [x8, :lo12:gp_flash_check_buf] + bl kfree +.LBB56_54: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB56_57 +// %bb.55: + mov w0, w22 + ldp x20, x19, [sp, #192] // 16-byte Folded Reload + ldp x22, x21, [sp, #176] // 16-byte Folded Reload + ldp x24, x23, [sp, #160] // 16-byte Folded Reload + ldp x26, x25, [sp, #144] // 16-byte Folded Reload + ldp x28, x27, [sp, #128] // 16-byte Folded Reload + ldp x29, x30, [sp, #112] // 16-byte Folded Reload + add sp, sp, #208 // =208 + hint #29 + ret +.LBB56_56: + adrp x19, idb_need_write_back + adrp x20, idb_buf + b .LBB56_53 +.LBB56_57: + bl __stack_chk_fail +.Lfunc_end56: + .size FtlWriteToIDB, .Lfunc_end56-FtlWriteToIDB + // -- End function + .globl sftl_vendor_read // -- Begin function sftl_vendor_read + .p2align 2 + .type sftl_vendor_read,@function +sftl_vendor_read: // @sftl_vendor_read +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + add w0, w0, #256 // =256 + mov x29, sp + bl FtlVendorPartRead + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end57: + .size sftl_vendor_read, .Lfunc_end57-sftl_vendor_read + // -- End function + .globl sftl_vendor_write // -- Begin function sftl_vendor_write + .p2align 2 + .type sftl_vendor_write,@function +sftl_vendor_write: // @sftl_vendor_write +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + add w0, w0, #256 // =256 + mov x29, sp + bl FtlVendorPartWrite + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end58: + .size sftl_vendor_write, .Lfunc_end58-sftl_vendor_write + // -- End function + .globl sftl_get_density // -- Begin function sftl_get_density + .p2align 2 + .type sftl_get_density,@function +sftl_get_density: // @sftl_get_density +// %bb.0: + hint #25 + adrp x8, g_MaxLbaSector + ldr w0, [x8, :lo12:g_MaxLbaSector] + hint #29 + ret +.Lfunc_end59: + .size sftl_get_density, .Lfunc_end59-sftl_get_density + // -- End function + .globl FtlBbtInfoPrint // -- Begin function FtlBbtInfoPrint + .p2align 2 + .type FtlBbtInfoPrint,@function +FtlBbtInfoPrint: // @FtlBbtInfoPrint +// %bb.0: + hint #25 + hint #29 + ret +.Lfunc_end60: + .size FtlBbtInfoPrint, .Lfunc_end60-FtlBbtInfoPrint + // -- End function + .globl FtlBbt2Bitmap // -- Begin function FtlBbt2Bitmap + .p2align 2 + .type FtlBbt2Bitmap,@function +FtlBbt2Bitmap: // @FtlBbt2Bitmap +// %bb.0: + hint #25 + stp x29, x30, [sp, #-80]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_bbm_buf_size + ldrh w8, [x8, :lo12:c_ftl_nand_bbm_buf_size] + stp x20, x19, [sp, #64] // 16-byte Folded Spill + mov x19, x1 + mov x20, x0 + lsl x2, x8, #2 + mov x0, x1 + mov w1, wzr + stp x26, x25, [sp, #16] // 16-byte Folded Spill + stp x24, x23, [sp, #32] // 16-byte Folded Spill + stp x22, x21, [sp, #48] // 16-byte Folded Spill + mov x29, sp + bl memset + adrp x21, .L.str.78 + adrp x22, .L__func__.FtlBbt2Bitmap + mov x23, xzr + mov w24, #65535 + adrp x25, c_ftl_nand_blks_per_die + mov w26, #1 + add x21, x21, :lo12:.L.str.78 + add x22, x22, :lo12:.L__func__.FtlBbt2Bitmap + b .LBB61_2 +.LBB61_1: // in Loop: Header=BB61_2 Depth=1 + lsr w9, w8, #3 + and x9, x9, #0x1ffc + ldr w10, [x19, x9] + lsl w8, w26, w8 + add x23, x23, #2 // =2 + cmp x23, #1024 // =1024 + orr w8, w8, w10 + str w8, [x19, x9] + b.eq .LBB61_5 +.LBB61_2: // =>This Inner Loop Header: Depth=1 + ldrh w8, [x20, x23] + cmp w8, w24 + b.eq .LBB61_5 +// %bb.3: // in Loop: Header=BB61_2 Depth=1 + ldrh w9, [x25, :lo12:c_ftl_nand_blks_per_die] + cmp w8, w9 + b.lo .LBB61_1 +// %bb.4: // in Loop: Header=BB61_2 Depth=1 + mov w2, #74 + mov x0, x21 + mov x1, x22 + bl sftl_printk + ldrh w8, [x20, x23] + b .LBB61_1 +.LBB61_5: + ldp x20, x19, [sp, #64] // 16-byte Folded Reload + ldp x22, x21, [sp, #48] // 16-byte Folded Reload + ldp x24, x23, [sp, #32] // 16-byte Folded Reload + ldp x26, x25, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #80 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end61: + .size FtlBbt2Bitmap, .Lfunc_end61-FtlBbt2Bitmap + // -- End function + .globl FtlBbtMemInit // -- Begin function FtlBbtMemInit + .p2align 2 + .type FtlBbtMemInit,@function +FtlBbtMemInit: // @FtlBbtMemInit +// %bb.0: + hint #25 + adrp x8, gBbtInfo + add x8, x8, :lo12:gBbtInfo + mov w9, #65535 + mov x10, #-1 + strh w9, [x8] + strh wzr, [x8, #6] + stur x10, [x8, #12] + stur x10, [x8, #20] + hint #29 + ret +.Lfunc_end62: + .size FtlBbtMemInit, .Lfunc_end62-FtlBbtMemInit + // -- End function + .globl FtlBbtCalcTotleCnt // -- Begin function FtlBbtCalcTotleCnt + .p2align 2 + .type FtlBbtCalcTotleCnt,@function +FtlBbtCalcTotleCnt: // @FtlBbtCalcTotleCnt +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_blks_per_die + adrp x9, c_ftl_nand_die_num + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + ldrh w11, [x9, :lo12:c_ftl_nand_die_num] + mul w9, w11, w8 + subs w10, w9, #1 // =1 + b.lt .LBB63_3 +// %bb.1: + cmp w9, #2 // =2 + b.hs .LBB63_4 +// %bb.2: + mov w0, wzr + mov w10, wzr + b .LBB63_10 +.LBB63_3: + mov w0, wzr + hint #29 + ret +.LBB63_4: + mneg w11, w11, w8 + tst w11, #0xffff + mov w0, wzr + b.eq .LBB63_9 +// %bb.5: + lsr w11, w10, #16 + mov w10, w0 + cbnz w11, .LBB63_10 +// %bb.6: + adrp x14, gBbtInfo+32 + mov w13, wzr + mov w12, wzr + and w10, w9, #0xfffffffe + add x14, x14, :lo12:gBbtInfo+32 +.LBB63_7: // =>This Inner Loop Header: Depth=1 + orr w15, w13, #0x1 + and w16, w13, #0xffff + and w17, w8, #0xffff + and w18, w15, #0xffff + udiv w16, w16, w17 + udiv w17, w18, w17 + msub w18, w16, w8, w13 + ldr x16, [x14, w16, uxtw #3] + msub w15, w17, w8, w15 + ldr x17, [x14, w17, uxtw #3] + lsr w0, w18, #3 + lsr w1, w15, #3 + and x0, x0, #0x1ffc + and x1, x1, #0x1ffc + ldr w16, [x16, x0] + ldr w17, [x17, x1] + add w13, w13, #2 // =2 + cmp w10, w13 + lsr w16, w16, w18 + lsr w15, w17, w15 + and w16, w16, #0x1 + and w15, w15, #0x1 + add w11, w11, w16 + add w12, w12, w15 + b.ne .LBB63_7 +// %bb.8: + cmp w9, w10 + add w0, w12, w11 + b.ne .LBB63_10 + b .LBB63_12 +.LBB63_9: + mov w10, w0 +.LBB63_10: + adrp x11, gBbtInfo + add x11, x11, :lo12:gBbtInfo +.LBB63_11: // =>This Inner Loop Header: Depth=1 + and w12, w8, #0xffff + and w13, w10, #0xffff + udiv w12, w13, w12 + add x13, x11, w12, uxtw #3 + ldr x13, [x13, #32] + msub w12, w12, w8, w10 + lsr w14, w12, #3 + and x14, x14, #0x1ffc + ldr w13, [x13, x14] + add w10, w10, #1 // =1 + cmp w9, w10, uxth + lsr w12, w13, w12 + and w12, w12, #0x1 + add w0, w0, w12 + b.gt .LBB63_11 +.LBB63_12: + hint #29 + ret +.Lfunc_end63: + .size FtlBbtCalcTotleCnt, .Lfunc_end63-FtlBbtCalcTotleCnt + // -- End function + .globl FtlGetLastWrittenPage // -- Begin function FtlGetLastWrittenPage + .p2align 2 + .type FtlGetLastWrittenPage,@function +FtlGetLastWrittenPage: // @FtlGetLastWrittenPage +// %bb.0: + hint #25 + sub sp, sp, #160 // =160 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + adrp x9, c_ftl_nand_page_pre_slc_blk + adrp x10, c_ftl_nand_page_pre_blk + stp x29, x30, [sp, #112] // 16-byte Folded Spill + add x29, sp, #112 // =112 + add x9, x9, :lo12:c_ftl_nand_page_pre_slc_blk + cmp w1, #1 // =1 + add x10, x10, :lo12:c_ftl_nand_page_pre_blk + stp x22, x21, [sp, #128] // 16-byte Folded Spill + stp x20, x19, [sp, #144] // 16-byte Folded Spill + stur x8, [x29, #-8] + adrp x8, sftl_temp_buf + csel x9, x9, x10, eq + ldr x8, [x8, :lo12:sftl_temp_buf] + ldrh w9, [x9] + add x10, sp, #40 // =40 + lsl w20, w0, #10 + stp x8, x10, [sp, #16] + sub w8, w9, #1 // =1 + sxth w19, w8 + orr w8, w20, w19 + add x0, sp, #8 // =8 + mov w1, #1 + str w8, [sp, #12] + bl FlashReadPages + ldr w8, [sp, #40] + cmn w8, #1 // =1 + b.ne .LBB64_4 +// %bb.1: + tbnz w19, #31, .LBB64_4 +// %bb.2: + mov w21, wzr +.LBB64_3: // =>This Inner Loop Header: Depth=1 + sxth w8, w21 + add w8, w8, w19, sxth + cmp w8, #0 // =0 + cinc w8, w8, lt + asr w22, w8, #1 + orr w8, w22, w20 + add x0, sp, #8 // =8 + mov w1, #1 + str w8, [sp, #12] + bl FlashReadPages + ldp w8, w9, [sp, #40] + ldr w10, [sp, #8] + and w8, w8, w9 + cmn w8, #1 // =1 + cset w8, ne + cmn w10, #1 // =1 + cset w9, eq + orr w8, w8, w9 + sub w9, w22, #1 // =1 + cmp w8, #0 // =0 + csel w8, w19, w9, ne + csinc w9, w21, w22, eq + sxth w19, w8 + sxth w21, w9 + cmp w21, w19 + b.le .LBB64_3 +.LBB64_4: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB64_6 +// %bb.5: + mov w0, w19 + ldp x20, x19, [sp, #144] // 16-byte Folded Reload + ldp x22, x21, [sp, #128] // 16-byte Folded Reload + ldp x29, x30, [sp, #112] // 16-byte Folded Reload + add sp, sp, #160 // =160 + hint #29 + ret +.LBB64_6: + bl __stack_chk_fail +.Lfunc_end64: + .size FtlGetLastWrittenPage, .Lfunc_end64-FtlGetLastWrittenPage + // -- End function + .globl FtlLoadFactoryBbt // -- Begin function FtlLoadFactoryBbt + .p2align 2 + .type FtlLoadFactoryBbt,@function +FtlLoadFactoryBbt: // @FtlLoadFactoryBbt +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + adrp x8, p_sys_data_buf + adrp x9, p_sys_spare_buf + adrp x20, c_ftl_nand_die_num + stp x22, x21, [sp, #64] // 16-byte Folded Spill + ldr x8, [x8, :lo12:p_sys_data_buf] + ldr x21, [x9, :lo12:p_sys_spare_buf] + ldrh w9, [x20, :lo12:c_ftl_nand_die_num] + adrp x10, req_sys+8 + add x10, x10, :lo12:req_sys+8 + str x27, [sp, #16] // 8-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + mov x29, sp + stp x8, x21, [x10] + cbz w9, .LBB65_8 +// %bb.1: + adrp x23, gBbtInfo + adrp x19, req_sys + mov x22, xzr + add x23, x23, :lo12:gBbtInfo + mov w24, #65535 + adrp x25, c_ftl_nand_blks_per_die + add x19, x19, :lo12:req_sys + b .LBB65_3 +.LBB65_2: // in Loop: Header=BB65_3 Depth=1 + ldrh w8, [x20, :lo12:c_ftl_nand_die_num] + add x22, x22, #1 // =1 + cmp x22, x8 + b.hs .LBB65_8 +.LBB65_3: // =>This Loop Header: Depth=1 + // Child Loop BB65_5 Depth 2 + ldrh w8, [x25, :lo12:c_ftl_nand_blks_per_die] + add x26, x23, x22, lsl #1 + strh w24, [x26, #12]! + sub w9, w8, #1 // =1 + and w27, w9, #0xffff + sub w9, w8, #16 // =16 + cmp w9, w27 + b.lt .LBB65_5 + b .LBB65_2 +.LBB65_4: // in Loop: Header=BB65_5 Depth=2 + ldrh w8, [x25, :lo12:c_ftl_nand_blks_per_die] + sub w9, w27, #1 // =1 + and w27, w9, #0xffff + sub w9, w8, #16 // =16 + cmp w9, w27 + b.ge .LBB65_2 +.LBB65_5: // Parent Loop BB65_3 Depth=1 + // => This Inner Loop Header: Depth=2 + madd w8, w8, w22, w27 + lsl w8, w8, #10 + mov w1, #1 + mov x0, x19 + str w8, [x19, #4] + bl FlashReadPages + ldr w8, [x19] + cmn w8, #1 // =1 + b.eq .LBB65_4 +// %bb.6: // in Loop: Header=BB65_5 Depth=2 + ldrsh w8, [x21] + cmn w8, #3872 // =3872 + b.ne .LBB65_4 +// %bb.7: // in Loop: Header=BB65_3 Depth=1 + strh w27, [x26] + b .LBB65_2 +.LBB65_8: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldr x27, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end65: + .size FtlLoadFactoryBbt, .Lfunc_end65-FtlLoadFactoryBbt + // -- End function + .globl FlashGetBadBlockList // -- Begin function FlashGetBadBlockList + .p2align 2 + .type FlashGetBadBlockList,@function +FlashGetBadBlockList: // @FlashGetBadBlockList +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + mov x20, #-1 + stp x20, x20, [x0, #240] + stp x20, x20, [x0, #224] + stp x20, x20, [x0, #208] + stp x20, x20, [x0, #192] + stp x20, x20, [x0, #176] + stp x20, x20, [x0, #160] + stp x20, x20, [x0, #144] + stp x20, x20, [x0, #128] + stp x20, x20, [x0, #112] + stp x20, x20, [x0, #96] + stp x20, x20, [x0, #80] + stp x20, x20, [x0, #64] + stp x20, x20, [x0, #48] + stp x20, x20, [x0, #32] + stp x20, x20, [x0, #16] + stp x20, x20, [x0] + adrp x8, g_nand_ops + ldr x8, [x8, :lo12:g_nand_ops] + mov x29, sp + mov x19, x0 + blr x8 + and w8, w0, #0xffff + cmp w8, #51 // =51 + b.lo .LBB66_2 +// %bb.1: + mov w0, wzr + stp x20, x20, [x19, #240] + stp x20, x20, [x19, #224] + stp x20, x20, [x19, #208] + stp x20, x20, [x19, #192] + stp x20, x20, [x19, #176] + stp x20, x20, [x19, #160] + stp x20, x20, [x19, #144] + stp x20, x20, [x19, #128] + stp x20, x20, [x19, #112] + stp x20, x20, [x19, #96] + stp x20, x20, [x19, #80] + stp x20, x20, [x19, #64] + stp x20, x20, [x19, #48] + stp x20, x20, [x19, #32] + stp x20, x20, [x19, #16] + stp x20, x20, [x19] + b .LBB66_11 +.LBB66_2: + adrp x8, g_nand_phy_info+14 + ldrh w8, [x8, :lo12:g_nand_phy_info+14] + cmp w8, #4 // =4 + b.ne .LBB66_11 +// %bb.3: + tst w0, #0xffff + b.eq .LBB66_11 +// %bb.4: + and w8, w0, #0xffff + cmp w8, #2 // =2 + b.hs .LBB66_6 +// %bb.5: + mov x9, xzr + b .LBB66_9 +.LBB66_6: + and x9, x8, #0xfffe + add x10, x19, #2 // =2 + mov x11, x9 +.LBB66_7: // =>This Inner Loop Header: Depth=1 + ldurh w12, [x10, #-2] + ldrh w13, [x10] + subs x11, x11, #2 // =2 + lsr w12, w12, #1 + lsr w13, w13, #1 + sturh w12, [x10, #-2] + strh w13, [x10], #4 + b.ne .LBB66_7 +// %bb.8: + cmp x9, x8 + b.eq .LBB66_11 +.LBB66_9: + add x10, x19, x9, lsl #1 + sub x8, x8, x9 +.LBB66_10: // =>This Inner Loop Header: Depth=1 + ldrh w9, [x10] + subs x8, x8, #1 // =1 + lsr w9, w9, #1 + strh w9, [x10], #2 + b.ne .LBB66_10 +.LBB66_11: + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + and w0, w0, #0xffff + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end66: + .size FlashGetBadBlockList, .Lfunc_end66-FlashGetBadBlockList + // -- End function + .globl FlashTestBlk // -- Begin function FlashTestBlk + .p2align 2 + .type FlashTestBlk,@function +FlashTestBlk: // @FlashTestBlk +// %bb.0: + hint #25 + sub sp, sp, #144 // =144 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + and w9, w0, #0xffff + stp x29, x30, [sp, #112] // 16-byte Folded Spill + add x29, sp, #112 // =112 + cmp w9, #12 // =12 + stp x20, x19, [sp, #128] // 16-byte Folded Spill + stur x8, [x29, #-8] + b.hs .LBB67_2 +// %bb.1: + mov w19, wzr + b .LBB67_6 +.LBB67_2: + adrp x8, sftl_temp_buf + mov x10, #42405 + mov x11, #23130 + ldr x8, [x8, :lo12:sftl_temp_buf] + movk x10, #42405, lsl #16 + movk x11, #23130, lsl #16 + movk x10, #42405, lsl #32 + movk x11, #23130, lsl #32 + add x9, sp, #40 // =40 + movk x10, #42405, lsl #48 + movk x11, #23130, lsl #48 + ubfiz w20, w0, #10, #16 + add x0, sp, #8 // =8 + mov w2, #1 + stp x10, x10, [sp, #40] + stp x10, x10, [sp, #56] + stp x8, x9, [sp, #16] + str x11, [x8] + str w20, [sp, #12] + bl FlashEraseBlocks + add x0, sp, #8 // =8 + mov w1, #1 + mov w2, #1 + bl FlashProgPages + ldr w8, [sp, #8] + cbz w8, .LBB67_4 +// %bb.3: + mov w19, #-1 + b .LBB67_5 +.LBB67_4: + orr w8, w20, #0x1 + add x0, sp, #8 // =8 + mov w1, #1 + mov w2, #1 + str w8, [sp, #12] + bl FlashProgPages + ldr w8, [sp, #8] + cmp w8, #0 // =0 + csetm w19, ne +.LBB67_5: + add x0, sp, #8 // =8 + mov w2, #1 + str w20, [sp, #12] + bl FlashEraseBlocks +.LBB67_6: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB67_8 +// %bb.7: + mov w0, w19 + ldp x20, x19, [sp, #128] // 16-byte Folded Reload + ldp x29, x30, [sp, #112] // 16-byte Folded Reload + add sp, sp, #144 // =144 + hint #29 + ret +.LBB67_8: + bl __stack_chk_fail +.Lfunc_end67: + .size FlashTestBlk, .Lfunc_end67-FlashTestBlk + // -- End function + .globl P2V_plane // -- Begin function P2V_plane + .p2align 2 + .type P2V_plane,@function +P2V_plane: // @P2V_plane +// %bb.0: + hint #25 + adrp x9, c_ftl_nand_planes_per_die + adrp x8, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_planes_per_die] + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + and w10, w0, #0xffff + hint #29 + udiv w11, w10, w9 + udiv w8, w10, w8 + msub w10, w11, w9, w10 + madd w0, w9, w8, w10 + ret +.Lfunc_end68: + .size P2V_plane, .Lfunc_end68-P2V_plane + // -- End function + .globl ftl_cmp_data_ver // -- Begin function ftl_cmp_data_ver + .p2align 2 + .type ftl_cmp_data_ver,@function +ftl_cmp_data_ver: // @ftl_cmp_data_ver +// %bb.0: + hint #25 + subs w8, w0, w1 + mov w9, #-2147483647 + sub w10, w1, w0 + mov w11, #-2147483648 + cmp w8, w9 + cset w8, lo + cmp w10, w11 + cset w9, hi + cmp w0, w1 + csel w0, w8, w9, hi + hint #29 + ret +.Lfunc_end69: + .size ftl_cmp_data_ver, .Lfunc_end69-ftl_cmp_data_ver + // -- End function + .globl FtlFreeSysBlkQueueEmpty // -- Begin function FtlFreeSysBlkQueueEmpty + .p2align 2 + .type FtlFreeSysBlkQueueEmpty,@function +FtlFreeSysBlkQueueEmpty: // @FtlFreeSysBlkQueueEmpty +// %bb.0: + hint #25 + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + hint #29 + cmp w8, #0 // =0 + cset w0, eq + ret +.Lfunc_end70: + .size FtlFreeSysBlkQueueEmpty, .Lfunc_end70-FtlFreeSysBlkQueueEmpty + // -- End function + .globl FtlFreeSysBlkQueueFull // -- Begin function FtlFreeSysBlkQueueFull + .p2align 2 + .type FtlFreeSysBlkQueueFull,@function +FtlFreeSysBlkQueueFull: // @FtlFreeSysBlkQueueFull +// %bb.0: + hint #25 + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + hint #29 + cmp w8, #1024 // =1024 + cset w0, eq + ret +.Lfunc_end71: + .size FtlFreeSysBlkQueueFull, .Lfunc_end71-FtlFreeSysBlkQueueFull + // -- End function + .globl FtlFreeSysBLkSort // -- Begin function FtlFreeSysBLkSort + .p2align 2 + .type FtlFreeSysBLkSort,@function +FtlFreeSysBLkSort: // @FtlFreeSysBLkSort +// %bb.0: + hint #25 + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + cbz w8, .LBB72_5 +// %bb.1: + adrp x8, g_sys_save_data+28 + ldrh w8, [x8, :lo12:g_sys_save_data+28] + and w8, w8, #0x1f + cbz w8, .LBB72_5 +// %bb.2: + adrp x9, gSysFreeQueue+2 + add x9, x9, :lo12:gSysFreeQueue+2 + ldrh w13, [x9] + ldrh w11, [x9, #2] + adrp x12, gSysFreeQueue+8 + mov w10, wzr + add x12, x12, :lo12:gSysFreeQueue+8 +.LBB72_3: // =>This Inner Loop Header: Depth=1 + and x14, x13, #0xffff + ldrh w14, [x12, x14, lsl #1] + add w13, w13, #1 // =1 + and x15, x11, #0xffff + add w11, w11, #1 // =1 + add w10, w10, #1 // =1 + and w13, w13, #0x3ff + cmp w8, w10, uxth + and w11, w11, #0x3ff + strh w14, [x12, x15, lsl #1] + b.hi .LBB72_3 +// %bb.4: + strh w13, [x9] + strh w11, [x9, #2] +.LBB72_5: + hint #29 + ret +.Lfunc_end72: + .size FtlFreeSysBLkSort, .Lfunc_end72-FtlFreeSysBLkSort + // -- End function + .globl IsInFreeQueue // -- Begin function IsInFreeQueue + .p2align 2 + .type IsInFreeQueue,@function +IsInFreeQueue: // @IsInFreeQueue +// %bb.0: + hint #25 + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + cmp w8, #1024 // =1024 + b.eq .LBB73_5 +// %bb.1: + cbz w8, .LBB73_5 +// %bb.2: + adrp x9, gSysFreeQueue+2 + ldrh w9, [x9, :lo12:gSysFreeQueue+2] + adrp x10, gSysFreeQueue + add x10, x10, :lo12:gSysFreeQueue +.LBB73_3: // =>This Inner Loop Header: Depth=1 + and w11, w9, #0x3ff + add x11, x10, w11, uxtw #1 + ldrh w11, [x11, #8] + cmp w11, w0, uxth + b.eq .LBB73_6 +// %bb.4: // in Loop: Header=BB73_3 Depth=1 + subs w8, w8, #1 // =1 + add w9, w9, #1 // =1 + b.ne .LBB73_3 +.LBB73_5: + mov w0, wzr + hint #29 + ret +.LBB73_6: + mov w0, #1 + hint #29 + ret +.Lfunc_end73: + .size IsInFreeQueue, .Lfunc_end73-IsInFreeQueue + // -- End function + .globl INSERT_FREE_LIST // -- Begin function INSERT_FREE_LIST + .p2align 2 + .type INSERT_FREE_LIST,@function +INSERT_FREE_LIST: // @INSERT_FREE_LIST +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + // kill: def $w0 killed $w0 def $x0 + mvn w8, w0 + tst w8, #0xffff + mov x29, sp + b.eq .LBB74_12 +// %bb.1: + adrp x8, p_data_block_list_table + ldr x9, [x8, :lo12:p_data_block_list_table] + and x13, x0, #0xffff + mov w10, #6 + mov w11, #-1 + madd x9, x13, x10, x9 + mov x10, x9 + str w11, [x10], #2 + adrp x12, p_free_data_block_list_head + ldr x11, [x12, :lo12:p_free_data_block_list_head] + cbz x11, .LBB74_11 +// %bb.2: + adrp x15, p_erase_count_table + ldr x14, [x8, :lo12:p_data_block_list_table] + ldr x15, [x15, :lo12:p_erase_count_table] + sub x17, x11, x14 + ldrh w16, [x15, x13, lsl #1] + asr x13, x17, #1 + mov x17, #-6148914691236517206 + movk x17, #43691 + mul x13, x13, x17 + and x17, x13, #0xffff + ldrh w17, [x15, x17, lsl #1] + // kill: def $w13 killed $w13 killed $x13 def $x13 + cmp w17, w16 + b.hs .LBB74_8 +// %bb.3: + ldrh w1, [x11] + mov w17, #65535 + cmp w1, w17 + b.eq .LBB74_7 +// %bb.4: + mov w18, #6 +.LBB74_5: // =>This Inner Loop Header: Depth=1 + mov w13, w1 + and x11, x13, #0xffff + ldrh w1, [x15, x11, lsl #1] + madd x11, x11, x18, x14 + cmp w1, w16 + b.hs .LBB74_8 +// %bb.6: // in Loop: Header=BB74_5 Depth=1 + ldrh w1, [x11] + cmp w1, w17 + b.ne .LBB74_5 +.LBB74_7: + strh w13, [x10] + strh w0, [x11] + b .LBB74_12 +.LBB74_8: + ldrh w14, [x11, #2] + strh w14, [x10] + strh w13, [x9] + ldr x10, [x12, :lo12:p_free_data_block_list_head] + cmp x11, x10 + b.eq .LBB74_10 +// %bb.9: + ldrh w9, [x11, #2] + ldr x8, [x8, :lo12:p_data_block_list_table] + mov w10, #6 + mul x9, x9, x10 + strh w0, [x8, x9] + strh w0, [x11, #2] + b .LBB74_12 +.LBB74_10: + strh w0, [x11, #2] +.LBB74_11: + str x9, [x12, :lo12:p_free_data_block_list_head] +.LBB74_12: + adrp x8, g_num_free_superblocks + ldrh w9, [x8, :lo12:g_num_free_superblocks] + adrp x10, c_ftl_nand_data_blks_per_plane + ldrh w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane] + add w9, w9, #1 // =1 + strh w9, [x8, :lo12:g_num_free_superblocks] + cmp w10, w9, uxth + b.hs .LBB74_14 +// %bb.13: + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_FREE_LIST + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_FREE_LIST + mov w2, #207 + bl sftl_printk +.LBB74_14: + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end74: + .size INSERT_FREE_LIST, .Lfunc_end74-INSERT_FREE_LIST + // -- End function + .globl insert_free_list // -- Begin function insert_free_list + .p2align 2 + .type insert_free_list,@function +insert_free_list: // @insert_free_list +// %bb.0: + hint #25 + // kill: def $w0 killed $w0 def $x0 + mvn w8, w0 + tst w8, #0xffff + b.eq .LBB75_13 +// %bb.1: + adrp x8, p_data_block_list_table + ldr x9, [x8, :lo12:p_data_block_list_table] + and x15, x0, #0xffff + mov w10, #6 + madd x9, x15, x10, x9 + mov w10, #-1 + mov x11, x9 + str w10, [x11], #2 + adrp x10, p_free_data_block_list_head + ldr x12, [x10, :lo12:p_free_data_block_list_head] + cbz x12, .LBB75_12 +// %bb.2: + ldr x13, [x8, :lo12:p_data_block_list_table] + adrp x14, p_erase_count_table + ldr x14, [x14, :lo12:p_erase_count_table] + mov x17, #-6148914691236517206 + sub x16, x12, x13 + asr x16, x16, #1 + movk x17, #43691 + mul x17, x16, x17 + and x16, x17, #0xffff + ldrh w15, [x14, x15, lsl #1] + ldrh w16, [x14, x16, lsl #1] + cmp w16, w15 + b.hs .LBB75_9 +// %bb.3: + ldrh w16, [x12] + mov w18, #65535 + cmp w16, w18 + b.eq .LBB75_7 +// %bb.4: + mov w1, #6 +.LBB75_5: // =>This Inner Loop Header: Depth=1 + and x12, x16, #0xffff + ldrh w17, [x14, x12, lsl #1] + madd x12, x12, x1, x13 + cmp w17, w15 + b.hs .LBB75_8 +// %bb.6: // in Loop: Header=BB75_5 Depth=1 + ldrh w2, [x12] + mov w17, w16 + cmp w2, w18 + mov w16, w2 + b.ne .LBB75_5 +.LBB75_7: + strh w17, [x11] + strh w0, [x12] + b .LBB75_13 +.LBB75_8: + mov w17, w16 +.LBB75_9: + ldrh w13, [x12, #2] + strh w13, [x11] + strh w17, [x9] + ldr x11, [x10, :lo12:p_free_data_block_list_head] + cmp x12, x11 + b.eq .LBB75_11 +// %bb.10: + ldrh w9, [x12, #2] + ldr x8, [x8, :lo12:p_data_block_list_table] + mov w10, #6 + mul x9, x9, x10 + strh w0, [x8, x9] + strh w0, [x12, #2] + b .LBB75_13 +.LBB75_11: + strh w0, [x12, #2] +.LBB75_12: + str x9, [x10, :lo12:p_free_data_block_list_head] +.LBB75_13: + mov w0, wzr + hint #29 + ret +.Lfunc_end75: + .size insert_free_list, .Lfunc_end75-insert_free_list + // -- End function + .globl INSERT_DATA_LIST // -- Begin function INSERT_DATA_LIST + .p2align 2 + .type INSERT_DATA_LIST,@function +INSERT_DATA_LIST: // @INSERT_DATA_LIST +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + mov x29, sp + bl insert_data_list + adrp x8, g_num_data_superblocks + ldrh w9, [x8, :lo12:g_num_data_superblocks] + adrp x10, c_ftl_nand_data_blks_per_plane + ldrh w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane] + add w9, w9, #1 // =1 + strh w9, [x8, :lo12:g_num_data_superblocks] + cmp w10, w9, uxth + b.hs .LBB76_2 +// %bb.1: + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + mov w2, #214 + bl sftl_printk +.LBB76_2: + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end76: + .size INSERT_DATA_LIST, .Lfunc_end76-INSERT_DATA_LIST + // -- End function + .globl insert_data_list // -- Begin function insert_data_list + .p2align 2 + .type insert_data_list,@function +insert_data_list: // @insert_data_list +// %bb.0: + hint #25 + adrp x16, c_ftl_nand_data_blks_per_plane + ldrh w8, [x16, :lo12:c_ftl_nand_data_blks_per_plane] + // kill: def $w0 killed $w0 def $x0 + cmp w8, w0, uxth + b.ls .LBB77_14 +// %bb.1: + adrp x8, p_data_block_list_table + ldr x15, [x8, :lo12:p_data_block_list_table] + and x17, x0, #0xffff + mov w9, #6 + mov w10, #-1 + madd x9, x17, x9, x15 + mov x12, x9 + str w10, [x12], #2 + adrp x10, p_data_block_list_head + ldr x11, [x10, :lo12:p_data_block_list_head] + cbz x11, .LBB77_13 +// %bb.2: + adrp x14, p_valid_page_count_table + ldr x14, [x14, :lo12:p_valid_page_count_table] + ldr x13, [x8, :lo12:p_data_block_list_table] + mov w18, #6 + madd x15, x17, x18, x15 + ldrh w15, [x15, #4] + ldrh w2, [x14, x17, lsl #1] + mov w1, #43691 + sub x18, x11, x13 + movk w1, #43690, lsl #16 + lsr x17, x18, #1 + mul w17, w17, w1 + cmp w15, #0 // =0 + mul w15, w15, w2 + and w18, w17, #0xffff + csinv w15, w15, wzr, ne + cmp w18, w0, uxth + b.eq .LBB77_14 +// %bb.3: + ldrh w16, [x16, :lo12:c_ftl_nand_data_blks_per_plane] + cbz w16, .LBB77_14 +// %bb.4: + mov w18, #1 + mov w1, #65535 + mov w2, #6 +.LBB77_5: // =>This Inner Loop Header: Depth=1 + and x3, x17, #0xffff + ldrh w4, [x11, #4] + ldrh w3, [x14, x3, lsl #1] + cmp w4, #0 // =0 + mul w3, w4, w3 + csinv w3, w3, wzr, ne + cmp w3, w15 + b.hs .LBB77_9 +// %bb.6: // in Loop: Header=BB77_5 Depth=1 + ldrh w3, [x11] + cmp x3, x1 + b.eq .LBB77_11 +// %bb.7: // in Loop: Header=BB77_5 Depth=1 + cmp w3, w0, uxth + b.eq .LBB77_14 +// %bb.8: // in Loop: Header=BB77_5 Depth=1 + add w18, w18, #1 // =1 + cmp w16, w18, uxth + madd x11, x3, x2, x13 + mov w17, w3 + b.hs .LBB77_5 + b .LBB77_14 +.LBB77_9: + strh w17, [x9] + ldrh w13, [x11, #2] + strh w13, [x12] + ldr x12, [x10, :lo12:p_data_block_list_head] + cmp x11, x12 + b.eq .LBB77_12 +// %bb.10: + ldrh w9, [x11, #2] + ldr x8, [x8, :lo12:p_data_block_list_table] + mov w10, #6 + mul x9, x9, x10 + strh w0, [x8, x9] + strh w0, [x11, #2] + b .LBB77_14 +.LBB77_11: + adrp x8, p_data_block_list_tail + strh w17, [x12] + strh w0, [x11] + str x9, [x8, :lo12:p_data_block_list_tail] + b .LBB77_14 +.LBB77_12: + strh w0, [x11, #2] +.LBB77_13: + str x9, [x10, :lo12:p_data_block_list_head] +.LBB77_14: + mov w0, wzr + hint #29 + ret +.Lfunc_end77: + .size insert_data_list, .Lfunc_end77-insert_data_list + // -- End function + .globl List_remove_node // -- Begin function List_remove_node + .p2align 2 + .type List_remove_node,@function +List_remove_node: // @List_remove_node +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + stp x22, x21, [sp, #16] // 16-byte Folded Spill + adrp x22, p_data_block_list_table + ldr x8, [x22, :lo12:p_data_block_list_table] + // kill: def $w1 killed $w1 def $x1 + and x9, x1, #0xffff + mov w10, #6 + stp x20, x19, [sp, #32] // 16-byte Folded Spill + madd x20, x9, x10, x8 + mov x21, x20 + ldrsh w8, [x21, #2]! + mov x19, x0 + mov x29, sp + cmn w8, #1 // =1 + b.ne .LBB78_3 +// %bb.1: + ldr x8, [x19] + cmp x20, x8 + b.eq .LBB78_3 +// %bb.2: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_remove_node + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_remove_node + mov w2, #372 + bl sftl_printk +.LBB78_3: + ldr x9, [x19] + ldrh w8, [x20] + cmp x20, x9 + b.eq .LBB78_6 +// %bb.4: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB78_8 +// %bb.5: + ldr x9, [x22, :lo12:p_data_block_list_table] + ldrh w10, [x21] + mov w11, #6 + madd x8, x8, x11, x9 + strh w10, [x8, #2] + ldrh w9, [x21] + ldr x8, [x22, :lo12:p_data_block_list_table] + ldrh w10, [x20] + mul x9, x9, x11 + strh w10, [x8, x9] + b .LBB78_11 +.LBB78_6: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB78_10 +// %bb.7: + ldr x10, [x22, :lo12:p_data_block_list_table] + mov w11, #6 + madd x8, x8, x11, x10 + str x8, [x19] + strh w9, [x8, #2] + b .LBB78_11 +.LBB78_8: + ldrh w8, [x21] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB78_11 +// %bb.9: + ldr x10, [x22, :lo12:p_data_block_list_table] + mov w11, #6 + mul x8, x8, x11 + strh w9, [x10, x8] + b .LBB78_11 +.LBB78_10: + str xzr, [x19] +.LBB78_11: + mov w8, #65535 + strh w8, [x20] + strh w8, [x21] + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldp x22, x21, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end78: + .size List_remove_node, .Lfunc_end78-List_remove_node + // -- End function + .globl List_pop_index_node // -- Begin function List_pop_index_node + .p2align 2 + .type List_pop_index_node,@function +List_pop_index_node: // @List_pop_index_node +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + ldr x8, [x0] + str x23, [sp, #16] // 8-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x29, sp + cbz x8, .LBB79_11 +// %bb.1: + adrp x20, p_data_block_list_table + ldr x9, [x20, :lo12:p_data_block_list_table] + mov x19, x0 + tst w1, #0xffff + mov x12, x8 + b.eq .LBB79_5 +// %bb.2: + mov w10, #65535 + mov w11, #6 + mov x12, x8 +.LBB79_3: // =>This Inner Loop Header: Depth=1 + ldrh w13, [x12] + cmp x13, x10 + b.eq .LBB79_5 +// %bb.4: // in Loop: Header=BB79_3 Depth=1 + sub w1, w1, #1 // =1 + tst w1, #0xffff + madd x12, x13, x11, x9 + b.ne .LBB79_3 +.LBB79_5: + sub x10, x12, x9 + mov x11, #-6148914691236517206 + movk x11, #43691 + asr x10, x10, #1 + mul x21, x10, x11 + and x10, x21, #0xffff + mov w11, #6 + madd x22, x10, x11, x9 + mov x23, x22 + ldrsh w9, [x23, #2]! + cmn w9, #1 // =1 + b.ne .LBB79_8 +// %bb.6: + cmp x22, x8 + b.eq .LBB79_8 +// %bb.7: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_remove_node + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_remove_node + mov w2, #372 + bl sftl_printk + ldr x8, [x19] +.LBB79_8: + ldrh w9, [x22] + cmp x22, x8 + b.eq .LBB79_12 +// %bb.9: + mov w8, #65535 + cmp w9, w8 + b.eq .LBB79_14 +// %bb.10: + ldr x8, [x20, :lo12:p_data_block_list_table] + ldrh w10, [x23] + mov w11, #6 + madd x8, x9, x11, x8 + strh w10, [x8, #2] + ldrh w9, [x23] + ldr x8, [x20, :lo12:p_data_block_list_table] + ldrh w10, [x22] + mul x9, x9, x11 + strh w10, [x8, x9] + b .LBB79_17 +.LBB79_11: + mov w0, #65535 + b .LBB79_18 +.LBB79_12: + mov w8, #65535 + cmp w9, w8 + b.eq .LBB79_16 +// %bb.13: + ldr x10, [x20, :lo12:p_data_block_list_table] + mov w11, #6 + madd x9, x9, x11, x10 + str x9, [x19] + strh w8, [x9, #2] + b .LBB79_17 +.LBB79_14: + ldrh w8, [x23] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB79_17 +// %bb.15: + ldr x10, [x20, :lo12:p_data_block_list_table] + mov w11, #6 + mul x8, x8, x11 + strh w9, [x10, x8] + b .LBB79_17 +.LBB79_16: + str xzr, [x19] +.LBB79_17: + mov w8, #65535 + and w0, w21, #0xffff + strh w8, [x22] + strh w8, [x23] +.LBB79_18: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end79: + .size List_pop_index_node, .Lfunc_end79-List_pop_index_node + // -- End function + .globl List_pop_head_node // -- Begin function List_pop_head_node + .p2align 2 + .type List_pop_head_node,@function +List_pop_head_node: // @List_pop_head_node +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + mov w1, wzr + mov x29, sp + bl List_pop_index_node + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end80: + .size List_pop_head_node, .Lfunc_end80-List_pop_head_node + // -- End function + .globl List_update_data_list // -- Begin function List_update_data_list + .p2align 2 + .type List_update_data_list,@function +List_update_data_list: // @List_update_data_list +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + adrp x8, g_active_superblock + ldrh w8, [x8, :lo12:g_active_superblock] + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + cmp w8, w0, uxth + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + mov x29, sp + b.eq .LBB81_25 +// %bb.1: + adrp x8, g_buffer_superblock + ldrh w8, [x8, :lo12:g_buffer_superblock] + mov w19, w0 + cmp w8, w0, uxth + b.eq .LBB81_25 +// %bb.2: + adrp x8, g_gc_temp_superblock + ldrh w8, [x8, :lo12:g_gc_temp_superblock] + cmp w8, w19, uxth + b.eq .LBB81_25 +// %bb.3: + adrp x20, p_data_block_list_table + ldr x8, [x20, :lo12:p_data_block_list_table] + adrp x21, p_data_block_list_head + ldr x9, [x21, :lo12:p_data_block_list_head] + and x22, x19, #0xffff + mov w10, #6 + madd x25, x22, x10, x8 + cmp x25, x9 + b.eq .LBB81_25 +// %bb.4: + adrp x23, p_valid_page_count_table + ldr x9, [x23, :lo12:p_valid_page_count_table] + mov w24, #6 + madd x28, x22, x24, x8 + mov w10, #65535 + ldrh w8, [x9, x22, lsl #1] + ldrh w27, [x28, #2]! + ldrh w9, [x28, #2] + mul w8, w9, w8 + cmp w9, #0 // =0 + csinv w26, w8, wzr, ne + cmp w27, w10 + b.ne .LBB81_9 +// %bb.5: + ldrsh w8, [x25] + mov w27, #65535 + cmn w8, #1 // =1 + b.ne .LBB81_9 +// %bb.6: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_update_data_list + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_update_data_list + mov w2, #463 + bl sftl_printk + ldrh w8, [x28] + cmp w8, w27 + mov w27, w8 + b.ne .LBB81_9 +// %bb.7: + ldrsh w8, [x25] + cmn w8, #1 // =1 + b.eq .LBB81_25 +// %bb.8: + mov w27, #65535 +.LBB81_9: + ldr x8, [x20, :lo12:p_data_block_list_table] + ldr x9, [x23, :lo12:p_valid_page_count_table] + umaddl x10, w27, w24, x8 + ldrh w9, [x9, w27, uxtw #1] + ldrh w10, [x10, #4] + mul w9, w10, w9 + cmp w10, #0 // =0 + csinv w9, w9, wzr, ne + cmp w26, w9 + b.hs .LBB81_25 +// %bb.10: + mov w9, #6 + madd x22, x22, x9, x8 + mov x23, x22 + ldrsh w8, [x23, #2]! + ldr x9, [x21, :lo12:p_data_block_list_head] + cmn w8, #1 // =1 + b.ne .LBB81_13 +// %bb.11: + cmp x22, x9 + b.eq .LBB81_13 +// %bb.12: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_remove_node + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_remove_node + mov w2, #372 + bl sftl_printk + ldr x9, [x21, :lo12:p_data_block_list_head] +.LBB81_13: + ldrh w8, [x22] + cmp x22, x9 + b.eq .LBB81_16 +// %bb.14: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB81_18 +// %bb.15: + ldr x9, [x20, :lo12:p_data_block_list_table] + ldrh w10, [x23] + mov w11, #6 + madd x8, x8, x11, x9 + strh w10, [x8, #2] + ldrh w9, [x23] + ldr x8, [x20, :lo12:p_data_block_list_table] + ldrh w10, [x22] + mul x9, x9, x11 + strh w10, [x8, x9] + b .LBB81_21 +.LBB81_16: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB81_20 +// %bb.17: + ldr x10, [x20, :lo12:p_data_block_list_table] + mov w11, #6 + madd x8, x8, x11, x10 + str x8, [x21, :lo12:p_data_block_list_head] + strh w9, [x8, #2] + b .LBB81_21 +.LBB81_18: + ldrh w8, [x23] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB81_21 +// %bb.19: + ldr x10, [x20, :lo12:p_data_block_list_table] + mov w11, #6 + mul x8, x8, x11 + strh w9, [x10, x8] + b .LBB81_21 +.LBB81_20: + str xzr, [x21, :lo12:p_data_block_list_head] +.LBB81_21: + mov w8, #65535 + strh w8, [x22] + strh w8, [x23] + adrp x20, g_num_data_superblocks + ldrh w8, [x20, :lo12:g_num_data_superblocks] + cbnz w8, .LBB81_23 +// %bb.22: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_update_data_list + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_update_data_list + mov w2, #474 + bl sftl_printk + ldrh w8, [x20, :lo12:g_num_data_superblocks] +.LBB81_23: + sub w8, w8, #1 // =1 + mov w0, w19 + strh w8, [x20, :lo12:g_num_data_superblocks] + bl insert_data_list + ldrh w8, [x20, :lo12:g_num_data_superblocks] + adrp x9, c_ftl_nand_data_blks_per_plane + ldrh w9, [x9, :lo12:c_ftl_nand_data_blks_per_plane] + add w8, w8, #1 // =1 + strh w8, [x20, :lo12:g_num_data_superblocks] + cmp w9, w8, uxth + b.hs .LBB81_25 +// %bb.24: + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + mov w2, #214 + bl sftl_printk +.LBB81_25: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end81: + .size List_update_data_list, .Lfunc_end81-List_update_data_list + // -- End function + .globl load_l2p_region // -- Begin function load_l2p_region + .p2align 2 + .type load_l2p_region,@function +load_l2p_region: // @load_l2p_region +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + stp x24, x23, [sp, #64] // 16-byte Folded Spill + adrp x24, c_ftl_nand_map_region_num + ldrh w8, [x24, :lo12:c_ftl_nand_map_region_num] + stp x20, x19, [sp, #96] // 16-byte Folded Spill + and w20, w0, #0xffff + stp x22, x21, [sp, #80] // 16-byte Folded Spill + mov w19, w0 + cmp w8, w20 + mov w22, w1 + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + add x29, sp, #16 // =16 + b.hs .LBB82_2 +// %bb.1: + adrp x0, .L.str.78 + adrp x1, .L__func__.load_l2p_region + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.load_l2p_region + mov w2, #485 + bl sftl_printk +.LBB82_2: + adrp x25, p_map_region_ppn_table + ldr x8, [x25, :lo12:p_map_region_ppn_table] + and x9, x19, #0xffff + ldr w21, [x8, x9, lsl #2] + cbz w21, .LBB82_6 +// %bb.3: + adrp x26, p_l2p_ram_map + ldr x8, [x26, :lo12:p_l2p_ram_map] + adrp x23, req_sys + add x23, x23, :lo12:req_sys + adrp x9, p_sys_spare_buf + str w21, [x23, #4] + add x8, x8, w22, uxth #4 + ldr x8, [x8, #8] + ldr x9, [x9, :lo12:p_sys_spare_buf] + mov w1, #1 + mov x0, x23 + and x22, x22, #0xffff + stp x8, x9, [x23, #8] + bl FlashReadPages + ldr x28, [x23, #16] + ldrh w8, [x28, #8] + cmp w8, w19, uxth + b.ne .LBB82_7 +// %bb.4: + adrp x8, req_sys + ldr w8, [x8, :lo12:req_sys] + cmp w8, #256 // =256 + b.ne .LBB82_15 +// %bb.5: + adrp x0, .L.str.90 + add x0, x0, :lo12:.L.str.90 + mov w1, w20 + mov w2, w21 + bl sftl_printk + ldr x8, [x26, :lo12:p_l2p_ram_map] + adrp x0, gL2pMapInfo + add x0, x0, :lo12:gL2pMapInfo + mov w1, w20 + add x8, x8, x22, lsl #4 + ldr x2, [x8, #8] + bl FtlMapWritePage + b .LBB82_15 +.LBB82_6: + adrp x20, p_l2p_ram_map + ldr x8, [x20, :lo12:p_l2p_ram_map] + // kill: def $w22 killed $w22 killed $x22 def $x22 + and x9, x22, #0xffff + lsl x21, x9, #4 + adrp x10, c_ftl_nand_byte_pre_page + add x8, x8, x21 + ldr x0, [x8, #8] + ldrh w2, [x10, :lo12:c_ftl_nand_byte_pre_page] + mov w1, #255 + bl memset + ldr x8, [x20, :lo12:p_l2p_ram_map] + strh w19, [x8, x21] + ldr x8, [x20, :lo12:p_l2p_ram_map] + add x8, x8, x21 + str wzr, [x8, #4] + b .LBB82_18 +.LBB82_7: + adrp x0, .L.str.87 + add x0, x0, :lo12:.L.str.87 + mov w1, w20 + mov w2, w21 + str x22, [sp, #8] // 8-byte Folded Spill + bl sftl_printk + adrp x8, req_sys+16 + ldr x20, [x8, :lo12:req_sys+16] + adrp x0, .L.str.116 + adrp x1, .L.str.88 + add x0, x0, :lo12:.L.str.116 + add x1, x1, :lo12:.L.str.88 + mov x2, x20 + mov w3, wzr + bl sftl_printk + ldr w1, [x20] + adrp x21, .L.str.117 + add x21, x21, :lo12:.L.str.117 + mov x0, x21 + bl sftl_printk + ldr w1, [x20, #4] + mov x0, x21 + bl sftl_printk + ldr w1, [x20, #8] + mov x0, x21 + bl sftl_printk + ldr w1, [x20, #12] + mov x0, x21 + bl sftl_printk + adrp x0, .L.str.120 + add x0, x0, :lo12:.L.str.120 + bl sftl_printk + ldrh w8, [x24, :lo12:c_ftl_nand_map_region_num] + cbz x8, .LBB82_14 +// %bb.8: + ldr x21, [x25, :lo12:p_map_region_ppn_table] + adrp x22, .L.str.116 + adrp x23, .L.str.89 + adrp x24, .L.str.117 + adrp x25, .L.str.120 + mov x20, xzr + mov w27, wzr + lsl x26, x8, #2 + add x22, x22, :lo12:.L.str.116 + add x23, x23, :lo12:.L.str.89 + add x24, x24, :lo12:.L.str.117 + add x25, x25, :lo12:.L.str.120 + b .LBB82_11 +.LBB82_9: // in Loop: Header=BB82_11 Depth=1 + ldr w1, [x21, x20] + mov x0, x24 + bl sftl_printk + add w27, w27, #1 // =1 + cmp w27, #16 // =16 + b.hs .LBB82_13 +.LBB82_10: // in Loop: Header=BB82_11 Depth=1 + add x20, x20, #4 // =4 + cmp x26, x20 + b.eq .LBB82_14 +.LBB82_11: // =>This Inner Loop Header: Depth=1 + cbnz w27, .LBB82_9 +// %bb.12: // in Loop: Header=BB82_11 Depth=1 + mov x0, x22 + mov x1, x23 + mov x2, x21 + mov w3, w20 + bl sftl_printk + b .LBB82_9 +.LBB82_13: // in Loop: Header=BB82_11 Depth=1 + mov x0, x25 + bl sftl_printk + mov w27, wzr + b .LBB82_10 +.LBB82_14: + adrp x0, .L.str.120 + add x0, x0, :lo12:.L.str.120 + bl sftl_printk + ldr x22, [sp, #8] // 8-byte Folded Reload + adrp x26, p_l2p_ram_map +.LBB82_15: + ldrh w8, [x28, #8] + cmp w8, w19, uxth + b.eq .LBB82_17 +// %bb.16: + adrp x0, .L.str.78 + adrp x1, .L__func__.load_l2p_region + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.load_l2p_region + mov w2, #508 + bl sftl_printk +.LBB82_17: + ldr x8, [x26, :lo12:p_l2p_ram_map] + lsl x9, x22, #4 + add x8, x8, x9 + str wzr, [x8, #4] + ldr x8, [x26, :lo12:p_l2p_ram_map] + strh w19, [x8, x9] +.LBB82_18: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.Lfunc_end82: + .size load_l2p_region, .Lfunc_end82-load_l2p_region + // -- End function + .globl rknand_print_hex // -- Begin function rknand_print_hex + .p2align 2 + .type rknand_print_hex,@function +rknand_print_hex: // @rknand_print_hex +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + mov x29, sp + cbz w3, .LBB83_12 +// %bb.1: + adrp x23, .L.str.116 + adrp x26, .L.str.117 + adrp x27, .L.str.119 + mov w19, w2 + mov x20, x1 + mov x21, x0 + mov w22, wzr + mov x28, xzr + mov w25, wzr + mov w24, w3 + add x23, x23, :lo12:.L.str.116 + add x26, x26, :lo12:.L.str.117 + add x27, x27, :lo12:.L.str.119 + b .LBB83_5 +.LBB83_2: // in Loop: Header=BB83_5 Depth=1 + ldrb w1, [x20, x28] + mov x0, x27 +.LBB83_3: // in Loop: Header=BB83_5 Depth=1 + bl sftl_printk + add w25, w25, #1 // =1 + cmp w25, #16 // =16 + b.hs .LBB83_11 +.LBB83_4: // in Loop: Header=BB83_5 Depth=1 + add x28, x28, #1 // =1 + cmp x24, x28 + add w22, w22, w19 + b.eq .LBB83_12 +.LBB83_5: // =>This Inner Loop Header: Depth=1 + cbz w25, .LBB83_9 +// %bb.6: // in Loop: Header=BB83_5 Depth=1 + cmp w19, #2 // =2 + b.eq .LBB83_10 +.LBB83_7: // in Loop: Header=BB83_5 Depth=1 + cmp w19, #4 // =4 + b.ne .LBB83_2 +// %bb.8: // in Loop: Header=BB83_5 Depth=1 + ldr w1, [x20, x28, lsl #2] + mov x0, x26 + b .LBB83_3 +.LBB83_9: // in Loop: Header=BB83_5 Depth=1 + mov x0, x23 + mov x1, x21 + mov x2, x20 + mov w3, w22 + bl sftl_printk + cmp w19, #2 // =2 + b.ne .LBB83_7 +.LBB83_10: // in Loop: Header=BB83_5 Depth=1 + ldrh w1, [x20, x28, lsl #1] + adrp x0, .L.str.118 + add x0, x0, :lo12:.L.str.118 + b .LBB83_3 +.LBB83_11: // in Loop: Header=BB83_5 Depth=1 + adrp x0, .L.str.120 + add x0, x0, :lo12:.L.str.120 + bl sftl_printk + mov w25, wzr + b .LBB83_4 +.LBB83_12: + adrp x0, .L.str.120 + add x0, x0, :lo12:.L.str.120 + bl sftl_printk + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end83: + .size rknand_print_hex, .Lfunc_end83-rknand_print_hex + // -- End function + .globl FtlMapWritePage // -- Begin function FtlMapWritePage + .p2align 2 + .type FtlMapWritePage,@function +FtlMapWritePage: // @FtlMapWritePage +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + adrp x26, req_sys+4 + adrp x24, req_sys + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + mov x19, x2 + mov w20, w1 + mov x21, x0 + mov w9, wzr + mov w27, w1 + adrp x28, g_totle_l2p_write_count + adrp x25, c_ftl_nand_page_pre_slc_blk + add x26, x26, :lo12:req_sys+4 + adrp x22, p_sys_spare_buf + adrp x23, c_ftl_nand_byte_pre_page + add x24, x24, :lo12:req_sys + stp x29, x30, [sp, #16] // 16-byte Folded Spill + add x29, sp, #16 // =16 +.LBB84_1: // =>This Loop Header: Depth=1 + // Child Loop BB84_3 Depth 2 + // Child Loop BB84_12 Depth 3 + stur w9, [x29, #-4] // 4-byte Folded Spill + b .LBB84_3 +.LBB84_2: // in Loop: Header=BB84_3 Depth=2 + str wzr, [x21, #56] +.LBB84_3: // Parent Loop BB84_1 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB84_12 Depth 3 + ldr w8, [x28, :lo12:g_totle_l2p_write_count] + add w8, w8, #1 // =1 + str w8, [x28, :lo12:g_totle_l2p_write_count] + ldrh w8, [x25, :lo12:c_ftl_nand_page_pre_slc_blk] + ldrh w9, [x21, #2] + sub w8, w8, #1 // =1 + cmp w8, w9 + b.le .LBB84_5 +// %bb.4: // in Loop: Header=BB84_3 Depth=2 + ldrh w8, [x21] + mov w9, #65535 + cmp w8, w9 + b.ne .LBB84_6 +.LBB84_5: // in Loop: Header=BB84_3 Depth=2 + mov x0, x21 + bl Ftl_write_map_blk_to_last_page + ldrh w8, [x21] +.LBB84_6: // in Loop: Header=BB84_3 Depth=2 + ldr x9, [x21, #16] + ldrh w9, [x9, w8, uxtw #1] + cbnz w9, .LBB84_8 +// %bb.7: // in Loop: Header=BB84_3 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlMapWritePage + mov w2, #700 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlMapWritePage + bl sftl_printk + ldrh w8, [x21] +.LBB84_8: // in Loop: Header=BB84_3 Depth=2 + ldrh w9, [x21, #10] + cmp w8, w9 + b.lo .LBB84_10 +// %bb.9: // in Loop: Header=BB84_3 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlMapWritePage + mov w2, #701 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlMapWritePage + bl sftl_printk + ldrh w8, [x21] +.LBB84_10: // in Loop: Header=BB84_3 Depth=2 + ldr x9, [x21, #16] + ldr x10, [x22, :lo12:p_sys_spare_buf] + ldrh w9, [x9, w8, uxtw #1] + ldrh w8, [x21, #2] + stur x19, [x26, #4] + stur x10, [x26, #12] + orr w8, w8, w9, lsl #10 + str w8, [x26] + stp xzr, xzr, [x10] + ldur x8, [x26, #12] + ldr w10, [x21, #48] + strh w20, [x8, #8] + str w10, [x8, #4] + ldrh w10, [x21, #4] + strh w9, [x8, #2] + strh w10, [x8] + ldrh w9, [x23, :lo12:c_ftl_nand_byte_pre_page] + mov w10, #42982 + movk w10, #18374, lsl #16 + cbz x9, .LBB84_13 +// %bb.11: // in Loop: Header=BB84_3 Depth=2 + ldur x11, [x26, #4] + mov w10, #42982 + movk w10, #18374, lsl #16 +.LBB84_12: // Parent Loop BB84_1 Depth=1 + // Parent Loop BB84_3 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrb w12, [x11], #1 + lsr w13, w10, #2 + add w13, w13, w10, lsl #5 + subs x9, x9, #1 // =1 + add w12, w13, w12 + eor w10, w12, w10 + b.ne .LBB84_12 +.LBB84_13: // in Loop: Header=BB84_3 Depth=2 + mov w1, #1 + mov w2, #1 + mov x0, x24 + str w10, [x8, #12] + bl FlashProgPages + ldrh w8, [x21, #2] + add w8, w8, #1 // =1 + strh w8, [x21, #2] + ldp w8, w1, [x24] + cmn w8, #1 // =1 + b.eq .LBB84_17 +// %bb.14: // in Loop: Header=BB84_3 Depth=2 + ldr x8, [x21, #40] + str w1, [x8, x27, lsl #2] + ldrh w8, [x21, #2] + cmp w8, #1 // =1 + b.eq .LBB84_2 +// %bb.15: // in Loop: Header=BB84_3 Depth=2 + adrp x8, req_sys + ldr w8, [x8, :lo12:req_sys] + cmp w8, #256 // =256 + b.eq .LBB84_2 +// %bb.16: // in Loop: Header=BB84_3 Depth=2 + ldr w9, [x21, #56] + cbnz w9, .LBB84_2 + b .LBB84_22 +.LBB84_17: // in Loop: Header=BB84_1 Depth=1 + adrp x0, .L.str.92 + add x0, x0, :lo12:.L.str.92 + bl sftl_printk + ldrh w8, [x21, #2] + cmp w8, #2 // =2 + b.hi .LBB84_19 +// %bb.18: // in Loop: Header=BB84_1 Depth=1 + ldrh w8, [x25, :lo12:c_ftl_nand_page_pre_slc_blk] + sub w8, w8, #1 // =1 + strh w8, [x21, #2] +.LBB84_19: // in Loop: Header=BB84_1 Depth=1 + ldur w9, [x29, #-4] // 4-byte Folded Reload + and w8, w9, #0xffff + cmp w8, #3 // =3 + b.hs .LBB84_25 +// %bb.20: // in Loop: Header=BB84_1 Depth=1 + ldr w8, [x21, #52] + add w9, w9, #1 // =1 + cbz w8, .LBB84_1 +.LBB84_21: // =>This Inner Loop Header: Depth=1 + b .LBB84_21 +.LBB84_22: + cmn w8, #1 // =1 + b.ne .LBB84_24 +// %bb.23: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlMapWritePage + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlMapWritePage + mov w2, #745 + bl sftl_printk +.LBB84_24: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.LBB84_25: + adrp x8, req_sys+4 + ldr w1, [x8, :lo12:req_sys+4] + adrp x0, .L.str.93 + add x0, x0, :lo12:.L.str.93 + mov w2, #4 + bl sftl_printk +.LBB84_26: // =>This Inner Loop Header: Depth=1 + b .LBB84_26 +.Lfunc_end84: + .size FtlMapWritePage, .Lfunc_end84-FtlMapWritePage + // -- End function + .globl ftl_free_no_use_map_blk // -- Begin function ftl_free_no_use_map_blk + .p2align 2 + .type ftl_free_no_use_map_blk,@function +ftl_free_no_use_map_blk: // @ftl_free_no_use_map_blk +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + ldrh w8, [x0, #10] + ldp x20, x22, [x0, #32] + ldr x21, [x0, #16] + mov x19, x0 + lsl x2, x8, #1 + mov x0, x20 + mov w1, wzr + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + mov x29, sp + bl memset + ldrh w10, [x19, #6] + cbz w10, .LBB85_11 +// %bb.1: + ldrh w9, [x19, #10] + mov x8, xzr + mov w11, w9 + b .LBB85_4 +.LBB85_2: // in Loop: Header=BB85_4 Depth=1 + ldrh w10, [x19, #6] + mov w11, w9 +.LBB85_3: // in Loop: Header=BB85_4 Depth=1 + add x8, x8, #1 // =1 + cmp x8, w10, uxth + b.hs .LBB85_11 +.LBB85_4: // =>This Loop Header: Depth=1 + // Child Loop BB85_7 Depth 2 + tst w11, #0xffff + b.eq .LBB85_10 +// %bb.5: // in Loop: Header=BB85_4 Depth=1 + ldr w10, [x22, x8, lsl #2] + mov x11, xzr + b .LBB85_7 +.LBB85_6: // in Loop: Header=BB85_7 Depth=2 + add x11, x11, #1 // =1 + cmp x11, w9, uxth + b.hs .LBB85_2 +.LBB85_7: // Parent Loop BB85_4 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w12, [x21, x11, lsl #1] + lsr w13, w10, #10 + cmp w12, w13, uxth + b.ne .LBB85_6 +// %bb.8: // in Loop: Header=BB85_7 Depth=2 + cbz w12, .LBB85_6 +// %bb.9: // in Loop: Header=BB85_7 Depth=2 + lsl x9, x11, #1 + ldrh w12, [x20, x9] + add w12, w12, #1 // =1 + strh w12, [x20, x9] + ldrh w9, [x19, #10] + b .LBB85_6 +.LBB85_10: // in Loop: Header=BB85_4 Depth=1 + mov w11, wzr + b .LBB85_3 +.LBB85_11: + adrp x8, c_ftl_nand_page_pre_slc_blk + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_slc_blk] + ldrh w9, [x19] + strh w8, [x20, x9, lsl #1] + ldrh w8, [x19, #10] + cbz w8, .LBB85_23 +// %bb.12: + ldrh w9, [x20], #2 + adrp x26, gSysFreeQueue + mov x23, xzr + mov w22, wzr + mov w11, #65535 + adrp x27, g_totle_sys_slc_erase_count + add x26, x26, :lo12:gSysFreeQueue + mov w24, w9 +.LBB85_13: // =>This Inner Loop Header: Depth=1 + and w10, w24, #0xffff + cmp w10, w9, uxth + b.ls .LBB85_15 +// %bb.14: // in Loop: Header=BB85_13 Depth=1 + ldrh w10, [x21, x23, lsl #1] + cmp w10, #0 // =0 + csel w24, w24, w9, eq + csel w22, w22, w23, eq +.LBB85_15: // in Loop: Header=BB85_13 Depth=1 + tst w9, #0xffff + b.ne .LBB85_21 +// %bb.16: // in Loop: Header=BB85_13 Depth=1 + ldrh w25, [x21, x23, lsl #1] + cbz w25, .LBB85_21 +// %bb.17: // in Loop: Header=BB85_13 Depth=1 + cmp w25, w11 + b.eq .LBB85_20 +// %bb.18: // in Loop: Header=BB85_13 Depth=1 + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + cmp w8, #1024 // =1024 + b.eq .LBB85_20 +// %bb.19: // in Loop: Header=BB85_13 Depth=1 + adrp x12, req_erase + ldr x8, [x12, :lo12:req_erase] + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + lsl w11, w25, #10 + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + str w11, [x8, #4] + ldr x0, [x12, :lo12:req_erase] + udiv w8, w25, w9 + msub w8, w8, w9, w25 + mov w2, #1 + udiv w28, w8, w10 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x28, #1 + mov w11, #65535 + ldrh w10, [x8, x9] + add w10, w10, #1 // =1 + strh w10, [x8, x9] + ldr w8, [x27, :lo12:g_totle_sys_slc_erase_count] + ldrh w9, [x26, #6] + ldrh w10, [x26, #4] + add w8, w8, #1 // =1 + add w9, w9, #1 // =1 + str w8, [x27, :lo12:g_totle_sys_slc_erase_count] + add x8, x26, x10, lsl #1 + add w10, w10, #1 // =1 + strh w9, [x26, #6] + strh w25, [x8, #8] + and w8, w10, #0x3ff + strh w8, [x26, #4] +.LBB85_20: // in Loop: Header=BB85_13 Depth=1 + strh wzr, [x21, x23, lsl #1] + ldrh w9, [x19, #8] + ldrh w8, [x19, #10] + sub w9, w9, #1 // =1 + strh w9, [x19, #8] +.LBB85_21: // in Loop: Header=BB85_13 Depth=1 + add x10, x23, #1 // =1 + cmp x10, w8, uxth + b.hs .LBB85_24 +// %bb.22: // in Loop: Header=BB85_13 Depth=1 + ldrh w9, [x20, x23, lsl #1] + mov x23, x10 + b .LBB85_13 +.LBB85_23: + mov w22, wzr +.LBB85_24: + and w0, w22, #0xffff + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end85: + .size ftl_free_no_use_map_blk, .Lfunc_end85-ftl_free_no_use_map_blk + // -- End function + .globl ftl_map_blk_alloc_new_blk // -- Begin function ftl_map_blk_alloc_new_blk + .p2align 2 + .type ftl_map_blk_alloc_new_blk,@function +ftl_map_blk_alloc_new_blk: // @ftl_map_blk_alloc_new_blk +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + ldrh w8, [x0, #10] + stp x24, x23, [sp, #16] // 16-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x29, sp + cbz x8, .LBB86_5 +// %bb.1: + ldr x22, [x0, #16] + mov x19, x0 + mov x21, xzr +.LBB86_2: // =>This Inner Loop Header: Depth=1 + ldrh w9, [x22, x21, lsl #1] + cbz w9, .LBB86_7 +// %bb.3: // in Loop: Header=BB86_2 Depth=1 + add x21, x21, #1 // =1 + cmp x21, x8 + b.lo .LBB86_2 +// %bb.4: + cmp w8, w21, uxth + b.hi .LBB86_6 +.LBB86_5: + adrp x0, .L.str.78 + adrp x1, .L__func__.ftl_map_blk_alloc_new_blk + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.ftl_map_blk_alloc_new_blk + mov w2, #578 + bl sftl_printk +.LBB86_6: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldp x24, x23, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.LBB86_7: + adrp x23, gSysFreeQueue+6 + ldrh w8, [x23, :lo12:gSysFreeQueue+6] + mov w24, #65535 + cbz w8, .LBB86_11 +// %bb.8: + adrp x9, gSysFreeQueue + add x9, x9, :lo12:gSysFreeQueue + ldrh w10, [x9, #2] + sub w8, w8, #1 // =1 + mov w2, #1 + add x11, x9, x10, lsl #1 + ldrh w20, [x11, #8] + strh w8, [x9, #6] + adrp x8, req_erase + ldr x11, [x8, :lo12:req_erase] + add w10, w10, #1 // =1 + and w10, w10, #0x3ff + strh w10, [x9, #2] + lsl w9, w20, #10 + str w9, [x11, #4] + ldr x0, [x8, :lo12:req_erase] + bl FlashEraseBlocks + adrp x8, g_totle_sys_slc_erase_count + ldr w9, [x8, :lo12:g_totle_sys_slc_erase_count] + cmp w20, w24 + add w9, w9, #1 // =1 + str w9, [x8, :lo12:g_totle_sys_slc_erase_count] + b.eq .LBB86_12 +// %bb.9: + cbz w20, .LBB86_12 +// %bb.10: + strh w20, [x22, x21, lsl #1] + ldr w9, [x19, #48] + ldrh w10, [x19, #8] + ldrh w8, [x19, #10] + strh wzr, [x19, #2] + add w9, w9, #1 // =1 + add w10, w10, #1 // =1 + strh w21, [x19] + str w9, [x19, #48] + strh w10, [x19, #8] + cmp w8, w21, uxth + b.ls .LBB86_5 + b .LBB86_6 +.LBB86_11: + mov w20, #65535 +.LBB86_12: + ldrh w2, [x23, :lo12:gSysFreeQueue+6] + adrp x0, .L.str.86 + add x0, x0, :lo12:.L.str.86 + mov w1, w20 + bl sftl_printk +.LBB86_13: // =>This Inner Loop Header: Depth=1 + b .LBB86_13 +.Lfunc_end86: + .size ftl_map_blk_alloc_new_blk, .Lfunc_end86-ftl_map_blk_alloc_new_blk + // -- End function + .globl ftl_map_blk_gc // -- Begin function ftl_map_blk_gc + .p2align 2 + .type ftl_map_blk_gc,@function +ftl_map_blk_gc: // @ftl_map_blk_gc +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + ldr x20, [x0, #16] + ldr x26, [x0, #40] + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + mov x29, sp + mov x19, x0 + bl ftl_free_no_use_map_blk + ldrh w8, [x19, #10] + ldrh w9, [x19, #8] + adrp x24, c_ftl_nand_page_pre_slc_blk + sub w8, w8, #5 // =5 + cmp w8, w9 + b.gt .LBB87_20 +// %bb.1: + and w8, w0, #0xffff + ldrh w25, [x20, w8, uxtw #1] + cbz w25, .LBB87_20 +// %bb.2: + ldr w9, [x19, #52] + cbnz w9, .LBB87_20 +// %bb.3: + mov w9, #1 + str w9, [x19, #52] + strh wzr, [x20, x8, lsl #1] + ldrh w8, [x19, #8] + sub w8, w8, #1 // =1 + strh w8, [x19, #8] + ldrh w8, [x19, #2] + ldrh w9, [x24, :lo12:c_ftl_nand_page_pre_slc_blk] + cmp w8, w9 + b.lo .LBB87_5 +// %bb.4: + mov x0, x19 + bl ftl_map_blk_alloc_new_blk +.LBB87_5: + ldrh w8, [x19, #6] + cbz w8, .LBB87_15 +// %bb.6: + adrp x21, req_sys + mov x20, xzr + adrp x27, p_sys_data_buf_1 + add x21, x21, :lo12:req_sys + adrp x28, p_sys_spare_buf + adrp x22, req_sys + b .LBB87_8 +.LBB87_7: // in Loop: Header=BB87_8 Depth=1 + add x20, x20, #1 // =1 + cmp x20, w8, uxth + b.hs .LBB87_15 +.LBB87_8: // =>This Inner Loop Header: Depth=1 + ldr w9, [x26, x20, lsl #2] + cmp w25, w9, lsr #10 + b.ne .LBB87_7 +// %bb.9: // in Loop: Header=BB87_8 Depth=1 + ldr x8, [x27, :lo12:p_sys_data_buf_1] + ldr x23, [x28, :lo12:p_sys_spare_buf] + mov w1, #1 + mov x0, x21 + stp x8, x23, [x21, #8] + ldr w8, [x26, x20, lsl #2] + str w8, [x21, #4] + bl FlashReadPages + ldrh w8, [x23, #8] + cmp x20, x8 + b.eq .LBB87_11 +// %bb.10: // in Loop: Header=BB87_8 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.ftl_map_blk_gc + mov w2, #611 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.ftl_map_blk_gc + bl sftl_printk +.LBB87_11: // in Loop: Header=BB87_8 Depth=1 + ldr w8, [x22, :lo12:req_sys] + cmn w8, #1 // =1 + b.eq .LBB87_23 +// %bb.12: // in Loop: Header=BB87_8 Depth=1 + ldrh w8, [x23, #8] + cmp x20, x8 + b.ne .LBB87_23 +// %bb.13: // in Loop: Header=BB87_8 Depth=1 + ldrh w8, [x23] + ldrh w9, [x19, #4] + cmp w8, w9 + b.ne .LBB87_23 +// %bb.14: // in Loop: Header=BB87_8 Depth=1 + adrp x8, req_sys+8 + ldr x2, [x8, :lo12:req_sys+8] + mov x0, x19 + mov w1, w20 + bl FtlMapWritePage + ldrh w8, [x19, #6] + b .LBB87_7 +.LBB87_15: + cbz w25, .LBB87_19 +// %bb.16: + mov w8, #65535 + cmp w25, w8 + b.eq .LBB87_19 +// %bb.17: + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + cmp w8, #1024 // =1024 + b.eq .LBB87_19 +// %bb.18: + adrp x9, req_erase + ldr x10, [x9, :lo12:req_erase] + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x11, c_ftl_nand_planes_per_die + lsl w12, w25, #10 + ldrh w11, [x11, :lo12:c_ftl_nand_planes_per_die] + str w12, [x10, #4] + ldr x0, [x9, :lo12:req_erase] + udiv w9, w25, w8 + msub w8, w9, w8, w25 + mov w2, #1 + udiv w20, w8, w11 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x20, #1 + adrp x11, g_totle_sys_slc_erase_count + ldrh w10, [x8, x9] + add w10, w10, #1 // =1 + strh w10, [x8, x9] + adrp x9, gSysFreeQueue + ldr w8, [x11, :lo12:g_totle_sys_slc_erase_count] + add x9, x9, :lo12:gSysFreeQueue + ldrh w10, [x9, #6] + ldrh w12, [x9, #4] + add w8, w8, #1 // =1 + str w8, [x11, :lo12:g_totle_sys_slc_erase_count] + add w8, w10, #1 // =1 + strh w8, [x9, #6] + add x8, x9, x12, lsl #1 + add w10, w12, #1 // =1 + strh w25, [x8, #8] + and w8, w10, #0x3ff + strh w8, [x9, #4] +.LBB87_19: + str wzr, [x19, #52] +.LBB87_20: + ldrh w8, [x19, #2] + ldrh w9, [x24, :lo12:c_ftl_nand_page_pre_slc_blk] + cmp w8, w9 + b.lo .LBB87_22 +// %bb.21: + mov x0, x19 + bl ftl_map_blk_alloc_new_blk +.LBB87_22: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.LBB87_23: + str wzr, [x26, x20, lsl #2] +.LBB87_24: // =>This Inner Loop Header: Depth=1 + b .LBB87_24 +.Lfunc_end87: + .size ftl_map_blk_gc, .Lfunc_end87-ftl_map_blk_gc + // -- End function + .globl Ftl_write_map_blk_to_last_page // -- Begin function Ftl_write_map_blk_to_last_page + .p2align 2 + .type Ftl_write_map_blk_to_last_page,@function +Ftl_write_map_blk_to_last_page: // @Ftl_write_map_blk_to_last_page +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + ldrh w8, [x0] + stp x22, x21, [sp, #32] // 16-byte Folded Spill + ldr x22, [x0, #16] + mov w9, #65535 + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x19, x0 + cmp x8, x9 + str x23, [sp, #16] // 8-byte Folded Spill + mov x29, sp + b.eq .LBB88_11 +// %bb.1: + ldrh w22, [x22, x8, lsl #1] + ldrh w8, [x19, #2] + adrp x23, p_sys_data_buf + adrp x10, p_sys_spare_buf + ldr x11, [x23, :lo12:p_sys_data_buf] + ldr x20, [x10, :lo12:p_sys_spare_buf] + adrp x9, req_sys+4 + add x9, x9, :lo12:req_sys+4 + orr w8, w8, w22, lsl #10 + ldr x21, [x19, #40] + str w8, [x9] + stur x11, [x9, #4] + stur x20, [x9, #12] + ldr w8, [x19, #48] + mov w9, #64245 + strh w9, [x20, #8] + mov w1, #255 + str w8, [x20, #4] + ldrh w8, [x19, #4] + strh w22, [x20, #2] + strh w8, [x20] + adrp x8, c_ftl_nand_page_pre_slc_blk + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_slc_blk] + ldr x0, [x23, :lo12:p_sys_data_buf] + lsl x2, x8, #3 + bl memset + ldrh w10, [x19, #6] + cbz w10, .LBB88_6 +// %bb.2: + mov x8, xzr + mov w9, wzr + b .LBB88_4 +.LBB88_3: // in Loop: Header=BB88_4 Depth=1 + add x8, x8, #1 // =1 + cmp x8, w10, uxth + b.hs .LBB88_6 +.LBB88_4: // =>This Inner Loop Header: Depth=1 + ldr w11, [x21, x8, lsl #2] + cmp w22, w11, lsr #10 + b.ne .LBB88_3 +// %bb.5: // in Loop: Header=BB88_4 Depth=1 + ldr x10, [x23, :lo12:p_sys_data_buf] + add w9, w9, #1 // =1 + and w11, w9, #0xffff + lsl w12, w11, #1 + str w8, [x10, w12, uxtw #2] + ldr w10, [x21, x8, lsl #2] + ldr x12, [x23, :lo12:p_sys_data_buf] + mov w13, #1 + bfi w13, w11, #1, #16 + str w10, [x12, w13, uxtw #2] + ldrh w10, [x19, #6] + b .LBB88_3 +.LBB88_6: + adrp x8, c_ftl_nand_byte_pre_page + ldrh w9, [x8, :lo12:c_ftl_nand_byte_pre_page] + mov w8, #42982 + movk w8, #18374, lsl #16 + cbz x9, .LBB88_9 +// %bb.7: + adrp x10, req_sys+8 + ldr x10, [x10, :lo12:req_sys+8] +.LBB88_8: // =>This Inner Loop Header: Depth=1 + ldrb w11, [x10], #1 + lsr w12, w8, #2 + add w12, w12, w8, lsl #5 + subs x9, x9, #1 // =1 + add w11, w12, w11 + eor w8, w11, w8 + b.ne .LBB88_8 +.LBB88_9: + adrp x0, req_sys + add x0, x0, :lo12:req_sys + mov w1, #1 + mov w2, #1 + str w8, [x20, #12] + bl FlashProgPages + ldrh w8, [x19, #2] + mov x0, x19 + add w8, w8, #1 // =1 + strh w8, [x19, #2] + bl ftl_map_blk_gc +.LBB88_10: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.LBB88_11: + ldrh w8, [x19, #8] + cbz w8, .LBB88_13 +// %bb.12: + adrp x0, .L.str.78 + adrp x1, .L__func__.Ftl_write_map_blk_to_last_page + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.Ftl_write_map_blk_to_last_page + mov w2, #641 + bl sftl_printk + ldrh w8, [x19, #8] + add w8, w8, #1 // =1 + b .LBB88_14 +.LBB88_13: + mov w8, #1 +.LBB88_14: + strh w8, [x19, #8] + adrp x21, gSysFreeQueue+6 + ldrh w8, [x21, :lo12:gSysFreeQueue+6] + mov w23, #65535 + cbz w8, .LBB88_18 +// %bb.15: + adrp x9, gSysFreeQueue + add x9, x9, :lo12:gSysFreeQueue + ldrh w10, [x9, #2] + sub w8, w8, #1 // =1 + mov w2, #1 + add x11, x9, x10, lsl #1 + ldrh w20, [x11, #8] + strh w8, [x9, #6] + adrp x8, req_erase + ldr x11, [x8, :lo12:req_erase] + add w10, w10, #1 // =1 + and w10, w10, #0x3ff + strh w10, [x9, #2] + lsl w9, w20, #10 + str w9, [x11, #4] + ldr x0, [x8, :lo12:req_erase] + bl FlashEraseBlocks + adrp x8, g_totle_sys_slc_erase_count + ldr w9, [x8, :lo12:g_totle_sys_slc_erase_count] + cmp w20, w23 + add w9, w9, #1 // =1 + str w9, [x8, :lo12:g_totle_sys_slc_erase_count] + b.eq .LBB88_19 +// %bb.16: + cbz w20, .LBB88_19 +// %bb.17: + strh w20, [x22] + ldr w8, [x19, #48] + str wzr, [x19] + add w8, w8, #1 // =1 + str w8, [x19, #48] + b .LBB88_10 +.LBB88_18: + mov w20, #65535 +.LBB88_19: + ldrh w2, [x21, :lo12:gSysFreeQueue+6] + adrp x0, .L.str.86 + add x0, x0, :lo12:.L.str.86 + mov w1, w20 + bl sftl_printk +.LBB88_20: // =>This Inner Loop Header: Depth=1 + b .LBB88_20 +.Lfunc_end88: + .size Ftl_write_map_blk_to_last_page, .Lfunc_end88-Ftl_write_map_blk_to_last_page + // -- End function + .globl js_hash // -- Begin function js_hash + .p2align 2 + .type js_hash,@function +js_hash: // @js_hash +// %bb.0: + hint #25 + mov x8, x0 + mov w0, #42982 + movk w0, #18374, lsl #16 + cbz w1, .LBB89_3 +// %bb.1: + mov w9, w1 +.LBB89_2: // =>This Inner Loop Header: Depth=1 + ldrb w10, [x8], #1 + lsr w11, w0, #2 + add w11, w11, w0, lsl #5 + subs x9, x9, #1 // =1 + add w10, w11, w10 + eor w0, w10, w0 + b.ne .LBB89_2 +.LBB89_3: + hint #29 + ret +.Lfunc_end89: + .size js_hash, .Lfunc_end89-js_hash + // -- End function + .globl flush_l2p_region // -- Begin function flush_l2p_region + .p2align 2 + .type flush_l2p_region,@function +flush_l2p_region: // @flush_l2p_region +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + adrp x19, p_l2p_ram_map + ldr x8, [x19, :lo12:p_l2p_ram_map] + // kill: def $w0 killed $w0 def $x0 + and x9, x0, #0xffff + lsl x20, x9, #4 + adrp x0, gL2pMapInfo + add x8, x8, x20 + ldrh w1, [x8] + ldr x2, [x8, #8] + add x0, x0, :lo12:gL2pMapInfo + mov x29, sp + bl FtlMapWritePage + ldr x8, [x19, :lo12:p_l2p_ram_map] + mov w0, wzr + add x8, x8, x20 + ldr w9, [x8, #4] + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end90: + .size flush_l2p_region, .Lfunc_end90-flush_l2p_region + // -- End function + .globl select_l2p_ram_region // -- Begin function select_l2p_ram_region + .p2align 2 + .type select_l2p_ram_region,@function +select_l2p_ram_region: // @select_l2p_ram_region +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x8, :lo12:c_ftl_nand_l2pmap_ram_region_num] + str x19, [sp, #16] // 8-byte Folded Spill + mov x29, sp + cbz x8, .LBB91_11 +// %bb.1: + adrp x9, p_l2p_ram_map + ldr x10, [x9, :lo12:p_l2p_ram_map] + mov x19, xzr +.LBB91_2: // =>This Inner Loop Header: Depth=1 + ldrsh w11, [x10] + cmn w11, #1 // =1 + b.eq .LBB91_14 +// %bb.3: // in Loop: Header=BB91_2 Depth=1 + add x19, x19, #1 // =1 + cmp x8, x19 + add x10, x10, #16 // =16 + b.ne .LBB91_2 +// %bb.4: + ldr x11, [x9, :lo12:p_l2p_ram_map] + mov x10, xzr + mov w12, #-2147483648 + mov w19, w8 + add x11, x11, #4 // =4 +.LBB91_5: // =>This Inner Loop Header: Depth=1 + ldr w13, [x11], #16 + cmp w13, #0 // =0 + cset w14, ge + cmp w13, w12 + cset w15, lo + tst w14, w15 + csel w19, w10, w19, ne + add x10, x10, #1 // =1 + csel w12, w13, w12, ne + cmp x8, x10 + b.ne .LBB91_5 +// %bb.6: + cmp w8, w19, uxth + b.hi .LBB91_14 +// %bb.7: + ldr x11, [x9, :lo12:p_l2p_ram_map] + adrp x9, g_l2p_last_update_region_id + ldrh w9, [x9, :lo12:g_l2p_last_update_region_id] + mov x10, xzr + add x11, x11, #4 // =4 + mov w12, #-1 + mov w19, w8 + b .LBB91_9 +.LBB91_8: // in Loop: Header=BB91_9 Depth=1 + add x10, x10, #1 // =1 + cmp x8, x10 + add x11, x11, #16 // =16 + b.eq .LBB91_12 +.LBB91_9: // =>This Inner Loop Header: Depth=1 + ldr w13, [x11] + cmp w13, w12 + b.hs .LBB91_8 +// %bb.10: // in Loop: Header=BB91_9 Depth=1 + ldurh w14, [x11, #-4] + cmp w9, w14 + csel w19, w19, w10, eq + csel w12, w12, w13, eq + b .LBB91_8 +.LBB91_11: + mov w19, wzr + b .LBB91_13 +.LBB91_12: + cmp w8, w19, uxth + b.hi .LBB91_14 +.LBB91_13: + adrp x0, .L.str.78 + adrp x1, .L__func__.select_l2p_ram_region + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.select_l2p_ram_region + mov w2, #796 + bl sftl_printk +.LBB91_14: + mov w0, w19 + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end91: + .size select_l2p_ram_region, .Lfunc_end91-select_l2p_ram_region + // -- End function + .globl FtlWriteDump_data // -- Begin function FtlWriteDump_data + .p2align 2 + .type FtlWriteDump_data,@function +FtlWriteDump_data: // @FtlWriteDump_data +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #48] // 16-byte Folded Spill + add x29, sp, #48 // =48 + adrp x9, g_active_superblock+4 + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + stur x8, [x29, #-8] + add x9, x9, :lo12:g_active_superblock+4 + ldrh w8, [x9] + cbz w8, .LBB92_3 +// %bb.1: + ldrb w9, [x9, #4] + cbnz w9, .LBB92_3 +// %bb.2: + adrp x9, g_active_superblock+7 + adrp x10, c_ftl_nand_page_pre_blk + ldrb w9, [x9, :lo12:g_active_superblock+7] + ldrh w10, [x10, :lo12:c_ftl_nand_page_pre_blk] + mul w9, w10, w9 + cmp w9, w8 + b.ne .LBB92_6 +.LBB92_3: + adrp x8, g_active_superblock+10 + strb wzr, [x8, :lo12:g_active_superblock+10] +.LBB92_4: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB92_16 +// %bb.5: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x29, x30, [sp, #48] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.LBB92_6: + adrp x21, g_active_superblock+10 + ldrb w8, [x21, :lo12:g_active_superblock+10] + cbnz w8, .LBB92_4 +// %bb.7: + adrp x8, g_MaxLpn + ldr w8, [x8, :lo12:g_MaxLpn] + adrp x9, c_ftl_nand_planes_num + ldrh w20, [x9, :lo12:c_ftl_nand_planes_num] + sub x1, x29, #12 // =12 + sub w19, w8, #1 // =1 + mov w0, w19 + mov w2, wzr + bl log2phys + ldur w9, [x29, #-12] + adrp x8, p_sys_data_buf + adrp x10, p_sys_spare_buf + ldr x11, [x8, :lo12:p_sys_data_buf] + ldr x22, [x10, :lo12:p_sys_spare_buf] + cmn w9, #1 // =1 + str w19, [sp, #24] + str w9, [sp, #4] + stp x11, x22, [sp, #8] + str wzr, [x22, #4] + b.eq .LBB92_9 +// %bb.8: + mov x0, sp + mov w1, #1 + bl FlashReadPages + b .LBB92_10 +.LBB92_9: + ldr x0, [x8, :lo12:p_sys_data_buf] + adrp x8, c_ftl_nand_byte_pre_page + ldrh w2, [x8, :lo12:c_ftl_nand_byte_pre_page] + mov w1, #255 + bl memset +.LBB92_10: + mov w8, #61589 + strh w8, [x22] + cbz w20, .LBB92_15 +// %bb.11: + adrp x8, g_active_superblock+4 + ldrh w8, [x8, :lo12:g_active_superblock+4] + cbz w8, .LBB92_15 +// %bb.12: + lsl w8, w20, #2 + mov w9, #1 + adrp x20, g_active_superblock + add x20, x20, :lo12:g_active_superblock + sub w23, w9, w8 + adrp x24, g_GlobalDataVersion +.LBB92_13: // =>This Inner Loop Header: Depth=1 + ldr w8, [sp, #4] + mov x0, x20 + stp w19, w8, [x22, #8] + ldrh w8, [x20] + strh w8, [x22, #2] + bl get_new_active_ppa + ldr w8, [x24, :lo12:g_GlobalDataVersion] + str w0, [sp, #4] + mov x0, sp + mov w1, #1 + add w9, w8, #1 // =1 + cmn w9, #1 // =1 + str w8, [x22, #4] + csinc w8, wzr, w8, eq + mov w2, wzr + str w8, [x24, :lo12:g_GlobalDataVersion] + bl FlashProgPages + ldrh w0, [x20] + bl decrement_vpc_count + cbz w23, .LBB92_15 +// %bb.14: // in Loop: Header=BB92_13 Depth=1 + ldrh w8, [x20, #4] + add w23, w23, #1 // =1 + cbnz w8, .LBB92_13 +.LBB92_15: + mov w8, #1 + strb w8, [x21, :lo12:g_active_superblock+10] + b .LBB92_4 +.LBB92_16: + bl __stack_chk_fail +.Lfunc_end92: + .size FtlWriteDump_data, .Lfunc_end92-FtlWriteDump_data + // -- End function + .globl Ftl_save_ext_data // -- Begin function Ftl_save_ext_data + .p2align 2 + .type Ftl_save_ext_data,@function +Ftl_save_ext_data: // @Ftl_save_ext_data +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + adrp x8, g_sys_ext_data + ldr w8, [x8, :lo12:g_sys_ext_data] + mov w9, #19539 + movk w9, #18004, lsl #16 + mov x29, sp + cmp w8, w9 + b.ne .LBB93_2 +// %bb.1: + adrp x9, g_totle_write_sector + adrp x10, g_totle_read_sector + ldr w9, [x9, :lo12:g_totle_write_sector] + ldr w10, [x10, :lo12:g_totle_read_sector] + adrp x2, g_sys_ext_data + add x2, x2, :lo12:g_sys_ext_data + adrp x11, g_totle_gc_page_count + adrp x12, g_totle_write_page_count + adrp x13, g_totle_read_page_count + stp w9, w10, [x2, #88] + ldr w10, [x11, :lo12:g_totle_gc_page_count] + ldr w11, [x12, :lo12:g_totle_write_page_count] + ldr w12, [x13, :lo12:g_totle_read_page_count] + mov w8, #86 + movk w8, #20480, lsl #16 + adrp x14, g_totle_l2p_write_count + adrp x15, g_totle_slc_erase_count + adrp x9, g_totle_sys_slc_erase_count + stp w8, w10, [x2, #4] + ldr w10, [x14, :lo12:g_totle_l2p_write_count] + stp w11, w12, [x2, #12] + ldr w12, [x15, :lo12:g_totle_slc_erase_count] + ldr w9, [x9, :lo12:g_totle_sys_slc_erase_count] + adrp x8, g_totle_discard_page_count + adrp x11, g_totle_cache_write_count + str w10, [x2, #20] + adrp x10, g_max_erase_count + stp w12, w9, [x2, #28] + adrp x9, g_min_erase_count + ldr w8, [x8, :lo12:g_totle_discard_page_count] + ldr w11, [x11, :lo12:g_totle_cache_write_count] + ldr w10, [x10, :lo12:g_max_erase_count] + ldr w9, [x9, :lo12:g_min_erase_count] + mov w1, #1 + mov w0, wzr + stp w8, w11, [x2, #36] + stp w10, w9, [x2, #44] + bl FtlVendorPartWrite +.LBB93_2: + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end93: + .size Ftl_save_ext_data, .Lfunc_end93-Ftl_save_ext_data + // -- End function + .globl FtlUpdateVaildLpn // -- Begin function FtlUpdateVaildLpn + .p2align 2 + .type FtlUpdateVaildLpn,@function +FtlUpdateVaildLpn: // @FtlUpdateVaildLpn +// %bb.0: + hint #25 + adrp x9, FtlUpdateVaildLpnCount + ldrh w8, [x9, :lo12:FtlUpdateVaildLpnCount] + add w10, w8, #1 // =1 + strh w10, [x9, :lo12:FtlUpdateVaildLpnCount] + cbnz w0, .LBB94_2 +// %bb.1: + cmp w8, #5 // =5 + b.lo .LBB94_7 +.LBB94_2: + adrp x8, c_ftl_nand_data_blks_per_plane + ldrh w8, [x8, :lo12:c_ftl_nand_data_blks_per_plane] + strh wzr, [x9, :lo12:FtlUpdateVaildLpnCount] + adrp x9, g_VaildLpn + str wzr, [x9, :lo12:g_VaildLpn] + cbz x8, .LBB94_7 +// %bb.3: + adrp x11, p_valid_page_count_table + ldr x11, [x11, :lo12:p_valid_page_count_table] + mov w10, wzr + mov w12, #65535 + b .LBB94_5 +.LBB94_4: // in Loop: Header=BB94_5 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB94_7 +.LBB94_5: // =>This Inner Loop Header: Depth=1 + ldrh w13, [x11] + cmp w13, w12 + b.eq .LBB94_4 +// %bb.6: // in Loop: Header=BB94_5 Depth=1 + add w10, w10, w13 + str w10, [x9, :lo12:g_VaildLpn] + b .LBB94_4 +.LBB94_7: + hint #29 + ret +.Lfunc_end94: + .size FtlUpdateVaildLpn, .Lfunc_end94-FtlUpdateVaildLpn + // -- End function + .globl FtlMapBlkWriteDump_data // -- Begin function FtlMapBlkWriteDump_data + .p2align 2 + .type FtlMapBlkWriteDump_data,@function +FtlMapBlkWriteDump_data: // @FtlMapBlkWriteDump_data +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + ldr w8, [x0, #56] + stp x20, x19, [sp, #16] // 16-byte Folded Spill + mov x29, sp + cbz w8, .LBB95_5 +// %bb.1: + ldrh w8, [x0, #6] + str wzr, [x0, #56] + adrp x10, p_sys_data_buf_1 + adrp x11, p_sys_spare_buf + mov x19, x0 + ldr x9, [x0, #40] + ldr x0, [x10, :lo12:p_sys_data_buf_1] + ldr x10, [x11, :lo12:p_sys_spare_buf] + adrp x11, req_sys+4 + add x11, x11, :lo12:req_sys+4 + sub w20, w8, #1 // =1 + stur x0, [x11, #4] + stur x10, [x11, #12] + and x8, x20, #0xffff + ldr w8, [x9, x8, lsl #2] + str w8, [x11] + cbz w8, .LBB95_3 +// %bb.2: + adrp x0, req_sys + add x0, x0, :lo12:req_sys + mov w1, #1 + bl FlashReadPages + b .LBB95_4 +.LBB95_3: + adrp x8, c_ftl_nand_byte_pre_page + ldrh w2, [x8, :lo12:c_ftl_nand_byte_pre_page] + mov w1, #255 + bl memset +.LBB95_4: + adrp x8, req_sys+8 + ldr x2, [x8, :lo12:req_sys+8] + and w1, w20, #0xffff + mov x0, x19 + bl FtlMapWritePage +.LBB95_5: + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end95: + .size FtlMapBlkWriteDump_data, .Lfunc_end95-FtlMapBlkWriteDump_data + // -- End function + .globl FtlScanSysBlk // -- Begin function FtlScanSysBlk + .p2align 2 + .type FtlScanSysBlk,@function +FtlScanSysBlk: // @FtlScanSysBlk +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + adrp x8, g_totle_map_block + adrp x19, c_ftl_nand_max_map_blks + adrp x9, p_map_block_ver_table + strh wzr, [x8, :lo12:g_totle_map_block] + ldr w8, [x19, :lo12:c_ftl_nand_max_map_blks] + ldr x0, [x9, :lo12:p_map_block_ver_table] + adrp x9, g_totle_vendor_block + mov w1, wzr + lsl w2, w8, #2 + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + mov x29, sp + strh wzr, [x9, :lo12:g_totle_vendor_block] + bl memset + adrp x9, p_map_block_table + ldr w8, [x19, :lo12:c_ftl_nand_max_map_blks] + ldr x0, [x9, :lo12:p_map_block_table] + mov w1, wzr + lsl w2, w8, #1 + bl memset + adrp x19, c_ftl_nand_max_vendor_blks + adrp x9, p_vendor_block_ver_table + ldrh w8, [x19, :lo12:c_ftl_nand_max_vendor_blks] + ldr x0, [x9, :lo12:p_vendor_block_ver_table] + mov w1, wzr + lsl x2, x8, #2 + bl memset + adrp x9, p_vendor_block_table + ldrh w8, [x19, :lo12:c_ftl_nand_max_vendor_blks] + ldr x0, [x9, :lo12:p_vendor_block_table] + mov w1, wzr + lsl x2, x8, #1 + bl memset + adrp x8, c_ftl_nand_data_blks_per_plane + adrp x9, c_ftl_nand_blk_pre_plane + ldrh w19, [x8, :lo12:c_ftl_nand_data_blks_per_plane] + ldrh w8, [x9, :lo12:c_ftl_nand_blk_pre_plane] + adrp x10, gSysInfo + add x10, x10, :lo12:gSysInfo + mov x9, #-1 + cmp w19, w8 + stp x9, x9, [x10] + b.hs .LBB96_80 +// %bb.1: + adrp x8, c_ftl_nand_planes_num + adrp x21, c_ftl_nand_planes_per_die + adrp x20, c_ftl_nand_blks_per_die + adrp x22, req_read + b .LBB96_3 +.LBB96_2: // in Loop: Header=BB96_3 Depth=1 + adrp x8, c_ftl_nand_blk_pre_plane + ldrh w8, [x8, :lo12:c_ftl_nand_blk_pre_plane] + add w19, w19, #1 // =1 + cmp w8, w19, uxth + adrp x8, c_ftl_nand_planes_num + b.ls .LBB96_80 +.LBB96_3: // =>This Loop Header: Depth=1 + // Child Loop BB96_6 Depth 2 + // Child Loop BB96_12 Depth 2 + // Child Loop BB96_48 Depth 3 + // Child Loop BB96_32 Depth 3 + // Child Loop BB96_40 Depth 3 + // Child Loop BB96_59 Depth 3 + // Child Loop BB96_67 Depth 3 + ldrh w9, [x8, :lo12:c_ftl_nand_planes_num] + cbz w9, .LBB96_2 +// %bb.4: // in Loop: Header=BB96_3 Depth=1 + adrp x16, p_plane_order_table + adrp x17, gBbtInfo + mov x8, xzr + mov w25, wzr + adrp x15, c_ftl_nand_planes_num + add x16, x16, :lo12:p_plane_order_table + add x17, x17, :lo12:gBbtInfo + adrp x18, p_gc_data_buf + adrp x0, p_gc_spare_buf + adrp x1, c_ftl_nand_byte_pre_oob + b .LBB96_6 +.LBB96_5: // in Loop: Header=BB96_6 Depth=2 + add x8, x8, #1 // =1 + cmp x8, w9, uxth + b.hs .LBB96_8 +.LBB96_6: // Parent Loop BB96_3 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrb w10, [x16, x8] + ldrh w11, [x21, :lo12:c_ftl_nand_planes_per_die] + ldrh w12, [x20, :lo12:c_ftl_nand_blks_per_die] + and w13, w10, #0xffff + and w14, w11, #0xffff + udiv w13, w13, w14 + mul w14, w11, w19 + madd w14, w12, w13, w14 + msub w10, w13, w11, w10 + add w11, w14, w10 + and w10, w11, #0xffff + and w13, w12, #0xffff + udiv w13, w10, w13 + add x14, x17, w13, uxtw #3 + ldr x14, [x14, #32] + msub w11, w13, w12, w11 + lsr w12, w11, #3 + and x12, x12, #0x1ffc + ldr w12, [x14, x12] + lsr w11, w12, w11 + tbnz w11, #0, .LBB96_5 +// %bb.7: // in Loop: Header=BB96_6 Depth=2 + ldr x9, [x22, :lo12:req_read] + and x11, x25, #0xffff + lsl x11, x11, #5 + lsl w10, w10, #10 + add x9, x9, x11 + str w10, [x9, #4] + ldr x9, [x22, :lo12:req_read] + ldr x10, [x18, :lo12:p_gc_data_buf] + add x9, x9, x11 + str x10, [x9, #8] + ldrh w9, [x1, :lo12:c_ftl_nand_byte_pre_oob] + and w10, w25, #0xffff + ldr x12, [x0, :lo12:p_gc_spare_buf] + ldr x13, [x22, :lo12:req_read] + mul w9, w9, w10 + add w10, w9, #3 // =3 + cmp w9, #0 // =0 + csel w9, w10, w9, lt + asr w9, w9, #2 + add x9, x12, w9, sxtw #2 + add x10, x13, x11 + str x9, [x10, #16] + ldrh w9, [x15, :lo12:c_ftl_nand_planes_num] + add w25, w25, #1 // =1 + b .LBB96_5 +.LBB96_8: // in Loop: Header=BB96_3 Depth=1 + tst w25, #0xffff + b.eq .LBB96_2 +// %bb.9: // in Loop: Header=BB96_3 Depth=1 + ldr x0, [x22, :lo12:req_read] + and w1, w25, #0xffff + bl FlashReadPages + mov x23, xzr + // kill: def $w25 killed $w25 killed $x25 def $x25 + and x28, x25, #0xffff + b .LBB96_12 +.LBB96_10: // in Loop: Header=BB96_12 Depth=2 + lsr w10, w27, #10 + strh w10, [x9, x8, lsl #1] +.LBB96_11: // in Loop: Header=BB96_12 Depth=2 + add x23, x23, #1 // =1 + cmp x23, x28 + b.eq .LBB96_2 +.LBB96_12: // Parent Loop BB96_3 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB96_48 Depth 3 + // Child Loop BB96_32 Depth 3 + // Child Loop BB96_40 Depth 3 + // Child Loop BB96_59 Depth 3 + // Child Loop BB96_67 Depth 3 + ldr x8, [x22, :lo12:req_read] + add x9, x8, x23, lsl #5 + ldp w10, w27, [x9] + ldr x25, [x9, #16] + cmn w10, #1 // =1 + b.eq .LBB96_46 +.LBB96_13: // in Loop: Header=BB96_12 Depth=2 + adrp x8, g_GlobalSysVersion + ldr w9, [x8, :lo12:g_GlobalSysVersion] + ldr w8, [x25, #4] + cmn w9, #1 // =1 + b.eq .LBB96_15 +// %bb.14: // in Loop: Header=BB96_12 Depth=2 + cmp w9, w8 + b.hi .LBB96_17 +.LBB96_15: // in Loop: Header=BB96_12 Depth=2 + cmn w8, #1 // =1 + b.eq .LBB96_17 +// %bb.16: // in Loop: Header=BB96_12 Depth=2 + add w9, w8, #1 // =1 + adrp x10, g_GlobalSysVersion + str w9, [x10, :lo12:g_GlobalSysVersion] +.LBB96_17: // in Loop: Header=BB96_12 Depth=2 + ldrh w9, [x25] + mov w10, #61633 + cmp w9, w10 + b.gt .LBB96_27 +// %bb.18: // in Loop: Header=BB96_12 Depth=2 + mov w10, #61574 + cmp w9, w10 + b.eq .LBB96_56 +// %bb.19: // in Loop: Header=BB96_12 Depth=2 + mov w10, #61604 + cmp w9, w10 + b.ne .LBB96_11 +// %bb.20: // in Loop: Header=BB96_12 Depth=2 + adrp x9, gSysInfo + ldrsh w9, [x9, :lo12:gSysInfo] + cmn w9, #1 // =1 + b.eq .LBB96_77 +// %bb.21: // in Loop: Header=BB96_12 Depth=2 + adrp x9, gSysInfo+4 + ldrh w24, [x9, :lo12:gSysInfo+4] + mov w9, #65535 + cmp w24, w9 + b.eq .LBB96_25 +// %bb.22: // in Loop: Header=BB96_12 Depth=2 + cbz w24, .LBB96_25 +// %bb.23: // in Loop: Header=BB96_12 Depth=2 + adrp x9, gSysFreeQueue+6 + ldrh w9, [x9, :lo12:gSysFreeQueue+6] + cmp w9, #1024 // =1024 + b.eq .LBB96_25 +// %bb.24: // in Loop: Header=BB96_12 Depth=2 + adrp x12, req_erase + ldr x8, [x12, :lo12:req_erase] + ldrh w9, [x20, :lo12:c_ftl_nand_blks_per_die] + lsl w11, w24, #10 + ldrh w10, [x21, :lo12:c_ftl_nand_planes_per_die] + str w11, [x8, #4] + ldr x0, [x12, :lo12:req_erase] + udiv w8, w24, w9 + msub w8, w8, w9, w24 + mov w2, #1 + udiv w26, w8, w10 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x26, #1 + adrp x11, g_totle_sys_slc_erase_count + adrp x12, gSysFreeQueue + ldrh w10, [x8, x9] + add x12, x12, :lo12:gSysFreeQueue + add w10, w10, #1 // =1 + strh w10, [x8, x9] + ldr w8, [x11, :lo12:g_totle_sys_slc_erase_count] + ldrh w9, [x12, #6] + ldrh w10, [x12, #4] + add w8, w8, #1 // =1 + add w9, w9, #1 // =1 + str w8, [x11, :lo12:g_totle_sys_slc_erase_count] + add x8, x12, x10, lsl #1 + add w10, w10, #1 // =1 + strh w9, [x12, #6] + strh w24, [x8, #8] + and w8, w10, #0x3ff + strh w8, [x12, #4] + ldr w8, [x25, #4] +.LBB96_25: // in Loop: Header=BB96_12 Depth=2 + adrp x9, gSysInfo+8 + ldr w9, [x9, :lo12:gSysInfo+8] + cmp w9, w8 + b.hs .LBB96_79 +// %bb.26: // in Loop: Header=BB96_12 Depth=2 + adrp x10, gSysInfo + add x10, x10, :lo12:gSysInfo + ldrh w8, [x10] + lsr w9, w27, #10 + strh w9, [x10] + strh w8, [x10, #4] + ldr w8, [x25, #4] + b .LBB96_78 +.LBB96_27: // in Loop: Header=BB96_12 Depth=2 + mov w8, #65535 + cmp w9, w8 + b.eq .LBB96_73 +// %bb.28: // in Loop: Header=BB96_12 Depth=2 + mov w8, #61634 + cmp w9, w8 + b.ne .LBB96_11 +// %bb.29: // in Loop: Header=BB96_12 Depth=2 + adrp x24, g_totle_map_block + adrp x26, c_ftl_nand_max_map_blks + ldrh w9, [x24, :lo12:g_totle_map_block] + ldr w11, [x26, :lo12:c_ftl_nand_max_map_blks] + cmp w11, w9 + b.hs .LBB96_31 +// %bb.30: // in Loop: Header=BB96_12 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlScanSysBlk + mov w2, #1232 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlScanSysBlk + bl sftl_printk + ldr w11, [x26, :lo12:c_ftl_nand_max_map_blks] + ldrh w9, [x24, :lo12:g_totle_map_block] +.LBB96_31: // in Loop: Header=BB96_12 Depth=2 + adrp x8, p_map_block_ver_table + ldr x10, [x8, :lo12:p_map_block_ver_table] + mvn w8, w9 + add w8, w11, w8 + sxth w13, w8 + mov w14, w11 +.LBB96_32: // Parent Loop BB96_3 Depth=1 + // Parent Loop BB96_12 Depth=2 + // => This Inner Loop Header: Depth=3 + sub w14, w14, #1 // =1 + sxth w8, w14 + cmp w13, w8 + b.ge .LBB96_43 +// %bb.33: // in Loop: Header=BB96_32 Depth=3 + ldr w12, [x25, #4] + ldr w15, [x10, w8, sxtw #2] + cmp w12, w15 + b.ls .LBB96_32 +// %bb.34: // in Loop: Header=BB96_12 Depth=2 + cmp w11, w9 + b.eq .LBB96_37 +// %bb.35: // in Loop: Header=BB96_12 Depth=2 + ldr w11, [x10] + cbnz w11, .LBB96_37 +// %bb.36: // in Loop: Header=BB96_12 Depth=2 + add w9, w9, #1 // =1 + adrp x11, g_totle_map_block + strh w9, [x11, :lo12:g_totle_map_block] +.LBB96_37: // in Loop: Header=BB96_12 Depth=2 + cbz w8, .LBB96_42 +// %bb.38: // in Loop: Header=BB96_12 Depth=2 + ldr w9, [x10, #4] + adrp x15, p_map_block_table + cmp w8, #1 // =1 + adrp x14, p_map_block_ver_table + str w9, [x10] + ldr x9, [x15, :lo12:p_map_block_table] + ldrh w10, [x9, #2] + strh w10, [x9] + b.eq .LBB96_41 +// %bb.39: // in Loop: Header=BB96_12 Depth=2 + mov w9, #1 +.LBB96_40: // Parent Loop BB96_3 Depth=1 + // Parent Loop BB96_12 Depth=2 + // => This Inner Loop Header: Depth=3 + ldr x10, [x14, :lo12:p_map_block_ver_table] + sxth x11, w9 + add x12, x11, #1 // =1 + add w9, w9, #1 // =1 + ldr w13, [x10, x12, lsl #2] + str w13, [x10, x11, lsl #2] + ldr x10, [x15, :lo12:p_map_block_table] + and w13, w9, #0xffff + cmp w13, w8, uxth + ldrh w12, [x10, x12, lsl #1] + strh w12, [x10, x11, lsl #1] + b.lo .LBB96_40 +.LBB96_41: // in Loop: Header=BB96_12 Depth=2 + ldr w12, [x25, #4] + ldr x10, [x14, :lo12:p_map_block_ver_table] +.LBB96_42: // in Loop: Header=BB96_12 Depth=2 + sxtw x9, w8 + str w12, [x10, x9, lsl #2] + adrp x10, p_map_block_table + ldr x10, [x10, :lo12:p_map_block_table] + lsr w11, w27, #10 + strh w11, [x10, x9, lsl #1] +.LBB96_43: // in Loop: Header=BB96_12 Depth=2 + tbnz w8, #31, .LBB96_11 +// %bb.44: // in Loop: Header=BB96_12 Depth=2 + adrp x9, g_totle_map_block + ldrh w9, [x9, :lo12:g_totle_map_block] + adrp x10, c_ftl_nand_max_map_blks + ldr w10, [x10, :lo12:c_ftl_nand_max_map_blks] + mvn w11, w9 + add w10, w10, w11 + cmp w8, w10, sxth + b.gt .LBB96_11 +// %bb.45: // in Loop: Header=BB96_12 Depth=2 + add w9, w9, #1 // =1 + adrp x10, g_totle_map_block + strh w9, [x10, :lo12:g_totle_map_block] + adrp x10, p_map_block_ver_table + ldr w9, [x25, #4] + ldr x10, [x10, :lo12:p_map_block_ver_table] + // kill: def $w8 killed $w8 killed $x8 def $x8 + and x8, x8, #0xffff + str w9, [x10, x8, lsl #2] + adrp x9, p_map_block_table + ldr x9, [x9, :lo12:p_map_block_table] + b .LBB96_10 +.LBB96_46: // in Loop: Header=BB96_12 Depth=2 + lsl x24, x23, #5 + add x8, x8, x24 + add w9, w27, #1 // =1 + str w9, [x8, #4] + ldr x8, [x22, :lo12:req_read] + mov w1, #1 + add x0, x8, x24 + bl FlashReadPages + ldrsh w8, [x25] + cmn w8, #1 // =1 + b.eq .LBB96_51 +// %bb.47: // in Loop: Header=BB96_12 Depth=2 + mov w26, wzr +.LBB96_48: // Parent Loop BB96_3 Depth=1 + // Parent Loop BB96_12 Depth=2 + // => This Inner Loop Header: Depth=3 + ldr x8, [x22, :lo12:req_read] + ldr w9, [x8, x24] + cmn w9, #1 // =1 + b.ne .LBB96_13 +// %bb.49: // in Loop: Header=BB96_48 Depth=3 + and w9, w26, #0xffff + cmp w9, #14 // =14 + b.hi .LBB96_52 +// %bb.50: // in Loop: Header=BB96_48 Depth=3 + add x8, x8, x24 + ldr w9, [x8, #4] + mov w1, #1 + add w26, w26, #1 // =1 + add w9, w9, #1 // =1 + str w9, [x8, #4] + ldr x8, [x22, :lo12:req_read] + add x0, x8, x24 + bl FlashReadPages + ldrsh w8, [x25] + cmn w8, #1 // =1 + b.ne .LBB96_48 +.LBB96_51: // in Loop: Header=BB96_12 Depth=2 + ldr x8, [x22, :lo12:req_read] + mov w9, #-1 + str w9, [x8, x24] + ldr x8, [x22, :lo12:req_read] + ldr w8, [x8, x24] + cmn w8, #1 // =1 + b.ne .LBB96_13 +.LBB96_52: // in Loop: Header=BB96_12 Depth=2 + ubfx w8, w27, #10, #16 + cbz w8, .LBB96_11 +// %bb.53: // in Loop: Header=BB96_12 Depth=2 + mov w9, #65535 + cmp w8, w9 + b.eq .LBB96_11 +// %bb.54: // in Loop: Header=BB96_12 Depth=2 + adrp x9, gSysFreeQueue+6 + ldrh w9, [x9, :lo12:gSysFreeQueue+6] + cmp w9, #1024 // =1024 + b.eq .LBB96_11 +// %bb.55: // in Loop: Header=BB96_12 Depth=2 + adrp x13, req_erase + ldr x9, [x13, :lo12:req_erase] + ldrh w10, [x20, :lo12:c_ftl_nand_blks_per_die] + and w12, w27, #0x3fffc00 + ldrh w11, [x21, :lo12:c_ftl_nand_planes_per_die] + str w12, [x9, #4] + ldr x0, [x13, :lo12:req_erase] + udiv w9, w8, w10 + msub w8, w9, w10, w8 + mov w2, #1 + lsr w24, w27, #10 + udiv w25, w8, w11 + bl FlashEraseBlocks + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + lsl x9, x25, #1 + adrp x11, g_totle_sys_slc_erase_count + adrp x12, gSysFreeQueue + ldrh w10, [x8, x9] + add x12, x12, :lo12:gSysFreeQueue + add w10, w10, #1 // =1 + strh w10, [x8, x9] + ldr w8, [x11, :lo12:g_totle_sys_slc_erase_count] + ldrh w9, [x12, #6] + ldrh w10, [x12, #4] + add w8, w8, #1 // =1 + add w9, w9, #1 // =1 + str w8, [x11, :lo12:g_totle_sys_slc_erase_count] + add x8, x12, x10, lsl #1 + add w10, w10, #1 // =1 + strh w9, [x12, #6] + strh w24, [x8, #8] + and w8, w10, #0x3ff + strh w8, [x12, #4] + b .LBB96_11 +.LBB96_56: // in Loop: Header=BB96_12 Depth=2 + adrp x8, g_totle_vendor_block + adrp x24, c_ftl_nand_max_vendor_blks + ldrh w10, [x8, :lo12:g_totle_vendor_block] + ldrh w11, [x24, :lo12:c_ftl_nand_max_vendor_blks] + cmp w10, w11 + b.ls .LBB96_58 +// %bb.57: // in Loop: Header=BB96_12 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlScanSysBlk + mov w2, #1273 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlScanSysBlk + mov x26, x8 + bl sftl_printk + ldrh w11, [x24, :lo12:c_ftl_nand_max_vendor_blks] + ldrh w10, [x26, :lo12:g_totle_vendor_block] +.LBB96_58: // in Loop: Header=BB96_12 Depth=2 + adrp x8, p_vendor_block_ver_table + ldr x9, [x8, :lo12:p_vendor_block_ver_table] + mvn w8, w10 + add w13, w8, w11 + mov w8, w11 +.LBB96_59: // Parent Loop BB96_3 Depth=1 + // Parent Loop BB96_12 Depth=2 + // => This Inner Loop Header: Depth=3 + sub w8, w8, #1 // =1 + sxth w8, w8 + cmp w13, w8 + b.ge .LBB96_70 +// %bb.60: // in Loop: Header=BB96_59 Depth=3 + ldr w12, [x25, #4] + ldr w14, [x9, w8, sxtw #2] + cmp w12, w14 + b.ls .LBB96_59 +// %bb.61: // in Loop: Header=BB96_12 Depth=2 + cmp w10, w11 + b.eq .LBB96_64 +// %bb.62: // in Loop: Header=BB96_12 Depth=2 + ldr w11, [x9] + cbnz w11, .LBB96_64 +// %bb.63: // in Loop: Header=BB96_12 Depth=2 + add w10, w10, #1 // =1 + adrp x11, g_totle_vendor_block + strh w10, [x11, :lo12:g_totle_vendor_block] +.LBB96_64: // in Loop: Header=BB96_12 Depth=2 + cbz w8, .LBB96_69 +// %bb.65: // in Loop: Header=BB96_12 Depth=2 + ldr w10, [x9, #4] + adrp x15, p_vendor_block_table + cmp w8, #1 // =1 + adrp x14, p_vendor_block_ver_table + str w10, [x9] + ldr x9, [x15, :lo12:p_vendor_block_table] + ldrh w10, [x9, #2] + strh w10, [x9] + b.eq .LBB96_68 +// %bb.66: // in Loop: Header=BB96_12 Depth=2 + mov w9, #1 +.LBB96_67: // Parent Loop BB96_3 Depth=1 + // Parent Loop BB96_12 Depth=2 + // => This Inner Loop Header: Depth=3 + ldr x10, [x14, :lo12:p_vendor_block_ver_table] + sxth x11, w9 + add x12, x11, #1 // =1 + add w9, w9, #1 // =1 + ldr w13, [x10, x12, lsl #2] + str w13, [x10, x11, lsl #2] + ldr x10, [x15, :lo12:p_vendor_block_table] + and w13, w9, #0xffff + cmp w13, w8, uxth + ldrh w12, [x10, x12, lsl #1] + strh w12, [x10, x11, lsl #1] + b.lo .LBB96_67 +.LBB96_68: // in Loop: Header=BB96_12 Depth=2 + ldr w12, [x25, #4] + ldr x9, [x14, :lo12:p_vendor_block_ver_table] +.LBB96_69: // in Loop: Header=BB96_12 Depth=2 + sxtw x10, w8 + str w12, [x9, x10, lsl #2] + adrp x9, p_vendor_block_table + ldr x9, [x9, :lo12:p_vendor_block_table] + lsr w11, w27, #10 + strh w11, [x9, x10, lsl #1] +.LBB96_70: // in Loop: Header=BB96_12 Depth=2 + tbnz w8, #31, .LBB96_11 +// %bb.71: // in Loop: Header=BB96_12 Depth=2 + adrp x9, g_totle_vendor_block + ldrh w9, [x9, :lo12:g_totle_vendor_block] + adrp x10, c_ftl_nand_max_vendor_blks + ldrh w10, [x10, :lo12:c_ftl_nand_max_vendor_blks] + mvn w11, w9 + add w10, w10, w11 + cmp w8, w10, sxth + b.gt .LBB96_11 +// %bb.72: // in Loop: Header=BB96_12 Depth=2 + add w9, w9, #1 // =1 + adrp x10, g_totle_vendor_block + strh w9, [x10, :lo12:g_totle_vendor_block] + adrp x10, p_vendor_block_ver_table + ldr w9, [x25, #4] + ldr x10, [x10, :lo12:p_vendor_block_ver_table] + // kill: def $w8 killed $w8 killed $x8 def $x8 + and x8, x8, #0xffff + str w9, [x10, x8, lsl #2] + adrp x9, p_vendor_block_table + ldr x9, [x9, :lo12:p_vendor_block_table] + b .LBB96_10 +.LBB96_73: // in Loop: Header=BB96_12 Depth=2 + ubfx w8, w27, #10, #16 + cbz w8, .LBB96_11 +// %bb.74: // in Loop: Header=BB96_12 Depth=2 + mov w9, #65535 + cmp w8, w9 + b.eq .LBB96_11 +// %bb.75: // in Loop: Header=BB96_12 Depth=2 + adrp x8, gSysFreeQueue+6 + ldrh w8, [x8, :lo12:gSysFreeQueue+6] + cmp w8, #1024 // =1024 + b.eq .LBB96_11 +// %bb.76: // in Loop: Header=BB96_12 Depth=2 + adrp x11, gSysFreeQueue + add x11, x11, :lo12:gSysFreeQueue + ldrh w9, [x11, #4] + add w8, w8, #1 // =1 + lsr w10, w27, #10 + strh w8, [x11, #6] + add x8, x11, x9, lsl #1 + add w9, w9, #1 // =1 + strh w10, [x8, #8] + and w8, w9, #0x3ff + strh w8, [x11, #4] + b .LBB96_11 +.LBB96_77: // in Loop: Header=BB96_12 Depth=2 + adrp x10, gSysInfo + lsr w9, w27, #10 + add x10, x10, :lo12:gSysInfo + strh w9, [x10] +.LBB96_78: // in Loop: Header=BB96_12 Depth=2 + str w8, [x10, #8] + b .LBB96_11 +.LBB96_79: // in Loop: Header=BB96_12 Depth=2 + lsr w8, w27, #10 + adrp x9, gSysInfo+4 + strh w8, [x9, :lo12:gSysInfo+4] + b .LBB96_11 +.LBB96_80: + adrp x17, p_map_block_table + ldr x10, [x17, :lo12:p_map_block_table] + adrp x16, c_ftl_nand_max_map_blks + ldr w8, [x16, :lo12:c_ftl_nand_max_map_blks] + adrp x15, g_totle_map_block + ldrh w9, [x10] + cbnz w9, .LBB96_90 +// %bb.81: + ldrh w9, [x15, :lo12:g_totle_map_block] + adrp x18, c_ftl_nand_max_vendor_blks + adrp x0, p_vendor_block_table + cbz w9, .LBB96_91 +// %bb.82: + cbz w8, .LBB96_91 +// %bb.83: + mov w13, wzr + adrp x14, p_map_block_ver_table +.LBB96_84: // =>This Inner Loop Header: Depth=1 + mov w11, w13 + add w13, w13, #1 // =1 + sxth w9, w13 + cmp w8, w9 + b.ls .LBB96_91 +// %bb.85: // in Loop: Header=BB96_84 Depth=1 + ldrh w12, [x10, w9, sxtw #1] + cbz w12, .LBB96_84 +// %bb.86: + cmp w8, w9 + b.ls .LBB96_91 +// %bb.87: + sub w8, w9, w9 + strh w12, [x10, w8, sxtw #1] + ldr x10, [x14, :lo12:p_map_block_ver_table] + sxtw x12, w9 + ldr w13, [x10, x12, lsl #2] + str w13, [x10, w8, sxtw #2] + ldr x8, [x17, :lo12:p_map_block_table] + add w10, w11, #2 // =2 + strh wzr, [x8, x12, lsl #1] + ldr w8, [x16, :lo12:c_ftl_nand_max_map_blks] +.LBB96_88: // =>This Inner Loop Header: Depth=1 + sxth w10, w10 + cmp w8, w10 + b.ls .LBB96_91 +// %bb.89: // in Loop: Header=BB96_88 Depth=1 + ldr x8, [x17, :lo12:p_map_block_table] + sbfiz x11, x10, #1, #16 + sub w13, w10, w9 + ldrh w12, [x8, x11] + strh w12, [x8, w13, sxtw #1] + ldr x8, [x14, :lo12:p_map_block_ver_table] + sxth x12, w10 + add w10, w10, #1 // =1 + ldr w12, [x8, x12, lsl #2] + str w12, [x8, w13, sxtw #2] + ldr x8, [x17, :lo12:p_map_block_table] + strh wzr, [x8, x11] + ldr w8, [x16, :lo12:c_ftl_nand_max_map_blks] + b .LBB96_88 +.LBB96_90: + adrp x18, c_ftl_nand_max_vendor_blks + adrp x0, p_vendor_block_table +.LBB96_91: + ldr x10, [x0, :lo12:p_vendor_block_table] + ldrh w9, [x10] + cbnz w9, .LBB96_102 +// %bb.92: + adrp x9, g_totle_vendor_block + ldrh w9, [x9, :lo12:g_totle_vendor_block] + cbz w9, .LBB96_102 +// %bb.93: + ldrh w12, [x18, :lo12:c_ftl_nand_max_vendor_blks] + cbz w12, .LBB96_102 +// %bb.94: + mov w14, wzr + adrp x17, p_vendor_block_ver_table +.LBB96_95: // =>This Inner Loop Header: Depth=1 + mov w11, w14 + add w14, w14, #1 // =1 + sxth w9, w14 + cmp w9, w12 + b.ge .LBB96_102 +// %bb.96: // in Loop: Header=BB96_95 Depth=1 + ldrh w13, [x10, w9, sxtw #1] + cbz w13, .LBB96_95 +// %bb.97: + cmp w9, w12 + b.ge .LBB96_102 +// %bb.98: + sub w8, w9, w9 + strh w13, [x10, w8, sxtw #1] + ldr x10, [x17, :lo12:p_vendor_block_ver_table] + sxtw x12, w9 + ldr w13, [x10, x12, lsl #2] + str w13, [x10, w8, sxtw #2] + ldr x8, [x0, :lo12:p_vendor_block_table] + strh wzr, [x8, x12, lsl #1] + ldrh w10, [x18, :lo12:c_ftl_nand_max_vendor_blks] + add w8, w11, #2 // =2 +.LBB96_99: // =>This Inner Loop Header: Depth=1 + sxth w8, w8 + cmp w8, w10 + b.ge .LBB96_101 +// %bb.100: // in Loop: Header=BB96_99 Depth=1 + ldr x10, [x0, :lo12:p_vendor_block_table] + sbfiz x11, x8, #1, #16 + sub w13, w8, w9 + ldrh w12, [x10, x11] + strh w12, [x10, w13, sxtw #1] + ldr x10, [x17, :lo12:p_vendor_block_ver_table] + sxth x12, w8 + add w8, w8, #1 // =1 + ldr w12, [x10, x12, lsl #2] + str w12, [x10, w13, sxtw #2] + ldr x10, [x0, :lo12:p_vendor_block_table] + strh wzr, [x10, x11] + ldrh w10, [x18, :lo12:c_ftl_nand_max_vendor_blks] + b .LBB96_99 +.LBB96_101: + ldr w8, [x16, :lo12:c_ftl_nand_max_map_blks] +.LBB96_102: + ldrh w9, [x15, :lo12:g_totle_map_block] + cmp w8, w9 + b.hs .LBB96_104 +// %bb.103: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlScanSysBlk + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlScanSysBlk + mov w2, #1398 + bl sftl_printk +.LBB96_104: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end96: + .size FtlScanSysBlk, .Lfunc_end96-FtlScanSysBlk + // -- End function + .globl FtlLoadEctTbl // -- Begin function FtlLoadEctTbl + .p2align 2 + .type FtlLoadEctTbl,@function +FtlLoadEctTbl: // @FtlLoadEctTbl +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + adrp x19, g_ect_tbl_info_size + adrp x20, gp_ect_tbl_info + ldrh w1, [x19, :lo12:g_ect_tbl_info_size] + ldr x2, [x20, :lo12:gp_ect_tbl_info] + mov w0, #64 + mov x29, sp + bl FtlVendorPartRead + ldr x8, [x20, :lo12:gp_ect_tbl_info] + mov w9, #17221 + movk w9, #16980, lsl #16 + ldr w8, [x8] + cmp w8, w9 + b.eq .LBB97_2 +// %bb.1: + adrp x0, .L.str.75 + adrp x1, .L.str.96 + add x0, x0, :lo12:.L.str.75 + add x1, x1, :lo12:.L.str.96 + bl sftl_printk + ldrh w8, [x19, :lo12:g_ect_tbl_info_size] + ldr x0, [x20, :lo12:gp_ect_tbl_info] + mov w1, wzr + lsl x2, x8, #9 + bl memset +.LBB97_2: + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end97: + .size FtlLoadEctTbl, .Lfunc_end97-FtlLoadEctTbl + // -- End function + .globl FtlLoadSysInfo // -- Begin function FtlLoadSysInfo + .p2align 2 + .type FtlLoadSysInfo,@function +FtlLoadSysInfo: // @FtlLoadSysInfo +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + adrp x11, c_ftl_nand_data_blks_per_plane + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + adrp x25, p_sys_data_buf + adrp x27, p_sys_spare_buf + adrp x12, p_valid_page_count_table + ldrh w11, [x11, :lo12:c_ftl_nand_data_blks_per_plane] + ldr x9, [x25, :lo12:p_sys_data_buf] + ldr x10, [x27, :lo12:p_sys_spare_buf] + ldr x0, [x12, :lo12:p_valid_page_count_table] + adrp x8, req_sys+8 + add x8, x8, :lo12:req_sys+8 + lsl x2, x11, #1 + mov w1, wzr + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + mov x29, sp + stp x9, x10, [x8] + bl memset + adrp x20, gSysInfo + ldrh w0, [x20, :lo12:gSysInfo] + mov w8, #65535 + cmp w0, w8 + b.eq .LBB98_39 +// %bb.1: + mov w26, #19539 + mov w1, #1 + movk w26, #18004, lsl #16 + bl FtlGetLastWrittenPage + add w8, w0, #1 // =1 + adrp x9, gSysInfo+2 + adrp x21, c_ftl_nand_byte_pre_page + strh w8, [x9, :lo12:gSysInfo+2] + tbnz w0, #15, .LBB98_19 +// %bb.2: + ldrh w8, [x20, :lo12:gSysInfo] + adrp x20, req_sys + mov w19, w0 + sxth w24, w0 + add x20, x20, :lo12:req_sys + adrp x22, gSysInfo+4 +.LBB98_3: // =>This Loop Header: Depth=1 + // Child Loop BB98_7 Depth 2 + // Child Loop BB98_11 Depth 3 + sxth w23, w8 + sbfiz w28, w8, #10, #16 + b .LBB98_7 +.LBB98_4: // in Loop: Header=BB98_7 Depth=2 + ldrh w4, [x22, :lo12:gSysInfo+4] + adrp x0, .L.str.97 + adrp x1, .L__func__.FtlLoadSysInfo + add x0, x0, :lo12:.L.str.97 + add x1, x1, :lo12:.L__func__.FtlLoadSysInfo + mov w2, w23 + mov w3, w24 + bl sftl_printk + tst w19, #0xffff + b.eq .LBB98_16 +.LBB98_5: // in Loop: Header=BB98_7 Depth=2 + adrp x8, req_sys + mov w9, #-1 + str w9, [x8, :lo12:req_sys] +.LBB98_6: // in Loop: Header=BB98_7 Depth=2 + sub w8, w19, #1 // =1 + sxth w24, w8 + mov w19, w24 + tbnz w8, #15, .LBB98_19 +.LBB98_7: // Parent Loop BB98_3 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB98_11 Depth 3 + ldr x8, [x25, :lo12:p_sys_data_buf] + orr w9, w28, w24 + mov w1, #1 + mov x0, x20 + str w9, [x20, #4] + str x8, [x20, #8] + bl FlashReadPages + ldr x8, [x20, #16] + ldr w5, [x8, #12] + ldr w8, [x20] + cbz w5, .LBB98_13 +// %bb.8: // in Loop: Header=BB98_7 Depth=2 + cmn w8, #1 // =1 + b.eq .LBB98_13 +// %bb.9: // in Loop: Header=BB98_7 Depth=2 + ldrh w9, [x21, :lo12:c_ftl_nand_byte_pre_page] + mov w6, #42982 + movk w6, #18374, lsl #16 + cbz x9, .LBB98_12 +// %bb.10: // in Loop: Header=BB98_7 Depth=2 + adrp x10, req_sys+8 + ldr x10, [x10, :lo12:req_sys+8] + mov w6, #42982 + movk w6, #18374, lsl #16 +.LBB98_11: // Parent Loop BB98_3 Depth=1 + // Parent Loop BB98_7 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrb w11, [x10], #1 + lsr w12, w6, #2 + add w12, w12, w6, lsl #5 + subs x9, x9, #1 // =1 + add w11, w12, w11 + eor w6, w11, w6 + b.ne .LBB98_11 +.LBB98_12: // in Loop: Header=BB98_7 Depth=2 + cmp w5, w6 + b.ne .LBB98_4 +.LBB98_13: // in Loop: Header=BB98_7 Depth=2 + cmn w8, #1 // =1 + b.eq .LBB98_6 +// %bb.14: // in Loop: Header=BB98_7 Depth=2 + ldr x8, [x25, :lo12:p_sys_data_buf] + ldr w8, [x8] + cmp w8, w26 + b.ne .LBB98_6 +// %bb.15: // in Loop: Header=BB98_7 Depth=2 + ldr x8, [x27, :lo12:p_sys_spare_buf] + ldrsh w8, [x8] + cmn w8, #3932 // =3932 + b.ne .LBB98_6 + b .LBB98_18 +.LBB98_16: // in Loop: Header=BB98_7 Depth=2 + ldrh w8, [x22, :lo12:gSysInfo+4] + cmp w23, w8 + b.eq .LBB98_5 +// %bb.17: // in Loop: Header=BB98_3 Depth=1 + adrp x9, c_ftl_nand_page_pre_slc_blk + ldrh w9, [x9, :lo12:c_ftl_nand_page_pre_slc_blk] + sub w9, w9, #1 // =1 + sxth w24, w9 + mov w19, w24 + tbz w9, #15, .LBB98_3 + b .LBB98_19 +.LBB98_18: + tbz w19, #15, .LBB98_20 +.LBB98_19: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlLoadSysInfo + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlLoadSysInfo + mov w2, #1474 + bl sftl_printk +.LBB98_20: + adrp x19, c_ftl_nand_data_blks_per_plane + ldrh w8, [x19, :lo12:c_ftl_nand_data_blks_per_plane] + ldrh w9, [x21, :lo12:c_ftl_nand_byte_pre_page] + lsl x2, x8, #1 + add x8, x2, #48 // =48 + cmp x8, x9 + b.ls .LBB98_22 +// %bb.21: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlLoadSysInfo + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlLoadSysInfo + mov w2, #1476 + bl sftl_printk + ldrh w8, [x19, :lo12:c_ftl_nand_data_blks_per_plane] + lsl x2, x8, #1 +.LBB98_22: + adrp x8, req_sys+8 + ldr x8, [x8, :lo12:req_sys+8] + adrp x19, g_sys_save_data + add x19, x19, :lo12:g_sys_save_data + adrp x13, p_valid_page_count_table + ldp x9, x10, [x8] + ldr x0, [x13, :lo12:p_valid_page_count_table] + add x1, x8, #48 // =48 + stp x9, x10, [x19] + ldp x9, x10, [x8, #32] + ldp x12, x11, [x8, #16] + stp x9, x10, [x19, #32] + stp x12, x11, [x19, #16] + bl memcpy + ldr w8, [x19] + cmp w8, w26 + b.ne .LBB98_39 +// %bb.23: + adrp x8, g_sys_save_data+8 + add x8, x8, :lo12:g_sys_save_data+8 + adrp x9, c_ftl_nand_die_num + ldrb w10, [x8, #2] + ldrh w9, [x9, :lo12:c_ftl_nand_die_num] + ldrh w8, [x8] + adrp x11, gSysInfo+6 + cmp w9, w10 + strh w8, [x11, :lo12:gSysInfo+6] + b.ne .LBB98_39 +// %bb.24: + adrp x9, c_ftl_nand_max_data_blks + adrp x10, gBbtInfo+6 + adrp x12, c_ftl_nand_page_pre_blk + ldr w9, [x9, :lo12:c_ftl_nand_max_data_blks] + ldrh w10, [x10, :lo12:gBbtInfo+6] + ldrh w12, [x12, :lo12:c_ftl_nand_page_pre_blk] + adrp x11, g_MaxLbn + str w8, [x11, :lo12:g_MaxLbn] + subs w11, w9, w8 + cmp w9, w8 + mul w8, w12, w8 + adrp x9, g_MaxLpn + sub w10, w11, w10 + adrp x11, c_ftl_nand_sec_pre_page + ldrh w11, [x11, :lo12:c_ftl_nand_sec_pre_page] + str w8, [x9, :lo12:g_MaxLpn] + adrp x9, c_ftl_nand_planes_num + ldrh w9, [x9, :lo12:c_ftl_nand_planes_num] + mul w8, w8, w11 + adrp x11, g_MaxLbaSector + str w8, [x11, :lo12:g_MaxLbaSector] + udiv w8, w10, w9 + adrp x9, c_ftl_nand_data_op_blks_per_plane + strh w8, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane] + b.hs .LBB98_26 +// %bb.25: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlLoadSysInfo + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlLoadSysInfo + mov w2, #1498 + bl sftl_printk +.LBB98_26: + adrp x8, g_sys_save_data+11 + add x8, x8, :lo12:g_sys_save_data+11 + ldur w11, [x8, #21] + adrp x13, g_totle_mlc_erase_count + ldurh w14, [x8, #11] + adrp x12, g_gc_temp_superblock + str w11, [x13, :lo12:g_totle_mlc_erase_count] + ldrb w11, [x8, #2] + ldurh w13, [x8, #13] + adrp x10, g_gc_superblock + add x12, x12, :lo12:g_gc_temp_superblock + add x10, x10, :lo12:g_gc_superblock + strh w14, [x12] + mov w14, #65535 + strb w11, [x12, #8] + lsr w11, w13, #6 + strh w11, [x12, #2] + and w11, w13, #0x3f + str w14, [x10] + adrp x13, g_totle_read_page_count + adrp x14, g_totle_slc_erase_count + str wzr, [x13, :lo12:g_totle_read_page_count] + ldrb w13, [x8] + str wzr, [x14, :lo12:g_totle_slc_erase_count] + ldurh w14, [x8, #5] + adrp x9, g_active_superblock + strb w11, [x12, #6] + adrp x12, g_totle_write_page_count + add x9, x9, :lo12:g_active_superblock + str wzr, [x12, :lo12:g_totle_write_page_count] + adrp x12, g_max_erase_count + str wzr, [x12, :lo12:g_max_erase_count] + strb w13, [x9, #8] + lsr w12, w14, #6 + and w13, w14, #0x3f + strb wzr, [x10, #6] + strb wzr, [x10, #8] + adrp x10, g_totle_l2p_write_count + strh w12, [x9, #2] + ldurh w12, [x8, #9] + strb w13, [x9, #6] + ldrb w13, [x8, #1] + str wzr, [x10, :lo12:g_totle_l2p_write_count] + ldurh w10, [x8, #3] + adrp x15, g_buffer_superblock + add x15, x15, :lo12:g_buffer_superblock + adrp x11, g_totle_gc_page_count + str wzr, [x11, :lo12:g_totle_gc_page_count] + adrp x11, g_GlobalSysVersion + strb w13, [x15, #8] + lsr w13, w12, #6 + strh w10, [x9] + ldurh w9, [x8, #7] + ldur w8, [x8, #29] + strh w13, [x15, #2] + ldr w13, [x11, :lo12:g_GlobalSysVersion] + and w12, w12, #0x3f + strb w12, [x15, #6] + adrp x12, g_totle_cache_write_count + cmp w8, w13 + strh w9, [x15] + str wzr, [x12, :lo12:g_totle_cache_write_count] + b.ls .LBB98_28 +// %bb.27: + str w8, [x11, :lo12:g_GlobalSysVersion] +.LBB98_28: + adrp x11, g_sys_save_data+36 + adrp x8, g_GlobalDataVersion + ldr w11, [x11, :lo12:g_sys_save_data+36] + ldr w12, [x8, :lo12:g_GlobalDataVersion] + cmp w11, w12 + b.ls .LBB98_30 +// %bb.29: + str w11, [x8, :lo12:g_GlobalDataVersion] +.LBB98_30: + mov w19, #65535 + cmp w10, w19 + b.eq .LBB98_32 +// %bb.31: + adrp x0, g_active_superblock + add x0, x0, :lo12:g_active_superblock + bl make_superblock + adrp x8, g_buffer_superblock + ldrh w9, [x8, :lo12:g_buffer_superblock] +.LBB98_32: + cmp w9, w19 + b.eq .LBB98_34 +// %bb.33: + adrp x0, g_buffer_superblock + add x0, x0, :lo12:g_buffer_superblock + bl make_superblock +.LBB98_34: + adrp x8, g_gc_temp_superblock + ldrsh w8, [x8, :lo12:g_gc_temp_superblock] + cmn w8, #1 // =1 + b.eq .LBB98_36 +// %bb.35: + adrp x0, g_gc_temp_superblock + add x0, x0, :lo12:g_gc_temp_superblock + bl make_superblock +.LBB98_36: + adrp x8, g_gc_superblock + ldrsh w8, [x8, :lo12:g_gc_superblock] + cmn w8, #1 // =1 + b.eq .LBB98_38 +// %bb.37: + adrp x0, g_gc_superblock + add x0, x0, :lo12:g_gc_superblock + bl make_superblock +.LBB98_38: + mov w0, wzr + b .LBB98_40 +.LBB98_39: + mov w0, #-1 +.LBB98_40: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end98: + .size FtlLoadSysInfo, .Lfunc_end98-FtlLoadSysInfo + // -- End function + .globl FtlMapTblRecovery // -- Begin function FtlMapTblRecovery + .p2align 2 + .type FtlMapTblRecovery,@function +FtlMapTblRecovery: // @FtlMapTblRecovery +// %bb.0: + hint #25 + sub sp, sp, #128 // =128 + stp x20, x19, [sp, #112] // 16-byte Folded Spill + mov x19, x0 + stp x28, x27, [sp, #48] // 16-byte Folded Spill + ldrh w28, [x19, #6] + ldr x0, [x0, #40] + ldp x27, x8, [x19, #16] + stp x22, x21, [sp, #96] // 16-byte Folded Spill + ldrh w22, [x19, #8] + stp x29, x30, [sp, #32] // 16-byte Folded Spill + add x29, sp, #32 // =32 + lsl x2, x28, #2 + mov w1, wzr + stp x26, x25, [sp, #64] // 16-byte Folded Spill + stp x24, x23, [sp, #80] // 16-byte Folded Spill + str x8, [sp, #8] // 8-byte Folded Spill + stur x0, [x29, #-8] // 8-byte Folded Spill + bl memset + adrp x10, p_sys_data_buf + adrp x9, p_sys_spare_buf + ldr x10, [x10, :lo12:p_sys_data_buf] + ldr x21, [x9, :lo12:p_sys_spare_buf] + adrp x8, req_sys+8 + add x8, x8, :lo12:req_sys+8 + mov w11, #-1 + mov w9, #1 + adrp x20, c_ftl_nand_page_pre_slc_blk + stp x10, x21, [x8] + str w11, [x19] + str xzr, [x19, #48] + str w9, [x19, #56] + str w22, [sp, #16] // 4-byte Folded Spill + cbz w22, .LBB99_40 +// %bb.1: + ldr w8, [sp, #16] // 4-byte Folded Reload + adrp x22, req_sys + mov w23, wzr + add x22, x22, :lo12:req_sys + sub w8, w8, #1 // =1 + adrp x24, c_ftl_nand_byte_pre_page + stur w8, [x29, #-12] // 4-byte Folded Spill + b .LBB99_3 +.LBB99_2: // in Loop: Header=BB99_3 Depth=1 + add w8, w23, #1 // =1 + sxth w23, w8 + ldr w8, [sp, #16] // 4-byte Folded Reload + cmp w23, w8 + b.ge .LBB99_40 +.LBB99_3: // =>This Loop Header: Depth=1 + // Child Loop BB99_10 Depth 2 + // Child Loop BB99_16 Depth 2 + // Child Loop BB99_20 Depth 3 + ldur w8, [x29, #-12] // 4-byte Folded Reload + cmp w8, w23 + b.eq .LBB99_26 +// %bb.4: // in Loop: Header=BB99_3 Depth=1 + adrp x8, p_sys_data_buf + ldr x8, [x8, :lo12:p_sys_data_buf] + sxth x25, w23 + mov w1, #1 + mov x0, x22 + str x8, [x22, #8] + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk] + ldrh w9, [x27, x25, lsl #1] + sub w8, w8, #1 // =1 + orr w8, w8, w9, lsl #10 + str w8, [x22, #4] + bl FlashReadPages + ldr w8, [x22] + cmn w8, #1 // =1 + b.eq .LBB99_12 +// %bb.5: // in Loop: Header=BB99_3 Depth=1 + ldrh w8, [x21] + ldrh w9, [x19, #4] + cmp w8, w9 + b.ne .LBB99_12 +// %bb.6: // in Loop: Header=BB99_3 Depth=1 + ldrsh w8, [x21, #8] + cmn w8, #1291 // =1291 + b.ne .LBB99_12 +// %bb.7: // in Loop: Header=BB99_3 Depth=1 + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk] + cmp w8, #2 // =2 + b.lo .LBB99_2 +// %bb.8: // in Loop: Header=BB99_3 Depth=1 + mov w9, wzr + b .LBB99_10 +.LBB99_9: // in Loop: Header=BB99_10 Depth=2 + add w9, w9, #1 // =1 + and w10, w8, #0xffff + sxth w9, w9 + sub w10, w10, #1 // =1 + cmp w10, w9 + b.le .LBB99_2 +.LBB99_10: // Parent Loop BB99_3 Depth=1 + // => This Inner Loop Header: Depth=2 + adrp x10, p_sys_data_buf + ldr x10, [x10, :lo12:p_sys_data_buf] + sbfiz x12, x9, #1, #32 + sxtw x11, w12 + lsl x11, x11, #2 + ldrh w11, [x10, x11] + cmp w11, w28 + b.hs .LBB99_9 +// %bb.11: // in Loop: Header=BB99_10 Depth=2 + lsl x8, x12, #2 + orr x8, x8, #0x4 + ldr w8, [x10, x8] + ldur x10, [x29, #-8] // 8-byte Folded Reload + str w8, [x10, x11, lsl #2] + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk] + b .LBB99_9 +.LBB99_12: // in Loop: Header=BB99_3 Depth=1 + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk] + cbz w8, .LBB99_2 +// %bb.13: // in Loop: Header=BB99_3 Depth=1 + mov w26, wzr + b .LBB99_16 +.LBB99_14: // in Loop: Header=BB99_16 Depth=2 + adrp x0, .L.str.99 + adrp x1, .L__func__.FtlMapTblRecovery + add x0, x0, :lo12:.L.str.99 + add x1, x1, :lo12:.L__func__.FtlMapTblRecovery + mov w2, w23 + mov w3, w26 + bl sftl_printk + adrp x8, req_sys + mov w9, #-1 + str w9, [x8, :lo12:req_sys] +.LBB99_15: // in Loop: Header=BB99_16 Depth=2 + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk] + add w9, w26, #1 // =1 + sxth w26, w9 + cmp w26, w8 + b.ge .LBB99_2 +.LBB99_16: // Parent Loop BB99_3 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB99_20 Depth 3 + ldrh w8, [x27, x25, lsl #1] + mov w1, #1 + mov x0, x22 + orr w8, w26, w8, lsl #10 + str w8, [x22, #4] + bl FlashReadPages + ldr x8, [x22, #16] + ldr w4, [x8, #12] + ldr w8, [x22] + cbz w4, .LBB99_22 +// %bb.17: // in Loop: Header=BB99_16 Depth=2 + cmn w8, #1 // =1 + b.eq .LBB99_22 +// %bb.18: // in Loop: Header=BB99_16 Depth=2 + ldrh w9, [x24, :lo12:c_ftl_nand_byte_pre_page] + mov w5, #42982 + movk w5, #18374, lsl #16 + cbz x9, .LBB99_21 +// %bb.19: // in Loop: Header=BB99_16 Depth=2 + adrp x10, req_sys+8 + ldr x10, [x10, :lo12:req_sys+8] + mov w5, #42982 + movk w5, #18374, lsl #16 +.LBB99_20: // Parent Loop BB99_3 Depth=1 + // Parent Loop BB99_16 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrb w11, [x10], #1 + lsr w12, w5, #2 + add w12, w12, w5, lsl #5 + subs x9, x9, #1 // =1 + add w11, w12, w11 + eor w5, w11, w5 + b.ne .LBB99_20 +.LBB99_21: // in Loop: Header=BB99_16 Depth=2 + cmp w4, w5 + b.ne .LBB99_14 +.LBB99_22: // in Loop: Header=BB99_16 Depth=2 + cmn w8, #1 // =1 + b.eq .LBB99_15 +// %bb.23: // in Loop: Header=BB99_16 Depth=2 + ldrh w8, [x21, #8] + cmp w8, w28 + b.hs .LBB99_15 +// %bb.24: // in Loop: Header=BB99_16 Depth=2 + ldrh w9, [x21] + ldrh w10, [x19, #4] + cmp w9, w10 + b.ne .LBB99_15 +// %bb.25: // in Loop: Header=BB99_16 Depth=2 + adrp x9, req_sys+4 + ldr w9, [x9, :lo12:req_sys+4] + ldur x10, [x29, #-8] // 8-byte Folded Reload + str w9, [x10, x8, lsl #2] + b .LBB99_15 +.LBB99_26: + mov w8, w23 + sxth x26, w8 + ldrh w0, [x27, x26, lsl #1] + mov w1, #1 + bl FtlGetLastWrittenPage + add w8, w0, #1 // =1 + strh w8, [x19, #2] + ldr x8, [sp, #8] // 8-byte Folded Reload + strh w23, [x19] + ldr w8, [x8, x26, lsl #2] + str w8, [x19, #48] + tbnz w0, #15, .LBB99_40 +// %bb.27: + mov w23, wzr + sxth w25, w0 + b .LBB99_30 +.LBB99_28: // in Loop: Header=BB99_30 Depth=1 + ldur w2, [x29, #-12] // 4-byte Folded Reload + adrp x0, .L.str.98 + adrp x1, .L__func__.FtlMapTblRecovery + add x0, x0, :lo12:.L.str.98 + add x1, x1, :lo12:.L__func__.FtlMapTblRecovery + mov w3, w23 + bl sftl_printk + adrp x8, req_sys + mov w9, #-1 + str w9, [x8, :lo12:req_sys] +.LBB99_29: // in Loop: Header=BB99_30 Depth=1 + add w8, w23, #1 // =1 + sxth w23, w8 + cmp w25, w23 + b.lt .LBB99_40 +.LBB99_30: // =>This Loop Header: Depth=1 + // Child Loop BB99_34 Depth 2 + ldrh w8, [x27, x26, lsl #1] + mov w1, #1 + mov x0, x22 + orr w8, w23, w8, lsl #10 + str w8, [x22, #4] + bl FlashReadPages + ldr x8, [x22, #16] + ldr w4, [x8, #12] + ldr w8, [x22] + cbz w4, .LBB99_36 +// %bb.31: // in Loop: Header=BB99_30 Depth=1 + cmn w8, #1 // =1 + b.eq .LBB99_36 +// %bb.32: // in Loop: Header=BB99_30 Depth=1 + ldrh w9, [x24, :lo12:c_ftl_nand_byte_pre_page] + mov w5, #42982 + movk w5, #18374, lsl #16 + cbz x9, .LBB99_35 +// %bb.33: // in Loop: Header=BB99_30 Depth=1 + adrp x10, req_sys+8 + ldr x10, [x10, :lo12:req_sys+8] + mov w5, #42982 + movk w5, #18374, lsl #16 +.LBB99_34: // Parent Loop BB99_30 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrb w11, [x10], #1 + lsr w12, w5, #2 + add w12, w12, w5, lsl #5 + subs x9, x9, #1 // =1 + add w11, w12, w11 + eor w5, w11, w5 + b.ne .LBB99_34 +.LBB99_35: // in Loop: Header=BB99_30 Depth=1 + cmp w4, w5 + b.ne .LBB99_28 +.LBB99_36: // in Loop: Header=BB99_30 Depth=1 + cmn w8, #1 // =1 + b.eq .LBB99_29 +// %bb.37: // in Loop: Header=BB99_30 Depth=1 + ldrh w8, [x21, #8] + cmp w8, w28 + b.hs .LBB99_29 +// %bb.38: // in Loop: Header=BB99_30 Depth=1 + ldrh w9, [x21] + ldrh w10, [x19, #4] + cmp w9, w10 + b.ne .LBB99_29 +// %bb.39: // in Loop: Header=BB99_30 Depth=1 + adrp x9, req_sys+4 + ldr w9, [x9, :lo12:req_sys+4] + ldur x10, [x29, #-8] // 8-byte Folded Reload + str w9, [x10, x8, lsl #2] + b .LBB99_29 +.LBB99_40: + mov x0, x19 + bl ftl_free_no_use_map_blk + ldrh w8, [x19, #2] + ldrh w9, [x20, :lo12:c_ftl_nand_page_pre_slc_blk] + cmp w8, w9 + b.ne .LBB99_42 +// %bb.41: + mov x0, x19 + bl ftl_map_blk_alloc_new_blk +.LBB99_42: + mov x0, x19 + bl ftl_map_blk_gc + mov x0, x19 + bl ftl_map_blk_gc + ldp x20, x19, [sp, #112] // 16-byte Folded Reload + ldp x22, x21, [sp, #96] // 16-byte Folded Reload + ldp x24, x23, [sp, #80] // 16-byte Folded Reload + ldp x26, x25, [sp, #64] // 16-byte Folded Reload + ldp x28, x27, [sp, #48] // 16-byte Folded Reload + ldp x29, x30, [sp, #32] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #128 // =128 + hint #29 + ret +.Lfunc_end99: + .size FtlMapTblRecovery, .Lfunc_end99-FtlMapTblRecovery + // -- End function + .globl FtlLoadVonderInfo // -- Begin function FtlLoadVonderInfo + .p2align 2 + .type FtlLoadVonderInfo,@function +FtlLoadVonderInfo: // @FtlLoadVonderInfo +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_max_vendor_blks + adrp x10, g_totle_vendor_block + adrp x11, c_ftl_nand_vendor_region_num + ldrh w8, [x8, :lo12:c_ftl_nand_max_vendor_blks] + ldrh w10, [x10, :lo12:g_totle_vendor_block] + ldrh w11, [x11, :lo12:c_ftl_nand_vendor_region_num] + adrp x0, gVendorBlkInfo + add x0, x0, :lo12:gVendorBlkInfo + mov w9, #61574 + strh w9, [x0, #4] + adrp x9, p_vendor_block_table + strh w8, [x0, #10] + adrp x8, p_vendor_block_ver_table + strh w10, [x0, #8] + adrp x10, p_vendor_block_valid_page_count + strh w11, [x0, #6] + adrp x11, p_vendor_region_ppn_table + ldr x9, [x9, :lo12:p_vendor_block_table] + ldr x8, [x8, :lo12:p_vendor_block_ver_table] + ldr x10, [x10, :lo12:p_vendor_block_valid_page_count] + ldr x11, [x11, :lo12:p_vendor_region_ppn_table] + mov x29, sp + stp x9, x8, [x0, #16] + stp x10, x11, [x0, #32] + bl FtlMapTblRecovery + mov w0, wzr + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end100: + .size FtlLoadVonderInfo, .Lfunc_end100-FtlLoadVonderInfo + // -- End function + .globl FtlLoadMapInfo // -- Begin function FtlLoadMapInfo + .p2align 2 + .type FtlLoadMapInfo,@function +FtlLoadMapInfo: // @FtlLoadMapInfo +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + adrp x20, c_ftl_nand_max_map_blks + adrp x19, p_map_block_valid_page_count + ldr w8, [x20, :lo12:c_ftl_nand_max_map_blks] + ldr x0, [x19, :lo12:p_map_block_valid_page_count] + mov w1, wzr + str x23, [sp, #16] // 8-byte Folded Spill + lsl w2, w8, #1 + stp x22, x21, [sp, #32] // 16-byte Folded Spill + mov x29, sp + bl memset + adrp x22, c_ftl_nand_byte_pre_page + adrp x23, c_ftl_nand_l2pmap_ram_region_num + adrp x21, p_l2p_map_buf + ldrh w8, [x22, :lo12:c_ftl_nand_byte_pre_page] + ldrh w9, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num] + ldr x0, [x21, :lo12:p_l2p_map_buf] + mov w1, #255 + mul x2, x9, x8 + bl memset + ldrh w8, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB101_3 +// %bb.1: + mov x8, xzr + mov x9, xzr + mov x10, xzr + adrp x11, p_l2p_ram_map + mov w12, #65535 + mov x13, #4294967296 +.LBB101_2: // =>This Inner Loop Header: Depth=1 + ldr x14, [x11, :lo12:p_l2p_ram_map] + add x10, x10, #1 // =1 + add x14, x14, x8 + str wzr, [x14, #4] + ldr x14, [x11, :lo12:p_l2p_ram_map] + strh w12, [x14, x8] + ldrh w14, [x22, :lo12:c_ftl_nand_byte_pre_page] + ldr x15, [x21, :lo12:p_l2p_map_buf] + ldr x16, [x11, :lo12:p_l2p_ram_map] + mul x14, x9, x14 + asr x14, x14, #32 + and x14, x14, #0xfffffffffffffffc + add x14, x15, x14 + add x15, x16, x8 + str x14, [x15, #8] + ldrh w14, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num] + add x9, x9, x13 + add x8, x8, #16 // =16 + cmp x10, x14 + b.lo .LBB101_2 +.LBB101_3: + adrp x0, gL2pMapInfo + add x0, x0, :lo12:gL2pMapInfo + mov w8, #-255655937 + mov w9, #65535 + stur w8, [x0, #2] + adrp x8, g_totle_map_block + strh w9, [x0] + adrp x9, c_ftl_nand_map_region_num + ldr w10, [x20, :lo12:c_ftl_nand_max_map_blks] + ldrh w8, [x8, :lo12:g_totle_map_block] + ldrh w9, [x9, :lo12:c_ftl_nand_map_region_num] + ldr x11, [x19, :lo12:p_map_block_valid_page_count] + strh w10, [x0, #10] + adrp x10, p_map_block_table + strh w8, [x0, #8] + adrp x8, p_map_block_ver_table + strh w9, [x0, #6] + adrp x9, p_map_region_ppn_table + ldr x10, [x10, :lo12:p_map_block_table] + ldr x8, [x8, :lo12:p_map_block_ver_table] + ldr x9, [x9, :lo12:p_map_region_ppn_table] + stp x10, x8, [x0, #16] + stp x11, x9, [x0, #32] + bl FtlMapTblRecovery + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end101: + .size FtlLoadMapInfo, .Lfunc_end101-FtlLoadMapInfo + // -- End function + .globl ftl_sb_update_avl_pages // -- Begin function ftl_sb_update_avl_pages + .p2align 2 + .type ftl_sb_update_avl_pages,@function +ftl_sb_update_avl_pages: // @ftl_sb_update_avl_pages +// %bb.0: + hint #25 + strh wzr, [x0, #4] + adrp x8, c_ftl_nand_planes_num + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + // kill: def $w2 killed $w2 def $x2 + mov w9, wzr + cmp w8, w2, uxth + b.ls .LBB102_5 +// %bb.1: + mov w9, wzr + and x10, x2, #0xffff + add x11, x0, #16 // =16 + b .LBB102_3 +.LBB102_2: // in Loop: Header=BB102_3 Depth=1 + add x10, x10, #1 // =1 + cmp x10, x8 + b.hs .LBB102_5 +.LBB102_3: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x11, x10, lsl #1] + cmn w12, #1 // =1 + b.eq .LBB102_2 +// %bb.4: // in Loop: Header=BB102_3 Depth=1 + add w9, w9, #1 // =1 + strh w9, [x0, #4] + b .LBB102_2 +.LBB102_5: + cbz w8, .LBB102_10 +// %bb.6: + adrp x10, c_ftl_nand_page_pre_blk + ldrh w10, [x10, :lo12:c_ftl_nand_page_pre_blk] + mvn w11, w1 + add w10, w10, w11 + add x11, x0, #16 // =16 + b .LBB102_8 +.LBB102_7: // in Loop: Header=BB102_8 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB102_10 +.LBB102_8: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x11] + cmn w12, #1 // =1 + b.eq .LBB102_7 +// %bb.9: // in Loop: Header=BB102_8 Depth=1 + add w9, w10, w9 + strh w9, [x0, #4] + b .LBB102_7 +.LBB102_10: + hint #29 + ret +.Lfunc_end102: + .size ftl_sb_update_avl_pages, .Lfunc_end102-ftl_sb_update_avl_pages + // -- End function + .globl FtlReUsePrevPpa // -- Begin function FtlReUsePrevPpa + .p2align 2 + .type FtlReUsePrevPpa,@function +FtlReUsePrevPpa: // @FtlReUsePrevPpa +// %bb.0: + hint #25 + sub sp, sp, #96 // =96 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + adrp x10, c_ftl_nand_blks_per_die + str x8, [sp, #8] + ldrh w10, [x10, :lo12:c_ftl_nand_blks_per_die] + adrp x11, c_ftl_nand_planes_per_die + adrp x21, p_valid_page_count_table + ldrh w11, [x11, :lo12:c_ftl_nand_planes_per_die] + ubfx w9, w1, #10, #16 + ldr x8, [x21, :lo12:p_valid_page_count_table] + udiv w12, w9, w10 + msub w9, w12, w10, w9 + str w1, [sp, #4] + udiv w20, w9, w11 + ldrh w9, [x8, w20, uxtw #1] + mov w19, w0 + add x29, sp, #16 // =16 + cbz w9, .LBB103_4 +// %bb.1: + add w9, w9, #1 // =1 + strh w9, [x8, x20, lsl #1] +.LBB103_2: + add x1, sp, #4 // =4 + mov w2, #1 + mov w0, w19 + bl log2phys + adrp x9, __stack_chk_guard + ldr x8, [sp, #8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB103_26 +// %bb.3: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #96 // =96 + hint #29 + ret +.LBB103_4: + adrp x24, p_free_data_block_list_head + ldr x8, [x24, :lo12:p_free_data_block_list_head] + cbz x8, .LBB103_2 +// %bb.5: + adrp x22, g_num_free_superblocks + ldrh w9, [x22, :lo12:g_num_free_superblocks] + cbz w9, .LBB103_2 +// %bb.6: + adrp x23, p_data_block_list_table + ldr x10, [x23, :lo12:p_data_block_list_table] + mov w13, #43691 + movk w13, #43690, lsl #16 + mov w11, wzr + sub x14, x8, x10 + lsr x14, x14, #1 + mov w12, #6 + mul w14, w14, w13 + mov w13, #65535 +.LBB103_7: // =>This Inner Loop Header: Depth=1 + and w15, w14, #0xffff + cmp w15, w20, uxth + b.eq .LBB103_10 +// %bb.8: // in Loop: Header=BB103_7 Depth=1 + and x14, x14, #0xffff + mul x14, x14, x12 + ldrh w14, [x10, x14] + cmp w14, w13 + b.eq .LBB103_2 +// %bb.9: // in Loop: Header=BB103_7 Depth=1 + add w11, w11, #1 // =1 + cmp w9, w11, uxth + b.hi .LBB103_7 + b .LBB103_2 +.LBB103_10: + mov w9, #6 + madd x25, x20, x9, x10 + mov x26, x25 + ldrh w9, [x26, #2]! + cmp x25, x8 + b.eq .LBB103_13 +// %bb.11: + mov w10, #65535 + cmp w9, w10 + b.ne .LBB103_13 +// %bb.12: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_remove_node + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_remove_node + mov w2, #372 + bl sftl_printk + ldr x8, [x24, :lo12:p_free_data_block_list_head] +.LBB103_13: + ldrh w9, [x25] + cmp x25, x8 + b.eq .LBB103_16 +// %bb.14: + mov w8, #65535 + cmp w9, w8 + b.eq .LBB103_18 +// %bb.15: + ldr x8, [x23, :lo12:p_data_block_list_table] + ldrh w10, [x26] + mov w11, #6 + madd x8, x9, x11, x8 + strh w10, [x8, #2] + ldrh w9, [x26] + ldr x8, [x23, :lo12:p_data_block_list_table] + ldrh w10, [x25] + mul x9, x9, x11 + strh w10, [x8, x9] + b .LBB103_21 +.LBB103_16: + mov w8, #65535 + cmp w9, w8 + b.eq .LBB103_20 +// %bb.17: + ldr x10, [x23, :lo12:p_data_block_list_table] + mov w11, #6 + madd x9, x9, x11, x10 + str x9, [x24, :lo12:p_free_data_block_list_head] + strh w8, [x9, #2] + b .LBB103_21 +.LBB103_18: + ldrh w8, [x26] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB103_21 +// %bb.19: + ldr x10, [x23, :lo12:p_data_block_list_table] + mov w11, #6 + mul x8, x8, x11 + strh w9, [x10, x8] + b .LBB103_21 +.LBB103_20: + str xzr, [x24, :lo12:p_free_data_block_list_head] +.LBB103_21: + mov w8, #65535 + strh w8, [x25] + strh w8, [x26] + ldrh w8, [x22, :lo12:g_num_free_superblocks] + cbnz w8, .LBB103_23 +// %bb.22: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlReUsePrevPpa + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlReUsePrevPpa + mov w2, #1742 + bl sftl_printk + ldrh w8, [x22, :lo12:g_num_free_superblocks] +.LBB103_23: + sub w8, w8, #1 // =1 + mov w0, w20 + strh w8, [x22, :lo12:g_num_free_superblocks] + bl insert_data_list + adrp x8, g_num_data_superblocks + ldrh w9, [x8, :lo12:g_num_data_superblocks] + adrp x10, c_ftl_nand_data_blks_per_plane + ldrh w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane] + add w9, w9, #1 // =1 + strh w9, [x8, :lo12:g_num_data_superblocks] + cmp w10, w9, uxth + b.hs .LBB103_25 +// %bb.24: + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + mov w2, #214 + bl sftl_printk +.LBB103_25: + ldr x8, [x21, :lo12:p_valid_page_count_table] + lsl x9, x20, #1 + ldrh w10, [x8, x9] + add w10, w10, #1 // =1 + strh w10, [x8, x9] + b .LBB103_2 +.LBB103_26: + bl __stack_chk_fail +.Lfunc_end103: + .size FtlReUsePrevPpa, .Lfunc_end103-FtlReUsePrevPpa + // -- End function + .globl FtlRecoverySuperblock // -- Begin function FtlRecoverySuperblock + .p2align 2 + .type FtlRecoverySuperblock,@function +FtlRecoverySuperblock: // @FtlRecoverySuperblock +// %bb.0: + hint #25 + sub sp, sp, #160 // =160 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #64] // 16-byte Folded Spill + add x29, sp, #64 // =64 + stp x28, x27, [sp, #80] // 16-byte Folded Spill + stp x26, x25, [sp, #96] // 16-byte Folded Spill + stp x24, x23, [sp, #112] // 16-byte Folded Spill + stp x22, x21, [sp, #128] // 16-byte Folded Spill + stp x20, x19, [sp, #144] // 16-byte Folded Spill + stur x8, [x29, #-8] + ldrsh w8, [x0] + cmn w8, #1 // =1 + b.eq .LBB104_148 +// %bb.1: + adrp x24, c_ftl_nand_page_pre_blk + ldrh w25, [x0, #2] + ldrh w8, [x24, :lo12:c_ftl_nand_page_pre_blk] + mov x19, x0 + cmp w25, w8 + b.ne .LBB104_3 +// %bb.2: + strh wzr, [x19, #4] + strb wzr, [x19, #6] + b .LBB104_148 +.LBB104_3: + ldrb w8, [x19, #6] + ldrh w0, [x19, #16] + str w8, [sp, #32] // 4-byte Folded Spill + mov w8, #65535 + cmp w0, w8 + b.eq .LBB104_5 +// %bb.4: + mov w21, wzr + b .LBB104_7 +.LBB104_5: + mov w21, wzr +.LBB104_6: // =>This Inner Loop Header: Depth=1 + add w21, w21, #1 // =1 + add x9, x19, w21, uxth #1 + ldrh w0, [x9, #16] + cmp w0, w8 + b.eq .LBB104_6 +.LBB104_7: + mov w1, #1 + bl FtlGetLastWrittenPage + cmn w0, #1 // =1 + b.eq .LBB104_13 +// %bb.8: + adrp x26, c_ftl_nand_planes_num + ldrh w15, [x26, :lo12:c_ftl_nand_planes_num] + mov w20, w0 + adrp x22, req_read + cbz w15, .LBB104_19 +// %bb.9: + mov x8, xzr + mov w23, wzr + add x9, x19, #16 // =16 + mov w10, #65535 + adrp x11, p_gc_data_buf + adrp x12, c_ftl_nand_byte_pre_page + adrp x13, p_gc_spare_buf + adrp x14, c_ftl_nand_byte_pre_oob + b .LBB104_11 +.LBB104_10: // in Loop: Header=BB104_11 Depth=1 + add x8, x8, #1 // =1 + cmp x8, w15, uxth + b.hs .LBB104_20 +.LBB104_11: // =>This Inner Loop Header: Depth=1 + ldrh w16, [x9, x8, lsl #1] + cmp w16, w10 + b.eq .LBB104_10 +// %bb.12: // in Loop: Header=BB104_11 Depth=1 + ldr x15, [x22, :lo12:req_read] + and x17, x23, #0xffff + lsl x17, x17, #5 + orr w16, w20, w16, lsl #10 + add x15, x15, x17 + str w16, [x15, #4] + ldrh w15, [x12, :lo12:c_ftl_nand_byte_pre_page] + and w16, w23, #0xffff + ldr x18, [x11, :lo12:p_gc_data_buf] + ldr x0, [x22, :lo12:req_read] + mul w15, w15, w16 + add w1, w15, #3 // =3 + cmp w15, #0 // =0 + csel w15, w1, w15, lt + asr w15, w15, #2 + add x0, x0, x17 + add x15, x18, w15, sxtw #2 + str x15, [x0, #8] + ldrh w15, [x14, :lo12:c_ftl_nand_byte_pre_oob] + ldr x18, [x13, :lo12:p_gc_spare_buf] + ldr x0, [x22, :lo12:req_read] + add w23, w23, #1 // =1 + mul w15, w15, w16 + add w16, w15, #3 // =3 + cmp w15, #0 // =0 + csel w15, w16, w15, lt + asr w15, w15, #2 + add x15, x18, w15, sxtw #2 + add x16, x0, x17 + str x15, [x16, #16] + ldrh w15, [x26, :lo12:c_ftl_nand_planes_num] + b .LBB104_10 +.LBB104_13: + cbz w25, .LBB104_15 +// %bb.14: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlRecoverySuperblock + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlRecoverySuperblock + mov w2, #1809 + bl sftl_printk +.LBB104_15: + ldr w8, [sp, #32] // 4-byte Folded Reload + cbz w8, .LBB104_18 +// %bb.16: + cmp w8, w21, uxth + b.eq .LBB104_18 +// %bb.17: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlRecoverySuperblock + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlRecoverySuperblock + mov w2, #1810 + bl sftl_printk +.LBB104_18: + strh wzr, [x19, #2] + strb wzr, [x19, #6] + b .LBB104_148 +.LBB104_19: + mov w23, wzr +.LBB104_20: + ldr x0, [x22, :lo12:req_read] + and w21, w23, #0xffff + mov w1, w21 + bl FlashReadPages + adrp x8, g_GlobalDataVersion + ldr w8, [x8, :lo12:g_GlobalDataVersion] + cbz w21, .LBB104_29 +// %bb.21: + ldr x13, [x22, :lo12:req_read] + mov w9, w23 + mov x10, xzr + and x11, x9, #0xffff + mov w9, #65535 + mov w12, #-2147483648 + add x13, x13, #16 // =16 + mov w14, #-2147483647 + mov w15, w8 + b .LBB104_24 +.LBB104_22: // in Loop: Header=BB104_24 Depth=1 + mov w9, w20 +.LBB104_23: // in Loop: Header=BB104_24 Depth=1 + add x10, x10, #1 // =1 + cmp x11, x10 + add x13, x13, #32 // =32 + b.eq .LBB104_31 +.LBB104_24: // =>This Inner Loop Header: Depth=1 + ldur w16, [x13, #-16] + cbnz w16, .LBB104_22 +// %bb.25: // in Loop: Header=BB104_24 Depth=1 + ldr x16, [x13] + ldr w17, [x16, #4] + cmn w17, #1 // =1 + b.eq .LBB104_28 +// %bb.26: // in Loop: Header=BB104_24 Depth=1 + subs w18, w17, w15 + sub w0, w15, w17 + cmp w18, w12 + cset w18, hi + cmp w0, w14 + cset w0, lo + cmp w17, w15 + csel w18, w18, w0, hi + tbnz w18, #0, .LBB104_28 +// %bb.27: // in Loop: Header=BB104_24 Depth=1 + add w15, w17, #1 // =1 + adrp x17, g_GlobalDataVersion + str w15, [x17, :lo12:g_GlobalDataVersion] +.LBB104_28: // in Loop: Header=BB104_24 Depth=1 + ldr w16, [x16] + cmn w16, #1 // =1 + b.ne .LBB104_23 + b .LBB104_30 +.LBB104_29: + mov w10, wzr + mov w9, #65535 +.LBB104_30: + and w11, w10, #0xffff + cmp w11, w23, uxth + b.ne .LBB104_32 +.LBB104_31: + ldr x10, [x22, :lo12:req_read] + adrp x11, c_ftl_nand_blks_per_die + adrp x12, c_ftl_nand_planes_per_die + ldrh w11, [x11, :lo12:c_ftl_nand_blks_per_die] + ldr w10, [x10, #4] + ldrh w12, [x12, :lo12:c_ftl_nand_planes_per_die] + add w14, w20, #1 // =1 + ubfx w10, w10, #10, #16 + udiv w11, w10, w11 + udiv w13, w10, w12 + b .LBB104_33 +.LBB104_32: + ldr x11, [x22, :lo12:req_read] + // kill: def $w10 killed $w10 killed $x10 def $x10 + adrp x12, c_ftl_nand_planes_per_die + and x10, x10, #0xffff + ldrh w12, [x12, :lo12:c_ftl_nand_planes_per_die] + add x10, x11, x10, lsl #5 + ldr w10, [x10, #4] + adrp x11, c_ftl_nand_blks_per_die + ldrh w11, [x11, :lo12:c_ftl_nand_blks_per_die] + mov w14, w20 + ubfx w10, w10, #10, #16 + udiv w13, w10, w12 + udiv w11, w10, w11 +.LBB104_33: + mul w11, w12, w11 + msub w12, w13, w12, w10 + ldrh w10, [x24, :lo12:c_ftl_nand_page_pre_blk] + and w13, w14, #0xffff + cmp w10, w13 + b.ne .LBB104_35 +// %bb.34: + strh w14, [x19, #2] + strb wzr, [x19, #6] + strh wzr, [x19, #4] +.LBB104_35: + add w12, w11, w12 + ldr w11, [sp, #32] // 4-byte Folded Reload + cmp w13, w25 + b.ne .LBB104_42 +// %bb.36: + cmp w11, w12, uxth + b.ne .LBB104_42 +// %bb.37: + strh wzr, [x19, #4] + ldrh w8, [x26, :lo12:c_ftl_nand_planes_num] + mov w9, wzr + cmp w8, w12, uxth + b.ls .LBB104_47 +// %bb.38: + sub x11, x8, w12, uxth + add x12, x19, w12, uxth #1 + mov w9, wzr + add x12, x12, #16 // =16 + b .LBB104_40 +.LBB104_39: // in Loop: Header=BB104_40 Depth=1 + subs x11, x11, #1 // =1 + add x12, x12, #2 // =2 + b.eq .LBB104_47 +.LBB104_40: // =>This Inner Loop Header: Depth=1 + ldrsh w13, [x12] + cmn w13, #1 // =1 + b.eq .LBB104_39 +// %bb.41: // in Loop: Header=BB104_40 Depth=1 + add w9, w9, #1 // =1 + strh w9, [x19, #4] + b .LBB104_39 +.LBB104_42: + sub w26, w8, #1 // =1 + mvn w8, w9 + tst w8, #0xffff + str x12, [sp, #24] // 8-byte Folded Spill + stp w25, w14, [x29, #-28] // 8-byte Folded Spill + b.eq .LBB104_67 +.LBB104_43: + adrp x9, g_recovery_page_min_ver + ldr w8, [x9, :lo12:g_recovery_page_min_ver] + cmn w8, #1 // =1 + b.ne .LBB104_45 +// %bb.44: + str w26, [x9, :lo12:g_recovery_page_min_ver] +.LBB104_45: + ldur w10, [x29, #-28] // 4-byte Folded Reload + and w21, w20, #0xffff + sub w9, w20, #7 // =7 + add w8, w10, #7 // =7 + cmp w21, w8 + csel w8, w9, w10, hi + and w23, w8, #0xffff + cmp w21, w23 + b.hs .LBB104_52 +.LBB104_46: + mov w8, #-1 + adrp x9, g_recovery_page_min_ver + str w8, [x9, :lo12:g_recovery_page_min_ver] + b .LBB104_68 +.LBB104_47: + cbz w8, .LBB104_148 +// %bb.48: + mvn w11, w14 + add w10, w10, w11 + add x11, x19, #16 // =16 + b .LBB104_50 +.LBB104_49: // in Loop: Header=BB104_50 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB104_148 +.LBB104_50: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x11] + cmn w12, #1 // =1 + b.eq .LBB104_49 +// %bb.51: // in Loop: Header=BB104_50 Depth=1 + add w9, w10, w9 + strh w9, [x19, #4] + b .LBB104_49 +.LBB104_52: + add x24, x19, #16 // =16 + mov w25, #65535 + b .LBB104_54 +.LBB104_53: // in Loop: Header=BB104_54 Depth=1 + add w8, w23, #1 // =1 + and w23, w8, #0xffff + cmp w21, w23 + b.lo .LBB104_46 +.LBB104_54: // =>This Loop Header: Depth=1 + // Child Loop BB104_57 Depth 2 + // Child Loop BB104_63 Depth 2 + adrp x8, c_ftl_nand_planes_num + ldrh w9, [x8, :lo12:c_ftl_nand_planes_num] + cbz w9, .LBB104_59 +// %bb.55: // in Loop: Header=BB104_54 Depth=1 + mov x8, xzr + mov w27, wzr + b .LBB104_57 +.LBB104_56: // in Loop: Header=BB104_57 Depth=2 + add x8, x8, #1 // =1 + cmp x8, w9, uxth + b.hs .LBB104_60 +.LBB104_57: // Parent Loop BB104_54 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w10, [x24, x8, lsl #1] + cmp w10, w25 + b.eq .LBB104_56 +// %bb.58: // in Loop: Header=BB104_57 Depth=2 + ldr x9, [x22, :lo12:req_read] + and x11, x27, #0xffff + orr w10, w23, w10, lsl #10 + add w27, w27, #1 // =1 + add x9, x9, x11, lsl #5 + str w10, [x9, #4] + adrp x9, c_ftl_nand_planes_num + ldrh w9, [x9, :lo12:c_ftl_nand_planes_num] + b .LBB104_56 +.LBB104_59: // in Loop: Header=BB104_54 Depth=1 + mov w27, wzr +.LBB104_60: // in Loop: Header=BB104_54 Depth=1 + ldr x0, [x22, :lo12:req_read] + and w20, w27, #0xffff + mov w1, w20 + bl FlashReadPages + cbz w20, .LBB104_53 +// %bb.61: // in Loop: Header=BB104_54 Depth=1 + ldr x9, [x22, :lo12:req_read] + // kill: def $w27 killed $w27 killed $x27 def $x27 + and x8, x27, #0xffff + add x9, x9, #16 // =16 + b .LBB104_63 +.LBB104_62: // in Loop: Header=BB104_63 Depth=2 + subs x8, x8, #1 // =1 + add x9, x9, #32 // =32 + b.eq .LBB104_53 +.LBB104_63: // Parent Loop BB104_54 Depth=1 + // => This Inner Loop Header: Depth=2 + ldur w10, [x9, #-16] + cbnz w10, .LBB104_68 +// %bb.64: // in Loop: Header=BB104_63 Depth=2 + ldr x10, [x9] + ldrsh w11, [x10] + cmn w11, #1 // =1 + b.eq .LBB104_62 +// %bb.65: // in Loop: Header=BB104_63 Depth=2 + ldr w10, [x10, #4] + cmn w10, #1 // =1 + b.eq .LBB104_62 +// %bb.66: // in Loop: Header=BB104_63 Depth=2 + adrp x11, g_recovery_page_min_ver + str w10, [x11, :lo12:g_recovery_page_min_ver] + b .LBB104_62 +.LBB104_67: + ldrb w8, [x19, #8] + cbz w8, .LBB104_43 +.LBB104_68: + ldur w25, [x29, #-28] // 4-byte Folded Reload + adrp x8, g_power_lost_recovery_flag + mov w9, #1 + add x20, x19, #16 // =16 + mov w14, #65535 + mov w28, w25 + strh w9, [x8, :lo12:g_power_lost_recovery_flag] + b .LBB104_70 +.LBB104_69: // in Loop: Header=BB104_70 Depth=1 + adrp x8, c_ftl_nand_page_pre_blk + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_blk] + add w28, w28, #1 // =1 + mov w14, #65535 + cmp w8, w28, uxth + b.eq .LBB104_143 +.LBB104_70: // =>This Loop Header: Depth=1 + // Child Loop BB104_73 Depth 2 + // Child Loop BB104_80 Depth 2 + adrp x13, c_ftl_nand_planes_num + ldrh w10, [x13, :lo12:c_ftl_nand_planes_num] + cbz w10, .LBB104_75 +// %bb.71: // in Loop: Header=BB104_70 Depth=1 + mov x8, xzr + mov w21, wzr + and w9, w28, #0xffff + b .LBB104_73 +.LBB104_72: // in Loop: Header=BB104_73 Depth=2 + add x8, x8, #1 // =1 + cmp x8, w10, uxth + b.hs .LBB104_76 +.LBB104_73: // Parent Loop BB104_70 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w11, [x20, x8, lsl #1] + cmp w11, w14 + b.eq .LBB104_72 +// %bb.74: // in Loop: Header=BB104_73 Depth=2 + ldr x10, [x22, :lo12:req_read] + and x12, x21, #0xffff + orr w11, w9, w11, lsl #10 + add w21, w21, #1 // =1 + add x10, x10, x12, lsl #5 + str w11, [x10, #4] + ldrh w10, [x13, :lo12:c_ftl_nand_planes_num] + b .LBB104_72 +.LBB104_75: // in Loop: Header=BB104_70 Depth=1 + mov w21, wzr +.LBB104_76: // in Loop: Header=BB104_70 Depth=1 + ldr x0, [x22, :lo12:req_read] + and w24, w21, #0xffff + mov w1, w24 + bl FlashReadPages + cbz w24, .LBB104_69 +// %bb.77: // in Loop: Header=BB104_70 Depth=1 + ldr w24, [sp, #32] // 4-byte Folded Reload + // kill: def $w21 killed $w21 killed $x21 def $x21 + and x8, x21, #0xffff + mov x27, xzr + lsl x23, x8, #5 + b .LBB104_80 +.LBB104_78: // in Loop: Header=BB104_80 Depth=2 + str w26, [x9, :lo12:g_recovery_page_min_ver] +.LBB104_79: // in Loop: Header=BB104_80 Depth=2 + add x27, x27, #32 // =32 + cmp x23, x27 + b.eq .LBB104_69 +.LBB104_80: // Parent Loop BB104_70 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x8, [x22, :lo12:req_read] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + and w11, w28, #0xffff + add x9, x8, x27 + ldr w21, [x9, #4] + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + ubfx w12, w21, #10, #16 + udiv w13, w12, w10 + udiv w9, w12, w9 + msub w12, w13, w10, w12 + madd w9, w10, w9, w12 + cmp w24, w9, uxth + cset w10, hi + cmp w11, w25 + cset w11, eq + stur w21, [x29, #-20] + b.lo .LBB104_79 +// %bb.81: // in Loop: Header=BB104_80 Depth=2 + and w10, w11, w10 + tbnz w10, #0, .LBB104_79 +// %bb.82: // in Loop: Header=BB104_80 Depth=2 + ldur w11, [x29, #-24] // 4-byte Folded Reload + and w10, w28, #0xffff + cmp w10, w11, uxth + b.ne .LBB104_84 +// %bb.83: // in Loop: Header=BB104_80 Depth=2 + ldr x10, [sp, #24] // 8-byte Folded Reload + and w9, w9, #0xffff + cmp w9, w10, uxth + b.eq .LBB104_133 +.LBB104_84: // in Loop: Header=BB104_80 Depth=2 + ldr w9, [x8, x27] + cmn w9, #1 // =1 + b.eq .LBB104_98 +// %bb.85: // in Loop: Header=BB104_80 Depth=2 + add x8, x8, x27 + ldr x25, [x8, #16] + ldrsh w8, [x25] + cmn w8, #3947 // =3947 + b.ne .LBB104_102 +// %bb.86: // in Loop: Header=BB104_80 Depth=2 + ldr w26, [x25, #4] + cmn w26, #1 // =1 + b.eq .LBB104_90 +// %bb.87: // in Loop: Header=BB104_80 Depth=2 + adrp x8, g_GlobalDataVersion + ldr w8, [x8, :lo12:g_GlobalDataVersion] + mov w11, #-2147483648 + subs w9, w26, w8 + sub w10, w8, w26 + cmp w9, w11 + mov w11, #-2147483647 + cset w9, hi + cmp w10, w11 + cset w10, lo + cmp w26, w8 + csel w8, w9, w10, hi + tbnz w8, #0, .LBB104_90 +// %bb.88: // in Loop: Header=BB104_80 Depth=2 + add w8, w26, #1 // =1 + adrp x9, g_GlobalDataVersion + str w8, [x9, :lo12:g_GlobalDataVersion] + ldrsh w8, [x25] + cmn w8, #3947 // =3947 + b.eq .LBB104_90 +// %bb.89: // in Loop: Header=BB104_80 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlRecoverySuperblock + mov w2, #1961 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlRecoverySuperblock + bl sftl_printk +.LBB104_90: // in Loop: Header=BB104_80 Depth=2 + ldp w0, w24, [x25, #8] + sub x1, x29, #16 // =16 + mov w2, wzr + stur w24, [x29, #-12] + str w0, [sp, #20] // 4-byte Folded Spill + bl log2phys + adrp x8, g_recovery_page_min_ver + ldr w8, [x8, :lo12:g_recovery_page_min_ver] + cmn w8, #1 // =1 + b.eq .LBB104_92 +// %bb.91: // in Loop: Header=BB104_80 Depth=2 + subs w9, w26, w8 + mov w11, #-2147483648 + sub w10, w8, w26 + cmp w9, w11 + mov w11, #-2147483647 + cset w9, hi + cmp w10, w11 + cset w10, lo + cmp w26, w8 + csel w8, w9, w10, hi + tbz w8, #0, .LBB104_114 +.LBB104_92: // in Loop: Header=BB104_80 Depth=2 + ldur w25, [x29, #-16] + cmp w25, w21 + b.ne .LBB104_104 +.LBB104_93: // in Loop: Header=BB104_80 Depth=2 + ldur w25, [x29, #-28] // 4-byte Folded Reload + cmn w24, #1 // =1 + b.eq .LBB104_120 +// %bb.94: // in Loop: Header=BB104_80 Depth=2 + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x11, c_ftl_nand_data_blks_per_plane + ubfx w9, w24, #10, #16 + ldrh w11, [x11, :lo12:c_ftl_nand_data_blks_per_plane] + udiv w12, w9, w8 + msub w8, w12, w8, w9 + udiv w24, w8, w10 + cmp w24, w11 + b.lo .LBB104_96 +// %bb.95: // in Loop: Header=BB104_80 Depth=2 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlRecoverySuperblock + mov w2, #2066 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlRecoverySuperblock + bl sftl_printk +.LBB104_96: // in Loop: Header=BB104_80 Depth=2 + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + and x9, x24, #0xffff + ldrh w8, [x8, x9, lsl #1] + cbz w8, .LBB104_121 +// %bb.97: // in Loop: Header=BB104_80 Depth=2 + mov w0, w24 + bl decrement_vpc_count + ldr w24, [sp, #32] // 4-byte Folded Reload + b .LBB104_79 +.LBB104_98: // in Loop: Header=BB104_80 Depth=2 + adrp x8, g_recovery_page_num + ldr w8, [x8, :lo12:g_recovery_page_num] + cmp w8, #31 // =31 + b.hi .LBB104_100 +// %bb.99: // in Loop: Header=BB104_80 Depth=2 + adrp x9, g_recovery_ppa_tbl + add x9, x9, :lo12:g_recovery_ppa_tbl + str w21, [x9, x8, lsl #2] + add w8, w8, #1 // =1 + adrp x9, g_recovery_page_num + str w8, [x9, :lo12:g_recovery_page_num] +.LBB104_100: // in Loop: Header=BB104_80 Depth=2 + ldrh w0, [x19] + bl decrement_vpc_count + adrp x9, g_recovery_page_min_ver + ldr w8, [x9, :lo12:g_recovery_page_min_ver] + cmn w8, #1 // =1 + b.eq .LBB104_78 +// %bb.101: // in Loop: Header=BB104_80 Depth=2 + cmp w8, w26 + b.ls .LBB104_79 + b .LBB104_78 +.LBB104_102: // in Loop: Header=BB104_80 Depth=2 + ldrh w0, [x19] + bl decrement_vpc_count +.LBB104_103: // in Loop: Header=BB104_80 Depth=2 + ldur w25, [x29, #-28] // 4-byte Folded Reload + b .LBB104_79 +.LBB104_104: // in Loop: Header=BB104_80 Depth=2 + cmn w24, #1 // =1 + b.eq .LBB104_106 +// %bb.105: // in Loop: Header=BB104_80 Depth=2 + adrp x8, c_ftl_nand_totle_phy_blks + ldr w8, [x8, :lo12:c_ftl_nand_totle_phy_blks] + cmp w8, w24, lsr #10 + b.ls .LBB104_124 +.LBB104_106: // in Loop: Header=BB104_80 Depth=2 + ldr w0, [sp, #20] // 4-byte Folded Reload + sub x1, x29, #20 // =20 + mov w2, #1 + bl log2phys + cmn w25, #1 // =1 + b.eq .LBB104_93 +// %bb.107: // in Loop: Header=BB104_80 Depth=2 + cmp w25, w24 + b.eq .LBB104_93 +// %bb.108: // in Loop: Header=BB104_80 Depth=2 + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x11, g_active_superblock + ubfx w9, w25, #10, #16 + ldrh w11, [x11, :lo12:g_active_superblock] + udiv w12, w9, w8 + msub w8, w12, w8, w9 + udiv w8, w8, w10 + cmp w8, w11 + b.eq .LBB104_111 +// %bb.109: // in Loop: Header=BB104_80 Depth=2 + adrp x9, g_buffer_superblock + ldrh w9, [x9, :lo12:g_buffer_superblock] + cmp w9, w8, uxth + b.eq .LBB104_111 +// %bb.110: // in Loop: Header=BB104_80 Depth=2 + adrp x9, g_gc_temp_superblock + ldrh w9, [x9, :lo12:g_gc_temp_superblock] + cmp w9, w8, uxth + b.ne .LBB104_93 +.LBB104_111: // in Loop: Header=BB104_80 Depth=2 + ldr x8, [x22, :lo12:req_read] + mov w1, #1 + str w25, [x8, #4] + ldr x0, [x22, :lo12:req_read] + ldr x21, [x8, #16] + bl FlashReadPages + ldr x8, [x22, :lo12:req_read] + ldr w8, [x8] + cmn w8, #1 // =1 + b.eq .LBB104_93 +// %bb.112: // in Loop: Header=BB104_80 Depth=2 + ldr w8, [x21, #4] + mov w11, #-2147483648 + subs w9, w26, w8 + sub w10, w8, w26 + cmp w9, w11 + mov w11, #-2147483647 + cset w9, hi + cmp w10, w11 + cset w10, lo + cmp w26, w8 + csel w8, w9, w10, hi + cmp w8, #1 // =1 + b.ne .LBB104_93 +// %bb.113: // in Loop: Header=BB104_80 Depth=2 + ldr w0, [sp, #20] // 4-byte Folded Reload + sub x1, x29, #16 // =16 + mov w2, #1 + bl log2phys + b .LBB104_93 +.LBB104_114: // in Loop: Header=BB104_80 Depth=2 + cmn w24, #1 // =1 + b.eq .LBB104_122 +// %bb.115: // in Loop: Header=BB104_80 Depth=2 + ldr x8, [x22, :lo12:req_read] + mov w1, #1 + add x8, x8, x27 + str w24, [x8, #4] + ldr x9, [x22, :lo12:req_read] + ldr x25, [x8, #16] + add x0, x9, x27 + bl FlashReadPages + ldr x8, [x22, :lo12:req_read] + mov x13, x25 + ldur w25, [x29, #-28] // 4-byte Folded Reload + ldr w9, [x8, x27] + cmn w9, #1 // =1 + b.eq .LBB104_126 +// %bb.116: // in Loop: Header=BB104_80 Depth=2 + ldr w9, [x13, #8] + ldr w10, [sp, #20] // 4-byte Folded Reload + cmp w9, w10 + b.ne .LBB104_126 +// %bb.117: // in Loop: Header=BB104_80 Depth=2 + adrp x9, g_recovery_page_min_ver + ldr w14, [x13, #4] + ldr w9, [x9, :lo12:g_recovery_page_min_ver] + mov w12, #-2147483648 + subs w10, w9, w14 + sub w11, w14, w9 + cmp w10, w12 + mov w12, #-2147483647 + cset w10, hi + cmp w11, w12 + cset w11, lo + cmp w9, w14 + csel w9, w10, w11, hi + tbnz w9, #0, .LBB104_126 +// %bb.118: // in Loop: Header=BB104_80 Depth=2 + ldur w9, [x29, #-16] + cmp w9, w21 + b.ne .LBB104_125 +.LBB104_119: // in Loop: Header=BB104_80 Depth=2 + ldr w0, [sp, #20] // 4-byte Folded Reload + mov w1, w24 + bl FtlReUsePrevPpa + b .LBB104_126 +.LBB104_120: // in Loop: Header=BB104_80 Depth=2 + ldr w24, [sp, #32] // 4-byte Folded Reload + b .LBB104_79 +.LBB104_121: // in Loop: Header=BB104_80 Depth=2 + adrp x0, .L.str.101 + add x0, x0, :lo12:.L.str.101 + mov w1, w24 + bl sftl_printk + ldr w24, [sp, #32] // 4-byte Folded Reload + b .LBB104_79 +.LBB104_122: // in Loop: Header=BB104_80 Depth=2 + ldur w8, [x29, #-16] + ldr w24, [sp, #32] // 4-byte Folded Reload + ldur w25, [x29, #-28] // 4-byte Folded Reload + cmp w8, w21 + b.ne .LBB104_79 +// %bb.123: // in Loop: Header=BB104_80 Depth=2 + ldr w0, [sp, #20] // 4-byte Folded Reload + sub x1, x29, #12 // =12 + mov w2, #1 + bl log2phys + b .LBB104_79 +.LBB104_124: // in Loop: Header=BB104_80 Depth=2 + adrp x0, .L.str.100 + add x0, x0, :lo12:.L.str.100 + mov w1, w24 + bl sftl_printk + ldr w24, [sp, #32] // 4-byte Folded Reload + b .LBB104_103 +.LBB104_125: // in Loop: Header=BB104_80 Depth=2 + cmp w9, w24 + b.ne .LBB104_127 +.LBB104_126: // in Loop: Header=BB104_80 Depth=2 + ldr w24, [sp, #32] // 4-byte Folded Reload + mov w8, #-1 + stur w8, [x29, #-12] + b .LBB104_79 +.LBB104_127: // in Loop: Header=BB104_80 Depth=2 + cmn w9, #1 // =1 + b.eq .LBB104_129 +// %bb.128: // in Loop: Header=BB104_80 Depth=2 + add x8, x8, x27 + str w9, [x8, #4] + ldr x9, [x22, :lo12:req_read] + ldr x8, [x8, #16] + mov w1, #1 + mov w21, w14 + add x0, x9, x27 + str x8, [sp, #8] // 8-byte Folded Spill + bl FlashReadPages + mov w14, w21 + b .LBB104_130 +.LBB104_129: // in Loop: Header=BB104_80 Depth=2 + str x13, [sp, #8] // 8-byte Folded Spill + str w9, [x8, x27] +.LBB104_130: // in Loop: Header=BB104_80 Depth=2 + ldr x8, [x22, :lo12:req_read] + adrp x9, g_recovery_page_min_ver + mov w12, #-2147483648 + mov w13, #-2147483647 + ldr w8, [x8, x27] + cmn w8, #1 // =1 + b.eq .LBB104_119 +// %bb.131: // in Loop: Header=BB104_80 Depth=2 + ldr x8, [sp, #8] // 8-byte Folded Reload + ldr w9, [x9, :lo12:g_recovery_page_min_ver] + ldr w8, [x8, #4] + subs w10, w9, w8 + sub w11, w8, w9 + cmp w10, w12 + cset w10, hi + cmp w11, w13 + cset w11, lo + cmp w9, w8 + csel w9, w10, w11, hi + tbnz w9, #0, .LBB104_119 +// %bb.132: // in Loop: Header=BB104_80 Depth=2 + subs w9, w14, w8 + sub w10, w8, w14 + cmp w9, w12 + cset w9, hi + cmp w10, w13 + cset w10, lo + cmp w14, w8 + csel w8, w9, w10, hi + tbz w8, #0, .LBB104_119 + b .LBB104_126 +.LBB104_133: + ldr x11, [sp, #24] // 8-byte Folded Reload + ldur w14, [x29, #-24] // 4-byte Folded Reload + strh wzr, [x19, #4] + adrp x8, c_ftl_nand_planes_num + strb w11, [x19, #6] + strh w14, [x19, #2] + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + mov w9, wzr + adrp x13, c_ftl_nand_page_pre_blk + cmp w8, w11, uxth + b.ls .LBB104_138 +// %bb.134: + sub x10, x8, w11, uxth + add x11, x19, w11, uxth #1 + mov w9, wzr + add x11, x11, #16 // =16 + b .LBB104_136 +.LBB104_135: // in Loop: Header=BB104_136 Depth=1 + subs x10, x10, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB104_138 +.LBB104_136: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x11] + cmn w12, #1 // =1 + b.eq .LBB104_135 +// %bb.137: // in Loop: Header=BB104_136 Depth=1 + add w9, w9, #1 // =1 + strh w9, [x19, #4] + b .LBB104_135 +.LBB104_138: + cbz w8, .LBB104_148 +// %bb.139: + ldrh w10, [x13, :lo12:c_ftl_nand_page_pre_blk] + mvn w11, w14 + add w10, w10, w11 + add x11, x19, #16 // =16 + b .LBB104_141 +.LBB104_140: // in Loop: Header=BB104_141 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB104_148 +.LBB104_141: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x11] + cmn w12, #1 // =1 + b.eq .LBB104_140 +// %bb.142: // in Loop: Header=BB104_141 Depth=1 + add w9, w10, w9 + strh w9, [x19, #4] + b .LBB104_140 +.LBB104_143: + strh w28, [x19, #2] + strh wzr, [x19, #4] + adrp x8, c_ftl_nand_planes_num + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + cbz x8, .LBB104_148 +// %bb.144: + mov x9, xzr + add x10, x19, #16 // =16 +.LBB104_145: // =>This Inner Loop Header: Depth=1 + ldrsh w11, [x10, x9, lsl #1] + cmn w11, #1 // =1 + b.ne .LBB104_147 +// %bb.146: // in Loop: Header=BB104_145 Depth=1 + add x9, x9, #1 // =1 + cmp x8, x9 + b.ne .LBB104_145 + b .LBB104_148 +.LBB104_147: + strb w9, [x19, #6] +.LBB104_148: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB104_150 +// %bb.149: + ldp x20, x19, [sp, #144] // 16-byte Folded Reload + ldp x22, x21, [sp, #128] // 16-byte Folded Reload + ldp x24, x23, [sp, #112] // 16-byte Folded Reload + ldp x26, x25, [sp, #96] // 16-byte Folded Reload + ldp x28, x27, [sp, #80] // 16-byte Folded Reload + ldp x29, x30, [sp, #64] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #160 // =160 + hint #29 + ret +.LBB104_150: + bl __stack_chk_fail +.Lfunc_end104: + .size FtlRecoverySuperblock, .Lfunc_end104-FtlRecoverySuperblock + // -- End function + .globl FtlSlcSuperblockCheck // -- Begin function FtlSlcSuperblockCheck + .p2align 2 + .type FtlSlcSuperblockCheck,@function +FtlSlcSuperblockCheck: // @FtlSlcSuperblockCheck +// %bb.0: + hint #25 + ldrh w8, [x0, #4] + cbz w8, .LBB105_3 +// %bb.1: + ldrsh w8, [x0] + cmn w8, #1 // =1 + b.eq .LBB105_3 +// %bb.2: + ldrb w9, [x0, #6] + add x8, x0, x9, lsl #1 + ldrsh w8, [x8, #16] + cmn w8, #1 // =1 + b.eq .LBB105_4 +.LBB105_3: + hint #29 + ret +.LBB105_4: + adrp x8, c_ftl_nand_planes_num + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + // kill: def $w9 killed $w9 killed $x9 def $x9 + b .LBB105_6 +.LBB105_5: // in Loop: Header=BB105_6 Depth=1 + add x10, x0, w9, uxtb #1 + ldrsh w10, [x10, #16] + cmn w10, #1 // =1 + b.ne .LBB105_8 +.LBB105_6: // =>This Inner Loop Header: Depth=1 + add w9, w9, #1 // =1 + cmp w8, w9, uxtb + b.ne .LBB105_5 +// %bb.7: // in Loop: Header=BB105_6 Depth=1 + ldrh w10, [x0, #2] + mov w9, wzr + add w10, w10, #1 // =1 + strh w10, [x0, #2] + b .LBB105_5 +.LBB105_8: + strb w9, [x0, #6] + hint #29 + ret +.Lfunc_end105: + .size FtlSlcSuperblockCheck, .Lfunc_end105-FtlSlcSuperblockCheck + // -- End function + .globl FtlPowerLostRecovery // -- Begin function FtlPowerLostRecovery + .p2align 2 + .type FtlPowerLostRecovery,@function +FtlPowerLostRecovery: // @FtlPowerLostRecovery +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + adrp x19, g_active_superblock + add x19, x19, :lo12:g_active_superblock + adrp x8, g_recovery_page_num + mov x0, x19 + mov x29, sp + str wzr, [x8, :lo12:g_recovery_page_num] + bl FtlRecoverySuperblock + ldrh w8, [x19, #4] + cbz w8, .LBB106_8 +// %bb.1: + ldrh w8, [x19] + mov w9, #65535 + cmp w8, w9 + b.eq .LBB106_8 +// %bb.2: + ldrb w9, [x19, #6] + add x8, x19, x9, lsl #1 + ldrsh w8, [x8, #16] + cmn w8, #1 // =1 + b.ne .LBB106_8 +// %bb.3: + adrp x8, c_ftl_nand_planes_num + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + adrp x10, g_active_superblock+2 + // kill: def $w9 killed $w9 killed $x9 def $x9 + b .LBB106_5 +.LBB106_4: // in Loop: Header=BB106_5 Depth=1 + add x11, x19, w9, uxtb #1 + ldrsh w11, [x11, #16] + cmn w11, #1 // =1 + b.ne .LBB106_7 +.LBB106_5: // =>This Inner Loop Header: Depth=1 + add w9, w9, #1 // =1 + cmp w8, w9, uxtb + b.ne .LBB106_4 +// %bb.6: // in Loop: Header=BB106_5 Depth=1 + ldrh w11, [x10, :lo12:g_active_superblock+2] + mov w9, wzr + add w11, w11, #1 // =1 + strh w11, [x10, :lo12:g_active_superblock+2] + b .LBB106_4 +.LBB106_7: + adrp x8, g_active_superblock+6 + strb w9, [x8, :lo12:g_active_superblock+6] +.LBB106_8: + adrp x19, g_buffer_superblock + add x19, x19, :lo12:g_buffer_superblock + mov x0, x19 + bl FtlRecoverySuperblock + ldrh w8, [x19, #4] + cbz w8, .LBB106_16 +// %bb.9: + ldrh w8, [x19] + mov w9, #65535 + cmp w8, w9 + b.eq .LBB106_16 +// %bb.10: + ldrb w9, [x19, #6] + add x8, x19, x9, lsl #1 + ldrsh w8, [x8, #16] + cmn w8, #1 // =1 + b.ne .LBB106_16 +// %bb.11: + adrp x8, c_ftl_nand_planes_num + ldrh w8, [x8, :lo12:c_ftl_nand_planes_num] + adrp x10, g_buffer_superblock+2 + // kill: def $w9 killed $w9 killed $x9 def $x9 + b .LBB106_13 +.LBB106_12: // in Loop: Header=BB106_13 Depth=1 + add x11, x19, w9, uxtb #1 + ldrsh w11, [x11, #16] + cmn w11, #1 // =1 + b.ne .LBB106_15 +.LBB106_13: // =>This Inner Loop Header: Depth=1 + add w9, w9, #1 // =1 + cmp w8, w9, uxtb + b.ne .LBB106_12 +// %bb.14: // in Loop: Header=BB106_13 Depth=1 + ldrh w11, [x10, :lo12:g_buffer_superblock+2] + mov w9, wzr + add w11, w11, #1 // =1 + strh w11, [x10, :lo12:g_buffer_superblock+2] + b .LBB106_12 +.LBB106_15: + adrp x8, g_buffer_superblock+6 + strb w9, [x8, :lo12:g_buffer_superblock+6] +.LBB106_16: + bl FtlGcPageRecovery + adrp x19, g_tmp_data_superblock_id + ldrh w0, [x19, :lo12:g_tmp_data_superblock_id] + mov w20, #65535 + cmp w0, w20 + b.eq .LBB106_20 +// %bb.17: + bl update_vpc_list + adrp x8, p_data_block_list_head + adrp x9, p_data_block_list_table + ldr w8, [x8, :lo12:p_data_block_list_head] + ldr w9, [x9, :lo12:p_data_block_list_table] + adrp x10, p_valid_page_count_table + ldr x10, [x10, :lo12:p_valid_page_count_table] + strh w20, [x19, :lo12:g_tmp_data_superblock_id] + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and x8, x8, #0xffff + ldrh w9, [x10, x8, lsl #1] + cbnz w9, .LBB106_21 +// %bb.18: + mov w9, #65535 + cmp x8, x9 + b.eq .LBB106_21 +// %bb.19: + adrp x0, .L.str.78 + adrp x1, .L__func__.decrement_vpc_count + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.decrement_vpc_count + mov w2, #2869 + bl sftl_printk + b .LBB106_21 +.LBB106_20: + strh w20, [x19, :lo12:g_tmp_data_superblock_id] +.LBB106_21: + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end106: + .size FtlPowerLostRecovery, .Lfunc_end106-FtlPowerLostRecovery + // -- End function + .globl FtlGcPageRecovery // -- Begin function FtlGcPageRecovery + .p2align 2 + .type FtlGcPageRecovery,@function +FtlGcPageRecovery: // @FtlGcPageRecovery +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + adrp x20, c_ftl_nand_page_pre_blk + ldrh w1, [x20, :lo12:c_ftl_nand_page_pre_blk] + adrp x19, g_gc_temp_superblock + add x19, x19, :lo12:g_gc_temp_superblock + mov x0, x19 + mov x29, sp + bl FtlGcScanTempBlk + ldrh w8, [x19, #2] + ldrh w9, [x20, :lo12:c_ftl_nand_page_pre_blk] + cmp w8, w9 + b.lo .LBB107_7 +// %bb.1: + adrp x8, gL2pMapInfo+6 + add x8, x8, :lo12:gL2pMapInfo+6 + ldur w9, [x8, #50] + cbz w9, .LBB107_6 +// %bb.2: + ldrh w8, [x8] + adrp x9, gL2pMapInfo+40 + adrp x10, p_sys_data_buf_1 + adrp x12, p_sys_spare_buf + add x9, x9, :lo12:gL2pMapInfo+40 + ldr x0, [x10, :lo12:p_sys_data_buf_1] + ldr x10, [x12, :lo12:p_sys_spare_buf] + ldr x13, [x9] + adrp x11, req_sys+4 + add x11, x11, :lo12:req_sys+4 + sub w19, w8, #1 // =1 + str wzr, [x9, #16] + stur x0, [x11, #4] + stur x10, [x11, #12] + and x8, x19, #0xffff + ldr w8, [x13, x8, lsl #2] + str w8, [x11] + cbz w8, .LBB107_4 +// %bb.3: + adrp x0, req_sys + add x0, x0, :lo12:req_sys + mov w1, #1 + bl FlashReadPages + b .LBB107_5 +.LBB107_4: + adrp x8, c_ftl_nand_byte_pre_page + ldrh w2, [x8, :lo12:c_ftl_nand_byte_pre_page] + mov w1, #255 + bl memset +.LBB107_5: + adrp x8, req_sys+8 + ldr x2, [x8, :lo12:req_sys+8] + adrp x0, gL2pMapInfo + and w1, w19, #0xffff + add x0, x0, :lo12:gL2pMapInfo + bl FtlMapWritePage +.LBB107_6: + mov w0, wzr + bl FtlGcFreeTempBlock + adrp x8, ftl_gc_temp_power_lost_recovery_flag + str wzr, [x8, :lo12:ftl_gc_temp_power_lost_recovery_flag] +.LBB107_7: + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end107: + .size FtlGcPageRecovery, .Lfunc_end107-FtlGcPageRecovery + // -- End function + .globl SupperBlkListInit // -- Begin function SupperBlkListInit + .p2align 2 + .type SupperBlkListInit,@function +SupperBlkListInit: // @SupperBlkListInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-96]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_blk_pre_plane + ldrh w8, [x8, :lo12:c_ftl_nand_blk_pre_plane] + stp x22, x21, [sp, #64] // 16-byte Folded Spill + adrp x22, p_data_block_list_table + ldr x0, [x22, :lo12:p_data_block_list_table] + add x8, x8, x8, lsl #1 + lsl x2, x8, #1 + mov w1, wzr + stp x28, x27, [sp, #16] // 16-byte Folded Spill + stp x26, x25, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #48] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + mov x29, sp + bl memset + adrp x8, p_free_data_block_list_head + adrp x27, c_ftl_nand_data_blks_per_plane + str xzr, [x8, :lo12:p_free_data_block_list_head] + ldrh w8, [x27, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x9, p_data_block_list_head + adrp x10, p_data_block_list_tail + str xzr, [x9, :lo12:p_data_block_list_head] + str xzr, [x10, :lo12:p_data_block_list_tail] + adrp x9, g_num_data_superblocks + adrp x10, g_num_free_superblocks + strh wzr, [x9, :lo12:g_num_data_superblocks] + strh wzr, [x10, :lo12:g_num_free_superblocks] + cbz w8, .LBB108_17 +// %bb.1: + adrp x24, gBbtInfo + mov x19, xzr + mov w25, wzr + mov w26, wzr + adrp x28, c_ftl_nand_planes_num + adrp x23, p_valid_page_count_table + mov w21, #6 + adrp x20, g_active_superblock + add x24, x24, :lo12:gBbtInfo + b .LBB108_4 +.LBB108_2: // in Loop: Header=BB108_4 Depth=1 + mov w0, w19 + add w25, w25, #1 // =1 + bl INSERT_FREE_LIST +.LBB108_3: // in Loop: Header=BB108_4 Depth=1 + ldrh w8, [x27, :lo12:c_ftl_nand_data_blks_per_plane] + add x19, x19, #1 // =1 + cmp x19, x8 + b.hs .LBB108_16 +.LBB108_4: // =>This Loop Header: Depth=1 + // Child Loop BB108_6 Depth 2 + ldrh w9, [x28, :lo12:c_ftl_nand_planes_num] + cbz x9, .LBB108_9 +// %bb.5: // in Loop: Header=BB108_4 Depth=1 + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x11, c_ftl_nand_blks_per_die + adrp x12, c_ftl_nand_page_pre_blk + ldrh w11, [x11, :lo12:c_ftl_nand_blks_per_die] + ldrh w12, [x12, :lo12:c_ftl_nand_page_pre_blk] + adrp x14, p_plane_order_table + mov w8, wzr + mul w13, w10, w19 + add x14, x14, :lo12:p_plane_order_table +.LBB108_6: // Parent Loop BB108_4 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrb w15, [x14], #1 + and w16, w10, #0xffff + and w17, w15, #0xffff + udiv w16, w17, w16 + msub w15, w16, w10, w15 + madd w16, w11, w16, w13 + add w15, w16, w15 + and w17, w11, #0xffff + and w16, w15, #0xffff + udiv w16, w16, w17 + add x17, x24, w16, uxtw #3 + ldr x17, [x17, #32] + msub w15, w16, w11, w15 + lsr w16, w15, #3 + and x16, x16, #0x1ffc + ldr w16, [x17, x16] + lsr w15, w16, w15 + tst w15, #0x1 + csel w15, w12, wzr, eq + subs x9, x9, #1 // =1 + add w8, w15, w8 + b.ne .LBB108_6 +// %bb.7: // in Loop: Header=BB108_4 Depth=1 + tst w8, #0xffff + b.eq .LBB108_9 +// %bb.8: // in Loop: Header=BB108_4 Depth=1 + and w8, w8, #0xffff + mov w9, #32768 + udiv w8, w9, w8 + b .LBB108_10 +.LBB108_9: // in Loop: Header=BB108_4 Depth=1 + ldr x9, [x23, :lo12:p_valid_page_count_table] + mov w8, wzr + mov w10, #65535 + strh w10, [x9, x19, lsl #1] +.LBB108_10: // in Loop: Header=BB108_4 Depth=1 + ldr x9, [x22, :lo12:p_data_block_list_table] + madd x9, x19, x21, x9 + strh w8, [x9, #4] + ldrh w8, [x20, :lo12:g_active_superblock] + cmp x19, x8 + b.eq .LBB108_3 +// %bb.11: // in Loop: Header=BB108_4 Depth=1 + adrp x8, g_buffer_superblock + ldrh w8, [x8, :lo12:g_buffer_superblock] + cmp x19, x8 + b.eq .LBB108_3 +// %bb.12: // in Loop: Header=BB108_4 Depth=1 + adrp x8, g_gc_temp_superblock + ldrh w8, [x8, :lo12:g_gc_temp_superblock] + cmp x19, x8 + b.eq .LBB108_3 +// %bb.13: // in Loop: Header=BB108_4 Depth=1 + ldr x8, [x23, :lo12:p_valid_page_count_table] + ldrh w8, [x8, x19, lsl #1] + cbz w8, .LBB108_2 +// %bb.14: // in Loop: Header=BB108_4 Depth=1 + mov w0, w19 + add w26, w26, #1 // =1 + bl insert_data_list + adrp x10, g_num_data_superblocks + ldrh w8, [x10, :lo12:g_num_data_superblocks] + ldrh w9, [x27, :lo12:c_ftl_nand_data_blks_per_plane] + add w8, w8, #1 // =1 + cmp w9, w8, uxth + strh w8, [x10, :lo12:g_num_data_superblocks] + b.hs .LBB108_3 +// %bb.15: // in Loop: Header=BB108_4 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + mov w2, #214 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + bl sftl_printk + b .LBB108_3 +.LBB108_16: + adrp x10, g_num_free_superblocks + b .LBB108_18 +.LBB108_17: + mov w26, wzr + mov w25, wzr +.LBB108_18: + adrp x9, g_num_data_superblocks + strh w26, [x9, :lo12:g_num_data_superblocks] + and w9, w25, #0xffff + add w9, w9, w26, uxth + cmp w9, w8 + strh w25, [x10, :lo12:g_num_free_superblocks] + b.ls .LBB108_20 +// %bb.19: + adrp x0, .L.str.78 + adrp x1, .L__func__.SupperBlkListInit + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.SupperBlkListInit + mov w2, #2219 + bl sftl_printk +.LBB108_20: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x24, x23, [sp, #48] // 16-byte Folded Reload + ldp x26, x25, [sp, #32] // 16-byte Folded Reload + ldp x28, x27, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #96 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end108: + .size SupperBlkListInit, .Lfunc_end108-SupperBlkListInit + // -- End function + .globl Ftl_load_ext_data // -- Begin function Ftl_load_ext_data + .p2align 2 + .type Ftl_load_ext_data,@function +Ftl_load_ext_data: // @Ftl_load_ext_data +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + adrp x19, g_sys_ext_data + add x19, x19, :lo12:g_sys_ext_data + mov w20, #19539 + mov w1, #1 + mov w0, wzr + mov x2, x19 + mov x29, sp + movk w20, #18004, lsl #16 + bl FtlVendorPartRead + ldr w8, [x19] + cmp w8, w20 + b.ne .LBB109_2 +// %bb.1: + adrp x12, g_sys_ext_data+8 + add x12, x12, :lo12:g_sys_ext_data+8 + ldp w0, w18, [x12, #80] + ldp w17, w16, [x12] + ldp w15, w14, [x12, #8] + ldp w8, w13, [x12, #20] + ldp w9, w11, [x12, #28] + ldp w10, w12, [x12, #36] + b .LBB109_3 +.LBB109_2: + add x0, x19, #4 // =4 + mov w2, #508 + mov w1, wzr + bl memset + mov w12, wzr + mov w10, wzr + mov w11, wzr + mov w9, wzr + mov w13, wzr + mov w8, wzr + mov w14, wzr + mov w15, wzr + mov w16, wzr + mov w17, wzr + mov w18, wzr + mov w0, wzr + str w20, [x19] +.LBB109_3: + adrp x1, g_totle_write_sector + str w0, [x1, :lo12:g_totle_write_sector] + adrp x0, g_totle_read_sector + adrp x1, g_totle_gc_page_count + str w18, [x0, :lo12:g_totle_read_sector] + adrp x18, g_totle_write_page_count + adrp x0, g_totle_read_page_count + str w17, [x1, :lo12:g_totle_gc_page_count] + adrp x17, g_totle_l2p_write_count + str w16, [x18, :lo12:g_totle_write_page_count] + adrp x16, g_totle_sys_slc_erase_count + adrp x18, g_totle_discard_page_count + str w15, [x0, :lo12:g_totle_read_page_count] + adrp x15, g_totle_cache_write_count + str w14, [x17, :lo12:g_totle_l2p_write_count] + adrp x17, g_totle_mlc_erase_count + str w13, [x16, :lo12:g_totle_sys_slc_erase_count] + adrp x13, c_mlc_erase_count_value + adrp x16, c_ftl_nand_data_blks_per_plane + str w9, [x18, :lo12:g_totle_discard_page_count] + str w11, [x15, :lo12:g_totle_cache_write_count] + ldr w9, [x17, :lo12:g_totle_mlc_erase_count] + ldrh w11, [x13, :lo12:c_mlc_erase_count_value] + ldrh w13, [x16, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x1, g_totle_slc_erase_count + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + str w8, [x1, :lo12:g_totle_slc_erase_count] + madd w8, w9, w11, w8 + adrp x0, g_max_erase_count + adrp x14, g_min_erase_count + udiv w8, w8, w13 + adrp x9, g_totle_avg_erase_count + str w10, [x0, :lo12:g_max_erase_count] + str w12, [x14, :lo12:g_min_erase_count] + str w8, [x9, :lo12:g_totle_avg_erase_count] + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end109: + .size Ftl_load_ext_data, .Lfunc_end109-Ftl_load_ext_data + // -- End function + .globl FtlSuperblockPowerLostFix // -- Begin function FtlSuperblockPowerLostFix + .p2align 2 + .type FtlSuperblockPowerLostFix,@function +FtlSuperblockPowerLostFix: // @FtlSuperblockPowerLostFix +// %bb.0: + hint #25 + sub sp, sp, #96 // =96 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #48] // 16-byte Folded Spill + add x29, sp, #48 // =48 + stp x22, x21, [sp, #64] // 16-byte Folded Spill + stp x20, x19, [sp, #80] // 16-byte Folded Spill + adrp x10, p_sys_data_buf + adrp x11, p_sys_spare_buf + stur x8, [x29, #-8] + ldr x8, [x10, :lo12:p_sys_data_buf] + ldr x20, [x11, :lo12:p_sys_spare_buf] + mov w9, #-1 + str w9, [sp, #32] + mov x9, #-3 + movk x9, #65534, lsl #32 + stp x8, x20, [sp, #16] + str x9, [x20, #8] + ldrh w8, [x0] + strh wzr, [x20] + mov w9, #61589 + mov x19, x0 + strh w8, [x20, #2] + ldr x8, [x10, :lo12:p_sys_data_buf] + str w9, [x8] + ldr x8, [x10, :lo12:p_sys_data_buf] + mov w9, #22136 + movk w9, #4660, lsl #16 + str w9, [x8, #4] + ldrh w8, [x0, #4] + cbz w8, .LBB110_5 +// %bb.1: + tst w8, #0x1 + mov w8, #6 + cinc w21, w8, ne + adrp x22, g_GlobalDataVersion +.LBB110_2: // =>This Inner Loop Header: Depth=1 + mov x0, x19 + bl get_new_active_ppa + cmn w0, #1 // =1 + str w0, [sp, #12] + b.eq .LBB110_5 +// %bb.3: // in Loop: Header=BB110_2 Depth=1 + ldr w8, [x22, :lo12:g_GlobalDataVersion] + add x0, sp, #8 // =8 + mov w1, #1 + mov w2, wzr + add w9, w8, #1 // =1 + cmn w9, #1 // =1 + str w8, [x20, #4] + csinc w8, wzr, w8, eq + str w8, [x22, :lo12:g_GlobalDataVersion] + bl FlashProgPages + ldrh w0, [x19] + bl decrement_vpc_count + subs w21, w21, #1 // =1 + b.eq .LBB110_5 +// %bb.4: // in Loop: Header=BB110_2 Depth=1 + ldrh w8, [x19, #4] + cbnz w8, .LBB110_2 +.LBB110_5: + adrp x8, p_valid_page_count_table + ldrh w9, [x19] + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldrh w10, [x19, #4] + lsl x9, x9, #1 + ldrh w11, [x8, x9] + sub w10, w11, w10 + adrp x11, c_ftl_nand_page_pre_blk + strh w10, [x8, x9] + ldrh w8, [x11, :lo12:c_ftl_nand_page_pre_blk] + strb wzr, [x19, #6] + strh wzr, [x19, #4] + adrp x9, __stack_chk_guard + strh w8, [x19, #2] + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB110_7 +// %bb.6: + ldp x20, x19, [sp, #80] // 16-byte Folded Reload + ldp x22, x21, [sp, #64] // 16-byte Folded Reload + ldp x29, x30, [sp, #48] // 16-byte Folded Reload + add sp, sp, #96 // =96 + hint #29 + ret +.LBB110_7: + bl __stack_chk_fail +.Lfunc_end110: + .size FtlSuperblockPowerLostFix, .Lfunc_end110-FtlSuperblockPowerLostFix + // -- End function + .globl FtlVpcCheckAndModify // -- Begin function FtlVpcCheckAndModify + .p2align 2 + .type FtlVpcCheckAndModify,@function +FtlVpcCheckAndModify: // @FtlVpcCheckAndModify +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + adrp x0, .L.str.102 + adrp x1, .L__func__.FtlVpcCheckAndModify + add x0, x0, :lo12:.L.str.102 + add x1, x1, :lo12:.L__func__.FtlVpcCheckAndModify + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + str x8, [sp, #8] + bl sftl_printk + adrp x8, c_ftl_nand_blk_pre_plane + adrp x25, p_valid_page_count_check_table + ldrh w8, [x8, :lo12:c_ftl_nand_blk_pre_plane] + ldr x0, [x25, :lo12:p_valid_page_count_check_table] + mov w1, wzr + lsl x2, x8, #1 + bl memset + adrp x20, g_MaxLpn + ldr w8, [x20, :lo12:g_MaxLpn] + cbz w8, .LBB111_5 +// %bb.1: + mov w19, wzr + adrp x21, c_ftl_nand_blks_per_die + adrp x22, c_ftl_nand_planes_per_die + b .LBB111_3 +.LBB111_2: // in Loop: Header=BB111_3 Depth=1 + ldr w8, [x20, :lo12:g_MaxLpn] + add w19, w19, #1 // =1 + cmp w19, w8 + b.hs .LBB111_5 +.LBB111_3: // =>This Inner Loop Header: Depth=1 + add x1, sp, #4 // =4 + mov w0, w19 + mov w2, wzr + bl log2phys + ldr w8, [sp, #4] + cmn w8, #1 // =1 + b.eq .LBB111_2 +// %bb.4: // in Loop: Header=BB111_3 Depth=1 + ldrh w9, [x21, :lo12:c_ftl_nand_blks_per_die] + ldrh w10, [x22, :lo12:c_ftl_nand_planes_per_die] + ubfx w8, w8, #10, #16 + ldr x12, [x25, :lo12:p_valid_page_count_check_table] + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w8, w8, w10 + lsl x8, x8, #1 + ldrh w9, [x12, x8] + add w9, w9, #1 // =1 + strh w9, [x12, x8] + b .LBB111_2 +.LBB111_5: + adrp x26, c_ftl_nand_data_blks_per_plane + ldrh w8, [x26, :lo12:c_ftl_nand_data_blks_per_plane] + cbz w8, .LBB111_30 +// %bb.6: + adrp x24, .L.str.103 + mov x27, xzr + mov x19, xzr + adrp x28, p_valid_page_count_table + mov w22, #65535 + add x24, x24, :lo12:.L.str.103 + adrp x20, g_active_superblock + adrp x23, g_gc_temp_superblock + b .LBB111_9 +.LBB111_7: // in Loop: Header=BB111_9 Depth=1 + mov w0, w19 + bl update_vpc_list +.LBB111_8: // in Loop: Header=BB111_9 Depth=1 + ldrh w8, [x26, :lo12:c_ftl_nand_data_blks_per_plane] + add x19, x19, #1 // =1 + add x27, x27, #6 // =6 + cmp x19, x8 + b.hs .LBB111_30 +.LBB111_9: // =>This Inner Loop Header: Depth=1 + ldr x8, [x28, :lo12:p_valid_page_count_table] + lsl x21, x19, #1 + ldrh w2, [x8, x21] + cmp w2, w22 + b.eq .LBB111_8 +// %bb.10: // in Loop: Header=BB111_9 Depth=1 + ldr x8, [x25, :lo12:p_valid_page_count_check_table] + ldrh w3, [x8, x21] + cmp w2, w3 + b.eq .LBB111_8 +// %bb.11: // in Loop: Header=BB111_9 Depth=1 + mov x0, x24 + mov w1, w19 + bl sftl_printk + ldrh w8, [x20, :lo12:g_active_superblock] + cmp x19, x8 + b.eq .LBB111_8 +// %bb.12: // in Loop: Header=BB111_9 Depth=1 + ldrh w8, [x23, :lo12:g_gc_temp_superblock] + cmp x19, x8 + b.eq .LBB111_8 +// %bb.13: // in Loop: Header=BB111_9 Depth=1 + adrp x8, g_buffer_superblock + ldrh w8, [x8, :lo12:g_buffer_superblock] + cmp x19, x8 + b.eq .LBB111_8 +// %bb.14: // in Loop: Header=BB111_9 Depth=1 + ldr x8, [x28, :lo12:p_valid_page_count_table] + ldr x9, [x25, :lo12:p_valid_page_count_check_table] + ldrh w10, [x8, x21] + ldrh w9, [x9, x21] + strh w9, [x8, x21] + cbnz w10, .LBB111_7 +// %bb.15: // in Loop: Header=BB111_9 Depth=1 + adrp x8, p_data_block_list_table + ldr x21, [x8, :lo12:p_data_block_list_table] + adrp x9, p_free_data_block_list_head + ldr x9, [x9, :lo12:p_free_data_block_list_head] + add x24, x21, x27 + ldrsh w8, [x24, #2] + cmn w8, #1 // =1 + b.ne .LBB111_18 +// %bb.16: // in Loop: Header=BB111_9 Depth=1 + cmp x24, x9 + b.eq .LBB111_18 +// %bb.17: // in Loop: Header=BB111_9 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.List_remove_node + mov w2, #372 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_remove_node + bl sftl_printk + adrp x8, p_free_data_block_list_head + ldr x9, [x8, :lo12:p_free_data_block_list_head] +.LBB111_18: // in Loop: Header=BB111_9 Depth=1 + ldrh w8, [x21, x27] + cmp x24, x9 + b.eq .LBB111_21 +// %bb.19: // in Loop: Header=BB111_9 Depth=1 + cmp w8, w22 + b.eq .LBB111_23 +// %bb.20: // in Loop: Header=BB111_9 Depth=1 + adrp x11, p_data_block_list_table + ldr x9, [x11, :lo12:p_data_block_list_table] + ldrh w10, [x24, #2] + mov w12, #6 + madd x8, x8, x12, x9 + strh w10, [x8, #2] + ldrh w9, [x24, #2] + ldr x8, [x11, :lo12:p_data_block_list_table] + ldrh w10, [x21, x27] + mul x9, x9, x12 + strh w10, [x8, x9] + b .LBB111_26 +.LBB111_21: // in Loop: Header=BB111_9 Depth=1 + cmp w8, w22 + b.eq .LBB111_25 +// %bb.22: // in Loop: Header=BB111_9 Depth=1 + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + mov w10, #6 + madd x8, x8, x10, x9 + adrp x9, p_free_data_block_list_head + str x8, [x9, :lo12:p_free_data_block_list_head] + strh w22, [x8, #2] + b .LBB111_26 +.LBB111_23: // in Loop: Header=BB111_9 Depth=1 + ldrh w8, [x24, #2] + cmp x8, x22 + b.eq .LBB111_26 +// %bb.24: // in Loop: Header=BB111_9 Depth=1 + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + mov w10, #6 + mul x8, x8, x10 + strh w22, [x9, x8] + b .LBB111_26 +.LBB111_25: // in Loop: Header=BB111_9 Depth=1 + adrp x8, p_free_data_block_list_head + str xzr, [x8, :lo12:p_free_data_block_list_head] +.LBB111_26: // in Loop: Header=BB111_9 Depth=1 + strh w22, [x21, x27] + strh w22, [x24, #2] + adrp x21, g_num_free_superblocks + ldrh w8, [x21, :lo12:g_num_free_superblocks] + cbnz w8, .LBB111_28 +// %bb.27: // in Loop: Header=BB111_9 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlVpcCheckAndModify + mov w2, #2330 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlVpcCheckAndModify + bl sftl_printk + ldrh w8, [x21, :lo12:g_num_free_superblocks] +.LBB111_28: // in Loop: Header=BB111_9 Depth=1 + sub w8, w8, #1 // =1 + mov w0, w19 + strh w8, [x21, :lo12:g_num_free_superblocks] + bl insert_data_list + adrp x10, g_num_data_superblocks + ldrh w8, [x10, :lo12:g_num_data_superblocks] + ldrh w9, [x26, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x24, .L.str.103 + add x24, x24, :lo12:.L.str.103 + add w8, w8, #1 // =1 + cmp w9, w8, uxth + strh w8, [x10, :lo12:g_num_data_superblocks] + b.hs .LBB111_8 +// %bb.29: // in Loop: Header=BB111_9 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + mov w2, #214 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + bl sftl_printk + b .LBB111_8 +.LBB111_30: + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB111_35 +// %bb.31: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB111_33 +.LBB111_32: // in Loop: Header=BB111_33 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB111_35 +.LBB111_33: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB111_32 +// %bb.34: // in Loop: Header=BB111_33 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB111_32 +.LBB111_35: + bl FtlVpcTblFlush + adrp x9, __stack_chk_guard + ldr x8, [sp, #8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB111_37 +// %bb.36: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.LBB111_37: + bl __stack_chk_fail +.Lfunc_end111: + .size FtlVpcCheckAndModify, .Lfunc_end111-FtlVpcCheckAndModify + // -- End function + .globl update_vpc_list // -- Begin function update_vpc_list + .p2align 2 + .type update_vpc_list,@function +update_vpc_list: // @update_vpc_list +// %bb.0: + hint #25 + stp x29, x30, [sp, #-80]! // 16-byte Folded Spill + stp x20, x19, [sp, #64] // 16-byte Folded Spill + adrp x20, p_valid_page_count_table + ldr x8, [x20, :lo12:p_valid_page_count_table] + mov w19, w0 + stp x22, x21, [sp, #48] // 16-byte Folded Spill + and x21, x19, #0xffff + ldrh w8, [x8, x21, lsl #1] + str x25, [sp, #16] // 8-byte Folded Spill + stp x24, x23, [sp, #32] // 16-byte Folded Spill + mov x29, sp + cbz w8, .LBB112_2 +// %bb.1: + mov w0, w19 + bl List_update_data_list + mov w0, wzr + b .LBB112_29 +.LBB112_2: + adrp x8, g_gc_next_blk + ldrh w9, [x8, :lo12:g_gc_next_blk] + cmp w9, w19, uxth + b.ne .LBB112_4 +// %bb.3: + mov w9, #65535 + strh w9, [x8, :lo12:g_gc_next_blk] +.LBB112_4: + adrp x8, g_gc_next_blk_1 + ldrh w9, [x8, :lo12:g_gc_next_blk_1] + cmp w9, w19, uxth + b.ne .LBB112_6 +// %bb.5: + mov w9, #65535 + strh w9, [x8, :lo12:g_gc_next_blk_1] +.LBB112_6: + adrp x8, g_gc_superblock + ldrh w9, [x8, :lo12:g_gc_superblock] + cmp w9, w19, uxth + b.ne .LBB112_8 +// %bb.7: + mov w9, #65535 + strh w9, [x8, :lo12:g_gc_superblock] + b .LBB112_11 +.LBB112_8: + adrp x8, g_active_superblock + ldrh w8, [x8, :lo12:g_active_superblock] + mov w0, wzr + cmp w8, w19, uxth + b.eq .LBB112_29 +// %bb.9: + adrp x8, g_buffer_superblock + ldrh w8, [x8, :lo12:g_buffer_superblock] + cmp w8, w19, uxth + b.eq .LBB112_29 +// %bb.10: + adrp x8, g_gc_temp_superblock + ldrh w8, [x8, :lo12:g_gc_temp_superblock] + cmp w8, w19, uxth + b.eq .LBB112_29 +.LBB112_11: + adrp x24, p_data_block_list_table + ldr x8, [x24, :lo12:p_data_block_list_table] + mov w9, #6 + adrp x25, p_data_block_list_head + madd x22, x21, x9, x8 + mov x23, x22 + ldrsh w8, [x23, #2]! + ldr x9, [x25, :lo12:p_data_block_list_head] + cmn w8, #1 // =1 + b.ne .LBB112_14 +// %bb.12: + cmp x22, x9 + b.eq .LBB112_14 +// %bb.13: + adrp x0, .L.str.78 + adrp x1, .L__func__.List_remove_node + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.List_remove_node + mov w2, #372 + bl sftl_printk + ldr x9, [x25, :lo12:p_data_block_list_head] +.LBB112_14: + ldrh w8, [x22] + cmp x22, x9 + b.eq .LBB112_17 +// %bb.15: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB112_19 +// %bb.16: + ldr x9, [x24, :lo12:p_data_block_list_table] + ldrh w10, [x23] + mov w11, #6 + madd x8, x8, x11, x9 + strh w10, [x8, #2] + ldrh w9, [x23] + ldr x8, [x24, :lo12:p_data_block_list_table] + ldrh w10, [x22] + mul x9, x9, x11 + strh w10, [x8, x9] + b .LBB112_22 +.LBB112_17: + mov w9, #65535 + cmp w8, w9 + b.eq .LBB112_21 +// %bb.18: + ldr x10, [x24, :lo12:p_data_block_list_table] + mov w11, #6 + madd x8, x8, x11, x10 + str x8, [x25, :lo12:p_data_block_list_head] + strh w9, [x8, #2] + b .LBB112_22 +.LBB112_19: + ldrh w8, [x23] + mov w9, #65535 + cmp x8, x9 + b.eq .LBB112_22 +// %bb.20: + ldr x10, [x24, :lo12:p_data_block_list_table] + mov w11, #6 + mul x8, x8, x11 + strh w9, [x10, x8] + b .LBB112_22 +.LBB112_21: + str xzr, [x25, :lo12:p_data_block_list_head] +.LBB112_22: + mov w8, #65535 + strh w8, [x22] + strh w8, [x23] + adrp x22, g_num_data_superblocks + ldrh w8, [x22, :lo12:g_num_data_superblocks] + cbnz w8, .LBB112_24 +// %bb.23: + adrp x0, .L.str.78 + adrp x1, .L__func__.update_vpc_list + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.update_vpc_list + mov w2, #2835 + bl sftl_printk + ldrh w8, [x22, :lo12:g_num_data_superblocks] +.LBB112_24: + mvn w9, w19 + sub w8, w8, #1 // =1 + tst w9, #0xffff + strh w8, [x22, :lo12:g_num_data_superblocks] + b.eq .LBB112_26 +// %bb.25: + ldr x8, [x20, :lo12:p_valid_page_count_table] + mov w0, w19 + strh wzr, [x8, x21, lsl #1] + bl INSERT_FREE_LIST +.LBB112_26: + mov w0, w19 + bl FtlGcFreeBadSuperBlk + adrp x8, g_num_free_superblocks + ldrh w9, [x22, :lo12:g_num_data_superblocks] + ldrh w8, [x8, :lo12:g_num_free_superblocks] + adrp x10, c_ftl_nand_data_blks_per_plane + ldrh w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane] + add w8, w9, w8 + cmp w8, w10 + b.ls .LBB112_28 +// %bb.27: + adrp x0, .L.str.78 + adrp x1, .L__func__.update_vpc_list + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.update_vpc_list + mov w2, #2838 + bl sftl_printk +.LBB112_28: + mov w0, #1 +.LBB112_29: + ldp x20, x19, [sp, #64] // 16-byte Folded Reload + ldp x22, x21, [sp, #48] // 16-byte Folded Reload + ldp x24, x23, [sp, #32] // 16-byte Folded Reload + ldr x25, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #80 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end112: + .size update_vpc_list, .Lfunc_end112-update_vpc_list + // -- End function + .globl ftl_check_vpc // -- Begin function ftl_check_vpc + .p2align 2 + .type ftl_check_vpc,@function +ftl_check_vpc: // @ftl_check_vpc +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + adrp x0, .L.str.102 + adrp x1, .L__func__.ftl_check_vpc + add x0, x0, :lo12:.L.str.102 + add x1, x1, :lo12:.L__func__.ftl_check_vpc + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + add x29, sp, #16 // =16 + str x8, [sp, #8] + bl sftl_printk + adrp x19, check_vpc_table + add x19, x19, :lo12:check_vpc_table + mov w2, #8192 + mov x0, x19 + mov w1, wzr + bl memset + adrp x21, g_MaxLpn + ldr w8, [x21, :lo12:g_MaxLpn] + cbz w8, .LBB113_5 +// %bb.1: + mov w20, wzr + adrp x22, c_ftl_nand_blks_per_die + adrp x23, c_ftl_nand_planes_per_die + b .LBB113_3 +.LBB113_2: // in Loop: Header=BB113_3 Depth=1 + ldr w8, [x21, :lo12:g_MaxLpn] + add w20, w20, #1 // =1 + cmp w20, w8 + b.hs .LBB113_5 +.LBB113_3: // =>This Inner Loop Header: Depth=1 + add x1, sp, #4 // =4 + mov w0, w20 + mov w2, wzr + bl log2phys + ldr w8, [sp, #4] + cmn w8, #1 // =1 + b.eq .LBB113_2 +// %bb.4: // in Loop: Header=BB113_3 Depth=1 + ldrh w9, [x22, :lo12:c_ftl_nand_blks_per_die] + ldrh w10, [x23, :lo12:c_ftl_nand_planes_per_die] + ubfx w8, w8, #10, #16 + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w8, w8, w10 + lsl x8, x8, #1 + ldrh w9, [x19, x8] + add w9, w9, #1 // =1 + strh w9, [x19, x8] + b .LBB113_2 +.LBB113_5: + adrp x24, c_ftl_nand_data_blks_per_plane + ldrh w8, [x24, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x22, p_valid_page_count_table + cbz w8, .LBB113_11 +// %bb.6: + ldr x8, [x22, :lo12:p_valid_page_count_table] + adrp x21, .L.str.104 + mov x20, xzr + mov w23, wzr + add x21, x21, :lo12:.L.str.104 + mov w25, #65535 + b .LBB113_8 +.LBB113_7: // in Loop: Header=BB113_8 Depth=1 + ldrh w9, [x24, :lo12:c_ftl_nand_data_blks_per_plane] + add x20, x20, #1 // =1 + cmp x20, x9 + b.hs .LBB113_12 +.LBB113_8: // =>This Inner Loop Header: Depth=1 + lsl x9, x20, #1 + ldrh w2, [x8, x9] + ldrh w3, [x19, x9] + cmp w2, w3 + b.eq .LBB113_7 +// %bb.9: // in Loop: Header=BB113_8 Depth=1 + mov x0, x21 + mov w1, w20 + bl sftl_printk + ldr x8, [x22, :lo12:p_valid_page_count_table] + ldrh w9, [x8, x20, lsl #1] + cmp w9, w25 + b.eq .LBB113_7 +// %bb.10: // in Loop: Header=BB113_8 Depth=1 + ldrh w10, [x19, x20, lsl #1] + cmp w9, w10 + csinc w23, w23, wzr, hs + b .LBB113_7 +.LBB113_11: + mov w23, wzr +.LBB113_12: + adrp x8, p_free_data_block_list_head + ldr x9, [x8, :lo12:p_free_data_block_list_head] + cbz x9, .LBB113_19 +// %bb.13: + adrp x8, g_num_free_superblocks + ldrh w24, [x8, :lo12:g_num_free_superblocks] + cbz w24, .LBB113_19 +// %bb.14: + adrp x26, p_data_block_list_table + ldr x8, [x26, :lo12:p_data_block_list_table] + mov w10, #43691 + movk w10, #43690, lsl #16 + adrp x20, .L.str.105 + sub x9, x9, x8 + lsr x9, x9, #1 + mov w25, wzr + mov w27, #6 + mov w28, #65535 + mul w9, w9, w10 + add x20, x20, :lo12:.L.str.105 +.LBB113_15: // =>This Inner Loop Header: Depth=1 + ldr x10, [x22, :lo12:p_valid_page_count_table] + and x21, x9, #0xffff + ldrh w2, [x10, x21, lsl #1] + cbz w2, .LBB113_17 +// %bb.16: // in Loop: Header=BB113_15 Depth=1 + ldrh w3, [x19, x21, lsl #1] + mov x0, x20 + mov w1, w21 + bl sftl_printk + ldr x8, [x26, :lo12:p_data_block_list_table] + mov w23, #1 +.LBB113_17: // in Loop: Header=BB113_15 Depth=1 + mul x9, x21, x27 + ldrh w9, [x8, x9] + cmp w9, w28 + b.eq .LBB113_19 +// %bb.18: // in Loop: Header=BB113_15 Depth=1 + add w25, w25, #1 // =1 + cmp w24, w25, uxth + b.hi .LBB113_15 +.LBB113_19: + tst w23, #0xffff + b.eq .LBB113_21 +// %bb.20: + adrp x0, .L.str.78 + adrp x1, .L__func__.ftl_check_vpc + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.ftl_check_vpc + mov w2, #2394 + bl sftl_printk +.LBB113_21: + adrp x9, __stack_chk_guard + ldr x8, [sp, #8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB113_23 +// %bb.22: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.LBB113_23: + bl __stack_chk_fail +.Lfunc_end113: + .size ftl_check_vpc, .Lfunc_end113-ftl_check_vpc + // -- End function + .globl ftl_scan_all_data // -- Begin function ftl_scan_all_data + .p2align 2 + .type ftl_scan_all_data,@function +ftl_scan_all_data: // @ftl_scan_all_data +// %bb.0: + hint #25 + sub sp, sp, #128 // =128 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + adrp x0, .L.str.106 + stp x29, x30, [sp, #32] // 16-byte Folded Spill + add x29, sp, #32 // =32 + add x0, x0, :lo12:.L.str.106 + mov w1, wzr + stp x28, x27, [sp, #48] // 16-byte Folded Spill + stp x26, x25, [sp, #64] // 16-byte Folded Spill + stp x24, x23, [sp, #80] // 16-byte Folded Spill + stp x22, x21, [sp, #96] // 16-byte Folded Spill + stp x20, x19, [sp, #112] // 16-byte Folded Spill + stur x8, [x29, #-8] + bl sftl_printk + adrp x24, g_MaxLpn + ldr w8, [x24, :lo12:g_MaxLpn] + cbz w8, .LBB114_10 +// %bb.1: + adrp x20, .L.str.107 + adrp x21, req_sys + adrp x27, req_sys+4 + adrp x22, .L.str.108 + mov w19, wzr + add x20, x20, :lo12:.L.str.107 + add x21, x21, :lo12:req_sys + adrp x25, p_sys_data_buf + adrp x26, p_sys_spare_buf + add x27, x27, :lo12:req_sys+4 + add x22, x22, :lo12:.L.str.108 + b .LBB114_4 +.LBB114_2: // in Loop: Header=BB114_4 Depth=1 + ldur x8, [x27, #12] + ldur x9, [x27, #4] + ldr w2, [x27] + mov x0, x22 + ldp w3, w4, [x8] + ldp w5, w6, [x8, #8] + ldp w7, w8, [x9] + mov w1, w19 + str w8, [sp] + bl sftl_printk +.LBB114_3: // in Loop: Header=BB114_4 Depth=1 + ldr w8, [x24, :lo12:g_MaxLpn] + add w19, w19, #1 // =1 + cmp w19, w8 + b.hs .LBB114_10 +.LBB114_4: // =>This Inner Loop Header: Depth=1 + sub x1, x29, #12 // =12 + mov w0, w19 + mov w2, wzr + bl log2phys + ldur w23, [x29, #-12] + tst w19, #0x7ff + b.eq .LBB114_6 +// %bb.5: // in Loop: Header=BB114_4 Depth=1 + cmn w23, #1 // =1 + b.ne .LBB114_7 + b .LBB114_3 +.LBB114_6: // in Loop: Header=BB114_4 Depth=1 + mov x0, x20 + mov w1, w19 + mov w2, w23 + bl sftl_printk + cmn w23, #1 // =1 + b.eq .LBB114_3 +.LBB114_7: // in Loop: Header=BB114_4 Depth=1 + ldr x8, [x25, :lo12:p_sys_data_buf] + ldr x28, [x26, :lo12:p_sys_spare_buf] + mov w1, #1 + mov x0, x21 + str w19, [x21, #24] + stp x8, x28, [x21, #8] + stp wzr, w23, [x21] + bl FlashReadPages + ldr w8, [x21] + cmn w8, #1 // =1 + b.eq .LBB114_2 +// %bb.8: // in Loop: Header=BB114_4 Depth=1 + cmp w8, #256 // =256 + b.eq .LBB114_2 +// %bb.9: // in Loop: Header=BB114_4 Depth=1 + ldr w8, [x28, #8] + cmp w19, w8 + b.ne .LBB114_2 + b .LBB114_3 +.LBB114_10: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB114_12 +// %bb.11: + ldp x20, x19, [sp, #112] // 16-byte Folded Reload + ldp x22, x21, [sp, #96] // 16-byte Folded Reload + ldp x24, x23, [sp, #80] // 16-byte Folded Reload + ldp x26, x25, [sp, #64] // 16-byte Folded Reload + ldp x28, x27, [sp, #48] // 16-byte Folded Reload + ldp x29, x30, [sp, #32] // 16-byte Folded Reload + add sp, sp, #128 // =128 + hint #29 + ret +.LBB114_12: + bl __stack_chk_fail +.Lfunc_end114: + .size ftl_scan_all_data, .Lfunc_end114-ftl_scan_all_data + // -- End function + .globl update_multiplier_value // -- Begin function update_multiplier_value + .p2align 2 + .type update_multiplier_value,@function +update_multiplier_value: // @update_multiplier_value +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_planes_num + ldrh w9, [x8, :lo12:c_ftl_nand_planes_num] + mov w8, wzr + // kill: def $w0 killed $w0 def $x0 + cbz x9, .LBB115_6 +// %bb.1: + adrp x10, c_ftl_nand_planes_per_die + adrp x11, c_ftl_nand_blks_per_die + adrp x12, c_ftl_nand_page_pre_blk + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + ldrh w11, [x11, :lo12:c_ftl_nand_blks_per_die] + ldrh w12, [x12, :lo12:c_ftl_nand_page_pre_blk] + adrp x13, p_plane_order_table + adrp x15, gBbtInfo + add x13, x13, :lo12:p_plane_order_table + mul w14, w10, w0 + add x15, x15, :lo12:gBbtInfo +.LBB115_2: // =>This Inner Loop Header: Depth=1 + ldrb w16, [x13], #1 + and w17, w10, #0xffff + and w18, w16, #0xffff + udiv w17, w18, w17 + msub w16, w17, w10, w16 + madd w17, w11, w17, w14 + add w16, w17, w16 + and w18, w11, #0xffff + and w17, w16, #0xffff + udiv w17, w17, w18 + add x18, x15, w17, uxtw #3 + ldr x18, [x18, #32] + msub w16, w17, w11, w16 + lsr w17, w16, #3 + and x17, x17, #0x1ffc + ldr w17, [x18, x17] + lsr w16, w17, w16 + tst w16, #0x1 + csel w16, w12, wzr, eq + subs x9, x9, #1 // =1 + add w8, w16, w8 + b.ne .LBB115_2 +// %bb.3: + tst w8, #0xffff + b.eq .LBB115_5 +// %bb.4: + and w8, w8, #0xffff + mov w9, #32768 + udiv w8, w9, w8 + b .LBB115_6 +.LBB115_5: + mov w8, wzr +.LBB115_6: + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + and x10, x0, #0xffff + mov w11, #6 + mov w0, wzr + madd x9, x10, x11, x9 + strh w8, [x9, #4] + hint #29 + ret +.Lfunc_end115: + .size update_multiplier_value, .Lfunc_end115-update_multiplier_value + // -- End function + .globl GetSwlReplaceBlock // -- Begin function GetSwlReplaceBlock + .p2align 2 + .type GetSwlReplaceBlock,@function +GetSwlReplaceBlock: // @GetSwlReplaceBlock +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x11, g_totle_avg_erase_count + adrp x9, g_min_erase_count + ldr w2, [x11, :lo12:g_totle_avg_erase_count] + ldr w10, [x9, :lo12:g_min_erase_count] + adrp x8, g_max_erase_count + str x19, [sp, #16] // 8-byte Folded Spill + mov x29, sp + cmp w2, w10 + b.hs .LBB116_5 +// %bb.1: + adrp x12, c_ftl_nand_data_blks_per_plane + ldrh w13, [x12, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x12, g_totle_mlc_erase_count + mov w14, wzr + str wzr, [x12, :lo12:g_totle_mlc_erase_count] + cbz w13, .LBB116_4 +// %bb.2: + adrp x15, p_erase_count_table + ldr x15, [x15, :lo12:p_erase_count_table] + cmp w13, #1 // =1 + csinc w16, w13, wzr, hi +.LBB116_3: // =>This Inner Loop Header: Depth=1 + ldrh w17, [x15], #2 + subs x16, x16, #1 // =1 + add w14, w14, w17 + str w14, [x12, :lo12:g_totle_mlc_erase_count] + b.ne .LBB116_3 +.LBB116_4: + adrp x15, g_totle_slc_erase_count + ldr w15, [x15, :lo12:g_totle_slc_erase_count] + adrp x16, c_mlc_erase_count_value + ldrh w16, [x16, :lo12:c_mlc_erase_count_value] + udiv w2, w14, w13 + str w2, [x11, :lo12:g_totle_avg_erase_count] + sub w11, w14, w15 + udiv w11, w11, w16 + str w11, [x12, :lo12:g_totle_mlc_erase_count] + b .LBB116_10 +.LBB116_5: + ldr w13, [x8, :lo12:g_max_erase_count] + cmp w2, w13 + b.ls .LBB116_10 +// %bb.6: + adrp x12, c_ftl_nand_data_blks_per_plane + ldrh w14, [x12, :lo12:c_ftl_nand_data_blks_per_plane] + add w13, w13, #1 // =1 + str w13, [x8, :lo12:g_max_erase_count] + cbz w14, .LBB116_10 +// %bb.7: + mov x10, xzr + adrp x13, p_erase_count_table +.LBB116_8: // =>This Inner Loop Header: Depth=1 + ldr x14, [x13, :lo12:p_erase_count_table] + lsl x15, x10, #1 + add x10, x10, #1 // =1 + ldrh w16, [x14, x15] + add w16, w16, #1 // =1 + strh w16, [x14, x15] + ldrh w14, [x12, :lo12:c_ftl_nand_data_blks_per_plane] + cmp x10, x14 + b.lo .LBB116_8 +// %bb.9: + ldr w10, [x9, :lo12:g_min_erase_count] + ldr w2, [x11, :lo12:g_totle_avg_erase_count] +.LBB116_10: + add w11, w10, #256 // =256 + cmp w11, w2 + b.ls .LBB116_13 +// %bb.11: + ldr w11, [x8, :lo12:g_max_erase_count] + add w12, w10, #768 // =768 + cmp w12, w11 + b.ls .LBB116_13 +.LBB116_12: + mov w0, #65535 + b .LBB116_43 +.LBB116_13: + adrp x11, p_free_data_block_list_head + ldr x11, [x11, :lo12:p_free_data_block_list_head] + cbz x11, .LBB116_18 +// %bb.14: + adrp x12, g_num_free_superblocks + ldrh w13, [x12, :lo12:g_num_free_superblocks] + adrp x12, p_data_block_list_table + ldr x12, [x12, :lo12:p_data_block_list_table] + lsl w15, w13, #3 + add w14, w13, w13, lsl #1 + sub w13, w15, w13 + lsr w14, w14, #2 + lsr w13, w13, #3 + cmp w13, w14 + sub x16, x11, x12 + csel w13, w13, w14, lo + mov w14, #43691 + lsr x15, x16, #1 + movk w14, #43690, lsl #16 + mul w16, w15, w14 + cbz w13, .LBB116_19 +// %bb.15: + mov w14, wzr + mov w15, #6 + mov w17, #65535 +.LBB116_16: // =>This Inner Loop Header: Depth=1 + and x18, x16, #0xffff + mul x18, x18, x15 + ldrh w18, [x12, x18] + mov w0, w16 + cmp w18, w17 + b.eq .LBB116_20 +// %bb.17: // in Loop: Header=BB116_16 Depth=1 + add w14, w14, #1 // =1 + and w16, w14, #0xffff + cmp w16, w13, uxth + mov w16, w18 + mov w0, w18 + b.lo .LBB116_16 + b .LBB116_20 +.LBB116_18: + mov w6, wzr + b .LBB116_21 +.LBB116_19: + mov w0, w16 +.LBB116_20: + adrp x12, p_erase_count_table + ldr x12, [x12, :lo12:p_erase_count_table] + and x13, x0, #0xffff + ldrh w6, [x12, x13, lsl #1] +.LBB116_21: + add w12, w10, #64 // =64 + cmp w12, w6 + mov w0, #65535 + b.hi .LBB116_43 +// %bb.22: + adrp x12, p_data_block_list_head + ldr x5, [x12, :lo12:p_data_block_list_head] + cbz x5, .LBB116_43 +// %bb.23: + ldrh w15, [x5] + mov w0, #65535 + cmp w15, w0 + b.eq .LBB116_43 +// %bb.24: + adrp x12, c_ftl_nand_data_blks_per_plane + adrp x13, p_data_block_list_table + adrp x14, p_erase_count_table + ldrh w17, [x12, :lo12:c_ftl_nand_data_blks_per_plane] + ldr x18, [x13, :lo12:p_data_block_list_table] + ldr x1, [x14, :lo12:p_erase_count_table] + mov x4, #-6148914691236517206 + mov w16, wzr + mov w3, #6 + movk x4, #43691 + mov w12, #65535 + mov w19, #65535 + b .LBB116_26 +.LBB116_25: // in Loop: Header=BB116_26 Depth=1 + and x15, x15, #0xffff + madd x5, x15, x3, x18 + ldrh w15, [x5] + cmp w15, w0 + b.eq .LBB116_31 +.LBB116_26: // =>This Inner Loop Header: Depth=1 + add w16, w16, #1 // =1 + cmp w17, w16, uxth + b.lo .LBB116_12 +// %bb.27: // in Loop: Header=BB116_26 Depth=1 + ldrh w7, [x5, #4] + cbz w7, .LBB116_25 +// %bb.28: // in Loop: Header=BB116_26 Depth=1 + sub x5, x5, x18 + asr x5, x5, #1 + mul x5, x5, x4 + and x7, x5, #0xffff + ldrh w7, [x1, x7, lsl #1] + cmp w10, w7 + b.hs .LBB116_30 +// %bb.29: // in Loop: Header=BB116_26 Depth=1 + cmp w7, w12, uxth + csel w19, w5, w19, lo + csel w12, w7, w12, lo + b .LBB116_25 +.LBB116_30: + mov w19, w5 +.LBB116_31: + and w1, w19, #0xffff + mov w0, #65535 + cmp w1, w0 + b.eq .LBB116_43 +// %bb.32: + ldr x14, [x14, :lo12:p_erase_count_table] + and x15, x19, #0xffff + ldrh w16, [x14, x15, lsl #1] + cmp w10, w16 + b.hs .LBB116_37 +// %bb.33: + cbz x11, .LBB116_35 +// %bb.34: + ldr w13, [x13, :lo12:p_data_block_list_table] + sub w11, w11, w13 + mov w13, #43691 + lsr w11, w11, #1 + movk w13, #43690, lsl #16 + mul w11, w11, w13 + and x11, x11, #0xffff + ldrh w11, [x14, x11, lsl #1] +.LBB116_35: + cmp w10, w11 + b.hs .LBB116_37 +// %bb.36: + and w10, w12, #0xffff + str w10, [x9, :lo12:g_min_erase_count] +.LBB116_37: + cmp w2, w16 + mov w0, #65535 + b.ls .LBB116_43 +// %bb.38: + add w9, w16, #128 // =128 + cmp w9, w6 + b.hs .LBB116_43 +// %bb.39: + add w9, w16, #256 // =256 + cmp w9, w2 + b.hs .LBB116_41 +// %bb.40: + ldr w3, [x8, :lo12:g_max_erase_count] + b .LBB116_42 +.LBB116_41: + ldr w3, [x8, :lo12:g_max_erase_count] + add w8, w16, #768 // =768 + cmp w8, w3 + b.hs .LBB116_12 +.LBB116_42: + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + lsl x9, x15, #1 + ldrh w5, [x14, x9] + adrp x0, .L.str.109 + ldrh w4, [x8, x9] + add x0, x0, :lo12:.L.str.109 + bl sftl_printk + adrp x8, g_in_swl_replace + mov w9, #1 + str w9, [x8, :lo12:g_in_swl_replace] + mov w0, w19 +.LBB116_43: + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end116: + .size GetSwlReplaceBlock, .Lfunc_end116-GetSwlReplaceBlock + // -- End function + .globl free_data_superblock // -- Begin function free_data_superblock + .p2align 2 + .type free_data_superblock,@function +free_data_superblock: // @free_data_superblock +// %bb.0: + hint #34 + // kill: def $w0 killed $w0 def $x0 + mvn w8, w0 + tst w8, #0xffff + b.eq .LBB117_2 +// %bb.1: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + and x9, x0, #0xffff + mov x29, sp + // kill: def $w0 killed $w0 killed $x0 + strh wzr, [x8, x9, lsl #1] + bl INSERT_FREE_LIST + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 +.LBB117_2: + mov w0, wzr + ret +.Lfunc_end117: + .size free_data_superblock, .Lfunc_end117-free_data_superblock + // -- End function + .globl allocate_data_superblock // -- Begin function allocate_data_superblock + .p2align 2 + .type allocate_data_superblock,@function +allocate_data_superblock: // @allocate_data_superblock +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + stp x26, x25, [sp, #48] // 16-byte Folded Spill + adrp x26, .L.str.78 + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + mov x19, x0 + add x24, x0, #16 // =16 + adrp x23, g_num_free_superblocks + adrp x28, g_num_data_superblocks + adrp x21, c_ftl_nand_data_blks_per_plane + add x26, x26, :lo12:.L.str.78 + adrp x27, p_valid_page_count_table + mov w22, #65535 + adrp x20, req_erase + stp x29, x30, [sp, #16] // 16-byte Folded Spill + add x29, sp, #16 // =16 +.LBB118_1: // =>This Loop Header: Depth=1 + // Child Loop BB118_16 Depth 2 + // Child Loop BB118_35 Depth 2 + // Child Loop BB118_39 Depth 2 + // Child Loop BB118_44 Depth 2 + ldrh w8, [x23, :lo12:g_num_free_superblocks] + ldrh w9, [x28, :lo12:g_num_data_superblocks] + ldrh w10, [x21, :lo12:c_ftl_nand_data_blks_per_plane] + add w8, w9, w8 + cmp w8, w10 + b.ls .LBB118_3 +// %bb.2: // in Loop: Header=BB118_1 Depth=1 + adrp x1, .L__func__.allocate_data_superblock + mov w2, #2667 + mov x0, x26 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + bl sftl_printk +.LBB118_3: // in Loop: Header=BB118_1 Depth=1 + adrp x8, g_gc_temp_superblock + add x8, x8, :lo12:g_gc_temp_superblock + cmp x19, x8 + b.eq .LBB118_5 +.LBB118_4: // in Loop: Header=BB118_1 Depth=1 + mov w1, wzr + b .LBB118_6 +.LBB118_5: // in Loop: Header=BB118_1 Depth=1 + adrp x9, g_in_swl_replace + ldrh w8, [x23, :lo12:g_num_free_superblocks] + ldr w9, [x9, :lo12:g_in_swl_replace] + mul w9, w9, w8 + lsr w9, w9, #2 + add w1, w9, w8, lsr #1 + mvn w8, w1 + tst w8, #0xffff + b.eq .LBB118_4 +.LBB118_6: // in Loop: Header=BB118_1 Depth=1 + adrp x0, p_free_data_block_list_head + add x0, x0, :lo12:p_free_data_block_list_head + bl List_pop_index_node + ldrh w8, [x23, :lo12:g_num_free_superblocks] + mov w25, w0 + cbnz w8, .LBB118_8 +// %bb.7: // in Loop: Header=BB118_1 Depth=1 + adrp x1, .L__func__.allocate_data_superblock + mov w2, #2676 + mov x0, x26 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + bl sftl_printk + ldrh w8, [x23, :lo12:g_num_free_superblocks] +.LBB118_8: // in Loop: Header=BB118_1 Depth=1 + ldrh w9, [x21, :lo12:c_ftl_nand_data_blks_per_plane] + sub w10, w8, #1 // =1 + and w8, w25, #0xffff + strh w10, [x23, :lo12:g_num_free_superblocks] + cmp w8, w9 + b.hs .LBB118_1 +// %bb.9: // in Loop: Header=BB118_1 Depth=1 + ldr x9, [x27, :lo12:p_valid_page_count_table] + ldrh w9, [x9, w8, uxtw #1] + mov w8, w8 + cbnz w9, .LBB118_1 +// %bb.10: // in Loop: Header=BB118_1 Depth=1 + mov x0, x19 + str x8, [sp, #8] // 8-byte Folded Spill + strh w25, [x19] + bl make_superblock + ldrb w8, [x19, #7] + cbz w8, .LBB118_25 +// %bb.11: // in Loop: Header=BB118_1 Depth=1 + ldrh w8, [x23, :lo12:g_num_free_superblocks] + ldrh w9, [x28, :lo12:g_num_data_superblocks] + ldrh w10, [x21, :lo12:c_ftl_nand_data_blks_per_plane] + add w8, w9, w8 + cmp w8, w10 + b.ls .LBB118_13 +// %bb.12: // in Loop: Header=BB118_1 Depth=1 + adrp x1, .L__func__.allocate_data_superblock + mov w2, #2693 + mov x0, x26 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + bl sftl_printk +.LBB118_13: // in Loop: Header=BB118_1 Depth=1 + adrp x13, c_ftl_nand_planes_num + ldrh w9, [x13, :lo12:c_ftl_nand_planes_num] + cbz w9, .LBB118_20 +// %bb.14: // in Loop: Header=BB118_1 Depth=1 + mov x8, xzr + mov x10, xzr + mov w21, wzr + b .LBB118_16 +.LBB118_15: // in Loop: Header=BB118_16 Depth=2 + add x10, x10, #1 // =1 + cmp x10, w9, uxth + add x8, x8, #32 // =32 + b.hs .LBB118_18 +.LBB118_16: // Parent Loop BB118_1 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x11, [x20, :lo12:req_erase] + add x11, x11, x8 + str xzr, [x11, #8] + ldr x11, [x20, :lo12:req_erase] + add x11, x11, x8 + str xzr, [x11, #16] + ldrh w11, [x24, x10, lsl #1] + cmp w11, w22 + b.eq .LBB118_15 +// %bb.17: // in Loop: Header=BB118_16 Depth=2 + ldr x9, [x20, :lo12:req_erase] + and x12, x21, #0xffff + lsl w11, w11, #10 + add w21, w21, #1 // =1 + add x9, x9, x12, lsl #5 + str w11, [x9, #4] + ldrh w9, [x13, :lo12:c_ftl_nand_planes_num] + b .LBB118_15 +.LBB118_18: // in Loop: Header=BB118_1 Depth=1 + ands w2, w21, #0xffff + b.eq .LBB118_20 +// %bb.19: // in Loop: Header=BB118_1 Depth=1 + mov w26, wzr + b .LBB118_21 +.LBB118_20: // in Loop: Header=BB118_1 Depth=1 + adrp x1, .L__func__.allocate_data_superblock + mov w2, #2704 + mov x0, x26 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + bl sftl_printk + mov w2, wzr + mov w21, wzr + mov w26, #1 +.LBB118_21: // in Loop: Header=BB118_1 Depth=1 + adrp x8, g_gc_superblock + ldrh w8, [x8, :lo12:g_gc_superblock] + ldr x11, [sp, #8] // 8-byte Folded Reload + cmp w8, w25, uxth + b.ne .LBB118_23 +// %bb.22: // in Loop: Header=BB118_1 Depth=1 + adrp x0, .L.str.78 + adrp x1, .L__func__.allocate_data_superblock + mov x23, x28 + mov w28, w26 + mov x26, x27 + mov w27, w2 + mov w2, #2706 + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + bl sftl_printk + ldr x11, [sp, #8] // 8-byte Folded Reload + mov w2, w27 + mov x27, x26 + mov w26, w28 + mov x28, x23 + adrp x23, g_num_free_superblocks +.LBB118_23: // in Loop: Header=BB118_1 Depth=1 + adrp x8, p_erase_count_table + ldr x8, [x8, :lo12:p_erase_count_table] + ldrb w10, [x19, #8] + ldrh w9, [x8, x11, lsl #1] + cbz w10, .LBB118_29 +// %bb.24: // in Loop: Header=BB118_1 Depth=1 + adrp x10, g_totle_slc_erase_count + add w9, w9, #1 // =1 + add x10, x10, :lo12:g_totle_slc_erase_count + b .LBB118_30 +.LBB118_25: // in Loop: Header=BB118_1 Depth=1 + ldr x8, [x27, :lo12:p_valid_page_count_table] + ldr x9, [sp, #8] // 8-byte Folded Reload + mov w0, w25 + strh w22, [x8, x9, lsl #1] + bl insert_data_list + ldrh w8, [x28, :lo12:g_num_data_superblocks] + ldrh w9, [x21, :lo12:c_ftl_nand_data_blks_per_plane] + add w8, w8, #1 // =1 + cmp w9, w8, uxth + strh w8, [x28, :lo12:g_num_data_superblocks] + b.hs .LBB118_27 +// %bb.26: // in Loop: Header=BB118_1 Depth=1 + adrp x1, .L__func__.INSERT_DATA_LIST + mov w2, #214 + mov x0, x26 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + bl sftl_printk + ldrh w8, [x28, :lo12:g_num_data_superblocks] + ldrh w9, [x21, :lo12:c_ftl_nand_data_blks_per_plane] +.LBB118_27: // in Loop: Header=BB118_1 Depth=1 + ldrh w10, [x23, :lo12:g_num_free_superblocks] + add w8, w10, w8, uxth + cmp w8, w9 + b.ls .LBB118_1 +// %bb.28: // in Loop: Header=BB118_1 Depth=1 + adrp x1, .L__func__.allocate_data_superblock + mov w2, #2690 + mov x0, x26 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + bl sftl_printk + b .LBB118_1 +.LBB118_29: // in Loop: Header=BB118_1 Depth=1 + adrp x10, c_mlc_erase_count_value + ldrh w10, [x10, :lo12:c_mlc_erase_count_value] + cmp w9, #0 // =0 + add w10, w10, w9 + mov w9, #2 + csel w9, w9, w10, eq + adrp x10, g_totle_mlc_erase_count + add x10, x10, :lo12:g_totle_mlc_erase_count +.LBB118_30: // in Loop: Header=BB118_1 Depth=1 + lsl x11, x11, #1 + strh w9, [x8, x11] + ldr w8, [x10] + adrp x9, p_erase_count_table + ldr x9, [x9, :lo12:p_erase_count_table] + add w8, w8, #1 // =1 + str w8, [x10] + ldrh w8, [x9, x11] + adrp x9, g_max_erase_count + ldr w9, [x9, :lo12:g_max_erase_count] + cmp w9, w8 + b.hs .LBB118_32 +// %bb.31: // in Loop: Header=BB118_1 Depth=1 + adrp x9, g_max_erase_count + str w8, [x9, :lo12:g_max_erase_count] +.LBB118_32: // in Loop: Header=BB118_1 Depth=1 + adrp x8, g_totle_mlc_erase_count + adrp x9, c_mlc_erase_count_value + adrp x10, g_totle_slc_erase_count + ldr w8, [x8, :lo12:g_totle_mlc_erase_count] + ldrh w9, [x9, :lo12:c_mlc_erase_count_value] + ldr w10, [x10, :lo12:g_totle_slc_erase_count] + adrp x11, c_ftl_nand_data_blks_per_plane + ldrh w11, [x11, :lo12:c_ftl_nand_data_blks_per_plane] + adrp x12, gp_ect_tbl_info + ldr x12, [x12, :lo12:gp_ect_tbl_info] + madd w8, w8, w9, w10 + udiv w8, w8, w11 + adrp x9, g_totle_avg_erase_count + str w8, [x9, :lo12:g_totle_avg_erase_count] + ldr w8, [x12, #16] + add w8, w8, #1 // =1 + str w8, [x12, #16] + cbz w26, .LBB118_34 +// %bb.33: // in Loop: Header=BB118_1 Depth=1 + ldr x0, [x20, :lo12:req_erase] + bl FlashEraseBlocks + b .LBB118_50 +.LBB118_34: // in Loop: Header=BB118_1 Depth=1 + // kill: def $w21 killed $w21 killed $x21 def $x21 + mov w9, #4 + and x21, x21, #0xffff + mov x8, x21 +.LBB118_35: // Parent Loop BB118_1 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x10, [x20, :lo12:req_erase] + subs x8, x8, #1 // =1 + ldr w11, [x10, x9] + and w11, w11, #0xfffffc00 + str w11, [x10, x9] + add x9, x9, #32 // =32 + b.ne .LBB118_35 +// %bb.36: // in Loop: Header=BB118_1 Depth=1 + ldr x0, [x20, :lo12:req_erase] + bl FlashEraseBlocks + adrp x10, c_ftl_nand_planes_num + tbnz w26, #0, .LBB118_50 +// %bb.37: // in Loop: Header=BB118_1 Depth=1 + mov x27, xzr + mov w26, wzr + mov x28, x24 + b .LBB118_39 +.LBB118_38: // in Loop: Header=BB118_39 Depth=2 + add x27, x27, #32 // =32 + subs x21, x21, #1 // =1 + add x28, x28, #2 // =2 + b.eq .LBB118_41 +.LBB118_39: // Parent Loop BB118_1 Depth=1 + // => This Inner Loop Header: Depth=2 + ldr x8, [x20, :lo12:req_erase] + ldr w9, [x8, x27] + cmn w9, #1 // =1 + b.ne .LBB118_38 +// %bb.40: // in Loop: Header=BB118_39 Depth=2 + add x8, x8, x27 + ldr w8, [x8, #4] + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x22, gBbtInfo + ubfx w1, w8, #10, #16 + add x22, x22, :lo12:gBbtInfo + udiv w2, w1, w9 + lsr w10, w8, #10 + add x8, x22, w2, uxtw #3 + ldr x8, [x8, #32] + msub w9, w2, w9, w10 + ubfx w10, w9, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x8, x10] + mov w12, #1 + and w3, w9, #0xffff + lsl w9, w12, w9 + adrp x0, .L.str.82 + orr w4, w9, w11 + add x0, x0, :lo12:.L.str.82 + add w26, w26, #1 // =1 + str w4, [x8, x10] + bl sftl_printk + ldrh w8, [x22, #6] + adrp x10, c_ftl_nand_planes_num + add w8, w8, #1 // =1 + strh w8, [x22, #6] + mov w22, #65535 + strh w22, [x28] + ldrb w8, [x19, #7] + sub w8, w8, #1 // =1 + strb w8, [x19, #7] + b .LBB118_38 +.LBB118_41: // in Loop: Header=BB118_1 Depth=1 + cmp w26, #1 // =1 + adrp x27, p_valid_page_count_table + adrp x28, g_num_data_superblocks + b.lt .LBB118_50 +// %bb.42: // in Loop: Header=BB118_1 Depth=1 + ldrh w9, [x10, :lo12:c_ftl_nand_planes_num] + cbz x9, .LBB118_47 +// %bb.43: // in Loop: Header=BB118_1 Depth=1 + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x11, c_ftl_nand_blks_per_die + adrp x12, c_ftl_nand_page_pre_blk + ldrh w11, [x11, :lo12:c_ftl_nand_blks_per_die] + ldrh w12, [x12, :lo12:c_ftl_nand_page_pre_blk] + adrp x14, p_plane_order_table + adrp x18, gBbtInfo + mov w8, wzr + mul w13, w10, w25 + add x14, x14, :lo12:p_plane_order_table + add x18, x18, :lo12:gBbtInfo +.LBB118_44: // Parent Loop BB118_1 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrb w15, [x14], #1 + and w16, w10, #0xffff + and w17, w15, #0xffff + udiv w16, w17, w16 + msub w15, w16, w10, w15 + madd w16, w16, w11, w13 + add w15, w16, w15 + and w17, w11, #0xffff + and w16, w15, #0xffff + udiv w16, w16, w17 + add x17, x18, w16, uxtw #3 + ldr x17, [x17, #32] + msub w15, w16, w11, w15 + lsr w16, w15, #3 + and x16, x16, #0x1ffc + ldr w16, [x17, x16] + lsr w15, w16, w15 + tst w15, #0x1 + csel w15, w12, wzr, eq + subs x9, x9, #1 // =1 + add w8, w15, w8 + b.ne .LBB118_44 +// %bb.45: // in Loop: Header=BB118_1 Depth=1 + ldr x11, [sp, #8] // 8-byte Folded Reload + tst w8, #0xffff + b.eq .LBB118_48 +// %bb.46: // in Loop: Header=BB118_1 Depth=1 + and w8, w8, #0xffff + mov w9, #32768 + udiv w8, w9, w8 + b .LBB118_49 +.LBB118_47: // in Loop: Header=BB118_1 Depth=1 + ldr x11, [sp, #8] // 8-byte Folded Reload +.LBB118_48: // in Loop: Header=BB118_1 Depth=1 + mov w8, wzr +.LBB118_49: // in Loop: Header=BB118_1 Depth=1 + adrp x9, p_data_block_list_table + ldr x9, [x9, :lo12:p_data_block_list_table] + mov w10, #6 + madd x9, x11, x10, x9 + strh w8, [x9, #4] + bl FtlBbmTblFlush +.LBB118_50: // in Loop: Header=BB118_1 Depth=1 + ldrb w8, [x19, #7] + cbnz w8, .LBB118_52 +// %bb.51: // in Loop: Header=BB118_1 Depth=1 + ldr x8, [x27, :lo12:p_valid_page_count_table] + ldr x9, [sp, #8] // 8-byte Folded Reload + adrp x26, .L.str.78 + adrp x21, c_ftl_nand_data_blks_per_plane + add x26, x26, :lo12:.L.str.78 + strh w22, [x8, x9, lsl #1] + b .LBB118_1 +.LBB118_52: + adrp x9, c_ftl_nand_page_pre_blk + ldrh w9, [x9, :lo12:c_ftl_nand_page_pre_blk] + strh w25, [x19] + strh wzr, [x19, #2] + strb wzr, [x19, #6] + mul w8, w9, w8 + adrp x10, g_GlobalSysVersion + strh w8, [x19, #4] + ldr w9, [x10, :lo12:g_GlobalSysVersion] + str w9, [x19, #12] + add w9, w9, #1 // =1 + str w9, [x10, :lo12:g_GlobalSysVersion] + ldr x9, [x27, :lo12:p_valid_page_count_table] + ldrh w10, [x19] + strh w8, [x9, x10, lsl #1] + ldrh w8, [x19, #4] + cbz w8, .LBB118_54 +// %bb.53: + ldrb w8, [x19, #7] + cbnz w8, .LBB118_55 +.LBB118_54: + adrp x0, .L.str.78 + adrp x1, .L__func__.allocate_data_superblock + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.allocate_data_superblock + mov w2, #2759 + bl sftl_printk +.LBB118_55: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.Lfunc_end118: + .size allocate_data_superblock, .Lfunc_end118-allocate_data_superblock + // -- End function + .globl FtlGcFreeBadSuperBlk // -- Begin function FtlGcFreeBadSuperBlk + .p2align 2 + .type FtlGcFreeBadSuperBlk,@function +FtlGcFreeBadSuperBlk: // @FtlGcFreeBadSuperBlk +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + stp x26, x25, [sp, #48] // 16-byte Folded Spill + adrp x26, g_gc_bad_block_temp_num + ldrh w8, [x26, :lo12:g_gc_bad_block_temp_num] + stp x29, x30, [sp, #16] // 16-byte Folded Spill + add x29, sp, #16 // =16 + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + stur w0, [x29, #-4] // 4-byte Folded Spill + cbz w8, .LBB119_28 +// %bb.1: + adrp x9, c_ftl_nand_planes_num + ldrh w9, [x9, :lo12:c_ftl_nand_planes_num] + adrp x24, g_gc_bad_block_temp_tbl + add x24, x24, :lo12:g_gc_bad_block_temp_tbl + cbz w9, .LBB119_17 +// %bb.2: + adrp x27, gBbtInfo + adrp x21, .L.str.82 + mov x28, xzr + add x27, x27, :lo12:gBbtInfo + add x21, x21, :lo12:.L.str.82 + mov w10, #1 + b .LBB119_5 +.LBB119_3: // in Loop: Header=BB119_5 Depth=1 + adrp x9, c_ftl_nand_planes_num + ldrh w9, [x9, :lo12:c_ftl_nand_planes_num] + mov w10, w8 +.LBB119_4: // in Loop: Header=BB119_5 Depth=1 + add x28, x28, #1 // =1 + cmp x28, w9, uxth + b.hs .LBB119_17 +.LBB119_5: // =>This Loop Header: Depth=1 + // Child Loop BB119_9 Depth 2 + // Child Loop BB119_13 Depth 3 + // Child Loop BB119_15 Depth 3 + tst w10, #0xffff + b.eq .LBB119_16 +// %bb.6: // in Loop: Header=BB119_5 Depth=1 + adrp x9, p_plane_order_table + add x9, x9, :lo12:p_plane_order_table + adrp x10, c_ftl_nand_planes_per_die + ldrb w9, [x9, x28] + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x11, c_ftl_nand_blks_per_die + ldur w14, [x29, #-4] // 4-byte Folded Reload + ldrh w11, [x11, :lo12:c_ftl_nand_blks_per_die] + and w12, w9, #0xffff + and w13, w10, #0xffff + mul w14, w10, w14 + udiv w12, w12, w13 + madd w11, w11, w12, w14 + msub w9, w12, w10, w9 + add w23, w11, w9 + adrp x20, g_gc_bad_block_temp_tbl+2 + mov x19, xzr + mov x25, xzr + and w22, w23, #0xffff + add x20, x20, :lo12:g_gc_bad_block_temp_tbl+2 + b .LBB119_9 +.LBB119_7: // in Loop: Header=BB119_9 Depth=2 + sub w8, w8, #1 // =1 + strh w8, [x26, :lo12:g_gc_bad_block_temp_num] +.LBB119_8: // in Loop: Header=BB119_9 Depth=2 + add x25, x25, #1 // =1 + add x20, x20, #2 // =2 + cmp x25, w8, uxth + sub x19, x19, #1 // =1 + b.hs .LBB119_3 +.LBB119_9: // Parent Loop BB119_5 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB119_13 Depth 3 + // Child Loop BB119_15 Depth 3 + ldrh w9, [x24, x25, lsl #1] + cmp w9, w23, uxth + b.ne .LBB119_8 +// %bb.10: // in Loop: Header=BB119_9 Depth=2 + adrp x0, .L.str.114 + add x0, x0, :lo12:.L.str.114 + mov w1, w22 + bl sftl_printk + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + and w9, w23, #0xffff + mov w12, #1 + mov x0, x21 + udiv w2, w9, w8 + add x9, x27, w2, uxtw #3 + ldr x9, [x9, #32] + msub w8, w2, w8, w23 + ubfx w10, w8, #3, #13 + and x10, x10, #0x1ffc + ldr w11, [x9, x10] + and w3, w8, #0xffff + lsl w8, w12, w8 + mov w1, w22 + orr w4, w8, w11 + str w4, [x9, x10] + bl sftl_printk + ldrh w8, [x27, #6] + add w8, w8, #1 // =1 + strh w8, [x27, #6] + bl FtlBbmTblFlush + ldrh w8, [x26, :lo12:g_gc_bad_block_temp_num] + cmp x25, x8 + b.hs .LBB119_7 +// %bb.11: // in Loop: Header=BB119_9 Depth=2 + sub x10, x8, x25 + cmp x10, #2 // =2 + mov x9, x25 + b.lo .LBB119_15 +// %bb.12: // in Loop: Header=BB119_9 Depth=2 + and x11, x10, #0xfffffffffffffffe + add x12, x19, x8 + add x9, x25, x11 + and x12, x12, #0xfffffffffffffffe + mov x13, x20 +.LBB119_13: // Parent Loop BB119_5 Depth=1 + // Parent Loop BB119_9 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrh w14, [x13] + ldrh w15, [x13, #2] + subs x12, x12, #2 // =2 + sturh w14, [x13, #-2] + strh w15, [x13], #4 + b.ne .LBB119_13 +// %bb.14: // in Loop: Header=BB119_9 Depth=2 + cmp x10, x11 + b.eq .LBB119_7 +.LBB119_15: // Parent Loop BB119_5 Depth=1 + // Parent Loop BB119_9 Depth=2 + // => This Inner Loop Header: Depth=3 + add x10, x24, x9, lsl #1 + ldrh w11, [x10, #2] + add x9, x9, #1 // =1 + cmp x9, x8 + strh w11, [x10] + b.lo .LBB119_15 + b .LBB119_7 +.LBB119_16: // in Loop: Header=BB119_5 Depth=1 + mov w10, wzr + b .LBB119_4 +.LBB119_17: + tst w8, #0xffff + b.eq .LBB119_28 +// %bb.18: + adrp x21, g_gc_next_blk + ldrh w9, [x21, :lo12:g_gc_next_blk] + mov w10, #65535 + cmp w9, w10 + b.ne .LBB119_28 +// %bb.19: + adrp x20, g_gc_bad_block_gc_index + ldrh w9, [x20, :lo12:g_gc_bad_block_gc_index] + cmp w9, w8, uxth + b.lo .LBB119_21 +// %bb.20: + mov w9, wzr + strh wzr, [x20, :lo12:g_gc_bad_block_gc_index] +.LBB119_21: + ldrh w8, [x24, w9, uxtw #1] + adrp x9, c_ftl_nand_blks_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x0, .L.str.112 + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w19, w8, w10 + add x0, x0, :lo12:.L.str.112 + mov w1, w19 + bl sftl_printk + ldrh w9, [x21, :lo12:g_gc_next_blk] + cmp w9, w19 + b.eq .LBB119_27 +// %bb.22: + adrp x8, g_gc_next_blk_1 + ldrh w10, [x8, :lo12:g_gc_next_blk_1] + cmp w10, w19, uxth + b.eq .LBB119_27 +// %bb.23: + mov w11, #65535 + cmp w9, w11 + b.eq .LBB119_26 +// %bb.24: + cmp w10, w11 + b.ne .LBB119_27 +// %bb.25: + strh w19, [x8, :lo12:g_gc_next_blk_1] + b .LBB119_27 +.LBB119_26: + strh w19, [x21, :lo12:g_gc_next_blk] +.LBB119_27: + ldrh w8, [x20, :lo12:g_gc_bad_block_gc_index] + add w8, w8, #1 // =1 + strh w8, [x20, :lo12:g_gc_bad_block_gc_index] +.LBB119_28: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + mov w0, wzr + add sp, sp, #112 // =112 + hint #29 + ret +.Lfunc_end119: + .size FtlGcFreeBadSuperBlk, .Lfunc_end119-FtlGcFreeBadSuperBlk + // -- End function + .globl FtlGcBufFree // -- Begin function FtlGcBufFree + .p2align 2 + .type FtlGcBufFree,@function +FtlGcBufFree: // @FtlGcBufFree +// %bb.0: + hint #25 + cbz w1, .LBB120_8 +// %bb.1: + mov w8, wzr + adrp x9, c_gc_page_buf_num + adrp x10, gp_gc_page_buf_info + mov w11, #24 + b .LBB120_4 +.LBB120_2: // in Loop: Header=BB120_4 Depth=1 + // kill: def $w15 killed $w15 killed $x15 def $x15 + and x13, x15, #0xffff + madd x12, x13, x11, x12 + str wzr, [x12, #16] +.LBB120_3: // in Loop: Header=BB120_4 Depth=1 + add w8, w8, #1 // =1 + cmp w1, w8, uxth + b.ls .LBB120_8 +.LBB120_4: // =>This Loop Header: Depth=1 + // Child Loop BB120_6 Depth 2 + ldr w13, [x9, :lo12:c_gc_page_buf_num] + cbz w13, .LBB120_3 +// %bb.5: // in Loop: Header=BB120_4 Depth=1 + and x14, x8, #0xffff + add x14, x0, x14, lsl #5 + ldr x12, [x10, :lo12:gp_gc_page_buf_info] + ldr x14, [x14, #8] + mov w15, wzr +.LBB120_6: // Parent Loop BB120_4 Depth=1 + // => This Inner Loop Header: Depth=2 + and x16, x15, #0xffff + mul x16, x16, x11 + ldr x16, [x12, x16] + cmp x16, x14 + b.eq .LBB120_2 +// %bb.7: // in Loop: Header=BB120_6 Depth=2 + add w15, w15, #1 // =1 + cmp w13, w15, uxth + b.hi .LBB120_6 + b .LBB120_3 +.LBB120_8: + hint #29 + ret +.Lfunc_end120: + .size FtlGcBufFree, .Lfunc_end120-FtlGcBufFree + // -- End function + .globl FtlGcBufAlloc // -- Begin function FtlGcBufAlloc + .p2align 2 + .type FtlGcBufAlloc,@function +FtlGcBufAlloc: // @FtlGcBufAlloc +// %bb.0: + hint #25 + cbz w1, .LBB121_8 +// %bb.1: + mov w8, wzr + adrp x9, c_gc_page_buf_num + adrp x10, gp_gc_page_buf_info + mov w11, #24 + mov w12, #1 + b .LBB121_4 +.LBB121_2: // in Loop: Header=BB121_4 Depth=1 + str w12, [x16] + ldr x13, [x10, :lo12:gp_gc_page_buf_info] + // kill: def $w15 killed $w15 killed $x15 def $x15 + and x14, x15, #0xffff + add x14, x14, w15, uxth #1 + lsl x14, x14, #3 + ldr x13, [x13, x14] + and x15, x8, #0xffff + add x15, x0, x15, lsl #5 + str x13, [x15, #8] + ldr x13, [x10, :lo12:gp_gc_page_buf_info] + add x13, x13, x14 + ldr x13, [x13, #8] + str x13, [x15, #16] +.LBB121_3: // in Loop: Header=BB121_4 Depth=1 + add w8, w8, #1 // =1 + cmp w1, w8, uxth + b.ls .LBB121_8 +.LBB121_4: // =>This Loop Header: Depth=1 + // Child Loop BB121_6 Depth 2 + ldr w13, [x9, :lo12:c_gc_page_buf_num] + cbz w13, .LBB121_3 +// %bb.5: // in Loop: Header=BB121_4 Depth=1 + ldr x14, [x10, :lo12:gp_gc_page_buf_info] + mov w15, wzr +.LBB121_6: // Parent Loop BB121_4 Depth=1 + // => This Inner Loop Header: Depth=2 + and x16, x15, #0xffff + madd x16, x16, x11, x14 + ldr w17, [x16, #16]! + cbz w17, .LBB121_2 +// %bb.7: // in Loop: Header=BB121_6 Depth=2 + add w15, w15, #1 // =1 + cmp w13, w15, uxth + b.hi .LBB121_6 + b .LBB121_3 +.LBB121_8: + hint #29 + ret +.Lfunc_end121: + .size FtlGcBufAlloc, .Lfunc_end121-FtlGcBufAlloc + // -- End function + .globl IsBlkInGcList // -- Begin function IsBlkInGcList + .p2align 2 + .type IsBlkInGcList,@function +IsBlkInGcList: // @IsBlkInGcList +// %bb.0: + hint #25 + adrp x8, g_gc_blk_num + ldrh w8, [x8, :lo12:g_gc_blk_num] + cbz x8, .LBB122_4 +// %bb.1: + adrp x9, p_gc_blk_tbl + ldr x9, [x9, :lo12:p_gc_blk_tbl] +.LBB122_2: // =>This Inner Loop Header: Depth=1 + ldrh w10, [x9] + cmp w10, w0, uxth + b.eq .LBB122_5 +// %bb.3: // in Loop: Header=BB122_2 Depth=1 + subs x8, x8, #1 // =1 + add x9, x9, #2 // =2 + b.ne .LBB122_2 +.LBB122_4: + mov w0, wzr + hint #29 + ret +.LBB122_5: + mov w0, #1 + hint #29 + ret +.Lfunc_end122: + .size IsBlkInGcList, .Lfunc_end122-IsBlkInGcList + // -- End function + .globl FtlGcUpdatePage // -- Begin function FtlGcUpdatePage + .p2align 2 + .type FtlGcUpdatePage,@function +FtlGcUpdatePage: // @FtlGcUpdatePage +// %bb.0: + hint #25 + adrp x8, c_ftl_nand_blks_per_die + ldrh w12, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + adrp x8, g_gc_blk_num + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + ubfx w9, w0, #10, #16 + ldrh w11, [x8, :lo12:g_gc_blk_num] + udiv w13, w9, w12 + msub w9, w13, w12, w9 + udiv w9, w9, w10 + adrp x10, p_gc_blk_tbl + cbz x11, .LBB123_5 +// %bb.1: + ldr x12, [x10, :lo12:p_gc_blk_tbl] + mov x13, xzr +.LBB123_2: // =>This Inner Loop Header: Depth=1 + ldrh w14, [x12, x13, lsl #1] + cmp w14, w9, uxth + b.eq .LBB123_4 +// %bb.3: // in Loop: Header=BB123_2 Depth=1 + add x13, x13, #1 // =1 + cmp x11, x13 + b.ne .LBB123_2 + b .LBB123_5 +.LBB123_4: + cmp w11, w13, uxth + mov w11, w13 + b.ne .LBB123_6 +.LBB123_5: + ldr x10, [x10, :lo12:p_gc_blk_tbl] + // kill: def $w11 killed $w11 killed $x11 def $x11 + and x11, x11, #0xffff + strh w9, [x10, x11, lsl #1] + ldrh w9, [x8, :lo12:g_gc_blk_num] + add w9, w9, #1 // =1 + strh w9, [x8, :lo12:g_gc_blk_num] +.LBB123_6: + adrp x8, p_gc_page_info + adrp x9, g_gc_page_offset + ldr x10, [x8, :lo12:p_gc_page_info] + ldrh w11, [x9, :lo12:g_gc_page_offset] + mov w12, #12 + madd x10, x11, x12, x10 + str w1, [x10, #4] + ldr x10, [x8, :lo12:p_gc_page_info] + ldrh w11, [x9, :lo12:g_gc_page_offset] + madd x10, x11, x12, x10 + str w2, [x10, #8] + ldrh w10, [x9, :lo12:g_gc_page_offset] + ldr x8, [x8, :lo12:p_gc_page_info] + mul x10, x10, x12 + str w0, [x8, x10] + ldrh w8, [x9, :lo12:g_gc_page_offset] + add w8, w8, #1 // =1 + strh w8, [x9, :lo12:g_gc_page_offset] + hint #29 + ret +.Lfunc_end123: + .size FtlGcUpdatePage, .Lfunc_end123-FtlGcUpdatePage + // -- End function + .globl FtlGcFreeTempBlock // -- Begin function FtlGcFreeTempBlock + .p2align 2 + .type FtlGcFreeTempBlock,@function +FtlGcFreeTempBlock: // @FtlGcFreeTempBlock +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + stp x20, x19, [sp, #96] // 16-byte Folded Spill + str x8, [sp, #8] + adrp x20, g_gc_temp_superblock + ldrsh w8, [x20, :lo12:g_gc_temp_superblock] + add x29, sp, #16 // =16 + cmn w8, #1 // =1 + b.eq .LBB124_4 +// %bb.1: + adrp x22, c_ftl_nand_page_pre_blk + ldrh w8, [x22, :lo12:c_ftl_nand_page_pre_blk] + adrp x21, ftl_gc_temp_block_bops_scan_page_addr + cbz w0, .LBB124_5 +// %bb.2: + ldrsh w9, [x21, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + mov w1, #2 + cmn w9, #1 // =1 + b.ne .LBB124_6 +// %bb.3: + adrp x9, g_num_free_superblocks + ldrh w9, [x9, :lo12:g_num_free_superblocks] + strh wzr, [x21, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + cmp w9, #18 // =18 + csel w1, w8, w1, lo + b .LBB124_6 +.LBB124_4: + adrp x8, ftl_gc_temp_power_lost_recovery_flag + mov w0, wzr + str wzr, [x8, :lo12:ftl_gc_temp_power_lost_recovery_flag] + b .LBB124_8 +.LBB124_5: + mov w1, w8 +.LBB124_6: + adrp x19, g_gc_temp_superblock + add x19, x19, :lo12:g_gc_temp_superblock + mov x0, x19 + bl FtlGcScanTempBlk + ldrsh w8, [x21, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + mov w9, #-1 + str w9, [sp, #4] + cmn w8, #1 // =1 + b.eq .LBB124_10 +// %bb.7: + mov w0, #1 +.LBB124_8: + adrp x9, __stack_chk_guard + ldr x8, [sp, #8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB124_39 +// %bb.9: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.LBB124_10: + ldrh w8, [x20, :lo12:g_gc_temp_superblock] + mov w10, #65535 + adrp x9, ftl_gc_temp_power_lost_recovery_flag + str wzr, [x9, :lo12:ftl_gc_temp_power_lost_recovery_flag] + cmp w8, w10 + b.eq .LBB124_26 +// %bb.11: + adrp x9, g_gc_temp_superblock+7 + adrp x21, g_gc_page_offset + ldrb w9, [x9, :lo12:g_gc_temp_superblock+7] + ldrh w10, [x22, :lo12:c_ftl_nand_page_pre_blk] + ldrh w11, [x21, :lo12:g_gc_page_offset] + mul w12, w10, w9 + cmp w12, w11 + b.eq .LBB124_13 +// %bb.12: + adrp x0, .L.str.78 + adrp x1, .L__func__.FtlGcFreeTempBlock + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.FtlGcFreeTempBlock + mov w2, #164 + bl sftl_printk + ldrb w9, [x19, #7] + ldrh w10, [x22, :lo12:c_ftl_nand_page_pre_blk] + ldrh w8, [x19] +.LBB124_13: + adrp x11, p_valid_page_count_table + ldr x11, [x11, :lo12:p_valid_page_count_table] + mul w9, w10, w9 + adrp x10, g_totle_gc_page_count + strh w9, [x11, w8, uxtw #1] + ldrh w8, [x21, :lo12:g_gc_page_offset] + ldr w9, [x10, :lo12:g_totle_gc_page_count] + add w9, w9, w8 + str w9, [x10, :lo12:g_totle_gc_page_count] + cbz w8, .LBB124_22 +// %bb.14: + mov x23, xzr + mov x24, xzr + adrp x25, p_gc_page_info + adrp x26, g_MaxLpn + adrp x27, c_ftl_nand_blks_per_die + adrp x28, c_ftl_nand_planes_per_die + b .LBB124_18 +.LBB124_15: // in Loop: Header=BB124_18 Depth=1 + ldrh w19, [x20, :lo12:g_gc_temp_superblock] +.LBB124_16: // in Loop: Header=BB124_18 Depth=1 + mov w0, w19 + bl decrement_vpc_count +.LBB124_17: // in Loop: Header=BB124_18 Depth=1 + ldrh w8, [x21, :lo12:g_gc_page_offset] + add x24, x24, #1 // =1 + add x23, x23, #12 // =12 + cmp x24, x8 + b.hs .LBB124_22 +.LBB124_18: // =>This Inner Loop Header: Depth=1 + ldr x19, [x25, :lo12:p_gc_page_info] + ldr w8, [x26, :lo12:g_MaxLpn] + add x22, x19, x23 + ldr w0, [x22, #8] + cmp w0, w8 + b.hs .LBB124_15 +// %bb.19: // in Loop: Header=BB124_18 Depth=1 + add x1, sp, #4 // =4 + mov w2, wzr + bl log2phys + ldr w8, [sp, #4] + ldr w9, [x19, x23] + cmp w8, w9 + b.ne .LBB124_21 +// %bb.20: // in Loop: Header=BB124_18 Depth=1 + ldrh w9, [x27, :lo12:c_ftl_nand_blks_per_die] + ldrh w10, [x28, :lo12:c_ftl_nand_planes_per_die] + ldr w0, [x22, #8] + ubfx w8, w8, #10, #16 + add x11, x19, x23 + udiv w12, w8, w9 + msub w8, w12, w9, w8 + add x1, x11, #4 // =4 + mov w2, #1 + udiv w19, w8, w10 + bl log2phys + b .LBB124_16 +.LBB124_21: // in Loop: Header=BB124_18 Depth=1 + add x9, x19, x23 + ldr w9, [x9, #4] + cmp w8, w9 + b.ne .LBB124_15 + b .LBB124_17 +.LBB124_22: + adrp x19, g_tmp_data_superblock_id + ldrh w0, [x19, :lo12:g_tmp_data_superblock_id] + mov w22, #65535 + cmp w0, w22 + b.eq .LBB124_27 +// %bb.23: + bl update_vpc_list + adrp x8, p_data_block_list_head + adrp x9, p_data_block_list_table + ldr w8, [x8, :lo12:p_data_block_list_head] + ldr w9, [x9, :lo12:p_data_block_list_table] + strh w22, [x19, :lo12:g_tmp_data_superblock_id] + adrp x19, p_valid_page_count_table + ldr x10, [x19, :lo12:p_valid_page_count_table] + sub w8, w8, w9 + mov w9, #43691 + lsr w8, w8, #1 + movk w9, #43690, lsl #16 + mul w8, w8, w9 + and x8, x8, #0xffff + ldrh w9, [x10, x8, lsl #1] + cbnz w9, .LBB124_28 +// %bb.24: + mov w9, #65535 + cmp x8, x9 + b.eq .LBB124_28 +// %bb.25: + adrp x0, .L.str.78 + adrp x1, .L__func__.decrement_vpc_count + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.decrement_vpc_count + mov w2, #2869 + bl sftl_printk + b .LBB124_28 +.LBB124_26: + mov w0, wzr + b .LBB124_8 +.LBB124_27: + strh w22, [x19, :lo12:g_tmp_data_superblock_id] + adrp x19, p_valid_page_count_table +.LBB124_28: + ldr x8, [x19, :lo12:p_valid_page_count_table] + ldrh w0, [x20, :lo12:g_gc_temp_superblock] + ldrh w8, [x8, x0, lsl #1] + cbz w8, .LBB124_31 +// %bb.29: + // kill: def $w0 killed $w0 killed $x0 + bl insert_data_list + adrp x8, g_num_data_superblocks + ldrh w9, [x8, :lo12:g_num_data_superblocks] + adrp x10, c_ftl_nand_data_blks_per_plane + ldrh w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane] + add w9, w9, #1 // =1 + strh w9, [x8, :lo12:g_num_data_superblocks] + cmp w10, w9, uxth + b.hs .LBB124_32 +// %bb.30: + adrp x0, .L.str.78 + adrp x1, .L__func__.INSERT_DATA_LIST + add x0, x0, :lo12:.L.str.78 + add x1, x1, :lo12:.L__func__.INSERT_DATA_LIST + mov w2, #214 + bl sftl_printk + b .LBB124_32 +.LBB124_31: + // kill: def $w0 killed $w0 killed $x0 + bl INSERT_FREE_LIST +.LBB124_32: + mov w22, #65535 + adrp x8, g_gc_blk_num + strh wzr, [x21, :lo12:g_gc_page_offset] + strh w22, [x20, :lo12:g_gc_temp_superblock] + strh wzr, [x8, :lo12:g_gc_blk_num] + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB124_37 +// %bb.33: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x23, xzr + adrp x24, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB124_35 +.LBB124_34: // in Loop: Header=BB124_35 Depth=1 + add x23, x23, #1 // =1 + cmp x23, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB124_37 +.LBB124_35: // =>This Inner Loop Header: Depth=1 + ldr x9, [x24, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB124_34 +// %bb.36: // in Loop: Header=BB124_35 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x24, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB124_34 +.LBB124_37: + bl FtlVpcTblFlush + adrp x9, c_ftl_nand_data_op_blks_per_plane + adrp x8, g_num_free_superblocks + ldrh w9, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane] + ldrh w8, [x8, :lo12:g_num_free_superblocks] + adrp x10, g_gc_superblock + mov w0, wzr + add w9, w9, w9, lsl #1 + cmp w8, w9, lsr #2 + strh w22, [x10, :lo12:g_gc_superblock] + b.ls .LBB124_8 +// %bb.38: + adrp x8, g_gc_free_blk_threshold + mov w9, #20 + strh w9, [x8, :lo12:g_gc_free_blk_threshold] + b .LBB124_8 +.LBB124_39: + bl __stack_chk_fail +.Lfunc_end124: + .size FtlGcFreeTempBlock, .Lfunc_end124-FtlGcFreeTempBlock + // -- End function + .globl FtlGcScanTempBlk // -- Begin function FtlGcScanTempBlk + .p2align 2 + .type FtlGcScanTempBlk,@function +FtlGcScanTempBlk: // @FtlGcScanTempBlk +// %bb.0: + hint #25 + sub sp, sp, #176 // =176 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #80] // 16-byte Folded Spill + add x29, sp, #80 // =80 + stp x28, x27, [sp, #96] // 16-byte Folded Spill + stp x26, x25, [sp, #112] // 16-byte Folded Spill + stp x24, x23, [sp, #128] // 16-byte Folded Spill + stp x22, x21, [sp, #144] // 16-byte Folded Spill + stp x20, x19, [sp, #160] // 16-byte Folded Spill + str w1, [sp, #12] // 4-byte Folded Spill + adrp x10, ftl_gc_temp_block_bops_scan_page_addr + stur x8, [x29, #-8] + ldrh w8, [x10, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + mov w9, #65535 + mov x22, x0 + adrp x11, g_gc_blk_num + cmp w8, w9 + adrp x26, g_gc_page_offset + csel w19, wzr, w8, eq + adrp x24, p_gc_page_info + cbz w8, .LBB125_2 +// %bb.1: + adrp x8, c_ftl_nand_page_pre_blk + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_blk] + ldr w9, [sp, #12] // 4-byte Folded Reload + cmp w8, w9 + b.ne .LBB125_3 +.LBB125_2: + adrp x20, c_ftl_nand_page_pre_super_blk + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_super_blk] + adrp x9, p_gc_blk_tbl + ldr x0, [x9, :lo12:p_gc_blk_tbl] + mov w1, #255 + lsl x2, x8, #1 + strh wzr, [x11, :lo12:g_gc_blk_num] + strh wzr, [x26, :lo12:g_gc_page_offset] + bl memset + ldrh w8, [x20, :lo12:c_ftl_nand_page_pre_super_blk] + ldr x0, [x24, :lo12:p_gc_page_info] + mov w1, #255 + add x8, x8, x8, lsl #1 + lsl x2, x8, #2 + bl memset + bl FtlGcBufInit +.LBB125_3: + ldrsh w8, [x22] + adrp x16, c_ftl_nand_planes_num + strb wzr, [x22, #8] + cmn w8, #1 // =1 + b.eq .LBB125_44 +// %bb.4: + add x20, x22, #16 // =16 + adrp x28, req_read + mov w21, #65535 + mov w27, #12 + adrp x17, p_gc_data_buf + adrp x18, c_ftl_nand_byte_pre_page + adrp x0, p_gc_spare_buf + adrp x1, c_ftl_nand_byte_pre_oob + str wzr, [sp, #16] // 4-byte Folded Spill + str x22, [sp, #24] // 8-byte Folded Spill + b .LBB125_6 +.LBB125_5: // in Loop: Header=BB125_6 Depth=1 + adrp x8, c_ftl_nand_page_pre_blk + ldrh w8, [x8, :lo12:c_ftl_nand_page_pre_blk] + adrp x16, c_ftl_nand_planes_num + adrp x17, p_gc_data_buf + adrp x18, c_ftl_nand_byte_pre_page + cmp w8, w19, uxth + adrp x0, p_gc_spare_buf + adrp x1, c_ftl_nand_byte_pre_oob + str w10, [sp, #16] // 4-byte Folded Spill + b.ls .LBB125_44 +.LBB125_6: // =>This Loop Header: Depth=1 + // Child Loop BB125_7 Depth 2 + // Child Loop BB125_10 Depth 3 + // Child Loop BB125_18 Depth 3 + // Child Loop BB125_21 Depth 4 + // Child Loop BB125_29 Depth 4 + // Child Loop BB125_33 Depth 4 + mov w9, w19 +.LBB125_7: // Parent Loop BB125_6 Depth=1 + // => This Loop Header: Depth=2 + // Child Loop BB125_10 Depth 3 + // Child Loop BB125_18 Depth 3 + // Child Loop BB125_21 Depth 4 + // Child Loop BB125_29 Depth 4 + // Child Loop BB125_33 Depth 4 + ldrh w10, [x16, :lo12:c_ftl_nand_planes_num] + str w9, [sp, #20] // 4-byte Folded Spill + cbz w10, .LBB125_12 +// %bb.8: // in Loop: Header=BB125_7 Depth=2 + mov x8, xzr + mov w19, wzr + and w9, w9, #0xffff + b .LBB125_10 +.LBB125_9: // in Loop: Header=BB125_10 Depth=3 + add x8, x8, #1 // =1 + cmp x8, w10, uxth + b.hs .LBB125_13 +.LBB125_10: // Parent Loop BB125_6 Depth=1 + // Parent Loop BB125_7 Depth=2 + // => This Inner Loop Header: Depth=3 + ldrh w11, [x20, x8, lsl #1] + cmp w11, w21 + b.eq .LBB125_9 +// %bb.11: // in Loop: Header=BB125_10 Depth=3 + ldr x10, [x28, :lo12:req_read] + and x12, x19, #0xffff + lsl x12, x12, #5 + orr w11, w9, w11, lsl #10 + add x10, x10, x12 + str w11, [x10, #4] + ldrh w10, [x18, :lo12:c_ftl_nand_byte_pre_page] + and w11, w19, #0xffff + ldr x13, [x17, :lo12:p_gc_data_buf] + ldr x14, [x28, :lo12:req_read] + mul w10, w10, w11 + add w15, w10, #3 // =3 + cmp w10, #0 // =0 + csel w10, w15, w10, lt + asr w10, w10, #2 + add x14, x14, x12 + add x10, x13, w10, sxtw #2 + str x10, [x14, #8] + ldrh w10, [x1, :lo12:c_ftl_nand_byte_pre_oob] + ldr x13, [x0, :lo12:p_gc_spare_buf] + ldr x14, [x28, :lo12:req_read] + add w19, w19, #1 // =1 + mul w10, w10, w11 + add w11, w10, #3 // =3 + cmp w10, #0 // =0 + csel w10, w11, w10, lt + asr w10, w10, #2 + add x10, x13, w10, sxtw #2 + add x11, x14, x12 + str x10, [x11, #16] + ldrh w10, [x16, :lo12:c_ftl_nand_planes_num] + b .LBB125_9 +.LBB125_12: // in Loop: Header=BB125_7 Depth=2 + mov w19, wzr +.LBB125_13: // in Loop: Header=BB125_7 Depth=2 + ldr x0, [x28, :lo12:req_read] + and w22, w19, #0xffff + mov w1, w22 + bl FlashReadPages + adrp x16, g_gc_blk_num + cbz w22, .LBB125_41 +// %bb.14: // in Loop: Header=BB125_7 Depth=2 + // kill: def $w19 killed $w19 killed $x19 def $x19 + mov x22, xzr + and x19, x19, #0xffff + b .LBB125_18 +.LBB125_15: // in Loop: Header=BB125_18 Depth=3 + strh w11, [x10, x9, lsl #1] + ldrh w9, [x16, :lo12:g_gc_blk_num] + add w9, w9, #1 // =1 + strh w9, [x16, :lo12:g_gc_blk_num] +.LBB125_16: // in Loop: Header=BB125_18 Depth=3 + ldr x9, [x24, :lo12:p_gc_page_info] + ldrh w10, [x26, :lo12:g_gc_page_offset] + madd x9, x10, x27, x9 + str w23, [x9, #4] + ldr x9, [x24, :lo12:p_gc_page_info] + ldrh w10, [x26, :lo12:g_gc_page_offset] + madd x9, x10, x27, x9 + mov w10, #-1 + str w10, [x9, #8] +.LBB125_17: // in Loop: Header=BB125_18 Depth=3 + ldrh w9, [x26, :lo12:g_gc_page_offset] + ldr x10, [x24, :lo12:p_gc_page_info] + add x22, x22, #1 // =1 + cmp x22, x19 + mul x9, x9, x27 + str w8, [x10, x9] + ldrh w8, [x26, :lo12:g_gc_page_offset] + add w8, w8, #1 // =1 + strh w8, [x26, :lo12:g_gc_page_offset] + b.eq .LBB125_41 +.LBB125_18: // Parent Loop BB125_6 Depth=1 + // Parent Loop BB125_7 Depth=2 + // => This Loop Header: Depth=3 + // Child Loop BB125_21 Depth 4 + // Child Loop BB125_29 Depth 4 + // Child Loop BB125_33 Depth 4 + ldr x8, [x28, :lo12:req_read] + add x8, x8, x22, lsl #5 + ldp w9, w23, [x8] + ldr x25, [x8, #16] + cbz w9, .LBB125_23 +// %bb.19: // in Loop: Header=BB125_18 Depth=3 + ldr w8, [x25, #12] + adrp x9, c_ftl_nand_blks_per_die + ldrh w11, [x9, :lo12:c_ftl_nand_blks_per_die] + adrp x9, c_ftl_nand_planes_per_die + ldrh w12, [x9, :lo12:c_ftl_nand_planes_per_die] + adrp x10, p_gc_blk_tbl + ldrh w9, [x16, :lo12:g_gc_blk_num] + ubfx w13, w8, #10, #16 + ldr x10, [x10, :lo12:p_gc_blk_tbl] + udiv w14, w13, w11 + msub w11, w14, w11, w13 + udiv w11, w11, w12 + cbz x9, .LBB125_15 +// %bb.20: // in Loop: Header=BB125_18 Depth=3 + mov x12, xzr +.LBB125_21: // Parent Loop BB125_6 Depth=1 + // Parent Loop BB125_7 Depth=2 + // Parent Loop BB125_18 Depth=3 + // => This Inner Loop Header: Depth=4 + ldrh w13, [x10, x12, lsl #1] + cmp w13, w11, uxth + b.eq .LBB125_35 +// %bb.22: // in Loop: Header=BB125_21 Depth=4 + add x12, x12, #1 // =1 + cmp x9, x12 + b.ne .LBB125_21 + b .LBB125_15 +.LBB125_23: // in Loop: Header=BB125_18 Depth=3 + ldrsh w8, [x25] + cmn w8, #1 // =1 + b.eq .LBB125_40 +// %bb.24: // in Loop: Header=BB125_18 Depth=3 + adrp x8, g_MaxLpn + ldr w0, [x25, #8] + ldr w8, [x8, :lo12:g_MaxLpn] + cmp w0, w8 + b.hi .LBB125_40 +// %bb.25: // in Loop: Header=BB125_18 Depth=3 + add x1, sp, #36 // =36 + mov w2, wzr + bl log2phys + ldr w8, [sp, #36] + adrp x16, g_gc_blk_num + cmn w8, #1 // =1 + b.eq .LBB125_31 +// %bb.26: // in Loop: Header=BB125_18 Depth=3 + ldr w9, [x25, #12] + cmp w8, w9 + b.ne .LBB125_31 +// %bb.27: // in Loop: Header=BB125_18 Depth=3 + adrp x9, p_io_data_buf_1 + adrp x10, p_io_spare_buf + ldr x9, [x9, :lo12:p_io_data_buf_1] + ldr x10, [x10, :lo12:p_io_spare_buf] + add x0, sp, #40 // =40 + mov w1, #1 + str w8, [sp, #44] + stp x9, x10, [sp, #48] + bl FlashReadPages + adrp x8, c_ftl_nand_sec_pre_page + ldrh w10, [x8, :lo12:c_ftl_nand_sec_pre_page] + adrp x16, g_gc_blk_num + cbz x10, .LBB125_31 +// %bb.28: // in Loop: Header=BB125_18 Depth=3 + ldr x8, [x28, :lo12:req_read] + ldr x9, [sp, #48] + lsl x10, x10, #7 + add x8, x8, x22, lsl #5 + ldr x8, [x8, #8] +.LBB125_29: // Parent Loop BB125_6 Depth=1 + // Parent Loop BB125_7 Depth=2 + // Parent Loop BB125_18 Depth=3 + // => This Inner Loop Header: Depth=4 + ldr w11, [x8] + ldr w12, [x9] + cmp w11, w12 + b.ne .LBB125_39 +// %bb.30: // in Loop: Header=BB125_29 Depth=4 + add x8, x8, #4 // =4 + subs x10, x10, #1 // =1 + add x9, x9, #4 // =4 + b.ne .LBB125_29 +.LBB125_31: // in Loop: Header=BB125_18 Depth=3 + ldp w9, w8, [x25, #8] + adrp x10, c_ftl_nand_blks_per_die + ldrh w12, [x10, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w13, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x11, p_gc_blk_tbl + ldrh w10, [x16, :lo12:g_gc_blk_num] + ubfx w14, w8, #10, #16 + ldr x11, [x11, :lo12:p_gc_blk_tbl] + udiv w15, w14, w12 + msub w12, w15, w12, w14 + udiv w12, w12, w13 + cbz x10, .LBB125_37 +// %bb.32: // in Loop: Header=BB125_18 Depth=3 + mov x13, xzr +.LBB125_33: // Parent Loop BB125_6 Depth=1 + // Parent Loop BB125_7 Depth=2 + // Parent Loop BB125_18 Depth=3 + // => This Inner Loop Header: Depth=4 + ldrh w14, [x11, x13, lsl #1] + cmp w14, w12, uxth + b.eq .LBB125_36 +// %bb.34: // in Loop: Header=BB125_33 Depth=4 + add x13, x13, #1 // =1 + cmp x10, x13 + b.ne .LBB125_33 + b .LBB125_37 +.LBB125_35: // in Loop: Header=BB125_18 Depth=3 + cmp w9, w12, uxth + b.eq .LBB125_15 + b .LBB125_16 +.LBB125_36: // in Loop: Header=BB125_18 Depth=3 + cmp w10, w13, uxth + b.ne .LBB125_38 +.LBB125_37: // in Loop: Header=BB125_18 Depth=3 + strh w12, [x11, x10, lsl #1] + ldrh w10, [x16, :lo12:g_gc_blk_num] + add w10, w10, #1 // =1 + strh w10, [x16, :lo12:g_gc_blk_num] +.LBB125_38: // in Loop: Header=BB125_18 Depth=3 + ldr x10, [x24, :lo12:p_gc_page_info] + ldrh w11, [x26, :lo12:g_gc_page_offset] + madd x10, x11, x27, x10 + str w23, [x10, #4] + ldr x10, [x24, :lo12:p_gc_page_info] + ldrh w11, [x26, :lo12:g_gc_page_offset] + madd x10, x11, x27, x10 + str w9, [x10, #8] + b .LBB125_17 +.LBB125_39: // in Loop: Header=BB125_7 Depth=2 + ldr x8, [sp, #24] // 8-byte Folded Reload + ldr w2, [sp, #44] + adrp x0, .L.str.111 + add x0, x0, :lo12:.L.str.111 + ldrh w1, [x8] + bl sftl_printk +.LBB125_40: // in Loop: Header=BB125_7 Depth=2 + ldr x22, [sp, #24] // 8-byte Folded Reload + adrp x8, p_valid_page_count_table + ldr x8, [x8, :lo12:p_valid_page_count_table] + ldrh w9, [x22] + strh wzr, [x8, x9, lsl #1] + ldrh w0, [x22] + bl INSERT_FREE_LIST + strh w21, [x22] + adrp x8, g_gc_superblock + adrp x19, c_ftl_nand_page_pre_super_blk + strh w21, [x8, :lo12:g_gc_superblock] + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk] + adrp x9, p_gc_blk_tbl + ldr x0, [x9, :lo12:p_gc_blk_tbl] + adrp x9, g_gc_blk_num + lsl x2, x8, #1 + mov w1, #255 + strh wzr, [x9, :lo12:g_gc_blk_num] + strh wzr, [x26, :lo12:g_gc_page_offset] + bl memset + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk] + ldr x0, [x24, :lo12:p_gc_page_info] + mov w1, #255 + add x8, x8, x8, lsl #1 + lsl x2, x8, #2 + bl memset + bl FtlGcBufInit + ldrsh w8, [x22] + mov w9, wzr + mov w19, wzr + adrp x16, c_ftl_nand_planes_num + cmn w8, #1 // =1 + adrp x17, p_gc_data_buf + adrp x18, c_ftl_nand_byte_pre_page + adrp x0, p_gc_spare_buf + adrp x1, c_ftl_nand_byte_pre_oob + strb wzr, [x22, #8] + b.ne .LBB125_7 + b .LBB125_44 +.LBB125_41: // in Loop: Header=BB125_6 Depth=1 + ldp w8, w10, [sp, #12] // 8-byte Folded Reload + ldr x22, [sp, #24] // 8-byte Folded Reload + add w10, w10, #1 // =1 + cmp w10, w8 + ldr w8, [sp, #20] // 4-byte Folded Reload + add w19, w8, #1 // =1 + b.lo .LBB125_5 +// %bb.42: // in Loop: Header=BB125_6 Depth=1 + adrp x8, ftl_gc_temp_block_bops_scan_page_addr + ldrh w8, [x8, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + cmp w8, w21 + b.eq .LBB125_5 +// %bb.43: // in Loop: Header=BB125_6 Depth=1 + adrp x9, c_ftl_nand_page_pre_blk + ldrh w9, [x9, :lo12:c_ftl_nand_page_pre_blk] + add w8, w8, w10 + cmp w9, w19, uxth + adrp x9, ftl_gc_temp_block_bops_scan_page_addr + strh w8, [x9, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + b.ls .LBB125_5 + b .LBB125_53 +.LBB125_44: + mov w8, #65535 + adrp x9, ftl_gc_temp_block_bops_scan_page_addr + strh w8, [x9, :lo12:ftl_gc_temp_block_bops_scan_page_addr] + strh w19, [x22, #2] + strb wzr, [x22, #6] + strh wzr, [x22, #4] + ldrh w8, [x16, :lo12:c_ftl_nand_planes_num] + cbz x8, .LBB125_53 +// %bb.45: + mov w9, wzr + add x10, x22, #16 // =16 + mov x11, x8 + b .LBB125_47 +.LBB125_46: // in Loop: Header=BB125_47 Depth=1 + subs x11, x11, #1 // =1 + add x10, x10, #2 // =2 + b.eq .LBB125_49 +.LBB125_47: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x10] + cmn w12, #1 // =1 + b.eq .LBB125_46 +// %bb.48: // in Loop: Header=BB125_47 Depth=1 + add w9, w9, #1 // =1 + strh w9, [x22, #4] + b .LBB125_46 +.LBB125_49: + adrp x10, c_ftl_nand_page_pre_blk + ldrh w10, [x10, :lo12:c_ftl_nand_page_pre_blk] + mvn w11, w19 + add w10, w10, w11 + add x11, x22, #16 // =16 + b .LBB125_51 +.LBB125_50: // in Loop: Header=BB125_51 Depth=1 + subs x8, x8, #1 // =1 + add x11, x11, #2 // =2 + b.eq .LBB125_53 +.LBB125_51: // =>This Inner Loop Header: Depth=1 + ldrsh w12, [x11] + cmn w12, #1 // =1 + b.eq .LBB125_50 +// %bb.52: // in Loop: Header=BB125_51 Depth=1 + add w9, w10, w9 + strh w9, [x22, #4] + b .LBB125_50 +.LBB125_53: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB125_55 +// %bb.54: + ldp x20, x19, [sp, #160] // 16-byte Folded Reload + ldp x22, x21, [sp, #144] // 16-byte Folded Reload + ldp x24, x23, [sp, #128] // 16-byte Folded Reload + ldp x26, x25, [sp, #112] // 16-byte Folded Reload + ldp x28, x27, [sp, #96] // 16-byte Folded Reload + ldp x29, x30, [sp, #80] // 16-byte Folded Reload + mov w0, #-1 + add sp, sp, #176 // =176 + hint #29 + ret +.LBB125_55: + bl __stack_chk_fail +.Lfunc_end125: + .size FtlGcScanTempBlk, .Lfunc_end125-FtlGcScanTempBlk + // -- End function + .globl FtlGcPageVarInit // -- Begin function FtlGcPageVarInit + .p2align 2 + .type FtlGcPageVarInit,@function +FtlGcPageVarInit: // @FtlGcPageVarInit +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + str x19, [sp, #16] // 8-byte Folded Spill + adrp x8, g_gc_blk_num + adrp x19, c_ftl_nand_page_pre_super_blk + adrp x9, p_gc_blk_tbl + strh wzr, [x8, :lo12:g_gc_blk_num] + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk] + ldr x0, [x9, :lo12:p_gc_blk_tbl] + adrp x9, g_gc_page_offset + mov w1, #255 + lsl x2, x8, #1 + mov x29, sp + strh wzr, [x9, :lo12:g_gc_page_offset] + bl memset + ldrh w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk] + adrp x9, p_gc_page_info + ldr x0, [x9, :lo12:p_gc_page_info] + mov w1, #255 + add x8, x8, x8, lsl #1 + lsl x2, x8, #2 + bl memset + bl FtlGcBufInit + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end126: + .size FtlGcPageVarInit, .Lfunc_end126-FtlGcPageVarInit + // -- End function + .globl Ftl_get_new_temp_ppa // -- Begin function Ftl_get_new_temp_ppa + .p2align 2 + .type Ftl_get_new_temp_ppa,@function +Ftl_get_new_temp_ppa: // @Ftl_get_new_temp_ppa +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + adrp x19, g_gc_temp_superblock + add x19, x19, :lo12:g_gc_temp_superblock + ldrsh w8, [x19] + str x23, [sp, #16] // 8-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + mov x29, sp + cmn w8, #1 // =1 + b.eq .LBB127_2 +// %bb.1: + ldrh w8, [x19, #4] + cbnz w8, .LBB127_8 +.LBB127_2: + mov w0, wzr + bl FtlGcFreeTempBlock + mov x0, x19 + strb wzr, [x19, #8] + bl allocate_data_superblock + adrp x8, g_gc_blk_num + adrp x9, g_gc_page_offset + strh wzr, [x8, :lo12:g_gc_blk_num] + strh wzr, [x9, :lo12:g_gc_page_offset] + bl FtlWriteDump_data + adrp x20, c_ftl_nand_l2pmap_ram_region_num + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + cbz w8, .LBB127_7 +// %bb.3: + adrp x19, gL2pMapInfo + mov x21, xzr + mov x22, xzr + adrp x23, p_l2p_ram_map + add x19, x19, :lo12:gL2pMapInfo + b .LBB127_5 +.LBB127_4: // in Loop: Header=BB127_5 Depth=1 + add x22, x22, #1 // =1 + cmp x22, w8, uxth + add x21, x21, #16 // =16 + b.hs .LBB127_7 +.LBB127_5: // =>This Inner Loop Header: Depth=1 + ldr x9, [x23, :lo12:p_l2p_ram_map] + add x9, x9, x21 + ldr w10, [x9, #4] + tbz w10, #31, .LBB127_4 +// %bb.6: // in Loop: Header=BB127_5 Depth=1 + ldrh w1, [x9] + ldr x2, [x9, #8] + mov x0, x19 + bl FtlMapWritePage + ldr x8, [x23, :lo12:p_l2p_ram_map] + add x8, x8, x21 + ldr w9, [x8, #4] + and w9, w9, #0x7fffffff + str w9, [x8, #4] + ldrh w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num] + b .LBB127_4 +.LBB127_7: + mov w0, wzr + bl FtlEctTblFlush + bl FtlVpcTblFlush +.LBB127_8: + adrp x0, g_gc_temp_superblock + add x0, x0, :lo12:g_gc_temp_superblock + bl get_new_active_ppa + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end127: + .size Ftl_get_new_temp_ppa, .Lfunc_end127-Ftl_get_new_temp_ppa + // -- End function + .globl Ftl_gc_temp_data_write_back // -- Begin function Ftl_gc_temp_data_write_back + .p2align 2 + .type Ftl_gc_temp_data_write_back,@function +Ftl_gc_temp_data_write_back: // @Ftl_gc_temp_data_write_back +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + stp x20, x19, [sp, #16] // 16-byte Folded Spill + adrp x19, req_gc_dst + adrp x20, g_gc_num_req + ldr x0, [x19, :lo12:req_gc_dst] + ldr w1, [x20, :lo12:g_gc_num_req] + mov w2, wzr + mov x29, sp + bl FlashProgPages + ldr w8, [x20, :lo12:g_gc_num_req] + cbz w8, .LBB128_25 +// %bb.1: + mov w8, wzr + adrp x9, c_ftl_nand_blks_per_die + adrp x10, c_ftl_nand_planes_per_die + adrp x11, g_gc_blk_num + adrp x12, p_gc_blk_tbl + adrp x13, p_gc_page_info + adrp x14, g_gc_page_offset + mov w15, #12 + b .LBB128_4 +.LBB128_2: // in Loop: Header=BB128_4 Depth=1 + strh w2, [x1, x0, lsl #1] + ldrh w0, [x11, :lo12:g_gc_blk_num] + add w0, w0, #1 // =1 + strh w0, [x11, :lo12:g_gc_blk_num] +.LBB128_3: // in Loop: Header=BB128_4 Depth=1 + ldr x0, [x13, :lo12:p_gc_page_info] + ldrh w1, [x14, :lo12:g_gc_page_offset] + add w8, w8, #1 // =1 + madd x0, x1, x15, x0 + str w17, [x0, #4] + ldr x17, [x13, :lo12:p_gc_page_info] + ldrh w0, [x14, :lo12:g_gc_page_offset] + madd x17, x0, x15, x17 + str w18, [x17, #8] + ldrh w17, [x14, :lo12:g_gc_page_offset] + ldr x18, [x13, :lo12:p_gc_page_info] + mul x17, x17, x15 + str w16, [x18, x17] + ldrh w17, [x14, :lo12:g_gc_page_offset] + ldr w16, [x20, :lo12:g_gc_num_req] + add w17, w17, #1 // =1 + cmp w16, w8, uxth + strh w17, [x14, :lo12:g_gc_page_offset] + b.ls .LBB128_17 +.LBB128_4: // =>This Loop Header: Depth=1 + // Child Loop BB128_7 Depth 2 + // Child Loop BB128_11 Depth 2 + ldr x16, [x19, :lo12:req_gc_dst] + and x17, x8, #0xffff + add x17, x16, x17, lsl #5 + ldr x18, [x17, #16] + ldp w0, w17, [x17] + ldr w16, [x18, #12] + cmn w0, #1 // =1 + b.eq .LBB128_9 +// %bb.5: // in Loop: Header=BB128_4 Depth=1 + ldrh w3, [x9, :lo12:c_ftl_nand_blks_per_die] + ldrh w4, [x10, :lo12:c_ftl_nand_planes_per_die] + ldr w18, [x18, #8] + ubfx w2, w16, #10, #16 + ldrh w0, [x11, :lo12:g_gc_blk_num] + ldr x1, [x12, :lo12:p_gc_blk_tbl] + udiv w5, w2, w3 + msub w2, w5, w3, w2 + udiv w2, w2, w4 + cbz x0, .LBB128_2 +// %bb.6: // in Loop: Header=BB128_4 Depth=1 + mov x3, xzr +.LBB128_7: // Parent Loop BB128_4 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w4, [x1, x3, lsl #1] + cmp w4, w2, uxth + b.eq .LBB128_13 +// %bb.8: // in Loop: Header=BB128_7 Depth=2 + add x3, x3, #1 // =1 + cmp x0, x3 + b.ne .LBB128_7 + b .LBB128_2 +.LBB128_9: // in Loop: Header=BB128_4 Depth=1 + ldrh w2, [x9, :lo12:c_ftl_nand_blks_per_die] + ldrh w3, [x10, :lo12:c_ftl_nand_planes_per_die] + ubfx w1, w16, #10, #16 + ldrh w18, [x11, :lo12:g_gc_blk_num] + ldr x0, [x12, :lo12:p_gc_blk_tbl] + udiv w4, w1, w2 + msub w1, w4, w2, w1 + udiv w1, w1, w3 + cbz x18, .LBB128_15 +// %bb.10: // in Loop: Header=BB128_4 Depth=1 + mov x2, xzr +.LBB128_11: // Parent Loop BB128_4 Depth=1 + // => This Inner Loop Header: Depth=2 + ldrh w3, [x0, x2, lsl #1] + cmp w3, w1, uxth + b.eq .LBB128_14 +// %bb.12: // in Loop: Header=BB128_11 Depth=2 + add x2, x2, #1 // =1 + cmp x18, x2 + b.ne .LBB128_11 + b .LBB128_15 +.LBB128_13: // in Loop: Header=BB128_4 Depth=1 + cmp w0, w3, uxth + b.ne .LBB128_3 + b .LBB128_2 +.LBB128_14: // in Loop: Header=BB128_4 Depth=1 + cmp w18, w2, uxth + b.ne .LBB128_16 +.LBB128_15: // in Loop: Header=BB128_4 Depth=1 + strh w1, [x0, x18, lsl #1] + ldrh w18, [x11, :lo12:g_gc_blk_num] + add w18, w18, #1 // =1 + strh w18, [x11, :lo12:g_gc_blk_num] +.LBB128_16: // in Loop: Header=BB128_4 Depth=1 + mov w18, #-1 + b .LBB128_3 +.LBB128_17: + cbz w16, .LBB128_25 +// %bb.18: + ldr x9, [x19, :lo12:req_gc_dst] + mov w8, wzr + adrp x10, c_gc_page_buf_num + adrp x11, gp_gc_page_buf_info + mov w12, #24 + b .LBB128_21 +.LBB128_19: // in Loop: Header=BB128_21 Depth=1 + // kill: def $w17 killed $w17 killed $x17 def $x17 + and x14, x17, #0xffff + madd x13, x14, x12, x13 + str wzr, [x13, #16] +.LBB128_20: // in Loop: Header=BB128_21 Depth=1 + add w8, w8, #1 // =1 + cmp w16, w8, uxth + b.ls .LBB128_25 +.LBB128_21: // =>This Loop Header: Depth=1 + // Child Loop BB128_23 Depth 2 + ldr w14, [x10, :lo12:c_gc_page_buf_num] + cbz w14, .LBB128_20 +// %bb.22: // in Loop: Header=BB128_21 Depth=1 + and x15, x8, #0xffff + add x15, x9, x15, lsl #5 + ldr x13, [x11, :lo12:gp_gc_page_buf_info] + ldr x15, [x15, #8] + mov w17, wzr +.LBB128_23: // Parent Loop BB128_21 Depth=1 + // => This Inner Loop Header: Depth=2 + and x18, x17, #0xffff + mul x18, x18, x12 + ldr x18, [x13, x18] + cmp x18, x15 + b.eq .LBB128_19 +// %bb.24: // in Loop: Header=BB128_23 Depth=2 + add w17, w17, #1 // =1 + cmp w14, w17, uxth + b.hi .LBB128_23 + b .LBB128_20 +.LBB128_25: + adrp x8, g_gc_temp_superblock+4 + ldrh w8, [x8, :lo12:g_gc_temp_superblock+4] + mov w19, wzr + str wzr, [x20, :lo12:g_gc_num_req] + cbnz w8, .LBB128_27 +// %bb.26: + mov w0, #1 + mov w19, #1 + bl FtlGcFreeTempBlock +.LBB128_27: + mov w0, w19 + ldp x20, x19, [sp, #16] // 16-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end128: + .size Ftl_gc_temp_data_write_back, .Lfunc_end128-Ftl_gc_temp_data_write_back + // -- End function + .globl FtlGcMarkBadPhyBlk // -- Begin function FtlGcMarkBadPhyBlk + .p2align 2 + .type FtlGcMarkBadPhyBlk,@function +FtlGcMarkBadPhyBlk: // @FtlGcMarkBadPhyBlk +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + str x21, [sp, #16] // 8-byte Folded Spill + adrp x9, c_ftl_nand_planes_per_die + adrp x21, g_gc_bad_block_temp_num + ldrh w9, [x9, :lo12:c_ftl_nand_planes_per_die] + ldrh w1, [x21, :lo12:g_gc_bad_block_temp_num] + and w2, w0, #0xffff + stp x20, x19, [sp, #32] // 16-byte Folded Spill + mov w19, w0 + udiv w10, w2, w8 + adrp x0, .L.str.113 + msub w8, w10, w8, w2 + add x0, x0, :lo12:.L.str.113 + mov x29, sp + udiv w20, w8, w9 + bl sftl_printk + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w20 + bl sftl_printk + adrp x8, g_gc_next_blk + ldrh w10, [x8, :lo12:g_gc_next_blk] + cmp w10, w20 + b.eq .LBB129_5 +// %bb.1: + adrp x9, g_gc_next_blk_1 + ldrh w11, [x9, :lo12:g_gc_next_blk_1] + cmp w11, w20, uxth + b.eq .LBB129_5 +// %bb.2: + mov w12, #65535 + cmp w10, w12 + b.eq .LBB129_12 +// %bb.3: + cmp w11, w12 + b.ne .LBB129_5 +// %bb.4: + strh w20, [x9, :lo12:g_gc_next_blk_1] +.LBB129_5: + ldrh w8, [x21, :lo12:g_gc_bad_block_temp_num] + cbz x8, .LBB129_10 +.LBB129_6: + adrp x9, g_gc_bad_block_temp_tbl + add x9, x9, :lo12:g_gc_bad_block_temp_tbl + mov x10, x8 +.LBB129_7: // =>This Inner Loop Header: Depth=1 + ldrh w11, [x9] + cmp w11, w19, uxth + b.eq .LBB129_11 +// %bb.8: // in Loop: Header=BB129_7 Depth=1 + subs x10, x10, #1 // =1 + add x9, x9, #2 // =2 + b.ne .LBB129_7 +// %bb.9: + cmp w8, #15 // =15 + b.hi .LBB129_11 +.LBB129_10: + adrp x9, g_gc_bad_block_temp_tbl + add x9, x9, :lo12:g_gc_bad_block_temp_tbl + add w10, w8, #1 // =1 + strh w10, [x21, :lo12:g_gc_bad_block_temp_num] + strh w19, [x9, w8, uxtw #1] +.LBB129_11: + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldr x21, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.LBB129_12: + strh w20, [x8, :lo12:g_gc_next_blk] + ldrh w8, [x21, :lo12:g_gc_bad_block_temp_num] + cbnz x8, .LBB129_6 + b .LBB129_10 +.Lfunc_end129: + .size FtlGcMarkBadPhyBlk, .Lfunc_end129-FtlGcMarkBadPhyBlk + // -- End function + .globl FtlGcReFreshBadBlk // -- Begin function FtlGcReFreshBadBlk + .p2align 2 + .type FtlGcReFreshBadBlk,@function +FtlGcReFreshBadBlk: // @FtlGcReFreshBadBlk +// %bb.0: + hint #25 + stp x29, x30, [sp, #-48]! // 16-byte Folded Spill + adrp x8, g_gc_bad_block_temp_num + ldrh w9, [x8, :lo12:g_gc_bad_block_temp_num] + str x21, [sp, #16] // 8-byte Folded Spill + stp x20, x19, [sp, #32] // 16-byte Folded Spill + mov x29, sp + cbz w9, .LBB130_11 +// %bb.1: + adrp x21, g_gc_next_blk + ldrh w8, [x21, :lo12:g_gc_next_blk] + mov w10, #65535 + cmp w8, w10 + b.ne .LBB130_11 +// %bb.2: + adrp x20, g_gc_bad_block_gc_index + ldrh w8, [x20, :lo12:g_gc_bad_block_gc_index] + cmp w8, w9 + b.lo .LBB130_4 +// %bb.3: + mov w8, wzr + strh wzr, [x20, :lo12:g_gc_bad_block_gc_index] +.LBB130_4: + adrp x9, g_gc_bad_block_temp_tbl + add x9, x9, :lo12:g_gc_bad_block_temp_tbl + adrp x10, c_ftl_nand_blks_per_die + ldrh w8, [x9, w8, uxtw #1] + ldrh w9, [x10, :lo12:c_ftl_nand_blks_per_die] + adrp x10, c_ftl_nand_planes_per_die + ldrh w10, [x10, :lo12:c_ftl_nand_planes_per_die] + adrp x0, .L.str.112 + udiv w11, w8, w9 + msub w8, w11, w9, w8 + udiv w19, w8, w10 + add x0, x0, :lo12:.L.str.112 + mov w1, w19 + bl sftl_printk + ldrh w9, [x21, :lo12:g_gc_next_blk] + cmp w9, w19 + b.eq .LBB130_10 +// %bb.5: + adrp x8, g_gc_next_blk_1 + ldrh w10, [x8, :lo12:g_gc_next_blk_1] + cmp w10, w19, uxth + b.eq .LBB130_10 +// %bb.6: + mov w11, #65535 + cmp w9, w11 + b.eq .LBB130_9 +// %bb.7: + cmp w10, w11 + b.ne .LBB130_10 +// %bb.8: + strh w19, [x8, :lo12:g_gc_next_blk_1] + b .LBB130_10 +.LBB130_9: + strh w19, [x21, :lo12:g_gc_next_blk] +.LBB130_10: + ldrh w8, [x20, :lo12:g_gc_bad_block_gc_index] + add w8, w8, #1 // =1 + strh w8, [x20, :lo12:g_gc_bad_block_gc_index] +.LBB130_11: + ldp x20, x19, [sp, #32] // 16-byte Folded Reload + ldr x21, [sp, #16] // 8-byte Folded Reload + mov w0, wzr + ldp x29, x30, [sp], #48 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end130: + .size FtlGcReFreshBadBlk, .Lfunc_end130-FtlGcReFreshBadBlk + // -- End function + .globl FtlReadRefresh // -- Begin function FtlReadRefresh + .p2align 2 + .type FtlReadRefresh,@function +FtlReadRefresh: // @FtlReadRefresh +// %bb.0: + hint #25 + sub sp, sp, #160 // =160 + adrp x8, __stack_chk_guard + ldr x8, [x8, :lo12:__stack_chk_guard] + stp x29, x30, [sp, #112] // 16-byte Folded Spill + add x29, sp, #112 // =112 + stp x22, x21, [sp, #128] // 16-byte Folded Spill + stp x20, x19, [sp, #144] // 16-byte Folded Spill + stur x8, [x29, #-8] + adrp x8, g_sys_ext_data+80 + ldr w8, [x8, :lo12:g_sys_ext_data+80] + cbz w8, .LBB131_6 +// %bb.1: + adrp x19, g_sys_ext_data+84 + adrp x20, g_MaxLpn + ldr w8, [x19, :lo12:g_sys_ext_data+84] + ldr w9, [x20, :lo12:g_MaxLpn] + cmp w8, w9 + b.hs .LBB131_11 +// %bb.2: + mov w21, #2047 +.LBB131_3: // =>This Inner Loop Header: Depth=1 + add x1, sp, #36 // =36 + mov w0, w8 + mov w2, wzr + bl log2phys + ldr w8, [x19, :lo12:g_sys_ext_data+84] + ldr w22, [sp, #36] + add w8, w8, #1 // =1 + cmn w22, #1 // =1 + str w8, [x19, :lo12:g_sys_ext_data+84] + b.ne .LBB131_12 +// %bb.4: // in Loop: Header=BB131_3 Depth=1 + subs w21, w21, #1 // =1 + mov w0, #-1 + b.lo .LBB131_20 +// %bb.5: // in Loop: Header=BB131_3 Depth=1 + ldr w9, [x20, :lo12:g_MaxLpn] + cmp w8, w9 + b.lo .LBB131_3 + b .LBB131_20 +.LBB131_6: + adrp x8, g_max_erase_count + adrp x11, g_totle_read_page_count + ldr w12, [x8, :lo12:g_max_erase_count] + ldr w8, [x11, :lo12:g_totle_read_page_count] + adrp x11, g_sys_ext_data+76 + ldr w11, [x11, :lo12:g_sys_ext_data+76] + mov w9, #10000 + mov w10, #63 + mov w13, #31 + cmp w12, w9 + add w9, w8, #256, lsl #12 // =1048576 + csel w10, w13, w10, hi + cmp w11, w9 + adrp x9, g_sys_save_data+28 + b.hi .LBB131_10 +// %bb.7: + adrp x13, g_MaxLpn + ldr w13, [x13, :lo12:g_MaxLpn] + mov w14, #1000 + lsr w12, w12, #10 + add w12, w12, #1 // =1 + mul w13, w13, w14 + udiv w12, w13, w12 + add w11, w12, w11 + cmp w11, w8 + b.lo .LBB131_10 +// %bb.8: + adrp x12, g_sys_ext_data+100 + ldrh w11, [x9, :lo12:g_sys_save_data+28] + ldr w12, [x12, :lo12:g_sys_ext_data+100] + mov w0, wzr + cmp w12, w11 + b.eq .LBB131_20 +// %bb.9: + and w10, w10, w11 + cbnz w10, .LBB131_20 +.LBB131_10: + ldrh w9, [x9, :lo12:g_sys_save_data+28] + adrp x10, g_sys_ext_data+76 + mov w0, wzr + add x10, x10, :lo12:g_sys_ext_data+76 + mov w11, #1 + stur x11, [x10, #4] + str w9, [x10, #24] + str w8, [x10] + b .LBB131_20 +.LBB131_11: + adrp x8, g_totle_read_page_count + ldr w8, [x8, :lo12:g_totle_read_page_count] + adrp x9, g_sys_ext_data+76 + add x9, x9, :lo12:g_sys_ext_data+76 + mov w0, wzr + stur xzr, [x9, #4] + str w8, [x9] + b .LBB131_20 +.LBB131_12: + adrp x9, sftl_temp_buf + ldr x9, [x9, :lo12:sftl_temp_buf] + str w8, [sp, #24] + add x8, sp, #40 // =40 + mov x0, sp + mov w1, #1 + stp x9, x8, [sp, #8] + stp wzr, w22, [sp] + bl FlashReadPages + ldr w8, [sp] + cmp w8, #256 // =256 + b.ne .LBB131_19 +// %bb.13: + adrp x8, c_ftl_nand_blks_per_die + ldrh w8, [x8, :lo12:c_ftl_nand_blks_per_die] + adrp x9, c_ftl_nand_planes_per_die + ldrh w9, [x9, :lo12:c_ftl_nand_planes_per_die] + ubfx w10, w22, #10, #16 + udiv w11, w10, w8 + msub w8, w11, w8, w10 + udiv w19, w8, w9 + adrp x0, .L.str.112 + add x0, x0, :lo12:.L.str.112 + mov w1, w19 + bl sftl_printk + adrp x8, g_gc_next_blk + ldrh w10, [x8, :lo12:g_gc_next_blk] + cmp w10, w19 + b.eq .LBB131_19 +// %bb.14: + adrp x9, g_gc_next_blk_1 + ldrh w11, [x9, :lo12:g_gc_next_blk_1] + cmp w11, w19, uxth + b.eq .LBB131_19 +// %bb.15: + mov w12, #65535 + cmp w10, w12 + b.eq .LBB131_18 +// %bb.16: + cmp w11, w12 + b.ne .LBB131_19 +// %bb.17: + strh w19, [x9, :lo12:g_gc_next_blk_1] + b .LBB131_19 +.LBB131_18: + strh w19, [x8, :lo12:g_gc_next_blk] +.LBB131_19: + mov w0, #-1 +.LBB131_20: + adrp x9, __stack_chk_guard + ldur x8, [x29, #-8] + ldr x9, [x9, :lo12:__stack_chk_guard] + cmp x9, x8 + b.ne .LBB131_22 +// %bb.21: + ldp x20, x19, [sp, #144] // 16-byte Folded Reload + ldp x22, x21, [sp, #128] // 16-byte Folded Reload + ldp x29, x30, [sp, #112] // 16-byte Folded Reload + add sp, sp, #160 // =160 + hint #29 + ret +.LBB131_22: + bl __stack_chk_fail +.Lfunc_end131: + .size FtlReadRefresh, .Lfunc_end131-FtlReadRefresh + // -- End function + .globl sftl_gc // -- Begin function sftl_gc + .p2align 2 + .type sftl_gc,@function +sftl_gc: // @sftl_gc +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + mov w0, #1 + mov x29, sp + bl rk_ftl_garbage_collect + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end132: + .size sftl_gc, .Lfunc_end132-sftl_gc + // -- End function + .globl ftl_free // -- Begin function ftl_free + .p2align 2 + .type ftl_free,@function +ftl_free: // @ftl_free +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + mov x29, sp + bl kfree + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end133: + .size ftl_free, .Lfunc_end133-ftl_free + // -- End function + .globl ftl_memcmp // -- Begin function ftl_memcmp + .p2align 2 + .type ftl_memcmp,@function +ftl_memcmp: // @ftl_memcmp +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + mov w2, w2 + mov x29, sp + bl memcmp + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end134: + .size ftl_memcmp, .Lfunc_end134-ftl_memcmp + // -- End function + .globl rk_sftl_vendor_dev_ops_register // -- Begin function rk_sftl_vendor_dev_ops_register + .p2align 2 + .type rk_sftl_vendor_dev_ops_register,@function +rk_sftl_vendor_dev_ops_register: // @rk_sftl_vendor_dev_ops_register +// %bb.0: + hint #25 + adrp x9, _flash_read + ldr x10, [x9, :lo12:_flash_read] + cbz x10, .LBB135_2 +// %bb.1: + mov w0, #-1 + hint #29 + ret +.LBB135_2: + mov x8, x0 + str x8, [x9, :lo12:_flash_read] + adrp x8, _flash_write + mov w0, wzr + str x1, [x8, :lo12:_flash_write] + hint #29 + ret +.Lfunc_end135: + .size rk_sftl_vendor_dev_ops_register, .Lfunc_end135-rk_sftl_vendor_dev_ops_register + // -- End function + .globl rk_sftl_vendor_storage_init // -- Begin function rk_sftl_vendor_storage_init + .p2align 2 + .type rk_sftl_vendor_storage_init,@function +rk_sftl_vendor_storage_init: // @rk_sftl_vendor_storage_init +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + mov w0, #65536 + mov w1, #3265 + mov w2, #4 + str x23, [sp, #16] // 8-byte Folded Spill + stp x22, x21, [sp, #32] // 16-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x29, sp + bl kmalloc_order + adrp x20, g_vendor + str x0, [x20, :lo12:g_vendor] + cbz x0, .LBB136_4 +// %bb.1: + adrp x22, _flash_read + ldr x8, [x22, :lo12:_flash_read] + mov x2, x0 + mov w1, #128 + mov w0, wzr + blr x8 + cbnz w0, .LBB136_7 +// %bb.2: + ldr x2, [x20, :lo12:g_vendor] + mov w21, #22084 + movk w21, #21067, lsl #16 + ldr w8, [x2] + cmp w8, w21 + b.ne .LBB136_5 +// %bb.3: + mov w8, #65532 + ldr w9, [x2, #4] + ldr w8, [x2, x8] + cmp w9, #0 // =0 + ccmp w8, w9, #0, ne + csel w23, w9, wzr, eq + b .LBB136_6 +.LBB136_4: + mov w0, #-12 + b .LBB136_8 +.LBB136_5: + mov w23, wzr +.LBB136_6: + ldr x8, [x22, :lo12:_flash_read] + mov w0, #128 + mov w1, #128 + blr x8 + cbz w0, .LBB136_9 +.LBB136_7: + ldr x0, [x20, :lo12:g_vendor] + bl kfree + mov w0, #-1 + str xzr, [x20, :lo12:g_vendor] +.LBB136_8: + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.LBB136_9: + ldr x19, [x20, :lo12:g_vendor] + ldr w8, [x19] + cmp w8, w21 + b.ne .LBB136_12 +// %bb.10: + mov w8, #65532 + ldr w9, [x19, #4] + ldr w8, [x19, x8] + mov w10, #128 + cmp w8, w9 + cset w8, eq + cmp w23, w9 + cset w11, lo + tst w8, w11 + csel w23, w9, w23, ne + csel w0, w10, wzr, ne + cbz w23, .LBB136_13 +.LBB136_11: + ldr x8, [x22, :lo12:_flash_read] + mov w1, #128 + mov x2, x19 + blr x8 + cbnz w0, .LBB136_7 + b .LBB136_8 +.LBB136_12: + mov w0, wzr + cbnz w23, .LBB136_11 +.LBB136_13: + add x0, x19, #8 // =8 + mov w2, #65524 + mov w1, wzr + bl memset + mov w8, #1 + mov w9, #65532 + mov w10, #-67633152 + mov w0, wzr + stp w21, w8, [x19] + str w8, [x19, x9] + str w10, [x19, #12] + b .LBB136_8 +.Lfunc_end136: + .size rk_sftl_vendor_storage_init, .Lfunc_end136-rk_sftl_vendor_storage_init + // -- End function + .globl rk_sftl_vendor_read // -- Begin function rk_sftl_vendor_read + .p2align 2 + .type rk_sftl_vendor_read,@function +rk_sftl_vendor_read: // @rk_sftl_vendor_read +// %bb.0: + hint #25 + stp x29, x30, [sp, #-32]! // 16-byte Folded Spill + adrp x8, g_vendor + ldr x8, [x8, :lo12:g_vendor] + str x19, [sp, #16] // 8-byte Folded Spill + mov x29, sp + cbz x8, .LBB137_5 +// %bb.1: + ldrh w10, [x8, #10] + cbz x10, .LBB137_5 +// %bb.2: + mov x11, xzr + add x9, x8, #20 // =20 +.LBB137_3: // =>This Inner Loop Header: Depth=1 + ldurh w12, [x9, #-4] + cmp w12, w0 + b.eq .LBB137_6 +// %bb.4: // in Loop: Header=BB137_3 Depth=1 + add x11, x11, #1 // =1 + cmp x11, x10 + add x9, x9, #8 // =8 + b.lo .LBB137_3 +.LBB137_5: + mov w19, #-1 + b .LBB137_7 +.LBB137_6: + ldrh w10, [x9] + ldurh w9, [x9, #-2] + mov x0, x1 + cmp w10, w2 + add x8, x8, x9 + csel w19, w10, w2, lo + add x8, x8, #1024 // =1024 + mov x1, x8 + mov x2, x19 + bl memcpy +.LBB137_7: + mov w0, w19 + ldr x19, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #32 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end137: + .size rk_sftl_vendor_read, .Lfunc_end137-rk_sftl_vendor_read + // -- End function + .globl rk_sftl_vendor_write // -- Begin function rk_sftl_vendor_write + .p2align 2 + .type rk_sftl_vendor_write,@function +rk_sftl_vendor_write: // @rk_sftl_vendor_write +// %bb.0: + hint #25 + sub sp, sp, #112 // =112 + adrp x8, g_vendor + stp x20, x19, [sp, #96] // 16-byte Folded Spill + ldr x19, [x8, :lo12:g_vendor] + stp x29, x30, [sp, #16] // 16-byte Folded Spill + stp x28, x27, [sp, #32] // 16-byte Folded Spill + stp x26, x25, [sp, #48] // 16-byte Folded Spill + stp x24, x23, [sp, #64] // 16-byte Folded Spill + stp x22, x21, [sp, #80] // 16-byte Folded Spill + add x29, sp, #16 // =16 + cbz x19, .LBB138_6 +// %bb.1: + ldrh w23, [x19, #10] + ldrh w24, [x19, #8] + add w8, w2, #63 // =63 + mov w21, w2 + mov w22, w0 + and w25, w8, #0xffffffc0 + cbz w23, .LBB138_5 +// %bb.2: + mov x27, xzr + mov w9, w23 + sub w8, w23, #1 // =1 + add x26, x19, #28 // =28 +.LBB138_3: // =>This Inner Loop Header: Depth=1 + ldurh w10, [x26, #-12] + cmp w10, w22 + b.eq .LBB138_8 +// %bb.4: // in Loop: Header=BB138_3 Depth=1 + add x27, x27, #1 // =1 + cmp x9, x27 + add x26, x26, #8 // =8 + b.ne .LBB138_3 +.LBB138_5: + ldrh w8, [x19, #14] + cmp w25, w8 + b.ls .LBB138_7 +.LBB138_6: + mov w0, #-1 + b .LBB138_18 +.LBB138_7: + add x9, x19, x23, lsl #3 + strh w22, [x9, #16] + ldrh w10, [x19, #12] + sub w8, w8, w25 + strh w21, [x9, #20] + mov w2, w21 + strh w10, [x9, #18] + strh w8, [x19, #14] + add x8, x19, x10 + add w9, w10, w25 + add x0, x8, #1024 // =1024 + strh w9, [x19, #12] + bl memcpy + ldr w9, [x19, #4] + add w8, w23, #1 // =1 + add w11, w24, #1 // =1 + strh w8, [x19, #10] + and w8, w11, #0xffff + cmp w8, #1 // =1 + mov w10, #65532 + csinc w8, wzr, w24, hi + add w9, w9, #1 // =1 + str w9, [x19, #4] + str w9, [x19, x10] + strh w8, [x19, #8] + b .LBB138_17 +.LBB138_8: + ldurh w9, [x26, #-8] + add w9, w9, #63 // =63 + and w20, w9, #0x1ffc0 + cmp w20, w21 + b.hs .LBB138_15 +// %bb.9: + ldrh w23, [x19, #14] + cmp w25, w23 + b.hi .LBB138_6 +// %bb.10: + ldurh w28, [x26, #-10] + cmp w8, w27 + b.ls .LBB138_14 +// %bb.11: + stp w23, w20, [sp] // 8-byte Folded Spill + sub x20, x8, x27 + mov w27, w8 + str x1, [sp, #8] // 8-byte Folded Spill +.LBB138_12: // =>This Inner Loop Header: Depth=1 + ldurh w8, [x26, #-4] + ldrh w9, [x26] + ldurh w11, [x26, #-2] + add x10, x19, #1024 // =1024 + sturh w8, [x26, #-12] + add w8, w9, #63 // =63 + and x23, x8, #0x1ffc0 + add x0, x10, w28, uxtw + add x1, x10, x11 + mov x2, x23 + sturh w28, [x26, #-10] + sturh w9, [x26, #-8] + bl memcpy + add w28, w23, w28 + subs x20, x20, #1 // =1 + add x26, x26, #8 // =8 + b.ne .LBB138_12 +// %bb.13: + ldr x1, [sp, #8] // 8-byte Folded Reload + ldp w23, w20, [sp] // 8-byte Folded Reload +.LBB138_14: + add x8, x19, x27, lsl #3 + and w9, w28, #0xffff + strh w22, [x8, #16] + strh w28, [x8, #18] + strh w21, [x8, #20] + add x8, x19, x9 + add x0, x8, #1024 // =1024 + mov w2, w21 + bl memcpy + add w8, w28, w25 + sub w9, w20, w25 + strh w8, [x19, #12] + add w8, w23, w9 + strh w8, [x19, #14] + b .LBB138_16 +.LBB138_15: + ldurh w8, [x26, #-10] + mov w2, w21 + add x8, x19, x8 + add x0, x8, #1024 // =1024 + bl memcpy + sturh w21, [x26, #-8] +.LBB138_16: + ldr w8, [x19, #4] + add w10, w24, #1 // =1 + and w10, w10, #0xffff + cmp w10, #1 // =1 + mov w9, #65532 + csinc w10, wzr, w24, hi + add w8, w8, #1 // =1 + str w8, [x19, #4] + str w8, [x19, x9] + strh w10, [x19, #8] +.LBB138_17: + adrp x8, _flash_write + ldr x8, [x8, :lo12:_flash_write] + lsl w0, w24, #7 + mov w1, #128 + mov x2, x19 + blr x8 + mov w0, wzr +.LBB138_18: + ldp x20, x19, [sp, #96] // 16-byte Folded Reload + ldp x22, x21, [sp, #80] // 16-byte Folded Reload + ldp x24, x23, [sp, #64] // 16-byte Folded Reload + ldp x26, x25, [sp, #48] // 16-byte Folded Reload + ldp x28, x27, [sp, #32] // 16-byte Folded Reload + ldp x29, x30, [sp, #16] // 16-byte Folded Reload + add sp, sp, #112 // =112 + hint #29 + ret +.Lfunc_end138: + .size rk_sftl_vendor_write, .Lfunc_end138-rk_sftl_vendor_write + // -- End function + .globl rk_sftl_vendor_storage_ioctl // -- Begin function rk_sftl_vendor_storage_ioctl + .p2align 2 + .type rk_sftl_vendor_storage_ioctl,@function +rk_sftl_vendor_storage_ioctl: // @rk_sftl_vendor_storage_ioctl +// %bb.0: + hint #25 + stp x29, x30, [sp, #-64]! // 16-byte Folded Spill + adrp x8, kmalloc_caches+320 + ldr x0, [x8, :lo12:kmalloc_caches+320] + stp x22, x21, [sp, #32] // 16-byte Folded Spill + mov w21, w1 + mov w1, #3265 + str x23, [sp, #16] // 8-byte Folded Spill + stp x20, x19, [sp, #48] // 16-byte Folded Spill + mov x29, sp + mov x20, x2 + bl kmem_cache_alloc + cbz x0, .LBB139_14 +// %bb.1: + mov w8, #30210 + movk w8, #16388, lsl #16 + mov x19, x0 + cmp w21, w8 + b.eq .LBB139_15 +// %bb.2: + mov w8, #30209 + movk w8, #16388, lsl #16 + cmp w21, w8 + b.ne .LBB139_29 +// %bb.3: + //APP + mrs x22, SP_EL0 + //NO_APP + ldrb w10, [x22, #46] + ldr x9, [x22, #8] + lsl x8, x20, #8 + tbnz w10, #5, .LBB139_5 +// %bb.4: + ldr x11, [x22] + mov x10, x20 + tbz w11, #26, .LBB139_6 +.LBB139_5: + and x10, x20, x8, asr #8 +.LBB139_6: + //APP + adds x10, x10, #8 // =8 + csel x9, xzr, x9, hi + csinv x10, x10, xzr, lo + sbcs xzr, x10, x9 + cset x10, ls + + //NO_APP + cbz x10, .LBB139_37 +// %bb.7: + //APP + + + //NO_APP + ldr x9, [x22, #8] + and x23, x20, x8, asr #8 + //APP + bics xzr, x23, x9 + csel x1, x20, xzr, eq + + //NO_APP + //APP + csdb + //NO_APP + mov w2, #8 + mov x0, x19 + bl __arch_copy_from_user + //APP + + + //NO_APP + cbnz x0, .LBB139_38 +// %bb.8: + ldr w8, [x19] + mov w9, #17745 + movk w9, #22098, lsl #16 + cmp w8, w9 + b.ne .LBB139_28 +// %bb.9: + adrp x8, g_vendor + ldr x8, [x8, :lo12:g_vendor] + cbz x8, .LBB139_28 +// %bb.10: + ldrh w9, [x8, #10] + cbz x9, .LBB139_28 +// %bb.11: + ldrh w12, [x19, #4] + ldrh w10, [x19, #6] + add x0, x19, #8 // =8 + add x11, x8, #20 // =20 +.LBB139_12: // =>This Inner Loop Header: Depth=1 + ldurh w13, [x11, #-4] + cmp w13, w12 + b.eq .LBB139_32 +// %bb.13: // in Loop: Header=BB139_12 Depth=1 + subs x9, x9, #1 // =1 + add x11, x11, #8 // =8 + b.ne .LBB139_12 + b .LBB139_28 +.LBB139_14: + mov x21, #-1 + b .LBB139_31 +.LBB139_15: + //APP + mrs x22, SP_EL0 + //NO_APP + ldrb w9, [x22, #46] + ldr x8, [x22, #8] + tbnz w9, #5, .LBB139_17 +// %bb.16: + ldr x10, [x22] + mov x9, x20 + tbz w10, #26, .LBB139_18 +.LBB139_17: + lsl x9, x20, #8 + and x9, x20, x9, asr #8 +.LBB139_18: + //APP + adds x9, x9, #8 // =8 + csel x8, xzr, x8, hi + csinv x9, x9, xzr, lo + sbcs xzr, x9, x8 + cset x9, ls + + //NO_APP + cbz x9, .LBB139_40 +// %bb.19: + lsl x9, x20, #8 + //APP + + + //NO_APP + ldr x8, [x22, #8] + and x23, x20, x9, asr #8 + //APP + bics xzr, x23, x8 + csel x1, x20, xzr, eq + + //NO_APP + //APP + csdb + //NO_APP + mov w2, #8 + mov x0, x19 + bl __arch_copy_from_user + //APP + + + //NO_APP + cbnz x0, .LBB139_41 +// %bb.20: + ldr w8, [x19] + mov w9, #17745 + movk w9, #22098, lsl #16 + cmp w8, w9 + b.ne .LBB139_28 +// %bb.21: + ldrh w9, [x19, #6] + cmp x9, #4087 // =4087 + b.hi .LBB139_28 +// %bb.22: + ldrb w10, [x22, #46] + ldr x8, [x22, #8] + add x21, x9, #8 // =8 + tbnz w10, #5, .LBB139_24 +// %bb.23: + ldr x10, [x22] + mov x9, x20 + tbz w10, #26, .LBB139_25 +.LBB139_24: + mov x9, x23 +.LBB139_25: + //APP + adds x9, x9, x21 + csel x8, xzr, x8, hi + csinv x9, x9, xzr, lo + sbcs xzr, x9, x8 + cset x9, ls + + //NO_APP + cbz x9, .LBB139_43 +// %bb.26: + //APP + + + //NO_APP + ldr x8, [x22, #8] + //APP + bics xzr, x23, x8 + csel x1, x20, xzr, eq + + //NO_APP + //APP + csdb + //NO_APP + mov x0, x19 + mov x2, x21 + bl __arch_copy_from_user + //APP + + + //NO_APP + cbnz x0, .LBB139_44 +// %bb.27: + ldrh w0, [x19, #4] + ldrh w2, [x19, #6] + add x1, x19, #8 // =8 + bl rk_sftl_vendor_write + // kill: def $w0 killed $w0 def $x0 + sxtw x21, w0 + b .LBB139_30 +.LBB139_28: + mov x21, #-1 + b .LBB139_30 +.LBB139_29: + mov x21, #-14 +.LBB139_30: + mov x0, x19 + bl kfree +.LBB139_31: + mov x0, x21 + ldp x20, x19, [sp, #48] // 16-byte Folded Reload + ldp x22, x21, [sp, #32] // 16-byte Folded Reload + ldr x23, [sp, #16] // 8-byte Folded Reload + ldp x29, x30, [sp], #64 // 16-byte Folded Reload + hint #29 + ret +.LBB139_32: + ldrh w9, [x11] + ldurh w11, [x11, #-2] + cmp w9, w10 + add x8, x8, x11 + csel w21, w9, w10, lo + add x1, x8, #1024 // =1024 + mov x2, x21 + bl memcpy + strh w21, [x19, #6] + ldrb w9, [x22, #46] + ldr x8, [x22, #8] + add w2, w21, #8 // =8 + tbnz w9, #5, .LBB139_34 +// %bb.33: + ldr x10, [x22] + mov x9, x20 + tbz w10, #26, .LBB139_35 +.LBB139_34: + mov x9, x23 +.LBB139_35: + mov x21, #-14 + //APP + adds x9, x9, x2 + csel x8, xzr, x8, hi + csinv x9, x9, xzr, lo + sbcs xzr, x9, x8 + cset x9, ls + + //NO_APP + cbz x9, .LBB139_30 +// %bb.36: + //APP + + + //NO_APP + ldr x8, [x22, #8] + //APP + bics xzr, x23, x8 + csel x0, x20, xzr, eq + + //NO_APP + //APP + csdb + //NO_APP + mov x1, x19 + bl __arch_copy_to_user + cmp x0, #0 // =0 + //APP + + + //NO_APP + csel x21, xzr, x21, eq + b .LBB139_30 +.LBB139_37: + mov w2, #8 + b .LBB139_39 +.LBB139_38: + mov x2, x0 +.LBB139_39: + sub x8, x19, x2 + add x0, x8, #8 // =8 + mov w1, wzr + bl memset + adrp x0, .L.str.131 + add x0, x0, :lo12:.L.str.131 + mov w1, #256 + b .LBB139_46 +.LBB139_40: + mov w2, #8 + b .LBB139_42 +.LBB139_41: + mov x2, x0 +.LBB139_42: + sub x8, x19, x2 + add x0, x8, #8 // =8 + mov w1, wzr + bl memset + adrp x0, .L.str.131 + add x0, x0, :lo12:.L.str.131 + mov w1, #276 + b .LBB139_46 +.LBB139_43: + mov x2, x21 + b .LBB139_45 +.LBB139_44: + mov x2, x0 +.LBB139_45: + sub x8, x21, x2 + add x0, x19, x8 + mov w1, wzr + bl memset + adrp x0, .L.str.131 + add x0, x0, :lo12:.L.str.131 + mov w1, #283 +.LBB139_46: + mov x2, x20 + bl sftl_printk + mov x21, #-14 + b .LBB139_30 +.Lfunc_end139: + .size rk_sftl_vendor_storage_ioctl, .Lfunc_end139-rk_sftl_vendor_storage_ioctl + // -- End function + .globl rk_sftl_vendor_register // -- Begin function rk_sftl_vendor_register + .p2align 2 + .type rk_sftl_vendor_register,@function +rk_sftl_vendor_register: // @rk_sftl_vendor_register +// %bb.0: + hint #25 + stp x29, x30, [sp, #-16]! // 16-byte Folded Spill + adrp x0, rkflash_vender_storage_dev + add x0, x0, :lo12:rkflash_vender_storage_dev + mov x29, sp + bl misc_register + ldp x29, x30, [sp], #16 // 16-byte Folded Reload + hint #29 + ret +.Lfunc_end140: + .size rk_sftl_vendor_register, .Lfunc_end140-rk_sftl_vendor_register + // -- End function + .type gFtlInitStatus,@object // @gFtlInitStatus + .data + .globl gFtlInitStatus + .p2align 2 +gFtlInitStatus: + .word 4294967295 // 0xffffffff + .size gFtlInitStatus, 4 + + .type .L.str,@object // @.str + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str: + .asciz "\n%s\n" + .size .L.str, 5 + + .type .L.str.1,@object // @.str.1 +.L.str.1: + .asciz "SFTL version: 5.0.56 20210329" + .size .L.str.1, 30 + + .type .L.str.2,@object // @.str.2 +.L.str.2: + .asciz "act blk: %x %x %x %x %x %x\n" + .size .L.str.2, 28 + + .type g_active_superblock,@object // @g_active_superblock + .bss + .globl g_active_superblock + .p2align 2 +g_active_superblock: + .zero 48 + .size g_active_superblock, 48 + + .type p_valid_page_count_table,@object // @p_valid_page_count_table + .globl p_valid_page_count_table + .p2align 3 +p_valid_page_count_table: + .xword 0 + .size p_valid_page_count_table, 8 + + .type .L.str.3,@object // @.str.3 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.3: + .asciz "buf blk: %x %x %x %x %x %x\n" + .size .L.str.3, 28 + + .type g_buffer_superblock,@object // @g_buffer_superblock + .bss + .globl g_buffer_superblock + .p2align 2 +g_buffer_superblock: + .zero 48 + .size g_buffer_superblock, 48 + + .type .L.str.4,@object // @.str.4 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.4: + .asciz "tmp blk: %x %x %x %x %x %x\n" + .size .L.str.4, 28 + + .type g_gc_temp_superblock,@object // @g_gc_temp_superblock + .bss + .globl g_gc_temp_superblock + .p2align 2 +g_gc_temp_superblock: + .zero 48 + .size g_gc_temp_superblock, 48 + + .type .L.str.5,@object // @.str.5 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.5: + .asciz "gc blk: %x %x %x %x %x %x\n" + .size .L.str.5, 27 + + .type g_gc_superblock,@object // @g_gc_superblock + .bss + .globl g_gc_superblock + .p2align 2 +g_gc_superblock: + .zero 48 + .size g_gc_superblock, 48 + + .type .L.str.6,@object // @.str.6 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.6: + .asciz "free blk: %x %x %x\n" + .size .L.str.6, 20 + + .type g_num_free_superblocks,@object // @g_num_free_superblocks + .bss + .globl g_num_free_superblocks + .p2align 2 +g_num_free_superblocks: + .hword 0 // 0x0 + .size g_num_free_superblocks, 2 + + .type g_gc_next_blk,@object // @g_gc_next_blk + .globl g_gc_next_blk + .p2align 2 +g_gc_next_blk: + .hword 0 // 0x0 + .size g_gc_next_blk, 2 + + .type g_gc_next_blk_1,@object // @g_gc_next_blk_1 + .globl g_gc_next_blk_1 + .p2align 2 +g_gc_next_blk_1: + .hword 0 // 0x0 + .size g_gc_next_blk_1, 2 + + .type .L.str.7,@object // @.str.7 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.7: + .asciz "FLASH INFO:\n" + .size .L.str.7, 13 + + .type .L.str.8,@object // @.str.8 +.L.str.8: + .asciz "Device Capacity: %d MB\n" + .size .L.str.8, 24 + + .type DeviceCapacity,@object // @DeviceCapacity + .bss + .globl DeviceCapacity + .p2align 2 +DeviceCapacity: + .word 0 // 0x0 + .size DeviceCapacity, 4 + + .type .L.str.9,@object // @.str.9 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.9: + .asciz "FTL INFO:\n" + .size .L.str.9, 11 + + .type .L.str.10,@object // @.str.10 +.L.str.10: + .asciz "g_MaxLpn = 0x%x\n" + .size .L.str.10, 17 + + .type g_MaxLpn,@object // @g_MaxLpn + .bss + .globl g_MaxLpn + .p2align 2 +g_MaxLpn: + .word 0 // 0x0 + .size g_MaxLpn, 4 + + .type .L.str.11,@object // @.str.11 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.11: + .asciz "g_VaildLpn = 0x%x\n" + .size .L.str.11, 19 + + .type g_VaildLpn,@object // @g_VaildLpn + .bss + .globl g_VaildLpn + .p2align 2 +g_VaildLpn: + .word 0 // 0x0 + .size g_VaildLpn, 4 + + .type .L.str.12,@object // @.str.12 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.12: + .asciz "read_page_count = 0x%x\n" + .size .L.str.12, 24 + + .type g_totle_read_page_count,@object // @g_totle_read_page_count + .bss + .globl g_totle_read_page_count + .p2align 2 +g_totle_read_page_count: + .word 0 // 0x0 + .size g_totle_read_page_count, 4 + + .type .L.str.13,@object // @.str.13 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.13: + .asciz "discard_page_count = 0x%x\n" + .size .L.str.13, 27 + + .type g_totle_discard_page_count,@object // @g_totle_discard_page_count + .bss + .globl g_totle_discard_page_count + .p2align 2 +g_totle_discard_page_count: + .word 0 // 0x0 + .size g_totle_discard_page_count, 4 + + .type .L.str.14,@object // @.str.14 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.14: + .asciz "write_page_count = 0x%x\n" + .size .L.str.14, 25 + + .type g_totle_write_page_count,@object // @g_totle_write_page_count + .bss + .globl g_totle_write_page_count + .p2align 2 +g_totle_write_page_count: + .word 0 // 0x0 + .size g_totle_write_page_count, 4 + + .type .L.str.15,@object // @.str.15 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.15: + .asciz "cache_write_count = 0x%x\n" + .size .L.str.15, 26 + + .type g_totle_cache_write_count,@object // @g_totle_cache_write_count + .bss + .globl g_totle_cache_write_count + .p2align 2 +g_totle_cache_write_count: + .word 0 // 0x0 + .size g_totle_cache_write_count, 4 + + .type .L.str.16,@object // @.str.16 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.16: + .asciz "l2p_write_count = 0x%x\n" + .size .L.str.16, 24 + + .type g_totle_l2p_write_count,@object // @g_totle_l2p_write_count + .bss + .globl g_totle_l2p_write_count + .p2align 2 +g_totle_l2p_write_count: + .word 0 // 0x0 + .size g_totle_l2p_write_count, 4 + + .type .L.str.17,@object // @.str.17 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.17: + .asciz "gc_page_count = 0x%x\n" + .size .L.str.17, 22 + + .type g_totle_gc_page_count,@object // @g_totle_gc_page_count + .bss + .globl g_totle_gc_page_count + .p2align 2 +g_totle_gc_page_count: + .word 0 // 0x0 + .size g_totle_gc_page_count, 4 + + .type .L.str.18,@object // @.str.18 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.18: + .asciz "totle_write = %d MB\n" + .size .L.str.18, 21 + + .type g_totle_write_sector,@object // @g_totle_write_sector + .bss + .globl g_totle_write_sector + .p2align 2 +g_totle_write_sector: + .word 0 // 0x0 + .size g_totle_write_sector, 4 + + .type .L.str.19,@object // @.str.19 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.19: + .asciz "totle_read = %d MB\n" + .size .L.str.19, 20 + + .type g_totle_read_sector,@object // @g_totle_read_sector + .bss + .globl g_totle_read_sector + .p2align 2 +g_totle_read_sector: + .word 0 // 0x0 + .size g_totle_read_sector, 4 + + .type .L.str.20,@object // @.str.20 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.20: + .asciz "GSV = 0x%x\n" + .size .L.str.20, 12 + + .type g_GlobalSysVersion,@object // @g_GlobalSysVersion + .bss + .globl g_GlobalSysVersion + .p2align 2 +g_GlobalSysVersion: + .word 0 // 0x0 + .size g_GlobalSysVersion, 4 + + .type .L.str.21,@object // @.str.21 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.21: + .asciz "GDV = 0x%x\n" + .size .L.str.21, 12 + + .type g_GlobalDataVersion,@object // @g_GlobalDataVersion + .bss + .globl g_GlobalDataVersion + .p2align 2 +g_GlobalDataVersion: + .word 0 // 0x0 + .size g_GlobalDataVersion, 4 + + .type .L.str.22,@object // @.str.22 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.22: + .asciz "bad blk num = %d\n" + .size .L.str.22, 18 + + .type gBbtInfo,@object // @gBbtInfo + .bss + .globl gBbtInfo + .p2align 3 +gBbtInfo: + .zero 96 + .size gBbtInfo, 96 + + .type .L.str.23,@object // @.str.23 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.23: + .asciz "free_superblocks = 0x%x\n" + .size .L.str.23, 25 + + .type .L.str.24,@object // @.str.24 +.L.str.24: + .asciz "mlc_EC = 0x%x\n" + .size .L.str.24, 15 + + .type g_totle_mlc_erase_count,@object // @g_totle_mlc_erase_count + .bss + .globl g_totle_mlc_erase_count + .p2align 2 +g_totle_mlc_erase_count: + .word 0 // 0x0 + .size g_totle_mlc_erase_count, 4 + + .type .L.str.25,@object // @.str.25 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.25: + .asciz "slc_EC = 0x%x\n" + .size .L.str.25, 15 + + .type g_totle_slc_erase_count,@object // @g_totle_slc_erase_count + .bss + .globl g_totle_slc_erase_count + .p2align 2 +g_totle_slc_erase_count: + .word 0 // 0x0 + .size g_totle_slc_erase_count, 4 + + .type .L.str.26,@object // @.str.26 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.26: + .asciz "avg_EC = 0x%x\n" + .size .L.str.26, 15 + + .type g_totle_avg_erase_count,@object // @g_totle_avg_erase_count + .bss + .globl g_totle_avg_erase_count + .p2align 2 +g_totle_avg_erase_count: + .word 0 // 0x0 + .size g_totle_avg_erase_count, 4 + + .type .L.str.27,@object // @.str.27 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.27: + .asciz "sys_EC = 0x%x\n" + .size .L.str.27, 15 + + .type g_totle_sys_slc_erase_count,@object // @g_totle_sys_slc_erase_count + .bss + .globl g_totle_sys_slc_erase_count + .p2align 2 +g_totle_sys_slc_erase_count: + .word 0 // 0x0 + .size g_totle_sys_slc_erase_count, 4 + + .type .L.str.28,@object // @.str.28 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.28: + .asciz "max_EC = 0x%x\n" + .size .L.str.28, 15 + + .type g_max_erase_count,@object // @g_max_erase_count + .bss + .globl g_max_erase_count + .p2align 2 +g_max_erase_count: + .word 0 // 0x0 + .size g_max_erase_count, 4 + + .type .L.str.29,@object // @.str.29 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.29: + .asciz "min_EC = 0x%x\n" + .size .L.str.29, 15 + + .type g_min_erase_count,@object // @g_min_erase_count + .bss + .globl g_min_erase_count + .p2align 2 +g_min_erase_count: + .word 0 // 0x0 + .size g_min_erase_count, 4 + + .type .L.str.30,@object // @.str.30 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.30: + .asciz "PLT = 0x%x\n" + .size .L.str.30, 12 + + .type g_sys_save_data,@object // @g_sys_save_data + .bss + .globl g_sys_save_data + .p2align 2 +g_sys_save_data: + .zero 48 + .size g_sys_save_data, 48 + + .type .L.str.31,@object // @.str.31 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.31: + .asciz "POT = 0x%x\n" + .size .L.str.31, 12 + + .type .L.str.32,@object // @.str.32 +.L.str.32: + .asciz "MaxSector = 0x%x\n" + .size .L.str.32, 18 + + .type g_MaxLbaSector,@object // @g_MaxLbaSector + .bss + .globl g_MaxLbaSector + .p2align 2 +g_MaxLbaSector: + .word 0 // 0x0 + .size g_MaxLbaSector, 4 + + .type .L.str.33,@object // @.str.33 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.33: + .asciz "init_sys_blks_pp = 0x%x\n" + .size .L.str.33, 25 + + .type c_ftl_nand_init_sys_blks_per_plane,@object // @c_ftl_nand_init_sys_blks_per_plane + .bss + .globl c_ftl_nand_init_sys_blks_per_plane + .p2align 2 +c_ftl_nand_init_sys_blks_per_plane: + .word 0 // 0x0 + .size c_ftl_nand_init_sys_blks_per_plane, 4 + + .type .L.str.34,@object // @.str.34 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.34: + .asciz "sys_blks_pp = 0x%x\n" + .size .L.str.34, 20 + + .type c_ftl_nand_sys_blks_per_plane,@object // @c_ftl_nand_sys_blks_per_plane + .bss + .globl c_ftl_nand_sys_blks_per_plane + .p2align 2 +c_ftl_nand_sys_blks_per_plane: + .word 0 // 0x0 + .size c_ftl_nand_sys_blks_per_plane, 4 + + .type .L.str.35,@object // @.str.35 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.35: + .asciz "free sysblock = 0x%x\n" + .size .L.str.35, 22 + + .type gSysFreeQueue,@object // @gSysFreeQueue + .bss + .globl gSysFreeQueue + .p2align 2 +gSysFreeQueue: + .zero 2056 + .size gSysFreeQueue, 2056 + + .type .L.str.36,@object // @.str.36 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.36: + .asciz "data_blks_pp = 0x%x\n" + .size .L.str.36, 21 + + .type c_ftl_nand_data_blks_per_plane,@object // @c_ftl_nand_data_blks_per_plane + .bss + .globl c_ftl_nand_data_blks_per_plane + .p2align 2 +c_ftl_nand_data_blks_per_plane: + .hword 0 // 0x0 + .size c_ftl_nand_data_blks_per_plane, 2 + + .type .L.str.37,@object // @.str.37 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.37: + .asciz "data_op_blks_pp = 0x%x\n" + .size .L.str.37, 24 + + .type c_ftl_nand_data_op_blks_per_plane,@object // @c_ftl_nand_data_op_blks_per_plane + .bss + .globl c_ftl_nand_data_op_blks_per_plane + .p2align 2 +c_ftl_nand_data_op_blks_per_plane: + .hword 0 // 0x0 + .size c_ftl_nand_data_op_blks_per_plane, 2 + + .type .L.str.38,@object // @.str.38 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.38: + .asciz "max_data_blks = 0x%x\n" + .size .L.str.38, 22 + + .type c_ftl_nand_max_data_blks,@object // @c_ftl_nand_max_data_blks + .bss + .globl c_ftl_nand_max_data_blks + .p2align 2 +c_ftl_nand_max_data_blks: + .word 0 // 0x0 + .size c_ftl_nand_max_data_blks, 4 + + .type .L.str.39,@object // @.str.39 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.39: + .asciz "Sys.id = 0x%x\n" + .size .L.str.39, 15 + + .type gSysInfo,@object // @gSysInfo + .bss + .globl gSysInfo + .p2align 2 +gSysInfo: + .zero 16 + .size gSysInfo, 16 + + .type .L.str.40,@object // @.str.40 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.40: + .asciz "Bbt.id = 0x%x\n" + .size .L.str.40, 15 + + .type .L.str.41,@object // @.str.41 +.L.str.41: + .asciz "ACT.page = 0x%x\n" + .size .L.str.41, 17 + + .type .L.str.42,@object // @.str.42 +.L.str.42: + .asciz "ACT.plane = 0x%x\n" + .size .L.str.42, 18 + + .type .L.str.43,@object // @.str.43 +.L.str.43: + .asciz "ACT.id = 0x%x\n" + .size .L.str.43, 15 + + .type .L.str.44,@object // @.str.44 +.L.str.44: + .asciz "ACT.mode = 0x%x\n" + .size .L.str.44, 17 + + .type .L.str.45,@object // @.str.45 +.L.str.45: + .asciz "ACT.a_pages = 0x%x\n" + .size .L.str.45, 20 + + .type .L.str.46,@object // @.str.46 +.L.str.46: + .asciz "ACT VPC = 0x%x\n" + .size .L.str.46, 16 + + .type .L.str.47,@object // @.str.47 +.L.str.47: + .asciz "BUF.page = 0x%x\n" + .size .L.str.47, 17 + + .type .L.str.48,@object // @.str.48 +.L.str.48: + .asciz "BUF.plane = 0x%x\n" + .size .L.str.48, 18 + + .type .L.str.49,@object // @.str.49 +.L.str.49: + .asciz "BUF.id = 0x%x\n" + .size .L.str.49, 15 + + .type .L.str.50,@object // @.str.50 +.L.str.50: + .asciz "BUF.mode = 0x%x\n" + .size .L.str.50, 17 + + .type .L.str.51,@object // @.str.51 +.L.str.51: + .asciz "BUF.a_pages = 0x%x\n" + .size .L.str.51, 20 + + .type .L.str.52,@object // @.str.52 +.L.str.52: + .asciz "BUF VPC = 0x%x\n" + .size .L.str.52, 16 + + .type .L.str.53,@object // @.str.53 +.L.str.53: + .asciz "TMP.page = 0x%x\n" + .size .L.str.53, 17 + + .type .L.str.54,@object // @.str.54 +.L.str.54: + .asciz "TMP.plane = 0x%x\n" + .size .L.str.54, 18 + + .type .L.str.55,@object // @.str.55 +.L.str.55: + .asciz "TMP.id = 0x%x\n" + .size .L.str.55, 15 + + .type .L.str.56,@object // @.str.56 +.L.str.56: + .asciz "TMP.mode = 0x%x\n" + .size .L.str.56, 17 + + .type .L.str.57,@object // @.str.57 +.L.str.57: + .asciz "TMP.a_pages = 0x%x\n" + .size .L.str.57, 20 + + .type .L.str.58,@object // @.str.58 +.L.str.58: + .asciz "GC.page = 0x%x\n" + .size .L.str.58, 16 + + .type .L.str.59,@object // @.str.59 +.L.str.59: + .asciz "GC.plane = 0x%x\n" + .size .L.str.59, 17 + + .type .L.str.60,@object // @.str.60 +.L.str.60: + .asciz "GC.id = 0x%x\n" + .size .L.str.60, 14 + + .type .L.str.61,@object // @.str.61 +.L.str.61: + .asciz "GC.mode = 0x%x\n" + .size .L.str.61, 16 + + .type .L.str.62,@object // @.str.62 +.L.str.62: + .asciz "GC.a_pages = 0x%x\n" + .size .L.str.62, 19 + + .type .L.str.63,@object // @.str.63 +.L.str.63: + .asciz "WR_CHK = %x %x %x\n" + .size .L.str.63, 19 + + .type g_sys_ext_data,@object // @g_sys_ext_data + .bss + .globl g_sys_ext_data + .p2align 2 +g_sys_ext_data: + .zero 512 + .size g_sys_ext_data, 512 + + .type .L.str.64,@object // @.str.64 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.64: + .asciz "Read Err Cnt = 0x%x\n" + .size .L.str.64, 21 + + .type .L.str.65,@object // @.str.65 +.L.str.65: + .asciz "Prog Err Cnt = 0x%x\n" + .size .L.str.65, 21 + + .type .L.str.66,@object // @.str.66 +.L.str.66: + .asciz "gc_free_blk_th= 0x%x\n" + .size .L.str.66, 22 + + .type g_gc_free_blk_threshold,@object // @g_gc_free_blk_threshold + .bss + .globl g_gc_free_blk_threshold + .p2align 2 +g_gc_free_blk_threshold: + .hword 0 // 0x0 + .size g_gc_free_blk_threshold, 2 + + .type .L.str.67,@object // @.str.67 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.67: + .asciz "gc_merge_free_blk_th= 0x%x\n" + .size .L.str.67, 28 + + .type g_gc_merge_free_blk_threshold,@object // @g_gc_merge_free_blk_threshold + .bss + .globl g_gc_merge_free_blk_threshold + .p2align 2 +g_gc_merge_free_blk_threshold: + .hword 0 // 0x0 + .size g_gc_merge_free_blk_threshold, 2 + + .type .L.str.68,@object // @.str.68 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.68: + .asciz "gc_skip_write_count= 0x%x\n" + .size .L.str.68, 27 + + .type g_gc_skip_write_count,@object // @g_gc_skip_write_count + .bss + .globl g_gc_skip_write_count + .p2align 2 +g_gc_skip_write_count: + .word 0 // 0x0 + .size g_gc_skip_write_count, 4 + + .type .L.str.69,@object // @.str.69 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.69: + .asciz "gc_blk_index= 0x%x\n" + .size .L.str.69, 20 + + .type g_gc_blk_index,@object // @g_gc_blk_index + .bss + .globl g_gc_blk_index + .p2align 2 +g_gc_blk_index: + .hword 0 // 0x0 + .size g_gc_blk_index, 2 + + .type .L.str.70,@object // @.str.70 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.70: + .asciz "free min EC= 0x%x\n" + .size .L.str.70, 19 + + .type .L.str.71,@object // @.str.71 +.L.str.71: + .asciz "free max EC= 0x%x\n" + .size .L.str.71, 19 + + .type .L.str.72,@object // @.str.72 +.L.str.72: + .asciz "GC__SB VPC = 0x%x\n" + .size .L.str.72, 19 + + .type .L.str.73,@object // @.str.73 +.L.str.73: + .asciz "%d. [0x%x]=0x%x 0x%x 0x%x\n" + .size .L.str.73, 28 + + .type p_data_block_list_table,@object // @p_data_block_list_table + .bss + .globl p_data_block_list_table + .p2align 3 +p_data_block_list_table: + .xword 0 + .size p_data_block_list_table, 8 + + .type p_erase_count_table,@object // @p_erase_count_table + .globl p_erase_count_table + .p2align 3 +p_erase_count_table: + .xword 0 + .size p_erase_count_table, 8 + + .type p_free_data_block_list_head,@object // @p_free_data_block_list_head + .globl p_free_data_block_list_head + .p2align 3 +p_free_data_block_list_head: + .xword 0 + .size p_free_data_block_list_head, 8 + + .type .L.str.74,@object // @.str.74 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.74: + .asciz "free %d. [0x%x] 0x%x 0x%x\n" + .size .L.str.74, 28 + + .type .L.str.75,@object // @.str.75 +.L.str.75: + .asciz "%s\n" + .size .L.str.75, 4 + + .type c_ftl_nand_planes_num,@object // @c_ftl_nand_planes_num + .bss + .globl c_ftl_nand_planes_num + .p2align 2 +c_ftl_nand_planes_num: + .hword 0 // 0x0 + .size c_ftl_nand_planes_num, 2 + + .type c_ftl_nand_max_sys_blks,@object // @c_ftl_nand_max_sys_blks + .globl c_ftl_nand_max_sys_blks + .p2align 2 +c_ftl_nand_max_sys_blks: + .word 0 // 0x0 + .size c_ftl_nand_max_sys_blks, 4 + + .type c_ftl_nand_blk_pre_plane,@object // @c_ftl_nand_blk_pre_plane + .globl c_ftl_nand_blk_pre_plane + .p2align 2 +c_ftl_nand_blk_pre_plane: + .hword 0 // 0x0 + .size c_ftl_nand_blk_pre_plane, 2 + + .type c_ftl_nand_totle_phy_blks,@object // @c_ftl_nand_totle_phy_blks + .globl c_ftl_nand_totle_phy_blks + .p2align 2 +c_ftl_nand_totle_phy_blks: + .word 0 // 0x0 + .size c_ftl_nand_totle_phy_blks, 4 + + .type c_ftl_nand_type,@object // @c_ftl_nand_type + .globl c_ftl_nand_type + .p2align 2 +c_ftl_nand_type: + .hword 0 // 0x0 + .size c_ftl_nand_type, 2 + + .type c_ftl_nand_die_num,@object // @c_ftl_nand_die_num + .globl c_ftl_nand_die_num + .p2align 2 +c_ftl_nand_die_num: + .hword 0 // 0x0 + .size c_ftl_nand_die_num, 2 + + .type c_ftl_nand_planes_per_die,@object // @c_ftl_nand_planes_per_die + .globl c_ftl_nand_planes_per_die + .p2align 2 +c_ftl_nand_planes_per_die: + .hword 0 // 0x0 + .size c_ftl_nand_planes_per_die, 2 + + .type c_ftl_nand_sec_pre_page,@object // @c_ftl_nand_sec_pre_page + .globl c_ftl_nand_sec_pre_page + .p2align 2 +c_ftl_nand_sec_pre_page: + .hword 0 // 0x0 + .size c_ftl_nand_sec_pre_page, 2 + + .type p_plane_order_table,@object // @p_plane_order_table + .globl p_plane_order_table + .p2align 2 +p_plane_order_table: + .zero 32 + .size p_plane_order_table, 32 + + .type c_mlc_erase_count_value,@object // @c_mlc_erase_count_value + .globl c_mlc_erase_count_value + .p2align 2 +c_mlc_erase_count_value: + .hword 0 // 0x0 + .size c_mlc_erase_count_value, 2 + + .type c_ftl_nand_ext_blk_pre_plane,@object // @c_ftl_nand_ext_blk_pre_plane + .globl c_ftl_nand_ext_blk_pre_plane + .p2align 2 +c_ftl_nand_ext_blk_pre_plane: + .hword 0 // 0x0 + .size c_ftl_nand_ext_blk_pre_plane, 2 + + .type c_ftl_vendor_part_size,@object // @c_ftl_vendor_part_size + .globl c_ftl_vendor_part_size + .p2align 2 +c_ftl_vendor_part_size: + .hword 0 // 0x0 + .size c_ftl_vendor_part_size, 2 + + .type c_ftl_nand_blks_per_die,@object // @c_ftl_nand_blks_per_die + .globl c_ftl_nand_blks_per_die + .p2align 2 +c_ftl_nand_blks_per_die: + .hword 0 // 0x0 + .size c_ftl_nand_blks_per_die, 2 + + .type c_ftl_nand_blks_per_die_shift,@object // @c_ftl_nand_blks_per_die_shift + .globl c_ftl_nand_blks_per_die_shift + .p2align 2 +c_ftl_nand_blks_per_die_shift: + .hword 0 // 0x0 + .size c_ftl_nand_blks_per_die_shift, 2 + + .type c_ftl_nand_page_pre_blk,@object // @c_ftl_nand_page_pre_blk + .globl c_ftl_nand_page_pre_blk + .p2align 2 +c_ftl_nand_page_pre_blk: + .hword 0 // 0x0 + .size c_ftl_nand_page_pre_blk, 2 + + .type c_ftl_nand_page_pre_slc_blk,@object // @c_ftl_nand_page_pre_slc_blk + .globl c_ftl_nand_page_pre_slc_blk + .p2align 2 +c_ftl_nand_page_pre_slc_blk: + .hword 0 // 0x0 + .size c_ftl_nand_page_pre_slc_blk, 2 + + .type c_ftl_nand_page_pre_super_blk,@object // @c_ftl_nand_page_pre_super_blk + .globl c_ftl_nand_page_pre_super_blk + .p2align 2 +c_ftl_nand_page_pre_super_blk: + .hword 0 // 0x0 + .size c_ftl_nand_page_pre_super_blk, 2 + + .type c_ftl_nand_sec_pre_page_shift,@object // @c_ftl_nand_sec_pre_page_shift + .globl c_ftl_nand_sec_pre_page_shift + .p2align 2 +c_ftl_nand_sec_pre_page_shift: + .hword 0 // 0x0 + .size c_ftl_nand_sec_pre_page_shift, 2 + + .type c_ftl_nand_byte_pre_page,@object // @c_ftl_nand_byte_pre_page + .globl c_ftl_nand_byte_pre_page + .p2align 2 +c_ftl_nand_byte_pre_page: + .hword 0 // 0x0 + .size c_ftl_nand_byte_pre_page, 2 + + .type c_ftl_nand_byte_pre_oob,@object // @c_ftl_nand_byte_pre_oob + .globl c_ftl_nand_byte_pre_oob + .p2align 2 +c_ftl_nand_byte_pre_oob: + .hword 0 // 0x0 + .size c_ftl_nand_byte_pre_oob, 2 + + .type c_ftl_nand_reserved_blks,@object // @c_ftl_nand_reserved_blks + .globl c_ftl_nand_reserved_blks + .p2align 2 +c_ftl_nand_reserved_blks: + .hword 0 // 0x0 + .size c_ftl_nand_reserved_blks, 2 + + .type c_ftl_nand_max_vendor_blks,@object // @c_ftl_nand_max_vendor_blks + .globl c_ftl_nand_max_vendor_blks + .p2align 2 +c_ftl_nand_max_vendor_blks: + .hword 0 // 0x0 + .size c_ftl_nand_max_vendor_blks, 2 + + .type c_ftl_nand_vendor_region_num,@object // @c_ftl_nand_vendor_region_num + .globl c_ftl_nand_vendor_region_num + .p2align 2 +c_ftl_nand_vendor_region_num: + .hword 0 // 0x0 + .size c_ftl_nand_vendor_region_num, 2 + + .type c_ftl_nand_map_blks_per_plane,@object // @c_ftl_nand_map_blks_per_plane + .globl c_ftl_nand_map_blks_per_plane + .p2align 2 +c_ftl_nand_map_blks_per_plane: + .hword 0 // 0x0 + .size c_ftl_nand_map_blks_per_plane, 2 + + .type c_ftl_nand_max_map_blks,@object // @c_ftl_nand_max_map_blks + .globl c_ftl_nand_max_map_blks + .p2align 2 +c_ftl_nand_max_map_blks: + .word 0 // 0x0 + .size c_ftl_nand_max_map_blks, 4 + + .type c_ftl_nand_map_region_num,@object // @c_ftl_nand_map_region_num + .globl c_ftl_nand_map_region_num + .p2align 2 +c_ftl_nand_map_region_num: + .hword 0 // 0x0 + .size c_ftl_nand_map_region_num, 2 + + .type c_ftl_nand_l2pmap_ram_region_num,@object // @c_ftl_nand_l2pmap_ram_region_num + .globl c_ftl_nand_l2pmap_ram_region_num + .p2align 2 +c_ftl_nand_l2pmap_ram_region_num: + .hword 0 // 0x0 + .size c_ftl_nand_l2pmap_ram_region_num, 2 + + .type g_in_gc_progress,@object // @g_in_gc_progress + .globl g_in_gc_progress + .p2align 2 +g_in_gc_progress: + .word 0 // 0x0 + .size g_in_gc_progress, 4 + + .type g_in_swl_replace,@object // @g_in_swl_replace + .globl g_in_swl_replace + .p2align 2 +g_in_swl_replace: + .word 0 // 0x0 + .size g_in_swl_replace, 4 + + .type g_gc_head_data_block,@object // @g_gc_head_data_block + .globl g_gc_head_data_block + .p2align 2 +g_gc_head_data_block: + .word 0 // 0x0 + .size g_gc_head_data_block, 4 + + .type g_gc_head_data_block_count,@object // @g_gc_head_data_block_count + .globl g_gc_head_data_block_count + .p2align 2 +g_gc_head_data_block_count: + .word 0 // 0x0 + .size g_gc_head_data_block_count, 4 + + .type g_cur_erase_blk,@object // @g_cur_erase_blk + .globl g_cur_erase_blk + .p2align 2 +g_cur_erase_blk: + .word 0 // 0x0 + .size g_cur_erase_blk, 4 + + .type g_gc_bad_block_temp_num,@object // @g_gc_bad_block_temp_num + .globl g_gc_bad_block_temp_num + .p2align 2 +g_gc_bad_block_temp_num: + .hword 0 // 0x0 + .size g_gc_bad_block_temp_num, 2 + + .type g_gc_bad_block_gc_index,@object // @g_gc_bad_block_gc_index + .globl g_gc_bad_block_gc_index + .p2align 2 +g_gc_bad_block_gc_index: + .hword 0 // 0x0 + .size g_gc_bad_block_gc_index, 2 + + .type p_gc_blk_tbl,@object // @p_gc_blk_tbl + .globl p_gc_blk_tbl + .p2align 3 +p_gc_blk_tbl: + .xword 0 + .size p_gc_blk_tbl, 8 + + .type p_gc_page_info,@object // @p_gc_page_info + .globl p_gc_page_info + .p2align 3 +p_gc_page_info: + .xword 0 + .size p_gc_page_info, 8 + + .type req_read,@object // @req_read + .globl req_read + .p2align 3 +req_read: + .xword 0 + .size req_read, 8 + + .type req_gc_dst,@object // @req_gc_dst + .globl req_gc_dst + .p2align 3 +req_gc_dst: + .xword 0 + .size req_gc_dst, 8 + + .type req_prgm,@object // @req_prgm + .globl req_prgm + .p2align 3 +req_prgm: + .xword 0 + .size req_prgm, 8 + + .type req_erase,@object // @req_erase + .globl req_erase + .p2align 3 +req_erase: + .xword 0 + .size req_erase, 8 + + .type req_gc,@object // @req_gc + .globl req_gc + .p2align 3 +req_gc: + .xword 0 + .size req_gc, 8 + + .type c_gc_page_buf_num,@object // @c_gc_page_buf_num + .globl c_gc_page_buf_num + .p2align 2 +c_gc_page_buf_num: + .word 0 // 0x0 + .size c_gc_page_buf_num, 4 + + .type p_sys_data_buf,@object // @p_sys_data_buf + .globl p_sys_data_buf + .p2align 3 +p_sys_data_buf: + .xword 0 + .size p_sys_data_buf, 8 + + .type p_sys_data_buf_1,@object // @p_sys_data_buf_1 + .globl p_sys_data_buf_1 + .p2align 3 +p_sys_data_buf_1: + .xword 0 + .size p_sys_data_buf_1, 8 + + .type p_vendor_data_buf,@object // @p_vendor_data_buf + .globl p_vendor_data_buf + .p2align 3 +p_vendor_data_buf: + .xword 0 + .size p_vendor_data_buf, 8 + + .type p_gc_data_buf,@object // @p_gc_data_buf + .globl p_gc_data_buf + .p2align 3 +p_gc_data_buf: + .xword 0 + .size p_gc_data_buf, 8 + + .type p_io_data_buf_0,@object // @p_io_data_buf_0 + .globl p_io_data_buf_0 + .p2align 3 +p_io_data_buf_0: + .xword 0 + .size p_io_data_buf_0, 8 + + .type p_io_data_buf_1,@object // @p_io_data_buf_1 + .globl p_io_data_buf_1 + .p2align 3 +p_io_data_buf_1: + .xword 0 + .size p_io_data_buf_1, 8 + + .type gp_gc_page_buf_info,@object // @gp_gc_page_buf_info + .globl gp_gc_page_buf_info + .p2align 3 +gp_gc_page_buf_info: + .xword 0 + .size gp_gc_page_buf_info, 8 + + .type sftl_nand_check_buf,@object // @sftl_nand_check_buf + .globl sftl_nand_check_buf + .p2align 3 +sftl_nand_check_buf: + .xword 0 + .size sftl_nand_check_buf, 8 + + .type sftl_temp_buf,@object // @sftl_temp_buf + .globl sftl_temp_buf + .p2align 3 +sftl_temp_buf: + .xword 0 + .size sftl_temp_buf, 8 + + .type sftl_nand_check_spare_buf,@object // @sftl_nand_check_spare_buf + .globl sftl_nand_check_spare_buf + .p2align 3 +sftl_nand_check_spare_buf: + .xword 0 + .size sftl_nand_check_spare_buf, 8 + + .type p_sys_spare_buf,@object // @p_sys_spare_buf + .globl p_sys_spare_buf + .p2align 3 +p_sys_spare_buf: + .xword 0 + .size p_sys_spare_buf, 8 + + .type p_io_spare_buf,@object // @p_io_spare_buf + .globl p_io_spare_buf + .p2align 3 +p_io_spare_buf: + .xword 0 + .size p_io_spare_buf, 8 + + .type p_gc_spare_buf,@object // @p_gc_spare_buf + .globl p_gc_spare_buf + .p2align 3 +p_gc_spare_buf: + .xword 0 + .size p_gc_spare_buf, 8 + + .type g_ect_tbl_info_size,@object // @g_ect_tbl_info_size + .globl g_ect_tbl_info_size + .p2align 2 +g_ect_tbl_info_size: + .hword 0 // 0x0 + .size g_ect_tbl_info_size, 2 + + .type p_swl_mul_table,@object // @p_swl_mul_table + .globl p_swl_mul_table + .p2align 3 +p_swl_mul_table: + .xword 0 + .size p_swl_mul_table, 8 + + .type gp_ect_tbl_info,@object // @gp_ect_tbl_info + .globl gp_ect_tbl_info + .p2align 3 +gp_ect_tbl_info: + .xword 0 + .size gp_ect_tbl_info, 8 + + .type p_valid_page_count_check_table,@object // @p_valid_page_count_check_table + .globl p_valid_page_count_check_table + .p2align 3 +p_valid_page_count_check_table: + .xword 0 + .size p_valid_page_count_check_table, 8 + + .type p_map_block_table,@object // @p_map_block_table + .globl p_map_block_table + .p2align 3 +p_map_block_table: + .xword 0 + .size p_map_block_table, 8 + + .type p_map_block_valid_page_count,@object // @p_map_block_valid_page_count + .globl p_map_block_valid_page_count + .p2align 3 +p_map_block_valid_page_count: + .xword 0 + .size p_map_block_valid_page_count, 8 + + .type p_vendor_block_table,@object // @p_vendor_block_table + .globl p_vendor_block_table + .p2align 3 +p_vendor_block_table: + .xword 0 + .size p_vendor_block_table, 8 + + .type p_vendor_block_valid_page_count,@object // @p_vendor_block_valid_page_count + .globl p_vendor_block_valid_page_count + .p2align 3 +p_vendor_block_valid_page_count: + .xword 0 + .size p_vendor_block_valid_page_count, 8 + + .type p_vendor_block_ver_table,@object // @p_vendor_block_ver_table + .globl p_vendor_block_ver_table + .p2align 3 +p_vendor_block_ver_table: + .xword 0 + .size p_vendor_block_ver_table, 8 + + .type p_vendor_region_ppn_table,@object // @p_vendor_region_ppn_table + .globl p_vendor_region_ppn_table + .p2align 3 +p_vendor_region_ppn_table: + .xword 0 + .size p_vendor_region_ppn_table, 8 + + .type p_map_region_ppn_table,@object // @p_map_region_ppn_table + .globl p_map_region_ppn_table + .p2align 3 +p_map_region_ppn_table: + .xword 0 + .size p_map_region_ppn_table, 8 + + .type p_map_block_ver_table,@object // @p_map_block_ver_table + .globl p_map_block_ver_table + .p2align 3 +p_map_block_ver_table: + .xword 0 + .size p_map_block_ver_table, 8 + + .type p_l2p_ram_map,@object // @p_l2p_ram_map + .globl p_l2p_ram_map + .p2align 3 +p_l2p_ram_map: + .xword 0 + .size p_l2p_ram_map, 8 + + .type p_l2p_map_buf,@object // @p_l2p_map_buf + .globl p_l2p_map_buf + .p2align 3 +p_l2p_map_buf: + .xword 0 + .size p_l2p_map_buf, 8 + + .type c_ftl_nand_bbm_buf_size,@object // @c_ftl_nand_bbm_buf_size + .globl c_ftl_nand_bbm_buf_size + .p2align 2 +c_ftl_nand_bbm_buf_size: + .hword 0 // 0x0 + .size c_ftl_nand_bbm_buf_size, 2 + + .type .L.str.76,@object // @.str.76 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.76: + .asciz "%s error allocating memory. return -1\n" + .size .L.str.76, 39 + + .type .L__func__.FtlMemInit,@object // @__func__.FtlMemInit +.L__func__.FtlMemInit: + .asciz "FtlMemInit" + .size .L__func__.FtlMemInit, 11 + + .type g_tmp_data_superblock_id,@object // @g_tmp_data_superblock_id + .bss + .globl g_tmp_data_superblock_id + .p2align 2 +g_tmp_data_superblock_id: + .hword 0 // 0x0 + .size g_tmp_data_superblock_id, 2 + + .type g_totle_swl_count,@object // @g_totle_swl_count + .globl g_totle_swl_count + .p2align 2 +g_totle_swl_count: + .word 0 // 0x0 + .size g_totle_swl_count, 4 + + .type ftl_gc_temp_power_lost_recovery_flag,@object // @ftl_gc_temp_power_lost_recovery_flag + .globl ftl_gc_temp_power_lost_recovery_flag + .p2align 2 +ftl_gc_temp_power_lost_recovery_flag: + .word 0 // 0x0 + .size ftl_gc_temp_power_lost_recovery_flag, 4 + + .type g_recovery_page_min_ver,@object // @g_recovery_page_min_ver + .globl g_recovery_page_min_ver + .p2align 2 +g_recovery_page_min_ver: + .word 0 // 0x0 + .size g_recovery_page_min_ver, 4 + + .type g_totle_vendor_block,@object // @g_totle_vendor_block + .globl g_totle_vendor_block + .p2align 2 +g_totle_vendor_block: + .hword 0 // 0x0 + .size g_totle_vendor_block, 2 + + .type g_MaxLbn,@object // @g_MaxLbn + .globl g_MaxLbn + .p2align 2 +g_MaxLbn: + .word 0 // 0x0 + .size g_MaxLbn, 4 + + .type g_nand_phy_info,@object // @g_nand_phy_info + .globl g_nand_phy_info + .p2align 1 +g_nand_phy_info: + .zero 24 + .size g_nand_phy_info, 24 + + .type .L.str.77,@object // @.str.77 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.77: + .asciz "FtlProgPages error %x = %d\n" + .size .L.str.77, 28 + + .type .L.str.78,@object // @.str.78 +.L.str.78: + .asciz "\n!!!!! error @ func:%s - line:%d\n" + .size .L.str.78, 34 + + .type .L__func__.FtlProgPages,@object // @__func__.FtlProgPages +.L__func__.FtlProgPages: + .asciz "FtlProgPages" + .size .L__func__.FtlProgPages, 13 + + .type .L.str.79,@object // @.str.79 +.L.str.79: + .asciz "Ftlwrite decrement_vpc_count %x = %d\n" + .size .L.str.79, 38 + + .type power_up_flag,@object // @power_up_flag + .data + .globl power_up_flag + .p2align 2 +power_up_flag: + .word 1 // 0x1 + .size power_up_flag, 4 + + .type g_ftl_nand_free_count,@object // @g_ftl_nand_free_count + .bss + .globl g_ftl_nand_free_count + .p2align 2 +g_ftl_nand_free_count: + .word 0 // 0x0 + .size g_ftl_nand_free_count, 4 + + .type .L__func__.FtlWrite,@object // @__func__.FtlWrite + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.FtlWrite: + .asciz "FtlWrite" + .size .L__func__.FtlWrite, 9 + + .type .L.str.80,@object // @.str.80 +.L.str.80: + .asciz "FtlWrite: ecc error:%x %x %x\n" + .size .L.str.80, 30 + + .type .L.str.81,@object // @.str.81 +.L.str.81: + .asciz "FtlWrite: lpa error:%x %x\n" + .size .L.str.81, 27 + + .type gc_discard_updated,@object // @gc_discard_updated + .local gc_discard_updated + .comm gc_discard_updated,4,4 + .type .L.str.82,@object // @.str.82 +.L.str.82: + .asciz "phyBlk = 0x%x die = %d block_in_die = 0x%x 0x%8x\n" + .size .L.str.82, 50 + + .type .L__func__.FtlBbt2Bitmap,@object // @__func__.FtlBbt2Bitmap +.L__func__.FtlBbt2Bitmap: + .asciz "FtlBbt2Bitmap" + .size .L__func__.FtlBbt2Bitmap, 14 + + .type req_sys,@object // @req_sys + .bss + .globl req_sys + .p2align 3 +req_sys: + .zero 32 + .size req_sys, 32 + + .type .L.str.83,@object // @.str.83 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.83: + .asciz "FtlBbmTblFlush id=%x,page=%x,previd=%x cnt=%d\n" + .size .L.str.83, 47 + + .type .L.str.84,@object // @.str.84 +.L.str.84: + .asciz "FtlBbmTblFlush error:%x\n" + .size .L.str.84, 25 + + .type .L.str.85,@object // @.str.85 +.L.str.85: + .asciz "FtlBbmTblFlush error = %x error count = %d\n" + .size .L.str.85, 44 + + .type .L__func__.FtlLoadBbt,@object // @__func__.FtlLoadBbt +.L__func__.FtlLoadBbt: + .asciz "FtlLoadBbt" + .size .L__func__.FtlLoadBbt, 11 + + .type .L.str.86,@object // @.str.86 +.L.str.86: + .asciz "FtlFreeSysBlkQueueOut = %x, free count = %d, error\n" + .size .L.str.86, 52 + + .type .L__func__.INSERT_FREE_LIST,@object // @__func__.INSERT_FREE_LIST +.L__func__.INSERT_FREE_LIST: + .asciz "INSERT_FREE_LIST" + .size .L__func__.INSERT_FREE_LIST, 17 + + .type g_num_data_superblocks,@object // @g_num_data_superblocks + .bss + .globl g_num_data_superblocks + .p2align 2 +g_num_data_superblocks: + .hword 0 // 0x0 + .size g_num_data_superblocks, 2 + + .type .L__func__.INSERT_DATA_LIST,@object // @__func__.INSERT_DATA_LIST + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.INSERT_DATA_LIST: + .asciz "INSERT_DATA_LIST" + .size .L__func__.INSERT_DATA_LIST, 17 + + .type p_data_block_list_head,@object // @p_data_block_list_head + .bss + .globl p_data_block_list_head + .p2align 3 +p_data_block_list_head: + .xword 0 + .size p_data_block_list_head, 8 + + .type p_data_block_list_tail,@object // @p_data_block_list_tail + .globl p_data_block_list_tail + .p2align 3 +p_data_block_list_tail: + .xword 0 + .size p_data_block_list_tail, 8 + + .type .L__func__.List_remove_node,@object // @__func__.List_remove_node + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.List_remove_node: + .asciz "List_remove_node" + .size .L__func__.List_remove_node, 17 + + .type .L__func__.List_update_data_list,@object // @__func__.List_update_data_list +.L__func__.List_update_data_list: + .asciz "List_update_data_list" + .size .L__func__.List_update_data_list, 22 + + .type .L__func__.load_l2p_region,@object // @__func__.load_l2p_region +.L__func__.load_l2p_region: + .asciz "load_l2p_region" + .size .L__func__.load_l2p_region, 16 + + .type .L.str.87,@object // @.str.87 +.L.str.87: + .asciz "region_id = %x phyAddr = %x\n" + .size .L.str.87, 29 + + .type .L.str.88,@object // @.str.88 +.L.str.88: + .asciz "spare:" + .size .L.str.88, 7 + + .type .L.str.89,@object // @.str.89 +.L.str.89: + .asciz "map_ppn:" + .size .L.str.89, 9 + + .type .L.str.90,@object // @.str.90 +.L.str.90: + .asciz "load_l2p_region refresh = %x phyAddr = %x\n" + .size .L.str.90, 43 + + .type gL2pMapInfo,@object // @gL2pMapInfo + .bss + .globl gL2pMapInfo + .p2align 3 +gL2pMapInfo: + .zero 64 + .size gL2pMapInfo, 64 + + .type .L__func__.ftl_map_blk_alloc_new_blk,@object // @__func__.ftl_map_blk_alloc_new_blk + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.ftl_map_blk_alloc_new_blk: + .asciz "ftl_map_blk_alloc_new_blk" + .size .L__func__.ftl_map_blk_alloc_new_blk, 26 + + .type .L__func__.ftl_map_blk_gc,@object // @__func__.ftl_map_blk_gc +.L__func__.ftl_map_blk_gc: + .asciz "ftl_map_blk_gc" + .size .L__func__.ftl_map_blk_gc, 15 + + .type .L__func__.Ftl_write_map_blk_to_last_page,@object // @__func__.Ftl_write_map_blk_to_last_page +.L__func__.Ftl_write_map_blk_to_last_page: + .asciz "Ftl_write_map_blk_to_last_page" + .size .L__func__.Ftl_write_map_blk_to_last_page, 31 + + .type .L__func__.FtlMapWritePage,@object // @__func__.FtlMapWritePage +.L__func__.FtlMapWritePage: + .asciz "FtlMapWritePage" + .size .L__func__.FtlMapWritePage, 16 + + .type .L.str.92,@object // @.str.92 +.L.str.92: + .asciz "FtlMapWritePage error = %x \n" + .size .L.str.92, 29 + + .type .L.str.93,@object // @.str.93 +.L.str.93: + .asciz "FtlMapWritePage error = %x error count = %d\n" + .size .L.str.93, 45 + + .type g_l2p_last_update_region_id,@object // @g_l2p_last_update_region_id + .bss + .globl g_l2p_last_update_region_id + .p2align 2 +g_l2p_last_update_region_id: + .hword 0 // 0x0 + .size g_l2p_last_update_region_id, 2 + + .type .L__func__.select_l2p_ram_region,@object // @__func__.select_l2p_ram_region + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.select_l2p_ram_region: + .asciz "select_l2p_ram_region" + .size .L__func__.select_l2p_ram_region, 22 + + .type .L__func__.log2phys,@object // @__func__.log2phys +.L__func__.log2phys: + .asciz "log2phys" + .size .L__func__.log2phys, 9 + + .type gVendorBlkInfo,@object // @gVendorBlkInfo + .bss + .globl gVendorBlkInfo + .p2align 3 +gVendorBlkInfo: + .zero 64 + .size gVendorBlkInfo, 64 + + .type .L.str.94,@object // @.str.94 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.94: + .asciz "FtlVendorPartRead refresh = %x phyAddr = %x\n" + .size .L.str.94, 45 + + .type g_ect_tbl_power_up_flush,@object // @g_ect_tbl_power_up_flush + .bss + .globl g_ect_tbl_power_up_flush + .p2align 2 +g_ect_tbl_power_up_flush: + .hword 0 // 0x0 + .size g_ect_tbl_power_up_flush, 2 + + .type FtlUpdateVaildLpnCount,@object // @FtlUpdateVaildLpnCount + .globl FtlUpdateVaildLpnCount + .p2align 2 +FtlUpdateVaildLpnCount: + .hword 0 // 0x0 + .size FtlUpdateVaildLpnCount, 2 + + .type .L__func__.FtlVpcTblFlush,@object // @__func__.FtlVpcTblFlush + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.FtlVpcTblFlush: + .asciz "FtlVpcTblFlush" + .size .L__func__.FtlVpcTblFlush, 15 + + .type .L.str.95,@object // @.str.95 +.L.str.95: + .asciz "FtlVpcTblFlush error = %x error count = %d\n" + .size .L.str.95, 44 + + .type g_totle_map_block,@object // @g_totle_map_block + .bss + .globl g_totle_map_block + .p2align 2 +g_totle_map_block: + .hword 0 // 0x0 + .size g_totle_map_block, 2 + + .type .L__func__.FtlScanSysBlk,@object // @__func__.FtlScanSysBlk + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.FtlScanSysBlk: + .asciz "FtlScanSysBlk" + .size .L__func__.FtlScanSysBlk, 14 + + .type .L.str.96,@object // @.str.96 +.L.str.96: + .asciz "no ect" + .size .L.str.96, 7 + + .type .L.str.97,@object // @.str.97 +.L.str.97: + .asciz "%s hash error this.id =%x page =%x pre_id =%x hash =%x hash_r =%x\n" + .size .L.str.97, 67 + + .type .L__func__.FtlLoadSysInfo,@object // @__func__.FtlLoadSysInfo +.L__func__.FtlLoadSysInfo: + .asciz "FtlLoadSysInfo" + .size .L__func__.FtlLoadSysInfo, 15 + + .type .L.str.98,@object // @.str.98 +.L.str.98: + .asciz "%s last blk_id =%x page =%x hash error hash =%x hash_r =%x\n" + .size .L.str.98, 60 + + .type .L__func__.FtlMapTblRecovery,@object // @__func__.FtlMapTblRecovery +.L__func__.FtlMapTblRecovery: + .asciz "FtlMapTblRecovery" + .size .L__func__.FtlMapTblRecovery, 18 + + .type .L.str.99,@object // @.str.99 +.L.str.99: + .asciz "%s scan blk_id =%x page =%x hash error hash =%x hash_r =%x\n" + .size .L.str.99, 60 + + .type .L__func__.FtlReUsePrevPpa,@object // @__func__.FtlReUsePrevPpa +.L__func__.FtlReUsePrevPpa: + .asciz "FtlReUsePrevPpa" + .size .L__func__.FtlReUsePrevPpa, 16 + + .type .L__func__.FtlRecoverySuperblock,@object // @__func__.FtlRecoverySuperblock +.L__func__.FtlRecoverySuperblock: + .asciz "FtlRecoverySuperblock" + .size .L__func__.FtlRecoverySuperblock, 22 + + .type g_power_lost_recovery_flag,@object // @g_power_lost_recovery_flag + .bss + .globl g_power_lost_recovery_flag + .p2align 2 +g_power_lost_recovery_flag: + .hword 0 // 0x0 + .size g_power_lost_recovery_flag, 2 + + .type .L.str.100,@object // @.str.100 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.100: + .asciz "data prev_ppa = %x error...................\n" + .size .L.str.100, 45 + + .type .L.str.101,@object // @.str.101 +.L.str.101: + .asciz "spuer block %x vpn is 0\n " + .size .L.str.101, 26 + + .type g_recovery_page_num,@object // @g_recovery_page_num + .bss + .globl g_recovery_page_num + .p2align 2 +g_recovery_page_num: + .word 0 // 0x0 + .size g_recovery_page_num, 4 + + .type g_recovery_ppa_tbl,@object // @g_recovery_ppa_tbl + .globl g_recovery_ppa_tbl + .p2align 2 +g_recovery_ppa_tbl: + .zero 128 + .size g_recovery_ppa_tbl, 128 + + .type .L__func__.make_superblock,@object // @__func__.make_superblock + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.make_superblock: + .asciz "make_superblock" + .size .L__func__.make_superblock, 16 + + .type .L__func__.SupperBlkListInit,@object // @__func__.SupperBlkListInit +.L__func__.SupperBlkListInit: + .asciz "SupperBlkListInit" + .size .L__func__.SupperBlkListInit, 18 + + .type .L.str.102,@object // @.str.102 +.L.str.102: + .asciz "...%s enter...\n" + .size .L.str.102, 16 + + .type .L__func__.FtlVpcCheckAndModify,@object // @__func__.FtlVpcCheckAndModify +.L__func__.FtlVpcCheckAndModify: + .asciz "FtlVpcCheckAndModify" + .size .L__func__.FtlVpcCheckAndModify, 21 + + .type .L.str.103,@object // @.str.103 +.L.str.103: + .asciz "FtlCheckVpc %x = %x %x\n" + .size .L.str.103, 25 + + .type .L__func__.ftl_check_vpc,@object // @__func__.ftl_check_vpc +.L__func__.ftl_check_vpc: + .asciz "ftl_check_vpc" + .size .L__func__.ftl_check_vpc, 14 + + .type check_vpc_table,@object // @check_vpc_table + .bss + .globl check_vpc_table + .p2align 1 +check_vpc_table: + .zero 16384 + .size check_vpc_table, 16384 + + .type .L.str.104,@object // @.str.104 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.104: + .asciz "FtlCheckVpc2 %x = %x %x\n" + .size .L.str.104, 26 + + .type .L.str.105,@object // @.str.105 +.L.str.105: + .asciz "free blk vpc error %x = %x %x\n" + .size .L.str.105, 32 + + .type .L.str.106,@object // @.str.106 +.L.str.106: + .asciz "ftl_scan_all_data = %x\n" + .size .L.str.106, 24 + + .type .L.str.107,@object // @.str.107 +.L.str.107: + .asciz "scan lpa = %x ppa= %x\n" + .size .L.str.107, 23 + + .type .L.str.108,@object // @.str.108 +.L.str.108: + .asciz "lpa = %x,addr= %x,spare= %x %x %x %x data=%x %x\n" + .size .L.str.108, 49 + + .type .L.str.109,@object // @.str.109 +.L.str.109: + .asciz "swblk %x ,avg = %x max= %x vpc= %x,ec=%x ,max ec=%x\n" + .size .L.str.109, 53 + + .type .L__func__.allocate_data_superblock,@object // @__func__.allocate_data_superblock +.L__func__.allocate_data_superblock: + .asciz "allocate_data_superblock" + .size .L__func__.allocate_data_superblock, 25 + + .type .L__func__.allocate_new_data_superblock,@object // @__func__.allocate_new_data_superblock +.L__func__.allocate_new_data_superblock: + .asciz "allocate_new_data_superblock" + .size .L__func__.allocate_new_data_superblock, 29 + + .type .L__func__.get_new_active_ppa,@object // @__func__.get_new_active_ppa +.L__func__.get_new_active_ppa: + .asciz "get_new_active_ppa" + .size .L__func__.get_new_active_ppa, 19 + + .type .L__func__.update_vpc_list,@object // @__func__.update_vpc_list +.L__func__.update_vpc_list: + .asciz "update_vpc_list" + .size .L__func__.update_vpc_list, 16 + + .type .L.str.110,@object // @.str.110 +.L.str.110: + .asciz "decrement_vpc_count %x = %d\n" + .size .L.str.110, 29 + + .type .L__func__.decrement_vpc_count,@object // @__func__.decrement_vpc_count +.L__func__.decrement_vpc_count: + .asciz "decrement_vpc_count" + .size .L__func__.decrement_vpc_count, 20 + + .type g_gc_num_req,@object // @g_gc_num_req + .bss + .globl g_gc_num_req + .p2align 2 +g_gc_num_req: + .word 0 // 0x0 + .size g_gc_num_req, 4 + + .type g_gc_blk_num,@object // @g_gc_blk_num + .globl g_gc_blk_num + .p2align 2 +g_gc_blk_num: + .hword 0 // 0x0 + .size g_gc_blk_num, 2 + + .type g_gc_page_offset,@object // @g_gc_page_offset + .globl g_gc_page_offset + .p2align 2 +g_gc_page_offset: + .hword 0 // 0x0 + .size g_gc_page_offset, 2 + + .type ftl_gc_temp_block_bops_scan_page_addr,@object // @ftl_gc_temp_block_bops_scan_page_addr + .data + .p2align 2 +ftl_gc_temp_block_bops_scan_page_addr: + .hword 65535 // 0xffff + .size ftl_gc_temp_block_bops_scan_page_addr, 2 + + .type .L__func__.FtlGcFreeTempBlock,@object // @__func__.FtlGcFreeTempBlock + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.FtlGcFreeTempBlock: + .asciz "FtlGcFreeTempBlock" + .size .L__func__.FtlGcFreeTempBlock, 19 + + .type .L.str.111,@object // @.str.111 +.L.str.111: + .asciz "FtlGcScanTempBlk Error ID %x %x!!!!!!! \n" + .size .L.str.111, 41 + + .type .L.str.112,@object // @.str.112 +.L.str.112: + .asciz "FtlGcRefreshBlock 0x%x\n" + .size .L.str.112, 25 + + .type .L.str.113,@object // @.str.113 +.L.str.113: + .asciz "FtlGcMarkBadPhyBlk %d 0x%x\n" + .size .L.str.113, 28 + + .type g_gc_bad_block_temp_tbl,@object // @g_gc_bad_block_temp_tbl + .bss + .globl g_gc_bad_block_temp_tbl + .p2align 1 +g_gc_bad_block_temp_tbl: + .zero 34 + .size g_gc_bad_block_temp_tbl, 34 + + .type .L.str.114,@object // @.str.114 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.114: + .asciz "FtlGcFreeBadSuperBlk 0x%x\n" + .size .L.str.114, 27 + + .type gc_ink_free_return_value,@object // @gc_ink_free_return_value + .bss + .globl gc_ink_free_return_value + .p2align 2 +gc_ink_free_return_value: + .hword 0 // 0x0 + .size gc_ink_free_return_value, 2 + + .type .L.str.115,@object // @.str.115 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.115: + .asciz "SWL %x, FSB = %x vpc= %x,ec=%x th=%x\n" + .size .L.str.115, 38 + + .type g_gc_cur_blk_valid_pages,@object // @g_gc_cur_blk_valid_pages + .bss + .globl g_gc_cur_blk_valid_pages + .p2align 2 +g_gc_cur_blk_valid_pages: + .hword 0 // 0x0 + .size g_gc_cur_blk_valid_pages, 2 + + .type g_gc_cur_blk_max_valid_pages,@object // @g_gc_cur_blk_max_valid_pages + .globl g_gc_cur_blk_max_valid_pages + .p2align 2 +g_gc_cur_blk_max_valid_pages: + .hword 0 // 0x0 + .size g_gc_cur_blk_max_valid_pages, 2 + + .type .L__func__.rk_ftl_garbage_collect,@object // @__func__.rk_ftl_garbage_collect + .section .rodata.str1.1,"aMS",@progbits,1 +.L__func__.rk_ftl_garbage_collect: + .asciz "rk_ftl_garbage_collect" + .size .L__func__.rk_ftl_garbage_collect, 23 + + .type .L.str.116,@object // @.str.116 +.L.str.116: + .asciz "%s %p + 0x%x:" + .size .L.str.116, 14 + + .type .L.str.117,@object // @.str.117 +.L.str.117: + .asciz "0x%08x," + .size .L.str.117, 8 + + .type .L.str.118,@object // @.str.118 +.L.str.118: + .asciz "0x%04x," + .size .L.str.118, 8 + + .type .L.str.119,@object // @.str.119 +.L.str.119: + .asciz "0x%02x," + .size .L.str.119, 8 + + .type .L.str.120,@object // @.str.120 +.L.str.120: + .asciz "\n" + .size .L.str.120, 2 + + .type .L__func__.FlashReadPages,@object // @__func__.FlashReadPages +.L__func__.FlashReadPages: + .asciz "FlashReadPages" + .size .L__func__.FlashReadPages, 15 + + .type g_nand_ops,@object // @g_nand_ops + .bss + .globl g_nand_ops + .p2align 3 +g_nand_ops: + .zero 48 + .size g_nand_ops, 48 + + .type .L.str.121,@object // @.str.121 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.121: + .asciz "FlashReadPages %x %x error_ecc_bits %d\n" + .size .L.str.121, 40 + + .type .L.str.122,@object // @.str.122 +.L.str.122: + .asciz "data:" + .size .L.str.122, 6 + + .type .L__func__.FlashProgPages,@object // @__func__.FlashProgPages +.L__func__.FlashProgPages: + .asciz "FlashProgPages" + .size .L__func__.FlashProgPages, 15 + + .type .L.str.123,@object // @.str.123 +.L.str.123: + .asciz "%s: addr: %x is in id block!!!!!!!!!!\n" + .size .L.str.123, 39 + + .type .L.str.124,@object // @.str.124 +.L.str.124: + .asciz "not free: w: d:" + .size .L.str.124, 16 + + .type .L.str.125,@object // @.str.125 +.L.str.125: + .asciz "not free: w: s:" + .size .L.str.125, 16 + + .type .L.str.126,@object // @.str.126 +.L.str.126: + .asciz "prog read error: = %x\n" + .size .L.str.126, 23 + + .type .L.str.127,@object // @.str.127 +.L.str.127: + .asciz "prog read REFRESH: = %x\n" + .size .L.str.127, 25 + + .type .L.str.128,@object // @.str.128 +.L.str.128: + .asciz "prog read s error: = %x %x %x\n" + .size .L.str.128, 31 + + .type .L.str.129,@object // @.str.129 +.L.str.129: + .asciz "prog read d error: = %x %x %x\n" + .size .L.str.129, 31 + + .type .L__func__.FlashEraseBlocks,@object // @__func__.FlashEraseBlocks +.L__func__.FlashEraseBlocks: + .asciz "FlashEraseBlocks" + .size .L__func__.FlashEraseBlocks, 17 + + .type idb_need_write_back,@object // @idb_need_write_back + .local idb_need_write_back + .comm idb_need_write_back,1,4 + .type idb_buf,@object // @idb_buf + .local idb_buf + .comm idb_buf,8,8 + .type gp_flash_check_buf,@object // @gp_flash_check_buf + .local gp_flash_check_buf + .comm gp_flash_check_buf,8,8 + .type .L.str.130,@object // @.str.130 +.L.str.130: + .asciz "%s idb buffer alloc fail\n" + .size .L.str.130, 26 + + .type .L__func__.FtlWriteToIDB,@object // @__func__.FtlWriteToIDB +.L__func__.FtlWriteToIDB: + .asciz "FtlWriteToIDB" + .size .L__func__.FtlWriteToIDB, 14 + + .type _flash_read,@object // @_flash_read + .local _flash_read + .comm _flash_read,8,8 + .type _flash_write,@object // @_flash_write + .local _flash_write + .comm _flash_write,8,8 + .type g_vendor,@object // @g_vendor + .local g_vendor + .comm g_vendor,8,8 + .type .L.str.131,@object // @.str.131 +.L.str.131: + .asciz "copy_from_user error %d %p %p\n" + .size .L.str.131, 31 + + .type rkflash_vender_storage_dev,@object // @rkflash_vender_storage_dev + .data + .p2align 3 +rkflash_vender_storage_dev: + .word 255 // 0xff + .zero 4 + .xword .L.str.135 + .xword rk_sftl_vendor_storage_fops + .zero 16 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .hword 0 // 0x0 + .zero 6 + .size rkflash_vender_storage_dev, 80 + + .type gp_last_act_superblock,@object // @gp_last_act_superblock + .bss + .globl gp_last_act_superblock + .p2align 3 +gp_last_act_superblock: + .xword 0 + .size gp_last_act_superblock, 8 + + .type .L.str.132,@object // @.str.132 + .section .rodata.str1.1,"aMS",@progbits,1 +.L.str.132: + .asciz "write_idblock %x %x\n" + .size .L.str.132, 21 + + .type .L.str.133,@object // @.str.133 +.L.str.133: + .asciz "write_idblock fail! %x %x %x %x\n" + .size .L.str.133, 33 + + .type .L.str.135,@object // @.str.135 +.L.str.135: + .asciz "vendor_storage" + .size .L.str.135, 15 + + .type rk_sftl_vendor_storage_fops,@object // @rk_sftl_vendor_storage_fops + .section .rodata,"a",@progbits + .p2align 3 +rk_sftl_vendor_storage_fops: + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword rk_sftl_vendor_storage_ioctl + .xword rk_sftl_vendor_storage_ioctl + .xword 0 + .xword 0 // 0x0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .xword 0 + .size rk_sftl_vendor_storage_fops, 256 + + .ident "Android (7284624, based on r416183b) clang version 12.0.5 (https://android.googlesource.com/toolchain/llvm-project c935d99d7cf2016289302412d708641d52d2f7ee)" + .section ".note.GNU-stack","",@progbits + .addrsig + .addrsig_sym rk_sftl_vendor_storage_ioctl + .addrsig_sym g_active_superblock + .addrsig_sym g_buffer_superblock + .addrsig_sym g_gc_temp_superblock + .addrsig_sym g_gc_superblock + .addrsig_sym g_sys_ext_data + .addrsig_sym p_free_data_block_list_head + .addrsig_sym g_nand_phy_info + .addrsig_sym req_sys + .addrsig_sym gL2pMapInfo + .addrsig_sym gVendorBlkInfo + .addrsig_sym rkflash_vender_storage_dev + .addrsig_sym rk_sftl_vendor_storage_fops