Cisco-IOS-XR-ptp-cfg

This module contains a collection of YANG definitions for Cisco IOS-XR ptp package configuration. This module contains definiti...

  • Version: 2021-02-12

    Cisco-IOS-XR-ptp-cfg@2021-02-12


    
      module Cisco-IOS-XR-ptp-cfg {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-ptp-cfg";
    
        prefix ptp-cfg;
    
        import ietf-inet-types {
          prefix inet;
        }
        import ietf-yang-types {
          prefix yang;
        }
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
        import Cisco-IOS-XR-ptp-datatypes {
          prefix dt1;
        }
        import Cisco-IOS-XR-ifmgr-cfg {
          prefix a1;
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
         Customer Service
         
         Postal: 170 West Tasman Drive
         San Jose, CA 95134
         
         Tel: +1 800 553-NETS
         
         E-mail: cs-yang@cisco.com";
    
        description
          "This module contains a collection of YANG definitions
         for Cisco IOS-XR ptp package configuration.
         
         This module contains definitions
         for the following management objects:
           ptp: PTP global configuration
         
         This YANG module augments the
           Cisco-IOS-XR-ifmgr-cfg
         module with configuration data.
         
         Copyright (c) 2013-2021 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2021-02-12" {
          description
            "Marked deprecated uncalibrated-clock-class leaf obsolete
           2020-09-07
             Added APTS config item";
        }
    
        revision "2020-01-31" {
          description
            "Added submode-enter enable handling.
           2020-01-15
           Added holdover-spec configuration options and uncalibrated time-traceable override option.
           2020-01-13
           Added servo slow tracking configuration item.";
        }
    
        revision "2019-10-31" {
          description
            "Added mandatory nodes and presence containers.";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2017-02-02" {
          description "Initial version.";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "3.1.0";
        semver:module-version "3.0.0";
        semver:module-version "2.0.0";
        semver:module-version "1.0.0";
    
        augment /a1:interface-configurations/a1:interface-configuration {
          description
            "This augment extends the configuration data of
           'Cisco-IOS-XR-ifmgr-cfg'";
          container ptp {
            presence
              "CLI submode compatibility.";
            description
              "Precision Time Protocol interface configuration";
            container source-ipv6-address {
              description "Source IPv6 Address";
              leaf enable {
                type boolean;
                description
                  "Enable source IPv6 address";
              }
    
              leaf source-ipv6 {
                type inet:ipv6-address-no-zone;
                description
                  "Source IPv6 address to use";
              }
            }  // container source-ipv6-address
    
            container announce-interval {
              description "Announce interval";
              leaf time-type {
                type dt1:Ptp-time;
                default "interval";
                description
                  "Interval or Frequency";
              }
    
              leaf time-period {
                type dt1:Ptp-time-period;
                default "2";
                description "Time Period";
              }
            }  // container announce-interval
    
            container interop {
              description
                "Table for interop configuration";
              container egress-conversion {
                description
                  "Iteroperation configuration to be used on
                 egress";
                container clock-class-mappings {
                  description
                    "Table for specific mappings for given clock
                   class values";
                  list clock-class-mapping {
                    key "clock-class-from";
                    description
                      "Mapping for a given clock class value";
                    leaf clock-class-from {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Clock Class to map from";
                    }
    
                    leaf clock-class-to {
                      type uint32 {
                        range "0..255";
                      }
                      mandatory true;
                      description
                        "Clock class to map to";
                    }
                  }  // list clock-class-mapping
                }  // container clock-class-mappings
    
                leaf clock-accuracy {
                  type uint32 {
                    range "0..254";
                  }
                  description
                    "Clock Accuracy value to use for the peer
                   clock";
                }
    
                leaf priority2 {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Priority2 value to use for the peer clock";
                }
    
                leaf clock-class-default {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Default clock class to use when a more
                   specific mapping is not available";
                }
    
                leaf offset-scaled-log-variance {
                  type uint32 {
                    range "0..65535";
                  }
                  description
                    "OSLV value to use for the peer clock";
                }
    
                leaf priority1 {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Priority1 value to use for the peer clock";
                }
              }  // container egress-conversion
    
              container ingress-conversion {
                description
                  "Iteroperation configuration to be used on
                 ingress";
                container clock-class-mappings {
                  description
                    "Table for specific mappings for given clock
                   class values";
                  list clock-class-mapping {
                    key "clock-class-from";
                    description
                      "Mapping for a given clock class value";
                    leaf clock-class-from {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Clock Class to map from";
                    }
    
                    leaf clock-class-to {
                      type uint32 {
                        range "0..255";
                      }
                      mandatory true;
                      description
                        "Clock class to map to";
                    }
                  }  // list clock-class-mapping
                }  // container clock-class-mappings
    
                leaf clock-accuracy {
                  type uint32 {
                    range "0..254";
                  }
                  description
                    "Clock Accuracy value to use for the peer
                   clock";
                }
    
                leaf priority2 {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Priority2 value to use for the peer clock";
                }
    
                leaf clock-class-default {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Default clock class to use when a more
                   specific mapping is not available";
                }
    
                leaf offset-scaled-log-variance {
                  type uint32 {
                    range "0..65535";
                  }
                  description
                    "OSLV value to use for the peer clock";
                }
    
                leaf priority1 {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Priority1 value to use for the peer clock";
                }
              }  // container ingress-conversion
    
              leaf profile {
                type dt1:Ptp-clock-profile;
                description
                  "Profile to interoperate with";
              }
    
              leaf domain {
                type uint32 {
                  range "0..255";
                }
                description
                  "Domain number of the peer clock";
              }
            }  // container interop
    
            container source-ipv4-address {
              description "Source IPv4 Address";
              leaf enable {
                type boolean;
                description
                  "Enable source IP address";
              }
    
              leaf source-ip {
                type inet:ipv4-address-no-zone;
                description
                  "Source IP address to use";
              }
            }  // container source-ipv4-address
    
            container slaves {
              description
                "Table for slave configuration";
              list slave {
                must "ethernet or ipv4-or-ipv6" {
                  description
                    "Ethernet or IPv4-or-IPv6 must be present.";
                }
                key "transport";
                description
                  "Slave configuration";
                grouping SLAVE-CONTENT {
                  description "SLAVE CONTENT";
                  leaf non-negotiated {
                    type boolean;
                    description
                      "Enable non-negotiated unicast on this
                     interface";
                  }
                }  // grouping SLAVE-CONTENT
                leaf transport {
                  type dt1:Ptp-encap;
                  description
                    "Slave Transport Type";
                }
    
                list ethernet {
                  when
                    "../transport = 'ethernet'" {
                    description
                      "../Transport = Ethernet";
                  }
                  key "slave-mac-address";
                  description "ethernet";
                  leaf slave-mac-address {
                    type yang:mac-address;
                    description
                      "Slave MAC Address";
                  }
    
                  uses SLAVE-CONTENT;
                }  // list ethernet
    
                list ipv4-or-ipv6 {
                  when
                    "../transport = 'ipv4' or ../transport = 'ipv6'" {
                    description
                      "../Transport = IPv4 or ../Transport = IPv6";
                  }
                  key "slave-ip-address";
                  description "ipv4 or ipv6";
                  leaf slave-ip-address {
                    type inet:ip-address-no-zone;
                    description
                      "Slave IP Address";
                  }
    
                  uses SLAVE-CONTENT;
                }  // list ipv4-or-ipv6
              }  // list slave
            }  // container slaves
    
            container sync-interval {
              description "Sync interval";
              leaf time-type {
                type dt1:Ptp-time;
                default "interval";
                description
                  "Interval or Frequency";
              }
    
              leaf time-period {
                type dt1:Ptp-time-period;
                default "1";
                description "Time Period";
              }
            }  // container sync-interval
    
            container masters {
              description
                "Table for master configuration";
              list master {
                must "ethernet or ipv4-or-ipv6" {
                  description
                    "Ethernet or IPv4-or-IPv6 must be present.";
                }
                key "transport";
                description
                  "Master configuration";
                grouping MASTER-CONTENT {
                  description "MASTER CONTENT";
                  container delay-asymmetry {
                    description
                      "The delay asymmetry for this master";
                    leaf magnitude {
                      type int32 {
                        range
                          "-500000000..500000000";
                      }
                      default "0";
                      description
                        "How much longer the master to slave path
                       takes than the reverse";
                    }
    
                    leaf units {
                      type dt1:Ptp-delay-asymmetry-units;
                      default "nanoseconds";
                      description
                        "The units to use for the delay asymmetry";
                    }
                  }  // container delay-asymmetry
    
                  leaf master-clock-class {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Master clock class";
                  }
    
                  leaf non-negotiated {
                    type boolean;
                    description
                      "Enable non-negotiated unicast on this
                     interface";
                  }
    
                  leaf priority {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Master priority";
                  }
    
                  leaf communication {
                    type dt1:Ptp-transport;
                    default "unicast";
                    description
                      "Communication Model";
                  }
                }  // grouping MASTER-CONTENT
                leaf transport {
                  type dt1:Ptp-encap;
                  description
                    "Master Transport Type";
                }
    
                list ethernet {
                  when
                    "../transport = 'ethernet'" {
                    description
                      "../Transport = Ethernet";
                  }
                  key "master-mac-address";
                  description "ethernet";
                  leaf master-mac-address {
                    type yang:mac-address;
                    description
                      "Master MAC Address - only used if Transport
                     is Ethernet";
                  }
    
                  uses MASTER-CONTENT;
                }  // list ethernet
    
                list ipv4-or-ipv6 {
                  when
                    "../transport = 'ipv4' or ../transport = 'ipv6'" {
                    description
                      "../Transport = IPv4 or ../Transport = IPv6";
                  }
                  key "master-ip-address";
                  description "ipv4 or ipv6";
                  leaf master-ip-address {
                    type inet:ip-address-no-zone;
                    description
                      "Master IP Address - used if Transport is not
                     Ethernet";
                  }
    
                  uses MASTER-CONTENT;
                }  // list ipv4-or-ipv6
              }  // list master
            }  // container masters
    
            container delay-asymmetry {
              description
                "Delay asymmetry to apply to all masters on the
               interface";
              leaf magnitude {
                type int32 {
                  range "-500000000..500000000";
                }
                default "0";
                description
                  "How much longer the master to slave path takes
                 than the reverse";
              }
    
              leaf units {
                type dt1:Ptp-delay-asymmetry-units;
                default "nanoseconds";
                description
                  "The units to use for the delay asymmetry";
              }
            }  // container delay-asymmetry
    
            container communication {
              description "Communication model";
              leaf model {
                type dt1:Ptp-transport;
                default "unicast";
                description
                  "Communication Model";
              }
    
              leaf target-address-set {
                type boolean;
                default "false";
                description "Target address set";
              }
    
              leaf target-address {
                type string;
                description "Target address";
              }
            }  // container communication
    
            container delay-request-minimum-interval {
              description
                "Minimum delay request interval";
              leaf time-type {
                type dt1:Ptp-time;
                default "interval";
                description
                  "Interval or Frequency";
              }
    
              leaf time-period {
                type dt1:Ptp-time-period;
                default "1";
                description "Time Period";
              }
            }  // container delay-request-minimum-interval
    
            leaf sync-grant-duration {
              type uint32 {
                range "60..1000";
              }
              units "second";
              default "300";
              description
                "Sync unicast grant duration, in seconds";
            }
    
            leaf general-cos {
              type uint32 {
                range "0..7";
              }
              default "6";
              description "General COS";
            }
    
            leaf enable {
              type empty;
              description
                "Enable the precision time protocol";
            }
    
            leaf sync-timeout {
              type uint32 {
                range "100..100000";
              }
              units "millisecond";
              default "5000";
              description
                "Sync timeout, in milliseconds";
            }
    
            leaf transport {
              type dt1:Ptp-encap;
              default "ipv4";
              description "Transport";
            }
    
            leaf profile {
              type string;
              description
                "Precision Time Protocol configuration profile";
            }
    
            leaf announce-timeout {
              type uint32 {
                range "2..10";
              }
              default "3";
              description "Announce Timeout";
            }
    
            leaf cos {
              type uint32 {
                range "0..7";
              }
              default "6";
              description "COS";
            }
    
            leaf ipv4ttl {
              type uint32 {
                range "1..255";
              }
              default "255";
              description "IPv4 TTL";
            }
    
            leaf port-state {
              type dt1:Ptp-port-state;
              default "any";
              description
                "Port state restriction";
            }
    
            leaf delay-response-timeout {
              type uint32 {
                range "100..100000";
              }
              units "millisecond";
              default "5000";
              description
                "Delay-Response timeout, in milliseconds";
            }
    
            leaf local-priority {
              type uint32 {
                range "1..255";
              }
              default "128";
              description "Local priority";
            }
    
            leaf delay-response-grant-duration {
              type uint32 {
                range "60..1000";
              }
              units "second";
              default "300";
              description
                "Delay-Response unicast grant duration, in
               seconds";
            }
    
            leaf event-cos {
              type uint32 {
                range "0..7";
              }
              default "6";
              description "Event COS";
            }
    
            leaf dscp {
              type uint32 {
                range "0..63";
              }
              default "46";
              description "DSCP";
            }
    
            leaf ipv6-hop-limit {
              type uint32 {
                range "1..255";
              }
              default "255";
              description "IPv6 Hop Limit";
            }
    
            leaf general-dscp {
              type uint32 {
                range "0..63";
              }
              default "46";
              description "General DSCP";
            }
    
            leaf clock-operation {
              type dt1:Ptp-clock-operation;
              default "two-step";
              description "Clock Operation";
            }
    
            leaf announce-grant-duration {
              type uint32 {
                range "60..1000";
              }
              units "second";
              default "300";
              description
                "Announce unicast grant duration, in seconds";
            }
    
            leaf unicast-grant-invalid-request {
              type dt1:Ptp-invalid-unicast-grant-request-response;
              default "reduce";
              description
                "Invalid unicast grant request response";
            }
    
            leaf event-dscp {
              type uint32 {
                range "0..63";
              }
              default "46";
              description "Event DSCP";
            }
          }  // container ptp
        }
    
        container ptp {
          presence "CLI submode compatibility.";
          description "PTP global configuration";
          container clock {
            description
              "PTP local clock configuration";
            container clock-profile {
              description
                "Local clock PTP profile";
              leaf clock-profile {
                type dt1:Ptp-clock-profile;
                default "default";
                description "Clock profile";
              }
    
              leaf telecom-clock-type {
                when
                  "../clock-profile = 'g82651' or ../clock-profile = 'g82751' or ../clock-profile = 'g82752'" {
                  description
                    "../ClockProfile = G82651 or ../ClockProfile
                   = G82751 or ../ClockProfile = G82752";
                }
                type dt1:Ptp-telecom-clock;
                description "Telecom clock type";
              }
            }  // container clock-profile
    
            container identity {
              description "Local clock identity";
              leaf clock-id-type {
                type dt1:Ptp-clock-id;
                default "router-mac";
                description
                  "Clock identity type";
              }
    
              leaf mac-address {
                when
                  "../clock-id-type = 'user-mac'" {
                  description
                    "../ClockIDType = UserMAC";
                }
                type yang:mac-address;
                description "MAC Address";
              }
    
              leaf eui {
                when "../clock-id-type = 'eui'" {
                  description
                    "../ClockIDType = EUI";
                }
                type string;
                description "EUI-64 number";
              }
            }  // container identity
    
            leaf timescale {
              type dt1:Ptp-timescale;
              description
                "Local clock timescale";
            }
    
            leaf domain {
              type uint32 {
                range "0..255";
              }
              default "0";
              description "Local clock domain";
            }
    
            leaf priority2 {
              type uint32 {
                range "0..255";
              }
              default "128";
              description
                "Local clock priority2";
            }
    
            leaf time-source {
              type dt1:Ptp-time-source;
              description
                "Local clock time source";
            }
    
            leaf priority1 {
              type uint32 {
                range "0..255";
              }
              default "128";
              description
                "Local clock priority1";
            }
    
            leaf clock-class {
              type uint32 {
                range "0..255";
              }
              default "0";
              description "Local clock class";
            }
          }  // container clock
    
          container profiles {
            description
              "Table for profile configuration";
            list profile {
              key "profile-name";
              description
                "Profile configuration";
              container announce-interval {
                description "Announce interval";
                leaf time-type {
                  type dt1:Ptp-time;
                  default "interval";
                  description
                    "Interval or Frequency";
                }
    
                leaf time-period {
                  type dt1:Ptp-time-period;
                  default "2";
                  description "Time Period";
                }
              }  // container announce-interval
    
              container interop {
                description
                  "Table for interop configuration";
                container egress-conversion {
                  description
                    "Iteroperation configuration to be used on
                   egress";
                  container clock-class-mappings {
                    description
                      "Table for specific mappings for given clock
                     class values";
                    list clock-class-mapping {
                      key "clock-class-from";
                      description
                        "Mapping for a given clock class value";
                      leaf clock-class-from {
                        type uint32 {
                          range "0..255";
                        }
                        description
                          "Clock Class to map from";
                      }
    
                      leaf clock-class-to {
                        type uint32 {
                          range "0..255";
                        }
                        mandatory true;
                        description
                          "Clock class to map to";
                      }
                    }  // list clock-class-mapping
                  }  // container clock-class-mappings
    
                  leaf clock-accuracy {
                    type uint32 {
                      range "0..254";
                    }
                    description
                      "Clock Accuracy value to use for the peer
                     clock";
                  }
    
                  leaf priority2 {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Priority2 value to use for the peer clock";
                  }
    
                  leaf clock-class-default {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Default clock class to use when a more
                     specific mapping is not available";
                  }
    
                  leaf offset-scaled-log-variance {
                    type uint32 {
                      range "0..65535";
                    }
                    description
                      "OSLV value to use for the peer clock";
                  }
    
                  leaf priority1 {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Priority1 value to use for the peer clock";
                  }
                }  // container egress-conversion
    
                container ingress-conversion {
                  description
                    "Iteroperation configuration to be used on
                   ingress";
                  container clock-class-mappings {
                    description
                      "Table for specific mappings for given clock
                     class values";
                    list clock-class-mapping {
                      key "clock-class-from";
                      description
                        "Mapping for a given clock class value";
                      leaf clock-class-from {
                        type uint32 {
                          range "0..255";
                        }
                        description
                          "Clock Class to map from";
                      }
    
                      leaf clock-class-to {
                        type uint32 {
                          range "0..255";
                        }
                        mandatory true;
                        description
                          "Clock class to map to";
                      }
                    }  // list clock-class-mapping
                  }  // container clock-class-mappings
    
                  leaf clock-accuracy {
                    type uint32 {
                      range "0..254";
                    }
                    description
                      "Clock Accuracy value to use for the peer
                     clock";
                  }
    
                  leaf priority2 {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Priority2 value to use for the peer clock";
                  }
    
                  leaf clock-class-default {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Default clock class to use when a more
                     specific mapping is not available";
                  }
    
                  leaf offset-scaled-log-variance {
                    type uint32 {
                      range "0..65535";
                    }
                    description
                      "OSLV value to use for the peer clock";
                  }
    
                  leaf priority1 {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Priority1 value to use for the peer clock";
                  }
                }  // container ingress-conversion
    
                leaf profile {
                  type dt1:Ptp-clock-profile;
                  description
                    "Profile to interoperate with";
                }
    
                leaf domain {
                  type uint32 {
                    range "0..255";
                  }
                  description
                    "Domain number of the peer clock";
                }
              }  // container interop
    
              container source-ipv4-address {
                description
                  "Source IPv4 Address";
                leaf enable {
                  type boolean;
                  description
                    "Enable source IP address";
                }
    
                leaf source-ip {
                  type inet:ipv4-address-no-zone;
                  description
                    "Source IP address to use";
                }
              }  // container source-ipv4-address
    
              container slaves {
                description
                  "Table for slave configuration";
                list slave {
                  must
                    "ethernet or ipv4-or-ipv6" {
                    description
                      "Ethernet or IPv4-or-IPv6 must be present.";
                  }
                  key "transport";
                  description
                    "Slave configuration";
                  grouping SLAVE-CONTENT {
                    description "SLAVE CONTENT";
                    leaf non-negotiated {
                      type boolean;
                      description
                        "Enable non-negotiated unicast on this
                       interface";
                    }
                  }  // grouping SLAVE-CONTENT
                  leaf transport {
                    type dt1:Ptp-encap;
                    description
                      "Slave Transport Type";
                  }
    
                  list ethernet {
                    when
                      "../transport = 'ethernet'" {
                      description
                        "../Transport = Ethernet";
                    }
                    key "slave-mac-address";
                    description "ethernet";
                    leaf slave-mac-address {
                      type yang:mac-address;
                      description
                        "Slave MAC Address";
                    }
    
                    uses SLAVE-CONTENT;
                  }  // list ethernet
    
                  list ipv4-or-ipv6 {
                    when
                      "../transport = 'ipv4' or ../transport = 'ipv6'" {
                      description
                        "../Transport = IPv4 or ../Transport = IPv6";
                    }
                    key "slave-ip-address";
                    description "ipv4 or ipv6";
                    leaf slave-ip-address {
                      type inet:ip-address-no-zone;
                      description
                        "Slave IP Address";
                    }
    
                    uses SLAVE-CONTENT;
                  }  // list ipv4-or-ipv6
                }  // list slave
              }  // container slaves
    
              container sync-interval {
                description "Sync interval";
                leaf time-type {
                  type dt1:Ptp-time;
                  default "interval";
                  description
                    "Interval or Frequency";
                }
    
                leaf time-period {
                  type dt1:Ptp-time-period;
                  default "1";
                  description "Time Period";
                }
              }  // container sync-interval
    
              container masters {
                description
                  "Table for master configuration";
                list master {
                  must
                    "ethernet or ipv4-or-ipv6" {
                    description
                      "Ethernet or IPv4-or-IPv6 must be present.";
                  }
                  key "transport";
                  description
                    "Master configuration";
                  grouping MASTER-CONTENT {
                    description "MASTER CONTENT";
                    container delay-asymmetry {
                      description
                        "The delay asymmetry for this master";
                      leaf magnitude {
                        type int32 {
                          range
                            "-500000000..500000000";
                        }
                        default "0";
                        description
                          "How much longer the master to slave path
                         takes than the reverse";
                      }
    
                      leaf units {
                        type dt1:Ptp-delay-asymmetry-units;
                        default "nanoseconds";
                        description
                          "The units to use for the delay asymmetry";
                      }
                    }  // container delay-asymmetry
    
                    leaf master-clock-class {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Master clock class";
                    }
    
                    leaf non-negotiated {
                      type boolean;
                      description
                        "Enable non-negotiated unicast on this
                       interface";
                    }
    
                    leaf priority {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Master priority";
                    }
    
                    leaf communication {
                      type dt1:Ptp-transport;
                      default "unicast";
                      description
                        "Communication Model";
                    }
                  }  // grouping MASTER-CONTENT
                  leaf transport {
                    type dt1:Ptp-encap;
                    description
                      "Master Transport Type";
                  }
    
                  list ethernet {
                    when
                      "../transport = 'ethernet'" {
                      description
                        "../Transport = Ethernet";
                    }
                    key "master-mac-address";
                    description "ethernet";
                    leaf master-mac-address {
                      type yang:mac-address;
                      description
                        "Master MAC Address - only used if Transport
                       is Ethernet";
                    }
    
                    uses MASTER-CONTENT;
                  }  // list ethernet
    
                  list ipv4-or-ipv6 {
                    when
                      "../transport = 'ipv4' or ../transport = 'ipv6'" {
                      description
                        "../Transport = IPv4 or ../Transport = IPv6";
                    }
                    key "master-ip-address";
                    description "ipv4 or ipv6";
                    leaf master-ip-address {
                      type inet:ip-address-no-zone;
                      description
                        "Master IP Address - used if Transport is
                       not Ethernet";
                    }
    
                    uses MASTER-CONTENT;
                  }  // list ipv4-or-ipv6
                }  // list master
              }  // container masters
    
              container delay-asymmetry {
                description
                  "Delay asymmetry to apply to all masters on an
                 interface";
                leaf magnitude {
                  type int32 {
                    range
                      "-500000000..500000000";
                  }
                  default "0";
                  description
                    "How much longer the master to slave path
                   takes than the reverse";
                }
    
                leaf units {
                  type dt1:Ptp-delay-asymmetry-units;
                  default "nanoseconds";
                  description
                    "The units to use for the delay asymmetry";
                }
              }  // container delay-asymmetry
    
              container communication {
                description
                  "Communication model";
                leaf model {
                  type dt1:Ptp-transport;
                  default "unicast";
                  description
                    "Communication Model";
                }
    
                leaf target-address-set {
                  type boolean;
                  default "false";
                  description
                    "Target address set";
                }
    
                leaf target-address {
                  type string;
                  description "Target address";
                }
              }  // container communication
    
              container delay-request-minimum-interval {
                description
                  "Minimum delay request interval";
                leaf time-type {
                  type dt1:Ptp-time;
                  default "interval";
                  description
                    "Interval or Frequency";
                }
    
                leaf time-period {
                  type dt1:Ptp-time-period;
                  default "1";
                  description "Time Period";
                }
              }  // container delay-request-minimum-interval
    
              container source-ipv6-address {
                description
                  "Source IPv6 Address";
                leaf enable {
                  type boolean;
                  description
                    "Enable source IPv6 address";
                }
    
                leaf source-ipv6 {
                  type inet:ipv6-address-no-zone;
                  description
                    "Source IPv6 address to use";
                }
              }  // container source-ipv6-address
    
              leaf sync-grant-duration {
                type uint32 {
                  range "60..1000";
                }
                units "second";
                default "300";
                description
                  "Sync unicast grant duration, in seconds";
              }
    
              leaf general-cos {
                type uint32 {
                  range "0..7";
                }
                default "6";
                description "General COS";
              }
    
              leaf sync-timeout {
                type uint32 {
                  range "100..100000";
                }
                units "millisecond";
                default "5000";
                description
                  "Sync timeout, in milliseconds";
              }
    
              leaf transport {
                type dt1:Ptp-encap;
                default "ipv4";
                description "Transport";
              }
    
              leaf announce-timeout {
                type uint32 {
                  range "2..10";
                }
                default "3";
                description "Announce Timeout";
              }
    
              leaf cos {
                type uint32 {
                  range "0..7";
                }
                default "6";
                description "COS";
              }
    
              leaf ipv4ttl {
                type uint32 {
                  range "1..255";
                }
                default "255";
                description "IPv4 TTL";
              }
    
              leaf port-state {
                type dt1:Ptp-port-state;
                default "any";
                description
                  "Port state restriction";
              }
    
              leaf delay-response-timeout {
                type uint32 {
                  range "100..100000";
                }
                units "millisecond";
                default "5000";
                description
                  "Delay-Response timeout, in milliseconds";
              }
    
              leaf delay-response-grant-duration {
                type uint32 {
                  range "60..1000";
                }
                units "second";
                default "300";
                description
                  "Delay-Response unicast grant duration, in
                 seconds";
              }
    
              leaf event-cos {
                type uint32 {
                  range "0..7";
                }
                default "6";
                description "Event COS";
              }
    
              leaf dscp {
                type uint32 {
                  range "0..63";
                }
                default "46";
                description "DSCP";
              }
    
              leaf ipv6-hop-limit {
                type uint32 {
                  range "1..255";
                }
                default "255";
                description "IPv6 Hop Limit";
              }
    
              leaf general-dscp {
                type uint32 {
                  range "0..63";
                }
                default "46";
                description "General DSCP";
              }
    
              leaf clock-operation {
                type dt1:Ptp-clock-operation;
                default "two-step";
                description "Clock Operation";
              }
    
              leaf announce-grant-duration {
                type uint32 {
                  range "60..1000";
                }
                units "second";
                default "300";
                description
                  "Announce unicast grant duration, in seconds";
              }
    
              leaf unicast-grant-invalid-request {
                type dt1:Ptp-invalid-unicast-grant-request-response;
                default "reduce";
                description
                  "Invalid unicast grant request response";
              }
    
              leaf event-dscp {
                type uint32 {
                  range "0..63";
                }
                default "46";
                description "Event DSCP";
              }
    
              leaf profile-name {
                type xr:Cisco-ios-xr-string;
                description "Profile";
              }
            }  // list profile
          }  // container profiles
    
          container utc-offset {
            description
              "UTC offset configuration";
            container leap-second-file {
              presence
                "Indicates a leap-second-file node is configured.";
              description
                "Source file containing leap second information";
              leaf source-url {
                type string;
                mandatory true;
                description "URL of source file";
              }
    
              leaf polling-frequency {
                type uint32 {
                  range "1..365";
                }
                units "day";
                description
                  "Polling frequency, in days";
              }
            }  // container leap-second-file
    
            container scheduled-offsets {
              description
                "Table for scheduled UTC offset configuration";
              list scheduled-offset {
                key "date";
                description
                  "Scheduled UTC offset configuration";
                leaf date {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Offset application date, in ISO-8601 format
                   (YYYY-MM-DD)";
                }
    
                leaf offset {
                  type uint32 {
                    range "0..32767";
                  }
                  units "second";
                  mandatory true;
                  description
                    "UTC offset, in seconds";
                }
              }  // list scheduled-offset
            }  // container scheduled-offsets
    
            leaf base-offset {
              type uint32 {
                range "0..32767";
              }
              units "second";
              description
                "Base UTC offset configuration";
            }
          }  // container utc-offset
    
          container logging {
            description
              "PTP logging configuration";
            container best-master-clock {
              description
                "PTP best master clock logging configuration";
              leaf changes {
                type empty;
                description
                  "Enable best master clock changes logging";
              }
            }  // container best-master-clock
          }  // container logging
    
          leaf uncalibrated-clock-class {
            type uint32 {
              range "0..255";
            }
            status obsolete;
            description
              "Clock class to be used while acquiring
             phase-lock to a parent clock. Note that
             this is deprecated and should not be
             used.";
          }
    
          container uncalibrated-clock-class2 {
            presence
              "Indicates a uncalibrated-clock-class2 node is configured.";
            description
              "Clock class to be used while acquiring
             phase-lock to a parent clock.";
            leaf clock-class {
              type uint32 {
                range "0..255";
              }
              mandatory true;
              description "Clock Class";
            }
    
            leaf unless-from-holdover {
              type boolean;
              description
                "Unless from holdover flag";
            }
          }  // container uncalibrated-clock-class2
    
          container transparent-clock {
            description
              "Transparent clock configuration";
            container domains {
              description
                "Table of domains containing transparent clock
               configuration";
              list domain {
                key "domain";
                description
                  "Transparent clock domain configuration";
                leaf domain {
                  type dt1:Transparent-clock-domain;
                  description "Domain";
                }
              }  // list domain
            }  // container domains
          }  // container transparent-clock
    
          container virtual-port {
            presence
              "CLI submode compatibility.";
            description
              "PTP virtual port configuration";
            leaf clock-accuracy {
              type uint32 {
                range "0..254";
              }
              description
                "Virtual port clock accuracy";
            }
    
            leaf priority2 {
              type uint32 {
                range "0..255";
              }
              description
                "Virtual port priority2";
            }
    
            leaf local-priority {
              type uint32 {
                range "1..255";
              }
              description
                "Virtual port local priority";
            }
    
            leaf offset-scaled-log-variance {
              type uint32 {
                range "0..65535";
              }
              description "Virtual port OSLV";
            }
    
            leaf priority1 {
              type uint32 {
                range "0..255";
              }
              description
                "Virtual port priority1";
            }
    
            leaf clock-class {
              type uint32 {
                range "0..255";
              }
              description
                "Virtual port clock class";
            }
          }  // container virtual-port
    
          leaf time-of-day-priority {
            type uint32 {
              range "1..254";
            }
            default "100";
            description "Time-of-day priority";
          }
    
          leaf frequency-priority {
            type uint32 {
              range "1..254";
            }
            default "254";
            description "Frequency priority";
          }
    
          leaf holdover-spec-clock-class {
            type uint32 {
              range "0..255";
            }
            description
              "Holdover spec clock-class";
          }
    
          leaf startup-clock-class {
            type uint32 {
              range "0..255";
            }
            description
              "Startup clock class value";
          }
    
          leaf verify-checksum {
            type empty;
            description "Enable verify-checksum";
          }
    
          leaf min-clock-class {
            type uint32 {
              range "0..255";
            }
            description
              "Clocks with a clock-class higher than the
             minimum clock class will not be considered for
             selection as a parent clock.";
          }
    
          leaf holdover-spec-traceable-override {
            type empty;
            description
              "Override time-traceability while in holdover";
          }
    
          leaf assisted-partial-timing-support {
            type empty;
            description
              "Enable assisted partial timing support";
          }
    
          leaf network-type-high-pdv {
            type empty;
            description
              "The network has high packet delay variation";
          }
    
          leaf holdover-spec-duration {
            type uint32;
            units "second";
            description
              "Holdover spec duration (seconds)";
          }
    
          leaf uncalibrated-traceable-override {
            type empty;
            description
              "Override time-traceability to true while
             acquiring phase lock to a parent clock.";
          }
    
          leaf physical-layer-frequency {
            type empty;
            description
              "Disable PTP as a source for frequency as only
             physical layer frequency sources are used";
          }
    
          leaf freerun-clock-class {
            type uint32 {
              range "0..255";
            }
            description
              "Freerun clock class value";
          }
    
          leaf servo-slow-tracking {
            type uint32 {
              range "8..984";
            }
            description
              "Restrict the rate, in ns per second, at which
             the servo may track to update the time and
             attain sync";
          }
        }  // container ptp
      }  // module Cisco-IOS-XR-ptp-cfg
    

© 2024 YumaWorks, Inc. All rights reserved.