diff --git a/Makefile b/Makefile
index be17a23..51f78d9 100644
--- a/Makefile
+++ b/Makefile
@@ -50,10 +50,10 @@
 VOLTHA_TOOLS_VERSION ?= 2.5.3
 
 # Dependencies versions
-LIBYANG_VERSION		?= v2.0.164
-SYSREPO_VERSION		?= v2.1.42
-LIBNETCONF2_VERSION	?= v2.1.7
-NETOPEER2_VERSION	?= v2.1.16
+LIBYANG_VERSION		?= f9bbd46fa3a6b09291ec0c1e93ebf569f3e30bd1
+SYSREPO_VERSION		?= 64e3c66442d682c31e979db289c4c64a3ec1f6c1
+LIBNETCONF2_VERSION	?= ef7d3e3ca1504e8ca9c4f4b5dd3847ba17bb809d
+NETOPEER2_VERSION	?= 39800066f9fbbde9b55e6cfde77927eeb5627c83
 
 # Default user and password for the netconf user in docker-build
 NETCONF_USER ?= voltha
diff --git a/build/package/Dockerfile.bbf-adapter b/build/package/Dockerfile.bbf-adapter
index 512e202..bbd3f1e 100644
--- a/build/package/Dockerfile.bbf-adapter
+++ b/build/package/Dockerfile.bbf-adapter
@@ -97,6 +97,14 @@
 COPY ./build/yang-files /yang
 RUN for f in /yang/*.yang; do sysrepoctl -i "$f" -s /yang -p 664 -v3; done
 
+# Enable admin and oper state in ietf-hardware
+RUN sysrepoctl -e hardware-state -c ietf-hardware
+
+COPY ./build/yang-files/schema-mount.xml /
+
+# Add sysrepo's yang library data to the data provided to the schema-mount libyang extension
+RUN sysrepocfg -X -x/ietf-yang-library:* -d operational >> /schema-mount.xml
+
 # Add user for connecting to netopeer2-server through ssh
 ARG NETCONF_USER=voltha
 ARG NETCONF_PASSWORD=onf
@@ -106,7 +114,7 @@
 RUN echo $NETCONF_USER:$NETCONF_PASSWORD | chpasswd
 
 # Set the working directory
-WORKDIR /app
+WORKDIR /
 
 # Copy required files
 COPY --from=dev /app/bbf-adapter /app/bbf-adapter
diff --git a/build/yang-files/iana-hardware@2018-03-13.yang b/build/yang-files/iana-hardware@2018-03-13.yang
new file mode 100644
index 0000000..7165863
--- /dev/null
+++ b/build/yang-files/iana-hardware@2018-03-13.yang
@@ -0,0 +1,187 @@
+module iana-hardware {
+  yang-version 1.1;
+  namespace "urn:ietf:params:xml:ns:yang:iana-hardware";
+  prefix ianahw;
+
+  organization "IANA";
+  contact
+    "        Internet Assigned Numbers Authority
+
+     Postal: ICANN
+             12025 Waterfront Drive, Suite 300
+             Los Angeles, CA  90094-2536
+             United States of America
+
+     Tel:    +1 310 301 5800
+     E-Mail: iana@iana.org>";
+
+  description
+    "IANA-defined identities for hardware class.
+
+     The latest revision of this YANG module can be obtained from
+     the IANA website.
+
+     Requests for new values should be made to IANA via
+     email (iana@iana.org).
+
+     Copyright (c) 2018 IETF Trust and the persons identified as
+     authors of the code.  All rights reserved.
+
+     Redistribution and use in source and binary forms, with or
+     without modification, is permitted pursuant to, and subject
+     to the license terms contained in, the Simplified BSD License
+     set forth in Section 4.c of the IETF Trust's Legal Provisions
+     Relating to IETF Documents
+     (https://trustee.ietf.org/license-info).
+
+     The initial version of this YANG module is part of RFC 8348;
+     see the RFC itself for full legal notices.";
+  reference
+    "https://www.iana.org/assignments/yang-parameters";
+
+  revision 2018-03-13 {
+    description
+      "Initial revision.";
+    reference
+      "RFC 8348: A YANG Data Model for Hardware Management";
+  }
+
+  /*
+   * Identities
+   */
+
+  identity hardware-class {
+    description
+      "This identity is the base for all hardware class
+       identifiers.";
+  }
+
+  identity unknown {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is unknown
+       to the server.";
+  }
+
+  identity chassis {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is an
+       overall container for networking equipment.  Any class of
+       physical component, except a stack, may be contained within a
+       chassis; a chassis may only be contained within a stack.";
+  }
+
+  identity backplane {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of device for aggregating and forwarding networking traffic,
+       such as a shared backplane in a modular ethernet switch.  Note
+       that an implementation may model a backplane as a single
+       physical component, which is actually implemented as multiple
+       discrete physical components (within a chassis or stack).";
+  }
+
+  identity container {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is capable
+       of containing one or more removable physical entities,
+       possibly of different types.  For example, each (empty or
+       full) slot in a chassis will be modeled as a container.  Note
+       that all removable physical components should be modeled
+       within a container component, such as field-replaceable
+       modules, fans, or power supplies.  Note that all known
+       containers should be modeled by the agent, including empty
+       containers.";
+  }
+
+  identity power-supply {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is a
+       power-supplying component.";
+  }
+
+  identity fan {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is a fan or
+       other heat-reduction component.";
+  }
+
+  identity sensor {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of sensor, such as a temperature sensor within a router
+       chassis.";
+  }
+
+  identity module {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of self-contained sub-system.  If a module component is
+       removable, then it should be modeled within a container
+       component; otherwise, it should be modeled directly within
+       another physical component (e.g., a chassis or another
+       module).";
+  }
+
+  identity port {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of networking port capable of receiving and/or transmitting
+       networking traffic.";
+  }
+
+  identity stack {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of super-container (possibly virtual) intended to group
+       together multiple chassis entities.  A stack may be realized
+       by a virtual cable, a real interconnect cable attached to
+       multiple chassis, or multiple interconnect cables.  A stack
+       should not be modeled within any other physical components,
+       but a stack may be contained within another stack.  Only
+       chassis components should be contained within a stack.";
+  }
+
+  identity cpu {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of central processing unit.";
+  }
+
+  identity energy-object {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of energy object, i.e., it is a piece of equipment that is
+       part of or attached to a communications network that is
+       monitored, it is controlled, or it aids in the management of
+       another device for Energy Management.";
+  }
+
+  identity battery {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of battery.";
+  }
+
+  identity storage-drive {
+    base ianahw:hardware-class;
+    description
+      "This identity is applicable if the hardware class is some sort
+       of component with data storage capability as its main
+       functionality, e.g., hard disk drive (HDD), solid-state device
+       (SSD), solid-state hybrid drive (SSHD), object storage device
+       (OSD), or other.";
+  }
+}
\ No newline at end of file
diff --git a/build/yang-files/ietf-hardware@2018-03-13.yang b/build/yang-files/ietf-hardware@2018-03-13.yang
new file mode 100644
index 0000000..4f984b6
--- /dev/null
+++ b/build/yang-files/ietf-hardware@2018-03-13.yang
@@ -0,0 +1,1194 @@
+module ietf-hardware {
+  yang-version 1.1;
+  namespace "urn:ietf:params:xml:ns:yang:ietf-hardware";
+  prefix hw;
+
+  import ietf-inet-types {
+    prefix inet;
+  }
+  import ietf-yang-types {
+    prefix yang;
+  }
+  import iana-hardware {
+    prefix ianahw;
+  }
+
+  organization
+    "IETF NETMOD (Network Modeling) Working Group";
+
+  contact
+    "WG Web:   <https://datatracker.ietf.org/wg/netmod/>
+     WG List:  <mailto:netmod@ietf.org>
+
+     Editor:   Andy Bierman
+               <mailto:andy@yumaworks.com>
+
+     Editor:   Martin Bjorklund
+               <mailto:mbj@tail-f.com>
+
+     Editor:   Jie Dong
+               <mailto:jie.dong@huawei.com>
+
+     Editor:   Dan Romascanu
+               <mailto:dromasca@gmail.com>";
+
+  description
+    "This module contains a collection of YANG definitions for
+     managing hardware.
+
+     This data model is designed for the Network Management Datastore
+     Architecture (NMDA) defined in RFC 8342.
+     Copyright (c) 2018 IETF Trust and the persons identified as
+     authors of the code.  All rights reserved.
+
+     Redistribution and use in source and binary forms, with or
+     without modification, is permitted pursuant to, and subject
+     to the license terms contained in, the Simplified BSD License
+     set forth in Section 4.c of the IETF Trust's Legal Provisions
+     Relating to IETF Documents
+     (https://trustee.ietf.org/license-info).
+
+     This version of this YANG module is part of RFC 8348; see
+     the RFC itself for full legal notices.";
+
+  revision 2018-03-13 {
+    description
+      "Initial revision.";
+    reference
+      "RFC 8348: A YANG Data Model for Hardware Management";
+  }
+
+  /*
+   * Features
+   */
+
+  feature entity-mib {
+    description
+      "This feature indicates that the device implements
+       the ENTITY-MIB.";
+    reference
+      "RFC 6933: Entity MIB (Version 4)";
+  }
+
+  feature hardware-state {
+    description
+      "Indicates that ENTITY-STATE-MIB objects are supported";
+    reference
+      "RFC 4268: Entity State MIB";
+  }
+
+  feature hardware-sensor {
+    description
+      "Indicates that ENTITY-SENSOR-MIB objects are supported";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base";
+  }
+
+  /*
+   * Typedefs
+   */
+
+  typedef admin-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report administrative state.";
+      }
+      enum locked {
+        value 2;
+        description
+          "The resource is administratively prohibited from use.";
+      }
+      enum shutting-down {
+        value 3;
+        description
+          "The resource usage is administratively limited to current
+           instances of use.";
+      }
+      enum unlocked {
+        value 4;
+        description
+          "The resource is not administratively prohibited from
+           use.";
+      }
+    }
+    description
+      "Represents the various possible administrative states.";
+    reference
+      "RFC 4268: Entity State MIB - EntityAdminState";
+  }
+
+  typedef oper-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report its operational state.";
+      }
+      enum disabled {
+        value 2;
+        description
+          "The resource is totally inoperable.";
+      }
+      enum enabled {
+        value 3;
+
+        description
+          "The resource is partially or fully operable.";
+      }
+      enum testing {
+        value 4;
+        description
+          "The resource is currently being tested and cannot
+           therefore report whether or not it is operational.";
+      }
+    }
+    description
+      "Represents the possible values of operational states.";
+    reference
+      "RFC 4268: Entity State MIB - EntityOperState";
+  }
+
+  typedef usage-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report usage state.";
+      }
+      enum idle {
+        value 2;
+        description
+          "The resource is servicing no users.";
+      }
+      enum active {
+        value 3;
+        description
+          "The resource is currently in use, and it has sufficient
+           spare capacity to provide for additional users.";
+      }
+      enum busy {
+        value 4;
+        description
+          "The resource is currently in use, but it currently has no
+           spare capacity to provide for additional users.";
+      }
+    }
+    description
+      "Represents the possible values of usage states.";
+    reference
+      "RFC 4268: Entity State MIB -  EntityUsageState";
+  }
+
+  typedef alarm-state {
+    type bits {
+      bit unknown {
+        position 0;
+        description
+          "The resource is unable to report alarm state.";
+      }
+      bit under-repair {
+        position 1;
+        description
+          "The resource is currently being repaired, which, depending
+           on the implementation, may make the other values in this
+           bit string not meaningful.";
+      }
+      bit critical {
+        position 2;
+        description
+          "One or more critical alarms are active against the
+           resource.";
+      }
+      bit major {
+        position 3;
+        description
+          "One or more major alarms are active against the
+           resource.";
+      }
+      bit minor {
+        position 4;
+        description
+          "One or more minor alarms are active against the
+           resource.";
+      }
+      bit warning {
+        position 5;
+        description
+          "One or more warning alarms are active against the
+           resource.";
+      }
+      bit indeterminate {
+        position 6;
+        description
+          "One or more alarms of whose perceived severity cannot be
+           determined are active against this resource.";
+      }
+    }
+    description
+      "Represents the possible values of alarm states.  An alarm is a
+       persistent indication of an error or warning condition.
+
+       When no bits of this attribute are set, then no active alarms
+       are known against this component and it is not under repair.";
+    reference
+      "RFC 4268: Entity State MIB - EntityAlarmStatus";
+  }
+
+  typedef standby-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report standby state.";
+      }
+      enum hot-standby {
+        value 2;
+        description
+          "The resource is not providing service, but it will be
+           immediately able to take over the role of the resource to
+           be backed up, without the need for initialization
+           activity, and will contain the same information as the
+           resource to be backed up.";
+      }
+      enum cold-standby {
+        value 3;
+        description
+          "The resource is to back up another resource, but it will
+           not be immediately able to take over the role of a
+           resource to be backed up and will require some
+           initialization activity.";
+      }
+      enum providing-service {
+        value 4;
+        description
+          "The resource is providing service.";
+      }
+    }
+    description
+      "Represents the possible values of standby states.";
+    reference
+      "RFC 4268: Entity State MIB - EntityStandbyStatus";
+  }
+
+  typedef sensor-value-type {
+    type enumeration {
+      enum other {
+        value 1;
+        description
+          "A measure other than those listed below.";
+      }
+      enum unknown {
+        value 2;
+        description
+          "An unknown measurement or arbitrary, relative numbers";
+      }
+      enum volts-AC {
+        value 3;
+        description
+          "A measure of electric potential (alternating current).";
+      }
+      enum volts-DC {
+        value 4;
+        description
+          "A measure of electric potential (direct current).";
+      }
+      enum amperes {
+        value 5;
+        description
+          "A measure of electric current.";
+      }
+      enum watts {
+        value 6;
+        description
+          "A measure of power.";
+      }
+      enum hertz {
+        value 7;
+        description
+          "A measure of frequency.";
+      }
+      enum celsius {
+        value 8;
+        description
+          "A measure of temperature.";
+      }
+      enum percent-RH {
+        value 9;
+        description
+          "A measure of percent relative humidity.";
+      }
+      enum rpm {
+        value 10;
+        description
+          "A measure of shaft revolutions per minute.";
+      }
+      enum cmm {
+        value 11;
+        description
+          "A measure of cubic meters per minute (airflow).";
+      }
+      enum truth-value {
+        value 12;
+        description
+          "Value is one of 1 (true) or 2 (false)";
+      }
+    }
+    description
+      "A node using this data type represents the sensor measurement
+       data type associated with a physical sensor value.  The actual
+       data units are determined by examining a node of this type
+       together with the associated sensor-value-scale node.
+
+       A node of this type SHOULD be defined together with nodes of
+       type sensor-value-scale and type sensor-value-precision.
+       These three types are used to identify the semantics of a node
+       of type sensor-value.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorDataType";
+  }
+
+  typedef sensor-value-scale {
+    type enumeration {
+      enum yocto {
+        value 1;
+        description
+          "Data scaling factor of 10^-24.";
+      }
+      enum zepto {
+        value 2;
+        description
+          "Data scaling factor of 10^-21.";
+      }
+      enum atto {
+        value 3;
+        description
+          "Data scaling factor of 10^-18.";
+      }
+      enum femto {
+        value 4;
+        description
+          "Data scaling factor of 10^-15.";
+      }
+      enum pico {
+        value 5;
+        description
+          "Data scaling factor of 10^-12.";
+      }
+      enum nano {
+        value 6;
+        description
+          "Data scaling factor of 10^-9.";
+      }
+      enum micro {
+        value 7;
+        description
+          "Data scaling factor of 10^-6.";
+      }
+      enum milli {
+        value 8;
+        description
+          "Data scaling factor of 10^-3.";
+      }
+      enum units {
+        value 9;
+        description
+          "Data scaling factor of 10^0.";
+      }
+      enum kilo {
+        value 10;
+        description
+          "Data scaling factor of 10^3.";
+      }
+      enum mega {
+        value 11;
+        description
+          "Data scaling factor of 10^6.";
+      }
+      enum giga {
+        value 12;
+        description
+          "Data scaling factor of 10^9.";
+      }
+      enum tera {
+        value 13;
+        description
+          "Data scaling factor of 10^12.";
+      }
+      enum peta {
+        value 14;
+        description
+          "Data scaling factor of 10^15.";
+      }
+      enum exa {
+        value 15;
+        description
+          "Data scaling factor of 10^18.";
+      }
+      enum zetta {
+        value 16;
+        description
+          "Data scaling factor of 10^21.";
+      }
+      enum yotta {
+        value 17;
+        description
+          "Data scaling factor of 10^24.";
+      }
+    }
+    description
+      "A node using this data type represents a data scaling factor,
+       represented with an International System of Units (SI) prefix.
+       The actual data units are determined by examining a node of
+       this type together with the associated sensor-value-type.
+
+       A node of this type SHOULD be defined together with nodes of
+       type sensor-value-type and type sensor-value-precision.
+       Together, associated nodes of these three types are used to
+       identify the semantics of a node of type sensor-value.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorDataScale";
+  }
+
+  typedef sensor-value-precision {
+    type int8 {
+      range "-8 .. 9";
+    }
+    description
+      "A node using this data type represents a sensor value
+       precision range.
+
+       A node of this type SHOULD be defined together with nodes of
+       type sensor-value-type and type sensor-value-scale.  Together,
+       associated nodes of these three types are used to identify the
+       semantics of a node of type sensor-value.
+
+       If a node of this type contains a value in the range 1 to 9,
+       it represents the number of decimal places in the fractional
+       part of an associated sensor-value fixed-point number.
+
+       If a node of this type contains a value in the range -8 to -1,
+       it represents the number of accurate digits in the associated
+       sensor-value fixed-point number.
+
+       The value zero indicates the associated sensor-value node is
+       not a fixed-point number.
+
+       Server implementers must choose a value for the associated
+       sensor-value-precision node so that the precision and accuracy
+       of the associated sensor-value node is correctly indicated.
+
+       For example, a component representing a temperature sensor
+       that can measure 0 to 100 degrees C in 0.1 degree
+       increments, +/- 0.05 degrees, would have a
+       sensor-value-precision value of '1', a sensor-value-scale
+       value of 'units', and a sensor-value ranging from '0' to
+       '1000'.  The sensor-value would be interpreted as
+       'degrees C * 10'.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorPrecision";
+  }
+
+  typedef sensor-value {
+    type int32 {
+      range "-1000000000 .. 1000000000";
+    }
+    description
+     "A node using this data type represents a sensor value.
+
+      A node of this type SHOULD be defined together with nodes of
+      type sensor-value-type, type sensor-value-scale, and
+      type sensor-value-precision.  Together, associated nodes of
+      those three types are used to identify the semantics of a node
+      of this data type.
+
+      The semantics of a node using this data type are determined by
+      the value of the associated sensor-value-type node.
+
+      If the associated sensor-value-type node is equal to 'voltsAC',
+      'voltsDC', 'amperes', 'watts', 'hertz', 'celsius', or 'cmm',
+      then a node of this type MUST contain a fixed-point number
+      ranging from -999,999,999 to +999,999,999.  The value
+      -1000000000 indicates an underflow error.  The value
+      +1000000000 indicates an overflow error.  The
+      sensor-value-precision indicates how many fractional digits
+      are represented in the associated sensor-value node.
+
+      If the associated sensor-value-type node is equal to
+      'percentRH', then a node of this type MUST contain a number
+      ranging from 0 to 100.
+
+      If the associated sensor-value-type node is equal to 'rpm',
+      then a node of this type MUST contain a number ranging from
+      -999,999,999 to +999,999,999.
+
+      If the associated sensor-value-type node is equal to
+      'truth-value', then a node of this type MUST contain either the
+      value 1 (true) or the value 2 (false).
+
+      If the associated sensor-value-type node is equal to 'other' or
+      'unknown', then a node of this type MUST contain a number
+      ranging from -1000000000 to 1000000000.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorValue";
+  }
+
+  typedef sensor-status {
+    type enumeration {
+      enum ok {
+        value 1;
+        description
+          "Indicates that the server can obtain the sensor value.";
+      }
+      enum unavailable {
+        value 2;
+        description
+          "Indicates that the server presently cannot obtain the
+           sensor value.";
+      }
+      enum nonoperational {
+        value 3;
+        description
+          "Indicates that the server believes the sensor is broken.
+           The sensor could have a hard failure (disconnected wire)
+           or a soft failure such as out-of-range, jittery, or wildly
+           fluctuating readings.";
+      }
+    }
+    description
+      "A node using this data type represents the operational status
+       of a physical sensor.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorStatus";
+  }
+
+  /*
+   * Data nodes
+   */
+
+  container hardware {
+    description
+      "Data nodes representing components.
+
+       If the server supports configuration of hardware components,
+       then this data model is instantiated in the configuration
+       datastores supported by the server.  The leaf-list 'datastore'
+       for the module 'ietf-hardware' in the YANG library provides
+       this information.";
+
+    leaf last-change {
+      type yang:date-and-time;
+      config false;
+      description
+        "The time the '/hardware/component' list changed in the
+         operational state.";
+    }
+
+    list component {
+      key name;
+      description
+        "List of components.
+
+         When the server detects a new hardware component, it
+         initializes a list entry in the operational state.
+
+         If the server does not support configuration of hardware
+         components, list entries in the operational state are
+         initialized with values for all nodes as detected by the
+         implementation.
+
+         Otherwise, this procedure is followed:
+
+           1. If there is an entry in the '/hardware/component' list
+              in the intended configuration with values for the nodes
+              'class', 'parent', and 'parent-rel-pos' that are equal
+              to the detected values, then the list entry in the
+              operational state is initialized with the configured
+              values, including the 'name'.
+
+           2. Otherwise (i.e., there is no matching configuration
+              entry), the list entry in the operational state is
+              initialized with values for all nodes as detected by
+              the implementation.
+
+         If the '/hardware/component' list in the intended
+         configuration is modified, then the system MUST behave as if
+         it re-initializes itself and follow the procedure in (1).";
+      reference
+        "RFC 6933: Entity MIB (Version 4) - entPhysicalEntry";
+
+      leaf name {
+        type string;
+        description
+          "The name assigned to this component.
+
+           This name is not required to be the same as
+           entPhysicalName.";
+      }
+
+      leaf class {
+        type identityref {
+          base ianahw:hardware-class;
+        }
+        mandatory true;
+        description
+          "An indication of the general hardware type of the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalClass";
+      }
+
+      leaf physical-index {
+        if-feature entity-mib;
+        type int32 {
+          range "1..2147483647";
+        }
+        config false;
+        description
+          "The entPhysicalIndex for the entPhysicalEntry represented
+           by this list entry.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalIndex";
+      }
+
+      leaf description {
+        type string;
+        config false;
+        description
+          "A textual description of the component.  This node should
+           contain a string that identifies the manufacturer's name
+           for the component and should be set to a distinct value
+           for each version or model of the component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalDescr";
+      }
+
+      leaf parent {
+        type leafref {
+          path "../../component/name";
+          require-instance false;
+        }
+        description
+          "The name of the component that physically contains this
+           component.
+
+           If this leaf is not instantiated, it indicates that this
+           component is not contained in any other component.
+
+           In the event that a physical component is contained by
+           more than one physical component (e.g., double-wide
+           modules), this node contains the name of one of these
+           components.  An implementation MUST use the same name
+           every time this node is instantiated.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalContainedIn";
+      }
+
+      leaf parent-rel-pos {
+        type int32 {
+          range "0 .. 2147483647";
+        }
+        description
+          "An indication of the relative position of this child
+           component among all its sibling components.  Sibling
+           components are defined as components that:
+
+             o share the same value of the 'parent' node and
+
+             o share a common base identity for the 'class' node.
+
+           Note that the last rule gives implementations flexibility
+           in how components are numbered.  For example, some
+           implementations might have a single number series for all
+           components derived from 'ianahw:port', while some others
+           might have different number series for different
+           components with identities derived from 'ianahw:port' (for
+           example, one for registered jack 45 (RJ45) and one for
+           small form-factor pluggable (SFP)).";
+
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalParentRelPos";
+      }
+
+      leaf-list contains-child {
+        type leafref {
+          path "../../component/name";
+        }
+        config false;
+        description
+          "The name of the contained component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalChildIndex";
+      }
+
+      leaf hardware-rev {
+        type string;
+        config false;
+        description
+          "The vendor-specific hardware revision string for the
+           component.  The preferred value is the hardware revision
+           identifier actually printed on the component itself (if
+           present).";
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalHardwareRev";
+      }
+
+      leaf firmware-rev {
+        type string;
+        config false;
+        description
+          "The vendor-specific firmware revision string for the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalFirmwareRev";
+      }
+
+      leaf software-rev {
+        type string;
+        config false;
+
+        description
+          "The vendor-specific software revision string for the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalSoftwareRev";
+      }
+
+      leaf serial-num {
+        type string;
+        config false;
+        description
+          "The vendor-specific serial number string for the
+           component.  The preferred value is the serial number
+           string actually printed on the component itself (if
+           present).";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalSerialNum";
+      }
+
+      leaf mfg-name {
+        type string;
+        config false;
+        description
+          "The name of the manufacturer of this physical component.
+           The preferred value is the manufacturer name string
+           actually printed on the component itself (if present).
+
+           Note that comparisons between instances of the
+           'model-name', 'firmware-rev', 'software-rev', and
+           'serial-num' nodes are only meaningful amongst components
+           with the same value of 'mfg-name'.
+
+           If the manufacturer name string associated with the
+           physical component is unknown to the server, then this
+           node is not instantiated.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgName";
+      }
+
+      leaf model-name {
+        type string;
+        config false;
+        description
+          "The vendor-specific model name identifier string
+           associated with this physical component.  The preferred
+           value is the customer-visible part number, which may be
+           printed on the component itself.
+           If the model name string associated with the physical
+           component is unknown to the server, then this node is not
+           instantiated.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalModelName";
+      }
+
+      leaf alias {
+        type string;
+        description
+          "An 'alias' name for the component, as specified by a
+           network manager, that provides a non-volatile 'handle' for
+           the component.
+
+           If no configured value exists, the server MAY set the
+           value of this node to a locally unique value in the
+           operational state.
+
+           A server implementation MAY map this leaf to the
+           entPhysicalAlias MIB object.  Such an implementation needs
+           to use some mechanism to handle the differences in size
+           and characters allowed between this leaf and
+           entPhysicalAlias.  The definition of such a mechanism is
+           outside the scope of this document.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalAlias";
+      }
+
+      leaf asset-id {
+        type string;
+        description
+          "This node is a user-assigned asset tracking identifier for
+           the component.
+
+           A server implementation MAY map this leaf to the
+           entPhysicalAssetID MIB object.  Such an implementation
+           needs to use some mechanism to handle the differences in
+           size and characters allowed between this leaf and
+           entPhysicalAssetID.  The definition of such a mechanism is
+           outside the scope of this document.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalAssetID";
+      }
+
+      leaf is-fru {
+        type boolean;
+        config false;
+
+        description
+          "This node indicates whether or not this component is
+           considered a 'field-replaceable unit' by the vendor.  If
+           this node contains the value 'true', then this component
+           identifies a field-replaceable unit.  For all components
+           that are permanently contained within a field-replaceable
+           unit, the value 'false' should be returned for this
+           node.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalIsFRU";
+      }
+
+      leaf mfg-date {
+        type yang:date-and-time;
+        config false;
+        description
+          "The date of manufacturing of the managed component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgDate";
+      }
+
+      leaf-list uri {
+        type inet:uri;
+        description
+          "This node contains identification information about the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalUris";
+      }
+
+      leaf uuid {
+        type yang:uuid;
+        config false;
+        description
+          "A Universally Unique Identifier of the component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalUUID";
+      }
+
+      container state {
+        if-feature hardware-state;
+        description
+          "State-related nodes";
+        reference
+          "RFC 4268: Entity State MIB";
+
+        leaf state-last-changed {
+          type yang:date-and-time;
+          config false;
+          description
+            "The date and time when the value of any of the
+             admin-state, oper-state, usage-state, alarm-state, or
+             standby-state changed for this component.
+
+             If there has been no change since the last
+             re-initialization of the local system, this node
+             contains the date and time of local system
+             initialization.  If there has been no change since the
+             component was added to the local system, this node
+             contains the date and time of the insertion.";
+          reference
+            "RFC 4268: Entity State MIB - entStateLastChanged";
+        }
+
+        leaf admin-state {
+          type admin-state;
+          description
+            "The administrative state for this component.
+
+             This node refers to a component's administrative
+             permission to service both other components within its
+             containment hierarchy as well other users of its
+             services defined by means outside the scope of this
+             module.
+
+             Some components exhibit only a subset of the remaining
+             administrative state values.  Some components cannot be
+             locked; hence, this node exhibits only the 'unlocked'
+             state.  Other components cannot be shut down gracefully;
+             hence, this node does not exhibit the 'shutting-down'
+             state.";
+          reference
+            "RFC 4268: Entity State MIB - entStateAdmin";
+        }
+
+        leaf oper-state {
+          type oper-state;
+          config false;
+          description
+            "The operational state for this component.
+
+             Note that this node does not follow the administrative
+             state.  An administrative state of 'down' does not
+             predict an operational state of 'disabled'.
+
+             Note that some implementations may not be able to
+             accurately report oper-state while the admin-state node
+             has a value other than 'unlocked'.  In these cases, this
+             node MUST have a value of 'unknown'.";
+          reference
+            "RFC 4268: Entity State MIB - entStateOper";
+        }
+
+        leaf usage-state {
+          type usage-state;
+          config false;
+          description
+            "The usage state for this component.
+
+             This node refers to a component's ability to service
+             more components in a containment hierarchy.
+
+             Some components will exhibit only a subset of the usage
+             state values.  Components that are unable to ever
+             service any components within a containment hierarchy
+             will always have a usage state of 'busy'.  In some
+             cases, a component will be able to support only one
+             other component within its containment hierarchy and
+             will therefore only exhibit values of 'idle' and
+             'busy'.";
+          reference
+            "RFC 4268: Entity State MIB - entStateUsage";
+        }
+
+        leaf alarm-state {
+          type alarm-state;
+          config false;
+          description
+            "The alarm state for this component.  It does not
+             include the alarms raised on child components within its
+             containment hierarchy.";
+          reference
+            "RFC 4268: Entity State MIB - entStateAlarm";
+        }
+
+        leaf standby-state {
+          type standby-state;
+          config false;
+          description
+            "The standby state for this component.
+
+             Some components will exhibit only a subset of the
+             remaining standby state values.  If this component
+             cannot operate in a standby role, the value of this node
+             will always be 'providing-service'.";
+          reference
+            "RFC 4268: Entity State MIB - entStateStandby";
+        }
+      }
+
+      container sensor-data {
+        when 'derived-from-or-self(../class,
+                                   "ianahw:sensor")' {
+          description
+            "Sensor data nodes present for any component of type
+             'sensor'";
+        }
+        if-feature hardware-sensor;
+        config false;
+
+        description
+          "Sensor-related nodes.";
+        reference
+          "RFC 3433: Entity Sensor Management Information Base";
+
+        leaf value {
+          type sensor-value;
+          description
+            "The most recent measurement obtained by the server
+             for this sensor.
+
+             A client that periodically fetches this node should also
+             fetch the nodes 'value-type', 'value-scale', and
+             'value-precision', since they may change when the value
+             is changed.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorValue";
+        }
+
+        leaf value-type {
+          type sensor-value-type;
+          description
+            "The type of data units associated with the
+             sensor value";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorType";
+        }
+        leaf value-scale {
+          type sensor-value-scale;
+          description
+            "The (power of 10) scaling factor associated
+             with the sensor value";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorScale";
+        }
+
+        leaf value-precision {
+          type sensor-value-precision;
+          description
+            "The number of decimal places of precision
+             associated with the sensor value";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorPrecision";
+        }
+
+        leaf oper-status {
+          type sensor-status;
+          description
+            "The operational status of the sensor.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorOperStatus";
+        }
+
+        leaf units-display {
+          type string;
+          description
+            "A textual description of the data units that should be
+             used in the display of the sensor value.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorUnitsDisplay";
+        }
+
+        leaf value-timestamp {
+          type yang:date-and-time;
+          description
+            "The time the status and/or value of this sensor was last
+             obtained by the server.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorValueTimeStamp";
+        }
+        leaf value-update-rate {
+          type uint32;
+          units "milliseconds";
+          description
+            "An indication of the frequency that the server updates
+             the associated 'value' node, represented in
+             milliseconds.  The value zero indicates:
+
+              - the sensor value is updated on demand (e.g.,
+                when polled by the server for a get-request),
+
+              - the sensor value is updated when the sensor
+                value changes (event-driven), or
+
+              - the server does not know the update rate.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorValueUpdateRate";
+        }
+      }
+    }
+  }
+
+  /*
+   * Notifications
+   */
+
+  notification hardware-state-change {
+    description
+      "A hardware-state-change notification is generated when the
+       value of /hardware/last-change changes in the operational
+       state.";
+    reference
+      "RFC 6933: Entity MIB (Version 4) - entConfigChange";
+  }
+
+  notification hardware-state-oper-enabled {
+    if-feature hardware-state;
+    description
+      "A hardware-state-oper-enabled notification signifies that a
+       component has transitioned into the 'enabled' state.";
+
+    leaf name {
+      type leafref {
+        path "/hardware/component/name";
+      }
+
+      description
+        "The name of the component that has transitioned into the
+         'enabled' state.";
+    }
+    leaf admin-state {
+      type leafref {
+        path "/hardware/component/state/admin-state";
+      }
+      description
+        "The administrative state for the component.";
+    }
+    leaf alarm-state {
+      type leafref {
+        path "/hardware/component/state/alarm-state";
+      }
+      description
+        "The alarm state for the component.";
+    }
+    reference
+      "RFC 4268: Entity State MIB - entStateOperEnabled";
+  }
+
+  notification hardware-state-oper-disabled {
+    if-feature hardware-state;
+    description
+      "A hardware-state-oper-disabled notification signifies that a
+       component has transitioned into the 'disabled' state.";
+
+    leaf name {
+      type leafref {
+        path "/hardware/component/name";
+      }
+      description
+        "The name of the component that has transitioned into the
+         'disabled' state.";
+    }
+    leaf admin-state {
+      type leafref {
+        path "/hardware/component/state/admin-state";
+      }
+      description
+        "The administrative state for the component.";
+    }
+    leaf alarm-state {
+      type leafref {
+        path "/hardware/component/state/alarm-state";
+      }
+
+      description
+        "The alarm state for the component.";
+    }
+    reference
+      "RFC 4268: Entity State MIB - entStateOperDisabled";
+  }
+
+}
diff --git a/build/yang-files/schema-mount.xml b/build/yang-files/schema-mount.xml
new file mode 100644
index 0000000..6460aa5
--- /dev/null
+++ b/build/yang-files/schema-mount.xml
@@ -0,0 +1,26 @@
+<!--
+  ~ Copyright 2022-present Open Networking Foundation
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<schema-mounts xmlns="urn:ietf:params:xml:ns:yang:ietf-yang-schema-mount">
+  <mount-point>
+    <module>bbf-device-aggregation</module>
+    <label>device-yang-library</label>
+    <config>true</config>
+    <shared-schema>
+      <parent-reference>/bbf-device-aggregation:devices/device</parent-reference>
+    </shared-schema>
+  </mount-point>
+</schema-mounts>
\ No newline at end of file
diff --git a/cmd/bbf-adapter/main.go b/cmd/bbf-adapter/main.go
index 85ed990..b5ac693 100644
--- a/cmd/bbf-adapter/main.go
+++ b/cmd/bbf-adapter/main.go
@@ -75,7 +75,7 @@
 	core.AdapterInstance = core.NewVolthaYangAdapter(a.volthaNbiClient, a.oltAppClient)
 
 	//Load sysrepo plugin
