MtkPreloader.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using MtkClient.Library.Config;
using MtkClient.Library.Connection;
using MtkClient.Library.Packet;
using MtkClient.Library.Recovery;
using MtkClient.Library.State;
using MtkClient.Library.Utils;

namespace MtkClient.Library
{
    public class TargetConfig
    {
        public bool SecureBoot { get; set; }
        public bool SLA { get; set; }
        public bool Daa { get; set; }
        public bool Sbc { get; set; }
        public bool EppParam { get; set; }
        public bool IsBrom { get; set; }
        public int MeId { get; set; }
        public int SocId { get; set; }
        public uint RawValue { get; set; }

        public override string ToString()
        {
            return $"SB={SecureBoot}, SLA={SLA}, DAA={Daa}, SBC={Sbc}";
        }
    }

    public class PlCap
    {
        public bool Brom { get; set; }
        public bool Preloader { get; set; }
        public ushort HwCode { get; set; }
        public ushort HwSubCode { get; set; }
        public ushort HwVer { get; set; }
        public ushort SwVer { get; set; }
        public ushort BlVer { get; set; }
        public byte[] RandomId { get; set; }
    }

    public class BromInfo
    {
        public ushort HwCode { get; set; }
        public ushort HwSubCode { get; set; }
        public ushort HwVer { get; set; }
        public ushort SwVer { get; set; }
        public ushort BlVer { get; set; }
        public byte[] MeId { get; set; }
        public byte[] SocId { get; set; }
        public byte[] BromLog { get; set; }
        public TargetConfig TargetConfig { get; set; }
        public bool IsBrom { get; set; }

        public override string ToString()
        {
            return $"HW:0x{HwCode:X4} Sub:0x{HwSubCode:X4} Ver:0x{HwVer:X4} SW:0x{SwVer:X4}";
        }
    }

    public class Preloader : LogBase
    {
        public MtkConfig Config { get; }
        public Port Port { get; }
        public TargetConfig TargetCfg { get; set; }
        public PlCap Capability { get; set; }
        public BromInfo DeviceInfo { get; private set; }
        public bool IsBrom { get; set; }
        public MtkStateManager StateManager { get; }
        public RecoveryManager RecoveryMgr { get; }

        // BROM Commands
        public const byte CMD_GET_HW_CODE = 0xFD;
        public const byte CMD_GET_HW_DICT = 0xFC;
        public const byte CMD_GET_BL_VER = 0xFE;
        public const byte CMD_READ16 = 0xA2;
        public const byte CMD_WRITE16 = 0xA4;
        public const byte CMD_CHECKSUM16 = 0xA8;
        public const byte CMD_READ32 = 0xD1;
        public const byte CMD_WRITE32 = 0xD4;
        public const byte CMD_JUMP_DA = 0xD5;
        public const byte CMD_SEND_DA = 0xD7;
        public const byte CMD_GET_TARGET_CONFIG = 0xD8;
        public const byte CMD_SEND_EPP = 0xD9;
        public const byte CMD_CHECKSUM = 0xDA;
        public const byte CMD_UART1_LOG_EN = 0xDB;
        public const byte CMD_UART1_SET_BAUDRATE = 0xDC;
        public const byte CMD_SET_META_BOOT = 0xE1;
        public const byte CMD_SEND_CERT = 0xE2;
        public const byte CMD_GET_ME_ID = 0xE1;
        public const byte CMD_GET_SOC_ID = 0xE7;
        public const byte CMD_GET_BROM_LOG = 0xEF;
        public const byte CMD_POWER_DOWN = 0xB7;
        public const byte CMD_I2C_INIT = 0xB0;
        public const byte CMD_COLD_RESET = 0xB1;
        public const byte CMD_SLA_CHALLENGE = 0xB4;
        public const byte CMD_PWR_INIT = 0xC4;
        public const byte CMD_PWR_DEINIT = 0xC5;
        public const byte CMD_PWR_READ16 = 0xC6;
        public const byte CMD_PWR_WRITE16 = 0xC7;

