yigid/openairinterface5g
1
0
Fork 0
mirror of https://gitlab.eurecom.fr/oai/openairinterface5g.git synced 2026-07-13 04:30:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/mplane-v16.01' into integration_2025_w48 (!3616)

Browse Source 
[FHI72 M-plane] Update the M-plane support to v16.01

- retrieve the additional hardware states (oper-state, admin-state,
  availability-state) and update according to the received notifications
- properly configure MIMO mode if a RU supports
- update the yang models to v16.01
- tested with Benetel v1.4.1, and added an example run in the M-plane doc

Note: backwards compatible with M-plane v05.00

Also, memory leakages fixed cause by ru_session_list_t, and xml functions
xmlReadMemory() and xmlNodeGetContent().
This commit is contained in:
Jaroslava Fiedlerova
2025-11-28 18:11:06 +01:00
parent c8b4aa2abd 19bb463049
commit 68a4bb9a61
23 changed files with 11526 additions and 2153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
radio/fhi_72/mplane/connect-mplane.c
View File

@@ -59,24 +59,7 @@ bool connect_mplane(ru_session_t *ru_session)
void disconnect_mplane(void *rus_disconnect)
{
ru_session_list_t *ru_session_list = (ru_session_list_t *)rus_disconnect;
for (size_t i = 0; i <ru_session_list->num_rus; i++) {
ru_session_t *ru_session = &ru_session_list->ru_session[i];
if (ru_session->session == NULL)
continue;
MP_LOG_I("Sending PM de-activation request for RU \"%s\".\n", ru_session->ru_ip_add);
bool success = pm_conf(ru_session, "false");
if (success)
MP_LOG_I("Successfully de-activated PM for RU \"%s\".\n", ru_session->ru_ip_add);
MP_LOG_I("Disconnecting from RU \"%s\".\n", ru_session->ru_ip_add);
nc_session_free(ru_session->session, NULL);
ru_session->session = NULL;
#ifdef MPLANE_V1
ly_ctx_destroy((struct ly_ctx *)ru_session->ctx, NULL);
#elif defined MPLANE_V2
ly_ctx_destroy((struct ly_ctx *)ru_session->ctx);
#endif
}
free_ru_session_list(ru_session_list);
nc_client_destroy();
}

76
radio/fhi_72/mplane/init-mplane.c
View File

