public override void OnAction(IMFDeployForm form, MFDevice device) { if (form == null || device == null) return; _DBG.Engine engine = device.DbgEngine; engine.RebootDevice(Microsoft.SPOT.Debugger.Engine.RebootOption.EnterBootloader); device.ConnectToTinyBooter(); }
public override void OnAction(IMFDeployForm form, MFDevice device) { if (device.ConnectToTinyBooter()) { _WP.Commands.Monitor_FlashSectorMap.Reply reply = device.DbgEngine.GetFlashSectorMap(); if (reply != null) { foreach (_WP.Commands.Monitor_FlashSectorMap.FlashSectorData sector in reply.m_map) { if (0 != (sector.m_flags & _WP.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CODE) || 0 != (sector.m_flags & _WP.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CONFIG)) { device.DbgEngine.EraseMemory(sector.m_address, sector.m_size); } } } } }
public override void OnAction(IMFDeployForm form, MFDevice device) { _DBG.Engine engine = device.DbgEngine; if (device.ConnectToTinyBooter()) { // ExecuteMemory at address 0 performs an enumerate and execute, which // will clear the bootloader entry flag engine.ExecuteMemory(0); } else { form.DumpToOutput("Unable to connect to TinyBooter!"); } }
/// <summary> /// Updates the given public signature key /// </summary> /// <param name="newKeyInfo">Information that is used to update the key: including the new key, /// the new key signature (if the key has already been set), and the key index</param> /// <returns>true if successful false otherwise</returns> public bool UpdatePublicKey(PublicKeyUpdateInfo newKeyInfo) { bool fRequiresReboot = false; bool retVal = false; _DBG.PublicKeyIndex keyIndex; if (!m_init) { InitializeConfigData(); } if (!m_init) { throw new MFInvalidConfigurationSectorException(); } if (!m_fStaticCfgOK) { throw new MFInvalidConfigurationSectorException(); } if ((newKeyInfo.NewPublicKey.Length) != TINYBOOTER_KEY_CONFIG.c_RSAKeyLength) { throw new MFInvalidKeyLengthException(); } if (newKeyInfo.PublicKeyIndex == PublicKeyUpdateInfo.KeyIndex.DeploymentKey) { keyIndex = _DBG.PublicKeyIndex.DeploymentKey; fRequiresReboot = m_deployKeyLocked; } else { keyIndex = _DBG.PublicKeyIndex.FirmwareKey; fRequiresReboot = m_firmwareKeyLocked; } if (m_device.DbgEngine.ConnectionSource != Microsoft.SPOT.Debugger.ConnectionSource.TinyBooter) { if (!m_device.ConnectToTinyBooter()) { throw new MFDeviceNoResponseException(); } } if (m_device.DbgEngine.UpdateSignatureKey(keyIndex, newKeyInfo.NewPublicKeySignature, newKeyInfo.NewPublicKey, null)) { // if the key was previously set it requires an erase and a write which requires a reboot on some devices if (fRequiresReboot) { m_device.Reboot(true); } retVal = true; } PingConnectionType conn = m_device.Ping(); if (PingConnectionType.TinyBooter == conn) { m_device.Execute(c_EnumerateAndLaunchAddr); } return(retVal); }
// Initialize the internal structures. private void InitializeConfigData() { uint hal_config_block_size = 0; uint hal_config_static_size = 0; int index = 0; unsafe { hal_config_block_size = (uint)sizeof(HAL_CONFIG_BLOCK); hal_config_static_size = (uint)sizeof(HAL_CONFIGURATION_SECTOR) - hal_config_block_size; } m_cfg_sector.m_address = uint.MaxValue; m_cfg_sector.m_size = 0; _DBG.Engine engine = m_device.DbgEngine; if (!engine.TryToConnect(10, 100, true, Microsoft.SPOT.Debugger.ConnectionSource.Unknown)) { throw new MFDeviceNoResponseException(); } if (!m_device.UpgradeToSsl()) { if (m_device.DbgEngine.ConnectionSource != Microsoft.SPOT.Debugger.ConnectionSource.TinyBooter) { if (!m_device.ConnectToTinyBooter()) { throw new MFDeviceNoResponseException(); } } } _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.Reply reply = engine.GetFlashSectorMap(); // Find the config sector foreach (_DBG.WireProtocol.Commands.Monitor_FlashSectorMap.FlashSectorData fsd in reply.m_map) { const uint usage_mask = _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK; const uint usage_cfg = _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CONFIG; if (usage_cfg == (fsd.m_flags & usage_mask)) { m_cfg_sector = fsd; break; } } // read in the configuration data if the config sector was found if (m_cfg_sector.m_address != uint.MaxValue) { int hal_static_cfg_size = 0; unsafe { hal_static_cfg_size = sizeof(HAL_CONFIGURATION_SECTOR); } // read in the static portion of the config sector engine.ReadMemory(m_cfg_sector.m_address, (uint)hal_static_cfg_size, out m_all_cfg_data); m_StaticConfig = (HAL_CONFIGURATION_SECTOR)UnmarshalData(m_all_cfg_data, typeof(HAL_CONFIGURATION_SECTOR)); // uninitialized config sector, lets try to fix it if (m_StaticConfig.ConfigurationLength == 0xFFFFFFFF) { m_StaticConfig.ConfigurationLength = (uint)hal_static_cfg_size; m_StaticConfig.Version.Major = 3; m_StaticConfig.Version.Minor = 0; m_StaticConfig.Version.Extra = 0; m_StaticConfig.Version.TinyBooter = 4; } if (m_StaticConfig.ConfigurationLength >= m_cfg_sector.m_size) { throw new MFInvalidConfigurationSectorException(); } if (m_StaticConfig.Version.TinyBooter == 4) { m_fStaticCfgOK = true; } else { m_fStaticCfgOK = (m_StaticConfig.ConfigurationLength != hal_config_static_size); } // determine if we have a new or old version of the config (security keys are only supported in the new version) m_fValidConfig = (m_StaticConfig.Version.TinyBooter == CONFIG_SECTOR_VERSION.c_CurrentTinyBooterVersion); if (m_fStaticCfgOK) { m_firmwareKeyLocked = CheckKeyLocked(m_StaticConfig, true); m_deployKeyLocked = CheckKeyLocked(m_StaticConfig, false); } // move to the dynamic configuration section index = (int)m_StaticConfig.ConfigurationLength; m_lastCfgIndex = index; while (true) { byte[] data; // read the next configuration block engine.ReadMemory((uint)(m_cfg_sector.m_address + index), hal_config_block_size, out data); HAL_CONFIG_BLOCK cfg_header = (HAL_CONFIG_BLOCK)UnmarshalData(data, typeof(HAL_CONFIG_BLOCK)); // out of memory or last record if (cfg_header.Size > m_cfg_sector.m_size) { // last record or bogus entry m_lastCfgIndex = index; // save the configuration data for later use m_all_cfg_data = new byte[m_lastCfgIndex]; int idx = 0; byte[] tmp; while (idx < index) { int size = 512; if ((index - idx) < size) { size = index - idx; } engine.ReadMemory((uint)(m_cfg_sector.m_address + idx), (uint)size, out tmp); Array.Copy(tmp, 0, m_all_cfg_data, idx, tmp.Length); idx += size; } break; // no more configs } // move to the next configuration block if (cfg_header.Size + hal_config_block_size + index > m_cfg_sector.m_size) { // end of config sector break; } m_cfgHash[cfg_header.DriverNameString] = new ConfigIndexData(index, (int)(cfg_header.Size + hal_config_block_size)); index += (int)(cfg_header.Size + hal_config_block_size); while (0 != (index % 4)) { index++; } } } m_init = true; }