-	a.sysrepoPlugin, err = sysrepo.StartNewPlugin(ctx)
+	a.sysrepoPlugin, err = sysrepo.StartNewPlugin(ctx, a.conf.SchemaMountFilePath)
 	if err != nil {
 		logger.Fatalw(ctx, "failed-to-start-sysrepo-plugin", log.Fields{"err": err})
 	} else {
diff --git a/docs/expanding.md b/docs/expanding.md
index eb7b773..166618f 100644
--- a/docs/expanding.md
+++ b/docs/expanding.md
@@ -1,12 +1,25 @@
 # Expanding the adapter's functionality
 
 ## Resources
-- [libsysrepo API documentation](https://netopeer.liberouter.org/doc/sysrepo/master/html/modules.html)
-- [libyang API documentation](https://netopeer.liberouter.org/doc/libyang/master/html/modules.html)
+- [libsysrepo API documentation](https://netopeer.liberouter.org/doc/sysrepo/devel/html/modules.html)
+- [libyang API documentation](https://netopeer.liberouter.org/doc/libyang/devel/html/modules.html)
+
+## Schema-mount support
+The yang modules used to map VOLTHA APIs use the schema-mount yang extension to create mountpoints, in which other moudels can be included. Libyang is the library used by sysrepo and netopeer2 to operate on yang data, and for this reason it needs to support the extension to let the BBF adapter create all the needed leafs.
+
+To make the extension work, additional data has to be provided to libyang (by both the adapter and netopeer2) through a callback function. More information on the data can be found [here](https://netopeer.liberouter.org/doc/libyang/devel/html/group__context.html#ga14853fe1a338c94d9e81be9566438243).
+
+The set of mountpoints used by the adapter (which has to be modified in case a new yang file with a mountpoint is added) is defined with an XML file, which can be found in `build/yang-files/schema-mount.xml`. This file is copied into the Docker image of the adapter, and is automatically extended with the `ietf-yang-library` provided by sysrepo.
+The path of `schema-mount.xml` is then passed to each process in [the startup script](https://github.com/opencord/voltha-helm-charts/blob/master/voltha-northbound-bbf-adapter/templates/configmap-startup.yaml).
+
+### Schema-mount callback in the BBF adapter
+The BBF adapter loads the content of `schema-mount.xml` (or its equivalent, whose path is provided with the `--schema_mount_path` flag) as libyang nodes during the startup of its sysrepo plugin.
+The callback that will pass this data to libyang is defined in `internal/sysrepo/plugin.c`, and is also registered during the startup.
 
 ## How to expand the adapter's functionality by creating new callbacks
 
 - If additional yang modules are needed, add them to `build/yang-files` to be installed to sysrepo during the creation of the adapter's Docker image
+- If additional sysrepo configuration is needed for the moudule (i.e. enabling a feature) it can be added to `build/package/Dockerfile.bbf-adapter`
 - A new callback function has to be created. CGO cannot directly express the `const` keyword used in the signature of the C callbacks of libsysrepo.\
 For this reason, a Go function can be created and exposed in `internal/sysrepo/sysrepo.go`, while its corresponding wrapper with the right signature has to be created in `internal/sysrepo/plugin.go`.
 - The new callback wrapper has to be registered in the StartNewPlugin function of `internal/sysrepo/sysrepo.go`, using the sysrepo API to subscribe to the desired type of operation and XPath.
diff --git a/internal/config/config.go b/internal/config/config.go
index d7e4916..d3be1fc 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -35,6 +35,7 @@
 	OnosRestEndpoint      string
 	OnosUser              string
 	OnosPassword          string
+	SchemaMountFilePath   string
 }
 
 // LoadConfig loads the BBF adapter configuration through
@@ -55,6 +56,7 @@
 	flag.StringVar(&conf.OnosRestEndpoint, "onos_rest_endpoint", conf.OnosRestEndpoint, "Endpoint of ONOS REST APIs")
 	flag.StringVar(&conf.OnosUser, "onos_user", conf.OnosUser, "Username for ONOS REST APIs")
 	flag.StringVar(&conf.OnosPassword, "onos_pass", conf.OnosPassword, "Password for ONOS REST APIs")
+	flag.StringVar(&conf.SchemaMountFilePath, "schema_mount_path", conf.SchemaMountFilePath, "Path to the XML file that defines schema-mounts for libyang")
 
 	flag.Parse()
 
@@ -77,5 +79,6 @@
 		OnosRestEndpoint:      "voltha-infra-onos-classic-hs.infra.svc:8181",
 		OnosUser:              "onos",
 		OnosPassword:          "rocks",
+		SchemaMountFilePath:   "/schema-mount.xml",
 	}
 }
diff --git a/internal/core/translation.go b/internal/core/translation.go
index bc7c692..634272c 100644
--- a/internal/core/translation.go
+++ b/internal/core/translation.go
@@ -19,14 +19,29 @@
 import (
 	"fmt"
 
+	"github.com/opencord/voltha-protos/v5/go/common"
 	"github.com/opencord/voltha-protos/v5/go/voltha"
 )
 
 const (
 	DeviceAggregationModel = "bbf-device-aggregation"
 	DevicesPath            = "/" + DeviceAggregationModel + ":devices"
-	DeviceTypeOlt          = "bbf-device-types:olt"
-	DeviceTypeOnu          = "bbf-device-types:onu"
+	HardwarePath           = "data/ietf-hardware:hardware"
+
+	//Device types
+	DeviceTypeOlt = "bbf-device-types:olt"
+	DeviceTypeOnu = "bbf-device-types:onu"
+
+	//Admin states
+	ietfAdminStateUnknown  = "unknown"
+	ietfAdminStateLocked   = "locked"
+	ietfAdminStateUnlocked = "unlocked"
+
+	//Oper states
+	ietfOperStateUnknown  = "unknown"
+	ietfOperStateDisabled = "disabled"
+	ietfOperStateEnabled  = "enabled"
+	ietfOperStateTesting  = "testing"
 )
 
 type YangItem struct {
@@ -39,20 +54,117 @@
 	return fmt.Sprintf("%s/device[name='%s']", DevicesPath, id)
 }
 
+//getDevicePath returns the yang path to the root of the device's hardware module in its data mountpoint
+func getDeviceHardwarePath(id string) string {
+	return fmt.Sprintf("%s/device[name='%s']/%s/component[name='%s']", DevicesPath, id, HardwarePath, id)
+}
+
+//ietfHardwareAdminState returns the string that represents the ietf-hardware admin state
+//enum value corresponding to the one of VOLTHA
+func ietfHardwareAdminState(volthaAdminState voltha.AdminState_Types) string {
+	//TODO: verify this mapping is correct
+	switch volthaAdminState {
+	case common.AdminState_UNKNOWN:
+		return ietfAdminStateUnknown
+	case common.AdminState_PREPROVISIONED:
+	case common.AdminState_DOWNLOADING_IMAGE:
+	case common.AdminState_ENABLED:
+		return ietfAdminStateUnlocked
+	case common.AdminState_DISABLED:
+		return ietfAdminStateLocked
+	}
+
+	//TODO: does something map to "shutting-down" ?
+
+	return ietfAdminStateUnknown
+}
+
+//ietfHardwareOperState returns the string that represents the ietf-hardware oper state
+//enum value corresponding to the one of VOLTHA
+func ietfHardwareOperState(volthaOperState voltha.OperStatus_Types) string {
+	//TODO: verify this mapping is correct
+	switch volthaOperState {
+	case common.OperStatus_UNKNOWN:
+		return ietfOperStateUnknown
+	case common.OperStatus_TESTING:
+		return ietfOperStateTesting
+	case common.OperStatus_ACTIVE:
+		return ietfOperStateEnabled
+	case common.OperStatus_DISCOVERED:
+	case common.OperStatus_ACTIVATING:
+	case common.OperStatus_FAILED:
+	case common.OperStatus_RECONCILING:
+	case common.OperStatus_RECONCILING_FAILED:
+		return ietfOperStateDisabled
+	}
+
+	return ietfOperStateUnknown
+}
+
 //translateDevice returns a slice of yang items that represent a voltha device
 func translateDevice(device voltha.Device) []YangItem {
 	devicePath := getDevicePath(device.Id)
+	hardwarePath := getDeviceHardwarePath(device.Id)
 
-	typeItem := YangItem{}
-	typeItem.Path = fmt.Sprintf("%s/type", devicePath)
+	result := []YangItem{}
 
+	//Device type
 	if device.Root {
-		typeItem.Value = DeviceTypeOlt
+		result = append(result, YangItem{
+			Path:  fmt.Sprintf("%s/type", devicePath),
+			Value: DeviceTypeOlt,
+		})
 	} else {
-		typeItem.Value = DeviceTypeOnu
+		result = append(result, YangItem{
+			Path:  fmt.Sprintf("%s/type", devicePath),
+			Value: DeviceTypeOnu,
+		})
 	}
 
-	return []YangItem{typeItem}
+	//Vendor name
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/mfg-name", hardwarePath),
+		Value: device.Vendor,
+	})
+
+	//Model
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/model-name", hardwarePath),
+		Value: device.Model,
+	})
+
+	//Hardware version
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/hardware-rev", hardwarePath),
+		Value: device.HardwareVersion,
+	})
+
+	//Firmware version
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/firmware-rev", hardwarePath),
+		Value: device.FirmwareVersion,
+	})
+
+	//Serial number
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/serial-num", hardwarePath),
+		Value: device.SerialNumber,
+	})
+
+	//Administrative state
+	//Translates VOLTHA admin state enum to ietf-hardware enum
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/state/admin-state", hardwarePath),
+		Value: ietfHardwareAdminState(device.AdminState),
+	})
+
+	//Operative state
+	result = append(result, YangItem{
+		Path:  fmt.Sprintf("%s/state/oper-state", hardwarePath),
+		Value: ietfHardwareOperState(device.OperStatus),
+	})
+
+	return result
 }
 
 //translateDevices returns a slice of yang items that represent a list of voltha devices