@@ -141,6 +141,43 @@ bool init_mplane(ru_session_list_t *ru_session_list)
return true;
}
static void init_ru_notif(ru_session_t *ru_session, const char* buffer)
{
char* usage_state = get_ru_xml_node(buffer, "usage-state");
if (usage_state != NULL && strcmp(usage_state, "busy") == 0) {
ru_session->ru_notif.rx_carrier_state = BUSY_CARRIER;
ru_session->ru_notif.tx_carrier_state = BUSY_CARRIER;
ru_session->ru_notif.config_change = true;
} else if (usage_state != NULL && strcmp(usage_state, "active") == 0) {
ru_session->ru_notif.rx_carrier_state = READY_CARRIER;
ru_session->ru_notif.tx_carrier_state = READY_CARRIER;
ru_session->ru_notif.config_change = true;
} else { // "idle" or NULL
ru_session->ru_notif.rx_carrier_state = DISABLED_CARRIER;
ru_session->ru_notif.tx_carrier_state = DISABLED_CARRIER;
ru_session->ru_notif.config_change = false;
}
char *oper_state = get_ru_xml_node(buffer, "oper-state");
ru_session->ru_notif.hardware.oper_state = (str_to_enum_oper(oper_state) != OPER_COUNT) ? str_to_enum_oper(oper_state) : ENABLED_OPER;
char *admin_state = get_ru_xml_node(buffer, "admin-state");
ru_session->ru_notif.hardware.admin_state = (str_to_enum_admin(admin_state) != ADMIN_COUNT) ? str_to_enum_admin(admin_state) : UNLOCKED_ADMIN;
char *avail_state = get_ru_xml_node(buffer, "availability-state");
ru_session->ru_notif.hardware.avail_state = (str_to_enum_avail(avail_state) != AVAIL_COUNT) ? str_to_enum_avail(avail_state) : NORMAL_AVAIL;
char *ptp_state = get_ru_xml_node(buffer, "sync-state");
ru_session->ru_notif.ptp_state = str_to_enum_ptp(ptp_state);
MP_LOG_I("RU is in \"%s\" sync state.\n", ptp_state);
free(usage_state);
free(oper_state);
free(admin_state);
free(avail_state);
free(ptp_state);
}
bool manage_ru(ru_session_t *ru_session, const openair0_config_t *oai, const size_t num_rus)
{
bool success = false;
@@ -149,12 +186,8 @@ bool manage_ru(ru_session_t *ru_session, const openair0_config_t *oai, const siz
success = get_mplane(ru_session, &operational_ds);
AssertError(success, return false, "[MPLANE] Unable to continue: could not get RU answer via get_mplane().\n");
bool ptp_state = false;
const char *sync_state = get_ru_xml_node(operational_ds, "sync-state");
if (strcmp(sync_state, "LOCKED") == 0) {
MP_LOG_I("RU is already PTP synchronized.\n");
ptp_state = true;
}
// init RU notifications
init_ru_notif(ru_session, operational_ds);
/* 1) as per M-plane spec, RU must be in supervised mode,
where stream = NULL && filter = "/o-ran-supervision:supervision-notification";
@@ -163,7 +196,6 @@ bool manage_ru(ru_session_t *ru_session, const openair0_config_t *oai, const siz
=> since more than one subscription at the time within one session is not possible, we will subscribe to all notifications */
const char *stream = "NETCONF";
const char *filter = NULL;
ru_session->ru_notif.ptp_state = ptp_state;
success = subscribe_mplane(ru_session, stream, filter, (void *)&ru_session->ru_notif);
AssertError(success, return false, "[MPLANE] Unable to continue: could not get RU answer via subscribe_mplane().\n");
@@ -189,26 +221,18 @@ bool manage_ru(ru_session_t *ru_session, const openair0_config_t *oai, const siz
success = load_yang_models(ru_session, operational_ds);
AssertError(success, return false, "[MPLANE] Unable to load yang models.\n");
if (ru_session->ru_notif.ptp_state) {
char *content = NULL;
success = configure_ru_from_yang(ru_session, oai, num_rus, &content);
AssertError(success, return false, "[MPLANE] Unable to create content for <edit-config> RPC for start-up procedure.\n");
while (1) {
sleep(5);
if (!ru_session->ru_notif.ptp_state && !ru_session->ru_notif.hardware.oper_state && !ru_session->ru_notif.hardware.admin_state && !ru_session->ru_notif.hardware.avail_state) {
char *content = NULL;
success = configure_ru_from_yang(ru_session, oai, num_rus, &content);
AssertError(success, return false, "[MPLANE] Unable to create content for <edit-config> RPC for start-up procedure.\n");
success = edit_val_commmit_rpc(ru_session, content);
AssertError(success, return false, "[MPLANE] Unable to continue.\n");
free(content);
}
const char *usage_state = get_ru_xml_node(operational_ds, "usage-state");
MP_LOG_I("Usage state = \"%s\" for RU \"%s\".\n", usage_state, ru_session->ru_ip_add);
if (strcmp(usage_state, "busy") == 0) { // carriers are already activated
ru_session->ru_notif.rx_carrier_state = true;
ru_session->ru_notif.tx_carrier_state = true;
ru_session->ru_notif.config_change = true;
} else {
ru_session->ru_notif.rx_carrier_state = false;
ru_session->ru_notif.tx_carrier_state = false;
ru_session->ru_notif.config_change = false;
success = edit_val_commmit_rpc(ru_session, content);
AssertError(success, return false, "[MPLANE] Unable to continue.\n");
free(content);
break;
}
}
free(operational_ds);

156
radio/fhi_72/mplane/ru-mplane-api.c
View File

@@ -20,11 +20,145 @@
*/
#include "ru-mplane-api.h"
#include "init-mplane.h"
#include "xml/get-xml.h"
#include "common/utils/assertions.h"
#include <string.h>
#include <libyang/libyang.h>
#include <nc_client.h>
static void free_pm_stats(pm_stats_t *src)
{
// free Rx window measurements
for (size_t i = 0; i < src->rx_num; i++) {
free(src->rx_window_meas[i]);
}
free(src->rx_window_meas);
// free Tx measurements
for (size_t i = 0; i < src->tx_num; i++) {
free(src->tx_meas[i]);
}
free(src->tx_meas);
}
static void free_uplane_info(uplane_info_t *src)
{
for (size_t i = 0; i < src->num; i++) {
free(src->name[i]);
}
free(src->name);
}
static void free_ru_mplane_config(ru_mplane_config_t *src)
{
// free DU MAC address(es) and VLAN tag(s)
for (size_t i = 0; i < src->num_cu_planes; i++) {
free(src->du_mac_addr[i]);
}
free(src->du_mac_addr);
free(src->vlan_tag);
// free interface name
free(src->interface_name);
// free endpoints and carriers
free_uplane_info(&src->tx_endpoints);
free_uplane_info(&src->rx_endpoints);
free_uplane_info(&src->tx_carriers);
free_uplane_info(&src->rx_carriers);
}
static void free_ru_session(ru_session_t *src)
{
// username
free(src->username);
// if no RU connected to, free only the initialized RU IP address
if (src->session == NULL) {
free(src->ru_ip_add);
return;
}
// disconnect from the RU
MP_LOG_I("Sending PM de-activation request for RU \"%s\".\n", src->ru_ip_add);
bool success = pm_conf(src, "false");
if (success)
MP_LOG_I("Successfully de-activated PM for RU \"%s\".\n", src->ru_ip_add);
MP_LOG_I("Disconnecting from RU \"%s\".\n", src->ru_ip_add);
// free RU IP address
free(src->ru_ip_add);
// free RU M-plane config
free_ru_mplane_config(&src->ru_mplane_config);
// free NETCONF session
nc_session_free(src->session, NULL);
src->session = NULL;
// free libyang context
#ifdef MPLANE_V1
ly_ctx_destroy((struct ly_ctx *)src->ctx, NULL);
#elif defined MPLANE_V2
ly_ctx_destroy((struct ly_ctx *)src->ctx);
#endif
// free only the RU MAC addressin xran M-plane info
free(src->xran_mplane.ru_mac_addr);
// nothing to free in ru_notif
// free PM stats
free_pm_stats(&src->pm_stats);
}
void free_ru_session_list(ru_session_list_t *src)
{
// DU key pair
for (size_t i = 0; i < 2; i++) {
free(src->du_key_pair[i]);
}
free(src->du_key_pair);
// RU session
for (size_t i = 0; i < src->num_rus; i++) {
free_ru_session(&src->ru_session[i]);
}
free(src->ru_session);
}
oper_state_e str_to_enum_oper(const char* value) {
#define X(name, str) if (value != NULL && strcmp(value, str) == 0) return name;
OPER_STATE
#undef X
return OPER_COUNT;
};
admin_state_e str_to_enum_admin(const char* value) {
#define X(name, str) if (value != NULL && strcmp(value, str) == 0) return name;
ADMIN_STATE
#undef X
return ADMIN_COUNT;
};
avail_state_e str_to_enum_avail(const char* value) {
#define X(name, str) if (value != NULL && strcmp(value, str) == 0) return name;
AVAIL_STATE
#undef X
return AVAIL_COUNT;
};
ptp_state_e str_to_enum_ptp(const char* value) {
#define X(name, str) if (value != NULL && strcmp(value, str) == 0) return name;
PTP_STATE
#undef X
return PTP_COUNT;
};
carrier_state_e str_to_enum_carrier(const char* value) {
#define X(name, str) if (value != NULL && strcmp(value, str) == 0) return name;
CARRIER_STATE
#undef X
return CARRIER_COUNT;
};
static void free_match_list(char **match_list, size_t count)
{
for (size_t i = 0; i < count; i++) {
@@ -63,13 +197,15 @@ static void fix_benetel_setting(xran_mplane_t *xran_mplane, const uint32_t inter
bool get_config_for_xran(const char *buffer, const int max_num_ant, xran_mplane_t *xran_mplane)
{
/* some O-RU vendors are not fully compliant as per M-plane specifications */
const char *ru_vendor = get_ru_xml_node(buffer, "mfg-name");
char *ru_vendor = get_ru_xml_node(buffer, "mfg-name");
// RU MAC
xran_mplane->ru_mac_addr = get_ru_xml_node(buffer, "mac-address"); // TODO: support for VVDN, as it defines multiple MAC addresses
// MTU
const uint32_t interface_mtu = (uint32_t)atoi(get_ru_xml_node(buffer, "l2-mtu"));
char *int_mtu_str = get_ru_xml_node(buffer, "l2-mtu");
const uint32_t interface_mtu = (uint32_t)atoi(int_mtu_str);
free(int_mtu_str);
// IQ bitwidth
char **match_list = NULL;
@@ -107,14 +243,17 @@ bool get_config_for_xran(const char *buffer, const int max_num_ant, xran_mplane_
free_match_list(match_list, count);
// Managed delay support
const char *managed_delay = get_ru_xml_node(buffer, "managed-delay-support");
char *managed_delay = get_ru_xml_node(buffer, "managed-delay-support");
xran_mplane->managed_delay = (strcasecmp(managed_delay, "NON_MANAGED") == 0) ? false : true;
free(managed_delay);
// Store the max gain
xran_mplane->max_tx_gain = (double)atof(get_ru_xml_node(buffer, "max-gain"));
char *max_tx_gain_str = get_ru_xml_node(buffer, "max-gain");
xran_mplane->max_tx_gain = (double)atof(max_tx_gain_str);
free(max_tx_gain_str);
// Model name
const char *model_name = get_ru_xml_node(buffer, "model-name");
char *model_name = get_ru_xml_node(buffer, "model-name");
if (strcasecmp(ru_vendor, "BENETEL") == 0 /* || strcmp(ru_vendor, "VVDN-LPRU") == 0 || strcmp(ru_vendor, "Metanoia") == 0 */) {
fix_benetel_setting(xran_mplane, interface_mtu, first_iq_width, max_num_ant, model_name);
@@ -150,6 +289,9 @@ bool get_config_for_xran(const char *buffer, const int max_num_ant, xran_mplane_
xran_mplane->ru_port,
xran_mplane->max_tx_gain);
free(ru_vendor);
free(model_name);
return true;
}
@@ -185,7 +327,7 @@ bool get_uplane_info(const char *buffer, ru_mplane_config_t *ru_mplane_config)
bool get_pm_object_list(const char *buffer, pm_stats_t *pm_stats)
{
const char *ru_vendor = get_ru_xml_node(buffer, "mfg-name");
char *ru_vendor = get_ru_xml_node(buffer, "mfg-name");
if (strcasecmp(ru_vendor, "BENETEL") == 0) {
pm_stats->start_up_timing = false;
} else {
@@ -200,5 +342,7 @@ bool get_pm_object_list(const char *buffer, pm_stats_t *pm_stats)
MP_LOG_I("Successfully retreived all performance measurement names.\n");
free(ru_vendor);
return true;
}

84
radio/fhi_72/mplane/ru-mplane-api.h
View File

@@ -31,10 +31,86 @@
#define MP_LOG_I(x, args...) LOG_I(HW, "[MPLANE] " x, ##args)
#define MP_LOG_W(x, args...) LOG_W(HW, "[MPLANE] " x, ##args)
#define OPER_STATE \
X(ENABLED_OPER, "enabled") \
X(DISABLED_OPER, "disabled")
typedef enum {
#define X(name, str) name,
OPER_STATE
#undef X
OPER_COUNT
} oper_state_e;
oper_state_e str_to_enum_oper(const char* value);
#define ADMIN_STATE \
X(UNLOCKED_ADMIN, "unlocked") \
X(SHUTTING_DOWN_ADMIN, "shutting-down") \
X(LOCKED_ADMIN, "locked")
typedef enum {
#define X(name, str) name,
ADMIN_STATE
#undef X
ADMIN_COUNT
} admin_state_e;
admin_state_e str_to_enum_admin(const char* value);
#define AVAIL_STATE \
X(NORMAL_AVAIL, "NORMAL") \
X(DEGRADED_AVAIL, "DEGRADED") \
X(FAULTY_AVAIL, "FAULTY")
typedef enum {
#define X(name, str) name,
AVAIL_STATE
#undef X
AVAIL_COUNT
} avail_state_e;
avail_state_e str_to_enum_avail(const char* value);
typedef struct {
bool ptp_state;
bool rx_carrier_state;
bool tx_carrier_state;
oper_state_e oper_state; // "enabled", "disabled"
admin_state_e admin_state; // "unlocked", "shutting-down", "locked"
avail_state_e avail_state; // "NORMAL", "DEGRADED", "FAULTY"
} hardware_notif_t;
#define PTP_STATE \
X(LOCKED_PTP, "LOCKED") \
X(FREERUN_PTP, "FREERUN") \
X(HOLDOVER_PTP, "HOLDOVER")
typedef enum {
#define X(name, str) name,
PTP_STATE
#undef X
PTP_COUNT
} ptp_state_e;
ptp_state_e str_to_enum_ptp(const char* value);
#define CARRIER_STATE \
X(READY_CARRIER, "READY") \
X(DISABLED_CARRIER, "DISABLED") \
X(BUSY_CARRIER, "BUSY")
typedef enum {
#define X(name, str) name,
CARRIER_STATE
#undef X
CARRIER_COUNT
} carrier_state_e;
carrier_state_e str_to_enum_carrier(const char* value);
typedef struct {
hardware_notif_t hardware;
ptp_state_e ptp_state; // "LOCKED", "FREERUN", "HOLDOVER"
carrier_state_e rx_carrier_state; // "READY", "DISABLED", "BUSY"
carrier_state_e tx_carrier_state; // "READY", "DISABLED", "BUSY"
bool config_change;
// to be extended with any notification callback
@@ -112,6 +188,8 @@ typedef struct {
} ru_session_list_t;
void free_ru_session_list(ru_session_list_t *src);
bool get_config_for_xran(const char *buffer, const int max_num_ant, xran_mplane_t *xran_mplane);
bool get_uplane_info(const char *buffer, ru_mplane_config_t *ru_mplane_config);

51
radio/fhi_72/mplane/subscribe-mplane.c
View File

@@ -30,13 +30,8 @@
static void recv_notif_v1(const struct nc_notif *notif, ru_notif_t *answer)
{
const char *node_name = notif->tree->child->attr->name;
const char *value = notif->tree->child->attr->value_str;
if (strcmp(node_name, "sync-state")) {
if (strcmp(value, "LOCKED") == 0) {
answer->ptp_state = true;
} else {
answer->ptp_state = false;
}
answer->ptp_state = str_to_enum_ptp(notif->tree->child->attr->value_str);
}
// carriers state - to be filled
@@ -52,6 +47,8 @@ static void notif_clb_v1(struct nc_session *session, const struct nc_notif *noti
MP_LOG_I("\nReceived notification at (%s)\n%s\n", notif->datetime, subs_reply);
recv_notif_v1(notif, answer);
free(subs_reply);
}
#elif MPLANE_V2
static void log_v2_pm_info(const char *ru_ip_add, struct lyd_node_inner *stats)
@@ -85,33 +82,36 @@ static void log_v2_pm_info(const char *ru_ip_add, struct lyd_node_inner *stats)
meas_list[7], count_list[7]);
}
static void get_hardware_states(struct lyd_node_inner *op, ru_notif_t *answer)
{
struct lyd_node *child = NULL;
LY_LIST_FOR(op->child, child) {
if (strcmp(child->schema->name, "admin-state") == 0) {
answer->hardware.admin_state = str_to_enum_admin(lyd_get_value(child));
} else if (strcmp(child->schema->name, "availability-state") == 0) {
answer->hardware.avail_state = str_to_enum_avail(lyd_get_value(child));
}
}
}
static void recv_notif_v2(struct lyd_node_inner *op, ru_notif_t *answer)
{
const char *notif = op->schema->name;
if (strcmp(notif, "synchronization-state-change") == 0) {
const char *value = lyd_get_value(op->child);
if (strcmp(value, "LOCKED") == 0) {
answer->ptp_state = true;
} else { // "FREERUN" or "HOLDOVER"
answer->ptp_state = false;
}
answer->ptp_state = str_to_enum_ptp(lyd_get_value(op->child));
} else if (strcmp(notif, "rx-array-carriers-state-change") == 0) {
const char *value = lyd_get_value(lyd_child(op->child)->next);
if (strcmp(value, "READY") == 0) {
answer->rx_carrier_state = true;
} else { // "DISABLED" or "BUSY"
answer->rx_carrier_state = false;
}
answer->rx_carrier_state = str_to_enum_carrier(lyd_get_value(lyd_child(op->child)->next));
} else if (strcmp(notif, "tx-array-carriers-state-change") == 0) {
const char *value = lyd_get_value(lyd_child(op->child)->next);
if (strcmp(value, "READY") == 0) {
answer->tx_carrier_state = true;
} else { // "DISABLED" or "BUSY"
answer->tx_carrier_state = false;
}
answer->tx_carrier_state = str_to_enum_carrier(lyd_get_value(lyd_child(op->child)->next));
} else if (strcmp(notif, "netconf-config-change") == 0) {
answer->config_change = true;
} else if (strcmp(notif, "hardware-state-oper-enabled") == 0) {
answer->hardware.oper_state = ENABLED_OPER;
get_hardware_states(op, answer);
} else if (strcmp(notif, "hardware-state-oper-disabled") == 0) {
answer->hardware.oper_state = DISABLED_OPER;
get_hardware_states(op, answer);
}
}
@@ -126,11 +126,14 @@ static void notif_clb_v2(struct nc_session *session, const struct lyd_node *envp
struct lyd_node_inner *op_inner = (struct lyd_node_inner *)op;
if (strcmp(op_inner->schema->name, "measurement-result-stats") == 0) {
log_v2_pm_info(ru_ip_add, op_inner);
free(subs_reply);
return;
}
MP_LOG_I("Received notification from RU \"%s\" at (%s)\n%s\n", ru_ip_add, ((struct lyd_node_opaq *)lyd_child(envp))->value, subs_reply);
recv_notif_v2(op_inner, answer);
free(subs_reply);
}
#endif

22
radio/fhi_72/mplane/xml/get-xml.c
View File

@@ -23,8 +23,9 @@
#include <libxml/parser.h>
#include <string.h>
#include <stdlib.h>
static char *find_ru_xml_node(xmlNode *node, const char *filter)
static xmlChar *find_ru_xml_node(xmlNode *node, const char *filter)
{
for (xmlNode *cur_node = node; cur_node; cur_node = cur_node->next) {
if (cur_node->type != XML_ELEMENT_NODE)
@@ -39,9 +40,9 @@ static char *find_ru_xml_node(xmlNode *node, const char *filter)
break;
}
}
return (char *)xmlNodeGetContent(target_node);
return xmlNodeGetContent(target_node);
}
char *answer = find_ru_xml_node(cur_node->children, filter);
xmlChar *answer = find_ru_xml_node(cur_node->children, filter);
if (answer != NULL) {
return answer;
}
@@ -56,7 +57,13 @@ char *get_ru_xml_node(const char *buffer, const char *filter)
xmlDoc *doc = xmlReadMemory(buffer, len, NULL, NULL, 0);
xmlNode *root_element = xmlDocGetRootElement(doc);
return find_ru_xml_node(root_element->children, filter);
xmlChar *content = find_ru_xml_node(root_element->children, filter);
char *value = strdup((char *)content);
xmlFree(content);
xmlFreeDoc(doc);
return value;
}
static void find_ru_xml_list(xmlNode *node, const char *filter, char ***match_list, size_t *count)
@@ -74,11 +81,12 @@ static void find_ru_xml_list(xmlNode *node, const char *filter, char ***match_li
break;
}
}
const char *content = (const char *)xmlNodeGetContent(name_node ? name_node : cur_node);
xmlChar *content = xmlNodeGetContent(name_node ? name_node : cur_node);
if (content) {
*match_list = realloc(*match_list, (*count + 1) * sizeof(char *));
(*match_list)[*count] = strdup(content);
(*match_list)[*count] = strdup((char *)content);
(*count)++;
xmlFree(content);
}
}
find_ru_xml_list(cur_node->children, filter, match_list, count);
@@ -93,4 +101,6 @@ void get_ru_xml_list(const char *buffer, const char *filter, char ***match_list,
xmlNode *root_element = xmlDocGetRootElement(doc);
find_ru_xml_list(root_element->children, filter, match_list, count);
xmlFreeDoc(doc);
}

133
radio/fhi_72/mplane/yang/create-yang-config.c
View File

@@ -233,85 +233,91 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
ret = lyd_new_path(NULL, (struct ly_ctx *)ru_session->ctx, "/o-ran-uplane-conf:user-plane-configuration", NULL, 0, root);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create root \"user-plane-configuration\" node.\n");
if (ru_session->ru_mplane_config.rx_carriers.num != 1 || ru_session->ru_mplane_config.tx_carriers.num !=1)
MP_LOG_I("Only one carrier supported at the moment.\n");
const size_t num_rx_ch = oai->rx_num_channels / num_rus;
// RX carriers
struct lyd_node *rx_carrier_node = NULL;
ret = lyd_new_list(*root, NULL, "rx-array-carriers", 0, &rx_carrier_node, ru_session->ru_mplane_config.rx_carriers.name[0]);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"rx-array-carriers\" node.\n");
const size_t num_rx_carriers = (ru_session->ru_mplane_config.rx_carriers.num == 1) ? 1 : num_rx_ch;
for (size_t i = 0; i < num_rx_carriers; i++) {
struct lyd_node *rx_carrier_node = NULL;
ret = lyd_new_list(*root, NULL, "rx-array-carriers", 0, &rx_carrier_node, ru_session->ru_mplane_config.rx_carriers.name[i]);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"rx-array-carriers\" node.\n");
char rx_freq[16];
snprintf(rx_freq, sizeof(rx_freq), "%.0f", oai->rx_freq[0]);
ret = lyd_new_term(rx_carrier_node, NULL, "center-of-channel-bandwidth", rx_freq, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"center-of-channel-bandwidth\" node.\n");
char rx_freq[16];
snprintf(rx_freq, sizeof(rx_freq), "%.0f", oai->rx_freq[0]);
ret = lyd_new_term(rx_carrier_node, NULL, "center-of-channel-bandwidth", rx_freq, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"center-of-channel-bandwidth\" node.\n");
char rx_arfcn[16];
snprintf(rx_arfcn, sizeof(rx_arfcn), "%d", to_nrarfcn(oai->nr_band, oai->rx_freq[0], oai->nr_scs_for_raster, oai->rx_bw));
ret = lyd_new_term(rx_carrier_node, NULL, "absolute-frequency-center", rx_arfcn, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"absolute-frequency-center\" node.\n");
char rx_arfcn[16];
snprintf(rx_arfcn, sizeof(rx_arfcn), "%d", to_nrarfcn(oai->nr_band, oai->rx_freq[0], oai->nr_scs_for_raster, oai->rx_bw));
ret = lyd_new_term(rx_carrier_node, NULL, "absolute-frequency-center", rx_arfcn, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"absolute-frequency-center\" node.\n");
char rx_bw[16];
snprintf(rx_bw, sizeof(rx_bw), "%.0f", oai->rx_bw);
ret = lyd_new_term(rx_carrier_node, NULL, "channel-bandwidth", rx_bw, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"channel-bandwidth\" node.\n");
char rx_bw[16];
snprintf(rx_bw, sizeof(rx_bw), "%.0f", oai->rx_bw);
ret = lyd_new_term(rx_carrier_node, NULL, "channel-bandwidth", rx_bw, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"channel-bandwidth\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "downlink-radio-frame-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-radio-frame-offset\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "downlink-radio-frame-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-radio-frame-offset\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "downlink-sfn-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-sfn-offset\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "downlink-sfn-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-sfn-offset\" node.\n");
// gain offset applied uniformly across all array elements or layers
// needs to be within <gain-correction-range>
ret = lyd_new_term(rx_carrier_node, NULL, "gain-correction", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"gain-correction\" node.\n");
// gain offset applied uniformly across all array elements or layers
// needs to be within <gain-correction-range>
ret = lyd_new_term(rx_carrier_node, NULL, "gain-correction", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"gain-correction\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "n-ta-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"n-ta-offset\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "n-ta-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"n-ta-offset\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "active", "ACTIVE", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"active\" node.\n");
ret = lyd_new_term(rx_carrier_node, NULL, "active", "ACTIVE", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"active\" node.\n");
}
const size_t num_tx_ch = oai->tx_num_channels / num_rus;
// TX carriers
struct lyd_node *tx_carrier_node = NULL;
ret = lyd_new_list(*root, NULL, "tx-array-carriers", 0, &tx_carrier_node, ru_session->ru_mplane_config.tx_carriers.name[0]);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"tx-array-carriers\" node.\n");
const size_t num_tx_carriers = (ru_session->ru_mplane_config.tx_carriers.num == 1) ? 1 : num_tx_ch;
for (size_t i = 0; i < num_tx_carriers; i++) {
struct lyd_node *tx_carrier_node = NULL;
ret = lyd_new_list(*root, NULL, "tx-array-carriers", 0, &tx_carrier_node, ru_session->ru_mplane_config.tx_carriers.name[i]);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"tx-array-carriers\" node.\n");
char tx_freq[16];
snprintf(tx_freq, sizeof(tx_freq), "%.0f", oai->tx_freq[0]);
ret = lyd_new_term(tx_carrier_node, NULL, "center-of-channel-bandwidth", tx_freq, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"center-of-channel-bandwidth\" node.\n");
char tx_freq[16];
snprintf(tx_freq, sizeof(tx_freq), "%.0f", oai->tx_freq[0]);
ret = lyd_new_term(tx_carrier_node, NULL, "center-of-channel-bandwidth", tx_freq, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"center-of-channel-bandwidth\" node.\n");
char tx_arfcn[16];
snprintf(tx_arfcn, sizeof(tx_arfcn), "%d", to_nrarfcn(oai->nr_band, oai->tx_freq[0], oai->nr_scs_for_raster, oai->tx_bw));
ret = lyd_new_term(tx_carrier_node, NULL, "absolute-frequency-center", tx_arfcn, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"absolute-frequency-center\" node.\n");
char tx_arfcn[16];
snprintf(tx_arfcn, sizeof(tx_arfcn), "%d", to_nrarfcn(oai->nr_band, oai->tx_freq[0], oai->nr_scs_for_raster, oai->tx_bw));
ret = lyd_new_term(tx_carrier_node, NULL, "absolute-frequency-center", tx_arfcn, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"absolute-frequency-center\" node.\n");
char tx_bw[16];
snprintf(tx_bw, sizeof(tx_bw), "%.0f", oai->tx_bw);
ret = lyd_new_term(tx_carrier_node, NULL, "channel-bandwidth", tx_bw, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"channel-bandwidth\" node.\n");
char tx_bw[16];
snprintf(tx_bw, sizeof(tx_bw), "%.0f", oai->tx_bw);
ret = lyd_new_term(tx_carrier_node, NULL, "channel-bandwidth", tx_bw, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"channel-bandwidth\" node.\n");
// oai->tx_gain takes the value of att_tx from the RU section of gNB config file
// we assume the same gain is applied to all channels; same as above for the frequency
const double tx_gain_value = ((oai->tx_gain[0] * 10000) < ru_session->xran_mplane.max_tx_gain) ? (oai->tx_gain[0] * 10000) : ru_session->xran_mplane.max_tx_gain;
char tx_gain_str[8];
snprintf(tx_gain_str, sizeof(tx_gain_str), "%.f", tx_gain_value);
ret = lyd_new_term(tx_carrier_node, NULL, "gain", tx_gain_str, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"gain\" node.\n");
// oai->tx_gain takes the value of att_tx from the RU section of gNB config file
// we assume the same gain is applied to all channels; same as above for the frequency
const double tx_gain_value = ((oai->tx_gain[0] * 10000) < ru_session->xran_mplane.max_tx_gain) ? (oai->tx_gain[0] * 10000) : ru_session->xran_mplane.max_tx_gain;
char tx_gain_str[8];
snprintf(tx_gain_str, sizeof(tx_gain_str), "%.f", tx_gain_value);
ret = lyd_new_term(tx_carrier_node, NULL, "gain", tx_gain_str, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"gain\" node.\n");
ret = lyd_new_term(tx_carrier_node, NULL, "downlink-radio-frame-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-radio-frame-offset\" node.\n");
ret = lyd_new_term(tx_carrier_node, NULL, "downlink-radio-frame-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-radio-frame-offset\" node.\n");
ret = lyd_new_term(tx_carrier_node, NULL, "downlink-sfn-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-sfn-offset\" node.\n");
ret = lyd_new_term(tx_carrier_node, NULL, "downlink-sfn-offset", "0", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"downlink-sfn-offset\" node.\n");
ret = lyd_new_term(tx_carrier_node, NULL, "active", "ACTIVE", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"active\" node.\n");
ret = lyd_new_term(tx_carrier_node, NULL, "active", "ACTIVE", 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"active\" node.\n");
}
// PUSCH & PRACH endpoints
const size_t num_rx_ch = oai->rx_num_channels / num_rus;
for (size_t i = 0; i < num_rx_ch; i++) {
struct lyd_node *pusch_node = NULL;
ret = lyd_new_list(*root, NULL, "low-level-rx-endpoints", 0, &pusch_node, ru_session->ru_mplane_config.rx_endpoints.name[i]);
@@ -330,7 +336,6 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
}
// PDSCH endpoints
const size_t num_tx_ch = oai->tx_num_channels / num_rus;
for (size_t i = 0; i < num_tx_ch; i++) {
struct lyd_node *pdsch_node = NULL;
ret = lyd_new_list(*root, NULL, "low-level-tx-endpoints", 0, &pdsch_node, ru_session->ru_mplane_config.tx_endpoints.name[i]);
@@ -342,6 +347,7 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
// PUSCH and PRACH links
for (size_t i = 0; i < num_rx_ch; i++) {
const size_t rx_carrier_id = (num_rx_carriers == 1) ? 0 : i;
// PUSCH
struct lyd_node *pusch_link_node = NULL;
char pusch_link[16];
@@ -352,7 +358,7 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
ret = lyd_new_term(pusch_link_node, NULL, "processing-element", u_proc_elem, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"processing-element\" node.\n");
ret = lyd_new_term(pusch_link_node, NULL, "rx-array-carrier", ru_session->ru_mplane_config.rx_carriers.name[0], 0, NULL);
ret = lyd_new_term(pusch_link_node, NULL, "rx-array-carrier", ru_session->ru_mplane_config.rx_carriers.name[rx_carrier_id], 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"rx-array-carrier\" node.\n");
ret = lyd_new_term(pusch_link_node, NULL, "low-level-rx-endpoint", ru_session->ru_mplane_config.rx_endpoints.name[i], 0, NULL);
@@ -368,7 +374,7 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
ret = lyd_new_term(prach_link_node, NULL, "processing-element", u_proc_elem, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"processing-element\" node.\n");
ret = lyd_new_term(prach_link_node, NULL, "rx-array-carrier", ru_session->ru_mplane_config.rx_carriers.name[0], 0, NULL);
ret = lyd_new_term(prach_link_node, NULL, "rx-array-carrier", ru_session->ru_mplane_config.rx_carriers.name[rx_carrier_id], 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"rx-array-carrier\" node.\n");
const size_t prach_endpoint_name_offset = i + (ru_session->ru_mplane_config.rx_endpoints.num / 2);
@@ -378,6 +384,7 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
// PDSCH links
for (size_t i = 0; i < num_tx_ch; i++) {
const size_t tx_carrier_id = (num_tx_carriers == 1) ? 0 : i;
struct lyd_node *pdsch_link_node = NULL;
char pdsch_link[16];
snprintf(pdsch_link, sizeof(pdsch_link), "%s%ld", "PdschLink", i);
@@ -387,7 +394,7 @@ static bool create_uplane_conf_v2(const ru_session_t *ru_session, const openair0
ret = lyd_new_term(pdsch_link_node, NULL, "processing-element", u_proc_elem, 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"processing-element\" node.\n");
ret = lyd_new_term(pdsch_link_node, NULL, "tx-array-carrier", ru_session->ru_mplane_config.tx_carriers.name[0], 0, NULL);
ret = lyd_new_term(pdsch_link_node, NULL, "tx-array-carrier", ru_session->ru_mplane_config.tx_carriers.name[tx_carrier_id], 0, NULL);
VERIFY_SUCCESS(ret == LY_SUCCESS, "[MPLANE] Failed to create \"tx-array-carrier\" node.\n");
ret = lyd_new_term(pdsch_link_node, NULL, "low-level-tx-endpoint", ru_session->ru_mplane_config.tx_endpoints.name[i], 0, NULL);

39
radio/fhi_72/mplane/yang/get-yang.c
View File

@@ -42,20 +42,30 @@ static bool store_schemas(xmlNode *node, ru_session_t *ru_session, struct ly_ctx
if (strcmp((const char *)cur_node->name, "schema") == 0) {
xmlNode *name_node = xmlFirstElementChild(cur_node);
char *module_name = (char *)xmlNodeGetContent(name_node);
xmlChar *module_name = xmlNodeGetContent(name_node);
xmlNode *revision_node = xmlNextElementSibling(name_node);
char *module_revision = (char *)xmlNodeGetContent(revision_node);
xmlChar *module_revision = xmlNodeGetContent(revision_node);
xmlNode *format_node = xmlNextElementSibling(revision_node);
char *module_format = (char *)xmlNodeGetContent(format_node);
xmlChar *module_format = xmlNodeGetContent(format_node);
if (strcmp(module_format, "yang") != 0)
if (strcmp((char*)module_format, "yang") != 0) {
xmlFree(module_name);
xmlFree(module_revision);
xmlFree(module_format);
continue;
}
MP_LOG_I("RPC request to RU \"%s\" = <get-schema> for module \"%s\".\n", ru_session->ru_ip_add, module_name);
struct nc_rpc *get_schema_rpc = nc_rpc_getschema(module_name, module_revision, "yang", param);
struct nc_rpc *get_schema_rpc = nc_rpc_getschema((char*)module_name, (char*)module_revision, "yang", param);
char *schema_data = NULL;
bool success = rpc_send_recv((struct nc_session *)ru_session->session, get_schema_rpc, wd, timeout, &schema_data);
AssertError(success, return false, "[MPLANE] Unable to get schema for module \"%s\" from RU \"%s\".\n", module_name, ru_session->ru_ip_add);
if (!success) {
MP_LOG_W("[MPLANE] Unable to get schema for module \"%s\" from RU \"%s\".\n", module_name, ru_session->ru_ip_add);
xmlFree(module_name);
xmlFree(module_revision);
xmlFree(module_format);
return false;
}
if (schema_data) {
#ifdef MPLANE_V1
@@ -68,11 +78,21 @@ static bool store_schemas(xmlNode *node, ru_session_t *ru_session, struct ly_ctx
if (!mod) {
MP_LOG_W("Unable to load module \"%s\" from RU \"%s\".\n", module_name, ru_session->ru_ip_add);
nc_rpc_free(get_schema_rpc);
#ifdef MPLANE_V1
ly_ctx_destroy(*ctx, NULL);
#elif defined MPLANE_V2
ly_ctx_destroy(*ctx);
return false;
}
#endif
xmlFree(module_name);
xmlFree(module_revision);
xmlFree(module_format);
return false;
}
}
nc_rpc_free(get_schema_rpc);
xmlFree(module_name);
xmlFree(module_revision);
xmlFree(module_format);
}
}
@@ -105,6 +125,7 @@ bool load_yang_models(ru_session_t *ru_session, const char *buffer)
xmlNode *root_element = xmlDocGetRootElement(doc);
bool success = load_from_operational_ds(root_element->children, ru_session, ctx);
xmlFreeDoc(doc);
if (success) {
MP_LOG_I("Successfully loaded all yang modules from operational datastore for RU \"%s\".\n", ru_session->ru_ip_add);
return true;
@@ -116,7 +137,7 @@ bool load_yang_models(ru_session_t *ru_session, const char *buffer)
1) the yang models order is not good - the dependancy models have to be loaded first
2) earlier O-RAN yang versions (e.g. v4) is not properly defined (i.e. optional parameters should not be included by default) */
const char *yang_dir = YANG_MODELS;
const char *yang_models[] = {"ietf-interfaces", "iana-if-type", "ietf-ip", "iana-hardware", "ietf-hardware", "o-ran-interfaces", "o-ran-module-cap", "o-ran-compression-factors", "o-ran-processing-element", "o-ran-uplane-conf", "ietf-netconf-acm", "ietf-crypto-types", "o-ran-file-management", "o-ran-performance-management"};
const char *yang_models[] = {"ietf-interfaces", "iana-if-type", "ietf-ip", "iana-hardware", "ietf-hardware", "o-ran-wg4-features", "o-ran-interfaces", "o-ran-module-cap", "o-ran-compression-factors", "ietf-crypto-types", "o-ran-usermgmt", "o-ran-processing-element", "o-ran-hardware", "o-ran-common-yang-types", "o-ran-delay-management", "o-ran-uplane-conf", "ietf-netconf-acm", "o-ran-file-management", "o-ran-performance-management"};
#ifdef MPLANE_V1
*ctx = ly_ctx_new(yang_dir, 0);

1985
radio/fhi_72/mplane/yang/models/ietf-crypto-types.yang
View File

File diff suppressed because it is too large Load Diff

449
radio/fhi_72/mplane/yang/models/o-ran-common-yang-types.yang Normal file
View File

@@ -0,0 +1,449 @@
module o-ran-common-yang-types {
yang-version 1.1;
namespace "urn:o-ran:common-yang-types:1.0";
prefix "o-ran-types";
import ietf-inet-types {
prefix inet;
}
organization "O-RAN Alliance";
contact
"www.o-ran.org";
description
"This module defines ORAN common YANG types.
Copyright 2023 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the above disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the above disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the Members of the O-RAN Alliance nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2023-08-14" {
description
"version 2.0.0
1) New availability status typedef";
reference "ORAN-WG1.IM.0-v01.00";
}
revision "2022-08-15" {
description
"version 1.1.0
1) style guide corrections";
reference "ORAN-WG1.IM.0-v01.00";
}
revision "2020-10-10" {
description
"version 1.0.0
1) Initial creation";
reference "ORAN-WG1.IM.0-v01.00";
}
typedef version {
type string {
pattern '[0-9]+(\.[0-9]+){1,2}';
}
description
"Definition used to represent a version of an interface.";
}
typedef timezone-name {
type string;
description
"A time zone name as used by the Time Zone Database,
sometimes referred to as the 'Olson Database'.
The complete set of valid values is defined in
https://www.iana.org/time-zones.
The exact set of supported values is an
implementation-specific matter.";
reference
"RFC 6557: Procedures for Maintaining the Time Zone Database
IANA Time Zone Database https://www.iana.org/time-zones ";
}
typedef protocol {
type enumeration {
enum ECPRI {
description
"Indicates that an O-RU supports the ecpri header format
for the C/U plane";
}
enum IEEE-1914-3 {
description
"Indicates that an O-RU supports the 1914.3 header format
for the C/U plane";
}
}
description "the type of C/U plane protocol";
}
typedef duplex-scheme {
type enumeration {
enum TDD {
description
"TDD scheme";
}
enum FDD {
description
"FDD scheme";
}
}
description
"Type of duplex scheme O-RU supports.";
}
typedef active {
type enumeration {
enum INACTIVE {
description
"Carrier does not provide signal - transmission is disabled";
}
enum SLEEP{
description
"Carrier is fully configured and was active but is energy saving mode";
}
enum ACTIVE{
description
"Carrier is fully configured and properly providing the signal";
}
}
description "the active status of a carrier";
}
typedef state {
type enumeration {
enum DISABLED {
description
"Array carrier is not active - transmission of signal is disabled.";
}
enum BUSY {
description
"Array carrier is processing an operation requested by change of active parameter.
When array carriers is BUSY the transmission of signal is not guaranteed.";
}
enum READY {
description
"Array carrier had completed activation operation - is active and transmission of signal is ongoing.";
}
}
description "the state on an array carrier";
}
typedef transport-session {
type enumeration {
enum ETHERNET {
description "VLAN based CUS Transport ";
}
enum UDP_IP {
// if-feature o-ran-int:UDPIP-BASED-CU-PLANE; How to handle enum value constrained by feature defined in o-ran-interface.yang?
description "UDP/IP based CUS Transport ";
}
enum ALIAS_MAC{
// if-feature o-ran-int:ALIASMAC-BASED-CU-PLANE; How to handle enum value constrained by feature defined in o-ran-interface.yang?
description "Alias MAC address based CUS Transport ";
}
enum SHARED_CELL {
// if-feature o-ran-elements:SHARED_CELL; How to handle enum value constrained by feature defined in o-ran-processing-element.yang?
description "VLAN based CUS Transport used for Shared Cell scenario";
}
}
description "the transport session type";
}
typedef netconf-client-id {
type union {
type inet:ip-address;
type inet:uri;
}
description "A NETCONF client identifier";
}
typedef ca-ra-server-id {
type union {
type inet:ip-address;
type inet:uri;
}
description "A CA/RA Server identifier";
}
typedef segw-id {
type union {
type inet:ip-address;
type inet:uri;
}
description "A SeGW identifier";
}
typedef pcp {
type uint8 {
range "0..7";
}
description
"Priority Code Point. PCP is a 3-bit field that refers to the
class of service applied to a VLAN tagged frame. The
field specifies a priority value between 0 and 7, these values
can be used by quality of service (QoS) to prioritize
different classes of traffic.";
reference
"IEEE 802.1Q-2014: Virtual Bridged Local Area Networks";
}
typedef vlan-id {
type uint16 {
range "1..4094";
}
description
"The VLAN-ID that uniquely identifies a VLAN. This is the 12-bit VLAN-ID
used in the VLAN Tag header.";
reference "[802.1q] 9.6";
}
typedef geographic-coordinate-degree {
type decimal64 {
fraction-digits 8;
}
description
"Decimal degree (DD) used to express latitude and longitude
geographic coordinates.";
}
typedef prach-preamble-format {
type enumeration {
enum LTE-0 {
description
"LTE PRACH Preamble format 0";
}
enum LTE-1 {
description
"LTE PRACH Preamble format 1";
}
enum LTE-2 {
description
"LTE PRACH Preamble format 2";
}
enum LTE-3 {
description
"LTE PRACH Preamble format 3";
}
enum LTE-4 {
description
"LTE PRACH Preamble format 4";
}
enum LTE-NB0 {
description
"LTE Narrowband PRACH format 0";
}
enum LTE-NB1 {
description
"LTE Narrowband PRACH format 1";
}
enum NR-0 {
description
"5GNR PRACH Preamble format 0";
}
enum NR-1 {
description
"5GNR PRACH Preamble format 1";
}
enum NR-2 {
description
"5GNR PRACH Preamble format 2";
}
enum NR-3 {
description
"5GNR PRACH Preamble format 3";
}
enum NR-A1 {
description
"5GNR PRACH Preamble format A1";
}
enum NR-A2 {
description
"5GNR PRACH Preamble format A2";
}
enum NR-A3 {
description
"5GNR PRACH Preamble format A3";
}
enum NR-B1 {
description
"5GNR PRACH Preamble format B1";
}
enum NR-B2 {
description
"5GNR PRACH Preamble format B2";
}
enum NR-B3 {
description
"5GNR PRACH Preamble format B3";
}
enum NR-B4 {
description
"5GNR PRACH Preamble format B4";
}
enum NR-C0 {
description
"5GNR PRACH Preamble format C0";
}
enum NR-C2 {
description
"5GNR PRACH Preamble format C2";
}
enum LTE-NB0-a {
description
"LTE Narrowband PRACH format 0-a";
}
enum LTE-NB1-a {
description
"LTE Narrowband PRACH format 1-a";
}
enum LTE-NB2 {
description
"LTE Narrowband PRACH format 2";
}
}
description
"PRACH preamble format definition";
}
typedef polarisation_type {
type enumeration {
enum MINUS_45 {
description "MINUS_45";
}
enum ZERO {
description "ZERO";
}
enum PLUS_45 {
description "PLUS_45";
}
enum PLUS_90 {
description "PLUS_90";
}
}
description "Type definition for polarisations";
}
typedef bandwidth {
type uint32 {
range "200 | 1400 | 3000 | 5000 | 10000 | 15000 | 20000 | 25000 |
30000 | 40000 | 50000 | 60000 | 70000 | 80000 | 90000 | 100000
| 200000 | 400000" ;
}
units kilohertz;
description
"transmission bandwidth configuration in units of kHz -
covering NBIoT through to New Radio - see 38.104";
}
typedef scs-config-type {
type enumeration {
enum KHZ_15 {
value 0;
description
"15kHz sub carrier spacing";
}
enum KHZ_30 {
value 1;
description
"30kHz sub carrier spacing";
}
enum KHZ_60 {
value 2;
description
"60kHz sub carrier spacing";
}
enum KHZ_120 {
value 3;
description
"120kHz sub carrier spacing";
}
enum KHZ_240 {
value 4;
description
"240kHz sub carrier spacing";
}
enum KHZ_1_25 {
value 12;
description
"1,25kHz sub carrier spacing";
}
enum KHZ_3_75 {
value 13;
description
"3.75kHz sub carrier spacing";
}
enum KHZ_5 {
value 14;
description
"5kHz sub carrier spacing";
}
enum KHZ_7_5 {
value 15;
description
"7.5kHz sub carrier spacing";
}
}
description
"Scs configuration type definition";
}
typedef availability-status {
type union {
type empty;
type enumeration {
enum FAILED {
description
"The resource has an internal fault that prevents it from operating.
The operational state is disabled.";
}
enum DEPENDENCY {
description
"The resource cannot operate because some other resource on which it
depends is unavailable. The operational state is disabled.";
}
}
}
description
"When the value of this attribute is empty set, this implies that none of
the status conditions described in the enumerations are present. Only current relevant status for M-plane defined are listed here";
reference "CCITT Rec. X.731 (1992 E) 8.1.2.3";
}
}

