module Cisco-IOS-XR-sysadmin-ethsw-esdma-mlap {

    yang-version 1;

    namespace
      "http://www.cisco.com/ns/yang/Cisco-IOS-XR-sysadmin-ethsw-esdma-mlap";

    prefix esdma_mlap;

    import ietf-yang-types {
      prefix ietf;
    }
    import Cisco-IOS-XR-sysadmin-ethsw-esdma-types {
      prefix esdma_types;
    }
    import Cisco-IOS-XR-sysadmin-show-trace {
      prefix show_trace;
    }
    import cisco-semver {
      prefix semver;
    }

    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 the YANG definitions
for the Cisco IOS-XR SysAdmin
'show controller switch mlap' commands.

Copyright(c) 2020 by Cisco Systems, Inc.
All rights reserved.

Copyright (c) 2012-2020 by Cisco Systems, Inc.
All rights reserved.";

    revision "2020-01-10" {
      description
        "Changes for whitebox esdma-mlap cli outputs";
    }

    revision "2019-04-15" {
      description
        "Establish semantic version baseline.";
    }

    revision "2017-05-01" {
      description
        "Namespace change to comply with Cisco guidelines on namespace";
    }

    revision "2016-10-12" {
      description
        "Unhide commands and configs. Moved to advanced-grp";
    }

    revision "2016-07-06" {
      description
        "Initial revision with content extracted from esdma_cli.yang.";
    }

    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    grouping mlap-endpoint-state-info {
      leaf valid {
        type boolean;
        description
          "Indicates whether this endpoint information contains valid data.";
      }

      leaf chassis-type {
        when "../valid = 'true'";
        type esdma_types:esdma-rack-type-enum;
        description
          "The chassis type of this endpoint is in";
      }

      leaf endpoint-type {
        when "../valid = 'true'";
        type esdma_types:esdma-switch-type-enum;
        description
          "The type of endpoint this endpoint switch is on";
      }

      leaf endpoint-slot-number {
        when "../valid = 'true'";
        type uint32;
        description
          "Slot number of this endpoint";
      }

      leaf endpoint-switch-number {
        when "../valid = 'true'";
        type uint32;
        description
          "Switch number for the endpoint";
      }

      leaf endpoint-switch-port-number {
        when "../valid = 'true'";
        type uint32;
        description
          "Port number on the switch for the endpoint";
      }

      leaf endpoint-switch-port-name {
        type string;
        description
          "Port number on the switch for the endpoint";
      }

      leaf endpoint-chassis-serial-number {
        when "../valid = 'true'";
        type string;
        description
          "Serial number for the endpoint";
      }

      leaf mlap-state {
        when "../valid = 'true'";
        type esdma_types:mlap-state-enum;
        description
          "Protocol invoked port state";
      }

      leaf inter-fcc_sw-port {
        when "../valid = 'true'";
        type boolean;
        description
          "Indicates whether this port is used for an inter-F-SW connection";
      }

      leaf fcc_sw-indirectly-reachable {
        when "../valid = 'true'";
        type boolean;
        description
          "Indicates whether this port can indirectly reach an F-SW";
      }
    }  // grouping mlap-endpoint-state-info

    grouping mlap-internal-details {
      container mlap-internal-details {
        container info {
          leaf port-owner {
            type esdma_types:esdma-cpu;
            description
              "Indicates which switch data path the port belongs to";
          }

          leaf current-active-owner {
            type esdma_types:esdma-cpu;
            description
              "Indicates which switch is currently mastering chassis data";
          }

          leaf mlap-peer-flags {
            type bits {
              bit Valid {
                position 0;
              }
              bit FCC-Active {
                position 1;
              }
              bit Force-Active {
                position 2;
              }
              bit Ignore-Data {
                position 31;
              }
            }
            description
              "Peer's port MLAP protocol flags";
          }

          leaf mlap-peer-idle-count {
            type uint32;
            description
              "Time intervals peer has not updated information";
          }

          leaf my-connection-active-mask {
            type uint64;
            description
              "My port active mask view";
          }

          leaf peer-connection-active-mask {
            type uint64;
            description
              "Peer's port active mask view";
          }

          leaf endpoint-card-type {
            type esdma_types:mlap-ep-type;
            description
              "Indicates the high-level card type this switch port is peering with";
          }

          leaf endpoint-mac-address {
            type ietf:mac-address;
            description
              "MAC addess of device of the protocol peer for this switch port";
          }
        }  // container info
      }  // container mlap-internal-details
    }  // grouping mlap-internal-details

