

#define RTOS_EVID_MAX 131


#define RTOS_EVID_STR_FMT { \
/* 0x0000 */{"misc_plus.c", "ReadGPIO", 689, "Formating, keep GPIO as Low",},\
/* 0x0001 */{"misc_plus.c", "cpu_clk_main", 3151, "\ncpu_clk(%d MHz)",},\
/* 0x0002 */{"misc_plus.c", "cpu_clk_main", 3175, "\ncpu_clk: Error - wrong parameter(%d), only 0: 320MHz, 1: 525MHz, 2: 575MHz, 3: 600MHz",},\
/* 0x0003 */{"misc_plus.c", "cpu_clk_main", 3183, "\nNo change: cpu_clk(Cur:%d MHz) = (New:%d MHz)",},\
/* 0x0004 */{"misc_plus.c", "cpu_clk_main", 3191, "\ncpu_clk(%d MHz)->(%d MHz)",},\
/* 0x0005 */{"misc_plus.c", "l1_console", 3207, "l1 %d -> %d, plz reboot your system",},\
/* 0x0006 */{"misc_plus.c", "lspci_main", 3261, "PCIe gen %d x %d",},\
/* 0x0007 */{"misc_plus.c", "misc_cpu2_lock", 1138, "CPU2 LOCK!!",},\
/* 0x0008 */{"misc_plus.c", "misc_pcie_debug_dump", 398, "pcie info 0xC0043000: ctrl(+0x00)=0x%x, unmask(+0x04)=0x%x, core(+0x18)=0x%x, ltssm=0x%x link=0x%x",},\
/* 0x0009 */{"misc_plus.c", "misc_pcie_debug_dump", 403, "ltssm Disable",},\
/* 0x000a */{"misc_plus.c", "misc_pcie_debug_dump", 405, "PCIe link is down",},\
/* 0x000b */{"misc_plus.c", "misc_pcie_debug_dump", 407, "PCIe completion timeout.Refer to PCIe spec",},\
/* 0x000c */{"misc_plus.c", "misc_pcie_debug_dump", 409, "PCIe link down happened",},\
/* 0x000d */{"misc_plus.c", "nand_clk_init", 2536, "NF clk %dMT/s",},\
/* 0x000e */{"misc_plus.c", "pcie_link_enable", 1795, "LTSSM enable ltssm %x",},\
/* 0x000f */{"misc_plus.c", "pcie_ltssm_debug", 382, "LTSSM 0x58 %x 0x5c %x 0x60 %x",},\
/* 0x0010 */{"misc_plus.c", "phy_ldo_main", 3230, "Running LDO vout is %s, options:",},\
/* 0x0011 */{"misc_plus.c", "phy_ldo_main", 3241, "Phy/Core LDO [%s] -> [%s]",},\
/* 0x0012 */{"misc_plus.c", "power_evt_handler", 1188, "power drop %x",},\
/* 0x0013 */{"misc_plus.c", "power_isr", 1013, "PLP-vol_stts:%x",},\
/* 0x0014 */{"misc_plus.c", "power_isr", 1025, "PLP-start power lost activities",},\
/* 0x0015 */{"misc_plus.c", "power_isr", 1036, "could not start power lost activities",},\
/* 0x0016 */{"misc_plus.c", "preset_n_isr", 1983, "prest enter ltssm %x app %x",},\
/* 0x0017 */{"misc_plus.c", "preset_n_isr", 2058, "exit ltssm %x app %x",},\
/* 0x0018 */{"misc_plus.c", "timer0_handler", 736, "disable scp",},\
/* 0x0019 */{"misc_plus.c", "timer0_handler", 745, "enable scp",},\
/* 0x001a */{"pmu.c", "_stby_nand_io_off", 1267, "sv reg %x = %x",},\
/* 0x001b */{"pmu.c", "idle_apst", 1614, "enter apst fail 2! %x %x",},\
/* 0x001c */{"pmu.c", "idle_apst", 1634, "ENTER IDLE_APST",},\
/* 0x001d */{"pmu.c", "idle_apst", 1635, "L1 SUP: 0x%x L1 STATE: 0x%x",},\
/* 0x001e */{"pmu.c", "idle_apst", 1682, "DONE EXIT IDLE APST!",},\
/* 0x001f */{"pmu.c", "idle_apst", 1688, "enter apst fail! %x %x",},\
/* 0x0020 */{"pmu.c", "is_L11_L12_enable", 1573, "L1.1 or L1.2 enabled",},\
/* 0x0021 */{"pmu.c", "pmu_enter", 750, "PMU suspend failed %d.",},\
/* 0x0022 */{"pmu.c", "pmu_enter", 759, "CPU 1 suspend fail sts:%d ",},\
/* 0x0023 */{"pmu.c", "pmu_enter", 769, "PMU sub-suspend failed %d.",},\
/* 0x0024 */{"pmu.c", "pmu_enter", 793, "PMU suspend Abort(%x).",},\
/* 0x0025 */{"pmu.c", "pmu_enter", 818, "PMU exit due to memory shortage",},\
/* 0x0026 */{"pmu.c", "pmu_enter", 827, "PMU exit not in L1.2",},\
/* 0x0027 */{"pmu.c", "pmu_enter", 917, "PMU resume from L1.2: sts 0x%x, cnt(%d), rdump(%x), share_pmu_sts %d",},\
/* 0x0028 */{"pmu.c", "pmu_enter", 926, "time-out",},\
/* 0x0029 */{"pmu.c", "pmu_enter", 929, "get 0xC00400A8 %x, 0xC004303c %x , cnt %d",},\
/* 0x002a */{"pmu.c", "pmu_hw_sts", 443, "PS3 fail, not L1",},\
/* 0x002b */{"pmu.c", "pmu_hw_sts", 454, "PS3 fail, not L1.1 or 1.2",},\
/* 0x002c */{"pmu.c", "pmu_hw_sts", 460, "PS4 fail, not L1.2",},\
/* 0x002d */{"pmu.c", "pmu_hw_sts", 516, "PMU fail, Shutdown event",},\
/* 0x002e */{"pmu.c", "pmu_hw_sts", 522, "PMU fail, Wait Message Complete",},\
/* 0x002f */{"pmu.c", "pmu_hw_sts", 534, "[%d]ALL BIT , 0x%x \n",},\
/* 0x0030 */{"pmu.c", "pmu_hw_sts", 549, "[%d]ALL BIT , 0x%x \n",},\
/* 0x0031 */{"pmu.c", "pmu_main", 1734, "Current PMU: %d",},\
/* 0x0032 */{"pmu.c", "pmu_main", 1740, "Enable PMU ...",},\
/* 0x0033 */{"pmu.c", "pmu_main", 1746, "Disable PMU ...",},\
/* 0x0034 */{"pmu.c", "pmu_main", 1757, "PMU r94(0x%x), r98(0x%x) r80(0x%x)",},\
/* 0x0035 */{"pmu.c", "pmu_main", 1761, "ATCM CRC (0x%x)\n",},\
/* 0x0036 */{"pmu.c", "pmu_main", 1765, "ENTER %d\n",},\
/* 0x0037 */{"pmu.c", "pmu_main", 1777, "domain level :0x%x -> 0x%x\n",},\
/* 0x0038 */{"pmu.c", "pmu_main", 1782, "domain mode :%d -> %d\n",},\
/* 0x0039 */{"pmu.c", "pmu_main", 1784, "sleep\n",},\
/* 0x003a */{"pmu.c", "pmu_main", 1792, "pmu_mem_status %d\n",},\
/* 0x003b */{"pmu.c", "pmu_main", 1797, "pmu support :%d -> %d\n",},\
/* 0x003c */{"pmu.c", "pmu_suspend", 239, "error cookie %d\n",},\
/* 0x003d */{"pmu.c", "set_pmu_delay", 1702, "current L1 %d ms, L1.2 %d ms",},\
/* 0x003e */{"pmu.c", "set_pmu_delay", 1704, "set_pmu_delay [0/1] [time], unit:100ms",},\
/* 0x003f */{"pmu.c", "set_pmu_delay", 1714, "set L1 delay %d -> %d",},\
/* 0x0040 */{"pmu.c", "set_pmu_delay", 1717, "set L1.2 delay %d -> %d",},\
/* 0x0041 */{"pmu.c", "stby_enter", 1481, "PS3 enter",},\
/* 0x0042 */{"pmu.c", "stby_enter", 1497, "PS3 abort (%x)",},\
/* 0x0043 */{"pmu.c", "stby_enter", 1503, "PS3 abort L1.2(%x)",},\
/* 0x0044 */{"pmu.c", "sys_sleep", 1096, "PMU timer collipse, give up %d",},\
/* 0x0045 */{"thermal.c", "set_tmt", 1224, "Please insert correct arguments. set_tmt TMT1 TMT2\n",},\
/* 0x0046 */{"thermal.c", "set_tmt_nand", 1238, "Please insert correct arguments. set_tmt_nand TMT1 TMT2 Tcritical\n",},\
/* 0x0047 */{"thermal.c", "soc_ts_read", 1264, "ts_dout = 0x%x, degree %d, CPU %d gear %d",},\
/* 0x0048 */{"thermal.c", "thermal_enable_timer_handling", 962, "enable thermal interrupt",},\
/* 0x0049 */{"thermal.c", "thermal_throttle", 301, "thermal throttle %d -> %d",},\
/* 0x004a */{"thermal.c", "thermal_throttle", 335, "Enable flow control!",},\
/* 0x004b */{"thermal.c", "thermal_throttle", 364, "Disable flow control!",},\
/* 0x004c */{"thermal.c", "thermal_throttle", 434, " CPU clk %d, NF clk %d, ECC clk %d",},\
/* 0x004d */{"thermal.c", "ts_console", 1275, "ts_console_dout_nand= %d, ",},\
/* 0x004e */{"thermal.c", "ts_console", 1278, "ts injection enable: ts %d, CPU %d gear %d",},\
/* 0x004f */{"thermal.c", "ts_get_soc", 929, "negative temp %d, cur_ts %d, ts_int.all %d",},\
/* 0x0050 */{"thermal.c", "ts_injection_main", 1209, "ts injection off",},\
/* 0x0051 */{"thermal.c", "ts_injection_main", 1212, "ts injection: ts set to %d",},\
/* 0x0052 */{"thermal.c", "ts_isr", 519, "%x ts_dout = 0x%x %d degree",},\
/* 0x0053 */{"thermal.c", "ts_isr", 569, "%x ts_dout = 0x%x %d degree, ts_nand = %d",},\
/* 0x0054 */{"thermal.c", "ts_isr", 673, "cur %d(%d, %d)",},\
/* 0x0055 */{"thermal.c", "ts_setup", 752, "thermal throttle restore",},\
/* 0x0056 */{"thermal.c", "ts_setup_cpu2", 716, "thermal throttle restore",},\
/* 0x0057 */{"thermal.c", "ts_tmt_setup", 825, "tmt setup SoC %d %d %d",},\
/* 0x0058 */{"thermal.c", "ts_tmt_setup_nand", 820, "tmt setup NAND %d %d %d %d",},\
/* 0x0059 */{"task.c", "task_ev_block", 255, "ts=%x,%d, count=%d, event=%p",},\
/* 0x005a */{"task.c", "task_ev_block", 271, "ts=%x,%d, count=%d, event=%p",},\
/* 0x005b */{"task.c", "task_ev_wake", 292, "ts=%x,%d, event=%p,%p",},\
/* 0x005c */{"task.c", "task_ev_wake", 305, "ts=%x,%d, count=%d",},\
/* 0x005d */{"task.c", "task_init", 59, "ts=%x,%d, stack=%x, size=%d",},\
/* 0x005e */{"task.c", "task_new", 97, "ts=%x,%d, stack=%x, size=%d",},\
/* 0x005f */{"task.c", "task_sleep", 236, "ts=%x,%d, ticks=%d, count=%d",},\
/* 0x0060 */{"task.c", "task_sleep", 247, "ts=%x,%d, ticks=%d, count=%d",},\
/* 0x0061 */{"irq.c", "_do_irq", 45, "irq with no source %x",},\
/* 0x0062 */{"rtos.c", "do_panic", 77, "panic %x\n",},\
/* 0x0063 */{"rtos.c", "event_panic", 439, "recieve panic message cdump_flag 0x%x",},\
/* 0x0064 */{"rtos.c", "event_panic", 441, "recieve panic message",},\
/* 0x0065 */{"rtos.c", "exception_handler", 111, "===> Kernel CRASH!!!",},\
/* 0x0066 */{"rtos.c", "sys_mem_init", 766, "%d: size=%d, start=0x%x",},\
/* 0x0067 */{"fsm.c", "_fsm_ctx_run", 74, "ctx %p, state %s(%d)",},\
/* 0x0068 */{"fsm.c", "_fsm_ctx_run", 77, "ctx %p, state %s(%d), res %d",},\
/* 0x0069 */{"fsm.c", "fsm_ctx_init", 37, "ctx %p, state %p",},\
/* 0x006a */{"fsm.c", "fsm_queue_insert_head", 120, "fsm %p, ctx %p",},\
/* 0x006b */{"fsm.c", "fsm_queue_insert_tail", 126, "fsm %p, ctx %p",},\
/* 0x006c */{"fsm.c", "fsm_queue_remove_first", 137, "fsm %p, ctx %p",},\
/* 0x006d */{"fsm.c", "fsm_queue_remove_last", 148, "fsm %p, ctx %p",},\
/* 0x006e */{"fsm.c", "fsm_queue_run", 157, "fsm %p",},\
/* 0x006f */{"pool.c", "pool_check_free", 47, "pl %p, e %p, %x/%x",},\
/* 0x0070 */{"pool.c", "pool_get", 107, "pl %p, e %p, next %p",},\
/* 0x0071 */{"pool.c", "pool_init", 66, "pl %p, base %p, size %d, esize %d, enum %d",},\
/* 0x0072 */{"pool.c", "pool_put", 123, "pl %p, base %p, end %p, %p",},\
/* 0x0073 */{"pool.c", "pool_put", 143, "pl %p, e %p, next %p",},\
/* 0x0074 */{"event.c", "evt_delay_resume", 165, "evt act %d",},\
/* 0x0075 */{"event.c", "evt_register", 70, "handler=%x, param=%x, index=%d",},\
/* 0x0076 */{"event.c", "evt_register", 74, "evt reg fail! handler=%x",},\
/* 0x0077 */{"event.c", "evt_set_cs", 121, "cookie error %d/%d",},\
/* 0x0078 */{"event.c", "evt_set_delay", 180, "evt delay %d %d",},\
/* 0x0079 */{"tmp102.c", "tmp102_init", 61, "smb_intr_sts: %x",},\
/* 0x007a */{"tmp102.c", "tmp102_read", 125, "TMP102 set ...",},\
/* 0x007b */{"tmp102.c", "tmp102_read", 146, "smb_intr_sts %x",},\
/* 0x007c */{"tmp102.c", "tmp102_read", 156, "TMP102 get ...",},\
/* 0x007d */{"tmp102.c", "tmp102_read", 159, "Data0: %x",},\
/* 0x007e */{"tmp102.c", "tmp102_read", 161, "Data1: %x",},\
/* 0x007f */{"tmp102.c", "tmp102_read", 166, "Temperature: %d c",},\
/* 0x0080 */{"stat_head.c", "stat_restore", 39, "new %x stat, sig %x error",},\
/* 0x0081 */{"stat_head.c", "stat_restore", 42, "src is NULL",},\
/* 0x0082 */{"stat_head.c", "stat_restore", 55, "stat %x upg %d(%d) -> %d(%d)",},\
};


#define FTL_EVID_MAX 887


