X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=data-model%2Fyang%2Fpublished%2Fo-ran%2Fru-fh%2Fo-ran-uplane-conf%402022-12-05.yang;fp=data-model%2Fyang%2Fpublished%2Fo-ran%2Fru-fh%2Fo-ran-uplane-conf%402022-12-05.yang;h=8562447bcf7aa16f613e0ccb0147b41e4d4cb0a1;hb=5a4d5f6105bb5f5fcf3ba92d2e50346766f2f485;hp=0000000000000000000000000000000000000000;hpb=ee63226cb62a49d3e08f14a78280d9d8d2a56992;p=scp%2Foam%2Fmodeling.git diff --git a/data-model/yang/published/o-ran/ru-fh/o-ran-uplane-conf@2022-12-05.yang b/data-model/yang/published/o-ran/ru-fh/o-ran-uplane-conf@2022-12-05.yang new file mode 100644 index 0000000..8562447 --- /dev/null +++ b/data-model/yang/published/o-ran/ru-fh/o-ran-uplane-conf@2022-12-05.yang @@ -0,0 +1,4058 @@ +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"; + } + + 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 2021 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 "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"; + } + + 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 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 bigendian 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."; + } + } + } + + 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) if section type 3 is not used or type of CP cannot be determined from cpLength."; + } + + 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 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 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"; + } + } + + 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 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 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."; + } + } + + 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 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: + Error C-Plane message + Maximum number of frequency ranges in SE-12 per section description exceeded + Reduce frequency ranges per section description used in SE-12"; + } + 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 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: + Error C-Plane message + Maximum number of frequency hops in SE 13 per section description exceeded + Reduce frequency hops per section description used in SE-13"; + } + + 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 beams 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."; + } + leaf max-beams-per-slot { + type uint16 { + range "min .. 32767"; + } + description + "Max number of beams 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."; + } + 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: + Error C-Plane message + max-prb-ranges-per-symbol exceeded + Reduce value of number of PRB ranges used per symbol"; + } + + 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 recieved 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: + Error C-Plane message + Maximum number of frequency hops per highest priority section description exceeded + Reduce frequency range per highest section description"; + } + + description + "Attributes limit maximum instances of certian parameters contained in a C-Plane mesaage 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 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"; + } + + 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 of 16bit is limitted by 4bit ciIqWidth in the C-Plane message. + 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 of 16bit is limitted by 4bit ciIqWidth in the C-Plane message. + + 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 choosen, 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; + description + "Bitwidth to be used in compression"; + } + + description + "List of available compressions, that can be dynamically choosen, 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 choosen, 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."; + } + } + description + "Section Type 4 command types supported by O-RU."; + } + } + + list st4-reception-mask { + key "cmd-scope"; + + 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 resouce operator where the sro-id idenifies + a specific shared resouce 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 resouce operator where the sro-id idenifies + a specific shared resouce 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'"; + } + } + + 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 '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 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"; + } + } + + 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"; + } + } + + 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"; + } + } + + 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; + + } + + 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"; + } + } + + 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 resouce operator where the sro-id idenifies + a specific shared resouce 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-rx-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 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 exsit in a section description for channel information, + the parameter ci-prb-group-size shall be used for this section description. + If the IE ciPrbGroupSize exsits 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."; + } + } + } + + 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 resouce operator where the sro-id idenifies + a specific shared resouce 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. + 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."; + } + } + + 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"; + } + } + + 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 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 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 operationwhen 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 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 tranmsmission 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'"; + } + } + + 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 operationwhen 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'"; + } + } + + 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; + } + } + + 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; + } + } + + 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 eaxcid 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 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 sequence of the PRACH. Sequence may be considered as 'single PRACH symbol'"; + } + + 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"; + + leaf prach-pattern-id { + type uint16; + mandatory true; + description + "Supplementary parameter acting as key for prach-pattern list."; + } + + leaf number-of-repetitions { + type uint8{ + range 1..14; + } + mandatory true; + description + "This parameter defines number of PRACH repetitions in PRACH occasion, + to which the section control is applicable."; + } + + leaf number-of-occasions { + type uint8; + mandatory true; + description + "This parameter informs how many consecutive PRACH occasions is described by the PRACH pattern."; + } + + 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 uint8; + mandatory true; + description + "Supplementary parameter acting as key in 'occasion-parameters' list"; + } + + 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; + } + } + + 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"; + } + } + } + + 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"; + } + } + } + + // top level container + container user-plane-configuration { + description "top level container for user plane configuration"; + + uses uplane-conf-group; + uses general-config; + } + + //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; + } +}