    grouping mlap-external-details {
      container mlap-external-details {
        container local-state-information {
          description
            "MLAP state information from this port's perspective";
          uses mlap-endpoint-state-info;
        }  // container local-state-information

        container peer-state-information {
          description
            "MLAP state information from peer port's perspective";
          uses mlap-endpoint-state-info;
        }  // container peer-state-information

        container peer-other-link-state-information {
          description
            "MLAP state information for peer's other uplink perspective (RP/SC only)";
          uses mlap-endpoint-state-info;
        }  // container peer-other-link-state-information
      }  // container mlap-external-details
    }  // grouping mlap-external-details

    grouping mlap-detail-data {
      container detail {
        list location {
          key "rack card switch-id";
          leaf rack {
            type esdma_types:esdma-rack-num-enum;
          }

          leaf card {
            type esdma_types:esdma-cpu;
          }

          leaf switch-id {
            type esdma_types:esdma-switch-type-enum;
            description "Switch type";
          }

          list port-iter {
            key "port";
            leaf port {
              type esdma_types:esdma-switch-port-type;
              description "Switch port";
            }

            container gen-data {
              leaf serial-num {
                type string;
                description
                  "Rack serial number";
              }

              leaf connects-to {
                type string;
                description
                  "Indicates what this port connects to";
              }

              leaf phys-state {
                type esdma_types:esdma-switch-port-state;
                description
                  "Physical port state";
              }

              leaf admin-state {
                type esdma_types:esdma-switch-port-state;
                description
                  "Administrative port state";
              }

              leaf protocol-state {
                type esdma_types:mlap-state-enum;
                description
                  "Protocol invoked port state";
              }

              leaf forwarding {
                type esdma_types:switch-forwarding-state;
                description
                  "Indicates whether this port is allowed to forward traffic";
              }

              leaf mlap-protocol {
                type esdma_types:mlap-protocol-enum;
                description
                  "Indicates whether the internal or external MLAP protocol is active on this port";
              }

              leaf protocol-pkt-sent {
                type uint64;
                description
                  "Number of protocol packets sent";
              }

              leaf protocol-pkt-recv {
                type uint64;
                description
                  "Number of protocol packets received";
              }

              leaf protocol-set-color-pkts-sent {
                type uint64;
                description
                  "Number of set-active-VLAN requests";
              }

              leaf protocol-set-color-pkts-recv {
                type uint64;
                description
                  "Number of set-active-VLAN responses";
              }

              leaf protocol-send-error {
                type uint64;
                description
                  "Number of protocol packet send errors";
              }

              leaf protocol-recv-error {
                type uint64;
                description
                  "Number of protocol packet receive errors";
              }

              leaf protocol-state-changes {
                type uint32;
                description
                  "Number of state changes";
              }

              leaf protocol-RxErrorPktLenMismatch {
                type uint64;
                description
                  "Number of recevied packet length mismatch error";
              }

              leaf protocol-RxErrorPktBadVlanEtype {
                type uint64;
                description
                  "Number of recevied packet with bad vlan data";
              }

              leaf protocol-RxErrPktBadVlanData {
                type uint64;
                description
                  "Number of recevied packet with bad vlan data";
              }

              leaf protocol-RxErrPktBadMlapEtype {
                type uint64;
                description
                  "Number of recevied packet with bad mlap Etpye";
              }

              leaf protocol-RxErrPktBadMlapVersion {
                type uint64;
                description
                  "Number of recevied packet with bad mlap version";
              }

              leaf protocol-RxErrPktMlapEtypeLenMismatch {
                type uint64;
                description
                  "Number of recevied packets with MLap Eptype mismatch(interchassis)";
              }

              leaf protocol-RxErrPktLenError {
                type uint64;
                description
                  "Number of recevied packet length error";
              }

              leaf protocol-RxPktBadCCCEtype {
                type uint64;
                description
                  "Number of recevied packet with Bad CCC etype";
              }

              leaf protocol-RxPktBadMlapCCCVersion {
                type uint64;
                description
                  "Number of recevied packet with Bad mlap ccc version";
              }

              leaf protocol-RxPktEtypeCCCLenErr {
                type uint64;
                description
                  "Number of recevied ccc packet with Etype len error";
              }

              leaf protocol-RxErrPktBadSeqCCCMagicIntraChassisProtocalId {
                type uint64;
                description
                  "Number of recevied ccc packets with bad seq magic for protocal ID ";
              }

              leaf protocol-RxErrPktCCCMagicIntraChassisSetVlanId {
                type uint64;
                description
                  "Number of recevied ccc packet with set vlan ID magic number error";
              }

              leaf protocol-RxErrPktCCCPktTypeErr {
                type uint64;
                description
                  "Number of recevied with ccc packet type error";
              }

              leaf protocol-RxErrPktCCCUnsupportedResponse {
                type uint64;
                description
                  "Number of recevied  with ccc pkt unsupported response error";
              }
            }  // container gen-data

            choice detail-type {
              case internal-detail {
                uses mlap-internal-details;
              }  // case internal-detail

              case external-detail {
                uses mlap-external-details;
              }  // case external-detail
            }  // choice detail-type
          }  // list port-iter
        }  // list location
      }  // container detail
    }  // grouping mlap-detail-data

