diff --git a/monitor/control.c b/monitor/control.c
index 756e97e..3ca56c7 100644
--- a/monitor/control.c
+++ b/monitor/control.c
#include "lib/hci.h"
#include "lib/mgmt.h"
+#include "src/shared/util.h"
#include "mainloop.h"
#include "display.h"
#include "packet.h"
return;
}
- flags = btohl(ev->flags);
+ flags = le32_to_cpu(ev->flags);
ba2str(&ev->addr.bdaddr, str);
printf("@ Device Connected: %s (%d) flags 0x%4.4x\n",
return;
}
- flags = btohl(ev->flags);
+ flags = le32_to_cpu(ev->flags);
ba2str(&ev->addr.bdaddr, str);
printf("@ Device Found: %s (%d) rssi %d flags 0x%4.4x\n",
ba2str(&ev->addr.bdaddr, str);
- passkey = btohl(ev->passkey);
+ passkey = le32_to_cpu(ev->passkey);
printf("@ Passkey Notify: %s (%d) passkey %06u entered %u\n",
str, ev->addr.type, passkey, ev->entered);
}
}
- opcode = btohs(hdr.opcode);
- index = btohs(hdr.index);
- pktlen = btohs(hdr.len);
+ opcode = le16_to_cpu(hdr.opcode);
+ index = le16_to_cpu(hdr.index);
+ pktlen = le16_to_cpu(hdr.len);
switch (data->channel) {
case HCI_CHANNEL_CONTROL:
if (data->offset > MGMT_HDR_SIZE) {
struct mgmt_hdr *hdr = (struct mgmt_hdr *) data->buf;
- uint16_t pktlen = btohs(hdr->len);
+ uint16_t pktlen = le16_to_cpu(hdr->len);
if (data->offset > pktlen + MGMT_HDR_SIZE) {
- uint16_t opcode = btohs(hdr->opcode);
- uint16_t index = btohs(hdr->index);
+ uint16_t opcode = le16_to_cpu(hdr->opcode);
+ uint16_t index = le16_to_cpu(hdr->index);
packet_monitor(NULL, index, opcode,
data->buf + MGMT_HDR_SIZE, pktlen);
diff --git a/monitor/l2cap.c b/monitor/l2cap.c
index c215882..60696bc 100644
--- a/monitor/l2cap.c
+++ b/monitor/l2cap.c
#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
#include <inttypes.h>
#include <bluetooth/bluetooth.h>
+#include "src/shared/util.h"
#include "bt.h"
#include "packet.h"
#include "display.h"
static void print_psm(uint16_t psm)
{
- print_field("PSM: %d (0x%4.4x)", btohs(psm), btohs(psm));
+ print_field("PSM: %d (0x%4.4x)", le16_to_cpu(psm), le16_to_cpu(psm));
}
static void print_cid(const char *type, uint16_t cid)
{
- print_field("%s CID: %d", type, btohs(cid));
+ print_field("%s CID: %d", type, le16_to_cpu(cid));
}
static void print_reject_reason(uint16_t reason)
{
const char *str;
- switch (btohs(reason)) {
+ switch (le16_to_cpu(reason)) {
case 0x0000:
str = "Command not understood";
break;
break;
}
- print_field("Reason: %s (0x%4.4x)", str, btohs(reason));
+ print_field("Reason: %s (0x%4.4x)", str, le16_to_cpu(reason));
}
static void print_conn_result(uint16_t result)
{
const char *str;
- switch (btohs(result)) {
+ switch (le16_to_cpu(result)) {
case 0x0000:
str = "Connection successful";
break;
break;
}
- print_field("Result: %s (0x%4.4x)", str, btohs(result));
+ print_field("Result: %s (0x%4.4x)", str, le16_to_cpu(result));
}
static void print_conn_status(uint16_t status)
{
const char *str;
- switch (btohs(status)) {
+ switch (le16_to_cpu(status)) {
case 0x0000:
str = "No further information available";
break;
break;
}
- print_field("Status: %s (0x%4.4x)", str, btohs(status));
+ print_field("Status: %s (0x%4.4x)", str, le16_to_cpu(status));
}
static void print_config_flags(uint16_t flags)
{
const char *str;
- if (btohs(flags) & 0x0001)
+ if (le16_to_cpu(flags) & 0x0001)
str = " (continuation)";
else
str = "";
- print_field("Flags: 0x%4.4x%s", btohs(flags), str);
+ print_field("Flags: 0x%4.4x%s", le16_to_cpu(flags), str);
}
static void print_config_result(uint16_t result)
{
const char *str;
- switch (btohs(result)) {
+ switch (le16_to_cpu(result)) {
case 0x0000:
str = "Success";
break;
break;
}
- print_field("Result: %s (0x%4.4x)", str, btohs(result));
+ print_field("Result: %s (0x%4.4x)", str, le16_to_cpu(result));
}
static struct {
{
const char *str;
- switch (btohs(type)) {
+ switch (le16_to_cpu(type)) {
case 0x0001:
str = "Connectionless MTU";
break;
break;
}
- print_field("Type: %s (0x%4.4x)", str, btohs(type));
+ print_field("Type: %s (0x%4.4x)", str, le16_to_cpu(type));
}
static void print_info_result(uint16_t result)
{
const char *str;
- switch (btohs(result)) {
+ switch (le16_to_cpu(result)) {
case 0x0000:
str = "Success";
break;
break;
}
- print_field("Result: %s (0x%4.4x)", str, btohs(result));
+ print_field("Result: %s (0x%4.4x)", str, le16_to_cpu(result));
}
static struct {
{
const char *str;
- switch (btohs(result)) {
+ switch (le16_to_cpu(result)) {
case 0x0000:
str = "Move success";
break;
break;
}
- print_field("Result: %s (0x%4.4x)", str, btohs(result));
+ print_field("Result: %s (0x%4.4x)", str, le16_to_cpu(result));
}
static void print_move_cfm_result(uint16_t result)
{
const char *str;
- switch (btohs(result)) {
+ switch (le16_to_cpu(result)) {
case 0x0000:
str = "Move success - both sides succeed";
break;
break;
}
- print_field("Result: %s (0x%4.4x)", str, btohs(result));
+ print_field("Result: %s (0x%4.4x)", str, le16_to_cpu(result));
}
static void print_conn_param_result(uint16_t result)
{
const char *str;
- switch (btohs(result)) {
+ switch (le16_to_cpu(result)) {
case 0x0000:
str = "Connection Parameters accepted";
break;
break;
}
- print_field("Result: %s (0x%4.4x)", str, btohs(result));
+ print_field("Result: %s (0x%4.4x)", str, le16_to_cpu(result));
}
static void sig_cmd_reject(const struct l2cap_frame *frame)
data += sizeof(*pdu);
size -= sizeof(*pdu);
- switch (btohs(pdu->reason)) {
+ switch (le16_to_cpu(pdu->reason)) {
case 0x0000:
if (size != 0) {
print_text(COLOR_ERROR, "invalid data size");
}
dcid = bt_get_le16(data);
scid = bt_get_le16(data + 2);
- print_cid("Destination", htobs(dcid));
- print_cid("Source", htobs(scid));
+ print_cid("Destination", cpu_to_le16(dcid));
+ print_cid("Source", cpu_to_le16(scid));
break;
default:
packet_hexdump(data, size);
print_psm(pdu->psm);
print_cid("Source", pdu->scid);
- assign_scid(frame, btohs(pdu->scid), btohs(pdu->psm), 0);
+ assign_scid(frame, le16_to_cpu(pdu->scid), le16_to_cpu(pdu->psm), 0);
}
static void sig_conn_rsp(const struct l2cap_frame *frame)
print_conn_result(pdu->result);
print_conn_status(pdu->status);
- assign_dcid(frame, btohs(pdu->dcid), btohs(pdu->scid));
+ assign_dcid(frame, le16_to_cpu(pdu->dcid), le16_to_cpu(pdu->scid));
}
static void sig_config_req(const struct l2cap_frame *frame)
print_cid("Destination", pdu->dcid);
print_config_flags(pdu->flags);
- print_config_options(frame, 4, btohs(pdu->dcid), false);
+ print_config_options(frame, 4, le16_to_cpu(pdu->dcid), false);
}
static void sig_config_rsp(const struct l2cap_frame *frame)
print_cid("Source", pdu->scid);
print_config_flags(pdu->flags);
print_config_result(pdu->result);
- print_config_options(frame, 6, btohs(pdu->scid), true);
+ print_config_options(frame, 6, le16_to_cpu(pdu->scid), true);
}
static void sig_disconn_req(const struct l2cap_frame *frame)
print_cid("Destination", pdu->dcid);
print_cid("Source", pdu->scid);
- release_scid(frame, btohs(pdu->scid));
+ release_scid(frame, le16_to_cpu(pdu->scid));
}
static void sig_echo_req(const struct l2cap_frame *frame)
data += sizeof(*pdu);
size -= sizeof(*pdu);
- if (btohs(pdu->result) != 0x0000) {
+ if (le16_to_cpu(pdu->result) != 0x0000) {
if (size > 0) {
print_text(COLOR_ERROR, "invalid data size");
packet_hexdump(data, size);
return;
}
- switch (btohs(pdu->type)) {
+ switch (le16_to_cpu(pdu->type)) {
case 0x0001:
if (size != 2) {
print_text(COLOR_ERROR, "invalid data size");
print_cid("Source", pdu->scid);
print_field("Controller ID: %d", pdu->ctrlid);
- assign_scid(frame, btohs(pdu->scid), btohs(pdu->psm), pdu->ctrlid);
+ assign_scid(frame, le16_to_cpu(pdu->scid), le16_to_cpu(pdu->psm),
+ pdu->ctrlid);
}
static void sig_create_chan_rsp(const struct l2cap_frame *frame)
print_conn_result(pdu->result);
print_conn_status(pdu->status);
- assign_dcid(frame, btohs(pdu->dcid), btohs(pdu->scid));
+ assign_dcid(frame, le16_to_cpu(pdu->dcid), le16_to_cpu(pdu->scid));
}
static void sig_move_chan_req(const struct l2cap_frame *frame)
{
const struct bt_l2cap_pdu_conn_param_req *pdu = frame->data;
- print_field("Min interval: %d", btohs(pdu->min_interval));
- print_field("Max interval: %d", btohs(pdu->max_interval));
- print_field("Slave latency: %d", btohs(pdu->latency));
- print_field("Timeout multiplier: %d", btohs(pdu->timeout));
+ print_field("Min interval: %d", le16_to_cpu(pdu->min_interval));
+ print_field("Max interval: %d", le16_to_cpu(pdu->max_interval));
+ print_field("Slave latency: %d", le16_to_cpu(pdu->latency));
+ print_field("Timeout multiplier: %d", le16_to_cpu(pdu->timeout));
}
static void sig_conn_param_rsp(const struct l2cap_frame *frame)
print_psm(pdu->psm);
print_cid("Source", pdu->scid);
- print_field("MTU: %u", btohs(pdu->mtu));
- print_field("MPS: %u", btohs(pdu->mps));
- print_field("Credits: %u", btohs(pdu->credits));
+ print_field("MTU: %u", le16_to_cpu(pdu->mtu));
+ print_field("MPS: %u", le16_to_cpu(pdu->mps));
+ print_field("Credits: %u", le16_to_cpu(pdu->credits));
- assign_scid(frame, btohs(pdu->scid), btohs(pdu->psm), 0);
+ assign_scid(frame, le16_to_cpu(pdu->scid), le16_to_cpu(pdu->psm), 0);
}
static void sig_le_conn_rsp(const struct l2cap_frame *frame)
const struct bt_l2cap_pdu_le_conn_rsp *pdu = frame->data;
print_cid("Destination", pdu->dcid);
- print_field("MTU: %u", btohs(pdu->mtu));
- print_field("MPS: %u", btohs(pdu->mps));
- print_field("Credits: %u", btohs(pdu->credits));
+ print_field("MTU: %u", le16_to_cpu(pdu->mtu));
+ print_field("MPS: %u", le16_to_cpu(pdu->mps));
+ print_field("Credits: %u", le16_to_cpu(pdu->credits));
print_conn_result(pdu->result);
- /*assign_dcid(frame, btohs(pdu->dcid), btohs(pdu->scid));*/
+ /*assign_dcid(frame, le16_to_cpu(pdu->dcid), le16_to_cpu(pdu->scid));*/
}
static void sig_le_flowctl_creds(const struct l2cap_frame *frame)
const struct bt_l2cap_pdu_le_flowctl_creds *pdu = frame->data;
print_cid("Source", pdu->cid);
- print_field("Credits: %u", btohs(pdu->credits));
+ print_field("Credits: %u", le16_to_cpu(pdu->credits));
}
struct sig_opcode_data {
return;
}
- len = btohs(hdr->len);
+ len = le16_to_cpu(hdr->len);
data += 4;
size -= 4;
return;
}
- len = btohs(hdr->len);
+ len = le16_to_cpu(hdr->len);
data += 4;
size -= 4;
return;
}
- psm = btohs(hdr->psm);
+ psm = le16_to_cpu(hdr->psm);
data += 2;
size -= 2;
{
const struct bt_l2cap_amp_cmd_reject *pdu = frame->data;
- print_field("Reason: 0x%4.4x", btohs(pdu->reason));
+ print_field("Reason: 0x%4.4x", le16_to_cpu(pdu->reason));
}
static void amp_discover_req(const struct l2cap_frame *frame)
{
const struct bt_l2cap_amp_discover_req *pdu = frame->data;
- print_field("MTU/MPS size: %d", btohs(pdu->size));
- print_field("Extended feature mask: 0x%4.4x", btohs(pdu->features));
+ print_field("MTU/MPS size: %d", le16_to_cpu(pdu->size));
+ print_field("Extended feature mask: 0x%4.4x",
+ le16_to_cpu(pdu->features));
}
static void amp_discover_rsp(const struct l2cap_frame *frame)
{
const struct bt_l2cap_amp_discover_rsp *pdu = frame->data;
- print_field("MTU/MPS size: %d", btohs(pdu->size));
- print_field("Extended feature mask: 0x%4.4x", btohs(pdu->features));
+ print_field("MTU/MPS size: %d", le16_to_cpu(pdu->size));
+ print_field("Extended feature mask: 0x%4.4x",
+ le16_to_cpu(pdu->features));
print_controller_list(frame->data + 4, frame->size - 4);
}
print_field("Status: %s (0x%2.2x)", str, pdu->status);
- print_field("Total bandwidth: %d kbps", btohl(pdu->total_bw));
- print_field("Max guaranteed bandwidth: %d kbps", btohl(pdu->max_bw));
- print_field("Min latency: %d", btohl(pdu->min_latency));
+ print_field("Total bandwidth: %d kbps", le32_to_cpu(pdu->total_bw));
+ print_field("Max guaranteed bandwidth: %d kbps",
+ le32_to_cpu(pdu->max_bw));
+ print_field("Min latency: %d", le32_to_cpu(pdu->min_latency));
- print_field("PAL capabilities: 0x%4.4x", btohs(pdu->pal_cap));
- print_field("Max ASSOC length: %d", btohs(pdu->max_assoc_len));
+ print_field("PAL capabilities: 0x%4.4x", le16_to_cpu(pdu->pal_cap));
+ print_field("Max ASSOC length: %d", le16_to_cpu(pdu->max_assoc_len));
}
static void amp_get_assoc_req(const struct l2cap_frame *frame)
print_field("%s (0x%2.2x)", att_opcode_to_str(pdu->request),
pdu->request);
- print_field("Handle: 0x%4.4x", btohs(pdu->handle));
+ print_field("Handle: 0x%4.4x", le16_to_cpu(pdu->handle));
print_field("Error: %s (0x%2.2x)", str, pdu->error);
}
{
const struct bt_l2cap_att_exchange_mtu_req *pdu = frame->data;
- print_field("Client RX MTU: %d", btohs(pdu->mtu));
+ print_field("Client RX MTU: %d", le16_to_cpu(pdu->mtu));
}
static void att_exchange_mtu_rsp(const struct l2cap_frame *frame)
{
const struct bt_l2cap_att_exchange_mtu_rsp *pdu = frame->data;
- print_field("Server RX MTU: %d", btohs(pdu->mtu));
+ print_field("Server RX MTU: %d", le16_to_cpu(pdu->mtu));
}
static void att_find_info_req(const struct l2cap_frame *frame)
{
const struct bt_l2cap_att_read_req *pdu = frame->data;
- print_field("Handle: 0x%4.4x", btohs(pdu->handle));
+ print_field("Handle: 0x%4.4x", le16_to_cpu(pdu->handle));
}
static void att_read_rsp(const struct l2cap_frame *frame)
{
const struct bt_l2cap_att_handle_value_notify *pdu = frame->data;
- print_field("Handle: 0x%4.4x", btohs(pdu->handle));
+ print_field("Handle: 0x%4.4x", le16_to_cpu(pdu->handle));
print_hex_field(" Data", frame->data + 2, frame->size - 2);
}
{
const struct bt_l2cap_att_handle_value_ind *pdu = frame->data;
- print_field("Handle: 0x%4.4x", btohs(pdu->handle));
+ print_field("Handle: 0x%4.4x", le16_to_cpu(pdu->handle));
print_hex_field(" Data", frame->data + 2, frame->size - 2);
}
{
const struct bt_l2cap_smp_master_ident *pdu = frame->data;
- print_field("EDIV: 0x%4.4x", btohs(pdu->ediv));
- print_field("Rand: 0x%16.16" PRIx64, btohll(pdu->rand));
+ print_field("EDIV: 0x%4.4x", le16_to_cpu(pdu->ediv));
+ print_field("Rand: 0x%16.16" PRIx64, le64_to_cpu(pdu->rand));
}
static void smp_ident_info(const struct l2cap_frame *frame)
return;
}
- len = btohs(hdr->len);
- cid = btohs(hdr->cid);
+ len = le16_to_cpu(hdr->len);
+ cid = le16_to_cpu(hdr->cid);
data += sizeof(*hdr);
size -= sizeof(*hdr);
return;
}
- len = btohs(hdr->len);
- cid = btohs(hdr->cid);
+ len = le16_to_cpu(hdr->len);
+ cid = le16_to_cpu(hdr->cid);
data += sizeof(*hdr);
size -= sizeof(*hdr);
diff --git a/monitor/ll.c b/monitor/ll.c
index 25a1b7d..6aaa32a 100644
--- a/monitor/ll.c
+++ b/monitor/ll.c
#include <bluetooth/bluetooth.h>
+#include "src/shared/util.h"
#include "display.h"
#include "packet.h"
#include "crc.h"
return;
}
- access_addr = btohl(hdr->access_addr);
+ access_addr = le32_to_cpu(hdr->access_addr);
pdu_data = data + sizeof(*hdr);
pdu_len = size - sizeof(*hdr) - 3;
const struct bt_ll_conn_update_req *pdu = data;
print_field("Transmit window size: %u", pdu->win_size);
- print_field("Transmit window offset: %u", btohs(pdu->win_offset));
- print_field("Connection interval: %u", btohs(pdu->interval));
- print_field("Connection slave latency: %u", btohs(pdu->latency));
- print_field("Connection supervision timeout: %u", btohs(pdu->timeout));;
- print_field("Connection instant: %u", btohs(pdu->instant));
+ print_field("Transmit window offset: %u", le16_to_cpu(pdu->win_offset));
+ print_field("Connection interval: %u", le16_to_cpu(pdu->interval));
+ print_field("Connection slave latency: %u", le16_to_cpu(pdu->latency));
+ print_field("Connection supervision timeout: %u", le16_to_cpu(pdu->timeout));
+ print_field("Connection instant: %u", le16_to_cpu(pdu->instant));
}
static void channel_map_req(const void *data, uint8_t size)
const struct bt_ll_channel_map_req *pdu = data;
packet_print_channel_map_ll(pdu->map);
- print_field("Connection instant: %u", btohs(pdu->instant));
+ print_field("Connection instant: %u", le16_to_cpu(pdu->instant));
}
static void terminate_ind(const void *data, uint8_t size)
{
const struct bt_ll_enc_req *pdu = data;
- print_field("Rand: 0x%16.16" PRIx64, btohll(pdu->rand));
- print_field("EDIV: 0x%4.4x", btohs(pdu->ediv));
- print_field("SKD (master): 0x%16.16" PRIx64, btohll(pdu->skd));
- print_field("IV (master): 0x%8.8x", btohl(pdu->iv));
+ print_field("Rand: 0x%16.16" PRIx64, le64_to_cpu(pdu->rand));
+ print_field("EDIV: 0x%4.4x", le16_to_cpu(pdu->ediv));
+ print_field("SKD (master): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
+ print_field("IV (master): 0x%8.8x", le32_to_cpu(pdu->iv));
}
static void enc_rsp(const void *data, uint8_t size)
{
const struct bt_ll_enc_rsp *pdu = data;
- print_field("SKD (slave): 0x%16.16" PRIx64, btohll(pdu->skd));
- print_field("IV (slave): 0x%8.8x", btohl(pdu->iv));
+ print_field("SKD (slave): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
+ print_field("IV (slave): 0x%8.8x", le32_to_cpu(pdu->iv));
}
static const char *opcode_to_string(uint8_t opcode);
const struct bt_ll_version_ind *pdu = data;
packet_print_version("Version", pdu->version,
- "Subversion", btohs(pdu->subversion));
- packet_print_company("Company", btohs(pdu->company));
+ "Subversion", le16_to_cpu(pdu->subversion));
+ packet_print_company("Company", le16_to_cpu(pdu->company));
}
static void reject_ind(const void *data, uint8_t size)
diff --git a/monitor/lmp.c b/monitor/lmp.c
index 250c8f1..33ef49c 100644
--- a/monitor/lmp.c
+++ b/monitor/lmp.c
#include <bluetooth/bluetooth.h>
+#include "src/shared/util.h"
#include "display.h"
#include "packet.h"
#include "bt.h"
const struct bt_lmp_version_req *pdu = data;
packet_print_version("Version", pdu->version,
- "Subversion", btohs(pdu->subversion));
- packet_print_company("Company", btohs(pdu->company));
+ "Subversion", le16_to_cpu(pdu->subversion));
+ packet_print_company("Company", le16_to_cpu(pdu->company));
}
static void version_res(const void *data, uint8_t size)
const struct bt_lmp_version_res *pdu = data;
packet_print_version("Version", pdu->version,
- "Subversion", btohs(pdu->subversion));
- packet_print_company("Company", btohs(pdu->company));
+ "Subversion", le16_to_cpu(pdu->subversion));
+ packet_print_company("Company", le16_to_cpu(pdu->company));
}
static void features_req(const void *data, uint8_t size)
const struct bt_lmp_set_afh *pdu = data;
const char *str;
- print_field("Instant: %u", htobl(pdu->instant));
+ print_field("Instant: %u", le32_to_cpu(pdu->instant));
switch (pdu->mode) {
case 0x00:
diff --git a/monitor/packet.c b/monitor/packet.c
index 636000c..cff3a79 100644
--- a/monitor/packet.c
+++ b/monitor/packet.c
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
+#include "src/shared/util.h"
#include "display.h"
#include "bt.h"
#include "ll.h"
static void print_handle(uint16_t handle)
{
- print_field("Handle: %d", btohs(handle));
+ print_field("Handle: %d", le16_to_cpu(handle));
}
static void print_phy_handle(uint8_t phy_handle)
uint16_t mask;
int i;
- print_field("Packet type: 0x%4.4x", btohs(pkt_type));
+ print_field("Packet type: 0x%4.4x", le16_to_cpu(pkt_type));
- mask = btohs(pkt_type);
+ mask = le16_to_cpu(pkt_type);
for (i = 0; pkt_type_table[i].str; i++) {
- if (btohs(pkt_type) & (1 << pkt_type_table[i].bit)) {
+ if (le16_to_cpu(pkt_type) & (1 << pkt_type_table[i].bit)) {
print_field(" %s", pkt_type_table[i].str);
mask &= ~(1 << pkt_type_table[i].bit);
}
uint16_t mask;
int i;
- print_field("Packet type: 0x%4.4x", btohs(pkt_type));
+ print_field("Packet type: 0x%4.4x", le16_to_cpu(pkt_type));
- mask = btohs(pkt_type);
+ mask = le16_to_cpu(pkt_type);
for (i = 0; pkt_type_sco_table[i].str; i++) {
- if (btohs(pkt_type) & (1 << pkt_type_sco_table[i].bit)) {
+ if (le16_to_cpu(pkt_type) & (1 << pkt_type_sco_table[i].bit)) {
print_field(" %s", pkt_type_sco_table[i].str);
mask &= ~(1 << pkt_type_sco_table[i].bit);
}
static void print_voice_setting(uint16_t setting)
{
- uint8_t input_coding = (btohs(setting) & 0x0300) >> 8;
- uint8_t input_data_format = (btohs(setting) & 0xc0) >> 6;
- uint8_t air_coding_format = btohs(setting) & 0x0003;
+ uint8_t input_coding = (le16_to_cpu(setting) & 0x0300) >> 8;
+ uint8_t input_data_format = (le16_to_cpu(setting) & 0xc0) >> 6;
+ uint8_t air_coding_format = le16_to_cpu(setting) & 0x0003;
const char *str;
- print_field("Setting: 0x%4.4x", btohs(setting));
+ print_field("Setting: 0x%4.4x", le16_to_cpu(setting));
switch (input_coding) {
case 0x00:
if (input_coding == 0x00) {
print_field(" Input Sample Size: %s",
- btohs(setting) & 0x20 ? "16-bit" : "8-bit");
+ le16_to_cpu(setting) & 0x20 ? "16-bit" : "8-bit");
print_field(" # of bits padding at MSB: %d",
- (btohs(setting) & 0x1c) >> 2);
+ (le16_to_cpu(setting) & 0x1c) >> 2);
}
switch (air_coding_format) {
static void print_link_policy(uint16_t link_policy)
{
- uint16_t policy = btohs(link_policy);
+ uint16_t policy = le16_to_cpu(link_policy);
print_field("Link policy: 0x%4.4x", policy);
static void print_auth_payload_timeout(uint16_t timeout)
{
print_field("Timeout: %d msec (0x%4.4x)",
- btohs(timeout) * 10, btohs(timeout));
+ le16_to_cpu(timeout) * 10, le16_to_cpu(timeout));
}
static void print_pscan_rep_mode(uint8_t pscan_rep_mode)
static void print_clock_offset(uint16_t clock_offset)
{
- print_field("Clock offset: 0x%4.4x", btohs(clock_offset));
+ print_field("Clock offset: 0x%4.4x", le16_to_cpu(clock_offset));
}
static void print_clock(uint32_t clock)
{
- print_field("Clock: 0x%8.8x", btohl(clock));
+ print_field("Clock: 0x%8.8x", le32_to_cpu(clock));
}
static void print_clock_type(uint8_t type)
static void print_clock_accuracy(uint16_t accuracy)
{
- if (btohs(accuracy) == 0xffff)
- print_field("Accuracy: Unknown (0x%4.4x)", btohs(accuracy));
+ if (le16_to_cpu(accuracy) == 0xffff)
+ print_field("Accuracy: Unknown (0x%4.4x)",
+ le16_to_cpu(accuracy));
else
print_field("Accuracy: %.4f msec (0x%4.4x)",
- btohs(accuracy) * 0.3125, btohs(accuracy));
+ le16_to_cpu(accuracy) * 0.3125,
+ le16_to_cpu(accuracy));
}
static void print_lpo_allowed(uint8_t lpo_allowed)
const char *str;
uint8_t conn_type;
- conn_type = get_type(btohs(handle));
+ conn_type = get_type(le16_to_cpu(handle));
switch (encr_mode) {
case 0x00:
static void print_passkey(uint32_t passkey)
{
- print_field("Passkey: %06d", btohl(passkey));
+ print_field("Passkey: %06d", le32_to_cpu(passkey));
}
static void print_io_capability(uint8_t capability)
static void print_slot_625(const char *label, uint16_t value)
{
print_field("%s: %.3f msec (0x%4.4x)", label,
- btohs(value) * 0.625, btohs(value));
+ le16_to_cpu(value) * 0.625, le16_to_cpu(value));
}
static void print_slot_125(const char *label, uint16_t value)
{
print_field("%s: %.2f msec (0x%4.4x)", label,
- btohs(value) * 1.25, btohs(value));
+ le16_to_cpu(value) * 1.25, le16_to_cpu(value));
}
static void print_timeout(uint16_t timeout)
static void print_hci_version(uint8_t version, uint16_t revision)
{
packet_print_version("HCI version", version,
- "Revision", btohs(revision));
+ "Revision", le16_to_cpu(revision));
}
static void print_lmp_version(uint8_t version, uint16_t subversion)
{
packet_print_version("LMP version", version,
- "Subversion", btohs(subversion));
+ "Subversion", le16_to_cpu(subversion));
}
static void print_pal_version(uint8_t version, uint16_t subversion)
}
print_field("PAL version: %s (0x%2.2x) - Subversion %d (0x%4.4x)",
- str, version, btohs(subversion), btohs(subversion));
+ str, version,
+ le16_to_cpu(subversion),
+ le16_to_cpu(subversion));
}
void packet_print_company(const char *label, uint16_t company)
static void print_manufacturer(uint16_t manufacturer)
{
- packet_print_company("Manufacturer", btohs(manufacturer));
+ packet_print_company("Manufacturer", le16_to_cpu(manufacturer));
}
static const char *get_supported_command(int bit);
print_status(rsp->status);
print_handle(rsp->handle);
print_field("LMP handle: %d", rsp->lmp_handle);
- print_field("Reserved: %d", btohl(rsp->reserved));
+ print_field("Reserved: %d", le32_to_cpu(rsp->reserved));
}
static void setup_sync_conn_cmd(const void *data, uint8_t size)
const struct bt_hci_cmd_setup_sync_conn *cmd = data;
print_handle(cmd->handle);
- print_field("Transmit bandwidth: %d", btohl(cmd->tx_bandwidth));
- print_field("Receive bandwidth: %d", btohl(cmd->rx_bandwidth));
- print_field("Max latency: %d", btohs(cmd->max_latency));
+ print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
+ print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
+ print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
print_voice_setting(cmd->voice_setting);
print_retransmission_effort(cmd->retrans_effort);
print_pkt_type_sco(cmd->pkt_type);
const struct bt_hci_cmd_accept_sync_conn_request *cmd = data;
print_bdaddr(cmd->bdaddr);
- print_field("Transmit bandwidth: %d", btohl(cmd->tx_bandwidth));
- print_field("Receive bandwidth: %d", btohl(cmd->rx_bandwidth));
- print_field("Max latency: %d", btohs(cmd->max_latency));
+ print_field("Transmit bandwidth: %d", le32_to_cpu(cmd->tx_bandwidth));
+ print_field("Receive bandwidth: %d", le32_to_cpu(cmd->rx_bandwidth));
+ print_field("Max latency: %d", le16_to_cpu(cmd->max_latency));
print_voice_setting(cmd->voice_setting);
print_retransmission_effort(cmd->retrans_effort);
print_pkt_type_sco(cmd->pkt_type);
print_bdaddr(cmd->bdaddr);
print_lt_addr(cmd->lt_addr);
print_interval(cmd->interval);
- print_field("Offset: 0x%8.8x", btohl(cmd->offset));
- print_field("Next broadcast instant: 0x%4.4x", btohs(cmd->instant));
+ print_field("Offset: 0x%8.8x", le32_to_cpu(cmd->offset));
+ print_field("Next broadcast instant: 0x%4.4x",
+ le16_to_cpu(cmd->instant));
print_slot_625("Supervision timeout", cmd->timeout);
print_field("Remote timing accuracy: %d ppm", cmd->accuracy);
print_field("Skip: 0x%2.2x", cmd->skip);
print_service_type(cmd->service_type);
- print_field("Token rate: %d", btohl(cmd->token_rate));
- print_field("Peak bandwidth: %d", btohl(cmd->peak_bandwidth));
- print_field("Latency: %d", btohl(cmd->latency));
- print_field("Delay variation: %d", btohl(cmd->delay_variation));
+ print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
+ print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
+ print_field("Latency: %d", le32_to_cpu(cmd->latency));
+ print_field("Delay variation: %d", le32_to_cpu(cmd->delay_variation));
}
static void role_discovery_cmd(const void *data, uint8_t size)
print_flow_direction(cmd->direction);
print_service_type(cmd->service_type);
- print_field("Token rate: %d", btohl(cmd->token_rate));
- print_field("Token bucket size: %d", btohl(cmd->token_bucket_size));
- print_field("Peak bandwidth: %d", btohl(cmd->peak_bandwidth));
- print_field("Access latency: %d", btohl(cmd->access_latency));
+ print_field("Token rate: %d", le32_to_cpu(cmd->token_rate));
+ print_field("Token bucket size: %d",
+ le32_to_cpu(cmd->token_bucket_size));
+ print_field("Peak bandwidth: %d", le32_to_cpu(cmd->peak_bandwidth));
+ print_field("Access latency: %d", le32_to_cpu(cmd->access_latency));
}
static void sniff_subrating_cmd(const void *data, uint8_t size)
const struct bt_hci_rsp_read_stored_link_key *rsp = data;
print_status(rsp->status);
- print_field("Max num keys: %d", btohs(rsp->max_num_keys));
- print_field("Num keys: %d", btohs(rsp->num_keys));
+ print_field("Max num keys: %d", le16_to_cpu(rsp->max_num_keys));
+ print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
}
static void write_stored_link_key_cmd(const void *data, uint8_t size)
const struct bt_hci_rsp_delete_stored_link_key *rsp = data;
print_status(rsp->status);
- print_field("Num keys: %d", btohs(rsp->num_keys));
+ print_field("Num keys: %d", le16_to_cpu(rsp->num_keys));
}
static void write_local_name_cmd(const void *data, uint8_t size)
const struct bt_hci_cmd_host_buffer_size *cmd = data;
print_field("ACL MTU: %-4d ACL max packet: %d",
- btohs(cmd->acl_mtu), btohs(cmd->acl_max_pkt));
+ le16_to_cpu(cmd->acl_mtu),
+ le16_to_cpu(cmd->acl_max_pkt));
print_field("SCO MTU: %-4d SCO max packet: %d",
- cmd->sco_mtu, btohs(cmd->sco_max_pkt));
+ cmd->sco_mtu,
+ le16_to_cpu(cmd->sco_max_pkt));
}
static void read_link_supv_timeout_cmd(const void *data, uint8_t size)
print_status(rsp->status);
print_interval(rsp->interval);
print_field("Timeout: %.3f msec (0x%8.8x)",
- btohl(rsp->timeout) * 0.625, btohl(rsp->timeout));
+ le32_to_cpu(rsp->timeout) * 0.625,
+ le32_to_cpu(rsp->timeout));
print_field("Service Data: 0x%2.2x", rsp->service_data);
}
print_slot_625("Min interval", cmd->min_interval);
print_slot_625("Max interval", cmd->max_interval);
print_field("Timeout: %.3f msec (0x%8.8x)",
- btohl(cmd->timeout) * 0.625, btohl(cmd->timeout));
+ le32_to_cpu(cmd->timeout) * 0.625,
+ le32_to_cpu(cmd->timeout));
print_field("Service Data: 0x%2.2x", cmd->service_data);
}
print_status(rsp->status);
print_field("ACL MTU: %-4d ACL max packet: %d",
- btohs(rsp->acl_mtu), btohs(rsp->acl_max_pkt));
+ le16_to_cpu(rsp->acl_mtu),
+ le16_to_cpu(rsp->acl_max_pkt));
print_field("SCO MTU: %-4d SCO max packet: %d",
- rsp->sco_mtu, btohs(rsp->sco_max_pkt));
+ rsp->sco_mtu,
+ le16_to_cpu(rsp->sco_max_pkt));
}
static void read_country_code_rsp(const void *data, uint8_t size)
const struct bt_hci_rsp_read_data_block_size *rsp = data;
print_status(rsp->status);
- print_field("Max ACL length: %d", btohs(rsp->max_acl_len));
- print_field("Block length: %d", btohs(rsp->block_len));
- print_field("Num blocks: %d", btohs(rsp->num_blocks));
+ print_field("Max ACL length: %d", le16_to_cpu(rsp->max_acl_len));
+ print_field("Block length: %d", le16_to_cpu(rsp->block_len));
+ print_field("Num blocks: %d", le16_to_cpu(rsp->num_blocks));
}
static void read_failed_contact_counter_cmd(const void *data, uint8_t size)
print_status(rsp->status);
print_handle(rsp->handle);
- print_field("Counter: %u", htobs(rsp->counter));
+ print_field("Counter: %u", le16_to_cpu(rsp->counter));
}
static void reset_failed_contact_counter_cmd(const void *data, uint8_t size)
print_status(rsp->status);
print_amp_status(rsp->amp_status);
- print_field("Total bandwidth: %d kbps", btohl(rsp->total_bw));
- print_field("Max guaranteed bandwidth: %d kbps", btohl(rsp->max_bw));
- print_field("Min latency: %d", btohl(rsp->min_latency));
- print_field("Max PDU size: %d", btohl(rsp->max_pdu));
+ print_field("Total bandwidth: %d kbps", le32_to_cpu(rsp->total_bw));
+ print_field("Max guaranteed bandwidth: %d kbps",
+ le32_to_cpu(rsp->max_bw));
+ print_field("Min latency: %d", le32_to_cpu(rsp->min_latency));
+ print_field("Max PDU size: %d", le32_to_cpu(rsp->max_pdu));
switch (rsp->amp_type) {
case 0x00:
print_field("Controller type: %s (0x%2.2x)", str, rsp->amp_type);
- print_field("PAL capabilities: 0x%4.4x", btohs(rsp->pal_cap));
- print_field("Max ASSOC length: %d", btohs(rsp->max_assoc_len));
- print_field("Max flush timeout: %d", btohl(rsp->max_flush_to));
- print_field("Best effort flush timeout: %d", btohl(rsp->be_flush_to));
+ print_field("PAL capabilities: 0x%4.4x", le16_to_cpu(rsp->pal_cap));
+ print_field("Max ASSOC length: %d", le16_to_cpu(rsp->max_assoc_len));
+ print_field("Max flush timeout: %d", le32_to_cpu(rsp->max_flush_to));
+ print_field("Best effort flush timeout: %d",
+ le32_to_cpu(rsp->be_flush_to));
}
static void read_local_amp_assoc_cmd(const void *data, uint8_t size)
const struct bt_hci_cmd_read_local_amp_assoc *cmd = data;
print_phy_handle(cmd->phy_handle);
- print_field("Length so far: %d", btohs(cmd->len_so_far));
- print_field("Max ASSOC length: %d", btohs(cmd->max_assoc_len));
+ print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
+ print_field("Max ASSOC length: %d", le16_to_cpu(cmd->max_assoc_len));
}
static void read_local_amp_assoc_rsp(const void *data, uint8_t size)
print_status(rsp->status);
print_phy_handle(rsp->phy_handle);
- print_field("Remaining ASSOC length: %d", btohs(rsp->remain_assoc_len));
+ print_field("Remaining ASSOC length: %d",
+ le16_to_cpu(rsp->remain_assoc_len));
packet_hexdump(data + 4, size - 4);
}
const struct bt_hci_cmd_write_remote_amp_assoc *cmd = data;
print_phy_handle(cmd->phy_handle);
- print_field("Length so far: %d", btohs(cmd->len_so_far));
- print_field("Remaining ASSOC length: %d", btohs(cmd->remain_assoc_len));
+ print_field("Length so far: %d", le16_to_cpu(cmd->len_so_far));
+ print_field("Remaining ASSOC length: %d",
+ le16_to_cpu(cmd->remain_assoc_len));
packet_hexdump(data + 5, size - 5);
}
const struct bt_hci_rsp_le_read_buffer_size *rsp = data;
print_status(rsp->status);
- print_field("Data packet length: %d", btohs(rsp->le_mtu));
+ print_field("Data packet length: %d", le16_to_cpu(rsp->le_mtu));
print_field("Num data packets: %d", rsp->le_max_pkt);
}
print_slot_125("Min connection interval", cmd->min_interval);
print_slot_125("Max connection interval", cmd->max_interval);
- print_field("Connection latency: 0x%4.4x", btohs(cmd->latency));
+ print_field("Connection latency: 0x%4.4x", le16_to_cpu(cmd->latency));
print_field("Supervision timeout: %d msec (0x%4.4x)",
- btohs(cmd->supv_timeout) * 10, btohs(cmd->supv_timeout));
+ le16_to_cpu(cmd->supv_timeout) * 10,
+ le16_to_cpu(cmd->supv_timeout));
print_slot_625("Min connection length", cmd->min_length);
print_slot_625("Max connection length", cmd->max_length);
}
print_handle(cmd->handle);
print_slot_125("Min connection interval", cmd->min_interval);
print_slot_125("Max connection interval", cmd->max_interval);
- print_field("Connection latency: 0x%4.4x", btohs(cmd->latency));
+ print_field("Connection latency: 0x%4.4x", le16_to_cpu(cmd->latency));
print_field("Supervision timeout: %d msec (0x%4.4x)",
- btohs(cmd->supv_timeout) * 10, btohs(cmd->supv_timeout));
+ le16_to_cpu(cmd->supv_timeout) * 10,
+ le16_to_cpu(cmd->supv_timeout));
print_slot_625("Min connection length", cmd->min_length);
print_slot_625("Max connection length", cmd->max_length);
}
print_handle(cmd->handle);
print_random_number(cmd->number);
print_field("Encryption diversifier: 0x%4.4x",
- btohs(cmd->diversifier));
+ le16_to_cpu(cmd->diversifier));
print_key("Long term key", cmd->ltk);
}
const struct bt_hci_rsp_le_test_end *rsp = data;
print_status(rsp->status);
- print_field("Number of packets: %d", btohs(rsp->num_packets));
+ print_field("Number of packets: %d", le16_to_cpu(rsp->num_packets));
}
struct opcode_data {
print_encr_mode(evt->encr_mode);
if (evt->status == 0x00)
- assign_handle(btohs(evt->handle), 0x00);
+ assign_handle(le16_to_cpu(evt->handle), 0x00);
}
static void conn_request_evt(const void *data, uint8_t size)
print_reason(evt->reason);
if (evt->status == 0x00)
- release_handle(btohs(evt->handle));
+ release_handle(le16_to_cpu(evt->handle));
}
static void auth_complete_evt(const void *data, uint8_t size)
print_service_type(evt->service_type);
- print_field("Token rate: %d", btohl(evt->token_rate));
- print_field("Peak bandwidth: %d", btohl(evt->peak_bandwidth));
- print_field("Latency: %d", btohl(evt->latency));
- print_field("Delay variation: %d", btohl(evt->delay_variation));
+ print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
+ print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
+ print_field("Latency: %d", le32_to_cpu(evt->latency));
+ print_field("Delay variation: %d", le32_to_cpu(evt->delay_variation));
}
static void cmd_complete_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_cmd_complete *evt = data;
- uint16_t opcode = btohs(evt->opcode);
+ uint16_t opcode = le16_to_cpu(evt->opcode);
uint16_t ogf = cmd_opcode_ogf(opcode);
uint16_t ocf = cmd_opcode_ocf(opcode);
const struct opcode_data *opcode_data = NULL;
static void cmd_status_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_cmd_status *evt = data;
- uint16_t opcode = btohs(evt->opcode);
+ uint16_t opcode = le16_to_cpu(evt->opcode);
uint16_t ogf = cmd_opcode_ogf(opcode);
uint16_t ocf = cmd_opcode_ocf(opcode);
const struct opcode_data *opcode_data = NULL;
print_field("Num handles: %d", evt->num_handles);
print_handle(evt->handle);
- print_field("Count: %d", btohs(evt->count));
+ print_field("Count: %d", le16_to_cpu(evt->count));
if (size > sizeof(*evt))
packet_hexdump(data + sizeof(*evt), size - sizeof(*evt));
print_flow_direction(evt->direction);
print_service_type(evt->service_type);
- print_field("Token rate: %d", btohl(evt->token_rate));
- print_field("Token bucket size: %d", btohl(evt->token_bucket_size));
- print_field("Peak bandwidth: %d", btohl(evt->peak_bandwidth));
- print_field("Access latency: %d", btohl(evt->access_latency));
+ print_field("Token rate: %d", le32_to_cpu(evt->token_rate));
+ print_field("Token bucket size: %d",
+ le32_to_cpu(evt->token_bucket_size));
+ print_field("Peak bandwidth: %d", le32_to_cpu(evt->peak_bandwidth));
+ print_field("Access latency: %d", le32_to_cpu(evt->access_latency));
}
static void inquiry_result_with_rssi_evt(const void *data, uint8_t size)
print_link_type(evt->link_type);
print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
- print_field("RX packet length: %d", btohs(evt->rx_pkt_len));
- print_field("TX packet length: %d", btohs(evt->tx_pkt_len));
+ print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
+ print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
print_air_mode(evt->air_mode);
}
print_handle(evt->handle);
print_field("Transmission interval: 0x%2.2x", evt->tx_interval);
print_field("Retransmission window: 0x%2.2x", evt->retrans_window);
- print_field("RX packet length: %d", btohs(evt->rx_pkt_len));
- print_field("TX packet length: %d", btohs(evt->tx_pkt_len));
+ print_field("RX packet length: %d", le16_to_cpu(evt->rx_pkt_len));
+ print_field("TX packet length: %d", le16_to_cpu(evt->tx_pkt_len));
}
static void sniff_subrating_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_num_completed_data_blocks *evt = data;
- print_field("Total num data blocks: %d", btohs(evt->total_num_blocks));
+ print_field("Total num data blocks: %d",
+ le16_to_cpu(evt->total_num_blocks));
print_field("Num handles: %d", evt->num_handles);
print_handle(evt->handle);
print_field("Num packets: %d", evt->num_packets);
print_status(evt->status);
print_bdaddr(evt->bdaddr);
- print_field("Offset: 0x%8.8x", btohl(evt->offset));
+ print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
print_channel_map(evt->map);
print_lt_addr(evt->lt_addr);
- print_field("Next broadcast instant: 0x%4.4x", btohs(evt->instant));
+ print_field("Next broadcast instant: 0x%4.4x",
+ le16_to_cpu(evt->instant));
print_interval(evt->interval);
print_field("Service Data: 0x%2.2x", evt->service_data);
}
print_bdaddr(evt->bdaddr);
print_lt_addr(evt->lt_addr);
- print_field("Clock: 0x%8.8x", btohl(evt->clock));
- print_field("Offset: 0x%8.8x", btohl(evt->offset));
+ print_field("Clock: 0x%8.8x", le32_to_cpu(evt->clock));
+ print_field("Offset: 0x%8.8x", le32_to_cpu(evt->offset));
print_field("Receive status: 0x%2.2x", evt->status);
print_broadcast_fragment(evt->fragment);
print_field("Length: %d", evt->length);
print_slot_125("Connection interval", evt->interval);
print_slot_125("Connection latency", evt->latency);
print_field("Supervision timeout: %d msec (0x%4.4x)",
- btohs(evt->supv_timeout) * 10, btohs(evt->supv_timeout));
+ le16_to_cpu(evt->supv_timeout) * 10,
+ le16_to_cpu(evt->supv_timeout));
print_field("Master clock accuracy: 0x%2.2x", evt->clock_accuracy);
if (evt->status == 0x00)
- assign_handle(btohs(evt->handle), 0x01);
+ assign_handle(le16_to_cpu(evt->handle), 0x01);
}
static void le_adv_report_evt(const void *data, uint8_t size)
print_slot_125("Connection interval", evt->interval);
print_slot_125("Connection latency", evt->latency);
print_field("Supervision timeout: %d msec (0x%4.4x)",
- btohs(evt->supv_timeout) * 10, btohs(evt->supv_timeout));
+ le16_to_cpu(evt->supv_timeout) * 10,
+ le16_to_cpu(evt->supv_timeout));
}
static void le_remote_features_complete_evt(const void *data, uint8_t size)
print_handle(evt->handle);
print_random_number(evt->number);
print_field("Encryption diversifier: 0x%4.4x",
- btohs(evt->diversifier));
+ le16_to_cpu(evt->diversifier));
}
struct subevent_data {
const void *data, uint16_t size)
{
const hci_command_hdr *hdr = data;
- uint16_t opcode = btohs(hdr->opcode);
+ uint16_t opcode = le16_to_cpu(hdr->opcode);
uint16_t ogf = cmd_opcode_ogf(opcode);
uint16_t ocf = cmd_opcode_ocf(opcode);
const struct opcode_data *opcode_data = NULL;
const void *data, uint16_t size)
{
const struct bt_hci_acl_hdr *hdr = data;
- uint16_t handle = btohs(hdr->handle);
- uint16_t dlen = btohs(hdr->dlen);
+ uint16_t handle = le16_to_cpu(hdr->handle);
+ uint16_t dlen = le16_to_cpu(hdr->dlen);
uint8_t flags = acl_flags(handle);
char handle_str[16], extra_str[32];
const void *data, uint16_t size)
{
const hci_sco_hdr *hdr = data;
- uint16_t handle = btohs(hdr->handle);
+ uint16_t handle = le16_to_cpu(hdr->handle);
uint8_t flags = acl_flags(handle);
char handle_str[16], extra_str[32];