werunplugged/unplugged-vendor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ebc759d833
unplugged-vendor/system/bt/mediatek/config/mtk_stack_config.cc

526 lines
18 KiB
C++
Raw Blame History

/* Copyright Statement:
* *
* * This software/firmware and related documentation ("MediaTek Software") are
* * protected under relevant copyright laws. The information contained herein
* * is confidential and proprietary to MediaTek Inc. and/or its licensors.
* * Without the prior written permission of MediaTek inc. and/or its licensors,
* * any reproduction, modification, use or disclosure of MediaTek Software,
* * and information contained herein, in whole or in part, shall be strictly prohibited.
* *
* * MediaTek Inc. (C) 2016. All rights reserved.
* *
* * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
* * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
* * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
* * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
* * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
* * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
* * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
* * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
* * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
* * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
* * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
* *
* * The following software/firmware and/or related documentation ("MediaTek Software")
* * have been modified by MediaTek Inc. All revisions are subject to any receiver's
* * applicable license agreements with MediaTek Inc.
* */
#if defined(MTK_STACK_CONFIG_LOG) && (MTK_STACK_CONFIG_LOG == TRUE)
#define LOG_TAG "bt_mtk_stack_config"
#include "mtk_stack_config.h"
#include <stdint.h>
#include <unistd.h> // access()
#include <algorithm>
#include <iomanip>
#include <iterator>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include <base/logging.h>
#include <base/memory/singleton.h>
#include "hci_internals.h"
#include "log_mode.h"
#include "mtk_util.h"
#include "osi/include/list.h"
#include "osi/include/log.h"
#include "osi/include/properties.h"
#include "snoop_log_config.h"
namespace vendor {
namespace mediatek {
namespace bt {
namespace stack {
static const std::string kPath("/etc/bluetooth/");
static const std::string kStackConf("mtk_bt_stack.conf");
static const std::string kControllerConf("mtk_bt_fw.conf");
class StackConfigParser {
public:
StackConfigParser() : kMtkBtStackConf_(kPath + kStackConf) {
stack_trace_["TRC_BTM"] = 0;
stack_trace_["TRC_HCI"] = 0;
stack_trace_["TRC_L2CAP"] = 0;
stack_trace_["TRC_RFCOMM"] = 0;
stack_trace_["TRC_OBEX"] = 0;
stack_trace_["TRC_AVCT"] = 0;
stack_trace_["TRC_AVDT"] = 0;
stack_trace_["TRC_AVRC"] = 0;
stack_trace_["TRC_AVDT_SCB"] = 0;
stack_trace_["TRC_AVDT_CCB"] = 0;
stack_trace_["TRC_A2D"] = 0;
stack_trace_["TRC_SDP"] = 0;
stack_trace_["TRC_GATT"] = 0;
stack_trace_["TRC_SMP"] = 0;
stack_trace_["TRC_BTAPP"] = 0;
stack_trace_["TRC_BTIF"] = 0;
stack_trace_["TRC_GAP"] = 0;
stack_trace_["TRC_BNEP"] = 0;
stack_trace_["TRC_PAN"] = 0;
stack_trace_["TRC_HID_HOST"] = 0;
stack_trace_["TRC_HID_DEV"] = 0;
conf_str_ext_["LoggingV"] = "--v=0";
conf_str_ext_["LoggingVModule"] =
"--vmodule=*/btm/*=1,btm_ble_multi*=2,btif_*=1";
conf_int_ext_[RECYCLE_RATE_KEY] = 10;
conf_int_ext_[PACKETS_CACHE_UPPER_LIMIT_KEY] = 10;
conf_int_ext_[MAX_LOG_SIZE_PER_FILE_KEY] = 20;
}
std::unique_ptr<config_t> OverwriteConfig(std::unique_ptr<config_t> config) {
CHECK(config != nullptr);
std::unique_ptr<config_t> mtk_config = config_new(kMtkBtStackConf_.c_str());
if (!mtk_config) {
LOG_ERROR("%s file %s not found!", __func__,
kMtkBtStackConf_.c_str());
} else {
for (auto& it : stack_trace_) {
if (config_has_key(*config, CONFIG_DEFAULT_SECTION, it.first) &&
config_has_key(*mtk_config, CONFIG_DEFAULT_SECTION, it.first)) {
it.second = config_get_int(*mtk_config, CONFIG_DEFAULT_SECTION,
it.first, it.second);
config_set_int(config.get(), CONFIG_DEFAULT_SECTION, it.first,
it.second);
LOG_INFO("%s Overwrite: %s = %d", __func__, it.first.c_str(),
it.second);
}
}
AppendStrConfig(config.get(), mtk_config.get());
AppendIntConfig(config.get(), mtk_config.get());
}
return config;
}
private:
void AppendStrConfig(config_t* config, config_t* mtk_config) {
for (auto& it : conf_str_ext_) {
if (config_has_key(*mtk_config, CONFIG_DEFAULT_SECTION,
it.first)) {
it.second = *config_get_string(*mtk_config, CONFIG_DEFAULT_SECTION,
it.first, &(it.second));
config_set_string(config, CONFIG_DEFAULT_SECTION, it.first,
it.second);
LOG_INFO("%s Append: %s = %s", __func__, it.first.c_str(),
it.second.c_str());
}
}
}
void AppendIntConfig(config_t* config, config_t* mtk_config) {
for (auto& it : conf_int_ext_) {
if (config_has_key(*mtk_config, CONFIG_DEFAULT_SECTION,
it.first.c_str())) {
it.second = config_get_int(*mtk_config, CONFIG_DEFAULT_SECTION,
it.first, it.second);
config_set_int(config, CONFIG_DEFAULT_SECTION, it.first,
it.second);
LOG_INFO("%s Append: %s = %d", __func__, it.first.c_str(),
it.second);
}
}
}
const std::string kMtkBtStackConf_;
std::map<std::string, int> stack_trace_;
std::map<std::string, std::string> conf_str_ext_;
std::map<std::string, int> conf_int_ext_;
};
class ControllerLogModeParser {
public:
explicit ControllerLogModeParser(TraceLevel level) : trace_level_(level) {}
virtual ~ControllerLogModeParser() {}
virtual std::vector<uint8_t> GetEnableCommandPacket() const = 0;
virtual std::vector<uint8_t> GetFilterommandPacket() const = 0;
protected:
TraceLevel GetTraceLevel() const { return trace_level_; }
private:
TraceLevel trace_level_;
};
class ControllerLogModeDefaultParser : public ControllerLogModeParser {
public:
explicit ControllerLogModeDefaultParser(TraceLevel level)
: ControllerLogModeParser(level) {
InitEnableCmdPackets();
InitFilterCmdPackets();
}
virtual ~ControllerLogModeDefaultParser() {}
std::vector<uint8_t> GetEnableCommandPacket() const override {
return enable_cmd_packets_[GetTraceLevel()];
}
std::vector<uint8_t> GetFilterommandPacket() const override {
return filter_cmd_packets_[GetTraceLevel()];
}
private:
void InitEnableCmdPackets() {
// kDefault
enable_cmd_packets_.push_back(std::vector<uint8_t>{0xBE, 0xFC, 0x01, 0x00});
// kSqc
enable_cmd_packets_.push_back(std::vector<uint8_t>{0xBE, 0xFC, 0x01, 0x05});
// kDebug
enable_cmd_packets_.push_back(std::vector<uint8_t>{0xBE, 0xFC, 0x01, 0x05});
}
void InitFilterCmdPackets() {
// kDefault
filter_cmd_packets_.push_back(std::vector<uint8_t>{
// C2 FC5F filter
0x5F, 0xFC, 0x2A, 0x50, 0x01, 0x09, 0x00, 0x00, 0x00,
// C201 SYS
0x00, 0x00, 0x00, 0x00,
// C202 TIM
0x00, 0x00, 0x00, 0x00,
// C203 PKV
0x00, 0x00, 0x00, 0x00,
// C204 LC
0x00, 0x00, 0x00, 0x00,
// C205 LL
0x00, 0x00, 0x00, 0x00,
// C206 ANT
0x00, 0x00, 0x00, 0x00,
// C207 LMP
0x00, 0x00, 0x00, 0x00,
// C208 CO
0x00, 0x00, 0x00, 0x00,
// C209 VOICE
0x00, 0x00, 0x00, 0x00});
// kSqc
filter_cmd_packets_.push_back(std::vector<uint8_t>{
// C2 FC5F filter
0x5F, 0xFC, 0x2A, 0x50, 0x01, 0x09, 0x00, 0x00, 0x00,
// C201 SYS
0x00, 0x00, 0x00, 0x88,
// C202 TIM
0x00, 0x00, 0x00, 0x00,
// C203 PKV
0x00, 0x00, 0x00, 0x00,
// C204 LC
0x00, 0x00, 0x00, 0x00,
// C205 LL
0x00, 0x00, 0x00, 0x00,
// C206 ANT
0x00, 0x00, 0x00, 0x00,
// C207 LMP
0x00, 0x00, 0x00, 0x00,
// C208 CO
0x00, 0x00, 0x00, 0x00,
// C209 VOICE
0x00, 0x00, 0x00, 0x00});
// kDebug
filter_cmd_packets_.push_back(std::vector<uint8_t>{
// C2 FC5F filter
0x5F, 0xFC, 0x2A, 0x50, 0x01, 0x09, 0x00, 0x00, 0x00,
// C201 SYS
0x00, 0x00, 0x00, 0xCC,
// C202 TIM
0x00, 0x00, 0x00, 0x00,
// C203 PKV
0x00, 0x00, 0x00, 0x00,
// C204 LC
0x1F, 0xF0, 0x00, 0x00,
// C205 LL
0x07, 0x27, 0x06, 0x00,
// C206 ANT
0x00, 0x00, 0x00, 0x00,
// C207 LMP
0x03, 0x00, 0x03, 0x00,
// C208 CO
0x03, 0x08, 0x00, 0x00,
// C209 VOICE
0x00, 0x00, 0x00, 0x00});
}
std::vector<std::vector<uint8_t> > enable_cmd_packets_;
std::vector<std::vector<uint8_t> > filter_cmd_packets_;
};
class ControllerLogModeConfParser : public ControllerLogModeParser {
public:
explicit ControllerLogModeConfParser(TraceLevel level)
: ControllerLogModeParser(level), kSerialTypeLen_(1) {
InitSections();
InitConfig();
}
virtual ~ControllerLogModeConfParser() {}
std::vector<uint8_t> GetEnableCommandPacket() const override {
return LoadEnableCommandData(GetTraceLevel());
}
std::vector<uint8_t> GetFilterommandPacket() const override {
return LoadFilterCommandData(GetTraceLevel());
}
private:
void InitSections() {
sections_[kDefault] = std::string("MtkBtFwLogOff");
sections_[kSqc] = std::string("MtkBtFwLogSqc");
sections_[kDebug] = std::string("MtkBtFwLogDebug");
}
void InitConfig() {
config_ = config_new(std::string(kPath + kControllerConf).c_str());
CHECK(config_ != nullptr);
}
std::vector<uint8_t> LoadEnableCommandData(TraceLevel level) const {
const std::string kEnableCmdKey("C1");
std::string cmd_temp(config_get_string(*config_, sections_.at(level),
kEnableCmdKey, NULL)->c_str());
std::vector<uint8_t> cmd_data = ConvertCmdStringToData(cmd_temp);
std::vector<uint8_t> enable_cmd;
// Skip to add serial type bit
std::copy(cmd_data.begin() + kSerialTypeLen_, cmd_data.end(),
std::back_inserter(enable_cmd));
return enable_cmd;
}
std::vector<uint8_t> LoadFilterCommandData(TraceLevel level) const {
const std::string kFilterCmdKey("C2");
constexpr int kC2NumOfRows(10);
std::string cmd_temp(config_get_string(*config_, sections_.at(level),
kFilterCmdKey, NULL)->c_str());
for (int i(1); i < kC2NumOfRows; i++) {
std::stringstream ss;
ss << kFilterCmdKey << std::setfill('0') << std::setw(2) << i;
std::string cmdx(config_get_string(*config_, sections_.at(level),
ss.str(), NULL)->c_str());
cmd_temp += std::string(" ") + cmdx;
}
std::vector<uint8_t> cmd_data = ConvertCmdStringToData(cmd_temp);
std::vector<uint8_t> filter_cmd;
// Skip to add serial type bit
std::copy(cmd_data.begin() + kSerialTypeLen_, cmd_data.end(),
std::back_inserter(filter_cmd));
return filter_cmd;
}
static uint8_t StringToUInt8(const std::string& str) {
return static_cast<uint8_t>(std::stoi(str, nullptr, 16));
}
std::vector<uint8_t> ConvertCmdStringToData(const std::string& cmd) const {
std::istringstream iss(cmd);
std::vector<std::string> tokens{std::istream_iterator<std::string>{iss},
std::istream_iterator<std::string>{}};
std::vector<uint8_t> data(tokens.size(), 0);
std::transform(tokens.begin(), tokens.end(), data.begin(), StringToUInt8);
return data;
}
const int kSerialTypeLen_;
std::unique_ptr<config_t> config_;
std::map<TraceLevel, std::string> sections_;
};
class ControllerLogModeFactory : public Singleton<ControllerLogModeFactory> {
public:
std::shared_ptr<ControllerLogModeParser> Create(TraceLevel level);
private:
friend class Singleton<ControllerLogModeFactory>;
};
std::shared_ptr<ControllerLogModeParser> ControllerLogModeFactory::Create(
TraceLevel level) {
if (access(std::string(kPath + kControllerConf).c_str(), F_OK)) {
return std::shared_ptr<ControllerLogModeParser>(
new ControllerLogModeDefaultParser(level));
} else {
return std::shared_ptr<ControllerLogModeParser>(
new ControllerLogModeConfParser(level));
}
}
class BTStackLogConfig : public Singleton<BTStackLogConfig> {
public:
bool IsNeedOverWriteConfig() const {
TraceLevel level = LogLevel::GetInstance()->QueryTraceLevel(kStack);
return (kDebug == level) || (kSqc == level);
}
bool IsBTSnoopEnabled() const {
// AOSP default
return isPropertySet(kBtSnoopEnableProperty) &&
IsBTSnoopFeatureEnabled(kBtSnoopEnableProperty);
}
bool IsInboundDataMonitorEnabled() const {
if (isPropertySet(kBTForceTurnOffInboundDataMonitorProperty_.c_str())) {
return !IsBTSnoopFeatureEnabled(
kBTForceTurnOffInboundDataMonitorProperty_.c_str());
} else {
return IsBTSnoopEnabled();
}
}
bool IsConnSYSDedicatedLogFeatureEnabled() const {
constexpr char kFeatureKey[] = "ro.vendor.connsys.dedicated.log";
char value[PROPERTY_VALUE_MAX] = {0};
osi_property_get(kFeatureKey, value, "-1");
return std::string(value) == std::string("1");
}
private:
BTStackLogConfig()
: kBTForceTurnOffInboundDataMonitorProperty_("persist.vendor.bluetooth.offmonitor") {}
bool isPropertySet(const std::string& key) const {
char value[PROPERTY_VALUE_MAX] = {0};
if (osi_property_get(key.c_str(), value, "")) {
return true;
} else {
return false;
}
}
bool IsBTSnoopFeatureEnabled(const char* key) const {
char btsnoop_enabled[PROPERTY_VALUE_MAX] = {0};
// Andrdoid P
//osi_property_get(key, btsnoop_enabled, "false");
//return std::string(btsnoop_enabled) == std::string("true");
// Andrdoid R
osi_property_get(key, btsnoop_enabled, "disabled");
return std::string(btsnoop_enabled) == std::string("filtered") || std::string(btsnoop_enabled) == std::string("full");
}
friend class Singleton<BTStackLogConfig>;
const std::string kBTForceTurnOffInboundDataMonitorProperty_;
};
class StackConfigImpl {
public:
StackConfigImpl() = default;
~StackConfigImpl() = default;
bool IsNeedOverWriteConfig() const {
return BTStackLogConfig::GetInstance()->IsNeedOverWriteConfig();
}
std::unique_ptr<config_t> OverwriteConfig(std::unique_ptr<config_t> config) {
std::unique_ptr<StackConfigParser> config_parse(new StackConfigParser);
return config_parse->OverwriteConfig(std::move(config));
}
const std::shared_ptr<ControllerLogModeParser> LoadFWLogModeParser(
TraceLevel level) {
return ControllerLogModeFactory::GetInstance()->Create(level);
}
std::vector<uint8_t> GetFWLogEnableCommandPacket(
const std::shared_ptr<ControllerLogModeParser>& parser) {
return parser->GetEnableCommandPacket();
}
std::vector<uint8_t> GetFWLogFilterommandPacket(
const std::shared_ptr<ControllerLogModeParser>& parser) {
return parser->GetFilterommandPacket();
}
bool IsBTSnoopEnabled() const {
return BTStackLogConfig::GetInstance()->IsBTSnoopEnabled();
}
bool IsInboundDataMonitorEnabled() const {
return BTStackLogConfig::GetInstance()->IsInboundDataMonitorEnabled();
}
bool IsConnSYSDedicatedLogFeatureEnabled() const {
return BTStackLogConfig::GetInstance()->IsConnSYSDedicatedLogFeatureEnabled();
}
};
StackConfig::StackConfig() : config_impl_(new StackConfigImpl()) {}
StackConfig* StackConfig::GetInstance() {
return base::Singleton<StackConfig>::get();
}
bool StackConfig::IsNeedOverWriteConfig() const {
return config_impl_->IsNeedOverWriteConfig();
}
std::unique_ptr<config_t> StackConfig::OverwriteConfig(
std::unique_ptr<config_t> config) {
return config_impl_->OverwriteConfig(std::move(config));
}
const std::shared_ptr<ControllerLogModeParser> StackConfig::LoadFWLogModeParser(
TraceLevel level) {
return config_impl_->LoadFWLogModeParser(level);
}
std::vector<uint8_t> StackConfig::GetFWLogEnableCommandPacket(
const std::shared_ptr<ControllerLogModeParser>& parser) {
return config_impl_->GetFWLogEnableCommandPacket(parser);
}
std::vector<uint8_t> StackConfig::GetFWLogFilterommandPacket(
const std::shared_ptr<ControllerLogModeParser>& parser) {
return config_impl_->GetFWLogFilterommandPacket(parser);
}
bool StackConfig::IsBTSnoopEnabled() const {
return config_impl_->IsBTSnoopEnabled();
}
bool StackConfig::IsInboundDataMonitorEnabled() const {
return config_impl_->IsInboundDataMonitorEnabled();
}
bool StackConfig::IsConnSYSDedicatedLogFeatureEnabled() const {
return config_impl_->IsConnSYSDedicatedLogFeatureEnabled();
}
} // namespace stack
} // namespace bt
} // namespace mediatek
} // namespace vendor
#endif
Reference in New Issue View Git Blame Copy Permalink