438
radio/fhi_72/mplane/yang/models/o-ran-compression-factors.yang
View File

@@ -13,7 +13,7 @@ module o-ran-compression-factors {
"This module defines the module capabilities for
the O-RAN Radio Unit U-Plane configuration.
Copyright 2020 the O-RAN Alliance.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -39,6 +39,46 @@ module o-ran-compression-factors {
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-08-12" {
description
"version 16.0.0
1) Clarify handling of deprecated leaf compression-format.
2) Add in SINR compression details";
reference "ORAN-WG4.M.0-v16.00";
}
revision "2023-08-14" {
description
"version 13.0.0
1) New compression methods BFP-SRES-MASK-IN-SEC-HEADER and MOD-SRES-MASK-IN-SEC-HEADER.";
reference "ORAN-WG4.M.0-v13.00";
}
revision "2021-12-01" {
description
"version 8.0.0
1) typographical corrections in descriptions.
2) Configuration for Beamforming weights were added together with changes
and updates to compressions.
3) add new beamspace compression enumeration for BEAMSPACE_TYPEII.";
reference "ORAN-WG4.M.0-v08.00";
}
revision "2021-03-22" {
description
"version 4.1.0
1) typographical corrections in descriptions.";
reference "ORAN-WG4.M.0-v04.00";
}
revision "2020-08-10" {
description
"version 4.0.0
@@ -62,7 +102,7 @@ module o-ran-compression-factors {
description
"version 1.1.0
1) changes related to compression bitwidth presentation";
1) changes related to compression bit-width presentation";
reference "ORAN-WG4.M.0-v01.00";
}
@@ -82,6 +122,171 @@ module o-ran-compression-factors {
"Presence of this feature means that O-RU supports configurable fs-offset for compression.";
}
typedef ci-compression-method-def {
type enumeration {
enum NO_COMPRESSION {
description
"No compression will be used";
}
enum BLOCK_FLOATING_POINT {
description
"Block floating point compression and decompression will be used";
}
enum BLOCK_SCALING {
description
"Block scaling compression and decompresion will be used";
}
enum U_LAW {
description
"u-Law compression and decompresion method will be used";
}
}
description
"Available compression methods for channel information (e.g., ST6).";
}
typedef compression-type-def {
type enumeration {
enum STATIC {
description
"Indicates that static compression method will be used (both compression and IQ bitwidth)";
}
enum DYNAMIC {
description
"Indicates that dynamic compression method will be used";
}
}
description
"Compression type that O-DU wants to be supported";
}
typedef bf-compression-method-def {
type enumeration {
enum NO_COMPRESSION {
description
"No compression will be used";
}
enum BLOCK_FLOATING_POINT {
description
"Block floating point compression and decompression will be used";
}
enum BLOCK_SCALING {
description
"Block scaling compression and decompresion will be used";
}
enum U_LAW {
description
"u-Law compression and decompresion method will be used";
}
enum BEAMSPACE {
description
"Beamspace compression and decompression will be used";
}
enum VOID_1 {
description
"Leftover of modulation, not to be used for beamforming weights";
}
enum VOID_2 {
description
"Leftover of block-floating-point-selective-re-sending, not to be used for beamforming weights";
}
enum VOID_3 {
description
"Leftover of modulation-compression-selective-re-sending, not to be used for beamforming weights";
}
enum BEAMSPACE_TYPEII {
description
"Beamspace compression typeII and decompression will be used ";
}
}
description
"Available compression methods for beamforming weights.";
}
typedef compression-method-def {
type enumeration {
enum NO_COMPRESSION {
description
"No compression";
}
enum BLOCK_FLOATING_POINT {
description
"Block floating point compression and decompression method";
}
enum BLOCK_SCALING {
description
"Block scaling compression and decompresion method";
}
enum U_LAW {
description
"u-Law compression and decompresion method";
}
enum VOID_1 {
description
"Leftover of beamspace, not to be used for IQ data.";
}
enum MODULATION {
description
"Modulation compression and decompression method";
}
enum BLOCK-FLOATING-POINT-SELECTIVE-RE-SENDING {
description
"block floating point with selective re sending
compression and decompression method";
}
enum MODULATION-COMPRESSION-SELECTIVE-RE-SENDING {
description
"modulation compression with selective re sending
compression and decompression method";
}
enum BFP-SRES-MASK-IN-SEC-HEADER {
description
"block floating point with selective re sending
compression and decompression method with selective re sending mask in the section header ";
}
enum MOD-SRES-MASK-IN-SEC-HEADER {
description
"modulation compression with selective re sending
compression and decompression method with selective re sending mask in the section header";
}
}
description
"Available compression methods for the data.";
}
typedef sinr-compression-method-def {
type enumeration {
enum BLOCK_FLOATING_POINT {
description
"Block floating point compression and decompression will be used";
}
enum NO_COMPRESSION {
description
"No compression will be used";
}
}
description
"Available compression methods for the SINR.";
}
grouping compression-method-grouping {
description
"Grouping for compression method.";
@@ -89,68 +294,148 @@ module o-ran-compression-factors {
leaf iq-bitwidth {
type uint8;
description
"Bitwidth to be used in compression";
"Bit-width to be used in compression";
}
leaf compression-method {
type enumeration {
enum NO_COMPRESSION {
description
"No compression will be used";
}
enum BLOCK_FLOATING_POINT {
description
"Block floating point compression and decompression will be used";
}
enum BLOCK_SCALING {
description
"Block scaling compression and decompresion will be used";
}
enum U_LAW {
description
"u-Law compression and decompresion method will be used";
}
enum BEAMSPACE {
description
"Beamspace compression and decompression will be used";
}
enum MODULATION {
description
"Modulation compression and decompression will be used";
}
enum BLOCK-FLOATING-POINT-SELECTIVE-RE-SENDING {
description
"block floating point with selective re sending
compression and decompression will be used";
}
enum MODULATION-COMPRESSION-SELECTIVE-RE-SENDING {
description
"modulation compression with selective re sending
compression and decompression will be used";
}
}
type compression-method-def;
description
"Compresion method which can be supported by the O-RU";
"Compression method which can be supported by the O-RU";
}
}
grouping compression-details {
description "";
leaf iq-bitwidth {
type uint8;
description
"Bitwidth to be used in compression";
}
leaf compression-type {
type compression-type-def;
mandatory true;
description
"Compression type that O-DU wants to be supported";
}
leaf bitwidth {
when "../compression-type = 'STATIC'";
type uint8;
status deprecated;
description
"Bitwidth to be used in compression.
This has since been replaced in M-Plane version
2.0.0 with the iq-bitwidth schema node";
}
leaf compression-method {
type compression-method-def;
description
"Compression method which can be supported by the O-RU";
}
uses compresion-format-grp {
status deprecated;
}
}
grouping bf-compression-details {
description "Compression formats defined for beamforming";
leaf iq-bitwidth {
type uint8;
description
"Bitwidth to be used in compression";
}
leaf compression-type {
type compression-type-def;
mandatory true;
description
"Compression type that O-DU wants to be supported";
}
leaf bitwidth {
when "../compression-type = 'STATIC'";
type uint8;
status deprecated;
description
"Bitwidth to be used in compression.
This has since been replaced in M-Plane version
2.0.0 with the iq-bitwidth schema node";
}
leaf compression-method {
type bf-compression-method-def;
description
"Compression method which can be supported by the beamforming";
}
uses compresion-format-grp {
status deprecated;
}
}
grouping sinr-compression-details {
description "Compression formats defined for SINR";
leaf sinr-bitwidth {
type uint8;
description
"Bitwidth to be used in compression";
}
leaf sinr-compression-method {
type sinr-compression-method-def;
description
"Compression method which can be supported by the SINR.";
}
leaf sinr-block-size {
type uint8;
description
"Block size used for reporting SINR.
If the parameter is absent, then the SINR values are sent without zero-padding
i.e., the block size is equal to the number of SINR values
Please refer to CUS specification clause 7.2.10 for more details.";
}
}
// *********** Deprecated ***********
grouping compression-formats {
status deprecated;
description
"Grouping deicated to list compression formats as choice";
"Grouping deicated to list compression formats as choice.";
uses compresion-format-grp {
status deprecated;
}
}
grouping compresion-format-grp {
status deprecated;
description
"Grouping to for compression format choice";
choice compression-format {
status deprecated;
description
"Choice of compression format for particular element";
"Choice of compression format for particular element.
Note: This method is deprecated. All should be done as emumeration as details are configured
by udCompHdr in CU-Plane messaging.
NOTE: Changing the configuration from any compression format to no compression would require
a delete-config followed by an edit-config";
case no-compresison {
description "Compression for beam weights is not supported.";
}
case block-floating-point {
description "Block floating point compression and decompression is supported.";
description "Block floating-point compression and decompression is supported.";
leaf exponent {
type uint8 {
@@ -162,7 +447,7 @@ module o-ran-compression-factors {
case block-floating-point-selective-re-sending {
description
"Block floating point with selective re sending compression and decompression is supported.";
"Block floating-point with selective re sending compression and decompression is supported.";
leaf sres-exponent {
type uint8 {
@@ -173,7 +458,7 @@ module o-ran-compression-factors {
}
case block-scaling {
description "Block scaling compression and decompresion is supported.";
description "Block scaling compression and decompression is supported.";
leaf block-scalar {
type uint8;
description
@@ -182,7 +467,7 @@ module o-ran-compression-factors {
}
case u-law {
description "u-Law compression and decompresion method is supported.";
description "u-Law compression and decompression method is supported.";
leaf comp-bit-width {
type uint8 {
range "0..15";
@@ -218,7 +503,7 @@ module o-ran-compression-factors {
type uint8 {
range "0..1";
}
description "Constallation shift flag";
description "Constellation shift flag";
}
leaf mod-comp-scaler {
@@ -235,7 +520,7 @@ module o-ran-compression-factors {
type uint8 {
range "0..1";
}
description "Constallation shift flag";
description "Constellation shift flag";
}
leaf sres-mod-comp-scaler {
@@ -250,54 +535,50 @@ module o-ran-compression-factors {
}
grouping compression-params {
status deprecated;
description
"Parameters to define compression";
leaf compression-type {
type enumeration {
enum STATIC {
description
"Indicates that static compression method will be used (both compression and IQ bitwidth)";
}
enum DYNAMIC {
description
"Indicates that dynamic compression method will be used";
}
}
type compression-type-def;
mandatory true;
description
"Compression type that O-DU wants to be supported";
}
// *********** TO BE REMOVED ***********
leaf bitwidth {
when "../compression-type = 'STATIC'";
type uint8;
status deprecated;
description
"Bitwidth to be used in compression.
"Bit-width to be used in compression.
This has since been replaced in M-Plane version
2.0.0 with the iq-bitwidth schema node";
}
// *************************************
uses compression-formats;
uses compression-formats {
status deprecated;
}
}
grouping compression-parameters {
status deprecated;
description
"Parameters used to define description type";
leaf iq-bitwidth {
type uint8;
description
"Bitwidth to be used in compression";
"Bit-width to be used in compression";
}
uses compression-formats;
uses compression-formats {
status deprecated;
}
}
grouping format-of-iq-sample {
status deprecated;
description
"Indicates module capabilities about IQ samples";
@@ -312,17 +593,20 @@ module o-ran-compression-factors {
type boolean;
description
"Informs if O-RU supports realtime variable bit with";
"Informs if O-RU supports real-time variable bit with";
}
list compression-method-supported {
uses compression-parameters;
status deprecated;
uses compression-parameters {
status deprecated;
}
description
"List of supported compression methods by O-RU
Note: if O-RU supports different compression methods per endpoint
then please refer do endpoints to have information what
exactly is supported on a paticular endpoint";
exactly is supported on a particular endpoint";
}
leaf syminc-supported {
@@ -353,16 +637,6 @@ module o-ran-compression-factors {
}
}
// *********** Deprecated End ***********
grouping compression-details {
description "";
leaf iq-bitwidth {
type uint8;
description
"Bitwidth to be used in compression";
}
uses compression-params;
}
}

591
radio/fhi_72/mplane/yang/models/o-ran-delay-management.yang Normal file
View File

@@ -0,0 +1,591 @@
module o-ran-delay-management {
yang-version 1.1;
namespace "urn:o-ran:delay:1.0";
prefix "o-ran-delay";
import o-ran-wg4-features {
prefix "feat";
}
organization "O-RAN Alliance";
contact
"www.o-ran.org";
description
"This module covers off aspects of O-DU to O-RU delay management,
including configuration data related to O-RU transmission and reception
windows.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the above disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the above disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the Members of the O-RAN Alliance nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-08-12" {
description
"version 16.0.0
1) Removing the range to align bandwidth type to same bandwidth type as
in uplane-config module and module-cap modules.
2) Add in Ta3-2g data processing delay";
reference "ORAN-WG4.M.0-v16.00";
}
revision "2024-04-15" {
description
"version 15.0.0
1) add support for for beamforming list and delay profiles(s) per endpoint.";
reference "ORAN-WG4.M.0-v15.00";
}
revision "2022-08-15" {
description
"version 10.0.0
1) introducing new feature for ACK NACK feedback.";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2021-12-01" {
description
"version 8.0.0
1) typographical corrections in descriptions.
2) add new schema node beam-context-gap-period.";
reference "ORAN-WG4.M.0-v08.00";
}
revision "2020-08-10" {
description
"version 4.0.0
1) introduction of new t1a-max-cp-dl leaf to enable decoupled timing between C- and U-Plane";
reference "ORAN-WG4.M.0-v04.00";
}
revision "2019-07-03" {
description
"version 1.1.0
1) fixing descriptions of ta3-min and ta3-max.
2) introducing grouping/uses to enable model re-use by WG5";
reference "ORAN-WG4.M.0-v01.00";
}
revision "2019-02-04" {
description
"version 1.0.0
1) imported model from xRAN
2) changed namespace and reference from xran to o-ran";
reference "ORAN-WG4.M.0-v01.00";
}
feature ADAPTIVE-RU-PROFILE {
description
"This feature indicates that the O-RU supports adaptive O-RU delay profile
based on information provided by the NETCONF client.";
}
typedef bandwidth {
type uint32;
units kilohertz;
description
"transmission bandwidth configuration in units of kHz -
covering NB-IoT through to New Radio.
Value shall correspond to a value defined in 38.104.";
}
grouping bandwidth-configuration {
description
"Grouping for bandwidth and SCS configuration";
leaf bandwidth {
type bandwidth;
description
"transmission bandwidth configuration in units of kHz -
covering NBIoT through to New Radio - see 38.104";
}
leaf subcarrier-spacing {
type uint32 {
range "0 .. 240000 ";
}
units Hertz;
description "sub-carrier spacing in Hz";
}
}
grouping t2a-up {
description
"configuration of t2a for uplink";
leaf t2a-min-up {
type uint32;
units nanoseconds;
mandatory true;
description
"the minimum O-RU data processing delay between receiving IQ data
message over the fronthaul interface and transmitting
the corresponding first IQ sample at the antenna";
}
leaf t2a-max-up {
type uint32;
units nanoseconds;
mandatory true;
description
"the earliest allowable time when a data packet is received before
the corresponding first IQ sample is transmitted at the antenna";
}
}
grouping t2a-cp-dl {
description
"Grouping for t2a CP for downlink";
leaf t2a-min-cp-dl {
type uint32;
units nanoseconds;
mandatory true;
description
"the minimum O-RU data processing delay between receiving downlink
real time control plane message over the fronthaul interface and
transmitting the corresponding first IQ sample at the antenna";
}
leaf t2a-max-cp-dl {
type uint32;
units nanoseconds;
mandatory true;
description
"the earliest allowable time when a downlink real time control message
is received before the corresponding first IQ sample is transmitted at
the antenna";
}
}
grouping ta3 {
description
"Grouping for ta3 configuration";
leaf ta3-min {
type uint32;
units nanoseconds;
mandatory true;
description
"the minimum O-RU data processing delay between receiving an IQ sample
at the antenna and transmitting the first data sample over the
fronthaul interface";
}
leaf ta3-max {
type uint32;
units nanoseconds;
mandatory true;
description
"the maximum O-RU data processing delay between receiving an IQ sample
at the antenna and transmitting the last data sample over the
fronthaul interface";
}
}
grouping t2a-cp-ul {
description
"Grouping for t2a CP uplink";
leaf t2a-min-cp-ul {
type uint32;
units nanoseconds;
mandatory true;
description
"the minimum O-RU data processing delay between receiving real time
up-link control plane message over the fronthaul interface and
receiving the first IQ sample at the antenna";
}
leaf t2a-max-cp-ul {
type uint32;
units nanoseconds;
mandatory true;
description
"the earliest allowable time when a real time up-link control message
is received before the corresponding first IQ sample is received at
the antenna";
}
}
grouping ta3-ack {
description
"Grouping for ta3-ack configuration";
leaf ta3-min-ack {
type int32;
units nanoseconds;
description
"the minimum delay between the DL/UL air reference point (tDL=0 or tUL=0) of symbol M
and the time O-RU sends section type 8 (ACK/NACK feedback) to O-DU.
This value can be negative, which indicates it is in advance of the air reference point.
This leaf only exists if section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback)
are supported by at least one endpoint.";
}
leaf ta3-max-ack {
type int32;
units nanoseconds;
description
"the maximum delay between the DL/UL air reference point (tDL=0 or tUL=0) of symbol M
and the time O-RU sends section type 8 (ACK/NACK feedback) to O-DU.
This value can be negative, which indicates it is in advance of the air reference point.
This leaf only exists if section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback)
are supported by at least one endpoint.";
}
}
grouping ta3-2g {
description
"Grouping for ta3-2g configuration";
leaf ta3-min-2g {
if-feature feat:RRM-MEAS-REPORTING;
type uint32;
units nanoseconds;
description
"The minimum O-RU data processing delay between receiving an IQ sample
at the antenna and transmitting a C-Plane message carrying RRM measurements
over the fronthaul interface.
Please refer to CUS specification clause 4.4.3 for more details.";
}
leaf ta3-max-2g {
if-feature feat:RRM-MEAS-REPORTING;
type uint32;
units nanoseconds;
description
"The maximum O-RU data processing delay between receiving an IQ sample
at the antenna and transmitting a C-Plane message carrying RRM measurements
over the fronthaul interface.
Please refer to CUS specification clause 4.4.3 for more details.";
}
}
grouping ru-delay-profile {
description
"Grouping for RU delay profile";
uses t2a-up;
uses t2a-cp-dl;
leaf tcp-adv-dl {
type uint32;
units nanoseconds;
mandatory true;
description
"the time difference (advance) between the reception window for
downlink real time Control messages and reception window for the
corresponding IQ data messages.";
}
uses ta3;
uses t2a-cp-ul;
uses ta3-ack;
uses ta3-2g;
}
grouping o-du-delay-profile {
description
"Grouping for O-DU delay profile";
leaf t1a-max-up {
type uint32;
units nanoseconds;
description
"the earliest possible time which the O-DU can support transmitting
an IQ data message prior to transmission of the corresponding IQ
samples at the antenna";
}
leaf tx-max {
type uint32;
units nanoseconds;
description
"The maximum amount of time which the O-DU requires to transmit
all downlink user plane IQ data message for a symbol";
}
leaf ta4-max {
type uint32;
units nanoseconds;
description
"the latest possible time which the O-DU can support receiving the
last uplink user plane IQ data message for a symbol.";
}
leaf rx-max {
type uint32;
units nanoseconds;
description
"The maximum time difference the O-DU can support between
receiving the first user plane IQ data message for a symbol and
receiving the last user plane IQ data message for the same symbol";
}
leaf t1a-max-cp-dl {
type uint32;
units nanoseconds;
description
"The earliest possible time which the O-DU can support transmitting the
downlink real time control message prior to transmission of the
corresponding IQ samples at the antenna.";
}
}
grouping t12 {
description
"Grouping for t12";
leaf t12-min {
type uint32;
units nanoseconds;
description
"the minimum measured delay between DU port-ID and O-RU port-ID";
}
// additional leaf added by Samsung
leaf t12-max {
type uint32;
units nanoseconds;
description
"the maximum measured delay between CU port-ID and O-RU port-ID";
}
}
grouping t34 {
description
"Grouping for t34";
leaf t34-min {
type uint32;
units nanoseconds;
description
"the minimum measured delay between O-RU port-ID and CU port-ID";
}
// additional leaf added by Samsung
leaf t34-max {
type uint32;
units nanoseconds;
description
"the maximum measured delay between O-RU port-ID and CU port-ID";
}
}
grouping non-default-ru-delay-profile {
description
"Grouping for O-RU delay profile different from the default value in ru-delay-profile.";
leaf t2a-min-up {
type uint32;
units nanoseconds;
description
"the minimum O-RU data processing delay between receiving IQ data
message over the fronthaul interface and transmitting
the corresponding first IQ sample at the antenna";
}
leaf t2a-max-up {
type uint32;
units nanoseconds;
description
"the earliest allowable time when a data packet is received before
the corresponding first IQ sample is transmitted at the antenna";
}
leaf t2a-min-cp-dl {
type uint32;
units nanoseconds;
description
"the minimum O-RU data processing delay between receiving downlink
real time control plane message over the fronthaul interface and
transmitting the corresponding first IQ sample at the antenna";
}
leaf t2a-max-cp-dl {
type uint32;
units nanoseconds;
description
"the earliest allowable time when a downlink real time control message
is received before the corresponding first IQ sample is transmitted at
the antenna";
}
leaf tcp-adv-dl {
type uint32;
units nanoseconds;
description
"the time difference (advance) between the reception window for
downlink real time Control messages and reception window for the
corresponding IQ data messages.";
}
leaf ta3-min {
type uint32;
units nanoseconds;
description
"the minimum O-RU data processing delay between receiving an IQ sample
at the antenna and transmitting the first data sample over the
fronthaul interface";
}
leaf ta3-max {
type uint32;
units nanoseconds;
description
"the maximum O-RU data processing delay between receiving an IQ sample
at the antenna and transmitting the last data sample over the
fronthaul interface";
}
leaf t2a-min-cp-ul {
type uint32;
units nanoseconds;
description
"the minimum O-RU data processing delay between receiving real time
up-link control plane message over the fronthaul interface and
receiving the first IQ sample at the antenna";
}
leaf t2a-max-cp-ul {
type uint32;
units nanoseconds;
description
"the earliest allowable time when a real time up-link control message
is received before the corresponding first IQ sample is received at
the antenna";
}
leaf ta3-min-ack {
type int32;
units nanoseconds;
description
"the minimum delay between the DL/UL air reference point (tDL=0 or tUL=0) of symbol M
and the time O-RU sends section type 8 (ACK/NACK feedback) to O-DU.
This value can be negative, which indicates it is in advance of the air reference point.
This leaf only exists if section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback)
are supported by at least one endpoint.";
}
leaf ta3-max-ack {
type int32;
units nanoseconds;
description
"the maximum delay between the DL/UL air reference point (tDL=0 or tUL=0) of symbol M
and the time O-RU sends section type 8 (ACK/NACK feedback) to O-DU.
This value can be negative, which indicates it is in advance of the air reference point.
This leaf only exists if section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback)
are supported by at least one endpoint.";
}
uses ta3-2g;
}
grouping delay-management-group {
description "a delay management grouping";
list bandwidth-scs-delay-state {
key "bandwidth subcarrier-spacing";
description
"Array of structures containing sets of parameters for delay management.";
uses bandwidth-configuration;
container ru-delay-profile {
config false;
description "container for O-RU delay parameters";
uses ru-delay-profile;
}
}
list non-default-ru-delay-profile {
if-feature feat:BF-DELAY-PROFILE;
key "delay-profile-id";
description
"Sets of parameters defined when o-ru supported multiple delay profiles,
only the parameters that are different from the default delay profile are defined.";
leaf delay-profile-id {
type uint16 {
range "1..max";
}
description
"Used to identify the set of delay profile that are different from the default delay profile.
Value '0' is reserved to refer to default value";
}
list non-default-bandwidth-scs-delay-state {
key "bandwidth subcarrier-spacing";
description
"Array of structures containing sets of parameters for delay management.";
uses bandwidth-configuration;
container non-default-ru-delay-profile {
config false;
description
"O-RU delay parameters that are different from the default delay profile.
If a parameter doesn't exist, this parameter will use the defalt value determined in ru-delay-profile.";
uses non-default-ru-delay-profile;
}
}
}
container adaptive-delay-configuration {
if-feature ADAPTIVE-RU-PROFILE;
description "container for adaptive delay parameters";
list bandwidth-scs-delay-state {
key "bandwidth subcarrier-spacing";
description
"Array of structures containing sets of parameters for delay management.";
uses bandwidth-configuration;
container o-du-delay-profile {
description
"O-DU provided delay profile for adaptive delay configuration";
uses o-du-delay-profile;
}
}
container transport-delay {
description
"O-DU provided transport-delay parameters";
uses t12;
uses t34;
}
}
leaf beam-context-gap-period {
type uint16;
units microseconds;
description
"Time gap between the end of reception window of the C-Plane message(Msg-A) with new beam weights for a given beamId and end of the reception window
of the C-Plane message(Msg-B) that cites the same beamId without weights in the new context.
Note: Value of '0' indicates that the end of the Msg-A and Msg-B reception windows are perfectly aligned, which should allow Msg-B to use the new
beamforming weights with a '0' microsecond beam-context-gap-period. Value of '65535' implies infinite gap, which means a beamId may not be reused
at all in a different context (applicable only to weight-based dynamic beamforming). If O-DU chooses not to interpret/honor this value, behaviour
of O-RU is unpredictable if a beamId has new weights loaded in one context and is reused in a different context. Please refer the CUS-Plane spec
Section 'Weight-based dynamic beamforming' for detailed description";
}
}
container delay-management {
description "top-level tree covering off O-DU to O-RU delay management";
uses delay-management-group;
}
}

287
radio/fhi_72/mplane/yang/models/o-ran-file-management.yang
View File

@@ -3,10 +3,12 @@ module o-ran-file-management {
namespace "urn:o-ran:file-management:1.0";
prefix "o-ran-file-mgmt";
import ietf-crypto-types {
prefix "ct";
}
import ietf-netconf-acm {
prefix nacm;
reference
"RFC 8341: Network Configuration Access Control Model";
}
organization "O-RAN Alliance";
@@ -16,7 +18,7 @@ module o-ran-file-management {
description
"This module defines the configuration and operations for handling upload.
Copyright 2019 the O-RAN Alliance.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -42,6 +44,52 @@ module o-ran-file-management {
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-08-12" {
description
"version 10.2.0
1) Improve YANG description enforce typing of IPv6 addresses";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2023-04-10" {
description
"version 10.1.0
1) Remove crypto-types dependency";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2022-08-15" {
description
"version 10.0.0
1) added password for FTPES
2) clarified path/folder description ";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2021-12-01" {
description
"version 7.1.0
1) typographical corrections";
reference "ORAN-WG4.M.0-v07.00";
}
revision "2021-07-26" {
description
"version 7.0.0
1) added FTPES support";
reference "ORAN-WG4.M.0-v07.00";
}
revision "2019-07-03" {
description
"version 1.1.0
@@ -63,21 +111,157 @@ module o-ran-file-management {
reference "ORAN-WG4.M.0-v01.00";
}
/***********************************************/
/* Identities for Asymmetric Key Algorithms */
/***********************************************/
identity asymmetric-key-algorithm {
description
"Base identity from which all asymmetric key
encryption Algorithm.";
}
identity rsa1024 {
base asymmetric-key-algorithm;
description
"The RSA algorithm using a 1024-bit key.";
reference
"RFC 8017:
PKCS #1: RSA Cryptography Specifications Version 2.2.";
}
identity rsa2048 {
base asymmetric-key-algorithm;
description
"The RSA algorithm using a 2048-bit key.";
reference
"RFC 8017:
PKCS #1: RSA Cryptography Specifications Version 2.2.";
}
identity rsa3072 {
base asymmetric-key-algorithm;
description
"The RSA algorithm using a 3072-bit key.";
reference
"RFC 8017:
PKCS #1: RSA Cryptography Specifications Version 2.2.";
}
identity rsa4096 {
base asymmetric-key-algorithm;
description
"The RSA algorithm using a 4096-bit key.";
reference
"RFC 8017:
PKCS #1: RSA Cryptography Specifications Version 2.2.";
}
identity rsa7680 {
base asymmetric-key-algorithm;
description
"The RSA algorithm using a 7680-bit key.";
reference
"RFC 8017:
PKCS #1: RSA Cryptography Specifications Version 2.2.";
}
identity rsa15360 {
base asymmetric-key-algorithm;
description
"The RSA algorithm using a 15360-bit key.";
reference
"RFC 8017:
PKCS #1: RSA Cryptography Specifications Version 2.2.";
}
identity secp192r1 {
base asymmetric-key-algorithm;
description
"The ECDSA algorithm using a NIST P256 Curve.";
reference
"RFC 6090:
Fundamental Elliptic Curve Cryptography Algorithms.";
}
identity secp224r1 {
base asymmetric-key-algorithm;
description
"The ECDSA algorithm using a NIST P256 Curve.";
reference
"RFC 6090:
Fundamental Elliptic Curve Cryptography Algorithms.";
}
identity secp256r1 {
base asymmetric-key-algorithm;
description
"The ECDSA algorithm using a NIST P256 Curve.";
reference
"RFC 6090:
Fundamental Elliptic Curve Cryptography Algorithms.";
}
identity secp384r1 {
base asymmetric-key-algorithm;
description
"The ECDSA algorithm using a NIST P256 Curve.";
reference
"RFC 6090:
Fundamental Elliptic Curve Cryptography Algorithms.";
}
identity secp521r1 {
base asymmetric-key-algorithm;
description
"The ECDSA algorithm using a NIST P256 Curve.";
reference
"RFC 6090:
Fundamental Elliptic Curve Cryptography Algorithms.";
}
/**********************************************************/
/* Typedefs for identityrefs to above base identities */
/**********************************************************/
typedef asymmetric-key-algorithm-ref {
type identityref {
base asymmetric-key-algorithm;
}
description
"This typedef enables importing modules to easily define an
identityref to the 'asymmetric-key-algorithm'
base identity.";
}
grouping file-path-grouping {
description "Complete logical path of the file to upload/download
(no wildcard is allowed) ex : /o-RAN/log/syslog.1";
description "Grouping, that provides local path and remote path for the
purpose of File Management scenarios.";
leaf local-logical-file-path {
type string;
mandatory true;
description "Local logical file path";
description "URI specifying the complete logical path relative to the root of the logical file system
structure (the common root for o-ran/log, o-ran/pm, o-ran/transceiver or o-ran/beamforming) of the file
to upload/download (no wildcard is allowed), including a file name and its extension.
Example: 'o-ran/log/file_1.abc', where 'o-ran/log/' represents relative path to folder containing log files
as specified by O-RAN, 'file_1' represents desired filename and 'abc' represents desired filename's extension.
The content shall conform to RFC3986 'Uniform Resource Identifier (URI): Generic Syntax'";
}
leaf remote-file-path {
type string;
mandatory true;
description "URI specifying the remote-file-path on O-DU/NMS.
Format:sftp://<username>@<host>[:port]/path";
description "URI specifying the remote-file-path on O-DU/SMO or on stand-alone file server.
The content shall conform to RFC3986 'Uniform Resource Identifier (URI): Generic Syntax'.
When upload/download is via sftp, the format shall be of the form
sftp://<username>@<host>[:port]/path
When upload/download is via ftpes, the format shall be of the form
ftpes://<username>@<host>[:port]/path
IPv6 addresses are distinguished by enclosing the IP literal within square brackets ('[' and ']') as defined by RFC3986 e.g., sftp://user@[2001:0:130F::9C0:876A:130B]:22/path.
Note, ftpes is not an IANA registered URI scheme, but used here to signal
that a file transfer should be performed over FTPES";
}
}
@@ -102,7 +286,7 @@ module o-ran-file-management {
}
grouping credential-information {
description "Type of authentication to use for SFTP upload or download.";
description "Type of authentication to use for file upload or download.";
choice credentials {
case password {
container password {
@@ -111,21 +295,22 @@ module o-ran-file-management {
type string;
mandatory true;
description
"password needed for O-RU authentication.";
"password used for O-RU authentication to sFTP server for the associated username defined in the remote-file-path.";
}
description
"password for O-RU authentication method in use";
"password for O-RU authentication method in use. This information
shall be ignored by an O-RU that is using FTPES based file transfer";
}
container server {
list keys {
key algorithm;
ordered-by user;
uses ct:public-key-grouping;
uses public-key-grouping;
description
"List of allowed algorithms with its keys";
}
description
"Key for sFTP server authentication";
"SSH Key for file server authentication";
}
}
case certificate {
@@ -134,9 +319,22 @@ module o-ran-file-management {
description
"certificate authentication method in use";
}
}
description "";
}
container application-layer-credential{
leaf appl-password {
type string;
description
"The parameter represents the password which may be needed for O-RU application level authentication.
For example, to perform authenticatation towards an FTPes server which does not allow anonymous account,
in addition to X.509v3 certificate for TLS authentication, password configured here need to be used together with username defined in the remote-file-path ";
}
description
"Application layer credential information";
}
}
grouping retrieve-input {
@@ -144,12 +342,13 @@ module o-ran-file-management {
leaf logical-path {
type string;
mandatory true;
description "O-RAN unit of which the files are to be listed.
ex : O-RAN/log, o-RAN/PM, O-RAN/transceiver";
description "URL specifying the logical path relative to the root of the logical file system
structure (the common root for o-ran/log, o-ran/pm, o-ran/transceiver or o-ran/beamforming)
of the files to be listed.";
}
leaf file-name-filter {
type string;
description "Filter which are to be applied on the result list of file names (* is allowed as wild-card).";
description "Filter which needs to be applied on the result list of file names (* is allowed as wild-card).";
}
}
@@ -163,10 +362,48 @@ module o-ran-file-management {
}
}
grouping public-key-grouping {
description
"A public key.
The 'algorithm' and 'public-key' nodes are not
mandatory because they MAY be defined in <operational>.
Implementations SHOULD assert that these values are
either configured or that they exist in <operational>.";
leaf algorithm {
nacm:default-deny-write;
type asymmetric-key-algorithm-ref;
must '../public-key';
description
"Identifies the key's algorithm. More specifically,
this leaf specifies how the 'public-key' binary leaf
is encoded.";
reference
"RFC CCCC: Common YANG Data Types for Cryptography";
}
leaf public-key {
nacm:default-deny-write;
type binary;
must '../algorithm';
description
"A binary that contains the value of the public key. The
interpretation of the content is defined by the key
algorithm. For example, a DSA key is an integer, an RSA
key is represented as RSAPublicKey as defined in
RFC 8017, and an Elliptic Curve Cryptography (ECC) key
is represented using the 'publicKey' described in
RFC 5915.";
reference
"RFC 8017: Public-Key Cryptography Standards (PKCS) #1:
RSA Cryptography Specifications Version 2.2.
RFC 5915: Elliptic Curve Private Key Structure.";
}
}
// RPCs
rpc file-upload {
description "File upload over SFTP from equipment to NETCONF client";
description "Management plane trigger to upload file from O-RU to file-server";
input {
uses file-path-grouping;
uses credential-information;
@@ -187,15 +424,9 @@ module o-ran-file-management {
}
}
notification file-upload-notification {
uses file-path-grouping;
uses output-status-grouping;
description "";
}
rpc file-download {
description
"Management plane triggered to generate the download file of O-RU.";
"Management plane trigger to download file from file-server to O-RU.";
input {
uses file-path-grouping;
uses credential-information;
@@ -205,6 +436,12 @@ module o-ran-file-management {
}
}
notification file-upload-notification {
uses file-path-grouping;
uses output-status-grouping;
description "";
}
notification file-download-event {
uses file-path-grouping;
uses output-status-grouping;

461
radio/fhi_72/mplane/yang/models/o-ran-hardware.yang Normal file
View File

@@ -0,0 +1,461 @@
module o-ran-hardware {
yang-version 1.1;
namespace "urn:o-ran:hardware:1.0";
prefix "o-ran-hw";
import ietf-hardware {
prefix hw;
}
import iana-hardware {
prefix ianahw;
}
import ietf-yang-types {
prefix yang;
}
import o-ran-wg4-features {
prefix or-feat;
}
organization "O-RAN Alliance";
contact
"www.o-ran.org";
description
"This module defines the YANG definitions for managing the O-RAN hardware.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the above disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the above disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the Members of the O-RAN Alliance nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-04-15" {
description
"version 15.0.0
1) Added support for new fan tray component.";
reference "ORAN-WG4.M.0-v15.00";
}
revision "2023-08-14" {
description
"version 13.0.0
1) New connector types for RS485 and external IO";
reference "ORAN-WG4.M.0-v13.00";
}
revision "2022-12-05" {
description
"version 10.1.0
1) Clarifications for Network Energy Saving";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2022-08-15" {
description
"version 10.0.0
1) introduction of O-RU connector functionality.
2) fixing constraints";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2021-12-01" {
description
"version 5.2.0
1) typographical corrections in descriptions.";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2021-03-22" {
description
"version 5.1.0
1) typographical corrections in descriptions.";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2020-12-10" {
description
"version 5.0.0
1) added date-last-service leaf used in pnfRegistration";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2020-04-17" {
description
"version 3.0.0
1) added new leaf to indicate whether O-RU supports dying gasp
2) added new identities for PA and FPGA";
reference "ORAN-WG4.M.0-v03.00";
}
revision "2019-07-03" {
description
"version 1.1.0
1) added new identities to accommodate cross working group use of
o-ran-hardware and associated set of augmentations that are backwards
compatible to version 1.0.0";
reference "ORAN-WG4.M.0-v01.00";
}
revision "2019-02-04" {
description
"version 1.0.0
1) imported model from xRAN
2) changed namespace and reference from xran to o-ran";
reference "ORAN-WG4.M.0-v01.00";
}
feature ENERGYSAVING {
description
"Indicates that the Radio Unit supports energy saving state.";
}
// identity statements
identity O-RAN-RADIO {
base ianahw:module;
description
"Module used as it represents a self-contained sub-system
used in /hw:/hardware/hw:component/hw:class to represent
an O-RAN RU";
}
identity O-RAN-HW-COMPONENT {
base ianahw:module;
description
"Module used as it represents a self-contained sub-system
used in /hw:/hardware/hw:component/hw:class to represent
any O-RAN hardware component";
}
identity O-DU-COMPONENT {
base O-RAN-HW-COMPONENT;
description
"Used in /hw:/hardware/hw:component/hw:class to represent
any O-RAN defined O-DU hardware component";
}
identity O-RAN-FAN-TRAY {
base O-RAN-HW-COMPONENT;
description
"Used in /hw:/hardware/hw:component/hw:class to represent
any O-RAN defined fan tray hardware component.";
}
identity O-RU-COMPONENT {
base O-RAN-HW-COMPONENT;
description
"Used in /hw:/hardware/hw:component/hw:class to represent
any O-RAN defined O-RU hardware component, including a stand-alone
O-RU or an O-RU component integrated into a multi-module system.";
}
identity O-RU-POWER-AMPLIFIER {
base O-RU-COMPONENT;
description
"Used in /hw:/hardware/hw:component/hw:class to represent
an O-RU's power amplifier, and may be used for reporting
measurements on a per class basis";
}
identity O-RU-FPGA {
base O-RU-COMPONENT;
description
"Used in /hw:/hardware/hw:component/hw:class to represent
an FPGA in an O-RU, and may be used for reporting
measurements on a per class basis";
}
identity O-RU-CONNECTOR {
base ianahw:hardware-class;
description
"This identity is applicable if the hardware class is some sort
of O-RU connector.";
}
identity O-RU-ANTENNA-CONNECTOR {
base O-RU-CONNECTOR;
description
"This identity is applicable if the hardware class is some sort
of connector capable of interfacing between an O-RU and some
antenna function.";
}
identity O-RU-FEEDER {
base O-RU-ANTENNA-CONNECTOR;
description
"This identity is applicable if the hardware class is an
antenna feeder.";
}
identity O-RU-BF-CAL {
base O-RU-ANTENNA-CONNECTOR;
description
"This identity is applicable if the hardware class is for
beamforming calibration.";
}
identity O-RU-RS485 {
base O-RU-CONNECTOR;
description
"This identity is applicable if the hardware class is some sort
of connector capable of interfacing between an O-RU and Antenna
Line Devices using RS-485 electrical standard.";
}
identity O-RU-EXTIO {
base O-RU-CONNECTOR;
description
"This identity is applicable if the hardware class is some sort
of connector capable of interfacing between an O-RU external I/O lines.";
}
// typedef statements
typedef energysaving-state {
type enumeration {
enum UNKNOWN {
description
"The O-RU is unable to report its energy saving state.";
}
enum SLEEPING {
description
"The O-RU is in energy saving state. In this mode M-Plane connection is active. Depending
on the O-RU's design - other planes, functions and hardware components which are not needed
by the O-RU in energy saving state can be disabled or switched off by the O-RU autonomously.";
}
enum AWAKE {
description
"The O-RU is not in an energy saving state.";
}
}
description
"New typedef since ietf-hardware only covers power-state
for redundancy purposes, not to indicate energy saving operations.
For details please see O-RAN WG4 M-Plane specification, clause 9.1.3 'Modify state'";
}
typedef availability-type {
type enumeration {
enum UNKNOWN {
description "The Radio Unit is unable to report its availability state.";
}
enum NORMAL {
description
"The equipment is functioning correctly.";
}
enum DEGRADED {
description
"The equipment may be reporting a major alarm or may be reporting a critical
alarm that is only impacting one or more subcomponent, but where the
equipment's implementation permit it to continue operation (server traffic)
in a degraded state.
Used for example, when the equipment has M identical sub-components and
when a critical alarm is impacting only N subcomponents, where N<M.";
}
enum FAULTY {
description
"The (sub-)components impacted by the critical alarm(s) impact the
ability of the equipment to continue operation (serve traffic).";
}
}
description
"Equipment's availability-state is derived by matching active faults
and their impact to module's operation and enables an equipment to indicate
that even though it may have one or more critical alarms, it can continue
to serve traffic.";
}
// common WG4 and cross-WG augmentations using O-RAN-RADIO identity
augment "/hw:hardware/hw:component" {
when "(derived-from-or-self(hw:class, 'o-ran-hw:O-RAN-RADIO')) or
(derived-from-or-self(hw:class, 'o-ran-hw:O-RAN-HW-COMPONENT'))";
description "New O-RAN parameters for o-ran hardware";
container label-content {
config false;
description
"Which set of attributes are printed on the Radio Unit's label";
leaf model-name {
type boolean;
description
"indicates whether model-name is included on the equipment's label";
}
leaf serial-number {
type boolean;
description
"indicates whether serial number is included on the equipment's label";
}
}
leaf product-code {
type string;
config false;
mandatory true;
description
"O-RAN term that is distinct from model-name in ietf-hardware.";
}
leaf energy-saving-enabled {
if-feature "ENERGYSAVING";
type boolean;
default false;
description
"This parameter enables the O-RU to enter into energy saving state if there is no need to keep processing
paths working.
TRUE is used to permit the O-RU to enter energy saving state. If there is still need keep any
processing path, functions or HW components working.
The O-RU shall keep necessary processing paths working if there is any [tr]x-array-carrier with
'state' != DISABLED.
There may be also additional implementation-specific conditions which may require keeping processing paths,
functions or HW components working.
FALSE is used to prohibit the O-RU to enter or to stay in energy saving state. This value is also used
to awake the O-RU from sleeping when the O-RU is already in energy saving state. Setting this value has
no effect on [tr]x-array-carrier::active.
When the O-RU enters energy saving state, the O-RU shall reduce its power consumption to the lowest level
whilst M-plane remains available. Ongoing Netconf session(s) shall not be affected when the O-RU enters
energy saving state.
The O-RU uses RO node power-state to inform if the O-RU is in energy saving state.
NETCONF client should set energy-saving-enabled to FALSE to ensure O-RU is ready to immediately activate a
carrier.";
}
leaf dying-gasp-support {
type boolean;
default false;
config false;
description
"indicates whether the O-RU supports the dying gasp
capability";
}
leaf last-service-date {
if-feature "or-feat:NON-PERSISTENT-MPLANE";
type yang:date-and-time;
description
"Date of last service or repair of hardware component. How this gets
populated is a vendor specific issue.";
reference
"3GPP 32.692";
}
}
augment "/hw:hardware/hw:component" {
when "(derived-from-or-self(hw:class, 'o-ran-hw:O-RAN-RADIO')) or
(derived-from-or-self(hw:class, 'ianahw:port')) or
(derived-from-or-self(hw:class, 'o-ran-hw:O-RAN-HW-COMPONENT'))";
description "New O-RAN parameters for o-ran naming";
leaf o-ran-name {
type leafref {
path "/hw:hardware/hw:component/hw:name";
}
must "re-match(current(),'[a-zA-Z0-9][a-zA-Z0-9\\.\\-_]{0,253}[a-zA-Z0-9]')" {
error-message "Name must match pattern and length.";
}
mandatory true;
description
"O-RAN name needed to bind and match with the name of hw element,
to be compliant with O-RAN naming convention.";
}
}
augment "/hw:hardware/hw:component/hw:state" {
when "(derived-from-or-self(../hw:class, 'o-ran-hw:O-RAN-RADIO')) or
(derived-from-or-self(../hw:class, 'o-ran-hw:O-RAN-HW-COMPONENT'))";
description
"new O-RAN defined state";
leaf power-state {
if-feature "ENERGYSAVING";
type energysaving-state;
config false;
description
"The current power saving state for this component.
Note - hw:/hardware/component/state/standby-state defined in RFC 4268 is
used for redundancy purposes but not for power saving operations.";
}
leaf availability-state {
type availability-type;
config false;
description
"Equipment's availability-state is derived by matching active faults
and their impact to module's operation and enables an equipment to indicate
that even though it may have one or more critical alarms, it can continue
to serve traffic.";
}
}
augment "/hw:hardware/hw:component" {
when "(derived-from-or-self(hw:class, 'o-ran-hw:O-RU-ANTENNA-CONNECTOR'))";
description "New O-RAN parameters for O-RAN Antenna connectors";
leaf connector-label {
type string;
config false;
description
"the label used to identify the connector on an O-RU ";
}
}
// augmentations to Notifications
augment "/hw:hardware-state-oper-enabled" {
description "new availability state";
leaf availability-state {
if-feature hw:hardware-state;
type leafref {
path "/hw:hardware/hw:component/hw:state/o-ran-hw:availability-state";
}
description
"The availability-state of the O-RU.";
}
}
augment "/hw:hardware-state-oper-disabled" {
description "new availability state";
leaf availability-state {
if-feature hw:hardware-state;
type leafref {
path "/hw:hardware/hw:component/hw:state/o-ran-hw:availability-state";
}
description
"The availability-state of the O-RU.";
}
}
}

