From 38ec3bc57476c6fde45cd7d722370a5408fd8e10 Mon Sep 17 00:00:00 2001
From: Dan Halbert <halbert@halwitz.org>
Date: Tue, 21 Apr 2020 17:37:22 -0400
Subject: further ringbuf cleanup

---
 py/py.mk     |   1 +
 py/ringbuf.c | 109 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 py/ringbuf.h |  82 ++++++++------------------------------------
 3 files changed, 125 insertions(+), 67 deletions(-)
 create mode 100644 py/ringbuf.c

(limited to 'py')

diff --git a/py/py.mk b/py/py.mk
index bca6ac14c..29d407f7a 100644
--- a/py/py.mk
+++ b/py/py.mk
@@ -257,6 +257,7 @@ PY_CORE_O_BASENAME = $(addprefix py/,\
 	repl.o \
 	smallint.o \
 	frozenmod.o \
+	ringbuf.o \
 	)
 
 PY_EXTMOD_O_BASENAME = \
diff --git a/py/ringbuf.c b/py/ringbuf.c
new file mode 100644
index 000000000..70245461f
--- /dev/null
+++ b/py/ringbuf.c
@@ -0,0 +1,109 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Paul Sokolovsky
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "ringbuf.h"
+
+// Dynamic initialization. This should be accessible from a root pointer.
+// capacity is the number of bytes the ring buffer can hold. The actual
+// size of the buffer is one greater than that, due to how the buffer
+// handles empty and full statuses.
+bool ringbuf_alloc(ringbuf_t *r, size_t capacity, bool long_lived) {
+    r->buf = gc_alloc(capacity + 1, false, long_lived);
+    r->size = capacity +  1;
+    r->iget = r->iput = 0;
+    return r->buf != NULL;
+}
+
+size_t ringbuf_capacity(ringbuf_t *r) {
+    return r->size - 1;
+}
+
+// Returns -1 if buffer is empty, else returns byte fetched.
+int ringbuf_get(ringbuf_t *r) {
+    if (r->iget == r->iput) {
+        return -1;
+    }
+    uint8_t v = r->buf[r->iget++];
+    if (r->iget >= r->size) {
+        r->iget = 0;
+    }
+    return v;
+}
+
+// Returns -1 if no room in buffer, else returns 0.
+int ringbuf_put(ringbuf_t *r, uint8_t v) {
+    uint32_t iput_new = r->iput + 1;
+    if (iput_new >= r->size) {
+        iput_new = 0;
+    }
+    if (iput_new == r->iget) {
+        return -1;
+    }
+    r->buf[r->iput] = v;
+    r->iput = iput_new;
+    return 0;
+}
+
+void ringbuf_clear(ringbuf_t *r) {
+    r->iput = r->iget = 0;
+}
+
+// Number of free slots that can be written.
+size_t ringbuf_free(ringbuf_t *r) {
+    return (r->size + r->iget - r->iput - 1) % r->size;
+}
+
+// Number of bytes available to read.
+size_t ringbuf_avail(ringbuf_t *r) {
+    return (r->size + r->iput - r->iget) % r->size;
+}
+
+// If the ring buffer fills up, not all bytes will be written.
+// Returns how many bytes were successfully written.
+size_t ringbuf_put_n(ringbuf_t* r, uint8_t* buf, size_t bufsize)
+{
+    for(size_t i=0; i < bufsize; i++) {
+        if ( ringbuf_put(r, buf[i]) < 0 ) {
+            // If ringbuf is full, give up and return how many bytes
+            // we wrote so far.
+            return i;
+        }
+    }
+    return bufsize;
+}
+
+// Returns how many bytes were fetched.
+size_t ringbuf_get_n(ringbuf_t* r, uint8_t* buf, size_t bufsize)
+{
+    for(size_t i=0; i < bufsize; i++) {
+        int b = ringbuf_get(r);
+        if (b < 0) {
+            return i;
+        }
+        buf[i] = b;
+    }
+    return bufsize;
+}
diff --git a/py/ringbuf.h b/py/ringbuf.h
index 7fc35d266..1e01091ab 100644
--- a/py/ringbuf.h
+++ b/py/ringbuf.h
@@ -32,78 +32,26 @@
 
 typedef struct _ringbuf_t {
     uint8_t *buf;
-    uint16_t size;
-    uint16_t iget;
-    uint16_t iput;
+    // Allocated size; capacity is one less. Don't reference this directly.
+    uint32_t size;
+    uint32_t iget;
+    uint32_t iput;
 } ringbuf_t;
 
+// Note that the capacity of the buffer is N-1!
+
 // Static initialization:
 // byte buf_array[N];
 // ringbuf_t buf = {buf_array, sizeof(buf_array)};
 
-// Dynamic initialization. This creates root pointer!
-#define ringbuf_alloc(r, sz, long_lived)                   \
-{ \
-    (r)->buf = gc_alloc(sz, false, long_lived);   \
-    (r)->size = sz; \
-    (r)->iget = (r)->iput = 0; \
-}
-
-static inline int ringbuf_get(ringbuf_t *r) {
-    if (r->iget == r->iput) {
-        return -1;
-    }
-    uint8_t v = r->buf[r->iget++];
-    if (r->iget >= r->size) {
-        r->iget = 0;
-    }
-    return v;
-}
-
-static inline int ringbuf_put(ringbuf_t *r, uint8_t v) {
-    uint32_t iput_new = r->iput + 1;
-    if (iput_new >= r->size) {
-        iput_new = 0;
-    }
-    if (iput_new == r->iget) {
-        return -1;
-    }
-    r->buf[r->iput] = v;
-    r->iput = iput_new;
-    return 0;
-}
-
-static inline uint16_t ringbuf_count(ringbuf_t *r)
-{
-    volatile int count = r->iput - r->iget;
-    if ( count < 0 ) {
-        count += r->size;
-    }
-
-    return (uint16_t) count;
-}
-
-static inline void ringbuf_clear(ringbuf_t *r)
-{
-    r->iput = r->iget = 0;
-}
-
-// will overwrite old data
-static inline void ringbuf_put_n(ringbuf_t* r, uint8_t* buf, uint8_t bufsize)
-{
-    for(uint8_t i=0; i < bufsize; i++) {
-        if ( ringbuf_put(r, buf[i]) < 0 ) {
-            // if full overwrite old data
-            (void) ringbuf_get(r);
-            ringbuf_put(r, buf[i]);
-        }
-    }
-}
+bool ringbuf_alloc(ringbuf_t *r, size_t capacity, bool long_lived);
+size_t ringbuf_capacity(ringbuf_t *r);
+int ringbuf_get(ringbuf_t *r);
+int ringbuf_put(ringbuf_t *r, uint8_t v);
+void ringbuf_clear(ringbuf_t *r);
+size_t ringbuf_free(ringbuf_t *r);
+size_t ringbuf_avail(ringbuf_t *r);
+size_t ringbuf_put_n(ringbuf_t* r, uint8_t* buf, size_t bufsize);
+size_t ringbuf_get_n(ringbuf_t* r, uint8_t* buf, size_t bufsize);
 
-static inline void ringbuf_get_n(ringbuf_t* r, uint8_t* buf, uint8_t bufsize)
-{
-    for(uint8_t i=0; i < bufsize; i++) {
-        buf[i] = ringbuf_get(r);
-    }
-}
 #endif // MICROPY_INCLUDED_PY_RINGBUF_H
-- 
cgit v1.2.3


From fbc8719fadbffd9b3e4ba1ceb42182c4370d0621 Mon Sep 17 00:00:00 2001
From: Dan Halbert <halbert@halwitz.org>
Date: Tue, 21 Apr 2020 22:40:12 -0400
Subject: ringbuf tested

---
 ports/mimxrt10xx/common-hal/busio/UART.c           | 11 +++---
 ports/mimxrt10xx/common-hal/busio/UART.h           |  2 +-
 ports/nrf/common-hal/_bleio/CharacteristicBuffer.c |  4 +-
 ports/nrf/common-hal/_bleio/PacketBuffer.c         | 43 ++++++++++------------
 ports/nrf/common-hal/busio/UART.c                  | 21 ++++-------
 ports/nrf/common-hal/busio/UART.h                  |  2 +-
 ports/stm/common-hal/busio/UART.c                  | 18 ++++-----
 ports/stm/common-hal/busio/UART.h                  |  2 +-
 py/ringbuf.c                                       | 10 ++++-
 py/ringbuf.h                                       |  5 ++-
 shared-module/_bleio/ScanResults.c                 |  6 +--
 11 files changed, 59 insertions(+), 65 deletions(-)

(limited to 'py')

