* Copyright (c) 2026 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <gtest/gtest.h>
#include <algorithm>
#include <deque>
#include <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_base/chip.h>
#include <internal/hasdef.h>
#include <mc/dict.h>
#include <mc/engine.h>
#include <smbus/std_smbus.h>
#include <stdexcept>
#include <string>
#define private public
#include <internal/chip/chip_mcu_switch/mcu_switch.h>
#undef private
namespace {
class test_bus : public dev::bus_base {
public:
uint32_t read(ACCESS_DATA_S& input) override
{
(void)input;
return HAS_OK;
}
uint32_t write(ACCESS_DATA_S& input) override
{
(void)input;
return HAS_OK;
}
uint8_t get_id() override
{
return m_id;
}
void bus_lock() override
{}
void bus_unlock() override
{}
void set_id(uint8_t id)
{
m_id = id;
}
private:
uint8_t m_id = 0;
};
std::string build_capability_payload(const std::vector<uint16_t>& opcodes)
{
std::string payload;
payload.push_back('\x00');
payload.push_back('\x00');
payload.push_back('\x00');
uint16_t count = static_cast<uint16_t>(opcodes.size());
payload.push_back(static_cast<char>(count & 0xFF));
payload.push_back(static_cast<char>((count >> 8) & 0xFF));
for (uint16_t opcode : opcodes) {
payload.push_back(static_cast<char>(opcode & 0xFF));
payload.push_back(static_cast<char>((opcode >> 8) & 0xFF));
}
return payload;
}
class switch_test_chip : public dev::chip_mcu_switch {
public:
struct queued_response {
uint16_t opcode;
std::string data;
uint16_t error_code = 0;
};
void queue_response(uint16_t opcode, const std::string& data, uint16_t error_code = 0)
{
m_responses.push_back({opcode, data, error_code});
}
int32_t combo_block_write_read(uint32_t write_offset, const std::vector<uint8_t>& write_buffer,
uint32_t read_offset, uint32_t read_length, std::vector<uint8_t>& in_buffer,
std::vector<uint8_t>& out_buffer, std::string& error) override
{
(void)write_offset;
(void)read_offset;
(void)read_length;
(void)in_buffer;
if (m_responses.empty()) {
throw std::runtime_error("no queued MCU switch response");
}
if (write_buffer.size() >= 5) {
requested_opcodes.push_back(read_u16(write_buffer, 3));
requested_payloads.push_back(extract_payload(write_buffer));
}
uint32_t request_offset = 0;
uint32_t request_length = 0;
if (write_buffer.size() >= 13) {
request_offset = read_u32(write_buffer, 5);
request_length = read_u32(write_buffer, 9);
}
const auto response = m_responses.front();
if (request_offset >= response.data.size()) {
out_buffer = build_protocol_response(response.opcode, response.data, response.error_code, "");
m_responses.pop_front();
return HAS_OK;
}
auto chunk_length = std::min<size_t>(request_length, response.data.size() - request_offset);
auto chunk = response.data.substr(request_offset, chunk_length);
out_buffer = build_protocol_response(response.opcode, response.data, response.error_code, chunk);
if (request_offset + chunk_length >= response.data.size()) {
m_responses.pop_front();
}
return HAS_OK;
}
std::vector<uint16_t> requested_opcodes;
std::vector<std::string> requested_payloads;
private:
static uint16_t read_u16(const std::vector<uint8_t>& data, size_t offset)
{
return static_cast<uint16_t>(data.at(offset)) | (static_cast<uint16_t>(data.at(offset + 1)) << 8);
}
static uint32_t read_u32(const std::vector<uint8_t>& data, size_t offset)
{
return static_cast<uint32_t>(data.at(offset)) | (static_cast<uint32_t>(data.at(offset + 1)) << 8) |
(static_cast<uint32_t>(data.at(offset + 2)) << 16) | (static_cast<uint32_t>(data.at(offset + 3)) << 24);
}
static std::string extract_payload(const std::vector<uint8_t>& request)
{
constexpr size_t request_header_len = 13;
if (request.size() <= request_header_len + 1) {
return "";
}
uint32_t declared_len = read_u32(request, 9);
size_t available_len = request.size() - request_header_len - 1;
size_t payload_len = std::min<size_t>(declared_len, available_len);
return std::string(request.begin() + request_header_len, request.begin() + request_header_len + payload_len);
}
std::vector<uint8_t> build_protocol_response(uint16_t opcode, const std::string& full_data, uint16_t error_code,
const std::string& chunk_data) const
{
constexpr uint8_t read_command_code = 0x21;
uint8_t count = static_cast<uint8_t>(header_len + chunk_data.size());
uint32_t total_length = static_cast<uint32_t>(full_data.size());
uint32_t length = static_cast<uint32_t>(chunk_data.size());
std::string rsp_without_crc;
rsp_without_crc.push_back(static_cast<char>(count));
rsp_without_crc.append(reinterpret_cast<const char*>(&error_code), sizeof(error_code));
rsp_without_crc.append(reinterpret_cast<const char*>(&opcode), sizeof(opcode));
rsp_without_crc.append(reinterpret_cast<const char*>(&total_length), sizeof(total_length));
rsp_without_crc.append(reinterpret_cast<const char*>(&length), sizeof(length));
rsp_without_crc.append(chunk_data);
std::string crc_input;
crc_input.push_back(static_cast<char>(get_address()));
crc_input.push_back(static_cast<char>(read_command_code));
crc_input.push_back(static_cast<char>(get_address() | 0x01));
crc_input.append(rsp_without_crc);
uint8_t crc = mc::crypto::CRC8().calculate(crc_input);
rsp_without_crc.push_back(static_cast<char>(crc));
return std::vector<uint8_t>(rsp_without_crc.begin(), rsp_without_crc.end());
}
std::deque<queued_response> m_responses;
};
class chip_mcu_switch_test : public ::testing::Test {
protected:
void SetUp() override
{
m_bus = std::make_shared<test_bus>();
m_bus->set_id(1);
}
std::shared_ptr<test_bus> m_bus;
};
TEST_F(chip_mcu_switch_test, open_channel_sends_capability_and_switch_open)
{
auto switch_chip = std::make_shared<switch_test_chip>();
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0xC8);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["SwitchSupported"] = true;
csr_object["object_name"] = std::string("chip-switch");
switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({MCU_SWITCH_OPCODE}));
switch_chip->queue_response(MCU_SWITCH_OPCODE, "");
ASSERT_TRUE(switch_chip->init(csr_object));
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
ASSERT_EQ(switch_chip->requested_opcodes.size(), 2U);
EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_SWITCH_OPCODE);
ASSERT_EQ(switch_chip->requested_payloads.size(), 2U);
EXPECT_TRUE(switch_chip->requested_payloads[0].empty());
EXPECT_EQ(switch_chip->requested_payloads[1], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
}
TEST_F(chip_mcu_switch_test, close_channel_sends_switch_close_after_capability_check)
{
auto switch_chip = std::make_shared<switch_test_chip>();
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0xC8);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["SwitchSupported"] = true;
switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({MCU_SWITCH_OPCODE}));
switch_chip->queue_response(MCU_SWITCH_OPCODE, "");
switch_chip->queue_response(MCU_SWITCH_OPCODE, "");
ASSERT_TRUE(switch_chip->init(csr_object));
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
EXPECT_EQ(switch_chip->close_channel(m_bus), HAS_OK);
ASSERT_EQ(switch_chip->requested_opcodes.size(), 3U);
EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_SWITCH_OPCODE);
EXPECT_EQ(switch_chip->requested_opcodes[2], MCU_SWITCH_OPCODE);
ASSERT_EQ(switch_chip->requested_payloads.size(), 3U);
EXPECT_TRUE(switch_chip->requested_payloads[0].empty());
EXPECT_EQ(switch_chip->requested_payloads[1], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
EXPECT_EQ(switch_chip->requested_payloads[2], std::string(1, static_cast<char>(MCU_SWITCH_CLOSE_DATA)));
}
TEST_F(chip_mcu_switch_test, capability_check_reads_multipage_response)
{
auto switch_chip = std::make_shared<switch_test_chip>();
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0xC8);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["SwitchSupported"] = true;
std::vector<uint16_t> capability_opcodes = {0x0006, 0x0018, 0x0019, 0x001a, 0x0301, 0x0302,
0x0303, 0x0304, 0x0305, 0x0306, MCU_SWITCH_OPCODE};
switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload(capability_opcodes));
switch_chip->queue_response(MCU_SWITCH_OPCODE, "");
ASSERT_TRUE(switch_chip->init(csr_object));
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
ASSERT_EQ(switch_chip->requested_opcodes.size(), 3U);
EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_CAPABILITIES_OPCODE);
EXPECT_EQ(switch_chip->requested_opcodes[2], MCU_SWITCH_OPCODE);
EXPECT_EQ(switch_chip->requested_payloads[2], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
}
TEST_F(chip_mcu_switch_test, capability_check_failure_is_treated_as_unsupported_and_can_retry)
{
auto switch_chip = std::make_shared<switch_test_chip>();
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0xC8);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["SwitchSupported"] = true;
switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, std::string("\x00", 1));
switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({MCU_SWITCH_OPCODE}));
switch_chip->queue_response(MCU_SWITCH_OPCODE, "");
ASSERT_TRUE(switch_chip->init(csr_object));
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
ASSERT_EQ(switch_chip->requested_opcodes.size(), 1U);
EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
ASSERT_EQ(switch_chip->requested_opcodes.size(), 3U);
EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_CAPABILITIES_OPCODE);
EXPECT_EQ(switch_chip->requested_opcodes[2], MCU_SWITCH_OPCODE);
EXPECT_EQ(switch_chip->requested_payloads[2], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
}
TEST_F(chip_mcu_switch_test, open_channel_treats_smbus_comm_failure_as_unsupported)
{
auto switch_chip = std::make_shared<switch_test_chip>();
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0xC8);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["SwitchSupported"] = true;
ASSERT_TRUE(switch_chip->init(csr_object));
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
EXPECT_TRUE(switch_chip->requested_opcodes.empty());
}
TEST_F(chip_mcu_switch_test, unsupported_capability_does_not_send_switch_request)
{
auto switch_chip = std::make_shared<switch_test_chip>();
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0xC8);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["SwitchSupported"] = true;
switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({0x0300}));
ASSERT_TRUE(switch_chip->init(csr_object));
EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
ASSERT_EQ(switch_chip->requested_opcodes.size(), 1U);
EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
ASSERT_EQ(switch_chip->requested_payloads.size(), 1U);
EXPECT_TRUE(switch_chip->requested_payloads[0].empty());
}
class stub_smbus : public dev::std_smbus {
public:
stub_smbus() : dev::std_smbus(nullptr)
{}
std::string send_request(mc::mutable_dict request) override
{
m_requests.push_back(request);
if (m_throw) {
throw std::runtime_error("injected smbus request failure");
}
return std::string();
}
void set_throw(bool value)
{
m_throw = value;
}
const std::vector<mc::mutable_dict>& requests() const
{
return m_requests;
}
private:
bool m_throw = false;
std::vector<mc::mutable_dict> m_requests;
};
TEST_F(chip_mcu_switch_test, do_mcu_switch_is_noop_without_capability_or_smbus)
{
auto chip = std::make_shared<dev::chip_mcu_switch>();
EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_OK);
auto smbus = std::make_shared<stub_smbus>();
chip->m_smbus_obj = smbus;
EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_OK);
EXPECT_TRUE(smbus->requests().empty());
}
TEST_F(chip_mcu_switch_test, do_mcu_switch_sends_single_byte_payload)
{
auto chip = std::make_shared<dev::chip_mcu_switch>();
auto smbus = std::make_shared<stub_smbus>();
chip->m_smbus_obj = smbus;
chip->m_switch_capability_available = true;
EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_OK);
ASSERT_EQ(smbus->requests().size(), 1U);
const mc::mutable_dict& request = smbus->requests()[0];
ASSERT_TRUE(request.contains("opcode"));
ASSERT_TRUE(request.contains("data"));
ASSERT_TRUE(request.contains("expect_data_len"));
EXPECT_EQ(request["opcode"].as<uint16_t>(), MCU_SWITCH_OPCODE);
EXPECT_EQ(request["data"].as<std::string>(), std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
EXPECT_EQ(request["expect_data_len"].as<int32_t>(), 0);
}
TEST_F(chip_mcu_switch_test, do_mcu_switch_close_sends_zero_payload)
{
auto chip = std::make_shared<dev::chip_mcu_switch>();
auto smbus = std::make_shared<stub_smbus>();
chip->m_smbus_obj = smbus;
chip->m_switch_capability_available = true;
EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_CLOSE_DATA), HAS_OK);
ASSERT_EQ(smbus->requests().size(), 1U);
EXPECT_EQ(smbus->requests()[0]["data"].as<std::string>(), std::string(1, '\0'));
}
TEST_F(chip_mcu_switch_test, do_mcu_switch_reports_request_exception)
{
auto chip = std::make_shared<dev::chip_mcu_switch>();
auto smbus = std::make_shared<stub_smbus>();
smbus->set_throw(true);
chip->m_smbus_obj = smbus;
chip->m_switch_capability_available = true;
EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_ERR);
EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_CLOSE_DATA), HAS_ERR);
EXPECT_EQ(smbus->requests().size(), 2U);
}
}