bouffalolab_firmware_utils.py

#!/usr/bin/env python3
# Copyright (c) 2021 Project CHIP Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import binascii
import configparser
import logging
import os
import pathlib
import platform
import re
import shutil
import subprocess
import sys

import coloredlogs
import firmware_utils
import toml
from Crypto.Cipher import AES

coloredlogs.install(level='DEBUG')

# Additional options that can be use to configure an `Flasher`
# object (as dictionary keys) and/or passed as command line options.


def any_base_int(s): return int(s, 0)


BOUFFALO_OPTIONS = {
    # Configuration options define properties used in flashing operations.
    'configuration': {
        'chipname': {
            'help': "Bouffalolab chip name",
            'default': None,
            'argparse': {
                'metavar': 'CHIP_NAME',
            }
        },
        'pt': {
            'help': 'Partition table for board for bl iot sdk',
            'default': None,
            'argparse': {
                'metavar': 'PARTITION_TABLE_FILE',
                'type': pathlib.Path
            }
        },
        'dts': {
            'help': 'Device tree file for bl iot sdk',
            'default': None,
            'argparse': {
                'metavar': 'DEVICE_TREE_FILE',
                'type': pathlib.Path
            }
        },
        'xtal': {
            'help': 'XTAL configuration for bl iot sdk',
            'default': None,
            'argparse': {
                'metavar': 'XTAL',
            }
        },
        'port': {
            'help': 'UART port to flash device',
            'default': None,
            'argparse': {
                'metavar': 'PORT',
            }
        },
        'baudrate': {
            'help': 'UART baudrate to flash device',
            'default': None,
            'argparse': {
                'metavar': 'BAUDRATE',
            },
        },
        'sk': {
            'help': 'private key to sign firmware to flash or sign ota image.',
            'default': None,
            'argparse': {
                'metavar': 'path',
                'type': pathlib.Path
            }
        },
        'mfd': {
            'help': 'matter factory data',
            'default': None,
            'argparse': {
                'metavar': 'path',
                'type': pathlib.Path
            }
        },
        'mfd-str': {
            'help': 'matter factory data string, only available for using bl iot sdk',
            'default': None,
            'argparse': {
                'metavar': 'mfd_str',
            }
        },
        'key': {
            'help': 'data key in security engine for matter factory data decryption',
            'default': None,
            'argparse': {
                'metavar': 'key',
            }
        },
        'boot2': {
            'help': 'boot2 image',
            'default': None,
            'argparse': {
                'metavar': 'path',
            }
        },
        'config': {
            'help': 'firmware programming configuration for bouffalo sdk',
            'default': None,
            'argparse': {
                'metavar': 'path',
            }
        },
        'build-ota': {
            'help': 'build ota image',
            'default': None,
            'argparse': {
                'action': 'store_true'
            },
        },
        'vendor-id': {
            'help': 'vendor id passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'vendor_id',
                "type": any_base_int
            }
        },
        'product-id': {
            'help': 'product id passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'product_id',
                "type": any_base_int
            }
        },
        'version': {
            'help': 'software version (numeric) passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'version',
                "type": any_base_int
            }
        },
        'version-str': {
            'help': 'software version string passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'version_str',
            }
        },
        'digest-algorithm': {
            'help': 'digest algorithm passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'digest_algorithm',
            }
        },
        "min-version": {
            'help': 'minimum software version passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'min_version',
                "type": any_base_int
            }
        },
        "max-version": {
            'help': 'maximum software version passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'max_version',
                "type": any_base_int
            }
        },
        "release-notes": {
            'help': 'release note passes to ota_image_tool.py ota image if --build-ota present',
            'default': None,
            'argparse': {
                'metavar': 'release_notes',
            }
        }
    },
}

MATTER_ROOT = os.getcwd()


class DictObject:
    def __init__(self, data_dict):
        for key, value in data_dict.items():
            if isinstance(value, dict):
                self.__dict__[key] = DictObject(value)
            else:
                self.__dict__[key] = value

    def __getattr__(self, name):
        return self.__dict__.get(name, None)

    def __setattr__(self, name, value):
        self.__dict__[name] = value

    def __repr__(self):
        return str(self.__dict__)