346
radio/fhi_72/mplane/yang/models/o-ran-interfaces.yang
View File

@@ -32,16 +32,20 @@ module o-ran-interfaces {
prefix "ianahw";
}
import o-ran-wg4-features {
prefix "feat";
}
organization "O-RAN Alliance";
contact
"www.o-ran.org";
description
"This module defines the YANG definitions for managng the O-RAN
"This module defines the YANG definitions for managing the O-RAN
interfaces.
Copyright 2020 the O-RAN Alliance.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -67,6 +71,52 @@ module o-ran-interfaces {
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-08-12" {
description
"version 16.0.0
1) added new MACsec bypass policy.";
reference "ORAN-WG4.M.0-v16.00";
}
revision "2024-04-15" {
description
"version 15.0.0
1) added new config false only leaf for maximum payload size.
2) new configuration for TCP MSS.";
reference "ORAN-WG4.M.0-v15.00";
}
revision "2021-12-01" {
description
"version 5.2.0
1) typographical corrections in descriptions.";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2021-03-22" {
description
"version 5.1.0
1) typographical corrections in descriptions.";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2020-12-10" {
description
"version 5.0.0
1) new functionality to describe over subscribed resources";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2020-04-17" {
description
"version 1.2.0
@@ -108,7 +158,6 @@ module o-ran-interfaces {
based transport for the CU plane.";
}
typedef pcp {
type uint8 {
range "0..7";
@@ -123,6 +172,21 @@ module o-ran-interfaces {
"IEEE 802.1Q-2014: Virtual Bridged Local Area Networks";
}
typedef mss {
type uint16;
description
"Type definition for TCP Maximum Segment Size.";
}
typedef ethertype-string {
type string {
pattern '([0-9A-Fa-f]{2}(:[0-9A-Fa-f]{2}))';
}
description
"A 2 octect hexadecimal string with octets represented as hex digits
separated by colons.";
}
grouping cos-marking {
description
"Configuration data for CU Plane ethernet CoS marking.
@@ -220,6 +284,146 @@ module o-ran-interfaces {
}
}
grouping tcp-config {
description "grouping for per-interface tcp configuration";
container tcp {
presence "tcp configuration";
description "per interface TCP configuration";
leaf mss-adjust {
type mss;
description
"Maximum Segment Size (MSS) used in the MSS Option sent
in the TCP initial handshake over this interface and
which specifies an upper bound for the TCP MSS of packets
that can be received on this interface.
NOTE, this can be used to reduce the packet size for NETCONF/TLS
or NETCONF/SSH to reduce head-of-line blocking due to M-Plane
packets sent over the fronthaul downlink interface";
}
}
}
grouping macsec-bypass-grouping {
description "grouping for MACsec bypass policy";
container macsec-bypass-policy {
if-feature feat:MACSEC-BYPASS-POLICY;
description
"This is a top level container for MACsec policies.
These policies can only be enforced on the base
Ethernet interface.
MAC, EtherType and vlan-id based policies are defined to
be applied to the base-interface.
VLAN based policies can additionally be implicitly
enforced by configuring the SecY on a VLAN interface and
do not use this container.";
list policy {
key "name";
description
"Each policy list entry has a matching criteria. Any frame
matching the criteris will be forwarded via the uncontrolled port.";
leaf name {
type string;
description
"The name of the MACsec policy.";
}
choice policy-type {
case mac {
leaf-list destination-mac-address {
type yang:mac-address;
description
"Destination IEEE 802 Media Access Control (MAC)
address of frames egressing via interface.";
}
}
case ethertype {
leaf-list ethertype {
type ethertype-string;
description
"list of ethertypes in frames egressing the interface.";
}
}
case vlan-id {
leaf-list vlan-id {
type uint16 {
range "1..4094";
}
description
"list of vlan-ids in frames egressing the interface.";
}
}
description
"choice of policy types";
}
}
}
}
grouping macsec-bypass-capabilities {
description "grouping for MACsec bypass capabilities";
container macsec-bypass-capabilities {
if-feature feat:MACSEC-BYPASS-POLICY;
config false;
description
"This is a container for MACsec bypass capabilities.";
leaf per-interface-policy-list-max-elements {
type uint16;
default 100;
description
"the maximum number of list of elements
for each instance of the list
/if:interfaces/if:interface/o-ran-int:/macsec-bypass-policy/o-ran-int/policy.";
}
leaf cummulative-policy-list-max-elements {
type uint16;
default 100;
description
"the maximum cummulative number of list entries for
all instances of the list
/if:interfaces/if:interface/o-ran-int:/macsec-bypass-policy/o-ran-int/policy";
}
leaf-list supported-policy {
type enumeration {
enum MAC {
description
"O-RU supports MAC address based by-pass policies
for frames egressing a base-interface.";
}
enum ETHERTYPE {
description
"O-RU supports ethertype based by-pass policies
for frames egressing a base-interface.";
}
enum VLAN {
description
"O-RU supports vlan-id based by-pass policies
for frames egressing a base-interface.";
}
}
description
"The type of mac bypass policies supported by the O-RU
on frames egressing a base-interface.
An O-RU supporting the MACSEC-BYPASS-POLICY shall include
at least one of the defined policies in this list.";
}
}
}
rpc reset-interface-counters {
description
"Management plane triggered restart of the interface counters.";
}
// Cross Working Group Augmentations Follow
// Cross Working Group augmentations for basic Ethernet leafs
@@ -245,6 +449,27 @@ module o-ran-interfaces {
4-8 byte overhead of any known (i.e. explicitly matched by
a child sub-interface) 801.1Q VLAN tags.";
}
leaf maximum-ethernet-payload-size {
type uint16 {
range "1500 .. 9000";
}
units bytes;
config false;
description
"The maximum size of the Ethernet payload that an O-RU can transmit
or receive on the interface (excluding any frame header,
maximum frame payload size, frame checksum
sequence and any 802.1Q tag).
TAKE NOTE - THE FORMULA IN THIS DESCRIPTION DIFFERS FROM THE
FORMULA IN THE DESCRIPTION OF THE l2-mtu LEAF.
THIS LEAF CORRESPONDS TO THE DATA/PAYLOAD **ONLY** AND DOES **NOT**
INCLUDE ANY OTHER FRAME OVERHEAD LIKE SOURCE/DESTINATION ADDRESSES,
LENGTH, 802.1Q TAGS OR FCS.";
}
leaf vlan-tagging {
type boolean;
default true;
@@ -261,8 +486,45 @@ module o-ran-interfaces {
equipment.";
}
uses cos-marking;
// interface-grouping insert - begin;
leaf-list interface-groups-id {
type leafref {
path "/if:interfaces/o-ran-int:interface-grouping/o-ran-int:interfaces-groups/o-ran-int:interface-group-id";
}
config false;
description
"an optional leaf used when the sustained rate able to be supported by an interface
is less than nominal bit rate indicated by o-ran-transceiver.yang
Identifies interface grouping particular physical hardware MAC address belongs to.";
}
// interface-grouping insert - end;
}
// augmentation for MACsec bypass policies
augment "/if:interfaces/if:interface" {
when "if:type = 'ianaift:ethernetCsmacd'" {
description "Applies to Ethernet interfaces";
}
if-feature feat:MACSEC-BYPASS-POLICY;
description
"Augment the interface model with bypass parameters for
base Ethernet interface";
uses macsec-bypass-grouping;
}
augment "/if:interfaces" {
if-feature feat:MACSEC-BYPASS-POLICY;
description "augmentation for MACsec bypass capabilitites";
uses macsec-bypass-capabilities;
}
// Cross Working Group augmentation for l2vlan interfaces for VLAN definition
augment "/if:interfaces/if:interface" {
@@ -276,7 +538,7 @@ module o-ran-interfaces {
"The base interface must have VLAN tagging enabled.";
}
description
"The base interface for the VLAN sub-interafce.";
"The base interface for the VLAN sub-interface.";
}
leaf vlan-id {
type uint16 {
@@ -287,7 +549,7 @@ module o-ran-interfaces {
}
}
// Cross Working Group augmention for both ethernetCsmacd and l2vlan interfaces
// Cross Working Group augmentation for both ethernetCsmacd and l2vlan interfaces
augment "/if:interfaces/if:interface" {
when "(if:type = 'ianaift:ethernetCsmacd') or
@@ -306,7 +568,7 @@ module o-ran-interfaces {
}
}
// Cross Working Group augmention to ietf-ip covering DSCP for M-Plane
// Cross Working Group augmentation to ietf-ip covering DSCP for M-Plane
augment "/if:interfaces/if:interface/ip:ipv4" {
description "augments for IPv4 based M-Plane transport";
@@ -325,28 +587,44 @@ augment "/if:interfaces/if:interface/ip:ipv6" {
}
}
// Cross Working Group augmentation to ietf-ip covering TCP MSS for M-Plane
augment "/if:interfaces/if:interface/ip:ipv4" {
if-feature feat:PER-INT-TCP-MSS;
description "augments for IPv4 based CUS transport";
uses tcp-config;
}
augment "/if:interfaces/if:interface/ip:ipv6" {
if-feature feat:PER-INT-TCP-MSS;
description "augments for IPv6 based CUS transport";
uses tcp-config;
}
// WG4 Specific Augmentations Follow
// WG4 Augmentation for basic Ethernet leafs
augment "/if:interfaces/if:interface" {
if-feature ALIASMAC-BASED-CU-PLANE;
when "if:type = 'ianaift:ethernetCsmacd'" {
description
"Applies to WG4 Ethernet interfaces for alias MAC based CU-Plane";
}
if-feature ALIASMAC-BASED-CU-PLANE;
description
"Augment the interface model with parameters for
base Ethernet interface";
leaf-list alias-macs {
type yang:mac-address;
description
"Augments interfaces with range of alias MAC addresses.";
}
}
// WG4 Augmention for both ethernetCsmacd and l2vlan interfaces
// WG4 Augmentation for both ethernetCsmacd and l2vlan interfaces
augment "/if:interfaces/if:interface" {
when "(if:type = 'ianaift:ethernetCsmacd') or
@@ -358,9 +636,11 @@ augment "/if:interfaces/if:interface/ip:ipv6" {
both ethernetCsmacd and l2vlan interfaces.";
leaf mac-address {
type yang:mac-address;
description
"The MAC address of the interface.";
}
container port-reference {
description
"a port reference used by other O-RAN modules";
@@ -391,7 +671,7 @@ augment "/if:interfaces/if:interface/ip:ipv6" {
}
}
// WG4 specific augmention to ietf-ip covering DSCP for CUS Plane
// WG4 specific augmentation to ietf-ip covering DSCP for CUS Plane
augment "/if:interfaces/if:interface/ip:ipv4" {
if-feature UDPIP-BASED-CU-PLANE;
@@ -406,9 +686,51 @@ augment "/if:interfaces/if:interface/ip:ipv6" {
// Other Working Group Specific Augmentations Follow Here
// interface-grouping insert - begin;
rpc reset-interface-counters {
description
"Management plane triggered restart of the interface counters.";
augment "/if:interfaces" {
description "augments interfaces for groupings of physical hardware addresses that can be used to group Ethernet ports";
container interface-grouping {
presence
"indicates maximum sustained throughput of an O-RU is less than the combined bandwidth of all physical ports";
config false;
description
"A container used by an O-RU where the maximum sustained throughput
of an O-RU is less than the combined bandwidth of all physical ports";
list interfaces-groups {
key interface-group-id;
description "List of interface groups.";
leaf interface-group-id {
type uint8;
description "interface group identifier.";
}
leaf max-sustainable-ingress-bandwidth {
type uint32;
units Mbps;
description
"Maximum sustainable ingress bandwidth the interface group can handle. The sustainable bandwidth is calculated
over one radio frame.
The peak ingress bandwidth may exceed the sustainable bandwidth for periods shorter than a radio frame period.";
}
leaf max-sustainable-egress-bandwidth {
type uint32;
units Mbps;
description
"Maximum sustainable egress bandwidth the interface group can handle. The sustainable bandwidth is calculated
over one radio frame.";
}
}
}
}
// interface-grouping insert - end;
}

576
radio/fhi_72/mplane/yang/models/o-ran-module-cap.yang
View File

@@ -5,7 +5,10 @@ module o-ran-module-cap {
import o-ran-compression-factors {
prefix "cf";
revision-date 2020-08-10;
}
import o-ran-wg4-features {
prefix "or-feat";
}
organization "O-RAN Alliance";
@@ -17,7 +20,7 @@ module o-ran-module-cap {
"This module defines the module capabilities for
the O-RAN Radio Unit.
Copyright 2020 the O-RAN Alliance.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
@@ -43,6 +46,116 @@ module o-ran-module-cap {
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-04-15" {
description
"version 15.0.0
1) add support for multiple beamid tables.
2) remove import by revision date for o-ran-compression-factors.
3) Support for deep hibernate sleep mode.";
reference "ORAN-WG4.M.0-v15.00";
}
revision "2023-12-11" {
description
"version 14.0.0
1) Introduce bundle-offset-in-se11-supported";
reference "ORAN-WG4.M.0-v14.00";
}
revision "2023-08-14" {
description
"version 13.0.0
1) Introduce TRX-control and advanced sleep modes";
reference "ORAN-WG4.M.0-v13.00";
}
revision "2023-04-10" {
description
"version 12.0.0
1) Clarify the parameter number-of-spatial-streams
2) Introduce NB-IoT";
reference "ORAN-WG4.M.0-v12.00";
}
revision "2022-12-05" {
description
"version 11.0.0
1) Deprecation of power-related capabilities and addition of min-gain
2) se6 rb bit handling for rbgSize equal to zero";
reference "ORAN-WG4.M.0-v11.00";
}
revision "2022-08-15" {
description
"version 10.0.0
1) clarified description statements for component carrier
2) style guide corrections
3) introducing new feature for ACK NACK feedback
4) deprecation for params in band-capabilities";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2022-04-18" {
description
"version 9.0.0
1) aded new parameter st6-4byte-alignment-required";
reference "ORAN-WG4.M.0-v09.00";
}
revision "2021-12-01" {
description
"version 8.0.0
1) Typographical corrections in descriptions.
2) deprecation of compression-method-grouping";
reference "ORAN-WG4.M.0-v08.00";
}
revision "2021-07-26" {
description
"version 7.0.0
1) Added support for external antenna delay handling ";
reference "ORAN-WG4.M.0-v07.00";
}
revision "2021-03-22" {
description
"version 5.1.0
1) typographical corrections in descriptions.
2) removed non-ASCII characters
3) clarified number-of-ru-ports_dl/ul description ";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2020-12-10" {
description
"version 5.0.0
1) added support for optimising coupling-via-frequency-and-time-with-priorities
by adding enhancement to existing method through a new leaf node";
reference "ORAN-WG4.M.0-v05.00";
}
revision "2020-08-10" {
description
"version 4.0.0
@@ -55,7 +168,7 @@ module o-ran-module-cap {
to Section Description Priority to serve for CUS-Plane C";
reference "ORAN-WG4.M.0-v04.00";
}
}
revision "2020-04-17" {
description
@@ -68,8 +181,8 @@ module o-ran-module-cap {
5) Enable PRACH preamble formats supported to be signalled by O-RU
6) adding support for selective RE sending
7) supporting new section extension for grouping multiple ports
8) signalling to enable O-RU to ndicate is requires unique ecpri sequence id
for eAxC_IDs serving for UL and DL for the same carrier component";
8) signalling to enable O-RU to indicate is requires unique ecpri sequence id
for eAxC_IDs serving for UL and DL for the same Component Carrier";
reference "ORAN-WG4.M.0-v03.00";
}
@@ -191,24 +304,26 @@ module o-ran-module-cap {
}
grouping compression-method-grouping {
status deprecated;
description
"Grouping for compression method.";
"Grouping for compression method.
Note: This grouping is deprecated. Please use the one from o-ran-compression-factors module.";
leaf compression-method {
type enumeration {
enum BLOCK_FLOATING_POINT {
description
"Block floating point compression and decompression will be used";
"Block floating-point compression and decompression will be used";
}
enum BLOCK_SCALING {
description
"Block scaling compression and decompresion will be used";
"Block scaling compression and decompression will be used";
}
enum U_LAW {
description
"u-Law compression and decompresion method will be used";
"u-Law compression and decompression method will be used";
}
enum BEAMSPACE {
@@ -223,7 +338,7 @@ module o-ran-module-cap {
enum BLOCK-FLOATING-POINT-SELECTIVE-RE-SENDING {
description
"block floating point with selective re sending
"block floating-point with selective re sending
compression and decompression will be used";
}
enum MODULATION-COMPRESSION-SELECTIVE-RE-SENDING {
@@ -233,7 +348,7 @@ module o-ran-module-cap {
}
}
description
"Compresion method which can be supported by the O-RU.
"Compression method which can be supported by the O-RU.
An O-RU may further refine the applicability of compression
methods per endpoint using o-ran-uplane-conf.yang model";
}
@@ -241,20 +356,20 @@ module o-ran-module-cap {
grouping sub-band-max-min-ul-dl-frequency {
description
"Grouping for defining max and min supported frequency - dl and ul.";
"Grouping for defining max and min supported frequency - DL and UL.";
leaf max-supported-frequency-dl {
type uint64;
description
"This value indicates Maximum supported downlink frequency in the
LAA subband. Value unit is Hz.";
LAA sub-band. Value unit is Hz.";
}
leaf min-supported-frequency-dl {
type uint64;
description
"This value indicates Minimum supported downlink frequency in the
LAA subband. Value unit is Hz.";
LAA sub-band. Value unit is Hz.";
}
}
@@ -273,7 +388,7 @@ module o-ran-module-cap {
type boolean;
description
"Informs if O-RU supports realtime variable bit with";
"Informs if O-RU supports real-time variable bit with";
}
list compression-method-supported {
@@ -293,7 +408,7 @@ module o-ran-module-cap {
"List of supported compression methods by O-RU
Note: if O-RU supports different compression methods per endpoint
then please refer to endpoints to have information what
exactly is supported on paticular endpoint";
exactly is supported on particular endpoint";
}
leaf variable-bit-width-per-channel-supported {
@@ -331,6 +446,29 @@ module o-ran-module-cap {
Note - little endian support does not invalidate bigendian support.";
}
leaf st6-4byte-alignment-required {
type boolean;
default false;
description
"An optional flag indicating whether O-RU requires 4-byte aligned Section Type 6 or not.
If 4-byte aligned Section Type 6 is required, O-RU shall set this flag to 'true'.
If the leaf is ommitted or set to 'false', the O-RU operates using 1-byte aligned Section Type 6.
An O-DU recovering a value of 'true' shall ensure that Section Type 6 shall be
sent with 4-byte aligned messages, as described in clause 'Elements for the C-Plane Protocol' of
the CUS-Plane specification.";
}
leaf se6-rb-bit-supported {
type boolean;
default false;
description
"If this leaf node has a value 'true', then O-DU may use the 'rb' bit, in which case
when the O-DU sets the 'rb' bit to one, it shall also set the value of 'rbgsize' to zero and the
O-RU shall interpret the value of 'rb' bit as applicable to this data section. Refer 'SE 6: Non-contiguous
PRB allocation in time and frequency domain' requirement #3 of the CUS-Plane specification.";
}
}
grouping scs-a-b {
@@ -351,7 +489,7 @@ module o-ran-module-cap {
grouping ul-mixed-num-required-guard-rbs {
description
"Required number of guard resource blocks for the combination of
subcarrier spacing values for uplink";
sub-carrier spacing values for uplink";
uses scs-a-b;
leaf number-of-guard-rbs-ul{
type uint8;
@@ -365,7 +503,7 @@ module o-ran-module-cap {
grouping dl-mixed-num-required-guard-rbs {
description
"Required number of guard resource blocks for the combination of
subcarrier spacing values for uplink";
sub-carrier spacing values for uplink";
uses scs-a-b;
leaf number-of-guard-rbs-dl{
type uint8;
@@ -376,6 +514,98 @@ module o-ran-module-cap {
}
}
grouping sleep-mode-capability-info {
description
"Grouping for sleep mode capabilities supported by the O-RU.";
list sleep-modes {
key "sleep-mode-type";
description
"List of sleep mode type supported.";
leaf sleep-mode-type {
type enumeration {
enum SLEEP_MODE_0 {
description "O-RU supports Sleep Mode 0.";
}
enum SLEEP_MODE_1 {
description "O-RU supports Sleep Mode 1.";
}
enum SLEEP_MODE_2 {
description "O-RU supports Sleep Mode 2.";
}
enum SLEEP_MODE_3 {
description "O-RU supports Sleep Mode 3.";
}
}
description
"Type of sleep mode supported.";
}
leaf wake-up-duration {
type uint32;
units microseconds;
description "Wake-up duration for a particular sleep mode.";
}
leaf wake-up-duration-guaranteed {
type boolean;
description
"Informs whether the O-RU guarantees the wakeup duration for a particular sleep mode.
For sleep-mode-type reported as 'SLEEP_MODE_0', the wake-up-duration-guaranteed shall be reported as 'true'";
}
}
leaf defined-duration-sleep-supported {
type boolean;
description
"Informs if the O-RU supports the defined-duration sleep functionality.";
}
leaf undefined-duration-sleep-supported {
type boolean;
description
"Informs if the O-RU supports the undefined-duration sleep functionality.";
}
}
grouping trx-control-capability-info {
description
"A grouping with parameters for TRX-CONTROL capabilities supported by the O-RU";
list supported-trx-control-masks {
key "index";
description
"List of supported TRX control masks.";
leaf index {
type uint8;
description
"Index to the list.";
}
leaf mask-name {
type string;
description
"Unique name for each supported TRX control mask.";
}
leaf antenna-mask {
type binary;
description
"Supported Antenna Mask.";
}
}
uses sleep-mode-capability-info;
}
grouping asm-capability-info {
description
"A grouping with parameters for advanced sleep mode capabilities supported by the O-RU";
uses sleep-mode-capability-info;
}
grouping ru-capabilities {
description
"Structure representing set of capabilities.";
@@ -409,43 +639,78 @@ module o-ran-module-cap {
leaf number-of-ru-ports-ul {
type uint8;
description
"Assuming all endpoints support time-managed traffic AND non-time-managed traffic (choice is as per configuration)
- the number of O-RU ports for uplink is the product of number of spatial streams (leaf number-of-spatial-streams) and number of numerologies O-RU supports.
For example, if the number of spatial streams is 4 then the number of O-RU ports is 8 when PUSCH and PRACH are processed in the different endpoints.
"Assuming all endpoints support time-managed traffic AND non-time-managed traffic AND static channel configuration (choice is as per configuration)
- the upper bound of the number of O-RU ports for uplink which is derived from number of UL spatial streams or layers
and associated numerology O-RU supports.
Numerology capability per spatial stream or layer is based on eaxc id description in CUS specification section entitled
'ecpriRtcid / ecpriPcid (real time control data / IQ data transfer message series identifier)'
For example, if O-RU supports for each of 'N' spatial streams or layers 'M' numerologies (as it applies to PUSCH and PRACH), number of ports is N * M.
In case there are specific endpoints that support non-time-managed traffic only
- the number of O-RU ports calculated with above mentioned equation is extended by number of endpoints supporting only non-time-managed traffic.";
- the number of O-RU ports calculated is extended by number of endpoints supporting only non-time-managed traffic.
Additionally, if there are specific endpoints that support static channel configuration only(e.g. static PRACH)
- the number of O-RU ports calculated above is further extended by number of endpoints supporting static channel configuration only.";
}
leaf number-of-ru-ports-dl {
type uint8;
description
"Assuming all endpoints support time-managed traffic AND non-time-managed traffic (choice is as per configuration)
- the number of O-RU ports for downlink is the product of number of spatial streams (leaf number-of-spatial-streams) and number of numerologies O-RU supports.
For example, if the number of spatial streams is 4 then the number of O-RU ports is 8 when SSB and non-SSB are processed in the different endpoints.
In case there are specific endpoints that support non-time-managed traffic only
- the number of O-RU ports calculated with above mentioned equation is extended by number of endpoints supporting only non-time-managed traffic.";
- the upper bound of the number of O-RU ports for downlink which is derived from number of DL spatial streams or layers
and associated numerology O-RU supports.
Numerology capability per spatial stream or layer is based on eaxc id description in CUS specification section entitled
'ecpriRtcid / ecpriPcid (real time control data / IQ data transfer message series identifier)'
For example, if O-RU supports for each of 'N' spatial streams or layers 'M' numerologies, number of ports is N * M.
In case there are specific endpoints that support non-time-managed traffic only.
- the number of O-RU ports calculated with above mentioned equation is extended by number of endpoints supporting only non-time-managed traffic";
}
leaf number-of-spatial-streams {
type uint8;
description
"This value indicates the number of spatial streams supported at O-RU for DL and UL.
For DL, it is same as the number of antenna ports specified in 3GPP TS38.214, Section 5.2 and 3GPP TS36.213, Section 5.2.";
"This value indicates the maximum accumulated number of spatial streams supported by O-RU for DL and UL.
For definition of spatial stream, please refer to CUS plane specification clause 3.1 for details.";
}
leaf number-of-spatial-streams-dl {
type uint8;
description
"The maximum number of DL spatial streams that O-RU supports.
For definition of spatial stream, please refer to CUS plane specification clause 3.1 for details.";
}
leaf number-of-spatial-streams-ul {
type uint8;
description
"The maximum number of UL spatial streams that O-RU supports.
For definition of spatial stream, please refer to CUS plane specification clause 3.1 for details..";
}
leaf max-num-bands {
type uint16;
description "maximum number of bands supported by the O-RU";
}
leaf max-power-per-pa-antenna {
type decimal64{
fraction-digits 4;
}
status deprecated;
description
"This value indicates Maximum Power per PA per antenna. Value unit is dBm.";
"This value indicates Maximum Power per PA per antenna. Value unit is dBm.
The parameter is deprecated. min-gain and max-gain define constraints related to
TX power budget, as defined in CUS-Plane, clause 8.1.3.3.";
}
leaf min-power-per-pa-antenna {
type decimal64{
fraction-digits 4;
}
status deprecated;
description
"This value indicates Minimum Power per PA per antenna. Value unit is dBm.";
"This value indicates Minimum Power per PA per antenna. Value unit is dBm.
The parameter is deprecated. min-gain and max-gain define constraints related to
TX power budget, as defined in CUS-Plane, clause 8.1.3.3.";
}
leaf fronthaul-split-option {
@@ -467,7 +732,7 @@ module o-ran-module-cap {
key "scs-a scs-b";
description
"List of required number of guard resource blocks
for the combination of subcarrier spacing values for downlink";
for the combination of sub-carrier spacing values for downlink";
uses ul-mixed-num-required-guard-rbs;
}
@@ -475,7 +740,7 @@ module o-ran-module-cap {
key "scs-a scs-b";
description
"List of required number of guard resource blocks
for the combination of subcarrier spacing values for uplink";
for the combination of sub-carrier spacing values for uplink";
uses dl-mixed-num-required-guard-rbs;
}
@@ -498,7 +763,7 @@ module o-ran-module-cap {
leaf max-num-tx-eaxc-ids-per-group {
type uint8;
description
"Maximum number of member-tx-eaxc-id in single tx-eaxc-id-group supported by O-RU.";
"Maximum number of eAxC IDs per tx-eaxc-id-group supported by O-RU, where each group is a union of the 'member-tx-eaxc-id's and a 'representative-tx-eaxc-id'.";
}
leaf max-num-rx-eaxc-id-groups {
type uint8;
@@ -508,7 +773,7 @@ module o-ran-module-cap {
leaf max-num-rx-eaxc-ids-per-group {
type uint8;
description
"the maximum number of eAxC IDs per rx-eaxc-id-group.";
"Maximum number of eAxC IDs per rx-eaxc-id-group supported by O-RU, where each group is a union of the 'member-rx-eaxc-id's and a 'representative-rx-eaxc-id'.";
}
}
@@ -523,13 +788,13 @@ module o-ran-module-cap {
type boolean;
default false;
description
"Parameter informs if O-RU expects unique ecpri sequence id for eAxC_IDs serving
for UL and DL for the same carrier component.
"Parameter informs if O-RU expects unique eCPRI sequence id for eAxC_IDs serving
for UL and DL for the same Component Carrier.
Note: If this is set to TRUE, the O-DU can decide to either use different eAxC_IDs for UL and
DL or can generate unique sequence ID per eAxC_ID.
TAKE NOTE: This leaf is backwards compatible from an O-RU persepctive BUT an O-RU that
TAKE NOTE: This leaf is backwards compatible from an O-RU perspective BUT an O-RU that
sets this leaf to TRUE may result in incompatibilities when operating with an O-DU
designed according to the O-RAN CUS-Plane Specification v02.00, e.g., if the O-DU is
incapable of using different eAxC values between UL and DL";
@@ -551,6 +816,13 @@ module o-ran-module-cap {
"Coupling via Frequency and time with priorities; see methods of coupling of C-plane and U-plane in CUS-Plane specification.
Note: If coupling-via-frequency-and-time-with-priorities is 'true' then coupling-via-frequency-and-time shall also be 'true'.";
}
leaf coupling-via-frequency-and-time-with-priorities-optimized {
type boolean;
description
"Coupling via Frequency and time with priorities optimised; see methods of coupling of C-plane and U-plane in CUS-Plane specification.
Note: If coupling-via-frequency-and-time-with-priorities-optimized is 'true' then coupling-via-frequency-and-time shall also be 'true'.";
}
}
leaf ud-comp-len-supported {
@@ -560,10 +832,109 @@ module o-ran-module-cap {
Only in case this leaf is present and its value is TRUE, O-RU supports U-Plane messages
containing udCompLen field in section header.";
}
leaf ext-ant-delay-capability {
if-feature "or-feat:EXT-ANT-DELAY-CONTROL";
type enumeration {
enum PER-ARRAY-CARRIER {
description
"Informs that the O-RU supports the configuration of different t-da-offset on different tx-array-carriers,
and different t-au-offset on different rx-array-carriers";
}
enum PER-ARRAY {
description
"Informs that the O-RU supports the configuration of different t-da-offset on different tx-array-carriers
only when those tx-array-carriers belong to different tx-arrays,
and the O-RU supports the configuration of different t-au-offset on different rx-array-carriers
only when those rx-array-carriers belong to different rx-arrays";
}
enum PER-O-RU {
description
"Informs that the O-RU only supports the configuration of a common t-da-offset across all tx-array-carriers,
and a common t-au-offset across all rx-array-carriers";
}
}
description
"This property informs what kind of capability the O-RU supports to be configured with external antenna delay.";
}
leaf nack-supported {
type boolean;
description
"This value indicates if O-RU supports sending NACK feedback if a section extension for ACK/NACK request is received,
If O-RU reports supporting section extension for ACK/NACK request (section extension 22) and ACK/NACK feedback (section type 8), ACK feedback shall always be supported,
while NACK feedback is optionally supported according to 'nack-supported'";
}
leaf st8-scs-supported {
type boolean;
description
"Informs if O-RU supports the optional field scs in Section Type 8 messages.";
}
container energy-saving-capability-common-info {
if-feature "or-feat:TRX-CONTROL or or-feat:ADVANCED-SLEEP-MODE";
description
"A container with parameters for common energy saving capabilities supported by the O-RU";
leaf st8-ready-message-supported {
type boolean;
description
"Informs if the O-RU supports Section Type 8 Ready message.";
}
leaf sleep-duration-extension-supported {
type boolean;
description
"Informs if the O-RU supports extension of sleep duration.";
}
leaf emergency-wake-up-command-supported {
type boolean;
description
"Informs if the O-RU supports emergency wake-up M-Plane command.";
}
}
leaf bundle-offset-in-se11-supported {
type boolean;
default false;
description
"Informs if O-RU supports receiving non-zero values of bundleOffset in SE11.
For details, see CUS-Plane Specification, clause 7.7.11.10.";
}
leaf max-beamId-tables-supported {
if-feature "or-feat:MULTIPLE-BEAMID-TABLES-SUPPORTED";
type uint8;
description
"This parameter defines the maximum number of beamId tables supported by the O-RU.";
}
leaf min-hibernate-time-duration {
if-feature "or-feat:DEEP-HIBERNATE";
type uint32;
units minutes;
description
"Informs about the minimum hibernate-time duration that O-RU
supports deep-hibernate sleep";
}
leaf max-hibernate-time-duration {
if-feature "or-feat:DEEP-HIBERNATE";
type uint32;
units minutes;
mandatory true;
description
"Informs about the maximum hibernate-time duration that O-RU supports deep-hibernate sleep";
}
}
grouping sub-band-info {
description "container for collection of leafs for LAA subband 46";
description "container for collection of leafs for LAA sub-band 46";
list sub-band-frequency-ranges {
key sub-band;
description "frequency information on a per sub-band basis";
@@ -584,7 +955,7 @@ module o-ran-module-cap {
description
"Maximum O-RU buffer size in Kilobytes (KB) per CC. This parameter is
needed at the O-DU to know how much data can be sent in advance
and stored at the O-RU to address the LBT uncertainity.";
and stored at the O-RU to address the LBT uncertainty.";
}
leaf maximum-processing-time {
@@ -593,7 +964,7 @@ module o-ran-module-cap {
description
"Maximum O-RU Processing time in microseconds at the O-RU to handle the
received/transmitted packets from/to the O-DU. This parameter is
needed at the O-DU to determine the time where it needs to send
needed at the O-DU to determine the time when it needs to send
the data to the O-RU.";
}
@@ -603,6 +974,61 @@ module o-ran-module-cap {
}
}
grouping supported-filter-pass-bandwidths {
description
"Grouping of filter pass bandwidth capabilities";
list supported-filter-pass-bandwidths {
key "id";
config false;
leaf id {
type uint32;
description
"Identification number for a supported filter pass bandwidth.";
}
leaf type {
type enumeration {
enum LTE {
description
"LTE technology.";
}
enum NR {
description
"NR technology.";
}
enum DSS_LTE_NR {
if-feature DSS_LTE_NR;
description
"DSS of LTE and NR technologies.";
}
}
description
"Supported carrier type for filter pass bandwidth value.";
}
leaf carrier-bandwidth {
type uint64;
units Hz;
description
"Bandwidth of a carrier for which filter pass bandwidth can be used.";
}
leaf filter-pass-bandwidth {
type uint64;
units Hz;
description
"Filter pass bandwidth of a carrier.";
}
description
"List of supported filter pass bandwidths by carriers.";
}
}
grouping support-for-dl {
description
"Grouping for DL specific parameters";
@@ -662,6 +1088,24 @@ module o-ran-module-cap {
description
"This list provides information regarding technologies supported in DL path";
}
container supported-filter-pass-bandwidths-dl {
description
"Filter pass bandwidth capabilities for DL.";
uses supported-filter-pass-bandwidths;
}
leaf-list tx-array-beamId-table-indexes {
if-feature "or-feat:MULTIPLE-BEAMID-TABLES-SUPPORTED";
type uint8;
min-elements 1;
description
"When O-RU advertises support for multiple beamId tables, this list shall specify the beamId table indexes
associated with a given tx-array capabilities list entry. O-DU shall be restricted to choose
one or multiple entries for a given configured tx-array-carrier from this list.
Note: tx-array and rx-array may use the same beamId table indexes.";
}
}
grouping support-for-ul {
@@ -723,6 +1167,23 @@ module o-ran-module-cap {
description
"This list provides information regarding technologies supported in UL path";
}
container supported-filter-pass-bandwidths-ul {
description
"Filter pass bandwidth capabilities for UL.";
uses supported-filter-pass-bandwidths;
}
leaf-list rx-array-beamId-table-indexes {
if-feature "or-feat:MULTIPLE-BEAMID-TABLES-SUPPORTED";
type uint8;
min-elements 1;
description
"When O-RU advertises support for multiple beamId tables, this list shall specify the beamId table indexes
associated with a given rx-array capabilities list entry. O-DU shall be restricted to choose
one or multiple entries for a given configured rx-array-carrier from this list.
Note: tx-array and rx-array may use the same beamId table indexes.";
}
}
grouping band-capabilities {
@@ -738,7 +1199,7 @@ module o-ran-module-cap {
container sub-band-info {
when "../band-number = '46'";
if-feature "o-ran-module-cap:LAA";
description "container for collection of leafs for LAA subband 46";
description "container for collection of leafs for LAA sub-band 46";
uses sub-band-info;
}
@@ -747,12 +1208,15 @@ module o-ran-module-cap {
leaf max-num-component-carriers {
type uint8;
description "maximum number of component carriers supported by the O-RU";
description "maximum number of component carriers supported by the O-RU. This parameter is the
cumulative value of 'max-num-carriers-dl' and 'max-num-carriers-ul'";
}
leaf max-num-bands {
type uint16;
description "maximum number of bands supported by the O-RU";
status deprecated;
description "maximum number of bands supported by the O-RU.
Parameter moved to ru-capabilities, hence deprecated";
}
leaf max-num-sectors {
@@ -764,34 +1228,48 @@ module o-ran-module-cap {
type decimal64{
fraction-digits 4;
}
status deprecated;
description
"This value indicates Maximum Power per band per antenna. Value unit is dBm.";
"This value indicates Maximum Power per band per antenna. Value unit is dBm.
The parameter is deprecated. min-gain and max-gain define constraints related to
TX power budget, as defined in CUS-Plane, clause 8.1.3.3.";
}
leaf min-power-per-antenna {
type decimal64{
fraction-digits 4;
}
status deprecated;
description
"This value indicates Minimum Power per band per antenna. Value unit is dBm.";
"This value indicates Minimum Power per band per antenna. Value unit is dBm.
The parameter is deprecated. min-gain and max-gain define constraints related to
TX power budget, as defined in CUS-Plane, clause 8.1.3.3.";
}
leaf codebook-configuration_ng {
type uint8;
status deprecated;
description
"This parameter informs the precoder codebook_ng that are used for precoding";
"This parameter informs the precoder codebook_ng that are used for precoding.
Parameter deprecated since antenna topology already specified in [tr]x-array";
}
leaf codebook-configuration_n1 {
type uint8;
status deprecated;
description
"This parameter informs the precoder codebook_n1 that are used for precoding";
"This parameter informs the precoder codebook_n1 that are used for precoding
Parameter deprecated since antenna topology already specified in [tr]x-array";
}
leaf codebook-configuration_n2 {
type uint8;
status deprecated;
description
"This parameter informs the precoder codebook_n2 that are used for precoding";
"This parameter informs the precoder codebook_n2 that are used for precoding
Parameter deprecated since antenna topology already specified in [tr]x-array";
}
}
@@ -836,5 +1314,5 @@ module o-ran-module-cap {
"This value indicates that the O-RU can manage the contention window locally.";
}
}
}
}
}

2008
radio/fhi_72/mplane/yang/models/o-ran-performance-management.yang
View File

File diff suppressed because it is too large Load Diff

425
radio/fhi_72/mplane/yang/models/o-ran-processing-element.yang
View File

@@ -23,6 +23,14 @@ module o-ran-processing-element {
prefix "o-ran-int";
}
import o-ran-wg4-features {
prefix "feat";
}
import o-ran-usermgmt {
prefix "or-user";
}
organization "O-RAN Alliance";
contact
@@ -32,7 +40,7 @@ module o-ran-processing-element {
"This module defines the YANG definitions for mapping of transport flows to
processing elements. Three options are supported:
i) virtual MAC based mapping
ii) MAC addrress + VLAN-ID based mapping
ii) MAC address + VLAN-ID based mapping
iii) UDP/IP based mapping
Copyright 2020 the O-RAN Alliance.
@@ -61,16 +69,37 @@ module o-ran-processing-element {
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2020-04-17" {
description
"version 3.0.0
revision "2022-08-15" {
description
"version 10.0.0
1) added new enum SHARED-CELL-ETH-INTERFACE in
transport-session-type and new containers north-eth-flow and
south-eth-flow to enable Shared cell scenario.";
1) introducing SHARED-ORU-MULTI-OPERATOR feature
2) fixing constraints";
reference "ORAN-WG4.M.0-v03.00";
}
reference "ORAN-WG4.M.0-v10.00";
}
revision "2021-12-01" {
description
"version 8.0.0
1) typographical corrections in descriptions.
2) Add support for multiple transport-session-type per O-RU";
reference "ORAN-WG4.M.0-v08.00";
}
revision "2020-04-17" {
description
"version 3.0.0
1) added new enum SHARED-CELL-ETH-INTERFACE in
transport-session-type and new containers north-eth-flow and
south-eth-flow to enable Shared cell scenario.";
reference "ORAN-WG4.M.0-v03.00";
}
revision "2019-07-03" {
description
@@ -78,7 +107,7 @@ module o-ran-processing-element {
1) added new leaf to enable O-RU to report the maximum number of
transport flows it can support, e.g., due to restrictions on number
of VLAN-IDs when ethernet type transport is used.";
of VLAN-IDs when Ethernet type transport is used.";
reference "ORAN-WG4.M.0-v01.00";
}
@@ -99,16 +128,162 @@ module o-ran-processing-element {
}
// groupings
grouping pe-group {
leaf maximum-number-of-transport-flows {
type uint16 {
range "1..4094";
grouping non-shared-cell-flow-group {
description "a grouping for non-shared cell O-RU flows";
container aliasmac-flow {
when "../../../transport-session-type = 'ALIASMAC-INTERFACE'";
if-feature o-ran-int:ALIASMAC-BASED-CU-PLANE;
description "leafs for virtual mac type data flows";
leaf ru-aliasmac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:alias-macs";
}
mandatory true;
description
"O-RU's alias MAC address used for alias MAC based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
description
"O-RU's VLAN-ID used for alias MAC based flow";
}
leaf o-du-mac-address {
type yang:mac-address;
mandatory true;
description
"O-DU's MAC address used for alias MAC based flow";
}
config false;
default 4094;
description
"The maximum number of transport flows that can be supported by an O-RU";
}
container eth-flow {
when "../../../transport-session-type = 'ETH-INTERFACE'";
description "leafs for mac + vlan-id type data flows";
leaf ru-mac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:mac-address";
}
mandatory true;
description
"O-RU's MAC address used for Ethernet based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
mandatory true;
description
"O-RU's VLAN-ID used for Ethernet based flow";
}
leaf o-du-mac-address {
type yang:mac-address;
mandatory true;
description
"O-DU's MAC address used for Ethernet based flow";
}
}
container udpip-flow {
when "../../../transport-session-type = 'UDPIP-INTERFACE'";
description "leafs for UDP/IP type data flows";
choice address {
leaf ru-ipv4-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/ip:ipv4/ip:address/ip:ip";
}
description "O-RU's IPv4 address";
}
leaf ru-ipv6-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/ip:ipv6/ip:address/ip:ip";
}
description "O-RU's IPv6 address";
}
mandatory true;
description "choice of O-RU IPv4 or IPv6 address";
}
leaf o-du-ip-address {
type inet:ip-address;
mandatory true;
description "O-DU's IP address";
}
leaf ru-ephemeral-udp-port {
type inet:port-number;
mandatory true;
description
"ephemeral port used by O-RU";
}
leaf o-du-ephemeral-udp-port {
type inet:port-number;
mandatory true;
description
"ephemeral port used by O-DU";
}
leaf ecpri-destination-udp {
type inet:port-number;
mandatory true;
description "the well-known UDP port number used by eCPRI";
// fixme - add in a default when allocated by IANA
}
}
}
grouping shared-cell-flow-group {
description "a grouping for shared cell O-RU flows";
container north-eth-flow {
when "../../../transport-session-type = 'SHARED-CELL-ETH-INTERFACE'";
if-feature "SHARED_CELL";
description "leafs for mac + vlan-id type data flows";
leaf ru-mac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:mac-address";
}
description
"O-RU's MAC address used for Ethernet based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
description
"O-RU's VLAN-ID used for Ethernet based flow";
}
leaf north-node-mac-address {
type yang:mac-address;
description
"North-node's MAC address used for Ethernet based flow";
}
}
container south-eth-flow {
when "../../../transport-session-type = 'SHARED-CELL-ETH-INTERFACE'";
if-feature "SHARED_CELL";
description "leafs for mac + vlan-id type data flows";
leaf ru-mac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:mac-address";
}
description
"O-RU's MAC address used for Ethernet based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
description
"O-RU's VLAN-ID used for Ethernet based flow";
}
leaf south-node-mac-address {
type yang:mac-address;
description
"south-node's MAC address used for Ethernet based flow";
}
}
}
grouping session-and-markings-group {
description "a grouping with transport session type and enhanced uplane markings";
leaf transport-session-type {
type enumeration {
enum ETH-INTERFACE {
@@ -158,7 +333,7 @@ module o-ran-processing-element {
case ipv4 {
when "(../../transport-session-type = 'UDPIP-INTERFACE')";
leaf upv4-dscp-name {
if-feature o-ran-int:UDPIP-BASED-CU-PLANE;
if-feature o-ran-int:UDPIP-BASED-CU-PLANE;
type leafref {
path "/if:interfaces/if:interface/ip:ipv4/o-ran-int:diffserv-markings/o-ran-int:enhanced-uplane-markings/o-ran-int:up-marking-name";
}
@@ -168,7 +343,7 @@ module o-ran-processing-element {
case ipv6 {
when "(../../transport-session-type = 'UDPIP-INTERFACE')";
leaf upv6-dscp-name {
if-feature o-ran-int:UDPIP-BASED-CU-PLANE;
if-feature o-ran-int:UDPIP-BASED-CU-PLANE;
type leafref {
path "/if:interfaces/if:interface/ip:ipv6/o-ran-int:diffserv-markings/o-ran-int:enhanced-uplane-markings/o-ran-int:up-marking-name";
}
@@ -178,6 +353,21 @@ module o-ran-processing-element {
}
}
}
}
grouping pe-group {
description "a grouping of processing elements";
leaf maximum-number-of-transport-flows {
type uint16 {
range "1..4094";
}
default 4094;
config false;
description
"The maximum number of transport flows that can be supported by an O-RU";
}
uses session-and-markings-group;
list ru-elements {
key "name";
description
@@ -193,6 +383,17 @@ module o-ran-processing-element {
This name may be used in fault management to refer to a fault source
or affected object";
}
leaf sro-id {
if-feature feat:SHARED-ORU-MULTI-OPERATOR;
type leafref {
path "/or-user:users/or-user:user/or-user:sro-id";
}
description
"The identity of a shared resource operator. When present,
indicates that the list entry corresponds to a processing element
associated with a shared resource operator where the sro-id identifies
the specific shared resource operator";
}
container transport-flow {
description
"container for the transport-flow used for CU plane";
@@ -202,154 +403,66 @@ module o-ran-processing-element {
}
description "the interface name ";
}
container aliasmac-flow {
when "../../../transport-session-type = 'ALIASMAC-INTERFACE'";
if-feature o-ran-int:ALIASMAC-BASED-CU-PLANE;
description "leafs for virtual mac type data flows";
leaf ru-aliasmac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:alias-macs";
}
mandatory true;
description
"O-RU's alias MAC address used for alias MAC based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
description
"O-RU's VLAN-ID used for alias MAC based flow";
}
leaf o-du-mac-address {
type yang:mac-address;
mandatory true;
description
"O-DU's MAC address used for alias MAC based flow";
uses non-shared-cell-flow-group;
uses shared-cell-flow-group;
}
}
list additional-transport-session-type-elements {
if-feature "feat:MULTIPLE-TRANSPORT-SESSION-TYPE";
key transport-session-type;
description
"Added to support multiple transport-session-type per O-RU,
it is always assumed that /processing-elements/ru-elements/ is configured with the first type of transport,
and /processing-element/additional-transport-session-elements/ru-elements/ is configured with the other types of transport.
If the O-RU is configured for shared-cell, this list will not be used. An O-RU shall reject any configuration
with a list entry with transport-session-type set to SHARED-CELL-ETH-INTERFACE";
uses session-and-markings-group;
list ru-elements {
key "name";
description
"the list of transport definitions for each processing element";
leaf name {
type string {
length "1..255";
}
description
"A name that is unique across the O-RU that identifies a processing
element instance.
This name may be used in fault management to refer to a fault source
or affected object";
}
container eth-flow {
when "../../../transport-session-type = 'ETH-INTERFACE'";
description "leafs for mac + vlan-id type data flows";
leaf ru-mac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:mac-address";
}
mandatory true;
description
"O-RU's MAC address used for Ethernet based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
mandatory true;
description
"O-RU's VLAN-ID used for Ethernet based flow";
}
leaf o-du-mac-address {
type yang:mac-address;
mandatory true;
description
"O-DU's MAC address used for Ethernet based flow";
leaf sro-id {
if-feature feat:SHARED-ORU-MULTI-OPERATOR;
type leafref {
path "/or-user:users/or-user:user/or-user:sro-id";
}
description
"The identity of a shared resource operator. When present,
indicates that the list entry corresponds to a processing element
associated with a shared resource operator where the sro-id identifies
the specific shared resource operator";
}
container udpip-flow {
when "../../../transport-session-type = 'UDPIP-INTERFACE'";
description "leafs for UDP/IP type data flows";
choice address {
leaf ru-ipv4-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/ip:ipv4/ip:address/ip:ip";
}
description "O-RU's IPv4 address";
}
leaf ru-ipv6-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/ip:ipv6/ip:address/ip:ip";
}
description "O-RU's IPv6 address";
}
mandatory true;
description "choice of O-RU IPv4 or IPv6 address";
}
leaf o-du-ip-address {
type inet:ip-address;
mandatory true;
description "O-DU's IPv address";
}
leaf ru-ephemeral-udp-port {
type inet:port-number;
mandatory true;
description
"ephemeral port used by O-RU";
}
leaf o-du-ephemeral-udp-port {
type inet:port-number;
mandatory true;
description
"ephemeral port used by O-DU";
}
leaf ecpri-destination-udp {
type inet:port-number;
mandatory true;
description "the well known UDP port number used by eCPRI";
// fixme - add in a default when allocated by IANA
}
}
container north-eth-flow {
when "../../../transport-session-type = 'SHARED-CELL-ETH-INTERFACE'";
if-feature "SHARED_CELL";
description "leafs for mac + vlan-id type data flows";
leaf ru-mac-address {
container transport-flow {
description
"container for the transport-flow used for CU plane";
leaf interface-name {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:mac-address";
path "/if:interfaces/if:interface/if:name";
}
description
"O-RU's MAC address used for Ethernet based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
description
"O-RU's VLAN-ID used for Ethernet based flow";
}
leaf north-node-mac-address {
type yang:mac-address;
description
"North-node's MAC address used for Ethernet based flow";
}
}
container south-eth-flow {
when "../../../transport-session-type = 'SHARED-CELL-ETH-INTERFACE'";
if-feature "SHARED_CELL";
description "leafs for mac + vlan-id type data flows";
leaf ru-mac-address {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:mac-address";
}
description
"O-RU's MAC address used for Ethernet based flow";
}
leaf vlan-id {
type leafref {
path "/if:interfaces/if:interface[if:name = current()/../../interface-name]/o-ran-int:vlan-id";
}
description
"O-RU's VLAN-ID used for Ethernet based flow";
}
leaf south-node-mac-address {
type yang:mac-address;
description
"south-node's MAC address used for Ethernet based flow";
description "the interface name ";
}
uses non-shared-cell-flow-group;
}
}
}
}
// top level container
// top-level container
container processing-elements {
description

3771
radio/fhi_72/mplane/yang/models/o-ran-uplane-conf.yang
View File

File diff suppressed because it is too large Load Diff

331
radio/fhi_72/mplane/yang/models/o-ran-usermgmt.yang Normal file
View File

@@ -0,0 +1,331 @@
module o-ran-usermgmt {
yang-version 1.1;
namespace "urn:o-ran:user-mgmt:1.0";
prefix "o-ran-usermgmt";
import ietf-netconf-acm {
prefix nacm;
reference
"RFC 8341: Network Configuration Access Control Model";
}
import o-ran-wg4-features {
prefix "feat";
}
import ietf-crypto-types {
prefix ct;
}
organization "O-RAN Alliance";
contact
"www.o-ran.org";
description
"This module defines the user management model for the O-RAN Equipment.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the above disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the above disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the Members of the O-RAN Alliance nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-08-12" {
description
"version 16.0.0
1) add SSH Public Key.";
reference "ORAN-WG4.M.0-v16.00";
}
revision "2023-12-11" {
description
"version 10.1.0
1) clarify handling of User-Names.";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2022-08-15" {
description
"version 10.0.0
1) introduced SHARED-ORU-MULTI-OPERATOR feature.";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2021-12-01" {
description
"version 1.3.0
1) typographical corrections in descriptions";
reference "ORAN-WG4.M.0-v01.00";
}
revision "2020-12-10" {
description
"version 1.2.0
1) updated description for enabled leaf";
reference "ORAN-WG4.M.0-v01.00";
}
revision "2019-07-03" {
description
"version 1.1.0
1) change name leaf to type nacm:user-name-type
2) added account-type to qualify when password is required ";
reference "ORAN-WG4.M.0-v01.00";
}
revision "2019-02-04" {
description
"version 1.0.0
1) imported model from xRAN
2) changed namespace and reference from xran to o-ran";
reference "ORAN-WG4.M.0-v01.00";
}
typedef password-type {
type string {
length "8..128";
pattern "[a-zA-Z0-9!$%\\^()\\[\\]_\\-~{}.+]*" {
error-message "Password content does not meet the requirements";
}
}
description
"The password for this entry.
The Password must contain at least 2 characters from
each of the following groups:
a) Lower case alphabetic (a-z)
b) Upper case alphabetic (A-Z)
c) Numeric 0-9
d) Special characters Allowed !$%^()[]_-~{}.+
Password must not contain Username.
When a password is received by a NETCONF server,
it should be securely stored in the O-RU's configuration datastore.
How to securely store the password in the datastore is implementation-specific
and out of scope of WG4 M-Plane specification.";
}
grouping user-list {
description "a user list grouping";
list user {
key "name";
description
"The list of local users configured on this device.";
leaf name {
type nacm:user-name-type;
description
"The user name string identifying this entry.
NOTE: o-ran-usermgmt:user-profile/user/name is
identical to nacm:nacm/groups/group/user-name
but the current schema is preserved for backwards
compatibility.";
}
leaf account-type {
type enumeration {
enum PASSWORD {
description "the user-name is for password based authentication";
}
enum CERTIFICATE {
description "the user-name is for certificate based authentication";
}
enum SSHPUBLICKEY {
if-feature feat:CLIENT-AUTH-SSH-PUBLIC-KEY;
description "the user-name is for public key based authentication";
}
}
default "PASSWORD";
description "the account type";
}
leaf password {
nacm:default-deny-all;
type password-type;
description
"The password for this entry.
This field is only valid when account-type is PASSWORD,
i.e., when account-type is NOT present or present and set to
PASSWORD.";
}
container ssh-public-key {
nacm:default-deny-all;
when "../account-type='SSHPUBLICKEY'";
if-feature feat:CLIENT-AUTH-SSH-PUBLIC-KEY;
uses ct:public-key-grouping;
description
"The SSH pubic key for this entry.
This field is valid only when account-type is SSHPUBLICKEY.";
}
leaf enabled {
type boolean;
description
"Indicates whether an account is enabled or disabled.
A NETCONF Server shall reject a configuration that attempts to
enable a Password account for an account where the password leaf
is not configured.
This validation statement is included in the YANG description and
not in a MUST statement to preserve backwards compatibility.";
}
leaf-list sro-id {
if-feature feat:SHARED-ORU-MULTI-OPERATOR;
type string;
description
"An optional list if Shared Resource Operator identities associated with the
user-account. Used to realize enhanced access privileges in a shared O-RU.
When an sro-id is configured in the O-RU, the O-RU shall
implement additional sro-id based NETCONF access control
as specified in O-RAN.WG4.MP.0-v10.00.
The O-RU does not further interpret the specific value of sro-id.";
}
}
}
container users {
must "user/enabled='true'" {
error-message "At least one account needs to be enabled.";
}
//TAKE NOTE - any configuration with zero enabled users is invalid.
//This will typically be the case when using a simulated NETCONF Server
//and so this constraint should be removed when operating in those scenarios
//The config data base of the O-RAN equipment should ensure that the user
//default account is enabled on factory restart
description "list of user accounts";
uses user-list;
}
rpc chg-password {
description "the RPC used to change a password";
nacm:default-deny-all;
input {
leaf currentPassword {
type password-type;
mandatory true;
description
"provide the current password";
}
leaf newPassword {
type password-type;
mandatory true;
description
"provide a new password";
}
leaf newPasswordConfirm {
type password-type;
mandatory true;
description
"re-enter the new password ";
}
}
output {
leaf status {
type enumeration {
enum "Successful" {
value 1;
description "change password operation is successful";
}
enum "Failed" {
value 2;
description "change password operation failed";
}
}
mandatory true;
description
"Successful or Failed";
}
leaf status-message {
type string;
description
"Gives a more detailed reason for success / failure";
}
}
}
rpc chg-ssh-public-key {
if-feature feat:CLIENT-AUTH-SSH-PUBLIC-KEY;
description "the RPC used to change SSH public key";
nacm:default-deny-all;
input {
container current-ssh-public-key {
uses ct:public-key-grouping;
description
"provide the current SSH public algorithm and key";
}
container new-ssh-public-key {
uses ct:public-key-grouping;
description
"provide a new SSH public algorithm and key";
}
container new-ssh-public-key-confirm {
uses ct:public-key-grouping;
description
"re-enter the new SSH public algorithm and key";
}
}
output {
leaf status {
type enumeration {
enum "Successful" {
value 1;
description "change SSH public key operation is successful";
}
enum "Failed" {
value 2;
description "change SSH public key operation failed";
}
}
mandatory true;
description
"Successful or Failed";
}
leaf status-message {
type string;
description
"Gives a more detailed reason for success / failure";
}
}
}
}

