diff --git a/example/daemon/le_scan.c b/example/daemon/le_scan.c
index f4e741537..20be7079d 100644
--- a/example/daemon/le_scan.c
+++ b/example/daemon/le_scan.c
@@ -67,7 +67,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
             switch (packet[2]) {
                 case HCI_SUBEVENT_LE_ADVERTISING_REPORT: 
                 	printf("\n- ADV: ");
-                	hexdumpf(packet, size);
+                	printf_hexdump(packet, size);
                     break;
                 }
                 break;
diff --git a/example/embedded/gatt_battery_query.c b/example/embedded/gatt_battery_query.c
index 1c6bcac9b..4c4490c5c 100644
--- a/example/embedded/gatt_battery_query.c
+++ b/example/embedded/gatt_battery_query.c
@@ -142,7 +142,7 @@ static void extract_service(le_service_t * service, uint8_t * packet){
     service->start_group_handle = little_endian_read_16(packet, 4);
     service->end_group_handle   = little_endian_read_16(packet, 6);
     service->uuid16 = 0;
-    swap128(&packet[8], service->uuid128);
+    reverse_128(&packet[8], service->uuid128);
     if (uuid_has_bluetooth_prefix(service->uuid128)){
         service->uuid16 = big_endian_read_32(service->uuid128, 0);
     }
@@ -154,7 +154,7 @@ static void extract_characteristic(le_characteristic_t * characteristic, uint8_t
     characteristic->end_handle =   little_endian_read_16(packet, 8);
     characteristic->properties =   little_endian_read_16(packet, 10);
     characteristic->uuid16 = 0;
-    swap128(&packet[12], characteristic->uuid128);
+    reverse_128(&packet[12], characteristic->uuid128);
     if (uuid_has_bluetooth_prefix(characteristic->uuid128)){
         characteristic->uuid16 = big_endian_read_32(characteristic->uuid128, 0);
     }
diff --git a/example/embedded/gatt_browser.c b/example/embedded/gatt_browser.c
index c42e2fdac..3eb1afbdc 100644
--- a/example/embedded/gatt_browser.c
+++ b/example/embedded/gatt_browser.c
@@ -244,7 +244,7 @@ static void extract_service(le_service_t * service, uint8_t * packet){
     service->start_group_handle = little_endian_read_16(packet, 4);
     service->end_group_handle   = little_endian_read_16(packet, 6);
     service->uuid16 = 0;
-    swap128(&packet[8], service->uuid128);
+    reverse_128(&packet[8], service->uuid128);
     if (uuid_has_bluetooth_prefix(service->uuid128)){
         service->uuid16 = big_endian_read_32(service->uuid128, 0);
     }
@@ -256,7 +256,7 @@ static void extract_characteristic(le_characteristic_t * characteristic, uint8_t
     characteristic->end_handle =   little_endian_read_16(packet, 8);
     characteristic->properties =   little_endian_read_16(packet, 10);
     characteristic->uuid16 = 0;
-    swap128(&packet[12], characteristic->uuid128);
+    reverse_128(&packet[12], characteristic->uuid128);
     if (uuid_has_bluetooth_prefix(characteristic->uuid128)){
         characteristic->uuid16 = big_endian_read_32(characteristic->uuid128, 0);
     }
diff --git a/example/embedded/hsp_hs_test.c b/example/embedded/hsp_hs_test.c
index bc2ac160e..f0edfc3c6 100644
--- a/example/embedded/hsp_hs_test.c
+++ b/example/embedded/hsp_hs_test.c
@@ -151,7 +151,6 @@ static void sco_packet_handler(uint8_t packet_type, uint8_t * packet, uint16_t s
     count++;
     if ((count & 15)) return;
     printf("SCO packets %u\n", count);
-    // hexdumpf(packet, size);
 }
 
 static void packet_handler(uint8_t * event, uint16_t event_size){
diff --git a/platform/daemon/daemon.c b/platform/daemon/daemon.c
index 61eba9652..c1906bc4c 100644
--- a/platform/daemon/daemon.c
+++ b/platform/daemon/daemon.c
@@ -846,13 +846,13 @@ btstack_linked_list_gatt_client_helper_t * daemon_setup_gatt_client_request(conn
 void daemon_gatt_deserialize_service(uint8_t *packet, int offset, le_service_t *service){
     service->start_group_handle = little_endian_read_16(packet, offset);
     service->end_group_handle = little_endian_read_16(packet, offset + 2);
-    swap128(&packet[offset + 4], service->uuid128);
+    reverse_128(&packet[offset + 4], service->uuid128);
 }
 
 void daemon_gatt_serialize_service(le_service_t * service, uint8_t * event, int offset){
     little_endian_store_16(event, offset, service->start_group_handle);
     little_endian_store_16(event, offset+2, service->end_group_handle);
-    swap128(service->uuid128, &event[offset + 4]);
+    reverse_128(service->uuid128, &event[offset + 4]);
 }
 
 void daemon_gatt_deserialize_characteristic(uint8_t * packet, int offset, le_characteristic_t * characteristic){
@@ -861,7 +861,7 @@ void daemon_gatt_deserialize_characteristic(uint8_t * packet, int offset, le_cha
     characteristic->end_handle = little_endian_read_16(packet, offset + 4);
     characteristic->properties = little_endian_read_16(packet, offset + 6);
     characteristic->uuid16 = little_endian_read_16(packet, offset + 8);
-    swap128(&packet[offset+10], characteristic->uuid128);
+    reverse_128(&packet[offset+10], characteristic->uuid128);
 }
 
 void daemon_gatt_serialize_characteristic(le_characteristic_t * characteristic, uint8_t * event, int offset){
@@ -869,17 +869,17 @@ void daemon_gatt_serialize_characteristic(le_characteristic_t * characteristic,
     little_endian_store_16(event, offset+2, characteristic->value_handle);
     little_endian_store_16(event, offset+4, characteristic->end_handle);
     little_endian_store_16(event, offset+6, characteristic->properties);
-    swap128(characteristic->uuid128, &event[offset+8]);
+    reverse_128(characteristic->uuid128, &event[offset+8]);
 }
 
 void daemon_gatt_deserialize_characteristic_descriptor(uint8_t * packet, int offset, le_characteristic_descriptor_t * descriptor){
     descriptor->handle = little_endian_read_16(packet, offset);
-    swap128(&packet[offset+2], descriptor->uuid128);
+    reverse_128(&packet[offset+2], descriptor->uuid128);
 }
 
 void daemon_gatt_serialize_characteristic_descriptor(le_characteristic_descriptor_t * characteristic_descriptor, uint8_t * event, int offset){
     little_endian_store_16(event, offset, characteristic_descriptor->handle);
-    swap128(characteristic_descriptor->uuid128, &event[offset+2]);
+    reverse_128(characteristic_descriptor->uuid128, &event[offset+2]);
 }
 
 #endif
@@ -1179,7 +1179,7 @@ static int btstack_command_handler(connection_t *connection, uint8_t *packet, ui
         case GATT_DISCOVER_PRIMARY_SERVICES_BY_UUID128:
             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
             if (!gatt_helper) break;
-            swap128(&packet[5], uuid128);
+            reverse_128(&packet[5], uuid128);
             gatt_client_discover_primary_services_by_uuid128(gatt_client_id, gatt_helper->con_handle, uuid128);
             break;
         case GATT_FIND_INCLUDED_SERVICES_FOR_SERVICE:
@@ -1199,7 +1199,7 @@ static int btstack_command_handler(connection_t *connection, uint8_t *packet, ui
             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
             if (!gatt_helper) break;
             daemon_gatt_deserialize_service(packet, 5, &service);
-            swap128(&packet[5 + SERVICE_LENGTH], uuid128);
+            reverse_128(&packet[5 + SERVICE_LENGTH], uuid128);
             gatt_client_discover_characteristics_for_service_by_uuid128(gatt_client_id, gatt_helper->con_handle, &service, uuid128);
             break;
         case GATT_DISCOVER_CHARACTERISTIC_DESCRIPTORS:
diff --git a/src/ble/ad_parser.c b/src/ble/ad_parser.c
index 1b01015c4..1a3abfc71 100644
--- a/src/ble/ad_parser.c
+++ b/src/ble/ad_parser.c
@@ -109,7 +109,7 @@ int ad_data_contains_uuid16(uint8_t ad_len, uint8_t * ad_data, uint16_t uuid16){
             case IncompleteList128:
             case CompleteList128:
                 uuid_add_bluetooth_prefix(ad_uuid128, uuid16);
-                swap128(ad_uuid128, uuid128_bt);
+                reverse_128(ad_uuid128, uuid128_bt);
             
                 for (i=0; i<data_len; i+=16){
                     if (memcmp(uuid128_bt, &data[i], 16) == 0) return 1;
@@ -126,7 +126,7 @@ int ad_data_contains_uuid128(uint8_t ad_len, uint8_t * ad_data, uint8_t * uuid12
     ad_context_t context;
     // input in big endian/network order, bluetooth data in little endian
     uint8_t uuid128_le[16];
-    swap128(uuid128, uuid128_le);
+    reverse_128(uuid128, uuid128_le);
     for (ad_iterator_init(&context, ad_len, ad_data) ; ad_iterator_has_more(&context) ; ad_iterator_next(&context)){
         uint8_t data_type = ad_iterator_get_data_type(&context);
         uint8_t data_len  = ad_iterator_get_data_len(&context);
diff --git a/src/ble/ancs_client.c b/src/ble/ancs_client.c
index 09f82ac30..f041d8a94 100644
--- a/src/ble/ancs_client.c
+++ b/src/ble/ancs_client.c
@@ -178,7 +178,7 @@ static void extract_service(le_service_t * service, uint8_t * packet){
     service->start_group_handle = little_endian_read_16(packet, 4);
     service->end_group_handle   = little_endian_read_16(packet, 6);
     service->uuid16 = 0;
-    swap128(&packet[8], service->uuid128);
+    reverse_128(&packet[8], service->uuid128);
     if (uuid_has_bluetooth_prefix(service->uuid128)){
         service->uuid16 = big_endian_read_32(service->uuid128, 0);
     }
@@ -190,7 +190,7 @@ static void extract_characteristic(le_characteristic_t * characteristic, uint8_t
     characteristic->end_handle =   little_endian_read_16(packet, 8);
     characteristic->properties =   little_endian_read_16(packet, 10);
     characteristic->uuid16 = 0;
-    swap128(&packet[12], characteristic->uuid128);
+    reverse_128(&packet[12], characteristic->uuid128);
     if (uuid_has_bluetooth_prefix(characteristic->uuid128)){
         characteristic->uuid16 = big_endian_read_32(characteristic->uuid128, 0);
     }
diff --git a/src/ble/att.c b/src/ble/att.c
index 6b24002f4..7330c2d86 100644
--- a/src/ble/att.c
+++ b/src/ble/att.c
@@ -208,7 +208,7 @@ void att_dump_attributes(void){
         }
         log_info("Handle: 0x%04x, flags: 0x%04x, uuid: ", it.handle, it.flags);
         if (it.flags & ATT_PROPERTY_UUID128){
-            swap128(it.uuid, uuid128);
+            reverse_128(it.uuid, uuid128);
             log_info("%s", uuid128_to_str(uuid128));
         } else {
             log_info("%04x", little_endian_read_16(it.uuid, 0));
diff --git a/src/ble/att_db_util.c b/src/ble/att_db_util.c
index 15090c7ef..034ac8ea0 100644
--- a/src/ble/att_db_util.c
+++ b/src/ble/att_db_util.c
@@ -131,7 +131,7 @@ static void att_db_util_add_attribute_uuid128(uint8_t * uuid128, uint16_t flags,
 	little_endian_store_16(att_db, att_db_size, att_db_next_handle);
 	att_db_size += 2;
 	att_db_next_handle++;
-	swap128(uuid128, &att_db[att_db_size]);
+	reverse_128(uuid128, &att_db[att_db_size]);
 	att_db_size += 16;
 	memcpy(&att_db[att_db_size], data, data_len);
 	att_db_size += data_len;
@@ -146,7 +146,7 @@ void att_db_util_add_service_uuid16(uint16_t uuid16){
 
 void att_db_util_add_service_uuid128(uint8_t * uuid128){
 	uint8_t buffer[16];
-	swap128(uuid128, buffer);
+	reverse_128(uuid128, buffer);
 	att_db_util_add_attribute_uuid16(GATT_PRIMARY_SERVICE_UUID, ATT_PROPERTY_READ, buffer, 16);
 }
 
@@ -170,7 +170,7 @@ uint16_t att_db_util_add_characteristic_uuid128(uint8_t * uuid128, uint16_t prop
 	uint8_t buffer[19];
 	buffer[0] = properties;
 	little_endian_store_16(buffer, 1, att_db_next_handle + 1);
-	swap128(uuid128, &buffer[3]);
+	reverse_128(uuid128, &buffer[3]);
 	att_db_util_add_attribute_uuid16(GATT_CHARACTERISTICS_UUID, ATT_PROPERTY_READ, buffer, sizeof(buffer));
 	uint16_t value_handle = att_db_next_handle;
 	att_db_util_add_attribute_uuid128(uuid128, properties, data, data_len);
diff --git a/src/ble/att_server.c b/src/ble/att_server.c
index c4dab8083..9368b399c 100644
--- a/src/ble/att_server.c
+++ b/src/ble/att_server.c
@@ -221,7 +221,7 @@ static void att_signed_write_handle_cmac_result(uint8_t hash[8]){
     if (att_server_state != ATT_SERVER_W4_SIGNED_WRITE_VALIDATION) return;
 
     uint8_t hash_flipped[8];
-    swap64(hash, hash_flipped);
+    reverse_64(hash, hash_flipped);
     if (memcmp(hash_flipped, &att_request_buffer[att_request_size-8], 8)){
         log_info("ATT Signed Write, invalid signature");
         att_server_state = ATT_SERVER_IDLE;
diff --git a/src/ble/gatt_client.c b/src/ble/gatt_client.c
index d6bd69da6..08c3eb5ba 100644
--- a/src/ble/gatt_client.c
+++ b/src/ble/gatt_client.c
@@ -287,7 +287,7 @@ static void att_read_by_type_or_group_request_for_uuid128(uint16_t request_type,
     request[0] = request_type;
     little_endian_store_16(request, 1, start_handle);
     little_endian_store_16(request, 3, end_handle);
-    swap128(uuid128, &request[5]);
+    reverse_128(uuid128, &request[5]);
     
     l2cap_send_prepared_connectionless(peripheral_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, 21);
 }
@@ -334,7 +334,7 @@ static void att_signed_write_request(uint16_t request_type, uint16_t peripheral_
     little_endian_store_16(request, 1, attribute_handle);
     memcpy(&request[3], value, value_length);
     little_endian_store_32(request, 3 + value_length, sign_counter);
-    swap64(sgn, &request[3 + value_length + 4]);
+    reverse_64(sgn, &request[3 + value_length + 4]);
     l2cap_send_prepared_connectionless(peripheral_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, 3 + value_length + 12);
 }
 
@@ -403,7 +403,7 @@ static void send_gatt_by_uuid_request(gatt_client_t *peripheral, uint16_t attrib
         return;
     }
     uint8_t uuid128[16];
-    swap128(peripheral->uuid128, uuid128);
+    reverse_128(peripheral->uuid128, uuid128);
     att_find_by_type_value_request(ATT_FIND_BY_TYPE_VALUE_REQUEST, attribute_group_type, peripheral->handle, peripheral->start_group_handle, peripheral->end_group_handle, uuid128, 16);
 }
 
@@ -533,7 +533,7 @@ static void emit_gatt_service_query_result_event(gatt_client_t * peripheral, uin
     ///
     little_endian_store_16(packet, 4, start_group_handle);
     little_endian_store_16(packet, 6, end_group_handle);
-    swap128(uuid128, &packet[8]);
+    reverse_128(uuid128, &packet[8]);
     emit_event_new(peripheral->subclient_id, packet, sizeof(packet));
 }
 
@@ -548,7 +548,7 @@ static void emit_gatt_included_service_query_result_event(gatt_client_t * periph
     //
     little_endian_store_16(packet, 6, start_group_handle);
     little_endian_store_16(packet, 8, end_group_handle);
-    swap128(uuid128, &packet[10]);
+    reverse_128(uuid128, &packet[10]);
     emit_event_new(peripheral->subclient_id, packet, sizeof(packet));
 }
 
@@ -564,7 +564,7 @@ static void emit_gatt_characteristic_query_result_event(gatt_client_t * peripher
     little_endian_store_16(packet, 6,  value_handle);
     little_endian_store_16(packet, 8,  end_handle);
     little_endian_store_16(packet, 10, properties);
-    swap128(uuid128, &packet[12]);
+    reverse_128(uuid128, &packet[12]);
     emit_event_new(peripheral->subclient_id, packet, sizeof(packet));
 }
 
@@ -577,7 +577,7 @@ static void emit_gatt_all_characteristic_descriptors_result_event(
     little_endian_store_16(packet, 2, peripheral->handle);
     ///
     little_endian_store_16(packet, 4,  descriptor_handle);
-    swap128(uuid128, &packet[6]);
+    reverse_128(uuid128, &packet[6]);
     emit_event_new(peripheral->subclient_id, packet, sizeof(packet));
 }
 ///
@@ -597,7 +597,7 @@ static void report_gatt_services(gatt_client_t * peripheral, uint8_t * packet,
             uuid16 = little_endian_read_16(packet, i+4);
             uuid_add_bluetooth_prefix((uint8_t*) &uuid128, uuid16);
         } else {
-            swap128(&packet[i+4], uuid128);
+            reverse_128(&packet[i+4], uuid128);
         }
         emit_gatt_service_query_result_event(peripheral, start_group_handle, end_group_handle, uuid128);
     }
@@ -612,7 +612,7 @@ static void characteristic_start_found(gatt_client_t * peripheral, uint16_t star
         uuid16 = little_endian_read_16(uuid, 0);
         uuid_add_bluetooth_prefix((uint8_t*) uuid128, uuid16);
     } else {
-        swap128(uuid, uuid128);
+        reverse_128(uuid, uuid128);
     }
     
     if (peripheral->filter_with_uuid && memcmp(peripheral->uuid128, uuid128, 16) != 0) return;
@@ -744,7 +744,7 @@ static void report_gatt_all_characteristic_descriptors(gatt_client_t * periphera
             uuid16 = little_endian_read_16(packet,i+2);
             uuid_add_bluetooth_prefix(uuid128, uuid16);
         } else {
-            swap128(&packet[i+2], uuid128);
+            reverse_128(&packet[i+2], uuid128);
         }        
         emit_gatt_all_characteristic_descriptors_result_event(peripheral, descriptor_handle, uuid128);
     }
@@ -1166,7 +1166,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
             switch (peripheral->gatt_client_state){
                 case P_W4_INCLUDED_SERVICE_UUID_WITH_QUERY_RESULT: {
                     uint8_t uuid128[16];
-                    swap128(&packet[1], uuid128);
+                    reverse_128(&packet[1], uuid128);
                     report_gatt_included_service_uuid128(peripheral, peripheral->start_group_handle, uuid128);
                     trigger_next_included_service_query(peripheral, peripheral->start_group_handle);
                     // GATT_EVENT_QUERY_COMPLETE is emitted by trigger_next_xxx when done
@@ -1385,7 +1385,7 @@ static void att_signed_write_handle_cmac_result(uint8_t hash[8]){
         if (peripheral->gatt_client_state == P_W4_CMAC_RESULT){
             // store result
             memcpy(peripheral->cmac, hash, 8);
-            // swap64(hash, peripheral->cmac);
+            // reverse_64(hash, peripheral->cmac);
             peripheral->gatt_client_state = P_W2_SEND_SIGNED_WRITE;
             gatt_client_run();
             return;
diff --git a/src/ble/sm.c b/src/ble/sm.c
index 5348b4755..c3c43eec8 100644
--- a/src/ble/sm.c
+++ b/src/ble/sm.c
@@ -381,8 +381,8 @@ static void sm_random_start(void * context){
 static void sm_aes128_start(sm_key_t key, sm_key_t plaintext, void * context){
     sm_aes128_state = SM_AES128_ACTIVE;
     sm_key_t key_flipped, plaintext_flipped;
-    swap128(key, key_flipped);
-    swap128(plaintext, plaintext_flipped);
+    reverse_128(key, key_flipped);
+    reverse_128(plaintext, plaintext_flipped);
     sm_aes128_context = context;
     hci_send_cmd(&hci_le_encrypt, key_flipped, plaintext_flipped);
 }
@@ -425,8 +425,8 @@ static void sm_c1_t1(sm_key_t r, uint8_t preq[7], uint8_t pres[7], uint8_t iat,
     // p1 is 0x05000800000302070710000001010001."
     
     sm_key_t p1;
-    swap56(pres, &p1[0]);
-    swap56(preq, &p1[7]);
+    reverse_56(pres, &p1[0]);
+    reverse_56(preq, &p1[7]);
     p1[14] = rat;
     p1[15] = iat;
     log_key("p1", p1);
@@ -1329,7 +1329,7 @@ static void sm_run(void){
             // initiator side
             case SM_INITIATOR_PH0_SEND_START_ENCRYPTION: {
                 sm_key_t peer_ltk_flipped;
-                swap128(setup->sm_peer_ltk, peer_ltk_flipped);
+                reverse_128(setup->sm_peer_ltk, peer_ltk_flipped);
                 connection->sm_engine_state = SM_INITIATOR_PH0_W4_CONNECTION_ENCRYPTED;
                 log_info("sm: hci_le_start_encryption ediv 0x%04x", setup->sm_peer_ediv);
                 uint32_t rand_high = big_endian_read_32(setup->sm_peer_rand, 0);
@@ -1366,7 +1366,7 @@ static void sm_run(void){
             case SM_PH2_SEND_PAIRING_RANDOM: {
                 uint8_t buffer[17];
                 buffer[0] = SM_CODE_PAIRING_RANDOM;
-                swap128(setup->sm_local_random, &buffer[1]);
+                reverse_128(setup->sm_local_random, &buffer[1]);
                 if (connection->sm_role){
                     connection->sm_engine_state = SM_RESPONDER_PH2_W4_LTK_REQUEST;
                 } else {
@@ -1457,7 +1457,7 @@ static void sm_run(void){
             case SM_PH2_C1_SEND_PAIRING_CONFIRM: {
                 uint8_t buffer[17];
                 buffer[0] = SM_CODE_PAIRING_CONFIRM;
-                swap128(setup->sm_local_confirm, &buffer[1]);
+                reverse_128(setup->sm_local_confirm, &buffer[1]);
                 if (connection->sm_role){
                     connection->sm_engine_state = SM_RESPONDER_PH2_W4_PAIRING_RANDOM;
                 } else {
@@ -1469,21 +1469,21 @@ static void sm_run(void){
             }
             case SM_RESPONDER_PH2_SEND_LTK_REPLY: {
                 sm_key_t stk_flipped;
-                swap128(setup->sm_ltk, stk_flipped);
+                reverse_128(setup->sm_ltk, stk_flipped);
                 connection->sm_engine_state = SM_PH2_W4_CONNECTION_ENCRYPTED;
                 hci_send_cmd(&hci_le_long_term_key_request_reply, connection->sm_handle, stk_flipped);
                 return;
             }
             case SM_INITIATOR_PH3_SEND_START_ENCRYPTION: {
                 sm_key_t stk_flipped;
-                swap128(setup->sm_ltk, stk_flipped);
+                reverse_128(setup->sm_ltk, stk_flipped);
                 connection->sm_engine_state = SM_PH2_W4_CONNECTION_ENCRYPTED;
                 hci_send_cmd(&hci_le_start_encryption, connection->sm_handle, 0, 0, 0, stk_flipped);
                 return;
             }
             case SM_RESPONDER_PH4_SEND_LTK: {
                 sm_key_t ltk_flipped;
-                swap128(setup->sm_ltk, ltk_flipped);
+                reverse_128(setup->sm_ltk, ltk_flipped);
                 connection->sm_engine_state = SM_RESPONDER_IDLE;
                 hci_send_cmd(&hci_le_long_term_key_request_reply, connection->sm_handle, ltk_flipped);
                 return;
@@ -1503,7 +1503,7 @@ static void sm_run(void){
                     setup->sm_key_distribution_send_set &= ~SM_KEYDIST_FLAG_ENCRYPTION_INFORMATION;
                     uint8_t buffer[17];
                     buffer[0] = SM_CODE_ENCRYPTION_INFORMATION;
-                    swap128(setup->sm_ltk, &buffer[1]);
+                    reverse_128(setup->sm_ltk, &buffer[1]);
                     l2cap_send_connectionless(connection->sm_handle, L2CAP_CID_SECURITY_MANAGER_PROTOCOL, (uint8_t*) buffer, sizeof(buffer));
                     sm_timeout_reset(connection);
                     return;
@@ -1513,7 +1513,7 @@ static void sm_run(void){
                     uint8_t buffer[11];
                     buffer[0] = SM_CODE_MASTER_IDENTIFICATION;
                     little_endian_store_16(buffer, 1, setup->sm_local_ediv);
-                    swap64(setup->sm_local_rand, &buffer[3]);
+                    reverse_64(setup->sm_local_rand, &buffer[3]);
                     l2cap_send_connectionless(connection->sm_handle, L2CAP_CID_SECURITY_MANAGER_PROTOCOL, (uint8_t*) buffer, sizeof(buffer));
                     sm_timeout_reset(connection);
                     return;
@@ -1522,7 +1522,7 @@ static void sm_run(void){
                     setup->sm_key_distribution_send_set &= ~SM_KEYDIST_FLAG_IDENTITY_INFORMATION;
                     uint8_t buffer[17];
                     buffer[0] = SM_CODE_IDENTITY_INFORMATION;
-                    swap128(sm_persistent_irk, &buffer[1]);
+                    reverse_128(sm_persistent_irk, &buffer[1]);
                     l2cap_send_connectionless(connection->sm_handle, L2CAP_CID_SECURITY_MANAGER_PROTOCOL, (uint8_t*) buffer, sizeof(buffer));
                     sm_timeout_reset(connection);
                     return;
@@ -1548,7 +1548,7 @@ static void sm_run(void){
 
                     uint8_t buffer[17];
                     buffer[0] = SM_CODE_SIGNING_INFORMATION;
-                    swap128(setup->sm_local_csrk, &buffer[1]);
+                    reverse_128(setup->sm_local_csrk, &buffer[1]);
                     l2cap_send_connectionless(connection->sm_handle, L2CAP_CID_SECURITY_MANAGER_PROTOCOL, (uint8_t*) buffer, sizeof(buffer));
                     sm_timeout_reset(connection);
                     return;
@@ -1589,7 +1589,7 @@ static void sm_handle_encryption_result(uint8_t * data){
         sm_address_resolution_ah_calculation_active = 0;
         // compare calulated address against connecting device
         uint8_t hash[3];
-        swap24(data, hash);
+        reverse_24(data, hash);
         if (memcmp(&sm_address_resolution_address[3], hash, 3) == 0){
             log_info("LE Device Lookup: matched resolvable private address");
             sm_address_resolution_handle_event(ADDRESS_RESOLUTION_SUCEEDED);
@@ -1602,12 +1602,12 @@ static void sm_handle_encryption_result(uint8_t * data){
 
     switch (dkg_state){
         case DKG_W4_IRK:
-            swap128(data, sm_persistent_irk);
+            reverse_128(data, sm_persistent_irk);
             log_key("irk", sm_persistent_irk);
             dkg_next_state();
             return;
         case DKG_W4_DHK:
-            swap128(data, sm_persistent_dhk);
+            reverse_128(data, sm_persistent_dhk);
             log_key("dhk", sm_persistent_dhk);
             dkg_next_state();
             // SM Init Finished
@@ -1618,7 +1618,7 @@ static void sm_handle_encryption_result(uint8_t * data){
 
     switch (rau_state){
         case RAU_W4_ENC:
-            swap24(data, &sm_random_address[3]);
+            reverse_24(data, &sm_random_address[3]);
             rau_next_state();
             return;
         default:
@@ -1631,7 +1631,7 @@ static void sm_handle_encryption_result(uint8_t * data){
         case CMAC_W4_MLAST:
             {
             sm_key_t t;
-            swap128(data, t);
+            reverse_128(data, t);
             sm_cmac_handle_encryption_result(t);
             }
             return;
@@ -1647,20 +1647,20 @@ static void sm_handle_encryption_result(uint8_t * data){
         case SM_PH2_C1_W4_ENC_C:
             {
             sm_key_t t2;
-            swap128(data, t2);
+            reverse_128(data, t2);
             sm_c1_t3(t2, setup->sm_m_address, setup->sm_s_address, setup->sm_c1_t3_value);
             }
             sm_next_responding_state(connection);
             return;
         case SM_PH2_C1_W4_ENC_B:
-            swap128(data, setup->sm_local_confirm);
+            reverse_128(data, setup->sm_local_confirm);
             log_key("c1!", setup->sm_local_confirm);
             connection->sm_engine_state = SM_PH2_C1_SEND_PAIRING_CONFIRM;
             return;
         case SM_PH2_C1_W4_ENC_D:
             {
             sm_key_t peer_confirm_test;
-            swap128(data, peer_confirm_test);
+            reverse_128(data, peer_confirm_test);
             log_key("c1!", peer_confirm_test);
             if (memcmp(setup->sm_peer_confirm, peer_confirm_test, 16) != 0){
                 setup->sm_pairing_failed_reason = SM_REASON_CONFIRM_VALUE_FAILED;
@@ -1675,7 +1675,7 @@ static void sm_handle_encryption_result(uint8_t * data){
             }
             return;
         case SM_PH2_W4_STK:
-            swap128(data, setup->sm_ltk);
+            reverse_128(data, setup->sm_ltk);
             sm_truncate_key(setup->sm_ltk, connection->sm_actual_encryption_key_size);
             log_key("stk", setup->sm_ltk);
             if (connection->sm_role){
@@ -1686,7 +1686,7 @@ static void sm_handle_encryption_result(uint8_t * data){
             return;
         case SM_PH3_Y_W4_ENC:{
             sm_key_t y128;
-            swap128(data, y128);
+            reverse_128(data, y128);
             setup->sm_local_y = big_endian_read_16(y128, 14);
             log_info_hex16("y", setup->sm_local_y);
             // PH3B3 - calculate EDIV
@@ -1699,7 +1699,7 @@ static void sm_handle_encryption_result(uint8_t * data){
         }
         case SM_RESPONDER_PH4_Y_W4_ENC:{
             sm_key_t y128;
-            swap128(data, y128);
+            reverse_128(data, y128);
             setup->sm_local_y = big_endian_read_16(y128, 14);
             log_info_hex16("y", setup->sm_local_y);
 
@@ -1712,13 +1712,13 @@ static void sm_handle_encryption_result(uint8_t * data){
             return;
         }
         case SM_PH3_LTK_W4_ENC:
-            swap128(data, setup->sm_ltk);
+            reverse_128(data, setup->sm_ltk);
             log_key("ltk", setup->sm_ltk);
             // calc CSRK next
             connection->sm_engine_state = SM_PH3_CSRK_GET_ENC;
             return;
         case SM_PH3_CSRK_W4_ENC:
-            swap128(data, setup->sm_local_csrk);
+            reverse_128(data, setup->sm_local_csrk);
             log_key("csrk", setup->sm_local_csrk);
             if (setup->sm_key_distribution_send_set){
                 connection->sm_engine_state = SM_PH3_DISTRIBUTE_KEYS;
@@ -1735,7 +1735,7 @@ static void sm_handle_encryption_result(uint8_t * data){
             }
             return;                                
         case SM_RESPONDER_PH4_LTK_W4_ENC:
-            swap128(data, setup->sm_ltk);
+            reverse_128(data, setup->sm_ltk);
             sm_truncate_key(setup->sm_ltk, connection->sm_actual_encryption_key_size);
             log_key("ltk", setup->sm_ltk);
             connection->sm_engine_state = SM_RESPONDER_PH4_SEND_LTK;
@@ -1808,7 +1808,7 @@ static void sm_handle_random_result(uint8_t * data){
             connection->sm_engine_state = SM_PH2_C1_GET_ENC_A;
             return;
         case SM_PH3_W4_RANDOM:
-            swap64(data, setup->sm_local_rand);
+            reverse_64(data, setup->sm_local_rand);
             // no db for encryption size hack: encryption size is stored in lowest nibble of setup->sm_local_rand
             setup->sm_local_rand[7] = (setup->sm_local_rand[7] & 0xf0) + (connection->sm_actual_encryption_key_size - 1);
             // no db for authenticated flag hack: store flag in bit 4 of LSB
@@ -1912,7 +1912,7 @@ static void sm_event_packet_handler (uint8_t packet_type, uint16_t channel, uint
                             }
 
                             // store rand and ediv
-                            swap64(&packet[5], sm_conn->sm_local_rand);
+                            reverse_64(&packet[5], sm_conn->sm_local_rand);
                             sm_conn->sm_local_ediv   = little_endian_read_16(packet, 13);
                             sm_conn->sm_engine_state = SM_RESPONDER_PH0_RECEIVED_LTK;
                             break;
@@ -2136,7 +2136,7 @@ static void sm_pdu_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet
             }
 
             // store s_confirm
-            swap128(&packet[1], setup->sm_peer_confirm);
+            reverse_128(&packet[1], setup->sm_peer_confirm);
             sm_conn->sm_engine_state = SM_PH2_SEND_PAIRING_RANDOM;
             break;
 
@@ -2147,7 +2147,7 @@ static void sm_pdu_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet
             }
 
             // received random value
-            swap128(&packet[1], setup->sm_peer_random);
+            reverse_128(&packet[1], setup->sm_peer_random);
             sm_conn->sm_engine_state = SM_PH2_C1_GET_ENC_C;
             break;
 
@@ -2172,7 +2172,7 @@ static void sm_pdu_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet
             }
 
             // received confirm value
-            swap128(&packet[1], setup->sm_peer_confirm);
+            reverse_128(&packet[1], setup->sm_peer_confirm);
 
             // notify client to hide shown passkey
             if (setup->sm_stk_generation_method == PK_INIT_INPUT){
@@ -2203,7 +2203,7 @@ static void sm_pdu_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet
             }
 
             // received random value
-            swap128(&packet[1], setup->sm_peer_random);
+            reverse_128(&packet[1], setup->sm_peer_random);
             sm_conn->sm_engine_state = SM_PH2_C1_GET_ENC_C;
             break;
 
@@ -2211,18 +2211,18 @@ static void sm_pdu_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet
             switch(packet[0]){
                 case SM_CODE_ENCRYPTION_INFORMATION:
                     setup->sm_key_distribution_received_set |= SM_KEYDIST_FLAG_ENCRYPTION_INFORMATION;
-                    swap128(&packet[1], setup->sm_peer_ltk);
+                    reverse_128(&packet[1], setup->sm_peer_ltk);
                     break;
 
                 case SM_CODE_MASTER_IDENTIFICATION:
                     setup->sm_key_distribution_received_set |= SM_KEYDIST_FLAG_MASTER_IDENTIFICATION;
                     setup->sm_peer_ediv = little_endian_read_16(packet, 1);
-                    swap64(&packet[3], setup->sm_peer_rand);
+                    reverse_64(&packet[3], setup->sm_peer_rand);
                     break;
 
                 case SM_CODE_IDENTITY_INFORMATION:
                     setup->sm_key_distribution_received_set |= SM_KEYDIST_FLAG_IDENTITY_INFORMATION;
-                    swap128(&packet[1], setup->sm_peer_irk);
+                    reverse_128(&packet[1], setup->sm_peer_irk);
                     break;
 
                 case SM_CODE_IDENTITY_ADDRESS_INFORMATION:
@@ -2233,7 +2233,7 @@ static void sm_pdu_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet
 
                 case SM_CODE_SIGNING_INFORMATION:
                     setup->sm_key_distribution_received_set |= SM_KEYDIST_FLAG_SIGNING_IDENTIFICATION;
-                    swap128(&packet[1], setup->sm_peer_csrk);
+                    reverse_128(&packet[1], setup->sm_peer_csrk);
                     break;
                 default:
                     // Unexpected PDU
diff --git a/src/btstack_event.h b/src/btstack_event.h
index 8728b8902..4e515e7e1 100644
--- a/src/btstack_event.h
+++ b/src/btstack_event.h
@@ -74,7 +74,7 @@ static inline uint8_t l2cap_event_channel_opened_get_status(const uint8_t * even
  * @note: btstack_type B
  */
 static inline void l2cap_event_channel_opened_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[3], address);    
+    reverse_48(&event[3], address);    
 }
 
 /**
@@ -174,7 +174,7 @@ static inline uint8_t l2cap_event_incoming_connection_get_status(const uint8_t *
  * @note: btstack_type B
  */
 static inline void l2cap_event_incoming_connection_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[3], address);    
+    reverse_48(&event[3], address);    
 }
 
 /**
@@ -324,7 +324,7 @@ static inline uint8_t rfcomm_event_open_channel_complete_get_status(const uint8_
  * @note: btstack_type B
  */
 static inline void rfcomm_event_open_channel_complete_get_bd_addr(const uint8_t * event, bd_addr_t bd_addr){
-    swap48(&event[3], bd_addr);    
+    reverse_48(&event[3], bd_addr);    
 }
 
 /**
@@ -384,7 +384,7 @@ static inline uint16_t rfcomm_event_channel_closed_get_rfcomm_cid(const uint8_t
  * @note: btstack_type B
  */
 static inline void rfcomm_event_incoming_connection_get_bd_addr(const uint8_t * event, bd_addr_t bd_addr){
-    swap48(&event[2], bd_addr);    
+    reverse_48(&event[2], bd_addr);    
 }
 
 /**
@@ -714,7 +714,7 @@ static inline uint8_t sm_event_just_works_request_get_addr_type(const uint8_t *
  * @note: btstack_type B
  */
 static inline void sm_event_just_works_request_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -744,7 +744,7 @@ static inline uint8_t sm_event_just_works_cancel_get_addr_type(const uint8_t * e
  * @note: btstack_type B
  */
 static inline void sm_event_just_works_cancel_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -774,7 +774,7 @@ static inline uint8_t sm_event_passkey_display_number_get_addr_type(const uint8_
  * @note: btstack_type B
  */
 static inline void sm_event_passkey_display_number_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -814,7 +814,7 @@ static inline uint8_t sm_event_passkey_display_cancel_get_addr_type(const uint8_
  * @note: btstack_type B
  */
 static inline void sm_event_passkey_display_cancel_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -844,7 +844,7 @@ static inline uint8_t sm_event_passkey_input_number_get_addr_type(const uint8_t
  * @note: btstack_type B
  */
 static inline void sm_event_passkey_input_number_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -874,7 +874,7 @@ static inline uint8_t sm_event_passkey_input_cancel_get_addr_type(const uint8_t
  * @note: btstack_type B
  */
 static inline void sm_event_passkey_input_cancel_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -904,7 +904,7 @@ static inline uint8_t sm_event_identity_resolving_started_get_addr_type(const ui
  * @note: btstack_type B
  */
 static inline void sm_event_identity_resolving_started_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -934,7 +934,7 @@ static inline uint8_t sm_event_identity_resolving_failed_get_addr_type(const uin
  * @note: btstack_type B
  */
 static inline void sm_event_identity_resolving_failed_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -964,7 +964,7 @@ static inline uint8_t sm_event_identity_resolving_succeeded_get_addr_type(const
  * @note: btstack_type B
  */
 static inline void sm_event_identity_resolving_succeeded_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -1004,7 +1004,7 @@ static inline uint8_t sm_event_authorization_request_get_addr_type(const uint8_t
  * @note: btstack_type B
  */
 static inline void sm_event_authorization_request_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
@@ -1034,7 +1034,7 @@ static inline uint8_t sm_event_authorization_result_get_addr_type(const uint8_t
  * @note: btstack_type B
  */
 static inline void sm_event_authorization_result_get_address(const uint8_t * event, bd_addr_t address){
-    swap48(&event[5], address);    
+    reverse_48(&event[5], address);    
 }
 
 /**
diff --git a/src/btstack_util.c b/src/btstack_util.c
index ac06ec8b1..8f86b1644 100644
--- a/src/btstack_util.c
+++ b/src/btstack_util.c
@@ -122,25 +122,25 @@ void bt_flip_addr(bd_addr_t dest, bd_addr_t src){
 }
 
 // general swap/endianess utils
-void swapX(const uint8_t *src, uint8_t *dst, int len){
+void reverse_bytes(const uint8_t *src, uint8_t *dst, int len){
     int i;
     for (i = 0; i < len; i++)
         dst[len - 1 - i] = src[i];
 }
-void swap24(const uint8_t * src, uint8_t * dst){
-    swapX(src, dst, 3);
+void reverse_24(const uint8_t * src, uint8_t * dst){
+    reverse_bytes(src, dst, 3);
 }
-void swap48(const uint8_t * src, uint8_t * dst){
-    swapX(src, dst, 6);
+void reverse_48(const uint8_t * src, uint8_t * dst){
+    reverse_bytes(src, dst, 6);
 }
-void swap56(const uint8_t * src, uint8_t * dst){
-    swapX(src, dst, 7);
+void reverse_56(const uint8_t * src, uint8_t * dst){
+    reverse_bytes(src, dst, 7);
 }
-void swap64(const uint8_t * src, uint8_t * dst){
-    swapX(src, dst, 8);
+void reverse_64(const uint8_t * src, uint8_t * dst){
+    reverse_bytes(src, dst, 8);
 }
-void swap128(const uint8_t * src, uint8_t * dst){
-    swapX(src, dst, 16);
+void reverse_128(const uint8_t * src, uint8_t * dst){
+    reverse_bytes(src, dst, 16);
 }
 
 char char_for_nibble(int nibble){
@@ -159,33 +159,6 @@ void printf_hexdump(const void *data, int size){
     printf("\n");
 }
 
-void hexdumpf(const void *data, int size){
-    char buffer[6*16+1];
-    int i, j;
-
-    uint8_t low = 0x0F;
-    uint8_t high = 0xF0;
-    j = 0;
-    for (i=0; i<size;i++){
-        uint8_t byte = ((uint8_t *)data)[i];
-        buffer[j++] = '0';
-        buffer[j++] = 'x';
-        buffer[j++] = char_for_nibble((byte & high) >> 4);
-        buffer[j++] = char_for_nibble(byte & low);
-        buffer[j++] = ',';
-        buffer[j++] = ' ';     
-        if (j >= 6*16 ){
-            buffer[j] = 0;
-            printf("%s\n", buffer);
-            j = 0;
-        }
-    }
-    if (j != 0){
-        buffer[j] = 0;
-        printf("%s\n", buffer);
-    }
-}
-
 //  void log_info_hexdump(..){
 //  
 //  }
diff --git a/src/btstack_util.h b/src/btstack_util.h
index c19b97eb7..c09c304df 100644
--- a/src/btstack_util.h
+++ b/src/btstack_util.h
@@ -58,9 +58,9 @@ extern "C" {
 #include "btstack_defines.h"
 #include "btstack_linked_list.h"
 	
-// hack: compilation with the android ndk causes an error as there's a swap64 macro
-#ifdef swap64
-#undef swap64
+// hack: compilation with the android ndk causes an error as there's a reverse_64 macro
+#ifdef reverse_64
+#undef reverse_64
 #endif
 
 // will be moved to daemon/btstack_device_name_db.h
@@ -112,13 +112,23 @@ void big_endian_store_32(uint8_t *buffer, uint16_t pos, uint32_t value);
 
 /**
  * @brief Copy from source to destination and reverse byte order
+ * @param src
+ * @param dest
+ * @param len
  */
-void swapX  (const uint8_t *src, uint8_t * dst, int len);
-void swap24 (const uint8_t *src, uint8_t * dst);
-void swap48 (const uint8_t *src, uint8_t * dst);
-void swap56 (const uint8_t *src, uint8_t * dst);
-void swap64 (const uint8_t *src, uint8_t * dst);
-void swap128(const uint8_t *src, uint8_t * dst);
+void reverse_bytes  (const uint8_t *src, uint8_t * dest, int len);
+
+/**
+ * @brief Wrapper around reverse_bytes for common buffer sizes
+ * @param src
+ * @param dest
+ */
+void reverse_24 (const uint8_t *src, uint8_t * dest);
+void reverse_48 (const uint8_t *src, uint8_t * dest);
+void reverse_56 (const uint8_t *src, uint8_t * dest);
+void reverse_64 (const uint8_t *src, uint8_t * dest);
+void reverse_128(const uint8_t *src, uint8_t * dest);
+
 void bt_flip_addr(bd_addr_t dest, bd_addr_t src);
 
 /** 
@@ -153,7 +163,6 @@ void log_key(const char * name, sm_key_t key);
 
 //
 void hexdump(const void *data, int size);
-void hexdumpf(const void *data, int size);
 
 /**
  * @brief Create human readable representation for UUID128
diff --git a/test/att_db/att_db_util_test.c b/test/att_db/att_db_util_test.c
index 78751a4c6..bf6f027ec 100644
--- a/test/att_db/att_db_util_test.c
+++ b/test/att_db/att_db_util_test.c
@@ -102,7 +102,6 @@ TEST(AttDbUtil, LeCounterDb){
     uint8_t * addr = att_db_util_get_address();
     uint16_t  size = att_db_util_get_size();
 
-    // hexdumpf(addr, size);    
     CHECK_EQUAL(size, (uint16_t)sizeof(profile_data));
     CHECK_EQUAL_ARRAY(profile_data, addr, size);
 }
diff --git a/test/gatt_client/gatt_client_test.c b/test/gatt_client/gatt_client_test.c
index 9ad958be1..327a98f75 100644
--- a/test/gatt_client/gatt_client_test.c
+++ b/test/gatt_client/gatt_client_test.c
@@ -161,7 +161,7 @@ static void handle_ble_client_event(uint8_t packet_type, uint16_t channel, uint8
 			service.start_group_handle = little_endian_read_16(packet, 4);
 			service.end_group_handle   = little_endian_read_16(packet, 6);
 			service.uuid16 = 0;
-			swap128(&packet[8], service.uuid128);
+			reverse_128(&packet[8], service.uuid128);
 			if (uuid_has_bluetooth_prefix(service.uuid128)){
 				service.uuid16 = big_endian_read_32(service.uuid128, 0);
 			}
@@ -172,7 +172,7 @@ static void handle_ble_client_event(uint8_t packet_type, uint16_t channel, uint8
 			service.start_group_handle = little_endian_read_16(packet, 6);
 			service.end_group_handle   = little_endian_read_16(packet, 8);
 			service.uuid16 = 0;
-			swap128(&packet[10], service.uuid128);
+			reverse_128(&packet[10], service.uuid128);
 			if (uuid_has_bluetooth_prefix(service.uuid128)){
 				service.uuid16 = big_endian_read_32(service.uuid128, 0);
 			}
@@ -185,7 +185,7 @@ static void handle_ble_client_event(uint8_t packet_type, uint16_t channel, uint8
         	characteristic.end_handle =   little_endian_read_16(packet, 8);
         	characteristic.properties =   little_endian_read_16(packet, 10);
 			characteristic.uuid16 = 0;
-			swap128(&packet[12], characteristic.uuid128);
+			reverse_128(&packet[12], characteristic.uuid128);
 			if (uuid_has_bluetooth_prefix(characteristic.uuid128)){
 				characteristic.uuid16 = big_endian_read_32(characteristic.uuid128, 0);
 			}
@@ -194,7 +194,7 @@ static void handle_ble_client_event(uint8_t packet_type, uint16_t channel, uint8
             break;
         case GATT_EVENT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT:
         	descriptor.handle = little_endian_read_16(packet, 4);
-			swap128(&packet[6], descriptor.uuid128);
+			reverse_128(&packet[6], descriptor.uuid128);
 			if (uuid_has_bluetooth_prefix(descriptor.uuid128)){
 				descriptor.uuid16 = big_endian_read_32(descriptor.uuid128, 0);
 			}
diff --git a/test/pts/ble_central_test.c b/test/pts/ble_central_test.c
index 4a2b6ce6a..072b4fd2f 100644
--- a/test/pts/ble_central_test.c
+++ b/test/pts/ble_central_test.c
@@ -413,7 +413,7 @@ static void extract_service(le_service_t * aService, uint8_t * data){
     aService->start_group_handle = little_endian_read_16(data, 0);
     aService->end_group_handle   = little_endian_read_16(data, 2);
     aService->uuid16 = 0;
-    swap128(&data[4], aService->uuid128);
+    reverse_128(&data[4], aService->uuid128);
     if (uuid_has_bluetooth_prefix(aService->uuid128)){
         aService->uuid16 = big_endian_read_32(aService->uuid128, 0);
     }
@@ -425,7 +425,7 @@ static void extract_characteristic(le_characteristic_t * characteristic, uint8_t
     characteristic->end_handle =   little_endian_read_16(packet, 8);
     characteristic->properties =   little_endian_read_16(packet, 10);
     characteristic->uuid16 = 0;
-    swap128(&packet[12], characteristic->uuid128);
+    reverse_128(&packet[12], characteristic->uuid128);
     if (uuid_has_bluetooth_prefix(characteristic->uuid128)){
         characteristic->uuid16 = big_endian_read_32(characteristic->uuid128, 0);
     }
@@ -515,7 +515,7 @@ static void handle_gatt_client_event(uint8_t packet_type, uint8_t *packet, uint1
         case GATT_EVENT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT: {
             uint16_t descriptor_handle = little_endian_read_16(packet, 4);
             uint8_t uuid128[16];
-            swap128(&packet[6], uuid128);
+            reverse_128(&packet[6], uuid128);
             if (uuid_has_bluetooth_prefix(uuid128)){
                 printf("Characteristic descriptor at 0x%04x with UUID %04x\n", descriptor_handle, big_endian_read_32(uuid128, 0));
             } else {
@@ -557,7 +557,7 @@ static void handle_gatt_client_event(uint8_t packet_type, uint8_t *packet, uint1
                                 printf("%04x\n", little_endian_read_16(value, 3));
                             } else {
                                 uint8_t uuid128[16];
-                                swap128(&value[3], uuid128);
+                                reverse_128(&value[3], uuid128);
                                 printUUID128(uuid128);
                                 printf("\n");
                             }
@@ -953,7 +953,7 @@ static void att_signed_write_handle_cmac_result(uint8_t hash[8]){
     little_endian_store_16(request, 1, pts_signed_write_characteristic_handle);
     memcpy(&request[3], signed_write_value, value_length);
     little_endian_store_32(request, 3 + value_length, 0);
-    swap64(hash, &request[3 + value_length + 4]);
+    reverse_64(hash, &request[3 + value_length + 4]);
     l2cap_send_prepared_connectionless(handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, 3 + value_length + 12);
 }
 
diff --git a/test/pts/bnep_test.c b/test/pts/bnep_test.c
index a45389265..5484e00e5 100644
--- a/test/pts/bnep_test.c
+++ b/test/pts/bnep_test.c
@@ -137,6 +137,33 @@ static uint8_t panu_sdp_record[200];
 
 static btstack_packet_callback_registration_t hci_event_callback_registration;
 
+static void hexdumpf(const void *data, int size){
+    char buffer[6*16+1];
+    int i, j;
+
+    uint8_t low = 0x0F;
+    uint8_t high = 0xF0;
+    j = 0;
+    for (i=0; i<size;i++){
+        uint8_t byte = ((uint8_t *)data)[i];
+        buffer[j++] = '0';
+        buffer[j++] = 'x';
+        buffer[j++] = char_for_nibble((byte & high) >> 4);
+        buffer[j++] = char_for_nibble(byte & low);
+        buffer[j++] = ',';
+        buffer[j++] = ' ';     
+        if (j >= 6*16 ){
+            buffer[j] = 0;
+            printf("%s\n", buffer);
+            j = 0;
+        }
+    }
+    if (j != 0){
+        buffer[j] = 0;
+        printf("%s\n", buffer);
+    }
+}
+
 static uint16_t setup_ethernet_header(int src_compressed, int dst_compressed, int broadcast, uint16_t network_protocol_type){
     // setup packet
     int pos = 0;
diff --git a/test/security_manager/mock.c b/test/security_manager/mock.c
index 475d64a5a..55bed6893 100644
--- a/test/security_manager/mock.c
+++ b/test/security_manager/mock.c
@@ -70,7 +70,7 @@ void aes128_report_result(void){
 	uint8_t le_enc_result[22];
 	uint8_t enc1_data[] = { 0x0e, 0x14, 0x01, 0x17, 0x20, 0x00 };
 	memcpy (le_enc_result, enc1_data, 6);
-	swap128(aes128_cyphertext, &le_enc_result[6]);
+	reverse_128(aes128_cyphertext, &le_enc_result[6]);
 	mock_simulate_hci_event(&le_enc_result[0], sizeof(le_enc_result));
 }
 
@@ -168,12 +168,12 @@ int hci_send_cmd(const hci_cmd_t *cmd, ...){
 	if (cmd->opcode ==  hci_le_encrypt.opcode){
 	    uint8_t * key_flipped = &packet_buffer[3];
 	    uint8_t key[16];
-		swap128(key_flipped, key);
+		reverse_128(key_flipped, key);
 	    // printf("le_encrypt key ");
 	    // hexdump(key, 16);
 	    uint8_t * plaintext_flipped = &packet_buffer[19];
 	    uint8_t plaintext[16];
- 		swap128(plaintext_flipped, plaintext);
+ 		reverse_128(plaintext_flipped, plaintext);
 	    // printf("le_encrypt txt ");
 	    // hexdump(plaintext, 16);
 	    aes128_calc_cyphertext(key, plaintext, aes128_cyphertext);
diff --git a/tool/btstack_event_generator.py b/tool/btstack_event_generator.py
index 1c1ecb7b6..14dfaf2dc 100755
--- a/tool/btstack_event_generator.py
+++ b/tool/btstack_event_generator.py
@@ -136,7 +136,7 @@ param_read = {
     '3' : 'return little_endian_read_24(event, {offset});',
     '4' : 'return little_endian_read_32(event, {offset});',
     'H' : 'return little_endian_read_16(event, {offset});',
-    'B' : 'swap48(&event[{offset}], {result_name});',
+    'B' : 'reverse_48(&event[{offset}], {result_name});',
     'R' : 'return &event[{offset}];',
     'T' : 'return (const char *) &event[{offset}];',
     'V' : 'return &event[{offset}];',