* Copyright (c) 2024 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 "uart.h"
#include <chrono>
#include <cstring>
#include <mc/exception.h>
#include <mc/log.h>
#include <mutex>
#include <poll.h>
#include <thread>
using namespace dev;
static std::mutex uart_connect_mutex;
bus_uart::bus_uart()
: m_channel_id(0), m_baudrate(UART_DEFAULT_BAUDRATE), m_databits(UART_DEFAULT_DATABITS),
m_stopbits(UART_DEFAULT_STOPBITS), m_parity(UartParity::None), m_fd(-1), m_device_open(false)
{}
bus_uart::~bus_uart()
{
close_device();
}
bool bus_uart::init(mc::mutable_dict& csr_object)
{
try {
if (csr_object.contains("ChannelId")) {
m_channel_id = csr_object["ChannelId"].as<uint8_t>();
if (m_channel_id > UART_MAX_CHANNEL_ID) {
MC_THROW(mc::invalid_arg_exception, "ChannelId must be 0~14");
}
}
if (csr_object.contains("BaudRate")) {
m_baudrate = csr_object["BaudRate"].as<uint32_t>();
if (!validate_baudrate(m_baudrate)) {
MC_THROW(mc::invalid_arg_exception, "Invalid BaudRate value");
}
}
if (csr_object.contains("object_name")) {
m_object_name = csr_object["object_name"].as<std::string>();
}
m_device_path = get_device_path();
m_class_name = "Uart";
return open_device();
} catch (const std::exception& e) {
elog("Uart init failed, exception: ${exception}", ("exception", e.what()));
return false;
}
}
std::string bus_uart::get_device_path()
{
return "/dev/ttySS" + std::to_string(m_channel_id);
}
bool bus_uart::open_device()
{
if (m_device_open) {
return true;
}
m_fd = open(m_device_path.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
if (m_fd < 0) {
elog("Failed to open uart device: ${path}", ("path", m_device_path));
return false;
}
if (tcgetattr(m_fd, &m_old_termios) < 0) {
elog("Failed to get uart attributes");
close(m_fd);
m_fd = -1;
return false;
}
if (!configure_termios()) {
close(m_fd);
m_fd = -1;
return false;
}
m_device_open = true;
dlog("Uart device opened: ${path}", ("path", m_device_path));
return true;
}
void bus_uart::close_device()
{
if (m_device_open && m_fd >= 0) {
tcsetattr(m_fd, TCSANOW, &m_old_termios);
close(m_fd);
m_fd = -1;
m_device_open = false;
}
}
bool bus_uart::configure_termios(FlushMode flush_mode)
{
auto start_time = std::chrono::steady_clock::now();
uint64_t start_ms = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
dlog("UART TIMING: configure_termios START - parity=${p}, flush_mode=${f}, time=${time}ms",
("p", static_cast<int>(m_parity))("f", static_cast<int>(flush_mode))("time", start_ms));
tcgetattr(m_fd, &m_current_termios);
cfmakeraw(&m_current_termios);
m_current_termios.c_cflag |= CREAD | CLOCAL;
m_current_termios.c_cflag &= ~CSIZE;
switch (m_databits) {
case 5:
m_current_termios.c_cflag |= CS5;
break;
case 6:
m_current_termios.c_cflag |= CS6;
break;
case 7:
m_current_termios.c_cflag |= CS7;
break;
case 8:
m_current_termios.c_cflag |= CS8;
break;
default:
m_current_termios.c_cflag |= CS8;
break;
}
m_current_termios.c_cflag &= ~(PARENB | PARODD | CMSPAR);
if (m_parity == UartParity::Even) {
m_current_termios.c_cflag |= PARENB;
} else if (m_parity == UartParity::Odd) {
m_current_termios.c_cflag |= PARENB | PARODD;
} else if (m_parity == UartParity::Mark) {
m_current_termios.c_cflag |= PARENB | PARODD | CMSPAR;
} else if (m_parity == UartParity::Space) {
m_current_termios.c_cflag |= PARENB | CMSPAR;
}
m_current_termios.c_cflag &= ~CSTOPB;
if (m_stopbits == 2) {
m_current_termios.c_cflag |= CSTOPB;
}
cfsetispeed(&m_current_termios, baudrate_to_speed(m_baudrate));
cfsetospeed(&m_current_termios, baudrate_to_speed(m_baudrate));
m_current_termios.c_cc[VMIN] = 0;
m_current_termios.c_cc[VTIME] = 0;
if (m_parity == UartParity::Mark) {
m_current_termios.c_iflag |= INPCK;
m_current_termios.c_iflag &= ~IGNPAR;
m_current_termios.c_iflag |= PARMRK;
dlog("UART PARITY CONFIG: Mark parity - INPCK=1, IGNPAR=0, PARMRK=1 (MARK Space parity data with 0xFF 0x00 "
"prefix, preserve fan response)");
} else if (m_parity == UartParity::Space) {
m_current_termios.c_iflag &= ~INPCK;
m_current_termios.c_iflag &= ~IGNPAR;
m_current_termios.c_iflag &= ~PARMRK;
dlog("UART PARITY CONFIG: Space parity - INPCK=0, IGNPAR=0, PARMRK=0 (ACCEPT all data for fan response)");
} else {
m_current_termios.c_iflag &= ~INPCK;
m_current_termios.c_iflag &= ~IGNPAR;
m_current_termios.c_iflag &= ~PARMRK;
dlog("UART PARITY CONFIG: Parity=${p} - INPCK=0, IGNPAR=0, PARMRK=0", ("p", static_cast<int>(m_parity)));
}
if (tcsetattr(m_fd, TCSADRAIN, &m_current_termios) < 0) {
elog("Failed to set uart attributes");
return false;
}
dlog("UART DIAGNOSTIC: flush_mode=${mode} (0=NONE, 1=INPUT, 2=OUTPUT, 3=BOTH)",
("mode", static_cast<uint32_t>(flush_mode)));
auto diag_start = std::chrono::steady_clock::now();
uint64_t diag_start_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(diag_start.time_since_epoch()).count();
dlog("UART TIMING: diagnose_parity_settings START - elapsed=${elapsed}ms", ("elapsed", diag_start_ms - start_ms));
diagnose_parity_settings();
auto diag_end = std::chrono::steady_clock::now();
uint64_t diag_end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(diag_end.time_since_epoch()).count();
dlog("UART TIMING: diagnose_parity_settings(brief) OK - elapsed=${elapsed}ms",
("elapsed", diag_end_ms - diag_start_ms));
auto flush_start = std::chrono::steady_clock::now();
uint64_t flush_start_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(flush_start.time_since_epoch()).count();
switch (flush_mode) {
case FlushMode::NONE:
dlog("UART DIAGNOSTIC: FLUSH_NONE - skipping flush");
break;
case FlushMode::INPUT:
dlog("UART DIAGNOSTIC: FLUSH_INPUT - tcflush(TCIFLUSH)");
tcflush(m_fd, TCIFLUSH);
break;
case FlushMode::OUTPUT:
dlog("UART DIAGNOSTIC: FLUSH_OUTPUT - tcflush(TCOFLUSH)");
tcflush(m_fd, TCOFLUSH);
break;
case FlushMode::BOTH:
dlog("UART DIAGNOSTIC: FLUSH_BOTH - tcflush(TCIOFLUSH)");
tcflush(m_fd, TCIOFLUSH);
break;
}
auto flush_end = std::chrono::steady_clock::now();
uint64_t flush_end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(flush_end.time_since_epoch()).count();
dlog("UART TIMING: flush complete - elapsed=${elapsed}ms", ("elapsed", flush_end_ms - flush_start_ms));
auto end_time = std::chrono::steady_clock::now();
uint64_t end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time.time_since_epoch()).count();
dlog("UART TIMING: configure_termios COMPLETE - total_time=${total}ms", ("total", end_ms - start_ms));
return true;
}
bool bus_uart::validate_baudrate(uint32_t baudrate)
{
for (auto valid_baud : UART_VALID_BAUDRATES) {
if (baudrate == valid_baud) {
return true;
}
}
return false;
}
speed_t bus_uart::baudrate_to_speed(uint32_t baudrate)
{
switch (baudrate) {
case 115200:
return B115200;
case 57600:
return B57600;
case 38400:
return B38400;
case 19200:
return B19200;
case 9600:
return B9600;
case 4800:
return B4800;
case 2400:
return B2400;
case 1800:
return B1800;
case 1200:
return B1200;
default:
return B115200;
}
}
bool bus_uart::set_baudrate(uint32_t baudrate, FlushMode flush_mode)
{
if (!validate_baudrate(baudrate)) {
return false;
}
m_baudrate = baudrate;
return configure_termios(flush_mode);
}
bool bus_uart::set_parity(UartParity parity, FlushMode flush_mode)
{
auto start_time = std::chrono::steady_clock::now();
uint64_t start_ms = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
dlog("UART TIMING: set_parity START - parity=${p}, flush_mode=${f}, time=${time}ms",
("p", static_cast<int>(parity))("f", static_cast<int>(flush_mode))("time", start_ms));
int rx_bytes_before = 0;
int rx_bytes_after = 0;
if (flush_mode != FlushMode::NONE && m_fd >= 0) {
ioctl(m_fd, FIONREAD, &rx_bytes_before);
auto flush_check_time = std::chrono::steady_clock::now();
uint64_t flush_check_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(flush_check_time.time_since_epoch()).count();
dlog("UART TIMING: set_parity PRE_FLUSH_CHECK - parity=${p}, rx_bytes=${bytes}, elapsed=${elapsed}ms",
("p", static_cast<int>(parity))("bytes", rx_bytes_before)("elapsed", flush_check_ms - start_ms));
}
auto config_start_time = std::chrono::steady_clock::now();
uint64_t config_start_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(config_start_time.time_since_epoch()).count();
dlog("UART TIMING: set_parity CONFIG_START - elapsed=${elapsed}ms", ("elapsed", config_start_ms - start_ms));
m_parity = parity;
bool result = configure_termios(flush_mode);
auto config_end_time = std::chrono::steady_clock::now();
uint64_t config_end_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(config_end_time.time_since_epoch()).count();
dlog("UART TIMING: set_parity CONFIG_END - result=${res}, elapsed=${elapsed}ms (configure_termios took "
"${config_time}ms)",
("res", result)("elapsed", config_end_ms - start_ms)("config_time", config_end_ms - config_start_ms));
if (flush_mode != FlushMode::NONE && m_fd >= 0) {
ioctl(m_fd, FIONREAD, &rx_bytes_after);
auto flush_end_time = std::chrono::steady_clock::now();
uint64_t flush_end_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(flush_end_time.time_since_epoch()).count();
dlog("UART TIMING: set_parity POST_FLUSH - flushed ${flushed} bytes, elapsed=${elapsed}ms",
("flushed", rx_bytes_before - rx_bytes_after)("elapsed", flush_end_ms - start_ms));
}
auto end_time = std::chrono::steady_clock::now();
uint64_t end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time.time_since_epoch()).count();
dlog("UART TIMING: set_parity COMPLETE - parity=${p}, total_time=${total}ms",
("p", static_cast<int>(parity))("total", end_ms - start_ms));
return result;
}
bool bus_uart::set_databits(uint8_t databits, FlushMode flush_mode)
{
if (databits < 5 || databits > 8) {
return false;
}
m_databits = databits;
return configure_termios(flush_mode);
}
bool bus_uart::set_stopbits(uint8_t stopbits, FlushMode flush_mode)
{
if (stopbits < 1 || stopbits > 2) {
return false;
}
m_stopbits = stopbits;
return configure_termios(flush_mode);
}
bool bus_uart::set_config(const UartConfig& config, FlushMode flush_mode)
{
if (!validate_baudrate(config.baudrate)) {
return false;
}
if (config.databits < 5 || config.databits > 8) {
return false;
}
if (config.stopbits < 1 || config.stopbits > 2) {
return false;
}
m_baudrate = config.baudrate;
m_databits = config.databits;
m_stopbits = config.stopbits;
m_parity = config.parity;
return configure_termios(flush_mode);
}
UartConfig bus_uart::get_config()
{
UartConfig config;
config.baudrate = m_baudrate;
config.databits = m_databits;
config.stopbits = m_stopbits;
config.parity = m_parity;
return config;
}
int bus_uart::uart_read(uint8_t* buffer, uint32_t length, uint32_t timeout_ms)
{
if (!m_device_open || m_fd < 0) {
return -1;
}
struct pollfd pfd;
pfd.fd = m_fd;
pfd.events = POLLIN;
int ret = poll(&pfd, 1, timeout_ms);
if (ret <= 0) {
return ret;
}
ssize_t bytes_read = ::read(m_fd, buffer, length);
return static_cast<int>(bytes_read);
}
int bus_uart::uart_write(const uint8_t* buffer, uint32_t length, uint32_t timeout_ms)
{
if (!m_device_open || m_fd < 0) {
return -1;
}
if (length > 0) {
dlog("UART DIAG: uart_write PRE_SEND - fd=${fd}, length=${len}, first_byte=0x${byte:02X}, timeout=${timeout}ms",
("fd", m_fd)("len", length)("byte", buffer[0])("timeout", timeout_ms));
}
uint32_t total_written = 0;
auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
while (total_written < length) {
auto remaining_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(deadline - std::chrono::steady_clock::now()).count();
if (remaining_ms <= 0) {
break;
}
struct pollfd pfd;
pfd.fd = m_fd;
pfd.events = POLLOUT;
int ret = poll(&pfd, 1, static_cast<int>(remaining_ms));
if (ret <= 0) {
break;
}
ssize_t bytes_written = ::write(m_fd, buffer + total_written, length - total_written);
if (bytes_written <= 0) {
break;
}
total_written += static_cast<uint32_t>(bytes_written);
}
if (length > 0) {
dlog("UART DIAG: uart_write POST_SEND - wrote ${written}/${total} bytes",
("written", total_written)("total", length));
}
return static_cast<int>(total_written);
}
int bus_uart::rx_bytes_available()
{
if (!m_device_open || m_fd < 0) {
return 0;
}
int bytes_available = 0;
ioctl(m_fd, FIONREAD, &bytes_available);
return bytes_available;
}
void bus_uart::diagnose_parity_settings(bool verbose)
{
if (!m_device_open || m_fd < 0) {
dlog("UART PARITY DIAG: device not open");
return;
}
struct termios current;
if (tcgetattr(m_fd, ¤t) != 0) {
dlog("UART PARITY DIAG: tcgetattr failed");
return;
}
bool inpck = (current.c_iflag & INPCK) != 0;
bool ignpar = (current.c_iflag & IGNPAR) != 0;
bool parmrk = (current.c_iflag & PARMRK) != 0;
bool parenb = (current.c_cflag & PARENB) != 0;
bool parodd = (current.c_cflag & PARODD) != 0;
bool cmspar = (current.c_cflag & CMSPAR) != 0;
if (!verbose) {
std::string parity_type;
if (!parenb) {
parity_type = "NONE";
} else if (cmspar) {
parity_type = parodd ? "MARK(bit9=1)" : "SPACE(bit9=0)";
} else {
parity_type = parodd ? "ODD" : "EVEN";
}
std::string input_mode;
if (!inpck) {
input_mode = "ACCEPT_ALL";
} else if (ignpar) {
input_mode = "DISCARD_ERR";
} else if (parmrk) {
input_mode = "MARK_ERR(0xFF0x00)";
} else {
input_mode = "PASS_ERR";
}
dlog("UART PARITY: ${type}, input=${mode}", ("type", parity_type)("mode", input_mode));
return;
}
dlog("UART PARITY DIAG: === CURRENT TERMIOS CONFIGURATION ===");
dlog("UART PARITY DIAG: c_cflag=0x${flag:08X}, c_iflag=0x${iflag:08X}",
("flag", current.c_cflag)("iflag", current.c_iflag));
dlog("UART PARITY DIAG: PARENB=${enb}, PARODD=${odd}, CMSPAR=${cms}",
("enb", parenb)("odd", parodd)("cms", cmspar));
if (parenb) {
if (cmspar) {
if (parodd) {
dlog("UART PARITY DIAG: MARK PARITY (bit9=1) - for address transmission");
} else {
dlog("UART PARITY DIAG: SPACE PARITY (bit9=0) - for fan response reception");
}
} else {
dlog("UART PARITY DIAG: ${parity} PARITY", ("parity", parodd ? "ODD" : "EVEN"));
}
} else {
dlog("UART PARITY DIAG: PARITY DISABLED (None parity)");
}
dlog("UART PARITY DIAG: INPCK=${inpck} (input parity check), IGNPAR=${ignpar} (ignore errors), PARMRK=${parmrk} "
"(mark errors)",
("inpck", inpck)("ignpar", ignpar)("parmrk", parmrk));
if (inpck) {
if (ignpar) {
dlog("UART PARITY DIAG: INPCK=1, IGNPAR=1 -> Parity errors detected and DISCARDED");
} else if (parmrk) {
dlog("UART PARITY DIAG: INPCK=1, IGNPAR=0, PARMRK=1 -> Parity errors detected and MARKED (0xFF 0x00 "
"prefix)");
dlog("UART PARITY DIAG: This preserves fan response data in RX buffer");
} else {
dlog("UART PARITY DIAG: INPCK=1, IGNPAR=0, PARMRK=0 -> Parity errors pass but may pollute buffer");
}
} else {
dlog("UART PARITY DIAG: INPCK=0 -> Input parity checking DISABLED");
dlog("UART PARITY DIAG: ALL data accepted (both Mark and Space parity bytes)");
}
dlog("UART PARITY DIAG: === END TERMIOS CONFIGURATION ===");
}
bool bus_uart::check_and_log_parity_errors()
{
if (!m_device_open || m_fd < 0) {
return false;
}
struct termios current;
if (tcgetattr(m_fd, ¤t) != 0) {
dlog("UART PARITY ERROR CHECK: tcgetattr failed");
return false;
}
bool inpck = (current.c_iflag & INPCK) != 0;
bool ignpar = (current.c_iflag & IGNPAR) != 0;
dlog("UART PARITY CONFIG CHECK: INPCK=${inpck} (parity checking), IGNPAR=${ignpar} (ignore parity errors)",
("inpck", inpck)("ignpar", ignpar));
if (!inpck) {
dlog("UART PARITY CONFIG CHECK: INPCK=0 → PARITY CHECKING DISABLED");
dlog("UART PARITY CONFIG CHECK: This means ALL data is accepted regardless of parity bit (bit9)");
dlog("UART PARITY CONFIG CHECK: Mark parity (bit9=1) and Space parity (bit9=0) data BOTH accepted");
dlog("UART PARITY CONFIG CHECK: RX buffer pollution possible: other fan responses may remain in buffer");
dlog("UART PARITY CONFIG CHECK: Solution: flush RX buffer BEFORE sending query address");
return false;
}
if (ignpar) {
dlog("UART PARITY CONFIG CHECK: IGNPAR=1 → data with parity errors will be DISCARDED silently");
dlog("UART PARITY CONFIG CHECK: Fan response during wrong parity mode may be rejected");
return true;
}
dlog("UART PARITY CONFIG CHECK: INPCK=1, IGNPAR=0 → parity errors detected but data not discarded");
return false;
}
uint8_t bus_uart::get_id()
{
return m_channel_id;
}
void bus_uart::bus_lock()
{
uart_connect_mutex.lock();
}
void bus_uart::bus_unlock()
{
uart_connect_mutex.unlock();
}
uint32_t bus_uart::read(ACCESS_DATA_S& input)
{
if (!m_device_open) {
return HAS_ERR;
}
if (input.length == 0 || input.length > UART_MAX_READ_LEN) {
elog("bus_uart read: invalid length ${len} (max ${max})", ("len", input.length)("max", UART_MAX_READ_LEN));
input.out_buffer.clear();
return HAS_ERR;
}
input.out_buffer.resize(input.length);
int ret = uart_read(input.out_buffer.data(), input.length,
input.read_time_out > 0 ? input.read_time_out : UART_DEFAULT_TIMEOUT_MS);
if (ret <= 0) {
input.out_buffer.clear();
return HAS_ERR;
}
input.out_buffer.resize(ret);
return HAS_OK;
}
uint32_t bus_uart::write(ACCESS_DATA_S& input)
{
if (!m_device_open) {
return HAS_ERR;
}
if (input.in_buffer.empty() || input.length == 0) {
return HAS_ERR;
}
if (input.length != input.in_buffer.size()) {
elog("bus_uart write: length(${len}) != in_buffer.size(${size})",
("len", input.length)("size", input.in_buffer.size()));
return HAS_ERR;
}
int ret = uart_write(input.in_buffer.data(), input.length,
input.write_time_out > 0 ? input.write_time_out : UART_DEFAULT_TIMEOUT_MS);
if (ret != static_cast<int>(input.length)) {
elog("bus_uart write: incomplete write - wrote ${wrote}/${total}", ("wrote", ret)("total", input.length));
return HAS_ERR;
}
return HAS_OK;
}
int bus_uart::uart_connect_port(uint8_t uart_id, uint8_t port_id)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
struct uart_connect_cfg cfg;
cfg.mode = UART_2_PORT;
cfg.src = uart_id;
cfg.dst = port_id;
int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
close(fd);
return ret;
}
int bus_uart::port_connect_port(uint8_t port_id, uint8_t target_id)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
struct uart_connect_cfg cfg;
cfg.mode = PORT_2_PORT;
cfg.src = port_id;
cfg.dst = target_id;
int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
close(fd);
return ret;
}
int bus_uart::query_uart_connection(uint8_t uart_id, uint32_t* connection_info)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
uint32_t buffer[3] = {0};
int ret = ioctl(fd, GET_UART_CONNECT_INFO, buffer);
if (ret == 0) {
uint32_t dw_index = uart_id / 6;
uint32_t bit_offset = (uart_id % 6) * 5;
if (dw_index < 3) {
*connection_info = (buffer[dw_index] >> bit_offset) & 0x1F;
}
}
close(fd);
return ret;
}
int bus_uart::query_port_connection(uint8_t port_id, uint32_t* connection_info)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
uint32_t buffer[3] = {0};
int ret = ioctl(fd, GET_PORT_CONNECT_INFO, buffer);
if (ret == 0) {
uint32_t dw_index = port_id / 6;
uint32_t bit_offset = (port_id % 6) * 5;
if (dw_index < 3) {
*connection_info = (buffer[dw_index] >> bit_offset) & 0x1F;
}
}
close(fd);
return ret;
}
int bus_uart::uart_connect_uart_from_uart_raw(uint8_t src_uart, uint8_t dst_uart)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
dlog("UART DIAGNOSTIC: Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
struct uart_connect_cfg cfg;
cfg.mode = UART_FROM_UART_RAW;
cfg.src = src_uart;
cfg.dst = dst_uart;
dlog("UART DIAGNOSTIC: Configuring uart connect: src=${src}(RX), dst=${dst}(TX), mode=UART_FROM_UART_RAW",
("src", src_uart)("dst", dst_uart));
int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
close(fd);
if (ret < 0) {
dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) failed, errno=${err}", ("err", errno));
return -1;
}
dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) success");
return 0;
}
int bus_uart::port_connect_uart_from_port_raw(uint8_t src_port, uint8_t dst_uart)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
dlog("UART DIAGNOSTIC: Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
struct uart_connect_cfg cfg;
cfg.mode = UART_FROM_PORT_RAW;
cfg.src = src_port;
cfg.dst = dst_uart;
dlog("UART DIAGNOSTIC: Configuring port connect: src=${src}(UART RX), dst=${dst}(PORT TX), mode=UART_FROM_PORT_RAW",
("src", src_port)("dst", dst_uart));
int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
close(fd);
if (ret < 0) {
dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) failed, errno=${err}", ("err", errno));
return -1;
}
dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) success");
return 0;
}
int bus_uart::reset_uart_connection()
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
int ret = ioctl(fd, RESET_UART_CONNECT, 0);
close(fd);
return ret;
}
int bus_uart::get_host_baudrate(uint8_t host_uart_chan, uint32_t* baudrate)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
struct host_uart_baud_info info;
info.host_uart_chan = host_uart_chan;
info.baud_constant_list = nullptr;
int ret = ioctl(fd, GET_HOST_BAUDRATE_INFO, &info);
if (ret == 0) {
*baudrate = info.uart_baud;
}
close(fd);
return ret;
}
int bus_uart::port_disconnect(uint8_t port_id)
{
std::lock_guard<std::mutex> lock(uart_connect_mutex);
int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
if (fd < 0) {
elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
return -1;
}
struct uart_connect_cfg cfg;
cfg.mode = PORT_DISCONNECT;
cfg.src = port_id;
cfg.dst = port_id;
int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
close(fd);
return ret;
}
void bus_uart::flush_rx_only()
{
if (m_fd >= 0 && m_device_open) {
tcflush(m_fd, TCIFLUSH);
dlog("UART DIAG: flush_rx_only() - cleared RX buffer (parity unchanged)");
}
}
void bus_uart::flush_tx_only()
{
if (m_fd >= 0 && m_device_open) {
tcflush(m_fd, TCOFLUSH);
dlog("UART DIAG: flush_tx_only() - cleared TX buffer (parity unchanged)");
}
}