diff --git a/src/plugins/baremetal/CMakeLists.txt b/src/plugins/baremetal/CMakeLists.txt index 2d558e8d396..201cce9ab63 100644 --- a/src/plugins/baremetal/CMakeLists.txt +++ b/src/plugins/baremetal/CMakeLists.txt @@ -18,6 +18,7 @@ add_qtc_plugin(BareMetal debugservers/gdb/openocdgdbserverprovider.cpp debugservers/gdb/openocdgdbserverprovider.h debugservers/gdb/stlinkutilgdbserverprovider.cpp debugservers/gdb/stlinkutilgdbserverprovider.h debugservers/gdb/jlinkgdbserverprovider.cpp debugservers/gdb/jlinkgdbserverprovider.h + debugservers/gdb/eblinkgdbserverprovider.cpp debugservers/gdb/eblinkgdbserverprovider.h iarewparser.cpp iarewparser.h iarewtoolchain.cpp iarewtoolchain.h idebugserverprovider.cpp idebugserverprovider.h diff --git a/src/plugins/baremetal/baremetal.qbs b/src/plugins/baremetal/baremetal.qbs index 4813c2cb153..cfab57ca617 100644 --- a/src/plugins/baremetal/baremetal.qbs +++ b/src/plugins/baremetal/baremetal.qbs @@ -45,6 +45,7 @@ QtcPlugin { "openocdgdbserverprovider.cpp", "openocdgdbserverprovider.h", "stlinkutilgdbserverprovider.cpp", "stlinkutilgdbserverprovider.h", "jlinkgdbserverprovider.cpp", "jlinkgdbserverprovider.h", + "eblinkgdbserverprovider.cpp", "eblinkgdbserverprovider.h", ] } } diff --git a/src/plugins/baremetal/baremetalconstants.h b/src/plugins/baremetal/baremetalconstants.h index bde03c43f30..cc18ce13f04 100644 --- a/src/plugins/baremetal/baremetalconstants.h +++ b/src/plugins/baremetal/baremetalconstants.h @@ -40,6 +40,7 @@ const char DEBUG_SERVER_PROVIDERS_SETTINGS_ID[] = "EE.BareMetal.DebugServerProvi const char GDBSERVER_OPENOCD_PROVIDER_ID[] = "BareMetal.GdbServerProvider.OpenOcd"; const char GDBSERVER_JLINK_PROVIDER_ID[] = "BareMetal.GdbServerProvider.JLink"; const char GDBSERVER_STLINK_UTIL_PROVIDER_ID[] = "BareMetal.GdbServerProvider.STLinkUtil"; +const char GDBSERVER_EBLINK_PROVIDER_ID[] = "BareMetal.GdbServerProvider.EBlink"; // Toolchain types. const char IAREW_TOOLCHAIN_TYPEID[] = "BareMetal.ToolChain.Iar"; diff --git a/src/plugins/baremetal/debugserverprovidermanager.cpp b/src/plugins/baremetal/debugserverprovidermanager.cpp index 37c03d059e2..faa64922802 100644 --- a/src/plugins/baremetal/debugserverprovidermanager.cpp +++ b/src/plugins/baremetal/debugserverprovidermanager.cpp @@ -30,6 +30,7 @@ #include "debugservers/gdb/openocdgdbserverprovider.h" #include "debugservers/gdb/stlinkutilgdbserverprovider.h" #include "debugservers/gdb/jlinkgdbserverprovider.h" +#include "debugservers/gdb/eblinkgdbserverprovider.h" #include @@ -57,7 +58,8 @@ DebugServerProviderManager::DebugServerProviderManager() : m_configFile(Utils::FilePath::fromString(Core::ICore::userResourcePath() + fileNameKeyC)) , m_factories({new JLinkGdbServerProviderFactory, new OpenOcdGdbServerProviderFactory, - new StLinkUtilGdbServerProviderFactory}) + new StLinkUtilGdbServerProviderFactory, + new EBlinkGdbServerProviderFactory}) { m_instance = this; m_writer = new Utils::PersistentSettingsWriter( diff --git a/src/plugins/baremetal/debugservers/gdb/eblinkgdbserverprovider.cpp b/src/plugins/baremetal/debugservers/gdb/eblinkgdbserverprovider.cpp new file mode 100644 index 00000000000..d5763f70c62 --- /dev/null +++ b/src/plugins/baremetal/debugservers/gdb/eblinkgdbserverprovider.cpp @@ -0,0 +1,446 @@ +/**************************************************************************** +** +** Copyright (C) 2019 Andrey Sobol +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +****************************************************************************/ + +#include "eblinkgdbserverprovider.h" + +#include +#include + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using namespace Utils; + +namespace BareMetal { +namespace Internal { + +const char executableFileKeyC[] = "BareMetal.EBlinkGdbServerProvider.ExecutableFile"; +const char verboseLevelKeyC[] = "BareMetal.EBlinkGdbServerProvider.VerboseLevel"; +const char deviceScriptC[] = "BareMetal.EBlinkGdbServerProvider.DeviceScript"; +const char interfaceTypeC[] = "BareMetal.EBlinkGdbServerProvider.InterfaceType"; +const char interfaceResetOnConnectC[] = "BareMetal.EBlinkGdbServerProvider.interfaceResetOnConnect"; +const char interfaceSpeedC[] = "BareMetal.EBlinkGdbServerProvider.InterfaceSpeed"; +const char interfaceExplicidDeviceC[] = "BareMetal.EBlinkGdbServerProvider.InterfaceExplicidDevice"; +const char targetNameC[] = "BareMetal.EBlinkGdbServerProvider.TargetName"; +const char targetDisableStackC[] = "BareMetal.EBlinkGdbServerProvider.TargetDisableStack"; +const char gdbShutDownAfterDisconnectC[] = "BareMetal.EBlinkGdbServerProvider.GdbShutDownAfterDisconnect"; +const char gdbNotUseCacheC[] = "BareMetal.EBlinkGdbServerProvider.GdbNotUseCache"; + +// EBlinkGdbServerProvider + +EBlinkGdbServerProvider::EBlinkGdbServerProvider() + : GdbServerProvider(Constants::GDBSERVER_EBLINK_PROVIDER_ID) +{ + setInitCommands(defaultInitCommands()); + setResetCommands(defaultResetCommands()); + setChannel("127.0.0.1", 2331); + setSettingsKeyBase("BareMetal.EBlinkGdbServerProvider"); + setTypeDisplayName(EBlinkGdbServerProviderFactory::tr("EBlink")); +} + +EBlinkGdbServerProvider::EBlinkGdbServerProvider( + const EBlinkGdbServerProvider &other) + : GdbServerProvider(other) + , m_executableFile(other.m_executableFile) + , m_verboseLevel(0) + , m_interfaceType(other.m_interfaceType) + , m_deviceScript(other.m_deviceScript) + , m_interfaceResetOnConnect(other.m_interfaceResetOnConnect) + , m_interfaceSpeed(other.m_interfaceSpeed) + , m_interfaceExplicidDevice(other.m_interfaceExplicidDevice) + , m_targetName(other.m_targetName) + , m_targetDisableStack(other.m_targetDisableStack) + , m_gdbShutDownAfterDisconnect(other.m_gdbShutDownAfterDisconnect) + , m_gdbNotUseCache(other.m_gdbNotUseCache){ +} + +QString EBlinkGdbServerProvider::defaultInitCommands() +{ + return {"monitor reset halt\n" + "load\n" + "monitor reset halt\n" + "break main\n"}; +} + +QString EBlinkGdbServerProvider::defaultResetCommands() +{ + return {"monitor reset halt\n"}; +} + +QString EBlinkGdbServerProvider::scriptFileWoExt() const +{ + // Server starts only without extension in scriptname + return m_deviceScript.toFileInfo().absolutePath() + + QDir::separator() + m_deviceScript.toFileInfo().baseName(); +} + +QString EBlinkGdbServerProvider::channelString() const +{ + switch (startupMode()) { + case StartupOnNetwork: + // Just return as "host:port" form. + return GdbServerProvider::channelString(); + default: + return {}; + } +} + +CommandLine EBlinkGdbServerProvider::command() const +{ + CommandLine cmd{m_executableFile, {}}; + QStringList interFaceTypeStrings = {"swd", "jtag"}; + + // Obligatorily -I + cmd.addArg("-I"); + QString interfaceArgs("stlink,%1,speed=%2"); + interfaceArgs = interfaceArgs.arg(interFaceTypeStrings.at(m_interfaceType)) + .arg(QString::number(m_interfaceSpeed)); + if (!m_interfaceResetOnConnect) + interfaceArgs.append(",dr"); + if (!m_interfaceExplicidDevice.trimmed().isEmpty()) + interfaceArgs.append(",device=" + m_interfaceExplicidDevice.trimmed()); + cmd.addArg(interfaceArgs); + + // Obligatorily -D + cmd.addArg("-D"); + cmd.addArg(scriptFileWoExt()); + + // Obligatorily -G + cmd.addArg("-G"); + QString gdbArgs("port=%1,address=%2"); + gdbArgs = gdbArgs.arg(QString::number(channel().port())) + .arg(channel().host()); + if (m_gdbNotUseCache) + gdbArgs.append(",nc"); + if (m_gdbShutDownAfterDisconnect) + gdbArgs.append(",S"); + cmd.addArg(gdbArgs); + + cmd.addArg("-T"); + QString targetArgs(m_targetName.trimmed()); + if (m_targetDisableStack) + targetArgs.append(",nu"); + cmd.addArg(targetArgs); + + cmd.addArg("-v"); + cmd.addArg(QString::number(m_verboseLevel)); + + if (HostOsInfo::isWindowsHost()) + cmd.addArg("-g"); // no gui + + return cmd; +} + +QSet +EBlinkGdbServerProvider::supportedStartupModes() const +{ + return {StartupOnNetwork}; +} + +bool EBlinkGdbServerProvider::isValid() const +{ + if (!GdbServerProvider::isValid()) + return false; + + switch (startupMode()) { + case StartupOnNetwork: + return !channel().host().isEmpty() && !m_executableFile.isEmpty() + && !m_deviceScript.isEmpty(); + default: + return false; + } +} + +GdbServerProvider *EBlinkGdbServerProvider::clone() const +{ + return new EBlinkGdbServerProvider(*this); +} + +QVariantMap EBlinkGdbServerProvider::toMap() const +{ + QVariantMap data = GdbServerProvider::toMap(); + data.insert(executableFileKeyC, m_executableFile.toVariant()); + data.insert(verboseLevelKeyC, m_verboseLevel); + data.insert(interfaceTypeC, m_interfaceType); + data.insert(deviceScriptC, m_deviceScript.toVariant()); + data.insert(interfaceResetOnConnectC, m_interfaceResetOnConnect); + data.insert(interfaceSpeedC, m_interfaceSpeed); + data.insert(interfaceExplicidDeviceC, m_interfaceExplicidDevice); + data.insert(targetNameC, m_targetName); + data.insert(targetDisableStackC, m_targetDisableStack); + data.insert(gdbShutDownAfterDisconnectC, m_gdbShutDownAfterDisconnect); + data.insert(gdbNotUseCacheC, m_gdbNotUseCache); + + return data; +} + +bool EBlinkGdbServerProvider::fromMap(const QVariantMap &data) +{ + if (!GdbServerProvider::fromMap(data)) + return false; + + m_executableFile = FilePath::fromVariant(data.value(executableFileKeyC)); + m_verboseLevel = data.value(verboseLevelKeyC).toInt(); + m_interfaceResetOnConnect = data.value(interfaceResetOnConnectC).toBool(); + m_interfaceType = static_cast( + data.value(interfaceTypeC).toInt()); + m_deviceScript = FilePath::fromVariant(data.value(deviceScriptC)); + m_interfaceResetOnConnect = data.value(interfaceResetOnConnectC).toBool(); + m_interfaceSpeed = data.value(interfaceSpeedC).toInt(); + m_interfaceExplicidDevice = data.value(interfaceExplicidDeviceC).toString(); + m_targetName = data.value(targetNameC).toString(); + m_targetDisableStack = data.value(targetDisableStackC).toBool(); + m_gdbShutDownAfterDisconnect = data.value(gdbShutDownAfterDisconnectC).toBool(); + m_gdbNotUseCache = data.value(gdbNotUseCacheC).toBool(); + + return true; +} + +bool EBlinkGdbServerProvider::operator==(const IDebugServerProvider &other) const +{ + if (!GdbServerProvider::operator==(other)) + return false; + + const auto p = static_cast(&other); + return m_executableFile == p->m_executableFile + && m_verboseLevel == p->m_verboseLevel + && m_interfaceType == p->m_interfaceType + && m_deviceScript == p->m_deviceScript + && m_interfaceResetOnConnect == p->m_interfaceResetOnConnect + && m_interfaceSpeed == p->m_interfaceSpeed + && m_interfaceExplicidDevice == p->m_interfaceExplicidDevice + && m_targetName == p->m_targetName + && m_targetDisableStack == p->m_targetDisableStack + && m_gdbShutDownAfterDisconnect == p->m_gdbShutDownAfterDisconnect + && m_gdbNotUseCache == p->m_gdbNotUseCache; +} + +GdbServerProviderConfigWidget *EBlinkGdbServerProvider::configurationWidget() +{ + return new EBlinkGdbServerProviderConfigWidget(this); +} + +// EBlinkGdbServerProviderFactory + +EBlinkGdbServerProviderFactory::EBlinkGdbServerProviderFactory() +{ + setId(Constants::GDBSERVER_EBLINK_PROVIDER_ID); + setDisplayName(tr("EBlink")); +} + +GdbServerProvider *EBlinkGdbServerProviderFactory::create() +{ + return new EBlinkGdbServerProvider; +} + +bool EBlinkGdbServerProviderFactory::canRestore(const QVariantMap &data) const +{ + const QString id = idFromMap(data); + return id.startsWith(Constants::GDBSERVER_EBLINK_PROVIDER_ID + QLatin1Char(':')); +} + +GdbServerProvider *EBlinkGdbServerProviderFactory::restore(const QVariantMap &data) +{ + const auto p = new EBlinkGdbServerProvider; + const auto updated = data; + + if (p->fromMap(updated)) + return p; + delete p; + return nullptr; +} + +// EBlinkGdbServerProviderConfigWidget + +EBlinkGdbServerProviderConfigWidget::EBlinkGdbServerProviderConfigWidget( + EBlinkGdbServerProvider *p) + : GdbServerProviderConfigWidget(p) +{ + Q_ASSERT(p); + + m_gdbHostWidget = new HostWidget(this); + m_mainLayout->addRow(tr("Host:"), m_gdbHostWidget); + + m_executableFileChooser = new PathChooser; + m_executableFileChooser->setExpectedKind(Utils::PathChooser::ExistingCommand); + m_mainLayout->addRow(tr("Executable file:"), m_executableFileChooser); + + m_scriptFileChooser = new Utils::PathChooser; + m_scriptFileChooser->setExpectedKind(Utils::PathChooser::File); + m_scriptFileChooser->setPromptDialogFilter("*.script"); + m_mainLayout->addRow(tr("Script file:"), m_scriptFileChooser); + + m_verboseLevelSpinBox = new QSpinBox; + m_verboseLevelSpinBox->setRange(0, 7); + m_verboseLevelSpinBox->setMaximumWidth(80); + m_verboseLevelSpinBox->setToolTip(tr("Specify the verbosity level (0..7).")); + m_mainLayout->addRow(tr("Verbosity level:"), m_verboseLevelSpinBox); + + m_resetOnConnectCheckBox = new QCheckBox; + m_resetOnConnectCheckBox->setToolTip(tr("Connect under reset (hotplug).")); + m_mainLayout->addRow(tr("Connect under reset:"), m_resetOnConnectCheckBox); + + m_interfaceTypeComboBox = new QComboBox; + m_interfaceTypeComboBox->setToolTip(tr("Interface type. SWD or JTAG")); + m_mainLayout->addRow(tr("Type:"), m_interfaceTypeComboBox); + + m_interfaceSpeedSpinBox = new QSpinBox; + m_interfaceSpeedSpinBox->setRange(120, 8000); + m_interfaceSpeedSpinBox->setMaximumWidth(120); + m_interfaceSpeedSpinBox->setToolTip(tr("Specify speed of Interface (120-8000)kHz")); + m_mainLayout->addRow(tr("Speed:"), m_interfaceSpeedSpinBox); + + m_notUseCacheCheckBox = new QCheckBox; + m_notUseCacheCheckBox->setToolTip(tr("Don't use EBlink flash cache")); + m_mainLayout->addRow(tr("Disable cache:"), m_notUseCacheCheckBox); + + m_shutDownAfterDisconnectCheckBox = new QCheckBox; + m_shutDownAfterDisconnectCheckBox->setEnabled(false); + m_shutDownAfterDisconnectCheckBox->setToolTip(tr("Shutdown EBlink server after disconnect")); + m_mainLayout->addRow(tr("Auto shutdown:"), m_shutDownAfterDisconnectCheckBox); + + m_initCommandsTextEdit = new QPlainTextEdit(this); + m_initCommandsTextEdit->setToolTip(defaultInitCommandsTooltip()); + m_mainLayout->addRow(tr("Init commands:"), m_initCommandsTextEdit); + m_resetCommandsTextEdit = new QPlainTextEdit(this); + m_resetCommandsTextEdit->setToolTip(defaultResetCommandsTooltip()); + m_mainLayout->addRow(tr("Reset commands:"), m_resetCommandsTextEdit); + + populateInterfaceTypes(); + addErrorLabel(); + setFromProvider(); + + const auto chooser = new Core::VariableChooser(this); + chooser->addSupportedWidget(m_initCommandsTextEdit); + chooser->addSupportedWidget(m_resetCommandsTextEdit); + + connect(m_gdbHostWidget, &HostWidget::dataChanged, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_executableFileChooser, &Utils::PathChooser::rawPathChanged, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_scriptFileChooser, &Utils::PathChooser::rawPathChanged, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_verboseLevelSpinBox, + QOverload::of(&QSpinBox::valueChanged), + this, &GdbServerProviderConfigWidget::dirty); + connect(m_interfaceSpeedSpinBox, + QOverload::of(&QSpinBox::valueChanged), + this, &GdbServerProviderConfigWidget::dirty); + connect(m_notUseCacheCheckBox, &QAbstractButton::clicked, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_shutDownAfterDisconnectCheckBox, &QAbstractButton::clicked, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_resetOnConnectCheckBox, &QAbstractButton::clicked, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_interfaceTypeComboBox, + QOverload::of(&QComboBox::currentIndexChanged), + this, &GdbServerProviderConfigWidget::dirty); + connect(m_initCommandsTextEdit, &QPlainTextEdit::textChanged, + this, &GdbServerProviderConfigWidget::dirty); + connect(m_resetCommandsTextEdit, &QPlainTextEdit::textChanged, + this, &GdbServerProviderConfigWidget::dirty); +} + +EBlinkGdbServerProvider::InterfaceType +EBlinkGdbServerProviderConfigWidget::interfaceTypeToWidget(int idx) const +{ + m_interfaceTypeComboBox->setCurrentIndex(idx); + return interfaceTypeFromWidget(); +} + +EBlinkGdbServerProvider::InterfaceType +EBlinkGdbServerProviderConfigWidget::interfaceTypeFromWidget() const +{ + return static_cast( + m_interfaceTypeComboBox->currentIndex()); +} + +void EBlinkGdbServerProviderConfigWidget::populateInterfaceTypes() +{ + m_interfaceTypeComboBox->insertItem(EBlinkGdbServerProvider::SWD, tr("SWD"), + EBlinkGdbServerProvider::SWD); + m_interfaceTypeComboBox->insertItem(EBlinkGdbServerProvider::JTAG, tr("JTAG"), + EBlinkGdbServerProvider::JTAG); +} + +void EBlinkGdbServerProviderConfigWidget::setFromProvider() +{ + const auto p = static_cast(m_provider); + Q_ASSERT(p); + + m_gdbHostWidget->setChannel(p->channel()); + m_executableFileChooser->setFileName(p->m_executableFile); + m_verboseLevelSpinBox->setValue(p->m_verboseLevel); + m_scriptFileChooser->setFileName(p->m_deviceScript); + m_interfaceTypeComboBox->setCurrentIndex(p->m_interfaceType); + m_resetOnConnectCheckBox->setChecked(p->m_interfaceResetOnConnect); + m_interfaceSpeedSpinBox->setValue(p->m_interfaceSpeed); + m_shutDownAfterDisconnectCheckBox->setChecked(p->m_gdbShutDownAfterDisconnect); + m_notUseCacheCheckBox->setChecked(p->m_gdbNotUseCache); + + m_initCommandsTextEdit->setPlainText(p->initCommands()); + m_resetCommandsTextEdit->setPlainText(p->resetCommands()); +} + + +void EBlinkGdbServerProviderConfigWidget::apply() +{ + const auto p = static_cast(m_provider); + Q_ASSERT(p); + + p->setChannel(m_gdbHostWidget->channel()); + p->m_executableFile = m_executableFileChooser->fileName(); + p->m_verboseLevel = m_verboseLevelSpinBox->value(); + p->m_deviceScript = m_scriptFileChooser->fileName(); + p->m_interfaceType = interfaceTypeFromWidget(); + p->m_interfaceResetOnConnect = m_resetOnConnectCheckBox->isChecked(); + p->m_interfaceSpeed = m_interfaceSpeedSpinBox->value(); + p->m_gdbShutDownAfterDisconnect = m_shutDownAfterDisconnectCheckBox->isChecked(); + p->m_gdbNotUseCache = m_notUseCacheCheckBox->isChecked(); + + p->setInitCommands(m_initCommandsTextEdit->toPlainText()); + p->setResetCommands(m_resetCommandsTextEdit->toPlainText()); + GdbServerProviderConfigWidget::apply(); +} + +void EBlinkGdbServerProviderConfigWidget::discard() +{ + setFromProvider(); + GdbServerProviderConfigWidget::discard(); +} + +} // namespace Internal +} // namespace BareMetal diff --git a/src/plugins/baremetal/debugservers/gdb/eblinkgdbserverprovider.h b/src/plugins/baremetal/debugservers/gdb/eblinkgdbserverprovider.h new file mode 100644 index 00000000000..7d01a237ebb --- /dev/null +++ b/src/plugins/baremetal/debugservers/gdb/eblinkgdbserverprovider.h @@ -0,0 +1,141 @@ +/**************************************************************************** +** +** Copyright (C) 2019 Andrey Sobol +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +****************************************************************************/ + +#pragma once + +#include "gdbserverprovider.h" + +QT_BEGIN_NAMESPACE +class QCheckBox; +class QPlainTextEdit; +QT_END_NAMESPACE + +namespace Utils { class PathChooser; } + +namespace BareMetal { +namespace Internal { + +// EBlinkGdbServerProvider + +class EBlinkGdbServerProvider final : public GdbServerProvider +{ +public: + enum InterfaceType { SWD, JTAG }; + + QVariantMap toMap() const final; + bool fromMap(const QVariantMap &data) final; + + bool operator==(const IDebugServerProvider &other) const final; + + GdbServerProviderConfigWidget *configurationWidget() final; + GdbServerProvider *clone() const final; + + QString channelString() const final; + Utils::CommandLine command() const final; + + QSet supportedStartupModes() const final; + bool isValid() const final; + +private: + explicit EBlinkGdbServerProvider(); + explicit EBlinkGdbServerProvider(const EBlinkGdbServerProvider &); + + static QString defaultInitCommands(); + static QString defaultResetCommands(); + + Utils::FilePath m_executableFile = + Utils::FilePath::fromString("eblink"); // server execute filename + int m_verboseLevel = 0; // verbose <0..7> Specify generally verbose logging + InterfaceType m_interfaceType = SWD; // -I stlink ;swd(default) jtag + Utils::FilePath m_deviceScript = + Utils::FilePath::fromString("stm32-auto.script"); // -D