Teodora
0ad393f28e
It is backwards compatible with the O-RAN.WG4.MP-YANGs-v04.00, previous supported version.
6100 lines
230 KiB
YANG
6100 lines
230 KiB
YANG
module o-ran-uplane-conf {
|
|
yang-version 1.1;
|
|
namespace "urn:o-ran:uplane-conf:1.0";
|
|
prefix "o-ran-uplane-conf";
|
|
|
|
import o-ran-processing-element {
|
|
prefix "o-ran-pe";
|
|
}
|
|
|
|
import ietf-interfaces {
|
|
prefix "if";
|
|
}
|
|
|
|
import o-ran-module-cap {
|
|
prefix "mcap";
|
|
}
|
|
|
|
import o-ran-compression-factors {
|
|
prefix "cf";
|
|
}
|
|
|
|
import o-ran-wg4-features {
|
|
prefix "feat";
|
|
}
|
|
|
|
import ietf-hardware {
|
|
prefix "hw";
|
|
}
|
|
|
|
import o-ran-hardware {
|
|
prefix "or-hw";
|
|
}
|
|
|
|
import o-ran-usermgmt {
|
|
prefix "or-user";
|
|
}
|
|
|
|
import o-ran-common-yang-types {
|
|
prefix "o-ran-cmn";
|
|
}
|
|
|
|
import o-ran-delay-management {
|
|
prefix "or-dm";
|
|
}
|
|
|
|
organization "O-RAN Alliance";
|
|
|
|
contact
|
|
"www.o-ran.org";
|
|
|
|
description
|
|
"This module defines the module capabilities for
|
|
the O-RAN Radio Unit U-Plane configuration.
|
|
|
|
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 up-link performance improvement functionality, including DMRX-BF-EQ and DMS-BF-NEQ features
|
|
2) Introduction of capabilities and configuration for SE27 O-DU controlled dimensionality reduction
|
|
3) add support for se-20-multi-sd-punc-pattern
|
|
4) add support for VSWR thresholds";
|
|
|
|
reference "ORAN-WG4.M.0-v16.00";
|
|
}
|
|
|
|
revision "2024-04-15" {
|
|
description
|
|
"version 15.0.0
|
|
|
|
1) add support for sending prgSize in SE-21 with ST 5 and ST6.
|
|
2) add support for for beamforming list and delay profiles(s) per endpoint.
|
|
3) add support for user-group optimization.
|
|
4) add support for multiple beamid tables.
|
|
5) support pass band for filterindex09 per scs.
|
|
6) support for M-plane based TRX control for Network Energy Saving.
|
|
7) clarified cp-type is not applicable for ST3 or ST0
|
|
8) Changed description of max-beams-per-symbol/slot, so they refer to
|
|
'different beamId values' instead of 'beams'
|
|
9) added new leafs called max-beams-per-symbol-multiple-beamid-tables
|
|
and max-beams-per-slot-multiple-beamid-tables";
|
|
|
|
reference "ORAN-WG4.M.0-v15.00";
|
|
}
|
|
|
|
revision "2023-12-11" {
|
|
description
|
|
"version 14.0.0
|
|
|
|
1) Corrected the configurable-tdd-pattern-supported leafref to point
|
|
to static-low-level-tx-endpoints
|
|
2) Clarify reference for supported-frame-structures
|
|
3) introduce max-prb-blks-per-sec-ext-23 and se-23-prb-block-mode-supported
|
|
4) Introduction of new energy saving sub-use case - Data Layer control";
|
|
|
|
reference "ORAN-WG4.M.0-v14.00";
|
|
}
|
|
|
|
revision "2023-08-14" {
|
|
description
|
|
"version 13.0.0
|
|
|
|
1) clarification for I/Q bitwidth parameter
|
|
2) clarification of ul-fft-sampling-offset parameter
|
|
3) adding availability status to carrier operational data and notifications
|
|
4) ability to disable sequence number checking
|
|
5) Introduction of TRX-Control and Advanced Sleep Mode for network energy savings";
|
|
|
|
reference "ORAN-WG4.M.0-v13.00";
|
|
}
|
|
|
|
revision "2023-04-10" {
|
|
description
|
|
"version 12.0.0
|
|
|
|
1) Typographical corrections
|
|
2) NB-IoT introduction
|
|
3) clarify PRACH repetitions
|
|
4) support for non-scheduled-ueid
|
|
5) continuity bit information in Section Extension 11
|
|
6) U-Plane Processing Limits";
|
|
|
|
reference "ORAN-WG4.M.0-v12.00";
|
|
}
|
|
|
|
revision "2022-12-05" {
|
|
description
|
|
"version 11.0.0
|
|
|
|
1) PRB range limit for SE 12 and HP section
|
|
2) Introduction of PRB ranges
|
|
3) uplane-only-dl-mode-enable
|
|
4) Deprecation of power-related capabilities and addition of min-gain
|
|
5) se 23 max mplane limits
|
|
6) support Section Type 4 and associated commands";
|
|
|
|
reference "ORAN-WG4.M.0-v11.00";
|
|
}
|
|
|
|
revision "2022-08-15" {
|
|
description
|
|
"version 10.0.0
|
|
|
|
1) clarified description statements for representative-t/rx-eaxc-id
|
|
2) clarified description statements for max-num-t/rx-eaxc-ids-per-group
|
|
4) clarified description statements for component carrier
|
|
5) style guide corrections
|
|
6) introduction of O-RU connector functionality
|
|
7) fixing constraints
|
|
8) introducing new feature for ACK NACK feedback
|
|
9) added SHARED-ORU-MULTI-OPERATOR anf SHARED-ORU-MULTI-ODU features";
|
|
|
|
reference "ORAN-WG4.M.0-v10.00";
|
|
}
|
|
|
|
revision "2022-04-18" {
|
|
description
|
|
"version 9.0.0
|
|
|
|
1) Descriptions fixed for max-beam-updates-per-slot / max-beam-updates-per-slot
|
|
2) Added references to CUS-Plane spec for parameters 'frame-structure' and
|
|
'supported-frame-structures'
|
|
3) clarified max-beams-per-symbol, max-beams-per-slot, max-beam-updates-per-slot,
|
|
max-beam-updates-per-symbol parameters
|
|
4) Clarification of cp-length and cp-length-other
|
|
5) deprecation of rw-type and rw-duplex-scheme";
|
|
|
|
reference "ORAN-WG4.M.0-v09.00";
|
|
}
|
|
|
|
revision "2021-12-01" {
|
|
description
|
|
"version 8.0.0
|
|
|
|
1) Various descriptions corrected and/or clarified
|
|
2) Configuration for Beamforming weights were added together with changes and updates to compressions
|
|
3) Added new leaf node 'beam-update-contention-control-limits-required' to 'endpoint-types'
|
|
to indicate endpoint capability to support beam update contention control processing limits.
|
|
4) Added instance of 'beam-update-contention-control-limits' to 'endpoint-types'.
|
|
5) Added new leaf node boolean flag 'beam-update-contention-control-enabled' for O-DU to indicate
|
|
support of feature BEAM-UPDATE-CONTENTION-CONTROL feature.
|
|
6) deprecate 'channel-information-iq-bitwidth' , and define a new parameter
|
|
'channel-information-bitwidth' under the container 'compression'
|
|
7) add capability and configuration for channel information PRB granularity.
|
|
8) Add support for multiple transport-session-type per O-RU.
|
|
9) add capability and configuration for channel information compression.
|
|
10) deprecate 'channel-information-iq-bitwidth' , and define a new parameter
|
|
'channel-information-bitwidth' under the container 'compression'";
|
|
|
|
reference "ORAN-WG4.M.0-v08.00";
|
|
}
|
|
|
|
revision "2021-07-26" {
|
|
description
|
|
"version 7.0.0
|
|
|
|
1) Added new grouping 'per-cplane-message-limits' containing params to limit
|
|
per C-Plane packet processing when CPLANE-MESSAGE-PROCESSING-LIMITS feature is
|
|
supported by O-RU and used by O-DU.
|
|
2) Added new leaf node 'cplane-message-processing-limits-required' to 'endpoint-types'
|
|
to indicate endpoint capability to support C-Plane message processing limits.
|
|
3) Added instances of 'per-cplane-message-limits' to 'endpoint-types' and
|
|
'endpoint-capacity-sharing-groups'.
|
|
4) Added new leaf node to low-level-tx/rx-endpoint 'cplane-message-processing-limits-enabled'
|
|
for O-DU to configure support for C-Plane limits
|
|
5) Added t-da-offset and t-au-offset for external antenna support
|
|
6) Added Channel IQ bitwidth for ST6
|
|
7) Added ordered-by user to leaf-list member-tx-eaxc-id and leaf-list member-rx-eaxc-id
|
|
8) Added new PRACH formats
|
|
9) Ensuring beam-ids can only be 15 bits
|
|
10) Clarify mixed numerology restrictions";
|
|
|
|
reference "ORAN-WG4.M.0-v07.00";
|
|
}
|
|
|
|
|
|
revision "2021-03-22" {
|
|
description
|
|
"version 6.0.0
|
|
|
|
1) typographical corrections in descriptions.
|
|
2) Updates to transmission window control.
|
|
3) Introduces to existing grouping 'endpoint-section-capacity' two new leaf nodes 'max-uplane-section-header-per-symbol' and
|
|
'max-uplane-section-header-per-slot' to limit U-Plane data section header addition/parsing.
|
|
4) deprecated parameter 'max-remasks-per-section-id' since it is duplicate of leaf node 'max-control-sections-per-data-section'.
|
|
5) introduces new leaf nodes 'max-beams-updates-per-slot' and ''max-beams-updates-per-symbol'
|
|
to grouping 'endpoint-beam-capacity'
|
|
6) added new SRS features:
|
|
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) introduces new coupling method coupling-via-frequency-and-time-with-priorities-optimized
|
|
2) introduces new max-highest-priority-sections-per-slot parameter";
|
|
|
|
reference "ORAN-WG4.M.0-v05.00";
|
|
}
|
|
|
|
revision "2020-08-10" {
|
|
description
|
|
"version 4.0.0
|
|
|
|
1) parameters allowing for static PRACH configuration introduced
|
|
2) parameters allowing for static SRS configuration introduced
|
|
3) parameters allowing for configuration of TDD pattern introduced
|
|
4) Backward compatible change to introduce new parameter 'coupling-method' related
|
|
to Section Description Priority to serve for CUS-Plane CR";
|
|
|
|
reference "ORAN-WG4.M.0-v04.00";
|
|
}
|
|
|
|
revision "2020-04-17" {
|
|
description
|
|
"version 3.0.0
|
|
|
|
1) Adding optional little endian support
|
|
2) Adding a new capability parameter to indicate that the O-RU
|
|
supports regularizationFactor in section type 5
|
|
3) Added support for Dynamic Spectrum Sharing feature
|
|
4) Clarify the supported number of reMasks in RU side
|
|
5) Section extension for grouping multiple ports
|
|
6) adding PRACH formats to endpoint capabilities";
|
|
|
|
reference "ORAN-WG4.M.0-v03.00";
|
|
}
|
|
|
|
revision "2019-07-03" {
|
|
description
|
|
"version 1.1.0
|
|
|
|
1) added new leaf multiple-numerology-supported to enable O-RU to report
|
|
whether it supports multiple numerologies.
|
|
|
|
2) fixing broken constraints (configuration cannot be dependent on
|
|
operational state). This is a backwards incompatible revision.
|
|
|
|
As these constraints only apply when the LAA feature is used, and also
|
|
when considering the limited number of implementation that need to be
|
|
taken into consideration for backwards compatibility, it has been
|
|
agreed to NOT increment the namespace integer.
|
|
|
|
3) added frequency related capabilities for tx-arrays and rx-array
|
|
|
|
4) removed redundant LAA import";
|
|
|
|
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 EAXC-GAIN-CORRECTION {
|
|
description
|
|
"Presence of feature indicates that O-RU supports eAxC specific gain correction.";
|
|
}
|
|
|
|
feature TX-REFERENCE-LEVEL {
|
|
description
|
|
"Presence of feature indicates that O-RU supports TX gain reference level control";
|
|
}
|
|
|
|
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 beamforming-method-type {
|
|
type enumeration {
|
|
enum NOBF {
|
|
description
|
|
"No beamforming.";
|
|
}
|
|
enum PDBF {
|
|
description
|
|
"Predefined-beam beamforming.";
|
|
}
|
|
enum WDBF {
|
|
description
|
|
"Weight-based dynamic beamforming (based on real-time-updated weights).";
|
|
}
|
|
enum ABBF {
|
|
description
|
|
"Attribute-based dynamic beamforming (based on real-time-updated beam attributes).";
|
|
}
|
|
enum CIBF {
|
|
description
|
|
"Channel-information-based beamforming.";
|
|
}
|
|
enum DMRS_BF_EQ {
|
|
description
|
|
"DMRS-based beamforming with equalization.";
|
|
}
|
|
enum DMRS_BF_NEQ {
|
|
description
|
|
"DMRS-based beamforming without equalization.";
|
|
}
|
|
}
|
|
description
|
|
"Type definition for beamforming method.";
|
|
}
|
|
|
|
typedef symb-reorder-capability {
|
|
type enumeration {
|
|
enum PER-TX-WIN-SYMB-REORDER-WITH-DMRS-SENDING {
|
|
description
|
|
"per-window symbol reordering when sending of port-reduced DMRS data is enabled,
|
|
please refer to clause 7.7.25.2 of the CUS-Plane Specification.";
|
|
}
|
|
enum PER-TX-WIN-SYMB-REORDER-WITHOUT-DMRS-SENDING {
|
|
description
|
|
"per-window symbol reordering when sending of port-reduced DMRS data is not enabled,
|
|
please refer to clause 7.7.25.2 of the CUS-Plane Specification.";
|
|
}
|
|
enum PER-SECTION-TX-WINDOW-REASSIGNMENT {
|
|
description
|
|
"per-section tx-window reassignment, please refer to clause 7.7.25.3 of the CUS-Plane
|
|
Specification.";
|
|
}
|
|
}
|
|
description
|
|
"Type definition for symbol reordering method supported.";
|
|
}
|
|
typedef symb-reorder-method {
|
|
type enumeration {
|
|
enum PER-TX-WIN-SYMB-REORDERG {
|
|
description
|
|
"per-window symbol reordering,
|
|
please refer to clause 7.7.25.2 of the CUS-Plane Specification.";
|
|
}
|
|
enum PER-SECTION-TX-WINDOW-REASSIGNMENT {
|
|
description
|
|
"per-section tx-window reassignment, please refer to clause 7.7.25.3 of the CUS-Plane
|
|
Specification.";
|
|
}
|
|
}
|
|
description
|
|
"Type definition for symbol reordering method configured.";
|
|
}
|
|
typedef up-SymbolId-type {
|
|
type enumeration {
|
|
enum OVER-AIR-SYMBOL-NUMBER {
|
|
description
|
|
"U-plane symbol Id interpretation as on-air symbol number for symbol reordering.";
|
|
}
|
|
enum TRANSMISSION-WINDOW-NUMBER {
|
|
description
|
|
"U-plane symbol Id interpretation as transmission window number for symbol reordering.";
|
|
}
|
|
}
|
|
description
|
|
"Type definition for symbol reordering symbol Id interpretation capability.";
|
|
}
|
|
|
|
typedef user-group-self-assembly-mode {
|
|
type enumeration {
|
|
enum SELF-ASSEMBLY-WITH-GROUP-ID {
|
|
description
|
|
"The mode in which the O-RU is capable of assembling user groups using 'usrGroupId' and
|
|
'usrGroupSize' fields in SE-24.";
|
|
}
|
|
enum SELF-ASSEMBLY-WITHOUT-GROUP-ID {
|
|
description
|
|
"The mode in which O-RU is capable of assembling user groups without using 'usrGroupId' and 'usrGroupSize'
|
|
fields in SE-24, but instead relying on PRB ranges of all UE layers overall all section for assembling
|
|
user groups.";
|
|
}
|
|
}
|
|
description
|
|
"Possible values for user group self assembly modes that the O-RU can support.";
|
|
}
|
|
|
|
typedef rrm-meas-types {
|
|
type enumeration {
|
|
enum MEAS-UE-TAE {
|
|
value 0;
|
|
description
|
|
"UE timing advance error per UE, per slot";
|
|
}
|
|
enum MEAS-UE-LAYER-POWER {
|
|
value 1;
|
|
description
|
|
"UE layer signal power per layer,per slot";
|
|
}
|
|
enum MEAS-UE-FREQ-OFFSET {
|
|
value 2;
|
|
description
|
|
"UE frequency offset per UE, per slot";
|
|
}
|
|
enum MEAS-IPN-ALLOC {
|
|
value 3;
|
|
description
|
|
"Interference plus Noise for allocated PRBs,per slot or per DMRS symbol group";
|
|
}
|
|
enum MEAS-IPN-UNALLOC {
|
|
value 4;
|
|
description
|
|
"Interference plus Noise for unallocated PRBs, per slot or per set of symbols in a slot";
|
|
}
|
|
enum MEAS-ANT-DMRS-SNR {
|
|
value 5;
|
|
description
|
|
"DMRS Signal to Noise Ratio per antenna, per layer. ";
|
|
}
|
|
}
|
|
description
|
|
"RRM measurement types, refer to CUS spec table 9.2.1-1 for details";
|
|
}
|
|
|
|
grouping transmission-buffering-capacity {
|
|
description
|
|
"UL U-plane buffering capacity available for scheduled transmission of UL U-plane messages";
|
|
|
|
list transmission-buffering-capacity {
|
|
description
|
|
"Buffering capacity for specific IQ format.
|
|
If the list does not contain an entry for particular IQ format than endpoint
|
|
or group of endpoints then buffering capacity for this IQ format is
|
|
max-buffered-prbs = 0 and max-buffered-symbols = 0.";
|
|
|
|
uses cf:compression-details;
|
|
|
|
leaf max-buffered-prbs {
|
|
type uint32;
|
|
description
|
|
"Max number of PRBs (for IQ format given in compression-details) that can be buffered by an endpoint
|
|
or buffered collectively by group of endpoints sharing capacity. This is divided between symbols buffered";
|
|
}
|
|
|
|
leaf max-buffered-symbols {
|
|
type uint32;
|
|
description
|
|
"Max number of symbols (for IQ format given in compression-details) that can be buffered by an endpoint
|
|
or buffered collectively by group of endpoints sharing capacity";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping mplane-trx-control-supp-antenna-masks {
|
|
description
|
|
"A grouping containing list of antenna masks supported by the O-RU";
|
|
|
|
list mplane-supported-trx-control-masks {
|
|
key "index";
|
|
description
|
|
"List of supported M-Plane controlled TRX control masks.";
|
|
|
|
leaf index {
|
|
type uint8;
|
|
description
|
|
"Index to the list of antenna masks";
|
|
}
|
|
|
|
leaf antenna-mask {
|
|
type binary;
|
|
description
|
|
"M-Plane controlled O-RU supported antenna mask value.";
|
|
}
|
|
}
|
|
}
|
|
grouping array-config-group {
|
|
description
|
|
"This group represents configuration for supported arrays,
|
|
e.g. mplane trx control mask for supported arrayes";
|
|
|
|
list tx-array-antenna-mask-config {
|
|
if-feature feat:MPLANE-TRX-CONTROL;
|
|
key array-name;
|
|
description
|
|
"List of mplane configured trx antenna mask for supported arrays";
|
|
|
|
leaf array-name {
|
|
type leafref {
|
|
path "/user-plane-configuration/tx-arrays/name";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Unique name of tx-array. ";
|
|
}
|
|
leaf antenna-bitmask {
|
|
type binary;
|
|
description
|
|
"If mplane-supported-trx-control-masks list is not advertised as part of capability for the referred [tr]x-array,parameter antenna-bitmask may be used for configuration.
|
|
The parameter antenna-bitmask-index shall not be used for configuration.
|
|
The antenna mask contains as many binary values as number of array elements associated
|
|
with respective tx or rx-array. Value of '1' indicates antenna element shall be
|
|
kept active and value of '0' indicates antenna element should be turned inactive.
|
|
Refer clause 20.3.2 of M-Plane specification.";
|
|
}
|
|
leaf antenna-bitmask-index {
|
|
type uint8;
|
|
description
|
|
"If mplane-supported-trx-control-masks list is advertised as part of capability for the referred [tr]x-array,
|
|
the parameter antenna-bitmask-index may be used for configuration to refer to the index of advertised mplane-supported-trx-control-masks.
|
|
The parameter antenna-bitmask shall not be used for configuration.";
|
|
}
|
|
}
|
|
list rx-array-antenna-mask-config {
|
|
if-feature feat:MPLANE-TRX-CONTROL;
|
|
key array-name;
|
|
description
|
|
"List of mplane configured trx antenna mask for supported arrays";
|
|
leaf array-name {
|
|
type leafref {
|
|
path "/user-plane-configuration/rx-arrays/name";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Unique name of rx-array. ";
|
|
}
|
|
|
|
leaf antenna-bitmask {
|
|
type binary;
|
|
description
|
|
"If mplane-supported-trx-control-masks list is not advertised as part of capability for the referred [tr]x-array,parameter antenna-bitmask may be used for configuration.
|
|
The parameter antenna-bitmask-index shall not be used for configuration.
|
|
The antenna mask contains as many binary values as number of array elements associated
|
|
with respective tx or rx-array. Value of '1' indicates antenna element shall be
|
|
kept active and value of '0' indicates antenna element should be turned inactive.
|
|
Refer clause 20.3.2 of M-Plane specification.";
|
|
}
|
|
leaf antenna-bitmask-index {
|
|
type uint8;
|
|
description
|
|
"If mplane-supported-trx-control-masks list is advertised as part of capability for the referred [tr]x-array,
|
|
the parameter antenna-bitmask-index may be used for configuration to refer to the index of advertised mplane-supported-trx-control-masks.
|
|
The parameter antenna-bitmask shall not be used for configuration.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping general-config {
|
|
description "a group for general configuration";
|
|
|
|
container general-config {
|
|
description "a container for general configuration";
|
|
|
|
leaf regularization-factor-se-configured {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Informs if regularization factor in section extension is configured(true) or not(false), this
|
|
leaf indicates whether the O-DU will send the regularization factor in section extension.
|
|
|
|
If the O-RU does not support regularization-factor-se-supported in o-ran-module-cap.yang,
|
|
this leaf is ignored.";
|
|
}
|
|
|
|
leaf little-endian-byte-order {
|
|
type boolean;
|
|
default false;
|
|
|
|
description
|
|
"If little endian byte order for C/U plane data flows is supported by
|
|
the O-RU, indicates if the O-RU should use little endian byte order
|
|
for all UL and DL C/U plane data flows.
|
|
|
|
If little endian byte order is NOT supported, this node is ignored
|
|
(and the default big endian byte order used)";
|
|
}
|
|
|
|
leaf uplane-only-dl-mode-enable {
|
|
if-feature feat:UPLANE-ONLY-DL-MODE;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"If set to true, enable IQ data transfer without C-Plane in DL for all
|
|
endpoints as specified in the CUS specification clause 8.2.2.";
|
|
}
|
|
|
|
leaf st4-for-time-domain-beamforming-weights-enabled {
|
|
if-feature feat:ST4-SLOT-CONFIG-MSG-SUPPORT;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"If O-RU indicates support for Section Type 4 command 'TIME_DOMAIN_BEAM_CONFIG' , O-DU may
|
|
configure the O-RU to use Section Type 4 TIME_DOMAIN_BEAM_CONFIG command by setting this
|
|
flag to 'true'. In which case, O-DU shall use only Section Type 4 TIME_DOMAIN_BEAM_CONFIG
|
|
for specifying time-domain beam information. refer to clause 12.4.3.4.4 of CUS-Plane spec.";
|
|
}
|
|
|
|
leaf seq-id-checking-disabled {
|
|
if-feature feat:SEQ-ID-CHECKING-CONFIGURABLE;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"When the parameter has value true, sequence number checking is disabled.";
|
|
}
|
|
|
|
leaf multiple-beamId-tables-support-enabled {
|
|
if-feature feat:MULTIPLE-BEAMID-TABLES-SUPPORTED;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"When the parameter has value true, O-DU will be able to use multiple beamId table capability of O-RU.
|
|
O-DU shall be able to associate specific [tr]x-array-carrier with specific beamId table indexes advertised
|
|
which are advertised in 'tx-array-beamId-table-indexes/rx-array-beamId-table-indexes' as part of tx-array
|
|
and rx-array capabilities.";
|
|
}
|
|
|
|
leaf-list energy-sharing-groups-disabled {
|
|
if-feature feat:MPLANE-DATA-LAYER-CONTROL;
|
|
type uint8;
|
|
description
|
|
"A list that indicates which energy sharing groups are currently switched off due to data layer control energy saving.
|
|
By default this list is empty and means that no data layer control energy saving is currently ongoing.
|
|
This value shall be specific values from the list of 'energy-sharing-group-id' advertised by O-RU
|
|
inside respective static-low-level-[tr]x-endpoints.";
|
|
}
|
|
|
|
leaf config-symb-reorder-method {
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
type symb-reorder-method;
|
|
description
|
|
"Indicated which symbol reordering method is used. If it's not configured, O-RU shall
|
|
operate with natural order.";
|
|
}
|
|
leaf config-symb-reorder-upSymbId-type {
|
|
when "../config-symb-reorder-method = 'PER-TX-WIN-SYMB-REORDERG'";
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
type leafref {
|
|
path "../../endpoint-types/supported-symb-reorder-capabilities/up-symbolId-type-supported";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Indicated which config-symb-reorder-upSymbId-type intended to be used for symbol reordering,
|
|
i.e. either 'on-air symbol number' or 'transmission window number' to the O-RU.
|
|
When 'per-section tx-window reassignment' method is used,
|
|
the U-Plane symbolId interpretation shall be configured as 'on-air symbol number'
|
|
Please refer to clause 7.7.25 in CUS plane for details.";
|
|
}
|
|
|
|
leaf ueid-persistence-enabled {
|
|
if-feature feat:UEID-PERSISTENCE;
|
|
type boolean;
|
|
description
|
|
"Indicates if ueId persistance over multiple slots is enabled.
|
|
See CUS-Plane clause 7.7.24.10.";
|
|
}
|
|
|
|
leaf ueid-layer-bits-configured {
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
type uint8;
|
|
description
|
|
"This parameter specified the number of bits configured by the O-DU for specifying ueid layers.";
|
|
}
|
|
|
|
container vswr-thresholds{
|
|
if-feature feat:CONFIGURABLE-VSWR-THRESHOLDS;
|
|
description "VSWR thresholds parameters.";
|
|
container default-vswr-thresholds {
|
|
config false;
|
|
leaf default-vswr-minor-threshold {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"Default VSWR minor threshold.";
|
|
}
|
|
leaf default-vswr-major-threshold {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"Default VSWR major threshold.";
|
|
}
|
|
description
|
|
"Default VSWR thresholds used by this O-RU";
|
|
}
|
|
container vswr-thresholds-range {
|
|
config false;
|
|
leaf min {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"The lowest allowed VSWR threshold";
|
|
}
|
|
leaf max {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"The highest allowed VSWR threshold";
|
|
}
|
|
description
|
|
"VSWR thresholds shall be configured within this range";
|
|
}
|
|
container configurable-vswr-thresholds{
|
|
description "vswr monitoring parameters to be configured by O-RU Controller";
|
|
leaf global-vswr-monitoring-trigger-power {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
units dBm;
|
|
description
|
|
"Power threshold for enabling VSWR monitoring.";
|
|
}
|
|
leaf global-vswr-minor-threshold {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"configured VSWR minor threshold which will be used to trigger an alarm.";
|
|
}
|
|
leaf global-vswr-major-threshold {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"configured VSWR major threshold which will be used to trigger an alarm.";
|
|
}
|
|
list vswr-threshold-per-tx-array-element {
|
|
key "tx-array-name array-element";
|
|
description
|
|
"individual vswr-thresholds configuration which will be applied to each tx array element";
|
|
leaf tx-array-name {
|
|
type leafref {
|
|
path "/o-ran-uplane-conf:user-plane-configuration/o-ran-uplane-conf:tx-arrays/o-ran-uplane-conf:name";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"tx-array where the configured vswr thresholds will be applied";
|
|
}
|
|
leaf array-element {
|
|
type uint16;
|
|
description
|
|
"the array-element number of the tx-array if there are multiple array-elements of the tx-array.";
|
|
}
|
|
leaf vswr-minor-threshold {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"configured VSWR minor threshold of the tx-array-element which will be used to trigger an alarm.
|
|
It shall override the configured global-vswr-minor-tresholds.";
|
|
}
|
|
leaf vswr-major-threshold {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
description
|
|
"configured VSWR major threshold of the tx-array-element which will be used to trigger an alarm.
|
|
It shall override the configured global-vswr-major-tresholds.";
|
|
}
|
|
leaf vswr-monitoring-trigger-power {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
units dBm;
|
|
description
|
|
"Power threshold for enabling VSWR monitoring.
|
|
it shall override the configured global-vswr-monitoring-trigger-power.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping laa-carrier-config {
|
|
description "Carrier Configuration for support of LAA. ";
|
|
leaf ed-threshold-pdsch {
|
|
type int8;
|
|
units dBm;
|
|
description
|
|
"This value indicates Energy Detection(ED) threshold for LBT for PDSCH and for measurements in dBm.";
|
|
}
|
|
|
|
leaf ed-threshold-drs {
|
|
type int8;
|
|
units dBm;
|
|
description
|
|
"This value indicates Energy Detection(ED) threshold for LBT for DRS in dBm.";
|
|
}
|
|
|
|
leaf tx-antenna-ports {
|
|
type uint8;
|
|
description
|
|
"This value indicates Tx antenna ports for DRS (1, 2, 4)";
|
|
}
|
|
|
|
leaf transmission-power-for-drs {
|
|
type int8;
|
|
units decibels;
|
|
description
|
|
"This value indicates offset of Cell specific reference Signal(CRS) power to reference signal power (dB).
|
|
DRS signal consists of CRS, PSS, SSS, and optionally CSI-RS.";
|
|
}
|
|
|
|
leaf dmtc-period {
|
|
type enumeration {
|
|
enum FORTY {
|
|
description
|
|
"40 ms";
|
|
}
|
|
enum EIGHTY {
|
|
description
|
|
"80 ms";
|
|
}
|
|
enum ONE-HUNDRED-SIXTY {
|
|
description
|
|
"160 ms";
|
|
}
|
|
}
|
|
units milliseconds;
|
|
description
|
|
"This value indicates DRS measurement timing configuration (DMTC) period in ms";
|
|
}
|
|
|
|
leaf dmtc-offset {
|
|
type uint8;
|
|
units subframes;
|
|
description
|
|
"This value indicates dmtc offset in Subframes.";
|
|
}
|
|
|
|
leaf lbt-timer {
|
|
type uint16;
|
|
units milliseconds;
|
|
description
|
|
"This value indicates LBT Timer in milliseconds.";
|
|
}
|
|
|
|
list max-cw-usage-counter {
|
|
when "/mcap:module-capability/mcap:rw-sub-band-info/mcap:rw-self-configure = 'true'";
|
|
key "priority";
|
|
description "";
|
|
leaf priority {
|
|
type enumeration {
|
|
enum P1 {
|
|
description "priority 1";
|
|
}
|
|
enum P2 {
|
|
description "priority 2";
|
|
}
|
|
enum P3 {
|
|
description "priority 3";
|
|
}
|
|
enum P4 {
|
|
description "priority 4";
|
|
}
|
|
}
|
|
description "This value provides the priority class traffic for which the counter is calculated.";
|
|
}
|
|
|
|
leaf counter-value {
|
|
type uint8 {
|
|
range "1..8";
|
|
}
|
|
description "This value indicates the maximum value of counter
|
|
which shows how many max congestion window value is used for backoff
|
|
number of priority class traffic. This value is defined at 3GPP 36.213
|
|
section 15.1.3 as K.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping coupling-methods {
|
|
description
|
|
"Grouping for configuration of desired C-Plane / U-Plane coupling methods (if supported)";
|
|
leaf coupling-to {
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:ru-capabilities/mcap:coupling-methods/mcap:coupling-via-frequency-and-time";
|
|
require-instance false;
|
|
}
|
|
|
|
description
|
|
"RW instance of RO parameter.";
|
|
}
|
|
leaf coupling-method {
|
|
when "../coupling-to = 'true'";
|
|
type enumeration{
|
|
enum NORMAL {
|
|
description "Coupling via sectionId value. This value can be used always.";
|
|
}
|
|
enum FREQUENCY_AND_TIME {
|
|
description "Coupling via frequency and time. Can be used when coupling-via-frequency-and-time = true
|
|
or coupling-via-frequency-and-time-with-priorities = true in o-ran-module-cap.yang";
|
|
}
|
|
enum FREQUENCY_AND_TIME_WITH_PRIORITIES {
|
|
description "Coupling via frequency and time with priorities. Can be used when
|
|
coupling-via-frequency-and-time-with-priorities = true in o-ran-module-cap.yang";
|
|
}
|
|
enum FREQUENCY_AND_TIME_WITH_PRIORITIES_OPTIMIZED {
|
|
description "Coupling via frequency and time with priorities optimized. Can be used when
|
|
coupling-via-frequency-and-time-with-priorities-optimized = true in o-ran-module-cap.yang";
|
|
}
|
|
}
|
|
default NORMAL;
|
|
description
|
|
"Method of coupling between C-Plane and U-Plane messages; see methods of coupling
|
|
of C-Plane and U-Plane in CUS-Plane specification. If an O-RU doesn't support the
|
|
necessary capability as defined in o-ran-module-cap.yang, the O-RU shall respond
|
|
with rpc-error including an error-message describing the error condition";
|
|
}
|
|
}
|
|
|
|
grouping eaxc {
|
|
description
|
|
"One eAxC identifier (eAxC ID) comprises a band and sector
|
|
identifier (BandSector_ID), a component-carrier identifier (CC_ID) and a
|
|
spatial stream identifier (RU_Port_ID).
|
|
|
|
In this version of the specification, one eAxC contains only one spatial
|
|
stream (i.e. one beam per subcarrier) at a time.
|
|
|
|
Bit allocation is subdivided as follows:
|
|
* O_DU_Port_ID: Used to differentiate processing units at O-DU
|
|
* BandSector_ID: Aggregated cell identifier
|
|
* CC_ID: distinguishes Component Carriers
|
|
* RU_Port_ID: Used to differentiate spatial streams or beams on the O-RU
|
|
|
|
The bitwidth of each of the above fields is variable this model is supposed to check
|
|
if we are occupying bits continuously, but we do not have to occupy all 16 bits";
|
|
|
|
|
|
leaf o-du-port-bitmask {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"mask for eaxc-id bits used to encode O-DU Port ID";
|
|
}
|
|
|
|
leaf band-sector-bitmask {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"mask for eaxc-id bits used to encode the band sector ID";
|
|
}
|
|
|
|
leaf ccid-bitmask {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"mask for eaxc-id bits used to encode the component carrier id";
|
|
}
|
|
|
|
leaf ru-port-bitmask {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"mask for eaxc-id bits used to encode the O-RU Port ID";
|
|
}
|
|
|
|
leaf eaxc-id {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"encoded value of eaxcid to be read by CU-Plane";
|
|
}
|
|
}
|
|
|
|
grouping parameters {
|
|
description
|
|
"Grouping of all parameters common between UL and DL";
|
|
|
|
leaf name {
|
|
type string;
|
|
mandatory true;
|
|
description "Unique name of array antenna";
|
|
}
|
|
|
|
leaf number-of-rows {
|
|
type uint16;
|
|
mandatory true;
|
|
description "Number of rows array elements are shaped into - M";
|
|
}
|
|
|
|
leaf number-of-columns {
|
|
type uint16;
|
|
mandatory true;
|
|
description "Number of columns array elements are shaped into - N";
|
|
}
|
|
|
|
leaf number-of-array-layers {
|
|
type uint8;
|
|
mandatory true;
|
|
description "Number of array layers array elements are shaped into - Q";
|
|
}
|
|
|
|
leaf horizontal-spacing {
|
|
type decimal64 {
|
|
fraction-digits 5;
|
|
}
|
|
units Meter;
|
|
|
|
description "Average distance between centres of nearby AE in horizontal direction (in array coordinates system)";
|
|
}
|
|
|
|
leaf vertical-spacing{
|
|
type decimal64 {
|
|
fraction-digits 5;
|
|
}
|
|
units Meter;
|
|
|
|
description "Average distance between centres of nearby AE in vertical direction (in array coordinates system)";
|
|
}
|
|
|
|
container normal-vector-direction {
|
|
description
|
|
"Counter-clockwise rotation around z and y axis.";
|
|
|
|
leaf azimuth-angle{
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units Degrees;
|
|
|
|
description "Azimuth angle, counter-clockwise rotation around z-axis. Value 'zero' points to broad-side, value '90' points to y-axis";
|
|
}
|
|
leaf zenith-angle{
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units Degrees;
|
|
|
|
description "Zenith angle, counter-clockwise rotation around y-axis. Value 'zero' points to zenith, value '90' points to horizon";
|
|
}
|
|
}
|
|
|
|
container leftmost-bottom-array-element-position {
|
|
description "Structure describing position of leftmost, bottom array element.";
|
|
leaf x {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units Meter;
|
|
|
|
description "X dimension of position of leftmost, bottom array element";
|
|
}
|
|
|
|
leaf y {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units Meter;
|
|
|
|
description "Y dimension of position of leftmost, bottom array element";
|
|
}
|
|
|
|
leaf z {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units Meter;
|
|
|
|
description "Z dimension of position of leftmost, bottom array element";
|
|
}
|
|
}
|
|
list polarisations {
|
|
key "p";
|
|
min-elements 1;
|
|
max-elements 2;
|
|
|
|
description
|
|
"List of supported polarisations.";
|
|
|
|
leaf p {
|
|
type uint8;
|
|
mandatory true;
|
|
description
|
|
"Polarisation index. See CUS-plane";
|
|
}
|
|
|
|
leaf polarisation {
|
|
type polarisation_type;
|
|
mandatory true;
|
|
description "Type of polarisation supported by array.";
|
|
}
|
|
}
|
|
leaf band-number {
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:band-capabilities/mcap:band-number";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"This parameter informing which frequency band particular antenna
|
|
array is serving for.
|
|
Intended use is to deal with multiband solutions.";
|
|
}
|
|
|
|
list related-o-ru-connectors {
|
|
key name;
|
|
|
|
leaf name {
|
|
type leafref {
|
|
path '/hw:hardware/hw:component/hw:name';
|
|
}
|
|
must "derived-from-or-self(deref(current())/../hw:class, 'or-hw:O-RU-ANTENNA-CONNECTOR')";
|
|
description
|
|
"Referenced name of O-RU connector used by the antenna array.";
|
|
}
|
|
leaf-list array-element-id {
|
|
type uint16;
|
|
description
|
|
"Identifiers of array element(s) related to specific O-RU connector. Allowed values and semantic - as per CUS-Plane spec, clause 'Identification and Ordering of Array Elements'";
|
|
}
|
|
description
|
|
"List of unique names that identify instances of O-RU's connectors the external [tr]x-array is reachable through.";
|
|
}
|
|
}
|
|
|
|
grouping array-choice {
|
|
choice antenna-type {
|
|
case tx {
|
|
leaf tx-array-name {
|
|
type leafref {
|
|
path "/o-ran-uplane-conf:user-plane-configuration/o-ran-uplane-conf:tx-arrays/o-ran-uplane-conf:name";
|
|
}
|
|
|
|
description
|
|
"Leafref to tx array if such is chosen";
|
|
}
|
|
}
|
|
case rx {
|
|
leaf rx-array-name {
|
|
type leafref {
|
|
path "/o-ran-uplane-conf:user-plane-configuration/o-ran-uplane-conf:rx-arrays/o-ran-uplane-conf:name";
|
|
}
|
|
|
|
description
|
|
"Leafref to rx array if such is chosen";
|
|
}
|
|
}
|
|
description
|
|
"Choice for antenna type";
|
|
}
|
|
description
|
|
"Elements which groups choice for antenna type";
|
|
}
|
|
|
|
grouping scs-config {
|
|
description
|
|
"It groups all parameters related to SCS configuration";
|
|
|
|
leaf frame-structure {
|
|
type uint8;
|
|
|
|
description
|
|
"This parameter provides value of frame structure. For semantics and allowed values see CUS-Plane Specification, clause 'frameStructure (frame structure)'";
|
|
}
|
|
|
|
leaf cp-type {
|
|
type enumeration {
|
|
enum NORMAL {
|
|
description
|
|
"Normal cyclic prefix";
|
|
}
|
|
|
|
enum EXTENDED {
|
|
description
|
|
"Extended cyclic prefix";
|
|
}
|
|
}
|
|
|
|
description
|
|
"Provides type of CP (cyclic prefix).
|
|
|
|
For section type 3 or section type 0, element and the value of this leaf shall be ignored by the O-RU. In such circumstances,
|
|
please refer to clause 7.5.2.14 cpLength (cyclic prefix length) of the CUS-Plane Specification.";
|
|
}
|
|
|
|
leaf cp-length {
|
|
type uint16;
|
|
units Ts;
|
|
mandatory true;
|
|
description
|
|
"Provides length of CP used for the first symbol after subframe boundary or half-subframe boundary.
|
|
See CUS-plane
|
|
|
|
If a section type 3 is used in C-plane messages addressed to the endpoint, then O-RU takes length of CP from
|
|
C-Plane cpLength Information Element and the value of this leaf shall be ignored by the O-RU. See cpLength (cyclic prefix length)
|
|
in CUS-Plane for details.
|
|
|
|
If a static configuration (see static-prach-configurations) is applicable to the endpoint, then O-RU takes
|
|
length of CP from M-Plane cp-length leaf in static-prach-configurations and the value of this leaf shall be ignored by the O-RU.";
|
|
}
|
|
|
|
leaf cp-length-other {
|
|
type uint16;
|
|
units Ts;
|
|
mandatory true;
|
|
description
|
|
"Provides length of CP used for symbols other than provided by cp-length.
|
|
|
|
If a section type 3 is used in C-plane messages addressed to the endpoint, then O-RU takes length of CP from
|
|
C-Plane cpLength Information Element and the value of this leaf shall be ignored by the O-RU. See cpLength (cyclic prefix length)
|
|
in CUS-Plane for details.
|
|
|
|
If a static configuration (see static-prach-configurations) is applicable to the endpoint, then O-RU takes
|
|
length of CP from M-Plane cp-length leaf in static-prach-configurations and the value of this leaf shall be ignored by the O-RU.";
|
|
}
|
|
|
|
leaf offset-to-absolute-frequency-center {
|
|
type int32;
|
|
mandatory true;
|
|
description
|
|
"This provides value of freqOffset to be used if section type 3 is not used. See freqOffset in CUS-plane.
|
|
offset-to-absolute-frequency-center defines the relative spacing between the centre of RE#0 of RB#0 to the center-of-channel-bandwidth.
|
|
If offset-to-absolute-frequency-center for NR with SCS=15kHz is odd,
|
|
it implies that 7.5kHz shift as indicated by the 3GPP parameter frequencyShift7p5khz for UL is applied,
|
|
which means enable the NR UL transmission with a 7.5 kHz shift to the LTE raster, as defined in 3GPP TS 38.331.
|
|
When type (in tx/rx-array-carrier) is DSS, 'offset-to-absolute-frequency-center' indicates the 1st RE of 1st RB of NR.";
|
|
}
|
|
|
|
list number-of-prb-per-scs {
|
|
key scs;
|
|
description
|
|
"List of configured for each SCS that will be used.";
|
|
|
|
leaf scs {
|
|
type mcap:scs-config-type;
|
|
description
|
|
"Value corresponds to SCS values defined for frameStructure in C-plane.
|
|
Note: set of allowed values is restricted by SCS derived from values in supported-frame-structures.";
|
|
}
|
|
|
|
leaf number-of-prb {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Determines max number of PRBs that will be used in all sections per one symbol.
|
|
This is affecting allocation of resources to endpoint. Value shall not exceed constrains
|
|
defined by max-prb-per-symbol of endpoint type. In addition, sum (over all used endpoints
|
|
within a group of endpoints sharing resources) of number-of-prb rounded up to the
|
|
nearest value from prb-capacity-allocation-granularity shall not exceed max-prb-per-symbol of the group.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping occupied-bandwidth {
|
|
description
|
|
"Grouping describing occupied bandwidth of a carrier.";
|
|
|
|
container occupied-bandwidth {
|
|
description
|
|
"Container describing occupied bandwidth of a carrier.
|
|
|
|
Information conveyed in this container can be used to determine minimum filter bandwidth in case
|
|
it cannot be fully determined basing on the carrier bandwidth itself e.g., when NB-IoT carriers
|
|
are allocated in the carrier's guard band.";
|
|
|
|
leaf lower-bound {
|
|
type uint64;
|
|
units Hz;
|
|
|
|
description
|
|
"Lower bound of the filter pass bandwidth of a carrier.";
|
|
}
|
|
|
|
leaf upper-bound {
|
|
type uint64;
|
|
units Hz;
|
|
|
|
description
|
|
"Upper bound of the filter pass bandwidth of a carrier.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping tx-common-array-carrier-elements {
|
|
description
|
|
"This grouping contains all common parameters for tx-array-carriers and rx-array-carriers";
|
|
|
|
leaf absolute-frequency-center {
|
|
type uint32;
|
|
status deprecated;
|
|
description
|
|
"deprecated in version 5.0.0 and replaced with offset-to-absolute-frequency-center
|
|
and common FREF translated from absolute-frequency-center (NREF) as defined in 38.104";
|
|
}
|
|
|
|
leaf center-of-channel-bandwidth {
|
|
type uint64;
|
|
units Hz;
|
|
mandatory true;
|
|
description
|
|
"Centre frequency of channel bandwidth in Hz. Common for all numerologies.
|
|
center-of-channel-bandwidth is the FREF translated from absolute-frequency-center (NREF) as per 3GPP TS 38.104.
|
|
Refer to Table 5: Centre Bandwidth Calculation in M-plane spec for calculation of this parameter
|
|
for even and odd number of PRBs in LTE, NR and DSS carrier configuration.";
|
|
}
|
|
|
|
leaf channel-bandwidth {
|
|
type uint64;
|
|
units Hz;
|
|
mandatory true;
|
|
|
|
description
|
|
"Width of carrier given in Hertz";
|
|
}
|
|
|
|
leaf 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";
|
|
}
|
|
}
|
|
default INACTIVE;
|
|
|
|
description
|
|
"Indicates if transmission is enabled for this array carriers. Note that NETCONF server uses state parameter
|
|
to indicate actual state of array carriers operation. When array carriers is in sleep status,
|
|
NETCONF server rejects all other operation request to tx-array-carriers object except either request to change from sleep
|
|
to active status or delete MO operation (see 4.8) to the object.";
|
|
}
|
|
|
|
leaf 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.";
|
|
}
|
|
}
|
|
config false;
|
|
mandatory true;
|
|
description
|
|
"Indicates state of array carriers activation operation";
|
|
}
|
|
|
|
leaf-list availability-status {
|
|
type o-ran-cmn:availability-status;
|
|
config false;
|
|
description
|
|
"indicates availability-status of array carrier";
|
|
}
|
|
|
|
leaf type {
|
|
type enumeration {
|
|
enum NR {
|
|
description
|
|
"5G technology";
|
|
}
|
|
enum LTE {
|
|
description
|
|
"LTE technology";
|
|
}
|
|
enum DSS_LTE_NR {
|
|
if-feature mcap:DSS_LTE_NR;
|
|
description
|
|
"NR and LTE technologies in Dynamic Spectrum Sharing mode";
|
|
}
|
|
}
|
|
description
|
|
"Type of carrier. Indicates array-carrier technology.";
|
|
}
|
|
|
|
leaf duplex-scheme {
|
|
type enumeration {
|
|
enum TDD {
|
|
description
|
|
"TDD scheme";
|
|
}
|
|
enum FDD {
|
|
description
|
|
"FDD scheme";
|
|
}
|
|
}
|
|
config false;
|
|
|
|
description
|
|
"Type of duplex scheme O-RU supports.";
|
|
}
|
|
leaf rw-duplex-scheme {
|
|
type leafref {
|
|
path "/user-plane-configuration/tx-array-carriers[name=current()/../name]" + "/duplex-scheme";
|
|
require-instance false;
|
|
}
|
|
status deprecated;
|
|
description
|
|
"Config true type of duplex scheme.
|
|
Status is deprecated because 'lte-tdd-frame' container, where it was used, is also deprecated.
|
|
Additionally duplex-scheme is derived from the band-number.";
|
|
}
|
|
leaf rw-type {
|
|
type leafref {
|
|
path "/user-plane-configuration/tx-array-carriers[name=current()/../name]" + "/type";
|
|
require-instance false;
|
|
}
|
|
status deprecated;
|
|
description
|
|
"Config true type of carrier.
|
|
Status is deprecated because leafref is to a 'config true' schema-node";
|
|
}
|
|
uses occupied-bandwidth;
|
|
|
|
leaf configured-tx-beamId-table-index {
|
|
if-feature feat:MULTIPLE-BEAMID-TABLES-SUPPORTED;
|
|
type uint8;
|
|
description
|
|
"The value of beamId table index configured to be used by the O-DU for a given tx-array-carrier.
|
|
The value shall be chosen from the list 'tx-array-beamId-table-indexes' advertised by the O-RU.";
|
|
}
|
|
}
|
|
|
|
grouping rx-common-array-carrier-elements {
|
|
description
|
|
"This grouping contains all common parameters for tx-array-carriers and rx-array-carriers";
|
|
|
|
leaf absolute-frequency-center {
|
|
type uint32;
|
|
status deprecated;
|
|
description
|
|
"deprecated in version 5.0.0 and replaced with offset-to-absolute-frequency-center
|
|
and common FREF translated from absolute-frequency-center (NREF) as defined in 38.104";
|
|
}
|
|
|
|
leaf center-of-channel-bandwidth {
|
|
type uint64;
|
|
units Hz;
|
|
mandatory true;
|
|
description
|
|
"Centre frequency of channel bandwidth in Hz. Common for all numerologies.
|
|
center-of-channel-bandwidth is the FREF translated from absolute-frequency-center (NREF) as per 3GPP TS 38.104.
|
|
Refer to Table 15.2.4-1: Centre Bandwidth Calculation in M-plane spec for calculation of this parameter
|
|
for even and odd number of PRBs in LTE, NR and DSS carrier configuration.";
|
|
}
|
|
|
|
leaf channel-bandwidth {
|
|
type uint64;
|
|
units Hz;
|
|
mandatory true;
|
|
|
|
description
|
|
"Width of carrier given in Hertz";
|
|
}
|
|
|
|
leaf 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";
|
|
}
|
|
}
|
|
default INACTIVE;
|
|
|
|
description
|
|
"Indicates if transmission is enabled for this array carriers. Note that NETCONF server uses state parameter
|
|
to indicate actual state of array carriers operation. When array carriers is in sleep status,
|
|
NETCONF server rejects all other operation request to tx-array-carriers object except either request to change from sleep
|
|
to active status or delete MO operation (see 4.8) to the object.";
|
|
}
|
|
|
|
leaf 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.";
|
|
}
|
|
}
|
|
config false;
|
|
mandatory true;
|
|
description
|
|
"Indicates state of array carriers activation operation";
|
|
}
|
|
|
|
leaf-list availability-status {
|
|
type o-ran-cmn:availability-status;
|
|
config false;
|
|
description
|
|
"indicates availability-status of array carrier";
|
|
}
|
|
|
|
leaf type {
|
|
type enumeration {
|
|
enum NR {
|
|
description
|
|
"5G technology";
|
|
}
|
|
enum LTE {
|
|
description
|
|
"LTE technology";
|
|
}
|
|
enum DSS_LTE_NR {
|
|
if-feature mcap:DSS_LTE_NR;
|
|
description
|
|
"NR and LTE technologies in Dynamic Spectrum Sharing mode";
|
|
}
|
|
}
|
|
description
|
|
"Type of carrier. Indicates array-carrier technology.";
|
|
}
|
|
|
|
leaf duplex-scheme {
|
|
type enumeration {
|
|
enum TDD {
|
|
description
|
|
"TDD scheme";
|
|
}
|
|
enum FDD {
|
|
description
|
|
"FDD scheme";
|
|
}
|
|
}
|
|
config false;
|
|
|
|
description
|
|
"Type of duplex scheme O-RU supports.";
|
|
}
|
|
uses occupied-bandwidth;
|
|
|
|
leaf configured-rx-beamId-table-index {
|
|
if-feature feat:MULTIPLE-BEAMID-TABLES-SUPPORTED;
|
|
type uint8;
|
|
description
|
|
"The value of beamId table index configured to be used by the O-DU for a given rx-array-carrier.
|
|
The value shall be chosen from list 'rx-array-beamId-table-indexes' advertised by the O-RU.";
|
|
}
|
|
}
|
|
|
|
grouping endpoint-section-capacity {
|
|
leaf max-control-sections-per-data-section {
|
|
type uint8 {
|
|
range "1..12";
|
|
}
|
|
description
|
|
"Max number of C-plane sections (C-plane section is part of C-plane message that carries 'section fields')
|
|
referring to same U-plane section (U-plane section is part of U-plane message that carries
|
|
'section header fields' and 'PRB fields') that is supported by endpoint.
|
|
Note that additional limitations specific for each section type apply on top of this number.";
|
|
}
|
|
leaf max-sections-per-symbol {
|
|
type uint16;
|
|
description
|
|
"Max number of sections within one symbol that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity";
|
|
}
|
|
leaf max-sections-per-slot {
|
|
type uint16;
|
|
description
|
|
"Max number of sections within one slot that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity.";
|
|
}
|
|
leaf max-highest-priority-sections-per-slot {
|
|
type uint16;
|
|
must "current() < ../max-sections-per-slot" {
|
|
error-message "the sectionID for the highest priority needs to be less than the max sectionIds per slot";
|
|
}
|
|
description
|
|
"Max number of highest priority sections within one slot that can be processed by endpoint or processed collectively by
|
|
group of endpoints sharing capacity. This leaf applies only when coupling-via-frequency-and-time-with-priorities-optimized
|
|
is true, in other instances this leaf is ignored by the O-RU. The sectionId for highest priority section descriptions shall
|
|
start from 0 to specified max value and is a subset of max-sections-per-slot and must be less than max-sections-per-slot.";
|
|
}
|
|
|
|
leaf max-remasks-per-section-id {
|
|
type uint8 {
|
|
range "1..12";
|
|
}
|
|
default 12;
|
|
status deprecated;
|
|
description
|
|
"maximum number of different reMask values that is applied to a PRB
|
|
within one section id. This value can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity.
|
|
This parameter is duplicated max-control-sections-per-data-section, hence being deprecated.";
|
|
}
|
|
leaf max-uplane-section-header-per-symbol {
|
|
type uint16;
|
|
description
|
|
"Maximum number of U-Plane data section header within one symbol that can be processed by an endpoint or processed collectively by group of
|
|
endpoints sharing capacity. Clarification for multiple U-Plane data section headers per C-Plane section description is specified in sectionId IE
|
|
description in CUS-Plane specification. For the cases where this optional parameter is not populated by O-RU or an older version O-DU does not
|
|
interpret this parameter, O-DU may optionally use max-sections-per-symbol as the default value to limit of U-Plane data section messages which
|
|
can be processed by the O-RU. If none of the above limitations are supported, O-RU and O-DU may rely on offline negotiation.
|
|
As an example, this parameter can be used to limit O-RU processing while using Section extension type#6 and #12, which are used for non-contiguous
|
|
PRB allocation, and hence results in multiple U-Plane data section headers for a given C-Plane section description.";
|
|
}
|
|
leaf max-uplane-section-header-per-slot {
|
|
type uint16;
|
|
description
|
|
"Maximum number of U-Plane data section headers within one slot that can be processed by an endpoint or processed collectively by group of
|
|
endpoints sharing capacity. Clarification for multiple U-Plane data section headers per C-Plane section description is specified in sectionId IE
|
|
description in CUS-Plane specification. For the cases where this optional parameter is not populated by O-RU or an older version O-DU does not
|
|
interpret this parameter, O-DU may optionally use max-sections-per-slot as the default value to limit of U-Plane data section messages which can
|
|
be processed by the O-RU. If none of the above limitations are supported, O-RU and O-DU may rely on offline negotiation.
|
|
As an example, this parameter can be used to limit O-RU processing while using Section extension type#6 and #12, which are used for non-contiguous
|
|
PRB allocation, and hence results in multiple U-Plane data section headers for a given C-Plane section description.";
|
|
}
|
|
|
|
description
|
|
"Parameters describing section capacity where section is understood as number of different sectionId values. Additionally, max limits for U-Plane data sections
|
|
refer to U-Plane data section headers";
|
|
}
|
|
|
|
grouping endpoint-section-extension-limits {
|
|
leaf max-mcscaleremask-per-prb {
|
|
type uint16;
|
|
description
|
|
"This parameter limits the number of sets of {mcScaleReMask, csf, mcScaleOffset} values per symPrbPattern the O-RU can support when SE 23 is used in a
|
|
data section description. Refer to clause 7.7.23.1 of the CUS-Plane specification.";
|
|
}
|
|
leaf max-prb-ranges-per-sec-ext-12 {
|
|
type uint16;
|
|
description
|
|
"Optional parameter reported by O-RU which applies to Section Extension 12 and specifies
|
|
the maximum number of frequency ranges R per section description supported by O-RU.
|
|
If this limit is exceeded by the O-DU, the O-RU may send alarm notification with
|
|
'fault-id = 31' to subscribers following the procedures defined in Clause 11 and
|
|
Table A.1-1 of O-RAN.WG4.MP.0.
|
|
As an example, the O-RU can include the following in the corresponding active-alarm list
|
|
entry and alarm-notification message:
|
|
<fault-text>Error C-Plane message</fault-text>
|
|
<probable-cause>Maximum number of frequency ranges in SE-12 per section description exceeded</probable-cause>
|
|
<proposed-repair-actions>Reduce frequency ranges per section description used in SE-12</proposed-repair-actions>";
|
|
}
|
|
leaf max-freq-hops-per-sec-ext-13 {
|
|
type uint16;
|
|
description
|
|
"Optional parameter reported by O-RU which applies to Section Extension 13 and specifies
|
|
the maximum number of frequency hops R per section description supported by O-RU.
|
|
If this limit is exceeded by the O-DU, the O-RU may send alarm notification with
|
|
'fault-id = 31' to subscribers following the procedures defined in Clause 11 and
|
|
Table A.1-1 of O-RAN.WG4.MP.0.
|
|
As an example, the O-RU can include the following in the corresponding active-alarm list
|
|
entry and alarm-notification message:
|
|
<fault-text>Error C-Plane message</fault-text>
|
|
<probable-cause>Maximum number of frequency hops in SE 13 per section description exceeded</probable-cause>
|
|
<proposed-repair-actions>Reduce frequency hops per section description used in SE-13</proposed-repair-actions>";
|
|
}
|
|
|
|
leaf max-prb-blks-per-sec-ext-23 {
|
|
if-feature feat:SE23-PRB-BLOCK-MODE-SUPPORT;
|
|
type uint16;
|
|
description
|
|
"Optional parameter reported by O-RU which applies to Section Extension 23 and specifies
|
|
the maximum number of prb blocks (Refer Clause 7.7.23.1 of CUS-Plane spec prb block) per
|
|
section description supported by O-RU.
|
|
If this limit is exceeded by the O-DU, the O-RU may send alarm notification with 'fault-id = 31'
|
|
to subscribers following the procedures defined in Clause 11 and
|
|
Table A.1-1 of O-RAN.WG4.MP.0.
|
|
As an example, the O-RU can include the following in the corresponding active-alarm list
|
|
entry and alarm-notification message:
|
|
<fault-text>Error C-Plane message</fault-text>
|
|
<probable-cause>Maximum number of prb blocks in SE-23 per section description exceeded</probable-cause>
|
|
<proposed-repair-actions>Reduce prb blocks per section description used in SE-23</proposed-repair-actions>";
|
|
}
|
|
|
|
description
|
|
"Parameters describing C-Plane section extension limits/capacities.";
|
|
}
|
|
|
|
grouping endpoint-beam-capacity {
|
|
leaf max-beams-per-symbol {
|
|
type uint16 {
|
|
range "min .. 32767";
|
|
}
|
|
description
|
|
"Max number of different beamId values within one symbol that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity
|
|
|
|
If the parameter is absent or if value 0 is reported for the parameter,
|
|
then the endpoint does not support beamforming operation.
|
|
|
|
The parameter doesn't apply if multiple-beamId-tables-support-enabled is set to true.
|
|
In such a case, max-beams-per-symbol-multiple-beamid-tables applies.";
|
|
}
|
|
leaf max-beams-per-slot {
|
|
type uint16 {
|
|
range "min .. 32767";
|
|
}
|
|
description
|
|
"Max number of different beamId values within one slot that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity
|
|
|
|
If the parameter is absent or if value 0 is reported for the parameter,
|
|
then the endpoint does not support beamforming operation.
|
|
|
|
The parameter doesn't apply if multiple-beamId-tables-support-enabled is set to true.
|
|
In such a case, max-beams-per-slot-multiple-beamid-tables applies.";
|
|
}
|
|
leaf max-beams-per-symbol-multiple-beamid-tables {
|
|
if-feature feat:MULTIPLE-BEAMID-TABLES-SUPPORTED;
|
|
type uint32;
|
|
description
|
|
"Max number of different beamId values within one symbol that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity.
|
|
beamId values associated with different beamId tables are always considered different.
|
|
|
|
This parameter only applies if multiple-beamId-tables-support-enabled is set to true.
|
|
If multiple-beamId-tables-support-enabled is set to false, then max-beams-per-symbol applies.";
|
|
}
|
|
leaf max-beams-per-slot-multiple-beamid-tables {
|
|
if-feature feat:MULTIPLE-BEAMID-TABLES-SUPPORTED;
|
|
type uint32;
|
|
description
|
|
"Max number of different beamId values within one slot that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity.
|
|
beamId values associated with different beamId tables are always considered different.
|
|
|
|
This parameter only applies if multiple-beamId-tables-support-enabled is set to true.
|
|
If multiple-beamId-tables-support-enabled is set to false, then max-beams-per-slot applies.";
|
|
}
|
|
leaf max-beam-updates-per-slot {
|
|
type uint16 {
|
|
range "min .. 32767";
|
|
}
|
|
description
|
|
"Max number of beams within one slot that can be updated by endpoint
|
|
or processed collectively by group of endpoints sharing capacity
|
|
|
|
If the parameter is absent or if value 0 is reported for the parameter,
|
|
then the endpoint does not support beamforming operation.";
|
|
}
|
|
leaf max-beam-updates-per-symbol {
|
|
type uint16 {
|
|
range "min .. 32767";
|
|
}
|
|
description
|
|
"Max number of beams within one symbol that can be updated by endpoint
|
|
or processed collectively by group of endpoints sharing capacity
|
|
|
|
If the parameter is absent or if value 0 is reported for the parameter,
|
|
then the endpoint does not support beamforming operation.";
|
|
}
|
|
|
|
description
|
|
"Parameters describing beam capacity where number of beams is understood as number of different beamId values.
|
|
Parameters defined for beam updates shall be used to put a maximum limit on number of beam/beamIds which can be updated
|
|
every slot/symbol. Note: This parameter does not put any restriction on which beams/beamIds can be updated.
|
|
|
|
If the parameters defining beam capacity and beam updates are absent or if value 0 is reported for the parameters
|
|
defining beam capacity and beam updates, then the endpoint does not support beamforming operation.";
|
|
}
|
|
|
|
grouping endpoint-prb-capacity {
|
|
leaf max-prb-per-symbol {
|
|
type uint16;
|
|
description
|
|
"Max number of prbs within one symbol that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity";
|
|
}
|
|
|
|
leaf max-prb-ranges-per-symbol {
|
|
type uint32;
|
|
description
|
|
"Optional parameter reported by O-RU which indicates the maximum number of PRB ranges
|
|
that can be processed by single endpoint or processed collectively by group of endpoints
|
|
sharing capacity within one symbol. For details please see O-RAN WG4 CUS-Plane specification,
|
|
Clause 7.8.2.1.2 'Limits of number of PRB ranges'.
|
|
|
|
In case CU-Plane traffic generated by the O-DU exceeds the limit, an O-RU is responsible
|
|
for sending alarm notification with 'fault-id = 31' to subscribers following the procedures
|
|
defined in Clause 11 and Table A.1-1 of O-RAN.WG4.MP.0.
|
|
|
|
As an example, the O-RU can include the following in the corresponding active-alarm list
|
|
entry and alarm-notif message:
|
|
<fault-text>Error C-Plane message</fault-text>
|
|
<probable-cause>max-prb-ranges-per-symbol exceeded</probable-cause>
|
|
<proposed-repair-actions>Reduce value of number of PRB ranges used per symbol</proposed-repair-actions>";
|
|
}
|
|
|
|
description
|
|
"Attributes presenting processing capacity related to PRB.";
|
|
}
|
|
|
|
grouping endpoint-numerology-capacity {
|
|
leaf max-numerologies-per-symbol {
|
|
type uint16;
|
|
description
|
|
"Max number of numerologies within one symbol that can be processed by endpoint
|
|
or processed collectively by group of endpoints sharing capacity";
|
|
}
|
|
|
|
description
|
|
"Attributes presenting processing capacity related to numerology.
|
|
|
|
This leaf contains valid data only when multiple-numerology-supported
|
|
is set to true.";
|
|
}
|
|
|
|
grouping per-cplane-message-limits {
|
|
leaf max-beams-per-cplane-message {
|
|
type uint16;
|
|
description
|
|
"Maximum number of beams which can be received in one single C-Plane message. Number of beams,
|
|
may include only beamIds, only beam weights or mix of beamIds and beamweights being received by
|
|
an O-RU in a single C-Plane message.
|
|
To avoid application layer fragmentation of C-Plane message across the fronthaul, O-RU should
|
|
avoid setting this to a very low value.
|
|
As a usage scenario, an O-RU may choose to define only a few quantized values e.g. (128, 256).
|
|
If the value is set to 0 by O-RU, the O-DU need not restrict the number of beams it can send
|
|
in single C-Plane message (except limited by MTU size).";
|
|
}
|
|
|
|
leaf max-highest-priority-sec-per-cplane-message {
|
|
type uint16;
|
|
description
|
|
"Maximum number of highest priority sections which can be received in one single C-Plane message.
|
|
This leaf applies only when 'coupling-via-frequency-and-time-with-priorities' is true";
|
|
}
|
|
|
|
leaf max-beams-per-slot-with-cplane-limits {
|
|
type uint16;
|
|
description
|
|
"Maximum number of beams that are required to be processed by endpoint or processed collectively
|
|
by group of endpoints sharing capacity when O-DU enables C-Plane limits. This value should replace
|
|
'max-beams-per-slot' defined in 'endpoint-beam-capacity'";
|
|
}
|
|
|
|
leaf max-highest-priority-sections-per-slot-with-cplane-limits {
|
|
type uint16;
|
|
description
|
|
"Maximum number of highest priority sections that are required to be processed by endpoint or processed
|
|
collectively by group of endpoints sharing capacity when O-DU supports C-Plane limits. This value should
|
|
replace 'max-highest-priority-sections-per-slot' defined in 'endpoint-section-capacity'";
|
|
}
|
|
|
|
leaf max-num-se22-per-cplane-message {
|
|
type uint16;
|
|
description
|
|
"This value limits the max number of section extension 22 (ACK/NACK request) included in a C-Plane message as supported
|
|
by the endpoint or collectively by group of endpoints sharing capacity when O-DU enables C-Plane limits
|
|
and when section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback) are supported by the endpoint or endpoint sharing group.";
|
|
}
|
|
|
|
leaf max-prb-ranges-per-hp-section-sec-ext-12 {
|
|
type uint16;
|
|
description
|
|
"Optional parameter reported by O-RU which applies to Section Extension 12 and specifies the
|
|
maximum number of frequency ranges R per highest priority section description supported by O-RU.
|
|
If this limit is exceeded by the O-DU, the O-RU is responsible for sending alarm notification
|
|
with 'fault-id = 31' to subscribers following the procedures defined in Clause 11 and
|
|
Table A.1-1 of O-RAN.WG4.MP.0.
|
|
As an example, the O-RU can include the following in the corresponding active-alarm list
|
|
entry and alarm-notification message:
|
|
<fault-text>Error C-Plane message</fault-text>
|
|
<probable-cause>Maximum number of frequency hops per highest priority section description exceeded</probable-cause>
|
|
<proposed-repair-actions>Reduce frequency range per highest section description</proposed-repair-actions>";
|
|
}
|
|
|
|
description
|
|
"Attributes limit maximum instances of certain parameters contained in a C-Plane message e.g. beams,
|
|
highest priority sections. This limitation is useful for O-RUs which are packet processing based and are
|
|
dimensioned to handle fixed number of parameters contained in a C-Plane message. In addition, if O-DU supports
|
|
cplane limits, O-RU can operate more efficiently and endpoint capacity for applicable parameters are enhanced.
|
|
as specified by 'max-beams-per-slot-with-cplane-limits' and 'max-highest-priority-sections-per-slot-with-cplane-limits'";
|
|
}
|
|
|
|
|
|
grouping per-uplane-message-limits {
|
|
leaf max-section-headers-per-uplane-message {
|
|
if-feature feat:UPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
type uint16;
|
|
description
|
|
"Maximum number of section headers which can be received in one single U-Plane message.";
|
|
}
|
|
|
|
description
|
|
"Attributes describe maximum instances of certian parameters contained in a U-Plane mesaage e.g.
|
|
number of section headers. Those limitations are required for O-RUs which are packet processing based and are
|
|
dimensioned to handle limited number of parameters contained in a U-Plane message. ";
|
|
}
|
|
|
|
grouping beam-update-contention-control-limits {
|
|
leaf max-beams-per-symbol-with-beam-contention-control {
|
|
type uint16;
|
|
description
|
|
"Maximum number of beams within one symbol that can be processed by an endpoint or processed collectively
|
|
by group of endpoints sharing capacity when O-DU enables the O-RU feature BEAM-UPDATE-CONTENTION-CONTROL.
|
|
This value should replace 'max-beams-per-symbol' defined in 'endpoint-beam-capacity'";
|
|
}
|
|
|
|
leaf max-beams-updates-per-symbol-with-beam-contention-control {
|
|
type uint16;
|
|
description
|
|
"Maximum number of beams within one symbol that can be updated by an endpoint or processed collectively
|
|
by group of endpoints sharing capacity when O-DU enables the O-RU feature BEAM-UPDATE-CONTENTION-CONTROL.
|
|
This value should replace 'max-beam-updates-per-symbol' defined in 'endpoint-beam-capacity'";
|
|
}
|
|
|
|
description
|
|
"If O-DU supports BEAM-UPDATE-CONTENTION-CONTROL, O-RU can operate more efficiently and endpoint capacity for applicable
|
|
parameters are enhanced.";
|
|
}
|
|
|
|
grouping endpoint-static-config-support {
|
|
leaf static-config-supported {
|
|
type enumeration {
|
|
enum NONE {
|
|
description
|
|
"The endpoint does not support static PRACH / SRS configuration.
|
|
Reception of PRACH / SRS is possible through real time C-Plane messages
|
|
if other endpoint capabilities allow for that.";
|
|
}
|
|
enum PRACH {
|
|
if-feature mcap:PRACH-STATIC-CONFIGURATION-SUPPORTED;
|
|
description
|
|
"The endpoint supports statically configured PRACH reception";
|
|
}
|
|
enum SRS {
|
|
if-feature mcap:SRS-STATIC-CONFIGURATION-SUPPORTED;
|
|
description
|
|
"The endpoint supports statically configured SRS reception";
|
|
}
|
|
}
|
|
default NONE;
|
|
|
|
description
|
|
"The parameter informs if endpoint can be statically configured to process PRACH or SRS reception";
|
|
}
|
|
|
|
leaf max-prach-patterns {
|
|
when "(/user-plane-configuration/static-low-level-rx-endpoints[name=current()/../name]/static-config-supported = 'PRACH')";
|
|
type uint8;
|
|
description
|
|
"Maximum number of PRACH patterns the endpoint can handle in PRACH configuration.
|
|
Due to limited range of the parameter, an O-DU should use extended-max-prach-patterns parameter.";
|
|
}
|
|
|
|
leaf extended-max-prach-patterns {
|
|
when "(/user-plane-configuration/static-low-level-rx-endpoints[name=current()/../name]/static-config-supported = 'PRACH')";
|
|
if-feature feat:EXTENDED-PRACH-CONFIGURATION;
|
|
type uint32;
|
|
description
|
|
"Maximum number of PRACH patterns the endpoint can handle in PRACH configuration if EXTENDED-STATIC-PRACH is supported.";
|
|
}
|
|
|
|
leaf max-srs-patterns {
|
|
when "(/user-plane-configuration/static-low-level-rx-endpoints[name=current()/../name]/static-config-supported = 'SRS')";
|
|
type uint8;
|
|
description
|
|
"Maximum number of SRS patterns the endpoint can handle in SRS configuration";
|
|
}
|
|
|
|
description
|
|
"Endpoint's capabilities related to static PRACH / SRS configuration.";
|
|
}
|
|
|
|
grouping endpoint-tdd-pattern-support {
|
|
leaf configurable-tdd-pattern-supported {
|
|
if-feature mcap:CONFIGURABLE-TDD-PATTERN-SUPPORTED;
|
|
type boolean;
|
|
default false;
|
|
|
|
description
|
|
"The parameter informs if endpoint supports configuration for TDD pattern";
|
|
}
|
|
|
|
leaf tdd-group {
|
|
type uint8;
|
|
description
|
|
"Parameter is used to group static-low-level-[tr]x-endpoints.
|
|
Note: [tr]x-array-carriers using static-low-level-[tr]x-endpoints
|
|
having the same value of tdd-group, must have the same TDD switching
|
|
points and the same directions to the air interface granted - regardless TDD switching
|
|
is controlled by M-Plane or by C-Plane";
|
|
}
|
|
|
|
description
|
|
"This grouping exposes static-low-level-[tr]x-endpoint's capabilities related to its support for configurable
|
|
TDD patterns and limitations regarding common TDD switching per groups of endpoints.";
|
|
}
|
|
|
|
grouping u-plane-transmission-control {
|
|
description
|
|
"Configuration for UL U-plane transmission control";
|
|
|
|
leaf transmission-window-control {
|
|
if-feature "feat:STATIC-TRANSMISSION-WINDOW-CONTROL or feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL";
|
|
type enumeration {
|
|
enum NONE {
|
|
description
|
|
"O-RU will use normal transmission type with normal transmission window";
|
|
}
|
|
enum STATIC {
|
|
if-feature feat:STATIC-TRANSMISSION-WINDOW-CONTROL;
|
|
description
|
|
"O-RU will use transmission window offset and size and transmission type as configured over M-plane";
|
|
}
|
|
enum DYNAMIC {
|
|
if-feature feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL;
|
|
description
|
|
"O-RU will use transmission window offset and size and transmission type as requested over C-plane";
|
|
}
|
|
}
|
|
default NONE;
|
|
|
|
description
|
|
"Selects type of UL U-plane transmission window control for the endpoint";
|
|
}
|
|
|
|
leaf transmission-window-schedule {
|
|
when "(../transmission-window-control = 'STATIC')";
|
|
if-feature feat:STATIC-TRANSMISSION-WINDOW-CONTROL;
|
|
type union {
|
|
type empty;
|
|
type leafref {
|
|
path "/user-plane-configuration/transmission-window-schedules/id";
|
|
}
|
|
}
|
|
description
|
|
"Identifies U-plane transmission window schedule (which provides a list of symbol-specific offsets)
|
|
to be used by the endpoint.
|
|
Symbol-specific offset values from the schedule are added to endpoint specific offset value
|
|
from transmission-window-offset.
|
|
If this element is not present, the O-RU assumes as all symbol specific offsets are zero.
|
|
For restrictions on values of symbol-specific offsets see description of transmission-window-offset.
|
|
This parameter shall not be set to value other than empty if transmission control is not enabled
|
|
by transmission-window-control.";
|
|
}
|
|
|
|
leaf transmission-window-offset {
|
|
when "(../transmission-window-control = 'STATIC')";
|
|
if-feature feat:STATIC-TRANSMISSION-WINDOW-CONTROL;
|
|
type uint16;
|
|
units "number of symbols";
|
|
default 0;
|
|
description
|
|
"Transmission window offset.
|
|
The effective symbol-specific offset is sum of endpoint-specific offset value from transmission-window-offset
|
|
and symbol-specific offset from transmission-window-schedules referenced by transmission-window-schedule.
|
|
|
|
If this element is not present then O-RU assumes transmission-window-offset is zero.
|
|
This parameter shall not be set to value other than 0 if transmission control is not enabled
|
|
by transmission-window-control.
|
|
|
|
There is no direct upper bound for this parameter (except value range defined by leaf type) but there are
|
|
restrictions on combination of values of transmission-window-offset, transmission-window-offset,
|
|
symbol-specific offset from transmission-window-schedules and transmission-window-size.
|
|
|
|
Specifically, if endpoint is set for delay managed operation (non-time-managed-delay-enabled = FALSE)
|
|
then O-RU handles U-Plane transmission as delay managed traffic and combination of values of
|
|
transmission-window-offset, symbol-specific offset from transmission-window-schedules and
|
|
transmission-window-size must not exceed O-RU buffering capacity (transmission-buffering-capacity)
|
|
for the requested reception schedule.
|
|
|
|
If endpoint is set for non-delay managed operation (non-time-managed-delay-enabled = TRUE)
|
|
then O-RU handles U-Plane transmission on best effort basis. In this case any combination of values
|
|
of transmission-window-offset, symbol-specific offset from transmission-window-schedules and
|
|
transmission-window-size is permitted. This does not remove restrictions on parameters due to restrictions
|
|
defined for value type or restrictions that depend on INDEPENDENT-TRANSMISSION-WINDOW-CONTROL feature
|
|
|
|
Additional restrictions on values (and presence) of transmission-window-schedule, transmission-window-offset
|
|
and transmission-window-size depend on presence of INDEPENDENT-TRANSMISSION-WINDOW-CONTROL feature.
|
|
|
|
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.";
|
|
}
|
|
|
|
leaf transmission-window-size {
|
|
when "(../transmission-window-control = 'STATIC')";
|
|
if-feature feat:STATIC-TRANSMISSION-WINDOW-CONTROL;
|
|
type uint16 {
|
|
range "0..10000";
|
|
}
|
|
units "microsecond";
|
|
default 0;
|
|
description
|
|
"Transmission window size to be used; only values that are compatible with SCS used
|
|
for the endpoint are allowed.
|
|
Minimum supported value is determined by SCS specific transmission window size
|
|
reported by O-RU in ru-delay-profile.
|
|
|
|
Client can use special value 0 (zero) instead of the SCS specific transmission window
|
|
size reported by O-RU in ru-delay-profile with the same effect.
|
|
This parameter shall not be set to value other than 0 if transmission control is not enabled
|
|
(transmission-window-control = NONE) or the endpoint is set for non-delay managed operation
|
|
(non-time-managed-delay-enabled = TRUE).
|
|
|
|
There is no direct upper bound for this parameter (except value range defined by leaf type) but there are
|
|
restrictions on combination of values of transmission-window-offset, transmission-window-offset,
|
|
symbol-specific offset from transmission-window-schedules and transmission-window-size.
|
|
See description of transmission-window-offset for more details.";
|
|
}
|
|
|
|
leaf transmission-type {
|
|
when "(../transmission-window-control = 'STATIC')";
|
|
if-feature "feat:STATIC-TRANSMISSION-WINDOW-CONTROL and feat:UNIFORMLY-DISTRIBUTED-TRANSMISSION";
|
|
type enumeration {
|
|
enum NORMAL {
|
|
description
|
|
"Normal transmission (unspecified within transmission window)";
|
|
}
|
|
enum UNIFORMLY-DISTRIBUTED {
|
|
if-feature feat:UNIFORMLY-DISTRIBUTED-TRANSMISSION;
|
|
description
|
|
"Uniformly distributed over transmission window: each of N messages in the window
|
|
transmitted at random time in a separate subwindow; subwindow size is window size / N ";
|
|
}
|
|
}
|
|
|
|
description "Type of delay supported by the endpoint";
|
|
}
|
|
}
|
|
|
|
grouping tx-endpoint-compression-grouping {
|
|
description
|
|
"Grouping for endpoint compression";
|
|
|
|
container compression {
|
|
presence
|
|
"This container shall exists to avoid misaligned compression
|
|
methods between devices";
|
|
|
|
description
|
|
"Container which consists of global configurable parameters for compression";
|
|
|
|
uses cf:compression-details;
|
|
|
|
leaf fs-offset {
|
|
if-feature cf:CONFIGURABLE-FS-OFFSET;
|
|
type uint8;
|
|
default 0;
|
|
description
|
|
"Adjusts FS (full scale) value of IQ format relative to FS derived from unmodified IQ format.
|
|
Please refer to CU-Plane specification for details";
|
|
}
|
|
|
|
list dynamic-compression-configuration {
|
|
when "../compression-type = 'DYNAMIC'";
|
|
key "id";
|
|
unique "compression-method iq-bitwidth fs-offset";
|
|
description
|
|
"List of possible configuration in case dynamic configuration is used
|
|
Note: In case of empty list all available compressions can be chosen dynamically
|
|
and default fs-offset is taken (0).
|
|
If the feature CONFIGURABLE-FS-OFFSET is not supported,
|
|
fs-offset will not be considered as one of the criteria for unique statement.
|
|
Refer to RFC7950 clause 7.8.3 for details of unique statement";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for particular compression";
|
|
}
|
|
|
|
uses cf:compression-method-grouping;
|
|
|
|
leaf fs-offset {
|
|
if-feature cf:CONFIGURABLE-FS-OFFSET;
|
|
type uint8;
|
|
default 0;
|
|
description
|
|
"Adjusts FS (full scale) value of IQ format relative to FS derived from unmodified IQ format.
|
|
Please refer to CU-Plane specification for details";
|
|
}
|
|
|
|
leaf channel-information-iq-bitwidth {
|
|
type uint8{
|
|
range "1..16";
|
|
}
|
|
status deprecated;
|
|
description
|
|
"I/Q bitwidth for channel information in Section Type6.
|
|
Leaf is deprecated as it should be independent of dynamic compression,
|
|
NETCONF client instead uses channel-information-bitwidth schema node";
|
|
}
|
|
}
|
|
|
|
leaf channel-information-bitwidth {
|
|
type uint8{
|
|
range "1..16";
|
|
}
|
|
description
|
|
"I/Q bitwidth for channel information in Section Type6.
|
|
Maximum value is limited to 16.
|
|
Value 1,2,..16 indicates I and Q are each 1,2..16 bits wide respectively.
|
|
Note: This parameter shall be used when the NETCONF client does not make use of
|
|
the CHANNEL-INFORMATION-COMPRESSION feature.";
|
|
}
|
|
|
|
list channel-information-compressions {
|
|
if-feature "feat:CHANNEL-INFORMATION-COMPRESSION";
|
|
key id;
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for particular channel information compression";
|
|
}
|
|
|
|
leaf channel-information-compression-method {
|
|
type cf:ci-compression-method-def;
|
|
description
|
|
"Channel information compression method";
|
|
}
|
|
|
|
leaf iq-bitwidth {
|
|
type uint8{
|
|
range "1..16";
|
|
}
|
|
description
|
|
"Bitwidth to be used in compression, maximum value is limited to 16.
|
|
Value 1,2,..16 indicates I and Q are each 1,2..16 bits wide respectively.
|
|
|
|
When this schema node is used in the configuration, the O-RU shall ignore the configuration of the
|
|
/low-level-tx-endpoints/compression/channel-information-bitwidth schema node";
|
|
}
|
|
|
|
description
|
|
"List of available compressions, that can be dynamically chosen, for channel information (e.g. ST6) for this endpoint.
|
|
Note1: When only one compression is listed here, it implies that channel information compression
|
|
is static and mentioned compression is taken into use.
|
|
Note2: O-RU Shall reject configuration with compressions that are not supported";
|
|
}
|
|
|
|
list bf-weights-compressions {
|
|
key id;
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for particular beamforming compression";
|
|
}
|
|
|
|
leaf bf-weights-compression {
|
|
type cf:bf-compression-method-def;
|
|
description
|
|
"Beamforming weight compression method";
|
|
}
|
|
|
|
leaf iq-bitwidth {
|
|
type uint8 {
|
|
range "1..16";
|
|
}
|
|
description
|
|
"Bitwidth to be used in compression, maximum value is limited to 16.
|
|
Value 1,2,..16 indicates I and Q are each 1,2..16 bits wide respectively";
|
|
}
|
|
description
|
|
"List of available compressions, that can be dynamically chosen, for beamforming weights for this endpoint.
|
|
Note1: When only one compression is listed here, it implies that beamforming weights compression
|
|
is static and mentioned compression is taken into use.
|
|
Note2: O-RU Shall reject configuration with compressions that are not supported";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping rx-endpoint-compression-grouping {
|
|
description
|
|
"Grouping for endpoint compression";
|
|
|
|
container compression {
|
|
presence
|
|
"This container shall exists to avoid misaligned compression
|
|
methods between devices";
|
|
|
|
description
|
|
"Container which consists of global configurable parameters for compression";
|
|
|
|
uses cf:compression-details;
|
|
|
|
leaf fs-offset {
|
|
if-feature cf:CONFIGURABLE-FS-OFFSET;
|
|
type uint8;
|
|
default 0;
|
|
description
|
|
"Adjusts FS (full scale) value of IQ format relative to FS derived from unmodified IQ format.
|
|
Please refer to CU-Plane specification for details";
|
|
}
|
|
|
|
list dynamic-compression-configuration {
|
|
when "../compression-type = 'DYNAMIC'";
|
|
key "id";
|
|
unique "compression-method iq-bitwidth fs-offset";
|
|
description
|
|
"List of possible configuration in case dynamic configuration is used
|
|
Note: In case of empty list all available compressions can be chosen dynamically
|
|
and default fs-offset is taken (0).
|
|
If the feature CONFIGURABLE-FS-OFFSET is not supported,
|
|
fs-offset will not be considered as one of the criteria for unique statement.
|
|
Refer to RFC7950 clause 7.8.3 for details of unique statement";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for particular compression";
|
|
}
|
|
|
|
uses cf:compression-method-grouping;
|
|
|
|
leaf fs-offset {
|
|
if-feature cf:CONFIGURABLE-FS-OFFSET;
|
|
type uint8;
|
|
default 0;
|
|
description
|
|
"Adjusts FS (full scale) value of IQ format relative to FS derived from unmodified IQ format.
|
|
Please refer to CU-Plane specification for details";
|
|
}
|
|
}
|
|
|
|
list bf-weights-compressions {
|
|
key id;
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for particular beamforming compression";
|
|
}
|
|
|
|
leaf bf-weights-compression {
|
|
type cf:bf-compression-method-def;
|
|
description
|
|
"Beamforming weight compression method";
|
|
}
|
|
|
|
leaf iq-bitwidth {
|
|
type uint8;
|
|
description
|
|
"Bitwidth to be used in compression";
|
|
}
|
|
|
|
description
|
|
"List of available compressions, that can be dynamically chosen, for beamforming weights for this endpoint.
|
|
Note1: When only one compression is listed here, it implies that beamforming weights compression
|
|
is static and mentioned compression is taken into use.
|
|
Note2: O-RU Shall reject configuration with compressions that are not supported";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping supported-section-type4-config {
|
|
description
|
|
"Set of parameters required for section type 4 slot configuration message.";
|
|
list st4-supported-commands {
|
|
key "st4-command-type";
|
|
|
|
description
|
|
"This parameter specifies the list of Section Type 4 command types supported by O-RU.";
|
|
leaf st4-command-type {
|
|
type enumeration {
|
|
enum TIME_DOMAIN_BEAM_CONFIG {
|
|
description "O-RU support for receiving time domain beamforming command.";
|
|
}
|
|
enum TDD_CONFIG_PATTERN {
|
|
description "O-RU support for receiving TDD symbol pattern for a given slot.";
|
|
}
|
|
enum TRX_CONTROL {
|
|
if-feature feat:TRX-CONTROL;
|
|
description "O-RU support for receiving TRX CONTROL command in a given slot.";
|
|
}
|
|
enum ASM {
|
|
if-feature feat:ADVANCED-SLEEP-MODE;
|
|
description "O-RU support for receiving ASM command in a given slot.";
|
|
}
|
|
}
|
|
description
|
|
"Section Type 4 command types supported by O-RU.";
|
|
}
|
|
|
|
list st4-command-scope-params {
|
|
key "cmd-scope";
|
|
|
|
description
|
|
"This list contains parameters which are specific to a given command scope associated with a particular section type 4 command type.";
|
|
|
|
leaf cmd-scope {
|
|
type enumeration {
|
|
enum ARRAY-COMMAND {
|
|
description
|
|
"Command applies to all endpoints assigned to the tx-array(s) and/or rx-array(s).If the O-RU
|
|
is operating with multiple O-DUs, the scope of an individual O-DU is limited, to the
|
|
endpoints assigned to the O-DU which was the originator of the command.";
|
|
}
|
|
enum CARRIER-COMMAND {
|
|
description
|
|
"Command applies to all endpoints assigned to the tx-array-carrier and/or rx-array-carrier.";
|
|
}
|
|
enum O-RU-COMMAND {
|
|
description
|
|
"O-RU level command, i.e., one that applies to all arrays and carriers. If the O-RU
|
|
is operating with multiple O-DUs, the scope of an individual O-DU is limited, as
|
|
specified in CUS-Plane specification, clause 7.5.2.17.";
|
|
}
|
|
}
|
|
description "Command scope for section type 4 commands";
|
|
}
|
|
|
|
leaf st4-reception-bitmask {
|
|
type uint16;
|
|
description
|
|
"This parameter specifies the O-RU capability to receive Section Type 4 message with associated commands with a particular command scope
|
|
for the symbols for which the corresponding bit is set to '1' in the bitmask. If the O-RU receives a Section Type 4 message with
|
|
associated command for a symbol whose bit value is set to '0' in this bitmask, the O-RU shall reject the Section Type 4 message";
|
|
}
|
|
}
|
|
}
|
|
|
|
list st4-reception-mask {
|
|
key "cmd-scope";
|
|
status deprecated;
|
|
|
|
description
|
|
"List of symbol mask per command scope, specifying the O-RU capability to receive Section Type 4 message for a
|
|
given command scope only for symbols for which the corresponding bit is set to '1' in the bitmask. If the O-RU
|
|
receives a Section Type 4 message with associated command for a symbol whose bit value is set to '0' in this
|
|
bitmask, the O-RU shall reject the Section Type 4 message";
|
|
|
|
leaf cmd-scope {
|
|
type enumeration {
|
|
enum ARRAY-COMMAND {
|
|
description
|
|
"Command applies to all endpoints assigned to the tx-array(s) and/or rx-array(s).If the O-RU
|
|
is operating with multiple O-DUs, the scope of an individual O-DU is limited, to the
|
|
endpoints assigned to the O-DU which was the originator of the command.";
|
|
}
|
|
enum CARRIER-COMMAND {
|
|
description
|
|
"Command applies to all endpoints assigned to the tx-array-carrier and/or rx-array-carrier.";
|
|
}
|
|
enum O-RU-COMMAND {
|
|
description
|
|
"O-RU level command, i.e., one that applies to all arrays and carriers. If the O-RU
|
|
is operating with multiple O-DUs, the scope of an individual O-DU is limited, as
|
|
specified in CUS-Plane specification, clause 7.5.2.17.";
|
|
}
|
|
}
|
|
description "Command scope for section type 4 commands";
|
|
}
|
|
|
|
leaf st4-reception-bitmask {
|
|
type uint16;
|
|
description
|
|
"This parameter specifies the O-RU capability to receive Section Type 4 message with associated commands for the symbols
|
|
for which the corresponding bit is set to '1' in the bitmask. If the O-RU receives a Section Type 4 message with
|
|
associated command for a symbol whose bit value is set to '0' in this bitmask, the O-RU shall reject the Section Type 4 message";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping uplane-conf-group {
|
|
description
|
|
"Grouping for uplane configuration related parameters";
|
|
|
|
list low-level-tx-links {
|
|
key name;
|
|
description
|
|
"Object model for low-level-tx-link configuration";
|
|
|
|
leaf name {
|
|
type string;
|
|
description
|
|
"Unique name of low-level-tx-link 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
|
|
"An optional shared resource operator associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a low-level-tx-link
|
|
associated with a shared resource operator where the sro-id identifies
|
|
a specific shared resource operator.
|
|
This schema-node is used to refine NACM privileges for shared
|
|
resource operators";
|
|
}
|
|
|
|
leaf processing-element {
|
|
type leafref {
|
|
path "/o-ran-pe:processing-elements/o-ran-pe:ru-elements/o-ran-pe:name";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Contains name of processing-element to be used as transport by low-level-tx-link,
|
|
if 'transport-qualified-processing-element' is included in the configuration,
|
|
the O-RU shall use 'transport-qualified-processing-element' instead of this schema node,
|
|
an O-RU Controller shall still configure this schema node with a leafref to a valid ru-element,
|
|
but this shall not be used by the O-RU.";
|
|
}
|
|
|
|
leaf transport-session-type {
|
|
if-feature "feat:MULTIPLE-TRANSPORT-SESSION-TYPE";
|
|
type enumeration {
|
|
enum ETH-INTERFACE {
|
|
description "VLAN based CUS Transport ";
|
|
}
|
|
enum UDPIP-INTERFACE {
|
|
description "UDP/IP based CUS Transport ";
|
|
}
|
|
enum ALIASMAC-INTERFACE{
|
|
description "Alias MAC address based CUS Transport ";
|
|
}
|
|
}
|
|
description
|
|
"transport session type used when an O-RU is configured with multiple processing elements of different transport session types,
|
|
in which case it is used for referencing a processing element in 'transport-qualified-processing-element'";
|
|
}
|
|
|
|
leaf transport-qualified-processing-element {
|
|
if-feature "feat:MULTIPLE-TRANSPORT-SESSION-TYPE";
|
|
type leafref {
|
|
path "/o-ran-pe:processing-elements/o-ran-pe:additional-transport-session-type-elements[o-ran-pe:transport-session-type = current()/../transport-session-type]/o-ran-pe:ru-elements/o-ran-pe:name";
|
|
}
|
|
description
|
|
"Contains name of processing-element to be used as transport by low-level-tx-link.
|
|
Used when the processing element is configured
|
|
by the list 'additional-transport-session-type-elements'";
|
|
}
|
|
|
|
leaf tx-array-carrier {
|
|
type leafref {
|
|
path "/user-plane-configuration/tx-array-carriers/name";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Contains name of tx-array-carriers MO to be used as transport by low-level-tx-link";
|
|
}
|
|
|
|
leaf low-level-tx-endpoint {
|
|
type leafref {
|
|
path "/user-plane-configuration/low-level-tx-endpoints/name";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Contains name of low-level-tx-endpoints MO to be used as transport by low-level-tx-link";
|
|
}
|
|
}
|
|
|
|
list low-level-rx-links {
|
|
key name;
|
|
description
|
|
"Object model for low-level-rx-links configuration";
|
|
|
|
leaf name {
|
|
type string;
|
|
|
|
description
|
|
"Unique name of low-level-rx-links 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
|
|
"An optional shared resource operator associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a low-level-rx-link
|
|
associated with a shared resource operator where the sro-id identifies
|
|
a specific shared resource operator.
|
|
This schema-node is used to refine NACM privileges for shared
|
|
resource operators";
|
|
}
|
|
|
|
leaf processing-element {
|
|
type leafref {
|
|
path "/o-ran-pe:processing-elements/o-ran-pe:ru-elements/o-ran-pe:name";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Contains name of processing-element to be used as transport by low-level-rx-link,
|
|
if 'transport-qualified-processing-element' is included in the configuration,
|
|
the O-RU shall use 'transport-qualified-processing-element' instead of this schema node,
|
|
an O-RU Controller shall still configure this schema node with a leafref to a valid ru-element,
|
|
but this shall not be used by the O-RU.";
|
|
}
|
|
|
|
leaf transport-session-type {
|
|
if-feature "feat:MULTIPLE-TRANSPORT-SESSION-TYPE";
|
|
type enumeration {
|
|
enum ETH-INTERFACE {
|
|
description "VLAN based CUS Transport ";
|
|
}
|
|
enum UDPIP-INTERFACE {
|
|
description "UDP/IP based CUS Transport ";
|
|
}
|
|
enum ALIASMAC-INTERFACE{
|
|
description "Alias MAC address based CUS Transport ";
|
|
}
|
|
}
|
|
description
|
|
"transport session type used when an O-RU is configured with multiple processing elements of different transport session types,
|
|
in which case it is used for referencing a processing element in 'transport-qualified-processing-element'";
|
|
}
|
|
|
|
leaf transport-qualified-processing-element {
|
|
if-feature "feat:MULTIPLE-TRANSPORT-SESSION-TYPE";
|
|
type leafref {
|
|
path "/o-ran-pe:processing-elements/o-ran-pe:additional-transport-session-type-elements[o-ran-pe:transport-session-type = current()/../transport-session-type]/o-ran-pe:ru-elements/o-ran-pe:name";
|
|
}
|
|
description
|
|
"Contains name of processing-element to be used as transport by low-level-rx-link.
|
|
Used when the processing element is configured
|
|
by the list 'additional-transport-session-type-elements'";
|
|
}
|
|
|
|
leaf rx-array-carrier {
|
|
type leafref {
|
|
path "/user-plane-configuration/rx-array-carriers/name";
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"Contains name of rx-array-carriers MO to be used as transport by low-level-rx-links";
|
|
}
|
|
|
|
leaf low-level-rx-endpoint {
|
|
type leafref {
|
|
path "/user-plane-configuration/low-level-rx-endpoints/name";
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"Contains name of low-level-rx-endpoints MO to be used as transport by low-level-rx-links";
|
|
}
|
|
|
|
leaf user-plane-uplink-marking {
|
|
type leafref {
|
|
path "/o-ran-pe:processing-elements/o-ran-pe:enhanced-uplane-mapping/o-ran-pe:uplane-mapping/o-ran-pe:up-marking-name";
|
|
}
|
|
description
|
|
"Parameter to set the non-default marking for user-plane";
|
|
}
|
|
|
|
leaf enhanced-user-plane-uplink-marking {
|
|
if-feature "feat:MULTIPLE-TRANSPORT-SESSION-TYPE";
|
|
type leafref {
|
|
path "/o-ran-pe:processing-elements/o-ran-pe:additional-transport-session-type-elements[o-ran-pe:transport-session-type = current()/../transport-session-type]/o-ran-pe:enhanced-uplane-mapping/o-ran-pe:uplane-mapping/o-ran-pe:up-marking-name";
|
|
}
|
|
description
|
|
"Parameter to set the non-default marking for user-plane.
|
|
Used when the enhanced-uplane-mapping is configured
|
|
by the list 'additional-transport-session-type-elements'";
|
|
}
|
|
}
|
|
|
|
grouping common-se24-dmrs-capabilities-grp {
|
|
description
|
|
"Grouping of common SE23 DMRS BF capabilities.
|
|
Please refer to CUS specification clause 7.7.24 for more details.";
|
|
|
|
leaf max-user-groups-per-slot {
|
|
type uint32;
|
|
description
|
|
"Maximum number user groups per slot.";
|
|
}
|
|
|
|
leaf max-entries-per-slot {
|
|
type uint32;
|
|
description
|
|
"Maximum number of entries in the table of DMRS configurations per slot.";
|
|
}
|
|
}
|
|
|
|
list endpoint-types {
|
|
key "id";
|
|
config false;
|
|
description
|
|
"Properties of endpoint that are common to multiple endpoints if such are identified
|
|
Note: For any endpoint supporting mixed numerology within slot/symbol (multiple-numerology-supported=TRUE)
|
|
* Interval specific (per-slot and per-symbol) capacity constraints instantaneous capacity usage
|
|
(i.e. capacity is shared/distributed between all numerologies used at an instant of time).
|
|
* Instantaneous capacity usage is the sum of capacity usages of all intervals of a specific type (slot/symbol)
|
|
that share the instant of time at which instantaneous capacity usage is evaluated regardless of numerology.
|
|
* Capacity used in an interval is allocated at the start of the interval and is released at the end of the interval
|
|
(e.g. capacity used for symbol #N of numerology #M is unavailable during symbol #N and available for reuse after symbol #N ends).";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identifies type of endpoints sharing same properties. Values shall start with 0 and shall be allocated without gaps.";
|
|
}
|
|
|
|
list supported-section-types {
|
|
key "section-type";
|
|
description
|
|
"Indicates section types and extensions endpoints of this type support";
|
|
|
|
leaf section-type {
|
|
type uint8;
|
|
|
|
description
|
|
"This parameter determines the characteristics of U-plane data to be transferred or received from a beam with one pattern id.";
|
|
}
|
|
|
|
leaf-list supported-section-extensions {
|
|
type uint8;
|
|
|
|
description
|
|
"This parameter provides the extension types supported by the O-RU
|
|
which provides additional parameters specific to the subject data extension";
|
|
}
|
|
}
|
|
|
|
uses supported-section-type4-config {
|
|
if-feature feat:ST4-SLOT-CONFIG-MSG-SUPPORT;
|
|
}
|
|
|
|
leaf-list supported-frame-structures {
|
|
type uint8;
|
|
|
|
description
|
|
"List of supported values of frame structure. For semantic and allowed values see CUS-Plane Specification, clause '7.5.2.13 frameStructure (frame structure)'";
|
|
}
|
|
|
|
leaf managed-delay-support {
|
|
type enumeration {
|
|
enum MANAGED {
|
|
description
|
|
"Time managed delays are supported";
|
|
}
|
|
|
|
enum NON_MANAGED {
|
|
description
|
|
"Non time managed delays are supported";
|
|
}
|
|
|
|
enum BOTH {
|
|
description
|
|
"Both time managed and non time managed delays are supported";
|
|
}
|
|
}
|
|
|
|
description
|
|
"Type of delay supported by the endpoint";
|
|
}
|
|
|
|
leaf multiple-numerology-supported {
|
|
type boolean;
|
|
default true;
|
|
description
|
|
"Indicates whether the endpoint type supports multiple numerologies";
|
|
}
|
|
|
|
leaf max-numerology-change-duration {
|
|
type uint16 {
|
|
range "0..10000";
|
|
}
|
|
|
|
units Ts;
|
|
description
|
|
"Maximum gap of endpoint operation that will be caused by changing of
|
|
numerology.
|
|
|
|
This time is required for reconfiguration and flushing of pipes.
|
|
|
|
This leaf contains valid data only when multiple-numerology-supported
|
|
is set to true.";
|
|
}
|
|
|
|
uses endpoint-section-capacity;
|
|
uses endpoint-beam-capacity;
|
|
uses endpoint-prb-capacity;
|
|
uses endpoint-section-extension-limits;
|
|
|
|
leaf-list prb-capacity-allocation-granularity {
|
|
type uint16;
|
|
|
|
description
|
|
"List of capacity allocation steps. O-RU allocates PRB capacity rounding it up to nearest value N
|
|
from prb-capacity-allocation-granularity such that M >= number-of-prb-per-scs.
|
|
See also number-of-prb-per-scs/number-of-prb.";
|
|
}
|
|
|
|
uses endpoint-numerology-capacity;
|
|
|
|
leaf static-transmission-window-control-supported {
|
|
if-feature feat:STATIC-TRANSMISSION-WINDOW-CONTROL;
|
|
type boolean;
|
|
description
|
|
"Endpoint supports transmission-window-control = STATIC";
|
|
}
|
|
|
|
leaf uniformly-distributed-transmission-supported {
|
|
if-feature "feat:STATIC-TRANSMISSION-WINDOW-CONTROL and feat:UNIFORMLY-DISTRIBUTED-TRANSMISSION";
|
|
type boolean;
|
|
description
|
|
"Endpoint supports transmission-type = UNIFORMLY-DISTRIBUTED";
|
|
}
|
|
|
|
leaf ordered-transmission-supported {
|
|
if-feature feat:ORDERED-TRANSMISSION;
|
|
type boolean;
|
|
description
|
|
"Endpoint supports ordered transmission of U-plane messages
|
|
and can be configured with ordered-transmission = TRUE";
|
|
}
|
|
|
|
leaf dynamic-transmission-window-control-supported {
|
|
if-feature feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL;
|
|
type boolean;
|
|
description
|
|
"Endpoint supports U-plane transmission window control via C-plane
|
|
(supports transmission-window-control = DYNAMIC) with independent window offset and size per symbol";
|
|
}
|
|
|
|
leaf dynamic-transmission-window-control-per-section-supported {
|
|
when "../dynamic-transmission-window-control-supported = 'true'";
|
|
if-feature feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL;
|
|
type boolean;
|
|
description
|
|
"Endpoint supports U-plane transmission window control via C-plane
|
|
(supports transmission-window-control = DYNAMIC) with independent window offset and size per section";
|
|
}
|
|
|
|
leaf dynamic-uniformly-distributed-transmission-supported {
|
|
if-feature "feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL and feat:UNIFORMLY-DISTRIBUTED-TRANSMISSION";
|
|
type boolean;
|
|
description
|
|
"Endpoint supports U-plane transmission window control via C-plane
|
|
(supports transmission-window-control = DYNAMIC) with independent transmission type per symbol";
|
|
}
|
|
|
|
leaf dynamic-uniformly-distributed-transmission-per-section-supported {
|
|
when "../dynamic-uniformly-distributed-transmission-supported = 'true'";
|
|
type boolean;
|
|
description
|
|
"Endpoint supports U-plane transmission window control via C-plane
|
|
(supports transmission-window-control = DYNAMIC) with independent transmission type per section";
|
|
}
|
|
|
|
uses transmission-buffering-capacity {
|
|
when "static-transmission-window-control-supported = 'true' or dynamic-transmission-window-control-supported = 'true'";
|
|
if-feature "feat:STATIC-TRANSMISSION-WINDOW-CONTROL or feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL";
|
|
}
|
|
|
|
leaf cplane-message-processing-limits-required {
|
|
if-feature feat:CPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
type boolean;
|
|
config false;
|
|
description
|
|
"Endpoint requires applying C-Plane message processing limits defined in 'per-cplane-message-limits'.
|
|
and can be configured with cplane-message-processing-limits-enabled = TRUE";
|
|
}
|
|
|
|
uses per-cplane-message-limits {
|
|
when "cplane-message-processing-limits-required = 'true'";
|
|
if-feature feat:CPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
}
|
|
|
|
leaf uplane-message-processing-limits-required {
|
|
if-feature feat:UPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
type boolean;
|
|
config false;
|
|
description
|
|
"Endpoint has processing limits regarding U-Plane message. Detailed types of limits are defined in 'per-uplane-message-limits'.";
|
|
}
|
|
|
|
uses per-uplane-message-limits {
|
|
when "uplane-message-processing-limits-required = 'true'";
|
|
if-feature feat:UPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
}
|
|
|
|
leaf beam-update-contention-control-limits-required {
|
|
if-feature feat:BEAM-UPDATE-CONTENTION-CONTROL;
|
|
type boolean;
|
|
config false;
|
|
description
|
|
"Endpoint requires applying beam update contention control limits defined in 'beam-update-contention-control-limits'.
|
|
and can be configured with beam-update-contention-control-enabled = TRUE";
|
|
}
|
|
|
|
uses beam-update-contention-control-limits {
|
|
when "beam-update-contention-control-limits-required = 'true'";
|
|
if-feature feat:BEAM-UPDATE-CONTENTION-CONTROL;
|
|
}
|
|
|
|
leaf max-ack-nack-per-symbol {
|
|
type uint16;
|
|
description
|
|
"This value indicates the max number of ACK/NACK feedbacks supported by the endpoint in a symbol when
|
|
section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback) are supported by the endpoint.
|
|
The number of ACK/NACK feedbacks in a symbol is defined as the sum of 'numberofACKs' + 'numberofNACKs' in all C-Plane
|
|
messages sent by the endpoints in a symbol";
|
|
}
|
|
|
|
leaf non-scheduled-ueid-supported {
|
|
if-feature feat:NON-SCHEDULED-UEID;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"The parameter informs that the endpoint supports the capability of interpreting that those PRBs in the specified port are not allocated.
|
|
Please refer to CUS specification clause 7.9.13 for more details.";
|
|
}
|
|
|
|
leaf se-11-continuity-flag-supported {
|
|
if-feature feat:SE11-WITH-CONTINUITY-BIT-SUPPORT;
|
|
type boolean;
|
|
config false;
|
|
description
|
|
"This flag is applicable for 'static-low-level-tx-endpoints' which support Section Extension 11 (SE 11). The
|
|
O-RU may choose to indicate its support for handling continuity flag as defined in CUS-Plane Clause 7.7.11.9
|
|
by advertising this flag to TRUE/FALSE.
|
|
- Value of the flag advertised as 'TRUE' implies O-RU supports handling of 'continuity' flag in SE 11;
|
|
- Value of the flag advertised to 'FALSE' implies the O-RU does not support handling of 'continuity' flag in SE 11.";
|
|
}
|
|
|
|
leaf se-23-prb-block-mode-supported {
|
|
if-feature feat:SE23-PRB-BLOCK-MODE-SUPPORT;
|
|
type boolean;
|
|
config false;
|
|
description
|
|
"This flag is applicable for 'static-low-level-tx-endpoints' which support Section Extension 23 (SE 23). The
|
|
O-RU may choose to indicate its support for prbMode = PRB-BLOCK mode flag as defined in CUS-Plane Clause 7.7.23.1
|
|
by advertising this flag as TRUE/FALSE.
|
|
- Value of the flag advertised as 'TRUE' implies O-RU supports both prbMode = PRB-BLOCK mode of SE 23
|
|
and prbMode = PRB-MASK which is the default mode when SE-23 is used.
|
|
- Value of the flag advertised as 'FALSE' implies O-RU supports prbMode = PRB-MASK which is the
|
|
default mode when SE-23 is used and the O-RU does not support prbMode = PRB-BLOCK mode.";
|
|
}
|
|
|
|
leaf user-group-optimization-supported {
|
|
if-feature feat:USER-GROUP-OPTIMIZATION;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"The parameter indicates that if O-RU sets this feature flag to 'TRUE' for a given endpoint, and the O-DU chooses to
|
|
support this feature by setting 'user-group-optimization-enabled-tx' to 'TRUE' for static-low-level-tx-endpoints,
|
|
'user-group-optimization-enabled-rx' to 'TRUE' for static-low-level-rx-endpoints,then the O-DU shall be required
|
|
to send all layers for a given user group UEs i.e., UEs with same time-frequency allocation using single C-Plane
|
|
section description. refer to CUS-Plane specification clause 7.9.14.";
|
|
}
|
|
|
|
leaf se-20-multi-sd-punc-pattern-suported {
|
|
if-feature feat:SE20-MULTI-SD-PUNC-PATTERN-SUPPORT;
|
|
type boolean;
|
|
config false;
|
|
description
|
|
"This flag is applicable for 'static-low-level-[tr]x-endpoints' which support Section Estension 20 (SE-20).
|
|
The flag associated with each puncturing pattern in SE-20. The details of are defined in CUS-Plane Clause
|
|
7.7.20.1. The O-RU indicates support for this feature by advertising this flag as TRUE/FALSE.
|
|
- Value of the flag advertised as 'TRUE' indicates O-RU supports handling of 'multiSDScope' field in SE-20.
|
|
- Value of the flag advertised as 'FALSE' indicates O-RU does not supports handling of 'multiSDScope' field in SE-20.";
|
|
}
|
|
|
|
uses supported-configuration-combinations-grp;
|
|
|
|
leaf-list supported-filter-indices {
|
|
type uint32;
|
|
description
|
|
"The list of supported values of filterIndex.
|
|
An empty list means that the set of supported values of filterIndex is not constrained.";
|
|
}
|
|
|
|
leaf-list bf-profile-group {
|
|
if-feature feat:BF-DELAY-PROFILE;
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-bf-profile-group/bf-profile-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"List of beamforming method groups supported by the endpoint, and the related delay profile values.";
|
|
}
|
|
|
|
list supported-pass-band-for-filterindex09-per-scs {
|
|
key "scs";
|
|
config false;
|
|
|
|
description
|
|
"When filterIndex 0x9 is used, O-RU shall use minimum pass band filter among the reported passband filter sizes
|
|
that can accommodate the numPrbc and startPrbc of all the section descriptions associated with same frameStructure.
|
|
Please refer to CUS specification clause 7.5.2.3 for more details.";
|
|
|
|
leaf scs {
|
|
type mcap:scs-config-type;
|
|
description
|
|
"Value corresponds to SCS values defined for frameStructure in C-plane.";
|
|
}
|
|
|
|
leaf supported-max-num-msg-for-filterindex0x9-per-scs {
|
|
type uint16;
|
|
description
|
|
"Max number of filters can be actived at a time,
|
|
and this parameter limits the maximum number of ST3 mesaages with filterIndex set to 9 that O-DU can send so that the total number of filters active is below the maximum limit";
|
|
}
|
|
|
|
leaf-list filter-bandwidth {
|
|
type uint64;
|
|
units Hz;
|
|
description
|
|
"Bandwidth of a filter given in Hz.
|
|
If the list for the given SCS indicated via frameStructure is not empty,
|
|
O-DU should set filterIndex as 1001b for mixed numerology and other channels except PRACH and NB-IoT as specified in Table 7.5.2.3-1 when ST 3 C-plane message is used.";
|
|
|
|
}
|
|
}
|
|
|
|
container se24-dmrs-capabilities {
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
description
|
|
"Container collecting SE24 DMRS BF capabilties.
|
|
Please refer to CUS specification clause 7.7.24 for more details.";
|
|
|
|
leaf-list supported-entry-types {
|
|
type uint8;
|
|
description
|
|
"Supported values of entryType.";
|
|
}
|
|
leaf ue-time-partial-overlap-supported {
|
|
type boolean;
|
|
description
|
|
"Indicates if UE time partial overlap is supported.
|
|
See CUS-plane clause 12.6.1.2.1.";
|
|
}
|
|
leaf ue-freq-partial-overlap-supported {
|
|
type boolean;
|
|
description
|
|
"Indicates if UE frequency partial overlap is supported.
|
|
See CUS-plane clause 12.6.1.2.1.";
|
|
}
|
|
leaf max-user-groups-per-ue-in-time {
|
|
type uint16;
|
|
description
|
|
"The maximum supported number of user groups in time-domain per UE.
|
|
See CUS-plane clause 12.6.1.2.1";
|
|
}
|
|
leaf different-transform-precoding-in-user-group-supported {
|
|
type boolean;
|
|
description
|
|
"Indicates if different transform precoding in user group is supported.";
|
|
}
|
|
leaf different-cdm-without-data-in-user-group-supported {
|
|
type boolean;
|
|
description
|
|
"Indicates if different cdm without data in user group is supported.";
|
|
}
|
|
leaf max-dmrs-configs-per-user-group-incl-first-last-prb {
|
|
type uint32;
|
|
description
|
|
"Maximum number of different DMRS configurations (excluding differences in dmrsPortNumber) per user group,
|
|
including first and last PRB.";
|
|
}
|
|
|
|
leaf max-dmrs-configs-per-user-group-excl-first-last-prb {
|
|
type uint32;
|
|
description
|
|
"Maximum number of different DMRS configurations (excluding differences in dmrsPortNumber) per user group,
|
|
excluding first and last PRB.";
|
|
}
|
|
uses common-se24-dmrs-capabilities-grp;
|
|
grouping dmr-mask-capability-grp {
|
|
description
|
|
"Grouping of transform-precoding capabilities";
|
|
|
|
list dmrs-mask-capability {
|
|
key id;
|
|
description
|
|
"Parameters for DMRS mask capabilities";
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"An identifier of an entry in the list.";
|
|
}
|
|
leaf-list dmrs-symbol-mask {
|
|
type uint16;
|
|
description
|
|
"Supported DMRS symbol mask.
|
|
Empty list means all the possible symbol masks are supported.";
|
|
}
|
|
leaf max-dmrs-ant-port-number {
|
|
type uint32;
|
|
description
|
|
"Maximum DMRS antenna port number.";
|
|
}
|
|
leaf max-user-data-layers {
|
|
type uint32;
|
|
description
|
|
"Maximum number of user data layers";
|
|
}
|
|
}
|
|
}
|
|
container transform-precoding-enabled {
|
|
description
|
|
"Parameters for SE24 DMRS BF capabilities with transform precoding enabled";
|
|
uses dmr-mask-capability-grp;
|
|
list low-papr-config {
|
|
key id;
|
|
description
|
|
"Supported Low-PAPR configs";
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"An identifier of an entry in the list.";
|
|
}
|
|
leaf low-papr-type {
|
|
type uint16 {
|
|
range "0 .. 3";
|
|
}
|
|
description
|
|
"Supported values of lowPaprType";
|
|
}
|
|
leaf hopping-mode {
|
|
type uint16 {
|
|
range "0 .. 3";
|
|
}
|
|
description
|
|
"Supported values of hoppingMode";
|
|
}
|
|
}
|
|
}
|
|
container transform-precoding-disabled {
|
|
description
|
|
"Parameters for SE24 DMRS BF capabilities with transform precoding disabled";
|
|
uses dmr-mask-capability-grp;
|
|
list dmrs-config {
|
|
key id;
|
|
description
|
|
"Supported DMRS configs";
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"An identifier of an entry in the list.";
|
|
}
|
|
leaf d-type {
|
|
type uint16 {
|
|
range "0 .. 1";
|
|
}
|
|
description
|
|
"Supported values of dType.";
|
|
}
|
|
leaf pusch-dmrs-muxing-supported {
|
|
type boolean;
|
|
description
|
|
"Indicates if PUSCH DMRS muxing is supported.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
leaf sinr-reporting-supported {
|
|
if-feature feat:DMRS-BF-EQ;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Indicates if SINR reporting is supported.";
|
|
}
|
|
container sinr-reporting-capabilities {
|
|
when "../sinr-reporting-supported = 'true'";
|
|
if-feature feat:DMRS-BF-EQ;
|
|
description
|
|
"Container collecting parameters related to capabilities of SINR reporting";
|
|
leaf simultaneous-sinr-and-dmrs-sending-supported {
|
|
type boolean;
|
|
description
|
|
"Indicates if simultaneous SINR and DMRS sending is supported.";
|
|
}
|
|
list supported-sinr-resolutions {
|
|
key "id";
|
|
description
|
|
"The list of supported SINR reporting resolutions.
|
|
This entry is applicable if maximum number of data layers in any user group in any slot does not exceed value of max-data-layers.
|
|
|
|
Please refer to CUS specification clause 7.2.10 for more details.";
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identifies a supported SINR reporting resolution.";
|
|
}
|
|
leaf sinr-max-data-layers {
|
|
type uint8;
|
|
description
|
|
"The maximum number of data layers scheduled in any user group in a slot.";
|
|
}
|
|
leaf-list sinr-per-prb {
|
|
type uint8;
|
|
description
|
|
"List of supported values. Indicates number of SINR values per PRB.";
|
|
}
|
|
leaf-list sinr-slot-mask {
|
|
type uint16;
|
|
description
|
|
"List of bitmasks representing supported patterns of SINR reporting in time domain. An emplty list means that the set of supported SINR reporting is unrestricted.";
|
|
}
|
|
}
|
|
container supported-sinr-reference-level {
|
|
description
|
|
"Supported range of SINR reference levels values.
|
|
|
|
See CUS specification clause 7.2.10 for more details";
|
|
leaf sinr-reference-level-min {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
description
|
|
"Minimum supported SINR reference level.";
|
|
}
|
|
leaf sinr-reference-level-max {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
description
|
|
"Maximum supported SINR reference level.";
|
|
}
|
|
}
|
|
list supported-sinr-compression-methods {
|
|
key "id";
|
|
description
|
|
"The list of supported SINR compression methods.";
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identifies a supported SINR compression method.";
|
|
}
|
|
uses cf:sinr-compression-details;
|
|
}
|
|
}
|
|
container supported-symb-reorder-capabilities {
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
description
|
|
"List of capabilities related to symbol reordering.";
|
|
uses supported-symb-reorder-capability;
|
|
}
|
|
leaf-list supported-user-group-self-assembly-modes {
|
|
if-feature feat:USER-GROUP-SELF-ASSEMBLY;
|
|
type user-group-self-assembly-mode ;
|
|
description
|
|
"List of user group self assembly mode(s) supported by an endpoint. The O-RU may support SELF-ASSEMBLY-WITH-GROUP-ID and/or SELF-ASSEMBLY-WITHOUT-GROUP-ID.";
|
|
}
|
|
leaf-list continuity-block-sizes-supported {
|
|
if-feature "(feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ) and feat:CONTINUITY-BLOCK-SIZE";
|
|
type uint16;
|
|
description
|
|
"List of continuity bock sizes supported by the O-RU.";
|
|
}
|
|
leaf eq-scale-offset-min {
|
|
if-feature feat:DMRS-BF-EQ;
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
description
|
|
"Refer to cus specification 8.3.1.4, max value 0 dB";
|
|
}
|
|
leaf eq-scale-offset-max {
|
|
if-feature feat:DMRS-BF-EQ;
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
description
|
|
"Refer to cus specification 8.3.1.4, max value 0 dB";
|
|
}
|
|
leaf-list rrm-meas-supported {
|
|
if-feature feat:RRM-MEAS-REPORTING;
|
|
type rrm-meas-types;
|
|
description
|
|
"List of rrm types supported by the endpoint type";
|
|
}
|
|
leaf max-ipn-unalloc-reports-supported {
|
|
when "../rrm-meas-supported = 'MEAS-IPN-UNALLOC'";
|
|
if-feature feat:RRM-MEAS-REPORTING;
|
|
type uint16;
|
|
description
|
|
"This value indicates the maximum number of ipn unallocated measurement reports per PRB (PRB range) and slot";
|
|
}
|
|
leaf max-ipn-unalloc-symbols-supported {
|
|
when "../rrm-meas-supported = 'MEAS-IPN-UNALLOC'";
|
|
if-feature feat:RRM-MEAS-REPORTING;
|
|
type uint16;
|
|
description
|
|
"This parameter indicates maximum number of measured symbols of all measurement reports for a PRB (PRB range) in the slot ";
|
|
}
|
|
leaf max-ipn-alloc-reports-supported {
|
|
when "../rrm-meas-supported = 'MEAS-IPN-ALLOC'";
|
|
if-feature feat:RRM-MEAS-REPORTING;
|
|
type uint16;
|
|
description
|
|
"This value indicates the maximum number of ipn alloc measurement reports per PRB per slot. Relationship between this value and alloc-ipn-per-sym-supported can be found in CUS plan specification clause 9.2.2.4";
|
|
}
|
|
leaf-list alloc-ipn-per-dmrs-sym-grp-supported {
|
|
when "../rrm-meas-supported = 'MEAS-IPN-ALLOC'";
|
|
if-feature feat:RRM-MEAS-REPORTING;
|
|
type uint8 {
|
|
range "0 .. 1";
|
|
}
|
|
description
|
|
"This parameter indicates alloc-ipn measurement type(s) supported by the O-RU.
|
|
Refer to CUS specification clause 9.2.2.4 for details";
|
|
}
|
|
leaf se-10-bgt-11b-supported {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"The parameter is applicable for static-low-level-[tr]x-endpoints supporting Section Extension 10. This flag
|
|
if set to TRUE indicates that the O-RU advertised endpoint, supporting Section Extension 10 supports beamGroupType = 11b.
|
|
It is mandatory for endpoints supporting DMRS-BF-EQ/DMRS-BF-NEQ beamforming methods to support beamGroupType = 11b.
|
|
refer to CUS-Plane specification clause 7.7.10.1";
|
|
}
|
|
|
|
leaf-list se-27-odu-controlled-dimensionality-reduction-supported {
|
|
if-feature feat:SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION;
|
|
type enumeration {
|
|
enum STATIC {
|
|
description
|
|
"Static O-DU controlled dimnesionality reduction enabled.";
|
|
}
|
|
enum DYNAMIC {
|
|
description
|
|
"Dynamic O-DU controlled dimnesionality reduction enabled.";
|
|
}
|
|
}
|
|
description
|
|
"Supported type O-DU controlled dimensionality reduction using SE27.
|
|
Please refer to CUS specification clause 7.7.27 for more details.";
|
|
}
|
|
leaf se-27-omission-when-enabled-supported {
|
|
when "(../se-27-odu-controlled-dimensionality-reduction-supported = 'STATIC')
|
|
or (../se-27-odu-controlled-dimensionality-reduction-supported = 'DYNAMIC')";
|
|
if-feature feat:SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION;
|
|
type boolean;
|
|
description
|
|
"Indicates if O-RU supports omission of SE27 when O-DU controlled dimensionality reduction using SE27 is enabled.
|
|
Please refer to CUS specification clause 7.7.27 for more details.";
|
|
}
|
|
list supported-se-27-configurations {
|
|
when "(../se-27-odu-controlled-dimensionality-reduction-supported = 'STATIC')
|
|
or (../se-27-odu-controlled-dimensionality-reduction-supported = 'DYNAMIC')";
|
|
if-feature feat:SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION;
|
|
key number-of-ue-data-layers;
|
|
description
|
|
"List of supported values of numElements parameter per number of UE
|
|
data layers scheduled in user group.
|
|
Please refer to CUS specification clause 7.7.27 for more details.";
|
|
leaf number-of-ue-data-layers {
|
|
type uint16;
|
|
description
|
|
"Number of UE data layers scheduled in user group.";
|
|
}
|
|
leaf-list supported-se-27-num-elements {
|
|
type uint16;
|
|
description
|
|
"Supported values of numElements in SE27 for the provided number of UE data layers.";
|
|
}
|
|
}
|
|
}
|
|
|
|
list transmission-window-schedules {
|
|
if-feature feat:STATIC-TRANSMISSION-WINDOW-CONTROL;
|
|
key id;
|
|
description
|
|
"Parameters for scheduled UL U-plane message transmission (static transmission window control)";
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identifies a UL U-plane message transmission schedule";
|
|
}
|
|
list schedule {
|
|
key symbol;
|
|
description
|
|
"Defines transmission window offset for given symbol.
|
|
If no entry is present for a symbol then O-RU assumes offset=0 for that symbol.
|
|
Entries with offset=0 shall be omitted.";
|
|
leaf symbol {
|
|
type uint16;
|
|
description
|
|
"Number of a symbol within a frame for which transmission offset is given.";
|
|
}
|
|
leaf offset {
|
|
type uint16;
|
|
description
|
|
"Transmission window offset; expressed as number of symbols the transmission window start is delayed by.
|
|
This value is added to u-plane-transmission-control/transmission-window-offset.
|
|
For restrictions on value of offset see description of transmission-window-offset.";
|
|
}
|
|
}
|
|
}
|
|
|
|
list endpoint-capacity-sharing-groups {
|
|
key "id";
|
|
config false;
|
|
description
|
|
"Represents groups of endpoints that share capacity. Depending on O-RU implementation,
|
|
processing resources that handle CU-plane (e.g. memory to keep sections and beams)
|
|
could be allocated per endpoint or shared between several endpoints.
|
|
To address this O-RU shall report own capability per endpoint (see endpoint-types)
|
|
and per group of endpoints sharing capacity.
|
|
If endpoint is in multiple groups then resulting constraint is minimum over all groups.
|
|
Note: values of parameters representing capacity that is not shared between endpoints in a group
|
|
shall be set to max value of specific parameter; this effectively removes related constraint.
|
|
Note: For any endpoint supporting mixed numerology within slot/symbol (multiple-numerology-supported=TRUE)
|
|
* Interval specific (per-slot and per-symbol) capacity constraints instantaneous capacity usage
|
|
(i.e. capacity is shared/distributed between all numerologies used at an instant of time).
|
|
* Instantaneous capacity usage is the sum of capacity usages of all intervals of a specific type (slot/symbol)
|
|
that share the instant of time at which instantaneous capacity usage is evaluated regardless of numerology.
|
|
* Capacity used in an interval is allocated at the start of the interval and is released at the end of the interval
|
|
(e.g. capacity used for symbol #N of numerology #M is unavailable during symbol #N and available for reuse after symbol #N ends).";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identifies group of endpoints sharing resources.
|
|
Values shall start with 0 and shall be allocated without gaps.";
|
|
}
|
|
uses endpoint-section-capacity;
|
|
uses endpoint-beam-capacity;
|
|
uses endpoint-prb-capacity;
|
|
uses endpoint-numerology-capacity;
|
|
uses endpoint-section-extension-limits;
|
|
|
|
leaf max-endpoints {
|
|
type uint16;
|
|
description
|
|
"Indicates how many endpoints in the group can be used4 simultaneously";
|
|
}
|
|
leaf max-managed-delay-endpoints {
|
|
type uint16;
|
|
description
|
|
"Number of endpoints supporting managed delay that can be used (configured for use) at a time";
|
|
}
|
|
leaf max-non-managed-delay-endpoints {
|
|
type uint16;
|
|
description
|
|
"Number of endpoints supporting non-managed delay that can be used (configured for use) at a time";
|
|
}
|
|
uses transmission-buffering-capacity {
|
|
if-feature "feat:STATIC-TRANSMISSION-WINDOW-CONTROL or feat:DYNAMIC-TRANSMISSION-WINDOW-CONTROL";
|
|
}
|
|
|
|
uses per-cplane-message-limits {
|
|
if-feature feat:CPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
}
|
|
leaf max-ack-nack-per-symbol {
|
|
type uint16;
|
|
description
|
|
"This value indicates the max number of ACK/NACK feedbacks supported by the endpoint sharing group in a symbol when
|
|
section extension 22 (ACK/NACK request) and section type 8 (ACK/NACK feedback) are supported by the endpoint sharing group.
|
|
The number of ACK/NACK feedbacks in a symbol is defined as the sum of 'numberofACKs' + 'numberofNACKs' in all C-Plane
|
|
messages sent by the endpoints in group in a symbol";
|
|
}
|
|
uses supported-configuration-combinations-grp;
|
|
|
|
container se24-dmrs-capabilities {
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
description
|
|
"Container collecting SE24 DMRS BF capabilties.
|
|
Please refer to CUS specification clause 7.7.24 for more details.";
|
|
|
|
uses common-se24-dmrs-capabilities-grp;
|
|
}
|
|
}
|
|
|
|
list endpoint-prach-group {
|
|
key "id";
|
|
config false;
|
|
description
|
|
"Represents group of a series of PRACH preamble formats";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identifies group of PRACH preamble formats.";
|
|
}
|
|
|
|
leaf-list supported-prach-preamble-formats {
|
|
type prach-preamble-format;
|
|
min-elements 1;
|
|
description
|
|
"the list of PRACH preamble formats supported by the endpoint-type that is
|
|
applicable to static-low-level-rx-endpoints in the O-RU";
|
|
}
|
|
|
|
}
|
|
|
|
list supported-compression-method-sets {
|
|
key "id";
|
|
config false;
|
|
description
|
|
"List of available compression methods supported by device";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for compression method set";
|
|
}
|
|
|
|
list compression-method-supported {
|
|
uses cf:compression-method-grouping;
|
|
uses cf:compresion-format-grp {
|
|
status deprecated;
|
|
}
|
|
|
|
leaf-list fs-offset {
|
|
if-feature cf:CONFIGURABLE-FS-OFFSET;
|
|
type uint8;
|
|
default 0;
|
|
description
|
|
"Adjusts FS (full scale) value of IQ format relative to FS derived from unmodified IQ format.
|
|
Please refer to CU-Plane specification for details";
|
|
|
|
}
|
|
description
|
|
"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 particular endpoint";
|
|
}
|
|
}
|
|
|
|
grouping supported-configuration-combinations-grp {
|
|
description
|
|
"Grouping of supported freqOffset & PRB range combinations.";
|
|
|
|
list supported-configuration-combinations {
|
|
key "combination-id";
|
|
config false;
|
|
|
|
leaf combination-id {
|
|
type uint32;
|
|
description
|
|
"Identification number for a combination.";
|
|
}
|
|
|
|
list set {
|
|
key "set-id";
|
|
|
|
leaf set-id {
|
|
type uint32;
|
|
description
|
|
"Identification number for a set.";
|
|
}
|
|
|
|
leaf max-overlapping-instances {
|
|
type uint32;
|
|
description
|
|
"Max number of configs of the set that can be used at the same time.";
|
|
}
|
|
|
|
list config {
|
|
key "config-id";
|
|
|
|
leaf config-id {
|
|
type uint32;
|
|
description
|
|
"Identification number for a config.";
|
|
}
|
|
|
|
leaf-list scs {
|
|
type mcap:scs-config-type;
|
|
description
|
|
"Value corresponds to SCS values defined for frameStructure in C-plane.";
|
|
}
|
|
|
|
leaf-list carrier-types {
|
|
type enumeration {
|
|
enum NR {
|
|
description
|
|
"5G technology";
|
|
}
|
|
enum LTE {
|
|
description
|
|
"LTE technology";
|
|
}
|
|
enum DSS_LTE_NR {
|
|
if-feature mcap:DSS_LTE_NR;
|
|
description
|
|
"NR and LTE technologies in Dynamic Spectrum Sharing mode";
|
|
}
|
|
}
|
|
description
|
|
"Type of carrier. Indicates array-carrier technology.";
|
|
}
|
|
|
|
leaf filter-pass-bandwidth {
|
|
type uint64;
|
|
units Hz;
|
|
|
|
description
|
|
"Width of a filter given in Hz.
|
|
The filter center frequency is given in center-of-channel-bandwidth of an array carrier.
|
|
When filterIndex 0x9 is used, O-RU shall report all the passband filter bandwidth per scs using the list supported-pass-band-for-filterindex09-per-scs.";
|
|
}
|
|
|
|
leaf max-prb-range {
|
|
type uint32;
|
|
|
|
description
|
|
"Maximum frequency range of PRBs that may be requested per frequency offset. Either contiguously or non-contiguously.
|
|
Total number of PRBs requested per config shall not exceed this value.";
|
|
}
|
|
|
|
leaf center-from-freqoffset {
|
|
type boolean;
|
|
description
|
|
"This node allows to distinguish between combinations valid when
|
|
center-from-freqoffset-enabled is set to TRUE and combinations
|
|
valid when center-from-freqoffset-enabled is set to FALSE";
|
|
}
|
|
|
|
leaf-list supported-filter-indices {
|
|
type uint32;
|
|
description
|
|
"The list of supported values of filterIndex.
|
|
An empty list means that the set of supported values of filterIndex is constrained by the supported-filter-indices
|
|
provided in the endpoint type.";
|
|
}
|
|
|
|
description
|
|
"Supported freqOffset & PRB range configuration.
|
|
Configuration is an instance of processing output equivalent to single FFT operation.";
|
|
}
|
|
description
|
|
"Set of freqOffset & PRB range configurations that require same resource allocation.";
|
|
}
|
|
description
|
|
"List of supported combinations of freqOffset & PRB range configurations.
|
|
If a leaf is not present in a list element it implies there is no constraint on that particular
|
|
parameter for the configuration in question.";
|
|
}
|
|
leaf center-from-freqoffset-supported {
|
|
type boolean;
|
|
description
|
|
"Endpoint's support for autonomous center frequency (k0) calculation based on frequency offset.
|
|
This capability applies only to RX endpoints.";
|
|
}
|
|
}
|
|
|
|
grouping supported-symb-reorder-capability {
|
|
description
|
|
"List of capabilities related to symbol reordering.";
|
|
leaf-list supported-symb-reorder-capability {
|
|
type symb-reorder-capability;
|
|
description
|
|
"List of supported symbol reordering methods.";
|
|
}
|
|
leaf max-num-symbol-reordering-pattern-per-slot {
|
|
when "../supported-symb-reorder-capability = 'PER-SECTION-TX-WINDOW-REASSIGNMENT'";
|
|
type uint16;
|
|
description
|
|
"This parameter defines the maximum number of unique symbol reassignment patterns supported
|
|
per slot per rx-array-carrier, where a 'symbol reassignment pattern' comprises 14 symbol
|
|
numbers specifying an altered symbol order (using txWinForOnAirSymbol0~13). The maximum
|
|
value applies over all SE25 invocations, including when an SE25 invocation includes
|
|
multiple symbol reassignment patterns. Repeated invocations of a single symbol reassignment
|
|
pattern shall count as a single unique instance. When endpoints of different endpoint-types
|
|
with different values of this parameter are associated with an rx-array-carrier, then the
|
|
smallest of the values shall apply.";
|
|
}
|
|
leaf-list up-symbolId-type-supported {
|
|
type up-SymbolId-type;
|
|
description
|
|
"List of supported symbol reordering symbolId interpretation capability.";
|
|
}
|
|
}
|
|
|
|
list static-low-level-tx-endpoints {
|
|
key name;
|
|
config false;
|
|
description
|
|
"Object model for static-low-level-tx-endpoints configuration";
|
|
|
|
leaf name {
|
|
type string;
|
|
|
|
description
|
|
"Unique name of static-low-level-tx-endpoints object.";
|
|
}
|
|
|
|
leaf-list restricted-interfaces {
|
|
type leafref {
|
|
path "/if:interfaces/if:interface/if:name";
|
|
}
|
|
description
|
|
"Optionally used to indicate that a low-level link is constrained to operate only via a subset of the available interfaces.";
|
|
}
|
|
|
|
leaf array {
|
|
type leafref {
|
|
path "/user-plane-configuration/tx-arrays/name";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Contains distname of tx-arrays, particular low-level-tx-endpoints is in hardware dependency with.
|
|
Note: single instance of tx-arrays can be referenced by many instances of low-level-tx-endpoints
|
|
(e.g. to allow DU to handle multiple fronthauls and multiple component carriers).";
|
|
}
|
|
|
|
leaf endpoint-type {
|
|
type leafref {
|
|
path "../../endpoint-types/id";
|
|
}
|
|
|
|
description
|
|
"Reference to endpoint type capabilities list element supported by this endpoint";
|
|
}
|
|
|
|
leaf-list capacity-sharing-groups {
|
|
type leafref {
|
|
path "../../endpoint-capacity-sharing-groups/id";
|
|
}
|
|
|
|
description
|
|
"Reference to capacities of sharing-groups supported by this endpoint";
|
|
}
|
|
|
|
list supported-reference-level {
|
|
if-feature TX-REFERENCE-LEVEL;
|
|
key "id";
|
|
description
|
|
"Informs about supported ranges for gain reference level.";
|
|
|
|
leaf id {
|
|
type uint16;
|
|
description
|
|
"Identification number for particular range";
|
|
}
|
|
|
|
leaf min {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
description
|
|
"Minimum of supported gain reference level";
|
|
}
|
|
|
|
leaf max {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
description
|
|
"Maximum of supported gain reference level";
|
|
}
|
|
}
|
|
|
|
container compression {
|
|
description
|
|
"Container collecting compression related parameters.";
|
|
|
|
leaf dynamic-compression-supported {
|
|
type boolean;
|
|
|
|
description
|
|
"Informs if endpoint supports dynamic compression method";
|
|
}
|
|
|
|
leaf realtime-variable-bit-width-supported {
|
|
type boolean;
|
|
|
|
description
|
|
"Informs if endpoint supports real-time variable bit with";
|
|
}
|
|
|
|
leaf supported-compression-set-id {
|
|
type leafref {
|
|
path "../../../supported-compression-method-sets/id";
|
|
}
|
|
|
|
description
|
|
"Id of supported compression set for this endpoint";
|
|
}
|
|
}
|
|
|
|
uses endpoint-tdd-pattern-support;
|
|
|
|
leaf-list energy-sharing-group-id {
|
|
if-feature feat:MPLANE-DATA-LAYER-CONTROL;
|
|
type uint8;
|
|
description
|
|
"This value indicates a group of common underlying HW that can be used for energy savings.";
|
|
}
|
|
leaf se10-member-candidate-list {
|
|
if-feature feat:SE10-MEMBER-CANDIDATE-LIST;
|
|
type leafref {
|
|
path "/user-plane-configuration/se10-member-candidate-tx-lists/id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"This parameter is a pointer to a given member-candidate list entry in 'se10-member-candidate-tx-lists'.
|
|
This parameter shall be applicable for endpoints supporting Section Extension 10";
|
|
}
|
|
}
|
|
|
|
list static-low-level-rx-endpoints {
|
|
key name;
|
|
config false;
|
|
description
|
|
"Object model for static-low-level-rx-endpoints configuration";
|
|
|
|
leaf name {
|
|
type string;
|
|
|
|
description
|
|
"Unique name of static-low-level-rx-endpoints object.";
|
|
}
|
|
|
|
leaf-list restricted-interfaces {
|
|
type leafref {
|
|
path "/if:interfaces/if:interface/if:name";
|
|
}
|
|
description
|
|
"Optionally used to indicate that a low-level link is constrained to operate only via a subset of the available interfaces.";
|
|
}
|
|
|
|
leaf array {
|
|
type leafref {
|
|
path "/user-plane-configuration/rx-arrays/name";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Contains distname of rx-arrays, particular low-level-rx-endpoints is in hardware dependency with.
|
|
Note: single instance of rx-arrays can be referenced by many instances of low-level-rx-endpoints
|
|
(e.g. to allow DU to handle multiple fronthauls and multiple component carriers).";
|
|
}
|
|
|
|
leaf endpoint-type {
|
|
type leafref {
|
|
path "../../endpoint-types/id";
|
|
}
|
|
|
|
description
|
|
"Reference to endpoint type capabilities list element supported by this endpoint";
|
|
}
|
|
|
|
leaf-list capacity-sharing-groups {
|
|
type leafref {
|
|
path "../../endpoint-capacity-sharing-groups/id";
|
|
}
|
|
|
|
description
|
|
"Reference to capacities of sharing-groups supported by this endpoint";
|
|
}
|
|
|
|
leaf prach-group {
|
|
type leafref {
|
|
path "../../endpoint-prach-group/id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"An optional leaf used for those rx endpoints that support PRACH, indicating
|
|
the group id describing the set of of PRACH preambles supported";
|
|
}
|
|
|
|
container compression {
|
|
description
|
|
"Container collecting compression related parameters.";
|
|
|
|
leaf dynamic-compression-supported {
|
|
type boolean;
|
|
|
|
description
|
|
"Informs if endpoint supports dynamic compression method";
|
|
}
|
|
|
|
leaf realtime-variable-bit-width-supported {
|
|
type boolean;
|
|
|
|
description
|
|
"Informs if endpoint supports real-time variable bit with";
|
|
}
|
|
|
|
leaf supported-compression-set-id {
|
|
type leafref {
|
|
path "../../../supported-compression-method-sets/id";
|
|
}
|
|
|
|
description
|
|
"Id of supported compression set for this endpoint";
|
|
}
|
|
}
|
|
|
|
uses endpoint-static-config-support;
|
|
|
|
uses endpoint-tdd-pattern-support;
|
|
|
|
leaf transmission-order {
|
|
when "(/user-plane-configuration/endpoint-types[id=current()/../endpoint-type]/ordered-transmission-supported = 'true')";
|
|
if-feature feat:ORDERED-TRANSMISSION;
|
|
type uint32;
|
|
description
|
|
"The value indicates relative order of sending U-plane messages specific to same symbol
|
|
and transmission window by two endpoints with ordered-transmission = TRUE
|
|
belonging to the same transmission-order-group;
|
|
multiple endpoints may report the same value if their relative sending order is not guaranteed";
|
|
}
|
|
|
|
leaf transmission-order-group {
|
|
when "(/user-plane-configuration/endpoint-types[id=current()/../endpoint-type]/ordered-transmission-supported = 'true')";
|
|
if-feature feat:ORDERED-TRANSMISSION;
|
|
type uint32;
|
|
description
|
|
"The value indicates a group of endpoints that preserve relative ordering of message sending;
|
|
message sending between endpoints in different groups is not guaranteed";
|
|
}
|
|
|
|
leaf-list energy-sharing-group-id {
|
|
if-feature feat:MPLANE-DATA-LAYER-CONTROL;
|
|
type uint8;
|
|
description
|
|
"This value indicates a group of common underlying HW that can be used for energy savings.";
|
|
}
|
|
leaf se10-member-candidate-list {
|
|
if-feature feat:SE10-MEMBER-CANDIDATE-LIST;
|
|
type leafref {
|
|
path "/user-plane-configuration/se10-member-candidate-rx-lists/id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"This parameter is a pointer to a given member-candidate list entry in 'se10-member-candidate-rx-lists'.
|
|
This parameter shall be applicable for endpoints supporting Section Extension 10";
|
|
}
|
|
}
|
|
|
|
list low-level-tx-endpoints {
|
|
key "name";
|
|
|
|
description
|
|
"Object model for low-level-tx-endpoints configuration - augmented static-low-level-tx-endpoints by local-address
|
|
which cannot be added to static low-level-tx-endpoints as we cannot have modifiable element in static object";
|
|
|
|
leaf name {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-tx-endpoints/name";
|
|
require-instance false;
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"Unique name of low-level-tx-endpoint object. Reference to static 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
|
|
"An optional shared resource operator associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a low-level-tx-endpoint
|
|
associated with a shared resource operator where the sro-id identifies
|
|
a specific shared resource operator.
|
|
This schema-node is used to refine NACM privileges for shared
|
|
resource operators";
|
|
}
|
|
|
|
|
|
uses tx-endpoint-compression-grouping;
|
|
uses scs-config;
|
|
|
|
container e-axcid {
|
|
uses eaxc;
|
|
|
|
description
|
|
"Contains local address of low level TX endpoint offered by NETCONF server.";
|
|
}
|
|
|
|
uses coupling-methods;
|
|
|
|
leaf configurable-tdd-pattern-supported {
|
|
if-feature mcap:CONFIGURABLE-TDD-PATTERN-SUPPORTED;
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-tx-endpoints[name=current()/../name]/configurable-tdd-pattern-supported";
|
|
require-instance false;
|
|
}
|
|
description "RO to RW parameter mapping - needed for conditional under tx-array-carrier";
|
|
}
|
|
|
|
leaf cplane-message-processing-limits-enabled {
|
|
if-feature feat:CPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"TRUE: O-DU shall support the C-Plane message processing limits and has selected to adhere to the C-Plane limits defined in 'per-cplane-message-limits'.
|
|
FALSE: O-DU shall not support C-Plane message processing limits and endpoint limits defined in 'per-cplane-message-limits' shall not apply";
|
|
}
|
|
|
|
leaf uplane-message-section-header-limit-enabled {
|
|
if-feature feat:UPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"O-DU declares to obey the limit exposed via the leaf max-section-headers-per-uplane-message by setting this parameter to 'true'.
|
|
For details of this parameter's usage, please refer to M-plane spec clause 15.10";
|
|
}
|
|
|
|
leaf beam-update-contention-control-enabled {
|
|
if-feature feat:BEAM-UPDATE-CONTENTION-CONTROL;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"TRUE: O-DU shall support beam update contention control feature of O-RU.Thus requiring O-DU to comply with beam
|
|
updates restrictions defined in CUS-Plane Spec Section 'Weight-based dynamic beamforming'. In this case applicable
|
|
beam limits defined in 'beam-update-contention-control-limits' shall apply.
|
|
FALSE: O-DU shall not support beam update contention control feature of O-RU. Applicable beam limits defined in
|
|
'endpoint-beam-capacity' shall apply";
|
|
}
|
|
|
|
container channel-information-prb-group-configuration {
|
|
if-feature feat:CHANNEL-INFORMATION-PRB-GROUP;
|
|
description
|
|
"Container for configurable parameters for channel information prb group";
|
|
|
|
leaf enable-ci-prb-group {
|
|
type boolean;
|
|
description
|
|
"Informs whether or not to enable channel information PRB group in the O-RU,
|
|
if its value is set to true, the O-RU shall receive and process channel
|
|
information (e.g., ST6) with PRB group size of configured ci-prb-group-size.";
|
|
}
|
|
|
|
leaf ci-prb-group-size {
|
|
type uint8 {
|
|
range "2..254";
|
|
}
|
|
description
|
|
"The configured channel information PRB group size.
|
|
If enable-ci-prb-group is configured as TRUE, and the IE ciPrbGroupSize doesn't exist in a section description for channel information,
|
|
the parameter ci-prb-group-size shall be used for this section description.
|
|
If the IE ciPrbGroupSize exists in a section description for channel information,
|
|
no matter whether enable-ci-prb-group is configured as TRUE, the IE ciPrbGroupSize shall be used for this section description.";
|
|
}
|
|
}
|
|
|
|
leaf non-scheduled-ueid-enabled{
|
|
if-feature feat:NON-SCHEDULED-UEID;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"If O-DU configures 'non-scheduled-ueid-enabled' = TRUE,
|
|
and Section Extension 10 is applied to Section Types 5 and beamGroupType = 10b,
|
|
and the O-DU set ueId of a port in Section Extension 10 to 0x7FFF,
|
|
the endpoint shall interpret that the PRBs in the section description are not scheduled for this port.
|
|
The endpoint only interprets this leaf if non-scheduled-ueid-supported = true is reported in the related static endpoint, in other cases this leaf is ignored.
|
|
Please refer to CUS specification clause 7.9.13 for more details.";
|
|
}
|
|
|
|
leaf se-11-continuity-flag-enabled {
|
|
if-feature feat:SE11-WITH-CONTINUITY-BIT-SUPPORT;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"By setting the value of this leaf node to TRUE, the O-DU declares it will provide 'continuity' flag information in SE 11.
|
|
In this case the O-DU shall provide PRB region 'continuity' information in every SE 11 sent to the applicable low-level-tx-endpoint(s)
|
|
(static-low-level-tx-endpoit(s) which indicated support of this feature by setting 'se-11-continuity-flag-supported' flag to TRUE).
|
|
In case
|
|
- O-DU is running SW conformant to older O_RAN release and does not interpret the flag 'se11-continuity-bit-enabled' or
|
|
- the O-DU sets 'se11-continuity-flag-enabled' = FALSE,
|
|
no information regarding PRB region continuity is sent to the O-RU. In such case the O-RU shall process the PRB bundles as
|
|
it would have in the absence of the 'continuity' flag in SE11.
|
|
This behavior shall be same as when O-RU receives message with 'reserved' field value set to '0b'.";
|
|
}
|
|
|
|
leaf prg-size-supp-se-21-with-st6-enabled {
|
|
if-feature feat:PRG-SIZE-SUPP-SE-21-WITH-ST6;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"TRUE: O-DU shall send prgSize information from the O-DU to the O-RU as described in Clause 7.7.2.3.1 of the CUS-Plane spec.
|
|
FALSE:prgSize information cannot be sent from the O-DU to the O-RU using Section Type 6.";
|
|
}
|
|
|
|
leaf prg-size-supp-se-21-with-st5-enabled {
|
|
if-feature feat:PRG-SIZE-SUPP-SE-21-WITH-ST5;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"TRUE: O-DU shall send prgSize information from the O-DU to the O-RU as described in Clause 7.7.2.3.2 of the CUS-Plane spec.
|
|
FALSE:prgSize information cannot be sent from the O-DU to the O-RU using Section Type 5.";
|
|
}
|
|
|
|
leaf user-group-optimization-enabled-tx {
|
|
if-feature feat:USER-GROUP-OPTIMIZATION;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"The parameter indicates that if the O-RU advertises the feature flag to 'user-group-optimization-supported' set to
|
|
TRUE for associated static-level-tx-endpoint, the O-DU may choose to set this flag to 'TRUE' or 'FALSE'.
|
|
- If set to 'TRUE', the O-DU shall be required to send all layers for a given user group UEs i.e., UEs with same
|
|
time-frequency allocation using single C-Plane section description.
|
|
- If set to 'FALSE', the O-DU restriction to send all layers for a given user group UEs shall not apply.";
|
|
}
|
|
|
|
leaf se-20-multi-sd-punc-pattern-enabled-tx {
|
|
if-feature feat:SE20-MULTI-SD-PUNC-PATTERN-SUPPORT;
|
|
if-feature feat:USER-GROUP-OPTIMIZATION;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"This flag is applicable for O-RU adevertised static-level-tx-endpoint advertises for which
|
|
'se-20-multi-sd-punc-pattern-suported' = TRUE. The flag is configured by the O-DU to TRUE/FALSE.
|
|
- Value of the flag set to 'TRUE' indicates O-DU shall set the value 'multiSDScope' in SE-20 to TRUE/FALSE.
|
|
- Value of the flag set to 'FALSE' indicates O-DU shall not set the value 'multiSDScope' in SE-20. The corresponding
|
|
fields shall be interpretted as reserved field by the O-RU.";
|
|
}
|
|
|
|
container combination-configuration {
|
|
leaf endpoint-type {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-tx-endpoints[name=current()/../../name]/endpoint-type";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Leafref to the endpoint-type of the endpoint.";
|
|
}
|
|
|
|
leaf combination-id {
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types[id = current()/../endpoint-type]/supported-configuration-combinations/combination-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"A parameter describing which configuration combination will be used by the endpoint.";
|
|
}
|
|
|
|
list configurations {
|
|
key id;
|
|
|
|
leaf id {
|
|
type uint32;
|
|
description
|
|
"Identifier of an entry in the list";
|
|
}
|
|
|
|
leaf set-id {
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types[id = current()/../../endpoint-type]/supported-configuration-combinations[combination-id = current()/../../combination-id]/set/set-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"A parameter describing which set will be used by the endpoint.";
|
|
}
|
|
|
|
leaf config-id {
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types[id = current()/../../endpoint-type]/supported-configuration-combinations[combination-id = current()/../../combination-id]/set[set-id = current()/../set-id]/config/config-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"A parameter describing which config will be used by the endpoint.";
|
|
}
|
|
|
|
description
|
|
"An optional list describing which configurations will be used by the endpoint.
|
|
The list can be provided by an O-DU, so that an O-RU can optimize the processing in the endpoint.
|
|
If the list is empty, then O-DU intends to use every capability within combination identified by combination-id.";
|
|
}
|
|
|
|
description
|
|
"An optional container describing which configuration combination will be used by the endpoint.
|
|
The container can be provided by an O-DU, so that an O-RU can optimize the processing in the endpoint.";
|
|
}
|
|
|
|
leaf configured-bf-profile-id {
|
|
if-feature feat:BF-DELAY-PROFILE;
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types/bf-profile-group";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Configure the beamforming method list and related delay profiles will be used by the endpoint.
|
|
The configured-bf-profile-id must be one of the supported bf-profile-id(s) reported by the endpiont-type related to the endpoint.
|
|
If O-DU does not set configured-bf-profile-id, the O-RU shall not support the feature.";
|
|
}
|
|
|
|
leaf-list bf-methods {
|
|
if-feature "feat:SELECTED-BF-METHOD-CONFIGURATION and feat:BF-DELAY-PROFILE";
|
|
type beamforming-method-type;
|
|
description
|
|
"Beamforming method(s) configured on the endpoint.
|
|
|
|
If the value of configured-bf-profile-id is set, then beamforming method(s) configured on the endpoint shall
|
|
be selected from the set of supported beamforming methods of the selected endpoint-bf-profile-group
|
|
Otherwise, the beamforming method(s) configured on the endpoint shall be selected from the set of supported
|
|
beamforming methods reported in the related endpoint-bf-profile-group(s).";
|
|
}
|
|
}
|
|
|
|
list low-level-rx-endpoints {
|
|
key name;
|
|
|
|
description
|
|
"Object model for low-level-rx-endpoint configuration - augmented static-low-level-rx-endpoints by local-address
|
|
which cannot be added to static low-level-rx-endpoints as we cannot have modifiable element in static object";
|
|
|
|
leaf name {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-rx-endpoints/name";
|
|
require-instance false;
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"Unique name of low-level-rx-endpoint object. Reference to static 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
|
|
"An optional shared resource operator associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a low-level-rx-endpoint
|
|
associated with a shared resource operator where the sro-id identifies
|
|
a specific shared resource operator.
|
|
This schema-node is used to refine NACM privileges for shared
|
|
resource operators";
|
|
}
|
|
|
|
uses rx-endpoint-compression-grouping;
|
|
uses scs-config;
|
|
|
|
list ul-fft-sampling-offsets {
|
|
key scs;
|
|
description
|
|
"List of FFT sampling offsets configured for each SCS that will be used.
|
|
Client shall configure one element for each SCS that will be used.";
|
|
|
|
leaf scs {
|
|
type mcap:scs-config-type;
|
|
description
|
|
"Value corresponds to SCS values defined for frameStructure in C-plane
|
|
Note: set of allowed values is restricted by SCS derived from values in supported-frame-structures.";
|
|
}
|
|
|
|
leaf ul-fft-sampling-offset {
|
|
type uint16;
|
|
|
|
units Ts;
|
|
description
|
|
"Determines time advance of capture window for FFT.
|
|
Value represents time advance of capture window start in relation to the end of CP. Unit is Ts.
|
|
The value of this parameter shall not be larger than the duration of the cyclic prefix; in case of
|
|
variability of the cyclic prefix duration, the limit is the shortest duration of the cyclic prefix in use.
|
|
Note: value of this parameter is usually set to '0' (zero) for PRACH channels.
|
|
Any phase offset resulting from the non-zero value of this parameter is handled in O-DU.
|
|
Please refer to the O-RAN CUS-Plane, clause 4.4.3 for more details on the intended usage and value restrictions.";
|
|
}
|
|
}
|
|
|
|
container e-axcid {
|
|
uses eaxc;
|
|
|
|
description
|
|
"Contains local address of low level RX endpoint offered by NETCONF server.";
|
|
}
|
|
|
|
leaf eaxc-gain-correction {
|
|
if-feature EAXC-GAIN-CORRECTION;
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
default 0;
|
|
description
|
|
"eAxC specific part of overall gain_correction.
|
|
gain_correction = common array-carrier gain-correction + eAxC-gain-correction.";
|
|
}
|
|
|
|
leaf non-time-managed-delay-enabled {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Tells if non time managed delay shall be enabled";
|
|
}
|
|
|
|
uses coupling-methods;
|
|
|
|
leaf static-config-supported {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-rx-endpoints[name=current()/../name]/static-config-supported";
|
|
require-instance false;
|
|
}
|
|
description "RO to RW parameter mapping - for further conditionals";
|
|
}
|
|
|
|
leaf static-prach-configuration {
|
|
when "(/user-plane-configuration/low-level-rx-endpoints[name=current()/../name]/static-config-supported = 'PRACH')";
|
|
if-feature mcap:PRACH-STATIC-CONFIGURATION-SUPPORTED;
|
|
type leafref {
|
|
path "/user-plane-configuration/static-prach-configurations/static-prach-config-id";
|
|
}
|
|
description
|
|
"This parameter creates reference to static PRACH configuration applicable for particular endpoint";
|
|
}
|
|
|
|
leaf static-srs-configuration {
|
|
when "(/user-plane-configuration/low-level-rx-endpoints[name=current()/../name]/static-config-supported = 'SRS')";
|
|
if-feature mcap:SRS-STATIC-CONFIGURATION-SUPPORTED;
|
|
type leafref {
|
|
path "/user-plane-configuration/static-srs-configurations/static-srs-config-id";
|
|
}
|
|
description
|
|
"This parameter creates reference to static SRS configuration applicable for particular endpoint";
|
|
}
|
|
|
|
leaf configurable-tdd-pattern-supported {
|
|
if-feature mcap:CONFIGURABLE-TDD-PATTERN-SUPPORTED;
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-rx-endpoints[name=current()/../name]/configurable-tdd-pattern-supported";
|
|
require-instance false;
|
|
}
|
|
description "RO to RW parameter mapping - needed for conditional under rx-array-carrier";
|
|
}
|
|
|
|
uses u-plane-transmission-control;
|
|
|
|
leaf ordered-transmission {
|
|
if-feature feat:ORDERED-TRANSMISSION;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Commands O-RU to order UL U-plane message transmission between endpoints
|
|
Meaningless when ordered transmission is not supported for particular endpoint.";
|
|
}
|
|
|
|
leaf cplane-message-processing-limits-enabled {
|
|
if-feature feat:CPLANE-MESSAGE-PROCESSING-LIMITS;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"TRUE: O-DU shall support C-Plane message processing limits and has selected to adhere
|
|
to the C-Plane limits defined in 'per-cplane-message-limits'.
|
|
FALSE: O-DU shall not support C-Plane message processing limits and hence C-Plane and
|
|
endpoint limits defined in 'per-cplane-message-limits' shall not apply";
|
|
}
|
|
|
|
leaf beam-update-contention-control-enabled {
|
|
if-feature feat:BEAM-UPDATE-CONTENTION-CONTROL;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"TRUE: O-DU shall support beam update contention control feature of O-RU.Thus requiring O-DU to comply with beam
|
|
updates restrictions defined in CUS-Plane Spec Section 'Weight-based dynamic beamforming'. In this case applicable
|
|
beam limits defined in 'beam-update-contention-control-limits' shall apply.
|
|
FALSE: O-DU shall not support beam update contention control feature of O-RU. Applicable beam limits defined in
|
|
'endpoint-beam-capacity' shall apply";
|
|
}
|
|
|
|
leaf non-scheduled-ueid-enabled{
|
|
if-feature feat:NON-SCHEDULED-UEID;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"If O-DU configures 'non-scheduled-ueid-enabled' = TRUE,
|
|
and Section Extension 10 is applied to Section Types 5 and beamGroupType = 10b,
|
|
and the O-DU set ueId of a port in Section Extension 10 to 0x7FFF,
|
|
the endpoint shall interpret that the PRBs in the section description are not scheduled for this port.
|
|
The endpoint only interprets this leaf if non-scheduled-ueid-supported = true is reported in the related static endpoint, in other cases this leaf is ignored.
|
|
Please refer to CUS specification clause 7.9.13 for more details.";
|
|
}
|
|
|
|
leaf center-from-freqoffset-enabled {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Endpoint is enabled / prohibited to autonomously calculate center frequency based on frequency offset.";
|
|
}
|
|
|
|
leaf user-group-optimization-enabled-rx{
|
|
if-feature feat:USER-GROUP-OPTIMIZATION;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"The parameter indicates that if the O-RU advertises the feature flag to 'user-group-optimization-supported' set to
|
|
TRUE for associated static-level-rx-endpoint, the O-DU may choose to set this flag to 'TRUE' or 'FALSE'.
|
|
- If set to 'TRUE', the O-DU shall be required to send all layers for a given user group UEs i.e.,
|
|
UEs with same time-frequency allocation using single C-Plane section description.
|
|
- If set to 'FALSE', the O-DU restriction to send all layers for a given user group UEs shall not apply.";
|
|
}
|
|
|
|
leaf se-20-multi-sd-punc-pattern-enabled-rx {
|
|
if-feature feat:SE20-MULTI-SD-PUNC-PATTERN-SUPPORT;
|
|
if-feature feat:USER-GROUP-OPTIMIZATION;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"This flag is applicable for O-RU adevertised static-level-rx-endpoint advertises for which
|
|
'se-20-multi-sd-punc-pattern-suported' = TRUE. The flag is configured by the O-DU to TRUE/FALSE.
|
|
- Value of the flag set to 'TRUE' indicates O-DU shall set the value 'multiSDScope' in SE-20 to TRUE/FALSE.
|
|
- Value of the flag set to 'FALSE' indicates O-DU shall not set the value 'multiSDScope' in SE-20. The corresponding
|
|
fields shall be interpretted as reserved field by the O-RU.";
|
|
}
|
|
|
|
container combination-configuration {
|
|
leaf endpoint-type {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-rx-endpoints[name=current()/../../name]/endpoint-type";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Leafref to the endpoint-type of the endpoint.";
|
|
}
|
|
|
|
leaf combination-id {
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types[id = current()/../endpoint-type]/supported-configuration-combinations/combination-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"A parameter describing which configuration combination will be used by the endpoint.";
|
|
}
|
|
|
|
list configurations {
|
|
key id;
|
|
|
|
leaf id {
|
|
type uint32;
|
|
description
|
|
"Identifier of an entry in the list";
|
|
}
|
|
|
|
leaf set-id {
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types[id = current()/../../endpoint-type]/supported-configuration-combinations[combination-id = current()/../../combination-id]/set/set-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"A parameter describing which set will be used by the endpoint.";
|
|
}
|
|
|
|
leaf config-id {
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types[id = current()/../../endpoint-type]/supported-configuration-combinations[combination-id = current()/../../combination-id]/set[set-id = current()/../set-id]/config/config-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"A parameter describing which config will be used by the endpoint.";
|
|
}
|
|
|
|
description
|
|
"An optional list describing which configurations will be used by the endpoint.
|
|
The list can be provided by an O-DU, so that an O-RU can optimize the processing in the endpoint.";
|
|
|
|
}
|
|
|
|
description
|
|
"An optional container describing which configuration combination will be used by the endpoint.
|
|
The container can be provided by an O-DU, so that an O-RU can optimize the processing in the endpoint.";
|
|
}
|
|
|
|
leaf configured-bf-profile-id {
|
|
if-feature feat:BF-DELAY-PROFILE;
|
|
type leafref {
|
|
path "/user-plane-configuration/endpoint-types/bf-profile-group";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Configure which beamforming method list and related delay profile will be used by the endpoint.
|
|
The configured-bf-profile-id must be one of the supported bf-profile-id(s) reported by the endpiont-type related to the endpoint.
|
|
If O-DU does not set configured-bf-profile-id, the O-RU shall not support the feature.";
|
|
}
|
|
|
|
leaf sinr-reporting-enabled {
|
|
if-feature feat:DMRS-BF-EQ;
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Enables SINR reporting for the endpoint.";
|
|
}
|
|
|
|
container sinr-reporting-configuration {
|
|
when "../sinr-reporting-enabled = 'true'";
|
|
if-feature feat:DMRS-BF-EQ;
|
|
description
|
|
"Container collecting parameters related to configuration of SINR reporting";
|
|
|
|
container sinr-resolution {
|
|
description
|
|
"Container collecting parameters related to configuration of SINR reporting
|
|
resolution.
|
|
Supported values are constrained by the values reported in endpoint-types/supported-sinr-resolutions.
|
|
|
|
Please refer to CUS specification clause 7.2.10 for more details.";
|
|
leaf sinr-per-prb {
|
|
type uint8;
|
|
description
|
|
"Number of SINR values per PRB.";
|
|
}
|
|
leaf sinr-slot-mask {
|
|
type uint16;
|
|
description
|
|
"Pattern of SINR reports represented as a bitmask.";
|
|
}
|
|
}
|
|
container sinr-compression {
|
|
description
|
|
"Configuration of SINR compression.";
|
|
uses cf:sinr-compression-details;
|
|
leaf sinr-reference-level-config {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
description
|
|
"SINR reference level.";
|
|
}
|
|
|
|
leaf sinr-reference-level-used {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
config false;
|
|
description
|
|
"SINR reference level used. This parameter shall be the O-RU's best approximation of the sinr-reference-level-config.";
|
|
}
|
|
}
|
|
}
|
|
leaf se26-usage-enabled {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"When se26-usage-enabled = FALSE, O-DU shall not use SE 26 and shall not convey UE frequency offset information.
|
|
When se26-usage-enabled = TRUE, O-DU may convey UE frequency offset information via SE 26.";
|
|
}
|
|
|
|
leaf-list bf-methods {
|
|
if-feature "feat:SELECTED-BF-METHOD-CONFIGURATION and feat:BF-DELAY-PROFILE";
|
|
type beamforming-method-type;
|
|
description
|
|
"Beamforming method(s) configured on the endpoint.
|
|
|
|
If the value of configured-bf-profile-id is set, then beamforming method(s) configured on the endpoint shall
|
|
be selected from the set of supported beamforming methods of the selected endpoint-bf-profile-group
|
|
Otherwise, the beamforming method(s) configured on the endpoint shall be selected from the set of supported
|
|
beamforming methods reported in the related endpoint-bf-profile-group(s).";
|
|
}
|
|
leaf eq-scale-offset-config {
|
|
if-feature "feat:DMRS-BF-EQ";
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
description
|
|
"scale offset is configured by the O-DU to avoid overflow when encoding data for the fronthaul interface.Refer to cus specification clause 8.1.3.4 for details.";
|
|
}
|
|
leaf eq-scale-offset-used {
|
|
if-feature "feat:DMRS-BF-EQ";
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
config false;
|
|
description
|
|
"scale offset is used by the O-RU to avoid overflow when encoding data for the fronthaul interface.Refer to cus specification clause 8.1.3.4 for details.";
|
|
}
|
|
leaf-list rrm-meas-enabled {
|
|
if-feature feat:RRM-MEAS-REPORTING;
|
|
type rrm-meas-types;
|
|
description
|
|
"This parameter indicates which rrm measurements are enabled for this low level endpoint";
|
|
}
|
|
|
|
leaf se-27-odu-controlled-dimensionality-reduction-enabled {
|
|
if-feature feat:SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION;
|
|
type enumeration {
|
|
enum DISABLED {
|
|
description
|
|
"O-DU controlled dimnesionality reduction disabled.";
|
|
}
|
|
enum STATIC {
|
|
description
|
|
"Static O-DU controlled dimnesionality reduction enabled.";
|
|
}
|
|
enum DYNAMIC {
|
|
description
|
|
"Dynamic O-DU controlled dimnesionality reduction enabled.";
|
|
}
|
|
}
|
|
default DISABLED;
|
|
description
|
|
"Parameter indicating if O-DU controlled dimnesionality reduction is enabled.
|
|
Please refer to CUS specification clause 7.7.27 for more details.";
|
|
}
|
|
leaf se-27-num-elements {
|
|
when "../se-27-odu-controlled-dimensionality-reduction-enabled = 'STATIC'";
|
|
if-feature feat:SE27-ODU-CONTROLLED-DIMENSIONALITY-REDUCTION;
|
|
type uint16;
|
|
description
|
|
"Configured value of numElements in SE27.
|
|
Please refer to CUS specification clause 7.7.27 for more details.";
|
|
}
|
|
}
|
|
|
|
list tx-array-carriers {
|
|
key name;
|
|
description
|
|
"Object model for tx-array-carriers configuration";
|
|
|
|
leaf name {
|
|
type string;
|
|
description
|
|
"Unique name of tx-array-carriers object.";
|
|
}
|
|
list odu-ids {
|
|
if-feature feat:SHARED-ORU-MULTI-ODU;
|
|
key odu-id;
|
|
description
|
|
"An optional list of o-du identities associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a tx-array-carrier
|
|
associated with one or more particular odu-id(s).
|
|
|
|
This list is used to enable enhanced watchdog operation when operating
|
|
in a single operator environment, where watchdog supervision is performed
|
|
on a per odu-id basis and supervision failure only results in a sub-set
|
|
of carriers being de-activated.";
|
|
|
|
leaf odu-id {
|
|
type string;
|
|
description "an o-du identity ";
|
|
}
|
|
}
|
|
|
|
list sro-ids-and-odu-ids {
|
|
if-feature "feat:SHARED-ORU-MULTI-ODU and feat:SHARED-ORU-MULTI-OPERATOR";
|
|
key "odu-id sro-id";
|
|
description
|
|
"An optional list of sro and o-du identities associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a tx-array-carrier
|
|
associated with one or more particular odu-id(s) operated by a particular sro-id.
|
|
|
|
This list is used to enable enhanced watchdog operation when operating
|
|
in a multi operator environment, where watchdog supervision is performed on
|
|
a per odu-id basis and supervision failure only results in a sub-set of
|
|
carriers being de-activated.";
|
|
leaf odu-id {
|
|
type string;
|
|
description "an o-du identity ";
|
|
}
|
|
leaf sro-id {
|
|
type string;
|
|
description "an sro identity ";
|
|
}
|
|
}
|
|
|
|
uses tx-common-array-carrier-elements;
|
|
|
|
leaf band-number {
|
|
if-feature mcap:LAA;
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:band-capabilities/mcap:band-number";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"This parameter informing which frequency band particular antenna
|
|
array is serving for.
|
|
Intended use is to deal with multi-band solutions.";
|
|
}
|
|
|
|
container lte-tdd-frame {
|
|
when "(/user-plane-configuration/tx-array-carriers/rw-type = 'LTE') and (/user-plane-configuration/tx-array-carriers/rw-duplex-scheme = 'TDD')";
|
|
status deprecated;
|
|
description
|
|
"Container which consists of global configurable parameters for tdd Frame.
|
|
This contained is deprecated due to introduction of TDD pattern configuration
|
|
applicable in a common way for LTE and NR.";
|
|
|
|
leaf subframe-assignment {
|
|
type enumeration {
|
|
enum SAO {
|
|
description "subframe assignment configuration 0";
|
|
}
|
|
enum SA1 {
|
|
description "subframe assignment configuration 1";
|
|
}
|
|
enum SA2 {
|
|
description "subframe assignment configuration 2";
|
|
}
|
|
enum SA3 {
|
|
description "subframe assignment configuration 3";
|
|
}
|
|
enum SA4 {
|
|
description "subframe assignment configuration 4";
|
|
}
|
|
enum SA5 {
|
|
description "subframe assignment configuration 5";
|
|
}
|
|
enum SA6 {
|
|
description "subframe assignment configuration 6";
|
|
}
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Indicates DL/UL subframe configuration as specified in
|
|
3GPP TS 36.211 [v15.3.0, table 4.2-2]";
|
|
}
|
|
leaf special-subframe-pattern {
|
|
type enumeration {
|
|
enum SPP0 {
|
|
description "special subframe pattern configuration 0";
|
|
}
|
|
enum SPP1 {
|
|
description "special subframe pattern configuration 1";
|
|
}
|
|
enum SPP2 {
|
|
description "special subframe pattern configuration 2";
|
|
}
|
|
enum SPP3 {
|
|
description "special subframe pattern configuration 3";
|
|
}
|
|
enum SPP4 {
|
|
description "special subframe pattern configuration 4";
|
|
}
|
|
enum SPP5 {
|
|
description "special subframe pattern configuration 5";
|
|
}
|
|
enum SPP6 {
|
|
description "special subframe pattern configuration 6";
|
|
}
|
|
enum SPP7 {
|
|
description "special subframe pattern configuration 7";
|
|
}
|
|
enum SPP8 {
|
|
description "special subframe pattern configuration 8";
|
|
}
|
|
enum SPP9 {
|
|
description "special subframe pattern configuration 9";
|
|
}
|
|
enum SPP10 {
|
|
description "special subframe pattern configuration 10";
|
|
}
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Indicates TDD special subframe configuration as in TS 36.211
|
|
[v15.3.0, table 4.2-1] ";
|
|
}
|
|
}
|
|
|
|
container laa-carrier-configuration {
|
|
when "../band-number = 46";
|
|
if-feature mcap:LAA;
|
|
description "Container to specify LAA feature related carrier configuration.";
|
|
uses laa-carrier-config;
|
|
}
|
|
|
|
leaf gain {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
|
|
description
|
|
"Transmission gain in dB. Value applicable to each array element carrier belonging to array carrier.
|
|
|
|
The value of transmission gain shall meet the constraints defined in CUS-Plane, clause 8.1.3.3.";
|
|
}
|
|
|
|
leaf downlink-radio-frame-offset {
|
|
type uint32 {
|
|
range 0..12288000;
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"This parameter is used for offsetting the starting position of 10ms radio frame.
|
|
Note: The value should have same value within DU to all tx-array-carriers that have same frequency and bandwidth.
|
|
Note2: Unit is 1/1.2288e9 s. Then, its range is calculated 0..12288000.";
|
|
}
|
|
|
|
leaf downlink-sfn-offset {
|
|
type int16 {
|
|
range -32768..32767;
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"This parameter is used for offsetting SFN value.
|
|
Unit is in 10ms.
|
|
Note: The value should have same value within DU to all tx-array-carriers that have same frequency and bandwidth.";
|
|
}
|
|
|
|
leaf t-da-offset {
|
|
if-feature "feat:EXT-ANT-DELAY-CONTROL";
|
|
type uint32;
|
|
units Tc;
|
|
default 0;
|
|
description
|
|
"the time difference between the output of DL signal at the
|
|
antenna connector of O-RU and the transmission over the air.
|
|
units are Tc=~0.5ns=1/1.96608GHz.
|
|
An O-RU with 'ext-ant-delay-capability' = 'PER-O-RU' shall reject any configuration
|
|
where different values of t-da-offset are configured on tx-array-carriers;
|
|
An O-RU with 'ext-ant-delay-capability' = 'PER-ARRAY' shall reject any configuration
|
|
where different values of t-da-offset are configured on tx-array-carriers associated with the same tx-array.";
|
|
}
|
|
|
|
leaf reference-level {
|
|
if-feature TX-REFERENCE-LEVEL;
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
default 0;
|
|
description
|
|
"Allows to adjust reference level for sum of IQ signal power over eAxCs in this array-carrier.";
|
|
}
|
|
|
|
leaf configurable-tdd-pattern {
|
|
when "not(/user-plane-configuration/low-level-tx-endpoints[name = string(/user-plane-configuration/low-level-tx-links[tx-array-carrier = current()/../name]/tx-array-carrier)]/configurable-tdd-pattern-supported = 'false')";
|
|
if-feature mcap:CONFIGURABLE-TDD-PATTERN-SUPPORTED;
|
|
type leafref {
|
|
path "/user-plane-configuration/configurable-tdd-patterns/tdd-pattern-id";
|
|
}
|
|
description
|
|
"This parameter creates reference to configuration for TDD pattern applicable for particular tx-array-carrier.
|
|
The leaf may exist under tx-array-carrier only in case O-RU supports feature 'CONFIGURABLE-TDD-PATTERN-SUPPORTED'
|
|
AND all low-level-tx-endpoints linked to this tx-array-carrier have configurable-tdd-pattern-supported = 'true'";
|
|
}
|
|
|
|
leaf crb-to-prb-grid-offset {
|
|
if-feature "feat:PRG-SIZE-SUPP-SE-21-WITH-ST6 or feat:PRG-SIZE-SUPP-SE-21-WITH-ST5";
|
|
type uint16 {
|
|
range 0..2199;
|
|
}
|
|
default 0;
|
|
description
|
|
"This parameter specifies the value of 'offsetToCarier' parameter as specified in the 3GPP Specification TS 38.331.
|
|
This value is the offset in frequency domain, between lowest subcarrier of common RB 0, which is the start of
|
|
carrier resource Block(CRB grid) and the lowest usable subcarrier on this array-carrier, which is (RE0 of PRB0),
|
|
in units of number of PRBs (using the SCS defined for associated array-carrier). This parameter shall be used with
|
|
'prgSize' in Section Extension 21 by the O-RU to correctly derive Channel Information Based Beamforming weights.
|
|
Value of this parameter is not interpretted by the O-RU, if either 'prg-size-supp-se-21-with-st6-enabled'
|
|
or 'prg-size-supp-se-21-with-st5-enabled' parameter is not set to TRUE by the O-DU.";
|
|
}
|
|
}
|
|
|
|
list rx-array-carriers {
|
|
key name;
|
|
description
|
|
"Object model for rx-array-carriers configuration";
|
|
|
|
leaf name {
|
|
type string;
|
|
description
|
|
"Unique name of rx-array-carriers object.";
|
|
}
|
|
|
|
list odu-ids {
|
|
if-feature feat:SHARED-ORU-MULTI-ODU;
|
|
key odu-id;
|
|
description
|
|
"An optional list of o-du identities associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a rx-array-carrier
|
|
associated with one or more particular odu-id(s).
|
|
|
|
This list is used to enable enhanced watchdog operation when operating
|
|
in a single operator environment, where watchdog supervision is performed
|
|
on a per odu-id basis and supervision failure only results in a sub-set
|
|
of carriers beign de-activated.";
|
|
|
|
leaf odu-id {
|
|
type string;
|
|
description "an o-du identity ";
|
|
}
|
|
}
|
|
|
|
list sro-ids-and-odu-ids {
|
|
if-feature "feat:SHARED-ORU-MULTI-ODU and feat:SHARED-ORU-MULTI-OPERATOR";
|
|
key "odu-id sro-id";
|
|
description
|
|
"An optional list of sro and o-du identities associated with this list entry.
|
|
When present, indicates that the list entry corresponds to a rx-array-carrier
|
|
associated with one or more particular odu-id(s) operated by a particular sro-id.
|
|
|
|
This list is used to enable enhanced watchdog operation when operating
|
|
in a multi operator environment, where watchdog supervision is performed on
|
|
a per odu-id basis and supervision failure only results in a sub-set of
|
|
carriers beign de-activated.";
|
|
leaf odu-id {
|
|
type string;
|
|
description "an o-du identity ";
|
|
}
|
|
leaf sro-id {
|
|
type string;
|
|
description "an sro identity ";
|
|
}
|
|
}
|
|
|
|
uses rx-common-array-carrier-elements;
|
|
|
|
leaf downlink-radio-frame-offset {
|
|
type uint32 {
|
|
range 0..12288000;
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"This parameter is used for offsetting the starting position of 10ms radio frame.
|
|
Note: The value should have same value within DU to all tx-array-carriers that have same frequency and bandwidth.
|
|
Note2: Unit is 1/1.2288e9 s. Then, its range is calculated 0..12288000.";
|
|
}
|
|
|
|
leaf downlink-sfn-offset {
|
|
type int16 {
|
|
range -32768..32767;
|
|
}
|
|
mandatory true;
|
|
|
|
description
|
|
"This parameter is used for offsetting SFN value.
|
|
Unit is in 10ms.
|
|
Note: The value should have same value within DU to all tx-array-carriers that have same frequency and bandwidth.";
|
|
}
|
|
|
|
leaf gain-correction {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
description
|
|
"Gain correction of RF path linked with array element or array layers.
|
|
Common part of overall gain_correction.
|
|
gain_correction = common array-carrier gain-correction + eAxC gain correction.";
|
|
}
|
|
|
|
leaf n-ta-offset {
|
|
type uint32;
|
|
units Tc;
|
|
mandatory true;
|
|
description
|
|
"Value of configurable N-TA offset
|
|
units are Tc=~0.5ns=1/1.96608GHz";
|
|
}
|
|
|
|
leaf t-au-offset {
|
|
if-feature "feat:EXT-ANT-DELAY-CONTROL";
|
|
type uint32;
|
|
units Tc;
|
|
default 0;
|
|
description
|
|
"the time difference between the reception over the air and
|
|
the input of UL signal at the antenna connector of O-RU.
|
|
units are Tc=~0.5ns=1/1.96608GHz.
|
|
An O-RU with 'ext-ant-delay-capability' = 'PER-O-RU' shall reject any configuration
|
|
where different values of t-au-offset are configured on rx-array-carriers;
|
|
An O-RU with 'ext-ant-delay-capability' = 'PER-ARRAY' shall reject any configuration
|
|
where different values of t-au-offset are configured on rx-array-carriers associated with the same rx-array.";
|
|
}
|
|
|
|
leaf configurable-tdd-pattern {
|
|
when "not(/user-plane-configuration/low-level-rx-endpoints[name = string(/user-plane-configuration/low-level-rx-links[rx-array-carrier = current()/../name]/rx-array-carrier)]/configurable-tdd-pattern-supported = 'false')";
|
|
if-feature mcap:CONFIGURABLE-TDD-PATTERN-SUPPORTED;
|
|
type leafref {
|
|
path "/user-plane-configuration/configurable-tdd-patterns/tdd-pattern-id";
|
|
}
|
|
description
|
|
"This parameter creates reference to configuration for TDD pattern applicable for particular rx-array-carrier.
|
|
The leaf may exist under rx-array-carrier only in case O-RU supports feature 'CONFIGURABLE-TDD-PATTERN-SUPPORTED'
|
|
AND all low-level-rx-endpoints linked to this rx-array-carrier have configurable-tdd-pattern-supported = 'true'";
|
|
}
|
|
|
|
leaf user-group-mode {
|
|
if-feature "feat:USER-GROUP-SELF-ASSEMBLY";
|
|
type enumeration {
|
|
enum NO-SELF-ASSEMBLY {
|
|
description "No user group self assembly";
|
|
}
|
|
enum SELF-ASSEMBLY-WITH-GROUP-ID {
|
|
description "User group self assembly with group id.";
|
|
}
|
|
enum SELF-ASSEMBLY-WITHOUT-GROUP-ID {
|
|
description "User group self assembly without group id.";
|
|
}
|
|
}
|
|
default NO-SELF-ASSEMBLY;
|
|
description
|
|
"Configuration of user group self assembly.";
|
|
}
|
|
|
|
leaf point-a-offset-to-absolute-frequency-center {
|
|
if-feature "(feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ) and feat:POINT-A-OFFSET-TO-ABSOLUTE-FREQUENCY-CENTER";
|
|
type int32;
|
|
description
|
|
"An offset between center-of-channel-bandwidth and Point A.
|
|
If the value is not provided, then Point A coincides with RE#0 of PRB#0 indicated by offset-to-absolute-frequency-center.
|
|
The unit of this parameter is 1/2 of reference SCS, where reference SCS is 15 kHz for FR1 and 60 kHz for FR2.
|
|
|
|
Please refer to CUS specification clause 7.7.24 for more details.";
|
|
}
|
|
|
|
leaf continuity-block-size-configured {
|
|
if-feature "(feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ) and feat:CONTINUITY-BLOCK-SIZE";
|
|
type uint8;
|
|
description
|
|
"This parameter specified the O-DU configured value of continuity block size per rx-array-carrier.
|
|
The O-DU shall pick one of the values advertised by the O-RU in 'continuity-block-size-list'";
|
|
}
|
|
|
|
leaf port-reduced-dmrs-data-sending-enabled {
|
|
if-feature "feat:DMRS-BF-EQ or feat:DMRS-BF-NEQ";
|
|
type boolean;
|
|
description
|
|
"This parameter value if set to TRUE indicates O-DU request to O-RU for sending port reduced DMRS
|
|
sending from O-RU. If the flag is set to FALSE indicates O-RU shall not send port reduced DMRS
|
|
from O-RU to O-DU.";
|
|
}
|
|
|
|
}
|
|
|
|
list tx-arrays {
|
|
key "name";
|
|
config false;
|
|
description
|
|
"Structure describing TX array parameters";
|
|
|
|
uses parameters;
|
|
|
|
leaf min-gain {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
|
|
}
|
|
units dB;
|
|
description
|
|
"Min gain of RF path linked with array element (maximum over elements of array) or array layers";
|
|
}
|
|
|
|
leaf max-gain {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
description
|
|
"Max gain of RF path linked with array element (minimum over elements of array) or array layers";
|
|
}
|
|
|
|
leaf independent-power-budget {
|
|
type boolean;
|
|
mandatory true;
|
|
description
|
|
"If true then every element of array has own, power budget independent from power budget of other elements.
|
|
Else all elements of array that are at same row and column and have same polarisation share power budget";
|
|
}
|
|
|
|
list capabilities {
|
|
description
|
|
"List of capabilities related to this tx-array";
|
|
uses mcap:support-for-dl;
|
|
|
|
container supported-energy-saving-capabilities-dl {
|
|
description
|
|
"Network energy saving capabilities supported in DL path";
|
|
|
|
container trx-control-capability-info {
|
|
if-feature feat:TRX-CONTROL;
|
|
description
|
|
"A container with parameters for TRX-CONTROL capabilities supported by the O-RU.";
|
|
uses mcap:trx-control-capability-info;
|
|
}
|
|
|
|
container asm-capability-info {
|
|
if-feature feat:ADVANCED-SLEEP-MODE;
|
|
description
|
|
"A container with parameters for advanced sleep mode capabilities supported by the O-RU.";
|
|
uses mcap:asm-capability-info;
|
|
}
|
|
}
|
|
}
|
|
container mplane-trx-control-txarr-capability-info {
|
|
if-feature feat:MPLANE-TRX-CONTROL;
|
|
description
|
|
"A container with parameters for MPLANE-TRX-CONTROL feature supported by the O-RU.";
|
|
uses mplane-trx-control-supp-antenna-masks;
|
|
}
|
|
}
|
|
|
|
list rx-arrays {
|
|
key "name";
|
|
config false;
|
|
description "Structure describing RX array parameters";
|
|
|
|
uses parameters;
|
|
container gain-correction-range {
|
|
leaf max {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
description "Array gain correction factor - maximum allowed value";
|
|
}
|
|
leaf min {
|
|
type decimal64 {
|
|
fraction-digits 4;
|
|
}
|
|
units dB;
|
|
mandatory true;
|
|
description "Array gain correction factor - minimum allowed value";
|
|
}
|
|
|
|
description
|
|
"Array gain correction factor";
|
|
}
|
|
|
|
list capabilities {
|
|
description
|
|
"List of capabilities related to this rx-array";
|
|
uses mcap:support-for-ul;
|
|
|
|
container supported-energy-saving-capabilities-ul {
|
|
description
|
|
"Network energy saving capabilities supported in UL path";
|
|
|
|
container trx-control-capability-info {
|
|
if-feature feat:TRX-CONTROL;
|
|
description
|
|
"A container with parameters for TRX-CONTROL capabilities supported by the O-RU";
|
|
uses mcap:trx-control-capability-info;
|
|
}
|
|
|
|
container asm-capability-info {
|
|
if-feature feat:ADVANCED-SLEEP-MODE;
|
|
description
|
|
"A container with parameters for advanced sleep mode capabilities supported by the O-RU";
|
|
uses mcap:asm-capability-info;
|
|
}
|
|
}
|
|
}
|
|
container mplane-trx-control-rxarr-capability-info {
|
|
if-feature feat:MPLANE-TRX-CONTROL;
|
|
description
|
|
"A container with parameters for MPLANE-TRX-CONTROL feature supported by the O-RU.";
|
|
|
|
uses mplane-trx-control-supp-antenna-masks;
|
|
}
|
|
}
|
|
|
|
list relations {
|
|
key "entity";
|
|
config false;
|
|
description "Structure describing relations between array elements";
|
|
|
|
leaf entity {
|
|
type uint16;
|
|
|
|
description
|
|
"Relation entity. Used as a key for list of relations.";
|
|
}
|
|
|
|
container array1 {
|
|
uses array-choice;
|
|
|
|
description
|
|
"Defines name for first array";
|
|
}
|
|
container array2 {
|
|
uses array-choice;
|
|
|
|
description
|
|
"Defines name for second array";
|
|
}
|
|
list types {
|
|
key "relation-type";
|
|
description
|
|
"Defines relation type and pairs for array elements for given arrays";
|
|
|
|
leaf relation-type {
|
|
type enumeration {
|
|
enum SHARED {
|
|
description "SHARED";
|
|
}
|
|
enum COALOCATED {
|
|
description "COALOCATED";
|
|
}
|
|
}
|
|
description "Type of relation between array elements";
|
|
}
|
|
list pairs {
|
|
key "element-array1";
|
|
description
|
|
"defines related array elements";
|
|
|
|
leaf element-array1 {
|
|
type uint16;
|
|
|
|
description
|
|
"Tells about id of element from array1";
|
|
}
|
|
leaf element-array2 {
|
|
type uint16;
|
|
|
|
description
|
|
"Tells about id of element from array2";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
container eaxc-id-group-configuration {
|
|
if-feature mcap:EAXC-ID-GROUP-SUPPORTED;
|
|
description
|
|
"This is the container for eAxC ID group configuration.";
|
|
leaf max-num-tx-eaxc-id-groups {
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:ru-capabilities/mcap:eaxcid-grouping-capabilities/mcap:max-num-tx-eaxc-id-groups";
|
|
require-instance false;
|
|
}
|
|
description "eaxc-id-group-configuration";
|
|
}
|
|
leaf max-num-tx-eaxc-ids-per-group {
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:ru-capabilities/mcap:eaxcid-grouping-capabilities/mcap:max-num-tx-eaxc-ids-per-group";
|
|
require-instance false;
|
|
}
|
|
description "max-num-tx-eaxc-ids-per-group";
|
|
}
|
|
leaf max-num-rx-eaxc-id-groups {
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:ru-capabilities/mcap:eaxcid-grouping-capabilities/mcap:max-num-rx-eaxc-id-groups";
|
|
require-instance false;
|
|
}
|
|
description "max-num-rx-eaxc-id-groups";
|
|
}
|
|
leaf max-num-rx-eaxc-ids-per-group {
|
|
type leafref {
|
|
path "/mcap:module-capability/mcap:ru-capabilities/mcap:eaxcid-grouping-capabilities/mcap:max-num-rx-eaxc-ids-per-group";
|
|
require-instance false;
|
|
}
|
|
description "max-num-rx-eaxc-ids-per-group";
|
|
}
|
|
|
|
list tx-eaxc-id-group {
|
|
must "count(../tx-eaxc-id-group) <= ../max-num-tx-eaxc-id-groups" {
|
|
error-message "too many tx-eaxcid-id groups";
|
|
}
|
|
key "representative-tx-eaxc-id";
|
|
description
|
|
"This is a list of the groups of the eAxC IDs assigned to low-level-tx-endpoints.
|
|
Each group is a union of the 'member-tx-eaxc-id's and a 'representative-tx-eaxc-id'.
|
|
The low-level-tx-endpoint associated to 'representative-tx-eaxc-id' is able to
|
|
process the DL C-plane information for all the low-level-tx-endpoints associated
|
|
to 'member-tx-eaxc-id's.
|
|
|
|
Take Note: This list should only contain eAxC IDs assigned to a tx-endpoint.";
|
|
|
|
|
|
leaf representative-tx-eaxc-id {
|
|
type uint16;
|
|
description
|
|
"This parameter contains eAxC_ID that populates content of C-Plane section
|
|
extension 10 to eAxC_IDs configured in the group as 'member-tx-eaxc-id'(s).";
|
|
}
|
|
leaf-list member-tx-eaxc-id {
|
|
type uint16;
|
|
must "count(../member-tx-eaxc-id) <= ../../max-num-tx-eaxc-ids-per-group" {
|
|
error-message "too many tx-eaxcid-id members";
|
|
}
|
|
must "current()!=../representative-tx-eaxc-id" {
|
|
error-message "the representative eaxcid does not need to be a list member";
|
|
}
|
|
ordered-by user;
|
|
description
|
|
"This is a list of member eAxC IDs, which together with the representative-tx-eaxc-id,
|
|
are assigned to low-level-tx-endpoints in the group.
|
|
This list is defined as 'ordered-by user', because the order of the eaxc-id list should be maintained,
|
|
and the parameters in the SE10 are applied to the eaxc-ids based on the order of eaxc-ids in the list
|
|
when the section extension conveys unique parameters (beamId/ueId) per eaxc-id.";
|
|
}
|
|
}
|
|
|
|
list rx-eaxc-id-group {
|
|
must "count(../rx-eaxc-id-group) <= ../max-num-rx-eaxc-id-groups" {
|
|
error-message "too many rx-eaxcid-id groups";
|
|
}
|
|
key "representative-rx-eaxc-id";
|
|
description
|
|
"This is a list of the groups of the eAxC IDs assigned to low-level-rx-endpoints.
|
|
Each group is a union of 'member-rx-eaxc-id's and a 'representative-rx-eaxc-id'.
|
|
The low-level-rx-endpoint associated to 'representative-rx-eaxc-id' is able to
|
|
process the UL C-plane information for all the low-level-rx-endpoints associated
|
|
to 'member-rx-eaxc-id's.
|
|
|
|
Take Note: This list should only contain eAxC IDs assigned to a rx-endpoint.";
|
|
|
|
leaf representative-rx-eaxc-id {
|
|
type uint16;
|
|
description
|
|
"This parameter contains eAxC_ID that populates content of C-Plane section
|
|
extension 10 to eAxC_IDs configured in the group as 'member-rx-eaxc-id'(s).";
|
|
}
|
|
|
|
leaf-list member-rx-eaxc-id {
|
|
type uint16;
|
|
must "count(../member-rx-eaxc-id) <= ../../max-num-rx-eaxc-ids-per-group" {
|
|
error-message "too many rx-eaxcid-id members";
|
|
}
|
|
must "current()!=../representative-rx-eaxc-id" {
|
|
error-message "the representative eaxc-id does not need to be a list member";
|
|
}
|
|
ordered-by user;
|
|
description
|
|
"This is a list of member eAxC IDs assigned to low-level-rx-endpoints in the group.
|
|
This list is defined as 'ordered-by user', because the order of the eaxc-id list should be maintained,
|
|
and the parameters in the SE10 are applied to the eaxc-ids based on the order of eaxc-ids in the list
|
|
when the section extension conveys unique parameters (beamId/ueId) per eaxc-id.";
|
|
}
|
|
}
|
|
}
|
|
|
|
list static-prach-configurations {
|
|
if-feature mcap:PRACH-STATIC-CONFIGURATION-SUPPORTED;
|
|
key static-prach-config-id;
|
|
description
|
|
"List of static PRACH configurations. An O-RU shall reject any configuration
|
|
modification which exceed the maximum permitted configurations supported by
|
|
the O-RU";
|
|
|
|
leaf static-prach-config-id {
|
|
type uint8;
|
|
description
|
|
"Supplementary parameter acting as key in list of static PRACH configurations.";
|
|
}
|
|
|
|
uses static-prach-configuration;
|
|
}
|
|
|
|
grouping static-prach-configuration {
|
|
description
|
|
"Set of parameters related to static PRACH configuration";
|
|
|
|
leaf sfn-offset {
|
|
type uint32;
|
|
|
|
description
|
|
"This parameter is used for offsetting SFN value.
|
|
The SFN that results from the offset is used as the reference for the start of pattern periods.
|
|
If the value is not set, then pattern periods follow the reference set in a related rx-array-carrier.
|
|
The value is primarily used for cases in which pattern-period is not a power of 2.
|
|
Unit is in 10ms.";
|
|
}
|
|
|
|
leaf pattern-period {
|
|
type uint16 {
|
|
range 1..1024;
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Period after which static PRACH patterns are repeated. Unit: number of frames.";
|
|
}
|
|
|
|
leaf guard-tone-low-re {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Number of REs occupied by the low guard tones.";
|
|
}
|
|
|
|
leaf num-prach-re {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Number of contiguous PRBs per data section description";
|
|
}
|
|
|
|
leaf guard-tone-high-re {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Number of REs occupied by the high guard tones.";
|
|
}
|
|
|
|
leaf sequence-duration {
|
|
type uint32 {
|
|
range 256..24576;
|
|
}
|
|
units Ts;
|
|
mandatory true;
|
|
description
|
|
"Duration of single PRACH Symbol. Refer to definition of PRACH Symbol in CUS specification clause 3.1.";
|
|
}
|
|
|
|
list prach-patterns {
|
|
key prach-pattern-id;
|
|
min-elements 1;
|
|
description
|
|
"Provides a PRACH pattern. Each record in the list represents a single PRACH occasion. Number of list entries cannot
|
|
exceed max-prach-patterns or extended-max-prach-patterns if EXTENDED-PRACH-CONFIGURATION is supported.";
|
|
|
|
leaf prach-pattern-id {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Supplementary parameter acting as key for prach-pattern list.
|
|
NETCONF client shall limit its maximum value to 65535 when configuring
|
|
any O-RU that does not support the EXTENDED-PRACH-CONFIGURATION feature.";
|
|
}
|
|
|
|
leaf number-of-repetitions {
|
|
type uint8{
|
|
range 1..14;
|
|
}
|
|
mandatory true;
|
|
description
|
|
"This parameter defines number of PRACH PRACH Symbol repetitions in PRACH occasion,
|
|
to which the section control is applicable. Refer to definition of PRACH Symbol in CUS specification clause 3.1.";
|
|
}
|
|
|
|
leaf number-of-occasions {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"This parameter informs how many consecutive PRACH occasions is described by the PRACH pattern.
|
|
NETCONF client shall limit its maximum value to 255 when configuring any O-RU that does not
|
|
support the EXTENDED-PRACH-CONFIGURATION feature.";
|
|
}
|
|
|
|
leaf re-offset {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Offset between the start of lowest-frequency RE of lowest-frequency PRB
|
|
and the start of lowest-frequency RE belonging to the PRACH occasion.
|
|
The re-offset is configured as number of PRACH REs.";
|
|
}
|
|
|
|
list occasion-parameters {
|
|
key occasion-id;
|
|
min-elements 1;
|
|
description
|
|
"This is list of cp-lengths, gp-lengths and beam-ids applicable
|
|
per each PRACH occasion in PRACH pattern.
|
|
Note: the number of records in this list MUST be equal
|
|
to value of parameter number-of-occasions.";
|
|
|
|
leaf occasion-id {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Supplementary parameter acting as key in 'occasion-parameters' list.
|
|
The value is limited to 255 if EXTENDED-PRACH-CONFIGURATION is unsupported.";
|
|
}
|
|
|
|
leaf cp-length {
|
|
type uint16;
|
|
units Ts;
|
|
mandatory true;
|
|
description
|
|
"Cyclic prefix length. See CUS-plane specification for detailed description.";
|
|
}
|
|
|
|
leaf gp-length {
|
|
type uint16;
|
|
units Ts;
|
|
description
|
|
"Guard period length.";
|
|
}
|
|
|
|
leaf beam-id {
|
|
type uint16 {
|
|
range "min .. 32767";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"This parameter defines the beam pattern to be applied to the U-Plane data.
|
|
beamId = 0 means no beamforming operation will be performed.";
|
|
}
|
|
}
|
|
|
|
leaf frame-number {
|
|
type uint16{
|
|
range 0..1023;
|
|
}
|
|
mandatory true;
|
|
description
|
|
"This parameter is an index inside the pattern-length, such that
|
|
PRACH occasion is happening for SFN which fulfills following equation:
|
|
[SFN mod pattern-length = frame-id]";
|
|
}
|
|
|
|
leaf sub-frame-id {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Identifier of sub-frame of the PRACH occasion. Value is interpreted in the same way
|
|
as subframeId field in a section description of a C-Plane message.";
|
|
}
|
|
|
|
leaf time-offset {
|
|
type uint16;
|
|
units Ts;
|
|
mandatory true;
|
|
description
|
|
"This parameter defines the time-offset from the start of the sub-frame
|
|
to the start of the first Cyclic Prefix of PRACH pattern";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping static-srs-configuration {
|
|
description
|
|
"Set of parameters related to static PRACH configuration";
|
|
|
|
leaf pattern-period {
|
|
type uint16 {
|
|
range 1..1024;
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Period after which static SRS patterns are repeated. Unit: number of frames.";
|
|
}
|
|
|
|
list srs-patterns {
|
|
key srs-pattern-id;
|
|
min-elements 1;
|
|
description
|
|
"Provides a SRS pattern. Each record in the list represents a single PRACH occasion. Number of list entries cannot exceed max-srs-patterns.";
|
|
|
|
leaf srs-pattern-id {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Supplementary parameter acting as key for srs-pattern list.";
|
|
}
|
|
|
|
leaf sub-frame-id {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Identifier of sub-frame of the Raw SRS occasion. Value is interpreted in the same way
|
|
as subframeId field in a section description of a C-Plane message.";
|
|
}
|
|
|
|
leaf slot-id {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Identifier of slot of the Raw SRS occasion. Value is interpreted in the same way
|
|
as slotId field in a section description of a C-Plane message.";
|
|
}
|
|
|
|
leaf start-symbol-id {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Identifier of first symbol of the Raw SRS occasion. Value is interpreted in the same way
|
|
as startSymbolId field in a section description of a C-Plane message.";
|
|
}
|
|
|
|
leaf beam-id {
|
|
type uint16 {
|
|
range "min .. 32767";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"This parameter defines the beam pattern to be applied to the U-Plane data.
|
|
beamId = 0 means no beamforming operation will be performed.";
|
|
}
|
|
|
|
leaf num-symbol {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"This parameter defines number of consecutive symbols covered by specific srs-pattern.
|
|
Single srs-pattern may address at least one symbol. However, possible optimisations
|
|
could allow for several (up to 14) symbols.";
|
|
}
|
|
|
|
leaf start-prbc {
|
|
type uint16 {
|
|
range 0..1023;
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Identifier of first PRB of the Raw SRS occasion. Value is interpreted in the same way
|
|
as startPrbc field in a section description of a C-Plane message.";
|
|
}
|
|
|
|
leaf num-prbc {
|
|
type uint16;
|
|
mandatory true;
|
|
description
|
|
"Number of PRBs of the Raw SRS occasion. Value is interpreted in the same way
|
|
as numPrbc field in a section description of a C-Plane message.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping configurable-tdd-pattern {
|
|
description
|
|
"Set of parameters related to configurable TDD pattern.
|
|
Note: configurable-tdd-pattern shall not be used in case the usage would collide with
|
|
deprecated 'lte-tdd-pattern'.";
|
|
|
|
list switching-points {
|
|
key switching-point-id;
|
|
description
|
|
"List of switching points within frame, related to configurable TDD pattern.
|
|
An O-RU shall reject any configuration modification which exceeds the maximum
|
|
number of switching-points supported by the O-RU";
|
|
|
|
leaf switching-point-id {
|
|
type uint16;
|
|
description
|
|
"Supplementary parameter acting as key for switching-points list.";
|
|
}
|
|
|
|
leaf direction {
|
|
type enumeration {
|
|
enum UL {
|
|
description "Uplink";
|
|
}
|
|
enum DL {
|
|
description "Downlink";
|
|
}
|
|
enum GP {
|
|
description "Guard period";
|
|
}
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Parameter provides information regarding desired signal direction at the moment switching point occurs.";
|
|
}
|
|
|
|
leaf frame-offset {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Offset from DL air frame boundary transmitted at RF connector to the point in time that is characteristic to the operation on RF switches. Unit is 1/1.2288e9 s.";
|
|
}
|
|
}
|
|
}
|
|
|
|
list static-srs-configurations {
|
|
if-feature mcap:SRS-STATIC-CONFIGURATION-SUPPORTED;
|
|
key static-srs-config-id;
|
|
description
|
|
"List of static SRS configurations";
|
|
|
|
leaf static-srs-config-id {
|
|
type uint8;
|
|
description
|
|
"Supplementary parameter acting as key in the list of static SRS configurations.";
|
|
}
|
|
|
|
uses static-srs-configuration;
|
|
}
|
|
|
|
list configurable-tdd-patterns {
|
|
if-feature mcap:CONFIGURABLE-TDD-PATTERN-SUPPORTED;
|
|
key tdd-pattern-id;
|
|
description
|
|
"List of configured TDD patterns";
|
|
|
|
leaf tdd-pattern-id {
|
|
type uint8;
|
|
description
|
|
"Supplementary parameter acting as key in the list of configured TDD patterns.";
|
|
}
|
|
|
|
uses configurable-tdd-pattern;
|
|
}
|
|
|
|
list endpoint-bf-profile-group {
|
|
if-feature feat:BF-DELAY-PROFILE;
|
|
key "bf-profile-id";
|
|
config false;
|
|
description
|
|
"An optional list of list(s) containing beamforming methods supported by the O-RU with the associated delay-profile-id
|
|
per each beamforming method list";
|
|
leaf bf-profile-id {
|
|
type uint16;
|
|
description
|
|
"Identifies the beamforming method list.";
|
|
}
|
|
leaf-list supported-bf-methods {
|
|
type beamforming-method-type;
|
|
min-elements 1;
|
|
description
|
|
"Beamforming methods can be supported simultaneously.";
|
|
}
|
|
leaf supported-delay-profile {
|
|
type leafref {
|
|
path "/or-dm:delay-management/or-dm:non-default-ru-delay-profile/or-dm:delay-profile-id";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"The delay-profile-id associated with the supported beamforming method list.
|
|
If not configured or the value is set to 0, all delay parameters shall be equivalent to the default value.";
|
|
}
|
|
}
|
|
list se10-member-candidate-tx-lists {
|
|
if-feature feat:SE10-MEMBER-CANDIDATE-LIST;
|
|
key "id";
|
|
config false;
|
|
description
|
|
"List of leaf-lists, where each leaf-list is a member-candidate list comprising of endpoints
|
|
which can be associated to one or more static-low-level-tx-endpoint(s).";
|
|
leaf id {
|
|
type uint8;
|
|
description
|
|
"Index into the list se10-member-candidate-tx-lists.";
|
|
}
|
|
leaf-list member-candidates {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-tx-endpoints/name";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Each leaf-list comprises one or more static-low-elevel-tx-endpoint(s). Endpoints in this list can
|
|
be representative endpoint or member endpoint.";
|
|
}
|
|
}
|
|
list se10-member-candidate-rx-lists {
|
|
if-feature feat:SE10-MEMBER-CANDIDATE-LIST;
|
|
key "id";
|
|
config false;
|
|
description
|
|
"List of leaf-lists, where each leaf-list is a member-candidate list comprising of endpoints
|
|
which can be associated to one or more static-low-level-rx-endpoint(s).";
|
|
leaf id {
|
|
type uint8;
|
|
description
|
|
"Index into the list se10-member-candidate-rx-lists.";
|
|
}
|
|
leaf-list member-candidates {
|
|
type leafref {
|
|
path "/user-plane-configuration/static-low-level-rx-endpoints/name";
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Each leaf-list comprises one or more static-low-elevel-rx-endpoint(s). Endpoints in this list can
|
|
be representative endpoint or member endpoint.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping tx-array-notification-group {
|
|
description
|
|
"Grouping for tx-array for notification";
|
|
|
|
list tx-array-carriers{
|
|
key name;
|
|
description "notification of state change for tx-array-carriers";
|
|
|
|
leaf name{
|
|
type leafref{
|
|
path "/user-plane-configuration/tx-array-carriers/name";
|
|
}
|
|
description
|
|
"name of tx-array-carriers is notified at state change";
|
|
}
|
|
leaf state{
|
|
type leafref{
|
|
path "/user-plane-configuration/tx-array-carriers/state";
|
|
}
|
|
description
|
|
"state of tx-array-carriers is notified at state change";
|
|
}
|
|
leaf availability-status{
|
|
type leafref{
|
|
path "/user-plane-configuration/tx-array-carriers/availability-status";
|
|
}
|
|
description
|
|
"availability-status of tx-array-carriers is notified at availability-status change";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping rx-array-notification-group {
|
|
description
|
|
"Grouping for rx-array for notification";
|
|
|
|
list rx-array-carriers{
|
|
key name;
|
|
description
|
|
"Notification used to inform about state change of rx-array-carriers";
|
|
leaf name{
|
|
type leafref{
|
|
path "/user-plane-configuration/rx-array-carriers/name";
|
|
}
|
|
description
|
|
"name of rx-array-carriers is notified at state change";
|
|
}
|
|
leaf state{
|
|
type leafref{
|
|
path "/user-plane-configuration/rx-array-carriers/state";
|
|
}
|
|
description
|
|
"state of rx-array-carriers is notified at state change";
|
|
}
|
|
leaf availability-status{
|
|
type leafref{
|
|
path "/user-plane-configuration/rx-array-carriers/availability-status";
|
|
}
|
|
description
|
|
"availability-status of rx-array-carriers is notified at availability-status change";
|
|
}
|
|
}
|
|
}
|
|
|
|
// top level container
|
|
container user-plane-configuration {
|
|
description "top level container for user plane configuration";
|
|
|
|
uses uplane-conf-group;
|
|
uses general-config;
|
|
uses array-config-group;
|
|
}
|
|
|
|
//notification statement
|
|
notification tx-array-carriers-state-change {
|
|
description
|
|
"Notification used to inform about state change of tx-array-carriers";
|
|
uses tx-array-notification-group;
|
|
}
|
|
notification rx-array-carriers-state-change {
|
|
description
|
|
"Notification used to inform about state change of tx-array-carriers";
|
|
|
|
uses rx-array-notification-group;
|
|
}
|
|
|
|
notification data-layer-control-wakeup-notification {
|
|
if-feature feat:MPLANE-DATA-LAYER-CONTROL;
|
|
description
|
|
"Notification used to inform about wake-up completion after M-Plane based data layer control sleep is terminated";
|
|
leaf-list energy-sharing-group {
|
|
type uint8;
|
|
description
|
|
"Notification for wake-up completion of underlying HW components corresponding to energy sharing group.
|
|
This value shall be specific values from the list of 'energy-sharing-group-id' inside static-low-level-[tr]x-endpoints.";
|
|
}
|
|
}
|
|
notification mplane-trx-control-ant-mask-update {
|
|
if-feature feat:MPLANE-TRX-CONTROL;
|
|
|
|
leaf array-name {
|
|
type union {
|
|
type leafref {
|
|
path "/user-plane-configuration/rx-arrays/name";
|
|
}
|
|
type leafref {
|
|
path "/user-plane-configuration/tx-arrays/name";
|
|
}
|
|
}
|
|
description
|
|
"The array name for which antenna mask has been updated using
|
|
MPLANE-TRX-CONTROL feature.";
|
|
}
|
|
leaf array-type {
|
|
type enumeration {
|
|
enum TX-ARRAY {
|
|
description
|
|
"this array is of type TX array";
|
|
}
|
|
enum RX-ARRAY {
|
|
description
|
|
"this array is of type RX array";
|
|
}
|
|
}
|
|
description
|
|
"The type of array for which antenna mask has been updated using
|
|
MPLANE-TRX-CONTROL feature.";
|
|
}
|
|
leaf updated-antenna-mask {
|
|
type binary;
|
|
description
|
|
"The updated antenna mask value after processing M-Plane based TRX control command at the O-RU.
|
|
If mplane-supported-trx-control-masks list is not advertised as part of capability for the referred [tr]x-array,
|
|
the parameter antenna-bitmask shall be used for notification.
|
|
The parameter antenna-bitmask-index shall not be used for notification.";
|
|
}
|
|
leaf updated-antenna-mask-index {
|
|
type uint8;
|
|
description
|
|
"The parameter indicates updated antenna mask index value after processing M-Plane based TRX control command at the O-RU.
|
|
If mplane-supported-trx-control-masks list is advertised as part of capability for the referred [tr]x-array,
|
|
the parameter antenna-bitmask-index shall be used for notification to refer to the index of advertised mplane-supported-trx-control-masks.
|
|
The parameter antenna-bitmask shall not be used for notification.";
|
|
}
|
|
description
|
|
"M-Plane notification event to notify that the commanded mask has been activated via M-plane. This notification
|
|
is required to be sent for either tx-array or rx-array for which the antenna mask was
|
|
commanded to be changed by the O-DU.";
|
|
}
|
|
}
|