71 lines
3.0 KiB
Python
Executable File
71 lines
3.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import sys, os
|
|
import math
|
|
|
|
W = 1024
|
|
SP = 128 * 1024
|
|
SL = 124 * 1024
|
|
BB = 0
|
|
O = SP - SL
|
|
|
|
# UBI uses some amount of flash space for its own purposes, thus reducing the amount of flash space available for UBI users. Namely
|
|
# 2 PEBs are used to store the volume table;
|
|
# 1 PEB is reserved for wear-leveling purposes;
|
|
# 1 PEB is reserved for the atomic LEB change operation;
|
|
# some amount of PEBs is reserved for bad PEB handling; this is applicable for NAND flash, but not for NOR flash; the amount of reserved PEBs is configurable and is equal to 20 blocks per 1024 blocks by default;
|
|
# UBI stores the EC and VID headers at the beginning of each PEB; the amount of bytes used for these purposes depends on the flash type and is explained below.
|
|
#
|
|
# W - total number of physical eraseblocks on the flash chip (NB: the entire chip, not the MTD partition);
|
|
# P - total number of physical eraseblocks on the MTD partition);
|
|
# SP - physical eraseblock size;
|
|
# SL - logical eraseblock size;
|
|
# BB - number of bad blocks on the MTD partition;
|
|
# BR - number of PEBs reserved for bad PEB handling. it is 20 * W/1024 for NAND by default, and 0 for NOR and other flash types which do not have bad PEBs;
|
|
# B - MAX(BR,BB);
|
|
# O - the overhead related to storing EC and VID headers in bytes, i.e. O = SP - SL.
|
|
|
|
# in case of NOR flash which has 1 byte minimum input/output unit, O is 128 bytes;
|
|
# in case of NAND flash which does not have sub-pages (e.g., MLC NAND), O is 2 NAND pages, i.e. 4KiB in case of 2KiB NAND page and 1KiB in case of 512 bytes NAND page;
|
|
# in case of NAND flash which has sub-pages, UBI optimizes its on-flash layout and puts the EC and VID headers at the same NAND page, but different sub-pages; in this case O is only one NAND page;
|
|
# for other flashes the overhead should be 2 min. I/O units if the min. I/O unit size is greater or equivalent to 64 bytes, and 2 times 64 bytes aligned to the min. I/O unit size if the min. I/O unit size is less than 64 bytes.
|
|
|
|
# N.B.: the formula above counts bad blocks as a UBI overhead. The real UBI overhead is: (B - BB + 4) * SP + O * (P - B - 4).
|
|
|
|
|
|
def usage():
|
|
print("Usage: %s PartitionSize(Bytes: in HEX)" % sys.argv[0])
|
|
|
|
def get_ubifs_max_leb(partition_size): #Unit: Bytes
|
|
P = partition_size/SP
|
|
BR = math.ceil(30 * W/float(1024)) # Sync with kernel
|
|
B = max(BB, BR)
|
|
|
|
ubi_overhead = (( B - BB + 4 ) * SP + O * ( P - B - 4 ))/float(SP)
|
|
ubi_overhead = math.ceil(ubi_overhead)
|
|
ubi_overhead = math.floor(((P - ubi_overhead) * SP) / float(SL))
|
|
if ubi_overhead < 0:
|
|
return -1
|
|
else:
|
|
return (ubi_overhead - 1)
|
|
|
|
def main():
|
|
if int(sys.argv[1], 16):
|
|
PTS = int(sys.argv[1], 16)
|
|
else:
|
|
print('it is not hex')
|
|
|
|
ret = get_ubifs_max_leb(PTS)
|
|
if ret > 0:
|
|
print("Your size is %s(%d)" %(sys.argv[1], int(sys.argv[1], 16)))
|
|
print("The MAX LEB is %d" %(get_ubifs_max_leb(PTS)))
|
|
else:
|
|
print("ERROR !!!!! Your size is %s(%d)" %(sys.argv[1], int(sys.argv[1], 16)))
|
|
|
|
if __name__ == "__main__":
|
|
if len(sys.argv) < 2:
|
|
usage()
|
|
sys.exit(0)
|
|
else:
|
|
main()
|