        // ACK/NACK
        public const ushort ACK = 0x5A5A;
        public const ushort NACK = 0xA5A5;

        // BROM Sync
        public static readonly byte[] SYNC_SEQUENCE = { 0xA0, 0x0A, 0x50, 0x05 };

        // Timeouts
        private const int CMD_TIMEOUT = 2000;
        private const int LONG_TIMEOUT = 10000;
        private const int SYNC_TIMEOUT = 50;

        public Preloader(MtkConfig config, Port port, LogLevel logLevel = LogLevel.Info,
            MtkStateManager stateManager = null, RecoveryManager recoveryManager = null)
        {
            InitLogger(logLevel);
            Config = config;
            Port = port;
            TargetCfg = new TargetConfig();
            Capability = new PlCap();
            DeviceInfo = new BromInfo();
            StateManager = stateManager ?? new MtkStateManager(logLevel);
            RecoveryMgr = recoveryManager ?? new RecoveryManager(StateManager, logLevel);
        }

        #region BROM Handshake & Sync

        public bool BromSync(int maxRetries = 50, CancellationToken cancellationToken = default)
        {
            Info("Starting BROM sync...");
            for (int attempt = 0; attempt < maxRetries; attempt++)
            {
                if (cancellationToken.IsCancellationRequested) return false;

                try
                {
                    bool syncOk = true;
                    for (int i = 0; i < SYNC_SEQUENCE.Length; i++)
                    {
                        Port.UsbWrite(new[] { SYNC_SEQUENCE[i] });
                        var resp = Port.UsbRead(1, SYNC_TIMEOUT);
                        byte expected = (byte)(~SYNC_SEQUENCE[i] & 0xFF);

                        if (resp == null || resp.Length == 0 || resp[0] != expected)
                        {
                            syncOk = false;
                            break;
                        }
                    }

                    if (syncOk)
                    {
                        Info($"BROM sync OK (attempt {attempt + 1})");
                        IsBrom = true;
                        StateManager.TransitionTo(DeviceState.BromMode, "BROM sync");
                        return true;
                    }
                }
                catch (Exception ex)
                {
                    Debug($"Sync attempt {attempt + 1} failed: {ex.Message}");
                }

                Thread.Sleep(50);
            }

            Warning("BROM sync failed");
            return false;
        }

        public bool DetectMode()
        {
            try
            {
                var hw = GetHwCode();
                if (hw.HasValue)
                {
                    IsBrom = true;
                    StateManager.TransitionTo(DeviceState.BromMode, "HW code received");
                    return true;
                }
            }
            catch { }

            try
            {
                // Try preloader detection
                Port.Cdc.Flush();
                var data = Port.UsbRead(1, 200);
                if (data != null && data.Length > 0)
                {
                    IsBrom = false;
                    StateManager.TransitionTo(DeviceState.PreloaderMode, "Preloader detected");
                    return true;
                }
            }
            catch { }

            return false;
        }

        #endregion

        #region Core BROM Commands