    grouping mlap-summary-data {
      container summary-data {
        list location {
          key "rack card switch-id";
          leaf rack {
            type esdma_types:esdma-rack-num-enum;
          }

          leaf card {
            type esdma_types:esdma-cpu;
            description
              "Card that owns a switch of interest";
          }

          leaf switch-id {
            type esdma_types:esdma-switch-type-enum;
            description "Switch type";
          }

          leaf serial-num {
            type string;
            description "Rack serial number";
          }

          list port-iter {
            key "port";
            leaf port {
              type esdma_types:esdma-switch-port-type;
              description "Switch port";
            }

            leaf port-name {
              type string;
              description "Switch port";
            }

            leaf phys-state {
              type esdma_types:esdma-switch-port-state;
              description
                "Physical port state";
            }

            leaf admin-state {
              type esdma_types:esdma-switch-port-state;
              description
                "Administrative port state";
            }

            leaf protocol-state {
              type esdma_types:mlap-state-enum;
              description
                "Protocol invoked port state";
            }

            leaf forwarding {
              type esdma_types:switch-forwarding-state;
              description
                "Indicates whether this port is allowed to forward traffic";
            }

            leaf mlap-protocol {
              type esdma_types:mlap-protocol-enum;
              description
                "Indicates whether the internal or external MLAP protocol is active on this port";
            }

            leaf connects-to {
              type string;
              description
                "Indicates what this port connects to";
            }

            leaf expected-endpoint {
              type string;
              description
                "Indicates what this port is expected to connect to";
            }

            leaf mismatch-string {
              type string;
              description
                "Indicates whether there is a mismatch";
            }
          }  // list port-iter
        }  // list location
      }  // container summary-data
    }  // grouping mlap-summary-data