class Flasher(firmware_utils.Flasher):

    args = {}
    work_dir = None
    bouffalo_sdk_chips = ["bl616"]

    def __init__(self, **options):
        super().__init__(platform=None, module=__name__, **options)
        self.define_options(BOUFFALO_OPTIONS)

    def find_file(self, path_dir, name_partten):

        ret_files = []

        for root, dirs, files in os.walk(path_dir, topdown=False):
            for name in files:
                if re.match(name_partten, name):
                    ret_files.append(os.path.join(root, name))

        return ret_files

    def parse_mfd(self):

        def decrypt_data(data_bytearray, key_bytearray, iv_bytearray):
            data_bytearray += bytes([0] * (16 - (len(data_bytearray) % 16)))
            cryptor = AES.new(key_bytearray, AES.MODE_CBC, iv_bytearray)
            plaintext = cryptor.decrypt(data_bytearray)
            return plaintext

        self.args["iv"] = None

        if not self.args["mfd"] and not self.args["mfd_str"]:
            return None

        if self.args['mfd_str']:
            try:
                iv = self.args['mfd_str'].split(":")[1].split(',')[0]
            except Exception:
                raise Exception("Invalid mfd-str format.")

            self.args["iv"] = iv
            return self.args['mfd_str']

        with open(self.args["mfd"], 'rb') as f:
            bytes_obj = f.read()

        sec_len = int.from_bytes(bytes_obj[0:4], byteorder='little')
        if sec_len:
            crc_val_calc = binascii.crc32(bytes_obj[4: 4 + sec_len])
            crc_val = int.from_bytes(bytes_obj[4 + sec_len: 4 + sec_len + 4], byteorder='little')
            if crc_val_calc != crc_val:
                raise Exception("MFD partition file has invalid format in secured data.")
            bytes_sec = bytes_obj[4: 4 + sec_len]

            if not self.args["key"]:
                raise Exception("MFD has secured data, but no key input.")
        else:
            bytes_sec = []

        raw_start = 4 + sec_len + 4
        raw_len = int.from_bytes(bytes_obj[raw_start: raw_start + 4], byteorder='little')
        if raw_len:
            crc_val_calc = binascii.crc32(bytes_obj[raw_start + 4: raw_start + 4 + raw_len])
            crc_val = int.from_bytes(bytes_obj[raw_start + 4 + raw_len: raw_start + 4 + raw_len + 4], byteorder='little')
            if crc_val_calc != crc_val:
                raise Exception("MFD partition file has invalid format in raw data.")
            bytes_raw = bytes_obj[raw_start + 4: raw_start + 4 + raw_len]
        else:
            bytes_raw = []

        offset = 0
        dict_raw = {}
        while offset < raw_len:
            type_id = int.from_bytes(bytes_raw[offset: offset + 2], byteorder='little')
            type_len = int.from_bytes(bytes_raw[offset + 2: offset + 4], byteorder='little')

            if 0x8001 == type_id:
                self.args["iv"] = bytes_raw[offset + 4: offset + 4 + type_len]

            if offset + 4 + type_len <= raw_len:
                dict_raw[type_id] = bytes(bytes_raw[offset + 4: offset + 4 + type_len]).hex()

            offset += (4 + type_len)

        if sec_len > 0 and self.args["key"] and not self.args["iv"]:
            raise Exception("No IV found in secured mfd data.")

        offset = 0
        dict_sec = {}
        if bytes_sec and self.args["iv"] and self.args["key"]:

            bytes_sec = decrypt_data(bytes_sec, bytearray.fromhex(self.args["key"]), self.args["iv"])
            while offset < raw_len:
                type_id = int.from_bytes(bytes_sec[offset: offset + 2], byteorder='little')
                type_len = int.from_bytes(bytes_sec[offset + 2:offset + 4], byteorder='little')

                if offset + 4 + type_len <= sec_len:
                    dict_sec[type_id] = bytes(bytes_sec[offset + 4: offset + 4 + type_len]).hex()

                offset += (4 + type_len)

        self.args["iv"] = self.args["iv"].hex()

        mfd_str = ""
        if dict_sec.keys():
            for idx in range(1, 1 + max(dict_sec.keys())):
                if idx in dict_sec.keys():
                    mfd_str += dict_sec[idx] + ","
                else:
                    mfd_str += ","

        mfd_str = mfd_str + ":"
        for idx in range(0x8001, 1 + max(dict_raw.keys())):
            if idx in dict_raw.keys():
                mfd_str += dict_raw[idx] + ","
            else:
                mfd_str += ","

        self.args["mfd_str"] = mfd_str

        return self.args['mfd_str']

    def iot_sdk_prog(self):

        def get_tools():
            flashtool_path = os.environ.get('BOUFFALOLAB_SDK_ROOT') + "/flashtool/BouffaloLabDevCube-v1.9.0"
            bflb_tools_dict = {
                "linux": {"flash_tool": "bflb_iot_tool-ubuntu"},
                "win32": {"flash_tool": "bflb_iot_tool.exe"},
                "darwin": {"flash_tool": "bflb_iot_tool-macos"},
            }

            try:
                flashtool_exe = flashtool_path + "/" + bflb_tools_dict[sys.platform]["flash_tool"]
            except Exception:
                raise Exception("Do NOT support {} operating system to program firmware.".format(sys.platform))

            if not os.path.exists(flashtool_exe):
                logging.fatal('*' * 80)
                logging.error('Flashtool is not installed, or environment variable BOUFFALOLAB_SDK_ROOT is not exported.')
                logging.fatal('\tPlease make sure Bouffalo Lab SDK installs as below:')
                logging.fatal('\t\t./third_party/bouffalolab/env-setup.sh')

                logging.fatal('\tPlease make sure BOUFFALOLAB_SDK_ROOT exports before building as below:')
                logging.fatal('\t\texport BOUFFALOLAB_SDK_ROOT="your install path"')
                logging.fatal('*' * 80)
                raise Exception("Flash tool is not installed.")

            return flashtool_path, flashtool_exe

        def get_dts_file(flashtool_path, dts):

            if dts:
                return dts
            else:
                return os.path.join(flashtool_path, "chips", self.args["chipname"],
                                    "device_tree", "bl_factory_params_IoTKitA_{}.dts".format(self.args["xtal"]))

        def get_boot_image(flashtool_path, boot2_image):

            if boot2_image:
                return boot2_image

            if self.args["chipname"] in ["bl702l"]:
                return None

            builtin_imgs_path = os.path.join(flashtool_path, "chips", self.args["chipname"], "builtin_imgs")
            boot2_images = self.find_file(builtin_imgs_path, r'boot2_isp_release.bin')
            if len(boot2_images) > 1:
                raise Exception("More than one boot2 image found.")
            if len(boot2_images) == 0:
                raise Exception("No boot2 image found.")

            return boot2_images[0]

        def get_mfd_addr():
            with open(self.args["pt"], 'r') as file:
                partition_config = toml.load(file)

            mfd_addr = None
            for v in partition_config["pt_entry"]:
                if v["name"] == "MFD" or v["name"] == "mfd":
                    mfd_addr = v["address0"]

            return mfd_addr

        def exe_gen_ota_image_cmd(flashtool_exe):

            os.system("rm -rf {}/FW_OTA.bin*".format(self.work_dir))
            os.system("rm -rf {}/ota_images".format(self.work_dir))

            if not self.args["build_ota"]:
                return

            gen_ota_img_cmd = [
                flashtool_exe,
                "--build",
                "--chipname", self.args["chipname"],
                "--dts", self.args["dts"],
                "--firmware", self.args["firmware"],
                "--pt", self.args["pt"],
                "--ota", self.work_dir
            ]

            if self.args["sk"]:
                gen_ota_img_cmd += ["--sk", self.args["sk"]]

            logging.info("ota image generating: {}".format(" ".join(gen_ota_img_cmd)))
            process = subprocess.Popen(gen_ota_img_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            while process.poll() is None:
                line = process.stdout.readline().decode('utf-8').rstrip()
                if line:
                    logging.info(line)

            fw_ota_images = self.find_file(self.work_dir, r'^FW_OTA.+\.hash$')
            if not fw_ota_images or 0 == len(fw_ota_images):
                raise Exception("Failed to generate Bouffalo Lab OTA image.")

            os.system("mkdir -p {}/ota_images".format(self.work_dir))
            fw_name = os.path.basename(self.args["firmware"])[:-len(".bin")]
            for img in fw_ota_images:
                ota_img_name = os.path.basename(img)
                new_name = os.path.join(self.work_dir, "ota_images", fw_name + ota_img_name[len("FW_OTA"):])
                os.system("mv {} {}".format(img, new_name))

        def construct_prog_confg():

            iot_cfg = {
                "param": {
                    "interface_type": "uart",
                    "comport_uart": self.args["port"],
                    "speed_uart": self.args["baudrate"],
                    "speed_jlink": "1000",
                    "chip_xtal": self.args["xtal"],
                    "ota": "",
                    "version": "",
                    "aes_key": "",
                    "aes_iv": "",
                    "addr": "0x0",
                    "publickey": "",
                    "privatekey": ""
                },
                "check_box": {
                    "fw_download": True,
                    "mfg_download": False,
                    "media_download": False,
                    "romfs_download": False,
                    "psm_download": False,
                    "key_download": False,
                    "data_download": False,
                    "factory_download": True if self.args["dts"] else False,
                    "mfd_download": True if self.args["mfd"] else False,
                    "boot2_download": True if self.args["boot2"] else False,
                    "ckb_erase_all": "True" if self.args["erase"] else "False",
                    "partition_download": True if self.args["pt"] else False,
                    "encrypt": False,
                    "sign": False,
                    "single_download": False,
                    "auto_efuse_verify": False
                },
                "input_path": {
                    "fw_bin_input": self.args['firmware'],
                    "mfg_bin_input": "",
                    "media_bin_input": "",
                    "romfs_dir_input": "",
                    "psm_bin_input": "",
                    "key_bin_input": "",
                    "data_bin_input": "",
                    "factory_bin_input": self.args["dts"],
                    "mfd_bin_input": self.args["mfd"],
                    "boot2_bin_input": self.args["boot2"],
                    "img_bin_input": "",
                    "pt_table_bin_input": self.args["pt"],
                    "publickey": "",
                    "privatekey": ""
                }
            }

            conf_toml = os.path.splitext(self.args['firmware'])[0] + "_config.toml"

            with open(conf_toml, "w", encoding="utf-8") as f:
                toml.dump(iot_cfg, f)

            return conf_toml

        def exe_prog_cmd(flashtool_exe, mfd_addr, flashtool_path):

            if not self.args["port"]:
                return

            if self.args["mfd"] and not mfd_addr:
                raise Exception("No MFD partition found in partition table.")

            if self.args["mfd"] and not self.args["key"]:
                conf_toml = construct_prog_confg()

                prog_cmd = [
                    flashtool_exe,
                    "--chipname", self.args["chipname"],
                    "--config", conf_toml,
                ]

            else:
                prog_cmd = [
                    flashtool_exe,
                    "--port", self.args["port"],
                    "--baudrate", self.args["baudrate"],
                    "--chipname", self.args["chipname"],
                    "--firmware", self.args["firmware"],
                    "--dts", self.args["dts"],
                    "--pt", self.args["pt"],
                ]

                if self.args["boot2"]:
                    prog_cmd += ["--boot2", self.args["boot2"]]

                if self.args["sk"]:
                    prog_cmd += ["--sk", self.args["sk"]]

                if mfd_addr and self.args["mfd_str"]:
                    if self.args["key"] and not self.args["iv"]:
                        logging.warning("mfd file has no iv, do NOT program mfd key.")
                    else:
                        prog_cmd += ["--dac_key", self.args["key"]]
                        prog_cmd += ["--dac_iv", self.args["iv"]]
                        prog_cmd += ["--dac_addr", hex(mfd_addr)]
                        prog_cmd += ["--dac_value", self.args["mfd_str"]]

                if self.option.erase:
                    prog_cmd += ["--erase"]

            logging.info("firmware programming: {}".format(" ".join(prog_cmd)))
            process = subprocess.Popen(prog_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            while process.poll() is None:
                line = process.stdout.readline().decode('utf-8').rstrip()
                if line:
                    logging.info(line)

        flashtool_path, flashtool_exe = get_tools()
        self.args["pt"] = os.path.join(os.getcwd(), str(self.args["pt"]))
        mfd_addr = get_mfd_addr()

        self.parse_mfd()
        self.args["dts"] = get_dts_file(flashtool_path, self.args["dts"])
        self.args["boot2"] = get_boot_image(flashtool_path, self.args["boot2"])

        os.chdir(self.work_dir)

        exe_gen_ota_image_cmd(flashtool_exe)
        exe_prog_cmd(flashtool_exe, mfd_addr, flashtool_path)

    def bouffalo_sdk_prog(self):

        def int_to_lhex(intvalue):
            lhex = ((intvalue & 0xff000000) >> 24) | ((intvalue & 0xff0000) >> 8)
            lhex |= ((intvalue & 0xff00) << 8) | ((intvalue & 0xff) << 24)

            return "%08x" % lhex

        def get_tools():
            bflb_tools = os.path.join(MATTER_ROOT, "third_party/bouffalolab/bouffalo_sdk/tools/bflb_tools")
            bflb_tools_dict = {
                "linux": {"fw_proc": "bflb_fw_post_proc/bflb_fw_post_proc-ubuntu", "flash_tool": "bouffalo_flash_cube/BLFlashCommand-ubuntu"},
                "win32": {"fw_proc": "bflb_fw_post_proc/bflb_fw_post_proc.exe", "flash_tool": "bouffalo_flash_cube/BLFlashCommand.exe"},
                "darwin": {"fw_proc": "bflb_fw_post_proc/bflb_fw_post_proc-macos", "flash_tool": "bouffalo_flash_cube/BLFlashCommand-macos"},
            }

            try:
                fw_proc_exe = os.path.join(bflb_tools, bflb_tools_dict[sys.platform]["fw_proc"])
                flashtool_exe = os.path.join(bflb_tools, bflb_tools_dict[sys.platform]["flash_tool"])
            except Exception:
                raise Exception("Do NOT support {} operating system to program firmware.".format(sys.platform))

            if not os.path.exists(flashtool_exe) or not os.path.exists(fw_proc_exe):
                logging.fatal('*' * 80)
                logging.error("Expecting tools as below:")
                logging.error(fw_proc_exe)
                logging.error(flashtool_exe)
                raise Exception("Flashtool or fw tool doesn't contain in SDK")

            return fw_proc_exe, flashtool_exe

        def prog_config(configDir, output, isErase=False):

            partition_file = self.find_file(configDir, r'^partition.+\.toml$')
            if len(partition_file) != 1:
                raise Exception("No partition file or one more partition file found.")

            partition_file = partition_file[0]
            with open(partition_file, 'r') as file:
                partition_config = toml.load(file)

            part_addr0 = partition_config["pt_table"]["address0"]
            part_addr1 = partition_config["pt_table"]["address1"]

            config = configparser.ConfigParser()

            config.add_section('cfg')
            config.set('cfg', 'erase', '2' if isErase else '1')
            config.set('cfg', 'skip_mode', '0x0, 0x0')
            config.set('cfg', 'boot2_isp_mode', '0')

            config.add_section('boot2')
            config.set('boot2', 'filedir', os.path.join(self.work_dir, "boot2*.bin"))
            config.set('boot2', 'address', '0x000000')

            config.add_section('partition')
            config.set('partition', 'filedir', os.path.join(self.work_dir, "partition*.bin"))
            config.set('partition', 'address', hex(part_addr0))

            config.add_section('partition1')
            config.set('partition1', 'filedir', os.path.join(self.work_dir, "partition*.bin"))
            config.set('partition1', 'address', hex(part_addr1))

            config.add_section('FW')
            config.set('FW', 'filedir', self.args["firmware"])
            config.set('FW', 'address', '@partition')

            if self.args["mfd"]:
                config.add_section("MFD")
                config.set('MFD', 'filedir', self.args["mfd"])
                config.set('MFD', 'address', '@partition')

            with open(output, 'w') as configfile:
                config.write(configfile)

        def exe_proc_cmd(fw_proc_exe):

            os.system("rm -rf {}/ota_images".format(self.work_dir))

            fw_proc_cmd = [
                fw_proc_exe,
                "--chipname", self.args["chipname"],
                "--brdcfgdir", os.path.join(self.work_dir, "config"),
                "--imgfile", self.args["firmware"],
            ]

            if self.args["sk"]:
                fw_proc_cmd += [
                    "--privatekey", self.args["sk"],
                ]

            if self.args["key"]:
                lock0 = int_to_lhex((1 << 30) | (1 << 20))
                lock1 = int_to_lhex((1 << 25) | (1 << 15))
                fw_proc_cmd += [
                    "--edata", "0x80,{};0x7c,{};0xfc,{}".format(self.args["key"], lock0, lock1)
                ]

            logging.info("firmware process command: {}".format(" ".join(fw_proc_cmd)))
            process = subprocess.Popen(fw_proc_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            while process.poll() is None:
                line = process.stdout.readline().decode('utf-8').rstrip()
                if line:
                    logging.info(line)

            os.system("mkdir -p {}/ota_images".format(self.work_dir))
            os.system("mv {}/*.ota {}/ota_images/".format(self.work_dir, self.work_dir))

        def exe_prog_cmd(flashtool_exe):
            prog_cmd = [
                flashtool_exe,
                "--chipname", self.args["chipname"],
                "--baudrate", str(self.args["baudrate"]),
                "--config", self.args["config"]
            ]

            if self.args["sk"] or (self.args["key"] and self.args["iv"]):
                prog_cmd += [
                    "--efuse", os.path.join(self.work_dir, "efusedata.bin")
                ]

            if self.args["port"]:
                prog_config(os.path.join(self.work_dir, "config"), os.path.join(
                    self.work_dir, "flash_prog_cfg.ini"), self.option.erase)

                prog_cmd += [
                    "--port", self.args["port"],
                ]

                logging.info("firwmare programming: {}".format(" ".join(prog_cmd)))
                process = subprocess.Popen(prog_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                while process.poll() is None:
                    line = process.stdout.readline().decode('utf-8').rstrip()
                    if line:
                        logging.info(line)

        fw_proc_exe, flashtool_exe = get_tools()
        os.chdir(self.work_dir)

        self.parse_mfd()

        exe_proc_cmd(fw_proc_exe)
        exe_prog_cmd(flashtool_exe)

    def gen_ota_image(self):
        sys.path.insert(0, os.path.join(MATTER_ROOT, 'src', 'app'))
        import ota_image_tool

        bflb_ota_images = self.find_file(os.path.join(self.work_dir, "ota_images"), r".+\.(ota|hash)$")
        if len(bflb_ota_images) == 0:
            raise Exception("No bouffalo lab OTA image found.")

        ota_image_cfg_list = [
            "vendor_id",
            "product_id",
            "version",
            "version_str",
            "digest_algorithm",
            "min_version",
            "max_version",
            "release_notes",
        ]
        ota_image_cfg = {}
        for k in ota_image_cfg_list:
            if self.args[k] is not None:
                ota_image_cfg[k] = self.args[k]
        ota_image_cfg = DictObject(ota_image_cfg)

        for img in bflb_ota_images:
            ota_image_cfg.input_files = [img]
            ota_image_cfg.output_file = img + ".matter"
            ota_image_tool.validate_header_attributes(ota_image_cfg)
            ota_image_tool.generate_image(ota_image_cfg)

            if re.match(r".+\.(xz.ota|xz.hash)$", img):
                self.log(0, 'Matter OTA compressed image generated: {}'.format(ota_image_cfg.output_file))
            else:
                self.log(0, 'Matter OTA image generated: {}'.format(ota_image_cfg.output_file))

    def verify(self):
        """Not supported"""
        self.log(0, "Verification is done after image flashed.")

    def reset(self):
        """Not supported"""
        self.log(0, "Reset is triggered automatically after image flashed.")

    def actions(self):
        """Perform actions on the device according to self.option."""
        self.log(3, 'Options:', self.option)

        # is_for_ota_image_building = None
        # is_for_programming = False
        # has_private_key = False
        # has_public_key = False
        # ota_output_folder = None
        # options_keys = BOUFFALO_OPTIONS["configuration"].keys()

        if platform.machine() not in ["x86_64"]:
            raise Exception("Only support x86_64 CPU machine to program firmware.")

        if self.option.reset:
            self.reset()
        if self.option.verify_application:
            self.verify()

        self.args = dict(vars(self.option))
        self.args["application"] = os.path.join(os.getcwd(), str(self.args["application"]))
        self.work_dir = os.path.dirname(self.args["application"])
        if self.args["sk"]:
            self.args["sk"] = str(self.args["sk"])

        if self.args["mfd"]:
            self.args["mfd"] = os.path.join(MATTER_ROOT, str(self.args["mfd"]))

        self.args["application"] = os.path.join(os.getcwd(), str(self.args["application"]))
        self.args["firmware"] = str(pathlib.Path(self.args["application"]).with_suffix(".bin"))
        if self.args["application"] != self.args["firmware"]:
            shutil.copy2(self.args["application"], self.args["firmware"])

        if self.args["build_ota"]:
            if self.args["port"]:
                raise Exception("Do not generate OTA image with firmware programming.")

        if self.args["chipname"] in self.bouffalo_sdk_chips:
            self.bouffalo_sdk_prog()
        else:
            if self.args["mfd"] and self.args["mfd_str"]:
                raise Exception("Cannot use option mfd and mfd-str together.")
            self.iot_sdk_prog()

        if self.args["build_ota"]:
            self.gen_ota_image()

        return self


if __name__ == '__main__':

    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])

    sys.exit(Flasher().flash_command(sys.argv))