diff --git a/system/dev/usb/usb-bus/rules.mk b/system/dev/usb/usb-bus/rules.mk
index d9c0df6..34fd27d 100644
--- a/system/dev/usb/usb-bus/rules.mk
+++ b/system/dev/usb/usb-bus/rules.mk
@@ -9,13 +9,14 @@
 MODULE_TYPE := driver
 
 MODULE_SRCS := \
-    $(LOCAL_DIR)/usb-bus.c \
-    $(LOCAL_DIR)/usb-device.c \
-    $(LOCAL_DIR)/util.c \
+    $(LOCAL_DIR)/usb-bus.cpp \
+    $(LOCAL_DIR)/usb-device.cpp \
+    $(LOCAL_DIR)/util.cpp \
 
 MODULE_STATIC_LIBS := \
     system/dev/lib/usb \
     system/ulib/ddk \
+    system/ulib/fbl \
     system/ulib/fidl \
     system/ulib/sync \
     system/ulib/utf_conversion \
diff --git a/system/dev/usb/usb-bus/usb-bus.c b/system/dev/usb/usb-bus/usb-bus.cpp
similarity index 87%
rename from system/dev/usb/usb-bus/usb-bus.c
rename to system/dev/usb/usb-bus/usb-bus.cpp
index c7618b7..29d9506 100644
--- a/system/dev/usb/usb-bus/usb-bus.c
+++ b/system/dev/usb/usb-bus/usb-bus.cpp
@@ -14,7 +14,7 @@
 
 static zx_status_t bus_add_device(void* ctx, uint32_t device_id, uint32_t hub_id,
                                       usb_speed_t speed) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
 
     if (device_id >= bus->max_device_count) return ZX_ERR_INVALID_ARGS;
 