532
radio/fhi_72/mplane/yang/models/o-ran-wg4-features.yang Normal file
View File

@@ -0,0 +1,532 @@
module o-ran-wg4-features {
yang-version 1.1;
namespace "urn:o-ran:wg4feat:1.0";
prefix "o-ran-feat";
organization "O-RAN Alliance";
contact
"www.o-ran.org";
description
"This module defines the set of re-usable type definitions for WG4 specific
features.
Copyright 2024 the O-RAN Alliance.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the above disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the above disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the Members of the O-RAN Alliance nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.";
revision "2024-08-12" {
description
"version 16.0.0
new features:
1) PRG-SIZE-SUPP-SE-21-WITH-ST6
2) PRG-SIZE-SUPP-SE-21-WITH-ST5
3) USER-GROUP-OPTIMIZATION
4) BF-DELAY-PROFILE
5) DMRS-BF-EQ
6) DMRS-BF-NEQ
7) RRM-MEAS-REPORTING
8) USER-GROUP-SELF-ASSEMBLY
9) UEID-PERSISTENCE
10) CONTINUITY-BLOCK-SIZE
11) SELECTED-BF-METHOD-CONFIGURATION
12) DMRS-BF-NEQ-UNALTERED-FREQ-OFFSET
13) DMRS-BF-NEQ-UNALTERED-TAE
14) SE10-MEMBER-CANDIDATE-LIST
15) MACSEC-BYPASS-POLICY
16) SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION
17) SE20-MULTI-SD-PUNC-PATTERN-SUPPORT
18) CONFIGURABLE-VSWR-THRESHOLDS
19) CLIENT-AUTH-SSH-PUBLIC-KEY
20) POINT-A-OFFSET-TO-ABSOLUTE-FREQUENCY-CENTER";
reference "ORAN-WG4.M.0-v16.00";
}
revision "2024-04-15" {
description
"version 15.0.0
new features:
1) PRG-SIZE-SUPP-SE-21-WITH-ST6
2) PRG-SIZE-SUPP-SE-21-WITH-ST5
3) BF-DELAY-PROFILE
4) USER-GROUP-OPTIMIZATION
5) MULTIPLE-BEAMID-TABLES-SUPPORTED
6) PER-PORT-PTP-CONFIG
7) PER-PORT-SYNCE-CONFIG
8) MPLANE-TRX-CONTROL
9) PER-INT-TCP-MSS
10) DEEP-HIBERNATE";
reference "ORAN-WG4.M.0-v15.00";
}
revision "2023-12-11" {
description
"version 14.0.0
new features:
1) SE23-PRB-BLOCK-MODE-SUPPORT
2) MPLANE-DATA-LAYER-CONTROL
3) SHARED-CELL-STATS";
reference "ORAN-WG4.M.0-v14.00";
}
revision "2023-08-14" {
description
"version 13.0.0
new features:
1) CALL-HOME-REACTIVATION-SUPPORTED
2) SEQ-ID-CHECKING-CONFIGURABLE
3) TRX-CONTROL
4) ADVANCED-SLEEP-MODE";
reference "ORAN-WG4.M.0-v13.00";
}
revision "2023-04-10" {
description
"version 12.0.0
new features:
1) EXTENDED-PRACH-CONFIGURATION
2) NON-SCHEDULED-UEID
3) SE11-WITH-CONTINUITY-BIT-SUPPORT
4) UPLANE-MESSAGE-PROCESSING-LIMITS";
reference "ORAN-WG4.M.0-v12.00";
}
revision "2022-12-05" {
description
"version 11.0.0
new features:
1) UPLANE-ONLY-DL-MODE
2) SUPERVISION-WITH-SESSION-ID
3) INTEGRITY-CHECK-AT-SW-DOWNLOAD
4) ST4-SLOT-CONFIG-MSG-SUPPORT";
reference "ORAN-WG4.M.0-v11.00";
}
revision "2022-08-15" {
description
"version 10.0.0
new features:
1) SHARED-ORU-MULTI-ODU
2) SHARED-ORU-MULTI-OPERATOR";
reference "ORAN-WG4.M.0-v10.00";
}
revision "2021-12-01" {
description
"version 8.0.0
new features:
1) Typographical corrections in descriptions
2) Add new features:
BEAM-UPDATE-CONTENTION-CONTROL
MULTIPLE-SCS-IN-EAXC
ENHANCED-T-COMBINE
CHANNEL-INFORMATION-COMPRESSION
CHANNEL-INFORMATION-PRB-GROUP
MULTIPLE-TRANSPORT-SESSION-TYPE";
reference "ORAN-WG4.M.0-v08.00";
}
revision "2021-07-26" {
description
"version 7.0.0
new features:
1) EXT-ANT-DELAY-CONTRO
2) CPLANE-MESSAGE-PROCESSING-LIMITS";
reference "ORAN-WG4.M.0-v07.00";
}
revision "2021-03-22" {
description
"version 6.0.0
1) Features added to handle updated transmission window control:
STATIC-TRANSMISSION-WINDOW-CONTROL
DYNAMIC-TRANSMISSION-WINDOW-CONTROL
UNIFORMLY-DISTRIBUTED-TRANSMISSION
ORDERED-TRANSMISSION
INDEPENDENT-TRANSMISSION-WINDOW-CONTROL
";
reference "ORAN-WG4.M.0-v06.00";
}
revision "2020-12-10" {
description
"version 5.0.0
1) initial version.";
reference "ORAN-WG4.M.0-v05.00";
}
feature NON-PERSISTENT-MPLANE {
description
"Indicates that the Radio Unit supports the optional
capability to improve the operation with a SMO using a non-
persistent NETCONF session.";
}
feature STATIC-TRANSMISSION-WINDOW-CONTROL {
description
"O-RU supports U-plane transmission window control (scheduled transmission
and optionally uniformly distributed transmission) configuration over M-plane";
}
feature DYNAMIC-TRANSMISSION-WINDOW-CONTROL {
description
"O-RU supports U-plane transmission window control (scheduled transmission
and optionally uniformly distributed transmission) configuration over C-plane";
}
feature UNIFORMLY-DISTRIBUTED-TRANSMISSION {
if-feature "STATIC-TRANSMISSION-WINDOW-CONTROL or DYNAMIC-TRANSMISSION-WINDOW-CONTROL";
description
"O-RU supports transmission of UL U-plane messages distributed uniformly over transmission window.";
}
feature ORDERED-TRANSMISSION {
description
"O-RU supports ordered transmission";
}
feature INDEPENDENT-TRANSMISSION-WINDOW-CONTROL {
if-feature "STATIC-TRANSMISSION-WINDOW-CONTROL or DYNAMIC-TRANSMISSION-WINDOW-CONTROL";
description
"O-RU supports independent U-plane transmission window per endpoint.
If this feature is not supported then for all endpoints with transmission control enabled
(see u-plane-transmission-control/transmission-window-control) must be configured for transmission
window offsets and window sizes that coincide for each symbol.
If INDEPENDENT-TRANSMISSION-WINDOW-CONTROL feature is not supported then all endpoints with
transmission control enabled that handle the same carrier type and SCS must be configured
(via M-plane or C-plane) with parameter values resulting in transmission windows that coincide
between the endpoints. That is, for every symbol N, the effective transmission window for symbol N
must be shared (start at the same time and end at the same time) by all the endpoints handling
same carrier type and SCS. This restriction applies only to endpoints that have transmission
control enabled.
If INDEPENDENT-TRANSMISSION-WINDOW-CONTROL feature is supported then restriction described
above does not apply and a different transmission window (window offset and window size)
can be used for every endpoint capable of transmission window control.";
}
feature EXT-ANT-DELAY-CONTROL {
description
"This feature indicates that the O-RU supports external antenna delay control";
}
feature CPLANE-MESSAGE-PROCESSING-LIMITS {
description
"Feature to indicate O-RU limitation of C-Plane message processing. Refer CUS-Plane specification
section 'O-RU C-Plane message limits' for more details on this feature.";
}
feature CHANNEL-INFORMATION-COMPRESSION {
description
"This feature indicates that the O-RU supports channel information compression.";
}
feature CHANNEL-INFORMATION-PRB-GROUP {
description
"Feature to indicate O-RU supports receiving and processing channel
information (e.g., ST6) with PRB group size greater than one PRB";
}
feature BEAM-UPDATE-CONTENTION-CONTROL {
description
"Feature to indicate O-RU requirements for beam weight update for a given beamId, to avoid beam update contentions.
Refer CUS-Plane specification section 'Weight-based dynamic beamforming' for more details on this feature.";
}
feature MULTIPLE-SCS-IN-EAXC {
description
"Presence of feature indicates that FHM supports combining for multiple SCS
or multiple c-plane-types/frameStructure in a single eAxC-id in UL direction.";
}
feature MULTIPLE-TRANSPORT-SESSION-TYPE {
description
"Feature to indicate O-RU supports to be configured with multiple transport-session-type
(Ethernet, ALIASMAC, UDP/IP)";
}
feature ENHANCED-T-COMBINE {
description
"Presence of feature indicates that FHM/Cascade O-RU can support t-combine-net and tx-duration";
}
feature SHARED-ORU-MULTI-OPERATOR {
description
"Feature to indicate the O-RU supports shared operation with one or more shared
resource operators (i.e., multiple MNOs) and implements enhanced NACM privileges per shared
resource operator.
Note, there is no linkage or dependency between the SHARED-CELL feature and the SHARED-ORU feature.";
}
feature SHARED-ORU-MULTI-ODU {
description
"Feature to indicate the O-RU supports independent supervision qualified based on odu-id, where
loss of supervision triggers selective carrier deactivation of carriers associated with odu-id.";
}
feature INTEGRITY-CHECK-AT-SW-DOWNLOAD {
description "Feature indicates that radio unit support performing integrity check at software download";
}
feature SUPERVISION-WITH-SESSION-ID {
description
"O-RUs supporting this feature reuse the session-id generated for each NETCONF
session in supervision-notification. The session-id is defined in RFC 6241.
For these O-RUs, the O-RU controller participating in the NETCONF supervision
procedure can subscribe to supervision-notification notification events,
filtering for the supervision-notification/session-id matching
session-id in the Hello Message received from NETCONF Server earlier.";
}
feature UPLANE-ONLY-DL-MODE {
description
"Presence of feature indicates that O-RU supports U-Plane-only DL mode.";
}
feature ST4-SLOT-CONFIG-MSG-SUPPORT {
description
"Feature to indicate O-RU support for Section Type 4 slot configuration message";
}
feature NON-SCHEDULED-UEID {
description
"Feature to indicate that O-RU supports 'non-scheduled-ueid' to indicate the ports in the section which are not scheduled for a given eAxcid";
}
feature EXTENDED-PRACH-CONFIGURATION {
description
"Presence of the feature indicates that O-RU supports extended number of PRACH patterns and occasions
provided by means of static PRACH.";
}
feature SE11-WITH-CONTINUITY-BIT-SUPPORT {
description
"Feature to indicate O-RU support for handling 'continuity' bit information in Section Extension 11";
}
feature UPLANE-MESSAGE-PROCESSING-LIMITS {
description
"Feature to indicate O-RU limitation of U-Plane message processing. Refer M-Plane specification
clause 15.10 for more details on this feature.";
}
feature CALL-HOME-REACTIVATION-SUPPORTED {
description
"Presence of the feature indicates that O-RU supports re-activation of timed out call home flows.";
}
feature SEQ-ID-CHECKING-CONFIGURABLE {
description
"Feature to indicate O-RU supports configuration of sequence number checking functionality.";
}
feature TRX-CONTROL {
description
"Feature to indicate O-RU support for handling RF channel reconfiguration by TRX Control.";
}
feature ADVANCED-SLEEP-MODE {
description
"Feature to indicate O-RU support for handling Advanced Sleep Modes.";
}
feature SE23-PRB-BLOCK-MODE-SUPPORT {
description
"Presence of the feature indicates that O-RU supports PRB-BLOCK mode of SE-23 as defined in CUS-Plane
specification Clause 7.7.23.1.";
}
feature MPLANE-DATA-LAYER-CONTROL {
description
"Feature to indicate O-RU support for M-Plane based data layer control energy saving feature.";
}
feature SHARED-CELL-STATS {
description
"Feature to indicate FHM/Cascade O-RU support for shared-cell-stats.";
}
feature PER-PORT-PTP-CONFIG {
description
"This feature indicates that the equipment supports per-port PTP configuration functionality";
}
feature PER-PORT-SYNCE-CONFIG {
description
"This feature indicates that the equipment supports per-port SYNCE configuration functionality";
}
feature PER-INT-TCP-MSS {
description
"This feature indicates that the RU supports a per-interfacece MSS
configuration for TCP.";
}
feature MULTIPLE-BEAMID-TABLES-SUPPORTED {
description
"Feature to indicate O-RU support for multiple beamId tables.";
}
feature MPLANE-TRX-CONTROL {
description
"Feature to indicate O-RU support for M-plane based TRX control for Network Energy Saving.";
}
feature DEEP-HIBERNATE {
description
"Feature to indicate O-RU support for M-Plane based deep-hibernate energy saving feature.";
}
feature PRG-SIZE-SUPP-SE-21-WITH-ST6 {
description
"Feature to indicate O-RU support for receiving prgSize information when Section Extension 21 is
sent with Section Type 6.";
}
feature PRG-SIZE-SUPP-SE-21-WITH-ST5 {
description
"Feature to indicate O-RU support for receiving prgSize information when Section Extension 21 is
sent with Section Type 5.";
}
feature USER-GROUP-OPTIMIZATION {
description
"Feature to indicate O-DU requirement to send all layers for a given user group i.e., UEs with same
time-frequency allocation using single C-Plane section description.";
}
feature BF-DELAY-PROFILE {
description
"Feature to indicate O-RU support for beamforming list and delay profiles(s) per endpoint.";
}
feature DMRS-BF-EQ {
description
"DMRS beamforming with equalization supported. See CUS-plane clause 12.6";
}
feature DMRS-BF-NEQ {
description
"DMRS beamforming without equalization supported. See CUS-plane clause 12.6";
}
feature RRM-MEAS-REPORTING {
description
"Reporting of RRM measurmenets supported. See CUS-plane clause 12.6.1.6";
}
feature USER-GROUP-SELF-ASSEMBLY {
description
"Feature to indicate user group self assembly. See CUS-Plane clause 7.7.24.7.";
}
feature UEID-PERSISTENCE {
description
"Feature to indicate if ueId persistance over multiple slots is supported. See CUS-Plane clause 7.7.24.10.";
}
feature CONTINUITY-BLOCK-SIZE {
description
"The O-RUs capability for reporting one or more values of continuity block sizes. See CUS-plane clause 12.6.1.2.1";
}
feature SELECTED-BF-METHOD-CONFIGURATION {
description
"Feature to indicate O-RU support for configuration of a subset of beamforming methods from an
endpoint-bf-profile-group that shall be used by a specific endpoint.";
}
feature DMRS-BF-NEQ-UNALTERED-FREQ-OFFSET {
description
"Feature to indicate that DMRS-BF-NEQ beamforming performed by the O-RU does not change frequency offset,
hence it can be measured by the O-DU.";
}
feature DMRS-BF-NEQ-UNALTERED-TAE {
description
"Feature to indicate that DMRS-BF-NEQ beamforming performed by the O-RU does not change TAE,
hence TAE can be measured by the O-DU. Refer CUS specification clause 9.2.2.1 for details.";
}
feature SE10-MEMBER-CANDIDATE-LIST {
description
"Reporting of member-list of endpoints for SE-10 supporting endpoint. See CUS-plane clause 7.7.10.1";
}
feature MACSEC-BYPASS-POLICY {
description
"O-RU supports MACsec bypass policy";
}
feature SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION {
description
"Presence of the feature indicates that O-RU supports O-DU controlled dimensionality reduction using SE27 as defined in CUS-Plane
specification Clause 7.7.27.";
}
feature SE20-MULTI-SD-PUNC-PATTERN-SUPPORT {
description
"Feature to indicate O-RU support for handling multiple section description puncturing pattern in
Section Extension 20 per endpoint.";
}
feature CONFIGURABLE-VSWR-THRESHOLDS {
description
"Feature to indicate O-RU support for configurable VSWR thresholds.";
}
feature CLIENT-AUTH-SSH-PUBLIC-KEY {
description
"O-RU supports an optional feature to authenticate SSH client via SSHPUBLICKEY method.";
}
feature POINT-A-OFFSET-TO-ABSOLUTE-FREQUENCY-CENTER {
description
"Feature to indicate if leaf rx-array-carriers/point-a-offset-to-absolute-frequency-center is supported. See CUS-Plane clause 7.7.24.1.";
}
}

