* Copyright (c) 2023 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 "smc.h"
#include <functional>
#include <mc/crypto/crc8.h>
#include <mc/exception.h>
#include <unistd.h>
#include "securec.h"
using namespace dev;
namespace {
const uint32_t SMC_MAX_DATA_LENGTH = 255;
const uint32_t SMC_MAX_BUFFER_LEN = SMC_MAX_DATA_LENGTH + 5;
const uint32_t SMC_MIN_READ_LEN = 2;
const uint32_t SMC_FORWARD_READ_LEN = 3;
const uint32_t SMC_DEFAULT_READ_LEN = 8;
const uint32_t SMC_MAX_BYTE_READ_SIZE = 4;
const uint32_t BITS_PER_BYTE = 8;
const uint32_t SMC_EXTRA_LEN = 1;
const uint32_t SMC_READ_LEN_OFFSET = 3;
const uint32_t SMC_READ_CC_OFFSET = SMC_READ_LEN_OFFSET + 1;
const uint32_t SMC_READ_DATA_OFFSET = SMC_READ_CC_OFFSET + 1;
const uint32_t SMC_RESP_RAW_READ_LEN_OFFSET = 0x00;
const uint32_t SMC_RESP_RAW_CC_OFFSET = 0x01;
const uint32_t SMC_MCTP_READ_LEN_OFFSET = 0x00;
const uint32_t SMC_MCTP_CC_OFFSET = 0x01;
const uint32_t SMC_MCTP_DATA_OFFSET = 0x03;
const uint32_t SMC_MCTP_CC_MASK = 0x0F;
const uint32_t SMC_MCTP_READ_EXTRA_LEN = 4;
const uint32_t SMC_MCTP_MAX_RETRIES = 5;
const uint8_t PROTOCOL_MCTP_OVER_SMC = 0x03;
const uint8_t FORWARD_TYPE_MCTP = 0x02;
const uint8_t FORWARD_TYPE_SMC = 0x01;
const uint32_t SMC_LISTEN_TIMES = 6;
const uint32_t SMC_SLEEP_TIME = 5000;
const uint32_t SMC_MULTI_MASK = 0x200;
const uint32_t SMC_RW_MASK = 0x100;
const uint32_t SMC_OPCODE_MASK = 0xfffffc00;
const uint32_t SMC_PARA_MASK = 0xff;
const uint32_t SMC_SET_TEST_REG = 0x2200;
const uint32_t SMC_GET_TEST_REG = 0x2100;
const uint32_t SMC_TEST_MASK = 0xff;
inline static uint8_t chip_smc_get_first_nonzero_pos(uint32_t mask)
{
return __builtin_ctz(mask);
}
template <typename T>
inline static T chip_smc_set_value_with_mask(uint32_t mask, T oriData, T setData)
{
uint8_t shift = chip_smc_get_first_nonzero_pos(mask);
return static_cast<T>((mask & (setData << shift)) | (oriData & (~mask)));
}
template <typename T>
inline static T chip_smc_get_value_with_mask(uint32_t mask, T oriData)
{
uint8_t shift = chip_smc_get_first_nonzero_pos(mask);
return static_cast<T>((oriData & mask) >> shift);
}
};
bool chip_smc::init(mc::mutable_dict& csr_object)
{
try {
chip_base::init(csr_object);
} catch (const std::exception& e) {
elog("SMC configuration loading failed: ${error}", ("error", e.what()));
return false;
}
return true;
}
int32_t chip_smc::chip_test(uint32_t* result)
{
try {
std::vector<uint8_t> write_data = {0xAA};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = bit_write(SMC_SET_TEST_REG, 1, SMC_TEST_MASK, write_data, out_buffer, error);
if (ret != HAS_OK) {
elog("${name} smc-selfTest failed: The writing operation failed, err: ${error}",
("name", get_object_name())("error", error));
if (result) {
*result = 0;
}
return HAS_ERR;
}
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> read_buffer;
ret = bit_read(SMC_GET_TEST_REG, 1, SMC_TEST_MASK, in_buffer, read_buffer, error);
if (ret != HAS_OK) {
elog("${name} smc-selfTest failed: The reading operation failed, err: ${error}",
("name", get_object_name())("error", error));
if (result) {
*result = 0;
}
return HAS_ERR;
}
if (read_buffer != write_data) {
elog("${name} smc-selfTest failed: The data written and read are inconsistent",
("name", get_object_name()));
if (result) {
*result = 0;
}
return HAS_ERR;
}
if (result) {
*result = 1;
}
return HAS_OK;
} catch (const std::exception& e) {
elog("${name} smc-selfTest exception: ${error}", ("name", get_object_name())("error", e.what()));
if (result) {
*result = 0;
}
return HAS_ERR;
}
}
int32_t chip_smc::bit_read(uint32_t offset, uint8_t size, uint32_t mask, std::vector<uint8_t>& in_buffer,
std::vector<uint8_t>& out_buffer, std::string& error)
{
if (size == 0 || size == 3 || size > SMC_MAX_BYTE_READ_SIZE) {
error = "request error, invalid input length: " + std::to_string(size);
return HAS_ERR;
}
if (mask == 0) {
out_buffer.clear();
return HAS_OK;
}
out_buffer.clear();
uint8_t read_buffer[SMC_MAX_BUFFER_LEN] = {0};
uint32_t ret = normal_read((offset & SMC_OPCODE_MASK) + 0x100, SMC_MAX_BUFFER_LEN, read_buffer, error);
if (ret != HAS_OK) {
return ret;
}
uint32_t para = offset & SMC_PARA_MASK;
if (para > 0) {
para--;
}
const uint32_t response_length = read_buffer[SMC_READ_LEN_OFFSET];
if (response_length < SMC_EXTRA_LEN) {
error = "response error, invalid smc response length";
return HAS_ERR;
}
const uint32_t data_length = response_length - SMC_EXTRA_LEN;
if (para * size + size > data_length) {
error = "request error, error para, para: " + std::to_string(para) + ", size: " + std::to_string(size) +
", read_len: " + std::to_string(data_length);
return HAS_ERR;
}
uint8_t* dataBuf = read_buffer + SMC_READ_DATA_OFFSET + para * size;
uint32_t raw_value = 0;
for (uint8_t i = 0; i < size; ++i) {
raw_value |= static_cast<uint32_t>(dataBuf[i]) << (BITS_PER_BYTE * i);
}
const uint32_t value = chip_smc_get_value_with_mask(mask, raw_value);
for (uint8_t i = 0; i < size; ++i) {
out_buffer.push_back(static_cast<uint8_t>(value >> (BITS_PER_BYTE * i)));
}
return HAS_OK;
}
int32_t chip_smc::bit_write(uint32_t offset, uint8_t size, uint32_t mask, const std::vector<uint8_t>& in_buffer,
std::vector<uint8_t>& out_buffer, std::string& error)
{
if (size == 0 || size == 3 || size > SMC_MAX_BYTE_READ_SIZE) {
error = "request error, invalid input length: " + std::to_string(size);
return HAS_ERR;
}
if (mask == 0) {
return HAS_OK;
}
if (in_buffer.size() < size) {
error = "request error, bit_write input length is shorter than size";
return HAS_ERR;
}
uint32_t para = offset & SMC_PARA_MASK;
const uint32_t full_mask = size == sizeof(uint32_t) ? UINT32_MAX : ((1U << (BITS_PER_BYTE * size)) - 1U);
if (para == 0 && full_mask == mask) {
return write(offset, size, in_buffer.data(), error);
}
if (para > 0) {
para--;
}
uint8_t read_buffer[SMC_MAX_BUFFER_LEN] = {0};
uint32_t ret = normal_read((offset & SMC_OPCODE_MASK) + 0x100, SMC_MAX_BUFFER_LEN, read_buffer, error);
if (ret != HAS_OK) {
return ret;
}
const uint32_t response_length = read_buffer[SMC_READ_LEN_OFFSET];
if (response_length < SMC_EXTRA_LEN) {
error = "response error, invalid smc response length";
return HAS_ERR;
}
const uint32_t data_length = response_length - SMC_EXTRA_LEN;
if (para * size + size > data_length) {
error = "bit_write para size overflow";
return HAS_ERR;
}
uint8_t* dataBuf = read_buffer + SMC_READ_DATA_OFFSET + para * size;
uint32_t original = 0;
uint32_t input = 0;
for (uint8_t i = 0; i < size; ++i) {
original |= static_cast<uint32_t>(dataBuf[i]) << (BITS_PER_BYTE * i);
input |= static_cast<uint32_t>(in_buffer[i]) << (BITS_PER_BYTE * i);
}
const uint32_t value = chip_smc_set_value_with_mask(mask, original, input);
for (uint8_t i = 0; i < size; ++i) {
dataBuf[i] = static_cast<uint8_t>(value >> (BITS_PER_BYTE * i));
}
return write(offset, size, dataBuf, error);
}
int32_t chip_smc::block_read(uint32_t offset, uint32_t length, std::vector<uint8_t>& in_buffer,
std::vector<uint8_t>& out_buffer, std::string& error)
{
out_buffer.clear();
auto ret = read(offset, length, out_buffer, error);
out_buffer.shrink_to_fit();
return ret;
}
int32_t chip_smc::block_write(uint32_t offset, const std::vector<uint8_t>& in_buffer, std::vector<uint8_t>& out_buffer,
std::string& error)
{
return write(offset, in_buffer.size(), in_buffer.data(), error);
}
int32_t chip_smc::block_write_read(uint32_t offset, const std::vector<uint8_t>& indata, uint32_t read_length,
std::vector<uint8_t>& out_buffer, std::string& error, uint8_t protocol_flag)
{
if (protocol_flag != PROTOCOL_MCTP_OVER_SMC) {
MC_THROW(mc::invalid_op_exception, "Chip SMC block_write_read not supported");
}
if (indata.empty()) {
error = "request error, mctp write buffer is empty";
return HAS_ERR;
}
if (read_length == 0) {
error = "request error, mctp read length is zero";
return HAS_ERR;
}
const uint8_t bus_id = m_host_bus ? m_host_bus->get_id() : m_channel_num;
auto ret = forward_write_mctp(indata, bus_id, error);
if (ret != HAS_OK) {
return ret;
}
return forward_read_mctp(read_length, out_buffer, error);
}
uint32_t chip_smc::forward_write_mctp(const std::vector<uint8_t>& request, uint8_t bus_id, std::string& error)
{
constexpr uint32_t FORWARD_OPCODE_WIDTH = 4;
if (request.empty()) {
error = "request error, mctp write buffer is empty";
return HAS_ERR;
}
const uint32_t payload_length = FORWARD_OPCODE_WIDTH + request.size() - 1;
if (payload_length > 250) {
error = "request error, smc wrap exceed maximum payload length";
return HAS_ERR;
}
const uint32_t forward_opcode = calc_forward_opcode(request.front(), 0, FORWARD_TYPE_MCTP, bus_id);
const auto payload = request.size() > 1 ? request.data() + 1 : nullptr;
return normal_write(forward_opcode, static_cast<uint32_t>(request.size() - 1), payload,
SMC_WRITE_OPCODE_FORWARD_MCTP, error);
}
uint32_t chip_smc::read_mctp_response(uint32_t length, std::vector<uint8_t>& response, std::string& error)
{
if (length > UINT32_MAX - SMC_MCTP_READ_EXTRA_LEN) {
error = "request error, mctp read length is too large";
return HAS_ERR;
}
std::vector<uint8_t> in_buffer;
response.clear();
const uint32_t read_length = length + SMC_MCTP_READ_EXTRA_LEN;
try {
const auto ret =
data_access(0, SMC_READ_BUFFER_FORWARD_MCTP, read_length, in_buffer, response, CHIP_OP_TYPE_READ);
if (ret != HAS_OK) {
error = "data_access failed";
}
return ret;
} catch (const std::exception& e) {
error = std::string("read_mctp_response error: ") + e.what();
return HAS_ERR;
}
}
uint32_t chip_smc::unwrap_mctp_response(const std::vector<uint8_t>& response, std::vector<uint8_t>& data_out,
std::string& error)
{
if (response.size() < SMC_MCTP_DATA_OFFSET + 1) {
error = "response error, mctp response is too short";
return HAS_ERR;
}
const uint32_t mctp_length = response[SMC_MCTP_READ_LEN_OFFSET] + ((response[SMC_MCTP_CC_OFFSET] & 0xF0) << 4);
const uint32_t response_length = mctp_length + 2;
if (response_length < SMC_MCTP_DATA_OFFSET + 1 || response.size() < response_length) {
error = "response error, mctp response length is invalid";
return HAS_ERR;
}
std::string crc_input;
crc_input.reserve(3 + response_length - 1);
crc_input.push_back(static_cast<char>(m_address & 0xFE));
crc_input.push_back(static_cast<char>(SMC_READ_BUFFER_FORWARD_MCTP));
crc_input.push_back(static_cast<char>(m_address | 0x01));
crc_input.append(response.begin(), response.begin() + response_length - 1);
const uint8_t crc = mc::crypto::CRC8().calculate(crc_input);
if (crc != response[response_length - 1]) {
error = "request error, get crc: " + std::to_string(response[response_length - 1]) +
", real crc: " + std::to_string(crc);
elog("${error}", ("error", error));
return HAS_ERR;
}
data_out.assign(response.begin() + SMC_MCTP_DATA_OFFSET, response.begin() + response_length - 1);
return HAS_OK;
}
uint32_t chip_smc::forward_read_mctp(uint32_t length, std::vector<uint8_t>& data_out, std::string& error)
{
constexpr uint8_t SMC_CC_NEED_MORE = 6;
data_out.clear();
uint32_t not_ready_count = 0;
while (not_ready_count < SMC_MCTP_MAX_RETRIES) {
usleep((1U << (not_ready_count + 2)) * 1000);
std::vector<uint8_t> response;
const auto ret = read_mctp_response(length, response, error);
if (ret != HAS_OK) {
return ret;
}
if (response.size() <= SMC_MCTP_CC_OFFSET) {
error = "response error, mctp response is too short";
return HAS_ERR;
}
const uint8_t completion_code = response[SMC_MCTP_CC_OFFSET] & SMC_MCTP_CC_MASK;
{
std::lock_guard<std::mutex> lock(m_status_mutex);
m_last_smc_cc = completion_code;
}
if (completion_code == SMC_CC_NOT_READY) {
++not_ready_count;
continue;
}
std::vector<uint8_t> response_data;
if (completion_code == SMC_CC_NEED_MORE || completion_code == SMC_CC_SUCCESS) {
const auto unwrap_ret = unwrap_mctp_response(response, response_data, error);
if (unwrap_ret != HAS_OK) {
return unwrap_ret;
}
data_out.insert(data_out.end(), response_data.begin(), response_data.end());
if (completion_code == SMC_CC_SUCCESS) {
return HAS_OK;
}
not_ready_count = 0;
continue;
}
error = get_object_name() + " Smc read_forward_mctp: request error, " +
std::string(smc_cc_to_string(completion_code)) +
", SMC completion code: " + std::to_string(completion_code);
return HAS_ERR;
}
error = "read_forward_mctp failed, max listen times reached";
return HAS_ERR;
}
uint32_t chip_smc::read_data(uint32_t read_length, uint8_t* out_buffer, uint8_t command_code, std::string& error)
{
std::vector<uint8_t> in_buffer_vec;
std::vector<uint8_t> out_buffer_vec;
out_buffer_vec.reserve(read_length + SMC_READ_LEN_OFFSET);
std::string retry_status = "no response";
for (uint32_t i = 0; i < SMC_LISTEN_TIMES; i++) {
usleep((1 << (i + 1)) * 1000);
try {
uint32_t ret = data_access(0, command_code, read_length, in_buffer_vec, out_buffer_vec, CHIP_OP_TYPE_READ);
if (ret != HAS_OK) {
error = "data_access failed";
elog("data_access failed, ret: ${ret}", ("ret", ret));
return ret;
}
} catch (const std::exception& e) {
error = std::string("read_data error: ") + e.what();
elog("${error}", ("error", error));
return HAS_ERR;
}
auto reject = [&](const std::string& status) {
retry_status = status;
dlog("${name} Smc read_data: ${status}, round: ${round}",
("name", get_object_name())("status", retry_status)("round", i));
};
if (out_buffer_vec.size() <= SMC_RESP_RAW_CC_OFFSET) {
reject("response too short");
continue;
}
const uint8_t completion_code = out_buffer_vec[SMC_RESP_RAW_CC_OFFSET];
const uint32_t response_length = out_buffer_vec[SMC_RESP_RAW_READ_LEN_OFFSET];
if (response_length == 0x00 || response_length == 0xFF) {
reject("invalid smc response length " + std::to_string(response_length));
continue;
}
const uint32_t frame_length = response_length + SMC_MIN_READ_LEN;
if (frame_length > read_length) {
reject("response length " + std::to_string(response_length) + " exceeds read length " +
std::to_string(read_length));
read_length = frame_length;
continue;
}
if (out_buffer_vec.size() < frame_length) {
reject("smc response length exceeds received bytes");
continue;
}
out_buffer_vec.resize(frame_length);
out_buffer_vec.insert(out_buffer_vec.begin(), m_address | 1);
out_buffer_vec.insert(out_buffer_vec.begin(), command_code);
out_buffer_vec.insert(out_buffer_vec.begin(), m_address & ~1);
std::string crc_input(out_buffer_vec.begin(), out_buffer_vec.end() - 1);
uint8_t crc8 = mc::crypto::CRC8().calculate(crc_input);
if (crc8 != out_buffer_vec.back()) {
reject("crc mismatch, crc8: " + std::to_string(crc8) +
", expected: " + std::to_string(out_buffer_vec.back()));
continue;
}
if (completion_code == SMC_CC_NOT_READY || completion_code > SMC_CC_MAX_NUMBER) {
reject((completion_code == SMC_CC_NOT_READY)
? "device not ready, SMC completion code:2"
: "undefined completion code " + std::to_string(completion_code));
continue;
}
if (completion_code != SMC_CC_SUCCESS) {
{
std::lock_guard<std::mutex> lock(m_status_mutex);
m_last_smc_cc = completion_code;
}
error = get_object_name() + " Smc read_data : request error, " +
std::string(smc_cc_to_string(completion_code)) +
" , SMC completion code:" + std::to_string(completion_code);
ilog("${error}", ("error", error));
return HAS_ERR;
}
errno_t err = memcpy_s(out_buffer, SMC_MAX_BUFFER_LEN, out_buffer_vec.data(), out_buffer_vec.size());
if (err != EOK) {
error = "memcpy_s failed, err=" + std::to_string(err);
elog("${error}", ("error", error));
return HAS_ERR;
}
{
std::lock_guard<std::mutex> lock(m_status_mutex);
m_last_smc_cc = SMC_CC_SUCCESS;
}
return HAS_OK;
}
{
std::lock_guard<std::mutex> lock(m_status_mutex);
m_last_smc_cc = SMC_CC_INVALID;
}
error = "read_data failed, max listen times reached, last status: " + retry_status;
elog("${error}", ("error", error));
return HAS_ERR;
}
void chip_smc::get_length_from_map(uint32_t offset, uint32_t& record_length)
{
auto it = m_opcode_length_map.find(offset);
if (it != m_opcode_length_map.end()) {
record_length = it->second;
} else {
record_length = SMC_DEFAULT_READ_LEN;
}
}
void chip_smc::update_length_to_map(uint32_t offset, uint32_t length)
{
m_opcode_length_map[offset & SMC_OPCODE_MASK] = length;
}
uint32_t chip_smc::read_from_hardware(uint32_t opcode, uint32_t out_length, uint8_t* out_buffer, std::string& error)
{
uint32_t ret = write(opcode, 0, NULL, error);
if (ret != HAS_OK) {
ilog("${name} write failed, ret: ${ret}", ("name", get_object_name())("ret", ret));
return ret;
}
uint32_t real_length = (out_length < SMC_MAX_DATA_LENGTH) ? out_length + SMC_MIN_READ_LEN : SMC_MIN_READ_LEN;
return read_data(real_length, out_buffer, SMC_READ_BUFFER, error);
}
uint32_t chip_smc::normal_read(uint32_t offset, uint32_t buffer_length, uint8_t* buffer, std::string& error)
{
uint32_t record_length = 0;
get_length_from_map(offset, record_length);
if (read_from_hardware(offset, record_length, buffer, error) != HAS_OK) {
return HAS_ERR;
}
update_length_to_map(offset, buffer[SMC_READ_LEN_OFFSET]);
return HAS_OK;
}
uint32_t chip_smc::normal_write(uint32_t offset, uint32_t length, const uint8_t* buffer, uint8_t command_code,
std::string& error)
{
if (length > SMC_MAX_DATA_LENGTH - sizeof(offset)) {
error = "request error, input length " + std::to_string(length) + " exceeds max " +
std::to_string(SMC_MAX_DATA_LENGTH - sizeof(offset));
return HAS_ERR;
}
std::string crc_input;
crc_input += static_cast<char>(m_address);
crc_input += static_cast<char>(command_code);
crc_input += static_cast<char>(sizeof(length) + length);
for (uint32_t i = sizeof(offset); i > 0; i--) {
crc_input += static_cast<char>((offset >> ((i - 1) * 8)) & 0xFF);
}
if (length != 0) {
crc_input += std::string(reinterpret_cast<const char*>(buffer), length);
}
uint8_t crc8 = mc::crypto::CRC8().calculate(crc_input);
crc_input += static_cast<char>(crc8);
std::vector<uint8_t> in_buffer_vec(crc_input.begin() + 2, crc_input.end());
std::vector<uint8_t> out_buffer_vec;
try {
uint32_t ret =
data_access(0, crc_input[1], in_buffer_vec.size(), in_buffer_vec, out_buffer_vec, CHIP_OP_TYPE_WRITE);
if (ret != HAS_OK) {
error = "data_access failed";
}
return ret;
} catch (const std::exception& e) {
error = std::string("normal_write error: ") + e.what();
elog("${error}", ("error", error));
return HAS_ERR;
}
}
uint32_t chip_smc::read(uint32_t offset, uint32_t length, std::vector<uint8_t>& buffer, std::string& error)
{
if (length == 0) {
return HAS_ERR;
}
uint8_t read_buffer[SMC_MAX_BUFFER_LEN] = {0};
uint32_t ret = normal_read(offset, SMC_MAX_BUFFER_LEN, read_buffer, error);
if (ret != HAS_OK) {
ilog("${name} normal_read failed, offset: ${offset}, ret: ${ret}, error: ${error}",
("name", get_object_name())("offset", offset)("ret", static_cast<int32_t>(ret))("error", error));
return ret;
}
const uint32_t response_length = read_buffer[SMC_READ_LEN_OFFSET];
const uint32_t data_length = response_length > 0 ? response_length - 1 : 0;
buffer.assign(length, 0);
for (uint32_t i = 0; i < length && i < data_length; i++) {
buffer[i] = read_buffer[i + SMC_READ_DATA_OFFSET];
}
return HAS_OK;
}
uint32_t chip_smc::write(uint32_t offset, uint32_t length, const uint8_t* buffer, std::string& error)
{
uint8_t command_code = (length == 0) ? SMC_WRITE_OPCODE : SMC_WRITE_OPCODE_WITH_DATA;
return normal_write(offset, length, buffer, command_code, error);
}
uint32_t chip_smc::forward_read(uint32_t length, std::vector<uint8_t>& data_out)
{
uint8_t out_buffer[SMC_MAX_BUFFER_LEN] = {0};
std::string error;
uint32_t read_length = (length < SMC_MAX_DATA_LENGTH) ? length + SMC_FORWARD_READ_LEN : SMC_FORWARD_READ_LEN;
uint32_t ret = read_data(read_length, out_buffer, SMC_READ_BUFFER_FORWARD, error);
if (ret != HAS_OK) {
elog("forward_read failed: read_data failed, ret=${ret}, length=${length}", ("ret", ret)("length", length));
return ret;
}
const uint32_t response_length = out_buffer[SMC_READ_LEN_OFFSET];
if (response_length < SMC_EXTRA_LEN ||
response_length - SMC_EXTRA_LEN > SMC_MAX_BUFFER_LEN - SMC_READ_DATA_OFFSET) {
elog("forward_read failed: invalid smc response length");
return HAS_ERR;
}
const uint32_t actual_length = std::min(length, response_length - SMC_EXTRA_LEN);
data_out.resize(actual_length);
for (uint32_t i = 0; i < actual_length; i++) {
data_out[i] = out_buffer[i + SMC_READ_DATA_OFFSET];
}
return ret;
}
uint32_t chip_smc::forward_write(uint32_t offset, uint32_t length, uint8_t* buffer)
{
std::string error;
return normal_write(offset, length, buffer, SMC_WRITE_OPCODE_FORWARD, error);
}
uint32_t chip_smc::calc_forward_opcode(uint8_t addr, uint32_t length, uint8_t chip_type, uint8_t bus_id)
{
constexpr uint32_t ADDR_LEFT_SHIFT = 24;
constexpr uint32_t LEN_LEFT_SHIFT = 16;
constexpr uint32_t CHIP_TYPE_LEFT_SHIFT = 10;
constexpr uint32_t BUS_ID_LEFT_SHIFT = 0;
uint32_t offset = 0;
offset |= (addr << ADDR_LEFT_SHIFT);
offset |= (length << LEN_LEFT_SHIFT);
offset |= (chip_type << CHIP_TYPE_LEFT_SHIFT);
offset |= (bus_id << BUS_ID_LEFT_SHIFT);
return offset;
}
int32_t chip_smc::forward_by_front_chip(ACCESS_DATA_S& data, const std::string& class_name, uint8_t bus_id)
{
const ACCESS_DATA_S* previous_trace_context = set_forward_trace_context(data.trace_enabled ? &data : nullptr);
struct scope_exit {
std::function<void()> fn;
~scope_exit()
{
fn();
}
} reset_trace_context{[this, previous_trace_context]() {
set_forward_trace_context(previous_trace_context);
}};
constexpr uint32_t BUFFER_LEN = 250;
bool is_smc = class_name == "smc";
int result = HAS_OK;
if (data.protocol_flag == PROTOCOL_MCTP_OVER_SMC) {
std::string error;
result = forward_write_mctp(data.in_buffer, bus_id, error);
if (result != HAS_OK || data.optype == CHIP_OP_TYPE_WRITE) {
if (result != HAS_OK) {
elog("forward MCTP write failed: ${error}", ("error", error));
}
return result;
}
if (data.optype != CHIP_OP_TYPE_READ) {
return HAS_ERR;
}
return forward_read_mctp(data.length, data.out_buffer, error);
}
if (data.offset_width > sizeof(data.offset)) {
elog("forward request has invalid offset width: ${width}", ("width", data.offset_width));
return HAS_ERR;
}
if (data.optype == CHIP_OP_TYPE_WRITE) {
uint8_t buffer[BUFFER_LEN] = {0};
uint8_t chip_type = is_smc ? FORWARD_TYPE_SMC : 0x00;
if (data.length > data.in_buffer.size() || data.length > BUFFER_LEN - data.offset_width) {
elog("forward write length exceeds input or buffer capacity");
return HAS_ERR;
}
uint32_t offset = calc_forward_opcode(data.addr, data.length, chip_type, bus_id);
uint32_t buffer_offset = 0;
for (uint32_t i = data.offset_width; i > 0; i--) {
buffer[buffer_offset++] = (data.offset >> ((i - 1) * 8)) & 0xFF;
}
errno_t err = memcpy_s(buffer + buffer_offset, BUFFER_LEN - buffer_offset, data.in_buffer.data(), data.length);
if (err != 0) {
elog("memcpy_s failed in forward_by_front_chip, err=${err}", ("err", err));
return HAS_ERR;
}
return forward_write(offset, data.length + buffer_offset, buffer);
}
if (!is_smc) {
uint8_t buffer[BUFFER_LEN] = {0};
uint8_t chip_type = 0x00;
uint32_t offset = calc_forward_opcode(data.addr | 0x01, data.length, chip_type, bus_id);
uint32_t buffer_offset = 0;
if (data.offset == CHIP_EXTEND_READ_MODE) {
if (data.in_buffer.empty()) {
elog("forward_by_front_chip extend read with empty in_buffer, addr: ${addr}", ("addr", data.addr));
return HAS_ERR;
}
errno_t err = memcpy_s(buffer, BUFFER_LEN, data.in_buffer.data(), data.in_buffer.size());
if (err != 0) {
elog("memcpy_s failed in forward_by_front_chip extend read, err=${err}", ("err", err));
return HAS_ERR;
}
buffer_offset = static_cast<uint32_t>(data.in_buffer.size());
} else {
for (uint32_t i = data.offset_width; i > 0; i--) {
buffer[buffer_offset++] = (data.offset >> ((i - 1) * 8)) & 0xFF;
}
}
result = forward_write(offset, buffer_offset, buffer);
if (result != HAS_OK) {
return result;
}
usleep(SMC_SLEEP_TIME);
}
return forward_read(data.length, data.out_buffer);
}
const char* chip_smc::get_class_name() const
{
return "smc";
}