#define FTL_EVID_STR_FMT { \
/* 0x0000 */{"defect_mgr.c", "defect_remap_rebuild", 251, "remap pair %d spb %d all defect",},\
/* 0x0001 */{"defect_mgr.c", "defect_remap_rebuild", 263, "rebuld %d remap pair",},\
/* 0x0002 */{"defect_mgr.c", "defect_version_check", 377, "defect version %d - %d (%d)",},\
/* 0x0003 */{"defect_mgr.c", "ftl_build_remap", 352, "total %d remapped spb",},\
/* 0x0004 */{"defect_mgr.c", "ftl_defect_prune_for_mp", 920, "mp mask %x",},\
/* 0x0005 */{"defect_mgr.c", "ftl_defect_prune_for_mp", 972, "real df %d, df %d after prune",},\
/* 0x0006 */{"defect_mgr.c", "ftl_drop_partial", 233, "total %d physical block drop",},\
/* 0x0007 */{"defect_mgr.c", "ftl_init_defect", 468, "expect %x free %x size %x",},\
/* 0x0008 */{"defect_mgr.c", "ftl_init_defect", 473, "alloc mem fail. size_alloc %d",},\
/* 0x0009 */{"defect_mgr.c", "ftl_init_defect", 543, "Load Defect BitMap Fail, will load mr defect BitMap",},\
/* 0x000a */{"defect_mgr.c", "ftl_scan_defect", 813, "partial defect SPB %d,",},\
/* 0x000b */{"defect_mgr.c", "ftl_scan_defect", 817, " %x",},\
/* 0x000c */{"defect_mgr.c", "ins_grwn_err_info", 602, "grown defect multiple error %x %x",},\
/* 0x000d */{"defect_mgr.c", "ins_grwn_err_info", 610, "grown defect insert list fail %x %x",},\
/* 0x000e */{"defect_mgr.c", "remap_dump_main", 1014, "Interleave error \n",},\
/* 0x000f */{"defect_mgr.c", "remap_dump_main", 985, "f %x cnt %d itlv %d",},\
/* 0x0010 */{"defect_mgr.c", "remap_idx_init", 370, "remap_idx is from cpu1 btcm addr(%x), size(%x)",},\
/* 0x0011 */{"defect_mgr.c", "spb_set_defect_blk", 685, "mark spb %d grown defect %x",},\
/* 0x0012 */{"defect_mgr.c", "spb_set_defect_blk", 712, "search spb %d miss",},\
/* 0x0013 */{"format.c", "format_timer_handler", 99, "ftl format type %d trigger by timer",},\
/* 0x0014 */{"format.c", "ftl_erase_err_handling", 236, "erase err %x %x",},\
/* 0x0015 */{"format.c", "ftl_format", 119, "lut busy, resume by timer",},\
/* 0x0016 */{"format.c", "ftl_format", 132, "ftl format type %d",},\
/* 0x0017 */{"format.c", "ftl_format_done_evt_handler", 370, "ftl format done",},\
/* 0x0018 */{"format.c", "ftl_spb_erase_exec", 344, "erase spb_id %d error",},\
/* 0x0019 */{"format.c", "ftl_spb_sync_erase", 297, "spb_id %d has defected, skip it",},\
/* 0x001a */{"ftl.c", "fdisk_dump_mem_init", 875, "dfs is null",},\
/* 0x001b */{"ftl.c", "fdisk_dump_mem_init", 884, "sram: oom",},\
/* 0x001c */{"ftl.c", "fdisk_dump_mem_init", 912, "srb cdump %d no exist",},\
/* 0x001d */{"ftl.c", "fdisk_dump_mem_init", 923, "Setup DFS cdump stat log",},\
/* 0x001e */{"ftl.c", "fdisk_dump_mem_init", 949, "dump spb 0x%x, max_wr_ptr %d, cur_slot %d (max %d)",},\
/* 0x001f */{"ftl.c", "fdisk_dump_mem_init", 955, "cdump_flag : 0x%x",},\
/* 0x0020 */{"ftl.c", "ftl_dump", 2424, "fcmd %d",},\
/* 0x0021 */{"ftl.c", "ftl_flush_io_block", 1135, "IO Block FTL flush start",},\
/* 0x0022 */{"ftl.c", "ftl_flush_io_block", 1138, "ftl busy",},\
/* 0x0023 */{"ftl.c", "ftl_flush_io_block", 1147, "IO Block FTL flush submit",},\
/* 0x0024 */{"ftl.c", "ftl_flush_io_block", 1150, "IO Block FTL flush end",},\
/* 0x0025 */{"ftl.c", "ftl_flush_pwr_loss", 1222, "Power loss FTL flush start",},\
/* 0x0026 */{"ftl.c", "ftl_flush_pwr_loss", 1225, "ftl busy",},\
/* 0x0027 */{"ftl.c", "ftl_flush_pwr_loss", 1232, "Power loss FTL flush submit",},\
/* 0x0028 */{"ftl.c", "ftl_flush_pwr_loss", 1235, "Power loss FTL flush end",},\
/* 0x0029 */{"ftl.c", "ftl_get_capacity", 1835, "User LS: 0x%x %d",},\
/* 0x002a */{"ftl.c", "ftl_init", 1741, "ftl %s init end",},\
/* 0x002b */{"ftl.c", "ftl_init", 1760, "Read_disturb_enable(%d)",},\
/* 0x002c */{"ftl.c", "ftl_init", 1808, "dtag %d ftl_req_time 0x%x",},\
/* 0x002d */{"ftl.c", "ftl_io_block_flush_cmpl", 1012, "ftl flush completed",},\
/* 0x002e */{"ftl.c", "ftl_io_block_flush_cmpl", 1015, "dfs_flush() completed",},\
/* 0x002f */{"ftl.c", "ftl_io_block_flush_cmpl", 1018, "evlog_flush() completed",},\
/* 0x0030 */{"ftl.c", "ftl_is_busy", 1069, "Trim Wait flush",},\
/* 0x0031 */{"ftl.c", "ftl_is_busy", 1073, "Need Flush user",},\
/* 0x0032 */{"ftl.c", "ftl_is_busy", 1078, "Wait middle timer",},\
/* 0x0033 */{"ftl.c", "ftl_mem_flush", 1172, "NCL BUSY",},\
/* 0x0034 */{"ftl.c", "ftl_mem_flush", 1180, "bg state",},\
/* 0x0035 */{"ftl.c", "ftl_mem_flush", 1198, "ftl busy->give up",},\
/* 0x0036 */{"ftl.c", "ftl_mem_flush", 1207, "FTL mem flush submit",},\
/* 0x0037 */{"ftl.c", "ftl_mem_flush_cmpl", 1157, "mem_flush cmpl",},\
/* 0x0038 */{"ftl.c", "ftl_pmu_flush_cmpl", 1029, "ftl flush completed",},\
/* 0x0039 */{"ftl.c", "ftl_pmu_flush_cmpl", 1032, "dfs_flush() completed",},\
/* 0x003a */{"ftl.c", "ftl_pmu_flush_cmpl", 1035, "evlog_flush() completed",},\
/* 0x003b */{"ftl.c", "ftl_req_init", 2293, "cache read enabled",},\
/* 0x003c */{"ftl.c", "ftl_req_status_dump", 2397, "ftl req free %d, simple free %d",},\
/* 0x003d */{"ftl.c", "ftl_req_status_dump", 2399, "ftl req hook bmp %x",},\
/* 0x003e */{"ftl.c", "ftl_resume", 1259, "recycle user %d\n",},\
/* 0x003f */{"ftl.c", "ftl_resume", 1264, "recycle middle %d\n",},\
/* 0x0040 */{"ftl.c", "ftl_resume", 1285, "1.resume\n",},\
/* 0x0041 */{"ftl.c", "ftl_resume", 1298, "2.resume\n",},\
/* 0x0042 */{"ftl.c", "ftl_shrink_capacity", 2355, "total du %d, disk_size_in_du %d",},\
/* 0x0043 */{"ftl.c", "ftl_shrink_capacity", 2366, "disk_size_in_gb %d %d",},\
/* 0x0044 */{"ftl.c", "ftl_spb_pool_init", 2058, "user spare %d slc req %d min %d",},\
/* 0x0045 */{"ftl.c", "ftl_spb_pool_init", 2122, "pool %d type %d cnt %d/%d/%d blk %d",},\
/* 0x0046 */{"ftl.c", "ftl_spb_pool_init", 2129, "user pool %d,GC(thr) (%d/%d/%d) (%d/%d)",},\
/* 0x0047 */{"ftl.c", "ftl_start", 983, "ftl start end, stop",},\
/* 0x0048 */{"ftl.c", "ftl_stat_restore", 1946, "Restore flag readonly(0x%x)",},\
/* 0x0049 */{"ftl.c", "ftl_suspend", 1109, "Prepare Mem off",},\
/* 0x004a */{"ftl.c", "get_spare_cnt", 1933, "no max spare record",},\
/* 0x004b */{"ftl_dbg.c", "ftl_dbg_main", 45, "trigger pool %d GC",},\
/* 0x004c */{"ftl_dbg.c", "ftl_dbg_main", 52, "weak gc disable %d->%d",},\
/* 0x004d */{"ftl_dbg.c", "ftl_dbg_main", 58, "disturb gc %d->%d",},\
/* 0x004e */{"ftl_dbg.c", "ftl_dbg_main", 69, "idle apst disable %d->%d",},\
/* 0x004f */{"ftl_dbg.c", "ftl_dbg_main", 82, "no support",},\
/* 0x0050 */{"internal_ctx.c", "_internal_ctx_get", 166, "need %d but %d",},\
/* 0x0051 */{"internal_ctx.c", "internal_ctx_set_pending_ils", 229, "ictx pend %d",},\
/* 0x0052 */{"page_allocator.c", "page_allocator_active_spb_setup", 378, "setup pga %d[%d] spb %d %d-%d",},\
/* 0x0053 */{"page_allocator.c", "page_allocator_active_spb_setup", 380, "dft %d, occupy %d max occupy %d state %d",},\
/* 0x0054 */{"page_allocator.c", "page_allocator_close", 264, "not idle aspb %d %d %d",},\
/* 0x0055 */{"page_allocator.c", "page_allocator_close", 270, "close aspb %d %d",},\
/* 0x0056 */{"page_allocator.c", "page_allocator_close_aspb", 524, "wait rsvd IO aspb %d",},\
/* 0x0057 */{"page_allocator.c", "page_allocator_close_aspb", 540, "RR force close %d",},\
/* 0x0058 */{"page_allocator.c", "page_allocator_close_aspb", 547, "wait %d idle",},\
/* 0x0059 */{"page_allocator.c", "page_allocator_dump", 611, "pga %d avl_cnt %d cur_slot %d f %x",},\
/* 0x005a */{"page_allocator.c", "page_allocator_dump", 616, "spb[%d] w_ptr %d compl_cnt %d integ fence %x",},\
/* 0x005b */{"page_allocator.c", "page_allocator_dump", 620, " id %d state %d f %x",},\
/* 0x005c */{"spb_info.c", "spb_info_dump", 140, "%d e %d f %x p %d\n",},\
/* 0x005d */{"spb_info.c", "spb_info_dump", 144, "dft %x %x %x %x\n",},\
/* 0x005e */{"spb_info.c", "spb_info_dump", 172, "Pool %d avg %d max %d min %d",},\
/* 0x005f */{"spb_info.c", "spb_info_dump_main", 197, "Invalid SPB id, range [0-%d]",},\
/* 0x0060 */{"user_ls.c", "user_valid_chk", 1767, "no mem",},\
/* 0x0061 */{"user_ls.c", "user_valid_chk", 1787, "no mem to acc valid",},\
/* 0x0062 */{"user_ls.c", "user_valid_chk", 1794, "scan issued",},\
/* 0x0063 */{"user_ls.c", "valid_acc_done", 1723, "scan done",},\
/* 0x0064 */{"wait.c", "wait_release", 78, "mutex resume %p",},\
/* 0x0065 */{"spb_manager.c", "_spb_pool_recycle", 2879, "no gc by shutdown",},\
/* 0x0066 */{"spb_manager.c", "_spb_pool_recycle", 2956, "spb %d didn't close on last power cycle, gc it",},\
/* 0x0067 */{"spb_manager.c", "_spb_pool_recycle", 3106, "GC SPB %d vc %d sn %d trigger pool[%d] free %d f 0x%x",},\
/* 0x0068 */{"spb_manager.c", "_spb_pool_recycle", 3123, "no GC req flag[%x], pool[%d]",},\
/* 0x0069 */{"spb_manager.c", "_spb_pool_recycle", 3128, "pool(%d) no GC candidate min(%d)",},\
/* 0x006a */{"spb_manager.c", "boot_flush_fence_done", 2349, "boot_flush_fence_done, erase spb %d",},\
/* 0x006b */{"spb_manager.c", "chk_risk_spb", 2663, "spb 0x%x is risk spb",},\
/* 0x006c */{"spb_manager.c", "chk_spb_can_gc", 2480, "Spb %d can't gc. flag %x sn %d trim_least_sn %d",},\
/* 0x006d */{"spb_manager.c", "chk_spb_is_gcing", 4646, "spb %d gcing",},\
/* 0x006e */{"spb_manager.c", "chk_spb_status", 1529, "good %d remap %d partial %d(%d) zombie %d",},\
/* 0x006f */{"spb_manager.c", "is_disturbed_spb", 2163, "SPB(%d) NEED RDGC by over_th(%x/%x) ttl_cnt(%d)",},\
/* 0x0070 */{"spb_manager.c", "pda_read_cnt_inc", 1112, "SPB(%d) NEED 2ND rd_cnt(%d)",},\
/* 0x0071 */{"spb_manager.c", "pda_read_cnt_inc_v1", 1144, "SPB(%d) NEED 2ND rd_cnt(%d)",},\
/* 0x0072 */{"spb_manager.c", "raid_force_close_cmpl", 3851, "raid stripe %d force close by %d disturb done",},\
/* 0x0073 */{"spb_manager.c", "refresh_next_page", 4439, "Totol Refresh cycle:%d",},\
/* 0x0074 */{"spb_manager.c", "refresh_next_page", 4442, "page cycle itl:%d spb:%d",},\
/* 0x0075 */{"spb_manager.c", "refresh_next_page", 4451, "FTL Refresh cycle:%d next spb:%d itl:%d page:%d %x %d",},\
/* 0x0076 */{"spb_manager.c", "refresh_next_spb", 4462, "cycle spb:%d",},\
/* 0x0077 */{"spb_manager.c", "refresh_read_done", 4493, "Refresh meet overlimt/uc(%d). wordline pda 0x%x org_pda 0x%x spb %d flags 0x%x. read again",},\
/* 0x0078 */{"spb_manager.c", "refresh_read_done", 4502, "Refresh meet overlimt/uc(%d). wordline pda 0x%x org_pda 0x%x spb %d flags 0x%x. recycle it",},\
/* 0x0079 */{"spb_manager.c", "refresh_read_done", 4507, "Refresh meet overlimt/uc(%d). pda 0x%x org_pda 0x%x spb %d flags 0x%x. don't recycle",},\
/* 0x007a */{"spb_manager.c", "refresh_read_done", 4511, "Refresh erased page. wordline pda 0x%x org_pda 0x%x",},\
/* 0x007b */{"spb_manager.c", "search_rd_fail_spb", 4333, "Got rd fail spb. %d %d %d",},\
/* 0x007c */{"spb_manager.c", "set_ext_max_dynamic_slc_count", 633, "extend dynamic slc ratio -> (%d)",},\
/* 0x007d */{"spb_manager.c", "set_max_dynamic_slc_count", 622, "restore dynamic slc ratio -> (%d)",},\
/* 0x007e */{"spb_manager.c", "share_pool_erase_chk", 1835, "share pool balance trigger, f 0x%x, avg erase cnt %d %d",},\
/* 0x007f */{"spb_manager.c", "share_pool_start_balance", 1968, "share pool balance start, f 0x%x",},\
/* 0x0080 */{"spb_manager.c", "share_pool_wait_cvrt_done", 1655, "share pool wait cvrt done, f 0x%x",},\
/* 0x0081 */{"spb_manager.c", "sp_balance_exit", 1781, "share pool balance done sys (%d %d) usr (%d %d)",},\
/* 0x0082 */{"spb_manager.c", "sp_balance_ready_exit", 1742, "share pool balance ready exit, f 0x%x",},\
/* 0x0083 */{"spb_manager.c", "sp_balance_ready_exit", 1746, "share pool balance ready exit, f 0x%x",},\
/* 0x0084 */{"spb_manager.c", "sp_balance_trigger_chk", 1865, "share pool balance trigger, pool %d free %d",},\
/* 0x0085 */{"spb_manager.c", "sp_check_op", 1646, "pool %d op warning, cap_blk %d ttl_blk %d",},\
/* 0x0086 */{"spb_manager.c", "spb_alloc_desc_flush", 3806, "spb alloc wait spb %d %d",},\
/* 0x0087 */{"spb_manager.c", "spb_allocation_handler", 2431, "fire erase cmd %d,ls %d",},\
/* 0x0088 */{"spb_manager.c", "spb_appl_dump", 4148, "qta:%d f:%x slc_p_id:%d nat_p_id:%d",},\
/* 0x0089 */{"spb_manager.c", "spb_appl_get_spb", 3670, "pool %d blk",},\
/* 0x008a */{"spb_manager.c", "spb_appl_get_spb", 3687, "pool %d blk",},\
/* 0x008b */{"spb_manager.c", "spb_appl_get_spb", 3690, "no SPB but must have, set read-only disk",},\
/* 0x008c */{"spb_manager.c", "spb_appl_get_spb", 3697, "can %d busy",},\
/* 0x008d */{"spb_manager.c", "spb_appl_get_spb", 3724, "appl id %d pool %d SPB %d free %d is_slc:%d ls %d",},\
/* 0x008e */{"spb_manager.c", "spb_appl_register", 666, "ls %d link slc %d native %d",},\
/* 0x008f */{"spb_manager.c", "spb_arrange_spb_to_pool", 1581, "skip spb %d-%d",},\
/* 0x0090 */{"spb_manager.c", "spb_arrange_spb_to_pool", 1584, "skip spb %d remap",},\
/* 0x0091 */{"spb_manager.c", "spb_arrange_spb_to_pool", 1632, "pool %d, cap blk %d/%d ttl %d",},\
/* 0x0092 */{"spb_manager.c", "spb_chk_close_spb", 4033, "force close spb %d",},\
/* 0x0093 */{"spb_manager.c", "spb_chk_pool_gc", 2279, "GC %d %d trigger pool[%d] free %d/%d",},\
/* 0x0094 */{"spb_manager.c", "spb_chk_pool_gc", 2287, "pool[%d] free %d/%d < %d",},\
/* 0x0095 */{"spb_manager.c", "spb_chk_set_read_only", 3252, "1: disk is read only. %d %d %d",},\
/* 0x0096 */{"spb_manager.c", "spb_chk_set_read_only", 3262, "3: disk is read only. %d %d %d",},\
/* 0x0097 */{"spb_manager.c", "spb_desc_flush_wait", 3754, "spb flush resume %d %d",},\
/* 0x0098 */{"spb_manager.c", "spb_dump_main", 4796, " Invalid SPB number, range [0-%d]",},\
/* 0x0099 */{"spb_manager.c", "spb_manager_init", 1210, "SPB cnt = %d",},\
/* 0x009a */{"spb_manager.c", "spb_manager_start", 1376, "sys log spb %x flag %x",},\
/* 0x009b */{"spb_manager.c", "spb_manager_start", 1384, "spb log spb %x flag %x",},\
/* 0x009c */{"spb_manager.c", "spb_manager_start", 1442, "a busy SPB was retired %d f %x",},\
/* 0x009d */{"spb_manager.c", "spb_manager_start", 1465, "pool %d free cnt %d/%d ttl %d/%d",},\
/* 0x009e */{"spb_manager.c", "spb_manager_start", 1470, "free_cnt_can_switch %d, used_slc_block_cnt %d",},\
/* 0x009f */{"spb_manager.c", "spb_meta_dump", 4184, "SPB %d D:%x %x %x %x cnt:%d",},\
/* 0x00a0 */{"spb_manager.c", "spb_meta_dump", 4189, "get res error! dtag %x, meta %x, bm %x",},\
/* 0x00a1 */{"spb_manager.c", "spb_meta_dump", 4205, "type:%s du_cnt:%d",},\
/* 0x00a2 */{"spb_manager.c", "spb_meta_dump", 4208, "from %d cnt %d",},\
/* 0x00a3 */{"spb_manager.c", "spb_meta_dump", 4228, "%x is defect",},\
/* 0x00a4 */{"spb_manager.c", "spb_meta_dump", 4232, "[%x](%x) %x %x %x %x",},\
/* 0x00a5 */{"spb_manager.c", "spb_mgr_dump", 4115, "spb_cnt : %d",},\
/* 0x00a6 */{"spb_manager.c", "spb_mgr_dump", 4127, "spb[%d] flag %x %x pool%d gc_imm %d vc %d",},\
/* 0x00a7 */{"spb_manager.c", "spb_mgr_dump", 4130, "tb[%d] sn %x defect %x %x %x %x",},\
/* 0x00a8 */{"spb_manager.c", "spb_mgr_dump", 4132, "spb[%d] ls_id %d r_cnt %d/%d erase %d/%d",},\
/* 0x00a9 */{"spb_manager.c", "spb_mgr_dump", 4139, "pool %d free %d ",},\
/* 0x00aa */{"spb_manager.c", "spb_mgr_dump", 4141, "f %x cookies %d",},\
/* 0x00ab */{"spb_manager.c", "spb_mgr_dump", 4143, "switch %d, used %d retire %d",},\
/* 0x00ac */{"spb_manager.c", "spb_pool_gc_thr_merge", 2325, "pool %d - %d/%d/%d",},\
/* 0x00ad */{"spb_manager.c", "spb_pool_recycle_done", 2814, "continue gc risk spb",},\
/* 0x00ae */{"spb_manager.c", "spb_pool_recycle_done", 2818, "STOP cont. GC pool %d flag %x",},\
/* 0x00af */{"spb_manager.c", "spb_read_cnt_inc", 1083, "SPB(%d) NEED 2ND rd_cnt(%d)",},\
/* 0x00b0 */{"spb_manager.c", "spb_read_disturb_chk", 3906, "raid stripe %d force close by %d disturb",},\
/* 0x00b1 */{"spb_manager.c", "spb_read_disturb_chk", 3915, "wait force close to close aspb %d",},\
/* 0x00b2 */{"spb_manager.c", "spb_read_disturb_chk", 3986, "spb %d ~RDGC",},\
/* 0x00b3 */{"spb_manager.c", "spb_read_disturb_chk", 3998, "gc_req using",},\
/* 0x00b4 */{"spb_manager.c", "spb_read_disturb_gc_done", 1000, "ls not match %d %d",},\
/* 0x00b5 */{"spb_manager.c", "spb_read_disturb_gc_done", 950, "no gc_req",},\
/* 0x00b6 */{"spb_manager.c", "spb_read_disturb_gc_done", 954, "Read retention GC done %d",},\
/* 0x00b7 */{"spb_manager.c", "spb_read_disturb_gc_done", 968, "RDGC done %d ttl_cnt %d",},\
/* 0x00b8 */{"spb_manager.c", "spb_read_disturb_gc_trigger", 1034, "no gc by shutdown",},\
/* 0x00b9 */{"spb_manager.c", "spb_read_disturb_gc_trigger", 1057, "Now RD gc %d rd_cnt(%d) ttl_cnt(%d)",},\
/* 0x00ba */{"spb_manager.c", "spb_read_disturb_gc_trigger", 1059, "Now RD gc %d rd_cnt(%d)",},\
/* 0x00bb */{"spb_manager.c", "spb_refresh_get_scan_page_cnt", 4632, "Nand temperature:%d scan:%d pages",},\
/* 0x00bc */{"spb_manager.c", "spb_refresh_handler", 4682, "spb %d flags 0x%x risk %d vc %d ls_id %d xlc %d",},\
/* 0x00bd */{"spb_manager.c", "spb_refresh_handler", 4691, "Begin scan spb:%d page:%d pda:%x %d/%d cnt:%d",},\
/* 0x00be */{"spb_manager.c", "spb_refresh_handler", 4712, "Total Refresh cycle:%d",},\
/* 0x00bf */{"spb_manager.c", "spb_refresh_handler", 4718, "to last spb:%d page:%d",},\
/* 0x00c0 */{"spb_manager.c", "spb_refresh_handler", 4733, "flush refresh->pda 0x%x",},\
/* 0x00c1 */{"spb_manager.c", "spb_refresh_init", 4775, "refresh->pda 0x%x",},\
/* 0x00c2 */{"spb_manager.c", "spb_rel_chk", 535, "spb rel chk %d",},\
/* 0x00c3 */{"spb_manager.c", "spb_release", 686, "release SPB %d(%d) %x",},\
/* 0x00c4 */{"spb_manager.c", "spb_release", 707, "spb release fast read spb 0x%x",},\
/* 0x00c5 */{"spb_manager.c", "spb_retire", 3277, "spb %d already retired",},\
/* 0x00c6 */{"spb_manager.c", "spb_retire", 3345, "spb retired %x pool %d blk %d, total %d",},\
/* 0x00c7 */{"spb_manager.c", "spb_set_retire", 3208, "mark spb %d retire type %d",},\
/* 0x00c8 */{"spb_manager.c", "spb_set_weak", 3221, "mark read weak spb %d, retire %d",},\
/* 0x00c9 */{"spb_manager.c", "spb_statis_busy_cnt", 1907, "pool %d-%d busy cnt %d-%d",},\
/* 0x00ca */{"spb_manager.c", "spb_valid_cnt_change", 805, "reset rd fail spb 0x%x vc to 1",},\
/* 0x00cb */{"spb_manager.c", "spb_valid_cnt_change", 810, "vcnt err spb %d %d - %d",},\
/* 0x00cc */{"spb_manager.c", "spb_valid_cnt_change", 824, "rel spb %d cnt %d",},\
/* 0x00cd */{"spb_manager.c", "spb_valid_cnt_change", 836, "rel spb %d cnt %d",},\
/* 0x00ce */{"spb_manager.c", "spb_valid_cnt_reset", 751, "SPB %d v %d -> %d",},\
/* 0x00cf */{"spb_manager.c", "spb_valid_cnt_reset", 758, "F %x",},\
/* 0x00d0 */{"spb_manager.c", "spb_valid_cnt_set", 772, "spb %d v %d -> %d",},\
/* 0x00d1 */{"spb_manager.c", "spb_weak_xlc_gc_done", 3147, "weak xlc recycle done spb %d",},\
/* 0x00d2 */{"spb_manager.c", "spb_weak_xlc_gc_trigger", 3193, "trigger weak xlc recycle spb %d pool %d",},\
/* 0x00d3 */{"spb_manager.c", "spb_wear_level", 3379, "no gc by shutdown",},\
/* 0x00d4 */{"spb_manager.c", "spb_wear_level", 3389, "## Enable WL Performace mode",},\
/* 0x00d5 */{"spb_manager.c", "spb_wear_level", 3399, "## host_written:%d host_skip_WL:%d GB",},\
/* 0x00d6 */{"spb_manager.c", "spb_wear_level", 3406, "## Disable WL Performace mode",},\
/* 0x00d7 */{"spb_manager.c", "spb_wear_level", 3505, "WL trigger, used epc min %d(spb %d), max %d(spb %d)",},\
/* 0x00d8 */{"spb_manager.c", "spb_wear_level", 3507, "WL trigger, free epc min %d(spb %d), max %d(spb %d)",},\
/* 0x00d9 */{"spb_manager.c", "spb_wear_level", 3525, "WL spb %d, epc %d, vc %d",},\
/* 0x00da */{"convert.c", "cfsm_completion_flush", 583, "cfsm wait flush",},\
/* 0x00db */{"ftl.c", "ftl_init", 1721, "After shrink User disk: %d GB",},\
/* 0x00dc */{"ftl.c", "ftl_init_cus_blk", 1503, "ftl force fua write config status (0 enable, 1 disable) ==> [%x]",},\
/* 0x00dd */{"ftl.c", "ftl_init_cus_blk", 1517, "nand_slc_xlc_mode %d",},\
/* 0x00de */{"ftl.c", "ftl_init_cus_blk", 1533, "has hmb %d",},\
/* 0x00df */{"ftl.c", "ftl_init_cus_blk", 1537, "ftl setting from NAND %d %d %d %d %d %d",},\
/* 0x00e0 */{"ftl.c", "ftl_init_cus_blk", 1541, "ftl setting from NAND %d %d %d %d %d",},\
/* 0x00e1 */{"ftl.c", "ftl_init_cus_blk", 1550, "Ignore Capacity Change %d GB, max %d",},\
/* 0x00e2 */{"ftl.c", "ftl_init_cus_blk", 1554, "Set default Capacity %d GB",},\
/* 0x00e3 */{"ftl.c", "ftl_init_cus_blk", 1563, "Capacity Change!! (%d -> %d)GB",},\
/* 0x00e4 */{"internal_ls.c", "internal_ls_desc_flush", 203, ">> spb %d %d %d state %d",},\
/* 0x00e5 */{"internal_ls.c", "internal_ls_desc_flush", 205, "[%d] set spb %d, w %d f %d",},\
/* 0x00e6 */{"internal_ls.c", "internal_ls_desc_flush", 212, ">> spb %d %d %d",},\
/* 0x00e7 */{"internal_ls.c", "internal_ls_desc_flush", 216, "[%d] set spb %d, w %d f %d",},\
/* 0x00e8 */{"internal_ls.c", "internal_ls_dump", 394, "sn %d",},\
/* 0x00e9 */{"internal_ls.c", "internal_ls_dump", 396, " appl spd_id:%d quota:%d f:%x",},\
/* 0x00ea */{"internal_ls.c", "internal_ls_dump", 401, " ls_id:%d slc_pool_id:%d nat_pool_id:%d",},\
/* 0x00eb */{"internal_ls.c", "internal_ls_recovery_ready_spb", 350, "ls %d ready SPB %d, active %d %d flag %x",},\
/* 0x00ec */{"internal_ls.c", "internal_ls_recovery_ready_spb", 369, "update inv_slot %d",},\
/* 0x00ed */{"internal_ls.c", "internal_ls_spb_notify_cb", 284, "ls %d spb_id %d sn %d",},\
/* 0x00ee */{"internal_ls.c", "internal_ls_start", 141, "ils->ls.flags %x ils_desc->flags %x",},\
/* 0x00ef */{"logical_space.c", "get_user_disk_sz", 323, "User disk: %d GB, lda %d",},\
/* 0x00f0 */{"logical_space.c", "get_user_disk_sz", 324, "s2s perf: %d-%d MB/s",},\
/* 0x00f1 */{"logical_space.c", "is_all_ls_clean", 334, "ls %d clean",},\
/* 0x00f2 */{"logical_space.c", "logical_space_init", 89, "ls %d init capacity = %x",},\
/* 0x00f3 */{"logical_space.c", "logical_spaces_init", 112, "User capacity: Total LDA(0x%x %d) for OPAL SSC use: LDA(0x%x %d)",},\
/* 0x00f4 */{"logical_space.c", "logical_spaces_init", 115, "User capacity: LDA(0x%x %d)",},\
/* 0x00f5 */{"logical_space.c", "logical_spaces_start", 234, "open system",},\
/* 0x00f6 */{"logical_space.c", "logical_spaces_start", 238, "system opened",},\
/* 0x00f7 */{"logical_space.c", "ls_dump", 385, "id %d io_blk_f %x cap %d f %x",},\
/* 0x00f8 */{"logical_space.c", "ls_dump", 392, "id:%d op:%d ctx:%d f:%d",},\
/* 0x00f9 */{"logical_space.c", "ls_dump", 395, " lrange type:%d, list_len:%d lda_cnt:%d",},\
/* 0x00fa */{"logical_space.c", "ls_dump", 407, "slba[%d]%x%x cnt:%x",},\
/* 0x00fb */{"logical_space.c", "ls_dump", 412, "lda[%d]:%x",},\
/* 0x00fc */{"logical_space.c", "ls_dump", 416, "lda:%x",},\
/* 0x00fd */{"logical_space.c", "ls_dump", 422, " gc spd_id %d ls_id %d",},\
/* 0x00fe */{"logical_space.c", "ls_dump", 424, " prior %d f %x",},\
/* 0x00ff */{"logical_space.c", "ls_dump_main", 444, "ls id invalid 0:user, 1:middle, 2:system",},\
/* 0x0100 */{"logical_space.c", "ls_make_dirty", 351, "make ls %d dirty",},\
/* 0x0101 */{"logical_space.c", "ls_make_dirty", 359, "ls make dirty failed",},\
/* 0x0102 */{"logical_space.c", "ls_make_dirty_done", 371, "ls %d is dirty",},\
/* 0x0103 */{"middle_ls.c", "middle_first_push_done", 234, "middle_first_push_done  %x",},\
/* 0x0104 */{"middle_ls.c", "middle_first_push_func", 249, "middle gc is busy now",},\
/* 0x0105 */{"middle_ls.c", "middle_first_push_func", 261, "start push middle lut to hdtag",},\
/* 0x0106 */{"middle_ls.c", "middle_hdtag_reset", 272, "middle_hdtag_reset",},\
/* 0x0107 */{"middle_ls.c", "middle_hdtag_resync", 285, "middle_hdtag resync",},\
/* 0x0108 */{"middle_ls.c", "middle_ls_lut_recycle", 392, "middle lut dirty %d",},\
/* 0x0109 */{"middle_ls.c", "middle_ls_reconstruction", 445, "mid sn %d",},\
/* 0x010a */{"middle_ls.c", "middle_ls_start", 221, "middle ls rebuild end, sn %d",},\
/* 0x010b */{"system_ls.c", "system_critical_gc", 179, "sys cri GC %d st %d",},\
/* 0x010c */{"system_ls.c", "system_ls_reconstruction", 323, "system sn %d",},\
/* 0x010d */{"system_ls.c", "system_ls_start", 169, "system ls rebuild end, sn %d",},\
/* 0x010e */{"user_ls.c", "user_convert_done", 1165, "remove %d - %d %d",},\
/* 0x010f */{"user_ls.c", "user_convert_done_notify", 1092, "cvrt done->%d-%d spb %d(%d)",},\
/* 0x0110 */{"user_ls.c", "user_ls_dump", 1662, "sn %d f %x fc.gc.perf %d",},\
/* 0x0111 */{"user_ls.c", "user_ls_dump", 1672, "aspb[%d][0] id %d fence %d p %d",},\
/* 0x0112 */{"user_ls.c", "user_ls_dump", 1676, "aspb[%d][1] id %d fence %d p %d",},\
/* 0x0113 */{"user_ls.c", "user_ls_dump", 1680, "rdy_spb[%d]:%d",},\
/* 0x0114 */{"user_ls.c", "user_ls_spb_allocator", 698, "alloc %d for [%d][%d]",},\
/* 0x0115 */{"user_ls.c", "user_ls_spb_notify_cb", 769, "spb_id %d sn %d",},\
/* 0x0116 */{"user_ls.c", "user_ls_start", 400, "sn:0x%x flag:0x%x",},\
/* 0x0117 */{"user_ls.c", "user_ls_start", 406, "spb id:0x%x fence:0x%x(%d) wr ptr:0x%x",},\
/* 0x0118 */{"user_ls.c", "user_ls_start", 417, "release backup spb %d",},\
/* 0x0119 */{"user_ls.c", "user_ls_start", 424, "ready spb:0x%x",},\
/* 0x011a */{"user_ls.c", "user_ls_start", 444, "trim lba:0x%x count:0x%x range idx:0x%x sn:0x%x",},\
/* 0x011b */{"user_ls.c", "user_ls_start", 474, "user rebuild start, sn %d",},\
/* 0x011c */{"user_ls.c", "user_ls_start", 476, "user rebuild end, sn %d",},\
/* 0x011d */{"user_ls_flush.c", "user_pad_cmpl", 640, "ls %d is dirty",},\
/* 0x011e */{"user_ls_recon.c", "user_ls_reconstruction", 530, "user sn %d",},\
/* 0x011f */{"user_ls_recon.c", "user_recon_insert_map", 621, "lda %d skip %x by %x",},\
/* 0x0120 */{"user_ls_recon.c", "usre_ls_recon_pga", 437, "spb 0x%x full, fence 0x%x max wptr 0x%x",},\
/* 0x0121 */{"user_ls_recon.c", "usre_ls_recon_pga", 470, "spb 0x%x df_cnt %d",},\
/* 0x0122 */{"user_ls_recon.c", "usre_ls_recon_pga", 478, "spb 0x%x erase page start 0x%x fence 0x%x bkp 0x%x",},\
/* 0x0123 */{"user_ls_trim.c", "user_trim_recon", 1471, "user sn %d",},\
/* 0x0124 */{"lut.c", "l2pp_fast_load_done", 1660, "fast op %p aborted",},\
/* 0x0125 */{"lut.c", "l2pp_load_done", 1532, "lut %d l2pp %d aborted",},\
/* 0x0126 */{"lut.c", "l2pp_single_load_done", 1710, "lut %d s l2pp %d",},\
/* 0x0127 */{"lut.c", "lut_dump", 1031, "ap_id %d f %x fl_cmd_c %d l_c_c %d",},\
/* 0x0128 */{"lut.c", "lut_fast_transaction_id_check", 512, "tid too old %d, %d",},\
/* 0x0129 */{"lut.c", "lut_load_l2pps", 1273, "ls %d lut nrm load cnt %d",},\
/* 0x012a */{"lut.c", "lut_load_l2pps", 1288, "no mem to load l2pp %d",},\
/* 0x012b */{"lut.c", "lut_op_push", 1120, "lut %d op push load %d, again %d",},\
/* 0x012c */{"lut.c", "lut_save_l2pps", 1959, "no ctx to flush l2pp",},\
/* 0x012d */{"lut.c", "lut_scan", 391, "to be scanned count %d, idx %d",},\
/* 0x012e */{"lut.c", "lut_scan_lists", 947, "lut scan %d/%d",},\
/* 0x012f */{"lut.c", "lut_scan_load", 808, "scan load %d %x",},\
/* 0x0130 */{"lut.c", "lut_single_lookup_list", 714, "pend to single l2pp %d",},\
/* 0x0131 */{"lut.c", "lut_single_lookup_list", 770, "pend single %x req %x l2pp %x",},\
/* 0x0132 */{"lut.c", "lut_transaction_id_check", 531, "tid too old %d, %d",},\
/* 0x0133 */{"lut.c", "lut_transaction_id_check", 543, "[%d] %x from umt",},\
/* 0x0134 */{"lut.c", "lut_transaction_id_check", 573, "[%d] %x from hmb",},\
/* 0x0135 */{"lut.c", "lut_update_lists", 1801, "update blocked",},\
/* 0x0136 */{"lut_cache.c", "lut_cache_clr_low_wm", 233, "set lut cahce high wm %d",},\
/* 0x0137 */{"lut_cache.c", "lut_cache_gc_urgt", 607, "Recycle dirty lut to meet demands",},\
/* 0x0138 */{"lut_cache.c", "lut_cache_recycle_to_minimal", 621, "set reserved_thr to %d total_dtag_cnt %d",},\
/* 0x0139 */{"lut_cache.c", "lut_cache_resume_reserved_to_high", 629, "resume reserved_thr to %d",},\
/* 0x013a */{"lut_cache.c", "lut_cache_set_low_wm", 227, "set lut cahce low wm %d",},\
/* 0x013b */{"lut_cache.c", "lut_cache_set_minimal", 553, "lut set %d %d -> %d, aval %d",},\
/* 0x013c */{"lut_cache.c", "lut_dtag_usage_dump", 588, "ttl %d, 0:%d, 1:%d, f %x",},\
/* 0x013d */{"ftl.c", "dfs_flush", 2629, "dump_log flag %x size %x",},\
/* 0x013e */{"ftl.c", "ftl_mapping_chk", 840, "L %x errPDA",},\
/* 0x013f */{"ftl.c", "pda_translate", 2716, "pda_translate [pda] [dir], dir(0: FTL_TRANS_WL2LNR, 1: FTL_TRANS_LNR2WL)\n",},\
/* 0x0140 */{"ftl.c", "pda_translate", 2721, "pda_translate [pda] [dir], dir(0: FTL_TRANS_WL2LNR, 1: FTL_TRANS_LNR2WL)\n",},\
/* 0x0141 */{"ftl.c", "pda_translate", 2726, "err pda\n",},\
/* 0x0142 */{"ftl.c", "pda_translate", 2737, "FTL_TRANS_WL2LNR : 0x%x ->0x%x\n",},\
/* 0x0143 */{"ftl.c", "pda_translate", 2745, "FTL_TRANS_LNR2WL : 0x%x ->0x%x\n",},\
/* 0x0144 */{"ftl.c", "set_slc_xlc_mode_main", 2656, "current nand_slc_xlc_mode is %s",},\
/* 0x0145 */{"ftl.c", "set_slc_xlc_mode_main", 2668, "slc_xlc_mode %d",},\
/* 0x0146 */{"ftl.c", "set_slc_xlc_mode_main", 2672, "update nand_slc_xlc_mode %s",},\
/* 0x0147 */{"erase.c", "erase_err_handling", 128, "erase err %x %x",},\
/* 0x0148 */{"read.c", "read_err_handling", 174, "ls %d rd err %d-%x l %x, %x, ctag %d",},\
/* 0x0149 */{"read.c", "read_err_handling", 181, "page %d, type %d, flags: ncl_cmd %x ftl_req %x",},\
/* 0x014a */{"read.c", "read_err_handling", 217, "SPB %d erase %d read cnt %d flag %x",},\
/* 0x014b */{"read.c", "test_read_err_handling", 105, "test_ftl_req(%d) skip pos(%d) by erased",},\
/* 0x014c */{"read.c", "test_read_err_handling", 68, "test_ftl_req(%d) err",},\
/* 0x014d */{"read.c", "test_read_err_handling", 76, "page[%d] info[%d] ovrlmt",},\
/* 0x014e */{"read.c", "test_read_err_handling", 93, "SPB(%d) rd_cnt(%d) NEED RDGC ttl_cnt(%d)",},\
/* 0x014f */{"internal_ls.c", "internal_wait_sys_log_flush", 316, "ls %d wait sys log flush %p",},\
/* 0x0150 */{"internal_ls_write.c", "internal_ls_gc_write_err", 116, "ils %d write error",},\
/* 0x0151 */{"internal_ls_write.c", "internal_ls_write", 99, "Ls_id(%d) is out of system page resource",},\
/* 0x0152 */{"internal_ls_write.c", "internal_ls_write_error", 249, "req %x ils %d write error %x %d",},\
/* 0x0153 */{"internal_ls_write.c", "internal_ls_write_error", 279, "wait for aspb idle",},\
/* 0x0154 */{"internal_ls_write.c", "internal_write_close_spb_flush_done", 207, "remove ils spb %d",},\
/* 0x0155 */{"lock.c", "lock_lock", 176, "%p blocked %d %d",},\
/* 0x0156 */{"lock.c", "lock_unlock", 200, "%p unblock",},\
/* 0x0157 */{"middle_ls_flush.c", "middle_flush_desc_flush", 185, "middle desc dirty flush",},\
/* 0x0158 */{"middle_ls_flush.c", "middle_flush_next_ls_flush_done", 230, "middle flush done",},\
/* 0x0159 */{"middle_ls_write.c", "middle_close_spb_flush", 340, "close middle active spb %d",},\
/* 0x015a */{"middle_ls_write.c", "middle_force_close_spb_flush", 429, "force close m aspb %d",},\
/* 0x015b */{"middle_ls_write.c", "middle_write_get_invalid_lda_cnt", 261, "mid -%d",},\
/* 0x015c */{"system_ls_flush.c", "system_flush_desc_flush", 114, "sys desc dirty flush",},\
/* 0x015d */{"system_ls_flush.c", "system_flush_desc_flush_done", 137, "system flush done",},\
/* 0x015e */{"system_ls_write.c", "system_close_spb_flush", 218, "close system active spb %d",},\
/* 0x015f */{"system_ls_write.c", "system_close_spb_flush", 230, "flush system log",},\
/* 0x0160 */{"system_ls_write.c", "system_force_close_spb_flush", 292, "write err close %d",},\
/* 0x0161 */{"system_ls_write.c", "system_write_err_handling", 259, "aspb idle",},\
/* 0x0162 */{"perf.c", "perf_mon_upd", 74, "new perf %d",},\
/* 0x0163 */{"user_ls.c", "fc_gc_hst_balance", 1456, "unsuspend gc by rdgc",},\
/* 0x0164 */{"user_ls.c", "fc_handler", 1515, "abort weak gc because of too few free spb",},\
/* 0x0165 */{"user_ls.c", "fc_handler", 1610, "wmk %d, perf %d/%d",},\
/* 0x0166 */{"user_ls.c", "user_convert_done_notify", 1122, " wr %d, fence %d",},\
/* 0x0167 */{"user_ls.c", "user_convert_trigger", 1001, "GC need stop %x",},\
/* 0x0168 */{"user_ls.c", "user_convert_trigger", 1032, "spb id:0x%x state:%d wr ptr:0x%x fence:0x%x vc:%d",},\
/* 0x0169 */{"user_ls.c", "user_convert_trigger", 996, "cvrt resume %x",},\
/* 0x016a */{"user_ls.c", "user_ls_flush_desc", 1278, "user sn %d",},\
/* 0x016b */{"user_ls.c", "user_ls_flush_desc", 1302, "> ready_spb[%d] %d",},\
/* 0x016c */{"user_ls.c", "user_ls_flush_desc", 1305, "> [%d][%d] spb %d %d, %d",},\
/* 0x016d */{"user_ls.c", "user_ls_flush_desc", 1315, "=====================S========================",},\
/* 0x016e */{"user_ls.c", "user_ls_flush_desc", 1317, "==============================================",},\
/* 0x016f */{"user_ls.c", "user_ls_flush_desc", 1327, "relase spb %d",},\
/* 0x0170 */{"user_ls.c", "user_ls_flush_desc", 1369, "=====================E========================",},\
/* 0x0171 */{"user_ls.c", "user_ls_flush_desc", 1371, "==============================================",},\
/* 0x0172 */{"user_ls.c", "user_ls_force_flush_rlut_done", 1073, "force close convert",},\
/* 0x0173 */{"user_ls_flush.c", "complete_flush_req", 799, "flush 0 done, %d",},\
/* 0x0174 */{"user_ls_flush.c", "complete_flush_req", 802, "flush keep dirty %d",},\
/* 0x0175 */{"user_ls_flush.c", "user_flush", 199, "skip usr flush, spb %x st %d integ_fence_pda %x, write_ptr %x risk %d",},\
/* 0x0176 */{"user_ls_flush.c", "user_flush", 243, "user flags %x %x %x",},\
/* 0x0177 */{"user_ls_flush.c", "user_flush", 257, "user flush wait for active stripe to be idle",},\
/* 0x0178 */{"user_ls_flush.c", "user_flush", 307, "start WL padding",},\
/* 0x0179 */{"user_ls_flush.c", "user_flush_table", 339, "user flush table start %d %d",},\
/* 0x017a */{"user_ls_flush.c", "user_flush_table", 348, "user/middle/sys are clean, didn't need to flush",},\
/* 0x017b */{"user_ls_flush.c", "user_flush_table", 368, "skip usr flush, spb %x st %d integ_fence_pda %x, write_ptr %x risk %d",},\
/* 0x017c */{"user_ls_flush.c", "user_flush_table", 415, "user flags %x %x %x",},\
/* 0x017d */{"user_ls_flush.c", "user_flush_table", 429, "user flush wait for active stripe to be idle",},\
/* 0x017e */{"user_ls_flush.c", "user_flush_table", 443, "skip RLUT, LUT, NEXT LS, and DESC flush",},\
/* 0x017f */{"user_ls_flush.c", "user_flush_write", 510, "type %d Spb %d, Pad from 0x%x to 0x%x, page num %d available_cnt %d",},\
/* 0x0180 */{"user_ls_flush.c", "user_flush_write", 539, "apu free:%d %d, %x %x",},\
/* 0x0181 */{"user_ls_flush.c", "user_flush_write", 548, "rlut:%d / %d, %x %x",},\
/* 0x0182 */{"user_ls_flush.c", "user_pad_cmpl", 647, "All padding done",},\
/* 0x0183 */{"user_ls_raid.c", "_raid_force_close", 1243, "force close meet closed stripe %d %x %x",},\
/* 0x0184 */{"user_ls_raid.c", "_raid_force_close", 1265, "force close %d stripe %x f %x wait prev write %d blk %x",},\
/* 0x0185 */{"user_ls_raid.c", "_raid_force_close", 1274, "gc force close alloc res fail",},\
/* 0x0186 */{"user_ls_raid.c", "_raid_force_idle", 1349, "raid correct is busy, wait",},\
/* 0x0187 */{"user_ls_raid.c", "_raid_force_idle", 1362, "all stripe closed",},\
/* 0x0188 */{"user_ls_raid.c", "_raid_pause", 1401, "raid correct is busy, wait",},\
/* 0x0189 */{"user_ls_raid.c", "_raid_pause", 1415, "wait for raid flying write",},\
/* 0x018a */{"user_ls_raid.c", "chk_stripe_construct", 2022, "alloc dtag fail, only got %d dtag",},\
/* 0x018b */{"user_ls_raid.c", "chk_stripe_construct", 2031, "chk stripe, spb %d page %d",},\
/* 0x018c */{"user_ls_raid.c", "chk_stripe_construct", 2049, "spb %d page %d intlv %d read data fail",},\
/* 0x018d */{"user_ls_raid.c", "chk_stripe_construct", 2069, "spb %d page %d read parity fail",},\
/* 0x018e */{"user_ls_raid.c", "chk_stripe_construct", 2074, "xored meta - parity meta: 0x%x - 0x%x",},\
/* 0x018f */{"user_ls_raid.c", "chk_stripe_finish", 540, "%x f %x resume force close %d cur %x",},\
/* 0x0190 */{"user_ls_raid.c", "du_correct_done", 924, "req 0x%x rc done",},\
/* 0x0191 */{"user_ls_raid.c", "gc_raid_close_sched", 1178, "gc force close resume",},\
/* 0x0192 */{"user_ls_raid.c", "raid_correct_chk_stripe", 724, "pda 0x%x hit stripe 0x%x(pga %d, flag 0x%x, fly_wr %d)",},\
/* 0x0193 */{"user_ls_raid.c", "raid_correct_dtag_evt", 794, "rc dtag evt resume",},\
/* 0x0194 */{"user_ls_raid.c", "raid_correct_get_dtags", 814, "rc try lut_cache_gc_urgt",},\
/* 0x0195 */{"user_ls_raid.c", "raid_correct_get_dtags", 817, "rc wait for dtag",},\
/* 0x0196 */{"user_ls_raid.c", "raid_correct_get_stripe", 783, "reuse stripe 0x%x(spb %d, page %d, fly wr %d, rcv page %d)",},\
/* 0x0197 */{"user_ls_raid.c", "raid_correct_get_uc_pda", 669, "get uc pda 0x%x(org 0x%x)",},\
/* 0x0198 */{"user_ls_raid.c", "raid_correct_push", 1165, "push req 0x%x(flags 0x%x) into rc",},\
/* 0x0199 */{"user_ls_raid.c", "raid_correct_trigger", 1148, "trigger req 0x%x do rc",},\
/* 0x019a */{"user_ls_raid.c", "raid_force_idle_close_cmpl", 1334, "all stripe closed",},\
/* 0x019b */{"user_ls_raid.c", "raid_main", 2086, "para invalid",},\
/* 0x019c */{"user_ls_raid.c", "raid_recon", 1770, "start recon raid of spb %d, ptr %d",},\
/* 0x019d */{"user_ls_raid.c", "raid_recon", 1793, "no open stripe on spb %d(last wr intlv %d)",},\
/* 0x019e */{"user_ls_raid.c", "raid_recon", 1866, "recon stripe on spb %d, page %d, intlv 0 -> %d",},\
/* 0x019f */{"user_ls_raid.c", "raid_recon", 1885, "recon active stripe meet uc error, discard active spb %d",},\
/* 0x01a0 */{"user_ls_raid.c", "read_xor_done", 963, "pda 0x%x correct done, sts %d",},\
/* 0x01a1 */{"user_ls_raid.c", "read_xor_done", 998, "xfer corrected data, ctag %d, off %d, dtag %d",},\
/* 0x01a2 */{"user_ls_raid.c", "replace_parity_lda", 1750, "replace lda in spb %d, intlv %d (pda 0x%x - 0x%x)",},\
/* 0x01a3 */{"user_ls_raid.c", "reset_err_stripe", 1708, "raid reset fail to get req",},\
/* 0x01a4 */{"user_ls_raid.c", "reset_err_stripe", 1715, "get err raid %d, err bmp 0x%x, avail bmp 0x%x",},\
/* 0x01a5 */{"user_ls_raid.c", "reset_err_stripe_done", 1678, "raid %d reset, err bmp 0x%x, avail bmp 0x%x",},\
/* 0x01a6 */{"user_ls_raid.c", "reset_err_stripe_resume", 1664, "raid reset resume",},\
/* 0x01a7 */{"user_ls_raid.c", "stripe_entry_return", 426, "resume force close %d",},\
/* 0x01a8 */{"user_ls_raid.c", "stripe_err_handle", 368, "stripe 0x%x err: flags 0x%x",},\
/* 0x01a9 */{"user_ls_raid.c", "stripe_err_handle", 375, "set stripe %d err",},\
/* 0x01aa */{"user_ls_read.c", "is_read_need_resubmit", 374, "req 0x%x pda 0x%x ls_sn 0x%x spb_sn 0x%x ls id %x/%x need re-read",},\
/* 0x01ab */{"user_ls_read.c", "resume_test_read_pending_req", 464, "resume pending host ftl req(%p)",},\
/* 0x01ac */{"user_ls_read.c", "setup_ncl_info_list", 1287, "%d L %x errPDA psag %d",},\
/* 0x01ad */{"user_ls_read.c", "test_read", 701, "get test_ftl_req(%d) ftl_req(%p) caller(%x)",},\
/* 0x01ae */{"user_ls_read.c", "test_read", 705, "pend ftl_req(%p) caller(%x)",},\
/* 0x01af */{"user_ls_read.c", "test_read", 745, "need test bitmap[%x]",},\
/* 0x01b0 */{"user_ls_read.c", "test_read", 768, "submit test_ftl_req(%d) pos(%d)",},\
/* 0x01b1 */{"user_ls_read.c", "test_read", 778, "no submit",},\
/* 0x01b2 */{"user_ls_read.c", "test_read_done", 512, "return test_ftl_req(%d)",},\
/* 0x01b3 */{"user_ls_read.c", "test_read_done", 513, "submit host ftl_req(%p) flag[%x]",},\
/* 0x01b4 */{"user_ls_read.c", "test_read_submit", 549, "spb %d RCT(%d) 2ND_READ PG(%d) PDA[%x]",},\
/* 0x01b5 */{"user_ls_read.c", "user_lookup_pda", 1681, "no req",},\
/* 0x01b6 */{"user_ls_read.c", "user_lookup_pda_done", 1659, "ftl lookup done, lda 0x%x unmap",},\
/* 0x01b7 */{"user_ls_read.c", "user_lookup_pda_done", 1663, "ftl lookup done, lda 0x%x ERR_PDA(UC)",},\
/* 0x01b8 */{"user_ls_read.c", "user_lookup_pda_done", 1667, "ftl lookup done, lda 0x%x liner_pda 0x%x",},\
/* 0x01b9 */{"user_ls_read.c", "user_read_submit_rapid_ncl", 1084, "err lda %x ftl req flag %x",},\
/* 0x01ba */{"user_ls_trim.c", "_trim_range_hit", 272, "lda 0x%x pda 0x%x hit trim %d",},\
/* 0x01bb */{"user_ls_trim.c", "chk_if_blk_trim", 628, "trim 0x%x blocked %d %d %d",},\
/* 0x01bc */{"user_ls_trim.c", "flush_trim_info", 1088, "trim info is saving",},\
/* 0x01bd */{"user_ls_trim.c", "flush_trim_info", 1093, "Wait dtag for flush trim info",},\
/* 0x01be */{"user_ls_trim.c", "flush_trim_info", 1098, "no lda to flush trim",},\
/* 0x01bf */{"user_ls_trim.c", "flush_trim_info", 1110, "fail to get dtag",},\
/* 0x01c0 */{"user_ls_trim.c", "flush_trim_info", 1147, "trim 0x%x(%d) flush to lda %d",},\
/* 0x01c1 */{"user_ls_trim.c", "get_dtag_for_trim_flush", 1067, "fail to get dtag while resume",},\
/* 0x01c2 */{"user_ls_trim.c", "get_dtag_for_trim_flush", 1073, "get dtag OK",},\
/* 0x01c3 */{"user_ls_trim.c", "is_trim_skip_WL", 390, "## SPB Free:%d, free_percent LV:%d\n",},\
/* 0x01c4 */{"user_ls_trim.c", "is_trim_skip_WL", 394, "## Host Trim Enable WL Delay",},\
/* 0x01c5 */{"user_ls_trim.c", "trim_assign_ckpt", 613, "trim ckpt, spb %d, wr_ptr %d, ls_sn %d",},\
/* 0x01c6 */{"user_ls_trim.c", "trim_convert_finish", 936, "all range trim done",},\
/* 0x01c7 */{"user_ls_trim.c", "trim_convert_finish", 939, "trim done[%d], lba:0x%x, cnt:0x%x",},\
/* 0x01c8 */{"user_ls_trim.c", "trim_finish", 859, "ftl trim done(0x%x) st(0x%x)",},\
/* 0x01c9 */{"user_ls_trim.c", "trim_flush_cmpl", 986, "trim 0x%x(%d) flushed %d -> 0x%x",},\
/* 0x01ca */{"user_ls_trim.c", "trim_timer_handler", 1212, "trim %x no ckpt, skip flush",},\
/* 0x01cb */{"user_ls_trim.c", "update_trim_range", 443, "use skip range [0x%x-0x%x] to update trim fence",},\
/* 0x01cc */{"user_ls_trim.c", "update_trim_range", 458, "skip range [0x%x-0x%x]",},\
/* 0x01cd */{"user_ls_trim.c", "user_trim_external", 725, "trim 0x%x resume",},\
/* 0x01ce */{"user_ls_trim.c", "user_trim_flush_all", 1179, "trim %x no ckpt, skip flush",},\
/* 0x01cf */{"user_ls_trim.c", "user_trim_internal", 757, "internal trim block by %x",},\
/* 0x01d0 */{"user_ls_trim.c", "user_trim_recon", 1328, "trim fence[%d]: %d %d [0x%x, 0x%x]",},\
/* 0x01d1 */{"user_ls_trim.c", "user_trim_recon", 1360, "inv trim lda %d old %x, vld %d",},\
/* 0x01d2 */{"user_ls_trim.c", "user_trim_recon", 1369, "found unfinished trim: sn %d at lda %d pda 0x%x",},\
/* 0x01d3 */{"user_ls_trim.c", "user_trim_recon", 1372, "trim range[%d]: [0x%x, 0x%x]",},\
/* 0x01d4 */{"user_ls_trim.c", "user_trim_recon", 1394, "trim recon size > DTAG",},\
/* 0x01d5 */{"user_ls_trim.c", "user_trim_recon", 1402, "No mem for trim recon",},\
/* 0x01d6 */{"user_ls_trim.c", "user_trim_recon", 1406, "Dtag for trim recon %d",},\
/* 0x01d7 */{"user_ls_trim.c", "user_trim_trigger", 484, "switch to high pri trim",},\
/* 0x01d8 */{"user_ls_trim.c", "user_trim_trigger", 493, "restore trim %d",},\
/* 0x01d9 */{"user_ls_trim.c", "user_trim_trigger", 540, "wait to trigger in trim timer",},\
/* 0x01da */{"user_ls_trim.c", "user_trim_trigger", 549, "trim trigger[%d] lba:0x%x, cnt:0x%x",},\
/* 0x01db */{"user_ls_trim.c", "user_trim_trigger", 556, "trim all, nr_lba 0x%x, nr_range %d",},\
/* 0x01dc */{"user_ls_write.c", "comt_queue_return", 712, "return %d du, rptr %d -> %d, wptr %d",},\
/* 0x01dd */{"user_ls_write.c", "get_cur_wr_ctx", 661, "continue write host data to host spb",},\
/* 0x01de */{"user_ls_write.c", "get_cur_wr_pl_info", 531, "Start to write host data to gc dest spb, return cur_du_cnt %d",},\
/* 0x01df */{"user_ls_write.c", "prepare_rewr_req_data", 1186, "Rewrite req %d prog error again!",},\
/* 0x01e0 */{"user_ls_write.c", "prepare_rewr_req_data", 1197, "Rewrite req ctx insert to backup list (insert cnt %d, ofst %d)",},\
/* 0x01e1 */{"user_ls_write.c", "prepare_rewr_req_data", 1200, "Rewrite req ctx backup (backup base %d)",},\
/* 0x01e2 */{"user_ls_write.c", "prepare_rewr_req_data", 1274, "Can't find atomic tail flag, set integ risk [%d -> 1]",},\
/* 0x01e3 */{"user_ls_write.c", "print_user_ls_info", 3215, "user ls, blk f:0x%x, fc rev:%d",},\
/* 0x01e4 */{"user_ls_write.c", "print_user_ls_info", 3219, "user ls, apu recon:%d free:%d order:%d",},\
/* 0x01e5 */{"user_ls_write.c", "recover_rewr_req_data_from_hmb_buffer", 1140, "Discard tail invalid lda.",},\
/* 0x01e6 */{"user_ls_write.c", "recover_rewr_req_data_from_hmb_buffer", 1147, "Waiting for pull HMB data!",},\
/* 0x01e7 */{"user_ls_write.c", "recover_rewr_req_data_from_hmb_buffer", 1152, "Waiting for pull HMB data, rewr req ctx flg 0x%x.",},\
/* 0x01e8 */{"user_ls_write.c", "recover_rewr_req_data_from_hmb_buffer", 1159, "Because HDBH disable, so discard current rewrite req data (req id 0x%x)",},\
/* 0x01e9 */{"user_ls_write.c", "reset_cur_wr_ctx_on_active_spb", 737, "spb %d need close in advance",},\
/* 0x01ea */{"user_ls_write.c", "rewr_mgr_get_share_dtag", 1064, "Get share dtag done!",},\
/* 0x01eb */{"user_ls_write.c", "rewr_mgr_put_share_dtag", 1079, "Put share dtag done!",},\
/* 0x01ec */{"user_ls_write.c", "set_usr_nand_w", 2705, "(0) %d %d, (1) %d %d, (H) %d-%d",},\
/* 0x01ed */{"user_ls_write.c", "tbw_cal", 2716, "DWPD0 %d/100, DWPD1 %d/100, year:%d, cell_life:%d",},\
/* 0x01ee */{"user_ls_write.c", "user_cur_wr_flush", 795, "flush cur wr, usr %d pad %d",},\
/* 0x01ef */{"user_ls_write.c", "user_plp_dch", 2860, "PLP-user_plp_dch_blkq",},\
/* 0x01f0 */{"user_ls_write.c", "user_plp_dch", 2877, "PLP-user_plp_dch_dtag",},\
/* 0x01f1 */{"user_ls_write.c", "user_plp_drh", 2931, "cpu1_plp_dtag %d",},\
/* 0x01f2 */{"user_ls_write.c", "user_plp_drh", 2946, "rcv lda %x, ofs %d, nlb %d",},\
/* 0x01f3 */{"user_ls_write.c", "user_plp_drh", 2983, "rcv lda %x, ofs %d, nlb %d",},\
/* 0x01f4 */{"user_ls_write.c", "user_plp_drh", 3004, "insert pre-read Dtag(%d)",},\
/* 0x01f5 */{"user_ls_write.c", "user_rewrite", 1300, "User rewrite start!",},\
/* 0x01f6 */{"user_ls_write.c", "user_rewrite", 1315, "Get rewr req: id %d, ttl_lda %d, blkq_cnt %d",},\
/* 0x01f7 */{"user_ls_write.c", "user_rewrite", 1332, "Discard tail invalid lda. (req id %d, cnt %d)",},\
/* 0x01f8 */{"user_ls_write.c", "user_rewrite", 1340, "Submit rewr req: id %d, start_lda 0x%x, rewr_lda_cnt %d/ttl_wr_du_cnt %d, remaining_lda_cnt %d",},\
/* 0x01f9 */{"user_ls_write.c", "user_rewrite", 1351, "Get rewrite du fail!",},\
/* 0x01fa */{"user_ls_write.c", "user_rewrite", 1360, "User rewrite done!",},\
/* 0x01fb */{"user_ls_write.c", "user_wr2gc_dest", 2581, "need flush %d du ",},\
/* 0x01fc */{"user_ls_write.c", "user_write", 1456, "user io block by %x",},\
/* 0x01fd */{"user_ls_write.c", "user_write", 1518, "rlut entry reserved failed",},\
/* 0x01fe */{"user_ls_write.c", "user_write", 1541, "stripe entry reserved failed",},\
/* 0x01ff */{"user_ls_write.c", "user_write", 1561, "lock fail, just order",},\
/* 0x0200 */{"user_ls_write.c", "user_write_ctx_submit", 2013, "good_pg %d",},\
/* 0x0201 */{"user_ls_write.c", "user_write_done", 1697, "req %x meta was destroyed %d %x %x %x",},\
/* 0x0202 */{"user_ls_write.c", "user_write_done", 1717, "ftl req:0x%x flags 0x%x startpda:0x%x page idx:%d",},\
/* 0x0203 */{"user_ls_write.c", "user_write_done", 1738, "end %d",},\
/* 0x0204 */{"user_ls_write.c", "user_write_done", 1753, "GC trigger convert again",},\
/* 0x0205 */{"user_ls_write.c", "user_write_done", 1767, "GC was stopped, and convert start",},\
/* 0x0206 */{"user_ls_write.c", "user_write_err_handling", 2344, "user write err %x, pda %x-%d, f %x",},\
/* 0x0207 */{"user_ls_write.c", "user_write_err_handling", 2386, "wait for u aspb idle",},\
/* 0x0208 */{"user_ls_write.c", "user_write_err_handling", 2435, "Insert req %d to rewrite queue (ttl lda cnt %d).",},\
/* 0x0209 */{"convert.c", "convert_handle_rd_fail_spb", 354, "HW %x clear pda:%x L %x",},\
/* 0x020a */{"convert.c", "convert_handle_rd_fail_spb", 380, "%x clear pda:%x",},\
/* 0x020b */{"convert.c", "convert_init", 263, "alloc slow mem for valid change buf",},\
/* 0x020c */{"convert.c", "convert_mem_resume", 287, "alloc slow mem for valid change buf",},\
/* 0x020d */{"bg.c", "is_system_idle", 588, "under shutdown, dont resume ugc/trim %d",},\
/* 0x020e */{"gc.c", "_gc_submit", 501, "gc_submit pool %d B/F?%x",},\
/* 0x020f */{"gc.c", "gc_check_and_resume_dtag_evt", 1524, "wake gc from dtag evt",},\
/* 0x0210 */{"gc.c", "gc_cont_dtag_remove_evt", 1277, "gc cont dtag evt %x rm %d",},\
/* 0x0211 */{"gc.c", "gc_cont_dtag_remove_evt", 1281, "gc cont dtag evt ctx %x not found",},\
/* 0x0212 */{"gc.c", "gc_dtag_borrow", 1859, "borrow cnt %d",},\
/* 0x0213 */{"gc.c", "gc_dtag_evt_cb", 1497, "ctx was using %d",},\
/* 0x0214 */{"gc.c", "gc_dtag_evt_cb", 1504, "no GC anymore",},\
/* 0x0215 */{"gc.c", "gc_dtag_return", 1865, "return cnt %d",},\
/* 0x0216 */{"gc.c", "gc_err_lda_found", 1718, "usr ls ttl(%d) good(%d)",},\
/* 0x0217 */{"gc.c", "gc_err_lda_found", 1744, "spb %d dec valid cnt lda %x pda %x",},\
/* 0x0218 */{"gc.c", "gc_finish", 1147, "gc_fsm end",},\
/* 0x0219 */{"gc.c", "gc_finish", 1149, "data moving %d done, %d/%d",},\
/* 0x021a */{"gc.c", "gc_finish", 1160, "valid 0 release",},\
/* 0x021b */{"gc.c", "gc_get_dtag_resource", 1577, "user GC suspend by dtag %d",},\
/* 0x021c */{"gc.c", "gc_get_dtag_resource", 1624, "gc extra get %d",},\
/* 0x021d */{"gc.c", "gc_get_resource", 713, "gc suspend, ls_id %d req %x spb %d",},\
/* 0x021e */{"gc.c", "gc_priority_schedule", 1476, "GC pri schedule %d",},\
/* 0x021f */{"gc.c", "gc_priority_suspend", 1455, "GC pri wait for %d suspend",},\
/* 0x0220 */{"gc.c", "gc_priority_suspend", 1461, "GC pri wait %d",},\
/* 0x0221 */{"gc.c", "gc_read", 775, "abort gc because met weak spb %d %d",},\
/* 0x0222 */{"gc.c", "gc_read", 785, "abort running bgc pool %d spb %d",},\
/* 0x0223 */{"gc.c", "gc_read", 790, "user gc need to be suspend",},\
/* 0x0224 */{"gc.c", "gc_read_err_handling", 1648, "gc rd err[%d] 0x%x %d spb id:0x%x",},\
/* 0x0225 */{"gc.c", "gc_read_err_handling", 1685, "gc RR ok!",},\
/* 0x0226 */{"gc.c", "gc_reset_err_buf", 1782, "FATAL: reset err buf [%d](%d) L %x P %x",},\
/* 0x0227 */{"gc.c", "gc_transfer", 1025, "%d suspend by priority",},\
/* 0x0228 */{"gc.c", "gc_transfer", 1035, "gc suspend, ls_id %d req %x spb %d areq %d",},\
/* 0x0229 */{"gc.c", "gc_transfer", 1050, "uGC(%d) suspend by bc",},\
/* 0x022a */{"gc.c", "gc_transfer", 1070, "GC was suspend %d",},\
/* 0x022b */{"gc.c", "gc_write", 937, "GC real write count = 0",},\
/* 0x022c */{"gc.c", "gc_write_done", 1251, "gc try extra %d %d %x",},\
/* 0x022d */{"middle_ls_gc.c", "middle_build_write_lda_list", 664, "mid gc write aborted",},\
/* 0x022e */{"middle_ls_gc.c", "middle_build_write_lda_list", 691, "middle skipped %x for l %d",},\
/* 0x022f */{"middle_ls_gc.c", "middle_build_write_lda_list", 697, "middle skipped %x for l %d",},\
/* 0x0230 */{"middle_ls_gc.c", "middle_fast_gc_scan_bitmap", 416, "GC %d lut chk changed %d %x ",},\
/* 0x0231 */{"middle_ls_gc.c", "middle_fast_gc_scan_bitmap", 441, "skip rlsd spb 0x%x rlut",},\
/* 0x0232 */{"middle_ls_gc.c", "middle_fast_gc_scan_bitmap", 490, "skip rlsd spb 0x%x rlut",},\
/* 0x0233 */{"middle_ls_gc.c", "middle_gc_done", 718, "data moving %d done",},\
/* 0x0234 */{"middle_ls_gc.c", "middle_gc_init", 236, "middle GC valid bitmap is from cpu1 btcm",},\
/* 0x0235 */{"middle_ls_gc.c", "middle_gc_init", 239, "middle GC valid bitmap: fast %d bytes @ %x, slow %d bytes @ %x",},\
/* 0x0236 */{"middle_ls_gc.c", "middle_gc_init", 273, "middle GC valid bitmap is from cpu1 btcm",},\
/* 0x0237 */{"middle_ls_gc.c", "middle_gc_init", 275, "middle GC valid bitmap: bytes %d bytes @ %x",},\
/* 0x0238 */{"middle_ls_gc.c", "middle_gc_scan_err_pda", 782, "err pda %x, found pda %x start %d i %d j %d",},\
/* 0x0239 */{"middle_ls_gc.c", "middle_gc_start_data_move", 574, "data moving %d",},\
/* 0x023a */{"middle_ls_gc.c", "middle_gc_start_data_move", 581, "mgc finish",},\
/* 0x023b */{"middle_ls_gc.c", "middle_ls_gc", 349, "middle GC %d",},\
/* 0x023c */{"system_ls_gc.c", "system_build_write_lda_list", 169, "sys gc write aborted",},\
/* 0x023d */{"system_ls_gc.c", "system_build_write_lda_list", 179, "system skip %x for l %d",},\
/* 0x023e */{"system_ls_gc.c", "system_gc_done", 198, "system gc spb %x vld %d, no mapping found!",},\
/* 0x023f */{"system_ls_gc.c", "system_gc_find_err_lda", 236, "sgc error found L %x P %x",},\
/* 0x0240 */{"system_ls_gc.c", "system_ls_gc", 112, "system GC %d",},\
/* 0x0241 */{"user_ls_gc.c", "user_build_rd_plist", 1376, "GC stop flag was detected",},\
/* 0x0242 */{"user_ls_gc.c", "user_build_rd_plist", 1396, "gc first read",},\
/* 0x0243 */{"user_ls_gc.c", "user_build_rd_plist", 1490, "GC write resource failed",},\
/* 0x0244 */{"user_ls_gc.c", "user_build_wr_llist", 1648, "user err discard P %x",},\
/* 0x0245 */{"user_ls_gc.c", "user_build_wr_llist", 1684, "user discard l %x %x, %d, %x",},\
/* 0x0246 */{"user_ls_gc.c", "user_build_wr_llist", 1702, "user gc write aborted",},\
/* 0x0247 */{"user_ls_gc.c", "user_build_wr_llist", 1734, "wait for ugc aspb idle",},\
/* 0x0248 */{"user_ls_gc.c", "user_find_err_lda_rlut_read_done", 1841, "read rlut error, i %d ugc->rlut_read_cnt %d",},\
/* 0x0249 */{"user_ls_gc.c", "user_find_err_lda_rlut_read_done", 1863, "found cnt %d L %x for P %x",},\
/* 0x024a */{"user_ls_gc.c", "user_gc_build_vbmp_by_dpe", 939, "GC %d lut chk changed %d %x ",},\
/* 0x024b */{"user_ls_gc.c", "user_gc_check_lut", 783, "rlut scan done",},\
/* 0x024c */{"user_ls_gc.c", "user_gc_check_lut", 804, "reach end %x",},\
/* 0x024d */{"user_ls_gc.c", "user_gc_check_lut", 843, "scanned rlut %d %d",},\
/* 0x024e */{"user_ls_gc.c", "user_gc_data_move_done", 1942, "ugc action %x spb_flag %x vc %d",},\
/* 0x024f */{"user_ls_gc.c", "user_gc_data_move_done", 1953, "GC done index %x",},\
/* 0x0250 */{"user_ls_gc.c", "user_gc_data_move_done", 1966, "unset GC %d",},\
/* 0x0251 */{"user_ls_gc.c", "user_gc_data_move_done", 1998, "GC perf(%d/%d): %d du/%dms, perf(%d/%d)",},\
/* 0x0252 */{"user_ls_gc.c", "user_gc_data_move_done", 2004, "GC time too short",},\
/* 0x0253 */{"user_ls_gc.c", "user_gc_done", 2032, "gc rd fail cnt:%d",},\
/* 0x0254 */{"user_ls_gc.c", "user_gc_done", 2044, "gc req aborted",},\
/* 0x0255 */{"user_ls_gc.c", "user_gc_done", 2056, "ugc %d done, l2pp(%d), vbm(%d), vdm(%d)",},\
/* 0x0256 */{"user_ls_gc.c", "user_gc_get_dtags", 692, "spb %d gc need full scan",},\
/* 0x0257 */{"user_ls_gc.c", "user_gc_get_dtags", 717, "lack of DTAG",},\
/* 0x0258 */{"user_ls_gc.c", "user_gc_lut_scan_action", 1030, "uGC abt %d %d",},\
/* 0x0259 */{"user_ls_gc.c", "user_gc_lut_scan_done", 973, "l2pp_ttl %d, l2pp_off %d, l2pp_cnt %d, rvc %d",},\
/* 0x025a */{"user_ls_gc.c", "user_gc_raid_force_close_cmpl", 2016, "gc stripe force closed",},\
/* 0x025b */{"user_ls_gc.c", "user_gc_read_rlut", 754, "read rlut %d %d",},\
/* 0x025c */{"user_ls_gc.c", "user_gc_rlut_ent_check_done", 896, "skip rlut entry %d(%d)",},\
/* 0x025d */{"user_ls_gc.c", "user_gc_rlut_read_done", 1092, "uGC %d rlut %d err %d, cont by full scan lut",},\
/* 0x025e */{"user_ls_gc.c", "user_gc_rlut_read_done", 1111, "reach last entry %d",},\
/* 0x025f */{"user_ls_gc.c", "user_gc_rlut_read_done", 1127, "scan rlut %d %d",},\
/* 0x0260 */{"user_ls_gc.c", "user_gc_suspend", 611, "alreay suspend",},\
/* 0x0261 */{"user_ls_gc.c", "user_gc_update_err_lda", 1904, "set spb(%d) read fail. wait convert to insert error",},\
/* 0x0262 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1532, "pvbmp cvrt trigger %d",},\
/* 0x0263 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1541, "still wait for cvrt %d",},\
/* 0x0264 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1562, "SPB %d %d %d flags %x",},\
/* 0x0265 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1567, "rd fail SPB %d %d %d",},\
/* 0x0266 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1588, "gc spb 0x%x skip_rst %d (0x%x 0x%x) vcnt(0x%x 0x%x)",},\
/* 0x0267 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1615, "spb %d vcnt %d - %d = %d st %d",},\
/* 0x0268 */{"user_ls_gc.c", "user_gc_vcnt_reset", 1617, "du_overwrite_umt %d du_trimed %d du_write_lock %d",},\
/* 0x0269 */{"user_ls_gc.c", "user_ls_chk_abort_gc", 464, "abort uGC. spb %d",},\
/* 0x026a */{"user_ls_gc.c", "user_ls_gc", 562, "GC mem suspend",},\
/* 0x026b */{"user_ls_gc.c", "user_ls_gc", 580, "user GC wait rlut %d",},\
/* 0x026c */{"user_ls_gc.c", "user_ls_gc_aborted", 2074, "uGC abort %d, (%d/%d)",},\
/* 0x026d */{"user_ls_gc.c", "user_ls_gc_init", 506, "valid bitmap %d",},\
/* 0x026e */{"user_ls_gc.c", "user_ls_gc_suspended", 2088, "uGC suspended. spb %d",},\
/* 0x026f */{"user_ls_gc.c", "user_ls_resume_gc", 436, "ugc(spb %d) was resumed . Only clear flag(0x%x)",},\
/* 0x0270 */{"user_ls_gc.c", "user_ls_resume_gc", 443, "ugc was resumed. Continue to gc spb %d",},\
/* 0x0271 */{"user_ls_gc.c", "user_write_acquire_resource", 1192, "GC umt fail",},\
/* 0x0272 */{"user_ls_gc.c", "user_write_acquire_resource", 1201, "GC rlut entry reserved failed",},\
/* 0x0273 */{"spb_info.c", "spb_info_init", 70, "spb log %d %d",},\
/* 0x0274 */{"spb_info.c", "spb_info_init", 76, "spb log virgin",},\
/* 0x0275 */{"rlut.c", "rlut_decapsulate", 1272, "rlut for spb_id %d",},\
/* 0x0276 */{"rlut.c", "rlut_descapsulate_check", 1293, "spb %d, sn %d, spb chk %d, sn %d, flags 0x%x",},\
/* 0x0277 */{"rlut.c", "rlut_mgr_flush", 1185, "flush rlut %d",},\
/* 0x0278 */{"rlut.c", "rlut_mgr_flush", 1204, "[%d]rlut spb 0x%x ofs 0x%x",},\
/* 0x0279 */{"rlut.c", "rlut_mgr_flush_done", 1362, "rlut flush done %d",},\
/* 0x027a */{"rlut.c", "rlut_mgr_force_flush", 545, "%d has RLUT entry %d in Que",},\
/* 0x027b */{"rlut.c", "rlut_mgr_plp_notify", 1155, "receive plp evt %d",},\
/* 0x027c */{"rlut.c", "rlut_mgr_release_opt_entry", 1142, "release opt entry %p",},\
/* 0x027d */{"rlut.c", "rlut_mgr_set_flush_spb", 1522, "rlut opt %p not set",},\
/* 0x027e */{"rlut.c", "rlut_mgr_unset_flush_spb", 1555, "rlut resume %p",},\
/* 0x027f */{"rlut.c", "rlut_read_check_collision", 1577, "rlut read pending %d %p",},\
/* 0x0280 */{"rlut.c", "rlut_read_done", 1395, "rlut ever rd err. %d %x ",},\
/* 0x0281 */{"rlut.c", "rlut_user_dump", 907, "ru %x avail %d",},\
/* 0x0282 */{"rlut.c", "rlut_user_dump", 909, "Uent %p spbid %d, fil %d, upd %d, %x",},\
/* 0x0283 */{"rlut.c", "rlut_user_dump", 914, "Went %p spbid %d, fil %d, upd %d, %x",},\
/* 0x0284 */{"rlut.c", "rlut_user_flush_remove_active", 1479, "rlut av -%d, %d",},\
/* 0x0285 */{"rlut.c", "rlut_user_flush_rlut", 727, "SPB %d RLUT %d@%d",},\
/* 0x0286 */{"rlut.c", "rlut_user_get_entry", 1092, "spda 0x%x cut %d",},\
/* 0x0287 */{"rlut.c", "rlut_user_recon_full_fill_rlut", 803, "rlut spb %x already full",},\
/* 0x0288 */{"rlut.c", "rlut_user_recon_full_fill_rlut", 809, "rlut spb %x pda 0x%x fill %d, ru aval %d",},\
/* 0x0289 */{"rlut.c", "rlut_user_recon_rlut", 839, "spb 0x%x wait for rlut flush done",},\
/* 0x028a */{"rlut.c", "rlut_user_recon_rlut", 864, "pda 0x%x cross rlut(0x%x, %d) (%d %d)",},\
/* 0x028b */{"rlut.c", "rlut_user_restart", 451, "wait for rlut flush done",},\
/* 0x028c */{"rlut.c", "rlut_user_restart", 457, "opt rlut ent %p",},\
/* 0x028d */{"rlut.c", "rlut_user_restart", 505, "spb %d met rd err, set full scan",},\
/* 0x028e */{"rlut.c", "rlut_user_restart", 525, "SPB %d RLUT %d@%d",},\
/* 0x028f */{"apu.c", "apu_init", 1025, "apu just has half shm elt recn cnt",},\
/* 0x0290 */{"apu.c", "apu_switch", 950, "switch to normal mode",},\
/* 0x0291 */{"rdmp.c", "rdmx_switch", 650, "switch to nrm resource",},\
/* 0x0292 */{"rdmt.c", "rdmt_entry_update", 595, "update err L %d",},\
/* 0x0293 */{"rdmt.c", "rdmx_dump", 893, "free %d order %d",},\
/* 0x0294 */{"rdmt.c", "rdmx_dump", 896, "spb[%d]%d",},\
/* 0x0295 */{"rdmt.c", "rdmx_invalidate", 450, "seq invalid %d",},\
/* 0x0296 */{"seqa.c", "seqa_dump", 390, "seq[%d] l %x p %x, c %d, s %d",},\
/* 0x0297 */{"seqa.c", "seqa_dump", 395, "ins/cvrt/cvrt_end:%d/%d/%d",},\
/* 0x0298 */{"seqa.c", "seqa_lookup", 213, "lda %d: ent(%d) slda %d pda %x cnt %d",},\
/* 0x0299 */{"umt.c", "umt_dump", 351, "UMT f %x l_cnt %d ",},\
/* 0x029a */{"umt.c", "umt_dump", 355, " aspb[%d] fence %d",},\
/* 0x029b */{"umt.c", "umt_err_insert", 150, "insert err L %x %d",},\
/* 0x029c */{"reconstruction.c", "determine_scan_sequence", 317, "determine sequence: spb id 0x%x",},\
/* 0x029d */{"reconstruction.c", "recon_check_unit_status", 1125, "status changed 1: %d",},\
/* 0x029e */{"reconstruction.c", "recon_check_unit_status", 1138, "status changed 2",},\
/* 0x029f */{"reconstruction.c", "recon_close_page_allocator", 267, "remove pga spb %d(%d)",},\
/* 0x02a0 */{"reconstruction.c", "recon_det_xlc_scan_page", 1217, "start ptr:0x%x start_wl_pda %x pg type:%x rd cnt:%d pg_check_unit:%d",},\
/* 0x02a1 */{"reconstruction.c", "recon_handle_scan_result", 906, "[%d] lda 0x%x, atomic %d, pda %x",},\
/* 0x02a2 */{"reconstruction.c", "recon_handle_scan_result", 921, "discard [%d]%x io_cnt %d",},\
/* 0x02a3 */{"reconstruction.c", "recon_handle_scan_result", 936, "erased [%d]%x",},\
/* 0x02a4 */{"reconstruction.c", "recon_handle_scan_result", 945, "fail [%d]%x io_cnt %d",},\
/* 0x02a5 */{"reconstruction.c", "recon_scan_page_allocator", 240, "rcrd tbl rptr %d wptr %d",},\
/* 0x02a6 */{"reconstruction.c", "recon_scan_page_allocator", 242, "discard pda 0x%x --- lda 0x%x",},\
/* 0x02a7 */{"reconstruction.c", "recon_scan_rlut", 1045, "spb %d rlut read err",},\
/* 0x02a8 */{"reconstruction.c", "recon_scan_rlut", 1066, "end mark %x",},\
/* 0x02a9 */{"reconstruction.c", "recon_scan_rlut", 1076, "k:%d lda 0x%x pda 0x%x",},\
/* 0x02aa */{"reconstruction.c", "recon_scan_rlut", 1099, "rlut start 0x%x backup start 0x%x",},\
/* 0x02ab */{"reconstruction.c", "recon_scan_spb", 454, "nal_get_interleave() %d",},\
/* 0x02ac */{"reconstruction.c", "recon_scan_spb", 455, "scan SPB 0x%x start ptr 0x%x, vc %d int:%d, df cnt %d, f %x",},\
/* 0x02ad */{"reconstruction.c", "recon_scan_spb", 480, "because of revert, so it's good interleave",},\
/* 0x02ae */{"reconstruction.c", "recon_scan_spb", 482, "it's should be defect interleave",},\
/* 0x02af */{"reconstruction.c", "recon_scan_spb", 496, "partial defect recon scan start plane %d, update start ptr 0x%x, share page cnt %d, type %d",},\
/* 0x02b0 */{"reconstruction.c", "recon_scan_spb", 695, "pda:0x%x 0x%x lda:0x%x info:0x%x",},\
/* 0x02b1 */{"reconstruction.c", "recon_scan_spb", 707, "force erase page start 0x%x status %d",},\
/* 0x02b2 */{"reconstruction.c", "recon_scan_spb", 716, "pda:0x%x 0x%x lda:0x%x info:0x%x",},\
/* 0x02b3 */{"reconstruction.c", "recon_scan_spb", 728, "i:%d pg_check_unit:%d unit_status:%d good_du_cnt %d",},\
/* 0x02b4 */{"reconstruction.c", "recon_scan_spb", 737, "reset last written ptr:0x%x seq %d",},\
/* 0x02b5 */{"reconstruction.c", "recon_scan_spb", 766, "start insert rlut, pda %x/%d, ofs %d",},\
/* 0x02b6 */{"reconstruction.c", "recon_scan_spb", 768, "start insert rlut pda %x",},\
/* 0x02b7 */{"reconstruction.c", "recon_scan_spb", 800, "start ptr:0x%x erase_seq:%d wptr:0x%x sn:0x%x f: %x",},\
/* 0x02b8 */{"reconstruction.c", "recon_scan_spb", 802, "end_ptr 0x%x max_write_ptr %x interleave_page_unit %d last_written_ptr %x",},\
/* 0x02b9 */{"reconstruction.c", "recon_scan_spb", 823, "error last_read_pda",},\
/* 0x02ba */{"reconstruction.c", "recon_scan_spb", 834, "padding 0x%x(%0x)",},\
/* 0x02bb */{"reconstruction.c", "recon_scan_spb", 877, "write_ptr 0x%x max_write_ptr 0x%x",},\
/* 0x02bc */{"user_ls.c", "user_convert_trigger", 962, "user flush rlut %d",},\
/* 0x02bd */{"user_ls.c", "user_ls_chk_aspb", 359, "ready close aspb %d",},\
/* 0x02be */{"user_ls_recon.c", "recon_decide_latest_page", 392, "from 0x%x to 0x%x cur 0x%x st %d",},\
/* 0x02bf */{"user_ls_recon.c", "user_ls_recovery", 147, "[%d]ready spb %d",},\
/* 0x02c0 */{"user_ls_recon.c", "user_recon_write_int", 239, "[%d] lda 0x%x atomic %d src_pda %x dst_pda 0x%x",},\
/* 0x02c1 */{"user_ls_recon.c", "user_recon_write_int", 250, "[slot %d] page_cnt %d spb 0x%x wptr 0x%x",},\
/* 0x02c2 */{"spb_log_flush.c", "spb_log_critical_chk", 147, "spb log critical gc",},\
/* 0x02c3 */{"system_log.c", "sys_log_critical_chk", 531, "system log critical gc",},\
/* 0x02c4 */{"system_log.c", "sys_log_dump", 549, "system log, %d(%d), %d-%d",},\
/* 0x02c5 */{"system_log.c", "sys_log_pages_flush", 742, "Hold on flush %d %d %d",},\
/* 0x02c6 */{"system_log.c", "sys_log_pages_flush", 767, "system log pend",},\
/* 0x02c7 */{"system_log.c", "sys_log_pages_flush", 791, "[%d/%d]%x %x",},\
/* 0x02c8 */{"system_log.c", "sys_log_spb_notify_cb", 695, "system log SPB %d next",},\
/* 0x02c9 */{"system_log.c", "sys_log_spb_notify_cb", 702, "system log resume",},\
/* 0x02ca */{"system_log.c", "sys_log_spb_notify_cb", 706, "sys log virgin boot flush",},\
/* 0x02cb */{"system_log.c", "sys_log_spb_notify_cb", 717, "system log SPB %d ready",},\
/* 0x02cc */{"system_log.c", "sys_log_start", 434, "system log start trigger spb alloc",},\
/* 0x02cd */{"log.c", "log_add_ready_spb", 536, "log ready SPB %d",},\
/* 0x02ce */{"log.c", "log_atomic_check", 375, "log atomic discard %d-%d-%d",},\
/* 0x02cf */{"log.c", "log_atomic_check", 390, "log atomic return page %d",},\
/* 0x02d0 */{"log.c", "log_atomic_check_ex", 413, "log page rd err %d %d %d, %x",},\
/* 0x02d1 */{"log.c", "log_atomic_check_ex", 425, "backup err %d, %x",},\
/* 0x02d2 */{"log.c", "log_atomic_check_ex", 435, "log atomic return page %d, %d/%d",},\
/* 0x02d3 */{"log.c", "log_blk_reconstruction", 261, "latest page %d, blk %d spb %d, error %d",},\
/* 0x02d4 */{"log.c", "log_blk_reconstruction", 300, "sig err, %x %x %x %x",},\
/* 0x02d5 */{"log.c", "log_blk_reconstruction", 313, "ready log SPB %d",},\
/* 0x02d6 */{"log.c", "log_blk_reconstruction", 329, "spb %d recon fail %d",},\
/* 0x02d7 */{"log.c", "log_blk_reconstruction", 349, "log scan start %x",},\
/* 0x02d8 */{"log.c", "log_blk_reconstruction", 358, "%d, %d >start %x",},\
/* 0x02d9 */{"log.c", "log_reconstruction", 213, "discard next %d",},\
/* 0x02da */{"log.c", "log_scan_blk_page", 468, "log scan [%d %d] to [%d %d]",},\
/* 0x02db */{"log.c", "log_scan_blk_page", 478, "scan lut[%d] %x",},\
/* 0x02dc */{"log.c", "log_scan_blk_page", 483, "log page rd err %d %d %d, %x",},\
/* 0x02dd */{"log.c", "log_scan_blk_page", 498, "log page erased",},\
/* 0x02de */{"log.c", "log_spb_reconstruction", 236, "log spb %d is eased SPB",},\
/* 0x02df */{"log.c", "spbs_decide_latest_spb", 562, "spb %d reused",},\
/* 0x02e0 */{"spb_log.c", "spb_log_reconstruction", 108, "spb log flush id is 0",},\
/* 0x02e1 */{"spb_log_flush.c", "spb_log_flush", 199, "spb log pend",},\
/* 0x02e2 */{"spb_log_flush.c", "spb_log_flush_done", 274, "spb log flush err %x, %d",},\
/* 0x02e3 */{"system_log.c", "sys_log_flush_done", 897, "sys log flush err %x, %d",},\
/* 0x02e4 */{"system_log.c", "sys_log_flush_flush_header", 1006, "sys log flush header at %x",},\
/* 0x02e5 */{"ftl_hmb.c", "ftl_hmb_hist_check", 137, "hist[%d] l2pp %d T %d > %d",},\
/* 0x02e6 */{"ftl_hmb.c", "ftl_hmb_push_done", 167, "hmb_in_error = %d, req %x f %x",},\
/* 0x02e7 */{"ftl_hmb.c", "ftl_hmb_req_pend", 203, "hmb req %p pend, idx %d/%d",},\
/* 0x02e8 */{"ftl_hmb.c", "ftl_hmb_req_resume", 278, "hmb error %p",},\
/* 0x02e9 */{"ftl_hmb.c", "ftl_hmb_req_resume", 283, "hmb error %p, wait finish",},\
/* 0x02ea */{"ftl_hmb.c", "ftl_hmb_req_resume", 289, "__hmb req %p pend, idx %d/%d",},\
/* 0x02eb */{"ftl_hmb.c", "ftl_hmb_req_resume", 295, "req %p finished",},\
/* 0x02ec */{"ftl_hmb.c", "hmb_hw_submit", 223, "issue %d hmb push",},\
/* 0x02ed */{"bg.c", "bg_switch_main", 642, "switch bg disable from %d -> %d",},\
/* 0x02ee */{"defect_mgr.c", "grwn_defect_rebuild", 400, "rebuild grown defect %d",},\
/* 0x02ef */{"frb_log.c", "_frb_log_flush", 537, "frb log switch cur %d next %d",},\
/* 0x02f0 */{"frb_log.c", "_frb_log_flush", 592, "frb log flush op %d pg %d at %x, id %d, spb %x sys %x",},\
/* 0x02f1 */{"frb_log.c", "chk_frb_curr_blk", 677, "frb empty cur %d next %d",},\
/* 0x02f2 */{"frb_log.c", "chk_frb_curr_blk", 693, "frb chk cur %d next %d",},\
/* 0x02f3 */{"frb_log.c", "frb_add_defect_main", 1497, " spb %d in not valid",},\
/* 0x02f4 */{"frb_log.c", "frb_boot_virgin", 1428, "force ftl virgin",},\
/* 0x02f5 */{"frb_log.c", "frb_defect_restore", 1399, "force ftl virgin",},\
/* 0x02f6 */{"frb_log.c", "frb_drop_grwn", 1441, "frb drop grown defect",},\
/* 0x02f7 */{"frb_log.c", "frb_drop_sys_log_id", 916, "drop frb sys log id %d %d",},\
/* 0x02f8 */{"frb_log.c", "frb_dump", 1320, "cur/next %d/%d fid %d f %x",},\
/* 0x02f9 */{"frb_log.c", "frb_dump", 1324, "frb ver %d, build %x",},\
/* 0x02fa */{"frb_log.c", "frb_dump", 1328, "next pg %d/%d",},\
/* 0x02fb */{"frb_log.c", "frb_dump", 1331, "system log %d %d",},\
/* 0x02fc */{"frb_log.c", "frb_dump", 1335, "spb log %d %d",},\
/* 0x02fd */{"frb_log.c", "frb_dump", 1339, "grown defect version %d count %d history %d",},\
/* 0x02fe */{"frb_log.c", "frb_dump", 1344, "ftl boot option %x",},\
/* 0x02ff */{"frb_log.c", "frb_erase_callby_vu", 1351, "erase frb can not work SRB MR block",},\
/* 0x0300 */{"frb_log.c", "frb_erase_callby_vu", 1356, "erase frb erase done, sys reset",},\
/* 0x0301 */{"frb_log.c", "frb_erase_main", 1364, "erase frb %d %d",},\
/* 0x0302 */{"frb_log.c", "frb_erase_main", 1367, "erase frb can not work SRB MR block",},\
/* 0x0303 */{"frb_log.c", "frb_erase_main", 1372, "erase frb erase done, sys reset",},\
/* 0x0304 */{"frb_log.c", "frb_header_update_cmpl", 1381, "frb header updated",},\
/* 0x0305 */{"frb_log.c", "frb_log_flush", 477, "frb log flush pend %d with %x",},\
/* 0x0306 */{"frb_log.c", "frb_log_init", 1054, "frb init cap %d GB",},\
/* 0x0307 */{"frb_log.c", "frb_log_recovery", 715, "frb head pg %d, next pg %x, fid %d",},\
/* 0x0308 */{"frb_log.c", "frb_log_recovery", 734, "dtag %x, sig %x, fid %x, type %d",},\
/* 0x0309 */{"frb_log.c", "frb_log_recovery", 742, "ver: %d -> %d, plz upgrade",},\
/* 0x030a */{"frb_log.c", "frb_log_recovery", 749, "Force erase pb %d . %d",},\
/* 0x030b */{"frb_log.c", "frb_log_recovery", 757, "FTL build mismatch %x <-> %x, virgin boot",},\
/* 0x030c */{"frb_log.c", "frb_log_recovery", 780, "grown defect info restart",},\
/* 0x030d */{"frb_log.c", "frb_log_recovery", 788, "frb tbl upgraded Cap",},\
/* 0x030e */{"frb_log.c", "frb_log_recovery", 801, "frb tbl Cap change %d to %d, virgin device",},\
/* 0x030f */{"frb_log.c", "frb_log_set_spare_cnt", 1149, "set spare %d",},\
/* 0x0310 */{"frb_log.c", "frb_log_start", 934, "ftl force virgin boot",},\
/* 0x0311 */{"frb_log.c", "frb_log_start", 943, "give up sys log spb %d %d %d %d",},\
/* 0x0312 */{"frb_log.c", "frb_log_start", 951, "ftl drop grown defect",},\
/* 0x0313 */{"frb_log.c", "frb_log_unmap_chk", 869, "verify frb unmap page fail",},\
/* 0x0314 */{"frb_log.c", "frb_log_update_grwn_def", 1133, "grown defect number max, kick %x %x",},\
/* 0x0315 */{"frb_log.c", "frb_pb_erase", 419, "frb erase pda %x id %d cmpl %x",},\
/* 0x0316 */{"frb_log.c", "frb_restore_update_cmpl", 1390, "frb restore updated",},\
/* 0x0317 */{"frb_log.c", "get_frb_pb_fid", 623, "frb %x, st %d sig %x t %d",},\
/* 0x0318 */{"frb_log.c", "get_frb_pb_fid", 638, "frb 0x%x, st %d rda(0x%x %d %d %d)",},\
/* 0x0319 */{"frb_log.c", "grwn_defect_dump", 1511, "grown defect version %d count %d history %d",},\
/* 0x031a */{"frb_log.c", "grwn_defect_dump", 1518, "grown defect %d, type %d, spb %d, pda %x",},\
/* 0x031b */{"frb_log.c", "set_ftl_capacity", 1461, "ftl capacity update %d %d",},\
/* 0x031c */{"frb_log.c", "sim_rom_find_frb_pos", 1305, "sim rom set fake frb0 at spb %d pd %d",},\
/* 0x031d */{"frb_log.c", "sim_rom_find_frb_pos", 1309, "sim rom set fake frb1 at spb %d pd %d",},\
/* 0x031e */{"frb_log.c", "sim_rom_find_pri_n_sec", 1208, "sim rom search start frb pda %x",},\
/* 0x031f */{"frb_log.c", "sim_rom_find_pri_n_sec", 1227, "sim rom no valid hearder",},\
/* 0x0320 */{"frb_log.c", "sim_rom_find_pri_n_sec", 1231, "sim rom frb valid header pg %x, fid %d",},\
/* 0x0321 */{"frb_log.c", "sim_rom_find_pri_n_sec", 1246, "sim rom pri %d sec %d",},\
/* 0x0322 */{"frb_log.c", "sim_rom_search_frb", 1282, "sim rom no find valid frb",},\
/* 0x0323 */{"frb_log.c", "unmap_pda_update", 1193, "upmap pda at %x,",},\
/* 0x0324 */{"bg.c", "bg_evt_handler", 446, "BGC CHK",},\
/* 0x0325 */{"bg.c", "bg_evt_handler", 456, "NO_BGC",},\
/* 0x0326 */{"bg.c", "bg_evt_handler", 494, "cache dirty, skip bg flush clean",},\
/* 0x0327 */{"bg.c", "bg_evt_handler", 515, "bg done",},\
/* 0x0328 */{"bg.c", "bg_evt_handler", 524, "bg pri %d done",},\
/* 0x0329 */{"bg.c", "bg_st_switch", 395, "bg st chg %d->%d",},\
/* 0x032a */{"bg.c", "bg_timer_handler", 367, "BG ST: 0x%x, BG_DIS: 0x%x",},\
/* 0x032b */{"bg.c", "idle_apst", 195, "enter apst fail 2! %x %x",},\
/* 0x032c */{"bg.c", "idle_apst", 215, "ENTER IDLE_APST",},\
/* 0x032d */{"bg.c", "idle_apst", 216, "L1 SUP: 0x%x L1 STATE: 0x%x",},\
/* 0x032e */{"bg.c", "idle_apst", 259, "DONE EXIT IDLE APST!",},\
/* 0x032f */{"bg.c", "idle_apst", 265, "enter apst fail! %x %x",},\
/* 0x0330 */{"bg.c", "is_L11_L12_enable", 167, "L1.1 or L1.2 enabled",},\
/* 0x0331 */{"bg.c", "wear_level_done", 611, "spb %d wear level done",},\
/* 0x0332 */{"plp_mgr.c", "cache_unmap_dtag_borrow", 127, "PLP-cache_unmap_dtag_borrow",},\
/* 0x0333 */{"plp_mgr.c", "cache_unmap_dtag_borrow", 131, "unmap_dtag exsit",},\
/* 0x0334 */{"plp_mgr.c", "default_host_plp_drh", 1295, "rcv lda %x, ofs %d, nlb %d",},\
/* 0x0335 */{"plp_mgr.c", "plp_fr_data_in", 708, "LDA(0x%x) offset(0x%x) nlb(0x%x) Dtag(%d)",},\
/* 0x0336 */{"plp_mgr.c", "plp_mgr_aspb_update", 954, "plp_mgr_aspb_update_start",},\
/* 0x0337 */{"plp_mgr.c", "plp_mgr_aspb_update", 971, "spb %d wrote cnt %d available cnt %d",},\
/* 0x0338 */{"plp_mgr.c", "plp_mgr_aspb_update", 979, "plp_mgr_aspb_update_End 1 wptr %x",},\
/* 0x0339 */{"plp_mgr.c", "plp_mgr_aspb_update", 984, "spb %d closed f%d",},\
/* 0x033a */{"plp_mgr.c", "plp_mgr_aspb_update", 988, "plp_mgr_aspb_update_End 2",},\
/* 0x033b */{"plp_mgr.c", "plp_mgr_complete", 515, "PLP-Mgr_Complete_Start",},\
/* 0x033c */{"plp_mgr.c", "plp_mgr_complete", 521, "PLP-Mgr_Complete_End",},\
/* 0x033d */{"plp_mgr.c", "plp_mgr_data_collect", 331, "PLP-Mgr_Data_Collect_Start",},\
/* 0x033e */{"plp_mgr.c", "plp_mgr_data_collect", 345, "PLP-CPU1 Merge ucache plp data End",},\
/* 0x033f */{"plp_mgr.c", "plp_mgr_data_collect", 376, "PLP-ttl_wr:%d , cpu1_save_cnt:%d , cpu1_vc:%d",},\
/* 0x0340 */{"plp_mgr.c", "plp_mgr_data_collect", 386, "PLP-Mgr_Data_Collect_End",},\
/* 0x0341 */{"plp_mgr.c", "plp_mgr_data_dispatch", 942, "unhandled mod %d",},\
/* 0x0342 */{"plp_mgr.c", "plp_mgr_data_dispatch", 947, "invalid mod %d",},\
/* 0x0343 */{"plp_mgr.c", "plp_mgr_data_fillup", 205, "require plp but not ready, unsupport!!",},\
/* 0x0344 */{"plp_mgr.c", "plp_mgr_data_flush", 422, "PLP-Mgr_Data_Flush",},\
/* 0x0345 */{"plp_mgr.c", "plp_mgr_data_flush", 437, "PLP-f%x",},\
/* 0x0346 */{"plp_mgr.c", "plp_mgr_data_flush", 456, "ttl %d valid %d from 0x%x to 0x%x",},\
/* 0x0347 */{"plp_mgr.c", "plp_mgr_data_flush", 492, "PLP-%x",},\
/* 0x0348 */{"plp_mgr.c", "plp_mgr_data_flush", 494, "plp_mgr_data_flush_End 2",},\
/* 0x0349 */{"plp_mgr.c", "plp_mgr_data_flush_done", 393, "plp_mgr_data_flush_done_start",},\
/* 0x034a */{"plp_mgr.c", "plp_mgr_data_flush_done", 401, "plp_mgr_data_flush_done_end",},\
/* 0x034b */{"plp_mgr.c", "plp_mgr_data_recovery", 1167, "plp_mgr_data_recovery_start path(%d)",},\
/* 0x034c */{"plp_mgr.c", "plp_mgr_data_recovery", 1169, "plp_mgr_data_recovery End by sys_rdy_flags=%x",},\
/* 0x034d */{"plp_mgr.c", "plp_mgr_data_recovery", 1197, "new spb for next use",},\
/* 0x034e */{"plp_mgr.c", "plp_mgr_data_recovery", 1200, "update desc",},\
/* 0x034f */{"plp_mgr.c", "plp_mgr_data_recovery", 1203, "no plp data",},\
/* 0x0350 */{"plp_mgr.c", "plp_mgr_data_recovery", 1206, "plp_mgr_data_recovery_end",},\
/* 0x0351 */{"plp_mgr.c", "plp_mgr_data_save", 250, "require plp but not ready, unsupport!!",},\
/* 0x0352 */{"plp_mgr.c", "plp_mgr_data_save", 258, "PLP_CPU2_Data_Save_STM_End",},\
/* 0x0353 */{"plp_mgr.c", "plp_mgr_data_scan", 1107, "erased[%d] %x",},\
/* 0x0354 */{"plp_mgr.c", "plp_mgr_data_scan", 1144, "plp_mgr_data_scan_full next wptr %x",},\
/* 0x0355 */{"plp_mgr.c", "plp_mgr_data_scan", 1153, "plp_mgr_data_scan_end",},\
/* 0x0356 */{"plp_mgr.c", "plp_mgr_data_scan", 1158, "spb %d scan sptr %d, erase sptr %d, erase seq %d",},\
/* 0x0357 */{"plp_mgr.c", "plp_mgr_data_scan", 994, "plp_mgr_data_scan_start",},\
/* 0x0358 */{"plp_mgr.c", "plp_mgr_desc_flush", 566, "plp_mgr_desc_flush_start",},\
/* 0x0359 */{"plp_mgr.c", "plp_mgr_desc_flush", 589, "[%d] set spb %d w %d",},\
/* 0x035a */{"plp_mgr.c", "plp_mgr_desc_flush", 594, "plp_mgr_desc_flush_end",},\
/* 0x035b */{"plp_mgr.c", "plp_mgr_desc_flush_cmpl", 615, "plp_mgr_desc_flush_cmpl_start",},\
/* 0x035c */{"plp_mgr.c", "plp_mgr_desc_flush_cmpl", 618, "PLP-Set PRD",},\
/* 0x035d */{"plp_mgr.c", "plp_mgr_desc_flush_cmpl", 622, "plp_mgr_desc_flush_cmpl_end",},\
/* 0x035e */{"plp_mgr.c", "plp_mgr_dsh", 312, "save lda %x ofs %d nlb %d",},\
/* 0x035f */{"plp_mgr.c", "plp_mgr_dump", 547, "plp_mgr_dump_start",},\
/* 0x0360 */{"plp_mgr.c", "plp_mgr_dump", 551, "sn %xh, rdy spb %xh, aspb %x@%x %x@%x",},\
/* 0x0361 */{"plp_mgr.c", "plp_mgr_dump", 558, "plp_mgr_dump_end",},\
/* 0x0362 */{"plp_mgr.c", "plp_mgr_get_resource", 272, "plp_mgr_get_resource_start",},\
/* 0x0363 */{"plp_mgr.c", "plp_mgr_get_resource", 287, "plp_mgr_get_resource_end",},\
/* 0x0364 */{"plp_mgr.c", "plp_mgr_init", 814, "plp_mgr_init Bgn",},\
/* 0x0365 */{"plp_mgr.c", "plp_mgr_init", 844, "plp_mgr_init End",},\
/* 0x0366 */{"plp_mgr.c", "plp_mgr_main", 1393, "sim flush ttl %d start",},\
/* 0x0367 */{"plp_mgr.c", "plp_mgr_main", 1401, "sim mod %d rcv plp evt %d",},\
/* 0x0368 */{"plp_mgr.c", "plp_mgr_notify", 1212, "PLP-Mgr_Notify_Start",},\
/* 0x0369 */{"plp_mgr.c", "plp_mgr_notify", 1225, "PLP-Mgr_Notify_End",},\
/* 0x036a */{"plp_mgr.c", "plp_mgr_register", 923, "plp_mgr_register_start",},\
/* 0x036b */{"plp_mgr.c", "plp_mgr_register", 929, "plp_mgr_register_end",},\
/* 0x036c */{"plp_mgr.c", "plp_mgr_sim_done", 1373, "sim flush ttl %d/%d done",},\
/* 0x036d */{"plp_mgr.c", "plp_mgr_spb_allocator", 628, "plp_mgr_spb_allocator_start",},\
/* 0x036e */{"plp_mgr.c", "plp_mgr_spb_allocator", 653, "plp_mgr_spb_allocator_end",},\
/* 0x036f */{"plp_mgr.c", "plp_mgr_spb_notify_cb", 600, "plp_mgr_spb_notify_cb_start",},\
/* 0x0370 */{"plp_mgr.c", "plp_mgr_spb_notify_cb", 606, "plp ready spb %d, sn %d f:%x",},\
/* 0x0371 */{"plp_mgr.c", "plp_mgr_spb_notify_cb", 609, "plp_mgr_spb_notify_cb_end",},\
/* 0x0372 */{"plp_mgr.c", "plp_mgr_start", 854, "plp_mgr_start Bgn",},\
/* 0x0373 */{"plp_mgr.c", "plp_mgr_start", 864, "plp_mgr.appl reg",},\
/* 0x0374 */{"plp_mgr.c", "plp_mgr_start", 911, "plp_mgr_start End",},\
/* 0x0375 */{"plp_mgr.c", "spb_desc_init", 659, "PLP-spb_desc_init_start",},\
/* 0x0376 */{"plp_mgr.c", "spb_desc_init", 669, "PLP-spb_desc_init_end",},\
};


