mirror of
https://github.com/DarkFlippers/unleashed-firmware
synced 2024-11-13 00:07:12 +00:00
3c93761d1d
* multiple new additions Hisense K321UW, Soniq E55V13A, Soniq E32W13B and 2 others * updated with proper names Viano STV65UHD4K Hisense K321UW Hisense EN2B27 Soniq E55V13A Soniq E32W13B * format tv.ir * Update tv.ir * new universal ac additions Maytag M6X06F2A Panasonic CS-E9HKR * new universal audio additions Sony MHC_GSX75 Elac EA101EQ-G Philips FW750C Pioneer VSX-D1-S * remove final # audio.ir * Scripts: update deprecated methods use in python scripts * Scripts: add comment reading support to fff, preserve comments in infrared cleanup script * Scripts: improved infrared files cleanup script * Scripts: add missing new line at the end of file in infrared file cleanup script * Infrared: cleanup universal remotes Co-authored-by: あく <alleteam@gmail.com>
307 lines
12 KiB
Python
Executable file
307 lines
12 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
|
|
import math
|
|
import os
|
|
import shutil
|
|
import tarfile
|
|
import zlib
|
|
from os.path import exists, join
|
|
|
|
from flipper.app import App
|
|
from flipper.assets.coprobin import CoproBinary, get_stack_type
|
|
from flipper.assets.heatshrink_stream import HeatshrinkDataStreamHeader
|
|
from flipper.assets.obdata import ObReferenceValues, OptionBytesData
|
|
from flipper.assets.tarball import compress_tree_tarball, tar_sanitizer_filter
|
|
from flipper.utils.fff import FlipperFormatFile
|
|
from slideshow import Main as SlideshowMain
|
|
|
|
|
|
class Main(App):
|
|
UPDATE_MANIFEST_VERSION = 2
|
|
UPDATE_MANIFEST_NAME = "update.fuf"
|
|
|
|
# No compression, plain tar
|
|
RESOURCE_TAR_MODE = "w:"
|
|
RESOURCE_FILE_NAME = "resources.ths" # .Tar.HeatShrink
|
|
RESOURCE_ENTRY_NAME_MAX_LENGTH = 100
|
|
|
|
WHITELISTED_STACK_TYPES = set(
|
|
map(
|
|
get_stack_type,
|
|
["BLE_FULL", "BLE_LIGHT", "BLE_BASIC"],
|
|
)
|
|
)
|
|
|
|
FLASH_BASE = 0x8000000
|
|
FLASH_PAGE_SIZE = 4 * 1024
|
|
MIN_GAP_PAGES = 2
|
|
|
|
# Update stage file larger than that is not loadable without fix
|
|
# https://github.com/flipperdevices/flipperzero-firmware/pull/3676
|
|
UPDATER_SIZE_THRESHOLD = 128 * 1024
|
|
|
|
HEATSHRINK_WINDOW_SIZE = 13
|
|
HEATSHRINK_LOOKAHEAD_SIZE = 6
|
|
|
|
# Post-update slideshow
|
|
SPLASH_BIN_NAME = "splash.bin"
|
|
|
|
def init(self):
|
|
self.subparsers = self.parser.add_subparsers(help="sub-command help")
|
|
|
|
# generate
|
|
self.parser_generate = self.subparsers.add_parser(
|
|
"generate", help="Generate update description file"
|
|
)
|
|
|
|
self.parser_generate.add_argument("-d", dest="directory", required=True)
|
|
self.parser_generate.add_argument("-v", dest="version", required=True)
|
|
self.parser_generate.add_argument("-t", dest="target", required=True)
|
|
self.parser_generate.add_argument(
|
|
"--dfu", dest="dfu", default="", required=False
|
|
)
|
|
self.parser_generate.add_argument("-r", dest="resources", required=False)
|
|
self.parser_generate.add_argument("--stage", dest="stage", required=True)
|
|
self.parser_generate.add_argument(
|
|
"--radio", dest="radiobin", default="", required=False
|
|
)
|
|
self.parser_generate.add_argument(
|
|
"--radioaddr",
|
|
dest="radioaddr",
|
|
type=lambda x: int(x, 16),
|
|
default=0,
|
|
required=False,
|
|
)
|
|
|
|
self.parser_generate.add_argument(
|
|
"--radiotype", dest="radiotype", required=False
|
|
)
|
|
|
|
self.parser_generate.add_argument("--obdata", dest="obdata", required=False)
|
|
self.parser_generate.add_argument("--splash", dest="splash", required=False)
|
|
self.parser_generate.add_argument(
|
|
"--I-understand-what-I-am-doing", dest="disclaimer", required=False
|
|
)
|
|
self.parser_generate.add_argument(
|
|
"--stackversion", dest="stack_version", required=False, default=""
|
|
)
|
|
|
|
self.parser_generate.set_defaults(func=self.generate)
|
|
|
|
def generate(self):
|
|
stage_basename = "updater.bin" # used to be basename(self.args.stage)
|
|
dfu_basename = (
|
|
"firmware.dfu" if self.args.dfu else ""
|
|
) # used to be basename(self.args.dfu)
|
|
radiobin_basename = (
|
|
"radio.bin" if self.args.radiobin else ""
|
|
) # used to be basename(self.args.radiobin)
|
|
resources_basename = ""
|
|
|
|
radio_version = 0
|
|
radio_meta = None
|
|
radio_addr = self.args.radioaddr
|
|
if self.args.radiobin:
|
|
if not self.args.radiotype:
|
|
raise ValueError("Missing --radiotype")
|
|
radio_meta = CoproBinary(self.args.radiobin)
|
|
if self.args.stack_version:
|
|
actual_stack_version_str = f"{radio_meta.img_sig.version_major}.{radio_meta.img_sig.version_minor}.{radio_meta.img_sig.version_sub}"
|
|
if actual_stack_version_str != self.args.stack_version:
|
|
self.logger.error(
|
|
f"Stack version mismatch: expected {self.args.stack_version}, actual {actual_stack_version_str}"
|
|
)
|
|
return 1
|
|
radio_version = self.copro_version_as_int(radio_meta, self.args.radiotype)
|
|
if (
|
|
get_stack_type(self.args.radiotype) not in self.WHITELISTED_STACK_TYPES
|
|
and self.args.disclaimer != "yes"
|
|
):
|
|
self.logger.error(
|
|
f"You are trying to bundle a non-standard stack type '{self.args.radiotype}'."
|
|
)
|
|
self.show_disclaimer()
|
|
return 1
|
|
|
|
if radio_addr == 0:
|
|
radio_addr = radio_meta.get_flash_load_addr()
|
|
self.logger.info(
|
|
f"Using guessed radio address 0x{radio_addr:08X}, verify with Release_Notes"
|
|
" or specify --radioaddr"
|
|
)
|
|
|
|
if not exists(self.args.directory):
|
|
os.makedirs(self.args.directory)
|
|
|
|
updater_stage_size = os.stat(self.args.stage).st_size
|
|
shutil.copyfile(self.args.stage, join(self.args.directory, stage_basename))
|
|
|
|
dfu_size = 0
|
|
if self.args.dfu:
|
|
dfu_size = os.stat(self.args.dfu).st_size
|
|
shutil.copyfile(self.args.dfu, join(self.args.directory, dfu_basename))
|
|
if radiobin_basename:
|
|
shutil.copyfile(
|
|
self.args.radiobin, join(self.args.directory, radiobin_basename)
|
|
)
|
|
if self.args.resources:
|
|
resources_basename = self.RESOURCE_FILE_NAME
|
|
if not self.package_resources(
|
|
self.args.resources, join(self.args.directory, resources_basename)
|
|
):
|
|
return 3
|
|
|
|
if not self.layout_check(updater_stage_size, dfu_size, radio_addr):
|
|
self.logger.warning("Memory layout looks suspicious")
|
|
if self.args.disclaimer != "yes":
|
|
self.show_disclaimer()
|
|
return 2
|
|
|
|
if self.args.splash:
|
|
splash_args = [
|
|
"-i",
|
|
self.args.splash,
|
|
"-o",
|
|
join(self.args.directory, self.SPLASH_BIN_NAME),
|
|
]
|
|
if splash_code := SlideshowMain(no_exit=True)(splash_args):
|
|
self.logger.error(
|
|
f"Failed to convert splash screen data: {splash_code}"
|
|
)
|
|
return splash_code
|
|
|
|
file = FlipperFormatFile()
|
|
file.setHeader(
|
|
"Flipper firmware upgrade configuration", self.UPDATE_MANIFEST_VERSION
|
|
)
|
|
file.writeKey("Info", self.args.version)
|
|
file.writeKey("Target", self.args.target[1:]) # dirty 'f' strip
|
|
file.writeKey("Loader", stage_basename)
|
|
file.writeComment("little-endian hex!")
|
|
file.writeKey("Loader CRC", self.int2ffhex(self.crc(self.args.stage)))
|
|
file.writeKey("Firmware", dfu_basename)
|
|
file.writeKey("Radio", radiobin_basename or "")
|
|
file.writeKey("Radio address", self.int2ffhex(radio_addr))
|
|
file.writeKey("Radio version", self.int2ffhex(radio_version, 12))
|
|
if radiobin_basename:
|
|
file.writeKey("Radio CRC", self.int2ffhex(self.crc(self.args.radiobin)))
|
|
else:
|
|
file.writeKey("Radio CRC", self.int2ffhex(0))
|
|
file.writeKey("Resources", resources_basename)
|
|
obvalues = ObReferenceValues((), (), ())
|
|
if self.args.obdata:
|
|
obd = OptionBytesData(self.args.obdata)
|
|
obvalues = obd.gen_values().export()
|
|
file.writeComment(
|
|
"NEVER EVER MESS WITH THESE VALUES, YOU WILL BRICK YOUR DEVICE"
|
|
)
|
|
file.writeKey("OB reference", self.bytes2ffhex(obvalues.reference))
|
|
file.writeKey("OB mask", self.bytes2ffhex(obvalues.compare_mask))
|
|
file.writeKey("OB write mask", self.bytes2ffhex(obvalues.write_mask))
|
|
file.writeKey("Splashscreen", self.SPLASH_BIN_NAME if self.args.splash else "")
|
|
file.save(join(self.args.directory, self.UPDATE_MANIFEST_NAME))
|
|
|
|
return 0
|
|
|
|
def layout_check(self, stage_size, fw_size, radio_addr):
|
|
if stage_size > self.UPDATER_SIZE_THRESHOLD:
|
|
self.logger.warning(
|
|
f"Updater size {stage_size}b > {self.UPDATER_SIZE_THRESHOLD}b and is not loadable on older firmwares!"
|
|
)
|
|
|
|
if fw_size == 0 or radio_addr == 0:
|
|
self.logger.info("Cannot validate layout for partial package")
|
|
return True
|
|
|
|
fw2stack_gap = radio_addr - self.FLASH_BASE - fw_size
|
|
self.logger.debug(f"Expected reserved space size: {fw2stack_gap}")
|
|
fw2stack_gap_pages = fw2stack_gap / self.FLASH_PAGE_SIZE
|
|
if fw2stack_gap_pages < 0:
|
|
self.logger.warning(
|
|
f"Firmware image overlaps C2 region and is not programmable!"
|
|
)
|
|
return False
|
|
|
|
elif fw2stack_gap_pages < self.MIN_GAP_PAGES:
|
|
self.logger.warning(
|
|
f"Expected reserved flash size is too small (~{int(fw2stack_gap_pages)} page(s), need >={self.MIN_GAP_PAGES} page(s))"
|
|
)
|
|
return False
|
|
return True
|
|
|
|
def show_disclaimer(self):
|
|
self.logger.error(
|
|
"You might brick your device into a state in which you'd need an SWD programmer to fix it."
|
|
)
|
|
self.logger.error(
|
|
"Please confirm that you REALLY want to do that with --I-understand-what-I-am-doing=yes"
|
|
)
|
|
|
|
def _tar_filter(self, tarinfo: tarfile.TarInfo):
|
|
if len(tarinfo.name) > self.RESOURCE_ENTRY_NAME_MAX_LENGTH:
|
|
self.logger.error(
|
|
f"Cannot package resource: name '{tarinfo.name}' too long"
|
|
)
|
|
raise ValueError("Resource name too long")
|
|
return tar_sanitizer_filter(tarinfo)
|
|
|
|
def package_resources(self, srcdir: str, dst_name: str):
|
|
try:
|
|
src_size, compressed_size = compress_tree_tarball(
|
|
srcdir, dst_name, filter=self._tar_filter
|
|
)
|
|
|
|
self.logger.info(
|
|
f"Resources compression ratio: {compressed_size * 100 / src_size:.2f}%"
|
|
)
|
|
return True
|
|
except Exception as e:
|
|
self.logger.error(f"Cannot package resources: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
def copro_version_as_int(coprometa, stacktype):
|
|
major = coprometa.img_sig.version_major
|
|
minor = coprometa.img_sig.version_minor
|
|
sub = coprometa.img_sig.version_sub
|
|
branch = coprometa.img_sig.version_branch
|
|
release = coprometa.img_sig.version_build
|
|
stype = get_stack_type(stacktype)
|
|
return (
|
|
major
|
|
| (minor << 8)
|
|
| (sub << 16)
|
|
| (branch << 24)
|
|
| (release << 32)
|
|
| (stype << 40)
|
|
)
|
|
|
|
@staticmethod
|
|
def bytes2ffhex(value: bytes):
|
|
return " ".join(f"{b:02X}" for b in value)
|
|
|
|
@staticmethod
|
|
def int2ffhex(value: int, n_hex_syms=8):
|
|
if value:
|
|
n_hex_syms = max(math.ceil(math.ceil(math.log2(value)) / 8) * 2, n_hex_syms)
|
|
fmtstr = f"%0{n_hex_syms}X"
|
|
hexstr = fmtstr % value
|
|
return " ".join(list(Main.batch(hexstr, 2))[::-1])
|
|
|
|
@staticmethod
|
|
def crc(fileName):
|
|
prev = 0
|
|
with open(fileName, "rb") as file:
|
|
for eachLine in file:
|
|
prev = zlib.crc32(eachLine, prev)
|
|
return prev & 0xFFFFFFFF
|
|
|
|
@staticmethod
|
|
def batch(iterable, n=1):
|
|
iterable_len = len(iterable)
|
|
for ndx in range(0, iterable_len, n):
|
|
yield iterable[ndx : min(ndx + n, iterable_len)]
|
|
|
|
|
|
if __name__ == "__main__":
|
|
Main()()
|