mirror of
https://github.com/intel/compute-runtime.git
synced 2025-11-15 10:14:56 +08:00
Move aub and tbx code to shared
Related-To: NEO-3964 Change-Id: Ice978e582721498d7496f989767ce7d6f5f4caf4 Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
committed by
sys_ocldev
sys_ocldev
parent
ccd5abfbfd
commit
ca5f34133b
14
shared/source/tbx/CMakeLists.txt
Normal file
14
shared/source/tbx/CMakeLists.txt
Normal file
@@ -0,0 +1,14 @@
|
||||
#
|
||||
# Copyright (C) 2018-2020 Intel Corporation
|
||||
#
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
|
||||
set(NEO_CORE_TBX
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/tbx_proto.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/tbx_sockets.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/tbx_sockets_imp.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/tbx_sockets_imp.h
|
||||
)
|
||||
set_property(GLOBAL PROPERTY NEO_CORE_TBX ${NEO_CORE_TBX})
|
||||
458
shared/source/tbx/tbx_proto.h
Normal file
458
shared/source/tbx/tbx_proto.h
Normal file
@@ -0,0 +1,458 @@
|
||||
/*
|
||||
* Copyright (C) 2017-2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstdint>
|
||||
|
||||
enum HAS_MSG_TYPE {
|
||||
HAS_MMIO_REQ_TYPE = 0,
|
||||
HAS_MMIO_RES_TYPE = 1,
|
||||
HAS_GTT_REQ_TYPE = 2,
|
||||
HAS_GTT_RES_TYPE = 3,
|
||||
HAS_WRITE_DATA_REQ_TYPE = 4,
|
||||
HAS_READ_DATA_REQ_TYPE = 5,
|
||||
HAS_READ_DATA_RES_TYPE = 6,
|
||||
HAS_MARKER_REQ_TYPE = 7,
|
||||
HAS_MARKER_RES_TYPE = 8,
|
||||
HAS_REPORT_REND_END_REQ_TYPE = 9,
|
||||
HAS_REPORT_REND_END_RES_TYPE = 10,
|
||||
HAS_CONTROL_REQ_TYPE = 11,
|
||||
HAS_PARAMS_REQ_TYPE = 12,
|
||||
HAS_PARAMS_RES_TYPE = 13,
|
||||
HAS_PCICFG_REQ_TYPE = 14,
|
||||
HAS_PCICFG_RES_TYPE = 15,
|
||||
HAS_GTT_PARAMS_REQ_TYPE = 16,
|
||||
HAS_EVENT_REQ_TYPE = 17,
|
||||
HAS_INNER_VAR_REQ_TYPE = 18,
|
||||
HAS_INNER_VAR_RES_TYPE = 19,
|
||||
HAS_INNER_VAR_LIST_REQ_TYPE = 20,
|
||||
HAS_INNER_VAR_LIST_RES_TYPE = 21,
|
||||
HAS_FUNNY_IO_REQ_TYPE = 22,
|
||||
HAS_FUNNY_IO_RES_TYPE = 23,
|
||||
HAS_IO_REQ_TYPE = 24,
|
||||
HAS_IO_RES_TYPE = 25,
|
||||
HAS_RPC_REQ_TYPE = 26,
|
||||
HAS_RPC_RES_TYPE = 27,
|
||||
HAS_CL_FLUSH_REQ_TYPE = 28,
|
||||
HAS_CL_FLUSH_RES_TYPE = 29,
|
||||
HAS_SYNC_ALL_PAGES_REQ_TYPE = 30,
|
||||
HAS_SYNC_ALL_PAGES_RES_TYPE = 31,
|
||||
HAS_GD2_MESSAGE_TYPE = 32,
|
||||
HAS_SIMTIME_RES_TYPE = 33,
|
||||
HAS_RL_STATUS_RES_TYPE = 34,
|
||||
NUM_OF_MSG_TYPE
|
||||
};
|
||||
|
||||
struct HAS_HDR {
|
||||
union {
|
||||
uint32_t msg_type;
|
||||
HAS_MSG_TYPE type;
|
||||
};
|
||||
uint32_t trans_id;
|
||||
uint32_t size;
|
||||
};
|
||||
|
||||
enum {
|
||||
MSG_TYPE_MMIO = 0,
|
||||
MSG_TYPE_IO,
|
||||
MSG_TYPE_FUNNY_IO
|
||||
};
|
||||
|
||||
struct HAS_MMIO_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t size : 3;
|
||||
uint32_t dev_idx : 2;
|
||||
uint32_t msg_type : 3;
|
||||
uint32_t reserved : 7;
|
||||
uint32_t delay : 16;
|
||||
|
||||
uint32_t offset;
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_MMIO_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_MMIO_EXT_REQ {
|
||||
struct HAS_MMIO_REQ mmio_req;
|
||||
uint32_t sourceid : 8;
|
||||
uint32_t reserved1 : 24;
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_MMIO_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_MMIO_RES {
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_MMIO_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_GTT32_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t reserved : 31;
|
||||
|
||||
uint32_t offset;
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_GTT_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_GTT32_RES {
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_GTT_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_GTT64_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t reserved : 31;
|
||||
|
||||
uint32_t offset;
|
||||
uint32_t data;
|
||||
uint32_t data_h;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_GTT_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_GTT64_RES {
|
||||
uint32_t data;
|
||||
uint32_t data_h;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_GTT_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_WRITE_DATA_REQ {
|
||||
uint32_t addr_type : 1;
|
||||
uint32_t mask_exist : 1;
|
||||
uint32_t frontdoor : 1;
|
||||
uint32_t take_ownership : 1;
|
||||
uint32_t model_owned : 1;
|
||||
uint32_t cacheline_disable : 1;
|
||||
uint32_t memory_type : 2;
|
||||
uint32_t reserved : 16;
|
||||
uint32_t address_h : 8;
|
||||
uint32_t address;
|
||||
uint32_t size;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_WRITE_DATA_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_READ_DATA_REQ {
|
||||
uint32_t addr_type : 1;
|
||||
uint32_t frontdoor : 1;
|
||||
uint32_t ownership_req : 1;
|
||||
uint32_t model_owned : 1;
|
||||
uint32_t cacheline_disable : 1;
|
||||
uint32_t reserved : 19;
|
||||
uint32_t address_h : 8;
|
||||
uint32_t address;
|
||||
uint32_t size;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_READ_DATA_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_READ_DATA_RES {
|
||||
uint32_t addr_type : 1;
|
||||
uint32_t mask_exist : 1;
|
||||
uint32_t last_page : 1;
|
||||
uint32_t ownership_res : 1;
|
||||
uint32_t reserved : 20;
|
||||
uint32_t address_h : 8;
|
||||
uint32_t address;
|
||||
uint32_t size;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_READ_DATA_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_CONTROL_REQ {
|
||||
uint32_t reset : 1; // [0:0]
|
||||
uint32_t has : 1; // [1:1]
|
||||
uint32_t rd_on_demand : 1; // [2:2]
|
||||
uint32_t write_mask : 1; // [3:3]
|
||||
uint32_t time_adv : 1; // [4:4]
|
||||
uint32_t async_msg : 1; // [5:5]
|
||||
uint32_t quit : 1; // [6:6]
|
||||
uint32_t cncry_enb : 1; // [7:7]
|
||||
uint32_t stime_enb : 1; // [8:8]
|
||||
uint32_t full_reset : 1; // [9:9]
|
||||
uint32_t auto_ownership : 1; // [10:10]
|
||||
uint32_t backdoor_model : 1; // [11:11]
|
||||
uint32_t flush : 1; // [12:12]
|
||||
uint32_t reserved : 3; // [15:13]
|
||||
|
||||
uint32_t reset_mask : 1; // [16:16]
|
||||
uint32_t has_mask : 1; // [17:17]
|
||||
uint32_t rd_on_demand_mask : 1; // [18:18]
|
||||
uint32_t write_mask_mask : 1; // [19:19]
|
||||
uint32_t time_adv_mask : 1; // [20:20]
|
||||
uint32_t async_msg_mask : 1; // [21:21]
|
||||
uint32_t quit_mask : 1; // [22:22]
|
||||
uint32_t cncry_enb_mask : 1; // [23:23]
|
||||
uint32_t stime_enb_mask : 1; // [24:24]
|
||||
uint32_t full_reset_mask : 1; // [25:25]
|
||||
uint32_t auto_ownership_mask : 1; // [26:26]
|
||||
uint32_t backdoor_model_mask : 1; // [27:27]
|
||||
uint32_t flush_mask : 1; // [28:28]
|
||||
uint32_t reserved_mask : 3; // [31:29]
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_CONTROL_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_REPORT_REND_END_REQ {
|
||||
uint32_t timeout;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_REPORT_REND_END_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_REPORT_REND_END_RES {
|
||||
uint32_t timeout : 1;
|
||||
uint32_t reserved : 31;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_REPORT_REND_END_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_PCICFG_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t size : 3;
|
||||
uint32_t bus : 8;
|
||||
uint32_t device : 5;
|
||||
uint32_t function : 3;
|
||||
uint32_t reserved : 12;
|
||||
uint32_t offset;
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_PCICFG_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_PCICFG_RES {
|
||||
uint32_t data;
|
||||
};
|
||||
|
||||
struct HAS_GTT_PARAMS_REQ {
|
||||
uint32_t base;
|
||||
uint32_t base_h : 8;
|
||||
uint32_t size : 24;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_GTT_PARAMS_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_EVENT_OBSOLETE_REQ {
|
||||
uint32_t offset;
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_EVENT_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_EVENT_REQ {
|
||||
uint32_t offset;
|
||||
uint32_t data;
|
||||
uint32_t dev_idx : 2;
|
||||
uint32_t reserved : 30;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_EVENT_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_INNER_VAR_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t non_dword : 16;
|
||||
uint32_t reserved : 15;
|
||||
uint32_t id;
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_INNER_VAR_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_INNER_VAR_RES {
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_INNER_VAR_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_INNER_VAR_LIST_RES {
|
||||
uint32_t size;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_INNER_VAR_LIST_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_INTERNAL_VAR_LIST_ENTRY_RES {
|
||||
uint32_t id;
|
||||
uint32_t min;
|
||||
uint32_t max;
|
||||
uint32_t desc_size;
|
||||
};
|
||||
|
||||
struct HAS_FUNNY_IO_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t reserved : 28;
|
||||
uint32_t size : 3;
|
||||
uint32_t offset;
|
||||
uint32_t value;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_FUNNY_IO_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_FUNNY_IO_RES {
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_FUNNY_IO_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_IO_REQ {
|
||||
uint32_t write : 1;
|
||||
uint32_t dev_idx : 2;
|
||||
uint32_t reserved : 26;
|
||||
uint32_t size : 3;
|
||||
uint32_t offset;
|
||||
uint32_t value;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_IO_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_IO_RES {
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_IO_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_RPC_REQ {
|
||||
uint32_t size;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_RPC_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_RPC_RES {
|
||||
uint32_t status;
|
||||
uint32_t size;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_RPC_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_CL_FLUSH_REQ {
|
||||
uint32_t reserved : 23;
|
||||
uint32_t ignore : 1;
|
||||
uint32_t address_h : 8;
|
||||
uint32_t address;
|
||||
uint32_t size;
|
||||
uint32_t delay;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_CL_FLUSH_REQ_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_CL_FLUSH_RES {
|
||||
uint32_t data;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_CL_FLUSH_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_SIMTIME_RES {
|
||||
uint32_t data_l;
|
||||
uint32_t data_h;
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_SIMTIME_RES_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
struct HAS_GD2_MESSAGE {
|
||||
uint32_t subOpcode;
|
||||
uint32_t data[1];
|
||||
|
||||
enum {
|
||||
HAS_MSG_TYPE = HAS_GD2_MESSAGE_TYPE
|
||||
};
|
||||
};
|
||||
|
||||
union HAS_MSG_BODY {
|
||||
struct HAS_MMIO_REQ mmio_req;
|
||||
struct HAS_MMIO_EXT_REQ mmio_req_ext;
|
||||
struct HAS_MMIO_RES mmio_res;
|
||||
struct HAS_GTT32_REQ gtt32_req;
|
||||
struct HAS_GTT32_RES gtt32_res;
|
||||
struct HAS_GTT64_REQ gtt64_req;
|
||||
struct HAS_GTT64_RES gtt64_res;
|
||||
struct HAS_WRITE_DATA_REQ write_req;
|
||||
struct HAS_READ_DATA_REQ read_req;
|
||||
struct HAS_READ_DATA_RES read_res;
|
||||
struct HAS_CONTROL_REQ control_req;
|
||||
struct HAS_REPORT_REND_END_REQ render_req;
|
||||
struct HAS_REPORT_REND_END_RES render_res;
|
||||
struct HAS_PCICFG_REQ pcicfg_req;
|
||||
struct HAS_PCICFG_RES pcicfg_res;
|
||||
struct HAS_GTT_PARAMS_REQ gtt_params_req;
|
||||
struct HAS_EVENT_REQ event_req;
|
||||
struct HAS_EVENT_OBSOLETE_REQ event_obsolete_req;
|
||||
struct HAS_INNER_VAR_REQ inner_var_req;
|
||||
struct HAS_INNER_VAR_RES inner_var_res;
|
||||
struct HAS_INNER_VAR_LIST_RES inner_var_list_res;
|
||||
struct HAS_IO_REQ io_req;
|
||||
struct HAS_IO_RES io_res;
|
||||
struct HAS_RPC_REQ rpc_req;
|
||||
struct HAS_RPC_RES rpc_res;
|
||||
struct HAS_CL_FLUSH_REQ flush_req;
|
||||
struct HAS_CL_FLUSH_RES flush_res;
|
||||
struct HAS_SIMTIME_RES stime_res;
|
||||
struct HAS_GD2_MESSAGE gd2_message_req;
|
||||
};
|
||||
|
||||
struct HAS_MSG {
|
||||
struct HAS_HDR hdr;
|
||||
union HAS_MSG_BODY u;
|
||||
};
|
||||
32
shared/source/tbx/tbx_sockets.h
Normal file
32
shared/source/tbx/tbx_sockets.h
Normal file
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* Copyright (C) 2017-2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
|
||||
namespace NEO {
|
||||
|
||||
class TbxSockets {
|
||||
protected:
|
||||
TbxSockets() = default;
|
||||
|
||||
public:
|
||||
virtual ~TbxSockets() = default;
|
||||
virtual bool init(const std::string &hostNameOrIp, uint16_t port) = 0;
|
||||
virtual void close() = 0;
|
||||
|
||||
virtual bool writeGTT(uint32_t offset, uint64_t entry) = 0;
|
||||
|
||||
virtual bool readMemory(uint64_t addr, void *memory, size_t size) = 0;
|
||||
virtual bool writeMemory(uint64_t addr, const void *memory, size_t size, uint32_t type) = 0;
|
||||
|
||||
virtual bool readMMIO(uint32_t offset, uint32_t *value) = 0;
|
||||
virtual bool writeMMIO(uint32_t offset, uint32_t value) = 0;
|
||||
|
||||
static TbxSockets *create();
|
||||
};
|
||||
} // namespace NEO
|
||||
320
shared/source/tbx/tbx_sockets_imp.cpp
Normal file
320
shared/source/tbx/tbx_sockets_imp.cpp
Normal file
@@ -0,0 +1,320 @@
|
||||
/*
|
||||
* Copyright (C) 2018-2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/tbx/tbx_sockets_imp.h"
|
||||
|
||||
#include "shared/source/helpers/debug_helpers.h"
|
||||
#include "shared/source/helpers/string.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
typedef int socklen_t;
|
||||
#else
|
||||
#include <arpa/inet.h>
|
||||
#include <netdb.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
typedef struct sockaddr SOCKADDR;
|
||||
#define SOCKET_ERROR -1
|
||||
#define INVALID_SOCKET -1
|
||||
#define WSAECONNRESET -1
|
||||
#endif
|
||||
#include "tbx_proto.h"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace NEO {
|
||||
|
||||
TbxSocketsImp::TbxSocketsImp(std::ostream &err)
|
||||
: cerrStream(err) {
|
||||
}
|
||||
|
||||
void TbxSocketsImp::close() {
|
||||
if (0 != m_socket) {
|
||||
#ifdef WIN32
|
||||
::shutdown(m_socket, 0x02 /*SD_BOTH*/);
|
||||
|
||||
::closesocket(m_socket);
|
||||
::WSACleanup();
|
||||
#else
|
||||
::shutdown(m_socket, SHUT_RDWR);
|
||||
::close(m_socket);
|
||||
#endif
|
||||
m_socket = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void TbxSocketsImp::logErrorInfo(const char *tag) {
|
||||
#ifdef WIN32
|
||||
cerrStream << tag << "TbxSocketsImp Error: <" << WSAGetLastError() << ">" << std::endl;
|
||||
#else
|
||||
cerrStream << tag << strerror(errno) << std::endl;
|
||||
#endif
|
||||
DEBUG_BREAK_IF(!false);
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::init(const std::string &hostNameOrIp, uint16_t port) {
|
||||
do {
|
||||
#ifdef WIN32
|
||||
WSADATA wsaData;
|
||||
auto iResult = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
|
||||
if (iResult != NO_ERROR) {
|
||||
cerrStream << "Error at WSAStartup()" << std::endl;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
m_socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (m_socket == INVALID_SOCKET) {
|
||||
logErrorInfo("Error at socket(): ");
|
||||
break;
|
||||
}
|
||||
|
||||
if (!connectToServer(hostNameOrIp, port)) {
|
||||
break;
|
||||
}
|
||||
|
||||
HAS_MSG cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.hdr.msg_type = HAS_CONTROL_REQ_TYPE;
|
||||
cmd.hdr.size = sizeof(HAS_CONTROL_REQ);
|
||||
cmd.hdr.trans_id = transID++;
|
||||
|
||||
cmd.u.control_req.time_adv_mask = 1;
|
||||
cmd.u.control_req.time_adv = 0;
|
||||
|
||||
cmd.u.control_req.async_msg_mask = 1;
|
||||
cmd.u.control_req.async_msg = 0;
|
||||
|
||||
cmd.u.control_req.has_mask = 1;
|
||||
cmd.u.control_req.has = 1;
|
||||
|
||||
sendWriteData(&cmd, sizeof(HAS_HDR) + cmd.hdr.size);
|
||||
} while (false);
|
||||
|
||||
return m_socket != INVALID_SOCKET;
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::connectToServer(const std::string &hostNameOrIp, uint16_t port) {
|
||||
do {
|
||||
sockaddr_in clientService;
|
||||
if (::isalpha(hostNameOrIp.at(0))) {
|
||||
auto hostData = ::gethostbyname(hostNameOrIp.c_str());
|
||||
if (hostData == nullptr) {
|
||||
cerrStream << "Host name look up failed for " << hostNameOrIp.c_str() << std::endl;
|
||||
break;
|
||||
}
|
||||
|
||||
memcpy_s(&clientService.sin_addr, sizeof(clientService.sin_addr), hostData->h_addr, hostData->h_length);
|
||||
} else {
|
||||
clientService.sin_addr.s_addr = inet_addr(hostNameOrIp.c_str());
|
||||
}
|
||||
|
||||
clientService.sin_family = AF_INET;
|
||||
clientService.sin_port = htons(port);
|
||||
|
||||
if (::connect(m_socket, (SOCKADDR *)&clientService, sizeof(clientService)) == SOCKET_ERROR) {
|
||||
logErrorInfo("Failed to connect: ");
|
||||
cerrStream << "Is TBX server process running on host system [ " << hostNameOrIp.c_str()
|
||||
<< ", port " << port << "]?" << std::endl;
|
||||
break;
|
||||
}
|
||||
} while (false);
|
||||
|
||||
return !!m_socket;
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::readMMIO(uint32_t offset, uint32_t *data) {
|
||||
bool success;
|
||||
do {
|
||||
HAS_MSG cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.hdr.msg_type = HAS_MMIO_REQ_TYPE;
|
||||
cmd.hdr.size = sizeof(HAS_MMIO_REQ);
|
||||
cmd.hdr.trans_id = transID++;
|
||||
cmd.u.mmio_req.offset = offset;
|
||||
cmd.u.mmio_req.data = 0;
|
||||
cmd.u.mmio_req.write = 0;
|
||||
cmd.u.mmio_req.delay = 0;
|
||||
cmd.u.mmio_req.msg_type = MSG_TYPE_MMIO;
|
||||
cmd.u.mmio_req.size = sizeof(uint32_t);
|
||||
|
||||
success = sendWriteData(&cmd, sizeof(HAS_HDR) + cmd.hdr.size);
|
||||
if (!success) {
|
||||
break;
|
||||
}
|
||||
|
||||
HAS_MSG resp;
|
||||
success = getResponseData((char *)(&resp), sizeof(HAS_HDR) + sizeof(HAS_MMIO_RES));
|
||||
if (!success) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (resp.hdr.msg_type != HAS_MMIO_RES_TYPE || cmd.hdr.trans_id != resp.hdr.trans_id) {
|
||||
*data = 0xdeadbeef;
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
|
||||
*data = resp.u.mmio_res.data;
|
||||
success = true;
|
||||
} while (false);
|
||||
|
||||
DEBUG_BREAK_IF(!success);
|
||||
return success;
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::writeMMIO(uint32_t offset, uint32_t value) {
|
||||
HAS_MSG cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.hdr.msg_type = HAS_MMIO_REQ_TYPE;
|
||||
cmd.hdr.size = sizeof(HAS_MMIO_REQ);
|
||||
cmd.hdr.trans_id = transID++;
|
||||
cmd.u.mmio_req.msg_type = MSG_TYPE_MMIO;
|
||||
cmd.u.mmio_req.offset = offset;
|
||||
cmd.u.mmio_req.data = value;
|
||||
cmd.u.mmio_req.write = 1;
|
||||
cmd.u.mmio_req.size = sizeof(uint32_t);
|
||||
|
||||
return sendWriteData(&cmd, sizeof(HAS_HDR) + cmd.hdr.size);
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::readMemory(uint64_t addrOffset, void *data, size_t size) {
|
||||
HAS_MSG cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.hdr.msg_type = HAS_READ_DATA_REQ_TYPE;
|
||||
cmd.hdr.trans_id = transID++;
|
||||
cmd.hdr.size = sizeof(HAS_READ_DATA_REQ);
|
||||
cmd.u.read_req.address = static_cast<uint32_t>(addrOffset);
|
||||
cmd.u.read_req.address_h = static_cast<uint32_t>(addrOffset >> 32);
|
||||
cmd.u.read_req.addr_type = 0;
|
||||
cmd.u.read_req.size = static_cast<uint32_t>(size);
|
||||
cmd.u.read_req.ownership_req = 0;
|
||||
cmd.u.read_req.frontdoor = 0;
|
||||
cmd.u.read_req.cacheline_disable = cmd.u.read_req.frontdoor;
|
||||
|
||||
bool success;
|
||||
do {
|
||||
success = sendWriteData(&cmd, sizeof(HAS_HDR) + sizeof(HAS_READ_DATA_REQ));
|
||||
if (!success) {
|
||||
break;
|
||||
}
|
||||
|
||||
HAS_MSG resp;
|
||||
success = getResponseData(&resp, sizeof(HAS_HDR) + sizeof(HAS_READ_DATA_RES));
|
||||
if (!success) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (resp.hdr.msg_type != HAS_READ_DATA_RES_TYPE || resp.hdr.trans_id != cmd.hdr.trans_id) {
|
||||
cerrStream << "Out of sequence read data packet?" << std::endl;
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
|
||||
success = getResponseData(data, size);
|
||||
} while (false);
|
||||
|
||||
DEBUG_BREAK_IF(!success);
|
||||
return success;
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::writeMemory(uint64_t physAddr, const void *data, size_t size, uint32_t type) {
|
||||
HAS_MSG cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.hdr.msg_type = HAS_WRITE_DATA_REQ_TYPE;
|
||||
cmd.hdr.trans_id = transID++;
|
||||
cmd.hdr.size = sizeof(HAS_WRITE_DATA_REQ);
|
||||
|
||||
cmd.u.write_req.address = static_cast<uint32_t>(physAddr);
|
||||
cmd.u.write_req.address_h = static_cast<uint32_t>(physAddr >> 32);
|
||||
cmd.u.write_req.addr_type = 0;
|
||||
cmd.u.write_req.size = static_cast<uint32_t>(size);
|
||||
cmd.u.write_req.take_ownership = 0;
|
||||
cmd.u.write_req.frontdoor = 0;
|
||||
cmd.u.write_req.cacheline_disable = cmd.u.write_req.frontdoor;
|
||||
cmd.u.write_req.memory_type = type;
|
||||
|
||||
bool success;
|
||||
do {
|
||||
success = sendWriteData(&cmd, sizeof(HAS_HDR) + sizeof(HAS_WRITE_DATA_REQ));
|
||||
if (!success) {
|
||||
break;
|
||||
}
|
||||
|
||||
success = sendWriteData(data, size);
|
||||
if (!success) {
|
||||
cerrStream << "Problem sending write data?" << std::endl;
|
||||
break;
|
||||
}
|
||||
} while (false);
|
||||
|
||||
DEBUG_BREAK_IF(!success);
|
||||
return success;
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::writeGTT(uint32_t offset, uint64_t entry) {
|
||||
HAS_MSG cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.hdr.msg_type = HAS_GTT_REQ_TYPE;
|
||||
cmd.hdr.size = sizeof(HAS_GTT64_REQ);
|
||||
cmd.hdr.trans_id = transID++;
|
||||
cmd.u.gtt64_req.write = 1;
|
||||
cmd.u.gtt64_req.offset = offset / sizeof(uint64_t); // the TBX server expects GTT index here, not offset
|
||||
cmd.u.gtt64_req.data = static_cast<uint32_t>(entry & 0xffffffff);
|
||||
cmd.u.gtt64_req.data_h = static_cast<uint32_t>(entry >> 32);
|
||||
|
||||
return sendWriteData(&cmd, sizeof(HAS_HDR) + cmd.hdr.size);
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::sendWriteData(const void *buffer, size_t sizeInBytes) {
|
||||
size_t totalSent = 0;
|
||||
auto dataBuffer = reinterpret_cast<const char *>(buffer);
|
||||
|
||||
do {
|
||||
auto bytesSent = ::send(m_socket, &dataBuffer[totalSent], static_cast<int>(sizeInBytes - totalSent), 0);
|
||||
if (bytesSent == 0 || bytesSent == WSAECONNRESET) {
|
||||
logErrorInfo("Connection Closed.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (bytesSent == SOCKET_ERROR) {
|
||||
logErrorInfo("Error on send()");
|
||||
return false;
|
||||
}
|
||||
totalSent += bytesSent;
|
||||
} while (totalSent < sizeInBytes);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TbxSocketsImp::getResponseData(void *buffer, size_t sizeInBytes) {
|
||||
size_t totalRecv = 0;
|
||||
auto dataBuffer = static_cast<char *>(buffer);
|
||||
|
||||
do {
|
||||
auto bytesRecv = ::recv(m_socket, &dataBuffer[totalRecv], static_cast<int>(sizeInBytes - totalRecv), 0);
|
||||
if (bytesRecv == 0 || bytesRecv == WSAECONNRESET) {
|
||||
logErrorInfo("Connection Closed.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (bytesRecv == SOCKET_ERROR) {
|
||||
logErrorInfo("Error on recv()");
|
||||
return false;
|
||||
}
|
||||
|
||||
totalRecv += bytesRecv;
|
||||
} while (totalRecv < sizeInBytes);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace NEO
|
||||
47
shared/source/tbx/tbx_sockets_imp.h
Normal file
47
shared/source/tbx/tbx_sockets_imp.h
Normal file
@@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright (C) 2018-2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/source/tbx/tbx_sockets.h"
|
||||
|
||||
#include "os_socket.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace NEO {
|
||||
|
||||
class TbxSocketsImp : public TbxSockets {
|
||||
public:
|
||||
TbxSocketsImp(std::ostream &err = std::cerr);
|
||||
~TbxSocketsImp() override = default;
|
||||
|
||||
bool init(const std::string &hostNameOrIp, uint16_t port) override;
|
||||
void close() override;
|
||||
|
||||
bool writeGTT(uint32_t gttOffset, uint64_t entry) override;
|
||||
|
||||
bool readMemory(uint64_t offset, void *data, size_t size) override;
|
||||
bool writeMemory(uint64_t offset, const void *data, size_t size, uint32_t type) override;
|
||||
|
||||
bool readMMIO(uint32_t offset, uint32_t *data) override;
|
||||
bool writeMMIO(uint32_t offset, uint32_t data) override;
|
||||
|
||||
protected:
|
||||
std::ostream &cerrStream;
|
||||
SOCKET m_socket = 0;
|
||||
|
||||
bool connectToServer(const std::string &hostNameOrIp, uint16_t port);
|
||||
bool sendWriteData(const void *buffer, size_t sizeInBytes);
|
||||
bool getResponseData(void *buffer, size_t sizeInBytes);
|
||||
|
||||
inline uint32_t getNextTransID() { return transID++; }
|
||||
|
||||
void logErrorInfo(const char *tag);
|
||||
|
||||
uint32_t transID = 0;
|
||||
};
|
||||
} // namespace NEO
|
||||
Reference in New Issue
Block a user