diff --git a/ironic_staging_drivers/intel_nm/__init__.py b/ironic_staging_drivers/intel_nm/__init__.py
new file mode 100644
index 0000000..f6b6cf1
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/__init__.py
@@ -0,0 +1,62 @@
+# 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.
+
+from ironic.drivers import base
+from ironic.drivers.modules import agent
+from ironic.drivers.modules import fake
+from ironic.drivers.modules import inspector
+from ironic.drivers.modules import ipmitool
+from ironic.drivers.modules import pxe
+from ironic.drivers import utils
+
+from ironic_staging_drivers.intel_nm import nm_vendor
+
+
+class FakeIntelNMDriver(base.BaseDriver):
+    """Fake Intel NM driver."""
+
+    def __init__(self):
+        self.power = fake.FakePower()
+        self.deploy = fake.FakeDeploy()
+        self.vendor = nm_vendor.IntelNMVendorPassthru()
+
+
+class AgentAndIPMIToolIntelNMDriver(base.BaseDriver):
+    """Agent + IPMITool driver with Intel NM policies."""
+    def __init__(self):
+        self.power = ipmitool.IPMIPower()
+        self.boot = pxe.PXEBoot()
+        self.deploy = agent.AgentDeploy()
+        self.management = ipmitool.IPMIManagement()
+        self.console = ipmitool.IPMIShellinaboxConsole()
+        self.agent_vendor = agent.AgentVendorInterface()
+        self.ipmi_vendor = ipmitool.VendorPassthru()
+        self.nm_vendor = nm_vendor.IntelNMVendorPassthru()
+        self.mapping = {'send_raw': self.ipmi_vendor,
+                        'bmc_reset': self.ipmi_vendor,
+                        'heartbeat': self.agent_vendor,
+                        'control_nm_policy': self.nm_vendor,
+                        'set_nm_policy': self.nm_vendor,
+                        'get_nm_policy': self.nm_vendor,
+                        'remove_nm_policy': self.nm_vendor,
+                        'set_nm_policy_suspend': self.nm_vendor,
+                        'get_nm_policy_suspend': self.nm_vendor,
+                        'remove_nm_policy_suspend': self.nm_vendor,
+                        'get_nm_capabilities': self.nm_vendor,
+                        'get_nm_version': self.nm_vendor}
+        self.driver_passthru_mapping = {'lookup': self.agent_vendor}
+        self.vendor = utils.MixinVendorInterface(
+            self.mapping,
+            driver_passthru_mapping=self.driver_passthru_mapping)
+        self.raid = agent.AgentRAID()
+        self.inspect = inspector.Inspector.create_if_enabled(
+            'AgentAndIPMIToolDriver')
diff --git a/ironic_staging_drivers/intel_nm/control_schema.json b/ironic_staging_drivers/intel_nm/control_schema.json
new file mode 100644
index 0000000..a899044
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/control_schema.json
@@ -0,0 +1,25 @@
+{
+    "title": "Intel Node Manager policies control schema",
+    "type": "object",
+    "properties": {
+        "scope": {
+            "type": "string",
+            "enum": ["global", "domain", "policy"]
+        },
+        "enable": {
+            "type": "boolean"
+        },
+        "domain_id": {
+            "type": "string",
+            "enum": ["platform", "cpu", "memory", "io"]
+        },
+        "policy_id": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 255
+        }
+    },
+    "required": ["scope", "enable"],
+    "additionalProperties": false
+}
+
diff --git a/ironic_staging_drivers/intel_nm/get_cap_schema.json b/ironic_staging_drivers/intel_nm/get_cap_schema.json
new file mode 100644
index 0000000..5e06a0b
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/get_cap_schema.json
@@ -0,0 +1,21 @@
+{
+    "title": "Intel Node Manager get capabilities schema",
+    "type": "object",
+    "properties": {
+        "domain_id": {
+            "type": "string",
+            "enum": ["platform", "cpu", "memory", "io"]
+        },
+        "policy_trigger": {
+            "type": "string",
+            "enum": ["none", "temperature", "power", "reset", "boot"]
+        },
+        "power_domain": {
+            "type": "string",
+            "enum": ["primary", "secondary"]
+        }
+    },
+    "required": ["domain_id", "policy_trigger", "power_domain" ],
+    "additionalProperties": false
+}
+
diff --git a/ironic_staging_drivers/intel_nm/ipmi.py b/ironic_staging_drivers/intel_nm/ipmi.py
new file mode 100644
index 0000000..18a25be
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/ipmi.py
@@ -0,0 +1,85 @@
+# 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.
+
+from ironic.common import exception
+from ironic.conductor import task_manager
+from ironic.drivers.modules import ipmitool
+from oslo_concurrency import processutils
+from oslo_log import log
+
+from ironic_staging_drivers.common.i18n import _LE
+
+LOG = log.getLogger(__name__)
+
+# NOTE(yuriyz): there are extended version of send_raw() from Ironic ipmitool
+# driver and dump_sdr(). These functions depends on ipmitool driver internals,
+# and should be moved to Ironic for use from out-of-tree drivers.
+
+
+@task_manager.require_exclusive_lock
+def send_raw(task, raw_bytes):
+    """Send raw bytes to the BMC. Bytes should be a string of bytes.
+
+    :param task: a TaskManager instance.
+    :param raw_bytes: a string of raw bytes to send, e.g. '0x00 0x01'
+    :returns: a tuple with stdout and stderr.
+    :raises: IPMIFailure on an error from ipmitool.
+    :raises: MissingParameterValue if a required parameter is missing.
+    :raises: InvalidParameterValue when an invalid value is specified.
+
+    """
+    node_uuid = task.node.uuid
+    LOG.debug('Sending node %(node)s raw bytes %(bytes)s',
+              {'bytes': raw_bytes, 'node': node_uuid})
+    driver_info = ipmitool._parse_driver_info(task.node)
+    cmd = 'raw %s' % raw_bytes
+
+    try:
+        out, err = ipmitool._exec_ipmitool(driver_info, cmd)
+        LOG.debug('send raw bytes returned stdout: %(stdout)s, stderr:'
+                  ' %(stderr)s', {'stdout': out, 'stderr': err})
+    except (exception.PasswordFileFailedToCreate,
+            processutils.ProcessExecutionError) as e:
+        LOG.exception(_LE('IPMI "raw bytes" failed for node %(node_id)s '
+                      'with error: %(error)s.'),
+                      {'node_id': node_uuid, 'error': e})
+        raise exception.IPMIFailure(cmd=cmd)
+
+    return out, err
+
+
+def dump_sdr(task, file_path):
+    """Dump SDR data to a file.
+
+    :param task: a TaskManager instance.
+    :param file_path: the path to SDR dump file.
+    :raises: IPMIFailure on an error from ipmitool.
+    :raises: MissingParameterValue if a required parameter is missing.
+    :raises: InvalidParameterValue when an invalid value is specified.
+
+    """
+    node_uuid = task.node.uuid
+    LOG.debug('Dump SDR data for node %(node)s to file %(name)s',
+              {'name': file_path, 'node': node_uuid})
+    driver_info = ipmitool._parse_driver_info(task.node)
+    cmd = 'sdr dump %s' % file_path
+
+    try:
+        out, err = ipmitool._exec_ipmitool(driver_info, cmd)
+        LOG.debug('dump SDR returned stdout: %(stdout)s, stderr:'
+                  ' %(stderr)s', {'stdout': out, 'stderr': err})
+    except (exception.PasswordFileFailedToCreate,
+            processutils.ProcessExecutionError) as e:
+        LOG.exception(_LE('IPMI "sdr dump" failed for node %(node_id)s '
+                      'with error: %(error)s.'),
+                      {'node_id': node_uuid, 'error': e})
+        raise exception.IPMIFailure(cmd=cmd)
diff --git a/ironic_staging_drivers/intel_nm/main_ids_schema.json b/ironic_staging_drivers/intel_nm/main_ids_schema.json
new file mode 100644
index 0000000..87d2de9
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/main_ids_schema.json
@@ -0,0 +1,17 @@
+{
+    "title": "Intel Node Manager domain and policy id json schema",
+    "type": "object",
+    "properties": {
+        "domain_id": {
+            "type": "string",
+            "enum": ["platform", "cpu", "memory", "io"]
+        },
+        "policy_id": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 255
+        }
+    },
+    "required": ["domain_id", "policy_id"],
+    "additionalProperties": false
+}
diff --git a/ironic_staging_drivers/intel_nm/nm_commands.py b/ironic_staging_drivers/intel_nm/nm_commands.py
new file mode 100644
index 0000000..c73badb
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/nm_commands.py
@@ -0,0 +1,429 @@
+# 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.
+
+import binascii
+import collections
+import struct
+
+from ironic.common import exception
+import six
+
+from ironic_staging_drivers.common.i18n import _
+
+
+INTEL_NM_DOMAINS = {
+    'platform': 0x00,
+    'cpu': 0x01,
+    'memory': 0x02,
+    'protection': 0x03,
+    'io': 0x04
+}
+
+INTEL_NM_TRIGGERS = {
+    'none': 0x00,
+    'temperature': 0x01,
+    'power': 0x02,
+    'reset': 0x03,
+    'boot': 0x04
+}
+
+INTEL_NM_CPU_CORRECTION = {
+    'auto': 0x00,
+    'unagressive': 0x20,
+    'aggressive': 0x40,
+}
+
+INTEL_NM_STORAGE = {
+    'persistent': 0x00,
+    'volatile': 0x80,
+}
+
+INTEL_NM_ACTIONS = {
+    'alert': 0x00,
+    'shutdown': 0x01,
+}
+
+INTEL_NM_POWER_DOMAIN = {
+    'primary': 0x00,
+    'secondary': 0x80,
+}
+
+INTEL_NM_BOOT_MODE = {
+    'power': 0x00,
+    'performance': 0x01,
+}
+
+INTEL_NM_DAYS = collections.OrderedDict([('monday', 0x01),
+                                         ('tuesday', 0x02),
+                                         ('wednesday', 0x04),
+                                         ('thursday', 0x08),
+                                         ('friday', 0x10),
+                                         ('saturday', 0x20),
+                                         ('sunday', 0x40)])
+
+VERSIONS = {
+    0x01: '1.0',
+    0x02: '1.5',
+    0x03: '2.0',
+    0x04: '2.5',
+    0x05: '3.0'
+}
+
+IPMI_VERSIONS = {
+    0x01: '1.0',
+    0x02: '2.0',
+    0x03: '3.0'
+}
+
+
+def _reverse_dict(d):
+    return {v: k for k, v in d.items()}
+
+
+INTEL_NM_DOMAINS_REV = _reverse_dict(INTEL_NM_DOMAINS)
+INTEL_NM_TRIGGERS_REV = _reverse_dict(INTEL_NM_TRIGGERS)
+INTEL_NM_CPU_CORRECTION_REV = _reverse_dict(INTEL_NM_CPU_CORRECTION)
+INTEL_NM_STORAGE_REV = _reverse_dict(INTEL_NM_STORAGE)
+INTEL_NM_ACTIONS_REV = _reverse_dict(INTEL_NM_ACTIONS)
+INTEL_NM_POWER_DOMAIN_REV = _reverse_dict(INTEL_NM_POWER_DOMAIN)
+
+# OEM group extension code defined in IPMI spec
+INTEL_NM_NETFN = '0x2E'
+
+# Intel manufacturer ID for OEM extension, LS byte first
+INTEL_NM_ID = ('0x57', '0x01', '0x00')
+
+# Intel NM commands
+INTEL_NM_POLICY_CONTROL = '0xC0'
+INTEL_NM_POLICY_SET = '0xC1'
+INTEL_NM_POLICY_GET = '0xC2'
+INTEL_NM_SUSPEND_SET = '0xC5'
+INTEL_NM_SUSPEND_GET = '0xC6'
+INTEL_NM_CAPABILITIES_GET = '0xC9'
+INTEL_NM_VERSION_GET = '0xCA'
+
+
+def _handle_parsing_error(func):
+    """Decorator for handling errors in raw output data."""
+    @six.wraps(func)
+    def wrapper(raw_data):
+        msg = _('Data from Intel Node Manager %s')
+
+        try:
+            return func(raw_data)
+        except (IndexError, struct.error):
+            raise exception.IPMIFailure(msg % _('has wrong length.'))
+        except KeyError:
+            raise exception.IPMIFailure(msg % _('is corrupted.'))
+        except ValueError:
+            raise exception.IPMIFailure(msg % _('cannot be converted.'))
+
+    return wrapper
+
+
+def _hex(x):
+    """Formatting integer as two digit hex value."""
+    return '0x{:02X}'.format(x)
+
+
+def _raw_to_int(raw_data):
+    """Converting list of raw hex values as strings to integers."""
+    return [int(x, 16) for x in raw_data]
+
+
+def _bytehex(data):
+    """Iterate by one byte with hexlify() output."""
+    for i in range(0, len(data), 2):
+        yield data[i:i + 2]
+
+
+def _hexarray(data):
+    """Converting binary data to list of hex bytes as strings."""
+    return ['0x' + x.decode() for x in _bytehex(binascii.hexlify(data))]
+
+
+def _append_to_command(cmd, data):
+    """Append list or single value to command."""
+    if not isinstance(data, (list, tuple)):
+        data = [data]
+    cmd.extend(data)
+
+
+def _add_to_dict(data_dict, values, names):
+    """Add to dict values with corresponding names."""
+    data_dict.update(dict(zip(names, values)))
+
+
+def _create_command_head(command):
+    """Create first part of Intel NM command."""
+    cmd = [INTEL_NM_NETFN, command]
+    _append_to_command(cmd, INTEL_NM_ID)
+    return cmd
+
+
+def _add_domain_policy_id(cmd, data):
+    """Add domain id and policy id to command."""
+    _append_to_command(cmd, _hex(INTEL_NM_DOMAINS[data['domain_id']]))
+    _append_to_command(cmd, _hex(data['policy_id']))
+
+
+def _days_compose(days):
+    """Converting list of days to binary representation."""
+    pattern = 0
+    for day in days:
+        pattern |= INTEL_NM_DAYS[day]
+    return pattern
+
+
+def _days_parse(pattern):
+    """Parse binary data with days of week."""
+    return [day for day in INTEL_NM_DAYS if pattern & INTEL_NM_DAYS[day]]
+
+
+def set_policy(policy):
+    """Return hex data for policy set command."""
+    # NM defaults
+    if 'cpu_power_correction' not in policy:
+        policy['cpu_power_correction'] = 'auto'
+    if 'storage' not in policy:
+        policy['storage'] = 'persistent'
+    if policy['policy_trigger'] in ('none', 'boot'):
+        policy['trigger_limit'] = 0
+
+    cmd = _create_command_head(INTEL_NM_POLICY_SET)
+    _append_to_command(cmd, _hex(INTEL_NM_DOMAINS[policy['domain_id']] |
+                       0x10 if policy['enable'] else 0x00))
+    _append_to_command(cmd, _hex(policy['policy_id']))
+    # 0x10 is policy add flag
+    _append_to_command(cmd, _hex(INTEL_NM_TRIGGERS[policy['policy_trigger']] |
+                       INTEL_NM_CPU_CORRECTION[policy['cpu_power_correction']]
+                       | INTEL_NM_STORAGE[policy['storage']] | 0x10))
+    _append_to_command(cmd, _hex(INTEL_NM_ACTIONS[policy['action']] |
+                       INTEL_NM_POWER_DOMAIN[policy['power_domain']]))
+
+    if isinstance(policy['target_limit'], int):
+        limit = policy['target_limit']
+    else:
+        mode = 0x00 if policy['target_limit']['boot_mode'] == 'power' else 0x01
+        cores_disabled = policy['target_limit']['cores_disabled'] << 1
+        limit = mode | cores_disabled
+
+    policy_values = struct.pack('<HIHH', limit, policy['correction_time'],
+                                policy['trigger_limit'],
+                                policy['reporting_period'])
+    _append_to_command(cmd, _hexarray(policy_values))
+
+    return cmd
+
+
+@_handle_parsing_error
+def parse_policy(raw_data):
+    """Parse policy data."""
+    policy = {}
+    raw_int = _raw_to_int(raw_data)
+
+    policy['domain_id'] = INTEL_NM_DOMAINS_REV[raw_int[3] & 0x0F]
+    policy['enabled'] = bool(raw_int[3] & 0x10)
+    policy['per_domain_enabled'] = bool(raw_int[3] & 0x20)
+    policy['global_enabled'] = bool(raw_int[3] & 0x40)
+    policy['created_by_nm'] = not bool(raw_int[3] & 0x80)
+    policy['policy_trigger'] = INTEL_NM_TRIGGERS_REV[raw_int[4] & 0x0F]
+    policy['power_policy'] = bool(raw_int[4] & 0x10)
+    power_correction = INTEL_NM_CPU_CORRECTION_REV[raw_int[4] & 0x60]
+    policy['cpu_power_correction'] = power_correction
+    policy['storage'] = INTEL_NM_STORAGE_REV[raw_int[4] & 0x80]
+    policy['action'] = INTEL_NM_ACTIONS_REV[raw_int[5] & 0x01]
+    policy['power_domain'] = INTEL_NM_POWER_DOMAIN_REV[raw_int[5] & 0x80]
+    policy_values = struct.unpack('<HIHH', bytearray(raw_int[6:]))
+    policy_names = ('target_limit', 'correction_time', 'trigger_limit',
+                    'reporting_period')
+    _add_to_dict(policy, policy_values, policy_names)
+
+    return policy
+
+
+def set_policy_suspend(suspend):
+    """Return hex data for policy suspend set command."""
+    cmd = _create_command_head(INTEL_NM_SUSPEND_SET)
+    _add_domain_policy_id(cmd, suspend)
+    periods = suspend['periods']
+    _append_to_command(cmd, _hex(len(periods)))
+
+    for period in periods:
+        _append_to_command(cmd, _hex(period['start']))
+        _append_to_command(cmd, _hex(period['stop']))
+        _append_to_command(cmd, _hex(_days_compose(period['days'])))
+
+    return cmd
+
+
+@_handle_parsing_error
+def parse_policy_suspend(raw_data):
+    """Parse policy suspend data."""
+    suspends = []
+    raw_int = _raw_to_int(raw_data)
+
+    policy_num = raw_int[3]
+    for num in range(policy_num):
+        base = num * 3 + 4
+        suspend = {
+            "start": raw_int[base],
+            "stop": raw_int[base + 1],
+            "days": _days_parse(raw_int[base + 2])
+        }
+        suspends.append(suspend)
+
+    return suspends
+
+
+def get_capabilities(data):
+    """Return hex data for capabilities get command."""
+    cmd = _create_command_head(INTEL_NM_CAPABILITIES_GET)
+    _append_to_command(cmd, _hex(INTEL_NM_DOMAINS[data['domain_id']]))
+    power_policy = 0x10
+    _append_to_command(cmd, _hex(INTEL_NM_TRIGGERS[data['policy_trigger']] |
+                       power_policy |
+                       INTEL_NM_POWER_DOMAIN[data['power_domain']]))
+
+    return cmd
+
+
+@_handle_parsing_error
+def parse_capabilities(raw_data):
+    """Parse capabilities data."""
+    capabilities = {}
+    raw_int = _raw_to_int(raw_data)
+
+    capabilities['max_policies'] = raw_int[3]
+    capabilities_values = struct.unpack('<HHIIHH', bytearray(
+                                        raw_int[4:20]))
+    capabilities_names = ('max_limit_value', 'min_limit_value',
+                          'min_correction_time', 'max_correction_time',
+                          'min_reporting_period', 'max_reporting_period')
+    _add_to_dict(capabilities, capabilities_values, capabilities_names)
+    capabilities['domain_id'] = INTEL_NM_DOMAINS_REV[raw_int[20] & 0x0F]
+    power_domain = INTEL_NM_POWER_DOMAIN_REV[raw_int[20] & 0x80]
+    capabilities['power_domain'] = power_domain
+
+    return capabilities
+
+
+def control_policies(control_data):
+    """Return hex data for enable or disable policy command."""
+    cmd = _create_command_head(INTEL_NM_POLICY_CONTROL)
+
+    enable = control_data['enable']
+    scope = control_data['scope']
+
+    if scope == 'global':
+        flags = '0x01' if enable else '0x00'
+        domain_id = 0
+        policy_id = 0
+    elif scope == 'domain':
+        flags = '0x03' if enable else '0x02'
+        domain_id = INTEL_NM_DOMAINS[control_data['domain_id']]
+        policy_id = 0
+    elif scope == 'policy':
+        flags = '0x05' if enable else '0x04'
+        domain_id = INTEL_NM_DOMAINS[control_data['domain_id']]
+        policy_id = control_data['policy_id']
+
+    _append_to_command(cmd, flags)
+    _append_to_command(cmd, _hex(domain_id))
+    _append_to_command(cmd, _hex(policy_id))
+
+    return cmd
+
+
+def get_policy(data):
+    """Return hex data for policy get command."""
+    cmd = _create_command_head(INTEL_NM_POLICY_GET)
+    _add_domain_policy_id(cmd, data)
+
+    return cmd
+
+
+def remove_policy(data):
+    """Return hex data for policy remove command."""
+    cmd = _create_command_head(INTEL_NM_POLICY_SET)
+    _add_domain_policy_id(cmd, data)
+    # first 0 is remove policy, extra will be ignored
+    _append_to_command(cmd, ('0x00',) * 12)
+
+    return cmd
+
+
+def get_policy_suspend(data):
+    """Return hex data for policy get suspend command."""
+    cmd = _create_command_head(INTEL_NM_SUSPEND_GET)
+    _add_domain_policy_id(cmd, data)
+
+    return cmd
+
+
+def remove_policy_suspend(data):
+    """Return hex data for policy remove suspend command."""
+    cmd = _create_command_head(INTEL_NM_SUSPEND_SET)
+    _add_domain_policy_id(cmd, data)
+    # remove suspend
+    _append_to_command(cmd, '0x00')
+
+    return cmd
+
+
+def get_version(data):
+    """Return hex data for version get command."""
+    cmd = _create_command_head(INTEL_NM_VERSION_GET)
+
+    return cmd
+
+
+@_handle_parsing_error
+def parse_version(raw_data):
+    """Parse versions data."""
+    version = {}
+    raw_int = _raw_to_int(raw_data)
+
+    version['nm'] = VERSIONS.get(raw_int[3], 'unknown')
+    version['ipmi'] = IPMI_VERSIONS.get(raw_int[4], 'unknown')
+    version['patch'] = str(raw_int[5])
+    version['firmware'] = str(raw_int[6]) + '.' + str(raw_int[7])
+
+    return version
+
+
+# Code below taken from Ceilometer
+# Copyright 2014 Intel Corporation.
+def parse_slave_and_channel(file_path):
+    """Parse the dumped file to get slave address and channel number.
+
+    :param file_path: file path of dumped SDR file.
+    :return: slave address and channel number of target device.
+    """
+    prefix = '5701000d01'
+    # According to Intel Node Manager spec, section 4.5, for Intel NM
+    # discovery OEM SDR records are type C0h. It contains manufacture ID
+    # and OEM data in the record body.
+    # 0-2 bytes are OEM ID, byte 3 is 0Dh and byte 4 is 01h. Byte 5, 6
+    # is Intel NM device slave address and channel number/sensor owner LUN.
+    with open(file_path, 'rb') as bin_fp:
+        data_str = binascii.hexlify(bin_fp.read())
+
+    if six.PY3:
+        data_str = data_str.decode()
+    oem_id_index = data_str.find(prefix)
+    if oem_id_index != -1:
+        ret = data_str[oem_id_index + len(prefix):
+                       oem_id_index + len(prefix) + 4]
+        # Byte 5 is slave address. [7:4] from byte 6 is channel
+        # number, so just pick ret[2] here.
+        return ('0x' + ret[0:2], '0x0' + ret[2])
diff --git a/ironic_staging_drivers/intel_nm/nm_vendor.py b/ironic_staging_drivers/intel_nm/nm_vendor.py
new file mode 100644
index 0000000..7ea69f9
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/nm_vendor.py
@@ -0,0 +1,294 @@
+# 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.
+
+import json
+import os
+
+from ironic.common import exception
+from ironic.drivers import base
+from ironic_lib import utils as ironic_utils
+import jsonschema
+from jsonschema import exceptions as json_schema_exc
+from oslo_config import cfg
+from oslo_log import log
+from oslo_utils import excutils
+import six
+
+from ironic_staging_drivers.common.i18n import _
+from ironic_staging_drivers.common.i18n import _LE
+from ironic_staging_drivers.common.i18n import _LI
+from ironic_staging_drivers.intel_nm import ipmi
+from ironic_staging_drivers.intel_nm import nm_commands
+
+
+CONF = cfg.CONF
+CONF.import_opt('tempdir', 'ironic.common.utils')
+LOG = log.getLogger(__name__)
+
+SCHEMAS = ('control_schema', 'get_cap_schema', 'main_ids_schema',
+           'policy_schema', 'suspend_schema')
+
+
+def _command_to_string(cmd):
+    """Convert a list with command raw bytes to string."""
+    return ' '.join(cmd)
+
+
+def _get_nm_address(task):
+    """Get Intel Node Manager target channel and address.
+
+    :param task: a TaskManager instance.
+    :raises: IPMIFailure if Intel Node Manager is not detected on a node or if
+             an error happens during detection.
+    :returns: a tuple with IPMI channel and address of Intel Node Manager.
+    """
+    node = task.node
+    driver_internal_info = node.driver_internal_info
+
+    def _save_to_node(channel, address):
+        driver_internal_info['intel_nm_channel'] = channel
+        driver_internal_info['intel_nm_address'] = address
+        node.driver_internal_info = driver_internal_info
+        node.save()
+
+    channel = driver_internal_info.get('intel_nm_channel')
+    address = driver_internal_info.get('intel_nm_address')
+    if channel and address:
+        return channel, address
+    if channel is False and address is False:
+        raise exception.IPMIFailure(_('Driver data indicates that Intel '
+                                      'Node Manager detection failed.'))
+    LOG.info(_LI('Start detection of Intel Node Manager on node %s'),
+             node.uuid)
+    sdr_filename = os.path.join(CONF.tempdir, node.uuid + '.sdr')
+    res = None
+    try:
+        ipmi.dump_sdr(task, sdr_filename)
+        res = nm_commands.parse_slave_and_channel(sdr_filename)
+    finally:
+        ironic_utils.unlink_without_raise(sdr_filename)
+    if res is None:
+        _save_to_node(False, False)
+        raise exception.IPMIFailure(_('Intel Node Manager is not detected.'))
+    address, channel = res
+    LOG.debug('Intel Node Manager sensors present in SDR on node %(node)s, '
+              'channel %(channel)s address %(address)s.',
+              {'node': node.uuid, 'channel': channel, 'address': address})
+    # SDR can contain wrong info, try simple command
+    node.driver_info['ipmi_bridging'] = 'single'
+    node.driver_info['ipmi_target_channel'] = channel
+    node.driver_info['ipmi_target_address'] = address
+    try:
+        ipmi.send_raw(task, _command_to_string(nm_commands.get_version(None)))
+        _save_to_node(channel, address)
+        return channel, address
+    except exception.IPMIFailure:
+        _save_to_node(False, False)
+        raise exception.IPMIFailure(_('Intel Node Manager sensors record '
+                                      'present in SDR but Node Manager is not '
+                                      'responding.'))
+
+
+def _execute_nm_command(task, data, command_func, parse_func=None):
+    """Execute Intel Node Manager command via send_raw().
+
+    :param task: a TaskManager instance.
+    :param data: a dict with data passed to vendor's method.
+    :param command_func: a function that returns raw command bytes.
+    :param parse_func: a function that parses returned raw bytes.
+    :raises: IPMIFailure if Intel Node Manager is not detected on a node or if
+             an error happens during command execution.
+    :returns: a dict with parsed output or None if command does not return
+              user's info.
+    """
+    try:
+        channel, address = _get_nm_address(task)
+    except exception.IPMIFailure as e:
+        with excutils.save_and_reraise_exception():
+            LOG.exception(_LE('Can not obtain Intel Node Manager address for '
+                              'node %(node)s: %(err)s'),
+                          {'node': task.node.uuid, 'err': six.text_type(e)})
+    driver_info = task.node.driver_info
+    driver_info['ipmi_bridging'] = 'single'
+    driver_info['ipmi_target_channel'] = channel
+    driver_info['ipmi_target_address'] = address
+    cmd = _command_to_string(command_func(data))
+    out = ipmi.send_raw(task, cmd)[0]
+    if parse_func:
+        try:
+            return parse_func(out.split())
+        except exception.IPMIFailure as e:
+            with excutils.save_and_reraise_exception():
+                LOG.exception(_LE('Error in returned data for node %(node)s: '
+                                  '%(err)s'), {'node': task.node.uuid,
+                                               'err': six.text_type(e)})
+
+
+class IntelNMVendorPassthru(base.VendorInterface):
+    """Intel Node Manager policies vendor interface."""
+
+    def __init__(self):
+        schemas_dir = os.path.dirname(__file__)
+        for schema in SCHEMAS:
+            filename = os.path.join(schemas_dir, schema + '.json')
+            with open(filename, 'r') as sf:
+                setattr(self, schema, json.load(sf))
+
+    def get_properties(self):
+        """Returns the properties of the interface.."""
+        return {}
+
+    def validate(self, task, method, http_method, **kwargs):
+        """Validates the vendor method's parameters.
+
+        This method validates whether the supplied data contains the required
+        information for the driver.
+
+        :param task: a TaskManager instance.
+        :param method: name of vendor method.
+        :param http_method: HTTP method.
+        :param kwargs: data passed to vendor's method.
+        :raises: InvalidParameterValue if supplied data is not valid.
+        :raises: MissingParameterValue if parameters missing in supplied data.
+        """
+        try:
+            if method in ('get_nm_policy', 'remove_nm_policy',
+                          'get_nm_policy_suspend', 'remove_nm_policy_suspend'):
+                jsonschema.validate(kwargs, self.main_ids_schema)
+
+            elif method == 'control_nm_policy':
+                jsonschema.validate(kwargs, self.control_schema)
+                no_domain = _('Missing "domain_id"')
+                no_policy = _('Missing "policy_id"')
+                if kwargs['scope'] == 'domain' and not kwargs.get('domain_id'):
+                    raise exception.MissingParameterValue(no_domain)
+                if kwargs['scope'] == 'policy':
+                    if not kwargs.get('domain_id'):
+                        raise exception.MissingParameterValue(no_domain)
+                    if not kwargs.get('policy_id'):
+                        raise exception.MissingParameterValue(no_policy)
+
+            elif method == 'set_nm_policy':
+                jsonschema.validate(kwargs, self.policy_schema)
+                if kwargs['policy_trigger'] == 'boot':
+                    if not isinstance(kwargs['target_limit'], dict):
+                        raise exception.InvalidParameterValue(_('Invalid boot '
+                                                                'policy'))
+
+            elif method == 'set_nm_policy_suspend':
+                jsonschema.validate(kwargs, self.suspend_schema)
+
+            elif method == 'get_nm_capabilities':
+                jsonschema.validate(kwargs, self.get_cap_schema)
+
+        except json_schema_exc.ValidationError as e:
+            raise exception.InvalidParameterValue(_('Input data validation '
+                                                    'error: %s') % e)
+
+    @base.passthru(['PUT'])
+    def control_nm_policy(self, task, **kwargs):
+        """Enable or disable Intel Node Manager policy control.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        """
+        _execute_nm_command(task, kwargs, nm_commands.control_policies)
+
+    @base.passthru(['PUT'])
+    def set_nm_policy(self, task, **kwargs):
+        """Set Intel Node Manager policy.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        """
+        _execute_nm_command(task, kwargs, nm_commands.set_policy)
+
+    @base.passthru(['GET'], async=False)
+    def get_nm_policy(self, task, **kwargs):
+        """Get Intel Node Manager policy.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        :returns: a dictionary containing policy settings.
+        """
+        return _execute_nm_command(task, kwargs, nm_commands.get_policy,
+                                   nm_commands.parse_policy)
+
+    @base.passthru(['DELETE'])
+    def remove_nm_policy(self, task, **kwargs):
+        """Remove Intel Node Manager policy.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        """
+        _execute_nm_command(task, kwargs, nm_commands.remove_policy)
+
+    @base.passthru(['PUT'])
+    def set_nm_policy_suspend(self, task, **kwargs):
+        """Set Intel Node Manager policy suspend periods.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        """
+        _execute_nm_command(task, kwargs, nm_commands.set_policy_suspend)
+
+    @base.passthru(['GET'], async=False)
+    def get_nm_policy_suspend(self, task, **kwargs):
+        """Get Intel Node Manager policy suspend periods.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        :returns: a dictionary containing suspend info for a policy.
+        """
+        return _execute_nm_command(task, kwargs,
+                                   nm_commands.get_policy_suspend,
+                                   nm_commands.parse_policy_suspend)
+
+    @base.passthru(['DELETE'])
+    def remove_nm_policy_suspend(self, task, **kwargs):
+        """Remove Intel Node Manager policy suspend periods.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        """
+        _execute_nm_command(task, kwargs, nm_commands.remove_policy_suspend)
+
+    @base.passthru(['GET'], async=False)
+    def get_nm_capabilities(self, task, **kwargs):
+        """Get Intel Node Manager capabilities.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        :returns: a dictionary containing Intel NM capabilities.
+        """
+        return _execute_nm_command(task, kwargs, nm_commands.get_capabilities,
+                                   nm_commands.parse_capabilities)
+
+    @base.passthru(['GET'], async=False)
+    def get_nm_version(self, task, **kwargs):
+        """Get Intel Node Manager version.
+
+        :param task: a TaskManager instance.
+        :param kwargs: data passed to method.
+        :raises: IPMIFailure on an error.
+        :returns: a dictionary containing Intel NM version.
+        """
+        return _execute_nm_command(task, kwargs, nm_commands.get_version,
+                                   nm_commands.parse_version)
diff --git a/ironic_staging_drivers/intel_nm/policy_schema.json b/ironic_staging_drivers/intel_nm/policy_schema.json
new file mode 100644
index 0000000..3c683e5
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/policy_schema.json
@@ -0,0 +1,79 @@
+{
+    "title": "Intel Node Manager policy json schema",
+    "type": "object",
+    "properties": {
+        "domain_id": {
+            "type": "string",
+            "enum": ["platform", "cpu", "memory", "io"]
+        },
+        "enable": {
+            "type": "boolean"
+        },
+        "policy_id": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 255
+        },
+        "policy_trigger": {
+            "type": "string",
+            "enum": ["none", "temperature", "power", "reset", "boot"]
+        },
+        "cpu_power_correction": {
+            "type": "string",
+            "enum": ["auto", "unagressive", "aggressive"]
+        },
+        "storage": {
+            "type": "string",
+            "enum": ["persistent", "volatile"]
+        },
+        "action": {
+            "type": "string",
+            "enum": ["alert", "shutdown"]
+        },
+        "power_domain": {
+            "type": "string",
+            "enum": ["primary", "secondary"]
+        },
+        "target_limit": {
+            "anyOf": [{
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 65535
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "boot_mode": {
+                        "type": "string",
+                        "enum": ["power", "performance"]
+                    },
+                    "cores_disabled": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 127
+                    }
+                },
+                "required": ["boot_mode", "cores_disabled"],
+                "additionalProperties": false
+
+            }]
+        },
+        "correction_time": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "trigger_limit": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 65535
+        },
+        "reporting_period": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 65535
+        }
+    },
+    "required": ["domain_id", "enable", "policy_id", "policy_trigger", "action", "power_domain", "target_limit", "correction_time", "reporting_period" ],
+    "additionalProperties": false
+}
+
diff --git a/ironic_staging_drivers/intel_nm/suspend_schema.json b/ironic_staging_drivers/intel_nm/suspend_schema.json
new file mode 100644
index 0000000..fe575a1
--- /dev/null
+++ b/ironic_staging_drivers/intel_nm/suspend_schema.json
@@ -0,0 +1,48 @@
+{
+    "title": "Intel Node Manager policy suspend periods json schema",
+    "type": "object",
+    "properties": {
+        "domain_id": {
+            "type": "string",
+            "enum": ["platform", "cpu", "memory", "io"]
+        },
+        "policy_id": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 255
+        },
+        "periods": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "start": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 240
+                    },
+                    "stop": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 240
+                    },
+                    "days": {
+                        "type": "array",
+                        "items": {
+                            "type": "string",
+                            "enum": ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
+                        },
+                        "uniqueItems": true,
+                        "minItems": 1
+                    }
+                },
+                "required": ["start", "stop", "days" ],
+                "additionalProperties": false
+            },
+            "minItems": 1,
+            "maxItems": 5
+        }
+    },
+    "required": ["domain_id", "policy_id", "periods" ],
+    "additionalProperties": false
+}
diff --git a/ironic_staging_drivers/tests/unit/intel_nm/__init__.py b/ironic_staging_drivers/tests/unit/intel_nm/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/ironic_staging_drivers/tests/unit/intel_nm/test_commands.py b/ironic_staging_drivers/tests/unit/intel_nm/test_commands.py
new file mode 100644
index 0000000..040eb14
--- /dev/null
+++ b/ironic_staging_drivers/tests/unit/intel_nm/test_commands.py
@@ -0,0 +1,265 @@
+# 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.
+
+"""
+Tests for Intel NM policies commands
+"""
+
+import tempfile
+
+from ironic.common import exception
+from ironic.tests import base
+
+from ironic_staging_drivers.intel_nm import nm_commands as commands
+
+
+@commands._handle_parsing_error
+def fake_parse(fake_data):
+    return fake_data
+
+
+@commands._handle_parsing_error
+def fake_parse_exc(d):
+    raise IndexError()
+
+
+class ParsingErrorDecoratorTestCase(base.TestCase):
+
+    def test_parse_no_errors(self):
+        self.assertEqual('foo', fake_parse('foo'))
+
+    def test_parse_handled_exception(self):
+        self.assertRaises(exception.IPMIFailure, fake_parse_exc, 'foo')
+
+
+class IntelNMPoliciesCommandTestCase(base.TestCase):
+
+    def test_set_policy(self):
+        policy = {'domain_id': 'platform', 'enable': True, 'policy_id': 123,
+                  'policy_trigger': 'temperature',
+                  'cpu_power_correction': 'auto', 'storage': 'persistent',
+                  'action': 'alert', 'power_domain': 'primary',
+                  'target_limit': 1000, 'correction_time': 2000,
+                  'trigger_limit': 100, 'reporting_period': 600}
+        expected = ['0x2E', '0xC1', '0x57', '0x01', '0x00', '0x10', '0x7B',
+                    '0x11', '0x00', '0xe8', '0x03', '0xd0', '0x07', '0x00',
+                    '0x00', '0x64', '0x00', '0x58', '0x02']
+        result = commands.set_policy(policy)
+        self.assertEqual(expected, result)
+
+    def test_set_policy_with_defaults(self):
+        policy = {'domain_id': 'platform', 'enable': True, 'policy_id': 123,
+                  'policy_trigger': 'none', 'action': 'alert',
+                  'power_domain': 'primary', 'target_limit': 1000,
+                  'correction_time': 2000, 'reporting_period': 600}
+        expected = ['0x2E', '0xC1', '0x57', '0x01', '0x00', '0x10', '0x7B',
+                    '0x10', '0x00', '0xe8', '0x03', '0xd0', '0x07', '0x00',
+                    '0x00', '0x00', '0x00', '0x58', '0x02']
+        result = commands.set_policy(policy)
+        self.assertEqual(expected, result)
+
+    def test_set_policy_boot(self):
+        policy = {'domain_id': 'platform', 'enable': True, 'policy_id': 123,
+                  'policy_trigger': 'boot', 'cpu_power_correction': 'auto',
+                  'storage': 'persistent', 'action': 'alert',
+                  'power_domain': 'primary',
+                  'target_limit': {'boot_mode': 'power', 'cores_disabled': 2},
+                  'correction_time': 2000, 'trigger_limit': 100,
+                  'reporting_period': 600}
+        expected = ['0x2E', '0xC1', '0x57', '0x01', '0x00', '0x10', '0x7B',
+                    '0x14', '0x00', '0x04', '0x00', '0xd0', '0x07', '0x00',
+                    '0x00', '0x00', '0x00', '0x58', '0x02']
+        result = commands.set_policy(policy)
+        self.assertEqual(expected, result)
+
+    def test_set_policy_suspend(self):
+        suspend = {'domain_id': 'platform', 'policy_id': 123,
+                   'periods': [{'start': 20, 'stop': 100,
+                                'days': ['monday', 'tuesday']},
+                               {'start': 30, 'stop': 150,
+                                'days': ['friday', 'sunday']}]}
+        result = commands.set_policy_suspend(suspend)
+        expected = ['0x2E', '0xC5', '0x57', '0x01', '0x00', '0x00', '0x7B',
+                    '0x02', '0x14', '0x64', '0x03', '0x1E', '0x96', '0x50']
+        self.assertEqual(expected, result)
+
+    def test_get_capabilities(self):
+        cap_data = {'domain_id': 'platform', 'policy_trigger': 'none',
+                    'power_domain': 'primary'}
+        result = commands.get_capabilities(cap_data)
+        expected = ['0x2E', '0xC9', '0x57', '0x01', '0x00', '0x00', '0x10']
+        self.assertEqual(expected, result)
+
+    def test_control_policies(self):
+        control_data = {'scope': 'policy', 'enable': True,
+                        'domain_id': 'platform', 'policy_id': 123}
+        result = commands.control_policies(control_data)
+        expected = ['0x2E', '0xC0', '0x57', '0x01', '0x00', '0x05', '0x00',
+                    '0x7B']
+        self.assertEqual(expected, result)
+
+    def test_get_policy(self):
+        data = {'domain_id': 'platform', 'policy_id': 123}
+        result = commands.get_policy(data)
+        expected = ['0x2E', '0xC2', '0x57', '0x01', '0x00', '0x00', '0x7B']
+        self.assertEqual(expected, result)
+
+    def test_remove_policy(self):
+        data = {'domain_id': 'platform', 'policy_id': 123}
+        expected = (['0x2E', '0xC1', '0x57', '0x01', '0x00', '0x00', '0x7B'] +
+                    ['0x00'] * 12)
+        result = commands.remove_policy(data)
+        self.assertEqual(expected, result)
+
+    def test_get_policy_suspend(self):
+        data = {'domain_id': 'platform', 'policy_id': 123}
+        expected = ['0x2E', '0xC6', '0x57', '0x01', '0x00', '0x00', '0x7B']
+        result = commands.get_policy_suspend(data)
+        self.assertEqual(expected, result)
+
+    def test_remove_policy_suspend(self):
+        data = {'domain_id': 'platform', 'policy_id': 123}
+        expected = ['0x2E', '0xC5', '0x57', '0x01', '0x00', '0x00', '0x7B',
+                    '0x00']
+        result = commands.remove_policy_suspend(data)
+        self.assertEqual(expected, result)
+
+    def test_get_version(self):
+        result = commands.get_version(None)
+        expected = ['0x2E', '0xCA', '0x57', '0x01', '0x00']
+        self.assertEqual(expected, result)
+
+    def test_parse_policy(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x70', '0x00', '0x00', '0x02',
+                    '0xFF', '0x00', '0x01', '0x02', '0x00', '0x01', '0x20',
+                    '0x40', '0x01']
+        expected = {'action': 'alert', 'correction_time': 131328,
+                    'cpu_power_correction': 'auto', 'created_by_nm': True,
+                    'domain_id': 'platform', 'enabled': True,
+                    'global_enabled': True, 'per_domain_enabled': True,
+                    'policy_trigger': 'none', 'power_domain': 'primary',
+                    'power_policy': False, 'reporting_period': 320,
+                    'storage': 'persistent', 'target_limit': 65282,
+                    'trigger_limit': 8193}
+
+        result = commands.parse_policy(raw_data)
+        self.assertEqual(expected, result)
+
+    def test_parse_policy_invalid_length(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x70', '0x00', '0x00', '0x02',
+                    '0xFF', '0x00', '0x01', '0x02', '0x00', '0x01', '0x20']
+        self.assertRaises(exception.IPMIFailure, commands.parse_policy,
+                          raw_data)
+
+    def test_parse_policy_corrupted_data(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x7F', '0x00', '0x00', '0x02',
+                    '0xFF', '0x00', '0x01', '0x02', '0x00', '0x01', '0x20',
+                    '0x40', '0x01']
+        self.assertRaises(exception.IPMIFailure, commands.parse_policy,
+                          raw_data)
+
+    def test_parse_policy_conversion_error(self):
+        raw_data = ['0x00', '0x00', '0x00', 'boo', '0x00', '0x00', '0x02',
+                    '0xFF', '0x00', '0x01', '0x02', '0x00', '0x01', '0x20',
+                    '0x40', '0x01']
+        self.assertRaises(exception.IPMIFailure, commands.parse_policy,
+                          raw_data)
+
+    def test_parse_policy_suspend(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x02', '0x08', '0x18', '0x03',
+                    '0x20', '0x50', '0x18']
+        expected = [{'days': ['monday', 'tuesday'], 'start': 8, 'stop': 24},
+                    {'days': ['thursday', 'friday'], 'start': 32, 'stop': 80}]
+        result = commands.parse_policy_suspend(raw_data)
+        self.assertEqual(expected, result)
+
+    def test_parse_policy_suspend_invalid_lenght(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x22', '0x08', '0x18', '0x03']
+        self.assertRaises(exception.IPMIFailure, commands.parse_policy_suspend,
+                          raw_data)
+
+    def test_parse_policy_suspend_conversion_error(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x02', 'boo', '0x18', '0x03',
+                    '0x20', '0x50', '0x18']
+        self.assertRaises(exception.IPMIFailure, commands.parse_policy_suspend,
+                          raw_data)
+
+    def test_parse_capabilities(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x10', '0x00', '0x10', '0x00',
+                    '0x00', '0x00', '0x00', '0x00', '0x00', '0x00', '0x00',
+                    '0x80', '0x00', '0x00', '0x00', '0x00', '0x80', '0x00']
+        expected = {'domain_id': 'platform', 'max_correction_time': 8388608,
+                    'max_limit_value': 4096, 'max_policies': 16,
+                    'max_reporting_period': 32768, 'min_correction_time': 0,
+                    'min_limit_value': 0, 'min_reporting_period': 0,
+                    'power_domain': 'primary'}
+        result = commands.parse_capabilities(raw_data)
+        self.assertEqual(expected, result)
+
+    def test_parse_capabilities_invalid_lenght(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x10', '0x00', '0x10', '0x00']
+        self.assertRaises(exception.IPMIFailure, commands.parse_capabilities,
+                          raw_data)
+
+    def test_parse_capabilities_corrupted_data(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x10', '0x00', '0x10', '0x00',
+                    '0x00', '0x00', '0x00', '0x00', '0x00', '0x00', '0x00',
+                    '0x80', '0x00', '0x00', '0x00', '0x00', '0x80', '0xFF']
+        self.assertRaises(exception.IPMIFailure, commands.parse_capabilities,
+                          raw_data)
+
+    def test_parse_capabilities_conversion_error(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x10', '0x00', '0x10', '0x00',
+                    '0x00', '0x00', '0x00', '0x00', '0x00', '0x00', '0x00',
+                    '0x80', '0x00', '0x00', '0x00', 'boo', '0x80', '0x00']
+        self.assertRaises(exception.IPMIFailure, commands.parse_capabilities,
+                          raw_data)
+
+    def test_parse_version(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x05', '0x03', '0x07', '0x01',
+                    '0x02']
+        expected = {'firmware': '1.2', 'ipmi': '3.0', 'nm': '3.0',
+                    'patch': '7'}
+        result = commands.parse_version(raw_data)
+        self.assertEqual(expected, result)
+
+    def test_parse_version_invalid_lenght(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x05', '0x03', '0x07', '0x01']
+        self.assertRaises(exception.IPMIFailure, commands.parse_version,
+                          raw_data)
+
+    def test_parse_version_conversion_error(self):
+        raw_data = ['0x00', '0x00', '0x00', '0x05', '0x03', '0x07', '0x01',
+                    'boo']
+        self.assertRaises(exception.IPMIFailure, commands.parse_version,
+                          raw_data)
+
+
+class ParsingFromFileTestCase(base.TestCase):
+
+    def setUp(self):
+        super(ParsingFromFileTestCase, self).setUp()
+        self.temp_file = tempfile.NamedTemporaryFile().name
+
+    def test_parsing_found(self):
+        data = b'\x00\xFF\x00\xFF\x57\x01\x00\x0D\x01\x6A\xB2\x00\xFF'
+        with open(self.temp_file, 'wb') as f:
+            f.write(data)
+        result = commands.parse_slave_and_channel(self.temp_file)
+        self.assertEqual(('0x6a', '0x0b'), result)
+
+    def test_parsing_not_found(self):
+        data = b'\x00\xFF\x00\xFF\x52\x01\x80\x0D\x01\x6A\xB7\x00\xFF'
+        with open(self.temp_file, 'wb') as f:
+            f.write(data)
+        result = commands.parse_slave_and_channel(self.temp_file)
+        self.assertIsNone(result)
diff --git a/ironic_staging_drivers/tests/unit/intel_nm/test_vendor.py b/ironic_staging_drivers/tests/unit/intel_nm/test_vendor.py
new file mode 100644
index 0000000..98e2f09
--- /dev/null
+++ b/ironic_staging_drivers/tests/unit/intel_nm/test_vendor.py
@@ -0,0 +1,354 @@
+# 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.
+
+"""
+Tests for Intel NM vendor interface
+"""
+
+import os
+
+from ironic.common import exception
+from ironic.conductor import task_manager
+from ironic.tests.unit.conductor import mgr_utils
+from ironic.tests.unit.db import base as db_base
+from ironic.tests.unit.objects import utils as obj_utils
+from ironic_lib import utils as ironic_utils
+import mock
+from oslo_config import cfg
+
+from ironic_staging_drivers.intel_nm import ipmi
+from ironic_staging_drivers.intel_nm import nm_commands
+from ironic_staging_drivers.intel_nm import nm_vendor
+
+
+CONF = cfg.CONF
+
+_MAIN_IDS = {'domain_id': 'platform', 'policy_id': 111}
+
+_POLICY = {'domain_id': 'platform', 'enable': True, 'policy_id': 111,
+           'policy_trigger': 'none', 'action': 'alert',
+           'power_domain': 'primary', 'target_limit': 100,
+           'correction_time': 200, 'reporting_period': 600}
+
+_SUSPEND = {'domain_id': 'platform', 'policy_id': 121,
+            'periods': [{'start': 10, 'stop': 30, 'days': ['monday']}]}
+
+_GET_CAP = {'domain_id': 'platform', 'policy_trigger': 'none',
+            'power_domain': 'primary'}
+
+_CONTROL = {'scope': 'global', 'enable': True}
+
+_VENDOR_METHODS_DATA = {'get_nm_policy': _MAIN_IDS,
+                        'remove_nm_policy': _MAIN_IDS,
+                        'get_nm_policy_suspend': _MAIN_IDS,
+                        'remove_nm_policy_suspend': _MAIN_IDS,
+                        'set_nm_policy': _POLICY,
+                        'set_nm_policy_suspend': _SUSPEND,
+                        'get_nm_capabilities': _GET_CAP,
+                        'control_nm_policy': _CONTROL}
+
+
+class IntelNMPassthruTestCase(db_base.DbTestCase):
+
+    def setUp(self):
+        super(IntelNMPassthruTestCase, self).setUp()
+        mgr_utils.mock_the_extension_manager(driver='fake_nm')
+        self.node = obj_utils.create_test_node(self.context, driver='fake_nm')
+        self.temp_filename = os.path.join(CONF.tempdir, self.node.uuid +
+                                          '.sdr')
+
+    @mock.patch.object(ironic_utils, 'unlink_without_raise', spec_set=True,
+                       autospec=True)
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(ipmi, 'dump_sdr', spec_set=True, autospec=True)
+    @mock.patch.object(nm_commands, 'parse_slave_and_channel', spec_set=True,
+                       autospec=True)
+    def test__get_nm_address_detected(self, parse_mock, dump_mock, raw_mock,
+                                      unlink_mock):
+        parse_mock.return_value = ('0x0A', '0x0B')
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            ret = nm_vendor._get_nm_address(task)
+            self.assertEqual(('0x0B', '0x0A'), ret)
+            self.node.refresh()
+            internal_info = self.node.driver_internal_info
+            self.assertEqual('0x0A', internal_info['intel_nm_address'])
+            self.assertEqual('0x0B', internal_info['intel_nm_channel'])
+            parse_mock.assert_called_once_with(self.temp_filename)
+            dump_mock.assert_called_once_with(task, self.temp_filename)
+            unlink_mock.assert_called_once_with(self.temp_filename)
+            raw_mock.assert_called_once_with(task, mock.ANY)
+
+    @mock.patch.object(ironic_utils, 'unlink_without_raise', spec_set=True,
+                       autospec=True)
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(ipmi, 'dump_sdr', spec_set=True, autospec=True)
+    @mock.patch.object(nm_commands, 'parse_slave_and_channel', spec_set=True,
+                       autospec=True)
+    def test__get_nm_address_already_detected(self, parse_mock, dump_mock,
+                                              raw_mock, unlink_mock):
+        internal_info = self.node.driver_internal_info
+        internal_info['intel_nm_channel'] = '0x0B'
+        internal_info['intel_nm_address'] = '0x0A'
+        self.node.driver_internal_info = internal_info
+        self.node.save()
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            ret = nm_vendor._get_nm_address(task)
+            self.assertEqual(('0x0B', '0x0A'), ret)
+        self.assertFalse(parse_mock.called)
+        self.assertFalse(dump_mock.called)
+        self.assertFalse(raw_mock.called)
+        self.assertFalse(unlink_mock.called)
+
+    @mock.patch.object(ironic_utils, 'unlink_without_raise', spec_set=True,
+                       autospec=True)
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(ipmi, 'dump_sdr', spec_set=True, autospec=True)
+    @mock.patch.object(nm_commands, 'parse_slave_and_channel', spec_set=True,
+                       autospec=True)
+    def test__get_nm_address_not_detected(self, parse_mock, dump_mock,
+                                          raw_mock, unlink_mock):
+        parse_mock.return_value = None
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            self.assertRaises(exception.IPMIFailure, nm_vendor._get_nm_address,
+                              task)
+            self.node.refresh()
+            internal_info = self.node.driver_internal_info
+            self.assertEqual(False, internal_info['intel_nm_address'])
+            self.assertEqual(False, internal_info['intel_nm_channel'])
+            parse_mock.assert_called_once_with(self.temp_filename)
+            dump_mock.assert_called_once_with(task, self.temp_filename)
+            unlink_mock.assert_called_once_with(self.temp_filename)
+            self.assertFalse(raw_mock.called)
+
+    @mock.patch.object(ironic_utils, 'unlink_without_raise', spec_set=True,
+                       autospec=True)
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(ipmi, 'dump_sdr', spec_set=True, autospec=True)
+    @mock.patch.object(nm_commands, 'parse_slave_and_channel', spec_set=True,
+                       autospec=True)
+    def test__get_nm_address_raw_fail(self, parse_mock, dump_mock, raw_mock,
+                                      unlink_mock):
+        parse_mock.return_value = ('0x0A', '0x0B')
+        raw_mock.side_effect = exception.IPMIFailure('raw error')
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            self.assertRaises(exception.IPMIFailure, nm_vendor._get_nm_address,
+                              task)
+            self.node.refresh()
+            internal_info = self.node.driver_internal_info
+            self.assertEqual(False, internal_info['intel_nm_address'])
+            self.assertEqual(False, internal_info['intel_nm_channel'])
+            parse_mock.assert_called_once_with(self.temp_filename)
+            dump_mock.assert_called_once_with(task, self.temp_filename)
+            unlink_mock.assert_called_once_with(self.temp_filename)
+            raw_mock.assert_called_once_with(task, mock.ANY)
+
+    @mock.patch.object(ironic_utils, 'unlink_without_raise', spec_set=True,
+                       autospec=True)
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(ipmi, 'dump_sdr', spec_set=True, autospec=True)
+    @mock.patch.object(nm_commands, 'parse_slave_and_channel', spec_set=True,
+                       autospec=True)
+    def test__get_nm_address_already_not_detected(self, parse_mock, dump_mock,
+                                                  raw_mock, unlink_mock):
+        internal_info = self.node.driver_internal_info
+        internal_info['intel_nm_channel'] = False
+        internal_info['intel_nm_address'] = False
+        self.node.driver_internal_info = internal_info
+        self.node.save()
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            self.assertRaises(exception.IPMIFailure, nm_vendor._get_nm_address,
+                              task)
+        self.assertFalse(parse_mock.called)
+        self.assertFalse(dump_mock.called)
+        self.assertFalse(raw_mock.called)
+        self.assertFalse(unlink_mock.called)
+
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(nm_vendor, '_get_nm_address', spec_set=True,
+                       autospec=True)
+    def test__execute_nm_command(self, addr_mock, raw_mock):
+        addr_mock.return_value = ('0x0A', '0x0B')
+        raw_mock.return_value = ('0x03 0x04', '')
+        fake_data = {'foo': 'bar'}
+        fake_command = mock.MagicMock()
+        fake_parse = mock.MagicMock()
+        fake_command.return_value = ('0x01', '0x02')
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            nm_vendor._execute_nm_command(task, fake_data, fake_command,
+                                          fake_parse)
+            self.assertEqual('single', task.node.driver_info['ipmi_bridging'])
+            self.assertEqual('0x0A',
+                             task.node.driver_info['ipmi_target_channel'])
+            self.assertEqual('0x0B',
+                             task.node.driver_info['ipmi_target_address'])
+            fake_command.assert_called_once_with(fake_data)
+            raw_mock.assert_called_once_with(task, '0x01 0x02')
+            fake_parse.assert_called_once_with(['0x03', '0x04'])
+
+    @mock.patch.object(ipmi, 'send_raw', spec_set=True, autospec=True)
+    @mock.patch.object(nm_vendor, '_get_nm_address', spec_set=True,
+                       autospec=True)
+    def test__execute_nm_command_no_parse(self, addr_mock, raw_mock):
+        addr_mock.return_value = ('0x0A', '0x0B')
+        fake_data = {'foo': 'bar'}
+        fake_command = mock.MagicMock()
+        fake_command.return_value = ('0x01', '0x02')
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            nm_vendor._execute_nm_command(task, fake_data, fake_command)
+            self.assertEqual('single', task.node.driver_info['ipmi_bridging'])
+            self.assertEqual('0x0A',
+                             task.node.driver_info['ipmi_target_channel'])
+            self.assertEqual('0x0B',
+                             task.node.driver_info['ipmi_target_address'])
+            fake_command.assert_called_once_with(fake_data)
+            raw_mock.assert_called_once_with(task, '0x01 0x02')
+
+    def test_validate_json(self):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            for method, data in _VENDOR_METHODS_DATA.items():
+                task.driver.vendor.validate(task, method, 'fake', **data)
+
+    def test_validate_json_error(self):
+        fake_data = {'foo': 'bar'}
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            for method in _VENDOR_METHODS_DATA:
+                self.assertRaises(exception.InvalidParameterValue,
+                                  task.driver.vendor.validate, task, method,
+                                  'fake', **fake_data)
+
+    def test_validate_control_no_domain(self):
+        data = {'scope': 'domain', 'enable': True}
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            self.assertRaises(exception.MissingParameterValue,
+                              task.driver.vendor.validate, task,
+                              'control_nm_policy', 'fake', **data)
+
+    def test_validate_control_no_policy(self):
+        data = {'scope': 'policy', 'enable': True, 'domain_id': 'platform'}
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            self.assertRaises(exception.MissingParameterValue,
+                              task.driver.vendor.validate, task,
+                              'control_nm_policy', 'fake', **data)
+
+    def test_validate_policy_boot(self):
+        data = _POLICY.copy()
+        data['policy_trigger'] = 'boot'
+        data['target_limit'] = {'boot_mode': 'power', 'cores_disabled': 2}
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.validate(task, 'set_nm_policy', 'fake', **data)
+
+    def test_validate_policy_boot_error(self):
+        data = _POLICY.copy()
+        data['policy_trigger'] = 'boot'
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            self.assertRaises(exception.InvalidParameterValue,
+                              task.driver.vendor.validate, task,
+                              'set_nm_policy', 'fake', **data)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_control_nm_policy(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.control_nm_policy(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.control_policies)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_set_nm_policy(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.set_nm_policy(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.set_policy)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_get_nm_policy(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.get_nm_policy(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.get_policy,
+                                              nm_commands.parse_policy)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_remove_nm_policy(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.remove_nm_policy(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.remove_policy)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_set_nm_policy_suspend(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.set_nm_policy_suspend(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.set_policy_suspend)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_get_nm_policy_suspend(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.get_nm_policy_suspend(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.get_policy_suspend,
+                                              nm_commands.parse_policy_suspend)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_remove_nm_policy_suspend(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.remove_nm_policy_suspend(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.remove_policy_suspend
+                                              )
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_get_nm_capabilities(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.get_nm_capabilities(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.get_capabilities,
+                                              nm_commands.parse_capabilities)
+
+    @mock.patch.object(nm_vendor, '_execute_nm_command', spec_set=True,
+                       autospec=True)
+    def test_get_nm_version(self, mock_exec):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=False) as task:
+            task.driver.vendor.get_nm_version(task)
+            mock_exec.assert_called_once_with(task, {},
+                                              nm_commands.get_version,
+                                              nm_commands.parse_version)
diff --git a/releasenotes/notes/add-intel-nm-driver-3baf3fbc2aa14688.yaml b/releasenotes/notes/add-intel-nm-driver-3baf3fbc2aa14688.yaml
new file mode 100644
index 0000000..52ebe61
--- /dev/null
+++ b/releasenotes/notes/add-intel-nm-driver-3baf3fbc2aa14688.yaml
@@ -0,0 +1,3 @@
+---
+features:
+  - Add Intel Node Manager driver
diff --git a/requirements.txt b/requirements.txt
index 0cd7961..93398a8 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,6 +2,12 @@
 # of appearance. Changing the order has an impact on the overall integration
 # process, which may cause wedges in the gate later.
 
+ironic-lib>=1.1.0 # Apache-2.0
 pbr>=1.6 # Apache-2.0
+oslo.concurrency>=3.5.0 # Apache-2.0
+oslo.config>=3.7.0 # Apache-2.0
 oslo.i18n>=2.1.0 # Apache-2.0
+oslo.log>=1.14.0 # Apache-2.0
 oslo.utils>=3.5.0 # Apache-2.0
+six>=1.9.0 # MIT
+jsonschema!=2.5.0,<3.0.0,>=2.0.0 # MIT
diff --git a/setup.cfg b/setup.cfg
index f718dae..23f8fb1 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -27,6 +27,8 @@ ironic.drivers =
     fake_wol_fake = ironic_staging_drivers.wol:FakeWakeOnLanFakeDriver
     pxe_wol_iscsi = ironic_staging_drivers.wol:PXEWakeOnLanISCSIDriver
     pxe_wol_agent = ironic_staging_drivers.wol:PXEWakeOnLanAgentDriver
+    agent_ipmitool_nm = ironic_staging_drivers.intel_nm:AgentAndIPMIToolIntelNMDriver
+    fake_nm = ironic_staging_drivers.intel_nm:FakeIntelNMDriver
 
 [build_sphinx]
 source-dir = doc/source