[Feature]add MT2731_MP2_MR2_SVN388 baseline version
Change-Id: Ief04314834b31e27effab435d3ca8ba33b499059
diff --git a/src/bsp/scatter/tools/bch b/src/bsp/scatter/tools/bch
new file mode 100755
index 0000000..4954ae1
--- /dev/null
+++ b/src/bsp/scatter/tools/bch
Binary files differ
diff --git a/src/bsp/scatter/tools/nand-utils/README b/src/bsp/scatter/tools/nand-utils/README
new file mode 100644
index 0000000..16294ea
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/README
@@ -0,0 +1,12 @@
+usage
+
+1. ramdomizer.py: in_image, out_image, randomizer_type, sec_reseed enable, page size, spare size, sector size, page per block, ppen, vendor
+e.g: python randomizer.py nand_storage_image/TC58TEG5DCJTA00_rand_off_ecc.bin nand_storage_image/random.bin 'SS' 1 16384 1280 1024 256 0 "TSB"
+
+2. gen_storage_image.py: NAND device name(reference nand_device_list.txt), in_image, out_image, rand_en
+e.g: python gen_storage_image.py F59D4G81A-45TG-18V nand_storage_image/GPT_2048_W1_64_FIT.bin nand_storage_image/F59D4G81A-45TG-18V-storage-image.bin 0
+
+3. gen_nand_header.py: NAND device name(reference nand_device_list.txt)
+e.g: python gen_nand_header.py TH58TFG8DDLAB4C
+
+If want to ignore .pyc file, please use python -B xxx.py
diff --git a/src/bsp/scatter/tools/nand-utils/__init__.py b/src/bsp/scatter/tools/nand-utils/__init__.py
new file mode 100755
index 0000000..e69de29
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/__init__.py
diff --git a/src/bsp/scatter/tools/nand-utils/ac_calculator/ac_calculator.py b/src/bsp/scatter/tools/nand-utils/ac_calculator/ac_calculator.py
new file mode 100755
index 0000000..4fe91b7
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ac_calculator/ac_calculator.py
@@ -0,0 +1,493 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import struct
+import os
+import math
+import xml.dom.minidom
+
+# max strobe delay cycle
+max_strobe_dly = 3
+
+def calculate_sdr_acccon(ac, rate):
+ # turn clock rate from HZ into KHZ
+ rate /= 1000
+ # calculate tpoecs
+ tpoecs = max(ac["tALH"], ac["tCLH"])
+ tpoecs = int(math.ceil(float(tpoecs) * rate / 1000000))
+ tpoecs &= 0xf
+ # calculate tprecs
+ tprecs = max(ac["tCLS"], ac["tALS"])
+ tprecs = int(math.ceil(float(tprecs) * rate / 1000000))
+ tprecs &= 0x3f
+ # calculate tc2r
+ tc2r = int(math.ceil(float(ac["tCR"]) * rate / 1000000)) - 1
+ tc2r = int(math.ceil(float(tc2r) / 2))
+ tc2r &= 0x3f
+ # calculate tw2r
+ tw2r = int(math.ceil(float(ac["tWHR"]) * rate / 1000000)) - 1
+ tw2r = int(math.ceil(float(tw2r) / 2))
+ tw2r &= 0xf;
+ # calculate twh
+ twh = max(ac["tREH"], ac["tWH"])
+ twh = int(math.ceil(float(twh) * rate / 1000000)) - 1
+ twh &= 0xf
+ # calculate twst
+ twst = 0
+ if (twh + 1) * 1000000 / rate < ac["tWC"]:
+ twst = ac["tWC"] - (twh + 1) * 1000000 / rate
+ twst = max(ac["tWP"], twst)
+ twst = int(math.ceil(float(twst) * rate / 1000000)) - 1
+ twst &= 0xf
+ # calculate trlt
+ trlt = 0
+ if (twh + 1) * 1000000 / rate < ac["tRC"]:
+ trlt = ac["tRC"] - (twh + 1) * 1000000 / rate
+ trlt = max(ac["tRP"], trlt)
+ trlt = int(math.ceil(float(trlt) * rate / 1000000)) - 1
+ trlt &= 0xf
+ # calculate strobe sel
+ tsel = 0
+ if (trlt + 1) * 1000000 / rate < ac["tREA"]:
+ tsel = int(math.ceil(float(ac["tREA"]) * rate / 1000000))
+ tsel -= trlt + 1
+ if tsel > max_strobe_dly:
+ trlt += tsel - max_strobe_dly
+ tsel = max_strobe_dly
+ # get acccon
+ acccon = (tpoecs) << 28 | (tprecs) << 22 | (tc2r) << 16 | (tw2r) << 12 | (twh) << 8 | (twst) << 4 | (trlt)
+
+ return (acccon, tsel)
+
+def check_sdr_acccon_match_spec(ac, rate, acccon):
+ # turn clock rate from HZ into KHZ
+ rate /= 1000
+ # check tWH
+ twh = ((acccon >> 8) & 0xf) + 1
+ if twh * 1000000 / rate < ac["tWH"]:
+ return 1
+ # check tREH
+ if twh * 1000000 / rate < ac["tREH"]:
+ return 1
+ # check tWP
+ twst = ((acccon >> 4) & 0xf) + 1
+ if twst * 1000000 / rate < ac["tWP"]:
+ return 1
+ # check tRP
+ trlt = (acccon & 0xf) + 1
+ if trlt * 1000000 / rate < ac["tRP"]:
+ return 1
+ # check tWC
+ if (twh + twst) * 1000000 / rate < ac["tWC"]:
+ return 1
+ # check tRC
+ if (twh + trlt) * 1000000 / rate < ac["tRC"]:
+ return 1
+ # check more below
+
+ return 0
+
+def calculate_sdr_speed(ac, acccon, array, rate):
+ # turn clock rate from HZ into KHZ
+ rate /= 1000
+
+ twh = ((acccon >> 8) & 0xf) + 1
+ twst = ((acccon >> 4) & 0xf) + 1
+ trlt = (acccon & 0xf) + 1
+ chunk = array["page_size"] + array["spare_size"]
+
+ # read speed
+ tread = (float)(twh + trlt) * 1000000 / rate
+ tread *= chunk
+ tread += ac["tR"]
+ tread /= 1000
+ rspeed = 1000000 / tread
+ rspeed *= array["page_size"] / 1024
+
+ # write speed
+ twrite = (float)(twh + twst) * 1000000 / rate
+ twrite *= chunk
+ twrite += ac["tPROG"]
+ twrite /= 1000
+ wspeed = 1000000 / twrite
+ wspeed *= array["page_size"] / 1024
+
+ # erase speed
+ terase = ac["tBERS"] / 1000
+ espeed = 1000000 / terase
+ espeed *= array["page_size"] * array["page_per_block"] / 1024
+
+ return (rspeed, wspeed, espeed)
+
+def get_array_para(nand):
+ array = {}
+ for node in nand.childNodes:
+ if node.nodeName != "entry":
+ continue
+ artype = node.getAttribute("type")
+ if artype == "name":
+ array["name"] = node.getAttribute("value")
+ elif artype == "page_size":
+ array["page_size"] = eval(node.getAttribute("value"))
+ elif artype == "spare_size":
+ array["spare_size"] = eval(node.getAttribute("value"))
+ elif artype == "page_per_block":
+ array["page_per_block"] = eval(node.getAttribute("value"))
+ print ("NAND: %s, page size: %d, spare size: %d, page per block: %d" %
+ (array["name"], array["page_size"], array["spare_size"], array["page_per_block"]))
+
+ return array
+
+def get_sdr_ac_timing(ac_timing):
+ # get AC timing parameter value
+ ac = {}
+ for node in ac_timing.childNodes:
+ if node.nodeName != "entry":
+ continue
+ actype = node.getAttribute("type")
+ if actype == "tREA":
+ ac["tREA"] = eval(node.getAttribute("value"))
+ elif actype == "tREH":
+ ac["tREH"] = eval(node.getAttribute("value"))
+ elif actype == "tCR":
+ ac["tCR"] = eval(node.getAttribute("value"))
+ elif actype == "tRP":
+ ac["tRP"] = eval(node.getAttribute("value"))
+ elif actype == "tWP":
+ ac["tWP"] = eval(node.getAttribute("value"))
+ elif actype == "tWH":
+ ac["tWH"] = eval(node.getAttribute("value"))
+ elif actype == "tWHR":
+ ac["tWHR"] = eval(node.getAttribute("value"))
+ elif actype == "tCLS":
+ ac["tCLS"] = eval(node.getAttribute("value"))
+ elif actype == "tALS":
+ ac["tALS"] = eval(node.getAttribute("value"))
+ elif actype == "tCLH":
+ ac["tCLH"] = eval(node.getAttribute("value"))
+ elif actype == "tALH":
+ ac["tALH"] = eval(node.getAttribute("value"))
+ elif actype == "tWC":
+ ac["tWC"] = eval(node.getAttribute("value"))
+ elif actype == "tRC":
+ ac["tRC"] = eval(node.getAttribute("value"))
+ elif actype == "tR":
+ ac["tR"] = eval(node.getAttribute("value"))
+ elif actype == "tPROG":
+ ac["tPROG"] = eval(node.getAttribute("value"))
+ elif actype == "tBERS":
+ ac["tBERS"] = eval(node.getAttribute("value"))
+ print ("tR: %d, tPROG: %d, tBERS: %d ns" % (ac["tR"], ac["tPROG"], ac["tBERS"]))
+ return ac
+
+def sdr_calculator(nand, freq):
+ print ("This is SDR mode calculator!!")
+ nand_file = "./sdr/" + nand
+ doc_nand = xml.dom.minidom.parse(nand_file)
+ root_nand = doc_nand.documentElement
+ for nand_node in root_nand.childNodes:
+ if nand_node.nodeName == "ac_timing":
+ ac = get_sdr_ac_timing(nand_node)
+ elif nand_node.nodeName == "array":
+ array = get_array_para(nand_node)
+
+ # get frequency
+ freq_file = "./freq/" + freq
+ root_freq = xml.dom.minidom.parse(freq_file)
+ for frequency in root_freq.childNodes:
+ if frequency.nodeName == "frequency":
+ break
+
+ divider = eval(frequency.getAttribute("divider"))
+
+ # calculate acccon, stobe, performance
+ print ("Read IO speed: %.2f KB/s, Write IO speed: %.2f KB/s" %
+ ((1000000000 / float(ac["tRC"]) / 1024), (1000000000 / float(ac["tWC"]) / 1024)))
+ out_format = "{:^12}\t{:^12}\t{:^5}\t{:^12}\t{:^12}\t{:^12}\t"
+ print (out_format.format("freq","acccon","strobe","read(KB/s)","write(KB/s)", "erase(KB/s)"))
+ performance = []
+ for node in frequency.childNodes:
+ if node.nodeName != "entry":
+ continue
+ rate = eval(node.getAttribute("value"))
+ rate /= divider
+ freq_name = node.getAttribute("name")
+ (acccon, strobe) = calculate_sdr_acccon(ac, rate)
+ acccon_match = check_sdr_acccon_match_spec(ac, rate, acccon)
+ if acccon_match > 1:
+ print ("acccon %#x strobe %d not match spec" % (acccon, strobe))
+ raise Exception("not match spec")
+ (rspeed, wspeed, espeed) = calculate_sdr_speed(ac, acccon, array, rate)
+ rate *= divider
+ print (out_format.format(rate, hex(acccon), strobe, format(rspeed, ".2f"), \
+ format(wspeed, ".2f"), espeed))
+ performance.append({"rate":rate, "acccon":hex(acccon), "strobe":strobe, \
+ "rspeed":rspeed, "wspeed":wspeed, "espeed":espeed})
+
+ best_read = best_write = 0
+ for best in performance:
+ if best["rspeed"] > best_read:
+ best_read = best["rspeed"]
+ best_read_idx = performance.index(best)
+ if best["wspeed"] > best_write:
+ best_write = best["wspeed"]
+ best_write_idx = performance.index(best)
+ print ("frequency[%d] has the best read performance [%.2f KB/s]" %
+ (performance[best_read_idx]["rate"], performance[best_read_idx]["rspeed"]))
+ print ("frequency[%d] has the best write performance [%.2f KB/s]" %
+ (performance[best_write_idx]["rate"], performance[best_read_idx]["wspeed"]))
+
+def get_onfi_ac_timing(ac_timing):
+ # get AC timing parameter value
+ ac = {}
+ for node in ac_timing.childNodes:
+ if node.nodeName != "entry":
+ continue
+ actype = node.getAttribute("type")
+ if actype == "tCAD":
+ ac["tCAD"] = eval(node.getAttribute("value"))
+ elif actype == "tWRCK":
+ ac["tWRCK"] = eval(node.getAttribute("value"))
+ elif actype == "tDQSCK":
+ ac["tDQSCK"] = eval(node.getAttribute("value"))
+ elif actype == "tWHR":
+ ac["tWHR"] = eval(node.getAttribute("value"))
+ elif actype == "tWPRE":
+ ac["tWPRE"] = eval(node.getAttribute("value"))
+ elif actype == "tWPST":
+ ac["tWPST"] = eval(node.getAttribute("value"))
+ elif actype == "rate_max":
+ ac["rate_max"] = eval(node.getAttribute("value"))
+ elif actype == "tR":
+ ac["tR"] = eval(node.getAttribute("value"))
+ elif actype == "tPROG":
+ ac["tPROG"] = eval(node.getAttribute("value"))
+ elif actype == "tBERS":
+ ac["tBERS"] = eval(node.getAttribute("value"))
+ print ("tR: %d, tPROG: %d, tBERS: %d ns" % (ac["tR"], ac["tPROG"], ac["tBERS"]))
+
+ ac["tCKWR"] = ac["tDQSCK"]
+
+ return ac
+
+def calculate_onfi_acccon(ac, rate):
+ # turn clock rate from HZ into KHZ
+ rate /= 1000
+ # calculate tWPRE, tWRST, tCKWR
+ ac["tWPRE_real"] = int(math.ceil(float(ac["tWPRE"]) * 1000000 / rate))
+ ac["tWPST_real"] = int(math.ceil(float(ac["tWPST"]) * 1000000 / rate))
+ ac["tCKWR"] = int(math.ceil(math.ceil(float(ac["tDQSCK"]) * rate / 1000000) * 1000000 / rate))
+ # acccon register setting
+ # calculate tprecs
+ tprecs = max(ac["tCAD"], ac["tWRCK"])
+ if ac["tWPRE_real"] > int(math.ceil(1.5 * 1000000 / rate)):
+ tprecs = max(tprecs, ac["tWPRE_real"] - int(math.ceil(1.5 * 1000000 / rate)))
+ tprecs = int(math.ceil(float(tprecs) * rate / 1000000))
+ tprecs &= 0x3f;
+ # calculate tw2r
+ tw2r = int(math.ceil(float(ac["tWHR"]) * rate / 1000000))
+ tw2r = int(math.ceil(float(tw2r - 1) / 2))
+ tw2r &= 0xf
+ acccon = (tprecs) << 22 | (tw2r) << 12
+
+ # acccon1 register setting
+ # calculate trdpst
+ trdpst = int(math.ceil(float(ac["tCKWR"]) * rate / 1000000)) - 1
+ trdpst &= 0x3f
+ # calculate twrpst
+ twrpst = int(math.ceil(float(ac["tWPST_real"]) * rate / 1000000)) - 1
+ twrpst &= 0x3f
+ acccon1 = (trdpst) << 8 | (twrpst)
+
+ return (acccon, acccon1)
+
+def get_toggle_ac_timing(ac_timing):
+ # get AC timing parameter value
+ ac = {}
+ for node in ac_timing.childNodes:
+ if node.nodeName != "entry":
+ continue
+ actype = node.getAttribute("type")
+ if actype == "tCH":
+ ac["tCH"] = eval(node.getAttribute("value"))
+ elif actype == "tCALS":
+ ac["tCALS"] = eval(node.getAttribute("value"))
+ elif actype == "tCALH":
+ ac["tCALH"] = eval(node.getAttribute("value"))
+ elif actype == "tWPRE":
+ ac["tWPRE"] = eval(node.getAttribute("value"))
+ elif actype == "tWPST":
+ ac["tWPST"] = eval(node.getAttribute("value"))
+ elif actype == "tWPSTH":
+ ac["tWPSTH"] = eval(node.getAttribute("value"))
+ elif actype == "tCR":
+ ac["tCR"] = eval(node.getAttribute("value"))
+ elif actype == "tDQSRE":
+ ac["tDQSRE"] = eval(node.getAttribute("value"))
+ elif actype == "tRPSTH":
+ ac["tRPSTH"] = eval(node.getAttribute("value"))
+ elif actype == "tCDQSS":
+ ac["tCDQSS"] = eval(node.getAttribute("value"))
+ elif actype == "tWHR":
+ ac["tWHR"] = eval(node.getAttribute("value"))
+ elif actype == "rate_max":
+ ac["rate_max"] = eval(node.getAttribute("value"))
+ elif actype == "tR":
+ ac["tR"] = eval(node.getAttribute("value"))
+ elif actype == "tPROG":
+ ac["tPROG"] = eval(node.getAttribute("value"))
+ elif actype == "tBERS":
+ ac["tBERS"] = eval(node.getAttribute("value"))
+ print ("tR: %d, tPROG: %d, tBERS: %d ns" % (ac["tR"], ac["tPROG"], ac["tBERS"]))
+
+ return ac
+
+def calculate_toggle_acccon(ac, rate):
+ # turn clock rate from HZ into KHZ
+ rate /= 1000
+ # calculate tRPST
+ ac["tRPST"] = ac["tDQSRE"] + 0.5 * 1000000 / rate
+ # acccon register setting
+ # calculate tpoecs
+ tpoecs = max(max(ac["tCALH"], ac["tWPSTH"]), ac["tRPSTH"])
+ tpoecs = int(math.ceil(float(tpoecs) * rate / 1000000)) - 1
+ tpoecs &= 0xf
+ # calculate tprecs
+ tprecs = max(ac["tCALS"], ac["tCDQSS"])
+ tprecs = int(math.ceil(float(tprecs) * rate / 1000000)) - 1
+ tprecs &= 0x3f
+ # calculate tc2r
+ tc2r = math.ceil(float(ac["tCR"]) * rate / 1000000) - 1
+ tc2r = int(math.ceil(tc2r / 2))
+ tc2r &= 0x3f
+ # calculate tw2r
+ tw2r = math.ceil(float(ac["tWHR"]) * rate / 1000000) - 1
+ tw2r = int(math.ceil(tw2r / 2))
+ tw2r &= 0x3f
+ # calculate twh
+ twh = max(ac["tCH"], ac["tCALH"])
+ twh = int(math.ceil(float(twh) * rate / 1000000)) - 1
+ twh &= 0xf
+ # calculate twst
+ twst = int(math.ceil(float(ac["tCALS"]) * rate / 1000000)) - 1
+ twst &= 0xf
+ trlt = 0
+ acccon = (tpoecs) << 28 | (tprecs) << 22 | (tc2r) << 16 | (tw2r) << 12 | (twh) << 8 | (twst) << 4 | (trlt)
+
+ # acccon1 register setting
+ # calculate trdpre
+ trdpre = int(math.ceil(float(ac["tWPRE"]) * rate / 1000000)) - 1
+ trdpre &= 0x3f
+ # calculate trdpst
+ trdpst = int(math.ceil(float(ac["tRPST"]) * rate / 1000000)) - 1
+ trdpst &= 0x3f
+ # calculate twrpre
+ twrpre = int(math.ceil(float(ac["tWPRE"]) * rate / 1000000)) - 1
+ twrpre &= 0x3f
+ # calculate twrpst
+ twrpst = int(math.ceil(float(ac["tWPST"]) * rate / 1000000)) - 1
+ twrpst &= 0x3f
+ acccon1 = (trdpre << 24) | (twrpre) << 16 | (trdpst) << 8 | (twrpst)
+
+ return (acccon, acccon1)
+
+def calculate_ddr_speed(ac, array, rate):
+ # turn clock rate from HZ into KHZ
+ rate /= 1000
+
+ chunk = array["page_size"] + array["spare_size"]
+
+ # read speed
+ tread = 1000000 / float(rate * 2)
+ tread *= chunk
+ tread += ac["tR"]
+ tread /= 1000
+ rspeed = 1000000 / tread
+ rspeed *= array["page_size"] / 1024
+
+ # write speed
+ twrite = 1000000 / float(rate * 2)
+ twrite *= chunk
+ twrite += ac["tPROG"]
+ twrite /= 1000
+ wspeed = 1000000 / twrite
+ wspeed *= array["page_size"] / 1024
+
+ # erase speed
+ terase = ac["tBERS"] / 1000
+ espeed = 1000000 / terase
+ espeed *= array["page_size"] * array["page_per_block"] / 1024
+
+ return (rspeed, wspeed, espeed)
+
+def ddr_calculator(nand, freq, mode):
+ print ("This is %s mode calculator!!" % mode)
+ nand_file = "./" + mode + "/" + nand
+ doc_nand = xml.dom.minidom.parse(nand_file)
+ root_nand = doc_nand.documentElement
+ for nand_node in root_nand.childNodes:
+ if nand_node.nodeName == "ac_timing":
+ if mode == "ddr_onfi":
+ ac = get_onfi_ac_timing(nand_node)
+ elif mode == "ddr_toggle":
+ ac = get_toggle_ac_timing(nand_node)
+ else:
+ raise Exception("unsupported ddr mode!!")
+ elif nand_node.nodeName == "array":
+ array = get_array_para(nand_node)
+
+ # get frequency
+ freq_file = "./freq/" + freq
+ root_freq = xml.dom.minidom.parse(freq_file)
+ for frequency in root_freq.childNodes:
+ if frequency.nodeName == "frequency":
+ break
+
+ divider = eval(frequency.getAttribute("divider"))
+
+ out_format = "{:^12}\t{:^12}\t{:^12}\t{:^12}\t{:^12}\t{:^12}\t"
+ print (out_format.format("freq","acccon","acccon1","read(KB/s)","write(KB/s)", "erase(KB/s)"))
+ rate_invalid = []
+ for node in frequency.childNodes:
+ if node.nodeName != "entry":
+ continue
+ rate = eval(node.getAttribute("value"))
+ rate /= divider
+ if rate > ac["rate_max"]:
+ rate_invalid.append(rate * divider)
+ continue
+ freq_name = node.getAttribute("name")
+ if mode == "ddr_onfi":
+ (acccon, acccon1) = calculate_onfi_acccon(ac, rate)
+ elif mode == "ddr_toggle":
+ (acccon, acccon1) = calculate_toggle_acccon(ac, rate)
+ else:
+ raise Exception("unsupported ddr mode!!")
+ (rspeed, wspeed, espeed) = calculate_ddr_speed(ac, array, rate)
+ rate *= divider
+ print (out_format.format(rate, hex(acccon), hex(acccon1), format(rspeed, ".2f"), \
+ format(wspeed, ".2f"), espeed))
+
+ for rate in rate_invalid:
+ print ("rate[%d] not supported!" % rate)
+
+def ddr_toggle_calculator(nand, freq):
+ print ("This is Toggle DDR mode calculator!!")
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('mode', help = 'working mode: sdr, ddr_onfi, ddr_toggle')
+ parser.add_argument('nand', help= 'nand AC timing xml file')
+ parser.add_argument('freq', help = 'frequency file')
+ args = parser.parse_args()
+
+ if args.mode == "sdr":
+ sdr_calculator(args.nand, args.freq)
+ elif args.mode == "ddr_onfi" or args.mode == "ddr_toggle":
+ ddr_calculator(args.nand, args.freq, args.mode)
+ else:
+ raise Exception("Working mode not supported!")
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/ac_calculator/ddr_onfi/MT29F64G08CBCGB.xml b/src/bsp/scatter/tools/nand-utils/ac_calculator/ddr_onfi/MT29F64G08CBCGB.xml
new file mode 100644
index 0000000..026a9d8
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ac_calculator/ddr_onfi/MT29F64G08CBCGB.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<nand>
+ <array>
+ <!--size value must be with "byte" unit-->
+ <entry type="name" value="MT29F64G08CBCGB" descript="nand name"/>
+ <entry type="page_size" value="16384" descript="page size"/>
+ <entry type="spare_size" value="2208" descript="spare size"/>
+ <entry type="page_per_block" value="512" descript="page per block"/>
+ </array>
+ <ac_timing>
+ <!--timing value not highlight must be with "ns" unit-->
+ <entry type="tCAD" value="25" descript="Command, address data delay"/>
+ <entry type="tWPRE" value="1.5" descript="unit tCK, DQS write preamble"/>
+ <entry type="tWPST" value="1.5" descript="unit tCK, DQS write postamble"/>
+ <entry type="tWRCK" value="20" descript="W/R# low to data output cycle"/>
+ <entry type="tDQSCK" value="20" descript="Access window of DQS from CLK"/>
+ <entry type="tCKWR" value="div_round_up(tDQSCK, tCK)" descript="unit tCK, Data output end to W/R# high"/>
+ <entry type="tWHR" value="80" descript="Command cycle to data output"/>
+ <entry type="tR" value="52000" descript="data transfer from cell to data register"/>
+ <entry type="tPROG" value="330000" descript="page program time"/>
+ <entry type="tBERS" value="10000000" descript="block erase time"/>
+ <entry type="rate_max" value="100000000" descript="max frequency supported (HZ)"/>
+ </ac_timing>
+</nand>
diff --git a/src/bsp/scatter/tools/nand-utils/ac_calculator/ddr_toggle/TC58TEG6DDLTA00.xml b/src/bsp/scatter/tools/nand-utils/ac_calculator/ddr_toggle/TC58TEG6DDLTA00.xml
new file mode 100644
index 0000000..f669901
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ac_calculator/ddr_toggle/TC58TEG6DDLTA00.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<nand>
+ <array>
+ <!--size value must be with "byte" unit-->
+ <entry type="name" value="TC58TEG6DDLTA00" descript="nand name"/>
+ <entry type="page_size" value="16384" descript="page size"/>
+ <entry type="spare_size" value="1280" descript="spare size"/>
+ <entry type="page_per_block" value="256" descript="page per block"/>
+ </array>
+ <ac_timing>
+ <!--timing value not highlight must be with "ns" unit-->
+ <entry type="tCH" value="5" descript="CE# hold time"/>
+ <entry type="tCALS" value="15" descript="CLE/ALE setup time"/>
+ <entry type="tCALH" value="5" descript="CLE/ALE hold time"/>
+ <entry type="tWPRE" value="15" descript="Write preamble"/>
+ <entry type="tWPST" value="6.5" descript="Write postamble"/>
+ <entry type="tWPSTH" value="25" descript="Write postamble hold time"/>
+ <entry type="tCR" value="10" descript="CE# low to RE# low"/>
+ <entry type="tDQSRE" value="25" descript="RE# to DQS and DQ delay"/>
+ <entry type="tRPST" value="tDQSRE+0.5*tRC" descript="Read postamble"/>
+ <entry type="tRPSTH" value="25" descript="Read postamble hold time"/>
+ <entry type="tCDQSS" value="100" descript="DQS setup time for data input mode start"/>
+ <entry type="tWHR" value="120" descript="WE# high to RE# low"/>
+ <entry type="tR" value="50000" descript="data transfer from cell to data register"/>
+ <entry type="tPROG" value="1400000" descript="page program time"/>
+ <entry type="tBERS" value="5000000" descript="block erase time"/>
+ <entry type="rate_max" value="100000000" descript="max frequency supported (HZ)"/>
+ </ac_timing>
+</nand>
diff --git a/src/bsp/scatter/tools/nand-utils/ac_calculator/freq/mt8133.xml b/src/bsp/scatter/tools/nand-utils/ac_calculator/freq/mt8133.xml
new file mode 100644
index 0000000..c791fd2
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ac_calculator/freq/mt8133.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--divider: 1: clocks below are 1x clock, 2: clocks below are 2x clock-->
+<frequency divider="2">
+ <!--rate unit: HZ-->
+ <entry name="26m" value="26000000"/>
+ <entry name="syspll2_d2" value="182000000"/>
+ <entry name="syspll_d7" value="156000000"/>
+ <entry name="syspll_d3" value="364000000"/>
+ <entry name="syspll2_d4" value="91000000"/>
+ <entry name="msdcpll_d2" value="200000000"/>
+ <entry name="univpll1_d2" value="312000000"/>
+ <entry name="univpll_d5" value="249600000"/>
+</frequency>
diff --git a/src/bsp/scatter/tools/nand-utils/ac_calculator/sdr/W29N08GZSIBA.xml b/src/bsp/scatter/tools/nand-utils/ac_calculator/sdr/W29N08GZSIBA.xml
new file mode 100644
index 0000000..85cf677
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ac_calculator/sdr/W29N08GZSIBA.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<nand>
+ <array>
+ <!--size value must be with "byte" unit-->
+ <entry type="name" value="W29N08GZSIBA" descript="nand name"/>
+ <entry type="page_size" value="2048" descript="page size"/>
+ <entry type="spare_size" value="64" descript="spare size"/>
+ <entry type="page_per_block" value="64" descript="page per block"/>
+ </array>
+ <ac_timing>
+ <!--timing value must be with "ns" unit-->
+ <entry type="tREA" value="25" descript="RE# access time"/>
+ <entry type="tREH" value="10" descript="RE# high hold time"/>
+ <entry type="tCR" value="0" descript="CE# low to RE# low. If no this para, set 0"/>
+ <entry type="tRP" value="12" descript="RE# pulse width"/>
+ <entry type="tWP" value="12" descript="WE# pulse width"/>
+ <entry type="tWH" value="10" descript="WE# high hold time"/>
+ <entry type="tWHR" value="80" descript="WE# high to RE# low"/>
+ <entry type="tCLS" value="10" descript="CLE setup time"/>
+ <entry type="tALS" value="10" descript="ALE setup time"/>
+ <entry type="tCLH" value="5" descript="CLE hold time"/>
+ <entry type="tALH" value="5" descript="ALE hold time"/>
+ <entry type="tWC" value="35" descript="write cycle time"/>
+ <entry type="tRC" value="35" descript="read cycle time"/>
+ <entry type="tR" value="25000" descript="data transfer from cell to data register"/>
+ <entry type="tPROG" value="250000" descript="page program time"/>
+ <entry type="tBERS" value="2000000" descript="block erase time"/>
+ </ac_timing>
+</nand>
diff --git a/src/bsp/scatter/tools/nand-utils/ecc_bch.py b/src/bsp/scatter/tools/nand-utils/ecc_bch.py
new file mode 100755
index 0000000..6e2c80e
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ecc_bch.py
@@ -0,0 +1,690 @@
+#!/usr/bin/env python3
+
+import math
+
+M_14_4 = ((0x85,0x5c,0x9a,0x89,0x8a,0x48,0x9b,0x01),
+ (0x0a,0xb9,0x34,0x13,0x15,0x91,0x36,0x03),
+ (0x14,0x72,0x69,0x26,0x2a,0x22,0x6d,0x06),
+ (0x28,0xe4,0xd2,0x4c,0x54,0x44,0xda,0x0c),
+ (0x50,0xc8,0xa5,0x99,0xa8,0x88,0xb4,0x19),
+ (0xa0,0x90,0x4b,0x33,0x51,0x11,0x69,0x33),
+ (0x40,0x21,0x97,0x66,0xa2,0x22,0xd2,0x66),
+ (0x80,0x42,0x2e,0xcd,0x44,0x45,0xa4,0xcd))
+
+M_14_6 = ((0xf9,0x0f,0x2a,0x86,0x79,0xef,0x10,0x33,0xaf,0x5c,0x12,0x00),
+ (0xf2,0x1f,0x54,0x0c,0xf3,0xde,0x21,0x66,0x5e,0xb9,0x24,0x00),
+ (0xe4,0x3f,0xa8,0x18,0xe6,0xbd,0x43,0xcc,0xbc,0x72,0x49,0x00),
+ (0xc8,0x7f,0x50,0x31,0xcc,0x7b,0x87,0x98,0x79,0xe5,0x92,0x00),
+ (0x90,0xff,0xa0,0x62,0x98,0xf7,0x0e,0x31,0xf3,0xca,0x25,0x01),
+ (0x20,0xff,0x41,0xc5,0x30,0xef,0x1d,0x62,0xe6,0x95,0x4b,0x02),
+ (0x40,0xfe,0x83,0x8a,0x61,0xde,0x3b,0xc4,0xcc,0x2b,0x97,0x04),
+ (0x80,0xfc,0x07,0x15,0xc3,0xbc,0x77,0x88,0x99,0x57,0x2e,0x09))
+
+M_14_8 = ((0xff,0xbc,0xd3,0xff,0x94,0x43,0x78,0xdc,0x34,0x8f,0x9c,0x67,0x75,0x68,0x01),
+ (0xfe,0x79,0xa7,0xff,0x29,0x87,0xf0,0xb8,0x69,0x1e,0x39,0xcf,0xea,0xd0,0x02),
+ (0xfc,0xf3,0x4e,0xff,0x53,0x0e,0xe1,0x71,0xd3,0x3c,0x72,0x9e,0xd5,0xa1,0x05),
+ (0xf8,0xe7,0x9d,0xfe,0xa7,0x1c,0xc2,0xe3,0xa6,0x79,0xe4,0x3c,0xab,0x43,0x0b),
+ (0xf0,0xcf,0x3b,0xfd,0x4f,0x39,0x84,0xc7,0x4d,0xf3,0xc8,0x79,0x56,0x87,0x16),
+ (0xe0,0x9f,0x77,0xfa,0x9f,0x72,0x08,0x8f,0x9b,0xe6,0x91,0xf3,0xac,0x0e,0x2d),
+ (0xc0,0x3f,0xef,0xf4,0x3f,0xe5,0x10,0x1e,0x37,0xcd,0x23,0xe7,0x59,0x1d,0x5a),
+ (0x80,0x7f,0xde,0xe9,0x7f,0xca,0x21,0x3c,0x6e,0x9a,0x47,0xce,0xb3,0x3a,0xb4))
+
+M_14_10 = ((0x39,0xb4,0xc5,0x64,0x41,0x71,0xe9,0xdc,0x14,0x76,0x1f,0x20,0xc4,0xdb,0xb7,0xb4,0x92,0x16,0x00),
+ (0x72,0x68,0x8b,0xc9,0x82,0xe2,0xd2,0xb9,0x29,0xec,0x3e,0x40,0x88,0xb7,0x6f,0x69,0x25,0x2d,0x00),
+ (0xe4,0xd0,0x16,0x93,0x05,0xc5,0xa5,0x73,0x53,0xd8,0x7d,0x80,0x10,0x6f,0xdf,0xd2,0x4a,0x5a,0x00),
+ (0xc8,0xa1,0x2d,0x26,0x0b,0x8a,0x4b,0xe7,0xa6,0xb0,0xfb,0x00,0x21,0xde,0xbe,0xa5,0x95,0xb4,0x00),
+ (0x90,0x43,0x5b,0x4c,0x16,0x14,0x97,0xce,0x4d,0x61,0xf7,0x01,0x42,0xbc,0x7d,0x4b,0x2b,0x69,0x01),
+ (0x20,0x87,0xb6,0x98,0x2c,0x28,0x2e,0x9d,0x9b,0xc2,0xee,0x03,0x84,0x78,0xfb,0x96,0x56,0xd2,0x02),
+ (0x40,0x0e,0x6d,0x31,0x59,0x50,0x5c,0x3a,0x37,0x85,0xdd,0x07,0x08,0xf1,0xf6,0x2d,0xad,0xa4,0x05),
+ (0x80,0x1c,0xda,0x62,0xb2,0xa0,0xb8,0x74,0x6e,0x0a,0xbb,0x0f,0x10,0xe2,0xed,0x5b,0x5a,0x49,0x0b))
+
+M_14_12 = ((0x09,0xba,0x4b,0x25,0xd5,0xac,0x8b,0x18,0x40,0xfa,0x59,0x74,0xbd,0x76,0x3c,0xaf,0x8e,0x99,0x61,0xd4,0x60,0x01),
+ (0x12,0x74,0x97,0x4a,0xaa,0x59,0x17,0x31,0x80,0xf4,0xb3,0xe8,0x7a,0xed,0x78,0x5e,0x1d,0x33,0xc3,0xa8,0xc1,0x02),
+ (0x24,0xe8,0x2e,0x95,0x54,0xb3,0x2e,0x62,0x00,0xe9,0x67,0xd1,0xf5,0xda,0xf1,0xbc,0x3a,0x66,0x86,0x51,0x83,0x05),
+ (0x48,0xd0,0x5d,0x2a,0xa9,0x66,0x5d,0xc4,0x00,0xd2,0xcf,0xa2,0xeb,0xb5,0xe3,0x79,0x75,0xcc,0x0c,0xa3,0x06,0x0b),
+ (0x90,0xa0,0xbb,0x54,0x52,0xcd,0xba,0x88,0x01,0xa4,0x9f,0x45,0xd7,0x6b,0xc7,0xf3,0xea,0x98,0x19,0x46,0x0d,0x16),
+ (0x20,0x41,0x77,0xa9,0xa4,0x9a,0x75,0x11,0x03,0x48,0x3f,0x8b,0xae,0xd7,0x8e,0xe7,0xd5,0x31,0x33,0x8c,0x1a,0x2c),
+ (0x40,0x82,0xee,0x52,0x49,0x35,0xeb,0x22,0x06,0x90,0x7e,0x16,0x5d,0xaf,0x1d,0xcf,0xab,0x63,0x66,0x18,0x35,0x58),
+ (0x80,0x04,0xdd,0xa5,0x92,0x6a,0xd6,0x45,0x0c,0x20,0xfd,0x2c,0xba,0x5e,0x3b,0x9e,0x57,0xc7,0xcc,0x30,0x6a,0xb0))
+
+M_14_14 = (
+ (0x99,0xb1,0x75,0x12,0xb5,0xb2,0xee,0x98,0xe1,0x46,0x4a,0x20,0xd7,0xc9,0xfd,0x38,0xff,0x67,0xc8,0xff,0xa6,0xe7,0xcb,0xe5,0x13,0x00),
+ (0x32,0x63,0xeb,0x24,0x6a,0x65,0xdd,0x31,0xc3,0x8d,0x94,0x40,0xae,0x93,0xfb,0x71,0xfe,0xcf,0x90,0xff,0x4d,0xcf,0x97,0xcb,0x27,0x00),
+ (0x64,0xc6,0xd6,0x49,0xd4,0xca,0xba,0x63,0x86,0x1b,0x29,0x81,0x5c,0x27,0xf7,0xe3,0xfc,0x9f,0x21,0xff,0x9b,0x9e,0x2f,0x97,0x4f,0x00),
+ (0xc8,0x8c,0xad,0x93,0xa8,0x95,0x75,0xc7,0x0c,0x37,0x52,0x02,0xb9,0x4e,0xee,0xc7,0xf9,0x3f,0x43,0xfe,0x37,0x3d,0x5f,0x2e,0x9f,0x00),
+ (0x90,0x19,0x5b,0x27,0x51,0x2b,0xeb,0x8e,0x19,0x6e,0xa4,0x04,0x72,0x9d,0xdc,0x8f,0xf3,0x7f,0x86,0xfc,0x6f,0x7a,0xbe,0x5c,0x3e,0x01),
+ (0x20,0x33,0xb6,0x4e,0xa2,0x56,0xd6,0x1d,0x33,0xdc,0x48,0x09,0xe4,0x3a,0xb9,0x1f,0xe7,0xff,0x0c,0xf9,0xdf,0xf4,0x7c,0xb9,0x7c,0x02),
+ (0x40,0x66,0x6c,0x9d,0x44,0xad,0xac,0x3b,0x66,0xb8,0x91,0x12,0xc8,0x75,0x72,0x3f,0xce,0xff,0x19,0xf2,0xbf,0xe9,0xf9,0x72,0xf9,0x04),
+ (0x80,0xcc,0xd8,0x3a,0x89,0x5a,0x59,0x77,0xcc,0x70,0x23,0x25,0x90,0xeb,0xe4,0x7e,0x9c,0xff,0x33,0xe4,0x7f,0xd3,0xf3,0xe5,0xf2,0x09))
+
+M_14_16 = (
+ (0x67,0x48,0x60,0x1c,0xa4,0x8a,0x25,0x51,0x86,0x8a,0x12,0x09,0x34,0xe5,0xfd,
+ 0xd7,0x8f,0x87,0x57,0x33,0x44,0x2e,0x6f,0x23,0xab,0x82,0xdd,0xe6,0x01),
+ (0xce,0x90,0xc0,0x38,0x48,0x15,0x4b,0xa2,0x0c,0x15,0x25,0x12,0x68,0xca,0xfb,
+ 0xaf,0x1f,0x0f,0xaf,0x66,0x88,0x5c,0xde,0x46,0x56,0x05,0xbb,0xcd,0x03),
+ (0x9c,0x21,0x81,0x71,0x90,0x2a,0x96,0x44,0x19,0x2a,0x4a,0x24,0xd0,0x94,0xf7,
+ 0x5f,0x3f,0x1e,0x5e,0xcd,0x10,0xb9,0xbc,0x8d,0xac,0x0a,0x76,0x9b,0x07),
+ (0x38,0x43,0x02,0xe3,0x20,0x55,0x2c,0x89,0x32,0x54,0x94,0x48,0xa0,0x29,0xef,
+ 0xbf,0x7e,0x3c,0xbc,0x9a,0x21,0x72,0x79,0x1b,0x59,0x15,0xec,0x36,0x0f),
+ (0x70,0x86,0x04,0xc6,0x41,0xaa,0x58,0x12,0x65,0xa8,0x28,0x91,0x40,0x53,0xde,
+ 0x7f,0xfd,0x78,0x78,0x35,0x43,0xe4,0xf2,0x36,0xb2,0x2a,0xd8,0x6d,0x1e),
+ (0xe0,0x0c,0x09,0x8c,0x83,0x54,0xb1,0x24,0xca,0x50,0x51,0x22,0x81,0xa6,0xbc,
+ 0xff,0xfa,0xf1,0xf0,0x6a,0x86,0xc8,0xe5,0x6d,0x64,0x55,0xb0,0xdb,0x3c),
+ (0xc0,0x19,0x12,0x18,0x07,0xa9,0x62,0x49,0x94,0xa1,0xa2,0x44,0x02,0x4d,0x79,
+ 0xff,0xf5,0xe3,0xe1,0xd5,0x0c,0x91,0xcb,0xdb,0xc8,0xaa,0x60,0xb7,0x79),
+ (0x80,0x33,0x24,0x30,0x0e,0x52,0xc5,0x92,0x28,0x43,0x45,0x89,0x04,0x9a,0xf2,
+ 0xfe,0xeb,0xc7,0xc3,0xab,0x19,0x22,0x97,0xb7,0x91,0x55,0xc1,0x6e,0xf3))
+
+M_14_18 = (
+ (0x05,0x2c,0x4b,0x17,0x5e,0x12,0x96,0x3a,0x12,0x8e,0x9d,0x4b,0xcb,0x85,0x8d,
+ 0xa5,0x7d,0x91,0x59,0x4e,0x86,0xb6,0x5a,0xca,0xc7,0x0c,0x3f,0x1c,0x20,0xd3,0x7e,0x1a,0x00),
+ (0x0a,0x58,0x96,0x2e,0xbc,0x24,0x2c,0x75,0x24,0x1c,0x3b,0x97,0x96,0x0b,0x1b,
+ 0x4b,0xfb,0x22,0xb3,0x9c,0x0c,0x6d,0xb5,0x94,0x8f,0x19,0x7e,0x38,0x40,0xa6,0xfd,0x34,0x00),
+ (0x14,0xb0,0x2c,0x5d,0x78,0x49,0x58,0xea,0x48,0x38,0x76,0x2e,0x2d,0x17,0x36,
+ 0x96,0xf6,0x45,0x66,0x39,0x19,0xda,0x6a,0x29,0x1f,0x33,0xfc,0x70,0x80,0x4c,0xfb,0x69,0x00),
+ (0x28,0x60,0x59,0xba,0xf0,0x92,0xb0,0xd4,0x91,0x70,0xec,0x5c,0x5a,0x2e,0x6c,
+ 0x2c,0xed,0x8b,0xcc,0x72,0x32,0xb4,0xd5,0x52,0x3e,0x66,0xf8,0xe1,0x00,0x99,0xf6,0xd3,0x00),
+ (0x50,0xc0,0xb2,0x74,0xe1,0x25,0x61,0xa9,0x23,0xe1,0xd8,0xb9,0xb4,0x5c,0xd8,
+ 0x58,0xda,0x17,0x99,0xe5,0x64,0x68,0xab,0xa5,0x7c,0xcc,0xf0,0xc3,0x01,0x32,0xed,0xa7,0x01),
+ (0xa0,0x80,0x65,0xe9,0xc2,0x4b,0xc2,0x52,0x47,0xc2,0xb1,0x73,0x69,0xb9,0xb0,
+ 0xb1,0xb4,0x2f,0x32,0xcb,0xc9,0xd0,0x56,0x4b,0xf9,0x98,0xe1,0x87,0x03,0x64,0xda,0x4f,0x03),
+ (0x40,0x01,0xcb,0xd2,0x85,0x97,0x84,0xa5,0x8e,0x84,0x63,0xe7,0xd2,0x72,0x61,
+ 0x63,0x69,0x5f,0x64,0x96,0x93,0xa1,0xad,0x96,0xf2,0x31,0xc3,0x0f,0x07,0xc8,0xb4,0x9f,0x06),
+ (0x80,0x02,0x96,0xa5,0x0b,0x2f,0x09,0x4b,0x1d,0x09,0xc7,0xce,0xa5,0xe5,0xc2,
+ 0xc6,0xd2,0xbe,0xc8,0x2c,0x27,0x43,0x5b,0x2d,0xe5,0x63,0x86,0x1f,0x0e,0x90,0x69,0x3f,0x0d))
+M_14_20 = (
+ (0xe1,0xa2,0x8a,0xab,0x20,0x3f,0xfa,0x57,0x9f,0x6b,0xe5,0x09,0x6b,0xb4,0xc2,0x9a,
+ 0x1d,0xaa,0xd3,0xde,0xd7,0x84,0x38,0x7a,0x50,0x9b,0x98,0x15,0xf1,0xd5,0xb5,0x2c,0x13,0x87,0x35,0x01),
+ (0xc2,0x45,0x15,0x57,0x41,0x7e,0xf4,0xaf,0x3e,0xd7,0xca,0x13,0xd6,0x68,0x85,0x35,
+ 0x3b,0x54,0xa7,0xbd,0xaf,0x09,0x71,0xf4,0xa0,0x36,0x31,0x2b,0xe2,0xab,0x6b,0x59,0x26,0x0e,0x6b,0x02),
+ (0x84,0x8b,0x2a,0xae,0x82,0xfc,0xe8,0x5f,0x7d,0xae,0x95,0x27,0xac,0xd1,0x0a,0x6b,
+ 0x76,0xa8,0x4e,0x7b,0x5f,0x13,0xe2,0xe8,0x41,0x6d,0x62,0x56,0xc4,0x57,0xd7,0xb2,0x4c,0x1c,0xd6,0x04),
+ (0x08,0x17,0x55,0x5c,0x05,0xf9,0xd1,0xbf,0xfa,0x5c,0x2b,0x4f,0x58,0xa3,0x15,0xd6,
+ 0xec,0x50,0x9d,0xf6,0xbe,0x26,0xc4,0xd1,0x83,0xda,0xc4,0xac,0x88,0xaf,0xae,0x65,0x99,0x38,0xac,0x09),
+ (0x10,0x2e,0xaa,0xb8,0x0a,0xf2,0xa3,0x7f,0xf5,0xb9,0x56,0x9e,0xb0,0x46,0x2b,0xac,
+ 0xd9,0xa1,0x3a,0xed,0x7d,0x4d,0x88,0xa3,0x07,0xb5,0x89,0x59,0x11,0x5f,0x5d,0xcb,0x32,0x71,0x58,0x13),
+ (0x20,0x5c,0x54,0x71,0x15,0xe4,0x47,0xff,0xea,0x73,0xad,0x3c,0x61,0x8d,0x56,0x58,
+ 0xb3,0x43,0x75,0xda,0xfb,0x9a,0x10,0x47,0x0f,0x6a,0x13,0xb3,0x22,0xbe,0xba,0x96,0x65,0xe2,0xb0,0x26),
+ (0x40,0xb8,0xa8,0xe2,0x2a,0xc8,0x8f,0xfe,0xd5,0xe7,0x5a,0x79,0xc2,0x1a,0xad,0xb0,
+ 0x66,0x87,0xea,0xb4,0xf7,0x35,0x21,0x8e,0x1e,0xd4,0x26,0x66,0x45,0x7c,0x75,0x2d,0xcb,0xc4,0x61,0x4d),
+ (0x80,0x70,0x51,0xc5,0x55,0x90,0x1f,0xfd,0xab,0xcf,0xb5,0xf2,0x84,0x35,0x5a,0x61,
+ 0xcd,0x0e,0xd5,0x69,0xef,0x6b,0x42,0x1c,0x3d,0xa8,0x4d,0xcc,0x8a,0xf8,0xea,0x5a,0x96,0x89,0xc3,0x9a))
+
+M_14_22 = (
+ (0x33,0xdb,0xdc,0x30,0x9c,0xe3,0xd0,0x5d,0x4f,0xfe,0x2f,0x46,0xe6,0x42,0xf9,0x14,0x3b,0xbf,
+ 0x84,0xff,0xc6,0x12,0xc8,0x8e,0x88,0x2d,0x62,0xf7,0xd7,0xdf,0x4a,0xfa,0x92,0x8a,0xd6,0x0c,0xb3,0xc9,0x13,0x00),
+ (0x66,0xb6,0xb9,0x61,0x38,0xc7,0xa1,0xbb,0x9e,0xfc,0x5f,0x8c,0xcc,0x85,0xf2,0x29,0x76,0x7e,
+ 0x09,0xff,0x8d,0x25,0x90,0x1d,0x11,0x5b,0xc4,0xee,0xaf,0xbf,0x95,0xf4,0x25,0x15,0xad,0x19,0x66,0x93,0x27,0x00),
+ (0xcc,0x6c,0x73,0xc3,0x70,0x8e,0x43,0x77,0x3d,0xf9,0xbf,0x18,0x99,0x0b,0xe5,0x53,0xec,0xfc,
+ 0x12,0xfe,0x1b,0x4b,0x20,0x3b,0x22,0xb6,0x88,0xdd,0x5f,0x7f,0x2b,0xe9,0x4b,0x2a,0x5a,0x33,0xcc,0x26,0x4f,0x00),
+ (0x98,0xd9,0xe6,0x86,0xe1,0x1c,0x87,0xee,0x7a,0xf2,0x7f,0x31,0x32,0x17,0xca,0xa7,0xd8,0xf9,
+ 0x25,0xfc,0x37,0x96,0x40,0x76,0x44,0x6c,0x11,0xbb,0xbf,0xfe,0x56,0xd2,0x97,0x54,0xb4,0x66,0x98,0x4d,0x9e,0x00),
+ (0x30,0xb3,0xcd,0x0d,0xc3,0x39,0x0e,0xdd,0xf5,0xe4,0xff,0x62,0x64,0x2e,0x94,0x4f,0xb1,0xf3,
+ 0x4b,0xf8,0x6f,0x2c,0x81,0xec,0x88,0xd8,0x22,0x76,0x7f,0xfd,0xad,0xa4,0x2f,0xa9,0x68,0xcd,0x30,0x9b,0x3c,0x01),
+ (0x60,0x66,0x9b,0x1b,0x86,0x73,0x1c,0xba,0xeb,0xc9,0xff,0xc5,0xc8,0x5c,0x28,0x9f,0x62,0xe7,
+ 0x97,0xf0,0xdf,0x58,0x02,0xd9,0x11,0xb1,0x45,0xec,0xfe,0xfa,0x5b,0x49,0x5f,0x52,0xd1,0x9a,0x61,0x36,0x79,0x02),
+ (0xc0,0xcc,0x36,0x37,0x0c,0xe7,0x38,0x74,0xd7,0x93,0xff,0x8b,0x91,0xb9,0x50,0x3e,0xc5,0xce,
+ 0x2f,0xe1,0xbf,0xb1,0x04,0xb2,0x23,0x62,0x8b,0xd8,0xfd,0xf5,0xb7,0x92,0xbe,0xa4,0xa2,0x35,0xc3,0x6c,0xf2,0x04),
+ (0x80,0x99,0x6d,0x6e,0x18,0xce,0x71,0xe8,0xae,0x27,0xff,0x17,0x23,0x73,0xa1,0x7c,0x8a,0x9d,
+ 0x5f,0xc2,0x7f,0x63,0x09,0x64,0x47,0xc4,0x16,0xb1,0xfb,0xeb,0x6f,0x25,0x7d,0x49,0x45,0x6b,0x86,0xd9,0xe4,0x09))
+
+M_14_24 = (
+ (0xe3,0x52,0x0e,0x48,0x62,0x13,0x72,0xa9,0x45,0x49,0x9d,0x16,0x6f,0x37,0x17,0x32,0xfe,0x9c,0xe1,0xe2,
+ 0x62,0xc9,0x86,0x96,0x28,0x92,0x8b,0x0b,0x24,0xb4,0x17,0xaa,0xed,0xa0,0x25,0x93,0xb2,0x58,0xad,0x57,0x18,0xee,0x01),
+ (0xc6,0xa5,0x1c,0x90,0xc4,0x26,0xe4,0x52,0x8b,0x92,0x3a,0x2d,0xde,0x6e,0x2e,0x64,0xfc,0x39,0xc3,0xc5,
+ 0xc5,0x92,0x0d,0x2d,0x51,0x24,0x17,0x17,0x48,0x68,0x2f,0x54,0xdb,0x41,0x4b,0x26,0x65,0xb1,0x5a,0xaf,0x30,0xdc,0x03),
+ (0x8c,0x4b,0x39,0x20,0x89,0x4d,0xc8,0xa5,0x16,0x25,0x75,0x5a,0xbc,0xdd,0x5c,0xc8,0xf8,0x73,0x86,0x8b,
+ 0x8b,0x25,0x1b,0x5a,0xa2,0x48,0x2e,0x2e,0x90,0xd0,0x5e,0xa8,0xb6,0x83,0x96,0x4c,0xca,0x62,0xb5,0x5e,0x61,0xb8,0x07),
+ (0x18,0x97,0x72,0x40,0x12,0x9b,0x90,0x4b,0x2d,0x4a,0xea,0xb4,0x78,0xbb,0xb9,0x90,0xf1,0xe7,0x0c,0x17,
+ 0x17,0x4b,0x36,0xb4,0x44,0x91,0x5c,0x5c,0x20,0xa1,0xbd,0x50,0x6d,0x07,0x2d,0x99,0x94,0xc5,0x6a,0xbd,0xc2,0x70,0x0f),
+ (0x30,0x2e,0xe5,0x80,0x24,0x36,0x21,0x97,0x5a,0x94,0xd4,0x69,0xf1,0x76,0x73,0x21,0xe3,0xcf,0x19,0x2e,
+ 0x2e,0x96,0x6c,0x68,0x89,0x22,0xb9,0xb8,0x40,0x42,0x7b,0xa1,0xda,0x0e,0x5a,0x32,0x29,0x8b,0xd5,0x7a,0x85,0xe1,0x1e),
+ (0x60,0x5c,0xca,0x01,0x49,0x6c,0x42,0x2e,0xb5,0x28,0xa9,0xd3,0xe2,0xed,0xe6,0x42,0xc6,0x9f,0x33,0x5c,
+ 0x5c,0x2c,0xd9,0xd0,0x12,0x45,0x72,0x71,0x81,0x84,0xf6,0x42,0xb5,0x1d,0xb4,0x64,0x52,0x16,0xab,0xf5,0x0a,0xc3,0x3d),
+ (0xc0,0xb8,0x94,0x03,0x92,0xd8,0x84,0x5c,0x6a,0x51,0x52,0xa7,0xc5,0xdb,0xcd,0x85,0x8c,0x3f,0x67,0xb8,
+ 0xb8,0x58,0xb2,0xa1,0x25,0x8a,0xe4,0xe2,0x02,0x09,0xed,0x85,0x6a,0x3b,0x68,0xc9,0xa4,0x2c,0x56,0xeb,0x15,0x86,0x7b),
+ (0x80,0x71,0x29,0x07,0x24,0xb1,0x09,0xb9,0xd4,0xa2,0xa4,0x4e,0x8b,0xb7,0x9b,0x0b,0x19,0x7f,0xce,0x70,
+ 0x71,0xb1,0x64,0x43,0x4b,0x14,0xc9,0xc5,0x05,0x12,0xda,0x0b,0xd5,0x76,0xd0,0x92,0x49,0x59,0xac,0xd6,0x2b,0x0c,0xf7))
+
+M_14_28 = (
+ (0x71,0x5c,0xcd,0xf7,0x4c,0x41,0x3d,0x9b,0xa0,0x5e,0x93,0x46,0x1b,0x6e,0x2d,0x27,0xe6,0x50,
+ 0xd8,0xf6,0x31,0x0c,0x17,0xdc,0xee,0x29,0xf5,0x71,0x0a,0x34,0xb7,0xa8,0x40,0x3a,0xe1,
+ 0xc9,0x00,0xfb,0x50,0xd3,0x64,0x27,0x9f,0xe9,0x2f,0x15,0xed,0x99,0x19,0x01),
+ (0xe2,0xb8,0x9a,0xef,0x99,0x82,0x7a,0x36,0x41,0xbd,0x26,0x8d,0x36,0xdc,0x5a,0x4e,0xcc,0xa1,
+ 0xb0,0xed,0x63,0x18,0x2e,0xb8,0xdd,0x53,0xea,0xe3,0x14,0x68,0x6e,0x51,0x81,0x74,0xc2,
+ 0x93,0x01,0xf6,0xa1,0xa6,0xc9,0x4e,0x3e,0xd3,0x5f,0x2a,0xda,0x33,0x33,0x02),
+ (0xc4,0x71,0x35,0xdf,0x33,0x05,0xf5,0x6c,0x82,0x7a,0x4d,0x1a,0x6d,0xb8,0xb5,0x9c,0x98,0x43,
+ 0x61,0xdb,0xc7,0x30,0x5c,0x70,0xbb,0xa7,0xd4,0xc7,0x29,0xd0,0xdc,0xa2,0x02,0xe9,0x84,
+ 0x27,0x03,0xec,0x43,0x4d,0x93,0x9d,0x7c,0xa6,0xbf,0x54,0xb4,0x67,0x66,0x04),
+ (0x88,0xe3,0x6a,0xbe,0x67,0x0a,0xea,0xd9,0x04,0xf5,0x9a,0x34,0xda,0x70,0x6b,0x39,0x31,0x87,
+ 0xc2,0xb6,0x8f,0x61,0xb8,0xe0,0x76,0x4f,0xa9,0x8f,0x53,0xa0,0xb9,0x45,0x05,0xd2,0x09,
+ 0x4f,0x06,0xd8,0x87,0x9a,0x26,0x3b,0xf9,0x4c,0x7f,0xa9,0x68,0xcf,0xcc,0x08),
+ (0x10,0xc7,0xd5,0x7c,0xcf,0x14,0xd4,0xb3,0x09,0xea,0x35,0x69,0xb4,0xe1,0xd6,0x72,0x62,0x0e,
+ 0x85,0x6d,0x1f,0xc3,0x70,0xc1,0xed,0x9e,0x52,0x1f,0xa7,0x40,0x73,0x8b,0x0a,0xa4,0x13,
+ 0x9e,0x0c,0xb0,0x0f,0x35,0x4d,0x76,0xf2,0x99,0xfe,0x52,0xd1,0x9e,0x99,0x11),
+ (0x20,0x8e,0xab,0xf9,0x9e,0x29,0xa8,0x67,0x13,0xd4,0x6b,0xd2,0x68,0xc3,0xad,0xe5,0xc4,0x1c,
+ 0x0a,0xdb,0x3e,0x86,0xe1,0x82,0xdb,0x3d,0xa5,0x3e,0x4e,0x81,0xe6,0x16,0x15,0x48,0x27,
+ 0x3c,0x19,0x60,0x1f,0x6a,0x9a,0xec,0xe4,0x33,0xfd,0xa5,0xa2,0x3d,0x33,0x23),
+ (0x40,0x1c,0x57,0xf3,0x3d,0x53,0x50,0xcf,0x26,0xa8,0xd7,0xa4,0xd1,0x86,0x5b,0xcb,0x89,0x39,
+ 0x14,0xb6,0x7d,0x0c,0xc3,0x05,0xb7,0x7b,0x4a,0x7d,0x9c,0x02,0xcd,0x2d,0x2a,0x90,0x4e,
+ 0x78,0x32,0xc0,0x3e,0xd4,0x34,0xd9,0xc9,0x67,0xfa,0x4b,0x45,0x7b,0x66,0x46),
+ (0x80,0x38,0xae,0xe6,0x7b,0xa6,0xa0,0x9e,0x4d,0x50,0xaf,0x49,0xa3,0x0d,0xb7,0x96,0x13,0x73,
+ 0x28,0x6c,0xfb,0x18,0x86,0x0b,0x6e,0xf7,0x94,0xfa,0x38,0x05,0x9a,0x5b,0x54,0x20,0x9d,
+ 0xf0,0x64,0x80,0x7d,0xa8,0x69,0xb2,0x93,0xcf,0xf4,0x97,0x8a,0xf6,0xcc,0x8c))
+
+M_14_32 = (
+ (0xe9,0xad,0x1d,0x01,0x8d,0x7a,0xce,0xe3,0x9d,0xea,0x5f,0x5b,0x0b,0xc1,0x33,0x1b,0x1e,0xc4,0xeb,
+ 0x8d,0x56,0x0a,0x03,0xb3,0x6c,0x36,0x35,0x60,0xc7,0x66,0xdc,0x33,0x1f,0xb7,0x9a,0x24,0x75,0x5c,0xf9,
+ 0x64,0xdb,0x1e,0x71,0x7a,0xfd,0x91,0x36,0x72,0xfd,0xf0,0xa3,0xab,0x90,0xf2,0xf1,0x13,0x01),
+ (0xd2,0x5b,0x3b,0x02,0x1a,0xf5,0x9c,0xc7,0x3b,0xd5,0xbf,0xb6,0x16,0x82,0x67,0x36,0x3c,0x88,0xd7,
+ 0x1b,0xad,0x14,0x06,0x66,0xd9,0x6c,0x6a,0xc0,0x8e,0xcd,0xb8,0x67,0x3e,0x6e,0x35,0x49,0xea,0xb8,0xf2,
+ 0xc9,0xb6,0x3d,0xe2,0xf4,0xfa,0x23,0x6d,0xe4,0xfa,0xe1,0x47,0x57,0x21,0xe5,0xe3,0x27,0x02),
+ (0xa4,0xb7,0x76,0x04,0x34,0xea,0x39,0x8f,0x77,0xaa,0x7f,0x6d,0x2d,0x04,0xcf,0x6c,0x78,0x10,0xaf,
+ 0x37,0x5a,0x29,0x0c,0xcc,0xb2,0xd9,0xd4,0x80,0x1d,0x9b,0x71,0xcf,0x7c,0xdc,0x6a,0x92,0xd4,0x71,0xe5,
+ 0x93,0x6d,0x7b,0xc4,0xe9,0xf5,0x47,0xda,0xc8,0xf5,0xc3,0x8f,0xae,0x42,0xca,0xc7,0x4f,0x04),
+ (0x48,0x6f,0xed,0x08,0x68,0xd4,0x73,0x1e,0xef,0x54,0xff,0xda,0x5a,0x08,0x9e,0xd9,0xf0,0x20,0x5e,
+ 0x6f,0xb4,0x52,0x18,0x98,0x65,0xb3,0xa9,0x01,0x3b,0x36,0xe3,0x9e,0xf9,0xb8,0xd5,0x24,0xa9,0xe3,0xca,
+ 0x27,0xdb,0xf6,0x88,0xd3,0xeb,0x8f,0xb4,0x91,0xeb,0x87,0x1f,0x5d,0x85,0x94,0x8f,0x9f,0x08),
+ (0x90,0xde,0xda,0x11,0xd0,0xa8,0xe7,0x3c,0xde,0xa9,0xfe,0xb5,0xb5,0x10,0x3c,0xb3,0xe1,0x41,0xbc,
+ 0xde,0x68,0xa5,0x30,0x30,0xcb,0x66,0x53,0x03,0x76,0x6c,0xc6,0x3d,0xf3,0x71,0xab,0x49,0x52,0xc7,0x95,
+ 0x4f,0xb6,0xed,0x11,0xa7,0xd7,0x1f,0x69,0x23,0xd7,0x0f,0x3f,0xba,0x0a,0x29,0x1f,0x3f,0x11),
+ (0x20,0xbd,0xb5,0x23,0xa0,0x51,0xcf,0x79,0xbc,0x53,0xfd,0x6b,0x6b,0x21,0x78,0x66,0xc3,0x83,0x78,
+ 0xbd,0xd1,0x4a,0x61,0x60,0x96,0xcd,0xa6,0x06,0xec,0xd8,0x8c,0x7b,0xe6,0xe3,0x56,0x93,0xa4,0x8e,0x2b,
+ 0x9f,0x6c,0xdb,0x23,0x4e,0xaf,0x3f,0xd2,0x46,0xae,0x1f,0x7e,0x74,0x15,0x52,0x3e,0x7e,0x22),
+ (0x40,0x7a,0x6b,0x47,0x40,0xa3,0x9e,0xf3,0x78,0xa7,0xfa,0xd7,0xd6,0x42,0xf0,0xcc,0x86,0x07,0xf1,
+ 0x7a,0xa3,0x95,0xc2,0xc0,0x2c,0x9b,0x4d,0x0d,0xd8,0xb1,0x19,0xf7,0xcc,0xc7,0xad,0x26,0x49,0x1d,0x57,
+ 0x3e,0xd9,0xb6,0x47,0x9c,0x5e,0x7f,0xa4,0x8d,0x5c,0x3f,0xfc,0xe8,0x2a,0xa4,0x7c,0xfc,0x44),
+ (0x80,0xf4,0xd6,0x8e,0x80,0x46,0x3d,0xe7,0xf1,0x4e,0xf5,0xaf,0xad,0x85,0xe0,0x99,0x0d,0x0f,0xe2,
+ 0xf5,0x46,0x2b,0x85,0x81,0x59,0x36,0x9b,0x1a,0xb0,0x63,0x33,0xee,0x99,0x8f,0x5b,0x4d,0x92,0x3a,0xae,
+ 0x7c,0xb2,0x6d,0x8f,0x38,0xbd,0xfe,0x48,0x1b,0xb9,0x7e,0xf8,0xd1,0x55,0x48,0xf9,0xf8,0x89))
+
+M_14_36 = (
+ (0x0b,0x60,0xbf,0x81,0x57,0x76,0xb3,0x6c,0xaa,0xd3,0xb7,0xc1,0x3b,0xf7,0x8f,0x6c,0xef,0x2a,0x35,0x63,
+ 0x0c,0xad,0xc0,0xdb,0x40,0x49,0x27,0x9c,0x40,0x1f,0xfc,0x83,0xe4,0x85,0x3f,0x75,0x0b,0x7f,0x60,0x3c,0x73,
+ 0xcd,0x64,0x3c,0x0d,0xd9,0xf2,0x17,0xf0,0x3e,0x1c,0xe4,0x3c,0xe4,0xa1,0x9e,0xba,0x51,0xd5,0xfd,0x09,0x56,0x6c,0x01),
+ (0x16,0xc0,0x7e,0x03,0xaf,0xec,0x66,0xd9,0x54,0xa7,0x6f,0x83,0x77,0xee,0x1f,0xd9,0xde,0x55,0x6a,0xc6,
+ 0x18,0x5a,0x81,0xb7,0x81,0x92,0x4e,0x38,0x81,0x3e,0xf8,0x07,0xc9,0x0b,0x7f,0xea,0x16,0xfe,0xc0,0x78,0xe6,
+ 0x9a,0xc9,0x78,0x1a,0xb2,0xe5,0x2f,0xe0,0x7d,0x38,0xc8,0x79,0xc8,0x43,0x3d,0x75,0xa3,0xaa,0xfb,0x13,0xac,0xd8,0x02),
+ (0x2c,0x80,0xfd,0x06,0x5e,0xd9,0xcd,0xb2,0xa9,0x4e,0xdf,0x06,0xef,0xdc,0x3f,0xb2,0xbd,0xab,0xd4,0x8c,
+ 0x31,0xb4,0x02,0x6f,0x03,0x25,0x9d,0x70,0x02,0x7d,0xf0,0x0f,0x92,0x17,0xfe,0xd4,0x2d,0xfc,0x81,0xf1,0xcc,
+ 0x35,0x93,0xf1,0x34,0x64,0xcb,0x5f,0xc0,0xfb,0x70,0x90,0xf3,0x90,0x87,0x7a,0xea,0x46,0x55,0xf7,0x27,0x58,0xb1,0x05),
+ (0x58,0x00,0xfb,0x0d,0xbc,0xb2,0x9b,0x65,0x53,0x9d,0xbe,0x0d,0xde,0xb9,0x7f,0x64,0x7b,0x57,0xa9,0x19,
+ 0x63,0x68,0x05,0xde,0x06,0x4a,0x3a,0xe1,0x04,0xfa,0xe0,0x1f,0x24,0x2f,0xfc,0xa9,0x5b,0xf8,0x03,0xe3,0x99,
+ 0x6b,0x26,0xe3,0x69,0xc8,0x96,0xbf,0x80,0xf7,0xe1,0x20,0xe7,0x21,0x0f,0xf5,0xd4,0x8d,0xaa,0xee,0x4f,0xb0,0x62,0x0b),
+ (0xb0,0x00,0xf6,0x1b,0x78,0x65,0x37,0xcb,0xa6,0x3a,0x7d,0x1b,0xbc,0x73,0xff,0xc8,0xf6,0xae,0x52,0x33,
+ 0xc6,0xd0,0x0a,0xbc,0x0d,0x94,0x74,0xc2,0x09,0xf4,0xc1,0x3f,0x48,0x5e,0xf8,0x53,0xb7,0xf0,0x07,0xc6,0x33,
+ 0xd7,0x4c,0xc6,0xd3,0x90,0x2d,0x7f,0x01,0xef,0xc3,0x41,0xce,0x43,0x1e,0xea,0xa9,0x1b,0x55,0xdd,0x9f,0x60,0xc5,0x16),
+ (0x60,0x01,0xec,0x37,0xf0,0xca,0x6e,0x96,0x4d,0x75,0xfa,0x36,0x78,0xe7,0xfe,0x91,0xed,0x5d,0xa5,0x66,
+ 0x8c,0xa1,0x15,0x78,0x1b,0x28,0xe9,0x84,0x13,0xe8,0x83,0x7f,0x90,0xbc,0xf0,0xa7,0x6e,0xe1,0x0f,0x8c,0x67,
+ 0xae,0x99,0x8c,0xa7,0x21,0x5b,0xfe,0x02,0xde,0x87,0x83,0x9c,0x87,0x3c,0xd4,0x53,0x37,0xaa,0xba,0x3f,0xc1,0x8a,0x2d),
+ (0xc0,0x02,0xd8,0x6f,0xe0,0x95,0xdd,0x2c,0x9b,0xea,0xf4,0x6d,0xf0,0xce,0xfd,0x23,0xdb,0xbb,0x4a,0xcd,
+ 0x18,0x43,0x2b,0xf0,0x36,0x50,0xd2,0x09,0x27,0xd0,0x07,0xff,0x20,0x79,0xe1,0x4f,0xdd,0xc2,0x1f,0x18,0xcf,
+ 0x5c,0x33,0x19,0x4f,0x43,0xb6,0xfc,0x05,0xbc,0x0f,0x07,0x39,0x0f,0x79,0xa8,0xa7,0x6e,0x54,0x75,0x7f,0x82,0x15,0x5b),
+ (0x80,0x05,0xb0,0xdf,0xc0,0x2b,0xbb,0x59,0x36,0xd5,0xe9,0xdb,0xe0,0x9d,0xfb,0x47,0xb6,0x77,0x95,0x9a,
+ 0x31,0x86,0x56,0xe0,0x6d,0xa0,0xa4,0x13,0x4e,0xa0,0x0f,0xfe,0x41,0xf2,0xc2,0x9f,0xba,0x85,0x3f,0x30,0x9e,
+ 0xb9,0x66,0x32,0x9e,0x86,0x6c,0xf9,0x0b,0x78,0x1f,0x0e,0x72,0x1e,0xf2,0x50,0x4f,0xdd,0xa8,0xea,0xfe,0x04,0x2b,0xb6))
+
+M_14_40 = (
+ (0x07,0xfc,0x23,0x1b,0x0b,0x76,0x74,0xd3,0x0c,0xf3,0x99,0x16,0x24,0xcd,0x55,0xde,0xf6,0x72,0xe5,0x93,
+ 0x5f,0xc9,0xef,0x51,0xee,0x1b,0x7e,0x95,0x33,0x51,0x2b,0x68,0x66,0x93,0x54,0x29,0x02,0x18,0xc4,0x7d,
+ 0xef,0xf8,0x99,0xa3,0x34,0x6f,0xf4,0x8b,0x10,0xea,0x8f,0xee,0xf7,0xeb,0x96,0x44,0xf6,0x19,0x65,0x4b,
+ 0xc1,0x8d,0xda,0x49,0x0a,0x80,0x72,0xee,0x69,0x07,0x01),
+ (0x0e,0xf8,0x47,0x36,0x16,0xec,0xe8,0xa6,0x19,0xe6,0x33,0x2d,0x48,0x9a,0xab,0xbc,0xed,0xe5,0xca,0x27,
+ 0xbf,0x92,0xdf,0xa3,0xdc,0x37,0xfc,0x2a,0x67,0xa2,0x56,0xd0,0xcc,0x26,0xa9,0x52,0x04,0x30,0x88,0xfb,
+ 0xde,0xf1,0x33,0x47,0x69,0xde,0xe8,0x17,0x21,0xd4,0x1f,0xdd,0xef,0xd7,0x2d,0x89,0xec,0x33,0xca,0x96,
+ 0x82,0x1b,0xb5,0x93,0x14,0x00,0xe5,0xdc,0xd3,0x0e,0x02),
+ (0x1c,0xf0,0x8f,0x6c,0x2c,0xd8,0xd1,0x4d,0x33,0xcc,0x67,0x5a,0x90,0x34,0x57,0x79,0xdb,0xcb,0x95,0x4f,
+ 0x7e,0x25,0xbf,0x47,0xb9,0x6f,0xf8,0x55,0xce,0x44,0xad,0xa0,0x99,0x4d,0x52,0xa5,0x08,0x60,0x10,0xf7,
+ 0xbd,0xe3,0x67,0x8e,0xd2,0xbc,0xd1,0x2f,0x42,0xa8,0x3f,0xba,0xdf,0xaf,0x5b,0x12,0xd9,0x67,0x94,0x2d,
+ 0x05,0x37,0x6a,0x27,0x29,0x00,0xca,0xb9,0xa7,0x1d,0x04),
+ (0x38,0xe0,0x1f,0xd9,0x58,0xb0,0xa3,0x9b,0x66,0x98,0xcf,0xb4,0x20,0x69,0xae,0xf2,0xb6,0x97,0x2b,0x9f,
+ 0xfc,0x4a,0x7e,0x8f,0x72,0xdf,0xf0,0xab,0x9c,0x89,0x5a,0x41,0x33,0x9b,0xa4,0x4a,0x11,0xc0,0x20,0xee,
+ 0x7b,0xc7,0xcf,0x1c,0xa5,0x79,0xa3,0x5f,0x84,0x50,0x7f,0x74,0xbf,0x5f,0xb7,0x24,0xb2,0xcf,0x28,0x5b,
+ 0x0a,0x6e,0xd4,0x4e,0x52,0x00,0x94,0x73,0x4f,0x3b,0x08),
+ (0x70,0xc0,0x3f,0xb2,0xb1,0x60,0x47,0x37,0xcd,0x30,0x9f,0x69,0x41,0xd2,0x5c,0xe5,0x6d,0x2f,0x57,0x3e,
+ 0xf9,0x95,0xfc,0x1e,0xe5,0xbe,0xe1,0x57,0x39,0x13,0xb5,0x82,0x66,0x36,0x49,0x95,0x22,0x80,0x41,0xdc,
+ 0xf7,0x8e,0x9f,0x39,0x4a,0xf3,0x46,0xbf,0x08,0xa1,0xfe,0xe8,0x7e,0xbf,0x6e,0x49,0x64,0x9f,0x51,0xb6,
+ 0x14,0xdc,0xa8,0x9d,0xa4,0x00,0x28,0xe7,0x9e,0x76,0x10),
+ (0xe0,0x80,0x7f,0x64,0x63,0xc1,0x8e,0x6e,0x9a,0x61,0x3e,0xd3,0x82,0xa4,0xb9,0xca,0xdb,0x5e,0xae,0x7c,
+ 0xf2,0x2b,0xf9,0x3d,0xca,0x7d,0xc3,0xaf,0x72,0x26,0x6a,0x05,0xcd,0x6c,0x92,0x2a,0x45,0x00,0x83,0xb8,
+ 0xef,0x1d,0x3f,0x73,0x94,0xe6,0x8d,0x7e,0x11,0x42,0xfd,0xd1,0xfd,0x7e,0xdd,0x92,0xc8,0x3e,0xa3,0x6c,
+ 0x29,0xb8,0x51,0x3b,0x49,0x01,0x50,0xce,0x3d,0xed,0x20),
+ (0xc0,0x01,0xff,0xc8,0xc6,0x82,0x1d,0xdd,0x34,0xc3,0x7c,0xa6,0x05,0x49,0x73,0x95,0xb7,0xbd,0x5c,0xf9,
+ 0xe4,0x57,0xf2,0x7b,0x94,0xfb,0x86,0x5f,0xe5,0x4c,0xd4,0x0a,0x9a,0xd9,0x24,0x55,0x8a,0x00,0x06,0x71,
+ 0xdf,0x3b,0x7e,0xe6,0x28,0xcd,0x1b,0xfd,0x22,0x84,0xfa,0xa3,0xfb,0xfd,0xba,0x25,0x91,0x7d,0x46,0xd9,
+ 0x52,0x70,0xa3,0x76,0x92,0x02,0xa0,0x9c,0x7b,0xda,0x41),
+ (0x80,0x03,0xfe,0x91,0x8d,0x05,0x3b,0xba,0x69,0x86,0xf9,0x4c,0x0b,0x92,0xe6,0x2a,0x6f,0x7b,0xb9,0xf2,
+ 0xc9,0xaf,0xe4,0xf7,0x28,0xf7,0x0d,0xbf,0xca,0x99,0xa8,0x15,0x34,0xb3,0x49,0xaa,0x14,0x01,0x0c,0xe2,
+ 0xbe,0x77,0xfc,0xcc,0x51,0x9a,0x37,0xfa,0x45,0x08,0xf5,0x47,0xf7,0xfb,0x75,0x4b,0x22,0xfb,0x8c,0xb2,
+ 0xa5,0xe0,0x46,0xed,0x24,0x05,0x40,0x39,0xf7,0xb4,0x83))
+
+M_14_44 = (
+ (0x7d,0xa2,0x90,0xd1,0x9e,0x20,0xfb,0xa2,0xfc,0xec,0x54,0xbe,0xe8,0x7c,0xc7,0xcf,0x35,0xe2,0x9e,0x88,
+ 0xbb,0x90,0x85,0x87,0xb0,0xce,0x13,0x68,0xe7,0xa1,0xfc,0xd7,0xe0,0x8b,0x65,0x5a,0xad,0xf2,0xfd,0x0c,
+ 0x14,0x48,0x8c,0xa1,0x2c,0x93,0xc1,0xac,0x2c,0x90,0x73,0x0e,0xe7,0xcb,0xf9,0x3c,0xef,0xb4,0xd8,0x6e,
+ 0x6e,0xed,0x5a,0x44,0xe9,0xde,0x74,0xfc,0xec,0x76,0x29,0xcb,0x9d,0x46,0x3a,0xd9,0x98,0x01),
+ (0xfa,0x44,0x21,0xa3,0x3d,0x41,0xf6,0x45,0xf9,0xd9,0xa9,0x7c,0xd1,0xf9,0x8e,0x9f,0x6b,0xc4,0x3d,0x11,
+ 0x77,0x21,0x0b,0x0f,0x61,0x9d,0x27,0xd0,0xce,0x43,0xf9,0xaf,0xc1,0x17,0xcb,0xb4,0x5a,0xe5,0xfb,0x19,
+ 0x28,0x90,0x18,0x43,0x59,0x26,0x83,0x59,0x59,0x20,0xe7,0x1c,0xce,0x97,0xf3,0x79,0xde,0x69,0xb1,0xdd,
+ 0xdc,0xda,0xb5,0x88,0xd2,0xbd,0xe9,0xf8,0xd9,0xed,0x52,0x96,0x3b,0x8d,0x74,0xb2,0x31,0x03),
+ (0xf4,0x89,0x42,0x46,0x7b,0x82,0xec,0x8b,0xf2,0xb3,0x53,0xf9,0xa2,0xf3,0x1d,0x3f,0xd7,0x88,0x7b,0x22,
+ 0xee,0x42,0x16,0x1e,0xc2,0x3a,0x4f,0xa0,0x9d,0x87,0xf2,0x5f,0x83,0x2f,0x96,0x69,0xb5,0xca,0xf7,0x33,
+ 0x50,0x20,0x31,0x86,0xb2,0x4c,0x06,0xb3,0xb2,0x40,0xce,0x39,0x9c,0x2f,0xe7,0xf3,0xbc,0xd3,0x62,0xbb,
+ 0xb9,0xb5,0x6b,0x11,0xa5,0x7b,0xd3,0xf1,0xb3,0xdb,0xa5,0x2c,0x77,0x1a,0xe9,0x64,0x63,0x06),
+ (0xe8,0x13,0x85,0x8c,0xf6,0x04,0xd9,0x17,0xe5,0x67,0xa7,0xf2,0x45,0xe7,0x3b,0x7e,0xae,0x11,0xf7,0x44,
+ 0xdc,0x85,0x2c,0x3c,0x84,0x75,0x9e,0x40,0x3b,0x0f,0xe5,0xbf,0x06,0x5f,0x2c,0xd3,0x6a,0x95,0xef,0x67,
+ 0xa0,0x40,0x62,0x0c,0x65,0x99,0x0c,0x66,0x65,0x81,0x9c,0x73,0x38,0x5f,0xce,0xe7,0x79,0xa7,0xc5,0x76,
+ 0x73,0x6b,0xd7,0x22,0x4a,0xf7,0xa6,0xe3,0x67,0xb7,0x4b,0x59,0xee,0x34,0xd2,0xc9,0xc6,0x0c),
+ (0xd0,0x27,0x0a,0x19,0xed,0x09,0xb2,0x2f,0xca,0xcf,0x4e,0xe5,0x8b,0xce,0x77,0xfc,0x5c,0x23,0xee,0x89,
+ 0xb8,0x0b,0x59,0x78,0x08,0xeb,0x3c,0x81,0x76,0x1e,0xca,0x7f,0x0d,0xbe,0x58,0xa6,0xd5,0x2a,0xdf,0xcf,
+ 0x40,0x81,0xc4,0x18,0xca,0x32,0x19,0xcc,0xca,0x02,0x39,0xe7,0x70,0xbe,0x9c,0xcf,0xf3,0x4e,0x8b,0xed,
+ 0xe6,0xd6,0xae,0x45,0x94,0xee,0x4d,0xc7,0xcf,0x6e,0x97,0xb2,0xdc,0x69,0xa4,0x93,0x8d,0x19),
+ (0xa0,0x4f,0x14,0x32,0xda,0x13,0x64,0x5f,0x94,0x9f,0x9d,0xca,0x17,0x9d,0xef,0xf8,0xb9,0x46,0xdc,0x13,
+ 0x71,0x17,0xb2,0xf0,0x10,0xd6,0x79,0x02,0xed,0x3c,0x94,0xff,0x1a,0x7c,0xb1,0x4c,0xab,0x55,0xbe,0x9f,
+ 0x81,0x02,0x89,0x31,0x94,0x65,0x32,0x98,0x95,0x05,0x72,0xce,0xe1,0x7c,0x39,0x9f,0xe7,0x9d,0x16,0xdb,
+ 0xcd,0xad,0x5d,0x8b,0x28,0xdd,0x9b,0x8e,0x9f,0xdd,0x2e,0x65,0xb9,0xd3,0x48,0x27,0x1b,0x33),
+ (0x40,0x9f,0x28,0x64,0xb4,0x27,0xc8,0xbe,0x28,0x3f,0x3b,0x95,0x2f,0x3a,0xdf,0xf1,0x73,0x8d,0xb8,0x27,
+ 0xe2,0x2e,0x64,0xe1,0x21,0xac,0xf3,0x04,0xda,0x79,0x28,0xff,0x35,0xf8,0x62,0x99,0x56,0xab,0x7c,0x3f,
+ 0x03,0x05,0x12,0x63,0x28,0xcb,0x64,0x30,0x2b,0x0b,0xe4,0x9c,0xc3,0xf9,0x72,0x3e,0xcf,0x3b,0x2d,0xb6,
+ 0x9b,0x5b,0xbb,0x16,0x51,0xba,0x37,0x1d,0x3f,0xbb,0x5d,0xca,0x72,0xa7,0x91,0x4e,0x36,0x66),
+ (0x80,0x3e,0x51,0xc8,0x68,0x4f,0x90,0x7d,0x51,0x7e,0x76,0x2a,0x5f,0x74,0xbe,0xe3,0xe7,0x1a,0x71,0x4f,
+ 0xc4,0x5d,0xc8,0xc2,0x43,0x58,0xe7,0x09,0xb4,0xf3,0x50,0xfe,0x6b,0xf0,0xc5,0x32,0xad,0x56,0xf9,0x7e,
+ 0x06,0x0a,0x24,0xc6,0x50,0x96,0xc9,0x60,0x56,0x16,0xc8,0x39,0x87,0xf3,0xe5,0x7c,0x9e,0x77,0x5a,0x6c,
+ 0x37,0xb7,0x76,0x2d,0xa2,0x74,0x6f,0x3a,0x7e,0x76,0xbb,0x94,0xe5,0x4e,0x23,0x9d,0x6c,0xcc))
+
+M_14_48 = (
+ (0x35,0x47,0xc2,0xf2,0xec,0xd9,0xb1,0x4c,0x34,0xd1,0x12,0x79,0x34,0xab,0x17,0x76,0x39,0x6a,0x37,0x7b,0x4d,
+ 0xfe,0xb6,0x97,0xee,0xe9,0x71,0x1d,0xf6,0x99,0xf7,0x8e,0x9a,0x1f,0x05,0x13,0x6f,0xcc,0xb9,0xce,0xcf,0x60,
+ 0xb9,0x66,0x35,0xa2,0xfc,0x8e,0x9a,0x40,0xdc,0x24,0xf6,0x6b,0xd9,0x96,0xfa,0xa1,0xfb,0x5f,0xc1,0xc2,0x6a,
+ 0x84,0x88,0x13,0x48,0x43,0xcb,0xcb,0x77,0x63,0xc1,0xfa,0xf9,0x16,0xd4,0x69,0xd8,0x98,0x96,0x38,0x8f,0xae,0x01),
+ (0x6a,0x8e,0x84,0xe5,0xd9,0xb3,0x63,0x99,0x68,0xa2,0x25,0xf2,0x68,0x56,0x2f,0xec,0x72,0xd4,0x6e,0xf6,0x9a,
+ 0xfc,0x6d,0x2f,0xdd,0xd3,0xe3,0x3a,0xec,0x33,0xef,0x1d,0x35,0x3f,0x0a,0x26,0xde,0x98,0x73,0x9d,0x9f,0xc1,
+ 0x72,0xcd,0x6a,0x44,0xf9,0x1d,0x35,0x81,0xb8,0x49,0xec,0xd7,0xb2,0x2d,0xf5,0x43,0xf7,0xbf,0x82,0x85,0xd5,
+ 0x08,0x11,0x27,0x90,0x86,0x96,0x97,0xef,0xc6,0x82,0xf5,0xf3,0x2d,0xa8,0xd3,0xb0,0x31,0x2d,0x71,0x1e,0x5d,0x03),
+ (0xd4,0x1c,0x09,0xcb,0xb3,0x67,0xc7,0x32,0xd1,0x44,0x4b,0xe4,0xd1,0xac,0x5e,0xd8,0xe5,0xa8,0xdd,0xec,0x35,
+ 0xf9,0xdb,0x5e,0xba,0xa7,0xc7,0x75,0xd8,0x67,0xde,0x3b,0x6a,0x7e,0x14,0x4c,0xbc,0x31,0xe7,0x3a,0x3f,0x83,
+ 0xe5,0x9a,0xd5,0x88,0xf2,0x3b,0x6a,0x02,0x71,0x93,0xd8,0xaf,0x65,0x5b,0xea,0x87,0xee,0x7f,0x05,0x0b,0xab,
+ 0x11,0x22,0x4e,0x20,0x0d,0x2d,0x2f,0xdf,0x8d,0x05,0xeb,0xe7,0x5b,0x50,0xa7,0x61,0x63,0x5a,0xe2,0x3c,0xba,0x06),
+ (0xa8,0x39,0x12,0x96,0x67,0xcf,0x8e,0x65,0xa2,0x89,0x96,0xc8,0xa3,0x59,0xbd,0xb0,0xcb,0x51,0xbb,0xd9,0x6b,
+ 0xf2,0xb7,0xbd,0x74,0x4f,0x8f,0xeb,0xb0,0xcf,0xbc,0x77,0xd4,0xfc,0x28,0x98,0x78,0x63,0xce,0x75,0x7e,0x06,
+ 0xcb,0x35,0xab,0x11,0xe5,0x77,0xd4,0x04,0xe2,0x26,0xb1,0x5f,0xcb,0xb6,0xd4,0x0f,0xdd,0xff,0x0a,0x16,0x56,
+ 0x23,0x44,0x9c,0x40,0x1a,0x5a,0x5e,0xbe,0x1b,0x0b,0xd6,0xcf,0xb7,0xa0,0x4e,0xc3,0xc6,0xb4,0xc4,0x79,0x74,0x0d),
+ (0x50,0x73,0x24,0x2c,0xcf,0x9e,0x1d,0xcb,0x44,0x13,0x2d,0x91,0x47,0xb3,0x7a,0x61,0x97,0xa3,0x76,0xb3,0xd7,
+ 0xe4,0x6f,0x7b,0xe9,0x9e,0x1e,0xd7,0x61,0x9f,0x79,0xef,0xa8,0xf9,0x51,0x30,0xf1,0xc6,0x9c,0xeb,0xfc,0x0c,
+ 0x96,0x6b,0x56,0x23,0xca,0xef,0xa8,0x09,0xc4,0x4d,0x62,0xbf,0x96,0x6d,0xa9,0x1f,0xba,0xff,0x15,0x2c,0xac,
+ 0x46,0x88,0x38,0x81,0x34,0xb4,0xbc,0x7c,0x37,0x16,0xac,0x9f,0x6f,0x41,0x9d,0x86,0x8d,0x69,0x89,0xf3,0xe8,0x1a),
+ (0xa0,0xe6,0x48,0x58,0x9e,0x3d,0x3b,0x96,0x89,0x26,0x5a,0x22,0x8f,0x66,0xf5,0xc2,0x2e,0x47,0xed,0x66,0xaf,
+ 0xc9,0xdf,0xf6,0xd2,0x3d,0x3d,0xae,0xc3,0x3e,0xf3,0xde,0x51,0xf3,0xa3,0x60,0xe2,0x8d,0x39,0xd7,0xf9,0x19,
+ 0x2c,0xd7,0xac,0x46,0x94,0xdf,0x51,0x13,0x88,0x9b,0xc4,0x7e,0x2d,0xdb,0x52,0x3f,0x74,0xff,0x2b,0x58,0x58,
+ 0x8d,0x10,0x71,0x02,0x69,0x68,0x79,0xf9,0x6e,0x2c,0x58,0x3f,0xdf,0x82,0x3a,0x0d,0x1b,0xd3,0x12,0xe7,0xd1,0x35),
+ (0x40,0xcd,0x91,0xb0,0x3c,0x7b,0x76,0x2c,0x13,0x4d,0xb4,0x44,0x1e,0xcd,0xea,0x85,0x5d,0x8e,0xda,0xcd,0x5e,
+ 0x93,0xbf,0xed,0xa5,0x7b,0x7a,0x5c,0x87,0x7d,0xe6,0xbd,0xa3,0xe6,0x47,0xc1,0xc4,0x1b,0x73,0xae,0xf3,0x33,
+ 0x58,0xae,0x59,0x8d,0x28,0xbf,0xa3,0x26,0x10,0x37,0x89,0xfd,0x5a,0xb6,0xa5,0x7e,0xe8,0xfe,0x57,0xb0,0xb0,
+ 0x1a,0x21,0xe2,0x04,0xd2,0xd0,0xf2,0xf2,0xdd,0x58,0xb0,0x7e,0xbe,0x05,0x75,0x1a,0x36,0xa6,0x25,0xce,0xa3,0x6b),
+ (0x80,0x9a,0x23,0x61,0x79,0xf6,0xec,0x58,0x26,0x9a,0x68,0x89,0x3c,0x9a,0xd5,0x0b,0xbb,0x1c,0xb5,0x9b,0xbd,
+ 0x26,0x7f,0xdb,0x4b,0xf7,0xf4,0xb8,0x0e,0xfb,0xcc,0x7b,0x47,0xcd,0x8f,0x82,0x89,0x37,0xe6,0x5c,0xe7,0x67,
+ 0xb0,0x5c,0xb3,0x1a,0x51,0x7e,0x47,0x4d,0x20,0x6e,0x12,0xfb,0xb5,0x6c,0x4b,0xfd,0xd0,0xfd,0xaf,0x60,0x61,
+ 0x35,0x42,0xc4,0x09,0xa4,0xa1,0xe5,0xe5,0xbb,0xb1,0x60,0xfd,0x7c,0x0b,0xea,0x34,0x6c,0x4c,0x4b,0x9c,0x47,0xd7))
+
+M_14_52 = (
+ (0x59,0x1e,0x2c,0xdc,0xd7,0x83,0xf5,0xe2,0x0b,0x8f,0x38,0xb3,0x18,0xaf,0x4d,0xc3,0xec,0x44,0x65,0xad,0xbf,
+ 0x7a,0xd7,0xd9,0x60,0x25,0x18,0x74,0xa4,0x00,0x48,0xce,0x0d,0xb8,0x77,0x76,0x2a,0x13,0xe3,0x63,0x93,0xd3,
+ 0xa4,0x17,0x9b,0x05,0x74,0x05,0x3d,0xad,0xa6,0xe6,0xcc,0x03,0xdf,0x2e,0xce,0xf5,0x32,0xd8,0x6f,0x76,0x16,
+ 0x4f,0x9c,0xbf,0x61,0x7e,0x04,0x1f,0x57,0xf6,0x68,0x01,0xff,0x7c,0x10,0xb1,0x7a,0x5e,0xb5,0xdd,0xae,0xef,
+ 0xe3,0xf7,0xa7,0x23,0xda,0xec,0xbd,0x01),
+ (0xb2,0x3c,0x58,0xb8,0xaf,0x07,0xeb,0xc5,0x17,0x1e,0x71,0x66,0x31,0x5e,0x9b,0x86,0xd9,0x89,0xca,0x5a,0x7f,
+ 0xf5,0xae,0xb3,0xc1,0x4a,0x30,0xe8,0x48,0x01,0x90,0x9c,0x1b,0x70,0xef,0xec,0x54,0x26,0xc6,0xc7,0x26,0xa7,
+ 0x49,0x2f,0x36,0x0b,0xe8,0x0a,0x7a,0x5a,0x4d,0xcd,0x99,0x07,0xbe,0x5d,0x9c,0xeb,0x65,0xb0,0xdf,0xec,0x2c,
+ 0x9e,0x38,0x7f,0xc3,0xfc,0x08,0x3e,0xae,0xec,0xd1,0x02,0xfe,0xf9,0x20,0x62,0xf5,0xbc,0x6a,0xbb,0x5d,0xdf,
+ 0xc7,0xef,0x4f,0x47,0xb4,0xd9,0x7b,0x03),
+ (0x64,0x79,0xb0,0x70,0x5f,0x0f,0xd6,0x8b,0x2f,0x3c,0xe2,0xcc,0x62,0xbc,0x36,0x0d,0xb3,0x13,0x95,0xb5,0xfe,
+ 0xea,0x5d,0x67,0x83,0x95,0x60,0xd0,0x91,0x02,0x20,0x39,0x37,0xe0,0xde,0xd9,0xa9,0x4c,0x8c,0x8f,0x4d,0x4e,
+ 0x93,0x5e,0x6c,0x16,0xd0,0x15,0xf4,0xb4,0x9a,0x9a,0x33,0x0f,0x7c,0xbb,0x38,0xd7,0xcb,0x60,0xbf,0xd9,0x59,
+ 0x3c,0x71,0xfe,0x86,0xf9,0x11,0x7c,0x5c,0xd9,0xa3,0x05,0xfc,0xf3,0x41,0xc4,0xea,0x79,0xd5,0x76,0xbb,0xbe,
+ 0x8f,0xdf,0x9f,0x8e,0x68,0xb3,0xf7,0x06),
+ (0xc8,0xf2,0x60,0xe1,0xbe,0x1e,0xac,0x17,0x5f,0x78,0xc4,0x99,0xc5,0x78,0x6d,0x1a,0x66,0x27,0x2a,0x6b,0xfd,
+ 0xd5,0xbb,0xce,0x06,0x2b,0xc1,0xa0,0x23,0x05,0x40,0x72,0x6e,0xc0,0xbd,0xb3,0x53,0x99,0x18,0x1f,0x9b,0x9c,
+ 0x26,0xbd,0xd8,0x2c,0xa0,0x2b,0xe8,0x69,0x35,0x35,0x67,0x1e,0xf8,0x76,0x71,0xae,0x97,0xc1,0x7e,0xb3,0xb3,
+ 0x78,0xe2,0xfc,0x0d,0xf3,0x23,0xf8,0xb8,0xb2,0x47,0x0b,0xf8,0xe7,0x83,0x88,0xd5,0xf3,0xaa,0xed,0x76,0x7d,
+ 0x1f,0xbf,0x3f,0x1d,0xd1,0x66,0xef,0x0d),
+ (0x90,0xe5,0xc1,0xc2,0x7d,0x3d,0x58,0x2f,0xbe,0xf0,0x88,0x33,0x8b,0xf1,0xda,0x34,0xcc,0x4e,0x54,0xd6,0xfa,
+ 0xab,0x77,0x9d,0x0d,0x56,0x82,0x41,0x47,0x0a,0x80,0xe4,0xdc,0x80,0x7b,0x67,0xa7,0x32,0x31,0x3e,0x36,0x39,
+ 0x4d,0x7a,0xb1,0x59,0x40,0x57,0xd0,0xd3,0x6a,0x6a,0xce,0x3c,0xf0,0xed,0xe2,0x5c,0x2f,0x83,0xfd,0x66,0x67,
+ 0xf1,0xc4,0xf9,0x1b,0xe6,0x47,0xf0,0x71,0x65,0x8f,0x16,0xf0,0xcf,0x07,0x11,0xab,0xe7,0x55,0xdb,0xed,0xfa,
+ 0x3e,0x7e,0x7f,0x3a,0xa2,0xcd,0xde,0x1b),
+ (0x20,0xcb,0x83,0x85,0xfb,0x7a,0xb0,0x5e,0x7c,0xe1,0x11,0x67,0x16,0xe3,0xb5,0x69,0x98,0x9d,0xa8,0xac,0xf5,
+ 0x57,0xef,0x3a,0x1b,0xac,0x04,0x83,0x8e,0x14,0x00,0xc9,0xb9,0x01,0xf7,0xce,0x4e,0x65,0x62,0x7c,0x6c,0x72,
+ 0x9a,0xf4,0x62,0xb3,0x80,0xae,0xa0,0xa7,0xd5,0xd4,0x9c,0x79,0xe0,0xdb,0xc5,0xb9,0x5e,0x06,0xfb,0xcd,0xce,
+ 0xe2,0x89,0xf3,0x37,0xcc,0x8f,0xe0,0xe3,0xca,0x1e,0x2d,0xe0,0x9f,0x0f,0x22,0x56,0xcf,0xab,0xb6,0xdb,0xf5,
+ 0x7d,0xfc,0xfe,0x74,0x44,0x9b,0xbd,0x37),
+ (0x40,0x96,0x07,0x0b,0xf7,0xf5,0x60,0xbd,0xf8,0xc2,0x23,0xce,0x2c,0xc6,0x6b,0xd3,0x30,0x3b,0x51,0x59,0xeb,
+ 0xaf,0xde,0x75,0x36,0x58,0x09,0x06,0x1d,0x29,0x00,0x92,0x73,0x03,0xee,0x9d,0x9d,0xca,0xc4,0xf8,0xd8,0xe4,
+ 0x34,0xe9,0xc5,0x66,0x01,0x5d,0x41,0x4f,0xab,0xa9,0x39,0xf3,0xc0,0xb7,0x8b,0x73,0xbd,0x0c,0xf6,0x9b,0x9d,
+ 0xc5,0x13,0xe7,0x6f,0x98,0x1f,0xc1,0xc7,0x95,0x3d,0x5a,0xc0,0x3f,0x1f,0x44,0xac,0x9e,0x57,0x6d,0xb7,0xeb,
+ 0xfb,0xf8,0xfd,0xe9,0x88,0x36,0x7b,0x6f),
+ (0x80,0x2c,0x0f,0x16,0xee,0xeb,0xc1,0x7a,0xf1,0x85,0x47,0x9c,0x59,0x8c,0xd7,0xa6,0x61,0x76,0xa2,0xb2,0xd6,
+ 0x5f,0xbd,0xeb,0x6c,0xb0,0x12,0x0c,0x3a,0x52,0x00,0x24,0xe7,0x06,0xdc,0x3b,0x3b,0x95,0x89,0xf1,0xb1,0xc9,
+ 0x69,0xd2,0x8b,0xcd,0x02,0xba,0x82,0x9e,0x56,0x53,0x73,0xe6,0x81,0x6f,0x17,0xe7,0x7a,0x19,0xec,0x37,0x3b,
+ 0x8b,0x27,0xce,0xdf,0x30,0x3f,0x82,0x8f,0x2b,0x7b,0xb4,0x80,0x7f,0x3e,0x88,0x58,0x3d,0xaf,0xda,0x6e,0xd7,
+ 0xf7,0xf1,0xfb,0xd3,0x11,0x6d,0xf6,0xde))
+
+M_14_56 = (
+ (0x09,0x0c,0xd9,0xd0,0xcb,0xbe,0x78,0x3e,0x36,0xc1,0x98,0xbd,0x12,0x71,0x0c,0x3f,0x74,0x83,0x2f,0x15,0x56,
+ 0xbf,0xd7,0xb9,0x1d,0x07,0x43,0xe8,0x19,0x60,0x3e,0xe4,0x9c,0x9e,0xfd,0xad,0x6e,0x9e,0xda,0x69,0xc9,0x52,
+ 0x2d,0xf5,0xe3,0x8e,0xe4,0x45,0x4a,0x34,0x7b,0x2d,0xce,0x27,0x8d,0x97,0x4a,0xa9,0xfc,0xd0,0xe0,0x99,0x90,
+ 0xb0,0x8e,0x7a,0xcf,0x2a,0xa1,0x9c,0xcb,0x1f,0x96,0x32,0xa3,0x19,0xd8,0x42,0x67,0x08,0x6e,0xf3,0xb0,0xd1,
+ 0x38,0xf3,0x05,0x88,0x34,0x5a,0x46,0x68,0x83,0x7d,0xa2,0xf9,0xf7,0x1d,0x01),
+ (0x12,0x18,0xb2,0xa1,0x97,0x7d,0xf1,0x7c,0x6c,0x82,0x31,0x7b,0x25,0xe2,0x18,0x7e,0xe8,0x06,0x5f,0x2a,0xac,
+ 0x7e,0xaf,0x73,0x3b,0x0e,0x86,0xd0,0x33,0xc0,0x7c,0xc8,0x39,0x3d,0xfb,0x5b,0xdd,0x3c,0xb5,0xd3,0x92,0xa5,
+ 0x5a,0xea,0xc7,0x1d,0xc9,0x8b,0x94,0x68,0xf6,0x5a,0x9c,0x4f,0x1a,0x2f,0x95,0x52,0xf9,0xa1,0xc1,0x33,0x21,
+ 0x61,0x1d,0xf5,0x9e,0x55,0x42,0x39,0x97,0x3f,0x2c,0x65,0x46,0x33,0xb0,0x85,0xce,0x10,0xdc,0xe6,0x61,0xa3,
+ 0x71,0xe6,0x0b,0x10,0x69,0xb4,0x8c,0xd0,0x06,0xfb,0x44,0xf3,0xef,0x3b,0x02),
+ (0x24,0x30,0x64,0x43,0x2f,0xfb,0xe2,0xf9,0xd8,0x04,0x63,0xf6,0x4a,0xc4,0x31,0xfc,0xd0,0x0d,0xbe,0x54,0x58,
+ 0xfd,0x5e,0xe7,0x76,0x1c,0x0c,0xa1,0x67,0x80,0xf9,0x90,0x73,0x7a,0xf6,0xb7,0xba,0x79,0x6a,0xa7,0x25,0x4b,
+ 0xb5,0xd4,0x8f,0x3b,0x92,0x17,0x29,0xd1,0xec,0xb5,0x38,0x9f,0x34,0x5e,0x2a,0xa5,0xf2,0x43,0x83,0x67,0x42,
+ 0xc2,0x3a,0xea,0x3d,0xab,0x84,0x72,0x2e,0x7f,0x58,0xca,0x8c,0x66,0x60,0x0b,0x9d,0x21,0xb8,0xcd,0xc3,0x46,
+ 0xe3,0xcc,0x17,0x20,0xd2,0x68,0x19,0xa1,0x0d,0xf6,0x89,0xe6,0xdf,0x77,0x04),
+ (0x48,0x60,0xc8,0x86,0x5e,0xf6,0xc5,0xf3,0xb1,0x09,0xc6,0xec,0x95,0x88,0x63,0xf8,0xa1,0x1b,0x7c,0xa9,0xb0,
+ 0xfa,0xbd,0xce,0xed,0x38,0x18,0x42,0xcf,0x00,0xf3,0x21,0xe7,0xf4,0xec,0x6f,0x75,0xf3,0xd4,0x4e,0x4b,0x96,
+ 0x6a,0xa9,0x1f,0x77,0x24,0x2f,0x52,0xa2,0xd9,0x6b,0x71,0x3e,0x69,0xbc,0x54,0x4a,0xe5,0x87,0x06,0xcf,0x84,
+ 0x84,0x75,0xd4,0x7b,0x56,0x09,0xe5,0x5c,0xfe,0xb0,0x94,0x19,0xcd,0xc0,0x16,0x3a,0x43,0x70,0x9b,0x87,0x8d,
+ 0xc6,0x99,0x2f,0x40,0xa4,0xd1,0x32,0x42,0x1b,0xec,0x13,0xcd,0xbf,0xef,0x08),
+ (0x90,0xc0,0x90,0x0d,0xbd,0xec,0x8b,0xe7,0x63,0x13,0x8c,0xd9,0x2b,0x11,0xc7,0xf0,0x43,0x37,0xf8,0x52,0x61,
+ 0xf5,0x7b,0x9d,0xdb,0x71,0x30,0x84,0x9e,0x01,0xe6,0x43,0xce,0xe9,0xd9,0xdf,0xea,0xe6,0xa9,0x9d,0x96,0x2c,
+ 0xd5,0x52,0x3f,0xee,0x48,0x5e,0xa4,0x44,0xb3,0xd7,0xe2,0x7c,0xd2,0x78,0xa9,0x94,0xca,0x0f,0x0d,0x9e,0x09,
+ 0x09,0xeb,0xa8,0xf7,0xac,0x12,0xca,0xb9,0xfc,0x61,0x29,0x33,0x9a,0x81,0x2d,0x74,0x86,0xe0,0x36,0x0f,0x1b,
+ 0x8d,0x33,0x5f,0x80,0x48,0xa3,0x65,0x84,0x36,0xd8,0x27,0x9a,0x7f,0xdf,0x11),
+ (0x20,0x81,0x21,0x1b,0x7a,0xd9,0x17,0xcf,0xc7,0x26,0x18,0xb3,0x57,0x22,0x8e,0xe1,0x87,0x6e,0xf0,0xa5,0xc2,
+ 0xea,0xf7,0x3a,0xb7,0xe3,0x60,0x08,0x3d,0x03,0xcc,0x87,0x9c,0xd3,0xb3,0xbf,0xd5,0xcd,0x53,0x3b,0x2d,0x59,
+ 0xaa,0xa5,0x7e,0xdc,0x91,0xbc,0x48,0x89,0x66,0xaf,0xc5,0xf9,0xa4,0xf1,0x52,0x29,0x95,0x1f,0x1a,0x3c,0x13,
+ 0x12,0xd6,0x51,0xef,0x59,0x25,0x94,0x73,0xf9,0xc3,0x52,0x66,0x34,0x03,0x5b,0xe8,0x0c,0xc1,0x6d,0x1e,0x36,
+ 0x1a,0x67,0xbe,0x00,0x91,0x46,0xcb,0x08,0x6d,0xb0,0x4f,0x34,0xff,0xbe,0x23),
+ (0x40,0x02,0x43,0x36,0xf4,0xb2,0x2f,0x9e,0x8f,0x4d,0x30,0x66,0xaf,0x44,0x1c,0xc3,0x0f,0xdd,0xe0,0x4b,0x85,
+ 0xd5,0xef,0x75,0x6e,0xc7,0xc1,0x10,0x7a,0x06,0x98,0x0f,0x39,0xa7,0x67,0x7f,0xab,0x9b,0xa7,0x76,0x5a,0xb2,
+ 0x54,0x4b,0xfd,0xb8,0x23,0x79,0x91,0x12,0xcd,0x5e,0x8b,0xf3,0x49,0xe3,0xa5,0x52,0x2a,0x3f,0x34,0x78,0x26,
+ 0x24,0xac,0xa3,0xde,0xb3,0x4a,0x28,0xe7,0xf2,0x87,0xa5,0xcc,0x68,0x06,0xb6,0xd0,0x19,0x82,0xdb,0x3c,0x6c,
+ 0x34,0xce,0x7c,0x01,0x22,0x8d,0x96,0x11,0xda,0x60,0x9f,0x68,0xfe,0x7d,0x47),
+ (0x80,0x04,0x86,0x6c,0xe8,0x65,0x5f,0x3c,0x1f,0x9b,0x60,0xcc,0x5e,0x89,0x38,0x86,0x1f,0xba,0xc1,0x97,0x0a,
+ 0xab,0xdf,0xeb,0xdc,0x8e,0x83,0x21,0xf4,0x0c,0x30,0x1f,0x72,0x4e,0xcf,0xfe,0x56,0x37,0x4f,0xed,0xb4,0x64,
+ 0xa9,0x96,0xfa,0x71,0x47,0xf2,0x22,0x25,0x9a,0xbd,0x16,0xe7,0x93,0xc6,0x4b,0xa5,0x54,0x7e,0x68,0xf0,0x4c,
+ 0x48,0x58,0x47,0xbd,0x67,0x95,0x50,0xce,0xe5,0x0f,0x4b,0x99,0xd1,0x0c,0x6c,0xa1,0x33,0x04,0xb7,0x79,0xd8,
+ 0x68,0x9c,0xf9,0x02,0x44,0x1a,0x2d,0x23,0xb4,0xc1,0x3e,0xd1,0xfc,0xfb,0x8e))
+
+M_14_60 = (
+ (0xb3,0xf4,0x1b,0x06,0x78,0x68,0xf9,0xe5,0xe9,0x1f,0xc1,0xce,0x37,0x6f,0x39,0xbd,0x28,0xc4,0xd3,0x49,0xd6,
+ 0x9f,0x34,0x0b,0x67,0xb7,0x6d,0x3c,0xb6,0x8c,0xcc,0xa2,0xfd,0x37,0x17,0xd9,0x85,0x02,0x1e,0x86,0x7d,0xc0,
+ 0xcc,0x64,0x92,0xc2,0x66,0x9a,0x36,0x77,0xb1,0xa8,0xa5,0xb9,0x47,0x22,0x75,0xde,0x09,0xe9,0x63,0xd6,0xf5,
+ 0x1b,0xd0,0xfd,0xfb,0x8f,0x3a,0xcd,0x4c,0xac,0xaa,0xe6,0xda,0x43,0xf5,0x2d,0xd3,0x1e,0xd8,0x78,0x21,0x8d,
+ 0x00,0xdf,0x88,0xd5,0x7b,0xaf,0xb3,0xd6,0x1c,0x80,0x5f,0x7c,0x37,0x9d,0xd7,0xea,0x4c,0x4f,0x8b,0xa1,0xc8,0x01),
+ (0x66,0xe9,0x37,0x0c,0xf0,0xd0,0xf2,0xcb,0xd3,0x3f,0x82,0x9d,0x6f,0xde,0x72,0x7a,0x51,0x88,0xa7,0x93,0xac,
+ 0x3f,0x69,0x16,0xce,0x6e,0xdb,0x78,0x6c,0x19,0x99,0x45,0xfb,0x6f,0x2e,0xb2,0x0b,0x05,0x3c,0x0c,0xfb,0x80,
+ 0x99,0xc9,0x24,0x85,0xcd,0x34,0x6d,0xee,0x62,0x51,0x4b,0x73,0x8f,0x44,0xea,0xbc,0x13,0xd2,0xc7,0xac,0xeb,
+ 0x37,0xa0,0xfb,0xf7,0x1f,0x75,0x9a,0x99,0x58,0x55,0xcd,0xb5,0x87,0xea,0x5b,0xa6,0x3d,0xb0,0xf1,0x42,0x1a,
+ 0x01,0xbe,0x11,0xab,0xf7,0x5e,0x67,0xad,0x39,0x00,0xbf,0xf8,0x6e,0x3a,0xaf,0xd5,0x99,0x9e,0x16,0x43,0x91,0x03),
+ (0xcc,0xd2,0x6f,0x18,0xe0,0xa1,0xe5,0x97,0xa7,0x7f,0x04,0x3b,0xdf,0xbc,0xe5,0xf4,0xa2,0x10,0x4f,0x27,0x59,
+ 0x7f,0xd2,0x2c,0x9c,0xdd,0xb6,0xf1,0xd8,0x32,0x32,0x8b,0xf6,0xdf,0x5c,0x64,0x17,0x0a,0x78,0x18,0xf6,0x01,
+ 0x33,0x93,0x49,0x0a,0x9b,0x69,0xda,0xdc,0xc5,0xa2,0x96,0xe6,0x1e,0x89,0xd4,0x79,0x27,0xa4,0x8f,0x59,0xd7,
+ 0x6f,0x40,0xf7,0xef,0x3f,0xea,0x34,0x33,0xb1,0xaa,0x9a,0x6b,0x0f,0xd5,0xb7,0x4c,0x7b,0x60,0xe3,0x85,0x34,
+ 0x02,0x7c,0x23,0x56,0xef,0xbd,0xce,0x5a,0x73,0x00,0x7e,0xf1,0xdd,0x74,0x5e,0xab,0x33,0x3d,0x2d,0x86,0x22,0x07),
+ (0x98,0xa5,0xdf,0x30,0xc0,0x43,0xcb,0x2f,0x4f,0xff,0x08,0x76,0xbe,0x79,0xcb,0xe9,0x45,0x21,0x9e,0x4e,0xb2,
+ 0xfe,0xa4,0x59,0x38,0xbb,0x6d,0xe3,0xb1,0x65,0x64,0x16,0xed,0xbf,0xb9,0xc8,0x2e,0x14,0xf0,0x30,0xec,0x03,
+ 0x66,0x26,0x93,0x14,0x36,0xd3,0xb4,0xb9,0x8b,0x45,0x2d,0xcd,0x3d,0x12,0xa9,0xf3,0x4e,0x48,0x1f,0xb3,0xae,
+ 0xdf,0x80,0xee,0xdf,0x7f,0xd4,0x69,0x66,0x62,0x55,0x35,0xd7,0x1e,0xaa,0x6f,0x99,0xf6,0xc0,0xc6,0x0b,0x69,
+ 0x04,0xf8,0x46,0xac,0xde,0x7b,0x9d,0xb5,0xe6,0x00,0xfc,0xe2,0xbb,0xe9,0xbc,0x56,0x67,0x7a,0x5a,0x0c,0x45,0x0e),
+ (0x30,0x4b,0xbf,0x61,0x80,0x87,0x96,0x5f,0x9e,0xfe,0x11,0xec,0x7c,0xf3,0x96,0xd3,0x8b,0x42,0x3c,0x9d,0x64,
+ 0xfd,0x49,0xb3,0x70,0x76,0xdb,0xc6,0x63,0xcb,0xc8,0x2c,0xda,0x7f,0x73,0x91,0x5d,0x28,0xe0,0x61,0xd8,0x07,
+ 0xcc,0x4c,0x26,0x29,0x6c,0xa6,0x69,0x73,0x17,0x8b,0x5a,0x9a,0x7b,0x24,0x52,0xe7,0x9d,0x90,0x3e,0x66,0x5d,
+ 0xbf,0x01,0xdd,0xbf,0xff,0xa8,0xd3,0xcc,0xc4,0xaa,0x6a,0xae,0x3d,0x54,0xdf,0x32,0xed,0x81,0x8d,0x17,0xd2,
+ 0x08,0xf0,0x8d,0x58,0xbd,0xf7,0x3a,0x6b,0xcd,0x01,0xf8,0xc5,0x77,0xd3,0x79,0xad,0xce,0xf4,0xb4,0x18,0x8a,0x1c),
+ (0x60,0x96,0x7e,0xc3,0x00,0x0f,0x2d,0xbf,0x3c,0xfd,0x23,0xd8,0xf9,0xe6,0x2d,0xa7,0x17,0x85,0x78,0x3a,0xc9,
+ 0xfa,0x93,0x66,0xe1,0xec,0xb6,0x8d,0xc7,0x96,0x91,0x59,0xb4,0xff,0xe6,0x22,0xbb,0x50,0xc0,0xc3,0xb0,0x0f,
+ 0x98,0x99,0x4c,0x52,0xd8,0x4c,0xd3,0xe6,0x2e,0x16,0xb5,0x34,0xf7,0x48,0xa4,0xce,0x3b,0x21,0x7d,0xcc,0xba,
+ 0x7e,0x03,0xba,0x7f,0xff,0x51,0xa7,0x99,0x89,0x55,0xd5,0x5c,0x7b,0xa8,0xbe,0x65,0xda,0x03,0x1b,0x2f,0xa4,
+ 0x11,0xe0,0x1b,0xb1,0x7a,0xef,0x75,0xd6,0x9a,0x03,0xf0,0x8b,0xef,0xa6,0xf3,0x5a,0x9d,0xe9,0x69,0x31,0x14,0x39),
+ (0xc0,0x2c,0xfd,0x86,0x01,0x1e,0x5a,0x7e,0x79,0xfa,0x47,0xb0,0xf3,0xcd,0x5b,0x4e,0x2f,0x0a,0xf1,0x74,0x92,
+ 0xf5,0x27,0xcd,0xc2,0xd9,0x6d,0x1b,0x8f,0x2d,0x23,0xb3,0x68,0xff,0xcd,0x45,0x76,0xa1,0x80,0x87,0x61,0x1f,
+ 0x30,0x33,0x99,0xa4,0xb0,0x99,0xa6,0xcd,0x5d,0x2c,0x6a,0x69,0xee,0x91,0x48,0x9d,0x77,0x42,0xfa,0x98,0x75,
+ 0xfd,0x06,0x74,0xff,0xfe,0xa3,0x4e,0x33,0x13,0xab,0xaa,0xb9,0xf6,0x50,0x7d,0xcb,0xb4,0x07,0x36,0x5e,0x48,
+ 0x23,0xc0,0x37,0x62,0xf5,0xde,0xeb,0xac,0x35,0x07,0xe0,0x17,0xdf,0x4d,0xe7,0xb5,0x3a,0xd3,0xd3,0x62,0x28,0x72),
+ (0x80,0x59,0xfa,0x0d,0x03,0x3c,0xb4,0xfc,0xf2,0xf4,0x8f,0x60,0xe7,0x9b,0xb7,0x9c,0x5e,0x14,0xe2,0xe9,0x24,
+ 0xeb,0x4f,0x9a,0x85,0xb3,0xdb,0x36,0x1e,0x5b,0x46,0x66,0xd1,0xfe,0x9b,0x8b,0xec,0x42,0x01,0x0f,0xc3,0x3e,
+ 0x60,0x66,0x32,0x49,0x61,0x33,0x4d,0x9b,0xbb,0x58,0xd4,0xd2,0xdc,0x23,0x91,0x3a,0xef,0x84,0xf4,0x31,0xeb,
+ 0xfa,0x0d,0xe8,0xfe,0xfd,0x47,0x9d,0x66,0x26,0x56,0x55,0x73,0xed,0xa1,0xfa,0x96,0x69,0x0f,0x6c,0xbc,0x90,
+ 0x46,0x80,0x6f,0xc4,0xea,0xbd,0xd7,0x59,0x6b,0x0e,0xc0,0x2f,0xbe,0x9b,0xce,0x6b,0x75,0xa6,0xa7,0xc5,0x50,0xe4))
+
+M_14_68 = (
+ (0x69,0xca,0x0b,0xcf,0x38,0x48,0x00,0xd2,0xb9,0x9f,0x98,0x8a,0xe6,0x14,0xb2,0x89,0x11,0x91,0xa9,0xb8,0x25,
+ 0x5e,0xfa,0xc6,0x5b,0x19,0x78,0xe6,0x47,0x46,0x13,0x3e,0xb8,0x62,0x2f,0xaa,0xcf,0x9c,0x80,0x2a,0xe2,0x8c,
+ 0x9a,0x48,0x0a,0xa7,0x09,0xf6,0x7a,0x9f,0x91,0x1e,0xbf,0xa1,0x2f,0xa7,0x4e,0xaf,0x9f,0x83,0xc3,0xbe,0x7c,
+ 0x1e,0x71,0x64,0xf0,0x68,0x20,0x66,0x35,0xb6,0xf7,0x82,0x44,0xde,0xf5,0xc3,0x50,0xfe,0xc7,0x51,0xf1,0x06,
+ 0xd9,0xad,0xfc,0xd3,0x2c,0x3a,0x57,0x0a,0xf3,0x0d,0xe5,0x2a,0x88,0xbf,0x5c,0xa6,0xa9,0x53,0xeb,0xa7,0x94,
+ 0xf2,0x81,0x2a,0xbb,0xaa,0x43,0x4e,0x47,0x40,0xe1,0x5d,0x0f,0x1a,0x02,0x00),
+ (0xd2,0x94,0x17,0x9e,0x71,0x90,0x00,0xa4,0x73,0x3f,0x31,0x15,0xcd,0x29,0x64,0x13,0x23,0x22,0x53,0x71,0x4b,
+ 0xbc,0xf4,0x8d,0xb7,0x32,0xf0,0xcc,0x8f,0x8c,0x26,0x7c,0x70,0xc5,0x5e,0x54,0x9f,0x39,0x01,0x55,0xc4,0x19,
+ 0x35,0x91,0x14,0x4e,0x13,0xec,0xf5,0x3e,0x23,0x3d,0x7e,0x43,0x5f,0x4e,0x9d,0x5e,0x3f,0x07,0x87,0x7d,0xf9,
+ 0x3c,0xe2,0xc8,0xe0,0xd1,0x40,0xcc,0x6a,0x6c,0xef,0x05,0x89,0xbc,0xeb,0x87,0xa1,0xfc,0x8f,0xa3,0xe2,0x0d,
+ 0xb2,0x5b,0xf9,0xa7,0x59,0x74,0xae,0x14,0xe6,0x1b,0xca,0x55,0x10,0x7f,0xb9,0x4c,0x53,0xa7,0xd6,0x4f,0x29,
+ 0xe5,0x03,0x55,0x76,0x55,0x87,0x9c,0x8e,0x80,0xc2,0xbb,0x1e,0x34,0x04,0x00),
+ (0xa4,0x29,0x2f,0x3c,0xe3,0x20,0x01,0x48,0xe7,0x7e,0x62,0x2a,0x9a,0x53,0xc8,0x26,0x46,0x44,0xa6,0xe2,0x96,
+ 0x78,0xe9,0x1b,0x6f,0x65,0xe0,0x99,0x1f,0x19,0x4d,0xf8,0xe0,0x8a,0xbd,0xa8,0x3e,0x73,0x02,0xaa,0x88,0x33,
+ 0x6a,0x22,0x29,0x9c,0x26,0xd8,0xeb,0x7d,0x46,0x7a,0xfc,0x86,0xbe,0x9c,0x3a,0xbd,0x7e,0x0e,0x0e,0xfb,0xf2,
+ 0x79,0xc4,0x91,0xc1,0xa3,0x81,0x98,0xd5,0xd8,0xde,0x0b,0x12,0x79,0xd7,0x0f,0x43,0xf9,0x1f,0x47,0xc5,0x1b,
+ 0x64,0xb7,0xf2,0x4f,0xb3,0xe8,0x5c,0x29,0xcc,0x37,0x94,0xab,0x20,0xfe,0x72,0x99,0xa6,0x4e,0xad,0x9f,0x52,
+ 0xca,0x07,0xaa,0xec,0xaa,0x0e,0x39,0x1d,0x01,0x85,0x77,0x3d,0x68,0x08,0x00),
+ (0x48,0x53,0x5e,0x78,0xc6,0x41,0x02,0x90,0xce,0xfd,0xc4,0x54,0x34,0xa7,0x90,0x4d,0x8c,0x88,0x4c,0xc5,0x2d,
+ 0xf1,0xd2,0x37,0xde,0xca,0xc0,0x33,0x3f,0x32,0x9a,0xf0,0xc1,0x15,0x7b,0x51,0x7d,0xe6,0x04,0x54,0x11,0x67,
+ 0xd4,0x44,0x52,0x38,0x4d,0xb0,0xd7,0xfb,0x8c,0xf4,0xf8,0x0d,0x7d,0x39,0x75,0x7a,0xfd,0x1c,0x1c,0xf6,0xe5,
+ 0xf3,0x88,0x23,0x83,0x47,0x03,0x31,0xab,0xb1,0xbd,0x17,0x24,0xf2,0xae,0x1f,0x86,0xf2,0x3f,0x8e,0x8a,0x37,
+ 0xc8,0x6e,0xe5,0x9f,0x66,0xd1,0xb9,0x52,0x98,0x6f,0x28,0x57,0x41,0xfc,0xe5,0x32,0x4d,0x9d,0x5a,0x3f,0xa5,
+ 0x94,0x0f,0x54,0xd9,0x55,0x1d,0x72,0x3a,0x02,0x0a,0xef,0x7a,0xd0,0x10,0x00),
+ (0x90,0xa6,0xbc,0xf0,0x8c,0x83,0x04,0x20,0x9d,0xfb,0x89,0xa9,0x68,0x4e,0x21,0x9b,0x18,0x11,0x99,0x8a,0x5b,
+ 0xe2,0xa5,0x6f,0xbc,0x95,0x81,0x67,0x7e,0x64,0x34,0xe1,0x83,0x2b,0xf6,0xa2,0xfa,0xcc,0x09,0xa8,0x22,0xce,
+ 0xa8,0x89,0xa4,0x70,0x9a,0x60,0xaf,0xf7,0x19,0xe9,0xf1,0x1b,0xfa,0x72,0xea,0xf4,0xfa,0x39,0x38,0xec,0xcb,
+ 0xe7,0x11,0x47,0x06,0x8f,0x06,0x62,0x56,0x63,0x7b,0x2f,0x48,0xe4,0x5d,0x3f,0x0c,0xe5,0x7f,0x1c,0x15,0x6f,
+ 0x90,0xdd,0xca,0x3f,0xcd,0xa2,0x73,0xa5,0x30,0xdf,0x50,0xae,0x82,0xf8,0xcb,0x65,0x9a,0x3a,0xb5,0x7e,0x4a,
+ 0x29,0x1f,0xa8,0xb2,0xab,0x3a,0xe4,0x74,0x04,0x14,0xde,0xf5,0xa0,0x21,0x00),
+ (0x20,0x4d,0x79,0xe1,0x19,0x07,0x09,0x40,0x3a,0xf7,0x13,0x53,0xd1,0x9c,0x42,0x36,0x31,0x22,0x32,0x15,0xb7,
+ 0xc4,0x4b,0xdf,0x78,0x2b,0x03,0xcf,0xfc,0xc8,0x68,0xc2,0x07,0x57,0xec,0x45,0xf5,0x99,0x13,0x50,0x45,0x9c,
+ 0x51,0x13,0x49,0xe1,0x34,0xc1,0x5e,0xef,0x33,0xd2,0xe3,0x37,0xf4,0xe5,0xd4,0xe9,0xf5,0x73,0x70,0xd8,0x97,
+ 0xcf,0x23,0x8e,0x0c,0x1e,0x0d,0xc4,0xac,0xc6,0xf6,0x5e,0x90,0xc8,0xbb,0x7e,0x18,0xca,0xff,0x38,0x2a,0xde,
+ 0x20,0xbb,0x95,0x7f,0x9a,0x45,0xe7,0x4a,0x61,0xbe,0xa1,0x5c,0x05,0xf1,0x97,0xcb,0x34,0x75,0x6a,0xfd,0x94,
+ 0x52,0x3e,0x50,0x65,0x57,0x75,0xc8,0xe9,0x08,0x28,0xbc,0xeb,0x41,0x43,0x00),
+ (0x40,0x9a,0xf2,0xc2,0x33,0x0e,0x12,0x80,0x74,0xee,0x27,0xa6,0xa2,0x39,0x85,0x6c,0x62,0x44,0x64,0x2a,0x6e,
+ 0x89,0x97,0xbe,0xf1,0x56,0x06,0x9e,0xf9,0x91,0xd1,0x84,0x0f,0xae,0xd8,0x8b,0xea,0x33,0x27,0xa0,0x8a,0x38,
+ 0xa3,0x26,0x92,0xc2,0x69,0x82,0xbd,0xde,0x67,0xa4,0xc7,0x6f,0xe8,0xcb,0xa9,0xd3,0xeb,0xe7,0xe0,0xb0,0x2f,
+ 0x9f,0x47,0x1c,0x19,0x3c,0x1a,0x88,0x59,0x8d,0xed,0xbd,0x20,0x91,0x77,0xfd,0x30,0x94,0xff,0x71,0x54,0xbc,
+ 0x41,0x76,0x2b,0xff,0x34,0x8b,0xce,0x95,0xc2,0x7c,0x43,0xb9,0x0a,0xe2,0x2f,0x97,0x69,0xea,0xd4,0xfa,0x29,
+ 0xa5,0x7c,0xa0,0xca,0xae,0xea,0x90,0xd3,0x11,0x50,0x78,0xd7,0x83,0x86,0x00),
+ (0x80,0x34,0xe5,0x85,0x67,0x1c,0x24,0x00,0xe9,0xdc,0x4f,0x4c,0x45,0x73,0x0a,0xd9,0xc4,0x88,0xc8,0x54,0xdc,
+ 0x12,0x2f,0x7d,0xe3,0xad,0x0c,0x3c,0xf3,0x23,0xa3,0x09,0x1f,0x5c,0xb1,0x17,0xd5,0x67,0x4e,0x40,0x15,0x71,
+ 0x46,0x4d,0x24,0x85,0xd3,0x04,0x7b,0xbd,0xcf,0x48,0x8f,0xdf,0xd0,0x97,0x53,0xa7,0xd7,0xcf,0xc1,0x61,0x5f,
+ 0x3e,0x8f,0x38,0x32,0x78,0x34,0x10,0xb3,0x1a,0xdb,0x7b,0x41,0x22,0xef,0xfa,0x61,0x28,0xff,0xe3,0xa8,0x78,
+ 0x83,0xec,0x56,0xfe,0x69,0x16,0x9d,0x2b,0x85,0xf9,0x86,0x72,0x15,0xc4,0x5f,0x2e,0xd3,0xd4,0xa9,0xf5,0x53,
+ 0x4a,0xf9,0x40,0x95,0x5d,0xd5,0x21,0xa7,0x23,0xa0,0xf0,0xae,0x07,0x0d,0x01))
+
+M_14_72 = (
+ (0x2d,0xdb,0xaa,0xfd,0x80,0xd2,0xff,0x17,0x22,0xad,0xb3,0x0d,0xbe,0x69,0x1c,0xe6,0xbc,0x6e,0x4a,0x07,0x64,
+ 0x01,0xd4,0x0a,0x01,0x7f,0xfc,0x49,0x87,0xdc,0xed,0x3d,0xe7,0x4f,0x48,0x0a,0xef,0x1e,0xbf,0xfd,0x6b,0x2b,
+ 0x6c,0x66,0x8c,0x5f,0xd1,0xe9,0x09,0xb3,0x75,0x13,0x80,0x24,0xd6,0xc9,0xcb,0xe7,0x91,0xad,0xc2,0x88,0xbe,
+ 0x84,0x25,0x42,0x40,0xd6,0xdc,0x89,0x0f,0xa5,0xeb,0x8b,0x84,0x34,0xd6,0x47,0xc7,0x0c,0xc9,0xe4,0xbb,0xfa,
+ 0x00,0xde,0x97,0x72,0x6f,0xf3,0xec,0x8e,0x26,0xf5,0x3a,0x44,0x21,0xea,0xb3,0xb0,0x40,0xab,0x2c,0xfc,0xd7,
+ 0x45,0x88,0x90,0x6d,0x4d,0x74,0x2a,0x8a,0xc2,0xbb,0x1d,0x98,0x70,0xcf,0x43,0x63,0x18,0x02,0x6f,0x5c,0x02,0x00),
+ (0x5a,0xb6,0x55,0xfb,0x01,0xa5,0xff,0x2f,0x44,0x5a,0x67,0x1b,0x7c,0xd3,0x38,0xcc,0x79,0xdd,0x94,0x0e,0xc8,
+ 0x02,0xa8,0x15,0x02,0xfe,0xf8,0x93,0x0e,0xb9,0xdb,0x7b,0xce,0x9f,0x90,0x14,0xde,0x3d,0x7e,0xfb,0xd7,0x56,
+ 0xd8,0xcc,0x18,0xbf,0xa2,0xd3,0x13,0x66,0xeb,0x26,0x00,0x49,0xac,0x93,0x97,0xcf,0x23,0x5b,0x85,0x11,0x7d,
+ 0x09,0x4b,0x84,0x80,0xac,0xb9,0x13,0x1f,0x4a,0xd7,0x17,0x09,0x69,0xac,0x8f,0x8e,0x19,0x92,0xc9,0x77,0xf5,
+ 0x01,0xbc,0x2f,0xe5,0xde,0xe6,0xd9,0x1d,0x4d,0xea,0x75,0x88,0x42,0xd4,0x67,0x61,0x81,0x56,0x59,0xf8,0xaf,
+ 0x8b,0x10,0x21,0xdb,0x9a,0xe8,0x54,0x14,0x85,0x77,0x3b,0x30,0xe1,0x9e,0x87,0xc6,0x30,0x04,0xde,0xb8,0x04,0x00),
+ (0xb4,0x6c,0xab,0xf6,0x03,0x4a,0xff,0x5f,0x88,0xb4,0xce,0x36,0xf8,0xa6,0x71,0x98,0xf3,0xba,0x29,0x1d,0x90,
+ 0x05,0x50,0x2b,0x04,0xfc,0xf1,0x27,0x1d,0x72,0xb7,0xf7,0x9c,0x3f,0x21,0x29,0xbc,0x7b,0xfc,0xf6,0xaf,0xad,
+ 0xb0,0x99,0x31,0x7e,0x45,0xa7,0x27,0xcc,0xd6,0x4d,0x00,0x92,0x58,0x27,0x2f,0x9f,0x47,0xb6,0x0a,0x23,0xfa,
+ 0x12,0x96,0x08,0x01,0x59,0x73,0x27,0x3e,0x94,0xae,0x2f,0x12,0xd2,0x58,0x1f,0x1d,0x33,0x24,0x93,0xef,0xea,
+ 0x03,0x78,0x5f,0xca,0xbd,0xcd,0xb3,0x3b,0x9a,0xd4,0xeb,0x10,0x85,0xa8,0xcf,0xc2,0x02,0xad,0xb2,0xf0,0x5f,
+ 0x17,0x21,0x42,0xb6,0x35,0xd1,0xa9,0x28,0x0a,0xef,0x76,0x60,0xc2,0x3d,0x0f,0x8d,0x61,0x08,0xbc,0x71,0x09,0x00),
+ (0x68,0xd9,0x56,0xed,0x07,0x94,0xfe,0xbf,0x10,0x69,0x9d,0x6d,0xf0,0x4d,0xe3,0x30,0xe7,0x75,0x53,0x3a,0x20,
+ 0x0b,0xa0,0x56,0x08,0xf8,0xe3,0x4f,0x3a,0xe4,0x6e,0xef,0x39,0x7f,0x42,0x52,0x78,0xf7,0xf8,0xed,0x5f,0x5b,
+ 0x61,0x33,0x63,0xfc,0x8a,0x4e,0x4f,0x98,0xad,0x9b,0x00,0x24,0xb1,0x4e,0x5e,0x3e,0x8f,0x6c,0x15,0x46,0xf4,
+ 0x25,0x2c,0x11,0x02,0xb2,0xe6,0x4e,0x7c,0x28,0x5d,0x5f,0x24,0xa4,0xb1,0x3e,0x3a,0x66,0x48,0x26,0xdf,0xd5,
+ 0x07,0xf0,0xbe,0x94,0x7b,0x9b,0x67,0x77,0x34,0xa9,0xd7,0x21,0x0a,0x51,0x9f,0x85,0x05,0x5a,0x65,0xe1,0xbf,
+ 0x2e,0x42,0x84,0x6c,0x6b,0xa2,0x53,0x51,0x14,0xde,0xed,0xc0,0x84,0x7b,0x1e,0x1a,0xc3,0x10,0x78,0xe3,0x12,0x00),
+ (0xd0,0xb2,0xad,0xda,0x0f,0x28,0xfd,0x7f,0x21,0xd2,0x3a,0xdb,0xe0,0x9b,0xc6,0x61,0xce,0xeb,0xa6,0x74,0x40,
+ 0x16,0x40,0xad,0x10,0xf0,0xc7,0x9f,0x74,0xc8,0xdd,0xde,0x73,0xfe,0x84,0xa4,0xf0,0xee,0xf1,0xdb,0xbf,0xb6,
+ 0xc2,0x66,0xc6,0xf8,0x15,0x9d,0x9e,0x30,0x5b,0x37,0x01,0x48,0x62,0x9d,0xbc,0x7c,0x1e,0xd9,0x2a,0x8c,0xe8,
+ 0x4b,0x58,0x22,0x04,0x64,0xcd,0x9d,0xf8,0x50,0xba,0xbe,0x48,0x48,0x63,0x7d,0x74,0xcc,0x90,0x4c,0xbe,0xab,
+ 0x0f,0xe0,0x7d,0x29,0xf7,0x36,0xcf,0xee,0x68,0x52,0xaf,0x43,0x14,0xa2,0x3e,0x0b,0x0b,0xb4,0xca,0xc2,0x7f,
+ 0x5d,0x84,0x08,0xd9,0xd6,0x44,0xa7,0xa2,0x28,0xbc,0xdb,0x81,0x09,0xf7,0x3c,0x34,0x86,0x21,0xf0,0xc6,0x25,0x00),
+ (0xa0,0x65,0x5b,0xb5,0x1f,0x50,0xfa,0xff,0x42,0xa4,0x75,0xb6,0xc1,0x37,0x8d,0xc3,0x9c,0xd7,0x4d,0xe9,0x80,
+ 0x2c,0x80,0x5a,0x21,0xe0,0x8f,0x3f,0xe9,0x90,0xbb,0xbd,0xe7,0xfc,0x09,0x49,0xe1,0xdd,0xe3,0xb7,0x7f,0x6d,
+ 0x85,0xcd,0x8c,0xf1,0x2b,0x3a,0x3d,0x61,0xb6,0x6e,0x02,0x90,0xc4,0x3a,0x79,0xf9,0x3c,0xb2,0x55,0x18,0xd1,
+ 0x97,0xb0,0x44,0x08,0xc8,0x9a,0x3b,0xf1,0xa1,0x74,0x7d,0x91,0x90,0xc6,0xfa,0xe8,0x98,0x21,0x99,0x7c,0x57,
+ 0x1f,0xc0,0xfb,0x52,0xee,0x6d,0x9e,0xdd,0xd1,0xa4,0x5e,0x87,0x28,0x44,0x7d,0x16,0x16,0x68,0x95,0x85,0xff,
+ 0xba,0x08,0x11,0xb2,0xad,0x89,0x4e,0x45,0x51,0x78,0xb7,0x03,0x13,0xee,0x79,0x68,0x0c,0x43,0xe0,0x8d,0x4b,0x00),
+ (0x40,0xcb,0xb6,0x6a,0x3f,0xa0,0xf4,0xff,0x85,0x48,0xeb,0x6c,0x83,0x6f,0x1a,0x87,0x39,0xaf,0x9b,0xd2,0x01,
+ 0x59,0x00,0xb5,0x42,0xc0,0x1f,0x7f,0xd2,0x21,0x77,0x7b,0xcf,0xf9,0x13,0x92,0xc2,0xbb,0xc7,0x6f,0xff,0xda,
+ 0x0a,0x9b,0x19,0xe3,0x57,0x74,0x7a,0xc2,0x6c,0xdd,0x04,0x20,0x89,0x75,0xf2,0xf2,0x79,0x64,0xab,0x30,0xa2,
+ 0x2f,0x61,0x89,0x10,0x90,0x35,0x77,0xe2,0x43,0xe9,0xfa,0x22,0x21,0x8d,0xf5,0xd1,0x31,0x43,0x32,0xf9,0xae,
+ 0x3e,0x80,0xf7,0xa5,0xdc,0xdb,0x3c,0xbb,0xa3,0x49,0xbd,0x0e,0x51,0x88,0xfa,0x2c,0x2c,0xd0,0x2a,0x0b,0xff,
+ 0x75,0x11,0x22,0x64,0x5b,0x13,0x9d,0x8a,0xa2,0xf0,0x6e,0x07,0x26,0xdc,0xf3,0xd0,0x18,0x86,0xc0,0x1b,0x97,0x00),
+ (0x80,0x96,0x6d,0xd5,0x7e,0x40,0xe9,0xff,0x0b,0x91,0xd6,0xd9,0x06,0xdf,0x34,0x0e,0x73,0x5e,0x37,0xa5,0x03,
+ 0xb2,0x00,0x6a,0x85,0x80,0x3f,0xfe,0xa4,0x43,0xee,0xf6,0x9e,0xf3,0x27,0x24,0x85,0x77,0x8f,0xdf,0xfe,0xb5,
+ 0x15,0x36,0x33,0xc6,0xaf,0xe8,0xf4,0x84,0xd9,0xba,0x09,0x40,0x12,0xeb,0xe4,0xe5,0xf3,0xc8,0x56,0x61,0x44,
+ 0x5f,0xc2,0x12,0x21,0x20,0x6b,0xee,0xc4,0x87,0xd2,0xf5,0x45,0x42,0x1a,0xeb,0xa3,0x63,0x86,0x64,0xf2,0x5d,
+ 0x7d,0x00,0xef,0x4b,0xb9,0xb7,0x79,0x76,0x47,0x93,0x7a,0x1d,0xa2,0x10,0xf5,0x59,0x58,0xa0,0x55,0x16,0xfe,
+ 0xeb,0x22,0x44,0xc8,0xb6,0x26,0x3a,0x15,0x45,0xe1,0xdd,0x0e,0x4c,0xb8,0xe7,0xa1,0x31,0x0c,0x81,0x37,0x2e,0x01))
+
+M_14_80 = (
+ (0x15,0x5e,0x86,0xe5,0xe1,0xb8,0x22,0x20,0x32,0xf5,0xca,0x86,0x4b,0x13,0xa3,0x49,0x5c,0x5a,0x83,0x37,0xfa,
+ 0x23,0x9e,0xd3,0x30,0x7b,0xae,0xfa,0x43,0x2c,0xfa,0x61,0xf0,0x67,0x71,0xb4,0x6f,0x54,0x73,0x8d,0x2a,0x77,
+ 0x78,0x38,0x7e,0x3c,0xe9,0x0b,0x79,0xd7,0x48,0xbf,0x4c,0xd8,0x21,0x77,0x26,0x23,0x51,0x23,0x85,0x89,0x97,
+ 0xa9,0xd2,0xe2,0xe1,0x0a,0x9c,0x3e,0xc7,0x51,0xa9,0x6d,0x73,0x88,0x69,0xb6,0xb3,0x1a,0xf1,0xa2,0x62,0xb7,
+ 0x4e,0x92,0xc0,0x21,0x31,0x93,0xbd,0xd6,0xe0,0x04,0x47,0x58,0xaf,0x70,0xc1,0x20,0x08,0xc3,0xd4,0x58,0x99,
+ 0x77,0x23,0xc5,0xd0,0x2e,0x1e,0x70,0xa7,0xbc,0xfb,0x25,0x3a,0x27,0x96,0x7b,0x44,0x44,0x1e,0xf5,0xb1,0x5e,
+ 0x2a,0x8e,0x30,0xe7,0x72,0x04,0x82,0xa4,0x73,0xf7,0xa0,0x9a,0xd7,0x02,0x00),
+ (0x2a,0xbc,0x0c,0xcb,0xc3,0x71,0x45,0x40,0x64,0xea,0x95,0x0d,0x97,0x26,0x46,0x93,0xb8,0xb4,0x06,0x6f,0xf4,
+ 0x47,0x3c,0xa7,0x61,0xf6,0x5c,0xf5,0x87,0x58,0xf4,0xc3,0xe0,0xcf,0xe2,0x68,0xdf,0xa8,0xe6,0x1a,0x55,0xee,
+ 0xf0,0x70,0xfc,0x78,0xd2,0x17,0xf2,0xae,0x91,0x7e,0x99,0xb0,0x43,0xee,0x4c,0x46,0xa2,0x46,0x0a,0x13,0x2f,
+ 0x53,0xa5,0xc5,0xc3,0x15,0x38,0x7d,0x8e,0xa3,0x52,0xdb,0xe6,0x10,0xd3,0x6c,0x67,0x35,0xe2,0x45,0xc5,0x6e,
+ 0x9d,0x24,0x81,0x43,0x62,0x26,0x7b,0xad,0xc1,0x09,0x8e,0xb0,0x5e,0xe1,0x82,0x41,0x10,0x86,0xa9,0xb1,0x32,
+ 0xef,0x46,0x8a,0xa1,0x5d,0x3c,0xe0,0x4e,0x79,0xf7,0x4b,0x74,0x4e,0x2c,0xf7,0x88,0x88,0x3c,0xea,0x63,0xbd,
+ 0x54,0x1c,0x61,0xce,0xe5,0x08,0x04,0x49,0xe7,0xee,0x41,0x35,0xaf,0x05,0x00),
+ (0x54,0x78,0x19,0x96,0x87,0xe3,0x8a,0x80,0xc8,0xd4,0x2b,0x1b,0x2e,0x4d,0x8c,0x26,0x71,0x69,0x0d,0xde,0xe8,
+ 0x8f,0x78,0x4e,0xc3,0xec,0xb9,0xea,0x0f,0xb1,0xe8,0x87,0xc1,0x9f,0xc5,0xd1,0xbe,0x51,0xcd,0x35,0xaa,0xdc,
+ 0xe1,0xe1,0xf8,0xf1,0xa4,0x2f,0xe4,0x5d,0x23,0xfd,0x32,0x61,0x87,0xdc,0x99,0x8c,0x44,0x8d,0x14,0x26,0x5e,
+ 0xa6,0x4a,0x8b,0x87,0x2b,0x70,0xfa,0x1c,0x47,0xa5,0xb6,0xcd,0x21,0xa6,0xd9,0xce,0x6a,0xc4,0x8b,0x8a,0xdd,
+ 0x3a,0x49,0x02,0x87,0xc4,0x4c,0xf6,0x5a,0x83,0x13,0x1c,0x61,0xbd,0xc2,0x05,0x83,0x20,0x0c,0x53,0x63,0x65,
+ 0xde,0x8d,0x14,0x43,0xbb,0x78,0xc0,0x9d,0xf2,0xee,0x97,0xe8,0x9c,0x58,0xee,0x11,0x11,0x79,0xd4,0xc7,0x7a,
+ 0xa9,0x38,0xc2,0x9c,0xcb,0x11,0x08,0x92,0xce,0xdd,0x83,0x6a,0x5e,0x0b,0x00),
+ (0xa8,0xf0,0x32,0x2c,0x0f,0xc7,0x15,0x01,0x91,0xa9,0x57,0x36,0x5c,0x9a,0x18,0x4d,0xe2,0xd2,0x1a,0xbc,0xd1,
+ 0x1f,0xf1,0x9c,0x86,0xd9,0x73,0xd5,0x1f,0x62,0xd1,0x0f,0x83,0x3f,0x8b,0xa3,0x7d,0xa3,0x9a,0x6b,0x54,0xb9,
+ 0xc3,0xc3,0xf1,0xe3,0x49,0x5f,0xc8,0xbb,0x46,0xfa,0x65,0xc2,0x0e,0xb9,0x33,0x19,0x89,0x1a,0x29,0x4c,0xbc,
+ 0x4c,0x95,0x16,0x0f,0x57,0xe0,0xf4,0x39,0x8e,0x4a,0x6d,0x9b,0x43,0x4c,0xb3,0x9d,0xd5,0x88,0x17,0x15,0xbb,
+ 0x75,0x92,0x04,0x0e,0x89,0x99,0xec,0xb5,0x06,0x27,0x38,0xc2,0x7a,0x85,0x0b,0x06,0x41,0x18,0xa6,0xc6,0xca,
+ 0xbc,0x1b,0x29,0x86,0x76,0xf1,0x80,0x3b,0xe5,0xdd,0x2f,0xd1,0x39,0xb1,0xdc,0x23,0x22,0xf2,0xa8,0x8f,0xf5,
+ 0x52,0x71,0x84,0x39,0x97,0x23,0x10,0x24,0x9d,0xbb,0x07,0xd5,0xbc,0x16,0x00),
+ (0x50,0xe1,0x65,0x58,0x1e,0x8e,0x2b,0x02,0x22,0x53,0xaf,0x6c,0xb8,0x34,0x31,0x9a,0xc4,0xa5,0x35,0x78,0xa3,
+ 0x3f,0xe2,0x39,0x0d,0xb3,0xe7,0xaa,0x3f,0xc4,0xa2,0x1f,0x06,0x7f,0x16,0x47,0xfb,0x46,0x35,0xd7,0xa8,0x72,
+ 0x87,0x87,0xe3,0xc7,0x93,0xbe,0x90,0x77,0x8d,0xf4,0xcb,0x84,0x1d,0x72,0x67,0x32,0x12,0x35,0x52,0x98,0x78,
+ 0x99,0x2a,0x2d,0x1e,0xae,0xc0,0xe9,0x73,0x1c,0x95,0xda,0x36,0x87,0x98,0x66,0x3b,0xab,0x11,0x2f,0x2a,0x76,
+ 0xeb,0x24,0x09,0x1c,0x12,0x33,0xd9,0x6b,0x0d,0x4e,0x70,0x84,0xf5,0x0a,0x17,0x0c,0x82,0x30,0x4c,0x8d,0x95,
+ 0x79,0x37,0x52,0x0c,0xed,0xe2,0x01,0x77,0xca,0xbb,0x5f,0xa2,0x73,0x62,0xb9,0x47,0x44,0xe4,0x51,0x1f,0xeb,
+ 0xa5,0xe2,0x08,0x73,0x2e,0x47,0x20,0x48,0x3a,0x77,0x0f,0xaa,0x79,0x2d,0x00),
+ (0xa0,0xc2,0xcb,0xb0,0x3c,0x1c,0x57,0x04,0x44,0xa6,0x5e,0xd9,0x70,0x69,0x62,0x34,0x89,0x4b,0x6b,0xf0,0x46,
+ 0x7f,0xc4,0x73,0x1a,0x66,0xcf,0x55,0x7f,0x88,0x45,0x3f,0x0c,0xfe,0x2c,0x8e,0xf6,0x8d,0x6a,0xae,0x51,0xe5,
+ 0x0e,0x0f,0xc7,0x8f,0x27,0x7d,0x21,0xef,0x1a,0xe9,0x97,0x09,0x3b,0xe4,0xce,0x64,0x24,0x6a,0xa4,0x30,0xf1,
+ 0x32,0x55,0x5a,0x3c,0x5c,0x81,0xd3,0xe7,0x38,0x2a,0xb5,0x6d,0x0e,0x31,0xcd,0x76,0x56,0x23,0x5e,0x54,0xec,
+ 0xd6,0x49,0x12,0x38,0x24,0x66,0xb2,0xd7,0x1a,0x9c,0xe0,0x08,0xeb,0x15,0x2e,0x18,0x04,0x61,0x98,0x1a,0x2b,
+ 0xf3,0x6e,0xa4,0x18,0xda,0xc5,0x03,0xee,0x94,0x77,0xbf,0x44,0xe7,0xc4,0x72,0x8f,0x88,0xc8,0xa3,0x3e,0xd6,
+ 0x4b,0xc5,0x11,0xe6,0x5c,0x8e,0x40,0x90,0x74,0xee,0x1e,0x54,0xf3,0x5a,0x00),
+ (0x40,0x85,0x97,0x61,0x79,0x38,0xae,0x08,0x88,0x4c,0xbd,0xb2,0xe1,0xd2,0xc4,0x68,0x12,0x97,0xd6,0xe0,0x8d,
+ 0xfe,0x88,0xe7,0x34,0xcc,0x9e,0xab,0xfe,0x10,0x8b,0x7e,0x18,0xfc,0x59,0x1c,0xed,0x1b,0xd5,0x5c,0xa3,0xca,
+ 0x1d,0x1e,0x8e,0x1f,0x4f,0xfa,0x42,0xde,0x35,0xd2,0x2f,0x13,0x76,0xc8,0x9d,0xc9,0x48,0xd4,0x48,0x61,0xe2,
+ 0x65,0xaa,0xb4,0x78,0xb8,0x02,0xa7,0xcf,0x71,0x54,0x6a,0xdb,0x1c,0x62,0x9a,0xed,0xac,0x46,0xbc,0xa8,0xd8,
+ 0xad,0x93,0x24,0x70,0x48,0xcc,0x64,0xaf,0x35,0x38,0xc1,0x11,0xd6,0x2b,0x5c,0x30,0x08,0xc2,0x30,0x35,0x56,
+ 0xe6,0xdd,0x48,0x31,0xb4,0x8b,0x07,0xdc,0x29,0xef,0x7e,0x89,0xce,0x89,0xe5,0x1e,0x11,0x91,0x47,0x7d,0xac,
+ 0x97,0x8a,0x23,0xcc,0xb9,0x1c,0x81,0x20,0xe9,0xdc,0x3d,0xa8,0xe6,0xb5,0x00),
+ (0x80,0x0a,0x2f,0xc3,0xf2,0x70,0x5c,0x11,0x10,0x99,0x7a,0x65,0xc3,0xa5,0x89,0xd1,0x24,0x2e,0xad,0xc1,0x1b,
+ 0xfd,0x11,0xcf,0x69,0x98,0x3d,0x57,0xfd,0x21,0x16,0xfd,0x30,0xf8,0xb3,0x38,0xda,0x37,0xaa,0xb9,0x46,0x95,
+ 0x3b,0x3c,0x1c,0x3f,0x9e,0xf4,0x85,0xbc,0x6b,0xa4,0x5f,0x26,0xec,0x90,0x3b,0x93,0x91,0xa8,0x91,0xc2,0xc4,
+ 0xcb,0x54,0x69,0xf1,0x70,0x05,0x4e,0x9f,0xe3,0xa8,0xd4,0xb6,0x39,0xc4,0x34,0xdb,0x59,0x8d,0x78,0x51,0xb1,
+ 0x5b,0x27,0x49,0xe0,0x90,0x98,0xc9,0x5e,0x6b,0x70,0x82,0x23,0xac,0x57,0xb8,0x60,0x10,0x84,0x61,0x6a,0xac,
+ 0xcc,0xbb,0x91,0x62,0x68,0x17,0x0f,0xb8,0x53,0xde,0xfd,0x12,0x9d,0x13,0xcb,0x3d,0x22,0x22,0x8f,0xfa,0x58,
+ 0x2f,0x15,0x47,0x98,0x73,0x39,0x02,0x41,0xd2,0xb9,0x7b,0x50,0xcd,0x6b,0x01))
+
+def bch_enc_14(data, enc_len, level):
+ """ bch ecc encode function, parity bits is 14.
+ data is the source buffer
+ enc_len is the encode length
+ level is the ecc level used """
+
+ #print "bch encode length is %d, " % enc_len,
+ #print "ecc level is %d " % level
+
+ # select proper matrix for the ecc level assigned #
+ parity_byte = int(math.ceil(float(level) * 14 / 8))
+ #temp = 'matrix = M_14_' + str(level)
+ #exec(temp)
+ if str(level) == "4":
+ matrix = M_14_4
+ elif str(level) == "6":
+ matrix = M_14_6
+ elif str(level) == "8":
+ matrix = M_14_8
+ elif str(level) == "10":
+ matrix = M_14_10
+ elif str(level) == "12":
+ matrix = M_14_12
+ elif str(level) == "14":
+ matrix = M_14_14
+ elif str(level) == "16":
+ matrix = M_14_16
+ elif str(level) == "18":
+ matrix = M_14_18
+ elif str(level) == "20":
+ matrix = M_14_20
+ elif str(level) == "22":
+ matrix = M_14_22
+ elif str(level) == "24":
+ matrix = M_14_24
+ elif str(level) == "28":
+ matrix = M_14_28
+ elif str(level) == "32":
+ matrix = M_14_32
+ elif str(level) == "36":
+ matrix = M_14_36
+ elif str(level) == "40":
+ matrix = M_14_40
+ elif str(level) == "44":
+ matrix = M_14_44
+ elif str(level) == "48":
+ matrix = M_14_48
+ elif str(level) == "52":
+ matrix = M_14_52
+ elif str(level) == "56":
+ matrix = M_14_56
+ elif str(level) == "60":
+ matrix = M_14_60
+ elif str(level) == "68":
+ matrix = M_14_68
+ elif str(level) == "72":
+ matrix = M_14_72
+ elif str(level) == "80":
+ matrix = M_14_80
+
+ # fetch raw data #
+ raw = data + (b'\0' * parity_byte)
+ raw = bytearray(raw)
+
+ for i in range(enc_len):
+ for j in range(8):
+ if (raw[i] & (1 << j)) != 0:
+ for k in range(parity_byte + 1):
+ raw[i + k] ^= matrix[j][k]
+
+ # feedback parity data generated #
+ #raw = raw.decode()#str(raw)
+ parity_data = raw[enc_len:]
+ return parity_data
+
+if __name__ == "__main__":
+ """ this is bch encode function. """
+ print("this is bch encode function.")
\ No newline at end of file
diff --git a/src/bsp/scatter/tools/nand-utils/ecc_bch_13.py b/src/bsp/scatter/tools/nand-utils/ecc_bch_13.py
new file mode 100755
index 0000000..ce7685f
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/ecc_bch_13.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+
+import math
+
+M_13_4 = ((0x45,0x89,0x41,0xb8,0x3a,0xac,0x1a,0x00),
+ (0x8a,0x12,0x83,0x70,0x75,0x58,0x35,0x00),
+ (0x14,0x25,0x06,0xe1,0xea,0xb0,0x6a,0x00),
+ (0x28,0x4a,0x0c,0xc2,0xd5,0x61,0xd5,0x00),
+ (0x50,0x94,0x18,0x84,0xab,0xc3,0xaa,0x01),
+ (0xa0,0x28,0x31,0x08,0x57,0x87,0x55,0x03),
+ (0x40,0x51,0x62,0x10,0xae,0x0e,0xab,0x06),
+ (0x80,0xa2,0xc4,0x20,0x5c,0x1d,0x56,0x0d))
+
+M_13_6 = ((0x7f,0x9e,0x49,0x86,0x93,0x87,0x9d,0xce,0x46,0x5f,0x00),
+ (0xfe,0x3c,0x93,0x0c,0x27,0x0f,0x3b,0x9d,0x8d,0xbe,0x00),
+ (0xfc,0x79,0x26,0x19,0x4e,0x1e,0x76,0x3a,0x1b,0x7d,0x01),
+ (0xf8,0xf3,0x4c,0x32,0x9c,0x3c,0xec,0x74,0x36,0xfa,0x02),
+ (0xf0,0xe7,0x99,0x64,0x38,0x79,0xd8,0xe9,0x6c,0xf4,0x05),
+ (0xe0,0xcf,0x33,0xc9,0x70,0xf2,0xb0,0xd3,0xd9,0xe8,0x0b),
+ (0xc0,0x9f,0x67,0x92,0xe1,0xe4,0x61,0xa7,0xb3,0xd1,0x17),
+ (0x80,0x3f,0xcf,0x24,0xc3,0xc9,0xc3,0x4e,0x67,0xa3,0x2f))
+
+M_13_8 = ((0x51,0x3f,0x51,0x0e,0xbc,0x61,0x90,0xc3,0x05,0x47,0x47,0xbe,0x89,0x01),
+ (0xa2,0x7e,0xa2,0x1c,0x78,0xc3,0x20,0x87,0x0b,0x8e,0x8e,0x7c,0x13,0x03),
+ (0x44,0xfd,0x44,0x39,0xf0,0x86,0x41,0x0e,0x17,0x1c,0x1d,0xf9,0x26,0x06),
+ (0x88,0xfa,0x89,0x72,0xe0,0x0d,0x83,0x1c,0x2e,0x38,0x3a,0xf2,0x4d,0x0c),
+ (0x10,0xf5,0x13,0xe5,0xc0,0x1b,0x06,0x39,0x5c,0x70,0x74,0xe4,0x9b,0x18),
+ (0x20,0xea,0x27,0xca,0x81,0x37,0x0c,0x72,0xb8,0xe0,0xe8,0xc8,0x37,0x31),
+ (0x40,0xd4,0x4f,0x94,0x03,0x6f,0x18,0xe4,0x70,0xc1,0xd1,0x91,0x6f,0x62),
+ (0x80,0xa8,0x9f,0x28,0x07,0xde,0x30,0xc8,0xe1,0x82,0xa3,0x23,0xdf,0xc4))
+
+M_13_10 = ((0xd3,0x92,0x7b,0x58,0x0a,0x9f,0x2c,0x92,0xdb,0x83,0x6a,0x40,0xf5,0x83,0x66,0x9f,0x04,0x00),
+ (0xa6,0x25,0xf7,0xb0,0x14,0x3e,0x59,0x24,0xb7,0x07,0xd5,0x80,0xea,0x07,0xcd,0x3e,0x09,0x00),
+ (0x4c,0x4b,0xee,0x61,0x29,0x7c,0xb2,0x48,0x6e,0x0f,0xaa,0x01,0xd5,0x0f,0x9a,0x7d,0x12,0x00),
+ (0x98,0x96,0xdc,0xc3,0x52,0xf8,0x64,0x91,0xdc,0x1e,0x54,0x03,0xaa,0x1f,0x34,0xfb,0x24,0x00),
+ (0x30,0x2d,0xb9,0x87,0xa5,0xf0,0xc9,0x22,0xb9,0x3d,0xa8,0x06,0x54,0x3f,0x68,0xf6,0x49,0x00),
+ (0x60,0x5a,0x72,0x0f,0x4b,0xe1,0x93,0x45,0x72,0x7b,0x50,0x0d,0xa8,0x7e,0xd0,0xec,0x93,0x00),
+ (0xc0,0xb4,0xe4,0x1e,0x96,0xc2,0x27,0x8b,0xe4,0xf6,0xa0,0x1a,0x50,0xfd,0xa0,0xd9,0x27,0x01),
+ (0x80,0x69,0xc9,0x3d,0x2c,0x85,0x4f,0x16,0xc9,0xed,0x41,0x35,0xa0,0xfa,0x41,0xb3,0x4f,0x02))
+
+M_13_12 = ((0x4f,0xc2,0x99,0xd4,0x10,0xb5,0xd4,0x3c,0xa4,0x2c,0x05,0x4a,0xc6,0xce,0xd6,0x0f,0x09,0xf4,0x40,0x11,0x00),
+ (0x9e,0x84,0x33,0xa9,0x21,0x6a,0xa9,0x79,0x48,0x59,0x0a,0x94,0x8c,0x9d,0xad,0x1f,0x12,0xe8,0x81,0x22,0x00),
+ (0x3c,0x09,0x67,0x52,0x43,0xd4,0x52,0xf3,0x90,0xb2,0x14,0x28,0x19,0x3b,0x5b,0x3f,0x24,0xd0,0x03,0x45,0x00),
+ (0x78,0x12,0xce,0xa4,0x86,0xa8,0xa5,0xe6,0x21,0x65,0x29,0x50,0x32,0x76,0xb6,0x7e,0x48,0xa0,0x07,0x8a,0x00),
+ (0xf0,0x24,0x9c,0x49,0x0d,0x51,0x4b,0xcd,0x43,0xca,0x52,0xa0,0x64,0xec,0x6c,0xfd,0x90,0x40,0x0f,0x14,0x01),
+ (0xe0,0x49,0x38,0x93,0x1a,0xa2,0x96,0x9a,0x87,0x94,0xa5,0x40,0xc9,0xd8,0xd9,0xfa,0x21,0x81,0x1e,0x28,0x02),
+ (0xc0,0x93,0x70,0x26,0x35,0x44,0x2d,0x35,0x0f,0x29,0x4b,0x81,0x92,0xb1,0xb3,0xf5,0x43,0x02,0x3d,0x50,0x04),
+ (0x80,0x27,0xe1,0x4c,0x6a,0x88,0x5a,0x6a,0x1e,0x52,0x96,0x02,0x25,0x63,0x67,0xeb,0x87,0x04,0x7a,0xa0,0x08))
+
+M_13_14 = ((0xeb,0xee,0x73,0xc9,0x34,0x8a,0xc0,0x32,0x03,0x65,0x1f,0x54,0x4b,0xad,0x2b,0xd4,0xe0,0x15,0x23,0xc2,0x08,0x65,0x4a,0x00),
+ (0xd6,0xdd,0xe7,0x92,0x69,0x14,0x81,0x65,0x06,0xca,0x3e,0xa8,0x96,0x5a,0x57,0xa8,0xc1,0x2b,0x46,0x84,0x11,0xca,0x94,0x00),
+ (0xac,0xbb,0xcf,0x25,0xd3,0x28,0x02,0xcb,0x0c,0x94,0x7d,0x50,0x2d,0xb5,0xae,0x50,0x83,0x57,0x8c,0x08,0x23,0x94,0x29,0x01),
+ (0x58,0x77,0x9f,0x4b,0xa6,0x51,0x04,0x96,0x19,0x28,0xfb,0xa0,0x5a,0x6a,0x5d,0xa1,0x06,0xaf,0x18,0x11,0x46,0x28,0x53,0x02),
+ (0xb0,0xee,0x3e,0x97,0x4c,0xa3,0x08,0x2c,0x33,0x50,0xf6,0x41,0xb5,0xd4,0xba,0x42,0x0d,0x5e,0x31,0x22,0x8c,0x50,0xa6,0x04),
+ (0x60,0xdd,0x7d,0x2e,0x99,0x46,0x11,0x58,0x66,0xa0,0xec,0x83,0x6a,0xa9,0x75,0x85,0x1a,0xbc,0x62,0x44,0x18,0xa1,0x4c,0x09),
+ (0xc0,0xba,0xfb,0x5c,0x32,0x8d,0x22,0xb0,0xcc,0x40,0xd9,0x07,0xd5,0x52,0xeb,0x0a,0x35,0x78,0xc5,0x88,0x30,0x42,0x99,0x12),
+ (0x80,0x75,0xf7,0xb9,0x64,0x1a,0x45,0x60,0x99,0x81,0xb2,0x0f,0xaa,0xa5,0xd6,0x15,0x6a,0xf0,0x8a,0x11,0x61,0x84,0x32,0x25))
+
+M_13_16 = ((0xa7,0xfb,0xf8,0x61,0xfb,0x46,0x8d,0x5b,0xbf,0x09,0xfe,0xc1,0xdf,0xab,0x44,0xff,0x81,0xec,0x9b,0x3d,0xca,0x00,0x67,0x17,0x7e,0x17,0x01),
+ (0x4e,0xf7,0xf1,0xc3,0xf6,0x8d,0x1a,0xb7,0x7e,0x13,0xfc,0x83,0xbf,0x57,0x89,0xfe,0x03,0xd9,0x37,0x7b,0x94,0x01,0xce,0x2e,0xfc,0x2e,0x02),
+ (0x9c,0xee,0xe3,0x87,0xed,0x1b,0x35,0x6e,0xfd,0x26,0xf8,0x07,0x7f,0xaf,0x12,0xfd,0x07,0xb2,0x6f,0xf6,0x28,0x03,0x9c,0x5d,0xf8,0x5d,0x04),
+ (0x38,0xdd,0xc7,0x0f,0xdb,0x37,0x6a,0xdc,0xfa,0x4d,0xf0,0x0f,0xfe,0x5e,0x25,0xfa,0x0f,0x64,0xdf,0xec,0x51,0x06,0x38,0xbb,0xf0,0xbb,0x08),
+ (0x70,0xba,0x8f,0x1f,0xb6,0x6f,0xd4,0xb8,0xf5,0x9b,0xe0,0x1f,0xfc,0xbd,0x4a,0xf4,0x1f,0xc8,0xbe,0xd9,0xa3,0x0c,0x70,0x76,0xe1,0x77,0x11),
+ (0xe0,0x74,0x1f,0x3f,0x6c,0xdf,0xa8,0x71,0xeb,0x37,0xc1,0x3f,0xf8,0x7b,0x95,0xe8,0x3f,0x90,0x7d,0xb3,0x47,0x19,0xe0,0xec,0xc2,0xef,0x22),
+ (0xc0,0xe9,0x3e,0x7e,0xd8,0xbe,0x51,0xe3,0xd6,0x6f,0x82,0x7f,0xf0,0xf7,0x2a,0xd1,0x7f,0x20,0xfb,0x66,0x8f,0x32,0xc0,0xd9,0x85,0xdf,0x45),
+ (0x80,0xd3,0x7d,0xfc,0xb0,0x7d,0xa3,0xc6,0xad,0xdf,0x04,0xff,0xe0,0xef,0x55,0xa2,0xff,0x40,0xf6,0xcd,0x1e,0x65,0x80,0xb3,0x0b,0xbf,0x8b))
+
+def bch_enc_13(data, enc_len, level):
+ """ bch ecc encode function, parity bits is 13.
+ data is the source buffer
+ enc_len is the encode length
+ level is the ecc level used """
+
+ #print "bch encode length is %d, " % enc_len,
+ #print "ecc level is %d " % level
+
+ # select proper matrix for the ecc level assigned #
+ parity_byte = int(math.ceil(float(level) * 13 / 8))
+ temp = 'matrix = M_13_' + str(level)
+ exec(temp)
+
+ # fetch raw data #
+ raw = data + ('\0' * parity_byte)
+ raw = bytearray(raw)
+
+ for i in range(enc_len):
+ for j in range(8):
+ if (raw[i] & (1 << j)) != 0:
+ for k in range(parity_byte + 1):
+ raw[i + k] ^= matrix[j][k]
+
+ # feedback parity data generated #
+ raw = str(raw)
+ parity_data = raw[enc_len:]
+ return parity_data
+
+if __name__ == "__main__":
+ """ this is bch encode function. """
+ print "this is bch encode function."
diff --git a/src/bsp/scatter/tools/nand-utils/gen-nand-burn-img.sh b/src/bsp/scatter/tools/nand-utils/gen-nand-burn-img.sh
new file mode 100755
index 0000000..1608eaa
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen-nand-burn-img.sh
@@ -0,0 +1,147 @@
+#! /bin/sh
+
+NAND_HEADER_VERSION=$1
+NAND_CHIP_NAME=$2
+PARTITION_XML=$3
+
+if [ "${NAND_CHIP_NAME}" = "" ]; then
+ echo "ERROR: please input NAND_CHIP_NAME"
+ exit 1
+else
+ echo "NAND: ${NAND_CHIP_NAME}"
+fi
+
+if [ "${NAND_HEADER_VERSION}" = "" ]; then
+ echo "ERROR: please input NAND_HEADER_VERSION"
+ exit 2
+else
+ echo "NAND_HEADER_VERSION: ${NAND_HEADER_VERSION}"
+ if [ "${NAND_HEADER_VERSION}" = "2.0" ]; then
+ RANDOM_EN=0
+ elif [ "${NAND_HEADER_VERSION}" = "1.1" ]; then
+ RANDOM_EN=1
+ fi
+fi
+
+if [ "${PARTITION_XML}" = "" ]; then
+ echo "ERROR: please input PARTITION_XML"
+ exit 3
+else
+ echo "PARTITION_XML: ${PARTITION_XML}"
+fi
+
+OUTPUT_FLD="output"
+IMAGE_FLD="images"
+BURN_SUFFIX="-burn"
+BURN_IMG="${PWD}/${OUTPUT_FLD}/nand-burn.img"
+BURN_LIST_CSV="${PWD}/${OUTPUT_FLD}/partition_table.csv"
+BURN_LIST_DEF="${PWD}/${OUTPUT_FLD}/partition_table.def"
+rm -rf ${PWD}/${OUTPUT_FLD}/*${BURN_SUFFIX}
+rm -rf ${BURN_IMG}
+touch ${BURN_IMG}
+
+rm -rf ${BURN_LIST_CSV}
+touch ${BURN_LIST_CSV}
+rm -rf ${BURN_LIST_DEF}
+touch ${BURN_LIST_DEF}
+
+python ${PWD}/tools/nand-utils/gen_burner_partition_table_def.py ${NAND_CHIP_NAME} \
+ ${NAND_HEADER_VERSION} ${BURN_LIST_DEF} 0 0 0 0
+
+LBS=$(grep -o 'lbs="[0-9]*"' ${PARTITION_XML} | grep -o [0-9]*)
+
+MBR_NAND="MBR_NAND"
+MBR_NAND_BRUN="MBR_NAND-burn"
+PART_IDX=0
+
+cat ${PARTITION_XML} | while read line
+do
+ IMAGE_NAME=""
+ LBA_START=""
+ LBA_END=""
+ CHECK=$(echo $line | grep "name")
+ if [ "${CHECK}" != "" ]; then
+ PARTITION=${line#*name=}
+ PARTITION=${PARTITION#*\"}
+ PARTITION=${PARTITION%%\"*}
+ else
+ PARTITION=""
+ fi
+ if [ "${PARTITION}" = "UBOOT" ]; then
+ IMAGE_NAME="lk.img"
+ fi
+ if [ "${PARTITION}" = "TEE1" -o "${PARTITION}" = "TEE2" ]; then
+ IMAGE_NAME="tz.img"
+ fi
+ if [ "${PARTITION}" = "USRDATA" ]; then
+ IMAGE_NAME="userdata.ubi"
+ fi
+ if [ "${PARTITION}" = "BOOTIMG1" -o "${PARTITION}" = "BOOTIMG2" ]; then
+ IMAGE_NAME="boot.img"
+ fi
+ if [ "${PARTITION}" = "ROOTFS1" -o "${PARTITION}" = "ROOTFS2" ]; then
+ IMAGE_NAME="rootfs.ubi"
+ fi
+
+ if [ "${PARTITION}" != "" ]; then
+ echo ${PART_IDX} ${PARTITION}
+ if [ "${IMAGE_NAME}" != "" -a ! -f "${PWD}/${IMAGE_FLD}/${IMAGE_NAME}" ]; then
+ echo "file "${PWD}/${IMAGE_FLD}/${IMAGE_NAME}" not exist!! "
+ IMAGE_NAME=""
+ fi
+ LBA_START=${line#*start=}
+ LBA_START=${LBA_START#*\"}
+ LBA_START=${LBA_START%%\"*}
+ LBA_END=${line#*end=}
+ LBA_END=${LBA_END#*\"}
+ LBA_END=${LBA_END%%\"*}
+ ((LBA_NUM=${LBA_END}-${LBA_START}+1))
+ ((PART_SIZE=${LBS}*${LBA_NUM}))
+ ((PART_START_ADDR=${LBS}*${LBA_START}))
+
+ if [ "${PART_IDX}" = "0" ]; then
+ ((MBR_PART_SIZE=${LBS}*${LBA_START}))
+ ((MBR_LBA_END=${LBA_START}-1))
+ python ${PWD}/tools/nand-utils/gen_burner_image.pyc ${NAND_CHIP_NAME} \
+ ${PWD}/${IMAGE_FLD}/${MBR_NAND} ${PWD}/${OUTPUT_FLD}/${MBR_NAND_BRUN} ${NAND_HEADER_VERSION} ${RANDOM_EN}
+ touch ${PWD}/${IMAGE_FLD}/${MBR_NAND_BRUN}
+ cat ${PWD}/${OUTPUT_FLD}/${MBR_NAND_BRUN} >> ${PWD}/${IMAGE_FLD}/${MBR_NAND_BRUN}
+ python ${PWD}/tools/nand-utils/pad_dummy_data_by_partition.pyc ${NAND_CHIP_NAME} \
+ ${PWD}/${IMAGE_FLD}/${MBR_NAND_BRUN} ${MBR_PART_SIZE} ${NAND_HEADER_VERSION}
+ cat ${PWD}/${IMAGE_FLD}/${MBR_NAND_BRUN} > ${BURN_IMG}
+ python ${PWD}/tools/nand-utils/gen_burner_partition_table_def.py ${NAND_CHIP_NAME} \
+ ${NAND_HEADER_VERSION} ${BURN_LIST_DEF} ${PWD}/${OUTPUT_FLD}/${MBR_NAND_BRUN} 0 ${MBR_LBA_END} 1
+ python ${PWD}/tools/nand-utils/gen_burner_partition_table_csv.py ${NAND_CHIP_NAME} \
+ ${NAND_HEADER_VERSION} ${BURN_LIST_CSV} ${PWD}/${OUTPUT_FLD}/${MBR_NAND_BRUN} 0 ${MBR_LBA_END} "MBR_NAND"
+ fi
+
+ fi
+
+ if [ "${IMAGE_NAME}" != "" ]; then
+ PART_IDX=$((${PART_IDX}+1))
+ if [ ! -f "${PWD}/${IMAGE_FLD}/${IMAGE_NAME}${BURN_SUFFIX}" ]; then
+ python ${PWD}/tools/nand-utils/gen_burner_image.pyc ${NAND_CHIP_NAME} \
+ ${PWD}/${IMAGE_FLD}/${IMAGE_NAME} ${PWD}/${OUTPUT_FLD}/${IMAGE_NAME}${BURN_SUFFIX} ${NAND_HEADER_VERSION} ${RANDOM_EN}
+ touch ${PWD}/${IMAGE_FLD}/${IMAGE_NAME}${BURN_SUFFIX}
+ cat ${PWD}/${OUTPUT_FLD}/${IMAGE_NAME}${BURN_SUFFIX} >> ${PWD}/${IMAGE_FLD}/${IMAGE_NAME}${BURN_SUFFIX}
+ python ${PWD}/tools/nand-utils/pad_dummy_data_by_partition.pyc ${NAND_CHIP_NAME} \
+ ${PWD}/${IMAGE_FLD}/${IMAGE_NAME}${BURN_SUFFIX} ${PART_SIZE} ${NAND_HEADER_VERSION}
+ fi
+ cat ${PWD}/${IMAGE_FLD}/${IMAGE_NAME}${BURN_SUFFIX} >> ${BURN_IMG}
+ python ${PWD}/tools/nand-utils/gen_burner_partition_table_def.py ${NAND_CHIP_NAME} \
+ ${NAND_HEADER_VERSION} ${BURN_LIST_DEF} ${PWD}/${OUTPUT_FLD}/${IMAGE_NAME}${BURN_SUFFIX} ${LBA_START} ${LBA_END} 1
+ python ${PWD}/tools/nand-utils/gen_burner_partition_table_csv.py ${NAND_CHIP_NAME} \
+ ${NAND_HEADER_VERSION} ${BURN_LIST_CSV} ${PWD}/${OUTPUT_FLD}/${IMAGE_NAME}${BURN_SUFFIX} ${LBA_START} ${LBA_END} ${PARTITION}
+ elif [ "${PARTITION}" != "" ]; then
+ PART_IDX=$((${PART_IDX}+1))
+ touch ${PWD}/${IMAGE_FLD}/${PARTITION}${BURN_SUFFIX}
+ python ${PWD}/tools/nand-utils/pad_dummy_data_by_partition.pyc ${NAND_CHIP_NAME} \
+ ${PWD}/${IMAGE_FLD}/${PARTITION}${BURN_SUFFIX} ${PART_SIZE} ${NAND_HEADER_VERSION}
+ cat ${PWD}/${IMAGE_FLD}/${PARTITION}${BURN_SUFFIX} >> ${BURN_IMG}
+ fi
+done
+
+python ${PWD}/tools/nand-utils/gen_burner_partition_table_def.py ${NAND_CHIP_NAME} \
+ ${NAND_HEADER_VERSION} ${BURN_LIST_DEF} 0 0 0 2
+
+rm -f ${PWD}/${IMAGE_FLD}/*${BURN_SUFFIX}
diff --git a/src/bsp/scatter/tools/nand-utils/gen_burner_image.py b/src/bsp/scatter/tools/nand-utils/gen_burner_image.py
new file mode 100644
index 0000000..a6acb1a
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_burner_image.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import os
+import math
+import shutil
+import pp_tbl
+import gen_nand_header
+import gen_nand_header_v11
+import randomizer
+from pad_ecc_by_sector import pad_ecc
+from randomizer import randomizer
+
+def padding(data, size):
+ return data + '\0' * (size - len(data))
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('in_image', help = 'raw input image')
+ parser.add_argument('out_image', help = 'the output burn image ')
+ parser.add_argument('version', help= 'nand header version')
+ parser.add_argument('rand_en', help = 'if randomizer is enabled')
+ args = parser.parse_args()
+ version = float(args.version)
+ rand_en = int(args.rand_en)
+
+ if version == 2.0:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header.gen_header(args.nand_name)
+ bad_swap = 1
+ elif version == 1.1:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header_v11.gen_header(args.nand_name, 192, args.nand_name + '_header.bin')
+ bad_swap = 0
+
+ ecc_file = args.out_image
+ rand_file = args.out_image
+ if rand_en == 1:
+ ecc_file = args.nand_name + '_ecc.bin'
+ if ppen == 1:
+ paired = raw_input("insert empty paired page ? Y/y or N/n ")
+ if paired in ['Y', 'y']:
+ rand_file = args.nand_name + '_rand.bin'
+ ecc_file = args.nand_name + '_ecc.bin'
+ sector_size = 1024 if page_size > 512 else 512
+ sector_per_page = page_size / sector_size
+ sector_spare_size = spare_size / sector_per_page
+ # input image page size alignment #
+ file_len = os.path.getsize(args.in_image)
+ pages = int(math.ceil(float(file_len) / page_size))
+ in_file = "temp_in.bin"
+ with open(args.in_image, "rb") as f_in:
+ with open(in_file, "wb") as f_temp:
+ f_temp.write(padding(f_in.read(), pages * page_size))
+ pad_ecc(in_file, ecc_file, sector_size, fdm_size, fdmecc_size, ecc_strength, sector_spare_size, page_size, bad_swap)
+
+ if rand_en == 1:
+ randomizer(ecc_file, rand_file, "SS", 1, page_size, spare_size, sector_size, ppb, ppen, vendor)
+
+ # MT8516 force sector spare size from 56, 54, to be 52
+ if version == 1.1:
+ # spare settings must match 8516 BOOT ROM, The sector size default is 1024 bytes.
+ SPARES = [32, 52, 64, 80, 88, 96, 100, 104, 122, 124]
+ sector_spare_size_adjust = sector_spare_size
+
+ for i in range(len(SPARES)):
+ if (sector_spare_size <= SPARES[i]):
+ if sector_spare_size == SPARES[i]:
+ sector_spare_size_adjust = SPARES[i]
+ if (sector_spare_size < SPARES[i]) and (i != 0):
+ sector_spare_size_adjust = SPARES[i - 1]
+ break
+ k = 0
+ pad_data = (sector_spare_size - sector_spare_size_adjust) * sector_per_page
+ adjust_file = rand_file + '_adjust'
+ f_in = open(rand_file, "rb")
+ f_out = open(adjust_file, "wb")
+ for i in range(pages * sector_per_page):
+ f_in.seek(((sector_size + sector_spare_size) * i), 0)
+ sector_data = f_in.read(sector_size + sector_spare_size_adjust)
+ if (i % sector_per_page) == (sector_per_page - 1):
+ sector_data += '\xff' * pad_data
+ if (i) > 0 and (i % sector_per_page) == 0:
+ k = k + 1
+ f_out.seek(((sector_size + sector_spare_size) * i), 0)
+ else:
+ f_out.seek((sector_size + sector_spare_size_adjust) * i + (k * pad_data), 0)
+
+ f_out.write(sector_data)
+
+ f_in.close()
+ f_out.close()
+ shutil.copyfile(adjust_file, rand_file)
+ # remove temp files #
+ os.remove(adjust_file)
+ # insert empty paired page #
+ if ppen == 1 and paired in ['Y', 'y']:
+ if rand_en == 1:
+ pp_file = rand_file
+ else:
+ pp_file = ecc_file
+ if vendor == 'TSB':
+ PP = pp_tbl.TSB_PP
+ else:
+ raise Exception("unsupport %s pp table " % vendor)
+ f_pp = open(pp_file, "rb")
+ f_out = open(args.out_image, "wb")
+
+ if (os.path.getsize(in_file) % page_size) != 0:
+ raise Exception("input image size is not page size aligned")
+ page_number = os.path.getsize(in_file) / page_size
+ block_number = int(math.ceil(float(page_number) / (ppb / 2)))
+ print "page num %d block num %d" % (page_number, block_number)
+ for i in range(ppb * block_number):
+ if page_number > 0 and (i % ppb) in PP:
+ f_out.write(f_pp.read(page_size + spare_size))
+ page_number -= 1
+ else:
+ f_out.write('\xff' * (page_size + spare_size))
+ f_pp.close()
+ f_out.close()
+ # remove temp files #
+ os.remove(pp_file)
+
+ if rand_en == 1:
+ os.remove(ecc_file)
+
+ # remove temp files #
+ os.remove(args.nand_name + '_header.bin')
+ os.remove(in_file)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_burner_partition_table_csv.py b/src/bsp/scatter/tools/nand-utils/gen_burner_partition_table_csv.py
new file mode 100755
index 0000000..c2adf29
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_burner_partition_table_csv.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+import argparse
+import csv
+import sys
+import struct
+import os
+import math
+import gen_nand_header
+import gen_nand_header_v11
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('version', help= 'nand header version')
+ parser.add_argument('table_file', help = 'partition table file')
+ parser.add_argument('image', help = 'image file name')
+ parser.add_argument('start_page', help = 'partition start page index')
+ parser.add_argument('end_page', help = 'partition end page index')
+ parser.add_argument('part_name', help = 'partition name')
+ args = parser.parse_args()
+
+ version = float(args.version)
+ start_page = int(args.start_page)
+ end_page = int(args.end_page)
+ if version == 2.0:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header.gen_header(args.nand_name)
+ elif version == 1.1:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header_v11.gen_header(args.nand_name, 192, args.nand_name + '_header.bin')
+
+ file_len = os.path.getsize(args.image)
+ if (file_len % (page_size + spare_size)) != 0:
+ raise Exception("image size is not full page size aligned")
+ block_num = int(math.ceil(float(file_len) / ((page_size + spare_size) * ppb)))
+ if (start_page % ppb) != 0:
+ raise Exception("partition start page is not block align")
+ start_blk = start_page / ppb
+ if ((end_page + 1) % ppb) != 0:
+ raise Exception("partition end page is not block align")
+ end_blk = end_page / ppb
+ line_info = [start_blk, end_blk, block_num, '0xffffffff', args.part_name]
+
+ with open(args.table_file, "ab") as csvf:
+ csvwriter = csv.writer(csvf, delimiter=';')
+ csvwriter.writerow(line_info)
+
+ # remove temp files #
+ os.remove(args.nand_name + '_header.bin')
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_burner_partition_table_def.py b/src/bsp/scatter/tools/nand-utils/gen_burner_partition_table_def.py
new file mode 100755
index 0000000..61c81dd
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_burner_partition_table_def.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import struct
+import os
+import math
+import gen_nand_header
+import gen_nand_header_v11
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('version', help= 'nand header version')
+ parser.add_argument('table_file', help = 'partition table file')
+ parser.add_argument('image', help = 'image file name')
+ parser.add_argument('start_page', help = 'partition start page index')
+ parser.add_argument('end_page', help = 'partition end page index')
+ parser.add_argument('pad', help = '0: pad header, 1: no pad, 2: pad tail')
+ args = parser.parse_args()
+ pad = int(args.pad)
+
+ if pad == 0:
+ line_info = "GROUP DEFINE2" + (3 * '\0')
+ elif pad == 2:
+ line_info = 16 * '\xff'
+ elif pad == 1:
+ version = float(args.version)
+ start_page = int(args.start_page)
+ end_page = int(args.end_page)
+ if version == 2.0:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header.gen_header(args.nand_name)
+ elif version == 1.1:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header_v11.gen_header(args.nand_name, 192, args.nand_name + '_header.bin')
+
+ file_len = os.path.getsize(args.image)
+ if (file_len % (page_size + spare_size)) != 0:
+ raise Exception("image size is not full page size aligned")
+ block_num = int(math.ceil(float(file_len) / ((page_size + spare_size) * ppb)))
+ if (start_page % ppb) != 0:
+ raise Exception("partition start page is not block align")
+ start_blk = start_page / ppb
+ if ((end_page + 1) % ppb) != 0:
+ raise Exception("partition end page is not block align")
+ end_blk = end_page / ppb
+
+ data_type = 1
+
+ line_info = struct.pack("I", data_type)
+ line_info += struct.pack("I", start_blk)
+ line_info += struct.pack("I", end_blk)
+ line_info += struct.pack("I", block_num)
+
+ # remove temp files #
+ os.remove(args.nand_name + '_header.bin')
+ else:
+ raise Exception("wrong pad type")
+
+ with open(args.table_file, "ab") as f:
+ f.write(line_info)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header.py
new file mode 100755
index 0000000..fa71e74
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header.py
@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+import pp_tbl
+
+def gen_header(nand_name):
+ """ device info:
+ name vendor totalsize(MB) pagesize(B) sparesize(B) pageperblock cycle eccstrength
+ interface acccon acccon1 dqsdlymux dqsdlyctrl nfidlyctrl pptableenable lbasize
+ fastclock usedma fdmsize fdmeccsize strobesel
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ vendor = s[1]
+ total_size = int(s[2])
+ page_size = int(s[3])
+ #page_shift = len(bin(page_size).replace('0b','')) - 1
+ page_shift = 16 if page_size > 512 else 8
+ spare_size = int(s[4])
+ page_per_block = int(s[5])
+ address_cycle = int(s[6])
+ ecc_strength = int(s[7])
+ interface = int(s[8])
+ acccon = eval(s[9])
+ acccon1 = eval(s[10])
+ dqsdlymux = int(s[11])
+ dqsdlyctrl = eval(s[12])
+ nfidlyctrl = eval(s[13])
+ pptableen = int(s[14])
+ lba_size = int(s[15])
+ fast_clk = int(s[16])
+ use_dma = int(s[17])
+ fdm_size = int(s[18])
+ fdmecc_size = int(s[19])
+ strobesel = int(s[20])
+
+ # meaningless, just set pptableen value as BROM test code #
+ if not pptableen:
+ pptableen = 0xffff
+
+ break
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ #print s[0]
+ #print "vendor %s, total size %d(MB) page size %d, page shift %d, spare size %d, page per block %d" \
+ # % (vendor, total_size, page_size, page_shift, spare_size, page_per_block)
+ #print "address cycle %d, ecc strength %d, interface %d, acccon 0x%x, acccon1 0x%x" \
+ # % (address_cycle, ecc_strength, interface, acccon, acccon1)
+ #print "dqsdlymux %d, dqsdlyctrl 0x%x, nfidlyctrl 0x%x, pptable enable %d, lba size %d" \
+ # % (dqsdlymux, dqsdlyctrl, nfidlyctrl, pptableen, lba_size)
+ #print "fast clock enable %d, use dma %d, fdm size %d, fdmecc size %d" \
+ # % (fast_clk, use_dma, fdm_size, fdmecc_size)
+ #raise KeyError("not support " + nand_name)
+
+ # nand header is total 440B include ecc parity 140B #
+ header_size = 300
+ pptbl_size = 128
+
+ header = "NANDCONFIG!" + '\0'
+ header += struct.pack("I", total_size)
+ header += struct.pack("H", page_size)
+ header += struct.pack("H", address_cycle)
+ header += struct.pack("H", spare_size)
+ header += struct.pack("H", interface)
+ header += struct.pack("I", ecc_strength)
+ header += struct.pack("H", page_per_block)
+ header += struct.pack("H", page_shift)
+ header += struct.pack("H", pptableen)
+ header += struct.pack("H", dqsdlymux)
+ header += struct.pack("I", dqsdlyctrl)
+ header += struct.pack("I", acccon)
+ header += struct.pack("I", acccon1)
+ header += struct.pack("I", nfidlyctrl)
+ header += struct.pack("H", lba_size)
+ header += struct.pack("H", fast_clk)
+ header += struct.pack("H", use_dma)
+ header += struct.pack("H", strobesel)
+ header += struct.pack("H", fdm_size)
+ header += struct.pack("H", fdmecc_size)
+
+ # pad dummy byte #
+ header += '\x5a' * (header_size - len(header) - pptbl_size)
+ if pptableen == 1:
+ # add pptable #
+ if vendor == 'TSB':
+ header += str(bytearray(pp_tbl.TSB_PP))
+ else:
+ raise KeyError(" no %s pptable " % vendor)
+ else:
+ header += '\xff' * pptbl_size
+
+ # calculate header ecc parity #
+ header_size = 300
+ ecc_level = 80
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+
+ header_file = nand_name + '_header.bin'
+ with open(header_file, "wb") as f:
+ f.write(header)
+
+ return (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, pptableen, page_per_block)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('gpt_image', help = 'pmbr + gpt entry image ')
+ args = parser.parse_args()
+
+ # generate nand device header #
+ gen_header(args.nand_name)
+
+ # pad nand header #
+ with open(args.nand_name + '_header.bin', "rb") as f_h:
+ h_buf = f_h.read()
+ with open(args.gpt_image, "rb+") as f_g:
+ f_g.seek(440, 0)
+ h_buf = h_buf + f_g.read()
+ f_g.seek(0, 0)
+ f_g.write(h_buf)
+
+ os.remove(args.nand_name + '_header.bin')
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_mt2731.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_mt2731.py
new file mode 100755
index 0000000..cea124e
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_mt2731.py
@@ -0,0 +1,141 @@
+#// SPDX-License-Identifier: MediaTekProprietary
+#!/usr/bin/env python
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+import pp_tbl
+
+def gen_header(nand_name):
+ """ device info:
+ name vendor totalsize(MB) pagesize(B) sparesize(B) pageperblock cycle eccstrength
+ interface acccon acccon1 dqsdlymux dqsdlyctrl nfidlyctrl pptableenable lbasize
+ fastclock usedma fdmsize fdmeccsize strobesel
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_mt2731.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ vendor = s[1]
+ total_size = int(s[2])
+ page_size = int(s[3])
+ #page_shift = len(bin(page_size).replace('0b','')) - 1
+ page_shift = 16 if page_size > 512 else 8
+ spare_size = int(s[4])
+ page_per_block = int(s[5])
+ address_cycle = int(s[6])
+ ecc_strength = int(s[7])
+ interface = int(s[8])
+ acccon = eval(s[9])
+ acccon1 = eval(s[10])
+ dqsdlymux = int(s[11])
+ dqsdlyctrl = eval(s[12])
+ nfidlyctrl = eval(s[13])
+ pptableen = int(s[14])
+ lba_size = int(s[15])
+ fast_clk = int(s[16])
+ use_dma = int(s[17])
+ fdm_size = int(s[18])
+ fdmecc_size = int(s[19])
+ strobesel = int(s[20])
+
+ # meaningless, just set pptableen value as BROM test code #
+ if not pptableen:
+ pptableen = 0xffff
+
+ break
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ #print s[0]
+ #print "vendor %s, total size %d(MB) page size %d, page shift %d, spare size %d, page per block %d" \
+ # % (vendor, total_size, page_size, page_shift, spare_size, page_per_block)
+ #print "address cycle %d, ecc strength %d, interface %d, acccon 0x%x, acccon1 0x%x" \
+ # % (address_cycle, ecc_strength, interface, acccon, acccon1)
+ #print "dqsdlymux %d, dqsdlyctrl 0x%x, nfidlyctrl 0x%x, pptable enable %d, lba size %d" \
+ # % (dqsdlymux, dqsdlyctrl, nfidlyctrl, pptableen, lba_size)
+ #print "fast clock enable %d, use dma %d, fdm size %d, fdmecc size %d" \
+ # % (fast_clk, use_dma, fdm_size, fdmecc_size)
+ #raise KeyError("not support " + nand_name)
+
+ # nand header is total 440B include ecc parity 140B #
+ header_size = 398
+ pptbl_size = 128
+
+ # the reserved region is for SGPT and BBT
+ reserved_size = page_size * page_per_block * 8 / 1024
+ # As NAND totol size for 2731 BROM is unit as Mega, the reserved size need to be the unit of Mega
+ if (reserved_size % 1024) == 0:
+ total_size = total_size - reserved_size / 1024
+
+ header = "NANDCONFIG!" + '\0'
+ header += struct.pack("I", total_size)
+ header += struct.pack("H", page_size)
+ header += struct.pack("H", address_cycle)
+ header += struct.pack("H", spare_size)
+ header += struct.pack("H", interface)
+ header += struct.pack("I", ecc_strength)
+ header += struct.pack("H", page_per_block)
+ header += struct.pack("H", page_shift)
+ header += struct.pack("H", pptableen)
+ header += struct.pack("H", dqsdlymux)
+ header += struct.pack("I", dqsdlyctrl)
+ header += struct.pack("I", acccon)
+ header += struct.pack("I", acccon1)
+ header += struct.pack("I", nfidlyctrl)
+ header += struct.pack("H", lba_size)
+ header += struct.pack("H", fast_clk)
+ header += struct.pack("H", use_dma)
+ header += struct.pack("H", strobesel)
+ header += struct.pack("H", fdm_size)
+ header += struct.pack("H", fdmecc_size)
+ # pad dummy byte #
+ header += '\x5a' * (header_size - len(header) - pptbl_size)
+ if pptableen == 1:
+ # add pptable #
+ if vendor == 'TSB':
+ header += str(bytearray(pp_tbl.TSB_PP))
+ else:
+ raise KeyError(" no %s pptable " % vendor)
+ else:
+ header += '\xff' * pptbl_size
+
+ # calculate header ecc parity #
+ header_size = 398
+ ecc_level = 24
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+
+ header_file = nand_name + '_header.bin'
+ with open(header_file, "wb") as f:
+ f.write(header)
+
+ return (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, pptableen, page_per_block)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('gpt_image', help = 'pmbr + gpt entry image ')
+ args = parser.parse_args()
+
+ # generate nand device header #
+ gen_header(args.nand_name)
+
+ # pad nand header #
+ with open(args.nand_name + '_header.bin', "rb") as f_h:
+ h_buf = f_h.read()
+ with open(args.gpt_image, "rb+") as f_g:
+ f_g.seek(440, 0)
+ h_buf = h_buf + f_g.read()
+ f_g.seek(0, 0)
+ f_g.write(h_buf)
+
+ os.remove(args.nand_name + '_header.bin')
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_mt2735_hsm.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_mt2735_hsm.py
new file mode 100755
index 0000000..13932c7
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_mt2735_hsm.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+
+def gen_header(nand_name, header_file):
+ """ device info:
+ name vendor pagesize(B) sparesize(B) pageperblock blocks cycle
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_mt2735_hsm.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ vendor = s[1]
+ page_size = int(s[2])
+ spare_size = int(s[3])
+ pages_per_block = int(s[4])
+ blocks = int(s[5])
+ cycle = int(s[6])
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ # step1: generate nand header info #
+ header = "NANDCFG!"
+ version = 1
+ # dma mode enable, normal speed
+ config = 0x1
+ sector_size = 1024
+ fdm_size = 8
+ fdmecc_size = 1
+ lbs = 0
+ header += struct.pack("IIIIII", version, config, sector_size,\
+ fdm_size, fdmecc_size, lbs)
+ plane_sel_poi = 12
+ # parameter page is enabled
+ parameter_page_en = (1 << 2)
+ if (config & parameter_page_en):
+ nand = struct.pack("IIIII", 0, 0,\
+ 0, 0,\
+ plane_sel_poi)
+ else:
+ nand = struct.pack("IIIII", page_size, spare_size,\
+ pages_per_block, blocks,\
+ plane_sel_poi)
+ header += nand
+ pll = 0
+ # normal speed, acccon do not need to be set, BROM use default 0x30C77FFF
+ acccon = 0
+ # normal speed, strobe_sel do not need to be set
+ strobe_sel = 0
+ acccon1 = 0
+ dqs_delay_mux = 0
+ dqs_delay_ctrl = 0
+ delay_ctrl = 0
+ latch_lat = 0
+ sam_dly = 0
+ driving = 0
+ high_speed = struct.pack("IIIIIIIIII", pll, acccon, strobe_sel,\
+ acccon1, dqs_delay_mux,\
+ dqs_delay_ctrl, delay_ctrl,\
+ latch_lat, sam_dly, driving)
+ header += high_speed
+ bl_start = 0
+ bl_end = 0
+ header += struct.pack("II", bl_start, bl_end)
+ ecc_level = 24
+ header_size = len(header) + ecc_level * 14 / 8
+ print "header_size: %d" % header_size
+
+ ecc = ecc_bch.bch_enc_14(header, len(header), ecc_level)
+ header += ecc
+
+ with open(header_file, "wb") as f:
+ f.write(header)
+
+ return (header_size, sector_size, fdm_size, fdmecc_size, lbs)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('gpt_image', help = 'pmbr + gpt entry image ')
+ args = parser.parse_args()
+
+ header_file = args.nand_name + '_header.bin'
+ # generate nand device header #
+ gen_header(args.nand_name, header_file)
+
+ # pad nand header #
+ with open(header_file, "rb") as f_h:
+ h_buf = f_h.read()
+ with open(args.gpt_image, "rb+") as f_g:
+ f_g.seek(440, 0)
+ h_buf += '\x00' * (440 - len(h_buf))
+ h_buf = h_buf + f_g.read()
+ f_g.seek(0, 0)
+ f_g.write(h_buf)
+
+ os.remove(header_file)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_v11.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v11.py
new file mode 100755
index 0000000..742c17a
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v11.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+
+def gen_header(nand_name, lk_start_addr, out_image):
+ """ device info:
+ name vendor interface pagesize(B) cycle sparesize(B) pageperblock total_blocks
+ page_shift block_shift ecc_strength
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_v11.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ vendor = s[1]
+ interface = eval(s[2])
+ page_size = int(s[3])
+ address_cycle = int(s[4])
+ spare_size = int(s[5])
+ page_per_block = int(s[6])
+ total_blocks = int(s[7])
+ page_shift = int(s[8])
+ block_shift = int(s[9])
+ ecc_strength = int(s[10])
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ #print s[0]
+ #print "vendor %s, page size %d, page shift %d, spare size %d, page per block %d" \
+ # % (vendor, page_size, page_shift, spare_size, page_per_block)
+ #print "address cycle %d, ecc strength %d, interface %d block_shift %d total_blocks %d" \
+ # % (address_cycle, ecc_strength, interface, block_shift, total_blocks)
+
+ # step1: generate nand header info #
+ header = "BOOTLOADER!" + '\0'
+ header += "V006"
+ header += "NFIINFO" + '\0'
+ header += struct.pack("H", interface)
+ header += struct.pack("H", page_size)
+ header += struct.pack("H", address_cycle)
+ # pad 0 for nand type, means slc nand#
+ header += struct.pack("H", 0)
+ # pad tlc control #
+ header += '\0' * 12
+ header += struct.pack("H", spare_size)
+ header += struct.pack("H", page_per_block)
+ header += struct.pack("H", total_blocks)
+ header += struct.pack("H", page_shift)
+ header += struct.pack("H", block_shift)
+ # pad arm align data #
+ header += '\0' * 2
+ # pad mlc control #
+ header += '\0' * 20
+ # pad dummy #
+ header += '\0' * (4 + 4 + 28)
+ # calculate header ecc parity #
+ header_size = 112
+ ecc_level = 80
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+ # pad 4B dummy #
+ header += '\0' * 4
+ # double nfb header #
+ header += header
+ # pad page size align dummy data #
+ header += '\0' * (page_size - 512)
+
+ # step2: generate brlyt #
+ header += "BRLYT" + ('\0' * 3)
+ brlyt_version = 1
+ header += struct.pack("I", brlyt_version)
+ boot_region_addr = lk_start_addr
+ header += struct.pack("I", boot_region_addr)
+ main_region_addr = boot_region_addr + (4 * page_per_block)
+ header += struct.pack("I", main_region_addr)
+ bl_desc_magic = 0x42424242
+ header += struct.pack("I", bl_desc_magic)
+ bl_desc_dev = 0x2
+ header += struct.pack("H", bl_desc_dev)
+ bl_desc_type = 0x1
+ header += struct.pack("H", bl_desc_type)
+ header += struct.pack("I", boot_region_addr)
+ header += struct.pack("I", main_region_addr)
+ bl_desc_attribute = 1
+ header += struct.pack("I", bl_desc_attribute)
+ # pad 7 descripters #
+ header += '\0' * 7 * 20
+ # pad page size align dummy data #
+ header += '\0' * (page_size - 180)
+
+ # step3: pad dummy data till GPT LBA #
+ # let us have an agreement that GPT alwasy be at LBA 128 for SLC NAND #
+ # should be the same LBA in lk and kernel to find GPT #
+ gpt_lba = 128
+ header += '\0' * page_size * (gpt_lba - 2)
+
+ with open(out_image, "wb") as f:
+ f.write(header)
+
+ #return (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, pptableen, page_per_block)
+ return (vendor, 8, 8, ecc_strength, spare_size, page_size, 0, page_per_block)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('lk_start_addr', help = 'lk start address in page unit')
+ parser.add_argument('out_image', help = 'the output header file')
+ args = parser.parse_args()
+ lk_start_addr = int(args.lk_start_addr)
+
+ # generate nand device header #
+ gen_header(args.nand_name, lk_start_addr, args.out_image)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_v12.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v12.py
new file mode 100755
index 0000000..8d9b55f
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v12.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+
+def gen_header(nand_name, out_image):
+ """ device info:
+ name interface pagesize(B) cycle sparesize(B) pageperblock total_blocks ecc_strength
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_v12.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ interface = eval(s[1])
+ page_size = int(s[2])
+ address_cycle = int(s[3])
+ spare_size = int(s[4])
+ page_per_block = int(s[5])
+ total_blocks = int(s[6])
+ ecc_strength = int(s[7])
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ # step1: generate nand header info #
+ header = b"BOOTLOADER!" + b'\0'
+ header += b"V006"
+ header += b"NFIINFO" + b'\0'
+ header += struct.pack("H", interface)
+ header += struct.pack("H", page_size)
+ header += struct.pack("H", address_cycle)
+ header += struct.pack("H", spare_size)
+ header += struct.pack("H", page_per_block)
+ header += struct.pack("H", total_blocks)
+ header += b'\0' * 24
+ # defualt not use ahb mode
+ header += struct.pack("H", 0)
+ header += struct.pack("B", int(ecc_strength))
+ # fdmecc size usually is 1
+ header += struct.pack("B", 1)
+ header += b'\0' * 16
+ # calculate header ecc parity #
+ header_size = 80
+ ecc_level = 24
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+ header += b'\0' * 6
+ # double nfb header #
+ header += header
+
+ with open(out_image, "wb+") as f:
+ f.write(header)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('out_image', help = 'the output header file')
+ args = parser.parse_args()
+
+ # generate nand device header #
+ gen_header(args.nand_name, args.out_image)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
\ No newline at end of file
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_v13.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v13.py
new file mode 100644
index 0000000..43f3d8a
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v13.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+
+def gen_header(nand_name, preloader_start_addr, out_image):
+ """ device info:
+ name vendor interface pagesize(B) cycle sparesize(B) pageperblock total_blocks
+ page_shift block_shift ecc_strength
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_v13.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ vendor = s[1]
+ interface = eval(s[2])
+ page_size = int(s[3])
+ address_cycle = int(s[4])
+ spare_size = int(s[5])
+ page_per_block = int(s[6])
+ total_blocks = int(s[7])
+ page_shift = int(s[8])
+ block_shift = int(s[9])
+ ecc_strength = int(s[10])
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ #print s[0]
+ #print "vendor %s, page size %d, page shift %d, spare size %d, page per block %d" \
+ # % (vendor, page_size, page_shift, spare_size, page_per_block)
+ #print "address cycle %d, ecc strength %d, interface %d block_shift %d total_blocks %d" \
+ # % (address_cycle, ecc_strength, interface, block_shift, total_blocks)
+
+ # step1: generate nand header info #
+ header = "BOOTLOADER!" + '\0'
+ header += "V006"
+ header += "NFIINFO" + '\0'
+ # nfi_info #
+ header += struct.pack("H", interface)
+ header += struct.pack("H", page_size)
+ header += struct.pack("H", address_cycle)
+ header += struct.pack("H", spare_size)
+ header += struct.pack("H", page_per_block)
+ header += struct.pack("H", total_blocks)
+ header += struct.pack("H", page_shift)
+ header += struct.pack("H", block_shift)
+ # pad mlc control #
+ header += '\0' * 20
+ # pad tlc control #
+ header += '\0' * 3
+ header += struct.pack("B", 1) #b_Randomizer_En
+ header += '\0' * 14
+ # pad dummy #
+ header += '\0' * 2
+ # reserved #
+ header += '\0' * 32
+ # calculate header ecc parity #
+ header_size = 112
+ ecc_level = 80
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+ # pad 4B dummy #
+ header += '\0' * 4 # pad 4 bytes to align total 256 bytes
+ # double nfb header #
+ header += header
+ # pad page size align dummy data #
+ header += '\0' * (page_size - 512) # fill the nand information to whole page, since it occupy one page
+
+ # step2: generate brlyt #
+ header += "BRLYT" + ('\0' * 3)
+ brlyt_version = 1
+ header += struct.pack("I", brlyt_version)
+ boot_region_addr = preloader_start_addr
+ header += struct.pack("I", boot_region_addr)
+ main_region_addr = boot_region_addr + (4 * page_per_block) # avoid if have bad block, so remain 4 blocks. need the same as partition_nand.xml
+ header += struct.pack("I", main_region_addr)
+ bl_desc_magic = 0x42424242
+ header += struct.pack("I", bl_desc_magic)
+ bl_desc_dev = 0x2
+ header += struct.pack("H", bl_desc_dev)
+ bl_desc_type = 0x1
+ header += struct.pack("H", bl_desc_type)
+ header += struct.pack("I", boot_region_addr)
+ header += struct.pack("I", main_region_addr)
+ bl_desc_attribute = 1
+ header += struct.pack("I", bl_desc_attribute)
+ # pad 7 descripters #
+ header += '\0' * 7 * 20
+ # pad page size align dummy data #
+ header += '\0' * (page_size - 180)
+
+ # step3: pad dummy data till GPT LBA #
+ # let us have an agreement that GPT alwasy be at LBA 128 for SLC NAND #
+ # should be the same LBA in lk and kernel to find GPT #
+ gpt_lba = 128
+ header += '\0' * page_size * (gpt_lba - 2)
+
+ with open(out_image, "wb") as f:
+ f.write(header)
+
+ #return (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, pptableen, page_per_block)
+ return (vendor, 8, 8, ecc_strength, spare_size, page_size, 0, page_per_block)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('preloader_start_addr', help = 'preloader start address in page unit')
+ parser.add_argument('out_image', help = 'the output header file')
+ args = parser.parse_args()
+ preloader_start_addr = int(args.preloader_start_addr)
+
+ # generate nand device header #
+ gen_header(args.nand_name, preloader_start_addr, args.out_image)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_v14.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v14.py
new file mode 100644
index 0000000..2abf043
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v14.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+
+def gen_header(nand_name, out_image):
+ """ device info:
+ name interface pagesize cycle sparesize pageperblock total_blocks nand_cfg accon fdmecc_size ecc_fdm plane_sel_poi
+ """
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_v14.txt", "r") as f:
+ found = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ interface = eval(s[1])
+ page_size = int(s[2])
+ address_cycle = int(s[3])
+ spare_size = int(s[4])
+ page_per_block = int(s[5])
+ total_blocks = int(s[6])
+ nand_cfg = int(s[7], 16)
+ accon = int(s[8])
+ fdmecc_size = int(s[9])
+ ecc_fdm = int(s[10])
+ plane_sel_poi = int(s[11])
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ # step1: generate nand header info #
+ header = "BOOTLOADER!" + '\0'
+ header += "V006"
+ header += struct.pack("H", interface)
+ header += struct.pack("H", page_size)
+ header += struct.pack("H", address_cycle)
+ header += struct.pack("H", spare_size)
+ header += struct.pack("H", page_per_block)
+ header += struct.pack("H", total_blocks)
+ header += struct.pack("I", nand_cfg)
+ header += '\0' * 8
+ header += struct.pack("I", accon)
+ header += '\0' * 8
+
+ bl_start = 1
+ bl_end = 255
+ header += struct.pack("BBHII", fdmecc_size, ecc_fdm, plane_sel_poi, bl_start,\
+ bl_end)
+ #16 dummy bytes
+ header += '\0' * 16
+ # calculate header ecc parity #
+ ecc_level = 24
+ header_size = len(header)
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+ header += '\0' * (128 - len(header))
+ # double nfb header #
+ header += header
+
+ with open(out_image, "wb") as f:
+ f.write(header)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('out_image', help = 'the output header file')
+ args = parser.parse_args()
+
+ # generate nand device header #
+ gen_header(args.nand_name, args.out_image)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_nand_header_v4.py b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v4.py
new file mode 100644
index 0000000..e6ef349
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_nand_header_v4.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+
+import ecc_bch
+import sys
+import os
+import struct
+import argparse
+import pp_tbl
+
+def calc_bcc(buf, buf_len):
+ raw = bytearray(buf)
+ bcc = 0
+
+ for i in range(buf_len):
+ bcc ^= raw[i]
+
+ return bcc
+
+def gen_header(nand_name):
+ print ("NAND: %s" % (nand_name))
+ with open(os.getcwd() + "/tools/nand-utils/nand_device_list_v4.txt", "r") as f:
+ found = 0
+ info_valid = 0
+ nfi_valid = 0
+ mag_valid = 0
+ pp_valid = 0
+ for l in f:
+ s = l.split()
+ if s[0] == nand_name:
+ found = 1
+ nfi_start_idx = 0
+ mag_start_idx = 0
+
+ enable_header = int(s[1])
+ if enable_header == 0:
+ break
+ info_valid = int(s[2])
+ nfi_valid = int(s[3])
+ mag_valid = int(s[4])
+ pp_valid = int(s[5])
+ pp_type = s[6]
+ if info_valid == 1:
+ nand_type = int(s[7])
+ io_width = int(s[8])
+ addr_cycle = int(s[9])
+ target_num = int(s[10])
+ lun_num = int(s[11])
+ plane_num = int(s[12])
+ program_order_type = int(s[13])
+ address_table_type = int(s[14])
+ bad_block_type = int(s[15])
+ read_retry_type = int(s[16])
+ interface_type = int(s[17])
+ sdr_timing_type = int(s[18])
+ ddr_timing_type = int(s[19])
+ block_num = int(s[20])
+ block_size = int(s[21])
+ page_size = int(s[22])
+ spare_size = int(s[23])
+ mode_type = int(s[24])
+ slc_pe_cycle = int(s[25])
+ slc_ecc_required = int(s[26])
+ slc_bitflip_thres = int(s[27])
+ xlc_pe_cycle = int(s[28])
+ xlc_ecc_required = int(s[29])
+ xlc_bitflip_thres = int(s[30])
+ nfi_start_idx = 31
+ mag_start_idx = 31
+ if nand_type == 0:
+ nfc_format = 1
+ rand_en = 0
+ else:
+ nfc_format = 0
+ rand_en = 1
+ if nfi_valid == 1:
+ dqs_dly_sel = int(s[nfi_start_idx])
+ dqs_dly_mux = int(s[nfi_start_idx + 1])
+ rd_dqs_ddr_timing = int(s[nfi_start_idx + 2])
+ mag_start_idx = nfi_start_idx + 3
+ if mag_valid == 1:
+ bm_type = int(s[mag_start_idx])
+ dma_en = int(s[mag_start_idx + 1])
+ ddr_en = int(s[mag_start_idx + 2])
+ nfc_format = int(s[mag_start_idx + 3])
+ break #found
+
+ if not found:
+ raise KeyError("not support " + nand_name)
+
+ # nand header is total 440B include ecc parity 140B #
+ header_size = 300
+ info_size = 64
+ setting_size = 16
+ mag_size = 8
+ pptbl_size = 128
+ dummy_size = header_size - 4 - info_size - setting_size - mag_size - pptbl_size - 3
+
+ header = b"NAND"
+
+ # struct nand_info #
+ if info_valid == 0:
+ header += '\x00' * info_size
+ bcc_chip = '\xff'
+ else:
+ info_buf = b"INFO"
+ info_buf += struct.pack("B", nand_type)
+ info_buf += struct.pack("B", io_width)
+ info_buf += struct.pack("B", addr_cycle)
+ info_buf += struct.pack("B", target_num)
+ info_buf += struct.pack("B", lun_num)
+ info_buf += struct.pack("B", plane_num)
+ info_buf += struct.pack("B", program_order_type)
+ info_buf += struct.pack("B", address_table_type)
+ info_buf += struct.pack("B", bad_block_type)
+ info_buf += struct.pack("B", read_retry_type)
+ info_buf += struct.pack("B", interface_type)
+ info_buf += struct.pack("B", sdr_timing_type)
+ info_buf += struct.pack("B", ddr_timing_type)
+ info_buf += b'\xff' * 3
+ info_buf += struct.pack("I", block_num)
+ info_buf += struct.pack("I", block_size)
+ info_buf += struct.pack("I", page_size)
+ info_buf += struct.pack("I", spare_size)
+ info_buf += struct.pack("I", mode_type)
+ info_buf += struct.pack("I", slc_pe_cycle)
+ info_buf += struct.pack("I", slc_ecc_required)
+ info_buf += struct.pack("I", slc_bitflip_thres)
+ info_buf += struct.pack("I", xlc_pe_cycle)
+ info_buf += struct.pack("I", xlc_ecc_required)
+ info_buf += struct.pack("I", xlc_bitflip_thres)
+ header += info_buf
+ bcc_chip = calc_bcc(info_buf, info_size)
+ bcc_chip = struct.pack("B", bcc_chip)
+
+ # struct nfi_setting #
+ if nfi_valid == 0:
+ header += b'\x00' * setting_size
+ bcc_setting = b'\xff'
+ else:
+ setting_buf = "NFIS"
+ setting_buf += struct.pack("I", dqs_dly_sel)
+ setting_buf += struct.pack("I", dqs_dly_mux)
+ setting_buf += struct.pack("I", rd_dqs_ddr_timing)
+ header += setting_buf
+ bcc_setting = calc_bcc(setting_buf, setting_size)
+ bcc_setting = struct.pack("B", bcc_setting)
+
+ # struct nand_manage #
+ if mag_valid == 0:
+ header += b'\x00' * mag_size
+ bcc_mag = b'\xff'
+ else:
+ mag_buf = "MANG"
+ mag_buf += struct.pack("B", bm_type)
+ mag_buf += struct.pack("B", dma_en)
+ mag_buf += struct.pack("B", ddr_en)
+ mag_buf += struct.pack("B", nfc_format)
+ header += mag_buf
+ bcc_mag = calc_bcc(mag_buf, mag_size)
+ bcc_mag = struct.pack("B", bcc_mag)
+
+ # bcc code #
+ header += bcc_chip
+ header += bcc_setting
+ header += bcc_mag
+
+ # pad dummy byte #
+ header += b'\xff' * dummy_size
+
+ if pp_valid == 1:
+ # add pptable #
+ if pp_type == 'TSB':
+ header += str(bytearray(pp_tbl.TSB_PP))
+ else:
+ raise KeyError(" no %s pptable " % vendor)
+ else:
+ header += b'\xff' * pptbl_size
+
+ # calculate header ecc parity #
+ ecc_level = 80
+ ecc = ecc_bch.bch_enc_14(header, header_size, ecc_level)
+ header += ecc
+
+ header_file = nand_name + '_header.bin'
+ with open(header_file, "wb") as f:
+ f.write(header)
+
+ if info_valid == 0:
+ print ("NAND info invalid, return!")
+ return
+
+ # feedback ecc & randomizer generateion info
+ fdm_size = spare_size / (page_size / 1024) - (xlc_ecc_required * 14 + 7) / 8
+ if fdm_size > 8:
+ fdm_size = 8
+ if nfc_format == 0:
+ fdmecc_size = fdm_size
+ bad_swap = 0
+ else:
+ fdmecc_size = 1
+ bad_swap = 1
+ ppb = block_size / page_size
+
+ return (pp_type, fdm_size, fdmecc_size, xlc_ecc_required, spare_size, page_size, pp_valid, ppb, bad_swap, rand_en)
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('gpt_image', help = 'pmbr + gpt entry image ')
+ args = parser.parse_args()
+
+ # generate nand device header #
+ gen_header(args.nand_name)
+
+ # pad nand header #
+ with open(args.nand_name + '_header.bin', "rb") as f_h:
+ h_buf = f_h.read()
+ with open(args.gpt_image, "rb+") as f_g:
+ f_g.seek(440, 0)
+ h_buf = h_buf + f_g.read()
+ f_g.seek(0, 0)
+ f_g.write(h_buf)
+
+ os.remove(args.nand_name + '_header.bin')
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gen_storage_image.py b/src/bsp/scatter/tools/nand-utils/gen_storage_image.py
new file mode 100644
index 0000000..cd0e2ec
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gen_storage_image.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import os
+import math
+import pp_tbl
+from gen_nand_header import gen_header
+from pad_ecc_by_sector import pad_ecc
+from randomizer import randomizer
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('in_image', help = 'raw input image which has GPT')
+ parser.add_argument('out_image', help = 'the output storage image ')
+ parser.add_argument('rand_en', help = 'if randomizer is enabled')
+ args = parser.parse_args()
+
+ rand_en = int(args.rand_en)
+
+ header_file = args.nand_name + '_header.bin'
+ header_size = 440
+
+ with open(args.in_image, "rb") as f_in:
+ f_in.seek(header_size, 0)
+ in_data = f_in.read()
+
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_header(args.nand_name)
+ with open(header_file, "rb+") as hf:
+ hf_data = hf.read()
+ hf.write(in_data)
+
+ ecc_file = args.out_image
+ rand_file = args.out_image
+ if rand_en == 1:
+ ecc_file = args.nand_name + '_ecc.bin'
+ if ppen == 1:
+ paired = raw_input("insert empty paired page ? Y/y or N/n ")
+ if paired in ['Y', 'y']:
+ if rand_en == 1:
+ rand_file = args.nand_name + '_rand.bin'
+ else:
+ ecc_file = args.nand_name + '_ecc.bin'
+ sector_size = 1024 if page_size > 512 else 512
+ sector_spare_size = spare_size / (page_size / sector_size)
+ pad_ecc(header_file, ecc_file, sector_size, fdm_size, fdmecc_size, ecc_strength, sector_spare_size, page_size, 1)
+
+ if rand_en == 1:
+ randomizer(ecc_file, rand_file, "SS", 1, page_size, spare_size, sector_size, ppb, ppen, vendor)
+
+ # insert empty paired page #
+ if ppen == 1 and paired in ['Y', 'y']:
+ if rand_en == 1:
+ pp_file = rand_file
+ else:
+ pp_file = ecc_file
+ if vendor == 'TSB':
+ PP = pp_tbl.TSB_PP
+ else:
+ raise Exception("unsupport %s pp table " % vendor)
+ f_pp = open(pp_file, "rb")
+ f_out = open(args.out_image, "wb")
+
+ if (os.path.getsize(header_file) % page_size) != 0:
+ raise Exception("input image size is not page size aligned")
+ page_number = os.path.getsize(header_file) / page_size
+ block_number = int(math.ceil(float(page_number) / (ppb / 2)))
+ print "page num %d block num %d" % (page_number, block_number)
+ for i in range(ppb * block_number):
+ if page_number > 0 and (i % ppb) in PP:
+ f_out.write(f_pp.read(page_size + spare_size))
+ page_number -= 1
+ else:
+ f_out.write('\xff' * (page_size + spare_size))
+ f_pp.close()
+ f_out.close()
+ # remove temp files #
+ os.remove(pp_file)
+
+ if rand_en == 1:
+ os.remove(ecc_file)
+
+ os.remove(header_file)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/gpt_analyser.py b/src/bsp/scatter/tools/nand-utils/gpt_analyser.py
new file mode 100755
index 0000000..296c04b
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/gpt_analyser.py
@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+#to do:
+#extract pmbr + gpt header + gpt entry
+#add txt file output
+#add picture file output
+
+import sys
+import os
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('in_image', help = 'input image with GPT')
+ args = parser.parse_args()
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list.txt
new file mode 100644
index 0000000..bf40f3c
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list.txt
@@ -0,0 +1,6 @@
+Attention: use SPACE to input next parameter
+name vendor totalsize(MB) pagesize(B) sparesize(B) pageperblock cycle eccstrength interface acccon acccon1 dqsdlymux dqsdlyctrl nfidlyctrl pptableenable lbasize fastclock usedma fdmsize fdmeccsize strobesel
+F59D4G81A-45TG-18V ESMT 512 2048 64 64 5 4 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
+MT29F4G08ABAEAWP MCN 512 4096 224 64 5 16 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
+TH58TFG8DDLAB4C TSB 4096 16384 1280 256 5 40 2 0x22005010 0x01010200 0 0 0 1 0 0 0 8 1 0
+MT29F16G08ADBCA MCN 2048 4096 224 64 5 24 1 0x10404011 0 0 0 0 0 0 7 1 8 1 0
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_mt2731.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_mt2731.txt
new file mode 100644
index 0000000..c343093
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_mt2731.txt
@@ -0,0 +1,10 @@
+Attention: use SPACE to input next parameter
+name vendor totalsize(MB) pagesize(B) sparesize(B) pageperblock cycle eccstrength interface acccon acccon1 dqsdlymux dqsdlyctrl nfidlyctrl pptableenable lbasize fastclock usedma fdmsize fdmeccsize strobesel
+F59D4G81A-45TG-18V ESMT 512 2048 64 64 5 4 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
+MT29F4G08ABAEAWP MCN 512 4096 224 64 5 16 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
+TH58TFG8DDLAB4C TSB 4096 16384 1280 256 5 40 2 0x22005010 0x01010200 0 0 0 1 0 0 0 8 1 0
+MT29F16G08ADBCA MCN 2048 4096 224 64 5 24 1 0x10404011 0 0 0 0 0 0 7 1 8 1 0
+MT29F4G08ABBFAH MCN 512 4096 256 64 5 12 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
+MT29F4G08ABBDA MCN 512 2048 64 64 5 4 1 0x10404012 0 0 0 0 0 0 0 0 8 1 0
+MT29F4G08ABBFA MCN 512 4096 256 64 5 12 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
+MT29F8G08ADBFA MCN 1024 4096 256 64 5 12 1 0x10400111 0 0 0 0 0 0 0 0 8 1 0
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_mt2735_hsm.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_mt2735_hsm.txt
new file mode 100644
index 0000000..0354dce
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_mt2735_hsm.txt
@@ -0,0 +1,3 @@
+Attention: use SPACE to input next parameter
+name vendor pagesize(B) sparesize(B) pageperblock blocks cycle
+MT29F8G08ABBCAH4 Micron 4096 224 64 4096 5
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_v11.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_v11.txt
new file mode 100755
index 0000000..c3a966e
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_v11.txt
@@ -0,0 +1,10 @@
+Attention: use SPACE to input next parameter
+name vendor interface pagesize(B) cycle sparesize(B) pageperblock total_blocks page_shift block_shift ecc_strength
+MX30LF1G18AC MXIC 0x100 2048 5 64 64 1024 16 22 12
+TC58NVG0S3HTA00 TOSHIBA 0x100 2048 5 128 64 1024 16 22 32
+MT29F2G08ABAEA MICRON 0x100 2048 5 64 64 2048 16 22 12
+MT29F2G08ABAGA MICRON 0x100 2048 5 128 64 2048 16 22 32
+MX30LF4G18AC MXIC 0x100 2048 5 64 64 4096 16 22 12
+MT29F4G08ABAEA MICRON 0x100 4096 5 224 64 2048 16 22 24
+TC58NVG2S0HTA00 TOSHIBA 0x100 4096 5 256 64 2048 16 22 32
+TC58NVG3S0HTA00 TOSHIBA 0x100 4096 5 256 64 4096 16 22 32
\ No newline at end of file
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_v12.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_v12.txt
new file mode 100644
index 0000000..7b24c12
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_v12.txt
@@ -0,0 +1,6 @@
+Attention: use SPACE to input next parameter
+name interface pagesize(B) cycle sparesize(B) pageperblock total_blocks ecc_strength
+MT29F4G01ABAFDWB 0x100 4096 5 256 64 2048 12
+MX30LF4G18AC 0x100 2048 5 64 64 4096 12
+TC58NVG2S0HTA00 0x100 4096 5 256 64 2048 24
+COMMONSLC 0x100 0 5 0 0 0 0
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_v13.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_v13.txt
new file mode 100755
index 0000000..b73c660
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_v13.txt
@@ -0,0 +1,3 @@
+Attention: use SPACE to input next parameter
+name vendor interface pagesize(B) cycle sparesize(B) pageperblock total_blocks page_shift block_shift ecc_strength
+NM1482KSLAXCL-3B TOSHIBA 0x100 4096 5 256 64 2048 16 22 32
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_v14.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_v14.txt
new file mode 100755
index 0000000..7fda451
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_v14.txt
@@ -0,0 +1,8 @@
+Attention: use SPACE to input next parameter
+name interface pagesize cycle sparesize pageperblock total_blocks nand_cfg accon fdmecc_size ecc_fdm plane_sel_poi
+pnand_4k_256 0x100 4096 5 256 64 2048 0x0 0 1 24 0
+pnand_2k_64 0x100 2048 5 64 64 2048 0x0 0 1 12 0
+snand_4k_256 0x100 4096 5 256 64 2048 0x0 0 1 8 12
+snand_2k_64 0x100 2048 5 64 64 2048 0x0 0 1 8 12
+COMMONSLC 0x100 4096 5 256 64 2048 0x2 0 1 24 0
+COMMONSPI 0x100 4096 5 256 64 2048 0x2 0 1 8 12
\ No newline at end of file
diff --git a/src/bsp/scatter/tools/nand-utils/nand_device_list_v4.txt b/src/bsp/scatter/tools/nand-utils/nand_device_list_v4.txt
new file mode 100644
index 0000000..036995f
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/nand_device_list_v4.txt
@@ -0,0 +1,16 @@
+#Attention: use SPACE to input next parameter
+#name enable info_valid nfi_valid mag_valid pp_valid pp_type <info> nand_type io_width addr_cycle
+#target_num lun_num plane_num program_order_type address_table_type bad_block_type
+#read_retry_type interface_type sdr_timing_type ddr_timing_type block_num
+#block_size page_size spare_size mode_type slc_pe_cycle slc_ecc_required
+#slc_bitflip_thres xlc_pe_cycle xlc_ecc_required xlc_bitflip_thres </info>
+#<nfi> dqs_dly_sel dqs_dly_mux rd_dqs_ddr_timing </nfi> <mag> bm_type dma_en
+#ddr_en nfc_format </mag>
+NAND_COMMON 0
+W29N08GZSIBA 1 1 0 0 0 NONE 0 0 5 1 1 1 0 0 0 0 0 7 0 8192 131072 2048 64 0 50000 12 8 500000 12 8
+SDTNSIAMA016G 1 1 0 0 0 NONE 2 0 5 1 1 2 1 2 2 12 2 0 0 1446 6291456 16384 1952 1 500 68 46 50000 68 46
+SDTNSGAMA008G 1 1 0 0 0 NONE 1 0 5 1 1 2 0 5 2 5 2 9 4 1074 4194304 16384 1280 1 30000 40 30 3000 40 30
+TC58TEG7THLTA00 1 1 0 0 0 NONE 2 0 5 1 1 2 1 2 0 13 2 0 0 1446 6291456 16384 1952 1 500 68 46 50000 68 46
+TC58TFG7DDLTA0D 1 1 0 0 0 NONE 1 0 5 1 1 2 0 5 0 7 2 9 4 2106 4194304 16384 1280 8 30000 40 30 3000 40 30
+MT29F4G08ABAEAWP 1 1 0 0 0 NONE 0 0 5 1 1 2 0 0 0 0 0 8 0 1024 262144 4096 224 0 50000 24 18 50000 24 18
+TC58TEG6TCKTA00 1 1 0 0 0 NONE 2 0 5 1 1 1 1 3 0 13 2 0 0 2092 4227072 16384 1952 1 30000 60 45 3000 60 45
diff --git a/src/bsp/scatter/tools/nand-utils/pad_dummy_data.py b/src/bsp/scatter/tools/nand-utils/pad_dummy_data.py
new file mode 100755
index 0000000..ccfba4b
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/pad_dummy_data.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import os
+
+def padding(data, size):
+ return data + '\xff' * (size - len(data))
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('in_image', help = 'raw input image which has GPT')
+ parser.add_argument('part_size', help = 'partition size')
+ args = parser.parse_args()
+ part_size = int(args.part_size, 16)
+ file_len = os.path.getsize(args.in_image)
+
+ with open(args.in_image, "rb+") as f:
+ f.read()
+ f.write('\xff' * (part_size - file_len))
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/pad_dummy_data.sh b/src/bsp/scatter/tools/nand-utils/pad_dummy_data.sh
new file mode 100755
index 0000000..bea14d4
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/pad_dummy_data.sh
@@ -0,0 +1,11 @@
+#! /bin/sh
+
+python -B pad_dummy_data.py ../build_imags/MBR_NAND_ECC 0x84000
+python -B pad_dummy_data.py ../build_imags/lk_ecc.img 0x84000
+python -B pad_dummy_data.py ../build_imags/boot_ecc.img 0x1080000
+python -B pad_dummy_data.py ../build_imags/tz_ecc.img 0x42000
+
+cat ../build_imags/MBR_NAND_ECC >> ../build_imags/burner.img
+cat ../build_imags/lk_ecc.img >> ../build_imags/burner.img
+cat ../build_imags/boot_ecc.img >> ../build_imags/burner.img
+cat ../build_imags/tz_ecc.img >> ../build_imags/burner.img
diff --git a/src/bsp/scatter/tools/nand-utils/pad_dummy_data_by_partition.py b/src/bsp/scatter/tools/nand-utils/pad_dummy_data_by_partition.py
new file mode 100755
index 0000000..1d11424
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/pad_dummy_data_by_partition.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import os
+import math
+import pp_tbl
+import gen_nand_header
+import gen_nand_header_v11
+from pad_ecc_by_sector import pad_ecc
+
+def padding(data, size):
+ return data + '\xff' * (size - len(data))
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('nand_name', help = 'nand device name')
+ parser.add_argument('in_image', help = 'raw input image')
+ parser.add_argument('part_size', help = 'partition size')
+ parser.add_argument('version', help= 'nand header version')
+ args = parser.parse_args()
+ version = float(args.version)
+
+ if version == 2.0:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header.gen_header(args.nand_name)
+ elif version == 1.1:
+ (vendor, fdm_size, fdmecc_size, ecc_strength, spare_size, page_size, ppen, ppb) = gen_nand_header_v11.gen_header(args.nand_name, 192, args.nand_name + '_header.bin')
+
+ # input image page size alignment #
+ file_len = os.path.getsize(args.in_image)
+ pages = int(int(args.part_size) / page_size)
+ part_size = pages * (page_size + spare_size)
+ with open(args.in_image, "rb+") as f:
+ f.read()
+ f.seek(0, 2)
+ f.write('\xff' * (part_size - file_len))
+
+ os.remove(args.nand_name + '_header.bin')
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/pad_ecc_by_sector.py b/src/bsp/scatter/tools/nand-utils/pad_ecc_by_sector.py
new file mode 100755
index 0000000..ef91095
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/pad_ecc_by_sector.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+
+import argparse
+import sys
+import os
+import math
+import ecc_bch
+
+def pad_ecc(in_image, out_image, sector_size, fdm_size, fdmecc_size, ecc_level, spare_size, page_size, bad_swap):
+ # file size check #
+ file_len = os.path.getsize(in_image)
+ if (file_len % sector_size) != 0:
+ raise Exception("input image size is not sector size aligned")
+ sector_num = file_len / sector_size
+
+ # calculate parity byte number #
+ parity_byte = int(math.ceil(float(ecc_level) * 14 / 8))
+
+ # bad block mark control setting #
+ if bad_swap != 0:
+ bad_sec = page_size / (sector_size + spare_size)
+ bad_pos = page_size % (sector_size + spare_size)
+ sec_per_page = page_size / sector_size
+ print "bad sector %d, bad position %d, sector number per page %d " \
+ % (bad_sec, bad_pos, sec_per_page)
+
+ f_in = open(in_image, "rb")
+ f_out = open(out_image, "wb")
+
+ for i in range(sector_num):
+ percent = float(i) / float(sector_num) * 100
+ sys.stdout.writelines("%.1f"%percent)
+ sys.stdout.writelines("%\r")
+ sys.stdout.flush();
+ f_in.seek(sector_size * i, 0)
+ f_out.seek((sector_size + spare_size) * i, 0)
+ sector_data = f_in.read(sector_size)
+ sector_data += '\xff' * fdmecc_size
+ # bad mark swap #
+ if bad_swap != 0:
+ if (i % sec_per_page) == bad_sec:
+ temp_buf = bytearray(sector_data)
+ temp_byte = temp_buf[bad_pos]
+ temp_buf[bad_pos] = temp_buf[sector_size]
+ temp_buf[sector_size] = temp_byte
+ sector_data = str(temp_buf)
+ parity_data = ecc_bch.bch_enc_14(sector_data, sector_size + fdmecc_size, ecc_level)
+ sector_data += '\xff' * (fdm_size - fdmecc_size)
+ sector_data += parity_data
+ sector_data += '\xff' * (spare_size - fdm_size - parity_byte)
+ f_out.write(sector_data)
+
+ f_in.close()
+ f_out.close()
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('in_image', help = 'raw input image')
+ parser.add_argument('out_image', help = 'ecc padded image')
+ parser.add_argument('sector_size', help = 'sector size')
+ parser.add_argument('fdm_size', help = 'FDM size')
+ parser.add_argument('fdmecc_size', help = 'FDM ECC size')
+ parser.add_argument('ecc_level', help = 'ECC level')
+ parser.add_argument('spare_size', help = 'spare size per sector')
+ parser.add_argument('page_size', help = 'page size')
+ parser.add_argument('bad_swap', help = 'whether do bad mark swap')
+ args = parser.parse_args()
+
+ sector_size = int(args.sector_size)
+ fdm_size = int(args.fdm_size)
+ fdmecc_size = int(args.fdmecc_size)
+ ecc_level = int(args.ecc_level)
+ spare_size = int(args.spare_size)
+ page_size = int(args.page_size)
+ parity_byte = int(math.ceil(float(ecc_level) * 14 / 8))
+ bad_swap = int(args.bad_swap)
+
+ print "secsize %d, fdmsz %d, fdmeccsz %d, lel %d, spare %d, parity_byte %d page size %d bad_swap %d" \
+ % (sector_size, fdm_size, fdmecc_size, ecc_level, spare_size, parity_byte, page_size, bad_swap)
+
+ pad_ecc(args.in_image, args.out_image, sector_size, fdm_size, fdmecc_size, ecc_level, spare_size, page_size, bad_swap)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/pp_tbl.py b/src/bsp/scatter/tools/nand-utils/pp_tbl.py
new file mode 100755
index 0000000..b5a5ecf
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/pp_tbl.py
@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+TSB_PP = (
+ 0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29,
+ 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61,
+ 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93,
+ 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125,
+ 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
+ 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189,
+ 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221,
+ 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253)
+
+if __name__ == "__main__":
+ """ this file is used to define pair page table """
diff --git a/src/bsp/scatter/tools/nand-utils/randomizer.py b/src/bsp/scatter/tools/nand-utils/randomizer.py
new file mode 100755
index 0000000..b3fe76a
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/randomizer.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import argparse
+import pp_tbl
+
+SS_SEED = (
+ 0x576A, 0x05E8, 0x629D, 0x45A3, 0x649C, 0x4BF0, 0x2342, 0x272E,
+ 0x7358, 0x4FF3, 0x73EC, 0x5F70, 0x7A60, 0x1AD8, 0x3472, 0x3612,
+ 0x224F, 0x0454, 0x030E, 0x70A5, 0x7809, 0x2521, 0x484F, 0x5A2D,
+ 0x492A, 0x043D, 0x7F61, 0x3969, 0x517A, 0x3B42, 0x769D, 0x0647,
+ 0x7E2A, 0x1383, 0x49D9, 0x07B8, 0x2578, 0x4EEC, 0x4423, 0x352F,
+ 0x5B22, 0x72B9, 0x367B, 0x24B6, 0x7E8E, 0x2318, 0x6BD0, 0x5519,
+ 0x1783, 0x18A7, 0x7B6E, 0x7602, 0x4B7F, 0x3648, 0x2C53, 0x6B99,
+ 0x0C23, 0x67CF, 0x7E0E, 0x4D8C, 0x5079, 0x209D, 0x244A, 0x747B,
+ 0x350B, 0x0E4D, 0x7004, 0x6AC3, 0x7F3E, 0x21F5, 0x7A15, 0x2379,
+ 0x1517, 0x1ABA, 0x4E77, 0x15A1, 0x04FA, 0x2D61, 0x253A, 0x1302,
+ 0x1F63, 0x5AB3, 0x049A, 0x5AE8, 0x1CD7, 0x4A00, 0x30C8, 0x3247,
+ 0x729C, 0x5034, 0x2B0E, 0x57F2, 0x00E4, 0x575B, 0x6192, 0x38F8,
+ 0x2F6A, 0x0C14, 0x45FC, 0x41DF, 0x38DA, 0x7AE1, 0x7322, 0x62DF,
+ 0x5E39, 0x0E64, 0x6D85, 0x5951, 0x5937, 0x6281, 0x33A1, 0x6A32,
+ 0x3A5A, 0x2BAC, 0x743A, 0x5E74, 0x3B2E, 0x7EC7, 0x4FD2, 0x5D28,
+ 0x751F, 0x3EF8, 0x39B1, 0x4E49, 0x746B, 0x6EF6, 0x44BE, 0x6DB7)
+
+def fetch_seed(ran_type, seeds, idx):
+ if ran_type == "SS":
+ seed_page = seeds[idx % len(seeds)]
+ seed_page &= 0x7fff
+ key = seed_page
+ return (key, seed_page)
+ else:
+ pass
+
+def pn_gen(ran_type, src_len, key):
+ pn_buf = []
+ for i in range(src_len):
+ pn_buf.append(0)
+ if ran_type == "SS":
+ for j in range(8):
+ if bool(key & 0x4000) != bool(key & 0x2000):
+ key <<= 1
+ key &= 0x7ffe
+ key += 1
+ pn_buf[i] += 1 << j
+ else:
+ key <<= 1
+ key &= 0x7ffe
+ else:
+ pass
+ return (key, pn_buf)
+
+def randomizer(in_image, out_image, ran_type, sec_reseed, page_size, spare_size, sector_size, page_per_block, ppen, vendor):
+ # check file length #
+ if (os.path.getsize(in_image) % (page_size + spare_size)) != 0:
+ raise Exception("input image size is not page size aligned")
+
+ page_number = os.path.getsize(in_image) / (page_size + spare_size)
+ sec_per_page = page_size / sector_size
+ spare_per_sec = spare_size / sec_per_page
+
+ if ran_type == "SS":
+ seeds = SS_SEED
+ else:
+ raise Exception("not support %s randomizer" % ran_type)
+ if ppen == 1:
+ if vendor == 'TSB':
+ PP = pp_tbl.TSB_PP
+ else:
+ raise Exception("unsupport %s pp table " % vendor)
+
+ f_in = open(in_image, "rb")
+ f_out = open(out_image, "wb")
+
+ for i in range(page_number):
+ percent = float(i) / float(page_number) * 100
+ sys.stdout.writelines("%.1f"%percent)
+ sys.stdout.writelines("%\r")
+ sys.stdout.flush();
+ if ppen == 1:
+ seed_idx = PP[i % (page_per_block / 2)]
+ else:
+ seed_idx = i % page_per_block
+ (key, seed_page) = fetch_seed(ran_type, seeds, seed_idx)
+ for j in range(sec_per_page):
+ if sec_reseed:
+ key = seed_page
+
+ (key, pn_buf) = pn_gen(ran_type, sector_size + spare_per_sec, key)
+
+ in_buf = f_in.read(sector_size + spare_per_sec)
+ if not in_buf:
+ break
+ in_buf = bytearray(in_buf)
+
+ for k in range(sector_size + spare_per_sec):
+ in_buf[k] ^= pn_buf[k]
+
+ in_buf = str(in_buf)
+ f_out.write(in_buf)
+
+ f_in.close()
+ f_out.close()
+
+def main(argv):
+ parser = argparse.ArgumentParser()
+ parser.add_argument('in_image', help = 'input image w/o random ')
+ parser.add_argument('out_image', help = 'output image w/ random ')
+ parser.add_argument('ran_type', default = 'SS', help = 'randomizer algorithm: SS or TSB')
+ parser.add_argument('sec_reseed', default = '1', help = 'whether reseed each sector')
+ parser.add_argument('page_size', help = 'page size')
+ parser.add_argument('spare_size', help = 'page spare size')
+ parser.add_argument('sector_size', help = 'sector size')
+ parser.add_argument('page_per_block', help = 'page per block number')
+ parser.add_argument('ppen', help = 'whether paired page is enabled')
+ parser.add_argument('vendor', help = 'vendor name')
+ args = parser.parse_args()
+
+ randomizer(args.in_image, args.out_image, args.ran_type, int(args.sec_reseed), int(args.page_size), \
+ int(args.spare_size), int(args.sector_size), int(args.page_per_block), int(args.ppen), args.vendor)
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/src/bsp/scatter/tools/nand-utils/start-burn.sh b/src/bsp/scatter/tools/nand-utils/start-burn.sh
new file mode 100755
index 0000000..29af331
--- /dev/null
+++ b/src/bsp/scatter/tools/nand-utils/start-burn.sh
@@ -0,0 +1,3 @@
+#! /bin/sh
+
+source ${PWD}/tools/nand-utils/gen-nand-burn-img.sh 1.1 MX30LF4G18AC ./project/aud8516-slc/partition_nand.xml
diff --git a/src/bsp/scatter/tools/partition_editor.html b/src/bsp/scatter/tools/partition_editor.html
new file mode 100644
index 0000000..0463856
--- /dev/null
+++ b/src/bsp/scatter/tools/partition_editor.html
@@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
+<script>
+$(document).ready(function() {
+ let xmldoc = null;
+
+ function check() {
+ $("#out").text("");
+ let hdr = xmldoc.getElementsByTagName("partition")[0];
+ if (hdr == null) {
+ $("#out").text("Error: invlaid partition file\n");
+ return;
+ }
+
+ let entries = xmldoc.getElementsByTagName("entry");
+ for (let i=0; i<entries.length; i++) {
+ if (parseInt(entries[i].getAttribute("end")) >= parseInt(hdr.getAttribute("lba"))) {
+ let error_msg = "Error: end lba of " + entries[i].getAttribute("name") + " (" + entries[i].getAttribute("end") + ") >= total lba (" + hdr.getAttribute("lba") + ")\n\n";
+ $("#out").text(error_msg);
+ return;
+ }
+ }
+ }
+
+ function show() {
+ if (xmldoc == null)
+ return;
+
+ $("#total_size").text((eval($("#total_lba").val()) * eval($("#lbs").val()) / 1024 / 1024) + "MB");
+ $("#start_addr").text((eval($("#start_lba").val()) * eval($("#lbs").val()) / 1024 / 1024) + "MB");
+
+ let text = "";
+ text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + xmldoc.documentElement.outerHTML;
+ text = text.replace(/>\s*</gm, ">\n<");
+ text = text.replace(/^<entry/gm, "\t<entry");
+ text = text.replace(/^\s+\n/gm, "");
+ $("#out").text($("#out").text() + text);
+ }
+
+ function init_editor() {
+ if (xmldoc == null)
+ return;
+
+ let hdr = xmldoc.getElementsByTagName("partition")[0];
+ $("#total_lba").val(hdr.getAttribute("lba"));
+ if (hdr.getAttribute("lbs") != null)
+ $("#lbs").val(hdr.getAttribute("lbs"));
+ else
+ $("#lbs").val(512);
+
+ let entries = xmldoc.getElementsByTagName("entry");
+ $("#start_lba").val(entries[0].getAttribute("start"));
+
+ let text = "";
+ for (let i=0; i<entries.length; i++) {
+ let size = ((entries[i].getAttribute("end") - entries[i].getAttribute("start") + 1)*$("#lbs").val()/1024);
+ text += (entries[i].getAttribute("name") + " " + size + "\n");
+ }
+ $("#entry_editor").val(text);
+ }
+
+ function update_xml() {
+ if (xmldoc == null)
+ return;
+
+ let hdr = xmldoc.getElementsByTagName("partition")[0];
+ hdr.setAttribute("lba", eval($("#total_lba").val()));
+
+ if (eval($("#lbs").val()) == 512)
+ hdr.removeAttribute("lbs");
+ else
+ hdr.setAttribute("lbs", eval($("#lbs").val()));
+
+ let entries = xmldoc.getElementsByTagName("entry");
+ let entry_strs = $("#entry_editor").val().split("\n");
+
+ let entry_cnt = 0;
+ for (let i=0; i<entry_strs.length; i++) {
+ if (entry_strs[i] == "")
+ continue;
+
+ if (entry_cnt >= entries.length) {
+ let newEle = xmldoc.createElement("entry");
+ newEle.setAttribute("type", entries[entry_cnt-1].getAttribute("type"));
+ hdr.appendChild(newEle);
+ entries = xmldoc.getElementsByTagName("entry");
+ }
+
+ entry = entry_strs[i].trim().split(/\s+/);
+ if (entry.length < 2)
+ continue;
+ if (entry_cnt == 0)
+ entries[entry_cnt].setAttribute("start", eval($("#start_lba").val()));
+ else
+ entries[entry_cnt].setAttribute("start", parseInt(entries[entry_cnt-1].getAttribute("end")) + 1);
+ entries[entry_cnt].setAttribute("end", (parseInt(entries[entry_cnt].getAttribute("start")) + eval(entry[1])*1024/eval($("#lbs").val()) - 1));
+ entries[entry_cnt].setAttribute("name", entry[0]);
+ entry_cnt++;
+ }
+
+ for (; entry_cnt < entries.length;) {
+ hdr.removeChild(entries[entry_cnt]);
+ entries = xmldoc.getElementsByTagName("entry");
+ }
+ }
+
+ $("#partition").change(function() {
+ let reader = new FileReader();
+ reader.onload = function() {
+ let parser = new DOMParser();
+ xmldoc = parser.parseFromString(reader.result, "application/xml");
+ init_editor();
+ check();
+ show();
+ };
+ reader.readAsText($("#partition")[0].files[0]);
+ });
+
+ $(":text,#entry_editor").keyup(function(){
+ update_xml();
+ check();
+ show();
+ });
+
+ $(":text").change(function(){
+ $(":focus").val(eval($(":focus").val()));
+ });
+
+ $("#entry_editor").change(function(){
+ let text = "";
+ let entry_strs = $("#entry_editor").val().split("\n");
+
+ for (let i=0; i<entry_strs.length; i++) {
+ if (entry_strs[i] == "")
+ continue;
+
+ let entry = entry_strs[i].trim().split(/\s+/);
+ if (entry.length < 2)
+ continue;
+
+ text += entry[0] + " " + eval(entry[1]) + "\n";
+ }
+
+ $("#entry_editor").val(text);
+ });
+
+});
+</script>
+</head>
+<body>
+<label>partition file:
+<input type=file id="partition">
+</label>
+<br>
+<hr>
+
+<label>lba size(lbs):
+<input type=text id="lbs">
+</label>
+<br>
+<label>total lba:
+<input type=text id="total_lba">
+</label>
+<label id="total_size">
+</label>
+<br>
+<hr>
+
+<label>start lba of the first partition:
+<input type=text id="start_lba">
+</label>
+<label id="start_addr">
+</label>
+<br>
+<label> name size(KB)
+</label>
+<br>
+<textarea id=entry_editor rows=20>
+</textarea>
+<br>
+<hr>
+
+<pre id="out"></pre>
+</body>
+</html>
diff --git a/src/bsp/scatter/tools/partition_editor.sh b/src/bsp/scatter/tools/partition_editor.sh
new file mode 100644
index 0000000..a01d283
--- /dev/null
+++ b/src/bsp/scatter/tools/partition_editor.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+
+if [ -z "$1" ]
+then
+ # Show the partition layout if no argument input
+ echo 'Usage:'
+ echo ' Show current Partitions layout:'
+ echo ' sh partition_editor.sh ${XMLFILE}'
+ exit 1
+fi
+
+if [ ! -f "$1" ]
+then
+ echo $1': File not exist!'
+ exit 1
+fi
+
+# Show the partition layout in better interactive mode
+tmpfile=".part.tmp"
+xmlfile=$1
+
+# LBS(size defined in tmp file is KB based)
+lbs_exist=`grep -o "\<lbs\>" ${xmlfile}`
+if [ -z $lbs_exist ]
+then
+ # For eMMC/Nor, only support 1024-aligned by now
+ lbs=1
+else
+ lbs=`awk -F'"' '/lbs=/{print $4}' ${xmlfile}`
+ lbs=$(($lbs/1024))
+fi
+# LBA(Total page number)
+lba_exist=`grep -o "\<lba\>" ${xmlfile}`
+if [ -z $lba_exist ]
+then
+ lba=0
+else
+ lba=`awk -F'"' '/lba=/{print $2}' ${xmlfile}`
+fi
+# reserved some blocks to store BBT
+reserved_exist=`grep -o "\<reserved\>" ${xmlfile}`
+if [ -z $reserved_exist ]
+then
+ reserved=0
+else
+ reserved=`awk -F'"' '/reserved=/{print $6}' ${xmlfile}`
+fi
+
+# Generate temporary file for interactive modifing and editing
+echo '*** You can delete/insert/modify(partname/size) partitions ***' > ${tmpfile}
+echo '*** Partition size must be ERASE_BLOCK_SIZE(define in Nand SPEC) aligned ***' >> ${tmpfile}
+echo '' >> ${tmpfile}
+echo 'Part_name Size(KB) Attr' >> ${tmpfile}
+`sed -nr 's/^.+start=\"(\w+)\"\s*end=\"(\w+)\"\s*(attributes=\"(\w+)\"\s*)?name=\"(\w+)\".+$/\5 \1 \2 \4/p' ${xmlfile} |
+ awk -v blk_size=$lbs '{printf "%-15s\t\t%d\t\t%s\n", $1, ($3-$2+1)*blk_size, $4}' >> ${tmpfile}`
+
+# Edit the partition layout via vim
+vim ${tmpfile}
+
+# The new partition layout
+part_name=(`awk '/^\w+\s+[0-9]+/{print $1}' ${tmpfile}`)
+part_size=(`awk '/^\w+\s+[0-9]+/{print $2}' ${tmpfile}`)
+part_attr=(`awk '/^\w+\s+[0-9]+/{if ($3 == "") print "-"; else print $3}' ${tmpfile}`)
+# How many elements in the array
+newcnt=$((${#part_name[@]}-1))
+# Generate the temporary xml file
+xmltmp=".xml.tmp"
+`cp -f ${xmlfile} ${xmltmp}`
+`sed -i '/name=/d' ${xmltmp}`
+# Modify the temporary xml file
+str1=' <entry type="{0FC63DAF-8483-4772-8E79-3D69D8477DE4}" start="'
+str2='" end="'
+strattr='" attributes="'
+str3='" name="'
+str4='" />'
+# first start address
+sa=`awk -F'"' '/name=/{print $4; exit;}' ${xmlfile}`
+# last end address
+lea=`sed -n '/name=/p' ${xmlfile} | sed -n '$p' | awk -F'"' '{print $6}'`
+for ((i=0; i<=$newcnt; i++)) {
+ len=${part_size[i]}
+ if [ $i -eq $newcnt ]
+ then
+ ea=$lea
+ if [ $lba -ne 0 -a $reserved -ne 0 ]
+ then
+ ea=$(($lba-$reserved-1))
+ fi
+ else
+ ea=$(($sa+$len/$lbs-1))
+ fi
+ name=${part_name[i]}
+ attr=${part_attr[i]}
+ if [ "$attr" == "-" ]
+ then
+ `sed -i '/<\/partition>/i \'"$str1$sa$str2$ea$str3$name$str4"'' ${xmltmp}`
+ else
+ `sed -i '/<\/partition>/i \'"$str1$sa$str2$ea$strattr$attr$str3$name$str4"'' ${xmltmp}`
+ fi
+ sa=$(($ea+1))
+}
+# Replace the xml file with the temp xml file, delete useless temporary files
+`cp -f ${xmltmp} ${xmlfile}`
+`rm -f ${xmltmp} ${tmpfile}`
+
+exit 0