    grouping mlap-statistics-data {
      container statistics {
        list location {
          key "rack card switch-id";
          leaf rack {
            type esdma_types:esdma-rack-num-enum;
          }

          leaf card {
            type esdma_types:esdma-cpu;
            description
              "Card that owns a switch of interest";
          }

          leaf switch-id {
            type esdma_types:esdma-switch-type-enum;
            description "Switch type";
          }

          leaf serial-num {
            type string;
            description "Rack serial number";
          }

          list port-iter {
            key "port";
            leaf port {
              type esdma_types:esdma-switch-port-type;
              description "Switch port";
            }

            leaf port-name {
              type string;
              description "Switch port";
            }

            leaf protocol-state {
              type esdma_types:mlap-state-enum;
              description
                "Protocol invoked port state";
            }

            leaf protocol-state-changes {
              type uint32;
              description
                "Number of state changes";
            }

            leaf protocol-pkt-sent {
              type uint64;
              description
                "Number of protocol packets sent";
            }

            leaf protocol-pkt-recv {
              type uint64;
              description
                "Number of protocol packets received";
            }

            leaf protocol-set-color-pkts-sent {
              type uint64;
              description
                "Number of set-active-VLAN requests";
            }

            leaf protocol-set-color-pkts-recv {
              type uint64;
              description
                "Number of set-active-VLAN responses";
            }

            leaf protocol-send-error {
              type uint64;
              description
                "Number of protocol packet send errors";
            }

            leaf protocol-recv-error {
              type uint64;
              description
                "Number of protocol packet receive errors";
            }

            leaf connects-to {
              type string;
              description
                "Indicates what this port connects to";
            }

            leaf expected-endpoint {
              type string;
              description
                "Indicates what this port is expected to connect to";
            }

            leaf mismatch-string {
              type string;
              description
                "Indicates whether there is a mismatch";
            }
          }  // list port-iter
        }  // list location
      }  // container statistics
    }  // grouping mlap-statistics-data

    grouping mlap-reachable-data {
      container reachable {
        list location {
          key "rack card switch-id";
          leaf rack {
            type esdma_types:esdma-rack-num-enum;
          }

          leaf card {
            type esdma_types:esdma-cpu;
          }

          leaf switch-id {
            type esdma_types:esdma-switch-type-enum;
          }
        }  // list location
      }  // container reachable
    }  // grouping mlap-reachable-data

    grouping mlap-debug-counters {
      container debug {
        container counters {
          list location {
            key "rack card switch-id";
            leaf rack {
              type esdma_types:esdma-rack-num-enum;
            }

            leaf card {
              type esdma_types:esdma-cpu;
            }

            leaf switch-id {
              type esdma_types:esdma-switch-type-enum;
            }

            container counters {
              leaf eval-all-links-called {
                type uint64;
              }

              leaf timer-event-queued {
                type uint64;
              }

              leaf rx-packet-event-queued {
                type uint64;
              }

              leaf eval-all-links-queued {
                type uint64;
              }

              leaf link-status-queued {
                type uint64;
              }

              leaf admin-status-queued {
                type uint64;
              }

              leaf fwd-status-queued {
                type uint64;
              }

              leaf current-fifo-depth {
                type uint64;
              }

              leaf max-fifo-depth {
                type uint64;
              }

              leaf vlan-color-changes {
                type uint32;
              }

              leaf current-mlap-timeout-ms-interval {
                type uint32;
              }

              leaf aging-debug-enabled {
                type boolean;
              }

              leaf trace-verbosity {
                type esdma_types:mlap-trace-verbosity;
              }
            }  // container counters
          }  // list location
        }  // container counters
      }  // container debug
    }  // grouping mlap-debug-counters

    grouping mlap-oper-group {
      container mlap {
        description "MLAP switch data";
        uses mlap-reachable-data;

        uses mlap-detail-data;

        uses mlap-statistics-data;

        uses mlap-summary-data;

        uses mlap-debug-counters;

        uses show_trace:traceable;
      }  // container mlap
    }  // grouping mlap-oper-group
  }  // module Cisco-IOS-XR-sysadmin-ethsw-esdma-mlap