diff --git a/ports/mimxrt10xx/common-hal/busio/UART.c b/ports/mimxrt10xx/common-hal/busio/UART.c
index 399f12e70..e3642daf5 100644
--- a/ports/mimxrt10xx/common-hal/busio/UART.c
+++ b/ports/mimxrt10xx/common-hal/busio/UART.c
@@ -198,9 +198,10 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
       claim_pin(self->tx_pin->pin);
 
     if (self->rx_pin != NULL) {
-        ringbuf_alloc(&self->rbuf, receiver_buffer_size, true);
+        // The LPUART ring buffer wastes one byte to distinguish between full and empty.
+        self->ringbuf = gc_alloc(receiver_buffer_size + 1, false, true /*long-lived*/);
 
-        if (!self->rbuf.buf) {
+        if (!self->ringbuf) {
             LPUART_Deinit(self->uart);
             mp_raise_msg(&mp_type_MemoryError, translate("Failed to allocate RX buffer"));
         }
@@ -208,7 +209,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
         LPUART_TransferCreateHandle(self->uart, &self->handle, LPUART_UserCallback, self);
         // Pass actual allocated size; the LPUART routines are cognizant that
         // the capacity is one less than the size.
-        LPUART_TransferStartRingBuffer(self->uart, &self->handle, self->rbuf.buf, self->rbuf.size);
+        LPUART_TransferStartRingBuffer(self->uart, &self->handle, self->ringbuf, receiver_buffer_size + 1);
 
         claim_pin(self->rx_pin->pin);
     }
@@ -225,9 +226,7 @@ void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
 
     LPUART_Deinit(self->uart);
 
-    gc_free(self->rbuf.buf);
-    self->rbuf.size = 0;
-    self->rbuf.iput = self->rbuf.iget = 0;
+    gc_free(self->ringbuf);
 
 //    reset_pin_number(self->rx_pin);
 //    reset_pin_number(self->tx_pin);
diff --git a/ports/mimxrt10xx/common-hal/busio/UART.h b/ports/mimxrt10xx/common-hal/busio/UART.h
index 9e768db3c..3a326eb3a 100644
--- a/ports/mimxrt10xx/common-hal/busio/UART.h
+++ b/ports/mimxrt10xx/common-hal/busio/UART.h
@@ -40,7 +40,7 @@ typedef struct {
     mp_obj_base_t base;
     LPUART_Type *uart;
     lpuart_handle_t handle;
-    ringbuf_t rbuf;
+    uint8_t* ringbuf;
     bool rx_ongoing;
     uint32_t baudrate;
     uint8_t character_bits;
diff --git a/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c b/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c
index 12fd73670..84e776121 100644
--- a/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c
+++ b/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c
@@ -102,7 +102,7 @@ uint32_t common_hal_bleio_characteristic_buffer_read(bleio_characteristic_buffer
     uint64_t start_ticks = supervisor_ticks_ms64();
 
     // Wait for all bytes received or timeout
-    while ( (ringbuf_avail(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ( (ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
         RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
         if ( mp_hal_is_interrupted() ) {
@@ -125,7 +125,7 @@ uint32_t common_hal_bleio_characteristic_buffer_read(bleio_characteristic_buffer
 uint32_t common_hal_bleio_characteristic_buffer_rx_characters_available(bleio_characteristic_buffer_obj_t *self) {
     uint8_t is_nested_critical_region;
     sd_nvic_critical_region_enter(&is_nested_critical_region);
-    uint16_t count = ringbuf_avail(&self->ringbuf);
+    uint16_t count = ringbuf_num_filled(&self->ringbuf);
     sd_nvic_critical_region_exit(is_nested_critical_region);
     return count;
 }
diff --git a/ports/nrf/common-hal/_bleio/PacketBuffer.c b/ports/nrf/common-hal/_bleio/PacketBuffer.c
index 269853219..29fd86cda 100644
--- a/ports/nrf/common-hal/_bleio/PacketBuffer.c
+++ b/ports/nrf/common-hal/_bleio/PacketBuffer.c
@@ -51,7 +51,7 @@ STATIC void write_to_ringbuf(bleio_packet_buffer_obj_t *self, uint8_t *data, uin
     uint8_t is_nested_critical_region;
     sd_nvic_critical_region_enter(&is_nested_critical_region);
     // Make room for the new value by dropping the oldest packets first.
-    while (ringbuf_capacity(&self->ringbuf) - ringbuf_avail(&self->ringbuf) < len + sizeof(uint16_t)) {
+    while (ringbuf_capacity(&self->ringbuf) - ringbuf_num_filled(&self->ringbuf) < len + sizeof(uint16_t)) {
         uint16_t packet_length;
         ringbuf_get_n(&self->ringbuf, (uint8_t*) &packet_length, sizeof(uint16_t));
         for (uint16_t i = 0; i < packet_length; i++) {
@@ -202,10 +202,7 @@ void common_hal_bleio_packet_buffer_construct(
     }
 
     if (incoming) {
-        // This is a macro.
-        ringbuf_alloc(&self->ringbuf, buffer_size * (sizeof(uint16_t) + characteristic->max_length), false);
-
-        if (self->ringbuf.buf == NULL) {
+        if (!ringbuf_alloc(&self->ringbuf, buffer_size * (sizeof(uint16_t) + characteristic->max_length), false)) {
             mp_raise_ValueError(translate("Buffer too large and unable to allocate"));
         }
     }
@@ -250,7 +247,7 @@ void common_hal_bleio_packet_buffer_construct(
 }
 
 int common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self, uint8_t *data, size_t len) {
-    if (ringbuf_avail(&self->ringbuf) < 2) {
+    if (ringbuf_num_filled(&self->ringbuf) < 2) {
         return 0;
     }
 
@@ -315,25 +312,25 @@ void common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, uint8
 }
 
 uint16_t common_hal_bleio_packet_buffer_get_packet_size(bleio_packet_buffer_obj_t *self) {
-    uint16_t mtu;
-    if (self->conn_handle == BLE_CONN_HANDLE_INVALID) {
-        return 0;
-    }
-    bleio_connection_internal_t *connection;
-    for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
-        connection = &bleio_connections[i];
-        if (connection->conn_handle == self->conn_handle) {
-            break;
+    // First, assume default MTU size.
+    uint16_t mtu = BLE_GATT_ATT_MTU_DEFAULT;
+
+    // If there's a connection, get its actual MTU.
+    if (self->conn_handle != BLE_CONN_HANDLE_INVALID) {
+        bleio_connection_internal_t *connection;
+        for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+            connection = &bleio_connections[i];
+            if (connection->conn_handle == self->conn_handle) {
+                if (connection->mtu != 0) {
+                    mtu = connection->mtu;
+                }
+                break;
+            }
         }
     }
-    if (connection->mtu == 0) {
-        mtu = BLE_GATT_ATT_MTU_DEFAULT;
-    }
-    if (self->characteristic->max_length > mtu) {
-        mtu = self->characteristic->max_length;
-    }
-    uint16_t att_overhead = 3;
-    return mtu - att_overhead;
+
+    // 3 is bytes of ATT overhead.
+    return MIN(mtu - 3, self->characteristic->max_length);
 }
 
 bool common_hal_bleio_packet_buffer_deinited(bleio_packet_buffer_obj_t *self) {
diff --git a/ports/nrf/common-hal/busio/UART.c b/ports/nrf/common-hal/busio/UART.c
index 43f155ca8..d223ea91f 100644
--- a/ports/nrf/common-hal/busio/UART.c
+++ b/ports/nrf/common-hal/busio/UART.c
@@ -99,7 +99,7 @@ static void uart_callback_irq (const nrfx_uarte_event_t * event, void * context)
 
     switch ( event->type ) {
         case NRFX_UARTE_EVT_RX_DONE:
-            ringbuf_put_n(&self->rbuf, event->data.rxtx.p_data, event->data.rxtx.bytes);
+            ringbuf_put_n(&self->ringbuf, event->data.rxtx.p_data, event->data.rxtx.bytes);
 
             // keep receiving
             (void) nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
@@ -113,7 +113,7 @@ static void uart_callback_irq (const nrfx_uarte_event_t * event, void * context)
             // Possible Error source is Overrun, Parity, Framing, Break
             // uint32_t errsrc = event->data.error.error_mask;
 
-            ringbuf_put_n(&self->rbuf, event->data.error.rxtx.p_data, event->data.error.rxtx.bytes);
+            ringbuf_put_n(&self->ringbuf, event->data.error.rxtx.p_data, event->data.error.rxtx.bytes);
 
             // Keep receiving
             (void) nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
@@ -191,9 +191,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
         // pointers like this are NOT moved, allocating the buffer
         // in the long-lived pool is not strictly necessary)
         // (This is a macro.)
-        ringbuf_alloc(&self->rbuf, receiver_buffer_size, true);
-
-        if ( !self->rbuf.buf ) {
+        if (!ringbuf_alloc(&self->ringbuf, receiver_buffer_size, true)) {
             nrfx_uarte_uninit(self->uarte);
             mp_raise_msg(&mp_type_MemoryError, translate("Failed to allocate RX buffer"));
         }
@@ -227,10 +225,7 @@ void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
         reset_pin_number(self->rx_pin_number);
         self->tx_pin_number = NO_PIN;
         self->rx_pin_number = NO_PIN;
-
-        gc_free(self->rbuf.buf);
-        self->rbuf.size = 0;
-        self->rbuf.iput = self->rbuf.iget = 0;
+        ringbuf_free(&self->ringbuf);
     }
 }
 
@@ -243,7 +238,7 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
     uint64_t start_ticks = supervisor_ticks_ms64();
 
     // Wait for all bytes received or timeout
-    while ( (ringbuf_avail(&self->rbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ( (ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
         RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
         if ( mp_hal_is_interrupted() ) {
@@ -255,7 +250,7 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
     NVIC_DisableIRQ(nrfx_get_irq_number(self->uarte->p_reg));
 
     // Copy as much received data as available, up to len bytes.
-    size_t rx_bytes = ringbuf_get_n(&self->rbuf, data, len);
+    size_t rx_bytes = ringbuf_get_n(&self->ringbuf, data, len);
 
     NVIC_EnableIRQ(nrfx_get_irq_number(self->uarte->p_reg));
 
@@ -312,13 +307,13 @@ void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeou
 }
 
 uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *self) {
-    return ringbuf_avail(&self->rbuf);
+    return ringbuf_num_filled(&self->ringbuf);
 }
 
 void common_hal_busio_uart_clear_rx_buffer(busio_uart_obj_t *self) {
     // prevent conflict with uart irq
     NVIC_DisableIRQ(nrfx_get_irq_number(self->uarte->p_reg));
-    ringbuf_clear(&self->rbuf);
+    ringbuf_clear(&self->ringbuf);
     NVIC_EnableIRQ(nrfx_get_irq_number(self->uarte->p_reg));
 }
 
diff --git a/ports/nrf/common-hal/busio/UART.h b/ports/nrf/common-hal/busio/UART.h
index 58432001c..a25116291 100644
--- a/ports/nrf/common-hal/busio/UART.h
+++ b/ports/nrf/common-hal/busio/UART.h
@@ -41,7 +41,7 @@ typedef struct {
     uint32_t baudrate;
     uint32_t timeout_ms;
 
-    ringbuf_t rbuf;
+    ringbuf_t ringbuf;
     uint8_t rx_char; // EasyDMA buf
 
     uint8_t tx_pin_number;
diff --git a/ports/stm/common-hal/busio/UART.c b/ports/stm/common-hal/busio/UART.c
index d1ee146f1..566955cd8 100644
--- a/ports/stm/common-hal/busio/UART.c
+++ b/ports/stm/common-hal/busio/UART.c
@@ -211,8 +211,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
 
     // Init buffer for rx and claim pins
     if (self->rx != NULL) {
-        ringbuf_alloc(&self->rbuf, receiver_buffer_size, true);
-        if (!self->rbuf.buf) {
+        if (!ringbuf_alloc(&self->ringbuf, receiver_buffer_size, true)) {
             mp_raise_ValueError(translate("UART Buffer allocation error"));
         }
         claim_pin(rx);
@@ -248,9 +247,7 @@ void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
     reset_pin_number(self->rx->pin->port,self->rx->pin->number);
     self->tx = NULL;
     self->rx = NULL;
-    gc_free(self->rbuf.buf);
-    self->rbuf.size = 0;
-    self->rbuf.iput = self->rbuf.iget = 0;
+    ringbuf_free(&self->ringbuf);
 }
 
 size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t len, int *errcode) {
@@ -258,11 +255,10 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
         mp_raise_ValueError(translate("No RX pin"));
     }
 
-    size_t rx_bytes = 0;
     uint64_t start_ticks = supervisor_ticks_ms64();
 
     // Wait for all bytes received or timeout, same as nrf
-    while ( (ringbuf_avail(&self->rbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ( (ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
         RUN_BACKGROUND_TASKS;
         //restart if it failed in the callback
         if (errflag != HAL_OK) {
@@ -277,7 +273,7 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
     // Halt reception
     HAL_NVIC_DisableIRQ(self->irq);
     // Copy as much received data as available, up to len bytes.
-    size_t rx_bytes = ringbuf_get_n(&self->rbuf, data, len);
+    size_t rx_bytes = ringbuf_get_n(&self->ringbuf, data, len);
     HAL_NVIC_EnableIRQ(self->irq);
 
     if (rx_bytes == 0) {
@@ -317,7 +313,7 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *handle)
             if ((HAL_UART_GetState(handle) & HAL_UART_STATE_BUSY_RX) == HAL_UART_STATE_BUSY_RX) {
                 return;
             }
-            ringbuf_put_n(&context->rbuf, &context->rx_char, 1);
+            ringbuf_put_n(&context->ringbuf, &context->rx_char, 1);
             errflag = HAL_UART_Receive_IT(handle, &context->rx_char, 1);
 
             return;
@@ -376,13 +372,13 @@ void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeou
 }
 
 uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *self) {
-    return ringbuf_avail(&self->rbuf);
+    return ringbuf_num_filled(&self->ringbuf);
 }
 
 void common_hal_busio_uart_clear_rx_buffer(busio_uart_obj_t *self) {
     // Halt reception
     HAL_NVIC_DisableIRQ(self->irq);
-    ringbuf_clear(&self->rbuf);
+    ringbuf_clear(&self->ringbuf);
     HAL_NVIC_EnableIRQ(self->irq);
 }
 
diff --git a/ports/stm/common-hal/busio/UART.h b/ports/stm/common-hal/busio/UART.h
index 5ac1d352c..d1971ce27 100644
--- a/ports/stm/common-hal/busio/UART.h
+++ b/ports/stm/common-hal/busio/UART.h
@@ -47,7 +47,7 @@ typedef struct {
     const mcu_periph_obj_t *tx;
     const mcu_periph_obj_t *rx;
 
-    ringbuf_t rbuf;
+    ringbuf_t ringbuf;
     uint8_t rx_char;
 
     uint32_t baudrate;
diff --git a/py/ringbuf.c b/py/ringbuf.c
index 70245461f..c19f1d44b 100644
--- a/py/ringbuf.c
+++ b/py/ringbuf.c
@@ -37,6 +37,12 @@ bool ringbuf_alloc(ringbuf_t *r, size_t capacity, bool long_lived) {
     return r->buf != NULL;
 }
 
+void ringbuf_free(ringbuf_t *r) {
+    gc_free(r->buf);
+    r->size = 0;
+    ringbuf_clear(r);
+}
+
 size_t ringbuf_capacity(ringbuf_t *r) {
     return r->size - 1;
 }
@@ -72,12 +78,12 @@ void ringbuf_clear(ringbuf_t *r) {
 }
 
 // Number of free slots that can be written.
-size_t ringbuf_free(ringbuf_t *r) {
+size_t ringbuf_num_empty(ringbuf_t *r) {
     return (r->size + r->iget - r->iput - 1) % r->size;
 }
 
 // Number of bytes available to read.
-size_t ringbuf_avail(ringbuf_t *r) {
+size_t ringbuf_num_filled(ringbuf_t *r) {
     return (r->size + r->iput - r->iget) % r->size;
 }
 
diff --git a/py/ringbuf.h b/py/ringbuf.h
index 1e01091ab..476bd428f 100644
--- a/py/ringbuf.h
+++ b/py/ringbuf.h
@@ -45,12 +45,13 @@ typedef struct _ringbuf_t {
 // ringbuf_t buf = {buf_array, sizeof(buf_array)};
 
 bool ringbuf_alloc(ringbuf_t *r, size_t capacity, bool long_lived);
+void ringbuf_free(ringbuf_t *r);
 size_t ringbuf_capacity(ringbuf_t *r);
 int ringbuf_get(ringbuf_t *r);
 int ringbuf_put(ringbuf_t *r, uint8_t v);
 void ringbuf_clear(ringbuf_t *r);
-size_t ringbuf_free(ringbuf_t *r);
-size_t ringbuf_avail(ringbuf_t *r);
+size_t ringbuf_num_empty(ringbuf_t *r);
+size_t ringbuf_num_filled(ringbuf_t *r);
 size_t ringbuf_put_n(ringbuf_t* r, uint8_t* buf, size_t bufsize);
 size_t ringbuf_get_n(ringbuf_t* r, uint8_t* buf, size_t bufsize);
 
diff --git a/shared-module/_bleio/ScanResults.c b/shared-module/_bleio/ScanResults.c
index 2e6fd07ff..ae36f8863 100644
--- a/shared-module/_bleio/ScanResults.c
+++ b/shared-module/_bleio/ScanResults.c
@@ -45,10 +45,10 @@ bleio_scanresults_obj_t* shared_module_bleio_new_scanresults(size_t buffer_size,
 }
 
 mp_obj_t common_hal_bleio_scanresults_next(bleio_scanresults_obj_t *self) {
-    while (ringbuf_avail(&self->buf) == 0 && !self->done && !mp_hal_is_interrupted()) {
+    while (ringbuf_num_filled(&self->buf) == 0 && !self->done && !mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
     }
-    if (ringbuf_avail(&self->buf) == 0 || mp_hal_is_interrupted()) {
+    if (ringbuf_num_filled(&self->buf) == 0 || mp_hal_is_interrupted()) {
         return mp_const_none;
     }
 
@@ -97,7 +97,7 @@ void shared_module_bleio_scanresults_append(bleio_scanresults_obj_t* self,
                                             uint16_t len) {
     int32_t packet_size = sizeof(uint8_t) + sizeof(ticks_ms) + sizeof(rssi) + NUM_BLEIO_ADDRESS_BYTES +
         sizeof(addr_type) + sizeof(len) + len;
-    int32_t empty_space = self->buf.size - ringbuf_avail(&self->buf);
+    int32_t empty_space = self->buf.size - ringbuf_num_filled(&self->buf);
     if (packet_size >= empty_space) {
         // We can't fit the packet so skip it.
         return;
-- 
cgit v1.2.3


From 241d7e2ae69100c972b7e843050e0808de83358c Mon Sep 17 00:00:00 2001
From: Dan Halbert <halbert@halwitz.org>
Date: Wed, 29 Apr 2020 23:31:34 -0400
Subject: change many ifndefs to ?=

---
 ports/nrf/mpconfigport.mk |  36 ++------
 py/circuitpy_mpconfig.mk  | 210 ++++++++++++----------------------------------
 2 files changed, 61 insertions(+), 185 deletions(-)

(limited to 'py')

diff --git a/ports/nrf/mpconfigport.mk b/ports/nrf/mpconfigport.mk
index 04110ffd2..58ab44282 100644
--- a/ports/nrf/mpconfigport.mk
+++ b/ports/nrf/mpconfigport.mk
@@ -14,39 +14,21 @@ USB_SERIAL_NUMBER_LENGTH = 16
 # All nRF ports have longints.
 LONGINT_IMPL = MPZ
 
-# Audio via PWM
-ifndef CIRCUITPY_AUDIOCORE
-CIRCUITPY_AUDIOCORE = 1
-endif
+# The ?='s allow overriding in mpconfigboard.mk.
 
+# Audio via PWM
 CIRCUITPY_AUDIOIO = 0
+CIRCUITPY_AUDIOBUSIO ?= 1
+CIRCUITPY_AUDIOCORE ?= 1
+CIRCUITPY_AUDIOMIXER ?= 1
+CIRCUITPY_AUDIOPWMIO ?= 1
 
-
-# The ifndef's allow overriding in mpconfigboard.mk.
-
-ifndef CIRCUITPY_BLEIO
-CIRCUITPY_BLEIO = 1
-endif
-
-ifndef CIRCUITPY_AUDIOMIXER
-CIRCUITPY_AUDIOMIXER = 1
-endif
-
-ifndef CIRCUITPY_AUDIOPWMIO
-CIRCUITPY_AUDIOPWMIO = 1
-endif
-
-ifndef CIRCUITPY_AUDIOBUSIO
-CIRCUITPY_AUDIOBUSIO = 1
-endif
+CIRCUITPY_BLEIO ?= 1
 
 # No I2CSlave implementation
 CIRCUITPY_I2CSLAVE = 0
 
-# enable RTC
-ifndef CIRCUITPY_RTC
-CIRCUITPY_RTC = 1
-endif
+CIRCUITPY_RTC ?= 1
 
 # frequencyio not yet implemented
 CIRCUITPY_FREQUENCYIO = 0
@@ -72,8 +54,6 @@ NRF_DEFINES += -DNRF52840_XXAA -DNRF52840
 # Defined here because system_nrf52840.c doesn't #include any of our own include files.
 CFLAGS += -DCONFIG_NFCT_PINS_AS_GPIOS
 
-CIRCUITPY_ULAB = 1
-
 else
 ifeq ($(MCU_CHIP),nrf52833)
 MCU_SERIES = m4
diff --git a/py/circuitpy_mpconfig.mk b/py/circuitpy_mpconfig.mk
index 30ab720d7..c0943230c 100644
--- a/py/circuitpy_mpconfig.mk
+++ b/py/circuitpy_mpconfig.mk
@@ -27,37 +27,25 @@
 # Manually disable by overriding in #mpconfigboard.mk
 
 # Smaller builds can be forced for resource constrained chips (typically SAMD21s
-# without external flash) by setting CIRCUITPY_FULL_BUILD=0. Avoid using this 
+# without external flash) by setting CIRCUITPY_FULL_BUILD=0. Avoid using this
 # for merely incomplete ports, as it changes settings in other files.
-ifndef CIRCUITPY_FULL_BUILD
-    CIRCUITPY_FULL_BUILD = 1
-endif
+CIRCUITPY_FULL_BUILD ?= 1
 CFLAGS += -DCIRCUITPY_FULL_BUILD=$(CIRCUITPY_FULL_BUILD)
 
 
-ifndef CIRCUITPY_ANALOGIO
-CIRCUITPY_ANALOGIO = 1
-endif
+CIRCUITPY_ANALOGIO ?= 1
 CFLAGS += -DCIRCUITPY_ANALOGIO=$(CIRCUITPY_ANALOGIO)
 
-ifndef CIRCUITPY_AUDIOBUSIO
-CIRCUITPY_AUDIOBUSIO = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_AUDIOBUSIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_AUDIOBUSIO=$(CIRCUITPY_AUDIOBUSIO)
 
-ifndef CIRCUITPY_AUDIOIO
-CIRCUITPY_AUDIOIO = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_AUDIOIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_AUDIOIO=$(CIRCUITPY_AUDIOIO)
 
-ifndef CIRCUITPY_AUDIOIO_COMPAT
-CIRCUITPY_AUDIOIO_COMPAT = $(CIRCUITPY_AUDIOIO)
-endif
+CIRCUITPY_AUDIOIO_COMPAT ?= $(CIRCUITPY_AUDIOIO)
 CFLAGS += -DCIRCUITPY_AUDIOIO_COMPAT=$(CIRCUITPY_AUDIOIO_COMPAT)
 
-ifndef CIRCUITPY_AUDIOPWMIO
-CIRCUITPY_AUDIOPWMIO = 0
-endif
+CIRCUITPY_AUDIOPWMIO ?= 0
 CFLAGS += -DCIRCUITPY_AUDIOPWMIO=$(CIRCUITPY_AUDIOPWMIO)
 
 ifndef CIRCUITPY_AUDIOCORE
@@ -69,9 +57,7 @@ endif
 endif
 CFLAGS += -DCIRCUITPY_AUDIOCORE=$(CIRCUITPY_AUDIOCORE)
 
-ifndef CIRCUITPY_AUDIOMIXER
-CIRCUITPY_AUDIOMIXER = $(CIRCUITPY_AUDIOIO)
-endif
+CIRCUITPY_AUDIOMIXER ?= $(CIRCUITPY_AUDIOIO)
 CFLAGS += -DCIRCUITPY_AUDIOMIXER=$(CIRCUITPY_AUDIOMIXER)
 
 ifndef CIRCUITPY_AUDIOMP3
@@ -83,246 +69,156 @@ endif
 endif
 CFLAGS += -DCIRCUITPY_AUDIOMP3=$(CIRCUITPY_AUDIOMP3)
 
-ifndef CIRCUITPY_BITBANGIO
-CIRCUITPY_BITBANGIO = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_BITBANGIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_BITBANGIO=$(CIRCUITPY_BITBANGIO)
 
 # Explicitly enabled for boards that support _bleio.
-ifndef CIRCUITPY_BLEIO
-CIRCUITPY_BLEIO = 0
-endif
+CIRCUITPY_BLEIO ?= 0
 CFLAGS += -DCIRCUITPY_BLEIO=$(CIRCUITPY_BLEIO)
 
-ifndef CIRCUITPY_BOARD
-CIRCUITPY_BOARD = 1
-endif
+CIRCUITPY_BOARD ?= 1
 CFLAGS += -DCIRCUITPY_BOARD=$(CIRCUITPY_BOARD)
 
-ifndef CIRCUITPY_BUSIO
-CIRCUITPY_BUSIO = 1
-endif
+CIRCUITPY_BUSIO ?= 1
 CFLAGS += -DCIRCUITPY_BUSIO=$(CIRCUITPY_BUSIO)
 
-ifndef CIRCUITPY_DIGITALIO
-CIRCUITPY_DIGITALIO = 1
-endif
+CIRCUITPY_DIGITALIO ?= 1
 CFLAGS += -DCIRCUITPY_DIGITALIO=$(CIRCUITPY_DIGITALIO)
 
-ifndef CIRCUITPY_DISPLAYIO
-CIRCUITPY_DISPLAYIO = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_DISPLAYIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_DISPLAYIO=$(CIRCUITPY_DISPLAYIO)
 
-ifndef CIRCUITPY_FRAMEBUFFERIO
-CIRCUITPY_FRAMEBUFFERIO = 0
-endif
+CIRCUITPY_FRAMEBUFFERIO ?= 0
 CFLAGS += -DCIRCUITPY_FRAMEBUFFERIO=$(CIRCUITPY_FRAMEBUFFERIO)
 
-ifndef CIRCUITPY_FREQUENCYIO
-CIRCUITPY_FREQUENCYIO = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_FREQUENCYIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_FREQUENCYIO=$(CIRCUITPY_FREQUENCYIO)
 
-ifndef CIRCUITPY_GAMEPAD
-CIRCUITPY_GAMEPAD = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_GAMEPAD ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_GAMEPAD=$(CIRCUITPY_GAMEPAD)
 
-ifndef CIRCUITPY_GAMEPADSHIFT
-CIRCUITPY_GAMEPADSHIFT = 0
-endif
+CIRCUITPY_GAMEPADSHIFT ?= 0
 CFLAGS += -DCIRCUITPY_GAMEPADSHIFT=$(CIRCUITPY_GAMEPADSHIFT)
 
-ifndef CIRCUITPY_I2CSLAVE
-CIRCUITPY_I2CSLAVE = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_I2CSLAVE ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_I2CSLAVE=$(CIRCUITPY_I2CSLAVE)
 
-ifndef CIRCUITPY_MATH
-CIRCUITPY_MATH = 1
-endif
+CIRCUITPY_MATH ?= 1
 CFLAGS += -DCIRCUITPY_MATH=$(CIRCUITPY_MATH)
 
-ifndef CIRCUITPY__EVE
-CIRCUITPY__EVE = 0
-endif
+CIRCUITPY__EVE ?= 0
 CFLAGS += -DCIRCUITPY__EVE=$(CIRCUITPY__EVE)
 
-ifndef CIRCUITPY_MICROCONTROLLER
-CIRCUITPY_MICROCONTROLLER = 1
-endif
+CIRCUITPY_MICROCONTROLLER ?= 1
 CFLAGS += -DCIRCUITPY_MICROCONTROLLER=$(CIRCUITPY_MICROCONTROLLER)
 
-ifndef CIRCUITPY_NEOPIXEL_WRITE
-CIRCUITPY_NEOPIXEL_WRITE = 1
-endif
+CIRCUITPY_NEOPIXEL_WRITE ?= 1
 CFLAGS += -DCIRCUITPY_NEOPIXEL_WRITE=$(CIRCUITPY_NEOPIXEL_WRITE)
 
 # Enabled on SAMD51. Won't fit on SAMD21 builds. Not tested on nRF or STM32F4 builds.
-ifndef CIRCUITPY_NETWORK
-CIRCUITPY_NETWORK = 0
-endif
+CIRCUITPY_NETWORK ?= 0
 CFLAGS += -DCIRCUITPY_NETWORK=$(CIRCUITPY_NETWORK)
 
-ifndef CIRCUITPY_NVM
-CIRCUITPY_NVM = 1
-endif
+CIRCUITPY_NVM ?= 1
 CFLAGS += -DCIRCUITPY_NVM=$(CIRCUITPY_NVM)
 
-ifndef CIRCUITPY_OS
-CIRCUITPY_OS = 1
-endif
+CIRCUITPY_OS ?= 1
 CFLAGS += -DCIRCUITPY_OS=$(CIRCUITPY_OS)
 
-ifndef CIRCUITPY_PIXELBUF
-CIRCUITPY_PIXELBUF = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_PIXELBUF ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_PIXELBUF=$(CIRCUITPY_PIXELBUF)
 
 # Only for SAMD boards for the moment
-ifndef CIRCUITPY_RGBMATRIX
-CIRCUITPY_RGBMATRIX = 0
-endif
+CIRCUITPY_RGBMATRIX ?= 0
 CFLAGS += -DCIRCUITPY_RGBMATRIX=$(CIRCUITPY_RGBMATRIX)
 
-ifndef CIRCUITPY_PULSEIO
-CIRCUITPY_PULSEIO = 1
-endif
+CIRCUITPY_PULSEIO ?= 1
 CFLAGS += -DCIRCUITPY_PULSEIO=$(CIRCUITPY_PULSEIO)
 
 # Only for SAMD boards for the moment
-ifndef CIRCUITPY_PS2IO
-CIRCUITPY_PS2IO = 0
-endif
+CIRCUITPY_PS2IO ?= 0
 CFLAGS += -DCIRCUITPY_PS2IO=$(CIRCUITPY_PS2IO)
 
-ifndef CIRCUITPY_RANDOM
-CIRCUITPY_RANDOM = 1
-endif
+CIRCUITPY_RANDOM ?= 1
 CFLAGS += -DCIRCUITPY_RANDOM=$(CIRCUITPY_RANDOM)
 
-ifndef CIRCUITPY_ROTARYIO
-CIRCUITPY_ROTARYIO = 1
-endif
+CIRCUITPY_ROTARYIO ?= 1
 CFLAGS += -DCIRCUITPY_ROTARYIO=$(CIRCUITPY_ROTARYIO)
 
-ifndef CIRCUITPY_RTC
-CIRCUITPY_RTC = 1
-endif
+CIRCUITPY_RTC ?= 1
 CFLAGS += -DCIRCUITPY_RTC=$(CIRCUITPY_RTC)
 
 # CIRCUITPY_SAMD is handled in the atmel-samd tree.
 # Only for SAMD chips.
 # Assume not a SAMD build.
-ifndef CIRCUITPY_SAMD
-CIRCUITPY_SAMD = 0
-endif
+CIRCUITPY_SAMD ?= 0
 CFLAGS += -DCIRCUITPY_SAMD=$(CIRCUITPY_SAMD)
 
 # Currently always off.
-ifndef CIRCUITPY_STAGE
-CIRCUITPY_STAGE = 0
-endif
+CIRCUITPY_STAGE ?= 0
 CFLAGS += -DCIRCUITPY_STAGE=$(CIRCUITPY_STAGE)
 
-ifndef CIRCUITPY_STORAGE
-CIRCUITPY_STORAGE = 1
-endif
+CIRCUITPY_STORAGE ?= 1
 CFLAGS += -DCIRCUITPY_STORAGE=$(CIRCUITPY_STORAGE)
 
-ifndef CIRCUITPY_STRUCT
-CIRCUITPY_STRUCT = 1
-endif
+CIRCUITPY_STRUCT ?= 1
 CFLAGS += -DCIRCUITPY_STRUCT=$(CIRCUITPY_STRUCT)
 
-ifndef CIRCUITPY_SUPERVISOR
-CIRCUITPY_SUPERVISOR = 1
-endif
+CIRCUITPY_SUPERVISOR ?= 1
 CFLAGS += -DCIRCUITPY_SUPERVISOR=$(CIRCUITPY_SUPERVISOR)
 
-ifndef CIRCUITPY_TIME
-CIRCUITPY_TIME = 1
-endif
+CIRCUITPY_TIME ?= 1
 CFLAGS += -DCIRCUITPY_TIME=$(CIRCUITPY_TIME)
 
 # touchio might be native or generic. See circuitpy_defns.mk.
-ifndef CIRCUITPY_TOUCHIO_USE_NATIVE
-CIRCUITPY_TOUCHIO_USE_NATIVE = 0
-endif
+CIRCUITPY_TOUCHIO_USE_NATIVE ?= 0
 CFLAGS += -DCIRCUITPY_TOUCHIO_USE_NATIVE=$(CIRCUITPY_TOUCHIO_USE_NATIVE)
 
-ifndef CIRCUITPY_TOUCHIO
-CIRCUITPY_TOUCHIO = 1
-endif
+CIRCUITPY_TOUCHIO ?= 1
 CFLAGS += -DCIRCUITPY_TOUCHIO=$(CIRCUITPY_TOUCHIO)
 
 # For debugging.
-ifndef CIRCUITPY_UHEAP
-CIRCUITPY_UHEAP = 0
-endif
+CIRCUITPY_UHEAP ?= 0
 CFLAGS += -DCIRCUITPY_UHEAP=$(CIRCUITPY_UHEAP)
 
-ifndef CIRCUITPY_USB_HID
-CIRCUITPY_USB_HID = 1
-endif
+CIRCUITPY_USB_HID ?= 1
 CFLAGS += -DCIRCUITPY_USB_HID=$(CIRCUITPY_USB_HID)
 
-ifndef CIRCUITPY_USB_MIDI
-CIRCUITPY_USB_MIDI = 1
-endif
+CIRCUITPY_USB_MIDI ?= 1
 CFLAGS += -DCIRCUITPY_USB_MIDI=$(CIRCUITPY_USB_MIDI)
 
-ifndef CIRCUITPY_PEW
-CIRCUITPY_PEW = 0
-endif
+CIRCUITPY_PEW ?= 0
 CFLAGS += -DCIRCUITPY_PEW=$(CIRCUITPY_PEW)
 
 # For debugging.
-ifndef CIRCUITPY_USTACK
-CIRCUITPY_USTACK = 0
-endif
+CIRCUITPY_USTACK ?= 0
 CFLAGS += -DCIRCUITPY_USTACK=$(CIRCUITPY_USTACK)
 
 # Non-module conditionals
 
-ifndef CIRCUITPY_BITBANG_APA102
-CIRCUITPY_BITBANG_APA102 = 0
-endif
+CIRCUITPY_BITBANG_APA102 ?= 0
 CFLAGS += -DCIRCUITPY_BITBANG_APA102=$(CIRCUITPY_BITBANG_APA102)
 
 # Should busio.I2C() check for pullups?
 # Some boards in combination with certain peripherals may not want this.
-ifndef CIRCUITPY_REQUIRE_I2C_PULLUPS
-CIRCUITPY_REQUIRE_I2C_PULLUPS = 1
-endif
+CIRCUITPY_REQUIRE_I2C_PULLUPS ?= 1
 CFLAGS += -DCIRCUITPY_REQUIRE_I2C_PULLUPS=$(CIRCUITPY_REQUIRE_I2C_PULLUPS)
 
 # REPL over BLE
-ifndef CIRCUITPY_SERIAL_BLE
-CIRCUITPY_SERIAL_BLE = 0
-endif
+CIRCUITPY_SERIAL_BLE ?= 0
 CFLAGS += -DCIRCUITPY_SERIAL_BLE=$(CIRCUITPY_SERIAL_BLE)
 
-ifndef CIRCUITPY_BLE_FILE_SERVICE
-CIRCUITPY_BLE_FILE_SERVICE = 0
-endif
+CIRCUITPY_BLE_FILE_SERVICE ?= 0
 CFLAGS += -DCIRCUITPY_BLE_FILE_SERVICE=$(CIRCUITPY_BLE_FILE_SERVICE)
 
 # REPL over UART
-ifndef CIRCUITPY_SERIAL_UART
-CIRCUITPY_SERIAL_UART = 0
-endif
+CIRCUITPY_SERIAL_UART ?= 0
 CFLAGS += -DCIRCUITPY_SERIAL_UART=$(CIRCUITPY_SERIAL_UART)
 
 # ulab numerics library
-ifndef CIRCUITPY_ULAB
-CIRCUITPY_ULAB = $(CIRCUITPY_FULL_BUILD)
-endif
+CIRCUITPY_ULAB ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_ULAB=$(CIRCUITPY_ULAB)
 
 # Enabled micropython.native decorator (experimental)
-ifndef CIRCUITPY_ENABLE_MPY_NATIVE
-CIRCUITPY_ENABLE_MPY_NATIVE = 0
-endif
+CIRCUITPY_ENABLE_MPY_NATIVE ?= 0
 CFLAGS += -DCIRCUITPY_ENABLE_MPY_NATIVE=$(CIRCUITPY_ENABLE_MPY_NATIVE)
-- 
cgit v1.2.3


From b168784fa0fd97b17807836b390c79abaadfa8e4 Mon Sep 17 00:00:00 2001
From: Sean Cross <sean@xobs.io>
Date: Tue, 14 Apr 2020 11:18:45 +0800
Subject: aesio: add basic AES encryption and decryption

This adds initial support for an AES module named aesio.  This
implementation supports only a subset of AES modes, namely
ECB, CBC, and CTR modes.

Example usage:

```
>>> import aesio
>>>
>>> key = b'Sixteen byte key'
>>> cipher = aesio.AES(key, aesio.MODE_ECB)
>>> output = bytearray(16)
>>> cipher.encrypt_into(b'Circuit Python!!', output)
>>> output
bytearray(b'E\x14\x85\x18\x9a\x9c\r\x95>\xa7kV\xa2`\x8b\n')
>>>
```

This key is 16-bytes, so it uses AES128.  If your key is 24- or 32-
bytes long, it will switch to AES192 or AES256 respectively.

This has been tested with many of the official NIST test vectors,
such as those used in `pycryptodome` at
https://github.com/Legrandin/pycryptodome/tree/39626a5b01ce5c1cf51d022be166ad0aea722177/lib/Crypto/SelfTest/Cipher/test_vectors/AES

CTR has not been tested as NIST does not provide test vectors for it.

Signed-off-by: Sean Cross <sean@xobs.io>
---
 py/circuitpy_defns.mk            |   5 +
 py/circuitpy_mpconfig.h          |   8 +
 py/circuitpy_mpconfig.mk         |   3 +
 shared-bindings/aesio/__init__.c |  79 +++++
 shared-bindings/aesio/__init__.h |  53 ++++
 shared-bindings/aesio/aes.c      | 271 +++++++++++++++++
 shared-module/aesio/__init__.c   |  58 ++++
 shared-module/aesio/__init__.h   |  59 ++++
 shared-module/aesio/aes.c        | 608 +++++++++++++++++++++++++++++++++++++++
 shared-module/aesio/aes.h        | 105 +++++++
 10 files changed, 1249 insertions(+)
 create mode 100644 shared-bindings/aesio/__init__.c
 create mode 100644 shared-bindings/aesio/__init__.h
 create mode 100644 shared-bindings/aesio/aes.c
 create mode 100644 shared-module/aesio/__init__.c
 create mode 100644 shared-module/aesio/__init__.h
 create mode 100644 shared-module/aesio/aes.c
 create mode 100644 shared-module/aesio/aes.h

(limited to 'py')

diff --git a/py/circuitpy_defns.mk b/py/circuitpy_defns.mk
index ec8e6c3e9..e3892d98e 100644
--- a/py/circuitpy_defns.mk
+++ b/py/circuitpy_defns.mk
@@ -99,6 +99,9 @@ endif
 ###
 # Select which builtin modules to compile and include.
 
+ifeq ($(CIRCUITPY_AESIO),1)
+SRC_PATTERNS += aesio/%
+endif
 ifeq ($(CIRCUITPY_ANALOGIO),1)
 SRC_PATTERNS += analogio/%
 endif
@@ -341,6 +344,8 @@ SRC_SHARED_MODULE_ALL = \
 	bitbangio/__init__.c \
 	board/__init__.c \
 	busio/OneWire.c \
+	aesio/__init__.c \
+	aesio/aes.c \
 	displayio/Bitmap.c \
 	displayio/ColorConverter.c \
 	displayio/Display.c \
diff --git a/py/circuitpy_mpconfig.h b/py/circuitpy_mpconfig.h
index 29a4d524c..6b7fc192f 100644
--- a/py/circuitpy_mpconfig.h
+++ b/py/circuitpy_mpconfig.h
@@ -223,6 +223,13 @@ typedef long mp_off_t;
 // These CIRCUITPY_xxx values should all be defined in the *.mk files as being on or off.
 // So if any are not defined in *.mk, they'll throw an error here.
 
+#if CIRCUITPY_AESIO
+extern const struct _mp_obj_module_t aesio_module;
+#define AESIO_MODULE       { MP_OBJ_NEW_QSTR(MP_QSTR_aesio), (mp_obj_t)&aesio_module },
+#else
+#define AESIO_MODULE
+#endif
+
 #if CIRCUITPY_ANALOGIO
 #define ANALOGIO_MODULE        { MP_OBJ_NEW_QSTR(MP_QSTR_analogio), (mp_obj_t)&analogio_module },
 extern const struct _mp_obj_module_t analogio_module;
@@ -619,6 +626,7 @@ extern const struct _mp_obj_module_t ustack_module;
 // Some of these definitions will be blank depending on what is turned on and off.
 // Some are omitted because they're in MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS above.
 #define MICROPY_PORT_BUILTIN_MODULES_STRONG_LINKS \
+    AESIO_MODULE \
     ANALOGIO_MODULE \
     AUDIOBUSIO_MODULE \
     AUDIOCORE_MODULE \
diff --git a/py/circuitpy_mpconfig.mk b/py/circuitpy_mpconfig.mk
index c0943230c..105253aec 100644
--- a/py/circuitpy_mpconfig.mk
+++ b/py/circuitpy_mpconfig.mk
@@ -33,6 +33,9 @@ CIRCUITPY_FULL_BUILD ?= 1
 CFLAGS += -DCIRCUITPY_FULL_BUILD=$(CIRCUITPY_FULL_BUILD)
 
 
+CIRCUITPY_AESIO ?= 0
+CFLAGS += -DCIRCUITPY_AESIO=$(CIRCUITPY_AESIO)
+
 CIRCUITPY_ANALOGIO ?= 1
 CFLAGS += -DCIRCUITPY_ANALOGIO=$(CIRCUITPY_ANALOGIO)
 
diff --git a/shared-bindings/aesio/__init__.c b/shared-bindings/aesio/__init__.c
new file mode 100644
index 000000000..43dc73e8b
--- /dev/null
+++ b/shared-bindings/aesio/__init__.c
@@ -0,0 +1,79 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+
+#include "__init__.h"
+
+//| :mod:`aesio` --- AES encryption routines
+//| ========================================
+//|
+//| .. module:: aesio
+//|   :synopsis: Embedded implementation of AES
+//|
+//| The `AES` module contains classes used to implement encryption
+//| and decryption. It aims to be low overhead in terms of memory.
+//|
+//|
+
+//| Libraries
+//|
+//| .. toctree::
+//|     :maxdepth: 3
+//|
+//|     aes
+
+
+STATIC const mp_obj_tuple_t mp_aes_key_size_obj = {
+    {&mp_type_tuple},
+    3,
+    {
+        MP_OBJ_NEW_SMALL_INT(16),
+        MP_OBJ_NEW_SMALL_INT(24),
+        MP_OBJ_NEW_SMALL_INT(32),
+    }
+};
+
+STATIC const mp_rom_map_elem_t aesio_module_globals_table[] = {
+    {MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_aesio)},
+    {MP_ROM_QSTR(MP_QSTR_AES), MP_ROM_PTR(&aesio_aes_type) },
+    {MP_ROM_QSTR(MP_QSTR_MODE_ECB), MP_ROM_INT(AES_MODE_ECB)},
+    {MP_ROM_QSTR(MP_QSTR_MODE_CBC), MP_ROM_INT(AES_MODE_CBC)},
+    {MP_ROM_QSTR(MP_QSTR_MODE_CTR), MP_ROM_INT(AES_MODE_CTR)},
+    {MP_ROM_QSTR(MP_QSTR_block_size), MP_ROM_INT(AES_BLOCKLEN)},
+    {MP_ROM_QSTR(MP_QSTR_key_size), (mp_obj_t)&mp_aes_key_size_obj},
+};
+
+STATIC MP_DEFINE_CONST_DICT(aesio_module_globals, aesio_module_globals_table);
+
+const mp_obj_module_t aesio_module = {
+    .base = {&mp_type_module},
+    .globals = (mp_obj_dict_t *)&aesio_module_globals,
+};
+
diff --git a/shared-bindings/aesio/__init__.h b/shared-bindings/aesio/__init__.h
new file mode 100644
index 000000000..634fed2e5
--- /dev/null
+++ b/shared-bindings/aesio/__init__.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_AESIO_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_AESIO_H
+
+#include "shared-module/aesio/__init__.h"
+
+extern const mp_obj_type_t aesio_aes_type;
+
+void common_hal_aesio_aes_construct(aesio_aes_obj_t* self,
+                              const uint8_t* key,
+                              uint32_t key_length,
+                              const uint8_t* iv,
+                              int mode,
+                              int counter);
+void common_hal_aesio_aes_rekey(aesio_aes_obj_t* self,
+                          const uint8_t* key,
+                          uint32_t key_length,
+                          const uint8_t* iv);
+void common_hal_aesio_aes_set_mode(aesio_aes_obj_t* self,
+                             int mode);
+void common_hal_aesio_aes_encrypt(aesio_aes_obj_t* self,
+                            uint8_t* buffer,
+                            size_t len);
+void common_hal_aesio_aes_decrypt(aesio_aes_obj_t* self,
+                            uint8_t* buffer,
+                            size_t len);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_AESIO_H
diff --git a/shared-bindings/aesio/aes.c b/shared-bindings/aesio/aes.c
new file mode 100644
index 000000000..4ddcfa898
--- /dev/null
+++ b/shared-bindings/aesio/aes.c
@@ -0,0 +1,271 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "py/obj.h"
+#include "py/objproperty.h"
+#include "py/runtime.h"
+
+#include "shared-bindings/aesio/__init__.h"
+
+// Defined at the end of this file
+
+//| .. currentmodule:: aesio
+//|
+//| :class:`aesio` -- Encrypt and decrypt AES streams
+//| =====================================================
+//|
+//| An object that represents an AES stream, including the current state.
+//|
+//| .. class:: AES(key, mode=0, iv=None, segment_size=8)
+//|
+//|   Create a new AES state with the given key.
+//|
+//|   :param bytearray key: A 16-, 24-, or 32-byte key
+//|   :param int mode: AES mode to use.  One of: AES.MODE_ECB, AES.MODE_CBC, or
+//|                    AES.MODE_CTR
+//|   :param bytearray iv: Initialization vector to use for CBC or CTR mode
+//|
+//|   Additional arguments are supported for legacy reasons.
+//|
+//|   Encrypting a string::
+//|
+//|     import aesio
+//|     from binascii import hexlify
+//|
+//|     key = b'Sixteen byte key'
+//|     inp = b'Circuit Python!!' # Note: 16-bytes long
+//|     outp = bytearray(len(inp))
+//|     cipher = aesio.AES(key, aesio.mode.MODE_ECB)
+//|     cipher.encrypt_into(inp, outp)
+//|     hexlify(outp)
+//|
+
+STATIC mp_obj_t aesio_aes_make_new(const mp_obj_type_t *type, size_t n_args,
+                                   const mp_obj_t *pos_args,
+                                   mp_map_t *kw_args) {
+  (void)type;
+  enum { ARG_key, ARG_mode, ARG_IV, ARG_counter, ARG_segment_size };
+  static const mp_arg_t allowed_args[] = {
+      {MP_QSTR_key, MP_ARG_OBJ | MP_ARG_REQUIRED},
+      {MP_QSTR_mode, MP_ARG_INT, {.u_int = AES_MODE_ECB}},
+      {MP_QSTR_IV, MP_ARG_OBJ},
+      {MP_QSTR_counter, MP_ARG_OBJ},
+      {MP_QSTR_segment_size, MP_ARG_INT, {.u_int = 8}},
+  };
+  mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+
+  mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args),
+                   allowed_args, args);
+
+  aesio_aes_obj_t *self = m_new_obj(aesio_aes_obj_t);
+  self->base.type = &aesio_aes_type;
+
+  mp_buffer_info_t bufinfo;
+
+  const uint8_t *key = NULL;
+  uint32_t key_length = 0;
+  if (mp_get_buffer(args[ARG_key].u_obj, &bufinfo, MP_BUFFER_READ)) {
+    if ((bufinfo.len != 16) && (bufinfo.len != 24) && (bufinfo.len != 32)) {
+      mp_raise_TypeError(translate("Key must be 16, 24, or 32 bytes long"));
+    }
+    key = bufinfo.buf;
+    key_length = bufinfo.len;
+  } else {
+    mp_raise_TypeError(translate("No key was specified"));
+  }
+
+  int mode = args[ARG_mode].u_int;
+  switch (args[ARG_mode].u_int) {
+  case AES_MODE_CBC:
+  case AES_MODE_ECB:
+  case AES_MODE_CTR:
+    break;
+  default:
+    mp_raise_TypeError(translate("Requested AES mode is unsupported"));
+  }
+
+  // IV is required for CBC mode and is ignored for other modes.
+  const uint8_t *iv = NULL;
+  if (args[ARG_IV].u_obj != NULL &&
+      mp_get_buffer(args[ARG_IV].u_obj, &bufinfo, MP_BUFFER_READ)) {
+    if (bufinfo.len != AES_BLOCKLEN) {
+      mp_raise_TypeError_varg(translate("IV must be %d bytes long"),
+                              AES_BLOCKLEN);
+    }
+    iv = bufinfo.buf;
+  }
+
+  common_hal_aesio_aes_construct(self, key, key_length, iv, mode,
+                                 args[ARG_counter].u_int);
+  return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t aesio_aes_rekey(size_t n_args, const mp_obj_t *pos_args) {
+  aesio_aes_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+
+  size_t key_length = 0;
+  const uint8_t *key =
+      (const uint8_t *)mp_obj_str_get_data(pos_args[1], &key_length);
+  if (key == NULL) {
+    mp_raise_ValueError(translate("No key was specified"));
+  }
+  if ((key_length != 16) && (key_length != 24) && (key_length != 32)) {
+    mp_raise_TypeError(translate("Key must be 16, 24, or 32 bytes long"));
+  }
+
+  const uint8_t *iv = NULL;
+  if (n_args > 2) {
+    size_t iv_length = 0;
+    iv = (const uint8_t *)mp_obj_str_get_data(pos_args[2], &iv_length);
+    if (iv_length != AES_BLOCKLEN) {
+      mp_raise_TypeError_varg(translate("IV must be %d bytes long"),
+                              AES_BLOCKLEN);
+    }
+  }
+
+  common_hal_aesio_aes_rekey(self, key, key_length, iv);
+  return mp_const_none;
+}
+
+MP_DEFINE_CONST_FUN_OBJ_VAR(aesio_aes_rekey_obj, 2, aesio_aes_rekey);
+
+STATIC void validate_length(aesio_aes_obj_t *self, size_t src_length,
+                            size_t dest_length) {
+  if (src_length != dest_length) {
+    mp_raise_ValueError(
+        translate("Source and destination buffers must be the same length"));
+  }
+
+  switch (self->mode) {
+  case AES_MODE_ECB:
+    if (src_length != 16) {
+      mp_raise_msg(&mp_type_ValueError,
+                   translate("ECB only operates on 16 bytes at a time"));
+    }
+    break;
+  case AES_MODE_CBC:
+    if ((src_length & 15) != 0) {
+      mp_raise_msg(&mp_type_ValueError,
+                   translate("CBC blocks must be multiples of 16 bytes"));
+    }
+    break;
+  case AES_MODE_CTR:
+    break;
+  }
+}
+
+//|   .. method:: encrypt_into(src, dest)
+//|
+//|      Encrypt the buffer from ``src`` into ``dest``.
+//|      For ECB mode, the buffers must be 16 bytes long.  For CBC mode, the
+//|      buffers must be a multiple of 16 bytes, and must be equal length.  For
+//|      CTX mode, there are no restrictions.
+//|
+STATIC mp_obj_t aesio_aes_encrypt_into(mp_obj_t aesio_obj, mp_obj_t src,
+                                       mp_obj_t dest) {
+  if (!MP_OBJ_IS_TYPE(aesio_obj, &aesio_aes_type)) {
+    mp_raise_TypeError_varg(translate("Expected a %q"), aesio_aes_type.name);
+  }
+  // Convert parameters into expected types.
+  aesio_aes_obj_t *aes = MP_OBJ_TO_PTR(aesio_obj);
+
+  mp_buffer_info_t srcbufinfo, destbufinfo;
+  mp_get_buffer_raise(src, &srcbufinfo, MP_BUFFER_READ);
+  mp_get_buffer_raise(dest, &destbufinfo, MP_BUFFER_READ);
+  validate_length(aes, srcbufinfo.len, destbufinfo.len);
+
+  memcpy(destbufinfo.buf, srcbufinfo.buf, srcbufinfo.len);
+
+  common_hal_aesio_aes_encrypt(aes, (uint8_t *)destbufinfo.buf,
+                               destbufinfo.len);
+  return mp_const_none;
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(aesio_aes_encrypt_into_obj,
+                                 aesio_aes_encrypt_into);
+
+//|   .. method:: decrypt_into(src, dest)
+//|
+//|      Decrypt the buffer from ``src`` into ``dest``.
+//|      For ECB mode, the buffers must be 16 bytes long.  For CBC mode, the
+//|      buffers must be a multiple of 16 bytes, and must be equal length.  For
+//|      CTX mode, there are no restrictions.
+//|
+STATIC mp_obj_t aesio_aes_decrypt_into(mp_obj_t aesio_obj, mp_obj_t src,
+                                       mp_obj_t dest) {
+  if (!MP_OBJ_IS_TYPE(aesio_obj, &aesio_aes_type)) {
+    mp_raise_TypeError_varg(translate("Expected a %q"), aesio_aes_type.name);
+  }
+  // Convert parameters into expected types.
+  aesio_aes_obj_t *aes = MP_OBJ_TO_PTR(aesio_obj);
+
+  mp_buffer_info_t srcbufinfo, destbufinfo;
+  mp_get_buffer_raise(src, &srcbufinfo, MP_BUFFER_READ);
+  mp_get_buffer_raise(dest, &destbufinfo, MP_BUFFER_READ);
+  validate_length(aes, srcbufinfo.len, destbufinfo.len);
+
+  memcpy(destbufinfo.buf, srcbufinfo.buf, srcbufinfo.len);
+
+  common_hal_aesio_aes_decrypt(aes, (uint8_t *)destbufinfo.buf,
+                               destbufinfo.len);
+  return mp_const_none;
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(aesio_aes_decrypt_into_obj,
+                                 aesio_aes_decrypt_into);
+
+STATIC mp_obj_t aesio_aes_get_mode(mp_obj_t aesio_obj) {
+  if (!MP_OBJ_IS_TYPE(aesio_obj, &aesio_aes_type)) {
+    mp_raise_TypeError_varg(translate("Expected a %q"), aesio_aes_type.name);
+  }
+  aesio_aes_obj_t *self = MP_OBJ_TO_PTR(aesio_obj);
+  return MP_OBJ_NEW_SMALL_INT(self->mode);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(aesio_aes_get_mode_obj, aesio_aes_get_mode);
+
+STATIC mp_obj_t aesio_aes_set_mode(mp_obj_t aesio_obj, mp_obj_t mode_obj) {
+  if (!MP_OBJ_IS_TYPE(aesio_obj, &aesio_aes_type)) {
+    mp_raise_TypeError_varg(translate("Expected a %q"), aesio_aes_type.name);
+  }
+  aesio_aes_obj_t *self = MP_OBJ_TO_PTR(aesio_obj);
+
+  int mode = mp_obj_get_int(mode_obj);
+  switch (mode) {
+  case AES_MODE_CBC:
+  case AES_MODE_ECB:
+  case AES_MODE_CTR:
+    break;
+  default:
+    mp_raise_TypeError(translate("Requested AES mode is unsupported"));
+  }
+
+  common_hal_aesio_aes_set_mode(self, mode);
+  return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(aesio_aes_set_mode_obj, aesio_aes_set_mode);
+
+const mp_obj_property_t aesio_aes_mode_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {
+      (mp_obj_t)&aesio_aes_get_mode_obj,
+      (mp_obj_t)&aesio_aes_set_mode_obj,
+      (mp_obj_t)&mp_const_none_obj
+    },
+};
+
+STATIC const mp_rom_map_elem_t aesio_locals_dict_table[] = {
+    // Methods
+    {MP_ROM_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_AES)},
+    {MP_ROM_QSTR(MP_QSTR_encrypt_into), (mp_obj_t)&aesio_aes_encrypt_into_obj},
+    {MP_ROM_QSTR(MP_QSTR_decrypt_into), (mp_obj_t)&aesio_aes_decrypt_into_obj},
+    {MP_ROM_QSTR(MP_QSTR_rekey), (mp_obj_t)&aesio_aes_rekey_obj},
+    {MP_ROM_QSTR(MP_QSTR_mode), (mp_obj_t)&aesio_aes_mode_obj},
+};
+STATIC MP_DEFINE_CONST_DICT(aesio_locals_dict, aesio_locals_dict_table);
+
+const mp_obj_type_t aesio_aes_type = {
+    {&mp_type_type},
+    .name = MP_QSTR_AES,
+    .make_new = aesio_aes_make_new,
+    .locals_dict = (mp_obj_dict_t *)&aesio_locals_dict,
+};
diff --git a/shared-module/aesio/__init__.c b/shared-module/aesio/__init__.c
new file mode 100644
index 000000000..2cacaeb66
--- /dev/null
+++ b/shared-module/aesio/__init__.c
@@ -0,0 +1,58 @@
+#include <string.h>
+
+#include "py/runtime.h"
+
+#include "shared-bindings/aesio/__init__.h"
+#include "shared-module/aesio/__init__.h"
+
+void common_hal_aesio_aes_construct(aesio_aes_obj_t *self, const uint8_t *key,
+                                    uint32_t key_length, const uint8_t *iv,
+                                    int mode, int counter) {
+  self->mode = mode;
+  self->counter = counter;
+  common_hal_aesio_aes_rekey(self, key, key_length, iv);
+}
+
+void common_hal_aesio_aes_rekey(aesio_aes_obj_t *self, const uint8_t *key,
+                                uint32_t key_length, const uint8_t *iv) {
+  memset(&self->ctx, 0, sizeof(self->ctx));
+  if (iv != NULL) {
+    AES_init_ctx_iv(&self->ctx, key, key_length, iv);
+  } else {
+    AES_init_ctx(&self->ctx, key, key_length);
+  }
+}
+
+void common_hal_aesio_aes_set_mode(aesio_aes_obj_t *self, int mode) {
+  self->mode = mode;
+}
+
+void common_hal_aesio_aes_encrypt(aesio_aes_obj_t *self, uint8_t *buffer,
+                            size_t length) {
+  switch (self->mode) {
+  case AES_MODE_ECB:
+    AES_ECB_encrypt(&self->ctx, buffer);
+    break;
+  case AES_MODE_CBC:
+    AES_CBC_encrypt_buffer(&self->ctx, buffer, length);
+    break;
+  case AES_MODE_CTR:
+    AES_CTR_xcrypt_buffer(&self->ctx, buffer, length);
+    break;
+  }
+}
+
+void common_hal_aesio_aes_decrypt(aesio_aes_obj_t *self, uint8_t *buffer,
+                                  size_t length) {
+  switch (self->mode) {
+  case AES_MODE_ECB:
+    AES_ECB_decrypt(&self->ctx, buffer);
+    break;
+  case AES_MODE_CBC:
+    AES_CBC_decrypt_buffer(&self->ctx, buffer, length);
+    break;
+  case AES_MODE_CTR:
+    AES_CTR_xcrypt_buffer(&self->ctx, buffer, length);
+    break;
+  }
+}
diff --git a/shared-module/aesio/__init__.h b/shared-module/aesio/__init__.h
new file mode 100644
index 000000000..1a0bb8696
--- /dev/null
+++ b/shared-module/aesio/__init__.h
@@ -0,0 +1,59 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AESIO__INIT__H
+#define MICROPY_INCLUDED_SHARED_MODULE_AESIO__INIT__H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/proto.h"
+
+#include "shared-module/aesio/aes.h"
+
+// These values were chosen to correspond with the values
+// present in pycrypto.
+enum AES_MODE {
+    AES_MODE_ECB = 1,
+    AES_MODE_CBC = 2,
+    AES_MODE_CTR = 6,
+};
+
+typedef struct {
+    mp_obj_base_t base;
+
+    // The tinyaes context
+    struct AES_ctx ctx;
+
+    // Which AES mode this instance of the object is configured to use
+    enum AES_MODE mode;
+
+    // Counter for running in CTR mode
+    uint32_t counter;
+} aesio_aes_obj_t;
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_AESIO__INIT__H
diff --git a/shared-module/aesio/aes.c b/shared-module/aesio/aes.c
new file mode 100644
index 000000000..b62b5afc4
--- /dev/null
+++ b/shared-module/aesio/aes.c
@@ -0,0 +1,608 @@
+/*
+
+This is an implementation of the AES algorithm, specifically ECB, CTR and CBC mode.
+Block size can be chosen in aes.h - available choices are AES128, AES192, AES256.
+
+The implementation is verified against the test vectors in:
+  National Institute of Standards and Technology Special Publication 800-38A 2001 ED
+
+ECB-AES128
+----------
+
+  plain-text:
+    6bc1bee22e409f96e93d7e117393172a
+    ae2d8a571e03ac9c9eb76fac45af8e51
+    30c81c46a35ce411e5fbc1191a0a52ef
+    f69f2445df4f9b17ad2b417be66c3710
+
+  key:
+    2b7e151628aed2a6abf7158809cf4f3c
+
+  resulting cipher
+    3ad77bb40d7a3660a89ecaf32466ef97
+    f5d3d58503b9699de785895a96fdbaaf
+    43b1cd7f598ece23881b00e3ed030688
+    7b0c785e27e8ad3f8223207104725dd4
+
+
+NOTE:   String length must be evenly divisible by 16byte (str_len % 16 == 0)
+        You should pad the end of the string with zeros if this is not the case.
+        For AES192/256 the key size is proportionally larger.
+
+*/
+
+/*****************************************************************************/
+/* Includes:                                                                 */
+/*****************************************************************************/
+#include <string.h> // CBC mode, for memset
+#include "aes.h"
+
+/*****************************************************************************/
+/* Defines:                                                                  */
+/*****************************************************************************/
+// The number of columns comprising a state in AES. This is a constant in AES.
+// Value=4
+#define Nb 4UL
+
+#if defined(AES256) && (AES256 == 1)
+    #define Nk256 8UL
+    #define Nr256 14UL
+#endif
+#if defined(AES192) && (AES192 == 1)
+    #define Nk192 6UL
+    #define Nr192 12UL
+#endif
+#if defined(AES128) && (AES128 == 1)
+    #define Nk128 4UL        // The number of 32 bit words in a key.
+    #define Nr128 10UL       // The number of rounds in AES Cipher.
+#endif
+
+// jcallan@github points out that declaring Multiply as a function reduces code
+// size considerably with the Keil ARM compiler. See this link for more
+// information: https://github.com/kokke/tiny-AES-C/pull/3
+#ifndef MULTIPLY_AS_A_FUNCTION
+  #define MULTIPLY_AS_A_FUNCTION 0
+#endif
+
+
+
+
+/*****************************************************************************/
+/* Private variables:                                                        */
+/*****************************************************************************/
+// state - array holding the intermediate results during decryption.
+typedef uint8_t state_t[4][4];
+
+
+
+// The lookup-tables are marked const so they can be placed in read-only storage
+// instead of RAM The numbers below can be computed dynamically trading ROM for
+// RAM - This can be useful in (embedded) bootloader applications, where ROM is
+// often limited.
+static const uint8_t sbox[256] = {
+  //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F
+  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
+
+static const uint8_t rsbox[256] = {
+  0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
+  0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
+  0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
+  0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
+  0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
+  0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
+  0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
+  0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
+  0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
+  0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
+  0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
+  0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
+  0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
+  0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
+  0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+  0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };
+
+// The round constant word array, Rcon[i], contains the values given by x to the
+// power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)
+static const uint8_t Rcon[11] = {
+  0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
+
+/*
+ * Jordan Goulder points out in PR #12
+ * (https://github.com/kokke/tiny-AES-C/pull/12), that you can remove most of
+ * the elements in the Rcon array, because they are unused.
+ *
+ * From Wikipedia's article on the Rijndael key schedule @
+ * https://en.wikipedia.org/wiki/Rijndael_key_schedule#Rcon
+ *
+ * "Only the first some of these constants are actually used – up to rcon[10]
+ *  for AES-128 (as 11 round keys are needed), up to rcon[8] for AES-192, up to
+ *  rcon[7] for AES-256. rcon[0] is not used in AES algorithm."
+ */
+
+
+/*****************************************************************************/
+/* Private functions:                                                        */
+/*****************************************************************************/
+static const uint8_t *GetRoundKey(const struct AES_ctx *ctx) {
+  switch (ctx->KeyLength) {
+#if defined(AES128) && (AES128 == 1)
+  case 16: return ctx->RoundKey128;
+#endif
+#if defined(AES192) && (AES192 == 1)
+  case 24: return ctx->RoundKey192;
+#endif
+#if defined(AES256) && (AES256 == 1)
+  case 32: return ctx->RoundKey256;
+#endif
+  }
+  return NULL;
+}
+
+
+/*
+static uint8_t getSBoxValue(uint8_t num)
+{
+  return sbox[num];
+}
+*/
+#define getSBoxValue(num) (sbox[(num)])
+/*
+static uint8_t getSBoxInvert(uint8_t num)
+{
+  return rsbox[num];
+}
+*/
+#define getSBoxInvert(num) (rsbox[(num)])
+
+// This function produces Nb(Nr+1) round keys. The round keys are used in each
+// round to decrypt the states.
+static void KeyExpansion(struct AES_ctx* ctx, const uint8_t* Key)
+{
+  uint8_t* RoundKey = (uint8_t *)GetRoundKey(ctx);
+
+  unsigned i, j, k;
+  uint8_t tempa[4]; // Used for the column/row operations
+
+  // The first round key is the key itself.
+  for (i = 0; i < ctx->Nk; ++i)
+  {
+    RoundKey[(i * 4) + 0] = Key[(i * 4) + 0];
+    RoundKey[(i * 4) + 1] = Key[(i * 4) + 1];
+    RoundKey[(i * 4) + 2] = Key[(i * 4) + 2];
+    RoundKey[(i * 4) + 3] = Key[(i * 4) + 3];
+  }
+
+  // All other round keys are found from the previous round keys.
+  for (i = ctx->Nk; i < Nb * (ctx->Nr + 1); ++i)
+  {
+    {
+      k = (i - 1) * 4;
+      tempa[0]=RoundKey[k + 0];
+      tempa[1]=RoundKey[k + 1];
+      tempa[2]=RoundKey[k + 2];
+      tempa[3]=RoundKey[k + 3];
+
+    }
+
+    if (i % ctx->Nk == 0)
+    {
+      // This function shifts the 4 bytes in a word to the left once.
+      // [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
+
+      // Function RotWord()
+      {
+        const uint8_t u8tmp = tempa[0];
+        tempa[0] = tempa[1];
+        tempa[1] = tempa[2];
+        tempa[2] = tempa[3];
+        tempa[3] = u8tmp;
+      }
+
+      // SubWord() is a function that takes a four-byte input word and applies
+      // the S-box to each of the four bytes to produce an output word.
+
+      // Function Subword()
+      {
+        tempa[0] = getSBoxValue(tempa[0]);
+        tempa[1] = getSBoxValue(tempa[1]);
+        tempa[2] = getSBoxValue(tempa[2]);
+        tempa[3] = getSBoxValue(tempa[3]);
+      }
+
+      tempa[0] = tempa[0] ^ Rcon[i/ctx->Nk];
+    }
+#if defined(AES256) && (AES256 == 1)
+    if (ctx->KeyLength == 32) {
+      if (i % ctx->Nk == 4)
+      {
+        // Function Subword()
+        {
+          tempa[0] = getSBoxValue(tempa[0]);
+          tempa[1] = getSBoxValue(tempa[1]);
+          tempa[2] = getSBoxValue(tempa[2]);
+          tempa[3] = getSBoxValue(tempa[3]);
+        }
+      }
+    }
+#endif
+    j = i * 4; k=(i - ctx->Nk) * 4;
+    RoundKey[j + 0] = RoundKey[k + 0] ^ tempa[0];
+    RoundKey[j + 1] = RoundKey[k + 1] ^ tempa[1];
+    RoundKey[j + 2] = RoundKey[k + 2] ^ tempa[2];
+    RoundKey[j + 3] = RoundKey[k + 3] ^ tempa[3];
+  }
+}
+
+void AES_init_ctx(struct AES_ctx* ctx, const uint8_t* key, uint32_t keylen)
+{
+  ctx->KeyLength = keylen;
+  switch (ctx->KeyLength) {
+#if defined(AES128) && (AES128 == 1)
+  case 16: ctx->Nr = Nr128; ctx->Nk = Nk128; break;
+#endif
+#if defined(AES192) && (AES192 == 1)
+  case 24: ctx->Nr = Nr192; ctx->Nk = Nk192; break;
+#endif
+#if defined(AES256) && (AES256 == 1)
+  case 32: ctx->Nr = Nr256; ctx->Nk = Nk256; break;
+#endif
+  default: ctx->Nr = 0; ctx->Nk = 0; break;
+  }
+  KeyExpansion(ctx, key);
+}
+#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))
+void AES_init_ctx_iv(struct AES_ctx* ctx, const uint8_t* key, uint32_t keylen, const uint8_t* iv)
+{
+  AES_init_ctx(ctx, key, keylen);
+  memcpy (ctx->Iv, iv, AES_BLOCKLEN);
+}
+void AES_ctx_set_iv(struct AES_ctx* ctx, const uint8_t* iv)
+{
+  memcpy (ctx->Iv, iv, AES_BLOCKLEN);
+}
+#endif
+
+// This function adds the round key to state. The round key is added to the
+// state by an XOR function.
+static void AddRoundKey(uint8_t round, state_t* state, const uint8_t* RoundKey)
+{
+  uint8_t i,j;
+  for (i = 0; i < 4; ++i)
+  {
+    for (j = 0; j < 4; ++j)
+    {
+      (*state)[i][j] ^= RoundKey[(round * Nb * 4) + (i * Nb) + j];
+    }
+  }
+}
+
+// The SubBytes Function Substitutes the values in the state matrix with values
+// in an S-box.
+static void SubBytes(state_t* state)
+{
+  uint8_t i, j;
+  for (i = 0; i < 4; ++i)
+  {
+    for (j = 0; j < 4; ++j)
+    {
+      (*state)[j][i] = getSBoxValue((*state)[j][i]);
+    }
+  }
+}
+
+// The ShiftRows() function shifts the rows in the state to the left. Each row
+// is shifted with different offset. Offset = Row number. So the first row is
+// not shifted.
+static void ShiftRows(state_t* state)
+{
+  uint8_t temp;
+
+  // Rotate first row 1 columns to left
+  temp           = (*state)[0][1];
+  (*state)[0][1] = (*state)[1][1];
+  (*state)[1][1] = (*state)[2][1];
+  (*state)[2][1] = (*state)[3][1];
+  (*state)[3][1] = temp;
+
+  // Rotate second row 2 columns to left
+  temp           = (*state)[0][2];
+  (*state)[0][2] = (*state)[2][2];
+  (*state)[2][2] = temp;
+
+  temp           = (*state)[1][2];
+  (*state)[1][2] = (*state)[3][2];
+  (*state)[3][2] = temp;
+
+  // Rotate third row 3 columns to left
+  temp           = (*state)[0][3];
+  (*state)[0][3] = (*state)[3][3];
+  (*state)[3][3] = (*state)[2][3];
+  (*state)[2][3] = (*state)[1][3];
+  (*state)[1][3] = temp;
+}
+
+static uint8_t xtime(uint8_t x)
+{
+  return ((x<<1) ^ (((x>>7) & 1) * 0x1b));
+}
+
+// MixColumns function mixes the columns of the state matrix
+static void MixColumns(state_t* state)
+{
+  uint8_t i;
+  uint8_t Tmp, Tm, t;
+  for (i = 0; i < 4; ++i)
+  {
+    t   = (*state)[i][0];
+    Tmp = (*state)[i][0] ^ (*state)[i][1] ^ (*state)[i][2] ^ (*state)[i][3] ;
+    Tm  = (*state)[i][0] ^ (*state)[i][1] ; Tm = xtime(Tm);  (*state)[i][0] ^= Tm ^ Tmp ;
+    Tm  = (*state)[i][1] ^ (*state)[i][2] ; Tm = xtime(Tm);  (*state)[i][1] ^= Tm ^ Tmp ;
+    Tm  = (*state)[i][2] ^ (*state)[i][3] ; Tm = xtime(Tm);  (*state)[i][2] ^= Tm ^ Tmp ;
+    Tm  = (*state)[i][3] ^ t ;              Tm = xtime(Tm);  (*state)[i][3] ^= Tm ^ Tmp ;
+  }
+}
+
+// Multiply is used to multiply numbers in the field GF(2^8)
+// Note: The last call to xtime() is unneeded, but often ends up generating a smaller binary
+//       The compiler seems to be able to vectorize the operation better this way.
+//       See https://github.com/kokke/tiny-AES-c/pull/34
+#if MULTIPLY_AS_A_FUNCTION
+static uint8_t Multiply(uint8_t x, uint8_t y)
+{
+  return (((y & 1) * x) ^
+       ((y>>1 & 1) * xtime(x)) ^
+       ((y>>2 & 1) * xtime(xtime(x))) ^
+       ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^
+       ((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))); /* this last call to xtime() can be omitted */
+  }
+#else
+#define Multiply(x, y)                                \
+      (  ((y & 1) * x) ^                              \
+      ((y>>1 & 1) * xtime(x)) ^                       \
+      ((y>>2 & 1) * xtime(xtime(x))) ^                \
+      ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^         \
+      ((y>>4 & 1) * xtime(xtime(xtime(xtime(x))))))   \
+
+#endif
+
+#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)
+// MixColumns function mixes the columns of the state matrix. The method used to
+// multiply may be difficult to understand for the inexperienced. Please use the
+// references to gain more information.
+static void InvMixColumns(state_t* state)
+{
+  int i;
+  uint8_t a, b, c, d;
+  for (i = 0; i < 4; ++i)
+  {
+    a = (*state)[i][0];
+    b = (*state)[i][1];
+    c = (*state)[i][2];
+    d = (*state)[i][3];
+
+    (*state)[i][0] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0x09);
+    (*state)[i][1] = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d);
+    (*state)[i][2] = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b);
+    (*state)[i][3] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^ Multiply(d, 0x0e);
+  }
+}
+
+
+// The SubBytes Function Substitutes the values in the state matrix with values
+// in an S-box.
+static void InvSubBytes(state_t* state)
+{
+  uint8_t i, j;
+  for (i = 0; i < 4; ++i)
+  {
+    for (j = 0; j < 4; ++j)
+    {
+      (*state)[j][i] = getSBoxInvert((*state)[j][i]);
+    }
+  }
+}
+
+static void InvShiftRows(state_t* state)
+{
+  uint8_t temp;
+
+  // Rotate first row 1 columns to right
+  temp = (*state)[3][1];
+  (*state)[3][1] = (*state)[2][1];
+  (*state)[2][1] = (*state)[1][1];
+  (*state)[1][1] = (*state)[0][1];
+  (*state)[0][1] = temp;
+
+  // Rotate second row 2 columns to right
+  temp = (*state)[0][2];
+  (*state)[0][2] = (*state)[2][2];
+  (*state)[2][2] = temp;
+
+  temp = (*state)[1][2];
+  (*state)[1][2] = (*state)[3][2];
+  (*state)[3][2] = temp;
+
+  // Rotate third row 3 columns to right
+  temp = (*state)[0][3];
+  (*state)[0][3] = (*state)[1][3];
+  (*state)[1][3] = (*state)[2][3];
+  (*state)[2][3] = (*state)[3][3];
+  (*state)[3][3] = temp;
+}
+#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)
+
+// Cipher is the main function that encrypts the PlainText.
+static void Cipher(state_t* state, const struct AES_ctx* ctx)
+{
+  const uint8_t* RoundKey = GetRoundKey(ctx);
+  uint8_t round = 0;
+
+  // Add the First round key to the state before starting the rounds.
+  AddRoundKey(0, state, RoundKey);
+
+  // There will be Nr rounds. The first Nr-1 rounds are identical. These Nr
+  // rounds are executed in the loop below. Last one without MixColumns()
+  for (round = 1; ; ++round)
+  {
+    SubBytes(state);
+    ShiftRows(state);
+    if (round == ctx->Nr) {
+      break;
+    }
+    MixColumns(state);
+    AddRoundKey(round, state, RoundKey);
+  }
+  // Add round key to last round
+  AddRoundKey(ctx->Nr, state, RoundKey);
+}
+
+#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)
+static void InvCipher(state_t* state, const struct AES_ctx* ctx)
+{
+  const uint8_t* RoundKey = GetRoundKey(ctx);
+  uint8_t round = 0;
+
+  // Add the First round key to the state before starting the rounds.
+  AddRoundKey(ctx->Nr, state, RoundKey);
+
+  // There will be Nr rounds. The first Nr-1 rounds are identical. These Nr
+  // rounds are executed in the loop below. Last one without InvMixColumn()
+  for (round = (ctx->Nr - 1); ; --round)
+  {
+    InvShiftRows(state);
+    InvSubBytes(state);
+    AddRoundKey(round, state, RoundKey);
+    if (round == 0) {
+      break;
+    }
+    InvMixColumns(state);
+  }
+
+}
+#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)
+
+/*****************************************************************************/
+/* Public functions:                                                         */
+/*****************************************************************************/
+#if defined(ECB) && (ECB == 1)
+
+
+void AES_ECB_encrypt(const struct AES_ctx* ctx, uint8_t* buf)
+{
+  // The next function call encrypts the PlainText with the Key using AES
+  // algorithm.
+  Cipher((state_t*)buf, ctx);
+}
+
+void AES_ECB_decrypt(const struct AES_ctx* ctx, uint8_t* buf)
+{
+  // The next function call decrypts the PlainText with the Key using AES
+  // algorithm.
+  InvCipher((state_t*)buf, ctx);
+}
+
+
+#endif // #if defined(ECB) && (ECB == 1)
+
+
+
+
+
+#if defined(CBC) && (CBC == 1)
+
+
+static void XorWithIv(uint8_t* buf, const uint8_t* Iv)
+{
+  uint8_t i;
+  for (i = 0; i < AES_BLOCKLEN; ++i) // The block in AES is always 128bit no matter the key size
+  {
+    buf[i] ^= Iv[i];
+  }
+}
+
+void AES_CBC_encrypt_buffer(struct AES_ctx *ctx, uint8_t* buf, uint32_t length)
+{
+  uintptr_t i;
+  uint8_t *Iv = ctx->Iv;
+  for (i = 0; i < length; i += AES_BLOCKLEN)
+  {
+    XorWithIv(buf, Iv);
+    Cipher((state_t*)buf, ctx);
+    Iv = buf;
+    buf += AES_BLOCKLEN;
+  }
+  /* store Iv in ctx for next call */
+  memcpy(ctx->Iv, Iv, AES_BLOCKLEN);
+}
+
+void AES_CBC_decrypt_buffer(struct AES_ctx* ctx, uint8_t* buf,  uint32_t length)
+{
+  uintptr_t i;
+  uint8_t storeNextIv[AES_BLOCKLEN];
+  for (i = 0; i < length; i += AES_BLOCKLEN)
+  {
+    memcpy(storeNextIv, buf, AES_BLOCKLEN);
+    InvCipher((state_t*)buf, ctx);
+    XorWithIv(buf, ctx->Iv);
+    memcpy(ctx->Iv, storeNextIv, AES_BLOCKLEN);
+    buf += AES_BLOCKLEN;
+  }
+
+}
+
+#endif // #if defined(CBC) && (CBC == 1)
+
+
+
+#if defined(CTR) && (CTR == 1)
+
+/* Symmetrical operation: same function for encrypting as for decrypting. Note
+any IV/nonce should never be reused with the same key */
+void AES_CTR_xcrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length)
+{
+  uint8_t buffer[AES_BLOCKLEN];
+
+  unsigned i;
+  int bi;
+  for (i = 0, bi = AES_BLOCKLEN; i < length; ++i, ++bi)
+  {
+    if (bi == AES_BLOCKLEN) /* we need to regen xor compliment in buffer */
+    {
+      memcpy(buffer, ctx->Iv, AES_BLOCKLEN);
+      Cipher((state_t*)buffer, ctx);
+
+      /* Increment Iv and handle overflow */
+      for (bi = (AES_BLOCKLEN - 1); bi >= 0; --bi)
+      {
+        /* inc will overflow */
+        if (ctx->Iv[bi] == 255)
+	      {
+          ctx->Iv[bi] = 0;
+          continue;
+        }
+        ctx->Iv[bi] += 1;
+        break;
+      }
+      bi = 0;
+    }
+
+    buf[i] = (buf[i] ^ buffer[bi]);
+  }
+}
+
+#endif // #if defined(CTR) && (CTR == 1)
diff --git a/shared-module/aesio/aes.h b/shared-module/aesio/aes.h
new file mode 100644
index 000000000..a87fa5be7
--- /dev/null
+++ b/shared-module/aesio/aes.h
@@ -0,0 +1,105 @@
+#ifndef _AES_H_
+#define _AES_H_
+
+#include <stdint.h>
+
+// #define the macros below to 1/0 to enable/disable the mode of operation.
+//
+// CBC enables AES encryption in CBC-mode of operation.
+// CTR enables encryption in counter-mode.
+// ECB enables the basic ECB 16-byte block algorithm. All can be enabled simultaneously.
+
+// The #ifndef-guard allows it to be configured before #include'ing or at compile time.
+#ifndef CBC
+  #define CBC 1
+#endif
+
+#ifndef ECB
+  #define ECB 1
+#endif
+
+#ifndef CTR
+  #define CTR 1
+#endif
+
+
+#define AES128 1
+#define AES192 1
+#define AES256 1
+
+#define AES_BLOCKLEN 16 // Block length in bytes - AES is 128b block only
+
+#if defined(AES256) && (AES256 == 1)
+    #define AES_KEYLEN256 32
+    #define AES_keyExpSize256 240
+#endif
+#if defined(AES192) && (AES192 == 1)
+    #define AES_KEYLEN192 24
+    #define AES_keyExpSize192 208
+#endif
+#if defined(AES128) && (AES128 == 1)
+    #define AES_KEYLEN128 16   // Key length in bytes
+    #define AES_keyExpSize128 176
+#endif
+
+struct AES_ctx
+{
+  union {
+#if defined(AES256) && (AES256 == 1)
+    uint8_t RoundKey256[AES_keyExpSize256];
+#endif
+#if defined(AES192) && (AES192 == 1)
+    uint8_t RoundKey192[AES_keyExpSize192];
+#endif
+#if defined(AES128) && (AES128 == 1)
+    uint8_t RoundKey128[AES_keyExpSize128];
+#endif
+  };
+#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))
+  uint8_t Iv[AES_BLOCKLEN];
+#endif
+  uint32_t KeyLength;
+  uint8_t Nr;
+  uint8_t Nk;
+};
+
+void AES_init_ctx(struct AES_ctx* ctx, const uint8_t* key, uint32_t keylen);
+#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))
+void AES_init_ctx_iv(struct AES_ctx* ctx, const uint8_t* key, uint32_t keylen, const uint8_t* iv);
+void AES_ctx_set_iv(struct AES_ctx* ctx, const uint8_t* iv);
+#endif
+
+#if defined(ECB) && (ECB == 1)
+// buffer size is exactly AES_BLOCKLEN bytes;
+// you need only AES_init_ctx as IV is not used in ECB
+// NB: ECB is considered insecure for most uses
+void AES_ECB_encrypt(const struct AES_ctx* ctx, uint8_t* buf);
+void AES_ECB_decrypt(const struct AES_ctx* ctx, uint8_t* buf);
+
+#endif // #if defined(ECB) && (ECB == !)
+
+
+#if defined(CBC) && (CBC == 1)
+// buffer size MUST be mutile of AES_BLOCKLEN;
+// Suggest https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7 for padding scheme
+// NOTES: you need to set IV in ctx via AES_init_ctx_iv() or AES_ctx_set_iv()
+//        no IV should ever be reused with the same key
+void AES_CBC_encrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length);
+void AES_CBC_decrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length);
+
+#endif // #if defined(CBC) && (CBC == 1)
+
+
+#if defined(CTR) && (CTR == 1)
+
+// Same function for encrypting as for decrypting.
+// IV is incremented for every block, and used after encryption as XOR-compliment for output
+// Suggesting https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7 for padding scheme
+// NOTES: you need to set IV in ctx with AES_init_ctx_iv() or AES_ctx_set_iv()
+//        no IV should ever be reused with the same key
+void AES_CTR_xcrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length);
+
+#endif // #if defined(CTR) && (CTR == 1)
+
+
+#endif // _AES_H_
-- 
cgit v1.2.3