@@ -24,7 +24,7 @@
 }
 
 static zx_status_t bus_remove_device(void* ctx, uint32_t device_id) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     if (device_id >= bus->max_device_count) {
         zxlogf(ERROR, "device_id out of range in usb_bus_remove_device\n");
         return ZX_ERR_INVALID_ARGS;
@@ -39,7 +39,7 @@
 }
 
 static zx_status_t bus_reset_hub_port(void* ctx, uint32_t hub_id, uint32_t port) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     if (hub_id >= bus->max_device_count) {
         zxlogf(ERROR, "hub_id out of range in usb_bus_reset_hub_port\n");
         return ZX_ERR_INVALID_ARGS;
@@ -73,7 +73,7 @@
 
 static zx_status_t bus_configure_hub(void* ctx, zx_device_t* hub_device, usb_speed_t speed,
                                      const usb_hub_descriptor_t* desc) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     uint32_t hub_id;
     if (bus_get_device_id(hub_device, &hub_id) != ZX_OK) {
         return ZX_ERR_INTERNAL;
@@ -83,7 +83,7 @@
 
 static zx_status_t bus_device_added(void* ctx, zx_device_t* hub_device, uint32_t port,
                                     usb_speed_t speed) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     uint32_t hub_id;
     if (bus_get_device_id(hub_device, &hub_id) != ZX_OK) {
         return ZX_ERR_INTERNAL;
@@ -92,7 +92,7 @@
 }
 
 static zx_status_t bus_device_removed(void* ctx, zx_device_t* hub_device, uint32_t port) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     uint32_t hub_id;
     if (bus_get_device_id(hub_device, &hub_id) != ZX_OK) {
         return ZX_ERR_INTERNAL;
@@ -102,7 +102,7 @@
 
 static zx_status_t bus_set_hub_interface(void* ctx, zx_device_t* usb_device,
                                          const usb_hub_interface_t* hub) {
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     uint32_t usb_device_id;
     if (bus_get_device_id(usb_device, &usb_device_id) != ZX_OK) {
         return ZX_ERR_INTERNAL;
@@ -125,7 +125,7 @@
 
 static void usb_bus_unbind(void* ctx) {
     zxlogf(INFO, "usb_bus_unbind\n");
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     usb_hci_set_bus_interface(&bus->hci, NULL);
 
     for (size_t i = 0; i < bus->max_device_count; i++) {
@@ -140,19 +140,21 @@
 
 static void usb_bus_release(void* ctx) {
     zxlogf(INFO, "usb_bus_release\n");
-    usb_bus_t* bus = ctx;
+    auto* bus = static_cast<usb_bus_t*>(ctx);
     free(bus->devices);
     free(bus);
 }
 
-static zx_protocol_device_t usb_bus_device_proto = {
-    .version = DEVICE_OPS_VERSION,
-    .unbind = usb_bus_unbind,
-    .release = usb_bus_release,
-};
+static zx_protocol_device_t usb_bus_device_proto = [](){
+    zx_protocol_device_t proto;
+    proto.version = DEVICE_OPS_VERSION;
+    proto.unbind = usb_bus_unbind;
+    proto.release = usb_bus_release;
+    return proto;
+}();
 
 static zx_status_t usb_bus_bind(void* ctx, zx_device_t* device) {
-    usb_bus_t* bus = calloc(1, sizeof(usb_bus_t));
+    auto* bus = static_cast<usb_bus_t*>(calloc(1, sizeof(usb_bus_t)));
     if (!bus) {
         zxlogf(ERROR, "Not enough memory for usb_bus_t.\n");
         return ZX_ERR_NO_MEMORY;
@@ -165,7 +167,7 @@
 
     bus->hci_zxdev = device;
     bus->max_device_count = usb_hci_get_max_device_count(&bus->hci);
-    bus->devices = calloc(bus->max_device_count, sizeof(usb_device_t *));
+    bus->devices = static_cast<usb_device_t**>(calloc(bus->max_device_count, sizeof(usb_device_t *)));
     if (!bus->devices) {
         zxlogf(ERROR, "Not enough memory for usb_bus_t->devices. max_device_count: %zu\n",
                bus->max_device_count);
diff --git a/system/dev/usb/usb-bus/usb-device.c b/system/dev/usb/usb-bus/usb-device.cpp
similarity index 93%
rename from system/dev/usb/usb-bus/usb-device.c
rename to system/dev/usb/usb-bus/usb-device.cpp
index a674369..013db48 100644
--- a/system/dev/usb/usb-bus/usb-device.c
+++ b/system/dev/usb/usb-bus/usb-device.cpp
@@ -93,7 +93,7 @@
 
 // usb request completion for the requests passed down to the HCI driver
 static void request_complete(void* ctx, usb_request_t* req) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
 
     mtx_lock(&dev->callback_lock);
     // move original request to completed_reqs list so it can be completed on the callback_thread
@@ -133,12 +133,12 @@
 }
 
 static void usb_device_unbind(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     device_remove(dev->zxdev);
 }
 
 static void usb_device_release(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
 
     stop_callback_thread(dev);
 
@@ -159,7 +159,7 @@
 static zx_status_t usb_device_control(void* ctx, uint8_t request_type, uint8_t request,
                                       uint16_t value, uint16_t index, void* data, size_t length,
                                       zx_time_t timeout, size_t* out_length) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
 
     usb_request_t* req = NULL;
     bool use_free_list = length == 0;
@@ -234,7 +234,7 @@
 
 static void usb_device_request_queue(void* ctx, usb_request_t* req, usb_request_complete_cb cb,
                                      void* cookie) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
 
     usb_device_req_internal_t* req_int = USB_REQ_TO_DEV_INTERNAL(req, dev->parent_req_size);
     req_int->complete_cb = cb;
@@ -258,24 +258,24 @@
 }
 
 static usb_speed_t usb_device_get_speed(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return dev->speed;
 }
 
 static zx_status_t usb_device_set_interface(void* ctx, uint8_t interface_number,
                                             uint8_t alt_setting) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_util_control(dev, USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_INTERFACE,
                             USB_REQ_SET_INTERFACE, alt_setting, interface_number, NULL, 0);
 }
 
 static uint8_t usb_device_get_configuration(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return dev->config_descs[dev->current_config_index]->bConfigurationValue;
 }
 
 static zx_status_t usb_device_set_configuration(void* ctx, uint8_t configuration) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     for (uint8_t i = 0; i < dev->num_configurations; i++) {
         usb_configuration_descriptor_t* descriptor = dev->config_descs[i];
         if (descriptor->bConfigurationValue == configuration) {
@@ -294,34 +294,34 @@
 static zx_status_t usb_device_enable_endpoint(void* ctx, usb_endpoint_descriptor_t* ep_desc,
                                               usb_ss_ep_comp_descriptor_t* ss_comp_desc,
                                               bool enable) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_hci_enable_endpoint(&dev->hci, dev->device_id, ep_desc, ss_comp_desc, enable);
 }
 
 static zx_status_t usb_device_reset_endpoint(void* ctx, uint8_t ep_address) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_hci_reset_endpoint(&dev->hci, dev->device_id, ep_address);
 }
 
 static size_t usb_device_get_max_transfer_size(void* ctx, uint8_t ep_address) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_hci_get_max_transfer_size(&dev->hci, dev->device_id, ep_address);
 }
 
 static uint32_t _usb_device_get_device_id(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return dev->device_id;
 }
 
 static void usb_device_get_device_descriptor(void* ctx, usb_device_descriptor_t* out_desc) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     memcpy(out_desc, &dev->device_desc, sizeof(usb_device_descriptor_t));
 }
 
 static zx_status_t usb_device_get_configuration_descriptor(void* ctx, uint8_t configuration,
                                                            usb_configuration_descriptor_t** out,
                                                            size_t* out_length) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     for (int i = 0; i <  dev->num_configurations; i++) {
         usb_configuration_descriptor_t* config_desc = dev->config_descs[i];
         if (config_desc->bConfigurationValue == configuration) {
@@ -343,7 +343,7 @@
 
 static zx_status_t usb_device_get_descriptor_list(void* ctx, void** out_descriptors,
                                                   size_t* out_length) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     usb_configuration_descriptor_t* config_desc = dev->config_descs[dev->current_config_index];
     size_t length = le16toh(config_desc->wTotalLength);
 
@@ -362,23 +362,23 @@
 zx_status_t usb_device_get_string_descriptor(void* ctx, uint8_t desc_id, uint16_t lang_id,
                                              uint8_t* buf, size_t buflen, size_t* out_actual,
                                              uint16_t* out_actual_lang_id) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_util_get_string_descriptor(dev, desc_id, lang_id, buf, buflen,
                                           out_actual, out_actual_lang_id);
 }
 
 static zx_status_t usb_device_cancel_all(void* ctx, uint8_t ep_address) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_hci_cancel_all(&dev->hci, dev->device_id, ep_address);
 }
 
 static uint64_t usb_device_get_current_frame(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return usb_hci_get_current_frame(&dev->hci);
 }
 
 static size_t usb_device_get_request_size(void* ctx) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return dev->req_size;
 }
 
@@ -404,17 +404,17 @@
 };
 
 static zx_status_t fidl_GetDeviceSpeed(void* ctx, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return zircon_usb_device_DeviceGetDeviceSpeed_reply(txn, dev->speed);
 }
 
 static zx_status_t fidl_GetDeviceDescriptor(void* ctx, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return zircon_usb_device_DeviceGetDeviceDescriptor_reply(txn, (uint8_t*)&dev->device_desc);
 }
 
 static zx_status_t fidl_GetConfigurationDescriptorSize(void* ctx, uint8_t config, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     usb_configuration_descriptor_t* descriptor = get_config_desc(dev, config);
     if (!descriptor) {
         return zircon_usb_device_DeviceGetConfigurationDescriptorSize_reply(txn,
@@ -426,7 +426,7 @@
 }
 
 static zx_status_t fidl_GetConfigurationDescriptor(void* ctx, uint8_t config, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     usb_configuration_descriptor_t* descriptor = get_config_desc(dev, config);
     if (!descriptor) {
         return zircon_usb_device_DeviceGetConfigurationDescriptor_reply(txn, ZX_ERR_INVALID_ARGS,
@@ -440,7 +440,7 @@
 
 static zx_status_t fidl_GetStringDescriptor(void* ctx, uint8_t desc_id, uint16_t lang_id,
                                             fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     uint8_t buffer[zircon_usb_device_MAX_STRING_DESC_SIZE];
     size_t actual;
     zx_status_t status = usb_util_get_string_descriptor(dev, desc_id, lang_id, buffer,
@@ -450,29 +450,29 @@
 
 static zx_status_t fidl_SetInterface(void* ctx, uint8_t interface_number, uint8_t alt_setting,
                                      fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     zx_status_t status = usb_device_set_interface(dev, interface_number, alt_setting);
     return zircon_usb_device_DeviceSetInterface_reply(txn, status);
 }
 
 static zx_status_t fidl_GetDeviceId(void* ctx, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return zircon_usb_device_DeviceGetDeviceId_reply(txn, dev->device_id);
 }
 
 static zx_status_t fidl_GetHubDeviceId(void* ctx, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     return zircon_usb_device_DeviceGetHubDeviceId_reply(txn, dev->hub_id);
 }
 
 static zx_status_t fidl_GetConfiguration(void* ctx, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     usb_configuration_descriptor_t* descriptor = dev->config_descs[dev->current_config_index];
     return zircon_usb_device_DeviceGetConfiguration_reply(txn, descriptor->bConfigurationValue);
 }
 
 static zx_status_t fidl_SetConfiguration(void* ctx, uint8_t configuration, fidl_txn_t* txn) {
-    usb_device_t* dev = ctx;
+    auto* dev = static_cast<usb_device_t*>(ctx);
     zx_status_t status = usb_device_set_configuration(dev, configuration);
     return zircon_usb_device_DeviceSetConfiguration_reply(txn, status);
 }
diff --git a/system/dev/usb/usb-bus/usb-device.h b/system/dev/usb/usb-bus/usb-device.h
index 69516f3..e969033 100644
--- a/system/dev/usb/usb-bus/usb-device.h
+++ b/system/dev/usb/usb-bus/usb-device.h
@@ -9,12 +9,12 @@
 #include <ddk/protocol/usb/hci.h>
 #include <ddk/protocol/usb/hub.h>
 #include <ddk/protocol/usb-old.h>
+#include <fbl/atomic.h>
 #include <usb/usb-request.h>
 #include <lib/sync/completion.h>
 #include <zircon/hw/usb.h>
 
 #include <threads.h>
-#include <stdatomic.h>
 
 typedef struct usb_bus usb_bus_t;
 
@@ -39,8 +39,8 @@
     uint8_t current_config_index;
     uint8_t num_configurations;
 
-    atomic_bool langids_fetched;
-    atomic_uintptr_t lang_ids;
+    fbl::atomic<bool> langids_fetched;
+    fbl::atomic<uintptr_t> lang_ids;
 
     // thread for calling client's usb request complete callback
     thrd_t callback_thread;
diff --git a/system/dev/usb/usb-bus/util.c b/system/dev/usb/usb-bus/util.cpp
similarity index 94%
rename from system/dev/usb/usb-bus/util.c
rename to system/dev/usb/usb-bus/util.cpp
index 5c556f6..75cd06f 100644
--- a/system/dev/usb/usb-bus/util.c
+++ b/system/dev/usb/usb-bus/util.cpp
@@ -28,7 +28,8 @@
 }
 
 zx_status_t usb_util_control(usb_device_t* dev, uint8_t request_type, uint8_t request,
-                             uint16_t value, uint16_t index, void* data, size_t length) {
+                             uint16_t value, uint16_t index, void* data, size_t length,
+                             size_t* out_actual) {
     usb_request_t* req = NULL;
     bool use_free_list = length == 0;
     if (use_free_list) {
@@ -43,9 +44,9 @@
     usb_setup_t* setup = &req->setup;
     setup->bmRequestType = request_type;
     setup->bRequest = request;
-    setup->wValue = value;
-    setup->wIndex = index;
-    setup->wLength = length;
+    setup->wValue = htole16(value);
+    setup->wIndex = htole16(index);
+    setup->wLength = htole16(static_cast<uint16_t>(length));
     req->header.device_id = dev->device_id;
 
     bool out = !!((request_type & USB_DIR_MASK) == USB_DIR_OUT);
@@ -53,7 +54,7 @@
         usb_request_copy_to(req, data, length, 0);
     }
 
-    sync_completion_t completion = SYNC_COMPLETION_INIT;
+    sync_completion_t completion;
 
     req->header.length = length;
 
@@ -104,7 +105,7 @@
     //  If we have never attempted to load our language ID table, do so now.
     zx_status_t result;
     if (!atomic_load_explicit(&dev->langids_fetched, memory_order_relaxed)) {
-        usb_langid_desc_t* id_desc = calloc(1, sizeof(usb_langid_desc_t));
+        auto* id_desc = static_cast<usb_langid_desc_t*>(calloc(1, sizeof(usb_langid_desc_t)));
 
         if (id_desc != NULL) {
             result = usb_util_get_descriptor(dev, USB_DT_STRING, 0, 0, id_desc, sizeof(*id_desc));
@@ -155,7 +156,7 @@
     // tried to obtain or synthesize one in the past, we are not going to get
     // one.  Just fail.
     usb_langid_desc_t* lang_ids =
-        (usb_langid_desc_t*)(atomic_load_explicit(&dev->lang_ids, memory_order_relaxed));
+        (usb_langid_desc_t*)(dev->lang_ids.load(memory_order_relaxed));
     if (!lang_ids) {
         return ZX_ERR_BAD_STATE;
     }