        public ushort? GetHwCode()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_HW_CODE });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var hwCode = Port.RWord();
                var hwSubCode = Port.RWord();
                var hwVer = Port.RWord();
                var swVer = Port.RWord();

                if (hwCode.HasValue)
                {
                    Config.HwCode = hwCode.Value;
                    Capability.HwCode = hwCode.Value;
                    Capability.HwSubCode = hwSubCode ?? 0;
                    Capability.HwVer = hwVer ?? 0;
                    Capability.SwVer = swVer ?? 0;

                    DeviceInfo.HwCode = hwCode.Value;
                    DeviceInfo.HwSubCode = hwSubCode ?? 0;
                    DeviceInfo.HwVer = hwVer ?? 0;
                    DeviceInfo.SwVer = swVer ?? 0;

                    Info($"HW Code: 0x{hwCode.Value:X4}");
                    return hwCode.Value;
                }
            }
            catch (Exception ex)
            {
                Error($"GetHwCode failed: {ex.Message}");
            }
            return null;
        }

        public ushort? GetHwDict()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_HW_DICT });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var hwSubCode = Port.RWord();
                var hwVer = Port.RWord();
                var swVer = Port.RWord();

                if (hwSubCode.HasValue)
                {
                    Capability.HwSubCode = hwSubCode.Value;
                    Capability.HwVer = hwVer ?? 0;
                    Capability.SwVer = swVer ?? 0;
                    return hwSubCode;
                }
            }
            catch (Exception ex)
            {
                Error($"GetHwDict failed: {ex.Message}");
            }
            return null;
        }

        public ushort? GetBlVer()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_BL_VER });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var blVer = Port.RWord();
                if (blVer.HasValue)
                {
                    Capability.BlVer = blVer.Value;
                    DeviceInfo.BlVer = blVer.Value;
                    Config.BlVer = blVer.Value;
                    Debug($"BL Version: 0x{blVer.Value:X4}");
                }
                return blVer;
            }
            catch (Exception ex)
            {
                Error($"GetBlVer failed: {ex.Message}");
                return null;
            }
        }

        public TargetConfig GetTargetConfig()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_TARGET_CONFIG });
                var ack = Port.RWord();
                if (ack != ACK) return TargetCfg;

                var targetConfig = Port.RdWord();
                if (targetConfig.HasValue)
                {
                    TargetCfg.RawValue = targetConfig.Value;
                    TargetCfg.SecureBoot = (targetConfig.Value & 1) != 0;
                    TargetCfg.SLA = (targetConfig.Value & 2) != 0;
                    TargetCfg.Daa = (targetConfig.Value & 4) != 0;
                    TargetCfg.Sbc = (targetConfig.Value & 8) != 0;
                    TargetCfg.EppParam = (targetConfig.Value & 0x10) != 0;

                    DeviceInfo.TargetConfig = TargetCfg;

                    // Update security state
                    if (TargetCfg.Daa)
                        StateManager.SetSecurityState(SecurityState.Daa);
                    else if (TargetCfg.SLA)
                        StateManager.SetSecurityState(SecurityState.Sla);
                    else if (TargetCfg.SecureBoot)
                        StateManager.SetSecurityState(SecurityState.SecureBoot);
                    else
                        StateManager.SetSecurityState(SecurityState.Unlocked);

                    Info($"Target config: {TargetCfg}");
                }

                Port.RWord(); // status
                return TargetCfg;
            }
            catch (Exception ex)
            {
                Error($"GetTargetConfig failed: {ex.Message}");
                return TargetCfg;
            }
        }

        #endregion

        #region Memory Access

        public byte[] Read32(uint addr, int length = 4)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_READ32 });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                Port.UsbWrite(MtkUtils.Pack32BE(addr));
                Port.UsbWrite(MtkUtils.Pack32BE((uint)length));

                ack = Port.RWord();
                if (ack != ACK) return null;

                var data = Port.UsbRead(length);
                Port.RWord(); // status
                return data;
            }
            catch (Exception ex)
            {
                Error($"Read32 0x{addr:X8} failed: {ex.Message}");
                return null;
            }
        }

        public uint? Read32Value(uint addr)
        {
            var data = Read32(addr, 4);
            if (data != null && data.Length >= 4)
                return MtkUtils.Unpack32BE(data);
            return null;
        }

        public byte[] Read32Batch(uint addr, int totalLength)
        {
            const int MAX_CHUNK = 0x1000;
            var result = new byte[totalLength];
            int offset = 0;

            while (offset < totalLength)
            {
                int chunkLen = Math.Min(MAX_CHUNK, totalLength - offset);
                var chunk = Read32(addr + (uint)offset, chunkLen);
                if (chunk == null) return null;
                Array.Copy(chunk, 0, result, offset, chunk.Length);
                offset += chunk.Length;
            }

            return result;
        }

        public bool Write32(uint addr, uint value)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_WRITE32 });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE(addr));
                Port.UsbWrite(MtkUtils.Pack32BE(4));
                Port.UsbWrite(MtkUtils.Pack32BE(value));

                ack = Port.RWord();
                if (ack != ACK) return false;

                Port.RWord(); // status
                return true;
            }
            catch (Exception ex)
            {
                Error($"Write32 0x{addr:X8} failed: {ex.Message}");
                return false;
            }
        }

        public bool Write32Batch(uint addr, byte[] data)
        {
            const int MAX_CHUNK = 0x1000;
            int offset = 0;

            while (offset < data.Length)
            {
                int chunkLen = Math.Min(MAX_CHUNK, data.Length - offset);

                try
                {
                    Port.UsbWrite(new byte[] { CMD_WRITE32 });
                    var ack = Port.RWord();
                    if (ack != ACK) return false;

                    Port.UsbWrite(MtkUtils.Pack32BE(addr + (uint)offset));
                    Port.UsbWrite(MtkUtils.Pack32BE((uint)chunkLen));

                    for (int i = 0; i < chunkLen; i += 4)
                    {
                        int wordLen = Math.Min(4, chunkLen - i);
                        var word = new byte[4];
                        Array.Copy(data, offset + i, word, 0, wordLen);
                        Port.UsbWrite(word);
                    }

                    ack = Port.RWord();
                    if (ack != ACK) return false;

                    Port.RWord(); // status
                }
                catch (Exception ex)
                {
                    Error($"Write32Batch 0x{addr + (uint)offset:X8} failed: {ex.Message}");
                    return false;
                }

                offset += chunkLen;
            }

            return true;
        }

        public byte[] Read16(uint addr, int length = 2)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_READ16 });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                Port.UsbWrite(MtkUtils.Pack32BE(addr));
                Port.UsbWrite(MtkUtils.Pack32BE((uint)length));

                ack = Port.RWord();
                if (ack != ACK) return null;

                var data = Port.UsbRead(length);
                Port.RWord(); // status
                return data;
            }
            catch (Exception ex)
            {
                Error($"Read16 0x{addr:X8} failed: {ex.Message}");
                return null;
            }
        }

        public bool Write16(uint addr, ushort value)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_WRITE16 });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE(addr));
                Port.UsbWrite(MtkUtils.Pack32BE(2));
                Port.UsbWrite(new byte[] { (byte)(value >> 8), (byte)(value & 0xFF) });

                ack = Port.RWord();
                if (ack != ACK) return false;

                Port.RWord(); // status
                return true;
            }
            catch (Exception ex)
            {
                Error($"Write16 0x{addr:X8} failed: {ex.Message}");
                return false;
            }
        }

        #endregion

        #region Memory Operations (Patch, Dump, Verify)

        public bool PatchMemory(uint addr, byte[] original, byte[] patched)
        {
            if (original != null && original.Length > 0)
            {
                var current = Read32(addr, original.Length);
                if (current == null) return false;

                bool match = true;
                for (int i = 0; i < original.Length && i < current.Length; i++)
                {
                    if (current[i] != original[i]) { match = false; break; }
                }
                if (!match)
                {
                    Warning($"Memory at 0x{addr:X8} doesn't match expected pattern");
                    return false;
                }
            }

            return Write32Batch(addr, patched);
        }

        public bool VerifyMemory(uint addr, byte[] expected)
        {
            var actual = Read32(addr, expected.Length);
            if (actual == null || actual.Length != expected.Length) return false;

            for (int i = 0; i < expected.Length; i++)
            {
                if (actual[i] != expected[i]) return false;
            }
            return true;
        }

        public byte[] DumpMemory(uint addr, int length, string label = null)
        {
            Info($"Dumping memory: 0x{addr:X8} len=0x{length:X} {label ?? ""}");
            var progress = new Progress(length, prefix: label ?? "Dump");
            var result = new byte[length];
            int offset = 0;
            const int chunkSize = 0x1000;

            while (offset < length)
            {
                int chunk = Math.Min(chunkSize, length - offset);
                var data = Read32(addr + (uint)offset, chunk);
                if (data == null)
                {
                    Error($"Dump failed at offset 0x{offset:X}");
                    return null;
                }
                Array.Copy(data, 0, result, offset, data.Length);
                offset += data.Length;
                progress.Update(data.Length);
            }

            return result;
        }

        #endregion

        #region DA Upload & Jump

        public bool SendDa(uint loadAddr, byte[] data, int sigLen = 0x100)
        {
            try
            {
                StateManager.SetDaStage(DaStage.Stage1Uploading);

                Port.UsbWrite(new byte[] { CMD_SEND_DA });
                var ack = Port.RWord();
                if (ack != ACK)
                {
                    Error("SendDA: command not acknowledged");
                    return false;
                }

                Port.UsbWrite(MtkUtils.Pack32BE(loadAddr));
                Port.UsbWrite(MtkUtils.Pack32BE((uint)data.Length));
                Port.UsbWrite(MtkUtils.Pack32BE((uint)sigLen));

                ack = Port.RWord();
                if (ack != ACK)
                {
                    Error("SendDA: parameters not acknowledged");
                    return false;
                }

                int chunkSize = 4096;
                var progress = new Progress(data.Length, prefix: "Sending DA");
                for (int offset = 0; offset < data.Length; offset += chunkSize)
                {
                    int len = Math.Min(chunkSize, data.Length - offset);
                    var chunk = new byte[len];
                    Array.Copy(data, offset, chunk, 0, len);
                    Port.UsbWrite(chunk);
                    progress.Update(len);
                }

                ushort checksum = MtkUtils.CalcChecksum(data);
                Port.UsbWrite(MtkUtils.Pack16LE(checksum));

                ack = Port.RWord();
                if (ack == ACK)
                {
                    Info("DA uploaded successfully");
                    return true;
                }

                Error($"SendDA: checksum NACK (expected ACK=0x{ACK:X4}, got 0x{ack:X4})");
                return false;
            }
            catch (Exception ex)
            {
                Error($"SendDA failed: {ex.Message}");
                StateManager.SetDaStage(DaStage.Error);
                return false;
            }
        }

        public bool SendDaWithRetry(uint loadAddr, byte[] data, int sigLen = 0x100, int maxRetries = 3)
        {
            return RecoveryMgr.ExecuteWithRetry(
                () =>
                {
                    if (!SendDa(loadAddr, data, sigLen))
                        throw new Exception("SendDA failed");
                },
                "SendDA",
                new RetryPolicy { MaxRetries = maxRetries, InitialDelayMs = 500 }
            );
        }

        public bool JumpDa(uint entryAddr)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_JUMP_DA });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE(entryAddr));
                ack = Port.RWord();

                if (ack == ACK)
                {
                    Info($"Jumped to DA at 0x{entryAddr:X8}");
                    StateManager.SetDaStage(DaStage.Stage1Running);
                    StateManager.TransitionTo(DeviceState.DaMode, "DA jump");
                    return true;
                }

                Error($"JumpDA: NACK at entry 0x{entryAddr:X8}");
                return false;
            }
            catch (Exception ex)
            {
                Error($"JumpDA failed: {ex.Message}");
                return false;
            }
        }

        #endregion

        #region Device Info Commands

        public byte[] GetMeId()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_ME_ID });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var lenData = Port.RdWord();
                if (lenData == null) return null;

                var meid = Port.UsbRead((int)lenData.Value);
                Port.RWord(); // status
                if (meid != null)
                {
                    Config.SetMeid(meid);
                    DeviceInfo.MeId = meid;
                    Debug($"ME ID: {MtkUtils.ToHex(meid)}");
                }
                return meid;
            }
            catch (Exception ex)
            {
                Error($"GetMeId failed: {ex.Message}");
                return null;
            }
        }

        public byte[] GetSocId()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_SOC_ID });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var lenData = Port.RdWord();
                if (lenData == null) return null;

                var socId = Port.UsbRead((int)lenData.Value);
                Port.RWord(); // status
                if (socId != null)
                {
                    Config.SetSocId(socId);
                    DeviceInfo.SocId = socId;
                    Debug($"SOC ID: {MtkUtils.ToHex(socId)}");
                }
                return socId;
            }
            catch (Exception ex)
            {
                Error($"GetSocId failed: {ex.Message}");
                return null;
            }
        }

        public byte[] GetBromLog()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_GET_BROM_LOG });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var lenData = Port.RdWord();
                if (lenData == null) return null;

                var log = Port.UsbRead((int)lenData.Value);
                if (log != null)
                    DeviceInfo.BromLog = log;
                return log;
            }
            catch (Exception ex)
            {
                Error($"GetBromLog failed: {ex.Message}");
                return null;
            }
        }

        public BromInfo GetFullDeviceInfo()
        {
            Info("Reading full device info...");
            GetHwCode();
            GetHwDict();
            GetBlVer();
            GetTargetConfig();
            GetMeId();

            if (Config.ReadSocId)
                GetSocId();

            DeviceInfo.IsBrom = IsBrom;
            Info($"Device: {DeviceInfo}");
            return DeviceInfo;
        }

        #endregion

        #region Security & Auth

        public bool SendAuth(byte[] authData)
        {
            if (authData == null || authData.Length == 0)
            {
                Warning("No auth data provided");
                return false;
            }

            try
            {
                Port.UsbWrite(new byte[] { CMD_SEND_CERT });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE((uint)authData.Length));
                Port.UsbWrite(authData);

                ack = Port.RWord();
                if (ack == ACK)
                {
                    Info("Auth data accepted");
                    return true;
                }

                Warning("Auth data rejected");
                return false;
            }
            catch (Exception ex)
            {
                Error($"SendAuth failed: {ex.Message}");
                return false;
            }
        }

        public bool SendCert(byte[] certData)
        {
            if (certData == null || certData.Length == 0)
            {
                Warning("No cert data provided");
                return false;
            }

            try
            {
                Port.UsbWrite(new byte[] { CMD_SEND_CERT });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE((uint)certData.Length));
                Port.UsbWrite(certData);

                ack = Port.RWord();
                if (ack == ACK)
                {
                    Info("Certificate accepted");
                    return true;
                }

                Warning("Certificate rejected");
                return false;
            }
            catch (Exception ex)
            {
                Error($"SendCert failed: {ex.Message}");
                return false;
            }
        }

        public byte[] SlaChallenge()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_SLA_CHALLENGE });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                var lenData = Port.RdWord();
                if (lenData == null || lenData.Value == 0) return null;

                var challenge = Port.UsbRead((int)lenData.Value);
                Debug($"SLA challenge: {MtkUtils.ToHex(challenge)}");
                return challenge;
            }
            catch (Exception ex)
            {
                Error($"SlaChallenge failed: {ex.Message}");
                return null;
            }
        }

        public bool SlaResponse(byte[] response)
        {
            if (response == null) return false;

            try
            {
                Port.UsbWrite(MtkUtils.Pack32BE((uint)response.Length));
                Port.UsbWrite(response);

                var ack = Port.RWord();
                if (ack == ACK)
                {
                    Info("SLA authentication successful");
                    return true;
                }

                Warning("SLA authentication failed");
                return false;
            }
            catch (Exception ex)
            {
                Error($"SlaResponse failed: {ex.Message}");
                return false;
            }
        }

        public bool SendEpp(byte[] eppData)
        {
            if (eppData == null) return false;

            try
            {
                Port.UsbWrite(new byte[] { CMD_SEND_EPP });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE((uint)eppData.Length));
                Port.UsbWrite(eppData);

                ack = Port.RWord();
                return ack == ACK;
            }
            catch (Exception ex)
            {
                Error($"SendEpp failed: {ex.Message}");
                return false;
            }
        }

        #endregion

        #region Watchdog & Power

        public void DisableWatchdog()
        {
            if (Config.ChipConfig.Watchdog.HasValue)
            {
                Write32(Config.ChipConfig.Watchdog.Value, 0x22000064);
                Info("Watchdog disabled");
            }
        }

        public void DisableWatchdogViaReg(uint watchdogAddr)
        {
            Write32(watchdogAddr, 0x22000064);
            Debug($"Watchdog disabled at 0x{watchdogAddr:X8}");
        }

        public void PowerDown()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_POWER_DOWN });
                StateManager.TransitionTo(DeviceState.Disconnected, "Power down");
            }
            catch { }
        }

        public void ColdReset()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_COLD_RESET });
                StateManager.TransitionTo(DeviceState.Rebooting, "Cold reset");
            }
            catch { }
        }

        #endregion

        #region PMIC / Power Management

        public bool PmicInit()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_I2C_INIT });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(new byte[] { CMD_PWR_INIT });
                ack = Port.RWord();
                return ack == ACK;
            }
            catch (Exception ex)
            {
                Error($"PmicInit failed: {ex.Message}");
                return false;
            }
        }

        public ushort? PmicRead16(ushort addr)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_PWR_READ16 });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                Port.UsbWrite(new byte[] { (byte)(addr >> 8), (byte)(addr & 0xFF) });
                var value = Port.RWord();
                Port.RWord(); // status
                return value;
            }
            catch (Exception ex)
            {
                Error($"PmicRead16 failed: {ex.Message}");
                return null;
            }
        }

        public bool PmicWrite16(ushort addr, ushort value)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_PWR_WRITE16 });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(new byte[] { (byte)(addr >> 8), (byte)(addr & 0xFF) });
                Port.UsbWrite(new byte[] { (byte)(value >> 8), (byte)(value & 0xFF) });

                ack = Port.RWord();
                return ack == ACK;
            }
            catch (Exception ex)
            {
                Error($"PmicWrite16 failed: {ex.Message}");
                return false;
            }
        }

        #endregion

        #region Checksum & Verification

        public ushort? Checksum16(uint addr, int length)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_CHECKSUM16 });
                var ack = Port.RWord();
                if (ack != ACK) return null;

                Port.UsbWrite(MtkUtils.Pack32BE(addr));
                Port.UsbWrite(MtkUtils.Pack32BE((uint)length));

                var checksum = Port.RWord();
                Port.RWord(); // status
                return checksum;
            }
            catch (Exception ex)
            {
                Error($"Checksum16 failed: {ex.Message}");
                return null;
            }
        }

        #endregion

        #region UART

        public bool EnableUartLog()
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_UART1_LOG_EN });
                var ack = Port.RWord();
                return ack == ACK;
            }
            catch (Exception ex)
            {
                Error($"EnableUartLog failed: {ex.Message}");
                return false;
            }
        }

        public bool SetBaudRate(uint baudRate)
        {
            try
            {
                Port.UsbWrite(new byte[] { CMD_UART1_SET_BAUDRATE });
                var ack = Port.RWord();
                if (ack != ACK) return false;

                Port.UsbWrite(MtkUtils.Pack32BE(baudRate));
                ack = Port.RWord();
                return ack == ACK;
            }
            catch (Exception ex)
            {
                Error($"SetBaudRate failed: {ex.Message}");
                return false;
            }
        }

        #endregion

        #region Recovery Helpers

        public bool Reconnect(int maxRetries = 3)
        {
            Info("Attempting reconnect...");
            for (int i = 0; i < maxRetries; i++)
            {
                StateManager.IncrementReconnect();

                Port.Cdc.Close(true);
                Thread.Sleep(500 * (i + 1));

                if (Port.Cdc.Connect())
                {
                    if (BromSync(10))
                    {
                        Info("Reconnected successfully");
                        StateManager.ResetReconnectCount();
                        return true;
                    }
                }
            }

            Error("Reconnect failed");
            StateManager.TransitionTo(DeviceState.Error, "Reconnect failed");
            return false;
        }

        public bool IsDeviceResponsive()
        {
            try
            {
                var hw = GetHwCode();
                return hw.HasValue;
            }
            catch
            {
                return false;
            }
        }

        #endregion
    }
}