diff --git a/internal/sysrepo/plugin.c b/internal/sysrepo/plugin.c
index f3ff6a3..08e7978 100644
--- a/internal/sysrepo/plugin.c
+++ b/internal/sysrepo/plugin.c
@@ -23,12 +23,26 @@
 
 //CGO can't see raw structs
 typedef struct lyd_node lyd_node;
+typedef struct ly_ctx ly_ctx;
 
-//Exported by sysrepo.go
+//Provides data for the schema-mount extension
+LY_ERR mountpoint_ext_data_clb(
+    const struct lysc_ext_instance *ext,
+    void *user_data,
+    void **ext_data,
+    ly_bool *ext_data_free)
+{
+    *ext_data = (lyd_node*) user_data;
+    *ext_data_free = 0;
+    return LY_SUCCESS;
+}
+
+// Exported by sysrepo.go
 sr_error_t get_devices_cb(sr_session_ctx_t *session, lyd_node **parent);
 
-//The wrapper function is needed because CGO cannot express const char*
-//and thus it can't match sysrepo's callback signature
+//The wrapper functions are needed because CGO cannot express some keywords
+//such as "const", and thus it can't match sysrepo's callback signature
+
 int get_devices_cb_wrapper(
     sr_session_ctx_t *session,
     uint32_t subscription_id,
diff --git a/internal/sysrepo/sysrepo.go b/internal/sysrepo/sysrepo.go
index 4ab96ff..3a4dc79 100644
--- a/internal/sysrepo/sysrepo.go
+++ b/internal/sysrepo/sysrepo.go
@@ -22,6 +22,8 @@
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
+	"os"
 	"unsafe"
 
 	"github.com/opencord/voltha-lib-go/v7/pkg/log"
@@ -29,15 +31,23 @@
 )
 
 type SysrepoPlugin struct {
-	connection   *C.sr_conn_ctx_t
-	session      *C.sr_session_ctx_t
-	subscription *C.sr_subscription_ctx_t
+	connection      *C.sr_conn_ctx_t
+	session         *C.sr_session_ctx_t
+	subscription    *C.sr_subscription_ctx_t
+	schemaMountData *C.lyd_node
 }
 
