module Cisco-IOS-XR-asic-error-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-asic-error-oper";

    prefix asic-error-oper;

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

    include Cisco-IOS-XR-asic-error-oper-sub2 {
      revision-date "2019-09-27";
    }
    include Cisco-IOS-XR-asic-error-oper-sub1 {
      revision-date "2019-09-27";
    }

    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 asic-error package operational data.

This module contains definitions
for the following management objects:
  asic-errors: Error summary of all asics

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

    revision "2019-09-27" {
      description
        "Introduced working oper model for asic-errors.";
    }

    revision "2019-09-24" {
      description
        "Introduced working oper model for asic-errors.";
    }

    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";
    semver:module-version "1.0.0";

    container asic-errors {
      config false;
      description
        "Error summary of all asics";
      container nodes {
        description
          "Asic errors for each available nodes";
        list node {
          key "node-name";
          description
            "Asic error for a particular node";
          leaf node-name {
            type xr:Node-id;
            description "Node ID";
          }

          list asic-information {
            key "asic";
            description "Asic on the node";
            container instances {
              description
                "All asic errors  on the node";
              list instance {
                key "asic-instance";
                description
                  "Particular asic instance on the node";
                container categories {
                  description
                    "Error path of the instances";
                  list category {
                    key "category";
                    description
                      "Error category soft/hard";
                    leaf category {
                      type xr:Cisco-ios-xr-string;
                      description
                        "Error Category soft/hard";
                    }

                    list error-class {
                      key "class";
                      description
                        "Error Classes - supported by asic type";
                      container asic-error-info {
                        description
                          "Asic Error Info";
                        container pacerr-nodes {
                          description
                            "pacerr nodes";
                          list error {
                            description
                              "Collection of errors";
                            leaf name {
                              type string;
                              description
                                "Name assigned to mem";
                            }

                            leaf asic-info {
                              type string;
                              description
                                "Name of rack/board/asic";
                            }

                            leaf node-key {
                              type uint32;
                              description
                                "32 bit key";
                            }

                            leaf alarm-on {
                              type boolean;
                              description
                                "High threshold crossed";
                            }

                            leaf thresh-hi {
                              type uint32;
                              description
                                "High threshold value";
                            }

                            leaf period-hi {
                              type uint32;
                              description
                                "High period value";
                            }

                            leaf thresh-lo {
                              type uint32;
                              description
                                "Low threshold value";
                            }

                            leaf period-lo {
                              type uint32;
                              description
                                "Low period value";
                            }

                            leaf count {
                              type uint32;
                              description
                                "Accumulated count";
                            }

                            leaf block-id {
                              type uint32;
                              description
                                "block where error occurred";
                            }

                            leaf addr {
                              type uint32;
                              description
                                "addr of the error interrupt inside node";
                            }

                            leaf leaf-id {
                              type uint32;
                              description
                                "leaf_id of the error occurred";
                            }

                            leaf intr-type {
                              type uint32;
                              description
                                "Type of error";
                            }

                            leaf last-cleared {
                              type uint64;
                              description
                                "Time  cleared";
                            }

                            list last-err {
                              description
                                "Last Printable error information";
                              leaf at-time {
                                type uint64;
                                description
                                  "at time";
                              }

                              leaf at-time-nsec {
                                type uint64;
                                description
                                  "at time nsec";
                              }

                              leaf counter-val {
                                type uint32;
                                description
                                  "counter val";
                              }

                              leaf error-desc {
                                type string;
                                description
                                  "error desc";
                              }
                            }  // list last-err
                          }  // list error
                        }  // container pacerr-nodes

                        container ciherr-nodes {
                          description
                            "ciherr nodes";
                          list error {
                            description
                              "Collection of errors";
                            leaf name {
                              type string;
                              description
                                "Name assigned to mem";
                            }

                            leaf asic-info {
                              type string;
                              description
                                "Name of rack/board/asic";
                            }

                            leaf node-key {
                              type uint32;
                              description
                                "32 bit key";
                            }

                            leaf alarm-on {
                              type boolean;
                              description
                                "High threshold crossed";
                            }

                            leaf thresh-hi {
                              type uint32;
                              description
                                "High threshold value";
                            }

                            leaf period-hi {
                              type uint32;
                              description
                                "High period value";
                            }

                            leaf thresh-lo {
                              type uint32;
                              description
                                "High threshold value";
                            }

                            leaf period-lo {
                              type uint32;
                              description
                                "High period value";
                            }

                            leaf count {
                              type uint32;
                              description
                                "Accumulated count";
                            }

                            leaf intr-type {
                              type uint32;
                              description
                                "Type of error";
                            }

                            leaf leaf-id {
                              type uint32;
                              description
                                "Leaf ID defined in user data";
                            }

                            leaf last-cleared {
                              type uint64;
                              description
                                "Time  cleared";
                            }

                            list csrs-info {
                              description
                                "List of csrs_info";
                              leaf name {
                                type string;
                                description
                                  "Name of csrs register";
                              }

                              leaf address {
                                type uint64;
                                description
                                  "Address of csrs register";
                              }

                              leaf width {
                                type uint32;
                                description
                                  "Width of csrs register";
                              }
                            }  // list csrs-info

                            list last-err {
                              description
                                "Last Printable error information";
                              leaf at-time {
                                type uint64;
                                description
                                  "Asic error time";
                              }

                              leaf at-time-nsec {
                                type uint64;
                                description
                                  "Asic error nsec";
                              }

                              leaf counter-val {
                                type uint32;
                                description
                                  "Number of occurrence";
                              }

                              leaf error-desc {
                                type string;
                                description
                                  "Error description";
                              }

                              list error-regval {
                                description
                                  "Error register value";
                                leaf entry {
                                  type uint8;
                                  description
                                    "Error register value";
                                }
                              }  // list error-regval
                            }  // list last-err
                          }  // list error
                        }  // container ciherr-nodes

                        container pcie-nodes {
                          description
                            "pcie nodes";
                          list error {
                            description
                              "Collection of errors";
                            leaf name {
                              type string;
                              description
                                "Name assigned to mem";
                            }

                            leaf node-key {
                              type uint32;
                              description
                                "32 bit key";
                            }

                            leaf alarm-on {
                              type boolean;
                              description
                                "High threshold crossed";
                            }

                            leaf thresh-hi {
                              type uint32;
                              description
                                "High threshold value";
                            }

                            leaf period-hi {
                              type uint32;
                              description
                                "High period value";
                            }

                            leaf count {
                              type uint32;
                              description
                                "Accumulated count";
                            }

                            leaf last-cleared {
                              type uint64;
                              description
                                "Time  cleared";
                            }

                            list last-err {
                              description
                                "Collection of last errs";
                              container error-data {
                                description
                                  "error data";
                                container tlp-header-data {
                                  description
                                    "tlp header data";
                                  leaf fmt-type {
                                    type uint32;
                                    description
                                      "fmt type";
                                  }

                                  leaf traffic-class {
                                    type uint32;
                                    description
                                      "traffic class";
                                  }

                                  leaf tlp-digest-field-present {
                                    type boolean;
                                    description
                                      "tlp digest field present";
                                  }

                                  leaf poisoned-data {
                                    type boolean;
                                    description
                                      "poisoned data";
                                  }

                                  leaf relaxed-ordering {
                                    type boolean;
                                    description
                                      "relaxed ordering";
                                  }

                                  leaf no-snoop {
                                    type boolean;
                                    description
                                      "no snoop";
                                  }

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

                                  leaf first-dw-byte-enables {
                                    type uint8;
                                    description
                                      "first dw byte enables";
                                  }

                                  leaf last-dw-byte-enables {
                                    type uint8;
                                    description
                                      "last dw byte enables";
                                  }

                                  leaf-list transaction-descriptor {
                                    type uint8;
                                    description
                                      "transaction descriptor";
                                  }
                                }  // container tlp-header-data

                                leaf err-type {
                                  type uint32;
                                  description
                                    "err type";
                                }

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

                                leaf err-attribute {
                                  type uint32;
                                  description
                                    "err attribute";
                                }

                                leaf is-tlp-header-present {
                                  type boolean;
                                  description
                                    "is tlp header present";
                                }

                                leaf-list raw-tlp-header {
                                  type uint32;
                                  description
                                    "raw tlp header";
                                }
                              }  // container error-data

                              leaf at-time {
                                type uint64;
                                description
                                  "at time";
                              }

                              leaf at-time-nsec {
                                type uint64;
                                description
                                  "at time nsec";
                              }

                              leaf counter-val {
                                type uint32;
                                description
                                  "counter val";
                              }

                              leaf top-ec {
                                type uint32;
                                description
                                  "top ec";
                              }

                              leaf block-ec {
                                type uint32;
                                description
                                  "block ec";
                              }
                            }  // list last-err
                          }  // list error
                        }  // container pcie-nodes
                      }  // container asic-error-info

                      leaf class {
                        type xr:Cisco-ios-xr-string;
                        description
                          "Error Class";
                      }
                    }  // list error-class
                  }  // list category
                }  // container categories

                container instance-summary {
                  description
                    "Summary for a specific instance";
                  leaf num-nodes {
                    type uint32;
                    description
                      "Number of nodes";
                  }

                  leaf crc-err-count {
                    type uint32;
                    description
                      "CRC Error Count";
                  }

                  leaf sbe-err-count {
                    type uint32;
                    description
                      "Single Bit Error Count";
                  }

                  leaf mbe-err-count {
                    type uint32;
                    description
                      "Multi-Bit Error Count";
                  }

                  leaf par-err-count {
                    type uint32;
                    description
                      "Parity Error Count";
                  }

                  leaf gen-err-count {
                    type uint32;
                    description
                      "General Error Count";
                  }

                  leaf reset-err-count {
                    type uint32;
                    description
                      "Reset Error Count";
                  }

                  list err-count {
                    description
                      "Error Count";
                    leaf name {
                      type string;
                      description
                        "Name of asic error";
                    }

                    leaf count {
                      type uint32;
                      description
                        "Number of occurrence";
                    }
                  }  // list err-count

                  list pcie-err-count {
                    description
                      "PCIE Error Count";
                    leaf name {
                      type string;
                      description
                        "Name of asic error";
                    }

                    leaf count {
                      type uint32;
                      description
                        "Number of occurrence";
                    }
                  }  // list pcie-err-count

                  list pacerr-count {
                    description
                      "Pac Error Count";
                    leaf name {
                      type string;
                      description
                        "Name of asic error";
                    }

                    leaf count {
                      type uint32;
                      description
                        "Number of occurrence";
                    }
                  }  // list pacerr-count

                  list node-key {
                    description
                      "Keys to the node";
                    leaf entry {
                      type uint32;
                      description
                        "Keys to the node";
                    }
                  }  // list node-key
                }  // container instance-summary

                leaf asic-instance {
                  type uint32 {
                    range "0..256";
                  }
                  description
                    "asic instance";
                }
              }  // list instance
            }  // container instances

            container all-instances {
              description
                "All asic instance on the node";
              container all-error-path {
                description
                  "Error path of all instances";
                container summary {
                  description
                    "Summary of all instances errors";
                  leaf legacy-client {
                    type boolean;
                    description
                      "boolean field for legacy client";
                  }

                  leaf cih-client {
                    type boolean;
                    description
                      "boolean field for cih client";
                  }

                  leaf pac-client {
                    type boolean;
                    description
                      "boolean field for pac client";
                  }

                  list sum-data {
                    description
                      "summary data for asic error";
                    leaf num-nodes {
                      type uint32;
                      description
                        "Number of nodes";
                    }

                    leaf crc-err-count {
                      type uint32;
                      description
                        "CRC Error Count";
                    }

                    leaf sbe-err-count {
                      type uint32;
                      description
                        "Single Bit Error Count";
                    }

                    leaf mbe-err-count {
                      type uint32;
                      description
                        "Multi-Bit Error Count";
                    }

                    leaf par-err-count {
                      type uint32;
                      description
                        "Parity Error Count";
                    }

                    leaf gen-err-count {
                      type uint32;
                      description
                        "General Error Count";
                    }

                    leaf reset-err-count {
                      type uint32;
                      description
                        "Reset Error Count";
                    }

                    list err-count {
                      description
                        "Error Count";
                      leaf name {
                        type string;
                        description
                          "Name of asic error";
                      }

                      leaf count {
                        type uint32;
                        description
                          "Number of occurrence";
                      }
                    }  // list err-count

                    list pcie-err-count {
                      description
                        "PCIE Error Count";
                      leaf name {
                        type string;
                        description
                          "Name of asic error";
                      }

                      leaf count {
                        type uint32;
                        description
                          "Number of occurrence";
                      }
                    }  // list pcie-err-count

                    list pacerr-count {
                      description
                        "Pac Error Count";
                      leaf name {
                        type string;
                        description
                          "Name of asic error";
                      }

                      leaf count {
                        type uint32;
                        description
                          "Number of occurrence";
                      }
                    }  // list pacerr-count

                    list node-key {
                      description
                        "Keys to the node";
                      leaf entry {
                        type uint32;
                        description
                          "Keys to the node";
                      }
                    }  // list node-key
                  }  // list sum-data
                }  // container summary
              }  // container all-error-path
            }  // container all-instances

            leaf asic {
              type xr:Cisco-ios-xr-string;
              description "Asic string";
            }
          }  // list asic-information
        }  // list node
      }  // container nodes
    }  // container asic-errors
  }  // module Cisco-IOS-XR-asic-error-oper