32
radio/fhi_72/oran_isolate.c
View File

@@ -86,6 +86,7 @@ int trx_oran_stop(openair0_device *device)
#ifdef OAI_MPLANE
printf("[MPLANE] Stopping M-plane.\n");
disconnect_mplane(s->mplane_priv);
free(s->mplane_priv);
#endif
return (0);
}
@@ -312,41 +313,42 @@ __attribute__((__visibility__("default"))) int transport_init(openair0_device *d
bool success = false;
#ifdef OAI_MPLANE
ru_session_list_t ru_session_list = {0};
success = init_mplane(&ru_session_list);
ru_session_list_t *ru_session_list = calloc(1, sizeof(*ru_session_list));
assert(ru_session_list != NULL && "Memory exhausted");
success = init_mplane(ru_session_list);
AssertFatal(success, "[MPLANE] Cannot initialize M-plane.\n");
bool ru_configured[ru_session_list.num_rus];
for (size_t i = 0; i < ru_session_list.num_rus; i++) {
ru_session_t *ru_session = &ru_session_list.ru_session[i];
bool ru_configured[ru_session_list->num_rus];
for (size_t i = 0; i < ru_session_list->num_rus; i++) {
ru_session_t *ru_session = &ru_session_list->ru_session[i];
ru_configured[i] = connect_mplane(ru_session);
if (!ru_configured[i]) {
continue;
}
ru_configured[i] = manage_ru(ru_session, openair0_cfg, ru_session_list.num_rus);
ru_configured[i] = manage_ru(ru_session, openair0_cfg, ru_session_list->num_rus);
}
bool all_ok = true;
bool ru_ready[ru_session_list.num_rus];
for (size_t i = 0; i < ru_session_list.num_rus; i++) {
bool ru_ready[ru_session_list->num_rus];
for (size_t i = 0; i < ru_session_list->num_rus; i++) {
if (!ru_configured[i]) {
MP_LOG_I("RU with IP %s couldn't be configured.\n", ru_session_list.ru_session[i].ru_ip_add);
MP_LOG_I("RU with IP %s couldn't be configured.\n", ru_session_list->ru_session[i].ru_ip_add);
all_ok = false;
}
ru_ready[i] = false;
}
if (!all_ok) {
disconnect_mplane((void *)&ru_session_list);
disconnect_mplane(ru_session_list);
AssertFatal(false, "[MPLANE] Stopping M-plane.\n");
}
while (true) {
sleep(1);
bool all_rus_ready = true;
for (int i = 0; i < ru_session_list.num_rus; i++) {
ru_session_t *ru_session = &ru_session_list.ru_session[i];
if (!ru_ready[i] && ru_session->ru_notif.config_change && ru_session->ru_notif.rx_carrier_state && ru_session->ru_notif.tx_carrier_state) {
for (int i = 0; i < ru_session_list->num_rus; i++) {
ru_session_t *ru_session = &ru_session_list->ru_session[i];
if (!ru_ready[i] && ru_session->ru_notif.config_change && !ru_session->ru_notif.rx_carrier_state && !ru_session->ru_notif.tx_carrier_state) {
MP_LOG_I("RU \"%s\" is now ready.\n", ru_session->ru_ip_add);
ru_ready[i] = true;
if (!ru_session->pm_stats.start_up_timing) {
@@ -364,9 +366,9 @@ __attribute__((__visibility__("default"))) int transport_init(openair0_device *d
}
}
eth->mplane_priv = (void *)&ru_session_list;
eth->mplane_priv = ru_session_list;
success = get_xran_config((void *)&ru_session_list, openair0_cfg, &fh_init, fh_config);
success = get_xran_config(ru_session_list, openair0_cfg, &fh_init, fh_config);
AssertFatal(success, "[MPLANE] Cannot configure xran with M-plane info.\n");
#else
success = get_xran_config(NULL, openair0_cfg, &fh_init, fh_config);