-func errorMsg(code C.int) string {
+func srErrorMsg(code C.int) string {
 	return C.GoString(C.sr_strerror(code))
 }
 
+func lyErrorMsg(ly_ctx *C.ly_ctx) string {
+	lyErrString := C.ly_errmsg(ly_ctx)
+	defer freeCString(lyErrString)
+
+	return C.GoString(lyErrString)
+}
+
 func freeCString(str *C.char) {
 	if str != nil {
 		C.free(unsafe.Pointer(str))
@@ -53,11 +63,16 @@
 
 	//libyang context
 	ly_ctx := C.sr_acquire_context(conn)
+	defer C.sr_release_context(conn)
 	if ly_ctx == nil {
 		return fmt.Errorf("null-libyang-context")
 	}
 
 	for _, item := range items {
+		if item.Value == "" {
+			continue
+		}
+
 		logger.Debugw(ctx, "updating-yang-item", log.Fields{"item": item})
 
 		path := C.CString(item.Path)
@@ -68,9 +83,7 @@
 			freeCString(path)
 			freeCString(value)
 
-			lyErrString := C.ly_errmsg(ly_ctx)
-			err := fmt.Errorf("libyang-new-path-failed: %d %s", lyErr, C.GoString(lyErrString))
-			freeCString(lyErrString)
+			err := fmt.Errorf("libyang-new-path-failed: %d %s", lyErr, lyErrorMsg(ly_ctx))
 
 			return err
 		}
@@ -91,7 +104,7 @@
 	errCode = C.sr_connect(C.SR_CONN_DEFAULT, &p.connection)
 	if errCode != C.SR_ERR_OK {
 		err := fmt.Errorf("sysrepo-connect-error")
-		logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": errorMsg(errCode)})
+		logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": srErrorMsg(errCode)})
 		return err
 	}
 
@@ -99,7 +112,7 @@
 	errCode = C.sr_session_start(p.connection, C.SR_DS_RUNNING, &p.session)
 	if errCode != C.SR_ERR_OK {
 		err := fmt.Errorf("sysrepo-session-error")
-		logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": errorMsg(errCode)})
+		logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": srErrorMsg(errCode)})
 
 		_ = p.Stop(ctx)
 
@@ -147,7 +160,7 @@
 	return C.SR_ERR_OK
 }
 
-func StartNewPlugin(ctx context.Context) (*SysrepoPlugin, error) {
+func StartNewPlugin(ctx context.Context, schemaMountFilePath string) (*SysrepoPlugin, error) {
 	plugin := &SysrepoPlugin{}
 
 	//Open a session to sysrepo
@@ -156,8 +169,34 @@
 		return nil, err
 	}
 
-	//TODO: could be useful to set it according to the adapter log level
-	C.sr_log_stderr(C.SR_LL_WRN)
+	//Read the schema-mount file
+	if _, err := os.Stat(schemaMountFilePath); err != nil {
+		//The file cannot be found
+		return nil, fmt.Errorf("plugin-startup-schema-mount-file-not-found: %v", err)
+	}
+
+	smBuffer, err := ioutil.ReadFile(schemaMountFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("plugin-startup-cannot-read-schema-mount-file: %v", err)
+	}
+
+	smString := C.CString(string(smBuffer))
+	defer freeCString(smString)
+
+	ly_ctx := C.sr_acquire_context(plugin.connection)
+	defer C.sr_release_context(plugin.connection)
+	if ly_ctx == nil {
+		return nil, fmt.Errorf("plugin-startup-null-libyang-context")
+	}
+
+	//Parse the schema-mount file into libyang nodes, and save them into the plugin data
+	lyErrCode := C.lyd_parse_data_mem(ly_ctx, smString, C.LYD_XML, C.LYD_PARSE_STRICT, C.LYD_VALIDATE_PRESENT, &plugin.schemaMountData)
+	if lyErrCode != C.LY_SUCCESS {
+		return nil, fmt.Errorf("plugin-startup-cannot-parse-schema-mount: %v", lyErrorMsg(ly_ctx))
+	}
+
+	//Bind the callback needed to support schema-mount
+	C.sr_set_ext_data_cb(plugin.connection, C.function(C.mountpoint_ext_data_clb), unsafe.Pointer(plugin.schemaMountData))
 
 	//Set callbacks for events
 
@@ -179,7 +218,7 @@
 	)
 	if errCode != C.SR_ERR_OK {
 		err := fmt.Errorf("sysrepo-failed-subscription-to-get-events")
-		logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": errorMsg(errCode)})
+		logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": srErrorMsg(errCode)})
 		return nil, err
 	}
 
@@ -191,12 +230,15 @@
 func (p *SysrepoPlugin) Stop(ctx context.Context) error {
 	var errCode C.int
 
+	//Free the libyang nodes for external schema-mount data
+	C.lyd_free_all(p.schemaMountData)
+
 	//Frees subscription
 	if p.subscription != nil {
 		errCode = C.sr_unsubscribe(p.subscription)
 		if errCode != C.SR_ERR_OK {
 			err := fmt.Errorf("failed-to-close-sysrepo-subscription")
-			logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": errorMsg(errCode)})
+			logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": srErrorMsg(errCode)})
 			return err
 		}
 		p.subscription = nil
@@ -207,7 +249,7 @@
 		errCode = C.sr_session_stop(p.session)
 		if errCode != C.SR_ERR_OK {
 			err := fmt.Errorf("failed-to-close-sysrepo-session")
-			logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": errorMsg(errCode)})
+			logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": srErrorMsg(errCode)})
 			return err
 		}
 		p.session = nil
@@ -218,7 +260,7 @@
 		errCode = C.sr_disconnect(p.connection)
 		if errCode != C.SR_ERR_OK {
 			err := fmt.Errorf("failed-to-close-sysrepo-connection")
-			logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": errorMsg(errCode)})
+			logger.Errorw(ctx, err.Error(), log.Fields{"errCode": errCode, "errMsg": srErrorMsg(errCode)})
 			return err
 		}
 		p.connection = nil