diff --git a/openthread/CONTRIBUTING.md b/openthread/CONTRIBUTING.md
new file mode 100644
index 0000000..2a78c3b
--- /dev/null
+++ b/openthread/CONTRIBUTING.md
@@ -0,0 +1,37 @@
+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement]
+(https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use Github pull requests for this purpose.
+
+### Code style
+Before submitting a pull request make sure to run:
+
+	make pretty
+	
+This will format the source code according to the OpenThread code style. This
+command requires the `astyle` tool. Please refer to your operating system 
+documentation to find information on how to install `astyle`.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement]
+(https://cla.developers.google.com/about/google-corporate).
+
diff --git a/openthread/LICENSE b/openthread/LICENSE
new file mode 100644
index 0000000..8417008
--- /dev/null
+++ b/openthread/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2016, The OpenThread Authors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the
+   names of its contributors may be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/openthread/NOTICE b/openthread/NOTICE
new file mode 100644
index 0000000..6c1dad8
--- /dev/null
+++ b/openthread/NOTICE
@@ -0,0 +1,19 @@
+OpenThread is an open source implementation of the Thread 1.0.1 Final Specification.
+The Thread 1.0.1 Final Specification is promulgated by the Thread Group. The Thread
+Group is a non-profit organization formed for the purposes of defining one or
+more specifications, best practices, reference architectures, implementation
+guidelines and certification programs to promote the availability of compliant
+implementations of the Thread protocol. Information on becoming a Member, including
+information about the benefits thereof, can be found at http://threadgroup.org.
+
+OpenThread is not affiliated with or endorsed by the Thread Group. Implementation
+of this OpenThread code does not assure compliance with the Thread 1.0.1 Final
+Specification and does not convey the right to identify any final product as Thread
+certified. Members of the Thread Group may hold patents and other intellectual
+property rights relating to the Thread 1.0.1 Final Specification, ownership and
+licenses of which are subject to the Thread Group’s IP Policies, and not this license.
+
+The included copyright to the OpenThread code is subject to the license in the
+LICENSE file, and all other rights and licenses are expressly reserved.
+No warranty or assurance is made with respect to additional rights that may be
+required to implement this code.
diff --git a/openthread/README.google b/openthread/README.google
new file mode 100644
index 0000000..8be24c8
--- /dev/null
+++ b/openthread/README.google
@@ -0,0 +1,13 @@
+URL: https://github.com/openthread/openthread/tree/5298a515c374ec31518ed176d1a9dd6033370c32
+Version: 5298a515c374ec31518ed176d1a9dd6033370c32
+License: BSD-3
+License File: LICENSE
+
+Description:
+OpenThread is an open-source implementation of the Thread networking
+protocol. With OpenThread, Nest is making the technology used in Nest
+products more broadly available to accelerate the development of
+products for the connected home.
+
+Local Modifications:
+Stripped all unused files.
diff --git a/openthread/README.md b/openthread/README.md
new file mode 100644
index 0000000..9052f86
--- /dev/null
+++ b/openthread/README.md
@@ -0,0 +1,126 @@
+[![OpenThread][ot-logo]][ot-repo]  
+[![Build Status][ot-travis-svg]][ot-travis]
+[![Build Status][ot-appveyor-svg]][ot-appveyor]
+[![Coverage Status][ot-codecov-svg]][ot-codecov]
+
+---
+
+OpenThread is an open-source implementation of the [Thread][thread]
+networking protocol. Nest has released OpenThread to make the technology
+used in Nest products more broadly available to developers to accelerate 
+the development of products for the connected home.
+
+The Thread specification defines an IPv6-based reliable, secure and
+low-power wireless device-to-device communication protocol for home
+applications. More information about Thread can be found on
+[threadgroup.org](http://threadgroup.org/).
+
+[thread]: http://threadgroup.org/technology/ourtechnology
+[ot-repo]: https://github.com/openthread/openthread
+[ot-logo]: doc/images/openthread_logo.png
+[ot-travis]: https://travis-ci.org/openthread/openthread
+[ot-travis-svg]: https://travis-ci.org/openthread/openthread.svg?branch=master
+[ot-appveyor]: https://ci.appveyor.com/project/jwhui/openthread
+[ot-appveyor-svg]: https://ci.appveyor.com/api/projects/status/r5qwyhn9p26nmfk3?svg=true
+[ot-codecov]: https://codecov.io/gh/openthread/openthread
+[ot-codecov-svg]: https://codecov.io/gh/openthread/openthread/branch/master/graph/badge.svg
+
+## Features ##
+
+ *  Highly portable: OS and platform agnostic with a radio
+    abstraction layer
+ *  Implements the End Device, Router, Leader and Border Router roles
+ *  Small memory footprint
+
+OpenThread implements all Thread networking layers including IPv6,
+6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, and
+Mesh Routing.
+
+
+# Who is supporting OpenThread #
+
+![OpenThread Contributor Logos](doc/images/openthread_contrib.png)
+
+Nest, along with ARM, Atmel, a subsidiary of Microchip Technology,
+Dialog Semiconductor, Microsoft Corporation, Nordic Semiconductor,
+Qualcomm Technologies, Inc. (a subsidiary of Qualcomm Incorporated),
+and Texas Instruments Incorporated are contributing to the ongoing
+development of OpenThread.
+
+
+# Getting started #
+
+The easiest way to get started is to run the CLI example in
+`/examples/apps/cli`. See the
+[CLI example README](examples/apps/cli/README.md)
+for more details.
+
+
+## What's included ##
+
+In the repo you'll find the following directories and files:
+
+File/Folder   | Provides
+--------------|----------------------------------------------------------------
+`doc`         | Doxygen docs
+`examples`    | Sample applications demonstrating OpenThread
+`include`     | Public API header files
+`src`         | Core implementation of the Thread standard and related add-ons
+`tests`       | Unit and Thread conformance tests
+`third_party` | Third-party code used by OpenThread
+`tools`       | Helpful utilities related to the OpenThread project
+
+
+## Documentation ##
+
+The Doxygen reference docs are [hosted online][ot-docs] and generated
+as part of the build.
+
+[ot-docs]: http://openthread.github.io/openthread/
+
+
+# Getting help #
+
+Submit bugs and feature requests to [issue tracker][ot-issues]. Usage
+questions? Post your questions to [Stack Overflow][stackoverflow] using the
+[`openthread` tag][ot-tag]. We also use Google Groups for discussion
+and announcements:
+
+ *  [openthread-announce](https://groups.google.com/forum/#!forum/openthread-announce)
+    \- subscribe for release notes and new updates on OpenThread
+ *  [openthread-users](https://groups.google.com/forum/#!forum/openthread-users)
+    \- the best place for users to discuss OpenThread and interact with
+    the OpenThread team
+ *  [openthread-devel](https://groups.google.com/forum/#!forum/openthread-devel)
+    \- team members discuss the on-going development of OpenThread
+
+[ot-issues]: https://github.com/openthread/openthread/issues
+[stackoverflow]: http://stackoverflow.com/
+[ot-tag]: http://stackoverflow.com/questions/tagged/openthread
+
+
+# Versioning #
+
+OpenThread follows [the Semantic Versioning guidelines][semver] for
+release cycle transparency and to maintain backwards compatibility.
+OpenThread's versioning is independent of the Thread protocol
+specification version but will clearly indicate which version of the
+specification it currently supports.
+
+[semver]: http://semver.org/
+
+
+# Contributing #
+
+See the [`CONTRIBUTING.md`](CONTRIBUTING.md) file for more information.
+
+
+# License #
+
+OpenThread is released under the [BSD 3-Clause license](LICENSE). See
+the [`LICENSE`](LICENSE) file for more information.
+
+Please only use the OpenThread name and marks when accurately
+referencing this software distribution. Do not use the marks in
+a way that suggests you are endorsed by or otherwise affiliated with
+Nest, Google, or The Thread Group.
diff --git a/openthread/src/ncp/PROTOCOL.md b/openthread/src/ncp/PROTOCOL.md
new file mode 100644
index 0000000..f5aff68
--- /dev/null
+++ b/openthread/src/ncp/PROTOCOL.md
@@ -0,0 +1,7 @@
+Spinel NCP Protocol Documentation
+=================================
+
+This document has moved into the top level `doc` folder and renamed
+[`draft-spinel-protocol.txt`](../../doc/draft-spinel-protocol.txt)
+and [`draft-spinel-protocol.html`](../../doc/draft-spinel-protocol.html).
+
diff --git a/openthread/src/ncp/spinel.c b/openthread/src/ncp/spinel.c
new file mode 100644
index 0000000..9449d6d
--- /dev/null
+++ b/openthread/src/ncp/spinel.c
@@ -0,0 +1,1996 @@
+/*
+ *    Copyright (c) 2016, The OpenThread Authors.
+ *    All rights reserved.
+ *
+ *    Redistribution and use in source and binary forms, with or without
+ *    modification, are permitted provided that the following conditions are met:
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *    3. Neither the name of the copyright holder nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ *    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ *    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ *    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  -------------------------------------------------------------------
+ *
+ *  ## Unit Test ##
+ *
+ *  This file includes its own unit test. To compile the unit test,
+ *  simply compile this file with the macro SPINEL_SELF_TEST set to 1.
+ *  For example:
+ *
+ *      cc spinel.c -Wall -DSPINEL_SELF_TEST=1 -o spinel
+ *
+ *  -------------------------------------------------------------------
+ */
+
+// ----------------------------------------------------------------------------
+// MARK: -
+// MARK: Headers
+
+#include "spinel.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdbool.h>
+// ----------------------------------------------------------------------------
+// MARK: -
+
+// IAR's errno.h apparently doesn't define EOVERFLOW.
+#ifndef EOVERFLOW
+// There is no real good choice for what to set
+// errno to in this case, so we just pick the
+// value '1' somewhat arbitrarily.
+#define EOVERFLOW 1
+#endif
+
+// IAR's errno.h apparently doesn't define EINVAL.
+#ifndef EINVAL
+// There is no real good choice for what to set
+// errno to in this case, so we just pick the
+// value '1' somewhat arbitrarily.
+#define EINVAL 1
+#endif
+
+#ifdef _KERNEL_MODE
+#define va_copy(destination, source) ((destination) = (source))
+#undef errno
+#define assert_printf(fmt, ...)
+#endif
+
+#if defined(errno) && SPINEL_PLATFORM_DOESNT_IMPLEMENT_ERRNO_VAR
+#error "SPINEL_PLATFORM_DOESNT_IMPLEMENT_ERRNO_VAR is set but errno is already defined."
+#endif
+
+// Work-around for platforms that don't implement the `errno` variable.
+#if !defined(errno) && SPINEL_PLATFORM_DOESNT_IMPLEMENT_ERRNO_VAR
+static int spinel_errno_workaround_;
+#define errno spinel_errno_workaround_
+#endif // SPINEL_PLATFORM_DOESNT_IMPLEMENT_ERRNO_VAR
+
+#ifndef assert_printf
+#if SPINEL_PLATFORM_DOESNT_IMPLEMENT_FPRINTF
+#define assert_printf(fmt, ...) \
+    printf(__FILE__ ":%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else // if SPINEL_PLATFORM_DOESNT_IMPLEMENT_FPRINTF
+#define assert_printf(fmt, ...) \
+    fprintf(stderr, __FILE__ ":%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#endif // else SPINEL_PLATFORM_DOESNT_IMPLEMENT_FPRINTF
+#endif
+
+#if !HAVE_STRNLEN
+// Provide a working strnlen if the platform doesn't have one.
+static size_t spinel_strnlen_(const char *s, size_t maxlen)
+{
+    size_t ret;
+    for (ret = 0; (ret < maxlen) && (s[ret] != 0); ret++)
+    {
+        // Empty loop.
+    }
+    return ret;
+}
+#define strnlen spinel_strnlen_
+#endif
+
+#ifndef require_action
+#if SPINEL_PLATFORM_SHOULD_LOG_ASSERTS
+#define require_action(c, l, a) \
+    do { if (!(c)) { \
+        assert_printf("Requirement Failed (%s)", # c); \
+        a; \
+        goto l; \
+    } } while (0)
+#else // if DEBUG
+#define require_action(c, l, a) \
+    do { if (!(c)) { \
+        a; \
+        goto l; \
+    } } while (0)
+#endif // else DEBUG
+#endif // ifndef require_action
+
+#ifndef require
+#define require(c, l)   require_action(c, l, {})
+#endif
+
+
+typedef struct {
+    va_list obj;
+} va_list_obj;
+
+// ----------------------------------------------------------------------------
+// MARK: -
+
+spinel_ssize_t
+spinel_packed_uint_decode(const uint8_t *bytes, spinel_size_t len, unsigned int *value_ptr)
+{
+    spinel_ssize_t ret = 0;
+    unsigned int value = 0;
+
+    int i = 0;
+
+    do
+    {
+        if (len < sizeof(uint8_t))
+        {
+            ret = -1;
+            break;
+        }
+
+        value |= (unsigned int)((bytes[0] & 0x7F) << i);
+        i += 7;
+        ret += sizeof(uint8_t);
+        bytes += sizeof(uint8_t);
+        len -= sizeof(uint8_t);
+    }
+    while ((bytes[-1] & 0x80) == 0x80);
+
+    if ((ret > 0) && (value_ptr != NULL))
+    {
+        *value_ptr = value;
+    }
+
+    return ret;
+}
+
+spinel_ssize_t
+spinel_packed_uint_size(unsigned int value)
+{
+    spinel_ssize_t ret;
+
+    if (value < (1 << 7))
+    {
+        ret = 1;
+    }
+    else if (value < (1 << 14))
+    {
+        ret = 2;
+    }
+    else if (value < (1 << 21))
+    {
+        ret = 3;
+    }
+    else if (value < (1 << 28))
+    {
+        ret = 4;
+    }
+    else
+    {
+        ret = 5;
+    }
+
+    return ret;
+}
+
+spinel_ssize_t
+spinel_packed_uint_encode(uint8_t *bytes, spinel_size_t len, unsigned int value)
+{
+    const spinel_ssize_t encoded_size = spinel_packed_uint_size(value);
+
+    if ((spinel_ssize_t)len >= encoded_size)
+    {
+        spinel_ssize_t i;
+
+        for (i = 0; i != encoded_size - 1; ++i)
+        {
+            *bytes++ = (value & 0x7F) | 0x80;
+            value = (value >> 7);
+        }
+
+        *bytes++ = (value & 0x7F);
+    }
+
+    return encoded_size;
+}
+
+const char *
+spinel_next_packed_datatype(const char *pack_format)
+{
+    int depth = 0;
+
+    do
+    {
+        switch (*++pack_format)
+        {
+        case '(':
+            depth++;
+            break;
+
+        case ')':
+            depth--;
+
+            if (depth == 0)
+            {
+                pack_format++;
+            }
+
+            break;
+        }
+    }
+    while ((depth > 0) && *pack_format != 0);
+
+    return pack_format;
+}
+
+static spinel_ssize_t
+spinel_datatype_vunpack_(const uint8_t *data_ptr, spinel_size_t data_len, const char *pack_format, va_list_obj *args)
+{
+    spinel_ssize_t ret = 0;
+
+    for (; *pack_format != 0; pack_format = spinel_next_packed_datatype(pack_format))
+    {
+        if (*pack_format == ')')
+        {
+            // Don't go past the end of a struct.
+            break;
+        }
+
+        switch ((spinel_datatype_t)pack_format[0])
+        {
+        case SPINEL_DATATYPE_BOOL_C:
+        {
+            bool *arg_ptr = va_arg(args->obj, bool *);
+            require_action(data_len >= sizeof(uint8_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = data_ptr[0];
+            }
+
+            ret += sizeof(uint8_t);
+            data_ptr += sizeof(uint8_t);
+            data_len -= sizeof(uint8_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_INT8_C:
+        case SPINEL_DATATYPE_UINT8_C:
+        {
+            uint8_t *arg_ptr = va_arg(args->obj, uint8_t *);
+            require_action(data_len >= sizeof(uint8_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = data_ptr[0];
+            }
+
+            ret += sizeof(uint8_t);
+            data_ptr += sizeof(uint8_t);
+            data_len -= sizeof(uint8_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_INT16_C:
+        case SPINEL_DATATYPE_UINT16_C:
+        {
+            uint16_t *arg_ptr = va_arg(args->obj, uint16_t *);
+            require_action(data_len >= sizeof(uint16_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = (uint16_t)((data_ptr[1] << 8) | data_ptr[0]);
+            }
+
+            ret += sizeof(uint16_t);
+            data_ptr += sizeof(uint16_t);
+            data_len -= sizeof(uint16_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_INT32_C:
+        case SPINEL_DATATYPE_UINT32_C:
+        {
+            uint32_t *arg_ptr = va_arg(args->obj, uint32_t *);
+            require_action(data_len >= sizeof(uint32_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = (uint32_t)((data_ptr[3] << 24) | (data_ptr[2] << 16) | (data_ptr[1] << 8) | data_ptr[0]);
+            }
+
+            ret += sizeof(uint32_t);
+            data_ptr += sizeof(uint32_t);
+            data_len -= sizeof(uint32_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_IPv6ADDR_C:
+        {
+            spinel_ipv6addr_t **arg_ptr = va_arg(args->obj, spinel_ipv6addr_t **);
+            require_action(data_len >= sizeof(spinel_ipv6addr_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = (spinel_ipv6addr_t *)data_ptr;
+            }
+
+            ret += sizeof(spinel_ipv6addr_t);
+            data_ptr += sizeof(spinel_ipv6addr_t);
+            data_len -= sizeof(spinel_ipv6addr_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_EUI64_C:
+        {
+            spinel_eui64_t **arg_ptr = va_arg(args->obj, spinel_eui64_t **);
+            require_action(data_len >= sizeof(spinel_eui64_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = (spinel_eui64_t *)data_ptr;
+            }
+
+            ret += sizeof(spinel_eui64_t);
+            data_ptr += sizeof(spinel_eui64_t);
+            data_len -= sizeof(spinel_eui64_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_EUI48_C:
+        {
+            spinel_eui48_t **arg_ptr = va_arg(args->obj, spinel_eui48_t **);
+            require_action(data_len >= sizeof(spinel_eui48_t), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = (spinel_eui48_t *)data_ptr;
+            }
+
+            ret += sizeof(spinel_eui48_t);
+            data_ptr += sizeof(spinel_eui48_t);
+            data_len -= sizeof(spinel_eui48_t);
+            break;
+        }
+
+        case SPINEL_DATATYPE_UINT_PACKED_C:
+        {
+            unsigned int *arg_ptr = va_arg(args->obj, unsigned int *);
+            spinel_ssize_t pui_len = spinel_packed_uint_decode(data_ptr, data_len, arg_ptr);
+
+            // Range check
+            require_action(NULL == arg_ptr || (*arg_ptr < SPINEL_MAX_UINT_PACKED), bail, {ret = -1; errno = ERANGE;});
+
+            require(pui_len > 0, bail);
+
+            require(pui_len <= (spinel_ssize_t)data_len, bail);
+
+            ret += pui_len;
+            data_ptr += pui_len;
+            data_len -= (spinel_size_t)pui_len;
+            break;
+        }
+
+        case SPINEL_DATATYPE_UTF8_C:
+        {
+            const char **arg_ptr = va_arg(args->obj, const char **);
+            size_t len = strnlen((const char *)data_ptr, data_len) + 1;
+
+            require_action((len <= data_len) || (data_ptr[data_len - 1] != 0), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (arg_ptr)
+            {
+                *arg_ptr = (const char *)data_ptr;
+            }
+
+            ret += (spinel_size_t)len;
+            data_ptr += len;
+            data_len -= (spinel_size_t)len;
+            break;
+        }
+
+        case SPINEL_DATATYPE_DATA_C:
+        case SPINEL_DATATYPE_DATA_WLEN_C:
+        {
+            spinel_ssize_t pui_len = 0;
+            uint16_t block_len = 0;
+            const uint8_t *block_ptr = data_ptr;
+            const uint8_t **block_ptr_ptr =  va_arg(args->obj, const uint8_t **);
+            unsigned int *block_len_ptr = va_arg(args->obj, unsigned int *);
+            char nextformat = *spinel_next_packed_datatype(pack_format);
+
+            if ( (pack_format[0] == SPINEL_DATATYPE_DATA_WLEN_C)
+              || ( (nextformat != 0) && (nextformat != ')') )
+            ) {
+                pui_len = spinel_datatype_unpack(data_ptr, data_len, SPINEL_DATATYPE_UINT16_S, &block_len);
+                block_ptr += pui_len;
+
+                require(pui_len > 0, bail);
+                require(block_len < SPINEL_FRAME_MAX_SIZE, bail);
+            }
+            else
+            {
+                block_len = (uint16_t)data_len;
+                pui_len = 0;
+            }
+
+            require_action((spinel_ssize_t)data_len >= (block_len + pui_len), bail, (ret = -1, errno = EOVERFLOW));
+
+            if (NULL != block_ptr_ptr)
+            {
+                *block_ptr_ptr = block_ptr;
+            }
+
+            if (NULL != block_len_ptr)
+            {
+                *block_len_ptr = block_len;
+            }
+
+            block_len += (uint16_t)pui_len;
+            ret += block_len;
+            data_ptr += block_len;
+            data_len -= block_len;
+            break;
+        }
+
+
+        case 'T':
+        case SPINEL_DATATYPE_STRUCT_C:
+        {
+            spinel_ssize_t pui_len = 0;
+            uint16_t block_len = 0;
+            spinel_ssize_t actual_len = 0;
+            const uint8_t *block_ptr = data_ptr;
+            char nextformat = *spinel_next_packed_datatype(pack_format);
+
+            if ( (pack_format[0] == SPINEL_DATATYPE_STRUCT_C)
+              || ( (nextformat != 0) && (nextformat != ')') )
+            ) {
+                pui_len = spinel_datatype_unpack(data_ptr, data_len, SPINEL_DATATYPE_UINT16_S, &block_len);
+                block_ptr += pui_len;
+
+                require(pui_len > 0, bail);
+                require(block_len < SPINEL_FRAME_MAX_SIZE, bail);
+            }
+            else
+            {
+                block_len = (uint16_t)data_len;
+                pui_len = 0;
+            }
+
+            require_action((spinel_ssize_t)data_len >= (block_len + pui_len), bail, (ret = -1, errno = EOVERFLOW));
+
+            actual_len = spinel_datatype_vunpack_(block_ptr, block_len, pack_format + 2, args);
+
+            require_action(actual_len > -1, bail, (ret = -1, errno = EOVERFLOW));
+
+            if (pui_len)
+            {
+                block_len += (uint16_t)pui_len;
+            }
+            else
+            {
+                block_len = (uint16_t)actual_len;
+            }
+
+            ret += block_len;
+            data_ptr += block_len;
+            data_len -= block_len;
+            break;
+        }
+
+        case '.':
+            // Skip.
+            break;
+
+        case SPINEL_DATATYPE_ARRAY_C:
+        default:
+            // Unsupported Type!
+            ret = -1;
+            errno = EINVAL;
+            goto bail;
+        }
+    }
+
+    return ret;
+
+bail:
+    return ret;
+}
+
+spinel_ssize_t
+spinel_datatype_unpack(const uint8_t *data_ptr, spinel_size_t data_len, const char *pack_format, ...)
+{
+    spinel_ssize_t ret;
+    va_list_obj args;
+    va_start(args.obj, pack_format);
+
+    ret = spinel_datatype_vunpack_(data_ptr, data_len, pack_format, &args);
+
+    va_end(args.obj);
+    return ret;
+}
+
+
+spinel_ssize_t
+spinel_datatype_vunpack(const uint8_t *data_ptr, spinel_size_t data_len, const char *pack_format, va_list args)
+{
+    spinel_ssize_t ret;
+    va_list_obj args_obj;
+    va_copy(args_obj.obj, args);
+
+    ret = spinel_datatype_vunpack_(data_ptr, data_len, pack_format, &args_obj);
+
+    va_end(args_obj.obj);
+    return ret;
+}
+
+static spinel_ssize_t
+spinel_datatype_vpack_(uint8_t *data_ptr, spinel_size_t data_len_max, const char *pack_format, va_list_obj *args)
+{
+    spinel_ssize_t ret = 0;
+
+    for (; *pack_format != 0; pack_format = spinel_next_packed_datatype(pack_format))
+    {
+        if (*pack_format == ')')
+        {
+            // Don't go past the end of a struct.
+            break;
+        }
+
+        switch ((spinel_datatype_t)*pack_format)
+        {
+        case SPINEL_DATATYPE_BOOL_C:
+        {
+            bool arg = (bool)va_arg(args->obj, int);
+            ret += sizeof(uint8_t);
+
+            if (data_len_max >= sizeof(uint8_t))
+            {
+                data_ptr[0] = (arg != false);
+                data_ptr += sizeof(uint8_t);
+                data_len_max -= sizeof(uint8_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_INT8_C:
+        case SPINEL_DATATYPE_UINT8_C:
+        {
+            uint8_t arg = (uint8_t)va_arg(args->obj, int);
+            ret += sizeof(uint8_t);
+
+            if (data_len_max >= sizeof(uint8_t))
+            {
+                data_ptr[0] = arg;
+                data_ptr += sizeof(uint8_t);
+                data_len_max -= sizeof(uint8_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_INT16_C:
+        case SPINEL_DATATYPE_UINT16_C:
+        {
+            uint16_t arg = (uint16_t)va_arg(args->obj, int);
+            ret += sizeof(uint16_t);
+
+            if (data_len_max >= sizeof(uint16_t))
+            {
+                data_ptr[1] = (arg >> 8) & 0xff;
+                data_ptr[0] = (arg >> 0) & 0xff;
+                data_ptr += sizeof(uint16_t);
+                data_len_max -= sizeof(uint16_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_INT32_C:
+        case SPINEL_DATATYPE_UINT32_C:
+        {
+            uint32_t arg = (uint32_t)va_arg(args->obj, int);
+            ret += sizeof(uint32_t);
+
+            if (data_len_max >= sizeof(uint32_t))
+            {
+                data_ptr[3] = (arg >> 24) & 0xff;
+                data_ptr[2] = (arg >> 16) & 0xff;
+                data_ptr[1] = (arg >> 8) & 0xff;
+                data_ptr[0] = (arg >> 0) & 0xff;
+                data_ptr += sizeof(uint32_t);
+                data_len_max -= sizeof(uint32_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_IPv6ADDR_C:
+        {
+            spinel_ipv6addr_t *arg = va_arg(args->obj, spinel_ipv6addr_t *);
+            ret += sizeof(spinel_ipv6addr_t);
+
+            if (data_len_max >= sizeof(spinel_ipv6addr_t))
+            {
+                *(spinel_ipv6addr_t *)data_ptr = *arg;
+                data_ptr += sizeof(spinel_ipv6addr_t);
+                data_len_max -= sizeof(spinel_ipv6addr_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_EUI48_C:
+        {
+            spinel_eui48_t *arg = va_arg(args->obj, spinel_eui48_t *);
+            ret += sizeof(spinel_eui48_t);
+
+            if (data_len_max >= sizeof(spinel_eui48_t))
+            {
+                *(spinel_eui48_t *)data_ptr = *arg;
+                data_ptr += sizeof(spinel_eui48_t);
+                data_len_max -= sizeof(spinel_eui48_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_EUI64_C:
+        {
+            spinel_eui64_t *arg = va_arg(args->obj, spinel_eui64_t *);
+            ret += sizeof(spinel_eui64_t);
+
+            if (data_len_max >= sizeof(spinel_eui64_t))
+            {
+                *(spinel_eui64_t *)data_ptr = *arg;
+                data_ptr += sizeof(spinel_eui64_t);
+                data_len_max -= sizeof(spinel_eui64_t);
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_UINT_PACKED_C:
+        {
+            uint32_t arg = va_arg(args->obj, uint32_t);
+            spinel_ssize_t encoded_size;
+
+            // Range Check
+            require_action(arg < SPINEL_MAX_UINT_PACKED, bail, {ret = -1; errno = EINVAL;});
+
+            encoded_size = spinel_packed_uint_encode(data_ptr, data_len_max, arg);
+            ret += encoded_size;
+
+            if ((spinel_ssize_t)data_len_max >= encoded_size)
+            {
+                data_ptr += encoded_size;
+                data_len_max -= (spinel_size_t)encoded_size;
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_UTF8_C:
+        {
+            const char *string_arg = va_arg(args->obj, const char *);
+            size_t string_arg_len = 0;
+
+            if (string_arg)
+            {
+                string_arg_len = strlen(string_arg) + 1;
+            }
+            else
+            {
+                string_arg = "";
+                string_arg_len = 1;
+            }
+
+            ret += (spinel_size_t)string_arg_len;
+
+            if (data_len_max >= string_arg_len)
+            {
+                memcpy(data_ptr, string_arg, string_arg_len);
+
+                data_ptr += string_arg_len;
+                data_len_max -= (spinel_size_t)string_arg_len;
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case SPINEL_DATATYPE_DATA_WLEN_C:
+        case SPINEL_DATATYPE_DATA_C:
+        {
+            const uint8_t *arg = va_arg(args->obj, const uint8_t *);
+            uint32_t data_size_arg = va_arg(args->obj, uint32_t);
+            spinel_ssize_t size_len = 0;
+            char nextformat = *spinel_next_packed_datatype(pack_format);
+
+            if ( (pack_format[0] == SPINEL_DATATYPE_DATA_WLEN_C)
+              || ( (nextformat != 0) && (nextformat != ')') )
+            ) {
+                size_len = spinel_datatype_pack(data_ptr, data_len_max, SPINEL_DATATYPE_UINT16_S, data_size_arg);
+                require_action(size_len > 0, bail, {ret = -1; errno = EINVAL;});
+            }
+
+            ret += (spinel_size_t)size_len + data_size_arg;
+
+            if (data_len_max >= (spinel_size_t)size_len + data_size_arg)
+            {
+                data_ptr += size_len;
+                data_len_max -= (spinel_size_t)size_len;
+
+                memcpy(data_ptr, arg, data_size_arg);
+
+                data_ptr += data_size_arg;
+                data_len_max -= data_size_arg;
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case 'T':
+        case SPINEL_DATATYPE_STRUCT_C:
+        {
+            spinel_ssize_t struct_len = 0;
+            spinel_ssize_t size_len = 0;
+            char nextformat = *spinel_next_packed_datatype(pack_format);
+
+            require_action(pack_format[1] == '(', bail, {ret = -1; errno = EINVAL;});
+
+            // First we figure out the size of the struct
+            {
+                va_list_obj subargs;
+                va_copy(subargs.obj, args->obj);
+                struct_len = spinel_datatype_vpack_(NULL, 0, pack_format + 2, &subargs);
+                va_end(subargs.obj);
+            }
+
+            if ( (pack_format[0] == SPINEL_DATATYPE_STRUCT_C)
+              || ( (nextformat != 0) && (nextformat != ')') )
+            ) {
+                size_len = spinel_datatype_pack(data_ptr, data_len_max, SPINEL_DATATYPE_UINT16_S, struct_len);
+                require_action(size_len > 0, bail, {ret = -1; errno = EINVAL;});
+            }
+
+            ret += size_len + struct_len;
+
+            if (struct_len + size_len <= (spinel_ssize_t)data_len_max)
+            {
+                data_ptr += size_len;
+                data_len_max -= (spinel_size_t)size_len;
+
+                struct_len = spinel_datatype_vpack_(data_ptr, data_len_max, pack_format + 2, args);
+
+                data_ptr += struct_len;
+                data_len_max -= (spinel_size_t)struct_len;
+            }
+            else
+            {
+                data_len_max = 0;
+            }
+
+            break;
+        }
+
+        case '.':
+            // Skip.
+            break;
+
+        default:
+            // Unsupported Type!
+            ret = -1;
+            errno = EINVAL;
+            goto bail;
+
+        }
+    }
+
+bail:
+    return ret;
+}
+
+spinel_ssize_t
+spinel_datatype_pack(uint8_t *data_ptr, spinel_size_t data_len_max, const char *pack_format, ...)
+{
+    int ret;
+    va_list_obj args;
+    va_start(args.obj, pack_format);
+
+    ret = spinel_datatype_vpack_(data_ptr, data_len_max, pack_format, &args);
+
+    va_end(args.obj);
+    return ret;
+}
+
+
+spinel_ssize_t
+spinel_datatype_vpack(uint8_t *data_ptr, spinel_size_t data_len_max, const char *pack_format, va_list args)
+{
+    int ret;
+    va_list_obj args_obj;
+    va_copy(args_obj.obj, args);
+
+    ret = spinel_datatype_vpack_(data_ptr, data_len_max, pack_format, &args_obj);
+
+    va_end(args_obj.obj);
+    return ret;
+}
+
+
+// ----------------------------------------------------------------------------
+// MARK: -
+
+// **** LCOV_EXCL_START ****
+
+const char *
+spinel_prop_key_to_cstr(spinel_prop_key_t prop_key)
+{
+    const char *ret = "UNKNOWN";
+
+    switch (prop_key)
+    {
+    case SPINEL_PROP_LAST_STATUS:
+        ret = "PROP_LAST_STATUS";
+        break;
+
+    case SPINEL_PROP_PROTOCOL_VERSION:
+        ret = "PROP_PROTOCOL_VERSION";
+        break;
+
+    case SPINEL_PROP_INTERFACE_TYPE:
+        ret = "PROP_INTERFACE_TYPE";
+        break;
+
+    case SPINEL_PROP_VENDOR_ID:
+        ret = "PROP_VENDOR_ID";
+        break;
+
+    case SPINEL_PROP_CAPS:
+        ret = "PROP_CAPS";
+        break;
+
+    case SPINEL_PROP_NCP_VERSION:
+        ret = "PROP_NCP_VERSION";
+        break;
+
+    case SPINEL_PROP_INTERFACE_COUNT:
+        ret = "PROP_INTERFACE_COUNT";
+        break;
+
+    case SPINEL_PROP_POWER_STATE:
+        ret = "PROP_POWER_STATE";
+        break;
+
+    case SPINEL_PROP_HWADDR:
+        ret = "PROP_HWADDR";
+        break;
+
+    case SPINEL_PROP_LOCK:
+        ret = "PROP_LOCK";
+        break;
+
+    case SPINEL_PROP_HBO_MEM_MAX:
+        ret = "PROP_HBO_MEM_MAX";
+        break;
+
+    case SPINEL_PROP_HBO_BLOCK_MAX:
+        ret = "PROP_HBO_BLOCK_MAX";
+        break;
+
+    case SPINEL_PROP_HOST_POWER_STATE:
+        ret = "PROP_HOST_POWER_STATE";
+        break;
+
+    case SPINEL_PROP_STREAM_DEBUG:
+        ret = "PROP_STREAM_DEBUG";
+        break;
+
+    case SPINEL_PROP_STREAM_RAW:
+        ret = "PROP_STREAM_RAW";
+        break;
+
+    case SPINEL_PROP_STREAM_NET:
+        ret = "PROP_STREAM_NET";
+        break;
+
+    case SPINEL_PROP_STREAM_NET_INSECURE:
+        ret = "PROP_STREAM_NET_INSECURE";
+        break;
+
+    case SPINEL_PROP_UART_BITRATE:
+        ret = "PROP_UART_BITRATE";
+        break;
+
+    case SPINEL_PROP_UART_XON_XOFF:
+        ret = "PROP_UART_XON_XOFF";
+        break;
+
+    case SPINEL_PROP_PHY_ENABLED:
+        ret = "PROP_PHY_ENABLED";
+        break;
+
+    case SPINEL_PROP_PHY_CHAN:
+        ret = "PROP_PHY_CHAN";
+        break;
+
+    case SPINEL_PROP_PHY_CHAN_SUPPORTED:
+        ret = "PROP_PHY_CHAN_SUPPORTED";
+        break;
+
+    case SPINEL_PROP_PHY_FREQ:
+        ret = "PROP_PHY_FREQ";
+        break;
+
+    case SPINEL_PROP_PHY_CCA_THRESHOLD:
+        ret = "PROP_PHY_CCA_THRESHOLD";
+        break;
+
+    case SPINEL_PROP_PHY_TX_POWER:
+        ret = "PROP_PHY_TX_POWER";
+        break;
+
+    case SPINEL_PROP_PHY_RSSI:
+        ret = "PROP_PHY_RSSI";
+        break;
+
+    case SPINEL_PROP_MAC_EXTENDED_ADDR:
+        ret = "PROP_MAC_EXTENDED_ADDR";
+        break;
+
+    case SPINEL_PROP_MAC_RAW_STREAM_ENABLED:
+        ret = "PROP_MAC_RAW_STREAM_ENABLED";
+        break;
+
+    case SPINEL_PROP_MAC_PROMISCUOUS_MODE:
+        ret = "PROP_MAC_PROMISCUOUS_MODE";
+        break;
+
+    case SPINEL_PROP_MAC_SCAN_STATE:
+        ret = "PROP_MAC_SCAN_STATE";
+        break;
+
+    case SPINEL_PROP_MAC_SCAN_MASK:
+        ret = "PROP_MAC_SCAN_MASK";
+        break;
+
+    case SPINEL_PROP_MAC_SCAN_BEACON:
+        ret = "PROP_MAC_SCAN_BEACON";
+        break;
+
+    case SPINEL_PROP_MAC_ENERGY_SCAN_RESULT:
+        ret = "PROP_MAC_SCAN_ENERGY_SCAN_RESULT";
+        break;
+
+    case SPINEL_PROP_MAC_SCAN_PERIOD:
+        ret = "PROP_MAC_SCAN_PERIOD";
+        break;
+
+    case SPINEL_PROP_MAC_15_4_LADDR:
+        ret = "PROP_MAC_15_4_LADDR";
+        break;
+
+    case SPINEL_PROP_MAC_15_4_SADDR:
+        ret = "PROP_MAC_15_4_SADDR";
+        break;
+
+    case SPINEL_PROP_MAC_15_4_PANID:
+        ret = "PROP_MAC_15_4_PANID";
+        break;
+
+    case SPINEL_PROP_NET_SAVED:
+        ret = "PROP_NET_SAVED";
+        break;
+
+    case SPINEL_PROP_NET_IF_UP:
+        ret = "PROP_NET_IF_UP";
+        break;
+
+    case SPINEL_PROP_NET_STACK_UP:
+        ret = "PROP_NET_STACK_UP";
+        break;
+
+    case SPINEL_PROP_NET_ROLE:
+        ret = "PROP_NET_ROLE";
+        break;
+
+    case SPINEL_PROP_NET_NETWORK_NAME:
+        ret = "PROP_NET_NETWORK_NAME";
+        break;
+
+    case SPINEL_PROP_NET_XPANID:
+        ret = "PROP_NET_XPANID";
+        break;
+
+    case SPINEL_PROP_NET_MASTER_KEY:
+        ret = "PROP_NET_MASTER_KEY";
+        break;
+
+    case SPINEL_PROP_NET_KEY_SEQUENCE_COUNTER:
+        ret = "PROP_NET_KEY_SEQUENCE_COUNTER";
+        break;
+
+    case SPINEL_PROP_NET_PARTITION_ID:
+        ret = "PROP_NET_PARTITION_ID";
+        break;
+
+    case SPINEL_PROP_NET_KEY_SWITCH_GUARDTIME:
+        ret = "PROP_NET_KEY_SWITCH_GUARDTIME";
+        break;
+
+    case SPINEL_PROP_NET_PSKC:
+        ret = "PROP_NET_PSKC";
+        break;
+
+    case SPINEL_PROP_THREAD_LEADER_ADDR:
+        ret = "PROP_THREAD_LEADER_ADDR";
+        break;
+
+    case SPINEL_PROP_THREAD_LEADER_RID:
+        ret = "PROP_THREAD_LEADER_RID";
+        break;
+
+    case SPINEL_PROP_THREAD_LEADER_WEIGHT:
+        ret = "PROP_THREAD_LEADER_WEIGHT";
+        break;
+
+    case SPINEL_PROP_THREAD_LOCAL_LEADER_WEIGHT:
+        ret = "PROP_THREAD_LOCAL_LEADER_WEIGHT";
+        break;
+
+    case SPINEL_PROP_THREAD_NETWORK_DATA_VERSION:
+        ret = "PROP_THREAD_NETWORK_DATA_VERSION";
+        break;
+
+    case SPINEL_PROP_THREAD_STABLE_NETWORK_DATA_VERSION:
+        ret = "PROP_THREAD_STABLE_NETWORK_DATA_VERSION";
+        break;
+
+    case SPINEL_PROP_THREAD_NETWORK_DATA:
+        ret = "PROP_THREAD_NETWORK_DATA";
+        break;
+
+    case SPINEL_PROP_THREAD_CHILD_TABLE:
+        ret = "PROP_THREAD_CHILD_TABLE";
+        break;
+
+    case SPINEL_PROP_IPV6_LL_ADDR:
+        ret = "PROP_IPV6_LL_ADDR";
+        break;
+
+    case SPINEL_PROP_IPV6_ML_ADDR:
+        ret = "PROP_IPV6_ML_ADDR";
+        break;
+
+    case SPINEL_PROP_IPV6_ML_PREFIX:
+        ret = "PROP_IPV6_ML_PREFIX";
+        break;
+
+    case SPINEL_PROP_IPV6_ADDRESS_TABLE:
+        ret = "PROP_IPV6_ADDRESS_TABLE";
+        break;
+
+    case SPINEL_PROP_IPV6_ROUTE_TABLE:
+        ret = "PROP_IPV6_ROUTE_TABLE";
+        break;
+
+    case SPINEL_PROP_IPV6_ICMP_PING_OFFLOAD:
+        ret = "PROP_IPV6_ICMP_PING_OFFLOAD";
+        break;
+
+    case SPINEL_PROP_THREAD_PARENT:
+        ret = "PROP_THREAD_PARENT";
+        break;
+
+    case SPINEL_PROP_THREAD_STABLE_NETWORK_DATA:
+        ret = "PROP_THREAD_STABLE_NETWORK_DATA";
+        break;
+
+    case SPINEL_PROP_THREAD_LEADER_NETWORK_DATA:
+        ret = "PROP_THREAD_LEADER_NETWORK_DATA";
+        break;
+
+    case SPINEL_PROP_THREAD_STABLE_LEADER_NETWORK_DATA:
+        ret = "PROP_THREAD_STABLE_LEADER_NETWORK_DATA";
+        break;
+
+    case SPINEL_PROP_THREAD_ON_MESH_NETS:
+        ret = "PROP_THREAD_ON_MESH_NETS";
+        break;
+
+    case SPINEL_PROP_THREAD_OFF_MESH_ROUTES:
+        ret = "PROP_THREAD_OFF_MESH_ROUTES";
+        break;
+
+    case SPINEL_PROP_THREAD_ASSISTING_PORTS:
+        ret = "PROP_THREAD_ASSISTING_PORTS";
+        break;
+
+    case SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE:
+        ret = "PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE";
+        break;
+
+    case SPINEL_PROP_THREAD_JOINERS:
+        ret = "PROP_THREAD_JOINERS";
+        break;
+
+    case SPINEL_PROP_THREAD_COMMISSIONER_ENABLED:
+        ret = "PROP_THREAD_COMMISSIONER_ENABLED";
+        break;
+
+    case SPINEL_PROP_THREAD_BA_PROXY_ENABLED:
+        ret = "PROP_THREAD_BA_PROXY_ENABLED";
+        break;
+
+    case SPINEL_PROP_THREAD_BA_PROXY_STREAM:
+        ret = "PROP_THREAD_BA_PROXY_STREAM";
+        break;
+
+    case SPINEL_PROP_THREAD_RLOC16_DEBUG_PASSTHRU:
+        ret = "PROP_THREAD_RLOC16_DEBUG_PASSTHRU";
+        break;
+
+    case SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED:
+        ret = "PROP_THREAD_ROUTER_ROLE_ENABLED";
+        break;
+
+    case SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD:
+        ret = "PROP_THREAD_ROUTER_UPGRADE_THRESHOLD";
+        break;
+
+    case SPINEL_PROP_THREAD_CONTEXT_REUSE_DELAY:
+        ret = "PROP_THREAD_CONTEXT_REUSE_DELAY";
+        break;
+
+    case SPINEL_PROP_THREAD_DISCOVERY_SCAN_JOINER_FLAG:
+        ret = "PROP_THREAD_DISCOVERY_SCAN_JOINER_FLAG";
+        break;
+
+    case SPINEL_PROP_THREAD_DISCOVERY_SCAN_ENABLE_FILTERING:
+        ret = "PROP_THREAD_DISCOVERY_SCAN_ENABLE_FILTERING";
+        break;
+
+    case SPINEL_PROP_THREAD_DISCOVERY_SCAN_PANID:
+        ret = "PROP_THREAD_DISCOVERY_SCAN_PANID";
+        break;
+
+    case SPINEL_PROP_THREAD_STEERING_DATA:
+        ret = "PROP_THREAD_STEERING_DATA";
+        break;
+
+    case SPINEL_PROP_MAC_WHITELIST:
+        ret = "PROP_MAC_WHITELIST";
+        break;
+
+    case SPINEL_PROP_MAC_WHITELIST_ENABLED:
+        ret = "PROP_MAC_WHITELIST_ENABLED";
+        break;
+
+    case SPINEL_PROP_THREAD_MODE:
+        ret = "PROP_THREAD_MODE";
+        break;
+
+    case SPINEL_PROP_THREAD_CHILD_TIMEOUT:
+        ret = "PROP_THREAD_CHILD_TIMEOUT";
+        break;
+
+    case SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING:
+        ret = "PROP_NET_REQUIRE_JOIN_EXISTING";
+        break;
+
+    case SPINEL_PROP_NEST_STREAM_MFG:
+        ret = "PROP_NEST_STREAM_MFG";
+        break;
+
+    case SPINEL_PROP_THREAD_NETWORK_ID_TIMEOUT:
+        ret = "PROP_THREAD_NETWORK_ID_TIMEOUT";
+        break;
+
+    case SPINEL_PROP_THREAD_ACTIVE_ROUTER_IDS:
+        ret = "PROP_THREAD_ACTIVE_ROUTER_IDS";
+        break;
+
+    case SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD:
+        ret = "PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD";
+        break;
+
+    case SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER:
+        ret = "PROP_THREAD_ROUTER_SELECTION_JITTER";
+        break;
+
+    case SPINEL_PROP_THREAD_PREFERRED_ROUTER_ID:
+        ret = "PROP_THREAD_PREFERRED_ROUTER_ID";
+        break;
+
+    case SPINEL_PROP_THREAD_NEIGHBOR_TABLE:
+        ret = "PROP_THREAD_NEIGHBOR_TABLE";
+        break;
+
+    case SPINEL_PROP_JAM_DETECT_ENABLE:
+        ret = "PROP_JAM_DETECT_ENABLE";
+        break;
+
+    case SPINEL_PROP_JAM_DETECTED:
+        ret = "PROP_JAM_DETECTED";
+        break;
+
+    case SPINEL_PROP_JAM_DETECT_RSSI_THRESHOLD:
+        ret = "PROP_JAM_DETECT_RSSI_THRESHOLD";
+        break;
+
+    case SPINEL_PROP_JAM_DETECT_WINDOW:
+        ret = "PROP_JAM_DETECT_WINDOW";
+        break;
+
+    case SPINEL_PROP_JAM_DETECT_HISTORY_BITMAP:
+        ret = "PROP_JAM_DETECT_HISTORY_BITMAP";
+        break;
+
+    case SPINEL_PROP_GPIO_CONFIG:
+        ret = "PROP_GPIO_CONFIG";
+        break;
+
+    case SPINEL_PROP_GPIO_STATE:
+        ret = "PROP_GPIO_STATE";
+        break;
+
+    case SPINEL_PROP_GPIO_STATE_SET:
+        ret = "PROP_GPIO_STATE_SET";
+        break;
+
+    case SPINEL_PROP_GPIO_STATE_CLEAR:
+        ret = "PROP_GPIO_STATE_CLEAR";
+        break;
+
+    case SPINEL_PROP_CNTR_RESET:
+        ret = "PROP_CNTR_RESET";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_TOTAL:
+        ret = "PROP_CNTR_TX_PKT_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_ACK_REQ:
+        ret = "PROP_CNTR_TX_PKT_ACK_REQ";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_ACKED:
+        ret = "PROP_CNTR_TX_PKT_ACKED";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_NO_ACK_REQ:
+        ret = "PROP_CNTR_TX_PKT_NO_ACK_REQ";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_DATA:
+        ret = "PROP_CNTR_TX_PKT_DATA";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_DATA_POLL:
+        ret = "PROP_CNTR_TX_PKT_DATA_POLL";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_BEACON:
+        ret = "PROP_CNTR_TX_PKT_BEACON";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_BEACON_REQ:
+        ret = "PROP_CNTR_TX_PKT_BEACON_REQ";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_OTHER:
+        ret = "PROP_CNTR_TX_PKT_OTHER";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_RETRY:
+        ret = "PROP_CNTR_TX_PKT_RETRY";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_ERR_CCA:
+        ret = "PROP_CNTR_TX_ERR_CCA";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_UNICAST:
+        ret = "PROP_CNTR_TX_PKT_UNICAST";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_PKT_BROADCAST:
+        ret = "PROP_CNTR_TX_PKT_BROADCAST";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_ERR_ABORT:
+        ret = "PROP_CNTR_TX_ERR_ABORT";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_TOTAL:
+        ret = "PROP_CNTR_RX_PKT_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_DATA:
+        ret = "PROP_CNTR_RX_PKT_DATA";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_DATA_POLL:
+        ret = "PROP_CNTR_RX_PKT_DATA_POLL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_BEACON:
+        ret = "PROP_CNTR_RX_PKT_BEACON";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_BEACON_REQ:
+        ret = "PROP_CNTR_RX_PKT_BEACON_REQ";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_OTHER:
+        ret = "PROP_CNTR_RX_PKT_OTHER";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_FILT_WL:
+        ret = "PROP_CNTR_RX_PKT_FILT_WL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_FILT_DA:
+        ret = "PROP_CNTR_RX_PKT_FILT_DA";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_ERR_EMPTY:
+        ret = "PROP_CNTR_RX_ERR_EMPTY";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_ERR_UKWN_NBR:
+        ret = "PROP_CNTR_RX_ERR_UKWN_NBR";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_ERR_NVLD_SADDR:
+        ret = "PROP_CNTR_RX_ERR_NVLD_SADDR";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_ERR_SECURITY:
+        ret = "PROP_CNTR_RX_ERR_SECURITY";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_ERR_BAD_FCS:
+        ret = "PROP_CNTR_RX_ERR_BAD_FCS";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_ERR_OTHER:
+        ret = "PROP_CNTR_RX_ERR_OTHER";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_DUP:
+        ret = "PROP_CNTR_RX_PKT_DUP";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_UNICAST:
+        ret = "PROP_CNTR_RX_PKT_UNICAST";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_PKT_BROADCAST:
+        ret = "PROP_CNTR_RX_PKT_BROADCAST";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_IP_SEC_TOTAL:
+        ret = "PROP_CNTR_TX_IP_SEC_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_IP_INSEC_TOTAL:
+        ret = "PROP_CNTR_TX_IP_INSEC_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_IP_DROPPED:
+        ret = "PROP_CNTR_TX_IP_DROPPED";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_IP_SEC_TOTAL:
+        ret = "PROP_CNTR_RX_IP_SEC_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_IP_INSEC_TOTAL:
+        ret = "PROP_CNTR_RX_IP_INSEC_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_IP_DROPPED:
+        ret = "PROP_CNTR_RX_IP_DROPPED";
+        break;
+
+    case SPINEL_PROP_CNTR_TX_SPINEL_TOTAL:
+        ret = "PROP_CNTR_TX_SPINEL_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_SPINEL_TOTAL:
+        ret = "PROP_CNTR_RX_SPINEL_TOTAL";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_SPINEL_ERR:
+        ret = "PROP_CNTR_RX_SPINEL_ERR";
+        break;
+
+    case SPINEL_PROP_CNTR_RX_SPINEL_OUT_OF_ORDER_TID:
+        ret = "PROP_CNTR_RX_SPINEL_OUT_OF_ORDER_TID";
+        break;
+
+    case SPINEL_PROP_CNTR_IP_TX_SUCCESS:
+        ret = "PROP_CNTR_IP_TX_SUCCESS";
+        break;
+
+    case SPINEL_PROP_CNTR_IP_RX_SUCCESS:
+        ret = "PROP_CNTR_IP_RX_SUCCESS";
+        break;
+
+    case SPINEL_PROP_CNTR_IP_TX_FAILURE:
+        ret = "PROP_CNTR_IP_TX_FAILURE";
+        break;
+
+    case SPINEL_PROP_CNTR_IP_RX_FAILURE:
+        ret = "PROP_CNTR_IP_RX_FAILURE";
+        break;
+
+    case SPINEL_PROP_MSG_BUFFER_COUNTERS:
+        ret = "PROP_MSG_BUFFER_COUNTERS";
+        break;
+
+    case SPINEL_PROP_NEST_LEGACY_ULA_PREFIX:
+        ret = "PROP_NEST_LEGACY_ULA_PREFIX";
+        break;
+
+    case SPINEL_PROP_NEST_LEGACY_JOINED_NODE:
+        ret = "PROP_NEST_LEGACY_JOINED_NODE";
+        break;
+
+    case SPINEL_PROP_DEBUG_TEST_ASSERT:
+        ret = "PROP_DEBUG_TEST_ASSERT";
+        break;
+
+    case SPINEL_PROP_DEBUG_NCP_LOG_LEVEL:
+        ret = "PROP_DEBUG_NCP_LOG_LEVEL";
+        break;
+
+    default:
+        break;
+    }
+
+    return ret;
+}
+
+const char *spinel_net_role_to_cstr(uint8_t net_role)
+{
+    const char *ret = "NET_ROLE_UNKNONW";
+
+    switch (net_role)
+    {
+    case SPINEL_NET_ROLE_DETACHED:
+        ret = "NET_ROLE_DETACHED";
+        break;
+
+    case SPINEL_NET_ROLE_CHILD:
+        ret = "NET_ROLE_CHILD";
+        break;
+
+    case SPINEL_NET_ROLE_ROUTER:
+        ret = "NET_ROLE_ROUTER";
+        break;
+
+    case SPINEL_NET_ROLE_LEADER:
+        ret = "NET_ROLE_LEADER";
+        break;
+
+    default:
+        break;
+    }
+
+    return ret;
+}
+
+const char *spinel_status_to_cstr(spinel_status_t status)
+{
+    const char *ret = "UNKNOWN";
+
+    switch (status)
+    {
+    case SPINEL_STATUS_OK:
+        ret = "STATUS_OK";
+        break;
+
+    case SPINEL_STATUS_FAILURE:
+        ret = "STATUS_FAILURE";
+        break;
+
+    case SPINEL_STATUS_UNIMPLEMENTED:
+        ret = "STATUS_UNIMPLEMENTED";
+        break;
+
+    case SPINEL_STATUS_INVALID_ARGUMENT:
+        ret = "STATUS_INVALID_ARGUMENT";
+        break;
+
+    case SPINEL_STATUS_INVALID_STATE:
+        ret = "STATUS_INVALID_STATE";
+        break;
+
+    case SPINEL_STATUS_INVALID_COMMAND:
+        ret = "STATUS_INVALID_COMMAND";
+        break;
+
+    case SPINEL_STATUS_INVALID_INTERFACE:
+        ret = "STATUS_INVALID_INTERFACE";
+        break;
+
+    case SPINEL_STATUS_INTERNAL_ERROR:
+        ret = "STATUS_INTERNAL_ERROR";
+        break;
+
+    case SPINEL_STATUS_SECURITY_ERROR:
+        ret = "STATUS_SECURITY_ERROR";
+        break;
+
+    case SPINEL_STATUS_PARSE_ERROR:
+        ret = "STATUS_PARSE_ERROR";
+        break;
+
+    case SPINEL_STATUS_IN_PROGRESS:
+        ret = "STATUS_IN_PROGRESS";
+        break;
+
+    case SPINEL_STATUS_NOMEM:
+        ret = "STATUS_NOMEM";
+        break;
+
+    case SPINEL_STATUS_BUSY:
+        ret = "STATUS_BUSY";
+        break;
+
+    case SPINEL_STATUS_PROP_NOT_FOUND:
+        ret = "STATUS_PROP_NOT_FOUND";
+        break;
+
+    case SPINEL_STATUS_DROPPED:
+        ret = "STATUS_DROPPED";
+        break;
+
+    case SPINEL_STATUS_EMPTY:
+        ret = "STATUS_EMPTY";
+        break;
+
+    case SPINEL_STATUS_CMD_TOO_BIG:
+        ret = "STATUS_CMD_TOO_BIG";
+        break;
+
+    case SPINEL_STATUS_NO_ACK:
+        ret = "STATUS_NO_ACK";
+        break;
+
+    case SPINEL_STATUS_CCA_FAILURE:
+        ret = "STATUS_CCA_FAILURE";
+        break;
+
+    case SPINEL_STATUS_ALREADY:
+        ret = "STATUS_ALREADY";
+        break;
+
+    case SPINEL_STATUS_ITEM_NOT_FOUND:
+        ret = "STATUS_ITEM_NOT_FOUND";
+        break;
+
+    case SPINEL_STATUS_INVALID_COMMAND_FOR_PROP:
+        ret = "STATUS_INVALID_COMMAND_FOR_PROP";
+        break;
+
+    case SPINEL_STATUS_JOIN_FAILURE:
+        ret = "STATUS_JOIN_FAILURE";
+        break;
+
+    case SPINEL_STATUS_JOIN_SECURITY:
+        ret = "STATUS_JOIN_SECURITY";
+        break;
+
+    case SPINEL_STATUS_JOIN_NO_PEERS:
+        ret = "STATUS_JOIN_NO_PEERS";
+        break;
+
+    case SPINEL_STATUS_JOIN_INCOMPATIBLE:
+        ret = "STATUS_JOIN_INCOMPATIBLE";
+        break;
+
+    case SPINEL_STATUS_RESET_POWER_ON:
+        ret = "STATUS_RESET_POWER_ON";
+        break;
+
+    case SPINEL_STATUS_RESET_EXTERNAL:
+        ret = "STATUS_RESET_EXTERNAL";
+        break;
+
+    case SPINEL_STATUS_RESET_SOFTWARE:
+        ret = "STATUS_RESET_SOFTWARE";
+        break;
+
+    case SPINEL_STATUS_RESET_FAULT:
+        ret = "STATUS_RESET_FAULT";
+        break;
+
+    case SPINEL_STATUS_RESET_CRASH:
+        ret = "STATUS_RESET_CRASH";
+        break;
+
+    case SPINEL_STATUS_RESET_ASSERT:
+        ret = "STATUS_RESET_ASSERT";
+        break;
+
+    case SPINEL_STATUS_RESET_OTHER:
+        ret = "STATUS_RESET_OTHER";
+        break;
+
+    case SPINEL_STATUS_RESET_UNKNOWN:
+        ret = "STATUS_RESET_UNKNOWN";
+        break;
+
+    case SPINEL_STATUS_RESET_WATCHDOG:
+        ret = "STATUS_RESET_WATCHDOG";
+        break;
+
+    default:
+        break;
+    }
+
+    return ret;
+}
+
+const char *spinel_capability_to_cstr(unsigned int capability)
+{
+    const char *ret = "UNKNOWN";
+
+    switch (capability)
+    {
+    case SPINEL_CAP_LOCK:
+        ret = "CAP_LOCK";
+        break;
+
+    case SPINEL_CAP_NET_SAVE:
+        ret = "CAP_NET_SAVE";
+        break;
+
+    case SPINEL_CAP_HBO:
+        ret = "CAP_HBO";
+        break;
+
+    case SPINEL_CAP_POWER_SAVE:
+        ret = "CAP_POWER_SAVE";
+        break;
+
+    case SPINEL_CAP_COUNTERS:
+        ret = "CAP_COUNTERS";
+        break;
+
+    case SPINEL_CAP_JAM_DETECT:
+        ret = "CAP_JAM_DETECT";
+        break;
+
+    case SPINEL_CAP_PEEK_POKE:
+        ret = "CAP_PEEK_POKE";
+        break;
+
+    case SPINEL_CAP_WRITABLE_RAW_STREAM:
+        ret = "CAP_WRITABLE_RAW_STREAM";
+        break;
+
+    case SPINEL_CAP_GPIO:
+        ret = "CAP_GPIO";
+        break;
+
+    case SPINEL_CAP_TRNG:
+        ret = "CAP_TRNG";
+        break;
+
+    case SPINEL_CAP_CMD_MULTI:
+        ret = "CAP_CMD_MULTI";
+        break;
+
+    case SPINEL_CAP_802_15_4_2003:
+        ret = "CAP_802_15_4_2003";
+        break;
+
+    case SPINEL_CAP_802_15_4_2006:
+        ret = "CAP_802_15_4_2006";
+        break;
+
+    case SPINEL_CAP_802_15_4_2011:
+        ret = "CAP_802_15_4_2011";
+        break;
+
+    case SPINEL_CAP_802_15_4_PIB:
+        ret = "CAP_802_15_4_PIB";
+        break;
+
+    case SPINEL_CAP_802_15_4_2450MHZ_OQPSK:
+        ret = "CAP_802_15_4_2450MHZ_OQPSK";
+        break;
+
+    case SPINEL_CAP_802_15_4_915MHZ_OQPSK:
+        ret = "CAP_802_15_4_915MHZ_OQPSK";
+        break;
+
+    case SPINEL_CAP_802_15_4_868MHZ_OQPSK:
+        ret = "CAP_802_15_4_868MHZ_OQPSK";
+        break;
+
+    case SPINEL_CAP_802_15_4_915MHZ_BPSK:
+        ret = "CAP_802_15_4_915MHZ_BPSK";
+        break;
+
+    case SPINEL_CAP_802_15_4_868MHZ_BPSK:
+        ret = "CAP_802_15_4_868MHZ_BPSK";
+        break;
+
+    case SPINEL_CAP_802_15_4_915MHZ_ASK:
+        ret = "CAP_802_15_4_915MHZ_ASK";
+        break;
+
+    case SPINEL_CAP_802_15_4_868MHZ_ASK:
+        ret = "CAP_802_15_4_868MHZ_ASK";
+        break;
+
+    case SPINEL_CAP_ROLE_ROUTER:
+        ret = "CAP_ROLE_ROUTER";
+        break;
+
+    case SPINEL_CAP_ROLE_SLEEPY:
+        ret = "CAP_ROLE_SLEEPY";
+        break;
+
+    case SPINEL_CAP_NET_THREAD_1_0:
+        ret = "CAP_NET_THREAD_1_0";
+        break;
+
+    case SPINEL_CAP_MAC_WHITELIST:
+        ret = "CAP_MAC_WHITELIST";
+        break;
+
+    case SPINEL_CAP_MAC_RAW:
+        ret = "CAP_MAC_RAW";
+        break;
+
+    case SPINEL_CAP_OOB_STEERING_DATA:
+        ret = "CAP_OOB_STEERING_DATA";
+        break;
+
+    case SPINEL_CAP_THREAD_COMMISSIONER:
+        ret = "CAP_THREAD_COMMISSIONER";
+        break;
+
+    case SPINEL_CAP_THREAD_BA_PROXY:
+        ret = "CAP_THREAD_BA_PROXY";
+        break;
+
+    case SPINEL_CAP_NEST_LEGACY_INTERFACE:
+        ret = "CAP_NEST_LEGACY_INTERFACE";
+        break;
+
+    case SPINEL_CAP_NEST_LEGACY_NET_WAKE:
+        ret = "CAP_NEST_LEGACY_NET_WAKE";
+        break;
+
+    case SPINEL_CAP_NEST_TRANSMIT_HOOK:
+        ret = "CAP_NEST_TRANSMIT_HOOK";
+        break;
+
+    default:
+        break;
+    }
+
+    return ret;
+}
+
+// **** LCOV_EXCL_STOP ****
+
+/* -------------------------------------------------------------------------- */
+
+#if SPINEL_SELF_TEST
+
+#include <stdlib.h>
+#include <string.h>
+
+
+int
+main(void)
+{
+    int ret = -1;
+
+    const char static_string[] = "static_string";
+    uint8_t buffer[1024];
+    ssize_t len;
+
+    len = spinel_datatype_pack(buffer, sizeof(buffer), "CiiLU", 0x88, 9, 0xA3, 0xDEADBEEF, static_string);
+
+    if (len != 22)
+    {
+        printf("error:%d: len != 22; (%d)\n", __LINE__, (int)len);
+        goto bail;
+    }
+
+    {
+        uint8_t c = 0;
+        unsigned int i1 = 0;
+        unsigned int i2 = 0;
+        uint32_t l = 0;
+        const char *str = NULL;
+
+        len = spinel_datatype_unpack(buffer, (spinel_size_t)len, "CiiLU", &c, &i1, &i2, &l, &str);
+
+        if (len != 22)
+        {
+            printf("error:%d: len != 22; (%d)\n", __LINE__, (int)len);
+            goto bail;
+        }
+
+        if (c != 0x88)
+        {
+            printf("error: x != 0x88; (%d)\n", c);
+            goto bail;
+        }
+
+        if (i1 != 9)
+        {
+            printf("error: i1 != 9; (%d)\n", i1);
+            goto bail;
+        }
+
+        if (i2 != 0xA3)
+        {
+            printf("error: i2 != 0xA3; (0x%02X)\n", i2);
+            goto bail;
+        }
+
+        if (l != 0xDEADBEEF)
+        {
+            printf("error: l != 0xDEADBEEF; (0x%08X)\n", (unsigned int)l);
+            goto bail;
+        }
+
+        if (strcmp(str, static_string) != 0)
+        {
+            printf("error:%d: strcmp(str,static_string) != 0\n", __LINE__);
+            goto bail;
+        }
+    }
+
+    // -----------------------------------
+
+    memset(buffer, 0xAA, sizeof(buffer));
+
+    len = spinel_datatype_pack(buffer, sizeof(buffer), "Cit(iL)U", 0x88, 9, 0xA3, 0xDEADBEEF, static_string);
+
+    if (len != 24)
+    {
+        printf("error:%d: len != 24; (%d)\n", __LINE__, (int)len);
+        goto bail;
+    }
+
+
+
+    {
+        uint8_t c = 0;
+        unsigned int i1 = 0;
+        unsigned int i2 = 0;
+        uint32_t l = 0;
+        const char *str = NULL;
+
+        len = spinel_datatype_unpack(buffer, (spinel_size_t)len, "Cit(iL)U", &c, &i1, &i2, &l, &str);
+
+        if (len != 24)
+        {
+            printf("error:%d: len != 24; (%d)\n", __LINE__, (int)len);
+            goto bail;
+        }
+
+        if (c != 0x88)
+        {
+            printf("error: x != 0x88; (%d)\n", c);
+            goto bail;
+        }
+
+        if (i1 != 9)
+        {
+            printf("error: i1 != 9; (%d)\n", i1);
+            goto bail;
+        }
+
+        if (i2 != 0xA3)
+        {
+            printf("error: i2 != 0xA3; (0x%02X)\n", i2);
+            goto bail;
+        }
+
+        if (l != 0xDEADBEEF)
+        {
+            printf("error: l != 0xDEADBEEF; (0x%08X)\n", (unsigned int)l);
+            goto bail;
+        }
+
+        if (strcmp(str, static_string) != 0)
+        {
+            printf("error:%d: strcmp(str,static_string) != 0\n", __LINE__);
+            goto bail;
+        }
+    }
+
+
+
+    printf("OK\n");
+    ret = 0;
+    return ret;
+
+bail:
+    printf("FAILURE\n");
+    return ret;
+}
+
+#endif // #if SPINEL_SELF_TEST
diff --git a/openthread/src/ncp/spinel.h b/openthread/src/ncp/spinel.h
new file mode 100644
index 0000000..05b5577
--- /dev/null
+++ b/openthread/src/ncp/spinel.h
@@ -0,0 +1,1379 @@
+/*
+ *    Copyright (c) 2016, The OpenThread Authors.
+ *    All rights reserved.
+ *
+ *    Redistribution and use in source and binary forms, with or without
+ *    modification, are permitted provided that the following conditions are met:
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *    3. Neither the name of the copyright holder nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ *    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ *    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ *    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SPINEL_HEADER_INCLUDED
+#define SPINEL_HEADER_INCLUDED 1
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+// ----------------------------------------------------------------------------
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+# if defined(__GNUC__)
+#  define SPINEL_API_EXTERN             extern __attribute__ ((visibility ("default")))
+#  define SPINEL_API_NONNULL_ALL        __attribute__((nonnull))
+#  define SPINEL_API_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+# endif // ifdef __GNUC__
+
+# if !defined(__BEGIN_DECLS) || !defined(__END_DECLS)
+#  if defined(__cplusplus)
+#   define __BEGIN_DECLS   extern "C" {
+#   define __END_DECLS     }
+#  else // if defined(__cplusplus)
+#   define __BEGIN_DECLS
+#   define __END_DECLS
+#  endif // else defined(__cplusplus)
+# endif // if !defined(__BEGIN_DECLS) || !defined(__END_DECLS)
+
+#endif // ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+#ifndef SPINEL_API_EXTERN
+# define SPINEL_API_EXTERN              extern
+#endif
+
+#ifndef SPINEL_API_NONNULL_ALL
+# define SPINEL_API_NONNULL_ALL
+#endif
+
+#ifndef SPINEL_API_WARN_UNUSED_RESULT
+# define SPINEL_API_WARN_UNUSED_RESULT
+#endif
+
+// ----------------------------------------------------------------------------
+
+#define SPINEL_PROTOCOL_VERSION_THREAD_MAJOR    4
+#define SPINEL_PROTOCOL_VERSION_THREAD_MINOR    3
+
+#define SPINEL_FRAME_MAX_SIZE           1300
+
+/// Macro for generating bit masks using bit index from the spec
+#define SPINEL_BIT_MASK(bit_index,field_bit_count)                                                      \
+                                        ( (1 << ((field_bit_count) - 1)) >> (bit_index) )
+
+// ----------------------------------------------------------------------------
+
+__BEGIN_DECLS
+
+typedef enum
+{
+    SPINEL_STATUS_OK                    = 0, ///< Operation has completed successfully.
+    SPINEL_STATUS_FAILURE               = 1, ///< Operation has failed for some undefined reason.
+
+    SPINEL_STATUS_UNIMPLEMENTED         = 2, ///< Given operation has not been implemented.
+    SPINEL_STATUS_INVALID_ARGUMENT      = 3, ///< An argument to the operation is invalid.
+    SPINEL_STATUS_INVALID_STATE         = 4, ///< This operation is invalid for the current device state.
+    SPINEL_STATUS_INVALID_COMMAND       = 5, ///< This command is not recognized.
+    SPINEL_STATUS_INVALID_INTERFACE     = 6, ///< This interface is not supported.
+    SPINEL_STATUS_INTERNAL_ERROR        = 7, ///< An internal runtime error has occured.
+    SPINEL_STATUS_SECURITY_ERROR        = 8, ///< A security/authentication error has occured.
+    SPINEL_STATUS_PARSE_ERROR           = 9, ///< A error has occured while parsing the command.
+    SPINEL_STATUS_IN_PROGRESS           = 10, ///< This operation is in progress.
+    SPINEL_STATUS_NOMEM                 = 11, ///< Operation prevented due to memory pressure.
+    SPINEL_STATUS_BUSY                  = 12, ///< The device is currently performing a mutually exclusive operation
+    SPINEL_STATUS_PROP_NOT_FOUND        = 13, ///< The given property is not recognized.
+    SPINEL_STATUS_DROPPED               = 14, ///< A/The packet was dropped.
+    SPINEL_STATUS_EMPTY                 = 15, ///< The result of the operation is empty.
+    SPINEL_STATUS_CMD_TOO_BIG           = 16, ///< The command was too large to fit in the internal buffer.
+    SPINEL_STATUS_NO_ACK                = 17, ///< The packet was not acknowledged.
+    SPINEL_STATUS_CCA_FAILURE           = 18, ///< The packet was not sent due to a CCA failure.
+    SPINEL_STATUS_ALREADY               = 19, ///< The operation is already in progress.
+    SPINEL_STATUS_ITEM_NOT_FOUND        = 20, ///< The given item could not be found.
+    SPINEL_STATUS_INVALID_COMMAND_FOR_PROP
+                                        = 21, ///< The given command cannot be performed on this property.
+
+    SPINEL_STATUS_JOIN__BEGIN           = 104,
+
+    /// Generic failure to associate with other peers.
+    /**
+     *  This status error should not be used by implementors if
+     *  enough information is available to determine that one of the
+     *  later join failure status codes would be more accurate.
+     *
+     *  \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING
+     */
+    SPINEL_STATUS_JOIN_FAILURE          = SPINEL_STATUS_JOIN__BEGIN + 0,
+
+    /// The node found other peers but was unable to decode their packets.
+    /**
+     *  Typically this error code indicates that the network
+     *  key has been set incorrectly.
+     *
+     *  \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING
+     */
+    SPINEL_STATUS_JOIN_SECURITY         = SPINEL_STATUS_JOIN__BEGIN + 1,
+
+    /// The node was unable to find any other peers on the network.
+    /**
+     *  \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING
+     */
+    SPINEL_STATUS_JOIN_NO_PEERS         = SPINEL_STATUS_JOIN__BEGIN + 2,
+
+    /// The only potential peer nodes found are incompatible.
+    /**
+     *  \sa SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING
+     */
+    SPINEL_STATUS_JOIN_INCOMPATIBLE     = SPINEL_STATUS_JOIN__BEGIN + 3,
+
+    SPINEL_STATUS_JOIN__END             = 112,
+
+    SPINEL_STATUS_RESET__BEGIN          = 112,
+    SPINEL_STATUS_RESET_POWER_ON        = SPINEL_STATUS_RESET__BEGIN + 0,
+    SPINEL_STATUS_RESET_EXTERNAL        = SPINEL_STATUS_RESET__BEGIN + 1,
+    SPINEL_STATUS_RESET_SOFTWARE        = SPINEL_STATUS_RESET__BEGIN + 2,
+    SPINEL_STATUS_RESET_FAULT           = SPINEL_STATUS_RESET__BEGIN + 3,
+    SPINEL_STATUS_RESET_CRASH           = SPINEL_STATUS_RESET__BEGIN + 4,
+    SPINEL_STATUS_RESET_ASSERT          = SPINEL_STATUS_RESET__BEGIN + 5,
+    SPINEL_STATUS_RESET_OTHER           = SPINEL_STATUS_RESET__BEGIN + 6,
+    SPINEL_STATUS_RESET_UNKNOWN         = SPINEL_STATUS_RESET__BEGIN + 7,
+    SPINEL_STATUS_RESET_WATCHDOG        = SPINEL_STATUS_RESET__BEGIN + 8,
+    SPINEL_STATUS_RESET__END            = 128,
+
+    SPINEL_STATUS_VENDOR__BEGIN         = 15360,
+    SPINEL_STATUS_VENDOR__END           = 16384,
+
+    SPINEL_STATUS_STACK_NATIVE__BEGIN   = 16384,
+    SPINEL_STATUS_STACK_NATIVE__END     = 81920,
+
+    SPINEL_STATUS_EXPERIMENTAL__BEGIN   = 2000000,
+    SPINEL_STATUS_EXPERIMENTAL__END     = 2097152,
+} spinel_status_t;
+
+typedef enum
+{
+    SPINEL_NET_ROLE_DETACHED            = 0,
+    SPINEL_NET_ROLE_CHILD               = 1,
+    SPINEL_NET_ROLE_ROUTER              = 2,
+    SPINEL_NET_ROLE_LEADER              = 3,
+} spinel_net_role_t;
+
+typedef enum
+{
+    SPINEL_SCAN_STATE_IDLE              = 0,
+    SPINEL_SCAN_STATE_BEACON            = 1,
+    SPINEL_SCAN_STATE_ENERGY            = 2,
+    SPINEL_SCAN_STATE_DISCOVER          = 3,
+} spinel_scan_state_t;
+
+typedef enum
+{
+    SPINEL_POWER_STATE_OFFLINE          = 0,
+    SPINEL_POWER_STATE_DEEP_SLEEP       = 1,
+    SPINEL_POWER_STATE_STANDBY          = 2,
+    SPINEL_POWER_STATE_LOW_POWER        = 3,
+    SPINEL_POWER_STATE_ONLINE           = 4,
+} spinel_power_state_t;
+
+typedef enum
+{
+    SPINEL_HOST_POWER_STATE_OFFLINE     = 0,
+    SPINEL_HOST_POWER_STATE_DEEP_SLEEP  = 1,
+    SPINEL_HOST_POWER_STATE_RESERVED    = 2,
+    SPINEL_HOST_POWER_STATE_LOW_POWER   = 3,
+    SPINEL_HOST_POWER_STATE_ONLINE      = 4,
+} spinel_host_power_state_t;
+
+enum
+{
+    SPINEL_NET_FLAG_ON_MESH             = (1 << 0),
+    SPINEL_NET_FLAG_DEFAULT_ROUTE       = (1 << 1),
+    SPINEL_NET_FLAG_CONFIGURE           = (1 << 2),
+    SPINEL_NET_FLAG_DHCP                = (1 << 3),
+    SPINEL_NET_FLAG_SLAAC               = (1 << 4),
+    SPINEL_NET_FLAG_PREFERRED           = (1 << 5),
+
+    SPINEL_NET_FLAG_PREFERENCE_OFFSET   = 6,
+    SPINEL_NET_FLAG_PREFERENCE_MASK     = (3 << SPINEL_NET_FLAG_PREFERENCE_OFFSET),
+};
+
+enum {
+    SPINEL_GPIO_FLAG_DIR_INPUT          = 0,
+    SPINEL_GPIO_FLAG_DIR_OUTPUT         = SPINEL_BIT_MASK(0, 8),
+    SPINEL_GPIO_FLAG_PULL_UP            = SPINEL_BIT_MASK(1, 8),
+    SPINEL_GPIO_FLAG_PULL_DOWN          = SPINEL_BIT_MASK(2, 8),
+    SPINEL_GPIO_FLAG_OPEN_DRAIN         = SPINEL_BIT_MASK(2, 8),
+    SPINEL_GPIO_FLAG_TRIGGER_NONE       = 0,
+    SPINEL_GPIO_FLAG_TRIGGER_RISING     = SPINEL_BIT_MASK(3, 8),
+    SPINEL_GPIO_FLAG_TRIGGER_FALLING    = SPINEL_BIT_MASK(4, 8),
+    SPINEL_GPIO_FLAG_TRIGGER_ANY        = SPINEL_GPIO_FLAG_TRIGGER_RISING
+                                        | SPINEL_GPIO_FLAG_TRIGGER_FALLING,
+};
+
+enum
+{
+    SPINEL_PROTOCOL_TYPE_BOOTLOADER     = 0,
+    SPINEL_PROTOCOL_TYPE_ZIGBEE_IP      = 2,
+    SPINEL_PROTOCOL_TYPE_THREAD         = 3,
+};
+
+enum
+{
+    SPINEL_MAC_PROMISCUOUS_MODE_OFF     = 0, ///< Normal MAC filtering is in place.
+    SPINEL_MAC_PROMISCUOUS_MODE_NETWORK = 1, ///< All MAC packets matching network are passed up the stack.
+    SPINEL_MAC_PROMISCUOUS_MODE_FULL    = 2, ///< All decoded MAC packets are passed up the stack.
+};
+
+enum
+{
+    SPINEL_NCP_LOG_LEVEL_EMERG          = 0,
+    SPINEL_NCP_LOG_LEVEL_ALERT          = 1,
+    SPINEL_NCP_LOG_LEVEL_CRIT           = 2,
+    SPINEL_NCP_LOG_LEVEL_ERR            = 3,
+    SPINEL_NCP_LOG_LEVEL_WARN           = 4,
+    SPINEL_NCP_LOG_LEVEL_NOTICE         = 5,
+    SPINEL_NCP_LOG_LEVEL_INFO           = 6,
+    SPINEL_NCP_LOG_LEVEL_DEBUG          = 7,
+};
+
+typedef struct
+{
+    uint8_t bytes[8];
+} spinel_eui64_t;
+
+typedef struct
+{
+    uint8_t bytes[8];
+} spinel_net_xpanid_t;
+
+typedef struct
+{
+    uint8_t bytes[16];
+} spinel_net_pskc_t;
+
+typedef struct
+{
+    uint8_t bytes[6];
+} spinel_eui48_t;
+
+typedef struct
+{
+    uint8_t bytes[16];
+} spinel_ipv6addr_t;
+
+typedef int spinel_ssize_t;
+typedef unsigned int spinel_size_t;
+typedef uint8_t spinel_tid_t;
+typedef unsigned int spinel_cid_t;
+
+enum
+{
+    SPINEL_MD_FLAG_TX                   = 0x0001, //!< Packet was transmitted, not received.
+    SPINEL_MD_FLAG_BAD_FCS              = 0x0004, //!< Packet was received with bad FCS
+    SPINEL_MD_FLAG_DUPE                 = 0x0008, //!< Packet seems to be a duplicate
+    SPINEL_MD_FLAG_RESERVED             = 0xFFF2, //!< Flags reserved for future use.
+};
+
+enum
+{
+    SPINEL_CMD_NOOP                     = 0,
+    SPINEL_CMD_RESET                    = 1,
+    SPINEL_CMD_PROP_VALUE_GET           = 2,
+    SPINEL_CMD_PROP_VALUE_SET           = 3,
+    SPINEL_CMD_PROP_VALUE_INSERT        = 4,
+    SPINEL_CMD_PROP_VALUE_REMOVE        = 5,
+    SPINEL_CMD_PROP_VALUE_IS            = 6,
+    SPINEL_CMD_PROP_VALUE_INSERTED      = 7,
+    SPINEL_CMD_PROP_VALUE_REMOVED       = 8,
+
+    SPINEL_CMD_NET_SAVE                 = 9,
+    SPINEL_CMD_NET_CLEAR                = 10,
+    SPINEL_CMD_NET_RECALL               = 11,
+
+    SPINEL_CMD_HBO_OFFLOAD              = 12,
+    SPINEL_CMD_HBO_RECLAIM              = 13,
+    SPINEL_CMD_HBO_DROP                 = 14,
+    SPINEL_CMD_HBO_OFFLOADED            = 15,
+    SPINEL_CMD_HBO_RECLAIMED            = 16,
+    SPINEL_CMD_HBO_DROPED               = 17,
+
+    SPINEL_CMD_PEEK                     = 18,
+    SPINEL_CMD_PEEK_RET                 = 19,
+    SPINEL_CMD_POKE                     = 20,
+
+    SPINEL_CMD_PROP_VALUE_MULTI_GET     = 21,
+    SPINEL_CMD_PROP_VALUE_MULTI_SET     = 22,
+    SPINEL_CMD_PROP_VALUES_ARE          = 23,
+
+    SPINEL_CMD_NEST__BEGIN              = 15296,
+    SPINEL_CMD_NEST__END                = 15360,
+
+    SPINEL_CMD_VENDOR__BEGIN            = 15360,
+    SPINEL_CMD_VENDOR__END              = 16384,
+
+    SPINEL_CMD_EXPERIMENTAL__BEGIN      = 2000000,
+    SPINEL_CMD_EXPERIMENTAL__END        = 2097152,
+};
+
+enum
+{
+    SPINEL_CAP_LOCK                     = 1,
+    SPINEL_CAP_NET_SAVE                 = 2,
+    SPINEL_CAP_HBO                      = 3,
+    SPINEL_CAP_POWER_SAVE               = 4,
+
+    SPINEL_CAP_COUNTERS                 = 5,
+    SPINEL_CAP_JAM_DETECT               = 6,
+
+    SPINEL_CAP_PEEK_POKE                = 7,
+
+    SPINEL_CAP_WRITABLE_RAW_STREAM      = 8,
+    SPINEL_CAP_GPIO                     = 9,
+    SPINEL_CAP_TRNG                     = 10,
+    SPINEL_CAP_CMD_MULTI                = 11,
+
+    SPINEL_CAP_802_15_4__BEGIN          = 16,
+    SPINEL_CAP_802_15_4_2003            = (SPINEL_CAP_802_15_4__BEGIN + 0),
+    SPINEL_CAP_802_15_4_2006            = (SPINEL_CAP_802_15_4__BEGIN + 1),
+    SPINEL_CAP_802_15_4_2011            = (SPINEL_CAP_802_15_4__BEGIN + 2),
+    SPINEL_CAP_802_15_4_PIB             = (SPINEL_CAP_802_15_4__BEGIN + 5),
+    SPINEL_CAP_802_15_4_2450MHZ_OQPSK   = (SPINEL_CAP_802_15_4__BEGIN + 8),
+    SPINEL_CAP_802_15_4_915MHZ_OQPSK    = (SPINEL_CAP_802_15_4__BEGIN + 9),
+    SPINEL_CAP_802_15_4_868MHZ_OQPSK    = (SPINEL_CAP_802_15_4__BEGIN + 10),
+    SPINEL_CAP_802_15_4_915MHZ_BPSK     = (SPINEL_CAP_802_15_4__BEGIN + 11),
+    SPINEL_CAP_802_15_4_868MHZ_BPSK     = (SPINEL_CAP_802_15_4__BEGIN + 12),
+    SPINEL_CAP_802_15_4_915MHZ_ASK      = (SPINEL_CAP_802_15_4__BEGIN + 13),
+    SPINEL_CAP_802_15_4_868MHZ_ASK      = (SPINEL_CAP_802_15_4__BEGIN + 14),
+    SPINEL_CAP_802_15_4__END            = 32,
+
+    SPINEL_CAP_ROLE__BEGIN              = 48,
+    SPINEL_CAP_ROLE_ROUTER              = (SPINEL_CAP_ROLE__BEGIN + 0),
+    SPINEL_CAP_ROLE_SLEEPY              = (SPINEL_CAP_ROLE__BEGIN + 1),
+    SPINEL_CAP_ROLE__END                = 52,
+
+    SPINEL_CAP_NET__BEGIN               = 52,
+    SPINEL_CAP_NET_THREAD_1_0           = (SPINEL_CAP_NET__BEGIN + 0),
+    SPINEL_CAP_NET__END                 = 64,
+
+    SPINEL_CAP_OPENTHREAD__BEGIN        = 512,
+    SPINEL_CAP_MAC_WHITELIST            = (SPINEL_CAP_OPENTHREAD__BEGIN + 0),
+    SPINEL_CAP_MAC_RAW                  = (SPINEL_CAP_OPENTHREAD__BEGIN + 1),
+    SPINEL_CAP_OOB_STEERING_DATA        = (SPINEL_CAP_OPENTHREAD__BEGIN + 2),
+    SPINEL_CAP_OPENTHREAD__END          = 640,
+
+    SPINEL_CAP_THREAD__BEGIN            = 1024,
+    SPINEL_CAP_THREAD_COMMISSIONER      = (SPINEL_CAP_THREAD__BEGIN + 0),
+    SPINEL_CAP_THREAD_BA_PROXY          = (SPINEL_CAP_THREAD__BEGIN + 1),
+    SPINEL_CAP_THREAD__END              = 1152,
+
+    SPINEL_CAP_NEST__BEGIN              = 15296,
+    SPINEL_CAP_NEST_LEGACY_INTERFACE    = (SPINEL_CAP_NEST__BEGIN + 0),
+    SPINEL_CAP_NEST_LEGACY_NET_WAKE     = (SPINEL_CAP_NEST__BEGIN + 1),
+    SPINEL_CAP_NEST_TRANSMIT_HOOK       = (SPINEL_CAP_NEST__BEGIN + 2),
+    SPINEL_CAP_NEST__END                = 15360,
+
+    SPINEL_CAP_VENDOR__BEGIN            = 15360,
+    SPINEL_CAP_VENDOR__END              = 16384,
+
+    SPINEL_CAP_EXPERIMENTAL__BEGIN      = 2000000,
+    SPINEL_CAP_EXPERIMENTAL__END        = 2097152,
+};
+
+typedef enum
+{
+    SPINEL_PROP_LAST_STATUS             = 0,        ///< status [i]
+    SPINEL_PROP_PROTOCOL_VERSION        = 1,        ///< major, minor [i,i]
+    SPINEL_PROP_NCP_VERSION             = 2,        ///< version string [U]
+    SPINEL_PROP_INTERFACE_TYPE          = 3,        ///< [i]
+    SPINEL_PROP_VENDOR_ID               = 4,        ///< [i]
+    SPINEL_PROP_CAPS                    = 5,        ///< capability list [A(i)]
+    SPINEL_PROP_INTERFACE_COUNT         = 6,        ///< Interface count [C]
+    SPINEL_PROP_POWER_STATE             = 7,        ///< PowerState [C]
+    SPINEL_PROP_HWADDR                  = 8,        ///< PermEUI64 [E]
+    SPINEL_PROP_LOCK                    = 9,        ///< PropLock [b]
+    SPINEL_PROP_HBO_MEM_MAX             = 10,       ///< Max offload mem [S]
+    SPINEL_PROP_HBO_BLOCK_MAX           = 11,       ///< Max offload block [S]
+    SPINEL_PROP_HOST_POWER_STATE        = 12,       ///< Host MCU power state [C]
+
+    SPINEL_PROP_BASE_EXT__BEGIN         = 0x1000,
+
+    /// GPIO Configuration
+    /** Format: `A(CCU)`
+     *  Type: Read-Only (Optionally Read-write using `CMD_PROP_VALUE_INSERT`)
+     *
+     * An array of structures which contain the following fields:
+     *
+     * *   `C`: GPIO Number
+     * *   `C`: GPIO Configuration Flags
+     * *   `U`: Human-readable GPIO name
+     *
+     * GPIOs which do not have a corresponding entry are not supported.
+     *
+     * The configuration parameter contains the configuration flags for the
+     * GPIO:
+     *
+     *       0   1   2   3   4   5   6   7
+     *     +---+---+---+---+---+---+---+---+
+     *     |DIR|PUP|PDN|TRIGGER|  RESERVED |
+     *     +---+---+---+---+---+---+---+---+
+     *             |O/D|
+     *             +---+
+     *
+     * *   `DIR`: Pin direction. Clear (0) for input, set (1) for output.
+     * *   `PUP`: Pull-up enabled flag.
+     * *   `PDN`/`O/D`: Flag meaning depends on pin direction:
+     *     *   Input: Pull-down enabled.
+     *     *   Output: Output is an open-drain.
+     * *   `TRIGGER`: Enumeration describing how pin changes generate
+     *     asynchronous notification commands (TBD) from the NCP to the host.
+     *     *   0: Feature disabled for this pin
+     *     *   1: Trigger on falling edge
+     *     *   2: Trigger on rising edge
+     *     *   3: Trigger on level change
+     * *   `RESERVED`: Bits reserved for future use. Always cleared to zero
+     *     and ignored when read.
+     *
+     * As an optional feature, the configuration of individual pins may be
+     * modified using the `CMD_PROP_VALUE_INSERT` command. Only the GPIO
+     * number and flags fields MUST be present, the GPIO name (if present)
+     * would be ignored. This command can only be used to modify the
+     * configuration of GPIOs which are already exposed---it cannot be used
+     * by the host to add additional GPIOs.
+     */
+    SPINEL_PROP_GPIO_CONFIG             = SPINEL_PROP_BASE_EXT__BEGIN + 0,
+
+    /// GPIO State Bitmask
+    /** Format: `D`
+     *  Type: Read-Write
+     *
+     * Contains a bit field identifying the state of the GPIOs. The length of
+     * the data associated with these properties depends on the number of
+     * GPIOs. If you have 10 GPIOs, you'd have two bytes. GPIOs are numbered
+     * from most significant bit to least significant bit, so 0x80 is GPIO 0,
+     * 0x40 is GPIO 1, etc.
+     *
+     * For GPIOs configured as inputs:
+     *
+     * *   `CMD_PROP_VAUE_GET`: The value of the associated bit describes the
+     *     logic level read from the pin.
+     * *   `CMD_PROP_VALUE_SET`: The value of the associated bit is ignored
+     *     for these pins.
+     *
+     * For GPIOs configured as outputs:
+     *
+     * *   `CMD_PROP_VAUE_GET`: The value of the associated bit is
+     *     implementation specific.
+     * *   `CMD_PROP_VALUE_SET`: The value of the associated bit determines
+     *     the new logic level of the output. If this pin is configured as an
+     *     open-drain, setting the associated bit to 1 will cause the pin to
+     *     enter a Hi-Z state.
+     *
+     * For GPIOs which are not specified in `PROP_GPIO_CONFIG`:
+     *
+     * *   `CMD_PROP_VAUE_GET`: The value of the associated bit is
+     *     implementation specific.
+     * *   `CMD_PROP_VALUE_SET`: The value of the associated bit MUST be
+     *     ignored by the NCP.
+     *
+     * When writing, unspecified bits are assumed to be zero.
+     */
+    SPINEL_PROP_GPIO_STATE              = SPINEL_PROP_BASE_EXT__BEGIN + 2,
+
+    /// GPIO State Set-Only Bitmask
+    /** Format: `D`
+     *  Type: Write-Only
+     *
+     * Allows for the state of various output GPIOs to be set without affecting
+     * other GPIO states. Contains a bit field identifying the output GPIOs that
+     * should have their state set to 1.
+     *
+     * When writing, unspecified bits are assumed to be zero. The value of
+     * any bits for GPIOs which are not specified in `PROP_GPIO_CONFIG` MUST
+     * be ignored.
+     */
+    SPINEL_PROP_GPIO_STATE_SET          = SPINEL_PROP_BASE_EXT__BEGIN + 3,
+
+    /// GPIO State Clear-Only Bitmask
+    /** Format: `D`
+     *  Type: Write-Only
+     *
+     * Allows for the state of various output GPIOs to be cleared without affecting
+     * other GPIO states. Contains a bit field identifying the output GPIOs that
+     * should have their state cleared to 0.
+     *
+     * When writing, unspecified bits are assumed to be zero. The value of
+     * any bits for GPIOs which are not specified in `PROP_GPIO_CONFIG` MUST
+     * be ignored.
+     */
+    SPINEL_PROP_GPIO_STATE_CLEAR        = SPINEL_PROP_BASE_EXT__BEGIN + 4,
+
+    /// 32-bit random number from TRNG, ready-to-use.
+    SPINEL_PROP_TRNG_32                 = SPINEL_PROP_BASE_EXT__BEGIN + 5,
+
+    /// 16 random bytes from TRNG, ready-to-use.
+    SPINEL_PROP_TRNG_128                = SPINEL_PROP_BASE_EXT__BEGIN + 6,
+
+    /// Raw samples from TRNG entropy source representing 32 bits of entropy.
+    SPINEL_PROP_TRNG_RAW_32             = SPINEL_PROP_BASE_EXT__BEGIN + 7,
+
+    SPINEL_PROP_BASE_EXT__END           = 0x1100,
+
+    SPINEL_PROP_PHY__BEGIN              = 0x20,
+    SPINEL_PROP_PHY_ENABLED             = SPINEL_PROP_PHY__BEGIN + 0, ///< [b]
+    SPINEL_PROP_PHY_CHAN                = SPINEL_PROP_PHY__BEGIN + 1, ///< [C]
+    SPINEL_PROP_PHY_CHAN_SUPPORTED      = SPINEL_PROP_PHY__BEGIN + 2, ///< [A(C)]
+    SPINEL_PROP_PHY_FREQ                = SPINEL_PROP_PHY__BEGIN + 3, ///< kHz [L]
+    SPINEL_PROP_PHY_CCA_THRESHOLD       = SPINEL_PROP_PHY__BEGIN + 4, ///< dBm [c]
+    SPINEL_PROP_PHY_TX_POWER            = SPINEL_PROP_PHY__BEGIN + 5, ///< [c]
+    SPINEL_PROP_PHY_RSSI                = SPINEL_PROP_PHY__BEGIN + 6, ///< dBm [c]
+    SPINEL_PROP_PHY_RX_SENSITIVITY      = SPINEL_PROP_PHY__BEGIN + 7, ///< dBm [c]
+    SPINEL_PROP_PHY__END                = 0x30,
+
+    SPINEL_PROP_PHY_EXT__BEGIN          = 0x1200,
+
+    /// Signal Jamming Detection Enable
+    /** Format: `b`
+     *
+     * Indicates if jamming detection is enabled or disabled. Set to true
+     * to enable jamming detection.
+     */
+    SPINEL_PROP_JAM_DETECT_ENABLE       = SPINEL_PROP_PHY_EXT__BEGIN + 0,
+
+    /// Signal Jamming Detected Indicator
+    /** Format: `b` (Read-Only)
+     *
+     * Set to true if radio jamming is detected. Set to false otherwise.
+     *
+     * When jamming detection is enabled, changes to the value of this
+     * property are emitted asynchronously via `CMD_PROP_VALUE_IS`.
+     */
+    SPINEL_PROP_JAM_DETECTED            = SPINEL_PROP_PHY_EXT__BEGIN + 1,
+
+    /// Jamming detection RSSI threshold
+    /** Format: `c`
+     *  Units: dBm
+     *
+     * This parameter describes the threshold RSSI level (measured in
+     * dBm) above which the jamming detection will consider the
+     * channel blocked.
+     */
+    SPINEL_PROP_JAM_DETECT_RSSI_THRESHOLD
+                                        = SPINEL_PROP_PHY_EXT__BEGIN + 2,
+
+    /// Jamming detection window size
+    /** Format: `C`
+     *  Units: Seconds (1-63)
+     *
+     * This parameter describes the window period for signal jamming
+     * detection.
+     */
+    SPINEL_PROP_JAM_DETECT_WINDOW       = SPINEL_PROP_PHY_EXT__BEGIN + 3,
+
+    /// Jamming detection busy period
+    /** Format: `C`
+     *  Units: Seconds (1-63)
+     *
+     * This parameter describes the number of aggregate seconds within
+     * the detection window where the RSSI must be above
+     * `PROP_JAM_DETECT_RSSI_THRESHOLD` to trigger detection.
+     *
+     * The behavior of the jamming detection feature when `PROP_JAM_DETECT_BUSY`
+     * is larger than `PROP_JAM_DETECT_WINDOW` is undefined.
+     */
+    SPINEL_PROP_JAM_DETECT_BUSY         = SPINEL_PROP_PHY_EXT__BEGIN + 4,
+
+    /// Jamming detection history bitmap (for debugging)
+    /** Format: `LL` (read-only)
+     *
+     * This value provides information about current state of jamming detection
+     * module for monitoring/debugging purpose. It returns a 64-bit value where
+     * each bit corresponds to one second interval starting with bit 0 for the
+     * most recent interval and bit 63 for the oldest intervals (63 sec earlier).
+     * The bit is set to 1 if the jamming detection module observed/detected
+     * high signal level during the corresponding one second interval.
+     *
+     * The value is read-only and is encoded as two uint32 values in
+     * little-endian format (first uint32 gives the lower bits corresponding to
+     * more recent history).
+     */
+    SPINEL_PROP_JAM_DETECT_HISTORY_BITMAP
+                                        = SPINEL_PROP_PHY_EXT__BEGIN + 5,
+
+    SPINEL_PROP_PHY_EXT__END            = 0x1300,
+
+    SPINEL_PROP_MAC__BEGIN              = 0x30,
+    SPINEL_PROP_MAC_SCAN_STATE          = SPINEL_PROP_MAC__BEGIN + 0, ///< [C]
+    SPINEL_PROP_MAC_SCAN_MASK           = SPINEL_PROP_MAC__BEGIN + 1, ///< [A(C)]
+    SPINEL_PROP_MAC_SCAN_PERIOD         = SPINEL_PROP_MAC__BEGIN + 2, ///< ms-per-channel [S]
+    SPINEL_PROP_MAC_SCAN_BEACON         = SPINEL_PROP_MAC__BEGIN + 3, ///< chan,rssi,mac_data,net_data [CcdD]
+    SPINEL_PROP_MAC_15_4_LADDR          = SPINEL_PROP_MAC__BEGIN + 4, ///< [E]
+    SPINEL_PROP_MAC_15_4_SADDR          = SPINEL_PROP_MAC__BEGIN + 5, ///< [S]
+    SPINEL_PROP_MAC_15_4_PANID          = SPINEL_PROP_MAC__BEGIN + 6, ///< [S]
+    SPINEL_PROP_MAC_RAW_STREAM_ENABLED  = SPINEL_PROP_MAC__BEGIN + 7, ///< [C]
+    SPINEL_PROP_MAC_PROMISCUOUS_MODE    = SPINEL_PROP_MAC__BEGIN + 8, ///< [C]
+    SPINEL_PROP_MAC_ENERGY_SCAN_RESULT  = SPINEL_PROP_MAC__BEGIN + 9, ///< chan,maxRssi [Cc]
+    SPINEL_PROP_MAC__END                = 0x40,
+
+    SPINEL_PROP_MAC_EXT__BEGIN          = 0x1300,
+    /// MAC Whitelist
+    /** Format: `A(t(Ec))`
+     *
+     * Structure Parameters:
+     *
+     * * `E`: EUI64 address of node
+     * * `c`: Optional fixed RSSI. 127 means not set.
+     */
+    SPINEL_PROP_MAC_WHITELIST           = SPINEL_PROP_MAC_EXT__BEGIN + 0,
+
+    /// MAC Whitelist Enabled Flag
+    /** Format: `b`
+     */
+    SPINEL_PROP_MAC_WHITELIST_ENABLED   = SPINEL_PROP_MAC_EXT__BEGIN + 1,
+
+    /// MAC Extended Address
+    /** Format: `E`
+     *
+     *  Specified by Thread. Randomly-chosen, but non-volatile EUI-64.
+     */
+    SPINEL_PROP_MAC_EXTENDED_ADDR       = SPINEL_PROP_MAC_EXT__BEGIN + 2,
+
+    /// MAC Source Match Enabled Flag
+    /** Format: `b`
+     */
+    SPINEL_PROP_MAC_SRC_MATCH_ENABLED   = SPINEL_PROP_MAC_EXT__BEGIN + 3,
+
+    /// MAC Source Match Short Address List
+    /** Format: `A(S)`
+     */
+    SPINEL_PROP_MAC_SRC_MATCH_SHORT_ADDRESSES
+                                        = SPINEL_PROP_MAC_EXT__BEGIN + 4,
+
+    /// MAC Source Match Extended Address List
+    /** Format: `A(E)`
+     */
+    SPINEL_PROP_MAC_SRC_MATCH_EXTENDED_ADDRESSES
+                                        = SPINEL_PROP_MAC_EXT__BEGIN + 5,
+    SPINEL_PROP_MAC_EXT__END            = 0x1400,
+
+    SPINEL_PROP_NET__BEGIN              = 0x40,
+    SPINEL_PROP_NET_SAVED               = SPINEL_PROP_NET__BEGIN + 0, ///< [b]
+    SPINEL_PROP_NET_IF_UP               = SPINEL_PROP_NET__BEGIN + 1, ///< [b]
+    SPINEL_PROP_NET_STACK_UP            = SPINEL_PROP_NET__BEGIN + 2, ///< [b]
+    SPINEL_PROP_NET_ROLE                = SPINEL_PROP_NET__BEGIN + 3, ///< [C]
+    SPINEL_PROP_NET_NETWORK_NAME        = SPINEL_PROP_NET__BEGIN + 4, ///< [U]
+    SPINEL_PROP_NET_XPANID              = SPINEL_PROP_NET__BEGIN + 5, ///< [D]
+    SPINEL_PROP_NET_MASTER_KEY          = SPINEL_PROP_NET__BEGIN + 6, ///< [D]
+    SPINEL_PROP_NET_KEY_SEQUENCE_COUNTER
+                                        = SPINEL_PROP_NET__BEGIN + 7, ///< [L]
+    SPINEL_PROP_NET_PARTITION_ID        = SPINEL_PROP_NET__BEGIN + 8, ///< [L]
+
+    /// Require Join Existing
+    /** Format: `b`
+     *  Default Value: `false`
+     *
+     * This flag is typically used for nodes that are associating with an
+     * existing network for the first time. If this is set to `true` before
+     * `PROP_NET_STACK_UP` is set to `true`, the
+     * creation of a new partition at association is prevented. If the node
+     * cannot associate with an existing partition, `PROP_LAST_STATUS` will
+     * emit a status that indicates why the association failed and
+     * `PROP_NET_STACK_UP` will automatically revert to `false`.
+     *
+     * Once associated with an existing partition, this flag automatically
+     * reverts to `false`.
+     *
+     * The behavior of this property being set to `true` when
+     * `PROP_NET_STACK_UP` is already set to `true` is undefined.
+     */
+    SPINEL_PROP_NET_REQUIRE_JOIN_EXISTING
+                                        = SPINEL_PROP_NET__BEGIN + 9,
+
+    SPINEL_PROP_NET_KEY_SWITCH_GUARDTIME
+                                        = SPINEL_PROP_NET__BEGIN + 10, ///< [L]
+
+    SPINEL_PROP_NET_PSKC                = SPINEL_PROP_NET__BEGIN + 11, ///< [D]
+
+    SPINEL_PROP_NET__END                = 0x50,
+
+    SPINEL_PROP_THREAD__BEGIN           = 0x50,
+    SPINEL_PROP_THREAD_LEADER_ADDR      = SPINEL_PROP_THREAD__BEGIN + 0, ///< [6]
+    SPINEL_PROP_THREAD_PARENT           = SPINEL_PROP_THREAD__BEGIN + 1, ///< LADDR, SADDR [ES]
+    SPINEL_PROP_THREAD_CHILD_TABLE      = SPINEL_PROP_THREAD__BEGIN + 2, ///< array(EUI64,rloc16,timeout,age,netDataVer,inLqi,aveRSS,mode) [A(t(ESLLCCcC))]
+    SPINEL_PROP_THREAD_LEADER_RID       = SPINEL_PROP_THREAD__BEGIN + 3, ///< [C]
+    SPINEL_PROP_THREAD_LEADER_WEIGHT    = SPINEL_PROP_THREAD__BEGIN + 4, ///< [C]
+    SPINEL_PROP_THREAD_LOCAL_LEADER_WEIGHT
+                                        = SPINEL_PROP_THREAD__BEGIN + 5, ///< [C]
+    SPINEL_PROP_THREAD_NETWORK_DATA     = SPINEL_PROP_THREAD__BEGIN + 6, ///< [D]
+    SPINEL_PROP_THREAD_NETWORK_DATA_VERSION
+                                        = SPINEL_PROP_THREAD__BEGIN + 7, ///< [S]
+    SPINEL_PROP_THREAD_STABLE_NETWORK_DATA
+                                        = SPINEL_PROP_THREAD__BEGIN + 8, ///< [D]
+    SPINEL_PROP_THREAD_STABLE_NETWORK_DATA_VERSION
+                                        = SPINEL_PROP_THREAD__BEGIN + 9,  ///< [S]
+    SPINEL_PROP_THREAD_ON_MESH_NETS     = SPINEL_PROP_THREAD__BEGIN + 10, ///< array(ipv6prefix,prefixlen,stable,flags,isLocal) [A(t(6CbCb))]
+    SPINEL_PROP_THREAD_OFF_MESH_ROUTES  = SPINEL_PROP_THREAD__BEGIN + 11, ///< array(ipv6prefix,prefixlen,stable,flags,isLocal) [A(t(6CbCb))]
+    SPINEL_PROP_THREAD_ASSISTING_PORTS  = SPINEL_PROP_THREAD__BEGIN + 12, ///< array(portn) [A(S)]
+    SPINEL_PROP_THREAD_ALLOW_LOCAL_NET_DATA_CHANGE
+                                        = SPINEL_PROP_THREAD__BEGIN + 13, ///< [b]
+
+    /// Thread Mode
+    /** Format: `C`
+     *
+     *  This property contains the value of the mode
+     *  TLV for this node. The meaning of the bits in this
+     *  bitfield are defined by section 4.5.2 of the Thread
+     *  specification.
+     */
+    SPINEL_PROP_THREAD_MODE             = SPINEL_PROP_THREAD__BEGIN + 14,
+    SPINEL_PROP_THREAD__END             = 0x60,
+
+    SPINEL_PROP_THREAD_EXT__BEGIN       = 0x1500,
+
+    /// Thread Child Timeout
+    /** Format: `L`
+     *
+     *  Used when operating in the Child role.
+     */
+    SPINEL_PROP_THREAD_CHILD_TIMEOUT    = SPINEL_PROP_THREAD_EXT__BEGIN + 0,
+
+    /// Thread RLOC16
+    /** Format: `S`
+     */
+    SPINEL_PROP_THREAD_RLOC16           = SPINEL_PROP_THREAD_EXT__BEGIN + 1,
+
+    /// Thread Router Upgrade Threshold
+    /** Format: `C`
+     */
+    SPINEL_PROP_THREAD_ROUTER_UPGRADE_THRESHOLD
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 2,
+
+    /// Thread Context Reuse Delay
+    /** Format: `L`
+     */
+    SPINEL_PROP_THREAD_CONTEXT_REUSE_DELAY
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 3,
+
+    /// Thread Network ID Timeout
+    /** Format: `C`
+     */
+    SPINEL_PROP_THREAD_NETWORK_ID_TIMEOUT
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 4,
+
+    /// List of active thread router ids
+    /** Format: `A(C)`
+     *
+     * Note that some implementations may not support CMD_GET_VALUE
+     * routerids, but may support CMD_REMOVE_VALUE when the node is
+     * a leader.
+     */
+    SPINEL_PROP_THREAD_ACTIVE_ROUTER_IDS
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 5,
+
+    /// Forward IPv6 packets that use RLOC16 addresses to HOST.
+    /** Format: `b`
+     */
+    SPINEL_PROP_THREAD_RLOC16_DEBUG_PASSTHRU
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 6,
+
+    /// This property indicates whether or not the `Router Role` is enabled.
+    /** Format `b`
+     */
+    SPINEL_PROP_THREAD_ROUTER_ROLE_ENABLED
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 7,
+
+    /// Thread Router Downgrade Threshold
+    /** Format: `C`
+     */
+    SPINEL_PROP_THREAD_ROUTER_DOWNGRADE_THRESHOLD
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 8,
+
+    /// Thread Router Selection Jitter
+    /** Format: `C`
+     */
+    SPINEL_PROP_THREAD_ROUTER_SELECTION_JITTER
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 9,
+
+    /// Thread Preferred Router Id
+    /** Format: `C` - Write only
+     */
+    SPINEL_PROP_THREAD_PREFERRED_ROUTER_ID
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 10,
+
+    /// Thread Neighbor Table
+    /** Format: `A(t(ESLCcCbLL))`
+     *  eui64, rloc16, age, inLqi ,aveRSS, mode, isChild. linkFrameCounter, mleCounter
+     */
+    SPINEL_PROP_THREAD_NEIGHBOR_TABLE   = SPINEL_PROP_THREAD_EXT__BEGIN + 11,
+
+    /// Thread Max Child Count
+    /** Format: `C`
+     */
+    SPINEL_PROP_THREAD_CHILD_COUNT_MAX  = SPINEL_PROP_THREAD_EXT__BEGIN + 12,
+
+    /// Leader network data
+    /** Format: `D` - Read only
+     */
+    SPINEL_PROP_THREAD_LEADER_NETWORK_DATA
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 13,
+
+    /// Stable leader network data
+    /** Format: `D` - Read only
+     */
+    SPINEL_PROP_THREAD_STABLE_LEADER_NETWORK_DATA
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 14,
+
+    /// Thread joiner data
+    /** Format `A(T(ULE))`
+    *  PSKd, joiner timeout, eui64 (optional)
+    */
+    SPINEL_PROP_THREAD_JOINERS          = SPINEL_PROP_THREAD_EXT__BEGIN + 15,
+
+    /// Thread commissioner enable
+    /** Format `b`
+     *
+     * Default value is `false`.
+     */
+    SPINEL_PROP_THREAD_COMMISSIONER_ENABLED
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 16,
+
+    /// Thread border agent proxy enable
+    /** Format `b`
+     *
+     * Default value is `false`.
+     */
+    SPINEL_PROP_THREAD_BA_PROXY_ENABLED = SPINEL_PROP_THREAD_EXT__BEGIN + 17,
+
+    /// Thread border agent proxy stream
+    /** Format `dSS`
+     */
+    SPINEL_PROP_THREAD_BA_PROXY_STREAM  = SPINEL_PROP_THREAD_EXT__BEGIN + 18,
+
+    /// Thread "joiner" flag used during discovery scan operation
+    /** Format `b`
+     *
+     * This property defines the Joiner Flag value in the Discovery Request TLV.
+     *
+     * Default value is `false`.
+     */
+    SPINEL_PROP_THREAD_DISCOVERY_SCAN_JOINER_FLAG
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 19,
+
+    /// Enable EUI64 filtering for discovery scan operation.
+    /** Format `b`
+     *
+     * Default value is `false`
+     */
+    SPINEL_PROP_THREAD_DISCOVERY_SCAN_ENABLE_FILTERING
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 20,
+
+    /// PANID used for Discovery scan operation (used for PANID filtering).
+    /** Format: `S`
+     *
+     * Default value is 0xffff (Broadcast PAN) to disable PANID filtering
+     *
+     */
+    SPINEL_PROP_THREAD_DISCOVERY_SCAN_PANID
+                                        = SPINEL_PROP_THREAD_EXT__BEGIN + 21,
+
+    /// Thread (out of band) steering data for MLE Discovery Response.
+    /** Format `E` - Write only
+     *
+     * Required capability: SPINEL_CAP_OOB_STEERING_DATA.
+     *
+     * Writing to this property allows to set/update the the MLE Discovery Response steering data out of band.
+     *
+     *  - All zeros to clear the steering data (indicating that there is no steering data).
+     *  - All 0xFFs to set steering data/bloom filter to accept/allow all.
+     *  - A specific EUI64 which is then added to current steering data/bloom filter.
+     *
+     */
+    SPINEL_PROP_THREAD_STEERING_DATA    = SPINEL_PROP_THREAD_EXT__BEGIN + 22,
+
+    SPINEL_PROP_THREAD_EXT__END         = 0x1600,
+
+    SPINEL_PROP_IPV6__BEGIN             = 0x60,
+    SPINEL_PROP_IPV6_LL_ADDR            = SPINEL_PROP_IPV6__BEGIN + 0, ///< [6]
+    SPINEL_PROP_IPV6_ML_ADDR            = SPINEL_PROP_IPV6__BEGIN + 1, ///< [6C]
+    SPINEL_PROP_IPV6_ML_PREFIX          = SPINEL_PROP_IPV6__BEGIN + 2, ///< [6C]
+    SPINEL_PROP_IPV6_ADDRESS_TABLE      = SPINEL_PROP_IPV6__BEGIN + 3, ///< array(ipv6addr,prefixlen,valid,preferred,flags) [A(t(6CLLC))]
+    SPINEL_PROP_IPV6_ROUTE_TABLE        = SPINEL_PROP_IPV6__BEGIN + 4, ///< array(ipv6prefix,prefixlen,iface,flags) [A(t(6CCC))]
+
+    /// IPv6 ICMP Ping Offload
+    /** Format: `b`
+     *
+     * Allow the NCP to directly respond to ICMP ping requests. If this is
+     * turned on, ping request ICMP packets will not be passed to the host.
+     *
+     * Default value is `false`.
+     */
+    SPINEL_PROP_IPV6_ICMP_PING_OFFLOAD  = SPINEL_PROP_IPV6__BEGIN + 5, ///< [b]
+
+    SPINEL_PROP_IPV6__END               = 0x70,
+
+    SPINEL_PROP_STREAM__BEGIN           = 0x70,
+    SPINEL_PROP_STREAM_DEBUG            = SPINEL_PROP_STREAM__BEGIN + 0, ///< [U]
+    SPINEL_PROP_STREAM_RAW              = SPINEL_PROP_STREAM__BEGIN + 1, ///< [dD]
+    SPINEL_PROP_STREAM_NET              = SPINEL_PROP_STREAM__BEGIN + 2, ///< [dD]
+    SPINEL_PROP_STREAM_NET_INSECURE     = SPINEL_PROP_STREAM__BEGIN + 3, ///< [dD]
+    SPINEL_PROP_STREAM__END             = 0x80,
+
+    /// UART Bitrate
+    /** Format: `L`
+     *
+     *  If the NCP is using a UART to communicate with the host,
+     *  this property allows the host to change the bitrate
+     *  of the serial connection. The value encoding is `L`,
+     *  which is a little-endian 32-bit unsigned integer.
+     *  The host should not assume that all possible numeric values
+     *  are supported.
+     *
+     *  If implemented by the NCP, this property should be persistent
+     *  across software resets and forgotten upon hardware resets.
+     *
+     *  This property is only implemented when a UART is being
+     *  used for Spinel. This property is optional.
+     *
+     *  When changing the bitrate, all frames will be received
+     *  at the previous bitrate until the response frame to this command
+     *  is received. Once a successful response frame is received by
+     *  the host, all further frames will be transmitted at the new
+     *  bitrate.
+     */
+    SPINEL_PROP_UART_BITRATE            = 0x100,
+
+    /// UART Software Flow Control
+    /** Format: `b`
+     *
+     *  If the NCP is using a UART to communicate with the host,
+     *  this property allows the host to determine if software flow
+     *  control (XON/XOFF style) should be used and (optionally) to
+     *  turn it on or off.
+     *
+     *  This property is only implemented when a UART is being
+     *  used for Spinel. This property is optional.
+     */
+    SPINEL_PROP_UART_XON_XOFF           = 0x101,
+
+    SPINEL_PROP_15_4_PIB__BEGIN         = 1024,
+    // For direct access to the 802.15.4 PID.
+    // Individual registers are fetched using
+    // `SPINEL_PROP_15_4_PIB__BEGIN+[PIB_IDENTIFIER]`
+    // Only supported if SPINEL_CAP_15_4_PIB is set.
+    //
+    // For brevity, the entire 802.15.4 PIB space is
+    // not defined here, but a few choice attributes
+    // are defined for illustration and convenience.
+    SPINEL_PROP_15_4_PIB_PHY_CHANNELS_SUPPORTED
+                                        = SPINEL_PROP_15_4_PIB__BEGIN + 0x01, ///< [A(L)]
+    SPINEL_PROP_15_4_PIB_MAC_PROMISCUOUS_MODE
+                                        = SPINEL_PROP_15_4_PIB__BEGIN + 0x51, ///< [b]
+    SPINEL_PROP_15_4_PIB_MAC_SECURITY_ENABLED
+                                        = SPINEL_PROP_15_4_PIB__BEGIN + 0x5d, ///< [b]
+    SPINEL_PROP_15_4_PIB__END           = 1280,
+
+    SPINEL_PROP_CNTR__BEGIN             = 1280,
+
+    /// Counter reset behavior
+    /** Format: `C`
+     *  Writing a '1' to this property will reset
+     *  all of the counters to zero. */
+    SPINEL_PROP_CNTR_RESET              = SPINEL_PROP_CNTR__BEGIN + 0,
+
+    /// The total number of transmissions.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_TOTAL       = SPINEL_PROP_CNTR__BEGIN + 1,
+
+    /// The number of transmissions with ack request.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_ACK_REQ     = SPINEL_PROP_CNTR__BEGIN + 2,
+
+    /// The number of transmissions that were acked.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_ACKED       = SPINEL_PROP_CNTR__BEGIN + 3,
+
+    /// The number of transmissions without ack request.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_NO_ACK_REQ  = SPINEL_PROP_CNTR__BEGIN + 4,
+
+    /// The number of transmitted data.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_DATA        = SPINEL_PROP_CNTR__BEGIN + 5,
+
+    /// The number of transmitted data poll.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_DATA_POLL   = SPINEL_PROP_CNTR__BEGIN + 6,
+
+    /// The number of transmitted beacon.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_BEACON      = SPINEL_PROP_CNTR__BEGIN + 7,
+
+    /// The number of transmitted beacon request.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_BEACON_REQ  = SPINEL_PROP_CNTR__BEGIN + 8,
+
+    /// The number of transmitted other types of frames.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_OTHER       = SPINEL_PROP_CNTR__BEGIN + 9,
+
+    /// The number of retransmission times.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_RETRY       = SPINEL_PROP_CNTR__BEGIN + 10,
+
+    /// The number of CCA failure times.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_ERR_CCA         = SPINEL_PROP_CNTR__BEGIN + 11,
+
+    /// The number of unicast packets transmitted.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_UNICAST     = SPINEL_PROP_CNTR__BEGIN + 12,
+
+    /// The number of broadcast packets transmitted.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_PKT_BROADCAST   = SPINEL_PROP_CNTR__BEGIN + 13,
+
+    /// The number of frame transmission failures due to abort error.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_ERR_ABORT       = SPINEL_PROP_CNTR__BEGIN + 14,
+
+    /// The total number of received packets.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_TOTAL       = SPINEL_PROP_CNTR__BEGIN + 100,
+
+    /// The number of received data.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_DATA        = SPINEL_PROP_CNTR__BEGIN + 101,
+
+    /// The number of received data poll.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_DATA_POLL   = SPINEL_PROP_CNTR__BEGIN + 102,
+
+    /// The number of received beacon.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_BEACON      = SPINEL_PROP_CNTR__BEGIN + 103,
+
+    /// The number of received beacon request.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_BEACON_REQ  = SPINEL_PROP_CNTR__BEGIN + 104,
+
+    /// The number of received other types of frames.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_OTHER       = SPINEL_PROP_CNTR__BEGIN + 105,
+
+    /// The number of received packets filtered by whitelist.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_FILT_WL     = SPINEL_PROP_CNTR__BEGIN + 106,
+
+    /// The number of received packets filtered by destination check.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_FILT_DA     = SPINEL_PROP_CNTR__BEGIN + 107,
+
+    /// The number of received packets that are empty.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_ERR_EMPTY       = SPINEL_PROP_CNTR__BEGIN + 108,
+
+    /// The number of received packets from an unknown neighbor.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_ERR_UKWN_NBR    = SPINEL_PROP_CNTR__BEGIN + 109,
+
+    /// The number of received packets whose source address is invalid.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_ERR_NVLD_SADDR  = SPINEL_PROP_CNTR__BEGIN + 110,
+
+    /// The number of received packets with a security error.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_ERR_SECURITY    = SPINEL_PROP_CNTR__BEGIN + 111,
+
+    /// The number of received packets with a checksum error.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_ERR_BAD_FCS     = SPINEL_PROP_CNTR__BEGIN + 112,
+
+    /// The number of received packets with other errors.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_ERR_OTHER       = SPINEL_PROP_CNTR__BEGIN + 113,
+
+    /// The number of received duplicated.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_DUP         = SPINEL_PROP_CNTR__BEGIN + 114,
+
+    /// The number of unicast packets received.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_UNICAST     = SPINEL_PROP_CNTR__BEGIN + 115,
+
+    /// The number of broadcast packets received.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_PKT_BROADCAST   = SPINEL_PROP_CNTR__BEGIN + 116,
+
+    /// The total number of secure transmitted IP messages.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_IP_SEC_TOTAL    = SPINEL_PROP_CNTR__BEGIN + 200,
+
+    /// The total number of insecure transmitted IP messages.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_IP_INSEC_TOTAL  = SPINEL_PROP_CNTR__BEGIN + 201,
+
+    /// The number of dropped (not transmitted) IP messages.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_IP_DROPPED      = SPINEL_PROP_CNTR__BEGIN + 202,
+
+    /// The total number of secure received IP message.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_IP_SEC_TOTAL    = SPINEL_PROP_CNTR__BEGIN + 203,
+
+    /// The total number of insecure received IP message.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_IP_INSEC_TOTAL  = SPINEL_PROP_CNTR__BEGIN + 204,
+
+    /// The number of dropped received IP messages.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_IP_DROPPED      = SPINEL_PROP_CNTR__BEGIN + 205,
+
+    /// The number of transmitted spinel frames.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_TX_SPINEL_TOTAL    = SPINEL_PROP_CNTR__BEGIN + 300,
+
+    /// The number of received spinel frames.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_SPINEL_TOTAL    = SPINEL_PROP_CNTR__BEGIN + 301,
+
+    /// The number of received spinel frames with error.
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_SPINEL_ERR      = SPINEL_PROP_CNTR__BEGIN + 302,
+
+    /// Number of out of order received spinel frames (tid increase by more than 1).
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_RX_SPINEL_OUT_OF_ORDER_TID
+                                        = SPINEL_PROP_CNTR__BEGIN + 303,
+
+    /// The number of successful Tx IP packets
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_IP_TX_SUCCESS      = SPINEL_PROP_CNTR__BEGIN + 304,
+
+    /// The number of successful Rx IP packets
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_IP_RX_SUCCESS      = SPINEL_PROP_CNTR__BEGIN + 305,
+
+    /// The number of failed Tx IP packets
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_IP_TX_FAILURE      = SPINEL_PROP_CNTR__BEGIN + 306,
+
+    /// The number of failed Rx IP packets
+    /** Format: `L` (Read-only) */
+    SPINEL_PROP_CNTR_IP_RX_FAILURE      = SPINEL_PROP_CNTR__BEGIN + 307,
+
+    /// The message buffer counter info
+    /** Format: `SSSSSSSSSSSSSSSS` (Read-only)
+     *      `S`, (TotalBuffers)           The number of buffers in the pool.
+     *      `S`, (FreeBuffers)            The number of free message buffers.
+     *      `S`, (6loSendMessages)        The number of messages in the 6lo send queue.
+     *      `S`, (6loSendBuffers)         The number of buffers in the 6lo send queue.
+     *      `S`, (6loReassemblyMessages)  The number of messages in the 6LoWPAN reassembly queue.
+     *      `S`, (6loReassemblyBuffers)   The number of buffers in the 6LoWPAN reassembly queue.
+     *      `S`, (Ip6Messages)            The number of messages in the IPv6 send queue.
+     *      `S`, (Ip6Buffers)             The number of buffers in the IPv6 send queue.
+     *      `S`, (MplMessages)            The number of messages in the MPL send queue.
+     *      `S`, (MplBuffers)             The number of buffers in the MPL send queue.
+     *      `S`, (MleMessages)            The number of messages in the MLE send queue.
+     *      `S`, (MleBuffers)             The number of buffers in the MLE send queue.
+     *      `S`, (ArpMessages)            The number of messages in the ARP send queue.
+     *      `S`, (ArpBuffers)             The number of buffers in the ARP send queue.
+     *      `S`, (CoapMessages)           The number of messages in the CoAP send queue.
+     *      `S`, (CoapBuffers)            The number of buffers in the CoAP send queue.
+     */
+    SPINEL_PROP_MSG_BUFFER_COUNTERS     = SPINEL_PROP_CNTR__BEGIN + 400,
+
+    SPINEL_PROP_CNTR__END               = 2048,
+
+    SPINEL_PROP_NEST__BEGIN             = 15296,
+    SPINEL_PROP_NEST_STREAM_MFG         = SPINEL_PROP_NEST__BEGIN + 0,
+
+    /// The legacy network ULA prefix (8 bytes)
+    /** Format: 'D' */
+    SPINEL_PROP_NEST_LEGACY_ULA_PREFIX  = SPINEL_PROP_NEST__BEGIN + 1,
+
+    /// A (newly) joined legacy node (this is signaled from NCP)
+    /** Format: 'E' */
+    SPINEL_PROP_NEST_LEGACY_JOINED_NODE = SPINEL_PROP_NEST__BEGIN + 2,
+
+    SPINEL_PROP_NEST__END               = 15360,
+
+    SPINEL_PROP_VENDOR__BEGIN           = 15360,
+    SPINEL_PROP_VENDOR__END             = 16384,
+
+    SPINEL_PROP_DEBUG__BEGIN            = 16384,
+
+    /// Reading this property will cause an assert on the NCP.
+    /// This is intended for testing the assert functionality of
+    /// underlying platform/NCP. Assert should ideally cause the
+    /// NCP to reset, but if this is not supported a `false` boolean
+    /// is returned in response.
+    /** Format: 'b' (read-only) */
+    SPINEL_PROP_DEBUG_TEST_ASSERT       = SPINEL_PROP_DEBUG__BEGIN + 0,
+
+    /// The NCP log level.
+    /** Format: `C` */
+    SPINEL_PROP_DEBUG_NCP_LOG_LEVEL     = SPINEL_PROP_DEBUG__BEGIN + 1,
+
+    SPINEL_PROP_DEBUG__END              = 17408,
+
+    SPINEL_PROP_EXPERIMENTAL__BEGIN     = 2000000,
+    SPINEL_PROP_EXPERIMENTAL__END       = 2097152,
+} spinel_prop_key_t;
+
+// ----------------------------------------------------------------------------
+
+#define SPINEL_HEADER_FLAG              0x80
+
+#define SPINEL_HEADER_TID_SHIFT         0
+#define SPINEL_HEADER_TID_MASK          (15 << SPINEL_HEADER_TID_SHIFT)
+
+#define SPINEL_HEADER_IID_SHIFT         4
+#define SPINEL_HEADER_IID_MASK          (3 << SPINEL_HEADER_IID_SHIFT)
+
+#define SPINEL_HEADER_IID_0             (0 << SPINEL_HEADER_IID_SHIFT)
+#define SPINEL_HEADER_IID_1             (1 << SPINEL_HEADER_IID_SHIFT)
+#define SPINEL_HEADER_IID_2             (2 << SPINEL_HEADER_IID_SHIFT)
+#define SPINEL_HEADER_IID_3             (3 << SPINEL_HEADER_IID_SHIFT)
+
+#define SPINEL_HEADER_GET_IID(x)        (((x) & SPINEL_HEADER_IID_MASK) >> SPINEL_HEADER_IID_SHIFT)
+#define SPINEL_HEADER_GET_TID(x)        (spinel_tid_t)(((x)&SPINEL_HEADER_TID_MASK)>>SPINEL_HEADER_TID_SHIFT)
+
+#define SPINEL_GET_NEXT_TID(x)          (spinel_tid_t)((x)>=0xF?1:(x)+1)
+
+#define SPINEL_BEACON_THREAD_FLAG_VERSION_SHIFT                                                         \
+                                        4
+
+#define SPINEL_BEACON_THREAD_FLAG_VERSION_MASK                                                          \
+                                        (0xf << SPINEL_BEACON_THREAD_FLAG_VERSION_SHIFT)
+
+#define SPINEL_BEACON_THREAD_FLAG_JOINABLE                                                              \
+                                        (1 << 0)
+
+#define SPINEL_BEACON_THREAD_FLAG_NATIVE                                                                \
+                                       (1 << 3)
+
+// ----------------------------------------------------------------------------
+
+enum
+{
+    SPINEL_DATATYPE_NULL_C              = 0,
+    SPINEL_DATATYPE_VOID_C              = '.',
+    SPINEL_DATATYPE_BOOL_C              = 'b',
+    SPINEL_DATATYPE_UINT8_C             = 'C',
+    SPINEL_DATATYPE_INT8_C              = 'c',
+    SPINEL_DATATYPE_UINT16_C            = 'S',
+    SPINEL_DATATYPE_INT16_C             = 's',
+    SPINEL_DATATYPE_UINT32_C            = 'L',
+    SPINEL_DATATYPE_INT32_C             = 'l',
+    SPINEL_DATATYPE_UINT_PACKED_C       = 'i',
+    SPINEL_DATATYPE_IPv6ADDR_C          = '6',
+    SPINEL_DATATYPE_EUI64_C             = 'E',
+    SPINEL_DATATYPE_EUI48_C             = 'e',
+    SPINEL_DATATYPE_DATA_WLEN_C         = 'd',
+    SPINEL_DATATYPE_DATA_C              = 'D',
+    SPINEL_DATATYPE_UTF8_C              = 'U', //!< Zero-Terminated UTF8-Encoded String
+    SPINEL_DATATYPE_STRUCT_C            = 't',
+    SPINEL_DATATYPE_ARRAY_C             = 'A',
+};
+
+typedef char spinel_datatype_t;
+
+#define SPINEL_DATATYPE_NULL_S          ""
+#define SPINEL_DATATYPE_VOID_S          "."
+#define SPINEL_DATATYPE_BOOL_S          "b"
+#define SPINEL_DATATYPE_UINT8_S         "C"
+#define SPINEL_DATATYPE_INT8_S          "c"
+#define SPINEL_DATATYPE_UINT16_S        "S"
+#define SPINEL_DATATYPE_INT16_S         "s"
+#define SPINEL_DATATYPE_UINT32_S        "L"
+#define SPINEL_DATATYPE_INT32_S         "l"
+#define SPINEL_DATATYPE_UINT_PACKED_S   "i"
+#define SPINEL_DATATYPE_IPv6ADDR_S      "6"
+#define SPINEL_DATATYPE_EUI64_S         "E"
+#define SPINEL_DATATYPE_EUI48_S         "e"
+#define SPINEL_DATATYPE_DATA_WLEN_S     "d"
+#define SPINEL_DATATYPE_DATA_S          "D"
+#define SPINEL_DATATYPE_UTF8_S          "U" //!< Zero-Terminated UTF8-Encoded String
+
+#define SPINEL_DATATYPE_ARRAY_S(x)      "A(" x ")"
+#define SPINEL_DATATYPE_STRUCT_S(x)     "t(" x ")"
+
+#define SPINEL_DATATYPE_ARRAY_STRUCT_S(x)                                                               \
+                                        SPINEL_DATATYPE_ARRAY_S(SPINEL_DATATYPE_STRUCT_WLEN_S(x))
+
+#define SPINEL_DATATYPE_COMMAND_S       SPINEL_DATATYPE_UINT8_S       /* header  */                     \
+                                        SPINEL_DATATYPE_UINT_PACKED_S /* command */
+
+#define SPINEL_DATATYPE_COMMAND_PROP_S  SPINEL_DATATYPE_COMMAND_S     /* prop command  */               \
+                                        SPINEL_DATATYPE_UINT_PACKED_S /* property id */
+
+#define SPINEL_DATATYPE_MAC_SCAN_RESULT_S(mac_format_str, net_format_str)                               \
+                                        SPINEL_DATATYPE_UINT8_S /* Channel */                           \
+                                        SPINEL_DATATYPE_INT8_S  /* RSSI */                              \
+                                        SPINEL_DATATYPE_STRUCT_S(mac_format_str) /* mac-layer data */   \
+                                        SPINEL_DATATYPE_STRUCT_S(net_format_str) /* net-layer data */
+
+#define SPINEL_802_15_4_DATATYPE_MAC_SCAN_RESULT_V1_S                                                   \
+                                        SPINEL_DATATYPE_EUI64_S  /* laddr */                            \
+                                        SPINEL_DATATYPE_UINT16_S /* saddr */                            \
+                                        SPINEL_DATATYPE_UINT16_S /* panid */                            \
+                                        SPINEL_DATATYPE_UINT8_S  /* lqi   */
+
+#define SPINEL_NET_DATATYPE_MAC_SCAN_RESULT_V1_S                                                        \
+                                        SPINEL_DATATYPE_UINT_PACKED_S /* type */                        \
+                                        SPINEL_DATATYPE_UINT8_S /* flags */                             \
+                                        SPINEL_DATATYPE_UTF8_S /* network name */                       \
+                                        SPINEL_DATATYPE_DATA_WLEN_S /* xpanid */
+
+#define SPINEL_NET_DATATYPE_MAC_SCAN_RESULT_V2_S                                                        \
+                                        SPINEL_NET_DATATYPE_MAC_SCAN_RESULT_V1_S                        \
+                                        SPINEL_DATATYPE_DATA_WLEN_S /* steering data */
+
+
+#define SPINEL_MAX_UINT_PACKED          2097151
+
+SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_pack(uint8_t *data_out, spinel_size_t data_len,
+                                                      const char *pack_format, ...);
+SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_vpack(uint8_t *data_out, spinel_size_t data_len,
+                                                       const char *pack_format, va_list args);
+SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_unpack(const uint8_t *data_in, spinel_size_t data_len,
+                                                        const char *pack_format, ...);
+SPINEL_API_EXTERN spinel_ssize_t spinel_datatype_vunpack(const uint8_t *data_in, spinel_size_t data_len,
+                                                         const char *pack_format, va_list args);
+
+SPINEL_API_EXTERN spinel_ssize_t spinel_packed_uint_decode(const uint8_t *bytes, spinel_size_t len,
+                                                           unsigned int *value);
+SPINEL_API_EXTERN spinel_ssize_t spinel_packed_uint_encode(uint8_t *bytes, spinel_size_t len, unsigned int value);
+SPINEL_API_EXTERN spinel_ssize_t spinel_packed_uint_size(unsigned int value);
+
+SPINEL_API_EXTERN const char *spinel_next_packed_datatype(const char *pack_format);
+
+// ----------------------------------------------------------------------------
+
+SPINEL_API_EXTERN const char *spinel_prop_key_to_cstr(spinel_prop_key_t prop_key);
+
+SPINEL_API_EXTERN const char *spinel_net_role_to_cstr(uint8_t net_role);
+
+SPINEL_API_EXTERN const char *spinel_status_to_cstr(spinel_status_t status);
+
+SPINEL_API_EXTERN const char *spinel_capability_to_cstr(unsigned int capability);
+
+// ----------------------------------------------------------------------------
+
+__END_DECLS
+
+#endif /* defined(SPINEL_HEADER_INCLUDED) */
diff --git a/openthread/tools/spi-hdlc-adapter/README.md b/openthread/tools/spi-hdlc-adapter/README.md
new file mode 100644
index 0000000..104efe8
--- /dev/null
+++ b/openthread/tools/spi-hdlc-adapter/README.md
@@ -0,0 +1,90 @@
+SPI/HDLC Adaptor
+================
+
+`spi-hdlc-adapter` is an adapter tool for using a SPI interface as if
+it were an HDLC-lite encoded bidirectional asynchronous serial stream.
+It uses the SPI protocol outlined in [Appendix A.2][1] of the Spinel
+protocol document.
+
+[1]: https://goo.gl/gt18O4
+
+## Syntax ##
+
+    spi-hdlc-adapter [options] <spi-device-path>
+
+## Options ##
+
+*   `--stdio`: Use `stdin` and `stdout` for HDLC input/output. Useful
+    when directly started by the program that will be using it.
+*   `--pty`: Create a pseudo terminal for HDLC input/output. The path
+    of the newly-created PTY will be written to `stdout`, followed by
+    a newline.
+*   `--raw`: Do not encode/decode packets using HDLC. Instead, write
+    whole, raw frames to the specified input and output FDs. This is
+    useful for emulating a serial port, or when datagram-based sockets
+    are supplied for `stdin` and `stdout` (when used with `--stdio`).
+*   `--mtu=[MTU]`: Specify the MTU. Currently only used in raw mode.
+    Default and maximum value is 2043. Must be greater than zero.
+*   `--gpio-int[=gpio-path]`: Specify a path to the Linux
+    sysfs-exported GPIO directory for the `I̅N̅T̅` pin. If not
+    specified, `spi-hdlc-adapter` will fall back to polling, which is
+    inefficient.
+*   `--gpio-reset[=gpio-path]`: Specify a path to the Linux
+    sysfs-exported GPIO directory for the `R̅E̅S̅` pin.
+*   `--spi-mode[=mode]`: Specify the SPI mode to use (0-3). Default
+    value is `0`.
+*   `--spi-speed[=hertz]`: Specify the SPI speed in hertz. Default
+    value is `1000000` (1MHz).
+*   `--spi-cs-delay[=usec]`: Specify the delay after C̅S̅ assertion,
+    in microseconds. Default is 20µs. Note that this may need to be
+    set to zero for spi-hdlc-adapter to work with some SPI drivers.
+*   `--spi-align-allowance[=n]`: Specify the the maximum number of 0xFF
+    bytes to clip from start of MISO frame. This makes this tool usable
+    with SPI slaves which have buggy SPI blocks that prepend up to
+    three 0xFF bytes to the start of MISO frame. Default value is `0`.
+    Maximum value is `3`. *This must be set to at least `2` for chips
+    in the SiLabs EM35x family.*
+*   `--verbose`: Increase debug verbosity.
+*   `--help`: Print out usage information to `stdout` and exit.
+
+`spi-device-path` is a required argument since it indicates which SPI
+device to use. An example path might be `/dev/spidev1.0`.
+
+The GPIO paths are to the top-level directory for that GPIO. They must
+be already be exported before `spi-hdlc-adapter` can use them.
+
+## Behavior ##
+
+If an MCU reset is detected by the reset bit being set on a SPI frame,
+the special vendor-specific HDLC-lite symbol `0xF8` is emitted. If
+`--gpio-reset` is specified, the HDLC client can trigger an MCU reset
+by sending the symbols `0x7E 0x13 0x11 0x7E` or by sending `SIGUSR1`.
+
+When started, `spi-hdlc-adapter` will configure the following
+properties on the GPIOs:
+
+1.  Set `I̅N̅T̅/direction` to `in`.
+2.  Set `I̅N̅T̅/edge` to `falling`.
+3.  Set `R̅E̅S̅/direction` to `high`.
+
+When resetting the slave device, `spi-hdlc` performs the following
+procedure:
+
+1.  Set `R̅E̅S̅/direction` to `low`.
+2.  Sleep for 30ms.
+3.  Set `R̅E̅S̅/direction` to `high`.
+
+## Statistics ##
+
+Some simple usage statistics are printed out to syslog at exit and
+whenever the `SIGUSR1` signal is received. The easiest way to send
+that signal to `spi-hdlc-adapter` is like this:
+
+    # killall -sigusr1 spi-hdlc-adapter
+
+At which point you will see something like this in the syslogs:
+
+    spi-hdlc-adapter[5215]: INFO: sSpiFrameCount=45660
+    spi-hdlc-adapter[5215]: INFO: sSpiValidFrameCount=45643
+    spi-hdlc-adapter[5215]: INFO: sSpiGarbageFrameCount=17
+    spi-hdlc-adapter[5215]: INFO: sSpiDuplexFrameCount=20931
diff --git a/openthread/tools/spi-hdlc-adapter/spi-hdlc-adapter.c b/openthread/tools/spi-hdlc-adapter/spi-hdlc-adapter.c
new file mode 100644
index 0000000..20b762c
--- /dev/null
+++ b/openthread/tools/spi-hdlc-adapter/spi-hdlc-adapter.c
@@ -0,0 +1,1996 @@
+/*
+ *    Copyright (c) 2017, The OpenThread Authors.
+ *    All rights reserved.
+ *
+ *    Redistribution and use in source and binary forms, with or without
+ *    modification, are permitted provided that the following conditions are met:
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *    3. Neither the name of the copyright holder nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ *    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ *    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ *    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define _GNU_SOURCE 1
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <syslog.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/select.h>
+#include <sys/ucontext.h>
+#include <sys/ioctl.h>
+#include <sys/file.h>
+
+#include <linux/spi/spidev.h>
+
+#if HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
+#if HAVE_PTY_H
+#include <pty.h>
+#endif
+
+#if HAVE_UTIL_H
+#include <util.h>
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Macros and Constants */
+
+#define SPI_HDLC_VERSION                "0.06"
+
+#define MAX_FRAME_SIZE                  2048
+#define HEADER_LEN                      5
+#define SPI_HEADER_RESET_FLAG           0x80
+#define SPI_HEADER_CRC_FLAG             0x40
+#define SPI_HEADER_PATTERN_VALUE        0x02
+#define SPI_HEADER_PATTERN_MASK         0x03
+
+#define EXIT_QUIT                       65535
+
+#ifndef MSEC_PER_SEC
+#define MSEC_PER_SEC                    1000
+#endif
+
+#ifndef USEC_PER_MSEC
+#define USEC_PER_MSEC                   1000
+#endif
+
+#ifndef USEC_PER_SEC
+#define USEC_PER_SEC                    (USEC_PER_MSEC * MSEC_PER_SEC)
+#endif
+
+#define SPI_POLL_PERIOD_MSEC            (MSEC_PER_SEC/30)
+
+#define GPIO_INT_ASSERT_STATE           0 // I̅N̅T̅ is asserted low
+#define GPIO_RES_ASSERT_STATE           0 // R̅E̅S̅ is asserted low
+
+#define SPI_RX_ALIGN_ALLOWANCE_MAX      6
+
+#define SOCKET_DEBUG_BYTES_PER_LINE     16
+
+#ifndef AUTO_PRINT_BACKTRACE
+#define AUTO_PRINT_BACKTRACE            (HAVE_EXECINFO_H)
+#endif
+
+#define AUTO_PRINT_BACKTRACE_STACK_DEPTH     20
+
+static const uint8_t kHdlcResetSignal[] = { 0x7E, 0x13, 0x11, 0x7E };
+static const uint16_t kHdlcCrcCheckValue = 0xf0b8;
+static const uint16_t kHdlcCrcResetValue = 0xffff;
+
+enum {
+    MODE_STDIO = 0,
+    MODE_PTY = 1,
+};
+
+// Ignores return value from function 's'
+#define IGNORE_RETURN_VALUE(s)  do { if (s){} } while (0)
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Global State */
+
+#if HAVE_OPENPTY
+static int sMode = MODE_PTY;
+#else
+static int sMode = MODE_STDIO;
+#endif
+
+static const char* sSpiDevPath     = NULL;
+static const char* sIntGpioDevPath = NULL;
+static const char* sResGpioDevPath = NULL;
+
+static int sVerbose             = LOG_NOTICE;
+
+static int sSpiDevFd            = -1;
+static int sResGpioValueFd      = -1;
+static int sIntGpioValueFd      = -1;
+
+static int sHdlcInputFd         = -1;
+static int sHdlcOutputFd        = -1;
+
+static int sSpiSpeed            = 1000000; // in Hz (default: 1MHz)
+static uint8_t sSpiMode         = 0;
+static int sSpiCsDelay          = 20;      // in microseconds
+
+static uint16_t sSpiRxPayloadSize;
+static uint8_t sSpiRxFrameBuffer[MAX_FRAME_SIZE + SPI_RX_ALIGN_ALLOWANCE_MAX];
+
+static uint16_t sSpiTxPayloadSize;
+static bool sSpiTxIsReady = false;
+static int sSpiTxRefusedCount = 0;
+static uint8_t sSpiTxFrameBuffer[MAX_FRAME_SIZE + SPI_RX_ALIGN_ALLOWANCE_MAX];
+
+static int sSpiRxAlignAllowance = 0;
+static int sSpiSmallPacketSize  = 32;      // in bytes
+
+static bool sSlaveDidReset = false;
+
+// If sUseRawFrames is set to true, HDLC encoding/encoding
+// is skipped and the raw frames are read-from/written-to
+// the sHdlcInputFd/sHdlcOutputFd whole. See `--raw`.
+static bool sUseRawFrames = false;
+
+static int sMTU = MAX_FRAME_SIZE - HEADER_LEN;
+
+static int sRet = 0;
+
+static bool sDumpStats = false;
+
+static sig_t sPreviousHandlerForSIGINT;
+static sig_t sPreviousHandlerForSIGTERM;
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Statistics */
+
+static uint64_t sSlaveResetCount = 0;
+static uint64_t sSpiFrameCount = 0;
+static uint64_t sSpiValidFrameCount = 0;
+static uint64_t sSpiGarbageFrameCount = 0;
+static uint64_t sSpiDuplexFrameCount = 0;
+static uint64_t sSpiUnresponsiveFrameCount = 0;
+static uint64_t sHdlcRxFrameByteCount = 0;
+static uint64_t sHdlcTxFrameByteCount = 0;
+static uint64_t sHdlcRxFrameCount = 0;
+static uint64_t sHdlcTxFrameCount = 0;
+static uint64_t sHdlcRxBadCrcCount = 0;
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Signal Handlers */
+
+static void signal_SIGINT(int sig)
+{
+    static const char message[] = "\nCaught SIGINT!\n";
+
+    sRet = EXIT_QUIT;
+
+    // Can't use syslog() because it isn't async signal safe.
+    // So we write to stderr
+    IGNORE_RETURN_VALUE(write(STDERR_FILENO, message, sizeof(message)-1));
+
+    // Restore the previous handler so that if we end up getting
+    // this signal again we perform the system default action.
+    signal(SIGINT, sPreviousHandlerForSIGINT);
+    sPreviousHandlerForSIGINT = NULL;
+
+    // Ignore signal argument.
+    (void)sig;
+}
+
+static void signal_SIGTERM(int sig)
+{
+    static const char message[] = "\nCaught SIGTERM!\n";
+
+    sRet = EXIT_QUIT;
+
+    // Can't use syslog() because it isn't async signal safe.
+    // So we write to stderr
+    IGNORE_RETURN_VALUE(write(STDERR_FILENO, message, sizeof(message)-1));
+
+    // Restore the previous handler so that if we end up getting
+    // this signal again we perform the system default action.
+    signal(SIGTERM, sPreviousHandlerForSIGTERM);
+    sPreviousHandlerForSIGTERM = NULL;
+
+    // Ignore signal argument.
+    (void)sig;
+}
+
+static void signal_SIGHUP(int sig)
+{
+    static const char message[] = "\nCaught SIGHUP!\n";
+
+    sRet = EXIT_FAILURE;
+
+    // Can't use syslog() because it isn't async signal safe.
+    // So we write to stderr
+    IGNORE_RETURN_VALUE(write(STDERR_FILENO, message, sizeof(message)-1));
+
+    // We don't restore the "previous handler"
+    // because we always want to let the main
+    // loop decide what to do for hangups.
+
+    // Ignore signal argument.
+    (void)sig;
+}
+
+static void signal_dumpstats(int sig)
+{
+    sDumpStats = true;
+
+    // Ignore signal argument.
+    (void)sig;
+}
+
+static void signal_clearstats(int sig)
+{
+    sDumpStats = true;
+    sSlaveResetCount = 0;
+    sSpiFrameCount = 0;
+    sSpiValidFrameCount = 0;
+    sSpiGarbageFrameCount = 0;
+    sSpiDuplexFrameCount = 0;
+    sSpiUnresponsiveFrameCount = 0;
+    sHdlcRxFrameByteCount = 0;
+    sHdlcTxFrameByteCount = 0;
+    sHdlcRxFrameCount = 0;
+    sHdlcTxFrameCount = 0;
+    sHdlcRxBadCrcCount = 0;
+
+    // Ignore signal argument.
+    (void)sig;
+}
+
+#if AUTO_PRINT_BACKTRACE
+static void signal_critical(int sig, siginfo_t * info, void * ucontext)
+{
+    // This is the last hurah for this process.
+    // We dump the stack, because that's all we can do.
+
+    void *stack_mem[AUTO_PRINT_BACKTRACE_STACK_DEPTH];
+    void **stack = stack_mem;
+    char **stack_symbols;
+    int stack_depth, i;
+    ucontext_t *uc = (ucontext_t*)ucontext;
+
+    // Shut up compiler warning.
+    (void)uc;
+    (void)info;
+
+    // We call some functions here which aren't async-signal-safe,
+    // but this function isn't really useful without those calls.
+    // Since we are making a gamble (and we deadlock if we loose),
+    // we are going to set up a two-second watchdog to make sure
+    // we end up terminating like we should. The choice of a two
+    // second timeout is entirely arbitrary, and may be changed
+    // if needs warrant.
+    alarm(2);
+    signal(SIGALRM, SIG_DFL);
+
+    fprintf(stderr, " *** FATAL ERROR: Caught signal %d (%s):\n", sig, strsignal(sig));
+
+    stack_depth = backtrace(stack, AUTO_PRINT_BACKTRACE_STACK_DEPTH);
+
+    // Here are are trying to update the pointer in the backtrace
+    // to be the actual location of the fault.
+#if defined(__x86_64__)
+    stack[1] = (void *) uc->uc_mcontext.gregs[REG_RIP];
+#elif defined(__i386__)
+    stack[1] = (void *) uc->uc_mcontext.gregs[REG_EIP];
+#elif defined(__arm__)
+    stack[1] = (void *) uc->uc_mcontext.arm_ip;
+#else
+#warning TODO: Add this arch to signal_critical
+#endif
+
+    // Now dump the symbols to stderr, in case syslog barfs.
+    backtrace_symbols_fd(stack, stack_depth, STDERR_FILENO);
+
+    // Load up the symbols individually, so we can output to syslog, too.
+    stack_symbols = backtrace_symbols(stack, stack_depth);
+
+    syslog(LOG_CRIT, " *** FATAL ERROR: Caught signal %d (%s):", sig, strsignal(sig));
+
+    for (i = 0; i != stack_depth; i++)
+    {
+        syslog(LOG_CRIT, "[BT] %2d: %s", i, stack_symbols[i]);
+    }
+
+    free(stack_symbols);
+
+    exit(EXIT_FAILURE);
+}
+#endif // if AUTO_PRINT_BACKTRACE
+
+static void log_debug_buffer(const char* desc, const uint8_t* buffer_ptr, int buffer_len, bool force)
+{
+    int i = 0;
+
+    if (!force && (sVerbose < LOG_DEBUG))
+    {
+        return;
+    }
+
+    while (i < buffer_len)
+    {
+        int j;
+        char dump_string[SOCKET_DEBUG_BYTES_PER_LINE*3+1];
+
+        for (j = 0; i < buffer_len && j < SOCKET_DEBUG_BYTES_PER_LINE; i++, j++)
+        {
+            sprintf(dump_string+j*3, "%02X ", buffer_ptr[i]);
+        }
+
+        syslog(force ? LOG_WARNING : LOG_DEBUG, "%s: %s%s", desc, dump_string, (i < buffer_len)?" ...":"");
+    }
+}
+
+/* ------------------------------------------------------------------------- */
+/* MARK: SPI Transfer Functions */
+
+static void spi_header_set_flag_byte(uint8_t *header, uint8_t value)
+{
+    header[0] = value;
+}
+
+static void spi_header_set_accept_len(uint8_t *header, uint16_t len)
+{
+    header[1] = ((len >> 0) & 0xFF);
+    header[2] = ((len >> 8) & 0xFF);
+}
+
+static void spi_header_set_data_len(uint8_t *header, uint16_t len)
+{
+    header[3] = ((len >> 0) & 0xFF);
+    header[4] = ((len >> 8) & 0xFF);
+}
+
+static uint8_t spi_header_get_flag_byte(const uint8_t *header)
+{
+    return header[0];
+}
+
+static uint16_t spi_header_get_accept_len(const uint8_t *header)
+{
+    return ( header[1] + (uint16_t)(header[2] << 8) );
+}
+
+static uint16_t spi_header_get_data_len(const uint8_t *header)
+{
+    return ( header[3] + (uint16_t)(header[4] << 8) );
+}
+
+static uint8_t* get_real_rx_frame_start(void)
+{
+    uint8_t* ret = sSpiRxFrameBuffer;
+    int i = 0;
+
+    for (i = 0; i < sSpiRxAlignAllowance; i++)
+    {
+        if (ret[0] != 0xFF)
+        {
+            break;
+        }
+        ret++;
+    }
+
+    return ret;
+}
+
+static int do_spi_xfer(int len)
+ {
+    int ret;
+
+    struct spi_ioc_transfer xfer[2] =
+    {
+        {   // This part is the delay between C̅S̅ being
+            // asserted and the SPI clock starting. This
+            // is not supported by all Linux SPI drivers.
+            .tx_buf = 0,
+            .rx_buf = 0,
+            .len = 0,
+            .delay_usecs = (uint16_t)sSpiCsDelay,
+            .speed_hz = (uint32_t)sSpiSpeed,
+            .bits_per_word = 8,
+            .cs_change = false,
+        },
+        {   // This part is the actual SPI transfer.
+            .tx_buf = (unsigned long)sSpiTxFrameBuffer,
+            .rx_buf = (unsigned long)sSpiRxFrameBuffer,
+            .len = (uint32_t)(len + HEADER_LEN + sSpiRxAlignAllowance),
+            .delay_usecs = 0,
+            .speed_hz = (uint32_t)sSpiSpeed,
+            .bits_per_word = 8,
+            .cs_change = false,
+        }
+    };
+
+
+
+    if (sSpiCsDelay > 0)
+    {
+        // A C̅S̅ delay has been specified. Start transactions
+        // with both parts.
+        ret = ioctl(sSpiDevFd, SPI_IOC_MESSAGE(2), &xfer[0]);
+    }
+    else
+    {
+        // No C̅S̅ delay has been specified, so we skip the first
+        // part because it causes some SPI drivers to croak.
+        ret = ioctl(sSpiDevFd, SPI_IOC_MESSAGE(1), &xfer[1]);
+    }
+
+    if (ret != -1)
+    {
+        log_debug_buffer("SPI-TX", sSpiTxFrameBuffer, (int)xfer[1].len, false);
+        log_debug_buffer("SPI-RX", sSpiRxFrameBuffer, (int)xfer[1].len, false);
+
+        sSpiFrameCount++;
+    }
+
+    return ret;
+}
+
+static void debug_spi_header(const char* hint, bool force)
+{
+    if (force || (sVerbose >= LOG_DEBUG))
+    {
+        const uint8_t* spiRxFrameBuffer = get_real_rx_frame_start();
+
+        syslog(force ? LOG_WARNING : LOG_DEBUG, "%s-TX: H:%02X ACCEPT:%d DATA:%0d\n",
+            hint,
+            spi_header_get_flag_byte(sSpiTxFrameBuffer),
+            spi_header_get_accept_len(sSpiTxFrameBuffer),
+            spi_header_get_data_len(sSpiTxFrameBuffer)
+        );
+
+        syslog(force ? LOG_WARNING : LOG_DEBUG, "%s-RX: H:%02X ACCEPT:%d DATA:%0d\n",
+            hint,
+            spi_header_get_flag_byte(spiRxFrameBuffer),
+            spi_header_get_accept_len(spiRxFrameBuffer),
+            spi_header_get_data_len(spiRxFrameBuffer)
+        );
+    }
+}
+
+static int push_pull_spi(void)
+{
+    int ret;
+    uint16_t spi_xfer_bytes = 0;
+    const uint8_t* spiRxFrameBuffer = NULL;
+    uint8_t slave_header;
+    uint16_t slave_max_rx;
+    int successful_exchanges = 0;
+
+    static uint16_t slave_data_len;
+
+    // For now, sSpiRxPayloadSize must be zero
+    // when entering this function. This may change
+    // at some point, for now this makes things
+    // much easier.
+    assert(sSpiRxPayloadSize == 0);
+
+    if (sSpiValidFrameCount == 0)
+    {
+        // Set the reset flag to indicate to our slave that we
+        // are coming up from scratch.
+        spi_header_set_flag_byte(sSpiTxFrameBuffer, SPI_HEADER_RESET_FLAG|SPI_HEADER_PATTERN_VALUE);
+    }
+    else
+    {
+        spi_header_set_flag_byte(sSpiTxFrameBuffer, SPI_HEADER_PATTERN_VALUE);
+    }
+
+    // Zero out our rx_accept and our data_len for now.
+    spi_header_set_accept_len(sSpiTxFrameBuffer, 0);
+    spi_header_set_data_len(sSpiTxFrameBuffer, 0);
+
+    // Sanity check.
+    if (slave_data_len > MAX_FRAME_SIZE)
+    {
+        slave_data_len = 0;
+    }
+
+    if (sSpiTxIsReady)
+    {
+        // Go ahead and try to immediately send a frame if we have it queued up.
+        spi_header_set_data_len(sSpiTxFrameBuffer, sSpiTxPayloadSize);
+
+        if (sSpiTxPayloadSize > spi_xfer_bytes)
+        {
+            spi_xfer_bytes = sSpiTxPayloadSize;
+        }
+    }
+
+    if (sSpiRxPayloadSize == 0)
+    {
+        if (slave_data_len != 0)
+        {
+            // In a previous transaction the slave indicated
+            // it had something to send us. Make sure our
+            // transaction is large enough to handle it.
+            if (slave_data_len > spi_xfer_bytes)
+            {
+                spi_xfer_bytes = slave_data_len;
+            }
+        }
+        else
+        {
+            // Set up a minimum transfer size to allow small
+            // frames the slave wants to send us to be handled
+            // in a single transaction.
+            if (sSpiSmallPacketSize > spi_xfer_bytes)
+            {
+                spi_xfer_bytes = (uint16_t)sSpiSmallPacketSize;
+            }
+        }
+
+        spi_header_set_accept_len(sSpiTxFrameBuffer, spi_xfer_bytes);
+    }
+
+    // Perform the SPI transaction.
+    ret = do_spi_xfer(spi_xfer_bytes);
+
+    if (ret < 0)
+    {
+        perror("do_spi_xfer");
+
+        // Print out a helpful error message for
+        // a common error.
+        if ( (sSpiCsDelay != 0)
+          && (errno == EINVAL)
+        ) {
+            syslog(LOG_ERR, "SPI ioctl failed with EINVAL. Try adding `--spi-cs-delay=0` to command line arguments.");
+        }
+        goto bail;
+    }
+
+    // Account for misalignment (0xFF bytes at the start)
+    spiRxFrameBuffer = get_real_rx_frame_start();
+
+    debug_spi_header("push_pull", false);
+
+    slave_header = spi_header_get_flag_byte(spiRxFrameBuffer);
+
+    if ((slave_header == 0xFF) || (slave_header == 0x00))
+    {
+        if ( (slave_header == spiRxFrameBuffer[1])
+          && (slave_header == spiRxFrameBuffer[2])
+          && (slave_header == spiRxFrameBuffer[3])
+          && (slave_header == spiRxFrameBuffer[4])
+        ) {
+            // Device is off or in a bad state.
+            // In some cases may be induced by flow control.
+            syslog(slave_data_len == 0 ? LOG_DEBUG : LOG_WARNING, "Slave did not respond to frame. (Header was all 0x%02X)", slave_header);
+            sSpiUnresponsiveFrameCount++;
+        }
+        else
+        {
+            // Header is full of garbage
+            syslog(
+                LOG_WARNING,
+                "Garbage in header : %02X %02X %02X %02X %02X",
+                spiRxFrameBuffer[0],
+                spiRxFrameBuffer[1],
+                spiRxFrameBuffer[2],
+                spiRxFrameBuffer[3],
+                spiRxFrameBuffer[4]
+            );
+            sSpiGarbageFrameCount++;
+            if (sVerbose < LOG_DEBUG)
+            {
+                log_debug_buffer("SPI-TX", sSpiTxFrameBuffer, (int)spi_xfer_bytes + HEADER_LEN + sSpiRxAlignAllowance, true);
+                log_debug_buffer("SPI-RX", sSpiRxFrameBuffer, (int)spi_xfer_bytes + HEADER_LEN + sSpiRxAlignAllowance, true);
+            }
+        }
+        sSpiTxRefusedCount++;
+        goto bail;
+    }
+
+    slave_max_rx = spi_header_get_accept_len(spiRxFrameBuffer);
+    slave_data_len = spi_header_get_data_len(spiRxFrameBuffer);
+
+    if ( ((slave_header & SPI_HEADER_PATTERN_MASK) != SPI_HEADER_PATTERN_VALUE)
+      || (slave_max_rx > MAX_FRAME_SIZE)
+      || (slave_data_len > MAX_FRAME_SIZE)
+    )
+    {
+        sSpiGarbageFrameCount++;
+        sSpiTxRefusedCount++;
+        slave_data_len = 0;
+        syslog(
+            LOG_WARNING,
+            "Garbage in header : %02X %02X %02X %02X %02X",
+            spiRxFrameBuffer[0],
+            spiRxFrameBuffer[1],
+            spiRxFrameBuffer[2],
+            spiRxFrameBuffer[3],
+            spiRxFrameBuffer[4]
+        );
+        if (sVerbose < LOG_DEBUG)
+        {
+            log_debug_buffer("SPI-TX", sSpiTxFrameBuffer, (int)spi_xfer_bytes + HEADER_LEN + sSpiRxAlignAllowance, true);
+            log_debug_buffer("SPI-RX", sSpiRxFrameBuffer, (int)spi_xfer_bytes + HEADER_LEN + sSpiRxAlignAllowance, true);
+        }
+        goto bail;
+    }
+
+    sSpiValidFrameCount++;
+
+    if ( (slave_header & SPI_HEADER_RESET_FLAG) == SPI_HEADER_RESET_FLAG)
+    {
+        sSlaveResetCount++;
+        syslog(LOG_NOTICE, "Slave did reset (%llu resets so far)", (unsigned long long)sSlaveResetCount);
+        sSlaveDidReset = true;
+        sDumpStats = true;
+    }
+
+    // Handle received packet, if any.
+    if ( (sSpiRxPayloadSize == 0)
+      && (slave_data_len != 0)
+      && (slave_data_len <= spi_header_get_accept_len(sSpiTxFrameBuffer))
+    ) {
+        // We have received a packet. Set sSpiRxPayloadSize so that
+        // the packet will eventually get queued up by push_hdlc().
+        sSpiRxPayloadSize = slave_data_len;
+
+        slave_data_len = 0;
+
+        successful_exchanges++;
+    }
+
+    // Handle transmitted packet, if any.
+    if ( sSpiTxIsReady
+      && (sSpiTxPayloadSize == spi_header_get_data_len(sSpiTxFrameBuffer))
+    ) {
+        if (spi_header_get_data_len(sSpiTxFrameBuffer) <= slave_max_rx)
+        {
+            // Our outbound packet has been successfully transmitted. Clear
+            // sSpiTxPayloadSize and sSpiTxIsReady so that pull_hdlc() can
+            // pull another packet for us to send.
+            sSpiTxIsReady = false;
+            sSpiTxPayloadSize = 0;
+            sSpiTxRefusedCount = 0;
+            successful_exchanges++;
+        }
+        else
+        {
+            // The slave Wasn't ready for what we had to
+            // send them. Incrementing this counter will
+            // turn on rate limiting so that we
+            // don't waste a ton of CPU bombarding them
+            // with useless SPI transfers.
+            sSpiTxRefusedCount++;
+        }
+    }
+
+    if (!sSpiTxIsReady)
+    {
+        sSpiTxRefusedCount = 0;
+    }
+
+    if (successful_exchanges == 2)
+    {
+        sSpiDuplexFrameCount++;
+    }
+bail:
+    return ret;
+}
+
+static bool check_and_clear_interrupt(void)
+{
+    if (sIntGpioValueFd >= 0)
+    {
+        char value[5] = "";
+        ssize_t len;
+
+        lseek(sIntGpioValueFd, 0, SEEK_SET);
+
+        len = read(sIntGpioValueFd, value, sizeof(value)-1);
+
+        if (len < 0)
+        {
+            perror("check_and_clear_interrupt");
+            sRet = EXIT_FAILURE;
+        }
+
+        // The interrupt pin is active low.
+        return GPIO_INT_ASSERT_STATE == atoi(value);
+    }
+
+    return true;
+}
+
+/* ------------------------------------------------------------------------- */
+/* MARK: HDLC Transfer Functions */
+
+#define HDLC_BYTE_FLAG             0x7E
+#define HDLC_BYTE_ESC              0x7D
+#define HDLC_BYTE_XON              0x11
+#define HDLC_BYTE_XOFF             0x13
+#define HDLC_BYTE_SPECIAL          0xF8
+#define HDLC_ESCAPE_XFORM          0x20
+
+static uint16_t hdlc_crc16(uint16_t aFcs, uint8_t aByte)
+{
+#if 1
+    // CRC-16/CCITT, CRC-16/CCITT-TRUE, CRC-CCITT
+    // width=16 poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 check=0x2189 name="KERMIT"
+    // http://reveng.sourceforge.net/crc-catalogue/16.htm#crc.cat.kermit
+    static const uint16_t sFcsTable[256] =
+    {
+        0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
+        0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
+        0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
+        0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
+        0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
+        0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
+        0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
+        0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
+        0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
+        0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
+        0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
+        0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
+        0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
+        0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
+        0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
+        0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
+        0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
+        0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
+        0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
+        0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
+        0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
+        0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
+        0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
+        0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
+        0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
+        0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
+        0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
+        0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
+        0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
+        0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
+        0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
+        0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
+    };
+    return (aFcs >> 8) ^ sFcsTable[(aFcs ^ aByte) & 0xff];
+#else
+    // CRC-16/CCITT-FALSE, same CRC as 802.15.4
+    // width=16 poly=0x1021 init=0xffff refin=false refout=false xorout=0x0000 check=0x29b1 name="CRC-16/CCITT-FALSE"
+    // http://reveng.sourceforge.net/crc-catalogue/16.htm#crc.cat.crc-16-ccitt-false
+    aFcs = (uint16_t)((aFcs >> 8) | (aFcs << 8));
+    aFcs ^= aByte;
+    aFcs ^= ((aFcs & 0xff) >> 4);
+    aFcs ^= (aFcs << 12);
+    aFcs ^= ((aFcs & 0xff) << 5);
+    return aFcs;
+#endif
+}
+
+static bool hdlc_byte_needs_escape(uint8_t byte)
+{
+    switch(byte)
+    {
+    case HDLC_BYTE_SPECIAL:
+    case HDLC_BYTE_ESC:
+    case HDLC_BYTE_FLAG:
+    case HDLC_BYTE_XOFF:
+    case HDLC_BYTE_XON:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+static int push_hdlc(void)
+{
+    int ret = 0;
+    const uint8_t* spiRxFrameBuffer = get_real_rx_frame_start();
+    static uint8_t escaped_frame_buffer[MAX_FRAME_SIZE*2];
+    static uint16_t unescaped_frame_len;
+    static uint16_t escaped_frame_len;
+    static uint16_t escaped_frame_sent;
+
+    if (escaped_frame_len == 0)
+    {
+        if (sSlaveDidReset)
+        {
+            // Indicate an MCU reset.
+            memcpy(escaped_frame_buffer, kHdlcResetSignal, sizeof(kHdlcResetSignal));
+            escaped_frame_len = sizeof(kHdlcResetSignal);
+            sSlaveDidReset = false;
+
+            // Set this to zero, since this isn't a real frame.
+            unescaped_frame_len = 0;
+        }
+        else if (sSpiRxPayloadSize != 0)
+        {
+            // Escape the frame.
+            uint8_t c;
+            uint16_t fcs = kHdlcCrcResetValue;
+            uint16_t i;
+
+            unescaped_frame_len = sSpiRxPayloadSize;
+
+            for (i = 0; i < sSpiRxPayloadSize; i++)
+            {
+                c = spiRxFrameBuffer[i + HEADER_LEN];
+                fcs = hdlc_crc16(fcs, c);
+                if (hdlc_byte_needs_escape(c))
+                {
+                    escaped_frame_buffer[escaped_frame_len++] = HDLC_BYTE_ESC;
+                    escaped_frame_buffer[escaped_frame_len++] = c ^ HDLC_ESCAPE_XFORM;
+                }
+                else
+                {
+                    escaped_frame_buffer[escaped_frame_len++] = c;
+                }
+            }
+
+            fcs ^= 0xFFFF;
+
+            c = fcs & 0xFF;
+            if (hdlc_byte_needs_escape(c))
+            {
+                escaped_frame_buffer[escaped_frame_len++] = HDLC_BYTE_ESC;
+                escaped_frame_buffer[escaped_frame_len++] = c ^ HDLC_ESCAPE_XFORM;
+            }
+            else
+            {
+                escaped_frame_buffer[escaped_frame_len++] = c;
+            }
+
+            c = (fcs >> 8) & 0xFF;
+            if (hdlc_byte_needs_escape(c))
+            {
+                escaped_frame_buffer[escaped_frame_len++] = HDLC_BYTE_ESC;
+                escaped_frame_buffer[escaped_frame_len++] = c ^ HDLC_ESCAPE_XFORM;
+            }
+            else
+            {
+                escaped_frame_buffer[escaped_frame_len++] = c;
+            }
+
+            escaped_frame_buffer[escaped_frame_len++] = HDLC_BYTE_FLAG;
+            escaped_frame_sent = 0;
+            sSpiRxPayloadSize = 0;
+
+        }
+        else
+        {
+            // Nothing to do.
+            goto bail;
+        }
+    }
+
+    ret = (int)write(
+        sHdlcOutputFd,
+        escaped_frame_buffer + escaped_frame_sent,
+        escaped_frame_len    - escaped_frame_sent
+    );
+
+    if (ret < 0)
+    {
+        if (errno == EAGAIN)
+        {
+            ret = 0;
+        }
+        else
+        {
+            perror("push_hdlc:write");
+            syslog(LOG_ERR, "push_hdlc:write: errno=%d (%s)", errno, strerror(errno));
+        }
+        goto bail;
+    }
+
+    escaped_frame_sent += ret;
+
+    // Reset state once we have sent the entire frame.
+    if (escaped_frame_len == escaped_frame_sent)
+    {
+        escaped_frame_len = escaped_frame_sent = 0;
+
+        // Increment counter for statistics
+        sHdlcTxFrameCount++;
+        sHdlcTxFrameByteCount += unescaped_frame_len;
+    }
+
+    ret = 0;
+
+bail:
+    return ret;
+}
+
+static int pull_hdlc(void)
+{
+    int ret = 0;
+    static uint16_t fcs;
+    static bool unescape_next_byte = false;
+
+    if (!sSpiTxIsReady)
+    {
+        uint8_t byte;
+        while ((ret = (int)read(sHdlcInputFd, &byte, 1)) == 1)
+        {
+            if (sSpiTxPayloadSize >= (MAX_FRAME_SIZE - HEADER_LEN))
+            {
+                syslog(LOG_WARNING, "HDLC frame was too big");
+                unescape_next_byte = false;
+                sSpiTxPayloadSize = 0;
+                fcs = kHdlcCrcResetValue;
+
+            }
+            else if (byte == HDLC_BYTE_FLAG)
+            {
+                if (sSpiTxPayloadSize <= 2)
+                {
+                    unescape_next_byte = false;
+                    sSpiTxPayloadSize = 0;
+                    fcs = kHdlcCrcResetValue;
+                    continue;
+
+                }
+                else if (fcs != kHdlcCrcCheckValue)
+                {
+                    syslog(LOG_WARNING, "HDLC frame with bad CRC (LEN:%d, FCS:0x%04X)", sSpiTxPayloadSize, fcs);
+                    sHdlcRxBadCrcCount++;
+                    unescape_next_byte = false;
+                    sSpiTxPayloadSize = 0;
+                    fcs = kHdlcCrcResetValue;
+                    continue;
+                }
+
+                // Clip off the CRC
+                sSpiTxPayloadSize -= 2;
+
+                // Indicate that a frame is ready to go out
+                sSpiTxIsReady = true;
+
+                // Increment counters for statistics
+                sHdlcRxFrameCount++;
+                sHdlcRxFrameByteCount += sSpiTxPayloadSize;
+
+                // Clean up for the next frame
+                unescape_next_byte = false;
+                fcs = kHdlcCrcResetValue;
+                break;
+
+            }
+            else if (byte == HDLC_BYTE_ESC)
+            {
+                unescape_next_byte = true;
+                continue;
+
+            }
+            else if (hdlc_byte_needs_escape(byte))
+            {
+                // Skip all other control codes.
+                continue;
+
+            }
+            else if (unescape_next_byte)
+            {
+                byte = byte ^ HDLC_ESCAPE_XFORM;
+                unescape_next_byte = false;
+            }
+
+            fcs = hdlc_crc16(fcs, byte);
+            sSpiTxFrameBuffer[HEADER_LEN + sSpiTxPayloadSize++] = byte;
+        }
+    }
+
+    if (ret < 0)
+    {
+        if (errno == EAGAIN)
+        {
+            ret = 0;
+        }
+        else
+        {
+            perror("pull_hdlc:read");
+            syslog(LOG_ERR, "pull_hdlc:read: errno=%d (%s)", errno, strerror(errno));
+        }
+    }
+
+    return ret < 0
+        ? ret
+        : 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Raw Transfer Functions */
+
+static int push_raw(void)
+{
+    int ret = 0;
+    const uint8_t* spiRxFrameBuffer = get_real_rx_frame_start();
+    static uint8_t raw_frame_buffer[MAX_FRAME_SIZE];
+    static uint16_t raw_frame_len;
+    static uint16_t raw_frame_sent;
+
+    if (raw_frame_len == 0)
+    {
+        if (sSlaveDidReset)
+        {
+            // Indicates an MCU reset.
+            // We don't have anything to do here because
+            // raw mode doesn't have any way to signal
+            // resets out-of-band.
+            sSlaveDidReset = false;
+        }
+        else if (sSpiRxPayloadSize > 0)
+        {
+            // Read the frame into raw_frame_buffer
+            assert(sSpiRxPayloadSize <= sizeof(raw_frame_buffer));
+            memcpy(raw_frame_buffer, &spiRxFrameBuffer[HEADER_LEN], sSpiRxPayloadSize);
+            raw_frame_len = sSpiRxPayloadSize;
+            raw_frame_sent = 0;
+            sSpiRxPayloadSize = 0;
+        }
+        else
+        {
+            // Nothing to do.
+            goto bail;
+        }
+    }
+
+    ret = (int)write(
+        sHdlcOutputFd,
+        raw_frame_buffer + raw_frame_sent,
+        raw_frame_len    - raw_frame_sent
+    );
+
+    if (ret < 0)
+    {
+        if (errno == EAGAIN)
+        {
+            ret = 0;
+        }
+        else
+        {
+            perror("push_raw:write");
+            syslog(LOG_ERR, "push_raw:write: errno=%d (%s)", errno, strerror(errno));
+        }
+        goto bail;
+    }
+
+    raw_frame_sent += ret;
+
+    // Reset state once we have sent the entire frame.
+    if (raw_frame_len == raw_frame_sent)
+    {
+        // Increment counter for statistics
+        sHdlcTxFrameCount++;
+        sHdlcTxFrameByteCount += raw_frame_len;
+
+        raw_frame_len = raw_frame_sent = 0;
+    }
+
+    ret = 0;
+
+bail:
+    return ret;
+}
+
+static int pull_raw(void)
+{
+    int ret = 0;
+
+    if (!sSpiTxIsReady)
+    {
+        ret = (int)read(sHdlcInputFd, &sSpiTxFrameBuffer[HEADER_LEN], (size_t)sMTU);
+
+        if (ret < 0)
+        {
+            if (errno == EAGAIN)
+            {
+                ret = 0;
+            }
+            else
+            {
+                perror("pull_raw:read");
+                syslog(LOG_ERR, "pull_raw:read: errno=%d (%s)", errno, strerror(errno));
+            }
+
+        }
+        else if (ret > 0)
+        {
+            sSpiTxPayloadSize = (uint16_t)ret;
+            sSpiTxIsReady = true;
+
+            // Increment counters for statistics
+            sHdlcRxFrameCount++;
+            sHdlcRxFrameByteCount += sSpiTxPayloadSize;
+        }
+    }
+
+    return ret < 0
+        ? ret
+        : 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Setup Functions */
+
+static bool update_spi_mode(int x)
+{
+    sSpiMode = (uint8_t)x;
+
+    if ( (sSpiDevFd >= 0)
+      && (ioctl(sSpiDevFd, SPI_IOC_WR_MODE, &sSpiMode) < 0)
+    )
+    {
+        perror("ioctl(SPI_IOC_WR_MODE)");
+        return false;
+    }
+
+    return true;
+}
+
+static bool update_spi_speed(int x)
+{
+    sSpiSpeed = x;
+
+    if ( (sSpiDevFd >= 0)
+      && (ioctl(sSpiDevFd, SPI_IOC_WR_MAX_SPEED_HZ, &sSpiSpeed) < 0)
+    )
+    {
+        perror("ioctl(SPI_IOC_WR_MAX_SPEED_HZ)");
+        return false;
+    }
+
+    return true;
+}
+
+
+static bool setup_spi_dev(const char* path)
+{
+    int fd = -1;
+    const uint8_t spi_word_bits = 8;
+    int ret;
+    sSpiDevPath = path;
+
+    fd = open(path, O_RDWR);
+    if (fd < 0)
+    {
+        perror("open");
+        goto bail;
+    }
+
+    // Set the SPI mode.
+    ret = ioctl(fd, SPI_IOC_WR_MODE, &sSpiMode);
+    if (ret < 0)
+    {
+        perror("ioctl(SPI_IOC_WR_MODE)");
+        goto bail;
+    }
+
+    // Set the SPI clock speed.
+    ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &sSpiSpeed);
+    if (ret < 0)
+    {
+        perror("ioctl(SPI_IOC_WR_MAX_SPEED_HZ)");
+        goto bail;
+    }
+
+    // Set the SPI word size.
+    ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &spi_word_bits);
+    if (ret < 0)
+    {
+        perror("ioctl(SPI_IOC_WR_BITS_PER_WORD)");
+        goto bail;
+    }
+
+    // Lock the file descriptor
+    if (flock(fd, LOCK_EX | LOCK_NB) < 0)
+    {
+        perror("flock");
+        goto bail;
+    }
+
+    sSpiDevFd = fd;
+    fd = -1;
+
+bail:
+    if (fd >= 0)
+    {
+        close(fd);
+    }
+    return sSpiDevFd >= 0;
+}
+
+static bool setup_res_gpio(const char* path)
+{
+    int setup_fd = -1;
+    char* dir_path = NULL;
+    char* value_path = NULL;
+    int len;
+
+    sResGpioDevPath = path;
+
+    len = asprintf(&dir_path, "%s/direction", path);
+
+    if (len < 0)
+    {
+        perror("asprintf");
+        goto bail;
+    }
+
+    len = asprintf(&value_path, "%s/value", path);
+
+    if (len < 0)
+    {
+        perror("asprintf");
+        goto bail;
+    }
+
+    setup_fd = open(dir_path, O_WRONLY);
+
+    if (setup_fd >= 0)
+    {
+        if (-1 == write(setup_fd, "high\n", 5))
+        {
+            perror("set_res_direction");
+            goto bail;
+        }
+    }
+
+    sResGpioValueFd = open(value_path, O_WRONLY);
+
+bail:
+
+    if (setup_fd >= 0)
+    {
+        close(setup_fd);
+    }
+
+    if (dir_path)
+    {
+        free(dir_path);
+    }
+
+    if (value_path)
+    {
+        free(value_path);
+    }
+
+    return sResGpioValueFd >= 0;
+}
+
+static void trigger_reset(void)
+{
+    if (sResGpioValueFd >= 0)
+    {
+        char str[] = { '0' + GPIO_RES_ASSERT_STATE, '\n' };
+
+        lseek(sResGpioValueFd, 0, SEEK_SET);
+        if (write(sResGpioValueFd, str, sizeof(str)) == -1)
+        {
+            syslog(LOG_ERR, "trigger_reset(): error on write: %d (%s)", errno, strerror(errno));
+        }
+
+        usleep(10 * USEC_PER_MSEC);
+
+        // Set the string to switch to the not-asserted state.
+        str[0] = '0' + !GPIO_RES_ASSERT_STATE;
+
+        lseek(sResGpioValueFd, 0, SEEK_SET);
+        if (write(sResGpioValueFd, str, sizeof(str)) == -1)
+        {
+            syslog(LOG_ERR, "trigger_reset(): error on write: %d (%s)", errno, strerror(errno));
+        }
+
+        syslog(LOG_NOTICE, "Triggered hardware reset");
+    }
+}
+
+static bool setup_int_gpio(const char* path)
+{
+    char* edge_path = NULL;
+    char* dir_path = NULL;
+    char* value_path = NULL;
+    ssize_t len;
+    int setup_fd = -1;
+
+    sIntGpioValueFd = -1;
+
+    sIntGpioDevPath = path;
+
+    len = asprintf(&dir_path, "%s/direction", path);
+
+    if (len < 0)
+    {
+        perror("asprintf");
+        goto bail;
+    }
+
+    len = asprintf(&edge_path, "%s/edge", path);
+
+    if (len < 0)
+    {
+        perror("asprintf");
+        goto bail;
+    }
+
+    len = asprintf(&value_path, "%s/value", path);
+
+    if (len < 0)
+    {
+        perror("asprintf");
+        goto bail;
+    }
+
+    setup_fd = open(dir_path, O_WRONLY);
+
+    if (setup_fd >= 0)
+    {
+        len = write(setup_fd, "in", 2);
+        if (len < 0)
+        {
+            perror("write");
+            goto bail;
+        }
+
+        close(setup_fd);
+    }
+
+    setup_fd = open(edge_path, O_WRONLY);
+
+    if (setup_fd >= 0)
+    {
+        len = write(setup_fd, "falling", 7);
+
+        if (len < 0)
+        {
+            perror("write");
+            goto bail;
+        }
+
+        close(setup_fd);
+
+        setup_fd = -1;
+    }
+
+    sIntGpioValueFd = open(value_path, O_RDONLY);
+
+bail:
+
+    if (setup_fd >= 0)
+    {
+        close(setup_fd);
+    }
+
+    if (edge_path)
+    {
+        free(edge_path);
+    }
+
+    if (dir_path)
+    {
+        free(dir_path);
+    }
+
+    if (value_path)
+    {
+        free(value_path);
+    }
+
+    return sIntGpioValueFd >= 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Help */
+
+static void print_version(void)
+{
+    printf("spi-hdlc-adapter " SPI_HDLC_VERSION " (" __TIME__ " " __DATE__ ")\n");
+    printf("Copyright (c) 2017 The OpenThread Authors, All Rights Reserved\n");
+}
+
+static void print_help(void)
+{
+    print_version();
+    const char* help =
+    "\n"
+    "Syntax:\n"
+    "\n"
+    "    spi-hdlc [options] <spi-device-path>\n"
+    "\n"
+    "Options:\n"
+    "\n"
+    "    --stdio ...................... Use `stdin` and `stdout` for HDLC input and\n"
+    "                                   output. Useful when directly started by the\n"
+    "                                   program that will be using it.\n"
+#if HAVE_OPENPTY
+    "    --pty ........................ Create a pseudoterminal for HDLC input and\n"
+    "                                   output. The path of the newly-created PTY\n"
+    "                                   will be written to `stdout`, followed by a\n"
+    "                                   newline.\n"
+#endif // HAVE_OPENPTY
+    "    --raw ........................ Do not encode/decode packets using HDLC.\n"
+    "                                   Instead, write whole, raw frames to the\n"
+    "                                   specified input and output FDs. This is useful\n"
+    "                                   for emulating a serial port, or when datagram-\n"
+    "                                   based sockets are supplied for stdin and\n"
+    "                                   stdout` (when used with --stdio).\n"
+    "    --mtu=[MTU] .................. Specify the MTU. Currently only used in raw mode.\n"
+    "                                   Default and maximum value is 2043.\n"
+    "    -i/--gpio-int[=gpio-path] .... Specify a path to the Linux sysfs-exported\n"
+    "                                   GPIO directory for the `I̅N̅T̅` pin. If not\n"
+    "                                   specified, `spi-hdlc` will fall back to\n"
+    "                                   polling, which is inefficient.\n"
+    "    -r/--gpio-reset[=gpio-path] .. Specify a path to the Linux sysfs-exported\n"
+    "                                   GPIO directory for the `R̅E̅S̅` pin.\n"
+    "    --spi-mode[=mode] ............ Specify the SPI mode to use (0-3).\n"
+    "    --spi-speed[=hertz] .......... Specify the SPI speed in hertz.\n"
+    "    --spi-cs-delay[=usec] ........ Specify the delay after C̅S̅ assertion, in µsec\n"
+    "    --spi-align-allowance[=n] .... Specify the the maximum number of FF bytes to\n"
+    "                                   clip from start of MISO frame. Max value is 3.\n"
+    "    --spi-small-packet=[n] ....... Specify the smallest packet we can receive\n"
+    "                                   in a single transaction(larger packets will\n"
+    "                                   require two transactions). Default value is 32.\n"
+    "    -v/--verbose ................. Increase debug verbosity. (Repeatable)\n"
+    "    -h/-?/--help ................. Print out usage information and exit.\n"
+    "\n";
+
+    printf("%s", help);
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* MARK: Main Loop */
+
+int main(int argc, char *argv[])
+{
+    int i = 0;
+    char prog[32];
+    static fd_set read_set;
+    static fd_set write_set;
+    static fd_set error_set;
+    struct timeval timeout;
+    int max_fd = -1;
+    bool did_print_rate_limit_log = false;
+
+#if AUTO_PRINT_BACKTRACE
+    struct sigaction sigact;
+#endif // if AUTO_PRINT_BACKTRACE
+
+    enum {
+        ARG_SPI_MODE = 1001,
+        ARG_SPI_SPEED = 1002,
+        ARG_VERBOSE = 1003,
+        ARG_SPI_CS_DELAY = 1004,
+        ARG_SPI_ALIGN_ALLOWANCE = 1005,
+        ARG_RAW = 1006,
+        ARG_MTU = 1007,
+        ARG_SPI_SMALL_PACKET = 1008,
+    };
+
+    static struct option options[] = {
+        { "stdio",      no_argument,       &sMode, MODE_STDIO    },
+        { "pty",        no_argument,       &sMode, MODE_PTY      },
+        { "gpio-int",   required_argument, NULL,   'i'           },
+        { "gpio-res",   required_argument, NULL,   'r'           },
+        { "verbose",    optional_argument, NULL,   ARG_VERBOSE   },
+        { "version",    no_argument,       NULL,   'V'           },
+        { "raw",        no_argument,       NULL,   ARG_RAW       },
+        { "mtu",        required_argument, NULL,   ARG_MTU       },
+        { "help",       no_argument,       NULL,   'h'           },
+        { "spi-mode",   required_argument, NULL,   ARG_SPI_MODE  },
+        { "spi-speed",  required_argument, NULL,   ARG_SPI_SPEED },
+        { "spi-cs-delay",required_argument,NULL,   ARG_SPI_CS_DELAY },
+        { "spi-align-allowance", required_argument, NULL, ARG_SPI_ALIGN_ALLOWANCE },
+        { "spi-small-packet", required_argument, NULL, ARG_SPI_SMALL_PACKET },
+        { NULL,         0,                 NULL,   0             },
+    };
+
+    strncpy(prog, argv[0], sizeof(prog) - 1);
+    prog[sizeof(prog) - 1] = 0;
+
+    if (argc < 2)
+    {
+        print_help();
+        exit(EXIT_FAILURE);
+    }
+
+
+    // ========================================================================
+    // INITIALIZATION
+
+    sPreviousHandlerForSIGINT = signal(SIGINT, &signal_SIGINT);
+    sPreviousHandlerForSIGTERM = signal(SIGTERM, &signal_SIGTERM);
+    signal(SIGHUP, &signal_SIGHUP);
+    signal(SIGUSR1, &signal_dumpstats);
+    signal(SIGUSR2, &signal_clearstats);
+
+#if AUTO_PRINT_BACKTRACE
+    sigact.sa_sigaction = &signal_critical;
+    sigact.sa_flags = SA_RESTART | SA_SIGINFO | SA_NOCLDWAIT;
+
+    sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);
+    sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);
+    sigaction(SIGILL, &sigact, (struct sigaction *)NULL);
+    sigaction(SIGABRT, &sigact, (struct sigaction *)NULL);
+#endif // if AUTO_PRINT_BACKTRACE
+
+    // ========================================================================
+    // ARGUMENT PARSING
+
+    openlog(basename(prog), LOG_PERROR | LOG_PID | LOG_CONS, LOG_DAEMON);
+
+    setlogmask(LOG_UPTO(sVerbose));
+
+    while (1)
+    {
+        int c = getopt_long(argc, argv, "i:r:vVh?", options, NULL);
+        if (c == -1)
+        {
+            break;
+        }
+        else
+        {
+            switch (c)
+            {
+            case 'i':
+                if (!setup_int_gpio(optarg))
+                {
+                    syslog(LOG_ERR, "Unable to setup INT GPIO \"%s\", %s", optarg, strerror(errno));
+                    exit(EXIT_FAILURE);
+                }
+                break;
+
+            case ARG_SPI_ALIGN_ALLOWANCE:
+                errno = 0;
+                sSpiRxAlignAllowance = atoi(optarg);
+
+                if (errno != 0 || (sSpiRxAlignAllowance < 0))
+                {
+                    syslog(LOG_ERR, "Invalid SPI RX Align Allowance \"%s\"", optarg);
+                    exit(EXIT_FAILURE);
+                }
+
+                if (sSpiRxAlignAllowance > SPI_RX_ALIGN_ALLOWANCE_MAX)
+                {
+                    syslog(LOG_WARNING, "Reducing SPI RX Align Allowance from %s to %d", optarg, SPI_RX_ALIGN_ALLOWANCE_MAX);
+                    sSpiRxAlignAllowance = SPI_RX_ALIGN_ALLOWANCE_MAX;
+                }
+
+                break;
+
+            case ARG_SPI_MODE:
+                if (!update_spi_mode(atoi(optarg)))
+                {
+                    syslog(LOG_ERR, "Unable to set SPI mode to \"%s\", %s", optarg, strerror(errno));
+                    exit(EXIT_FAILURE);
+                }
+                break;
+
+            case ARG_SPI_SPEED:
+                if (!update_spi_speed(atoi(optarg)))
+                {
+                    syslog(LOG_ERR, "Unable to set SPI speed to \"%s\", %s", optarg, strerror(errno));
+                    exit(EXIT_FAILURE);
+                }
+                break;
+
+            case ARG_SPI_SMALL_PACKET:
+                sSpiSmallPacketSize = atoi(optarg);
+                if (sSpiSmallPacketSize > MAX_FRAME_SIZE - HEADER_LEN)
+                {
+                    syslog(LOG_WARNING, "Reducing SPI small-packet size from %s to %d", optarg, MAX_FRAME_SIZE - HEADER_LEN);
+                    sSpiSmallPacketSize = MAX_FRAME_SIZE - HEADER_LEN;
+                }
+                if (sSpiSmallPacketSize < 0)
+                {
+                    syslog(LOG_ERR, "The argument to --spi-small-packet cannot be negative. (Given: \"%s\")", optarg);
+                    exit(EXIT_FAILURE);
+                }
+                syslog(LOG_NOTICE, "SPI small-packet size set to %d bytes.", sSpiSmallPacketSize);
+                break;
+
+            case ARG_SPI_CS_DELAY:
+                sSpiCsDelay = atoi(optarg);
+                if (sSpiCsDelay < 0)
+                {
+                    syslog(LOG_ERR, "Negative values (%d) for --spi-cs-delay are invalid.", sSpiCsDelay);
+                    exit(EXIT_FAILURE);
+                }
+                syslog(LOG_NOTICE, "SPI CS Delay set to %d usec", sSpiCsDelay);
+                break;
+
+            case ARG_RAW:
+                sUseRawFrames = true;
+                syslog(LOG_NOTICE, "HDLC encoding/decoding disabled. Will use raw frames for input/output.");
+                break;
+
+            case ARG_MTU:
+                sMTU = atoi(optarg);
+                if (sMTU > MAX_FRAME_SIZE - HEADER_LEN)
+                {
+                    syslog(LOG_ERR, "Specified MTU of %d is too large, maximum is %d bytes.", sMTU, MAX_FRAME_SIZE - HEADER_LEN);
+                    exit(EXIT_FAILURE);
+                }
+                if (sMTU < 1)
+                {
+                    syslog(LOG_ERR, "Specified MTU of %d is too small, minimum is 1 byte.", sMTU);
+                    exit(EXIT_FAILURE);
+                }
+                syslog(LOG_NOTICE, "MTU set to %d bytes", sMTU);
+                break;
+
+            case 'r':
+                if (!setup_res_gpio(optarg))
+                {
+                    syslog(LOG_ERR, "Unable to setup RES GPIO \"%s\", %s", optarg, strerror(errno));
+                    exit(EXIT_FAILURE);
+                }
+                break;
+
+            case 'v':
+            case ARG_VERBOSE:
+                if (sVerbose < LOG_DEBUG)
+                {
+                    if (optarg)
+                    {
+                        sVerbose += atoi(optarg);
+                    }
+                    else
+                    {
+                        sVerbose++;
+                    }
+                    setlogmask(setlogmask(0) | LOG_UPTO(sVerbose));
+                    syslog(sVerbose, "Verbosity set to level %d", sVerbose);
+                }
+                break;
+
+            case 'V':
+                print_version();
+                exit(EXIT_SUCCESS);
+                break;
+
+            case 'h':
+            case '?':
+                print_help();
+                exit(EXIT_SUCCESS);
+                break;
+            }
+        }
+    }
+
+    syslog(LOG_NOTICE,"spi-hdlc-adapter " SPI_HDLC_VERSION " (" __TIME__ " " __DATE__ ")\n");
+
+    argc -= optind;
+    argv += optind;
+
+    if (argc >= 1)
+    {
+        if (!setup_spi_dev(argv[0]))
+        {
+            char spi_path[64];
+
+            strncpy(spi_path, argv[0], sizeof(spi_path) - 1);
+            spi_path[sizeof(spi_path) - 1] = 0;
+            syslog(LOG_ERR, "%s: Unable to open SPI device \"%s\", %s", prog, spi_path, strerror(errno));
+            exit(EXIT_FAILURE);
+        }
+        argc--;
+        argv++;
+    }
+
+    if (argc >= 1)
+    {
+        fprintf(stderr, "%s: Unexpected argument \"%s\"\n", prog, argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    if (sSpiDevPath == NULL)
+    {
+        fprintf(stderr, "%s: Missing SPI device path\n", prog);
+        exit(EXIT_FAILURE);
+    }
+
+    if (sMode == MODE_STDIO)
+    {
+        sHdlcInputFd = dup(STDIN_FILENO);
+        sHdlcOutputFd = dup(STDOUT_FILENO);
+        close(STDIN_FILENO);
+        close(STDOUT_FILENO);
+
+    }
+    else if (sMode == MODE_PTY)
+    {
+#if HAVE_OPENPTY
+
+        static int pty_slave_fd = -1;
+        char pty_name[1024];
+        sRet = openpty(&sHdlcInputFd, &pty_slave_fd, pty_name, NULL, NULL);
+
+        if (sRet != 0)
+        {
+            perror("openpty");
+            goto bail;
+        }
+
+        sHdlcOutputFd = dup(sHdlcInputFd);
+
+        printf("%s\n", pty_name);
+
+        close(STDOUT_FILENO);
+
+#else // if HAVE_OPENPTY
+
+        syslog(LOG_ERR, "Not built with support for `--pty`.");
+        sRet = EXIT_FAILURE;
+        goto bail;
+
+#endif // else HAVE_OPENPTY
+
+    }
+    else
+    {
+        sRet = EXIT_FAILURE;
+        goto bail;
+    }
+
+    if ((sHdlcInputFd < 0) || (sHdlcOutputFd < 0))
+    {
+        sRet = EXIT_FAILURE;
+        goto bail;
+    }
+
+    // Set up sHdlcInputFd for non-blocking I/O
+    if (-1 == (i = fcntl(sHdlcInputFd, F_GETFL, 0)))
+    {
+        i = 0;
+    }
+    IGNORE_RETURN_VALUE(fcntl(sHdlcInputFd, F_SETFL, i | O_NONBLOCK));
+
+    // Since there are so few file descriptors in
+    // this program, we calculate `max_fd` once
+    // instead of trying to optimize its value
+    // at every iteration.
+    max_fd = sHdlcInputFd;
+
+    if (max_fd < sHdlcOutputFd)
+    {
+        max_fd = sHdlcOutputFd;
+    }
+
+    if (max_fd < sIntGpioValueFd)
+    {
+        max_fd = sIntGpioValueFd;
+    }
+
+    if (sIntGpioValueFd < 0)
+    {
+        syslog(LOG_WARNING, "Interrupt pin was not set, must poll SPI. Performance will suffer.");
+    }
+
+    trigger_reset();
+
+    // ========================================================================
+    // MAIN LOOP
+
+    while (sRet == 0)
+    {
+        int timeout_ms = MSEC_PER_SEC * 60 * 60 * 24; // 24 hours
+
+        FD_ZERO(&read_set);
+        FD_ZERO(&write_set);
+        FD_ZERO(&error_set);
+
+        if (!sSpiTxIsReady)
+        {
+            FD_SET(sHdlcInputFd, &read_set);
+
+        }
+        else
+        {
+            // We have data to send to the slave.
+            timeout_ms = 0;
+        }
+
+        if (sSpiRxPayloadSize != 0)
+        {
+            // We have data that we are waiting to send out
+            // of the HDLC descriptor, so we need to wait
+            // for that to clear out before we can do anything
+            // else.
+            FD_SET(sHdlcOutputFd, &write_set);
+
+        }
+        else if (sIntGpioValueFd >= 0)
+        {
+            if (check_and_clear_interrupt())
+            {
+                // Interrupt pin is asserted,
+                // set the timeout to be 0.
+                timeout_ms = 0;
+
+                syslog(LOG_DEBUG, "Interrupt.");
+            }
+            else
+            {
+                // The interrupt pin was not asserted,
+                // so we wait for the interrupt pin to
+                // be asserted by adding it to the error
+                // set.
+                FD_SET(sIntGpioValueFd, &error_set);
+            }
+
+        }
+        else if (timeout_ms > SPI_POLL_PERIOD_MSEC)
+        {
+            // In this case we don't have an interrupt, so
+            // we revert to SPI polling.
+            timeout_ms = SPI_POLL_PERIOD_MSEC;
+        }
+
+        if (sDumpStats)
+        {
+            timeout_ms = 0;
+        }
+
+        if (sSpiTxRefusedCount)
+        {
+            // We are being rate-limited by the slave. This is
+            // fairly normal behavior. We poll because we
+            // won't get an interrupt unless the slave happens
+            // to be trying to send us something.
+            if (timeout_ms < SPI_POLL_PERIOD_MSEC)
+            {
+                timeout_ms = SPI_POLL_PERIOD_MSEC;
+            }
+
+            if ( sSpiTxIsReady
+              && !did_print_rate_limit_log
+              && (sSpiTxRefusedCount > 1)
+            ) {
+                // To avoid printing out this message over and over,
+                // we only print it out once the refused count is at
+                // two or higher when we actually have something to
+                // send the slave. And then, we only print it once.
+                syslog(LOG_INFO, "Slave is rate limiting transactions");
+
+                did_print_rate_limit_log = true;
+            }
+
+            if (sSpiTxRefusedCount == 30)
+            {
+                // Ua-oh. The slave hasn't given us a chance to send
+                // it anything for over thirty frames. If this ever
+                // happens, print out a warning to the logs.
+                syslog(LOG_WARNING, "Slave seems stuck.");
+            }
+
+            if (sSpiTxRefusedCount == 100)
+            {
+                // Double ua-oh. The slave hasn't given us a chance
+                // to send it anything for over a hundred frames.
+                // This almost certainly means that the slave has
+                // locked up or gotten into an unrecoverable state.
+                // It is not spi-hdlc-adapter's job to identify and
+                // reset misbehaving devices (that is handled at a
+                // higher level), but we go ahead and log the condition
+                // for debugging purposes.
+                syslog(LOG_ERR, "Slave seems REALLY stuck.");
+            }
+        }
+        else
+        {
+            did_print_rate_limit_log = false;
+        }
+
+        // Calculate the timeout value.
+        timeout.tv_sec = timeout_ms / MSEC_PER_SEC;
+        timeout.tv_usec = (timeout_ms % MSEC_PER_SEC) * USEC_PER_MSEC;
+
+        // Wait for something to happen.
+        IGNORE_RETURN_VALUE(select(max_fd + 1, &read_set, &write_set, &error_set, &timeout));
+
+        if (sDumpStats || sRet != 0)
+        {
+            sDumpStats = false;
+            syslog(LOG_NOTICE, "INFO: sSlaveResetCount=%llu", (unsigned long long)sSlaveResetCount);
+            syslog(LOG_NOTICE, "INFO: sSpiFrameCount=%llu", (unsigned long long)sSpiFrameCount);
+            syslog(LOG_NOTICE, "INFO: sSpiValidFrameCount=%llu", (unsigned long long)sSpiValidFrameCount);
+            syslog(LOG_NOTICE, "INFO: sSpiDuplexFrameCount=%llu", (unsigned long long)sSpiDuplexFrameCount);
+            syslog(LOG_NOTICE, "INFO: sSpiUnresponsiveFrameCount=%llu", (unsigned long long)sSpiUnresponsiveFrameCount);
+            syslog(LOG_NOTICE, "INFO: sSpiGarbageFrameCount=%llu", (unsigned long long)sSpiGarbageFrameCount);
+            syslog(LOG_NOTICE, "INFO: sHdlcTxFrameCount=%llu", (unsigned long long)sHdlcTxFrameCount);
+            syslog(LOG_NOTICE, "INFO: sHdlcTxFrameByteCount=%llu", (unsigned long long)sHdlcTxFrameByteCount);
+            syslog(LOG_NOTICE, "INFO: sHdlcRxFrameCount=%llu", (unsigned long long)sHdlcRxFrameCount);
+            syslog(LOG_NOTICE, "INFO: sHdlcRxFrameByteCount=%llu", (unsigned long long)sHdlcRxFrameByteCount);
+            syslog(LOG_NOTICE, "INFO: sHdlcRxBadCrcCount=%llu", (unsigned long long)sHdlcRxBadCrcCount);
+        }
+
+        // Handle serial input.
+        if (FD_ISSET(sHdlcInputFd, &read_set))
+        {
+            // Read in the data.
+            if ((sUseRawFrames ? pull_raw() : pull_hdlc()) < 0)
+            {
+                sRet = EXIT_FAILURE;
+                break;
+            }
+        }
+
+        // Handle serial output.
+        if (FD_ISSET(sHdlcOutputFd, &write_set))
+        {
+            // Write out the data.
+            if ((sUseRawFrames ? push_raw() : push_hdlc()) < 0)
+            {
+                sRet = EXIT_FAILURE;
+                break;
+            }
+
+            continue;
+        }
+
+        // Service the SPI port if we can receive
+        // a packet or we have a packet to be sent.
+        if ( (sSpiRxPayloadSize == 0)
+          && (sSpiTxIsReady || check_and_clear_interrupt())
+        ) {
+            // We guard this with the above check because we don't
+            // want to overwrite any previously received (but not
+            // yet pushed out) frames.
+            if (push_pull_spi() < 0)
+            {
+                sRet = EXIT_FAILURE;
+            }
+        }
+    }
+
+
+    // ========================================================================
+    // SHUTDOWN
+
+bail:
+    syslog(LOG_NOTICE, "Shutdown. (sRet = %d)", sRet);
+
+    if (sRet == EXIT_QUIT)
+    {
+        sRet = EXIT_SUCCESS;
+    }
+    else if (sRet == -1)
+    {
+        sRet = EXIT_FAILURE;
+    }
+
+    return sRet;
+}