module Cisco-IOS-XR-asr9k-lc-ethctrl-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-asr9k-lc-ethctrl-oper";

    prefix asr9k-lc-ethctrl-oper;

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-asr9k-lc-ethctrl-oper-sub1 {
      revision-date "2019-04-05";
    }

    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 asr9k-lc-ethctrl package operational data.
     
     This module contains definitions
     for the following management objects:
       mlan: Management LAN Operational data space
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.0.0";

    container mlan {
      config false;
      description
        "Management LAN Operational data space";
      container nodes {
        description "Table of nodes";
        list node {
          key "node";
          description "Number";
          container port-status-numbers {
            description
              "Table of port status";
            list port-status-number {
              key "number";
              description "Number";
              container port-status {
                description
                  "mlan port status info";
                container config {
                  description
                    "Configuration Data";
                  leaf speed {
                    type uint32;
                    description "speed";
                  }

                  leaf duplex {
                    type uint32;
                    description "duplex";
                  }

                  leaf pause {
                    type uint16;
                    description "pauseEn";
                  }

                  leaf my-pause {
                    type uint16;
                    description "myPause";
                  }

                  leaf loopback {
                    type uint32;
                    description "loopback";
                  }
                }  // container config

                container phy {
                  description
                    "PHY Registers";
                  list reg {
                    max-elements 32;
                    description "reg";
                    leaf entry {
                      type uint16;
                      description "reg";
                    }
                  }  // list reg
                }  // container phy

                container serdes {
                  description
                    "SERDES Registers";
                  list reg {
                    max-elements 32;
                    description "reg";
                    leaf entry {
                      type uint16;
                      description "reg";
                    }
                  }  // list reg
                }  // container serdes

                container mac {
                  description
                    "MAC Registers";
                  list reg {
                    max-elements 32;
                    description "reg";
                    leaf entry {
                      type uint16;
                      description "reg";
                    }
                  }  // list reg
                }  // container mac

                leaf port-num {
                  type uint32;
                  description "Port Number";
                }

                leaf phy-valid {
                  type uint32;
                  description
                    "PHY data valid";
                }

                leaf serdes-valid {
                  type uint32;
                  description
                    "SERDES data valid";
                }

                leaf mac-valid {
                  type uint32;
                  description
                    "MAC data valid";
                }
              }  // container port-status

              leaf number {
                type uint32;
                description "port number";
              }
            }  // list port-status-number
          }  // container port-status-numbers

          container switch-status-table {
            description
              "Table of switch status";
            container switch-status {
              description
                "mlan switch status info";
              container sw-reg-1 {
                description
                  "Switch Global Registers";
                list reg {
                  max-elements 32;
                  description "reg";
                  leaf entry {
                    type uint16;
                    description "reg";
                  }
                }  // list reg
              }  // container sw-reg-1

              container sw-reg-2 {
                description
                  "Switch Global Registers";
                list reg {
                  max-elements 32;
                  description "reg";
                  leaf entry {
                    type uint16;
                    description "reg";
                  }
                }  // list reg
              }  // container sw-reg-2

              container sw-status {
                description
                  "Switch Status Data";
                leaf ppu {
                  type uint32;
                  description "ppu";
                }

                leaf mtu {
                  type uint32;
                  description "mtu";
                }

                leaf mac {
                  type string {
                    length "0..6";
                  }
                  description "mac";
                }

                leaf cpu-port {
                  type uint16;
                  description "cpu port";
                }

                leaf cpu-mac {
                  type uint16;
                  description "cpu mac";
                }

                leaf initialized {
                  type uint16;
                  description "initialized";
                }

                leaf restarted {
                  type uint16;
                  description "restarted";
                }
              }  // container sw-status

              leaf rate-limit {
                type int32;
                description
                  "CPU Interface Rate Limit";
              }
            }  // container switch-status
          }  // container switch-status-table

          container port-counters-numbers {
            description
              "Table of port counters";
            list port-counters-number {
              key "number";
              description "Number";
              container port-counters {
                description
                  "mlan port counters info";
                container mlan-stats {
                  description
                    "Switch Port Statistics";
                  leaf in-good-octets-hi {
                    type uint32;
                    description
                      "inGoodOctets hi";
                  }

                  leaf in-good-octets {
                    type uint32;
                    description
                      "inGoodOctets";
                  }

                  leaf in-bad-octets {
                    type uint32;
                    description
                      "inBadOctets";
                  }

                  leaf in-unicast-pkt {
                    type uint32;
                    description
                      "inUnicastPkt";
                  }

                  leaf in-bcast-pkt {
                    type uint32;
                    description "inBcastPkt";
                  }

                  leaf in-mcast-pkt {
                    type uint32;
                    description "inMcastPkt";
                  }

                  leaf in-pause-pkt {
                    type uint32;
                    description "inPausePkt";
                  }

                  leaf in-undersize-pkt {
                    type uint32;
                    description
                      "inUndersizePkt";
                  }

                  leaf in-fragments {
                    type uint32;
                    description
                      "inFragments";
                  }

                  leaf in-oversize {
                    type uint32;
                    description "inOversize";
                  }

                  leaf in-jabber {
                    type uint32;
                    description "inJabber";
                  }

                  leaf in-rx-err {
                    type uint32;
                    description "inRxErr";
                  }

                  leaf in-fcs-err {
                    type uint32;
                    description "inFcsErr";
                  }

                  leaf out-octets-hi {
                    type uint32;
                    description
                      "outOctets hi";
                  }

                  leaf out-octets {
                    type uint32;
                    description "outOctets";
                  }

                  leaf out-unicast-pkt {
                    type uint32;
                    description
                      "outUnicastPkt";
                  }

                  leaf out-bcast-pkt {
                    type uint32;
                    description
                      "outBcastPkt";
                  }

                  leaf out-mcast-pkt {
                    type uint32;
                    description
                      "outMcastPkt";
                  }

                  leaf out-pause-pkt {
                    type uint32;
                    description
                      "outPausePkt";
                  }

                  leaf excessive {
                    type uint32;
                    description "excessive";
                  }

                  leaf collisions {
                    type uint32;
                    description "collisions";
                  }

                  leaf deferred {
                    type uint32;
                    description "deferred";
                  }

                  leaf single {
                    type uint32;
                    description "single";
                  }

                  leaf multiple {
                    type uint32;
                    description "multiple";
                  }

                  leaf out-fcs-err {
                    type uint32;
                    description "outFcsErr";
                  }

                  leaf late {
                    type uint32;
                    description "late";
                  }

                  leaf rx-tx-64-octets {
                    type uint32;
                    description
                      "rx tx 64 Octets";
                  }

                  leaf rx-tx-65-127-octets {
                    type uint32;
                    description
                      "rx tx 65 127 Octets";
                  }

                  leaf rx-tx-128-255-octets {
                    type uint32;
                    description
                      "rx tx 128 255 Octets";
                  }

                  leaf rx-tx-256-511-octets {
                    type uint32;
                    description
                      "rx tx 256 511 Octets";
                  }

                  leaf rx-tx-512-1023-octets {
                    type uint32;
                    description
                      "rx tx 512 1023 Octets";
                  }

                  leaf rx-tx-1024-max-octets {
                    type uint32;
                    description
                      "rx tx 1024 Max Octets";
                  }

                  leaf in-discards {
                    type uint32;
                    description "inDiscards";
                  }

                  leaf in-filtered {
                    type uint32;
                    description "inFiltered";
                  }

                  leaf out-filtered {
                    type uint32;
                    description
                      "outFiltered";
                  }
                }  // container mlan-stats

                leaf port-num {
                  type uint32;
                  description "Port Number";
                }
              }  // container port-counters

              leaf number {
                type uint32;
                description "port number";
              }
            }  // list port-counters-number
          }  // container port-counters-numbers

          container atu-entry-numbers {
            description
              "Table of switch ATU";
            list atu-entry-number {
              key "entry";
              description "Entry number";
              container switch-counters {
                description
                  "mlan switch counters info";
                container atu {
                  description
                    "Switch ATU Data";
                  leaf db-num {
                    type uint16;
                    description "dbNum";
                  }

                  leaf priority {
                    type uint8;
                    description "priority";
                  }

                  leaf trunk {
                    type boolean;
                    description "trunk";
                  }

                  leaf dpv {
                    type uint8;
                    description "dpv";
                  }

                  leaf es {
                    type uint8;
                    description "es";
                  }

                  list macaddr {
                    max-elements 3;
                    description "macaddr";
                    leaf entry {
                      type uint16;
                      description "macaddr";
                    }
                  }  // list macaddr
                }  // container atu

                leaf entry-num {
                  type uint32;
                  description
                    "Index of ATU Entry";
                }
              }  // container switch-counters

              leaf entry {
                type uint32;
                description "entry number";
              }
            }  // list atu-entry-number
          }  // container atu-entry-numbers

          leaf node {
            type xr:Node-id;
            description "node number";
          }
        }  // list node
      }  // container nodes
    }  // container mlan
  }  // module Cisco-IOS-XR-asr9k-lc-ethctrl-oper