#define FW_EVID_MAX 1194


#define FW_EVID_STR_FMT { \
/* 0x0000 */{"main.c", "evt_task", 202, "evt_task spun for 10000 iterations, nr %d",},\
/* 0x0001 */{"dtag.c", "_dtag_get", 393, "allocate Dtag(%d) avail(%d)",},\
/* 0x0002 */{"dtag.c", "_dtag_put", 149, "recycle Dtag(%d) avail(%d) evt(%d)",},\
/* 0x0003 */{"dtag.c", "_dtag_put_urgt", 195, "recycle Dtag(%d) avail(%d) evt(%d)",},\
/* 0x0004 */{"dtag.c", "dtag_add", 765, "mem(0x%p) or size(0x%x) should be 4096 align",},\
/* 0x0005 */{"dtag.c", "dtag_add", 782, "mem(0x%p) size(0x%x) #Dtags(%d)",},\
/* 0x0006 */{"dtag.c", "dtag_blackout", 800, "mem %p Dtag[%d] is taken",},\
/* 0x0007 */{"dtag.c", "dtag_blackout", 811, "mem(0x%p) size(0x%x) Blacked out, left #Dtags(%d)",},\
/* 0x0008 */{"dtag.c", "dtag_get_bulk", 716, "allocate Dtag(%d) avail(%d)",},\
/* 0x0009 */{"dtag.c", "dtag_get_cont", 480, "after dtag_gc no suitable dtag for cont",},\
/* 0x000a */{"dtag.c", "dtag_get_cont", 488, "no suitable dtag for cont",},\
/* 0x000b */{"dtag.c", "dtag_get_cont", 516, "cont DTAG %d-%d",},\
/* 0x000c */{"dtag.c", "dtag_get_cont_urgt", 447, "cont DTAG %d-%d",},\
/* 0x000d */{"dtag.c", "dtag_get_urgt", 692, "allocate Dtag(%d) avail(%d)",},\
/* 0x000e */{"dtag.c", "dtag_put_cont", 560, "recycle cont Dtag(%d)-%d avail(%d) evt(%d)",},\
/* 0x000f */{"dtag.c", "dtag_register_evt", 822, "ctx = %p, evt = %d",},\
/* 0x0010 */{"dtag.c", "dtag_remove_evt", 849, "dtag evt ctx %p removed",},\
/* 0x0011 */{"dtag.c", "dtag_remove_evt", 855, "dtag evt ctx %p not found",},\
/* 0x0012 */{"dtag.c", "dtags_main", 1127, "require_bmp(%x) avali(%d) events(%d) wr(%d)",},\
/* 0x0013 */{"dtag.c", "dtags_main", 1133, "lutc(%d/%d) gc(%d/%d)",},\
/* 0x0014 */{"dtag.c", "dtags_print", 1108, "require_bmp(%x) avali(%d) events(%d) wr(%d)",},\
/* 0x0015 */{"dtag.c", "dtags_print", 1114, "lutc(%d/%d) gc(%d/%d)",},\
/* 0x0016 */{"dtag.c", "io_dtag_get", 975, "io dtag %x, -%d, %d/%d",},\
/* 0x0017 */{"bf_mgr.c", "bm_debug_dump", 445, "int sts 0xC0010008 = 0x%x",},\
/* 0x0018 */{"bf_mgr.c", "bm_debug_dump", 446, "nrm 0xC0010108 = 0x%x r/w(0x%x/0x%x)",},\
/* 0x0019 */{"bf_mgr.c", "bm_debug_dump", 447, "par 0xC0010114 = 0x%x r/w(0x%x/0x%x)",},\
/* 0x001a */{"bf_mgr.c", "bm_handle_tcm_com_free", 749, "%x rptr = %d, wptr = %d -> (%d)",},\
/* 0x001b */{"bf_mgr.c", "bm_handle_tcm_update", 699, "%x rptr = %d, wptr = %d -> (%d)",},\
/* 0x001c */{"bf_mgr.c", "bm_hb_dtag_rcyc", 1506, "dtag %d du_ofst %d ctag %d",},\
/* 0x001d */{"bf_mgr.c", "bm_hb_dtag_rcyc", 1511, "dtag_hmb_buf_map[%d] %d req_id %d dtag_cnt_per_req %d cpu_id_in_req %d",},\
/* 0x001e */{"bf_mgr.c", "bm_hb_pull_cancel", 1395, "Get REQ-id=0x%x cpu=%d req_cnt=%d loop=0x%x",},\
/* 0x001f */{"bf_mgr.c", "bm_isr", 1026, "sts = %x",},\
/* 0x0020 */{"bf_mgr.c", "bm_isr", 1063, "hmb_rd_data_back0",},\
/* 0x0021 */{"bf_mgr.c", "bm_isr", 1071, "hmb_rd_data_back1",},\
/* 0x0022 */{"bf_mgr.c", "bm_isr", 1090, "hmb_dtag_err, but there is no rd_err and wr_err",},\
/* 0x0023 */{"bf_mgr.c", "bm_isr", 1095, "hmb rd err, hdtag %x, group %d",},\
/* 0x0024 */{"bf_mgr.c", "bm_isr", 1118, "hmb wr err, hdtag %x, group %d",},\
/* 0x0025 */{"bf_mgr.c", "bm_pop_dtag_llist", 2229, "no support",},\
/* 0x0026 */{"bf_mgr.c", "bm_pop_dtag_llist", 2244, "free count 0x%x",},\
/* 0x0027 */{"bf_mgr.c", "bm_pop_wd_entry_llist", 1275, "no support",},\
/* 0x0028 */{"bf_mgr.c", "bm_pop_wd_entry_llist", 1287, "free count %x",},\
/* 0x0029 */{"bf_mgr.c", "bm_rd_dtag_commit", 462, "Du_ofst(%d) Ctag(%d) Dtag(%d)",},\
/* 0x002a */{"bf_mgr.c", "bm_rd_err_recycle", 643, "recycle err rd ent c(%d) o(%d) d(%d)",},\
/* 0x002b */{"bf_mgr.c", "bm_reset", 1870, "wait bm idle",},\
/* 0x002c */{"bf_mgr.c", "bm_reset", 1886, "reset aurl %d abort wr ent cnt %d, bmq %d",},\
/* 0x002d */{"bf_mgr.c", "bm_reset", 1892, "external dtag %d before pop",},\
/* 0x002e */{"bf_mgr.c", "bm_reset", 1899, "external dtag %d after pop",},\
/* 0x002f */{"bf_mgr.c", "bm_slow_isr", 936, "sram ecc error",},\
/* 0x0030 */{"bf_mgr.c", "bm_slow_isr", 945, "bm data parity error bm_ctrl_sts 0x%x ",},\
/* 0x0031 */{"bf_mgr.c", "bm_slow_isr", 954, "Try to do pcie reset",},\
/* 0x0032 */{"bf_mgr.c", "bm_slow_isr", 975, "HMB dtag %d, table %d NVMe %d",},\
/* 0x0033 */{"bf_mgr.c", "bm_slow_isr", 986, "llist over flow %x",},\
/* 0x0034 */{"bf_mgr.c", "bm_slow_isr", 991, "unhandled ISR sts 0x%x",},\
/* 0x0035 */{"bf_mgr.c", "bm_wait_aurl_idle", 2024, "fr %d rd %d",},\
/* 0x0036 */{"bf_mgr.c", "bm_wait_aurl_idle", 2056, "+fr %d rd %d",},\
/* 0x0037 */{"bf_mgr.c", "bm_wait_radj_idle", 1812, "radj %d",},\
/* 0x0038 */{"bf_mgr.c", "bm_wait_radj_idle", 1829, "radj ent c(%d) o(%d) d(%d)",},\
/* 0x0039 */{"bf_mgr.c", "bm_wait_radj_idle", 1836, "+radj %d",},\
/* 0x003a */{"bf_mgr.c", "bm_wait_radj_idle", 1942, "radj %d",},\
/* 0x003b */{"bf_mgr.c", "bm_wait_radj_idle", 1959, "radj ent c(%d) o(%d) d(%d)",},\
/* 0x003c */{"bf_mgr.c", "bm_wait_radj_idle", 1966, "+radj %d",},\
/* 0x003d */{"bf_mgr.c", "bm_wd_err_recycle", 850, "wr data err cnt:%d",},\
/* 0x003e */{"bf_mgr.c", "bm_wr_data_entry_check", 1255, "ctag %d has WDE %d",},\
/* 0x003f */{"bf_mgr.c", "streaming_share_dtag_get", 2331, "wait loop %d, get cnt %d",},\
/* 0x0040 */{"bf_mgr_dpe.c", "bm_dpe_dump_last_cmd", 697, "last req dump: %d",},\
/* 0x0041 */{"bf_mgr_dpe.c", "bm_dpe_dump_last_cmd", 699, "%x %x %x %x",},\
/* 0x0042 */{"bf_mgr_dpe.c", "bm_data_merge", 217, "dpe ctx about to overflow %d %d",},\
/* 0x0043 */{"bf_mgr_dpe.c", "dpe_rsp_handle", 970, "DPE sts: %d code: %d",},\
/* 0x0044 */{"hmb_bf_mgr.c", "hb_dbg", 904, "hdtag_dbg %d",},\
/* 0x0045 */{"hmb_bf_mgr.c", "hb_dbg", 910, "dtag_dbg %d",},\
/* 0x0046 */{"hmb_bf_mgr.c", "hb_dbg", 921, "Push to hdtag%d-hdtag%d",},\
/* 0x0047 */{"hmb_bf_mgr.c", "hb_hdtag_op", 319, "hb req 0x%x pend",},\
/* 0x0048 */{"hmb_bf_mgr.c", "hb_mem_init", 757, "total hdtag %d ",},\
/* 0x0049 */{"hmb_bf_mgr.c", "hb_pull_done", 825, "pull done hdtag%d - hdtag%d",},\
/* 0x004a */{"hmb_bf_mgr.c", "hb_pull_done", 834, "i %d *ptr %x patten %x ",},\
/* 0x004b */{"hmb_bf_mgr.c", "hb_pull_done", 845, "pull from hdtag%d-hdtag%d",},\
/* 0x004c */{"hmb_bf_mgr.c", "hb_pull_done", 850, "test success. hdtag_dbg.dtag %d",},\
/* 0x004d */{"hmb_bf_mgr.c", "hb_push_done", 864, "push done hdtag%d - hdtag%d",},\
/* 0x004e */{"hmb_bf_mgr.c", "hb_push_done", 874, "pull from hdtag%d-hdtag%d",},\
/* 0x004f */{"hmb_bf_mgr.c", "hb_push_done", 887, "Push to hdtag%d-hdtag%d",},\
/* 0x0050 */{"hmb_bf_mgr.c", "hb_req_callback", 363, "hreq[%d] met error",},\
/* 0x0051 */{"hmb_bf_mgr.c", "hb_req_callback", 373, "Add hreq[%d] retry %d",},\
/* 0x0052 */{"hmb_bf_mgr.c", "hb_req_callback", 398, "hreq[%d] met error",},\
/* 0x0053 */{"hmb_bf_mgr.c", "hb_req_callback", 407, "Add hreq[%d] retry %d",},\
/* 0x0054 */{"hmb_bf_mgr.c", "hb_req_callback", 429, "hb req 0x%x resume",},\
/* 0x0055 */{"hmb_bf_mgr.c", "hb_req_init", 796, "hb req init success. Total req cnt %d",},\
/* 0x0056 */{"hmb_bf_mgr.c", "hdbh_abort_hb_push", 558, "hb running req %d abort",},\
/* 0x0057 */{"hmb_bf_mgr.c", "hdbh_timer_handler", 598, "hdbh sleep, [TIMEOUT]hmb wr queue rptr: %d, wptr: %d",},\
/* 0x0058 */{"hmb_bf_mgr.c", "hdbh_timer_handler", 606, "hdbh sleep, [TIMEOUT]hmb rd queue rptr: %d, wptr: %d",},\
/* 0x0059 */{"hmb_bf_mgr.c", "hdbh_timer_handler", 611, "hb_req[%d], end tm: %d, start tm: %d, timeout: %d",},\
/* 0x005a */{"hmb_bf_mgr.c", "hdbh_timer_handler", 628, "ftl_req[%d], end tm: %d, start tm: %d, timeout: %d",},\
/* 0x005b */{"hmb_bf_mgr.c", "hdbh_timer_handler", 632, "[%d]hmb wr queue rptr: %d, wptr: %d",},\
/* 0x005c */{"hmb_bf_mgr.c", "hdbh_timer_handler", 638, "[%d]hmb rd queue rptr: %d, wptr: %d",},\
/* 0x005d */{"hmb_bf_mgr.c", "hdbh_timer_handler", 648, "hdbh resume",},\
/* 0x005e */{"hmb_bf_mgr.c", "hdbh_timer_handler", 650, "hdbh deep sleep",},\
/* 0x005f */{"hmb_bf_mgr.c", "hdbh_timer_handler", 672, "hdbh resume from deep sleep",},\
/* 0x0060 */{"hmb_bf_mgr.c", "hmb_variable_suspend", 728, "cpu1 mem shortage!",},\
/* 0x0061 */{"ncl.c", "ncl_init", 956, "NCL Init Done",},\
/* 0x0062 */{"ncl.c", "ncl_is_block_factory_defective", 545, "RDA [%x_%x_%x] is defect",},\
/* 0x0063 */{"ncl.c", "ncl_is_pda_factory_defective", 519, "PDA %x is defect[col %x = %x]",},\
/* 0x0064 */{"ncl.c", "ncl_pda_raw_operation", 417, "PDA %x RAW Dump %x_%x_%x_%x",},\
/* 0x0065 */{"ncl.c", "ncl_pda_read", 253, "PDA %x Read Dump %x_%x_%x_%x",},\
/* 0x0066 */{"ncl.c", "ncl_read_pasg_handler", 132, "NCL in-read done Ctag(%d) Du_off(%d) Dtag(%d)",},\
/* 0x0067 */{"ncl.c", "ncl_spb_defect_scan", 614, "SPB %d Blk %d off %d is defect",},\
/* 0x0068 */{"ncl_cmd.c", "<global>", 4192, "timeout %d fcmd",},\
/* 0x0069 */{"ncl_cmd.c", "<global>", 4205, "timeout:fcmd %p id %d req %p",},\
/* 0x006a */{"ncl_cmd.c", "<global>", 4236, "WA: FICU reset",},\
/* 0x006b */{"ncl_cmd.c", "ncl_cmd_acquire_du_tag_ptr", 382, "Dtag ptr is busy, FCMD %d",},\
/* 0x006c */{"ncl_cmd.c", "ncl_cmd_cb2_set_pdone_count", 3743, "copyback early done",},\
/* 0x006d */{"ncl_cmd.c", "ncl_cmd_check_timeout", 4104, "FCMD %d, op %d real timeout, outs %d, %d",},\
/* 0x006e */{"ncl_cmd.c", "ncl_cmd_check_timeout", 4114, "WFCMD %d(%p) timeout, outs %d,%d",},\
/* 0x006f */{"ncl_cmd.c", "ncl_cmd_check_timeout", 4128, "WA: FICU reset",},\
/* 0x0070 */{"ncl_cmd.c", "ncl_cmd_copyback_cmd_split", 3673, "index %d, width %d, len %d",},\
/* 0x0071 */{"ncl_cmd.c", "ncl_cmd_copyback_prog_completion", 3393, "cb prog done",},\
/* 0x0072 */{"ncl_cmd.c", "ncl_cmd_copyback_read_completion", 3529, "cb read done",},\
/* 0x0073 */{"ncl_cmd.c", "ncl_cmd_copyback_read_eh_completion", 3435, "cb %x reread err",},\
/* 0x0074 */{"ncl_cmd.c", "ncl_cmd_copyback_read_eh_completion", 3441, "cb reread good",},\
/* 0x0075 */{"ncl_cmd.c", "ncl_cmd_copyback_read_error_handling", 3486, "cb read err PDA %d: %x",},\
/* 0x0076 */{"ncl_cmd.c", "ncl_cmd_delay_completion", 1933, "delay complete cmd %p op %d, flags %x",},\
/* 0x0077 */{"ncl_cmd.c", "ncl_cmd_dump", 4053, "NCL cmd: %p, op %d",},\
/* 0x0078 */{"ncl_cmd.c", "ncl_cmd_dump", 4064, "PDA %d: %x, type %d, sts %x",},\
/* 0x0079 */{"ncl_cmd.c", "ncl_cmd_err_pda_update", 1175, "PDA[%d] %x, dup read, sts %d",},\
/* 0x007a */{"ncl_cmd.c", "ncl_cmd_err_pda_update", 1212, "CB error, op %d, sts %x",},\
/* 0x007b */{"ncl_cmd.c", "ncl_cmd_err_pda_update", 1223, "PDA[%d] %x error, op %d, st: %x",},\
/* 0x007c */{"ncl_cmd.c", "ncl_cmd_err_pda_update", 1250, "Dont find freq %p err PDA %x, op %d %x %x",},\
/* 0x007d */{"ncl_cmd.c", "ncl_cmd_err_pda_update", 1289, "Try PDA %x - %x",},\
/* 0x007e */{"ncl_cmd.c", "ncl_cmd_handle_rr_pending_list", 1439, "handle running rr",},\
/* 0x007f */{"ncl_cmd.c", "ncl_cmd_handle_rr_pending_list", 1455, "pend rr handle %p %d",},\
/* 0x0080 */{"ncl_cmd.c", "ncl_cmd_mu_qlc_extra_read_eh_completion", 1584, "ext RR sts %d",},\
/* 0x0081 */{"ncl_cmd.c", "ncl_cmd_mu_qlc_extra_read_error_handling", 1663, "qlc extra read err PDA %d: %x",},\
/* 0x0082 */{"ncl_cmd.c", "ncl_cmd_op_issue", 3770, "issue nest",},\
/* 0x0083 */{"ncl_cmd.c", "ncl_cmd_push_read_error_handling", 1049, "Insert %p RR list",},\
/* 0x0084 */{"ncl_cmd.c", "ncl_cmd_raid_parity_out_read_completion", 2713, "raid recovery fail pda %x st %x strp %d ofst %d",},\
/* 0x0085 */{"ncl_cmd.c", "ncl_cmd_read_pages_dispatch", 831, "read pg %d, idx %d cnt %d, pda %x",},\
/* 0x0086 */{"ncl_cmd.c", "ncl_cmd_timeout_dump", 4416, "fcmd %d, jiffies: 0x%x, cmd_list:0x%x 0x%x, 0x%x",},\
/* 0x0087 */{"ncl_cmd.c", "ncl_cmd_timeout_dump", 4422, "pending_cmds_list: %d: %p",},\
/* 0x0088 */{"ncl_cmd.c", "ncl_cmd_timeout_dump", 4428, "rr pending: %d: %p",},\
/* 0x0089 */{"ncl_cmd.c", "ncl_cmd_timeout_dump", 4434, "completion pending: %d: %p",},\
/* 0x008a */{"ncl_cmd.c", "ncl_cmd_timeout_dump", 4445, "timeout:fcmd %p id %d req %p, time %x",},\
/* 0x008b */{"ncl_cmd.c", "plp_handle_done", 4550, "deadloop",},\
/* 0x008c */{"ncl_cmd_simple.c", "ncl_cmd_simple_submit", 353, "op %d err",},\
/* 0x008d */{"ncl_cmd_eh.c", "ncl_eh_cmd_error_handling", 1061, "start RR %p",},\
/* 0x008e */{"ncl_cmd_eh.c", "ncl_eh_complete_orig_cmd", 584, "Done RR %p, PDA %x cost_time %d(u) ret-type-phase %x, cnt_step 0x%x, sts %d",},\
/* 0x008f */{"ncl_cmd_eh.c", "ncl_eh_cont_handling", 814, "process RR %p, idx %d/%d do %d",},\
/* 0x0090 */{"ncl_cmd_eh.c", "ncl_eh_cont_handling", 834, "ERD PDA %x type %d, step %d/%d",},\
/* 0x0091 */{"ncl_cmd_eh.c", "ncl_eh_cont_handling", 854, "ERD PDA %x type %d",},\
/* 0x0092 */{"ncl_cmd_eh.c", "ncl_eh_erd_completion", 371, "ERD OOO, req %p, ERD %d, Orig %d",},\
/* 0x0093 */{"ncl_cmd_eh.c", "ncl_eh_erd_completion", 377, "ERD reread done, req %p, FCMD %d",},\
/* 0x0094 */{"ncl_cmd_eh.c", "ncl_eh_erd_completion", 382, "Start decoding",},\
/* 0x0095 */{"ncl_cmd_eh.c", "ncl_eh_erd_ipi_submit", 291, "ERD IPI pg %d row %x cnt %d",},\
/* 0x0096 */{"ncl_cmd_eh.c", "ncl_eh_erd_ipi_submit", 302, "Start decoding",},\
/* 0x0097 */{"ncl_cmd_eh.c", "ncl_eh_erd_submit", 410, "Enter ERD, row %x, CW %d, rec_CW %d, sts %x",},\
/* 0x0098 */{"ncl_cmd_eh.c", "ncl_eh_erd_submit", 425, "err CW %d, sts %d",},\
/* 0x0099 */{"ncl_cmd_eh.c", "ncl_eh_erd_submit", 461, "Leave ERD",},\
/* 0x009a */{"ncl_cmd_eh.c", "ncl_eh_inc_reread", 322, "Incremental Re-read",},\
/* 0x009b */{"ncl_cmd_eh.c", "ncl_eh_read_completion", 649, "done RR %p, idx %d/%d, idx %d, pda %x sts %d",},\
/* 0x009c */{"ncl_profile.c", "ncl_profile_alloc_dtag", 791, "Profile DTag %d",},\
/* 0x009d */{"ncl_profile.c", "ncl_profile_completion", 436, "profile done",},\
/* 0x009e */{"ncl_profile.c", "ncl_profile_dump", 344, "Profile Item %d OP: %s, %s",},\
/* 0x009f */{"ncl_profile.c", "ncl_profile_dump", 347, "====>\t BS %d KB, Range: %d MB Depth: %d",},\
/* 0x00a0 */{"ncl_profile.c", "ncl_profile_dump", 351, "====>\t IOPS %d Bandwidth %d MB",},\
/* 0x00a1 */{"ncl_profile.c", "ncl_profile_generate_result", 362, "Item %d completed time : %d ms",},\
/* 0x00a2 */{"ncl_profile.c", "ncl_profile_handling", 717, "Start Item %d OP: %s, %s",},\
/* 0x00a3 */{"ncl_profile.c", "ncl_profile_handling", 720, "-->\t BS %d KB, Range: %d MB Depth: %d",},\
/* 0x00a4 */{"ncl_profile.c", "ncl_profile_handling", 740, "\tSPB start %d PDA %x, count %d",},\
/* 0x00a5 */{"ncl_profile.c", "ncl_profile_read_completion", 390, "RD Error %p",},\
/* 0x00a6 */{"ncl_profile.c", "ncl_profile_read_completion", 392, "PDA Error %d: %x",},\
/* 0x00a7 */{"ncl_profile.c", "ncl_profile_spb_erase", 318, "Erase SPB %d",},\
/* 0x00a8 */{"ncl_profile.c", "ncl_profile_test", 615, "Looping...",},\
/* 0x00a9 */{"ncl_console.c", "_ncl_get_tPROG", 579, "No enough dtag %d.",},\
/* 0x00aa */{"ncl_console.c", "_ncl_get_tPROG", 585, "No enough meta",},\
/* 0x00ab */{"ncl_console.c", "eccu_clk_main", 2075, "0: 106, 1: 133, 2: 266, 3: 533",},\
/* 0x00ac */{"ncl_console.c", "eccu_clk_main", 2079, "Not support",},\
/* 0x00ad */{"ncl_console.c", "eccu_clk_main", 2102, "eccu_clk: Error - wrong parameter(%d)",},\
/* 0x00ae */{"ncl_console.c", "eccu_clk_main", 2106, "eccu_clk(%d MHz)",},\
/* 0x00af */{"ncl_console.c", "flash_io_clk_main", 2034, "0: 100, 1: 200, 2: 400, 3: 533, 4: 667",},\
/* 0x00b0 */{"ncl_console.c", "flash_io_clk_main", 2059, "flash_io_clk: Error - wrong parameter(%d)",},\
/* 0x00b1 */{"ncl_console.c", "flash_io_clk_main", 2063, "flash_io_clk(%d MHz)",},\
/* 0x00b2 */{"ncl_console.c", "ncl_console_init", 2296, "NCL Debug Mode Enable",},\
/* 0x00b3 */{"ncl_console.c", "ncl_get_fda", 2386, "PDA 0x%x, type: %d",},\
/* 0x00b4 */{"ncl_console.c", "ncl_get_fda", 2387, "CH %d CE %d Lun %d Plane %d ROW %x",},\
/* 0x00b5 */{"ncl_console.c", "ncl_get_fda", 2390, "block %d page %d du %d(%s)",},\
/* 0x00b6 */{"ncl_console.c", "ncl_get_fda", 2399, "page %d type %d",},\
/* 0x00b7 */{"ncl_console.c", "ncl_page_cache_write", 208, "No enough dtag %d.",},\
/* 0x00b8 */{"ncl_console.c", "ncl_page_cache_write", 214, "No enough meta",},\
/* 0x00b9 */{"ncl_console.c", "ncl_page_write", 113, "write page: row %x, ch %d, ce %d, blk %d, pg %d, cnt %d.",},\
/* 0x00ba */{"ncl_console.c", "ncl_page_write", 117, "write pda was not page align %x, force page alignment.",},\
/* 0x00bb */{"ncl_console.c", "ncl_page_write", 125, "No enough dtag %d.",},\
/* 0x00bc */{"ncl_console.c", "ncl_page_write", 131, "No enough meta",},\
/* 0x00bd */{"ncl_console.c", "ncl_page_write", 183, "wexec t = %d us",},\
/* 0x00be */{"ncl_pmu.c", "ncl_pmu_suspend", 422, "PMU get ENC fail",},\
/* 0x00bf */{"ncl_pmu.c", "ncl_pmu_suspend", 432, "PMU get CMF DEC fail",},\
/* 0x00c0 */{"ncl_read_refresh.c", "ncl_read_refresh_init", 310, "no pda_list",},\
/* 0x00c1 */{"ncl_read_refresh.c", "ncl_read_refresh_init", 316, "no pda_list",},\
/* 0x00c2 */{"tsb_ops.c", "nal_set_tsb_tsv_high_speed", 202, "tsv hs: ch %d ce %d expect: %x, real: %x",},\
/* 0x00c3 */{"tsb_ops.c", "nal_set_tsb_tsv_nand_interface", 166, "tsv inf: ch %d ce %d get: %x",},\
/* 0x00c4 */{"tsb_ops.c", "nal_set_tsb_tsv_nand_interface", 181, "tsv inf: ch %d ce %d expect: %x, real: %x",},\
/* 0x00c5 */{"nal_features.c", "nal_execute_zq_calibration", 175, "ZQ %d/%d/%d Fail",},\
/* 0x00c6 */{"nal_features.c", "nal_get_onfi_timing", 216, "nand timing err: ch %d ce %d, expect: %x, real: %x",},\
/* 0x00c7 */{"nal_features.c", "nal_get_parameter_page", 585, "get param err %d",},\
/* 0x00c8 */{"nal_features.c", "nal_handle_onfi_parameter_page", 349, "Invalid param %x.",},\
/* 0x00c9 */{"nal_features.c", "nal_handle_onfi_parameter_page", 358, "RP CRC err",},\
/* 0x00ca */{"nal_features.c", "nal_handle_toggle_parameter_page", 465, "Invalid param %x.",},\
/* 0x00cb */{"nal_features.c", "nal_handle_toggle_parameter_page", 473, "RP %d CRC err",},\
/* 0x00cc */{"nal_features.c", "nal_handle_toggle_parameter_page", 477, "TSV ignores CRC err",},\
/* 0x00cd */{"nal_features.c", "nal_scan_devices_id", 619, "NAND CH %d force not exists, SS_EVB has odd channel",},\
/* 0x00ce */{"nal_features.c", "nal_scan_devices_id", 643, "NAND CH %d, CE %d (id %x) not exists",},\
/* 0x00cf */{"nal_features.c", "nal_scan_devices_id", 658, "Detected NAND ID:[%x_%x]",},\
/* 0x00d0 */{"nal_features.c", "nal_scan_devices_id", 663, "NAND dev ID error, CH %d, CE %d, ID: %x_%x",},\
/* 0x00d1 */{"nal_features.c", "nal_set_ddr23_conf", 82, "nand ddr conf err: ch %d ce %d expect: %x, real: %x",},\
/* 0x00d2 */{"nal_features.c", "nal_set_drive_strength", 259, "ds err: ch %d ce %d expect: %x, real: %x",},\
/* 0x00d3 */{"nal_features.c", "nal_set_toggle_timing", 145, "TSB ODT err: ch %d ce %d expect: %x, real: %x",},\
/* 0x00d4 */{"nal_init.c", "nal_ce_remapping", 304, "NAND CH %d's CE remapping",},\
/* 0x00d5 */{"nal_init.c", "nal_ce_remapping", 312, "NAND CE %d -> CE %d",},\
/* 0x00d6 */{"nal_init.c", "nal_init", 508, "NAND detection failure!",},\
/* 0x00d7 */{"nal_init.c", "nal_init", 513, "NAND Detection Done, Use %s conf",},\
/* 0x00d8 */{"nal_init.c", "nal_init", 526, "DEV CFG: CH %d,CE %d,LUN %d,PLN %d,BLK %d",},\
/* 0x00d9 */{"nal_init.c", "nal_init", 530, "PG %d, SZ %x, LUN Bit: %d, Plane Bit: %d, BLK SFT %d",},\
/* 0x00da */{"nal_init.c", "nal_init_channel_remapping", 381, "CH remapping %d -> %d",},\
/* 0x00db */{"nal_init.c", "nal_init_device_discovery", 106, "First CH %d",},\
/* 0x00dc */{"nal_init.c", "nal_init_device_discovery", 144, "NAND is CONV TOGGLE.",},\
/* 0x00dd */{"nal_init.c", "nal_init_device_discovery", 178, "Reconf TSV to %x",},\
/* 0x00de */{"nal_init.c", "nal_init_device_discovery", 185, "ch/ce err!",},\
/* 0x00df */{"nal_init.c", "nal_init_device_discovery", 188, "T %d CH %d CE %d!",},\
/* 0x00e0 */{"nal_init.c", "nal_init_geo", 227, "Force reduce blocks to %d(original 1/4).\n",},\
/* 0x00e1 */{"nal_init.c", "nal_init_timing", 284, "fwconfig set nand timing(%d) eccu(%x), nand(%d)",},\
/* 0x00e2 */{"eccu.c", "eccu_dsm_disable", 919, "Page RBER_H: %d, RBER_L: %d, DSM_CW_COUNT: %d, AVG_RBER: %d, MDec: ITER %d",},\
/* 0x00e3 */{"eccu.c", "eccu_du_fmt_id_init", 496, "DU FMT %d par sz %x",},\
/* 0x00e4 */{"eccu.c", "eccu_du_fmt_id_init", 508, "DU sz %x/%x",},\
/* 0x00e5 */{"eccu.c", "eccu_du_fmt_id_init", 515, "DU %d sz error, pg size: %x",},\
/* 0x00e6 */{"eccu.c", "eccu_du_fmt_id_init", 552, "DU sz %x/%x, pad sz %x",},\
/* 0x00e7 */{"eccu.c", "eccu_dump_err_count", 1059, "PDec: ITER %d 0to1: %d, 1to0: %d",},\
/* 0x00e8 */{"eccu.c", "eccu_hw_init", 1007, "ECCU ver: %x",},\
/* 0x00e9 */{"fcmd.c", "fcmd_pda2row", 312, "pda %d %x to %x (%d)",},\
/* 0x00ea */{"fcmd.c", "fcmd_set_ncb_format", 503, "FCMD ID %d(%d) CH %d CE %d lv %d/%d",},\
/* 0x00eb */{"ndcu.c", "ndcu_execute_cmd", 639, "Retry CMD %x failure",},\
/* 0x00ec */{"ndcu.c", "ndcu_execute_cmd", 722, "CMD %x in DDR",},\
/* 0x00ed */{"ndcu.c", "ndcu_execute_cmd", 779, "Retry CMD %x@%d",},\
/* 0x00ee */{"ndcu.c", "ndcu_pull_data", 605, "Mismatch %d, val %x",},\
/* 0x00ef */{"ndcu.c", "ndcu_pull_data", 619, "FIFO is still rdy",},\
/* 0x00f0 */{"ndcu.c", "ndcu_read_data_mode", 957, "Unknown device class",},\
/* 0x00f1 */{"ndcu.c", "ndcu_read_id", 1034, "read ID, CH %d CE %d data[%x %x]",},\
/* 0x00f2 */{"ndcu.c", "ndcu_read_lun_status", 881, "LUN sts failed %x, ch %d, ce %d",},\
/* 0x00f3 */{"ndcu.c", "ndcu_read_onfi_id", 1023, "read ONFI ID, CH %d CE %d, data[%x]",},\
/* 0x00f4 */{"ndcu.c", "ndcu_read_toggle_id", 1012, "read Toggle ID, CH %d CE %d data[%x%x]",},\
/* 0x00f5 */{"ndcu.c", "ndcu_set_high_freq", 250, "Set type %x to %d MHz",},\
/* 0x00f6 */{"ndcu.c", "ndcu_set_timing_mode", 131, "Set Timing to %x, tm %d",},\
/* 0x00f7 */{"ndcu.c", "ndcu_wait_device_ready", 916, "read st failed %x, ch %d, ce %d",},\
/* 0x00f8 */{"ndcu_io.c", "ndcu_erase_slc_blk_demo", 113, "Erase page, ID CH: %d, CE: %d, result: %s",},\
/* 0x00f9 */{"ndcu_io.c", "ndcu_read_slc_page_demo", 159, "Read block, ID CH: %d, CE: %d, result: %s, data %x",},\
/* 0x00fa */{"ndcu_io.c", "ndcu_wait_io_ready", 73, "read st failed %x",},\
/* 0x00fb */{"ndcu_io.c", "ndcu_write_slc_page_demo", 206, "Write page, ID CH: %d, CE: %d, result: %s",},\
/* 0x00fc */{"ndphy.c", "ndcu_phy_init", 803, "NAND PHY init",},\
/* 0x00fd */{"ndphy.c", "ndcu_phy_init", 812, "NAND PHY Done",},\
/* 0x00fe */{"ndphy.c", "ndphy_init_per_ch", 570, "CH %d PHY DLL Lock failed",},\
/* 0x00ff */{"ndphy.c", "ndphy_init_per_ch_dll_lock", 431, "CH %d PHY DLL Lock failed",},\
/* 0x0100 */{"ndphy.c", "ndphy_locking_mode", 471, "set ch %d dll %d, str %d",},\
/* 0x0101 */{"ndphy.c", "ndphy_locking_mode", 473, "ch %d dll fail!",},\
/* 0x0102 */{"ndphy.c", "ndphy_loopback", 758, "NAND PHY loopback for channel %d",},\
/* 0x0103 */{"ndphy.c", "ndphy_loopback", 793, "Ch %d sts: %x",},\
/* 0x0104 */{"ndphy.c", "ndphy_set_phy_dll", 351, "PHY calc CH %d PHY DLL Lock failed",},\
/* 0x0105 */{"ficu.c", "_ficu_cmpl_fcmd_handling", 574, "TODO FICU err %x, sts %x",},\
/* 0x0106 */{"ficu.c", "ficu_clear_fcmd_error", 166, "FCMD err clean fail",},\
/* 0x0107 */{"ficu.c", "ficu_cmds_dump", 587, "FICU sts %x, CNT %x, Unc %x/%x",},\
/* 0x0108 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 324, "FICU ERR: int sts %x, sts1 %x, sts2 %x, dec sts %x",},\
/* 0x0109 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 331, "FCMD ID: %d FIID: %d LUTID: %d, TLC type: %d MP_ERR: %x",},\
/* 0x010a */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 374, "ERR FCMD %p req %p, ous %d",},\
/* 0x010b */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 386, "fcmd %p missing",},\
/* 0x010c */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 391, "ERR col %x(%d), CH %d, dev %d, ROW %x, PDA %x",},\
/* 0x010d */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 398, "NF err, fcmd %d, sts2 %x, power %x",},\
/* 0x010e */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 405, "rd erased err",},\
/* 0x010f */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 409, "rd decoding err",},\
/* 0x0110 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 412, "rd dfu err",},\
/* 0x0111 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 415, "rd raid err",},\
/* 0x0112 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 418, "rd ovlmt err",},\
/* 0x0113 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 421, "rd ncb err",},\
/* 0x0114 */{"ficu.c", "ficu_cmpl_fcmd_error_handling", 448, "wr enc err %x",},\
/* 0x0115 */{"ficu.c", "ficu_fcmd_completion", 125, "fcmd %p missing",},\
/* 0x0116 */{"ficu.c", "ficu_get_finst_lut_id", 199, "FID: %d status: %x LUT_PTR %p",},\
/* 0x0117 */{"ficu.c", "ficu_get_finst_lut_id", 215, "Don't find LUT ID",},\
/* 0x0118 */{"ficu.c", "ficu_mode_disable", 887, "Abort %d CMD",},\
/* 0x0119 */{"ficu.c", "ficu_mode_toggle", 988, "Error %d CMD",},\
/* 0x011a */{"ficu.c", "ficu_wait_sq_ready", 758, "err: full s-%d-queue",},\
/* 0x011b */{"mu_rr.c", "_nand_rr_erd_submit", 352, "ERD req %p, FCMD %d",},\
/* 0x011c */{"mu_rr.c", "nand_rr_erd_submit", 665, "ERD: Step %d, PB type: %d",},\
/* 0x011d */{"mu_rr.c", "nand_set_init_feature", 851, "NandSetFeature Mismatch, CH(%d), CE(%d), addr(0x%x), set_value(0x%x), get_value(0x%x)\n",},\
/* 0x011e */{"mu_rr.c", "nand_set_init_feature", 866, "NandSetFeature Mismatch, CH(%d), CE(%d), addr(0x%x), set_value(0x%x), get_value(0x%x)\n",},\
/* 0x011f */{"mu_rr.c", "nand_set_init_feature", 883, "NandSetFeature Mismatch, CH(%d), CE(%d), addr(0x%x), set_value(0x%x), get_value(0x%x)\n",},\
/* 0x0120 */{"mu_rr.c", "nand_set_init_feature", 918, "NandSetFeature Mismatch, CH(%d), CE(%d), addr(0x%x), set_value(0x%x), get_value(0x%x)\n",},\
/* 0x0121 */{"tsb_rr.c", "_nand_rr_erd_submit", 1384, "ERD req %p, FCMD %d",},\
/* 0x0122 */{"tsb_rr.c", "nand_rr_erd_submit", 1708, "ERD Step %d, PB Type: %d",},\
/* 0x0123 */{"sd_rr.c", "_nand_rr_erd_submit", 1472, "ERD req %p, FCMD %d",},\
/* 0x0124 */{"sd_rr.c", "nand_rr_erd_submit", 1650, "ERD Step %d, PB Type: %d",},\
/* 0x0125 */{"sk_rr.c", "_nand_rr_erd_submit", 279, "ERD req %p, FCMD %d",},\
/* 0x0126 */{"sk_rr.c", "nand_get_sk_vref_setting", 324, "SLC OTP RRT invalid",},\
/* 0x0127 */{"sk_rr.c", "nand_get_sk_vref_setting", 332, "TLC OTP RRT invalid",},\
/* 0x0128 */{"sk_rr.c", "nand_rr_erd_submit", 680, "ERD Step %d, PB Type: %d",},\
/* 0x0129 */{"sd_rr.c", "nand_set_init_feature", 1716, "NandSetFeature Mismatch, CH(%d), CE(%d), addr(0x%x), set_value(0x%x), get_value(0x%x)",},\
/* 0x012a */{"ymtc_rr.c", "_nand_rr_erd_submit", 891, "ERD req %p, FCMD %d",},\
/* 0x012b */{"ymtc_rr.c", "nand_rr_erd_submit", 948, "ERD: Step %d, PB type: %d",},\
/* 0x012c */{"ymtc_rr.c", "nand_set_init_feature", 1028, "NandSetFeature Mismatch, CH(%d), CE(%d), addr(0x%x), set_value(0x%x), get_value(0x%x)",},\
/* 0x012d */{"admin_cmd.c", "_nvmet_admin_cmd_done", 5609, "admin req aborted",},\
/* 0x012e */{"admin_cmd.c", "_nvmet_admin_cmd_done", 5632, "admin req %x aborted",},\
/* 0x012f */{"admin_cmd.c", "check_vsc_sig", 1787, "signature mismatch",},\
/* 0x0130 */{"admin_cmd.c", "hmb_switch", 5954, "HMB %d -> %d, plz reboot your system\n",},\
/* 0x0131 */{"admin_cmd.c", "hostMemRd_Callback", 6002, "Read finish",},\
/* 0x0132 */{"admin_cmd.c", "hostMemRd_Callback", 6004, "But DMA Read Error",},\
/* 0x0133 */{"admin_cmd.c", "hostMemRd_Callback", 6012, "hmio Finish",},\
/* 0x0134 */{"admin_cmd.c", "hostMemWr", 6049, "PCIe Memory Space is Disable. CfgHdrCmd=0x%x, LTSSM=0x%x",},\
/* 0x0135 */{"admin_cmd.c", "hostMemWr", 6053, "LTSSM state(0x%x)",},\
/* 0x0136 */{"admin_cmd.c", "hostMemWr", 6069, "unsupport state!",},\
/* 0x0137 */{"admin_cmd.c", "hostMemWr", 6093, "Test PRP addr[%x:%x]",},\
/* 0x0138 */{"admin_cmd.c", "hostMemWr", 6096, "Write check start",},\
/* 0x0139 */{"admin_cmd.c", "hostMemWr_Callback", 6024, "Write finish",},\
/* 0x013a */{"admin_cmd.c", "hostMemWr_Callback", 6027, "But DMA Write Error",},\
/* 0x013b */{"admin_cmd.c", "hostMemWr_Callback", 6033, "Read check start",},\
/* 0x013c */{"admin_cmd.c", "nvme_vu_brand_new", 4903, "[Tip] Do a quick erase, Done!",},\
/* 0x013d */{"admin_cmd.c", "nvme_vu_erase_eventlog", 2052, "Event log is writing/flushing",},\
/* 0x013e */{"admin_cmd.c", "nvme_vu_securerase", 5088, "VU_FRB_ERASE",},\
/* 0x013f */{"admin_cmd.c", "nvme_vu_setwp_doqe", 4926, "Set read only flag done, DWord type(%x).",},\
/* 0x0140 */{"admin_cmd.c", "nvme_vu_setwp_doqe", 4930, "Clear read only flag done, DWord type(%x).",},\
/* 0x0141 */{"admin_cmd.c", "nvme_vu_setwp_doqe", 4955, "[Error] Unknown DWord type(%x).",},\
/* 0x0142 */{"admin_cmd.c", "nvmet_abort", 4729, "req (%x) Ctag(%x) Op(%d) exec time (%d)ms",},\
/* 0x0143 */{"admin_cmd.c", "nvmet_abort", 4749, "AER req (%x) Ctag(%x) Op(%d) exec time (%d)ms",},\
/* 0x0144 */{"admin_cmd.c", "nvmet_admin_aer_out", 5810, "Req (%x) AER masked",},\
/* 0x0145 */{"admin_cmd.c", "nvmet_admin_cmd_in", 5714, "req(%x) rslt(%d)",},\
/* 0x0146 */{"admin_cmd.c", "nvmet_admin_xfer_abort", 5347, "req(%x) opc %x aborted",},\
/* 0x0147 */{"admin_cmd.c", "nvmet_admin_xfer_done", 5430, "req(%x) xfered sts=(%d)",},\
/* 0x0148 */{"admin_cmd.c", "nvmet_admin_xfer_done", 5549, "set apst_entry[i].itpt %d, apst_entry[i].itps %d\n",},\
/* 0x0149 */{"admin_cmd.c", "nvmet_admin_xfer_done", 5552, "set itps to not supported ps\n",},\
/* 0x014a */{"admin_cmd.c", "nvmet_admin_xfer_done", 5555, "set itps operation power state\n",},\
/* 0x014b */{"admin_cmd.c", "nvmet_admin_xfer_done", 5558, "set itps to higher PS\n",},\
/* 0x014c */{"admin_cmd.c", "nvmet_alloc_admin_res_for_download", 481, "alloc fail",},\
/* 0x014d */{"admin_cmd.c", "nvmet_asq_handle", 5140, "req:%p Admin opc: %x",},\
/* 0x014e */{"admin_cmd.c", "nvmet_asq_handle", 5156, "DEVICE SELFTEST",},\
/* 0x014f */{"admin_cmd.c", "nvmet_asq_handle", 5160, "BRAND NEW SSD",},\
/* 0x0150 */{"admin_cmd.c", "nvmet_asq_handle", 5167, "SET_FACTCMD",},\
/* 0x0151 */{"admin_cmd.c", "nvmet_asq_handle", 5173, "GET_FACTCMD",},\
/* 0x0152 */{"admin_cmd.c", "nvmet_asq_handle", 5177, "GET_ALL_INFO",},\
/* 0x0153 */{"admin_cmd.c", "nvmet_asq_handle", 5186, "GET_NANDCMD",},\
/* 0x0154 */{"admin_cmd.c", "nvmet_asq_handle", 5190, "GET_DISKCMD",},\
/* 0x0155 */{"admin_cmd.c", "nvmet_asq_handle", 5194, "NVME_OPC_VU_GET_FW_INFO",},\
/* 0x0156 */{"admin_cmd.c", "nvmet_asq_handle", 5198, "NVME_OPC_VU_ERASE_FW_BLK",},\
/* 0x0157 */{"admin_cmd.c", "nvmet_asq_handle", 5202, "NVME_OPC_VU_WARM_REBOOT",},\
/* 0x0158 */{"admin_cmd.c", "nvmet_asq_handle", 5206, "NVME_OPC_VU_SET_DISK_CAPACITY",},\
/* 0x0159 */{"admin_cmd.c", "nvmet_asq_handle", 5210, "NVME_OPC_VU_TEST_CMD_IN",},\
/* 0x015a */{"admin_cmd.c", "nvmet_asq_handle", 5214, "NVME_OPC_VU_SET_WARN_CRI_THRE",},\
/* 0x015b */{"admin_cmd.c", "nvmet_asq_handle", 5227, "NVME_OPC_VU_EVENTLOG_VIRGIN",},\
/* 0x015c */{"admin_cmd.c", "nvmet_asq_handle", 5233, "NVME_OPC_VU_GET_FW_CONFIG",},\
/* 0x015d */{"admin_cmd.c", "nvmet_asq_handle", 5237, "NVME_OPC_VU_FTL_VIRGIN",},\
/* 0x015e */{"admin_cmd.c", "nvmet_asq_handle", 5241, "NVME_OPC_VU_SETDEVICEINFO",},\
/* 0x015f */{"admin_cmd.c", "nvmet_asq_handle", 5245, "NVME_OPC_VU_CMD_F7",},\
/* 0x0160 */{"admin_cmd.c", "nvmet_asq_handle", 5250, "TS_INJECTION CMD",},\
/* 0x0161 */{"admin_cmd.c", "nvmet_asq_handle", 5255, "NVME_OPC_VU_ERRINJECTION",},\
/* 0x0162 */{"admin_cmd.c", "nvmet_asq_handle", 5259, "NVME_OPC_VU_SMARTCLEAN",},\
/* 0x0163 */{"admin_cmd.c", "nvmet_asq_handle", 5263, "NVME_OPC_VU_GET_GRWN_DEFECT",},\
/* 0x0164 */{"admin_cmd.c", "nvmet_asq_handle", 5337, "req: %p Admin opc: %x CE: SCT(%x) SC(%x)",},\
/* 0x0165 */{"admin_cmd.c", "nvmet_create_io_sq", 693, "create I/O SQ (%d) pairs CQ (%d)",},\
/* 0x0166 */{"admin_cmd.c", "nvmet_delete_io_cq", 559, "Delete I/O Completion Queue (%d)",},\
/* 0x0167 */{"admin_cmd.c", "nvmet_delete_io_sq", 631, "Delete I/O Submission Queue (%d)",},\
/* 0x0168 */{"admin_cmd.c", "nvmet_device_selftest", 1019, "Unknown DST cmd type (%x).",},\
/* 0x0169 */{"admin_cmd.c", "nvmet_device_selftest", 1047, "The ctrlr or nvm subsystem already has a dst operation in process.",},\
/* 0x016a */{"admin_cmd.c", "nvmet_device_selftest", 1053, "DST cmd(%d) processing completed: dst_cur_op(%d) .",},\
/* 0x016b */{"admin_cmd.c", "nvmet_feat_get_scp", 4185, "DELL Get Feature",},\
/* 0x016c */{"admin_cmd.c", "nvmet_feat_set_apst", 4233, "apst set to %d, save %d",},\
/* 0x016d */{"admin_cmd.c", "nvmet_feat_set_arbitration", 3212, "Artbration (0x%x) -> (0x%x)",},\
/* 0x016e */{"admin_cmd.c", "nvmet_feat_set_async_event_conf", 3530, "Asynchronous Event Configuration (0x%x) -> (0x%x)",},\
/* 0x016f */{"admin_cmd.c", "nvmet_feat_set_error_recovery", 3555, "Error recovery (0x%x) -> (0x%x)",},\
/* 0x0170 */{"admin_cmd.c", "nvmet_feat_set_host_memory", 3839, "Host Memory Buffer set, MR(%d) EN(%d) size(%d KB)",},\
/* 0x0171 */{"admin_cmd.c", "nvmet_feat_set_host_memory", 3859, "hmblec size(%x) over CPU1 free BTCM(%x)",},\
/* 0x0172 */{"admin_cmd.c", "nvmet_feat_set_host_memory", 3885, "Pull HMDEL %x%x, cnt %d, %d bytes",},\
/* 0x0173 */{"admin_cmd.c", "nvmet_feat_set_number_of_queues", 3193, "Request ncqr/nsqr (%d/%d) and Allocate sq/cq (%d/%d)",},\
/* 0x0174 */{"admin_cmd.c", "nvmet_feat_set_power_management", 3621, "WH (%d )Power State (%d) -> (%d)",},\
/* 0x0175 */{"admin_cmd.c", "nvmet_feat_set_scp", 4211, "DELL Set Feature, SCP set to %d, save %d",},\
/* 0x0176 */{"admin_cmd.c", "nvmet_feat_set_tempture_threshold", 3295, "Tempture Threshold %d(%d) (0x%x) -> (0x%x)",},\
/* 0x0177 */{"admin_cmd.c", "nvmet_feat_set_volatile_wr_cache", 3803, "Volatile Write Cache (0x%x) -> (0x%x)",},\
/* 0x0178 */{"admin_cmd.c", "nvmet_feat_set_write_atomic", 3439, "Write Automic Normal (0x%x) -> (0x%x)",},\
/* 0x0179 */{"admin_cmd.c", "nvmet_firmware_commit", 1650, "Commit slot %d ca:%d nsid:%x",},\
/* 0x017a */{"admin_cmd.c", "nvmet_firmware_commit", 1686, "Commit slot %d ca:%d ",},\
/* 0x017b */{"admin_cmd.c", "nvmet_firmware_image_download", 1726, "NUMD(%d) OFFSET(%d) PRP1(%x) PRP2(%x)",},\
/* 0x017c */{"admin_cmd.c", "nvmet_firmware_image_download", 1739, "download fw NUMD(%d) OFFSET(%d) not 4K alignment",},\
/* 0x017d */{"admin_cmd.c", "nvmet_firmware_image_download", 1757, "alloc amin res fail",},\
/* 0x017e */{"admin_cmd.c", "nvmet_format_done", 2303, "[Tip] Reset the feature to default, Done!",},\
/* 0x017f */{"admin_cmd.c", "nvmet_format_hmb_reset_done", 2275, "hmb reset done",},\
/* 0x0180 */{"admin_cmd.c", "nvmet_format_ns", 2356, "format lbaf %d mset %d pi %d pil %d ses %d",},\
/* 0x0181 */{"admin_cmd.c", "nvmet_format_ns", 2419, "format %x",},\
/* 0x0182 */{"admin_cmd.c", "nvmet_format_resume_blk_req", 2262, "error: resume req not format req(req %x, host-fmt-fls-req %x).",},\
/* 0x0183 */{"admin_cmd.c", "nvmet_free_mr_dtags", 4802, "gc_put_cont_dtags",},\
/* 0x0184 */{"admin_cmd.c", "nvmet_get_dst_log", 971, "Get device self test log page",},\
/* 0x0185 */{"admin_cmd.c", "nvmet_get_feature", 4536, "get feature[%x], %s, NSID=%x",},\
/* 0x0186 */{"admin_cmd.c", "nvmet_get_feature", 4539, "error namespace id %d fid %d",},\
/* 0x0187 */{"admin_cmd.c", "nvmet_get_log_page", 1563, "LID(%d) NUMD(%d) PRP1(%x) PRP2(%x)",},\
/* 0x0188 */{"admin_cmd.c", "nvmet_get_log_page", 1569, "LPOU %x, LPOL %x - over range",},\
/* 0x0189 */{"admin_cmd.c", "nvmet_get_log_page", 1615, "No support %d",},\
/* 0x018a */{"admin_cmd.c", "nvmet_get_lp_health_information", 1247, "smart error %x",},\
/* 0x018b */{"admin_cmd.c", "nvmet_get_lp_log_error", 1118, "Valid(%d) Pos(%d)",},\
/* 0x018c */{"admin_cmd.c", "nvmet_get_lp_smart_information_dell", 4097, "DELL SMART Log",},\
/* 0x018d */{"admin_cmd.c", "nvmet_get_lp_telemetry", 1509, "only support 4K length",},\
/* 0x018e */{"admin_cmd.c", "nvmet_get_lp_telemetry", 1526, "read_dump_data fail",},\
/* 0x018f */{"admin_cmd.c", "nvmet_get_lp_telemetry", 1535, "telemetry %x ava %d",},\
/* 0x0190 */{"admin_cmd.c", "nvmet_identify", 3014, "CNS(%d) NSID(%d) CNTID(%d)",},\
/* 0x0191 */{"admin_cmd.c", "nvmet_identify", 3023, "nvmet_identify: No such controller id %x",},\
/* 0x0192 */{"admin_cmd.c", "nvmet_identify", 3036, "Identify: Invalid namespace (0x%x)",},\
/* 0x0193 */{"admin_cmd.c", "nvmet_identify", 3066, "NSID(%d) isn't Active",},\
/* 0x0194 */{"admin_cmd.c", "nvmet_identify", 3091, "Identify: Invalid namespace (0x%x)",},\
/* 0x0195 */{"admin_cmd.c", "nvmet_identify", 3120, "Identify: (NSL) Invalid namespace (%d)",},\
/* 0x0196 */{"admin_cmd.c", "nvmet_identify", 3156, "Identify: CNS(%d) DMA transfer(%d)",},\
/* 0x0197 */{"admin_cmd.c", "nvmet_map_admin_prp", 406, "wait dtag to xfer prp list",},\
/* 0x0198 */{"admin_cmd.c", "nvmet_prepare_mr_dtags", 4790, "operation fac info wait dtag, req 0x%x",},\
/* 0x0199 */{"admin_cmd.c", "nvmet_prepare_mr_dtags", 4793, "gc_get_cont_dtags success",},\
/* 0x019a */{"admin_cmd.c", "nvmet_queue_sanity_check", 527, "req(%x) qid(%x)",},\
/* 0x019b */{"admin_cmd.c", "nvmet_queue_sanity_check", 535, "req(%x) qsize(%x)",},\
/* 0x019c */{"admin_cmd.c", "nvmet_set_feature", 4304, "set feature[%x], sv=%d, NSID=%x\n",},\
/* 0x019d */{"admin_cmd.c", "nvmet_set_feature", 4307, "error namespace id %d fid %d",},\
/* 0x019e */{"admin_cmd.c", "nvmet_set_spb_info", 1898, "total spb cnt mismatch. should be %d but %d",},\
/* 0x019f */{"admin_cmd.c", "nvmet_set_spb_info", 1902, "total spb cnt match",},\
/* 0x01a0 */{"admin_cmd.c", "set_device_info", 1818, "Invalid option for setting device info!",},\
/* 0x01a1 */{"admin_cmd.c", "set_warn_cri_thre", 1845, "Invalid option for setting warning/critical threshold!",},\
/* 0x01a2 */{"admin_cmd.c", "setfactoryinfo", 4859, "opsetting: %d",},\
/* 0x01a3 */{"core.c", "bool", 292, "NS update cap(%x -> %x), lbads(%d -> %d)",},\
/* 0x01a4 */{"core.c", "core_hang_main", 2848, "curr core_hang sts %d",},\
/* 0x01a5 */{"core.c", "core_hang_main", 2853, "core_hang sts [%d] -> [%d]",},\
/* 0x01a6 */{"core.c", "dell_scp_in", 2495, "dell_scp_in",},\
/* 0x01a7 */{"core.c", "dell_scp_in", 2499, "delay scp handle, remain %d",},\
/* 0x01a8 */{"core.c", "dell_scp_in", 2524, "scp start",},\
/* 0x01a9 */{"core.c", "err_injection_main", 2468, "smart_err_num(%d)\n",},\
/* 0x01aa */{"core.c", "err_injection_main", 2472, "error injection done\n",},\
/* 0x01ab */{"core.c", "fill_lookup_pda_done", 1919, "hmb lookup error",},\
/* 0x01ac */{"core.c", "hmb_lookup_pda", 2805, "start hmb lookup lda 0x%x",},\
/* 0x01ad */{"core.c", "hmb_lookup_pda_done", 2775, "hmb lookup done, miss",},\
/* 0x01ae */{"core.c", "hmb_lookup_pda_done", 2779, "hmb lookup done, unmap",},\
/* 0x01af */{"core.c", "hmb_lookup_pda_done", 2783, "hmb lookup done, ERR_PDA(UC)",},\
/* 0x01b0 */{"core.c", "hmb_lookup_pda_done", 2787, "hmb lookup done, liner_pda %x",},\
/* 0x01b1 */{"core.c", "lookup_pda", 2814, "lkp pda, lda 0x%x from %d",},\
/* 0x01b2 */{"core.c", "nvmet_abort_all_running_reqs", 1486, "[%d] req 0x%p(%d) state(%d) abt #Dtags(%d), rt(%d)",},\
/* 0x01b3 */{"core.c", "nvmet_abort_all_running_reqs", 1516, "all abort wreq 0x%p %d LBA 0x%x%d(%d)",},\
/* 0x01b4 */{"core.c", "nvmet_abort_all_running_reqs", 1536, "bm_free_wr_size %d",},\
/* 0x01b5 */{"core.c", "nvmet_abort_all_running_reqs", 1556, "all abort wreq cnt %d %d %d",},\
/* 0x01b6 */{"core.c", "nvmet_abort_running_req", 497, "abort admin %x opc %x %x",},\
/* 0x01b7 */{"core.c", "nvmet_abort_running_req", 585, "wr %x st %d fua %d xfer done",},\
/* 0x01b8 */{"core.c", "nvmet_abort_running_req", 657, "wait dma done, req 0x%x required %d",},\
/* 0x01b9 */{"core.c", "nvmet_abort_running_req", 664, "trim req 0x%x state %d done in advance",},\
/* 0x01ba */{"core.c", "nvmet_abort_running_req", 695, "no handle op in %p %d %d",},\
/* 0x01bb */{"core.c", "nvmet_aer_error_status", 1762, "SQ(%d) Invalid Queue",},\
/* 0x01bc */{"core.c", "nvmet_aer_smart_health", 1812, "available spare(%d) < thr(%d)",},\
/* 0x01bd */{"core.c", "nvmet_clear_aer", 1254, "abort #(%d) AER commands",},\
/* 0x01be */{"core.c", "nvmet_clear_io_queue", 1287, "Outstanding #AER(%d)",},\
/* 0x01bf */{"core.c", "nvmet_core_cmd_done", 933, "req(%p) Ctags(%d) resubmit ",},\
/* 0x01c0 */{"core.c", "nvmet_core_cmd_done", 978, "req op %d max tm %d ",},\
/* 0x01c1 */{"core.c", "nvmet_core_err_cmd_done", 858, "abort done",},\
/* 0x01c2 */{"core.c", "nvmet_core_err_cmd_done", 874, "ctag err read",},\
/* 0x01c3 */{"core.c", "nvmet_core_err_cmd_done", 877, "ctag err done",},\
/* 0x01c4 */{"core.c", "nvmet_evt_cc_en", 1694, "\033[91mCC.EN (0->1)\x1b[0m",},\
/* 0x01c5 */{"core.c", "nvmet_evt_handle_err_cmd", 1086, "req(%p) Ctags(%d) sts=(0x%x)",},\
/* 0x01c6 */{"core.c", "nvmet_evt_handle_err_cmd", 1097, "slba %d, cnt %d",},\
/* 0x01c7 */{"core.c", "nvmet_evt_handle_err_cmd", 1102, "prp 1 %x %x",},\
/* 0x01c8 */{"core.c", "nvmet_evt_handle_err_cmd", 1107, "prp2 %x %x",},\
/* 0x01c9 */{"core.c", "nvmet_evt_handle_err_cmd", 1111, "PCIE timeout op %d left %d [%x %x]\n",},\
/* 0x01ca */{"core.c", "nvmet_evt_handle_err_cmd", 1119, "cmd err sct 0x%x sc 0x%x",},\
/* 0x01cb */{"core.c", "nvmet_evt_shutdown", 1578, "EVT shutdown",},\
/* 0x01cc */{"core.c", "nvmet_evt_shutdown", 1583, "shutdown abort",},\
/* 0x01cd */{"core.c", "nvmet_evt_shutdown", 1595, "Wait cmpl_q and bm_q empty %x %x",},\
/* 0x01ce */{"core.c", "nvmet_evt_shutdown", 1605, "\033[91mCC.EN (1->0)\x1b[0m, isr %d",},\
/* 0x01cf */{"core.c", "nvmet_evt_shutdown", 1638, "flying shutdown cnt %d",},\
/* 0x01d0 */{"core.c", "nvmet_fe_shutdown_done", 1368, "skip shutdown cb %d flying cnt %d",},\
/* 0x01d1 */{"core.c", "nvmet_hmb_detach", 2117, "1st HMB detach",},\
/* 0x01d2 */{"core.c", "nvmet_hmb_detach", 2135, "2st HMB detach",},\
/* 0x01d3 */{"core.c", "nvmet_plp_done", 2175, "%dms -> DeadLoop",},\
/* 0x01d4 */{"core.c", "nvmet_plp_done", 2181, "deadloop",},\
/* 0x01d5 */{"core.c", "nvmet_plp_done", 2218, "deadloop",},\
/* 0x01d6 */{"core.c", "nvmet_preset_detach", 2257, "preset detach. r1(0x%x), r2(0x%x)",},\
/* 0x01d7 */{"core.c", "nvmet_preset_detach", 2295, "HMB detach by preset",},\
/* 0x01d8 */{"core.c", "nvmet_reqs_dump", 1429, "Running NVM(e) Cmd (%d)",},\
/* 0x01d9 */{"core.c", "nvmet_reqs_dump", 1436, "sq req 0x%p(op %d) state %d ctag %d",},\
/* 0x01da */{"core.c", "nvmet_reqs_dump", 1438, "auto_cpl %d auto_done %d ctag_done %d err %d",},\
/* 0x01db */{"core.c", "nvmet_reqs_dump", 1447, "aborting req 0x%p(op %d) state %d ctag %d",},\
/* 0x01dc */{"core.c", "nvmet_reqs_dump", 1449, "auto_cpl %d auto_done %d ctag_done %d err %d",},\
/* 0x01dd */{"core.c", "nvmet_restore_feat", 355, "def feat used",},\
/* 0x01de */{"core.c", "nvmet_set_factory_info_done", 1183, "Ignore Capacity Change %d GB, max %d",},\
/* 0x01df */{"core.c", "nvmet_set_factory_info_done", 1189, "Set default Capacity %d GB",},\
/* 0x01e0 */{"core.c", "nvmet_set_factory_info_done", 1193, "Capacity Change!! (%d -> %d)GB",},\
/* 0x01e1 */{"core.c", "nvmet_set_factory_info_done", 1205, "SET_FACTINFO_cmpl",},\
/* 0x01e2 */{"core.c", "nvmet_sq_timer_chk", 756, "req 0x%p timeout(%d ms), ctag(%d), op(%d) act(0x%x) cmd_proc 0x%x",},\
/* 0x01e3 */{"core.c", "nvmet_sq_timer_chk", 780, "skip aborting wreq",},\
/* 0x01e4 */{"core.c", "nvmet_sq_timer_chk", 785, "bm_free_wr_size %d",},\
/* 0x01e5 */{"core.c", "nvmet_start_warm_boot", 2393, "abort #(%d) AER commands",},\
/* 0x01e6 */{"core.c", "nvmet_start_warm_boot", 2407, "warm boot disable sq OK",},\
/* 0x01e7 */{"core.c", "scp_shutdown_done", 2485, "scp done. time %d ms",},\
/* 0x01e8 */{"core.c", "send_ltr_to_host", 2831, "send ltr",},\
/* 0x01e9 */{"io_cmd.c", "io_max_main", 1548, "Max I/O requests: %d",},\
/* 0x01ea */{"io_cmd.c", "io_max_main", 1554, "%d shall be less %d",},\
/* 0x01eb */{"io_cmd.c", "io_max_main", 1558, "I/O max requests: (%d -> %d)",},\
/* 0x01ec */{"io_cmd.c", "nvmet_abort_locked_req", 1492, "abort locked req(%d) %p",},\
/* 0x01ed */{"io_cmd.c", "nvmet_abort_pending_req", 1458, "abort pending req(%d) %p",},\
/* 0x01ee */{"io_cmd.c", "nvmet_io_cmd_ex", 1265, "leave due to scp",},\
/* 0x01ef */{"io_cmd.c", "nvmet_io_cmd_ex", 1293, "leave due to scp",},\
/* 0x01f0 */{"io_cmd.c", "nvmet_read_qos", 501, "tgt %d, pnd %d, act %d, CID %d, sts %d",},\
/* 0x01f1 */{"io_cmd.c", "nvmet_setup_discard", 799, "trim ad is zero, complete",},\
/* 0x01f2 */{"io_cmd.c", "nvmet_setup_discard", 807, "trim: lack of dtag, evt_cnt %d, flying %d, ftl_pend %d trim_wait_dtag_range %d",},\
/* 0x01f3 */{"io_cmd.c", "nvmet_setup_rw", 256, "Block I/O because of reaching tmt2",},\
/* 0x01f4 */{"io_cmd.c", "nvmet_sq_handle", 1038, "Flush: (NSL) Invalid namespace (%d)",},\
/* 0x01f5 */{"io_cmd.c", "nvmet_sq_handle", 1067, "pnd_trim_cmd req 0x%p timeout (6s)",},\
/* 0x01f6 */{"io_cmd.c", "nvmet_sq_handle", 919, "Block I/O because of reaching tmt2",},\
/* 0x01f7 */{"io_cmd.c", "read_q_req", 468, "tgt %d, pnd %d, act %d, CID %d",},\
/* 0x01f8 */{"io_cmd.c", "read_q_reset", 372, "req q[%d] act %d -> 0\n",},\
/* 0x01f9 */{"io_cmd.c", "read_q_sched", 442, "tgt %d, pnd %d, act %d, CID %d, sts %d",},\
/* 0x01fa */{"io_cmd.c", "trim_merger_abort", 618, "trim req(0x%x) range pulling",},\
/* 0x01fb */{"io_cmd.c", "trim_merger_abort", 631, "clean ftl_req(0x%x) bind trim_req(0x%x)",},\
/* 0x01fc */{"io_cmd.c", "trim_merger_abort", 634, "clean trim merger hdr req(0x%x)",},\
/* 0x01fd */{"io_cmd.c", "trim_merger_abort", 644, "change ftl_req(0x%x) bind trim req (0x%x -> 0x%x)",},\
/* 0x01fe */{"io_cmd.c", "trim_merger_abort", 647, "change trim merger hdr req(0x%x -> 0x%x) ",},\
/* 0x01ff */{"io_cmd.c", "trim_merger_abort", 652, "del trim req(0x%x) ",},\
/* 0x0200 */{"io_cmd.c", "trim_merger_manager", 587, "merger 0x%p->0x%p(ttl range cnt %d now)",},\
/* 0x0201 */{"io_cmd.c", "trim_merger_manager", 600, "trim trigger 0x%p, ttl range cnt %d",},\
/* 0x0202 */{"io_cmd.c", "trim_range_pull_done", 725, "pull trim field err",},\
/* 0x0203 */{"io_cmd.c", "trim_range_pull_done", 739, "trim cmd pull done, but timeout. req 0x%p timeout(%d ms)",},\
/* 0x0204 */{"smart.c", "health_get_nvm_status", 213, "available spare(%d) < thr(%d)",},\
/* 0x0205 */{"smart.c", "health_get_smart_nvm_info", 163, "smart->controller_model %d\n",},\
/* 0x0206 */{"smart.c", "health_get_smart_nvm_info", 164, "smart->smart_version 0x%x\n",},\
/* 0x0207 */{"smart.c", "health_get_smart_nvm_info", 165, "smart->pe_cycle  %d\n",},\
/* 0x0208 */{"smart.c", "health_get_smart_nvm_info", 166, "smart->flash_type %d\n",},\
/* 0x0209 */{"smart.c", "health_get_smart_nvm_info", 167, "smart->ssd_protect_mode  %d\n",},\
/* 0x020a */{"smart.c", "health_get_smart_nvm_info", 168, "smart->host_read_unrecover_count %d\n",},\
/* 0x020b */{"smart.c", "health_get_smart_nvm_info", 169, "smart->phy_err_count %d\n",},\
/* 0x020c */{"smart.c", "health_get_smart_nvm_info", 170, "smart->crc_err_count %d\n",},\
/* 0x020d */{"smart.c", "health_get_smart_nvm_info", 171, "smart->total_early_bad_block %d\n",},\
/* 0x020e */{"smart.c", "health_get_smart_nvm_info", 172, "smart->total_later_bad_block %d\n",},\
/* 0x020f */{"smart.c", "health_get_smart_nvm_info", 173, "smart->max_erase_count %d\n",},\
/* 0x0210 */{"smart.c", "health_get_smart_nvm_info", 174, "smart->average_erase_count %d\n",},\
/* 0x0211 */{"smart.c", "health_get_smart_nvm_info", 175, "smart->program_fail_count %d\n",},\
/* 0x0212 */{"smart.c", "health_get_smart_nvm_info", 176, "smart->erase_fail_count %d\n",},\
/* 0x0213 */{"smart.c", "health_get_smart_nvm_info", 177, "smart->flash_write_sector %d\n",},\
/* 0x0214 */{"smart.c", "health_get_smart_nvm_info", 178, "smart->total_spare_block %d\n",},\
/* 0x0215 */{"smart.c", "health_get_smart_nvm_info", 179, "smart->current_spare_block %d\n",},\
/* 0x0216 */{"smart.c", "health_get_smart_nvm_info", 180, "smart->read_retry_count %d\n",},\
/* 0x0217 */{"smart.c", "health_get_temperature", 300, "This temperature sensor is off(id %d), Use the default NAND temperature sensor(id 0).",},\
/* 0x0218 */{"smart.c", "health_get_temperature", 329, "temp %d, (%d %d)",},\
/* 0x0219 */{"smart.c", "health_get_temperature", 346, "temp[%d] %d, (%d %d)",},\
/* 0x021a */{"smart.c", "health_get_temperature", 356, "smart temp [%d]",},\
/* 0x021b */{"fdisk.c", "_req_to_slow_ftl_exec", 1430, "read req %x blk by %x op %d",},\
/* 0x021c */{"fdisk.c", "_req_to_slow_ftl_exec", 1495, "wr req %x blk by %x op %d st %d",},\
/* 0x021d */{"fdisk.c", "_req_to_slow_ftl_exec", 1537, "flush req %x blk by %x op %d",},\
/* 0x021e */{"fdisk.c", "_req_to_slow_ftl_exec", 1582, "format req %x blk by %x op %d",},\
/* 0x021f */{"fdisk.c", "_req_to_slow_ftl_exec", 1594, "format req %x is running",},\
/* 0x0220 */{"fdisk.c", "_req_to_slow_ftl_exec", 1603, "format wait otf ftl req idle",},\
/* 0x0221 */{"fdisk.c", "_req_to_slow_ftl_exec", 1607, "format req %x wait cache clean",},\
/* 0x0222 */{"fdisk.c", "_req_to_slow_ftl_exec", 1615, "trim req %x blk by %x op %d",},\
/* 0x0223 */{"fdisk.c", "abort_pending_fw_dwnld_req", 2613, "pending dwnld cmd st %d %d, nr dtag %d",},\
/* 0x0224 */{"fdisk.c", "abort_pending_fw_dwnld_req", 2624, "gc_put_cont_dtags",},\
/* 0x0225 */{"fdisk.c", "abort_pending_fw_dwnld_req", 2627, "No pending dwnld cmd?!",},\
/* 0x0226 */{"fdisk.c", "ctag_buf_dump", 300, "ctag r:%d w:%d ctag:0x%x",},\
/* 0x0227 */{"fdisk.c", "ctag_err_handle", 282, "ctag:%d mode:%d cnt:%d flag:%d",},\
/* 0x0228 */{"fdisk.c", "ctag_err_handle", 285, "ctag err[%d]:0x%x %d %d c:0x%x",},\
/* 0x0229 */{"fdisk.c", "dfs_flush", 581, "smart: oom",},\
/* 0x022a */{"fdisk.c", "dfs_flush", 612, "miss dfs",},\
/* 0x022b */{"fdisk.c", "dfs_flush", 619, "smart: oom",},\
/* 0x022c */{"fdisk.c", "dfs_flush", 637, "dump_log flag %x size %x",},\
/* 0x022d */{"fdisk.c", "dump_ard_mon", 4408, "cpu %d: ard_mon",},\
/* 0x022e */{"fdisk.c", "dump_cmd_data_table_mon", 4502, "cpu %d: cmd_data_table_mon",},\
/* 0x022f */{"fdisk.c", "dump_cmd_data_xfer_mon", 4468, "cpu %d: cmd_data_xfer_mon",},\
/* 0x0230 */{"fdisk.c", "dump_cpu_regs", 3954, "cpu_reg_sts %x",},\
/* 0x0231 */{"fdisk.c", "dump_cpu_regs", 3959, "backup cpu0 cpu_regs",},\
/* 0x0232 */{"fdisk.c", "dump_cpu_regs", 3963, "send msg to cpu1 to get cpu_regs",},\
/* 0x0233 */{"fdisk.c", "dump_cpu_regs", 3968, "already backup cpu%d cpu_regs",},\
/* 0x0234 */{"fdisk.c", "dump_eccu_mon", 4260, "cpu %d: eccu_mon",},\
/* 0x0235 */{"fdisk.c", "dump_ficu_mon", 4375, "cpu %d: ficu_mon",},\
/* 0x0236 */{"fdisk.c", "dump_ficu_sts_reg", 4525, "cpu %d: %s",},\
/* 0x0237 */{"fdisk.c", "dump_lut_mem", 4122, "cpu %d: mem_start: %x mem_end: %x",},\
/* 0x0238 */{"fdisk.c", "dump_mem_data", 4015, "cpu %d: %s mem_start: %x mem_end: %x",},\
/* 0x0239 */{"fdisk.c", "dump_ndcu_mon", 4215, "cpu %d: ndcu_mon",},\
/* 0x023a */{"fdisk.c", "dump_reg", 4101, "cpu %d: %s mem_start: %x mem_end: %x",},\
/* 0x023b */{"fdisk.c", "fdisk_abort_flushing_req", 3287, "abort flush req %x",},\
/* 0x023c */{"fdisk.c", "fdisk_abort_wr_dump", 3228, "flush req %x",},\
/* 0x023d */{"fdisk.c", "fdisk_abort_wr_dump", 3230, "External #Dtags (%d)",},\
/* 0x023e */{"fdisk.c", "fdisk_format_done", 662, "fdisk format done",},\
/* 0x023f */{"fdisk.c", "fdisk_format_secure_erase", 675, "waiting dtag for sec erase...",},\
/* 0x0240 */{"fdisk.c", "fdisk_format_secure_erase", 685, "TODO for ATA Security or OPAL",},\
/* 0x0241 */{"fdisk.c", "fdisk_format_timer", 3580, "clear format_saved_jiffes to 0",},\
/* 0x0242 */{"fdisk.c", "fdisk_free_fw_upgrade_dtag", 2594, "gc_put_cont_dtags",},\
/* 0x0243 */{"fdisk.c", "fdisk_fua_done", 2488, "ctag %d req fua done",},\
/* 0x0244 */{"fdisk.c", "fdisk_fw_commit", 2981, "commit ca [%d] don't support",},\
/* 0x0245 */{"fdisk.c", "fdisk_fw_commit", 2992, "dus_amt %d put dtag %d",},\
/* 0x0246 */{"fdisk.c", "fdisk_fw_commit", 3002, "transfer fw not complete, can't commit",},\
/* 0x0247 */{"fdisk.c", "fdisk_fw_commit", 3026, "down load wait dtag cur status:%d",},\
/* 0x0248 */{"fdisk.c", "fdisk_fw_commit", 3034, "fwconfig not found, commit abort",},\
/* 0x0249 */{"fdisk.c", "fdisk_fw_commit", 3055, "commit load fwb error",},\
/* 0x024a */{"fdisk.c", "fdisk_fw_commit", 3066, "commit fw complete",},\
/* 0x024b */{"fdisk.c", "fdisk_fw_dwnld", 2687, "down load fw start",},\
/* 0x024c */{"fdisk.c", "fdisk_fw_dwnld", 2690, "dus_amt %d put dtag %d",},\
/* 0x024d */{"fdisk.c", "fdisk_fw_dwnld", 2708, "Image format SIG (0x%x) <- Exp. (0x%x)/(0x%x)/(0x%x) du:(0x%x)fail",},\
/* 0x024e */{"fdisk.c", "fdisk_fw_dwnld", 2765, "down load wait dtag cur status:%d",},\
/* 0x024f */{"fdisk.c", "fdisk_fw_dwnld", 2776, "xfer (%d) -> cur(%d)",},\
/* 0x0250 */{"fdisk.c", "fdisk_fw_dwnld", 2791, "fw image do verify, F-data(%x)",},\
/* 0x0251 */{"fdisk.c", "fdisk_fw_dwnld", 2801, "transfer fw image complete, but CRC error",},\
/* 0x0252 */{"fdisk.c", "fdisk_fw_dwnld", 2807, "Fw config Image SIG (0x%x) <- Exp. (0x%x) fail",},\
/* 0x0253 */{"fdisk.c", "fdisk_fw_dwnld", 2812, "Last xfer cur(%d)",},\
/* 0x0254 */{"fdisk.c", "fdisk_fw_dwnld", 2827, "transfer combo image complete, but CRC error",},\
/* 0x0255 */{"fdisk.c", "fdisk_fw_dwnld", 2831, "Fw config not found, set current value",},\
/* 0x0256 */{"fdisk.c", "fdisk_fw_dwnld", 2847, "fw_build_buffer_block1-Last: %d count(%d)",},\
/* 0x0257 */{"fdisk.c", "fdisk_fw_dwnld", 2852, "transfer combo image complete, but CRC error in NAND",},\
/* 0x0258 */{"fdisk.c", "fdisk_fw_dwnld", 2858, "fw_build_buffer_block1 %d",},\
/* 0x0259 */{"fdisk.c", "fdisk_fw_dwnld", 2864, "alloc download buffer Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x025a */{"fdisk.c", "fdisk_fw_dwnld", 2879, "Get fwconfig dtag(%x), First data(%x)",},\
/* 0x025b */{"fdisk.c", "fdisk_get_fw_upgrade_dtag", 2551, "gc_get_cont_dtags success",},\
/* 0x025c */{"fdisk.c", "fdisk_init", 3750, "fdisk initialization",},\
/* 0x025d */{"fdisk.c", "fdisk_init_done", 3506, "ftldisk init",},\
/* 0x025e */{"fdisk.c", "fdisk_power_state_change", 3280, "change power state [%d] complete",},\
/* 0x025f */{"fdisk.c", "fdisk_reset_disk", 3314, "------- WR DUMMY(%d,%d)",},\
/* 0x0260 */{"fdisk.c", "fdisk_reset_disk", 3329, "reset fdisk!%d",},\
/* 0x0261 */{"fdisk.c", "fdisk_reset_disk", 3337, "reset fdisk?%p %d",},\
/* 0x0262 */{"fdisk.c", "fdisk_resubmit_req", 1736, "req %x op %d resubmit pend",},\
/* 0x0263 */{"fdisk.c", "fdisk_set_disk_capacity", 3145, "Ignore Capacity Change %d GB, max %d",},\
/* 0x0264 */{"fdisk.c", "fdisk_set_disk_capacity", 3149, "Capacity Change!! (%d -> %d)GB",},\
/* 0x0265 */{"fdisk.c", "fdisk_trim", 1143, "discard trim 0x%x",},\
/* 0x0266 */{"fdisk.c", "fdisk_trim", 1171, "resume trim 0x%x",},\
/* 0x0267 */{"fdisk.c", "fdisk_trim", 1195, "pend trim 0x%x, %d",},\
/* 0x0268 */{"fdisk.c", "fdisk_wd_err_updt", 3365, "err wd pop c %d, duo %d, dtag %d",},\
/* 0x0269 */{"fdisk.c", "fdisk_wd_req_err", 3412, "ctag %d %d pop %d",},\
/* 0x026a */{"fdisk.c", "fdisk_wd_req_err", 3416, "req %x fua %d rls %d left %d",},\
/* 0x026b */{"fdisk.c", "fdisk_wd_req_err", 3436, "ctag:%x done %d updt dtags_xfer_left %d -> %d wr_err:%d",},\
/* 0x026c */{"fdisk.c", "fdisk_wr_dtags_gc", 350, "rls dtag %d, wr free %d wd %d",},\
/* 0x026d */{"fdisk.c", "fdisk_write_dump_data", 4564, "dfs_dev Error!!",},\
/* 0x026e */{"fdisk.c", "fdisk_write_dump_data", 4570, "fdisk_write_dump_data slot %d",},\
/* 0x026f */{"fdisk.c", "fdisk_write_dump_data", 4592, "erase dump block, ch %d ce %d du %d pb %d row 0x%x",},\
/* 0x0270 */{"fdisk.c", "fdisk_write_dump_data", 4607, "get dtag 0x%x",},\
/* 0x0271 */{"fdisk.c", "fdisk_write_dump_data", 4662, "dump data to spb 0x%x slot %d cmpl, wptr 0x%x ttl_sz 0x%x",},\
/* 0x0272 */{"fdisk.c", "ftl_flush_cmpl", 704, "shutdown req %x op %d done",},\
/* 0x0273 */{"fdisk.c", "ftl_flush_cmpl", 717, "flush req already aborted %x st %d reset %d",},\
/* 0x0274 */{"fdisk.c", "ftl_flush_cmpl", 746, "format req already aborted %x",},\
/* 0x0275 */{"fdisk.c", "ftl_trim_cmpl", 928, "fe done trim(0x%x) st(0x%x) ftl_req(0x%x)",},\
/* 0x0276 */{"fdisk.c", "ftl_trim_unbind_req", 896, "trim req(0x%x) and ftl_req(0x%x) unbind",},\
/* 0x0277 */{"fdisk.c", "hdbh_disable", 2300, "hdbh disabling",},\
/* 0x0278 */{"fdisk.c", "hdbh_disable", 2325, "hdbh disable",},\
/* 0x0279 */{"fdisk.c", "hdbh_enable", 2368, "hdbh enable",},\
/* 0x027a */{"fdisk.c", "hst_wr_ent_cmpl", 1905, "fua req %x err %d xfer done",},\
/* 0x027b */{"fdisk.c", "hst_wr_err_handle", 1868, "ctag err %d %d %x du_ofst:%d",},\
/* 0x027c */{"fdisk.c", "single_ncl_read_err_dump", 816, "pda 0x%x L 0x%x s %d",},\
/* 0x027d */{"fdisk.c", "smart_clean_main", 3501, "smart clean finish",},\
/* 0x027e */{"fdisk.c", "trim_merger_req_done", 913, "child req 0x%p done",},\
/* 0x027f */{"fdisk.c", "trim_merger_req_done", 918, "hdr req 0x%p done",},\
/* 0x0280 */{"fdisk.c", "wr_idle_chk_timer", 3555, "wr(%d) wd(%d), poped %d, dtag free %d",},\
/* 0x0281 */{"ra.c", "ra_forcast", 850, "ra_disable %d %d",},\
/* 0x0282 */{"ra.c", "ra_hmb_pda_lookup_done", 521, "FTL hmb lookup error",},\
/* 0x0283 */{"ramdisk.c", "check_unmap", 777, "PI G %x A %x R %x",},\
/* 0x0284 */{"ramdisk.c", "ramdisk_cmp_wd_updt", 439, "req(%x) Ctag(%d) Dtag(%d)",},\
/* 0x0285 */{"ramdisk.c", "ramdisk_cmp_wd_updt", 450, "cmp Du(%d) %d-%d",},\
/* 0x0286 */{"ramdisk.c", "ramdisk_dyn_read_cont", 749, "Dyn(R)(c) Ctag(%d) Du(%d)",},\
/* 0x0287 */{"ramdisk.c", "ramdisk_init", 1016, "alloc Streaming Read #Dtags(%d)",},\
/* 0x0288 */{"ramdisk.c", "ramdisk_init", 1057, "Ramdisk Init done",},\
/* 0x0289 */{"ramdisk.c", "ramdisk_nrm_wd_updt", 311, "req(%x) Ctag(%d) Dtag(%d)",},\
/* 0x028a */{"ramdisk.c", "ramdisk_part_wd_updt", 590, "req(%x) Ctag(%d) Dtag(%d)",},\
/* 0x028b */{"ramdisk.c", "ramdisk_part_wd_updt", 618, "merge DU(%d) %d(%d)",},\
/* 0x028c */{"ramdisk.c", "ramdisk_part_wd_updt", 625, "req(%x) Ctag(%d) Dtag(%d)",},\
/* 0x028d */{"ramdisk.c", "ramdisk_part_wd_updt", 631, "merge DU(%d) %d(%d)",},\
/* 0x028e */{"ramdisk.c", "ramdisk_trim", 833, "ramdisk finish dtag(%d)",},\
/* 0x028f */{"ramdisk.c", "ramdisk_wd_err_updt", 708, "wd err upt recycle dtag(%d)",},\
/* 0x0290 */{"ramdisk.c", "ramdisk_wd_req_err", 674, "pop free dtag %d due error",},\
/* 0x0291 */{"ramdisk.c", "ramdisk_wd_req_err", 676, "no free dtag",},\
/* 0x0292 */{"ramdisk.c", "req_exec", 888, "(R) Ctag(%d) T(S) NLB(%d) Du(%d/%d)",},\
/* 0x0293 */{"ramdisk.c", "req_exec", 916, "(R) Ctag(%d) T(D) NLB(%d) Du(%d/%d)",},\
/* 0x0294 */{"ramdisk.c", "req_exec", 967, "(W) Ctag(%d) rDtags(%d/%d) NLB(%d)",},\
/* 0x0295 */{"ramdisk.c", "set_map", 263, "PI G %x A %x R %x",},\
/* 0x0296 */{"rawdisk.c", "_rawdisk_nrm_wd_updt", 1567, "write %d LDA %x",},\
/* 0x0297 */{"rawdisk.c", "rawdisk_collision", 2416, "lda(0x%x) is re-written, discard it",},\
/* 0x0298 */{"rawdisk.c", "rawdisk_collision", 2420, "lda(0x%x) is in write buffer",},\
/* 0x0299 */{"rawdisk.c", "rawdisk_erase", 683, "spb %d erase done",},\
/* 0x029a */{"rawdisk.c", "rawdisk_fbbt_trans_bbt", 2882, "Trying mirror fbbt ...",},\
/* 0x029b */{"rawdisk.c", "rawdisk_fbbt_trans_bbt", 2884, "Defect in MR read fail 2",},\
/* 0x029c */{"rawdisk.c", "rawdisk_fbbt_trans_bbt", 2889, "SRB fbbt loaded",},\
/* 0x029d */{"rawdisk.c", "rawdisk_format", 2552, "rawdisk format: PI %s",},\
/* 0x029e */{"rawdisk.c", "rawdisk_fw_commit", 2290, "commit ca [%d] don't support\n",},\
/* 0x029f */{"rawdisk.c", "rawdisk_fw_commit", 2303, "transfer fw not complete,can't commit\n",},\
/* 0x02a0 */{"rawdisk.c", "rawdisk_fw_commit", 2314, "down load wait dtag cur status:%d",},\
/* 0x02a1 */{"rawdisk.c", "rawdisk_fw_commit", 2329, "rawdisk srb rebuild start",},\
/* 0x02a2 */{"rawdisk.c", "rawdisk_fw_commit", 2345, "commit load srb error\n",},\
/* 0x02a3 */{"rawdisk.c", "rawdisk_fw_commit", 2352, "commit fw complete\n",},\
/* 0x02a4 */{"rawdisk.c", "rawdisk_fw_dwnld", 2178, "Image SIG (0x%x) <- Exp. (0x%x) fail",},\
/* 0x02a5 */{"rawdisk.c", "rawdisk_fw_dwnld", 2191, "down load wait dtag cur status:%d",},\
/* 0x02a6 */{"rawdisk.c", "rawdisk_fw_dwnld", 2217, "transfer fw image complete, but CRC error\n",},\
/* 0x02a7 */{"rawdisk.c", "rawdisk_fw_dwnld", 2226, "transfer fw image complete\n",},\
/* 0x02a8 */{"rawdisk.c", "rawdisk_fw_dwnld", 2229, "transfer fw image complete, but CRC error\n",},\
/* 0x02a9 */{"rawdisk.c", "rawdisk_fw_dwnld", 2236, "alloc download buffer Row(0x%x)@CH/CE(%d/%d)\n",},\
/* 0x02aa */{"rawdisk.c", "rawdisk_fw_dwnld", 2247, "xfer (%d) -> cur(%d)",},\
/* 0x02ab */{"rawdisk.c", "rawdisk_idle_flush", 1470, "%s",},\
/* 0x02ac */{"rawdisk.c", "rawdisk_init", 3129, "cur_spb(%d), nxt_spb(%d)",},\
/* 0x02ad */{"rawdisk.c", "rawdisk_init", 3131, "No good SPB, check defect table!",},\
/* 0x02ae */{"rawdisk.c", "rawdisk_init", 3141, "alloc Streaming Read #Dtags(%d)",},\
/* 0x02af */{"rawdisk.c", "rawdisk_init", 3190, "Rawdisk init done.",},\
/* 0x02b0 */{"rawdisk.c", "rawdisk_merge", 1753, "%d: merge %d head %d",},\
/* 0x02b1 */{"rawdisk.c", "rawdisk_merge", 1758, "%d: merge %d tail %d",},\
/* 0x02b2 */{"rawdisk.c", "rawdisk_par_wd_updt", 2002, "par in c %d o %d d %d",},\
/* 0x02b3 */{"rawdisk.c", "rawdisk_pickup_spb", 901, "cur_spb(%d), nxt_spb(%d)",},\
/* 0x02b4 */{"rawdisk.c", "rawdisk_power_state_change", 2382, "change power state [%d] complete\n",},\
/* 0x02b5 */{"rawdisk.c", "rawdisk_read", 786, "op_type = %d, streaming(%d)",},\
/* 0x02b6 */{"rawdisk.c", "rawdisk_read_error_pda", 2522, "lda(%d/0x%x) is in error area",},\
/* 0x02b7 */{"rawdisk.c", "rawdisk_read_prep", 1429, "lda(0x%x) -> pda(0x%x)",},\
/* 0x02b8 */{"rawdisk.c", "rawdisk_srb_scan", 2787, "SRB hdr scan Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x02b9 */{"rawdisk.c", "rawdisk_srb_scan", 2794, "SRB Signature -> 0x%x%x",},\
/* 0x02ba */{"rawdisk.c", "rawdisk_srb_scan", 2799, "SRB hdr founded",},\
/* 0x02bb */{"rawdisk.c", "rawdisk_srb_scan", 2806, "Trying mirror fbbt ...",},\
/* 0x02bc */{"rawdisk.c", "rawdisk_srb_scan", 2808, "SRB fbbt load fail",},\
/* 0x02bd */{"rawdisk.c", "rawdisk_unmap_pda", 2489, "lda(%d/0x%x) is in unmapping area",},\
/* 0x02be */{"rawdisk.c", "rawdisk_wd_err_updt", 2993, "wd err upt recycle dtag(%d)",},\
/* 0x02bf */{"rawdisk.c", "rawdisk_write_prep", 1359, "lda(0x%x) -> pda(0x%x) Dtag(%d)",},\
/* 0x02c0 */{"rawdisk.c", "rawdisk_write_prep_for_mu_qlc", 1253, "lda(0x%x) -> pda(0x%x) Dtag(%d)",},\
/* 0x02c1 */{"rawdisk.c", "rawdisk_write_prep_for_ss_tlc", 1009, "lda(0x%x) -> pda(0x%x) Dtag(%d)",},\
/* 0x02c2 */{"rawdisk.c", "rawdisk_write_prep_for_tsb_tlc", 1121, "lda(0x%x) -> pda(0x%x) Dtag(%d)",},\
/* 0x02c3 */{"rawdisk.c", "req_exec", 2721, "(W) Ctag(%d) rDtags(%d/%d) NLB(%d)",},\
/* 0x02c4 */{"ucache.c", "cache_plp_dch_buddy_queue", 2486, "pick out meet lda %x in err status",},\
/* 0x02c5 */{"ucache.c", "cache_plp_dch_buddy_queue", 2493, "save lda %x dtag %d",},\
/* 0x02c6 */{"ucache.c", "cache_plp_dch_buddy_queue", 2502, "ttl_cnt %d",},\
/* 0x02c7 */{"ucache.c", "cache_plp_dch_merger_list", 2530, "save lda %x dtag %d, ofs %d, nlb %d",},\
/* 0x02c8 */{"ucache.c", "cache_plp_dch_merger_list", 2541, "ttl_cnt %d",},\
/* 0x02c9 */{"ucache.c", "cache_plp_notify", 2600, "PLP-receive plp evt %d",},\
/* 0x02ca */{"ucache.c", "default_host_plp_drh", 2286, "rcv lda %x, ofs %d, nlb %d",},\
/* 0x02cb */{"ucache.c", "print_ucache_info", 2707, "rptr %d wptr %d updt_ptr %d rls_otr %d force %d avail %d",},\
/* 0x02cc */{"ucache.c", "ucache_dtag_plp", 2220, "put lda %x",},\
/* 0x02cd */{"ucache.c", "ucache_dtag_plp", 2229, "put par_lda %x ofs %d",},\
/* 0x02ce */{"ucache.c", "ucache_dtag_plp", 2248, "trigger_plp_data_recovery again",},\
/* 0x02cf */{"ucache.c", "ucache_dtag_plp", 2256, "trigger_plp_data_recovery cpu1_plp_dtag return",},\
/* 0x02d0 */{"ucache.c", "ucache_plp_dch_UPDATER", 2401, "uc UPDATER idx:%d",},\
/* 0x02d1 */{"ucache.c", "ucache_plp_dch_mslice", 2452, "uc mslice ttl_cnt %d",},\
/* 0x02d2 */{"ucache.c", "ucache_plp_mgr_dsh", 2359, "save lda %x ofs %d nlb %d",},\
/* 0x02d3 */{"vdisk.c", "fwb_build", 819, "firmware commit to slot [%d]",},\
/* 0x02d4 */{"vdisk.c", "fwb_build", 841, "firmware commit to slot [%d]",},\
/* 0x02d5 */{"vdisk.c", "fwb_build", 902, "Program %s Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x02d6 */{"vdisk.c", "fwb_build", 930, "Program %s Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x02d7 */{"vdisk.c", "get_section", 622, "get section 0x%x, len %d, offset %x",},\
/* 0x02d8 */{"vdisk.c", "get_section_data_from_img", 689, "[single DU %d] 0x%x - 0x%x",},\
/* 0x02d9 */{"vdisk.c", "get_section_data_from_img", 695, "[cross DU %d] 0x%x - 0x%x",},\
/* 0x02da */{"vdisk.c", "pkey_verify", 797, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x02db */{"vdisk.c", "rda_erase", 311, "Erasing block Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x02dc */{"vdisk.c", "rda_erase", 314, "result: %d",},\
/* 0x02dd */{"vdisk.c", "sb_verify", 1033, "[%d] 0x%x - 0x%x",},\
/* 0x02de */{"vdisk.c", "sb_verify", 1035, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x02df */{"vdisk.c", "srb_bbt_scan", 510, "SLC Bad Block(%d)@CH/CE/LUN/PLN(%d/%d/%d/%d), PDA %x",},\
/* 0x02e0 */{"vdisk.c", "srb_bbt_scan", 599, "Bad Block(%d)@CH/CE/LUN/PLN(%d/%d/%d/%d)",},\
/* 0x02e1 */{"vdisk.c", "srb_build", 1670, "MR B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e2 */{"vdisk.c", "srb_build", 1673, "MR(m)  B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e3 */{"vdisk.c", "srb_build", 1681, "Using old MR parameters: %d",},\
/* 0x02e4 */{"vdisk.c", "srb_build", 1865, "FTL B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e5 */{"vdisk.c", "srb_build", 1867, "FTL(m)  B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e6 */{"vdisk.c", "srb_build", 1870, "FWB B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e7 */{"vdisk.c", "srb_build", 1872, "FWB(m) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e8 */{"vdisk.c", "srb_build", 1875, "DEVB B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02e9 */{"vdisk.c", "srb_build", 1877, "DEVB(m) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02ea */{"vdisk.c", "srb_build", 1880, "CUSTOMER B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d), rowAddr:%x",},\
/* 0x02eb */{"vdisk.c", "srb_build", 1882, "CUSTOMER(m) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02ec */{"vdisk.c", "srb_build", 1885, "EVT B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02ed */{"vdisk.c", "srb_build", 1887, "EVT(m)  B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02ee */{"vdisk.c", "srb_build", 1890, "FWB(buffer) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x02ef */{"vdisk.c", "srb_build", 1946, "sec_enable:0x%x sec_mode:0x%x\n",},\
/* 0x02f0 */{"vdisk.c", "srb_build", 1956, "SRBH(0~0x%x) C -> {SB(0x%x) SBD(0x%x) ECMF(0x%x) DCMF(0x%x) DBBT(0x%x)}",},\
/* 0x02f1 */{"vdisk.c", "srb_build", 1958, "SRBH(m)(0~0x%x) C -> {SB(0x%x) SBD(0x%x) ECMF(0x%x) DCMF(0x%x) DBBT(0x%x)}",},\
/* 0x02f2 */{"vdisk.c", "srb_build", 1960, "security image\n",},\
/* 0x02f3 */{"vdisk.c", "srb_build", 1965, "SRBH(0~0x%x) C -> {SB(0x%x) SBD(0x%x) ECMF(0x%x) DCMF(0x%x) DBBT(0x%x)}",},\
/* 0x02f4 */{"vdisk.c", "srb_build", 1967, "SRBH(m)(0~0x%x) C -> {SB(0x%x) SBD(0x%x) ECMF(0x%x) DCMF(0x%x) DBBT(0x%x)}",},\
/* 0x02f5 */{"vdisk.c", "srb_build", 1996, "srb->srb_hdr.srb_pub_key_len:0x%x",},\
/* 0x02f6 */{"vdisk.c", "srb_build", 2008, "SRB Header CRC(0x%x)",},\
/* 0x02f7 */{"vdisk.c", "srb_build", 2010, "SRB(m) Header CRC(0x%x)",},\
/* 0x02f8 */{"vdisk.c", "srb_build", 2100, "Program _SRBH_ Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x02f9 */{"vdisk.c", "srb_build", 2116, "Program _SRBH_(m) Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x02fa */{"vdisk.c", "srb_build", 2134, "Program _PKEY_Row(0x%x) dual Row (0x%x), length %d @CH/CE(%d/%d)",},\
/* 0x02fb */{"vdisk.c", "srb_build", 2138, "Program _PKEY(m)_Row(0x%x) dual Row (0x%x), length %d @CH/CE(%d/%d)",},\
/* 0x02fc */{"vdisk.c", "srb_build", 2143, "Program _FW_Row(0x%x) dual Row (0x%x) Row(m)(0x%x) dual Row(m)(0x%x) @CH/CE(%d/%d) ",},\
/* 0x02fd */{"vdisk.c", "srb_build", 2149, "Program _FW(m)_Row(0x%x) dual Row (0x%x) Row(m)(0x%x) dual Row(m)(0x%x) @CH/CE(%d/%d) ",},\
/* 0x02fe */{"vdisk.c", "srb_build", 2154, "Shastap Loader Program Done.",},\
/* 0x02ff */{"vdisk.c", "srb_build", 2158, "Shastap Firmware Program Done.",},\
/* 0x0300 */{"vdisk.c", "srb_build", 2165, "Overlay manager build done",},\
/* 0x0301 */{"vdisk.c", "srb_build", 2171, "OPAL SSC tables Program Done",},\
/* 0x0302 */{"vdisk.c", "srb_build", 2176, "Program _ECMF_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x0303 */{"vdisk.c", "srb_build", 2199, "Program _ECMF(m)_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x0304 */{"vdisk.c", "srb_build", 2222, "Program _DCMF_ Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x0305 */{"vdisk.c", "srb_build", 2245, "Program _DCMF(m)_ Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x0306 */{"vdisk.c", "srb_build", 2272, "Dftb size(%d) -> #Dus(%d) #PGs(%d)",},\
/* 0x0307 */{"vdisk.c", "srb_build", 2294, "Program _DFTB_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x0308 */{"vdisk.c", "srb_build", 2318, "Program _DFTB(m)_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x0309 */{"vdisk.c", "srb_build", 2444, "Scan _DFTB_ Row(0x%x)@CH/CE(%d/%d) PDA(0x%x)",},\
/* 0x030a */{"vdisk.c", "srb_build", 2466, "Scan _DFTB_(m) Row(0x%x)@CH/CE(%d/%d) PDA(0x%x)",},\
/* 0x030b */{"vdisk.c", "srb_build", 2483, "MR Block Program Done",},\
/* 0x030c */{"vdisk.c", "srb_build", 2553, "MR B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x030d */{"vdisk.c", "srb_build", 2556, "MR(m)  B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x030e */{"vdisk.c", "srb_build", 2582, "Using old MR parameters: %d",},\
/* 0x030f */{"vdisk.c", "srb_build", 2721, "FTL B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0310 */{"vdisk.c", "srb_build", 2723, "FTL(m)  B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0311 */{"vdisk.c", "srb_build", 2726, "FWB B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0312 */{"vdisk.c", "srb_build", 2728, "FWB(m) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0313 */{"vdisk.c", "srb_build", 2731, "DEVB B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0314 */{"vdisk.c", "srb_build", 2733, "DEVB(m) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0315 */{"vdisk.c", "srb_build", 2736, "CUSTOMER B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d), rowAddr:%d",},\
/* 0x0316 */{"vdisk.c", "srb_build", 2738, "CUSTOMER(m) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0317 */{"vdisk.c", "srb_build", 2741, "EVT B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0318 */{"vdisk.c", "srb_build", 2743, "EVT(m)  B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x0319 */{"vdisk.c", "srb_build", 2754, "FWB(buffer) B(%d) PL(%d) LUN (%d) @CH/CE(%d/%d)",},\
/* 0x031a */{"vdisk.c", "srb_build", 2785, "SRBH(0~0x%x) C -> {SB(0x%x) SBD(0x%x) ECMF(0x%x) DCMF(0x%x) DBBT(0x%x)}",},\
/* 0x031b */{"vdisk.c", "srb_build", 2787, "SRBH(m)(0~0x%x) C -> {SB(0x%x) SBD(0x%x) ECMF(0x%x) DCMF(0x%x) DBBT(0x%x)}",},\
/* 0x031c */{"vdisk.c", "srb_build", 2847, "SRB Header CRC(0x%x)",},\
/* 0x031d */{"vdisk.c", "srb_build", 2849, "SRB(m) Header CRC(0x%x)",},\
/* 0x031e */{"vdisk.c", "srb_build", 2937, "Program _SRBH_ Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x031f */{"vdisk.c", "srb_build", 2954, "Program _SRBH_(m) Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x0320 */{"vdisk.c", "srb_build", 2976, "Program _PKEY_Row(0x%x) dual Row (0x%x), length %d @CH/CE(%d/%d)",},\
/* 0x0321 */{"vdisk.c", "srb_build", 2980, "Program _PKEY(m)_Row(0x%x) dual Row (0x%x), length %d @CH/CE(%d/%d)",},\
/* 0x0322 */{"vdisk.c", "srb_build", 2986, "Program _FW_Row(0x%x) dual Row (0x%x) Row(m)(0x%x) dual Row(m)(0x%x) @CH/CE(%d/%d) ",},\
/* 0x0323 */{"vdisk.c", "srb_build", 2992, "Program _FW(m)_Row(0x%x) dual Row (0x%x) Row(m)(0x%x) dual Row(m)(0x%x) @CH/CE(%d/%d) ",},\
/* 0x0324 */{"vdisk.c", "srb_build", 2997, "Shasta Loader Program Done.",},\
/* 0x0325 */{"vdisk.c", "srb_build", 3001, "Shasta Firmware Program Done.",},\
/* 0x0326 */{"vdisk.c", "srb_build", 3011, "OPAL SSC tables Program Done",},\
/* 0x0327 */{"vdisk.c", "srb_build", 3016, "Program _ECMF_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x0328 */{"vdisk.c", "srb_build", 3039, "Program _ECMF(m)_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x0329 */{"vdisk.c", "srb_build", 3062, "Program _DCMF_ Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x032a */{"vdisk.c", "srb_build", 3085, "Program _DCMF(m)_ Row(0x%x~0x%x)@CH/CE(%d/%d)",},\
/* 0x032b */{"vdisk.c", "srb_build", 3111, "Dftb size(%d) -> #Dus(%d) #PGs(%d)",},\
/* 0x032c */{"vdisk.c", "srb_build", 3113, "Program _DFTB_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x032d */{"vdisk.c", "srb_build", 3137, "Program _DFTB(m)_ Row(0x%x ~ 0x%x)@CH/CE(%d/%d)",},\
/* 0x032e */{"vdisk.c", "srb_build", 3263, "Scan _DFTB_ Row(0x%x)@CH/CE(%d/%d) PDA(0x%x)",},\
/* 0x032f */{"vdisk.c", "srb_build", 3285, "Scan _DFTB_(m) Row(0x%x)@CH/CE(%d/%d) PDA(0x%x)",},\
/* 0x0330 */{"vdisk.c", "srb_build", 3302, "MR Block Program Done",},\
/* 0x0331 */{"vdisk.c", "srb_scan", 1080, "SRB hdr scan Blk(%d) Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x0332 */{"vdisk.c", "srb_scan", 1087, "SRB Signature -> 0x%x%x",},\
/* 0x0333 */{"vdisk.c", "srb_scan", 1092, "SRB hdr founded",},\
/* 0x0334 */{"vdisk.c", "srb_scan", 1097, "old crypto algo id: %d",},\
/* 0x0335 */{"vdisk.c", "srb_scan", 1099, "Loading fbbt if any ...",},\
/* 0x0336 */{"vdisk.c", "srb_scan", 1101, "SRB fbbt length(%x -> %x), consider incomplete.",},\
/* 0x0337 */{"vdisk.c", "srb_scan", 1109, "Trying mirror fbbt ...",},\
/* 0x0338 */{"vdisk.c", "srb_scan", 1138, "SRB fbbt loaded",},\
/* 0x0339 */{"vdisk.c", "srb_scan", 1164, "SRB fbbt load fail",},\
/* 0x033a */{"vdisk.c", "vdisk_fw_commit_Prog", 3853, "CRC(0x%x) vs. Real(0x%x), please retry!",},\
/* 0x033b */{"vdisk.c", "vdisk_fw_commit_Prog", 3859, "firmware CRC verified.",},\
/* 0x033c */{"vdisk.c", "vdisk_fw_commit_Prog", 3865, "There is no CRC information in FW, please retry!",},\
/* 0x033d */{"vdisk.c", "vdisk_fw_commit_Prog", 3883, "Image SIG (0x%x) -> Exp (0x%x) | AUs (%d)",},\
/* 0x033e */{"vdisk.c", "vdisk_fw_commit_Prog", 3886, "true GRIT image.",},\
/* 0x033f */{"vdisk.c", "vdisk_fw_commit_Prog", 3890, "combo image",},\
/* 0x0340 */{"vdisk.c", "vdisk_fw_commit_Prog", 3898, "cmfg image",},\
/* 0x0341 */{"vdisk.c", "vdisk_fw_commit_Prog", 3908, "fwcfg_du:%x fw_du:%x img:%p",},\
/* 0x0342 */{"vdisk.c", "vdisk_fw_dwnld", 3428, "Image SIG (0x%x) <- Exp. (0x%x) or (0x%x)",},\
/* 0x0343 */{"vdisk.c", "vdisk_fw_dwnld", 3434, "xfer (%d) -> cur(%d)",},\
/* 0x0344 */{"vdisk.c", "vdisk_init", 4764, "Enc size(%d) -> #Dus(%d) #PGs(%d)",},\
/* 0x0345 */{"vdisk.c", "vdisk_init", 4769, "Dec size(%d) -> #Dus(%d) #PGs(%d)",},\
/* 0x0346 */{"vdisk.c", "vdisk_init", 4850, "Vdisk init done!",},\
/* 0x0347 */{"ctrlr.c", "nvmet_isr", 2597, "admin coming during pmu entering",},\
/* 0x0348 */{"hmb.c", "hmb_encry_get_key", 1346, "hmb key %x",},\
/* 0x0349 */{"ctrlr.c", "_nvmet_cc_en_enable_isr", 2287, "platform msi mod %d",},\
/* 0x034a */{"ctrlr.c", "hal_nvmet_bootpart_get_cmd", 1144, "Boot Partition(%d) is not active\n",},\
/* 0x034b */{"ctrlr.c", "hal_nvmet_check_ppnd_cpl", 562, "[OUT] cpl_ppnd_cnt=%d",},\
/* 0x034c */{"ctrlr.c", "hal_nvmet_check_ppnd_cpl", 565, "%p %p\n",},\
/* 0x034d */{"ctrlr.c", "hal_nvmet_check_ppnd_cpl", 570, "cpl_ppnd_cmd(%p) id %d\n",},\
/* 0x034e */{"ctrlr.c", "hal_nvmet_check_ppnd_cpl", 575, "WIP %p",},\
/* 0x034f */{"ctrlr.c", "hal_nvmet_create_cq", 1016, "create CQ (%d) Qdepth (%d)",},\
/* 0x0350 */{"ctrlr.c", "hal_nvmet_create_sq", 921, "create SQ (%d), QDepth(%d/%d)",},\
/* 0x0351 */{"ctrlr.c", "hal_nvmet_delete_cq", 693, "Delete CQ (%d), Before cq_count(%d)",},\
/* 0x0352 */{"ctrlr.c", "hal_nvmet_delete_sq", 806, "Delete SQ (%d)",},\
/* 0x0353 */{"ctrlr.c", "hal_nvmet_delete_sq", 836, "pop empty cmd",},\
/* 0x0354 */{"ctrlr.c", "hal_nvmet_delete_sq", 841, "discard %d SQ %d",},\
/* 0x0355 */{"ctrlr.c", "hal_nvmet_delete_sq", 848, "SQ %d %d/%d",},\
/* 0x0356 */{"ctrlr.c", "hal_nvmet_delete_sq", 852, "SQ %d %d/%d",},\
/* 0x0357 */{"ctrlr.c", "hal_nvmet_get_sq_cmd", 457, "cmd(%p) qid(%d) opcode 0x%x, cid(%d) SQ rptr/wptr(%d/%d)",},\
/* 0x0358 */{"ctrlr.c", "hal_nvmet_get_sq_cmds", 490, "cmd(%p) qid(%d) opcode 0x%x, cid(%d) SQ rptr/wptr(%d/%d)",},\
/* 0x0359 */{"ctrlr.c", "hal_nvmet_rebuild_sq", 1197, "enable SQ (%d), QDepth(%d)",},\
/* 0x035a */{"ctrlr.c", "hal_nvmet_update_cq", 630, "ACQ is full(H: 0x%x T: 0x%x), rptr: 0x%x wptr: 0x%x",},\
/* 0x035b */{"ctrlr.c", "hal_nvmet_update_cq", 656, "(IN) %p cqid %d cnt = %d",},\
/* 0x035c */{"ctrlr.c", "nvme_cmd_get", 284, "out of nvme cmd",},\
/* 0x035d */{"ctrlr.c", "nvme_dma_queue_err_isr", 2182, "q0_ctrlr_sts 0x%x",},\
/* 0x035e */{"ctrlr.c", "nvme_dma_queue_err_isr", 2193, "q1_ctrlr_sts 0x%x",},\
/* 0x035f */{"ctrlr.c", "nvmet_abort_dma_queue", 1703, "DMA timeout elapsed %d ms, dir %d, 0xC00321B0 = %x, 0xc0043018 = %x",},\
/* 0x0360 */{"ctrlr.c", "nvmet_abort_dma_queue", 1709, "DMA abort req %x %x",},\
/* 0x0361 */{"ctrlr.c", "nvmet_abort_dma_queue", 1730, "DMA abort req %x",},\
/* 0x0362 */{"ctrlr.c", "nvmet_config_xfer_payload", 1983, " No pcie clock ",},\
/* 0x0363 */{"ctrlr.c", "nvmet_config_xfer_payload", 1993, "PCIE mps %d mrr %d",},\
/* 0x0364 */{"ctrlr.c", "nvmet_del_ppnd_cmpl", 670, "cpl_ppnd_cnt=%d",},\
/* 0x0365 */{"ctrlr.c", "nvmet_del_ppnd_cmpl", 677, "cpl_ppnd_cmd(%p) cqid %d del %d",},\
/* 0x0366 */{"ctrlr.c", "nvmet_dma_queue_done", 1770, "DMA timeout elapsed %d ms, dir %d, 0xC00321B0 = %x, 0xc0043018 = %x",},\
/* 0x0367 */{"ctrlr.c", "nvmet_init_aqa_attrs", 1523, "ASQ/ACQ (0x%x%x/0x%x%x)",},\
/* 0x0368 */{"ctrlr.c", "nvmet_init_aqa_attrs", 1529, "ASQ/ACQ Qdepth (%d/%d) -> (%d/%d)",},\
/* 0x0369 */{"ctrlr.c", "nvmet_isr", 2582, "HMB rsp full",},\
/* 0x036a */{"ctrlr.c", "nvmet_print_sq_err_info", 2218, "SQ %d db %x size %x fetch ptr %x",},\
/* 0x036b */{"ctrlr.c", "nvmet_slow_isr", 2374, "DMA queue xfer error 0x%x",},\
/* 0x036c */{"ctrlr.c", "nvmet_slow_isr", 2410, "SQ ptr err %x, bm sts %x, pcie_sts %x",},\
/* 0x036d */{"ctrlr.c", "nvmet_slow_isr", 2456, "CQ ptr err %x",},\
/* 0x036e */{"ctrlr.c", "nvmet_slow_isr", 2472, "NVMe Subsystem Reset ...",},\
/* 0x036f */{"ctrlr.c", "shutdown", 2083, "reset NVMe!!!",},\
/* 0x0370 */{"cmd_proc.c", "cmd_proc_cmd_abort", 371, "Abort Ctag(%d)",},\
/* 0x0371 */{"cmd_proc.c", "cmd_proc_cmd_issue", 354, "Ctag(%d) <- (qid(%d) cmd(%p) %d)",},\
/* 0x0372 */{"cmd_proc.c", "cmd_proc_cmpl_isr", 422, "Ctag(%d) completion",},\
/* 0x0373 */{"cmd_proc.c", "cmd_proc_debug_dump", 190, "debug addr %x val %x",},\
/* 0x0374 */{"cmd_proc.c", "cmd_proc_err_paser", 213, "cmd: sts %x ctag %d, elba %d",},\
/* 0x0375 */{"cmd_proc.c", "cmd_proc_isr", 466, "unhandled ISR sts 0x%x abort_sts 0x%x/ %x",},\
/* 0x0376 */{"hmb_cmd.c", "_hmb_lkp_fmt2", 196, "no support %d lda lookup",},\
/* 0x0377 */{"hmb.c", "_hmb_mem_set", 1870, "iter[%d] addr %x%x size %d",},\
/* 0x0378 */{"hmb.c", "_hmb_tbl_init", 1532, "tid aren't equal %d %d, reset to ~0",},\
/* 0x0379 */{"hmb.c", "_hmb_tbl_init", 1571, "HBUF Seg[%d]: %x%x size %d MB",},\
/* 0x037a */{"hmb.c", "_hmb_tbl_init", 1581, "TBL Seg[%d]: %x%x size %d MB",},\
/* 0x037b */{"hmb.c", "_hmb_tbl_init", 1587, "HMB table %d MB tbl_seg_cnt %d",},\
/* 0x037c */{"hmb.c", "_hmb_tbl_init", 1588, "HMB buffer %d MB buf_seg_cnt %d",},\
/* 0x037d */{"hmb.c", "_hmb_tbl_init", 1687, "hmb is not enable",},\
/* 0x037e */{"hmb.c", "hmb_auto_cmd_done_handler", 1005, "cmd is not handled, yet %d/%d",},\
/* 0x037f */{"hmb.c", "hmb_auto_cmd_done_handler", 1019, "Discard HMB Que ptr:%x-%x wait:%x t:%x ",},\
/* 0x0380 */{"hmb.c", "hmb_auto_cmd_done_handler", 1025, "Discard HMB RST",},\
/* 0x0381 */{"hmb.c", "hmb_auto_cmd_done_handler", 1043, "Discard HMB RST %x %d/%d %d %d %d",},\
/* 0x0382 */{"hmb.c", "hmb_auto_cmd_done_handler", 1092, "hmb crc error 0x%x(%d), hmb_in_error %d",},\
/* 0x0383 */{"hmb.c", "hmb_auto_cmd_done_handler", 1126, "hmb queue full, ptr %d/%d free cb %d req(0x%x) wait lkup %d",},\
/* 0x0384 */{"hmb.c", "hmb_auto_cmd_done_handler", 967, "auto lkp isr ptr %x, but not inited",},\
/* 0x0385 */{"hmb.c", "hmb_auto_cmd_done_handler", 995, "Discard HMB RST, and invalid reqid %d",},\
/* 0x0386 */{"hmb.c", "hmb_auto_lkp_rsp_dump", 900, "sq %d fid %d crc %d ent %d",},\
/* 0x0387 */{"hmb.c", "hmb_cancel_cmds", 1366, "res ptr %d/%d",},\
/* 0x0388 */{"hmb.c", "hmb_cancel_cmds", 1376, "hmb fw resp giveup %p(%d)",},\
/* 0x0389 */{"hmb.c", "hmb_cancel_cmds", 1402, "ptr %d/%d, otf %d",},\
/* 0x038a */{"hmb.c", "hmb_cancel_cmds", 1413, "hmb fw cmd giveup %p(%d)",},\
/* 0x038b */{"hmb.c", "hmb_cancel_cmds", 1446, "hmb fw cmd force cancel %p(%d)",},\
/* 0x038c */{"hmb.c", "hmb_chk_cmd_timeout", 1252, "HMB timeout 2s cb:0x%x cmd_id:%d",},\
/* 0x038d */{"hmb.c", "hmb_cmd_done", 636, "hmb cmd %d done, resp_code:%d",},\
/* 0x038e */{"hmb.c", "hmb_cmd_done", 640, "hmb cmd %d done, resp_code:%d",},\
/* 0x038f */{"hmb.c", "hmb_cmd_done", 645, "hmb crc error %d, cmd %d, resp_code:%d",},\
/* 0x0390 */{"hmb.c", "hmb_cmd_done_handler", 845, "hmb cmd done isr ptr %x, but not inited",},\
/* 0x0391 */{"hmb.c", "hmb_cmd_done_handler", 854, "no new hmb resp %d-%d",},\
/* 0x0392 */{"hmb.c", "hmb_detach", 1492, "hmb detached",},\
/* 0x0393 */{"hmb.c", "hmb_discard_auto_lookup_result", 921, "hmb auto resp discard %d->%d",},\
/* 0x0394 */{"hmb.c", "hmb_find_suit_seg", 483, "new seg[%d]: addr %x%x %d",},\
/* 0x0395 */{"hmb.c", "hmb_find_suit_seg", 490, "new seg[%d]: addr %x%x %d",},\
/* 0x0396 */{"hmb.c", "hmb_mem_set", 1906, "hmb meta size %d",},\
/* 0x0397 */{"hmb.c", "hmb_mem_set", 1910, "hmb [%d-%d] size %d",},\
/* 0x0398 */{"hmb.c", "hmb_mem_set_cb", 1807, "hmb %d seg clear done",},\
/* 0x0399 */{"hmb.c", "hmb_mem_set_cb", 1847, "req %p %p\n",},\
/* 0x039a */{"hmb.c", "hmb_pre_init", 2016, "Size[%d]/list_cnt %d ",},\
/* 0x039b */{"hmb.c", "hmb_pre_init", 2084, "Seg[%d]: %x%x size %d MB",},\
/* 0x039c */{"hmb.c", "hmb_pre_init", 2101, "HMB CRC Seg: %d, %dB",},\
/* 0x039d */{"hmb.c", "hmb_pre_init", 2107, "HMB META Seg: %d, %dB",},\
/* 0x039e */{"hmb.c", "hmb_pre_init", 2114, "HMB DMETA Seg: %d, %dB",},\
/* 0x039f */{"hmb.c", "hmb_reset_rptr", 934, "reset hm rptr",},\
/* 0x03a0 */{"hmb.c", "hmb_setup_preset", 1728, "HMB set timer hit prest",},\
/* 0x03a1 */{"hmb.c", "hmb_setup_timer", 1744, "HMB set in timer",},\
/* 0x03a2 */{"hmb.c", "hmb_setup_timer", 1747, "HMB set wait in timer",},\
/* 0x03a3 */{"hmb.c", "hmb_tbl_init", 1756, "warm boot hmb table init",},\
/* 0x03a4 */{"hmb.c", "hmb_tbl_init", 1773, "HMB init meet new fetched cmd",},\
/* 0x03a5 */{"hmb.c", "hmb_tbl_init", 1778, "HMB set directly",},\
/* 0x03a6 */{"hmb.c", "hmb_tbl_init", 1782, "HMB set wait timer trigger",},\
/* 0x03a7 */{"hmb_cmd.c", "hmb_lkp_rep_fmt2", 323, "HMB lookup/replace fmt2 cnt err %d",},\
/* 0x03a8 */{"hmb_cmd.c", "hmb_lkp_rep_fmt2", 337, "HMB lookup/replace no cmd",},\
/* 0x03a9 */{"ucache.c", "MERGER", 1204, "discontig ofst (%d != %d), Wake up READER_IMT",},\
/* 0x03aa */{"ucache.c", "MERGER", 1220, "concat Dtag(%d) ofst(%d) with Dtag(%d) len (%d)",},\
/* 0x03ab */{"ucache.c", "MERGER", 1339, "merge lda %x on err dtag",},\
/* 0x03ac */{"ucache.c", "MERGER", 1344, "merge Dtag(%d) ofst(%d) nlba (%d) to Dtag(%d)",},\
/* 0x03ad */{"ucache.c", "READER", 675, "get cp dtag lda:%x",},\
/* 0x03ae */{"ucache.c", "READER", 693, "insert pre-read Dtag(%d)",},\
/* 0x03af */{"ucache.c", "READER", 763, "read cancel idx(%d) LDA 0x(%x)",},\
/* 0x03b0 */{"ucache.c", "_ucache_merge_done", 928, "rd fail ce lda:%x atmoic:%x",},\
/* 0x03b1 */{"ucache.c", "_ucache_merge_done", 974, "Wrong ce_state(%x)",},\
/* 0x03b2 */{"ucache.c", "_ucache_merge_done", 981, "old merger, lda(0x%x) dtag(0x%x)",},\
/* 0x03b3 */{"ucache.c", "record_hit_ce", 429, "index %d jiffies %x lda %x state %d ref_cnt %d data(offset:64) %x",},\
/* 0x03b4 */{"ucache.c", "record_hit_ra", 404, "index %d jiffies %x lda %x dtag %d data(offset:0x64) %x",},\
/* 0x03b5 */{"ucache.c", "ucache_concat_done", 1078, "join Dtag(%d) nlba (%d -> %d)",},\
/* 0x03b6 */{"ucache.c", "ucache_concat_done", 1114, "TODO:",},\
/* 0x03b7 */{"ucache.c", "ucache_concat_done", 1119, "Wrong CE state (%x)",},\
/* 0x03b8 */{"ucache.c", "ucache_concat_done", 1130, "continue concat Dtag(%d) ofst(%d) with Dtag(%d) len (%d)",},\
/* 0x03b9 */{"ucache.c", "ucache_concat_done", 1141, "waiting for READER_IMT to merge Dtag(%d) ofst(%d) nlba(%d)",},\
/* 0x03ba */{"ucache.c", "ucache_concat_done", 1164, "Dtag(%d) concat DU FULL, state -> CE_ST_DIRTY",},\
/* 0x03bb */{"ucache.c", "ucache_force_flush", 2092, "Force l2p update cnt (%d)",},\
/* 0x03bc */{"ucache.c", "ucache_force_flush", 2099, "force ucache clean",},\
/* 0x03bd */{"ucache.c", "ucache_fr_data_in", 1895, "LDA(0x%x) Dtag(%d)",},\
/* 0x03be */{"ucache.c", "ucache_fr_data_in", 1919, "Wrong ce_state(%x)",},\
/* 0x03bf */{"ucache.c", "ucache_idle_concat_flush", 2065, "cancel concat merge, READ_IMT for normal merge",},\
/* 0x03c0 */{"ucache.c", "ucache_nrm_dsm_in", 1830, "lda[0x%x - 0x%x] pend",},\
/* 0x03c1 */{"ucache.c", "ucache_par_data_in", 1600, "ce(0x%p) s(%d): LDA(0x%x) Dtag(%d)",},\
/* 0x03c2 */{"ucache.c", "ucache_read_cont", 544, "LDA(0x%x) ce->state (%x)",},\
/* 0x03c3 */{"ucache.c", "ucache_read_data_out", 2015, "Wrong ce_state(%x)",},\
/* 0x03c4 */{"ucache.c", "ucache_show_record", 2777, "ucache hit: index %d jiffies %x lda %x state %d ref_cnt %d data[offset_64] %x",},\
/* 0x03c5 */{"ucache.c", "ucache_show_record", 2780, "ra hit: index %d jiffies %x lda %x dtag %d data(offset:64) %x",},\
/* 0x03c6 */{"ucache.c", "ucache_stop_record", 2746, "ucache hit: index %d jiffies %x lda %x state %d ref_cnt %d data[offset_64] %x",},\
/* 0x03c7 */{"ucache.c", "ucache_stop_record", 2749, "ra hit: index %d jiffies %x lda %x dtag %d data(offset:64) %x",},\
/* 0x03c8 */{"ovly_mgr.c", "cpu2_ovly_async_load_section", 303, "CPU2 start load ovly section",},\
/* 0x03c9 */{"ovly_mgr.c", "cpu2_ovly_sync_load_section", 316, "sync ovly loading...",},\
/* 0x03ca */{"ovly_mgr.c", "fdisk_fw_mr_read", 164, "Read fw all copy fail Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x03cb */{"ovly_mgr.c", "fdisk_get_ovly_section", 133, "get ovly section 0x%x, len 0x%x, offset 0x%x pma 0x%x",},\
/* 0x03cc */{"ovly_mgr.c", "fdisk_rebuild_ovly_setion", 243, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x03cd */{"ovly_mgr.c", "fdisk_update_ovly_section", 224, "Overlay section updated done",},\
/* 0x03ce */{"ovly_mgr.c", "ovly_load_exec_async", 66, "Async ovly loading...",},\
/* 0x03cf */{"ovly_mgr.c", "ovly_load_section", 267, "Load overlay: 0x%x pma: 0x%x length: 0x%x offset: 0x%x",},\
/* 0x03d0 */{"ovly_mgr.c", "ovly_prepare_dtags", 291, "ovly waiting dtag ...",},\
/* 0x03d1 */{"ovly_mgr.c", "ovly_share_tramp", 333, "ovly during pmu entering %d-%p",},\
/* 0x03d2 */{"ata.c", "ata_dev_pwd_recieve_cmd", 336, "Recieve SECP: 0x%x SPSP0: 0x%x SPSP1: 0x%x cdw11: 0x%x",},\
/* 0x03d3 */{"ata.c", "ata_dev_pwd_send_cmd", 212, "Send SECP: 0x%x SPSP0: 0x%x SPSP1: 0x%x cdw11: 0x%x",},\
/* 0x03d4 */{"crypto_hw_init.c", "crypto_hw_selftest_trigger", 441, "wait %d fcmd done before selftest",},\
/* 0x03d5 */{"crypto_hw_init.c", "crypto_init", 337, "Crypto algo id: %d mode: %d for user",},\
/* 0x03d6 */{"crypto_hw_init.c", "crypto_mek_init", 380, "First power on",},\
/* 0x03d7 */{"crypto_hw_init.c", "crypto_mek_update", 365, "New MEK update done",},\
/* 0x03d8 */{"crypto_hw_init.c", "crypto_switch_user_cfg", 290, "wrong cfg: %d",},\
/* 0x03d9 */{"crypto_hw_init.c", "crypto_switch_user_cfg", 295, "wrong cfg: %d",},\
/* 0x03da */{"crypto_hw_init.c", "crypto_switch_user_cfg", 302, "User cfg chgd: %d -> %d",},\
/* 0x03db */{"crypto_hw_init.c", "crypto_user_key_select", 310, "wrong key idx: %d",},\
/* 0x03dc */{"crypto_hw_init.c", "crypto_user_key_select", 314, "User key sel chgd: %d -> %d",},\
/* 0x03dd */{"ftl_byte_tables.c", "ftl_opal_data_move_wait_dtags", 260, "opal dmc wait dtags, sleep",},\
/* 0x03de */{"ftl_byte_tables.c", "ftl_opal_data_move_wait_dtags", 264, "opal dmc lda cnt: %d",},\
/* 0x03df */{"opal_tables.c", "opal_build", 1388, "OPAL program done",},\
/* 0x03e0 */{"opal_tables.c", "opal_fill_layout", 1182, "lda: %x size: %x offset: %x",},\
/* 0x03e1 */{"security_cmd.c", "nvmet_sec_cmd_done", 1448, "nls",},\
/* 0x03e2 */{"security_cmd.c", "nvmet_security_abort_cmd", 1395, "abort sec cmd: 0x%x sp(%d) comid(%d) ss(%d) auth(%d)",},\
/* 0x03e3 */{"security_cmd.c", "opal_cache_force_flush", 570, "not used",},\
/* 0x03e4 */{"security_cmd.c", "opal_first_cfg", 922, "PSID not programmed ...",},\
/* 0x03e5 */{"security_cmd.c", "opal_first_cfg", 927, "MSID not programmed ...",},\
/* 0x03e6 */{"security_cmd.c", "opal_first_cfg", 941, "opal P(M)SID: %d len: %d(%d)",},\
/* 0x03e7 */{"security_cmd.c", "opal_free_tables", 746, "%d-%d %d %d",},\
/* 0x03e8 */{"security_cmd.c", "opal_gen_prgm_gr_mek", 899, "GR MEK updated",},\
/* 0x03e9 */{"security_cmd.c", "opal_get_dtag_res", 86, "get dtag: %d -> %d %d %d, sleep",},\
/* 0x03ea */{"security_cmd.c", "opal_range_cross_check", 1069, "range crossing check lr: %x, %x - %x VS %x - %x cross lrs: %x",},\
/* 0x03eb */{"security_cmd.c", "security_cmd_prepare_dtags", 1487, "sec cmd waiting dtags %d %d",},\
/* 0x03ec */{"security_cmd.c", "security_init", 1387, "OPAL SSC init done",},\
/* 0x03ed */{"security_recieve.c", "nvmet_security_recieve_handler", 1911, "Get security secp supported list, AL: 0x%x",},\
/* 0x03ee */{"security_recieve.c", "nvmet_security_recieve_handler", 1914, "TODO: no cert data, return 0",},\
/* 0x03ef */{"security_send.c", "opal_activate_method", 2074, "LSP life cycle: %d -> %d",},\
/* 0x03f0 */{"security_send.c", "opal_block_SID_func", 3827, "SID already BLOCKED",},\
/* 0x03f1 */{"security_send.c", "opal_block_SID_func", 3833, "Block SID(%d %d %d)",},\
/* 0x03f2 */{"security_send.c", "opal_gen_prgm_key", 1793, "gen mek for LR: %d",},\
/* 0x03f3 */{"security_send.c", "opal_regular_session_status_list_check", 1187, "Not Unsigned interger",},\
/* 0x03f4 */{"security_send.c", "opal_regular_session_status_list_check", 1195, "fsc: %x",},\
/* 0x03f5 */{"security_send.c", "opal_revert_method", 3320, "SP: %d LSP life cycle: %d",},\
/* 0x03f6 */{"security_send.c", "opal_revert_method", 3335, "BLK SID cleared",},\
/* 0x03f7 */{"security_send.c", "opal_revert_sp_mthod", 2253, "LSP life cycle: %d -> %d",},\
/* 0x03f8 */{"security_send.c", "opal_revert_sp_mthod", 2259, "KGR: %d",},\
/* 0x03f9 */{"security_send.c", "opal_thissp_authenticate_method", 3519, "SID Blocked",},\
/* 0x03fa */{"security_send.c", "opal_token_transaction", 3378, "EOT -> %d",},\
/* 0x03fb */{"security_send.c", "opal_update_tables_after_set", 1029, "SID value state: %d",},\
/* 0x03fc */{"security_send.c", "opal_update_tables_after_set", 1061, "MBR state: %d %d",},\
/* 0x03fd */{"security_test.c", "security_selftest", 874, "sec algo selftest: 0x%x vs 0xFF",},\
/* 0x03fe */{"security_test.c", "test_ss_key_wp_uwp", 442, "CFP ..... ENABLED",},\
/* 0x03ff */{"security_test.c", "test_ss_key_wp_uwp", 445, "CFP ..... DISABLED",},\
/* 0x0400 */{"security_test.c", "test_ss_key_wp_uwp", 458, "CFP ..... ENABLED",},\
/* 0x0401 */{"security_test.c", "test_ss_key_wp_uwp", 461, "CFP ..... DISABLED",},\
/* 0x0402 */{"security_test.c", "test_ss_key_wp_uwp", 538, "CFP ..... ENABLED",},\
/* 0x0403 */{"security_test.c", "test_ss_key_wp_uwp", 541, "CFP ..... DISABLED",},\
/* 0x0404 */{"security_test.c", "test_ss_key_wp_uwp", 554, "CFP ..... ENABLED",},\
/* 0x0405 */{"security_test.c", "test_ss_key_wp_uwp", 557, "CFP ..... DISABLED",},\
/* 0x0406 */{"security_test.c", "test_ss_key_wp_uwp", 571, "..... NO VALID TEST VECTOR SELECTED",},\
/* 0x0407 */{"security_test.c", "test_ss_key_wp_uwp", 583, "AES_256B_KWP_NO_SECURE ..... PASS",},\
/* 0x0408 */{"security_test.c", "test_ss_key_wp_uwp", 585, "AES_256B_KWP_NO_SECURE ..... FAIL",},\
/* 0x0409 */{"security_test.c", "test_ss_key_wp_uwp", 590, "AES_256B_KUWP_NO_SECURE ..... PASS",},\
/* 0x040a */{"security_test.c", "test_ss_key_wp_uwp", 592, "AES_256B_KUWP_NO_SECURE ..... FAIL",},\
/* 0x040b */{"security_test.c", "test_ss_key_wp_uwp", 597, "AES_256B_RAW_ENCRYPT ..... PASS",},\
/* 0x040c */{"security_test.c", "test_ss_key_wp_uwp", 599, "AES_256B_RAW_ENCRYPT ..... FAIL",},\
/* 0x040d */{"security_test.c", "test_ss_key_wp_uwp", 604, "AES_256B_RAW_DECRYPT ..... PASS",},\
/* 0x040e */{"security_test.c", "test_ss_key_wp_uwp", 606, "AES_256B_RAW_DECRYPT ..... FAIL",},\
/* 0x040f */{"security_test.c", "test_ss_key_wp_uwp", 611, "AES_256B_KWP_SECURE_NO_CFP ..... PASS",},\
/* 0x0410 */{"security_test.c", "test_ss_key_wp_uwp", 613, "AES_256B_KWP_SECURE_NO_CFP ..... FAIL",},\
/* 0x0411 */{"security_test.c", "test_ss_key_wp_uwp", 618, "AES_256B_KUWP_SECURE_NO_CFP ..... PASS",},\
/* 0x0412 */{"security_test.c", "test_ss_key_wp_uwp", 620, "AES_256B_KUWP_SECURE_NO_CFP ..... FAIL",},\
/* 0x0413 */{"security_test.c", "test_ss_key_wp_uwp", 625, "AES_256B_KWP_SECURE_CFP ..... PASS",},\
/* 0x0414 */{"security_test.c", "test_ss_key_wp_uwp", 628, "AES_256B_KUWP_SECURE_CFP ..... PASS",},\
/* 0x0415 */{"security_test.c", "test_ss_key_wp_uwp", 635, "SM4_128B_KWP_NO_SECURE ..... PASS",},\
/* 0x0416 */{"security_test.c", "test_ss_key_wp_uwp", 637, "SM4_128B_KWP_NO_SECURE ..... FAIL",},\
/* 0x0417 */{"security_test.c", "test_ss_key_wp_uwp", 642, "SM4_128B_KUWP_NO_SECURE ..... PASS",},\
/* 0x0418 */{"security_test.c", "test_ss_key_wp_uwp", 644, "SM4_128B_KUWP_NO_SECURE ..... FAIL",},\
/* 0x0419 */{"security_test.c", "test_ss_key_wp_uwp", 649, "SM4_128B_RAW_ENCRYPT ..... PASS",},\
/* 0x041a */{"security_test.c", "test_ss_key_wp_uwp", 651, "SM4_128B_RAW_ENCRYPT ..... FAIL",},\
/* 0x041b */{"security_test.c", "test_ss_key_wp_uwp", 656, "SM4_128B_RAW_DECRYPT ..... PASS",},\
/* 0x041c */{"security_test.c", "test_ss_key_wp_uwp", 658, "SM4_128B_RAW_DECRYPT ..... FAIL",},\
/* 0x041d */{"security_test.c", "test_ss_key_wp_uwp", 663, "SM4_128B_KWP_SECURE_NO_CFP ..... PASS",},\
/* 0x041e */{"security_test.c", "test_ss_key_wp_uwp", 665, "SM4_128B_KWP_SECURE_NO_CFP ..... FAIL",},\
/* 0x041f */{"security_test.c", "test_ss_key_wp_uwp", 670, "SM4_128B_KUWP_SECURE_NO_CFP ..... PASS",},\
/* 0x0420 */{"security_test.c", "test_ss_key_wp_uwp", 672, "SM4_128B_KUWP_SECURE_NO_CFP ..... FAIL",},\
/* 0x0421 */{"security_test.c", "test_ss_key_wp_uwp", 677, "SM4_128B_KWP_SECURE_CFP ..... PASS",},\
/* 0x0422 */{"security_test.c", "test_ss_key_wp_uwp", 680, "SM4_128B_KUWP_SECURE_CFP ..... PASS",},\
/* 0x0423 */{"security_test.c", "test_ss_key_wp_uwp", 684, "..... NO VALID TEST VECTOR SELECTED",},\
/* 0x0424 */{"srb.c", "cus_info_operation", 1783, "cus_info optype = %d, cus_flag = 0x%x, fcty_dft_cnt = %d, total_aging_dft_cnt = %d\n",},\
/* 0x0425 */{"srb.c", "cus_info_operation", 1836, "cus_info flag NONONO set [%d]\n",},\
/* 0x0426 */{"srb.c", "cus_info_operation", 1899, "cus_info No exist optype = %d, size = %d\n",},\
/* 0x0427 */{"srb.c", "cus_info_operation", 1905, "cus_info read type = %d, size = %d\n",},\
/* 0x0428 */{"srb.c", "cus_info_operation", 1907, "MAX defects permission is %d!\n",},\
/* 0x0429 */{"srb.c", "cus_info_operation", 1944, "CUS read info PDA = 0x%x Row = 0x%x, count = %d",},\
/* 0x042a */{"srb.c", "cus_info_operation", 1950, "cus_info read data(%d) > SRB_MR_DU_SZE(%d)",},\
/* 0x042b */{"srb.c", "cus_info_operation", 1954, "cus_info read data(%d) =< SRB_MR_DU_SZE(%d)",},\
/* 0x042c */{"srb.c", "cus_info_operation", 1970, "cus_info read desult data OPtype = %d, data = 0x%x",},\
/* 0x042d */{"srb.c", "cus_info_operation", 1972, "cus_info write type = %d, size = %d",},\
/* 0x042e */{"srb.c", "cus_info_operation", 1979, "cus_info write type = %d, size = %d",},\
/* 0x042f */{"srb.c", "cus_info_operation", 1986, "cus_info Write data OPtype = %d, data = 0x%x, 0x%x",},\
/* 0x0430 */{"srb.c", "cus_info_operation", 2000, "CUS write info Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x0431 */{"srb.c", "cus_info_operation", 2001, "CUS write info PDA = 0x%x\n",},\
/* 0x0432 */{"srb.c", "cus_info_operation", 2002, "CUS write info size(%d) -> #Dus(%d) #PGs(%d)",},\
/* 0x0433 */{"srb.c", "cus_info_operation", 2038, "CUS Wite Header index Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x0434 */{"srb.c", "cus_info_operation", 2039, "CUS Wite Header index PDA = 0x%x size = %d",},\
/* 0x0435 */{"srb.c", "cus_search_pdft_header", 1685, "CusPriPos (%x) is invalid! Need re-manufacturing",},\
/* 0x0436 */{"srb.c", "cus_search_pdft_header", 1689, "PDFT header search %x %d",},\
/* 0x0437 */{"srb.c", "cus_search_pdft_header", 1692, "enter mr fail",},\
/* 0x0438 */{"srb.c", "cus_search_pdft_header", 1699, "PDFT header blank area start PDA = 0x%x, block_id = %d, page = %d",},\
/* 0x0439 */{"srb.c", "cus_search_pdft_header", 1711, "CUS_PDFT header search fail, return first page PDA = 0x%x",},\
/* 0x043a */{"srb.c", "cus_search_pdft_header", 1723, "CUS_PDFT Finding Row(0x%x)@CH/CE(%1d/%1d) PDA = 0x%x, page = %3d\n",},\
/* 0x043b */{"srb.c", "cus_search_pdft_header", 1726, "CUS_PDFT can't find latest info Row(0x%x)@CH/CE(%1d/%1d) PDA = 0x%x, page = %3d",},\
/* 0x043c */{"srb.c", "cus_search_pdft_header", 1728, "flag = 0x%x, SG = 0x%x",},\
/* 0x043d */{"srb.c", "cus_search_pdft_header", 1731, "CUS_PDFT header search fail, return first page PDA = 0x%x",},\
/* 0x043e */{"srb.c", "fw_build_buffer_block", 737, "download Program Row(0x%x)@CH/CE(%d/%d) dus:%d",},\
/* 0x043f */{"srb.c", "fw_build_buffer_block", 752, "download Program Row(0x%x)@CH/CE(%d/%d) err",},\
/* 0x0440 */{"srb.c", "fw_verify_image", 770, "CRC(0x%x) vs. Real(0x%x), please retry!",},\
/* 0x0441 */{"srb.c", "fw_verify_image", 781, "firmware image verfied.",},\
/* 0x0442 */{"srb.c", "fw_verify_image", 786, "this firmware image not have CRC verify info.",},\
/* 0x0443 */{"srb.c", "srb_access_sus", 1027, "srb sus access failed, pda: 0x%x info status: 0x%x",},\
/* 0x0444 */{"srb.c", "srb_fw_copy_fwcfg", 874, "parm dtag(s:%x,d:%x) slot:%x",},\
/* 0x0445 */{"srb.c", "srb_fw_copy_fwcfg", 879, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x0446 */{"srb.c", "srb_fw_copy_fwcfg", 885, "firmware block signature:[0x%x] != [0x%x] fail",},\
/* 0x0447 */{"srb.c", "srb_fw_copy_fwcfg", 890, "fwconfig signature:[0x%x] != [0x%x] fail",},\
/* 0x0448 */{"srb.c", "srb_fw_copy_fwcfg", 898, "slot info slot:%d, cnt:%d",},\
/* 0x0449 */{"srb.c", "srb_fw_copy_fwcfg", 909, "FW config not found in FWB.",},\
/* 0x044a */{"srb.c", "srb_fw_copy_fwcfg", 912, "FW config Copy Done.",},\
/* 0x044b */{"srb.c", "srb_fwb_verify_after_upgrade", 684, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x044c */{"srb.c", "srb_fwb_verify_after_upgrade", 691, "verify fw image slot %d error after fw commit",},\
/* 0x044d */{"srb.c", "srb_fwb_verify_after_upgrade", 699, "verify fw image slot %d dual error after fw commit",},\
/* 0x044e */{"srb.c", "srb_fwb_verify_after_upgrade", 707, "verify fw image slot %d mirror error after fw commit",},\
/* 0x044f */{"srb.c", "srb_fwb_verify_after_upgrade", 715, "verify fw image slot %d dual mirror error after fw commit",},\
/* 0x0450 */{"srb.c", "srb_loader_verify", 938, "verify image Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x0451 */{"srb.c", "srb_loader_verify", 942, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x0452 */{"srb.c", "srb_loader_verify", 949, "Image sign:[0x%x != 0x%x] CRC:[0x%x != 0x%x] fail",},\
/* 0x0453 */{"srb.c", "srb_loader_verify", 954, "Row[%x] 0x%x - 0x%x dus:0x%x",},\
/* 0x0454 */{"srb.c", "srb_loader_verify", 974, "fw image CRC error",},\
/* 0x0455 */{"srb.c", "srb_page_copy", 499, "copy source Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x0456 */{"srb.c", "srb_page_copy", 501, "copy Program Row(0x%x)@CH/CE(%d/%d)pageCnt(0x%x)",},\
/* 0x0457 */{"srb.c", "srb_rebuild_fwb", 553, "Row(0x%x)@CH/CE(%d/%d) fail",},\
/* 0x0458 */{"srb.c", "srb_rebuild_fwb", 559, "firmware block signature:[0x%x] != [0x%x] fail",},\
/* 0x0459 */{"srb.c", "srb_rebuild_fwb", 570, "firmware commit invaild download slot:%d, active slot:%d",},\
/* 0x045a */{"srb.c", "srb_rebuild_fwb", 627, "firmware slot%d rebuild start",},\
/* 0x045b */{"srb.c", "srb_rebuild_fwb", 651, "(m)firmware slot%d rebuild start",},\
/* 0x045c */{"srb.c", "srb_rebuild_fwb", 660, "Shasta fwb Program Done.",},\
/* 0x045d */{"srb.c", "srb_replace_fwcfg", 811, "copy source Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x045e */{"srb.c", "srb_replace_fwcfg", 813, "copy Program Row(0x%x)@CH/CE(%d/%d)pageCnt(0x%x)",},\
/* 0x045f */{"srb.c", "srb_replace_fwcfg", 826, "Found cofig Row(0x%x)@CH/CE(%d/%d)pageCnt(0x%x)",},\
/* 0x0460 */{"srb.c", "srb_scan_and_load", 414, "SRB hdr scan Row(0x%x)@CH/CE(%d/%d)",},\
/* 0x0461 */{"srb.c", "srb_scan_and_load", 420, "SRB Signature -> 0x%x%x",},\
/* 0x0462 */{"srb.c", "srb_scan_and_load", 421, "SRB Header CRC:[0x%x] [0x%x]",},\
/* 0x0463 */{"srb.c", "srb_scan_and_load", 426, "SRB hdr founded CRC:[0x%x]",},\
/* 0x0464 */{"srb.c", "srb_sus_flush_data", 1569, "sus flush data start prev num:%d",},\
/* 0x0465 */{"srb.c", "srb_sus_flush_data", 1611, "sus write lda:0x%x block:%d err",},\
/* 0x0466 */{"srb.c", "srb_sus_flush_data", 1620, "sus write lda:0x%x block:%d err",},\
/* 0x0467 */{"srb.c", "srb_sus_gc_block", 1069, "srb sus GC get dtag fail, into wait gc status",},\
/* 0x0468 */{"srb.c", "srb_sus_gc_block", 1096, "sus block: %d dus:[0x%x] lda:0x%x read error",},\
/* 0x0469 */{"srb.c", "srb_sus_gc_block", 1122, "sus write lda:0x%x block:%d err",},\
/* 0x046a */{"srb.c", "srb_sus_gc_block", 1131, "sus write lda:0x%x block:%d err",},\
/* 0x046b */{"srb.c", "srb_sus_gc_block", 1157, "wait ncl idle %d before sus gc blk erase rda 0x%x",},\
/* 0x046c */{"srb.c", "srb_sus_init", 2079, "sus init srb signature err",},\
/* 0x046d */{"srb.c", "srb_sus_init", 2092, "can't find sus block for OPAL",},\
/* 0x046e */{"srb.c", "srb_sus_read", 1412, "sus status:[%d] read error",},\
/* 0x046f */{"srb.c", "srb_sus_read", 1431, "Invalid LDA: 0x%x",},\
/* 0x0470 */{"srb.c", "srb_sus_read", 1452, "sus read lda:0x%x block:%d dus:0x%x err",},\
/* 0x0471 */{"srb.c", "srb_sus_rebuild", 1371, "sus rebuild error",},\
/* 0x0472 */{"srb.c", "srb_sus_rebuild", 1379, "sus rebuild error",},\
/* 0x0473 */{"srb.c", "srb_sus_rebuild", 1386, "sus rebuild error",},\
/* 0x0474 */{"srb.c", "srb_sus_rebuild_block", 1201, "sus block[%d] read error",},\
/* 0x0475 */{"srb.c", "srb_sus_rebuild_block", 1209, "sus block[%d] not have data",},\
/* 0x0476 */{"srb.c", "srb_sus_rebuild_block", 1222, "sus cur block[0x%x] cur du page[0x%x]",},\
/* 0x0477 */{"srb.c", "srb_sus_rebuild_block", 1248, "sus block[%d] row[0x%x] read error",},\
/* 0x0478 */{"srb.c", "srb_sus_rebuild_block", 1263, "sus block[%d] page[0x%x] du offset:%d SIGNATURE error",},\
/* 0x0479 */{"srb.c", "srb_sus_req_handler", 2113, "srb sus req: %p op: %d dtag: 0x%x lda: 0x%x",},\
/* 0x047a */{"srb.c", "srb_sus_write", 1474, "sus status:[%d] write error",},\
/* 0x047b */{"srb.c", "srb_sus_write", 1490, "sus write get dtag error",},\
/* 0x047c */{"srb.c", "srb_sus_write", 1538, "sus write lda:0x%x block:%d err",},\
/* 0x047d */{"srb.c", "srb_sus_write", 1547, "sus write lda:0x%x block:%d err",},\
/* 0x047e */{"srb.c", "tran_dftb_mr_2_ftl", 252, "New Bad Block(%d)@CH/CE/LUN/PLN(%d/%d/%d/%d)\n",},\
/* 0x047f */{"srb.c", "tran_ftl_2_mr_dftb", 276, "%d FBBT Bad Block(%d)@CH/CE/LUN/PLN(%d/%d/%d/%d)",},\
/* 0x0480 */{"device_fs.c", "_write_dump_data_to_nand", 1397, "dump_spb is full",},\
/* 0x0481 */{"device_fs.c", "_write_dump_data_to_nand", 1425, "pda 0x%x wptr 0x%x dtag 0x%x",},\
/* 0x0482 */{"device_fs.c", "dfs_init", 1294, "device block init fail",},\
/* 0x0483 */{"device_fs.c", "dfs_start", 1314, "open err, new stat file",},\
/* 0x0484 */{"device_fs.c", "dfs_start", 1324, "stat file was drop",},\
/* 0x0485 */{"device_fs.c", "dump_block_erase", 1375, "pda %x ch %d ce %d du %d pb %d row 0x%x",},\
/* 0x0486 */{"device_fs.c", "find_old_dfs_file", 668, "discard file %x %x %x %x",},\
/* 0x0487 */{"device_fs.c", "find_old_dfs_file", 673, "old file %x %x %x %x",},\
/* 0x0488 */{"device_fs.c", "host_read_dump_data", 1453, "out of mem, slot %d",},\
/* 0x0489 */{"device_fs.c", "host_read_dump_data", 1465, "invalid log, slot %d f 0x%x",},\
/* 0x048a */{"device_fs.c", "host_read_dump_data", 1475, "ready read dump data, slot %d size %x",},\
/* 0x048b */{"device_fs.c", "host_read_dump_data", 1507, "-- pda 0x%x dtag 0x%x",},\
/* 0x048c */{"device_fs.c", "host_read_dump_data", 1511, "read dump data fail %d pda 0x%x",},\
/* 0x048d */{"device_fs.c", "host_read_dump_data", 1515, "val %d sn %x flags %x",},\
/* 0x048e */{"device_fs.c", "host_read_dump_data", 1519, "i %d sn 0x%x flag 0x%x not match",},\
/* 0x048f */{"device_fs.c", "host_read_dump_data", 1533, "cur_read %x ttl_size %x",},\
/* 0x0490 */{"device_fs.c", "host_read_dump_data", 1538, "slot %d read done, ptr 0x%x read %d(ttl %d)",},\
/* 0x0491 */{"device_fs.c", "read_dfs_file", 733, "No Mem File %d",},\
/* 0x0492 */{"device_fs.c", "srb_dfs_max_log_free_mem", 360, "mem type %d ptr %x",},\
/* 0x0493 */{"device_fs.c", "srb_dfs_max_log_get_mem", 336, "mem type %d ptr %x",},\
/* 0x0494 */{"device_fs.c", "srb_dfs_max_log_get_mem", 344, "mem type %d ptr %x",},\
/* 0x0495 */{"device_fs.c", "srb_dfs_scan_blk", 1121, "FS %p MG err",},\
/* 0x0496 */{"device_fs.c", "srb_dfs_scan_blk", 1146, "Log Ver %p CRC",},\
/* 0x0497 */{"device_fs.c", "srb_dfs_scan_blk", 1155, "FS %p CRC err",},\
/* 0x0498 */{"device_fs.c", "srb_dfs_scan_blk", 1162, "FS %p ver up",},\
/* 0x0499 */{"device_fs.c", "srb_dfs_scan_blk", 1176, "Srb Dev FS: %d ROW: %x, PDA:%x\n",},\
/* 0x049a */{"device_fs.c", "srb_dfs_turn", 397, "DFS Turn %d->%d, skip %d",},\
/* 0x049b */{"device_fs.c", "srb_dfs_turn", 470, "FS %d rd err %d",},\
/* 0x049c */{"device_fs.c", "srb_dfs_turn", 474, "R File %d, Mem SZ %d, Read SZ %d/%d, off %d",},\
/* 0x049d */{"device_fs.c", "srb_dfs_turn", 518, "File %d, unread %d",},\
/* 0x049e */{"device_fs.c", "srb_dfs_turn", 550, "DFS wptr %x, log %x",},\
/* 0x049f */{"device_fs.c", "write_dfs_file", 884, "No Mem File %d",},\
/* 0x04a0 */{"device_fs.c", "write_dfs_file", 894, "No Page File %d",},\
/* 0x04a1 */{"evlog.c", "evlog_flush", 625, "handle: %p flags: 0x%x",},\
/* 0x04a2 */{"evlog.c", "evlog_read_dfs_stub", 202, "read %d %d %d %d get %d",},\
/* 0x04a3 */{"evlog.c", "evlog_read_dfs_stub", 218, "evlog sig invd %x",},\
/* 0x04a4 */{"evlog.c", "evlog_read_internal_buffer", 716, "there is no log in buf",},\
/* 0x04a5 */{"evlog.c", "evlog_read_to_host", 843, "evlog not ready!",},\
/* 0x04a6 */{"evlog.c", "evlog_read_to_host", 853, "evlog read internal",},\
/* 0x04a7 */{"evlog.c", "evlog_read_to_host", 856, "evlog read dfs",},\
/* 0x04a8 */{"evlog.c", "evlog_read_to_host", 868, "evlog read dfs bypass, read internal",},\
/* 0x04a9 */{"evlog.c", "evlog_tmp_to_buf", 400, "evt %d dropped",},\
};


#define EVID_FMT_CRC32 0x37f4d266

