Ignore:
Timestamp:
Apr 5, 2019, 9:26:53 PM (5 years ago)
Author:
coas-nagasima
Message:

mbed関連を更新
シリアルドライバをmbedのHALを使うよう変更
ファイルディスクリプタの処理を更新

Location:
asp3_tinet_ecnl_rx/trunk/btstack
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • asp3_tinet_ecnl_rx/trunk/btstack/include/btstack/hci_cmds.h

    r337 r374  
    404404 * @param status
    405405 */
    406 #define SDP_QUERY_COMPLETE                                 0x91
     406#define SDP_EVENT_QUERY_COMPLETE                           0x91
    407407
    408408// data: event(8), len(8), rfcomm channel(8), name(var)
    … …  
    422422 * @param attribute_value
    423423 */
    424 #define SDP_QUERY_ATTRIBUTE_VALUE                          0x93
     424#define SDP_EVENT_QUERY_ATTRIBUTE_VALUE                    0x93
    425425
    426426// not provided by daemon, only used for internal testing

  • asp3_tinet_ecnl_rx/trunk/btstack/include/btstack/sdp_util.h

    r337 r374  
    6868// UNIVERSAL ATTRIBUTE DEFINITIONS
    6969#define SDP_ServiceRecordHandle     0x0000
    70 #define SDP_ServiceClassIDList      0x0001
     70#define BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST      0x0001
    7171#define SDP_ServiceRecordState      0x0002
    7272#define SDP_ServiceID               0x0003
    73 #define SDP_ProtocolDescriptorList  0x0004
     73#define BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST  0x0004
    7474#define SDP_BrowseGroupList                 0x0005
    7575#define SDP_LanguageBaseAttributeIDList 0x0006
    … …  
    9393#define SDP_RFCOMMProtocol    0x0003
    9494#define SDP_OBEXProtocol      0x0008
    95 #define SDP_L2CAPProtocol     0x0100
    96 #define SDP_BNEPProtocol      0x000f
     95#define BLUETOOTH_PROTOCOL_L2CAP     0x0100
     96#define BLUETOOTH_PROTOCOL_BNEP      0x000f
    9797
    9898// OFFSETS FOR LOCALIZED ATTRIBUTES - SDP_LanguageBaseAttributeIDList

  • asp3_tinet_ecnl_rx/trunk/btstack/include/btstack/utils.h

    r337 r374  
    9090
    9191// helper for BT little endian format
    92 #define READ_BT_16( buffer, pos) ( ((uint16_t) buffer[pos]) | (((uint16_t)buffer[pos+1]) << 8))
    93 #define READ_BT_24( buffer, pos) ( ((uint32_t) buffer[pos]) | (((uint32_t)buffer[pos+1]) << 8) | (((uint32_t)buffer[pos+2]) << 16))
    94 #define READ_BT_32( buffer, pos) ( ((uint32_t) buffer[pos]) | (((uint32_t)buffer[pos+1]) << 8) | (((uint32_t)buffer[pos+2]) << 16) | (((uint32_t) buffer[pos+3])) << 24)
     92#define little_endian_read_16( buffer, pos) ( ((uint16_t) buffer[pos]) | (((uint16_t)buffer[pos+1]) << 8))
     93#define little_endian_read_24( buffer, pos) ( ((uint32_t) buffer[pos]) | (((uint32_t)buffer[pos+1]) << 8) | (((uint32_t)buffer[pos+2]) << 16))
     94#define little_endian_read_32( buffer, pos) ( ((uint32_t) buffer[pos]) | (((uint32_t)buffer[pos+1]) << 8) | (((uint32_t)buffer[pos+2]) << 16) | (((uint32_t) buffer[pos+3])) << 24)
    9595
    9696// helper for SDP big endian format
    97 #define READ_NET_16( buffer, pos) ( ((uint16_t) buffer[pos+1]) | (((uint16_t)buffer[pos  ]) << 8))
    98 #define READ_NET_32( buffer, pos) ( ((uint32_t) buffer[pos+3]) | (((uint32_t)buffer[pos+2]) << 8) | (((uint32_t)buffer[pos+1]) << 16) | (((uint32_t) buffer[pos])) << 24)
     97#define big_endian_read_16( buffer, pos) ( ((uint16_t) buffer[pos+1]) | (((uint16_t)buffer[pos  ]) << 8))
     98#define big_endian_read_32( buffer, pos) ( ((uint32_t) buffer[pos+3]) | (((uint32_t)buffer[pos+2]) << 8) | (((uint32_t)buffer[pos+1]) << 16) | (((uint32_t) buffer[pos])) << 24)
    9999
    100100// HCI CMD OGF/OCF
    … …  
    103103
    104104// check if command complete event for given command
    105 #define COMMAND_COMPLETE_EVENT(event,cmd) ( event[0] == HCI_EVENT_COMMAND_COMPLETE && READ_BT_16(event,3) == cmd.opcode)
    106 #define COMMAND_STATUS_EVENT(event,cmd) ( event[0] == HCI_EVENT_COMMAND_STATUS && READ_BT_16(event,4) == cmd.opcode)
     105#define HCI_EVENT_IS_COMMAND_COMPLETE(event,cmd) ( event[0] == HCI_EVENT_COMMAND_COMPLETE && little_endian_read_16(event,3) == cmd.opcode)
     106#define COMMAND_STATUS_EVENT(event,cmd) ( event[0] == HCI_EVENT_COMMAND_STATUS && little_endian_read_16(event,4) == cmd.opcode)
    107107
    108108// Code+Len=2, Pkts+Opcode=3; total=5
    … …  
    110110
    111111// ACL Packet
    112 #define READ_ACL_CONNECTION_HANDLE( buffer ) ( READ_BT_16(buffer,0) & 0x0fff)
     112#define READ_ACL_CONNECTION_HANDLE( buffer ) ( little_endian_read_16(buffer,0) & 0x0fff)
    113113#define READ_ACL_FLAGS( buffer )      ( buffer[1] >> 4 )
    114 #define READ_ACL_LENGTH( buffer )     (READ_BT_16(buffer, 2))
     114#define READ_ACL_LENGTH( buffer )     (little_endian_read_16(buffer, 2))
    115115
    116116// L2CAP Packet
    117 #define READ_L2CAP_LENGTH(buffer)     ( READ_BT_16(buffer, 4))
    118 #define READ_L2CAP_CHANNEL_ID(buffer) ( READ_BT_16(buffer, 6))
     117#define READ_L2CAP_LENGTH(buffer)     ( little_endian_read_16(buffer, 4))
     118#define READ_L2CAP_CHANNEL_ID(buffer) ( little_endian_read_16(buffer, 6))
    119119
    120 void bt_store_16(uint8_t *buffer, uint16_t pos, uint16_t value);
    121 void bt_store_32(uint8_t *buffer, uint16_t pos, uint32_t value);
    122 void bt_flip_addr(bd_addr_t dest, bd_addr_t src);
     120void little_endian_store_16(uint8_t *buffer, uint16_t pos, uint16_t value);
     121void little_endian_store_32(uint8_t *buffer, uint16_t pos, uint32_t value);
     122void reverse_bd_addr(bd_addr_t src, bd_addr_t dest);
    123123
    124124void net_store_16(uint8_t *buffer, uint16_t pos, uint16_t value);

  • asp3_tinet_ecnl_rx/trunk/btstack/src/bnep.c

    r337 r374  
    8484    event[1] = sizeof(event) - 2;
    8585    event[2] = status;
    86     bt_store_16(event, 3, channel->l2cap_cid);
    87     bt_store_16(event, 5, channel->uuid_source);
    88     bt_store_16(event, 7, channel->uuid_dest);
    89     bt_store_16(event, 9, channel->max_frame_size);
     86    little_endian_store_16(event, 3, channel->l2cap_cid);
     87    little_endian_store_16(event, 5, channel->uuid_source);
     88    little_endian_store_16(event, 7, channel->uuid_dest);
     89    little_endian_store_16(event, 9, channel->max_frame_size);
    9090    BD_ADDR_COPY(&event[11], channel->remote_addr);
    9191    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    101101    event[0] = BNEP_EVENT_CHANNEL_TIMEOUT;
    102102    event[1] = sizeof(event) - 2;
    103     bt_store_16(event, 2, channel->l2cap_cid);
    104     bt_store_16(event, 4, channel->uuid_source);
    105     bt_store_16(event, 6, channel->uuid_dest);
     103    little_endian_store_16(event, 2, channel->l2cap_cid);
     104    little_endian_store_16(event, 4, channel->uuid_source);
     105    little_endian_store_16(event, 6, channel->uuid_dest);
    106106    BD_ADDR_COPY(&event[8], channel->remote_addr);
    107107    event[14] = channel->state;
    … …  
    118118    event[0] = BNEP_EVENT_CHANNEL_CLOSED;
    119119    event[1] = sizeof(event) - 2;
    120     bt_store_16(event, 2, channel->l2cap_cid);
    121     bt_store_16(event, 4, channel->uuid_source);
    122     bt_store_16(event, 6, channel->uuid_dest);
     120    little_endian_store_16(event, 2, channel->l2cap_cid);
     121    little_endian_store_16(event, 4, channel->uuid_source);
     122    little_endian_store_16(event, 6, channel->uuid_dest);
    123123    BD_ADDR_COPY(&event[8], channel->remote_addr);
    124124    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    133133    event[0] = BNEP_EVENT_READY_TO_SEND;
    134134    event[1] = sizeof(event) - 2;
    135     bt_store_16(event, 2, channel->l2cap_cid);
     135    little_endian_store_16(event, 2, channel->l2cap_cid);
    136136    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    137137        (*app_packet_handler)(channel->connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event));
    … …  
    464464    BD_ADDR_COPY(addr_source, &packet[pos]);
    465465    pos += sizeof(bd_addr_t);
    466     network_protocol_type = READ_NET_16(packet, pos);
     466    network_protocol_type = big_endian_read_16(packet, pos);
    467467    pos += sizeof(uint16_t);
    468468
    … …  
    475475        }
    476476        /* The "real" network protocol type is 4 bytes ahead in a VLAN packet */
    477                 network_protocol_type = READ_NET_16(packet, pos + 2);
     477                network_protocol_type = big_endian_read_16(packet, pos + 2);
    478478        }
    479479
    … …  
    808808    /* Check source and destination UUIDs for valid combinations */
    809809    if (response_code == BNEP_RESP_SETUP_SUCCESS) {
    810         channel->uuid_dest = READ_NET_16(packet, 2 + uuid_offset);
    811         channel->uuid_source = READ_NET_16(packet, 2 + uuid_offset + uuid_size);
    812 
    813         if ((channel->uuid_dest != BNEP_UUID_PANU) &&
    814             (channel->uuid_dest != BNEP_UUID_NAP) &&
    815             (channel->uuid_dest != BNEP_UUID_GN)) {
     810        channel->uuid_dest = big_endian_read_16(packet, 2 + uuid_offset);
     811        channel->uuid_source = big_endian_read_16(packet, 2 + uuid_offset + uuid_size);
     812
     813        if ((channel->uuid_dest != BLUETOOTH_SERVICE_CLASS_PANU) &&
     814            (channel->uuid_dest != BLUETOOTH_SERVICE_CLASS_NAP) &&
     815            (channel->uuid_dest != BLUETOOTH_SERVICE_CLASS_GN)) {
    816816            log_error("BNEP_CONNECTION_REQUEST: Invalid destination service UUID: %04x", channel->uuid_dest);
    817817            channel->uuid_dest = 0;
    818818        }
    819         if ((channel->uuid_source != BNEP_UUID_PANU) &&
    820             (channel->uuid_source != BNEP_UUID_NAP) &&
    821             (channel->uuid_source != BNEP_UUID_GN)) {
     819        if ((channel->uuid_source != BLUETOOTH_SERVICE_CLASS_PANU) &&
     820            (channel->uuid_source != BLUETOOTH_SERVICE_CLASS_NAP) &&
     821            (channel->uuid_source != BLUETOOTH_SERVICE_CLASS_GN)) {
    822822            log_error("BNEP_CONNECTION_REQUEST: Invalid source service UUID: %04x", channel->uuid_source);
    823823            channel->uuid_source = 0;
    … …  
    829829            response_code = BNEP_RESP_SETUP_INVALID_DEST_UUID;
    830830        } else
    831         if ((channel->uuid_source != BNEP_UUID_PANU) && (channel->uuid_dest != BNEP_UUID_PANU)) {
     831        if ((channel->uuid_source != BLUETOOTH_SERVICE_CLASS_PANU) && (channel->uuid_dest != BLUETOOTH_SERVICE_CLASS_PANU)) {
    832832            response_code = BNEP_RESP_SETUP_INVALID_SOURCE_UUID;
    833833        }
    … …  
    857857    }
    858858
    859     response_code = READ_NET_16(packet, 1);
     859    response_code = big_endian_read_16(packet, 1);
    860860
    861861    if (response_code == BNEP_RESP_SETUP_SUCCESS) {
    … …  
    882882    }
    883883
    884     list_length = READ_NET_16(packet, 1);
     884    list_length = big_endian_read_16(packet, 1);
    885885    /* Sanity check packet size again with known package size */
    886886    if (size < 3 + list_length) {
    … …  
    903903        /* There is still enough space, copy the filters to our filter list */
    904904        for (i = 0; i < list_length / (2 * 2); i ++) {
    905             channel->net_filter[channel->net_filter_count].range_start = READ_NET_16(packet, 1 + 2 + i * 4);
    906             channel->net_filter[channel->net_filter_count].range_end = READ_NET_16(packet, 1 + 2 + i * 4 + 2);
     905            channel->net_filter[channel->net_filter_count].range_start = big_endian_read_16(packet, 1 + 2 + i * 4);
     906            channel->net_filter[channel->net_filter_count].range_end = big_endian_read_16(packet, 1 + 2 + i * 4 + 2);
    907907            if (channel->net_filter[channel->net_filter_count].range_start > channel->net_filter[channel->net_filter_count].range_end) {
    908908                /* Invalid filter range, ignore this filter rule */
    … …  
    945945    }
    946946
    947     response_code = READ_NET_16(packet, 1);
     947    response_code = big_endian_read_16(packet, 1);
    948948
    949949    if (response_code == BNEP_RESP_FILTER_SUCCESS) {
    … …  
    966966    }
    967967
    968     list_length = READ_NET_16(packet, 1);
     968    list_length = big_endian_read_16(packet, 1);
    969969    /* Sanity check packet size again with known package size */
    970970    if (size < 3 + list_length) {
    … …  
    10321032    }
    10331033
    1034     response_code = READ_NET_16(packet, 1);
     1034    response_code = big_endian_read_16(packet, 1);
    10351035
    10361036    if (response_code == BNEP_RESP_FILTER_SUCCESS) {
    … …  
    11691169        case L2CAP_EVENT_INCOMING_CONNECTION:
    11701170            /* L2CAP event data: event(8), len(8), address(48), handle (16),  psm (16), source cid(16) dest cid(16) */
    1171             bt_flip_addr(event_addr, &packet[2]);
    1172             con_handle = READ_BT_16(packet,  8);
    1173             psm        = READ_BT_16(packet, 10);
    1174             l2cap_cid  = READ_BT_16(packet, 12);
     1171            reverse_bd_addr(&packet[2], event_addr);
     1172            con_handle = little_endian_read_16(packet,  8);
     1173            psm        = little_endian_read_16(packet, 10);
     1174            l2cap_cid  = little_endian_read_16(packet, 12);
    11751175
    11761176            if (psm != PSM_BNEP) break;
    … …  
    12111211        case L2CAP_EVENT_CHANNEL_OPENED:
    12121212            /* Check if the l2cap channel has been opened for PSM_BNEP */
    1213             if (READ_BT_16(packet, 11) != PSM_BNEP) {
     1213            if (little_endian_read_16(packet, 11) != PSM_BNEP) {
    12141214                break;
    12151215            }
    … …  
    12191219
    12201220            /* Get the bnep channel fpr remote address */
    1221             con_handle = READ_BT_16(packet, 9);
    1222             l2cap_cid  = READ_BT_16(packet, 13);
    1223             bt_flip_addr(event_addr, &packet[3]);
     1221            con_handle = little_endian_read_16(packet, 9);
     1222            l2cap_cid  = little_endian_read_16(packet, 13);
     1223            reverse_bd_addr(&packet[3], event_addr);
    12241224            channel = bnep_channel_for_addr(&event_addr);
    12251225            if (!channel) {
    … …  
    12521252                    channel->state = BNEP_CHANNEL_STATE_WAIT_FOR_CONNECTION_RESPONSE;
    12531253                    bnep_channel_state_add(channel, BNEP_CHANNEL_STATE_VAR_SND_CONNECTION_REQUEST);
    1254                     channel->max_frame_size = bnep_max_frame_size_for_l2cap_mtu(READ_BT_16(packet, 17));
     1254                    channel->max_frame_size = bnep_max_frame_size_for_l2cap_mtu(little_endian_read_16(packet, 17));
    12551255                    bnep_run();
    12561256                    break;
    12571257                case BNEP_CHANNEL_STATE_WAIT_FOR_CONNECTION_REQUEST:
    12581258                    /* New information: channel mtu */
    1259                     channel->max_frame_size = bnep_max_frame_size_for_l2cap_mtu(READ_BT_16(packet, 17));
     1259                    channel->max_frame_size = bnep_max_frame_size_for_l2cap_mtu(little_endian_read_16(packet, 17));
    12601260                    break;
    12611261                default:
    … …  
    12721272        case L2CAP_EVENT_CHANNEL_CLOSED:
    12731273            // data: event (8), len(8), channel (16)
    1274             l2cap_cid   = READ_BT_16(packet, 2);
     1274            l2cap_cid   = little_endian_read_16(packet, 2);
    12751275            channel = bnep_channel_for_l2cap_cid(l2cap_cid);
    12761276            log_info("L2CAP_EVENT_CHANNEL_CLOSED cid 0x%0x, channel %p", l2cap_cid, channel);
    … …  
    13311331            BD_ADDR_COPY(addr_source, &packet[pos]);
    13321332            pos += sizeof(bd_addr_t);
    1333             network_protocol_type = READ_NET_16(packet, pos);
     1333            network_protocol_type = big_endian_read_16(packet, pos);
    13341334            pos += 2;
    13351335            break;
    … …  
    13371337            BD_ADDR_COPY(addr_dest, channel->local_addr);
    13381338            BD_ADDR_COPY(addr_source, channel->remote_addr);
    1339             network_protocol_type = READ_NET_16(packet, pos);
     1339            network_protocol_type = big_endian_read_16(packet, pos);
    13401340            pos += 2;
    13411341            break;
    … …  
    13441344            BD_ADDR_COPY(addr_source, &packet[pos]);
    13451345            pos += sizeof(bd_addr_t);
    1346             network_protocol_type = READ_NET_16(packet, pos);
     1346            network_protocol_type = big_endian_read_16(packet, pos);
    13471347            pos += 2;
    13481348            break;
    … …  
    13511351            pos += sizeof(bd_addr_t);
    13521352            BD_ADDR_COPY(addr_source, channel->remote_addr);
    1353             network_protocol_type = READ_NET_16(packet, pos);
     1353            network_protocol_type = big_endian_read_16(packet, pos);
    13541354            pos += 2;
    13551355            break;
    … …  
    15631563    }
    15641564
    1565     channel->uuid_source = BNEP_UUID_PANU;
     1565    channel->uuid_source = BLUETOOTH_SERVICE_CLASS_PANU;
    15661566    channel->uuid_dest   = uuid_dest;
    15671567
    … …  
    15971597
    15981598    /* Only alow one the three service types: PANU, NAP, GN */
    1599     if ((service_uuid != BNEP_UUID_PANU) &&
    1600         (service_uuid != BNEP_UUID_NAP) &&
    1601         (service_uuid != BNEP_UUID_GN)) {
     1599    if ((service_uuid != BLUETOOTH_SERVICE_CLASS_PANU) &&
     1600        (service_uuid != BLUETOOTH_SERVICE_CLASS_NAP) &&
     1601        (service_uuid != BLUETOOTH_SERVICE_CLASS_GN)) {
    16021602        log_info("BNEP_REGISTER_SERVICE: Invalid service UUID: %04x", service_uuid);
    16031603        return BNEP_CHANNEL_NOT_CONNECTED;

  • asp3_tinet_ecnl_rx/trunk/btstack/src/bnep.h

    r337 r374  
    7272
    7373/* BNEP UUIDs */
    74 #define BNEP_UUID_PANU                                  0x1115
    75 #define BNEP_UUID_NAP                                   0x1116
    76 #define BNEP_UUID_GN                                    0x1117
     74#define BLUETOOTH_SERVICE_CLASS_PANU                    0x1115
     75#define BLUETOOTH_SERVICE_CLASS_NAP                     0x1116
     76#define BLUETOOTH_SERVICE_CLASS_GN                      0x1117
    7777   
    7878/* BNEP packet types */   

  • asp3_tinet_ecnl_rx/trunk/btstack/src/hci.c

    r337 r374  
    233233    bd_addr_t addr;
    234234    hci_connection_t * conn;
    235     bt_flip_addr(addr, *(bd_addr_t *) bd_addr);
     235    reverse_bd_addr(*(bd_addr_t *) bd_addr, addr);
    236236    conn = hci_connection_for_bd_addr_and_type(&addr, BD_ADDR_TYPE_CLASSIC);
    237237    if (conn) {
    … …  
    469469        // copy handle_and_flags if not first fragment and update packet boundary flags to be 01 (continuing fragmnent)
    470470        if (acl_header_pos > 0){
    471             uint16_t handle_and_flags = READ_BT_16(hci_stack->hci_packet_buffer, 0);
     471            uint16_t handle_and_flags = little_endian_read_16(hci_stack->hci_packet_buffer, 0);
    472472            handle_and_flags = (handle_and_flags & 0xcfff) | (1 << 12);
    473             bt_store_16(hci_stack->hci_packet_buffer, acl_header_pos, handle_and_flags);
     473            little_endian_store_16(hci_stack->hci_packet_buffer, acl_header_pos, handle_and_flags);
    474474        }
    475475
    476476        // update header len
    477         bt_store_16(hci_stack->hci_packet_buffer, acl_header_pos + 2, current_acl_data_packet_length);
     477        little_endian_store_16(hci_stack->hci_packet_buffer, acl_header_pos + 2, current_acl_data_packet_length);
    478478
    479479        // count packet
    … …  
    640640                conn->acl_recombination_pos    = acl_length + 4;
    641641                conn->acl_recombination_length = l2cap_length;
    642                 bt_store_16(conn->acl_recombination_buffer, HCI_INCOMING_PRE_BUFFER_SIZE + 2, l2cap_length +4);
     642                little_endian_store_16(conn->acl_recombination_buffer, HCI_INCOMING_PRE_BUFFER_SIZE + 2, l2cap_length +4);
    643643            }
    644644            break;
    … …  
    793793    // odd: waiting for event
    794794    if (packet[0] == HCI_EVENT_COMMAND_COMPLETE){
    795         uint16_t opcode = READ_BT_16(packet,3);
     795        uint16_t opcode = little_endian_read_16(packet,3);
    796796        if (opcode == hci_stack->last_cmd_opcode){
    797797            command_completed = 1;
    … …  
    803803    if (packet[0] == HCI_EVENT_COMMAND_STATUS){
    804804        uint8_t  status = packet[2];
    805         uint16_t opcode = READ_BT_16(packet,4);
     805        uint16_t opcode = little_endian_read_16(packet,4);
    806806        if (opcode == hci_stack->last_cmd_opcode){
    807807            if (status){
    … …  
    843843        case 1: // SEND BAUD CHANGE
    844844            hci_stack->control->baudrate_cmd(hci_stack->config, ((hci_uart_config_t *)hci_stack->config)->baudrate_main, hci_stack->hci_packet_buffer);
    845             hci_stack->last_cmd_opcode = READ_BT_16(hci_stack->hci_packet_buffer, 0);
     845            hci_stack->last_cmd_opcode = little_endian_read_16(hci_stack->hci_packet_buffer, 0);
    846846            hci_dump_packet(HCI_COMMAND_DATA_PACKET, 0, hci_stack->hci_packet_buffer, 3 + hci_stack->hci_packet_buffer[2]);
    847847            hci_send_cmd_packet(hci_stack->hci_packet_buffer, 3 + hci_stack->hci_packet_buffer[2]);
    … …  
    860860                if (valid_cmd){
    861861                    int size = 3 + hci_stack->hci_packet_buffer[2];
    862                     hci_stack->last_cmd_opcode = READ_BT_16(hci_stack->hci_packet_buffer, 0);
     862                    hci_stack->last_cmd_opcode = little_endian_read_16(hci_stack->hci_packet_buffer, 0);
    863863                    hci_dump_packet(HCI_COMMAND_DATA_PACKET, 0, hci_stack->hci_packet_buffer, size);
    864864                    hci_stack->hci_transport->send_packet(HCI_COMMAND_DATA_PACKET, hci_stack->hci_packet_buffer, size);
    … …  
    992992            hci_stack->num_cmd_packets = packet[2];
    993993
    994             if (COMMAND_COMPLETE_EVENT(packet, hci_read_buffer_size)){
     994            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_buffer_size)){
    995995                // from offset 5
    996996                // status
    997997                // "The HC_ACL_Data_Packet_Length return parameter will be used to determine the size of the L2CAP segments contained in ACL Data Packets"
    998                 hci_stack->acl_data_packet_length = READ_BT_16(packet, 6);
     998                hci_stack->acl_data_packet_length = little_endian_read_16(packet, 6);
    999999                // ignore: SCO data packet len (8)
    10001000                hci_stack->acl_packets_total_num  = packet[9];
    … …  
    10101010            }
    10111011#ifdef HAVE_BLE
    1012             if (COMMAND_COMPLETE_EVENT(packet, hci_le_read_buffer_size)){
    1013                 hci_stack->le_data_packets_length = READ_BT_16(packet, 6);
     1012            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_le_read_buffer_size)){
     1013                hci_stack->le_data_packets_length = little_endian_read_16(packet, 6);
    10141014                hci_stack->le_acl_packets_total_num  = packet[8];
    10151015                    // determine usable ACL payload size
    … …  
    10211021#endif
    10221022            // Dump local address
    1023             if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)) {
    1024                 bt_flip_addr(hci_stack->local_bd_addr, &packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE + 1]);
     1023            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_bd_addr)) {
     1024                reverse_bd_addr(&packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE + 1], hci_stack->local_bd_addr);
    10251025                log_info("Local Address, Status: 0x%02x: Addr: %s",
    10261026                    packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE], bd_addr_to_str(hci_stack->local_bd_addr));
    10271027            }
    1028             if (COMMAND_COMPLETE_EVENT(packet, hci_write_scan_enable)){
     1028            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_scan_enable)){
    10291029                hci_emit_discoverable_enabled(hci_stack->discoverable);
    10301030            }
    10311031            // Note: HCI init checks
    1032             if (COMMAND_COMPLETE_EVENT(packet, hci_read_local_supported_features)){
     1032            if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_supported_features)){
    10331033                memcpy(hci_stack->local_supported_features, &packet[OFFSET_OF_DATA_IN_COMMAND_COMPLETE+1], 8);
    10341034                log_info("Local Supported Features: 0x%02x%02x%02x%02x%02x%02x%02x%02x",
    … …  
    10571057            for (i=0; i<packet[2];i++){
    10581058                uint16_t num_packets;
    1059                 handle = READ_BT_16(packet, offset);
     1059                handle = little_endian_read_16(packet, offset);
    10601060                offset += 2;
    1061                 num_packets = READ_BT_16(packet, offset);
     1061                num_packets = little_endian_read_16(packet, offset);
    10621062                offset += 2;
    10631063
    … …  
    10791079        }
    10801080        case HCI_EVENT_CONNECTION_REQUEST:
    1081             bt_flip_addr(addr, &packet[2]);
     1081            reverse_bd_addr(&packet[2], addr);
    10821082            // TODO: eval COD 8-10
    10831083            link_type = packet[11];
    … …  
    11061106        case HCI_EVENT_CONNECTION_COMPLETE:
    11071107            // Connection management
    1108             bt_flip_addr(addr, &packet[5]);
     1108            reverse_bd_addr(&packet[5], addr);
    11091109            log_info("Connection_complete (status=%u) %s", packet[2], bd_addr_to_str(addr));
    11101110            addr_type = BD_ADDR_TYPE_CLASSIC;
    … …  
    11131113                if (!packet[2]){
    11141114                    conn->state = OPEN;
    1115                     conn->con_handle = READ_BT_16(packet, 3);
     1115                    conn->con_handle = little_endian_read_16(packet, 3);
    11161116                    conn->bonding_flags |= BONDING_REQUEST_REMOTE_FEATURES;
    11171117
    … …  
    11481148
    11491149        case HCI_EVENT_READ_REMOTE_SUPPORTED_FEATURES_COMPLETE:
    1150             handle = READ_BT_16(packet, 3);
     1150            handle = little_endian_read_16(packet, 3);
    11511151            conn = hci_connection_for_handle(handle);
    11521152            if (!conn) break;
    … …  
    11761176        case HCI_EVENT_LINK_KEY_NOTIFICATION: {
    11771177            link_key_type_t link_key_type;
    1178             bt_flip_addr(addr, &packet[2]);
     1178            reverse_bd_addr(&packet[2], addr);
    11791179            conn = hci_connection_for_bd_addr_and_type(&addr, BD_ADDR_TYPE_CLASSIC);
    11801180            if (!conn) break;
    … …  
    12011201            // PIN CODE REQUEST means the link key request didn't succee -> delete stored link key
    12021202            if (!hci_stack->remote_device_db) break;
    1203             bt_flip_addr(addr, &packet[2]);
     1203            reverse_bd_addr(&packet[2], addr);
    12041204            hci_stack->remote_device_db->delete_link_key(&addr);
    12051205            break;
    … …  
    12231223
    12241224        case HCI_EVENT_ENCRYPTION_CHANGE:
    1225             handle = READ_BT_16(packet, 3);
     1225            handle = little_endian_read_16(packet, 3);
    12261226            conn = hci_connection_for_handle(handle);
    12271227            if (!conn) break;
    … …  
    12371237
    12381238        case HCI_EVENT_AUTHENTICATION_COMPLETE_EVENT:
    1239             handle = READ_BT_16(packet, 3);
     1239            handle = little_endian_read_16(packet, 3);
    12401240            conn = hci_connection_for_handle(handle);
    12411241            if (!conn) break;
    … …  
    12621262            if (!hci_stack->remote_device_db) break;
    12631263            if (packet[2]) break; // status not ok
    1264             bt_flip_addr(addr, &packet[3]);
     1264            reverse_bd_addr(&packet[3], addr);
    12651265            // fix for invalid remote names - terminate on 0xff
    12661266            for (i=0; i<248;i++){
    … …  
    12831283            int offset = 3;
    12841284            for (i=0; i<packet[2];i++){
    1285                 bt_flip_addr(addr, &packet[offset]);
     1285                reverse_bd_addr(&packet[offset], addr);
    12861286                offset += 14; // 6 + 1 + 1 + 1 + 3 + 2;
    12871287                if (hci_stack->remote_device_db->get_name(&addr, &device_name)){
    … …  
    13081308        case HCI_EVENT_ROLE_CHANGE:
    13091309            if (packet[2]) break;   // status != 0
    1310             handle = READ_BT_16(packet, 3);
     1310            handle = little_endian_read_16(packet, 3);
    13111311            conn = hci_connection_for_handle(handle);
    13121312            if (!conn) break;       // no conn
    … …  
    13311331                case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
    13321332                    // Connection management
    1333                     bt_flip_addr(addr, &packet[8]);
     1333                    reverse_bd_addr(&packet[8], addr);
    13341334                    addr_type = (bd_addr_type_t)packet[7];
    13351335                    log_info("LE Connection_complete (status=%u) type %u, %s", packet[3], addr_type, bd_addr_to_str(addr));
    … …  
    13571357
    13581358                    conn->state = OPEN;
    1359                     conn->con_handle = READ_BT_16(packet, 4);
     1359                    conn->con_handle = little_endian_read_16(packet, 4);
    13601360
    13611361                    // TODO: store - role, peer address type, conn_interval, conn_latency, supervision timeout, master clock
    … …  
    13701370                    break;
    13711371
    1372             // log_info("LE buffer size: %u, count %u", READ_BT_16(packet,6), packet[8]);
     1372            // log_info("LE buffer size: %u, count %u", little_endian_read_16(packet,6), packet[8]);
    13731373
    13741374                default:
    … …  
    13891389    if (hci_stack->state == HCI_STATE_FALLING_ASLEEP
    13901390        && hci_stack->substate == 1
    1391         && COMMAND_COMPLETE_EVENT(packet, hci_write_scan_enable)){
     1391        && HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_scan_enable)){
    13921392        hci_stack->substate++;
    13931393    }
    … …  
    14001400        if (!packet[2]){
    14011401            hci_connection_t * conn;
    1402             handle = READ_BT_16(packet, 3);
     1402            handle = little_endian_read_16(packet, 3);
    14031403            conn = hci_connection_for_handle(handle);
    14041404            if (conn) {
    … …  
    17931793}
    17941794
    1795 void hci_discoverable_control(uint8_t enable){
     1795void gap_discoverable_control(uint8_t enable){
    17961796    if (enable) enable = 1; // normalize argument
    17971797
    … …  
    21402140    // create_connection?
    21412141    if (IS_COMMAND(packet, hci_create_connection)){
    2142         bt_flip_addr(addr, &packet[3]);
     2142        reverse_bd_addr(&packet[3], addr);
    21432143        log_info("Create_connection to %s", bd_addr_to_str(addr));
    21442144
    … …  
    21792179    if (IS_COMMAND(packet, hci_delete_stored_link_key)){
    21802180        if (hci_stack->remote_device_db){
    2181             bt_flip_addr(addr, &packet[3]);
     2181            reverse_bd_addr(&packet[3], addr);
    21822182            hci_stack->remote_device_db->delete_link_key(&addr);
    21832183        }
    … …  
    21862186    if (IS_COMMAND(packet, hci_pin_code_request_negative_reply)
    21872187    ||  IS_COMMAND(packet, hci_pin_code_request_reply)){
    2188         bt_flip_addr(addr, &packet[3]);
     2188        reverse_bd_addr(&packet[3], addr);
    21892189        conn = hci_connection_for_bd_addr_and_type(&addr, BD_ADDR_TYPE_CLASSIC);
    21902190        if (conn){
    … …  
    21972197    ||  IS_COMMAND(packet, hci_user_passkey_request_negative_reply)
    21982198    ||  IS_COMMAND(packet, hci_user_passkey_request_reply)) {
    2199         bt_flip_addr(addr, &packet[3]);
     2199        reverse_bd_addr(&packet[3], addr);
    22002200        conn = hci_connection_for_bd_addr_and_type(&addr, BD_ADDR_TYPE_CLASSIC);
    22012201        if (conn){
    … …  
    22092209    }
    22102210    if (IS_COMMAND(packet, hci_le_set_random_address)){
    2211         bt_flip_addr(hci_stack->adv_address, &packet[3]);
     2211        reverse_bd_addr(&packet[3], hci_stack->adv_address);
    22122212    }
    22132213#endif
    … …  
    23032303    event[1] = sizeof(event) - 2;
    23042304    event[2] = status;
    2305     bt_store_16(event, 3, conn->con_handle);
    2306     bt_flip_addr(&event[5], conn->address);
     2305    little_endian_store_16(event, 3, conn->con_handle);
     2306    reverse_bd_addr(conn->address, &event[5]);
    23072307    event[11] = 1; // ACL connection
    23082308    event[12] = 0; // encryption disabled
    … …  
    23172317    event[2] = HCI_SUBEVENT_LE_CONNECTION_COMPLETE;
    23182318    event[3] = status;
    2319     bt_store_16(event, 4, conn_handle);
     2319    little_endian_store_16(event, 4, conn_handle);
    23202320    event[6] = 0; // TODO: role
    23212321    event[7] = address_type;
    2322     bt_flip_addr(&event[8], *address);
    2323     bt_store_16(event, 14, 0); // interval
    2324     bt_store_16(event, 16, 0); // latency
    2325     bt_store_16(event, 18, 0); // supervision timeout
     2322    reverse_bd_addr(*address, &event[8]);
     2323    little_endian_store_16(event, 14, 0); // interval
     2324    little_endian_store_16(event, 16, 0); // latency
     2325    little_endian_store_16(event, 18, 0); // supervision timeout
    23262326    event[20] = 0; // master clock accuracy
    23272327    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    23342334    event[1] = sizeof(event) - 2;
    23352335    event[2] = 0; // status = OK
    2336     bt_store_16(event, 3, handle);
     2336    little_endian_store_16(event, 3, handle);
    23372337    event[5] = reason;
    23382338    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    23462346    event[0] = L2CAP_EVENT_TIMEOUT_CHECK;
    23472347    event[1] = sizeof(event) - 2;
    2348     bt_store_16(event, 2, conn->con_handle);
     2348    little_endian_store_16(event, 2, conn->con_handle);
    23492349    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    23502350    hci_stack->packet_handler(HCI_EVENT_PACKET, event, sizeof(event));
    … …  
    23782378    event[2] = BTSTACK_MAJOR;
    23792379    event[3] = BTSTACK_MINOR;
    2380     bt_store_16(event, 4, BTSTACK_REVISION);
     2380    little_endian_store_16(event, 4, BTSTACK_REVISION);
    23812381    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    23822382    hci_stack->packet_handler(HCI_EVENT_PACKET, event, sizeof(event));
    … …  
    23992399    event[1] = sizeof(event) - 2 - 1;
    24002400    event[2] = 0;   // just to be compatible with HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE
    2401     bt_flip_addr(&event[3], *addr);
     2401    reverse_bd_addr(*addr, &event[3]);
    24022402    memcpy(&event[9], name, 248);
    24032403
    … …  
    24262426    event[pos++] = GAP_SECURITY_LEVEL;
    24272427    event[pos++] = sizeof(event) - 2;
    2428     bt_store_16(event, 2, con_handle);
     2428    little_endian_store_16(event, 2, con_handle);
    24292429    pos += 2;
    24302430    event[pos++] = level;
    … …  
    24412441    event[pos++] = sizeof(event) - 2;
    24422442    event[pos++] = status;
    2443     bt_flip_addr( * (bd_addr_t *) &event[pos], address);
     2443    reverse_bd_addr(address,  * (bd_addr_t *) &event[pos]);
    24442444    pos += 6;
    24452445    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));

  • asp3_tinet_ecnl_rx/trunk/btstack/src/hci.h

    r337 r374  
    234234
    235235//
    236 #define IS_COMMAND(packet, command) (READ_BT_16(packet,0) == command.opcode)
     236#define IS_COMMAND(packet, command) (little_endian_read_16(packet,0) == command.opcode)
    237237
    238238// data: event(8)
    … …  
    595595
    596596// Allows to control if device is discoverable. OFF by default.
    597 void hci_discoverable_control(uint8_t enable);
     597void gap_discoverable_control(uint8_t enable);
    598598
    599599// Creates and sends HCI command packets based on a template and

  • asp3_tinet_ecnl_rx/trunk/btstack/src/hci_dump.c

    r337 r374  
    194194
    195195        case HCI_DUMP_BLUEZ:
    196             bt_store_16( (uint8_t *) &header_bluez.len, 0, 1 + len);
     196            little_endian_store_16( (uint8_t *) &header_bluez.len, 0, 1 + len);
    197197            header_bluez.in  = in;
    198198            header_bluez.pad = 0;
    199             bt_store_32( (uint8_t *) &header_bluez.ts_sec,  0, curr_time.tv_sec);
    200             bt_store_32( (uint8_t *) &header_bluez.ts_usec, 0, curr_time.tv_usec);
     199            little_endian_store_32( (uint8_t *) &header_bluez.ts_sec,  0, curr_time.tv_sec);
     200            little_endian_store_32( (uint8_t *) &header_bluez.ts_usec, 0, curr_time.tv_usec);
    201201            header_bluez.packet_type = packet_type;
    202202            write (dump_file, &header_bluez, sizeof(hcidump_hdr) );

  • asp3_tinet_ecnl_rx/trunk/btstack/src/l2cap.c

    r337 r374  
    135135    event[1] = sizeof(event) - 2;
    136136    event[2] = status;
    137     bt_flip_addr(&event[3], channel->address);
    138     bt_store_16(event,  9, channel->handle);
    139     bt_store_16(event, 11, channel->psm);
    140     bt_store_16(event, 13, channel->local_cid);
    141     bt_store_16(event, 15, channel->remote_cid);
    142     bt_store_16(event, 17, channel->local_mtu);
    143     bt_store_16(event, 19, channel->remote_mtu);
    144     bt_store_16(event, 21, channel->flush_timeout);
     137    reverse_bd_addr(channel->address, &event[3]);
     138    little_endian_store_16(event,  9, channel->handle);
     139    little_endian_store_16(event, 11, channel->psm);
     140    little_endian_store_16(event, 13, channel->local_cid);
     141    little_endian_store_16(event, 15, channel->remote_cid);
     142    little_endian_store_16(event, 17, channel->local_mtu);
     143    little_endian_store_16(event, 19, channel->remote_mtu);
     144    little_endian_store_16(event, 21, channel->flush_timeout);
    145145    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    146146    l2cap_dispatch(channel, HCI_EVENT_PACKET, event, sizeof(event));
    … …  
    152152    event[0] = L2CAP_EVENT_CHANNEL_CLOSED;
    153153    event[1] = sizeof(event) - 2;
    154     bt_store_16(event, 2, channel->local_cid);
     154    little_endian_store_16(event, 2, channel->local_cid);
    155155    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    156156    l2cap_dispatch(channel, HCI_EVENT_PACKET, event, sizeof(event));
    … …  
    163163    event[0] = L2CAP_EVENT_INCOMING_CONNECTION;
    164164    event[1] = sizeof(event) - 2;
    165     bt_flip_addr(&event[2], channel->address);
    166     bt_store_16(event,  8, channel->handle);
    167     bt_store_16(event, 10, channel->psm);
    168     bt_store_16(event, 12, channel->local_cid);
    169     bt_store_16(event, 14, channel->remote_cid);
     165    reverse_bd_addr(channel->address, &event[2]);
     166    little_endian_store_16(event,  8, channel->handle);
     167    little_endian_store_16(event, 10, channel->psm);
     168    little_endian_store_16(event, 12, channel->local_cid);
     169    little_endian_store_16(event, 14, channel->remote_cid);
    170170    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    171171    l2cap_dispatch(channel, HCI_EVENT_PACKET, event, sizeof(event));
    … …  
    176176    event[0] = L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_RESPONSE;
    177177    event[1] = 4;
    178     bt_store_16(event, 2, handle);
    179     bt_store_16(event, 4, result);
     178    little_endian_store_16(event, 2, handle);
     179    little_endian_store_16(event, 4, result);
    180180    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    181181    (*packet_handler)(NULL, HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    188188    event[1] = sizeof(event) - 2;
    189189    event[2] = status;
    190     bt_store_16(event, 3, psm);
     190    little_endian_store_16(event, 3, psm);
    191191    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    192192    (*packet_handler)(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    201201    event[0] = L2CAP_EVENT_CREDITS;
    202202    event[1] = sizeof(event) - 2;
    203     bt_store_16(event, 2, channel->local_cid);
     203    little_endian_store_16(event, 2, channel->local_cid);
    204204    event[4] = credits;
    205205    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    412412
    413413    // 0 - Connection handle : PB=pb : BC=00
    414     bt_store_16(acl_buffer, 0, channel->handle | (pb << 12) | (0 << 14));
     414    little_endian_store_16(acl_buffer, 0, channel->handle | (pb << 12) | (0 << 14));
    415415    // 2 - ACL length
    416     bt_store_16(acl_buffer, 2,  len + 4);
     416    little_endian_store_16(acl_buffer, 2,  len + 4);
    417417    // 4 - L2CAP packet length
    418     bt_store_16(acl_buffer, 4,  len + 0);
     418    little_endian_store_16(acl_buffer, 4,  len + 0);
    419419    // 6 - L2CAP channel DEST
    420     bt_store_16(acl_buffer, 6, channel->remote_cid);
     420    little_endian_store_16(acl_buffer, 6, channel->remote_cid);
    421421    // send
    422422    err = hci_send_acl_packet_buffer(len+8);
    … …  
    449449
    450450    // 0 - Connection handle : PB=pb : BC=00
    451     bt_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
     451    little_endian_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
    452452    // 2 - ACL length
    453     bt_store_16(acl_buffer, 2,  len + 4);
     453    little_endian_store_16(acl_buffer, 2,  len + 4);
    454454    // 4 - L2CAP packet length
    455     bt_store_16(acl_buffer, 4,  len + 0);
     455    little_endian_store_16(acl_buffer, 4,  len + 0);
    456456    // 6 - L2CAP channel DEST
    457     bt_store_16(acl_buffer, 6, cid);
     457    little_endian_store_16(acl_buffer, 6, cid);
    458458    // send
    459459    err = hci_send_acl_packet_buffer(len+8);
    … …  
    665665                        config_options[0] = 1; // MTU
    666666                        config_options[1] = 2; // len param
    667                         bt_store_16( (uint8_t*)&config_options, 2, channel->remote_mtu);
     667                        little_endian_store_16( (uint8_t*)&config_options, 2, channel->remote_mtu);
    668668                        l2cap_send_signaling_packet(channel->handle, CONFIGURE_RESPONSE, channel->remote_sig_id, channel->remote_cid, flags, 0, 4, &config_options);
    669669                        channelStateVarClearFlag(channel,L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU);
    … …  
    679679                    config_options[0] = 1; // MTU
    680680                    config_options[1] = 2; // len param
    681                     bt_store_16( (uint8_t*)&config_options, 2, channel->local_mtu);
     681                    little_endian_store_16( (uint8_t*)&config_options, 2, channel->local_mtu);
    682682                    l2cap_send_signaling_packet(channel->handle, CONFIGURE_REQUEST, channel->local_sig_id, channel->remote_cid, 0, 4, &config_options);
    683683                    l2cap_start_rtx(channel);
    … …  
    893893        // handle connection complete events
    894894        case HCI_EVENT_CONNECTION_COMPLETE:
    895             bt_flip_addr(address, &packet[5]);
     895            reverse_bd_addr(&packet[5], address);
    896896            if (packet[2] == 0){
    897                 handle = READ_BT_16(packet, 3);
     897                handle = little_endian_read_16(packet, 3);
    898898                l2cap_handle_connection_success_for_addr(address, handle);
    899899            } else {
    … …  
    904904        // handle successful create connection cancel command
    905905        case HCI_EVENT_COMMAND_COMPLETE:
    906             if ( COMMAND_COMPLETE_EVENT(packet, hci_create_connection_cancel) ) {
     906            if ( HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_create_connection_cancel) ) {
    907907                if (packet[5] == 0){
    908                     bt_flip_addr(address, &packet[6]);
     908                    reverse_bd_addr(&packet[6], address);
    909909                    // CONNECTION TERMINATED BY LOCAL HOST (0X16)
    910910                    l2cap_handle_connection_failed_for_addr(address, 0x16);
    … …  
    921921        case HCI_EVENT_DISCONNECTION_COMPLETE:
    922922            // send l2cap disconnect events for all channels on this handle and free them
    923             handle = READ_BT_16(packet, 3);
     923            handle = little_endian_read_16(packet, 3);
    924924            linked_list_iterator_init(&it, &l2cap_channels);
    925925            while (linked_list_iterator_has_next(&it)){
    … …  
    940940        // HCI Connection Timeouts
    941941        case L2CAP_EVENT_TIMEOUT_CHECK:
    942             handle = READ_BT_16(packet, 2);
     942            handle = little_endian_read_16(packet, 2);
    943943            if (hci_authentication_active_for_handle(handle)) break;
    944944            hci_con_used = 0;
    … …  
    971971
    972972        case HCI_EVENT_READ_REMOTE_SUPPORTED_FEATURES_COMPLETE:
    973             handle = READ_BT_16(packet, 3);
     973            handle = little_endian_read_16(packet, 3);
    974974            linked_list_iterator_init(&it, &l2cap_channels);
    975975            while (linked_list_iterator_has_next(&it)){
    … …  
    982982
    983983        case GAP_SECURITY_LEVEL:
    984             handle = READ_BT_16(packet, 2);
     984            handle = little_endian_read_16(packet, 2);
    985985            log_info("l2cap - security level update");
    986986            linked_list_iterator_init(&it, &l2cap_channels);
    … …  
    11631163    channel->remote_sig_id = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET];
    11641164
    1165     flags = READ_BT_16(command, 6);
     1165    flags = little_endian_read_16(command, 6);
    11661166    if (flags & 1) {
    11671167        channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT);
    … …  
    11691169
    11701170    // accept the other's configuration options
    1171     end_pos = 4 + READ_BT_16(command, L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET);
     1171    end_pos = 4 + little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET);
    11721172    pos     = 8;
    11731173    while (pos < end_pos){
    … …  
    11801180        // MTU { type(8): 1, len(8):2, MTU(16) }
    11811181        if (option_type == 1 && length == 2){
    1182             channel->remote_mtu = READ_BT_16(command, pos);
     1182            channel->remote_mtu = little_endian_read_16(command, pos);
    11831183            // log_info("l2cap cid 0x%02x, remote mtu %u", channel->local_cid, channel->remote_mtu);
    11841184            channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU);
    … …  
    11861186        // Flush timeout { type(8):2, len(8): 2, Flush Timeout(16)}
    11871187        if (option_type == 2 && length == 2){
    1188             channel->flush_timeout = READ_BT_16(command, pos);
     1188            channel->flush_timeout = little_endian_read_16(command, pos);
    11891189        }
    11901190        // check for unknown options
    … …  
    12371237                case CONNECTION_RESPONSE:
    12381238                    l2cap_stop_rtx(channel);
    1239                     result = READ_BT_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4);
     1239                    result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4);
    12401240                    switch (result) {
    12411241                        case 0:
    12421242                            // successful connection
    1243                             channel->remote_cid = READ_BT_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
     1243                            channel->remote_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
    12441244                            channel->state = L2CAP_STATE_CONFIG;
    12451245                            channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ);
    … …  
    12741274
    12751275        case L2CAP_STATE_CONFIG:
    1276             result = READ_BT_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4);
     1276            result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4);
    12771277            switch (code) {
    12781278                case CONFIGURE_REQUEST:
    … …  
    13531353
    13541354        case CONNECTION_REQUEST: {
    1355             uint16_t psm =        READ_BT_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
    1356             uint16_t source_cid = READ_BT_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+2);
     1355            uint16_t psm =        little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
     1356            uint16_t source_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+2);
    13571357            l2cap_handle_connection_request(handle, sig_id, psm, source_cid);
    13581358            return;
    … …  
    13641364
    13651365        case INFORMATION_REQUEST: {
    1366             uint16_t infoType = READ_BT_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
     1366            uint16_t infoType = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
    13671367            l2cap_register_signaling_response(handle, code, sig_id, infoType);
    13681368            return;
    … …  
    13751375   
    13761376    // Get potential destination CID
    1377     dest_cid = READ_BT_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
     1377    dest_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
    13781378
    13791379    // Find channel for this sig_id and connection handle
    … …  
    14151415
    14161416                // increment command_offset
    1417                 command_offset += L2CAP_SIGNALING_COMMAND_DATA_OFFSET + READ_BT_16(packet, command_offset + L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET);
     1417                command_offset += L2CAP_SIGNALING_COMMAND_DATA_OFFSET + little_endian_read_16(packet, command_offset + L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET);
    14181418            }
    14191419            break;
    … …  
    14351435            switch (packet[8]){
    14361436                case CONNECTION_PARAMETER_UPDATE_RESPONSE: {
    1437                     uint16_t result = READ_BT_16(packet, 12);
     1437                    uint16_t result = little_endian_read_16(packet, 12);
    14381438                    l2cap_emit_connection_parameter_update_response(handle, result);
    14391439                    break;
    … …  
    14501450                        int update_parameter = 1;
    14511451                        le_connection_parameter_range_t existing_range = gap_le_get_connection_parameter_range();
    1452                         uint16_t le_conn_interval_min = READ_BT_16(packet,12);
    1453                         uint16_t le_conn_interval_max = READ_BT_16(packet,14);
    1454                         uint16_t le_conn_latency = READ_BT_16(packet,16);
    1455                         uint16_t le_supervision_timeout = READ_BT_16(packet,18);
     1452                        uint16_t le_conn_interval_min = little_endian_read_16(packet,12);
     1453                        uint16_t le_conn_interval_max = little_endian_read_16(packet,14);
     1454                        uint16_t le_conn_latency = little_endian_read_16(packet,16);
     1455                        uint16_t le_supervision_timeout = little_endian_read_16(packet,18);
    14561456
    14571457                        if (le_conn_interval_min < existing_range.le_conn_interval_min) update_parameter = 0;

  • asp3_tinet_ecnl_rx/trunk/btstack/src/l2cap_signaling.c

    r337 r374  
    9191
    9292    // 0 - Connection handle : PB=pb : BC=00
    93     bt_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
     93    little_endian_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
    9494    // 6 - L2CAP channel = 1
    95     bt_store_16(acl_buffer, 6, cid);
     95    little_endian_store_16(acl_buffer, 6, cid);
    9696    // 8 - Code
    9797    acl_buffer[8] = cmd;
    … …  
    134134
    135135    // 2 - ACL length
    136     bt_store_16(acl_buffer, 2,  pos - 4);
     136    little_endian_store_16(acl_buffer, 2,  pos - 4);
    137137    // 4 - L2CAP packet length
    138     bt_store_16(acl_buffer, 4,  pos - 6 - 2);
     138    little_endian_store_16(acl_buffer, 4,  pos - 6 - 2);
    139139    // 10 - L2CAP signaling parameter length
    140     bt_store_16(acl_buffer, 10, pos - 12);
     140    little_endian_store_16(acl_buffer, 10, pos - 12);
    141141
    142142    return pos;
    … …  
    158158
    159159    // 0 - Connection handle : PB=pb : BC=00
    160     bt_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
     160    little_endian_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
    161161    // 6 - L2CAP LE Signaling channel = 5
    162     bt_store_16(acl_buffer, 6, 5);
     162    little_endian_store_16(acl_buffer, 6, 5);
    163163    // 8 - Code
    164164    acl_buffer[8] = CONNECTION_PARAMETER_UPDATE_REQUEST;
    … …  
    166166    acl_buffer[9] = 1;
    167167    uint16_t pos = 12;
    168     bt_store_16(acl_buffer, pos, interval_min);
    169     pos += 2;
    170     bt_store_16(acl_buffer, pos, interval_max);
    171     pos += 2;
    172     bt_store_16(acl_buffer, pos, slave_latency);
    173     pos += 2;
    174     bt_store_16(acl_buffer, pos, timeout_multiplier);
     168    little_endian_store_16(acl_buffer, pos, interval_min);
     169    pos += 2;
     170    little_endian_store_16(acl_buffer, pos, interval_max);
     171    pos += 2;
     172    little_endian_store_16(acl_buffer, pos, slave_latency);
     173    pos += 2;
     174    little_endian_store_16(acl_buffer, pos, timeout_multiplier);
    175175    pos += 2;
    176176    // 2 - ACL length
    177     bt_store_16(acl_buffer, 2,  pos - 4);
     177    little_endian_store_16(acl_buffer, 2,  pos - 4);
    178178    // 4 - L2CAP packet length
    179     bt_store_16(acl_buffer, 4,  pos - 6 - 2);
     179    little_endian_store_16(acl_buffer, 4,  pos - 6 - 2);
    180180    // 10 - L2CAP signaling parameter length
    181     bt_store_16(acl_buffer, 10, pos - 12);
     181    little_endian_store_16(acl_buffer, 10, pos - 12);
    182182    return pos;
    183183}
    … …  
    188188
    189189    // 0 - Connection handle : PB=pb : BC=00
    190     bt_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
     190    little_endian_store_16(acl_buffer, 0, handle | (pb << 12) | (0 << 14));
    191191    // 6 - L2CAP LE Signaling channel = 5
    192     bt_store_16(acl_buffer, 6, 5);
     192    little_endian_store_16(acl_buffer, 6, 5);
    193193    // 8 - Code
    194194    acl_buffer[8] = CONNECTION_PARAMETER_UPDATE_REQUEST;
    … …  
    196196    acl_buffer[9] = 1;
    197197    uint16_t pos = 12;
    198     bt_store_16(acl_buffer, pos, response);
     198    little_endian_store_16(acl_buffer, pos, response);
    199199    pos += 2;
    200200    // 2 - ACL length
    201     bt_store_16(acl_buffer, 2,  pos - 4);
     201    little_endian_store_16(acl_buffer, 2,  pos - 4);
    202202    // 4 - L2CAP packet length
    203     bt_store_16(acl_buffer, 4,  pos - 6 - 2);
     203    little_endian_store_16(acl_buffer, 4,  pos - 6 - 2);
    204204    // 10 - L2CAP signaling parameter length
    205     bt_store_16(acl_buffer, 10, pos - 12);
     205    little_endian_store_16(acl_buffer, 10, pos - 12);
    206206    return pos;
    207207}

  • asp3_tinet_ecnl_rx/trunk/btstack/src/pan.c

    r337 r374  
    8080
    8181        // 0x0001 "Service Class ID List"
    82         de_add_number(service,  DE_UINT, DE_SIZE_16, SDP_ServiceClassIDList);
     82        de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
    8383        attribute = de_push_sequence(service);
    8484        {
    … …  
    8989
    9090        // 0x0004 "Protocol Descriptor List"
    91         de_add_number(service,  DE_UINT, DE_SIZE_16, SDP_ProtocolDescriptorList);
     91        de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
    9292        attribute = de_push_sequence(service);
    9393        {
    … …  
    9595                {
    9696                        de_add_number(l2cpProtocol,  DE_UUID, DE_SIZE_16, 0x0100);
    97                         de_add_number(l2cpProtocol,  DE_UINT, DE_SIZE_16, SDP_BNEPProtocol);  // l2cap psm
     97                        de_add_number(l2cpProtocol,  DE_UINT, DE_SIZE_16, BLUETOOTH_PROTOCOL_BNEP);  // l2cap psm
    9898                }
    9999                de_pop_sequence(attribute, l2cpProtocol);

  • asp3_tinet_ecnl_rx/trunk/btstack/src/rfcomm.c

    r337 r374  
    136136    event[0] = RFCOMM_EVENT_INCOMING_CONNECTION;
    137137    event[1] = sizeof(event) - 2;
    138     bt_flip_addr(&event[2], channel->multiplexer->remote_addr);
     138    reverse_bd_addr(channel->multiplexer->remote_addr, &event[2]);
    139139    event[8] = channel->dlci >> 1;
    140     bt_store_16(event, 9, channel->rfcomm_cid);
     140    little_endian_store_16(event, 9, channel->rfcomm_cid);
    141141    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    142142        (*app_packet_handler)(channel->connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event));
    … …  
    157157    event[pos++] = sizeof(event) - 2;
    158158    event[pos++] = status;
    159     bt_flip_addr(&event[pos], channel->multiplexer->remote_addr); pos += 6;
    160     bt_store_16(event,  pos, channel->multiplexer->con_handle);   pos += 2;
     159    reverse_bd_addr(channel->multiplexer->remote_addr, &event[pos]); pos += 6;
     160    little_endian_store_16(event,  pos, channel->multiplexer->con_handle);   pos += 2;
    161161        event[pos++] = channel->dlci >> 1;
    162         bt_store_16(event, pos, channel->rfcomm_cid); pos += 2;       // channel ID
    163         bt_store_16(event, pos, channel->max_frame_size); pos += 2;   // max frame size
     162        little_endian_store_16(event, pos, channel->rfcomm_cid); pos += 2;       // channel ID
     163        little_endian_store_16(event, pos, channel->max_frame_size); pos += 2;   // max frame size
    164164    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    165165        (*app_packet_handler)(channel->connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, pos);
    … …  
    175175    event[pos++] = sizeof(event) - 2;
    176176    event[pos++] = BTSTACK_MEMORY_ALLOC_FAILED;
    177     bt_flip_addr(&event[pos], *addr); pos += 6;
    178     bt_store_16(event,  pos, 0);   pos += 2;
     177    reverse_bd_addr(*addr, &event[pos]); pos += 6;
     178    little_endian_store_16(event,  pos, 0);   pos += 2;
    179179        event[pos++] = server_channel;
    180         bt_store_16(event, pos, 0); pos += 2;   // channel ID
    181         bt_store_16(event, pos, 0); pos += 2;   // max frame size
     180        little_endian_store_16(event, pos, 0); pos += 2;   // channel ID
     181        little_endian_store_16(event, pos, 0); pos += 2;   // max frame size
    182182    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    183183        (*app_packet_handler)(connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, pos);
    … …  
    204204    event[0] = RFCOMM_EVENT_CHANNEL_CLOSED;
    205205    event[1] = sizeof(event) - 2;
    206     bt_store_16(event, 2, channel->rfcomm_cid);
     206    little_endian_store_16(event, 2, channel->rfcomm_cid);
    207207    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    208208        (*app_packet_handler)(channel->connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event));
    … …  
    214214    event[0] = RFCOMM_EVENT_CREDITS;
    215215    event[1] = sizeof(event) - 2;
    216     bt_store_16(event, 2, channel->rfcomm_cid);
     216    little_endian_store_16(event, 2, channel->rfcomm_cid);
    217217    event[4] = credits;
    218218    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    237237    event[0] = RFCOMM_EVENT_REMOTE_LINE_STATUS;
    238238    event[1] = sizeof(event) - 2;
    239     bt_store_16(event, 2, channel->rfcomm_cid);
     239    little_endian_store_16(event, 2, channel->rfcomm_cid);
    240240    event[4] = line_status;
    241241    hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
    … …  
    905905        case L2CAP_EVENT_INCOMING_CONNECTION:
    906906            // data: event(8), len(8), address(48), handle (16),  psm (16), source cid(16) dest cid(16)
    907             bt_flip_addr(event_addr, &packet[2]);
    908             con_handle = READ_BT_16(packet,  8);
    909             psm        = READ_BT_16(packet, 10);
    910             l2cap_cid  = READ_BT_16(packet, 12);
     907            reverse_bd_addr(&packet[2], event_addr);
     908            con_handle = little_endian_read_16(packet,  8);
     909            psm        = little_endian_read_16(packet, 10);
     910            l2cap_cid  = little_endian_read_16(packet, 12);
    911911
    912912            if (psm != PSM_RFCOMM) break;
    … …  
    939939        case L2CAP_EVENT_CHANNEL_OPENED:
    940940
    941             if (READ_BT_16(packet, 11) != PSM_RFCOMM) break;
     941            if (little_endian_read_16(packet, 11) != PSM_RFCOMM) break;
    942942
    943943            status = packet[2];
    … …  
    945945
    946946            // get multiplexer for remote addr
    947             con_handle = READ_BT_16(packet, 9);
    948             l2cap_cid = READ_BT_16(packet, 13);
    949             bt_flip_addr(event_addr, &packet[3]);
     947            con_handle = little_endian_read_16(packet, 9);
     948            l2cap_cid = little_endian_read_16(packet, 13);
     949            reverse_bd_addr(&packet[3], event_addr);
    950950            multiplexer = rfcomm_multiplexer_for_addr(&event_addr);
    951951            if (!multiplexer) {
    … …  
    990990
    991991                // set max frame size based on l2cap MTU
    992                 multiplexer->max_frame_size = rfcomm_max_frame_size_for_l2cap_mtu(READ_BT_16(packet, 17));
     992                multiplexer->max_frame_size = rfcomm_max_frame_size_for_l2cap_mtu(little_endian_read_16(packet, 17));
    993993            }
    994994            return 1;
    … …  
    998998        case L2CAP_EVENT_CREDITS:
    999999            // data: event(8), len(8), local_cid(16), credits(8)
    1000             l2cap_cid = READ_BT_16(packet, 2);
     1000            l2cap_cid = little_endian_read_16(packet, 2);
    10011001            multiplexer = rfcomm_multiplexer_for_l2cap_cid(l2cap_cid);
    10021002            if (!multiplexer) break;
    … …  
    10191019        case L2CAP_EVENT_CHANNEL_CLOSED:
    10201020            // data: event (8), len(8), channel (16)
    1021             l2cap_cid = READ_BT_16(packet, 2);
     1021            l2cap_cid = little_endian_read_16(packet, 2);
    10221022            multiplexer = rfcomm_multiplexer_for_l2cap_cid(l2cap_cid);
    10231023            log_info("L2CAP_EVENT_CHANNEL_CLOSED cid 0x%0x, mult %p", l2cap_cid, multiplexer);
    … …  
    14781478                    event_pn.super.type = CH_EVT_RCVD_PN;
    14791479                    event_pn.priority = packet[payload_offset+4];
    1480                     event_pn.max_frame_size = READ_BT_16(packet, payload_offset+6);
     1480                    event_pn.max_frame_size = little_endian_read_16(packet, payload_offset+6);
    14811481                    event_pn.credits_outgoing = packet[payload_offset+9];
    14821482                    log_info("Received UIH Parameter Negotiation Command for #%u, credits %u",
    … …  
    14891489                    event_pn.super.type = CH_EVT_RCVD_PN_RSP;
    14901490                    event_pn.priority = packet[payload_offset+4];
    1491                     event_pn.max_frame_size = READ_BT_16(packet, payload_offset+6);
     1491                    event_pn.max_frame_size = little_endian_read_16(packet, payload_offset+6);
    14921492                    event_pn.credits_outgoing = packet[payload_offset+9];
    14931493                    log_info("Received UIH Parameter Negotiation Response max frame %u, credits %u",

  • asp3_tinet_ecnl_rx/trunk/btstack/src/sdp.c

    r337 r374  
    9090    if (de_get_element_type(serviceRecordHandleAttribute) != DE_UINT) return 0;
    9191    if (de_get_size_type(serviceRecordHandleAttribute) != DE_SIZE_32) return 0;
    92     return READ_NET_32(serviceRecordHandleAttribute, 1);
     92    return big_endian_read_32(serviceRecordHandleAttribute, 1);
    9393}
    9494
    … …  
    100100    event[1] = sizeof(event) - 2;
    101101    event[2] = status;
    102     bt_store_32(event, 3, handle);
     102    little_endian_store_32(event, 3, handle);
    103103    hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
    104104    (*app_packet_handler)(connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event));
    … …  
    275275
    276276    // get request details
    277     uint16_t  transaction_id = READ_NET_16(packet, 1);
    278     // not used yet - uint16_t  param_len = READ_NET_16(packet, 3);
     277    uint16_t  transaction_id = big_endian_read_16(packet, 1);
     278    // not used yet - uint16_t  param_len = big_endian_read_16(packet, 3);
    279279    uint8_t * serviceSearchPattern = &packet[5];
    280280    uint16_t  serviceSearchPatternLen = de_get_len(serviceSearchPattern);
    281     uint16_t  maximumServiceRecordCount = READ_NET_16(packet, 5 + serviceSearchPatternLen);
     281    uint16_t  maximumServiceRecordCount = big_endian_read_16(packet, 5 + serviceSearchPatternLen);
    282282    uint8_t * continuationState = &packet[5+serviceSearchPatternLen+2];
    283283
    … …  
    297297    continuation_index = 0;
    298298    if (continuationState[0] == 2){
    299         continuation_index = READ_NET_16(continuationState, 1);
     299        continuation_index = big_endian_read_16(continuationState, 1);
    300300    }
    301301
    … …  
    359359
    360360    // get request details
    361     uint16_t  transaction_id = READ_NET_16(packet, 1);
    362     // not used yet - uint16_t  param_len = READ_NET_16(packet, 3);
    363     uint32_t  serviceRecordHandle = READ_NET_32(packet, 5);
    364     uint16_t  maximumAttributeByteCount = READ_NET_16(packet, 9);
     361    uint16_t  transaction_id = big_endian_read_16(packet, 1);
     362    // not used yet - uint16_t  param_len = big_endian_read_16(packet, 3);
     363    uint32_t  serviceRecordHandle = big_endian_read_32(packet, 5);
     364    uint16_t  maximumAttributeByteCount = big_endian_read_16(packet, 9);
    365365    uint8_t * attributeIDList = &packet[11];
    366366    uint16_t  attributeIDListLen = de_get_len(attributeIDList);
    … …  
    383383    continuation_offset = 0;
    384384    if (continuationState[0] == 2){
    385         continuation_offset = READ_NET_16(continuationState, 1);
     385        continuation_offset = big_endian_read_16(continuationState, 1);
    386386    }
    387387
    … …  
    452452
    453453    // get request details
    454     uint16_t  transaction_id = READ_NET_16(packet, 1);
    455     // not used yet - uint16_t  param_len = READ_NET_16(packet, 3);
     454    uint16_t  transaction_id = big_endian_read_16(packet, 1);
     455    // not used yet - uint16_t  param_len = big_endian_read_16(packet, 3);
    456456    uint8_t * serviceSearchPattern = &packet[5];
    457457    uint16_t  serviceSearchPatternLen = de_get_len(serviceSearchPattern);
    458     uint16_t  maximumAttributeByteCount = READ_NET_16(packet, 5 + serviceSearchPatternLen);
     458    uint16_t  maximumAttributeByteCount = big_endian_read_16(packet, 5 + serviceSearchPatternLen);
    459459    uint8_t * attributeIDList = &packet[5+serviceSearchPatternLen+2];
    460460    uint16_t  attributeIDListLen = de_get_len(attributeIDList);
    … …  
    481481    continuation_offset = 0;
    482482    if (continuationState[0] == 4){
    483         continuation_service_index = READ_NET_16(continuationState, 1);
    484         continuation_offset = READ_NET_16(continuationState, 3);
     483        continuation_service_index = big_endian_read_16(continuationState, 1);
     484        continuation_offset = big_endian_read_16(continuationState, 3);
    485485    }
    486486
    … …  
    593593        case L2CAP_DATA_PACKET:
    594594            pdu_id = (SDP_PDU_ID_t) packet[0];
    595             transaction_id = READ_NET_16(packet, 1);
    596             // param_len = READ_NET_16(packet, 3);
     595            transaction_id = big_endian_read_16(packet, 1);
     596            // param_len = big_endian_read_16(packet, 3);
    597597            remote_mtu = l2cap_get_remote_mtu_for_local_cid(channel);
    598598            // account for our buffer

  • asp3_tinet_ecnl_rx/trunk/btstack/src/sdp_client.c

    r337 r374  
    151151static void parse_service_search_attribute_response(uint8_t* packet){
    152152    uint16_t offset = 3;
    153     uint16_t parameterLength = READ_NET_16(packet,offset);
     153    uint16_t parameterLength = big_endian_read_16(packet,offset);
    154154    uint16_t attributeListByteCount;
    155155    offset+=2;
    156156    // AttributeListByteCount <= mtu
    157     attributeListByteCount = READ_NET_16(packet,offset);
     157    attributeListByteCount = big_endian_read_16(packet,offset);
    158158    offset+=2;
    159159
    … …  
    185185    // uint16_t handle;
    186186    if (packet_type == L2CAP_DATA_PACKET){
    187         uint16_t responseTransactionID = READ_NET_16(packet,1);
     187        uint16_t responseTransactionID = big_endian_read_16(packet,1);
    188188        if ( responseTransactionID != transactionID){
    189189            log_error("Missmatching transaction ID, expected %u, found %u.", transactionID, responseTransactionID);
    … …  
    247247            }
    248248            sdp_cid = channel;
    249             mtu = READ_BT_16(packet, 17);
    250             // handle = READ_BT_16(packet, 9);
     249            mtu = little_endian_read_16(packet, 17);
     250            // handle = little_endian_read_16(packet, 9);
    251251            log_info("SDP Client Connected, cid %x, mtu %u.", sdp_cid, mtu);
    252252
    … …  
    261261        case L2CAP_EVENT_CHANNEL_CLOSED: {
    262262            uint8_t status;
    263             if (sdp_cid != READ_BT_16(packet, 2)) {
    264                 // log_info("Received L2CAP_EVENT_CHANNEL_CLOSED for cid %x, current cid %x\n",  READ_BT_16(packet, 2),sdp_cid);
     263            if (sdp_cid != little_endian_read_16(packet, 2)) {
     264                // log_info("Received L2CAP_EVENT_CHANNEL_CLOSED for cid %x, current cid %x\n",  little_endian_read_16(packet, 2),sdp_cid);
    265265                break;
    266266            }
    … …  
    402402static void parse_service_search_response(uint8_t* packet){
    403403    uint16_t offset = 3;
    404     uint16_t parameterLength = READ_NET_16(packet,offset);
     404    uint16_t parameterLength = big_endian_read_16(packet,offset);
    405405    uint16_t totalServiceRecordCount;
    406406    uint16_t currentServiceRecordCount;
    407407    offset+=2;
    408408
    409     totalServiceRecordCount = READ_NET_16(packet,offset);
    410     offset+=2;
    411 
    412     currentServiceRecordCount = READ_NET_16(packet,offset);
     409    totalServiceRecordCount = big_endian_read_16(packet,offset);
     410    offset+=2;
     411
     412    currentServiceRecordCount = big_endian_read_16(packet,offset);
    413413    offset+=2;
    414414    if (currentServiceRecordCount > totalServiceRecordCount){
    … …  
    436436static void parse_service_attribute_response(uint8_t* packet){
    437437    uint16_t offset = 3;
    438     uint16_t parameterLength = READ_NET_16(packet,offset);
     438    uint16_t parameterLength = big_endian_read_16(packet,offset);
    439439        uint16_t attributeListByteCount;
    440440    offset+=2;
    441441
    442442    // AttributeListByteCount <= mtu
    443     attributeListByteCount = READ_NET_16(packet,offset);
     443    attributeListByteCount = big_endian_read_16(packet,offset);
    444444    offset+=2;
    445445

  • asp3_tinet_ecnl_rx/trunk/btstack/src/sdp_parser.c

    r337 r374  
    166166            {
    167167            sdp_query_attribute_value_event_t attribute_value_event = {
    168                 SDP_QUERY_ATTRIBUTE_VALUE,
     168                SDP_EVENT_QUERY_ATTRIBUTE_VALUE,
    169169                record_counter,
    170170                attribute_id,
    … …  
    186186            {
    187187            sdp_query_attribute_value_event_t attribute_value_event = {
    188                 SDP_QUERY_ATTRIBUTE_VALUE,
     188                SDP_EVENT_QUERY_ATTRIBUTE_VALUE,
    189189                record_counter,
    190190                attribute_id,
    … …  
    258258    int i;
    259259    for (i=0;i<record_handle_count;i++){
    260         record_handle = READ_NET_32(data, i*4);
     260        record_handle = big_endian_read_32(data, i*4);
    261261        record_counter++;
    262262                {
    … …  
    275275void sdp_parser_handle_done(uint8_t status){
    276276    sdp_query_complete_event_t complete_event = {
    277         SDP_QUERY_COMPLETE,
     277        SDP_EVENT_QUERY_COMPLETE,
    278278        status
    279279    };

  • asp3_tinet_ecnl_rx/trunk/btstack/src/sdp_query_rfcomm.c

    r337 r374  
    248248    sdp_query_attribute_value_event_t * ve;
    249249    switch (event->type){
    250         case SDP_QUERY_ATTRIBUTE_VALUE:
     250        case SDP_EVENT_QUERY_ATTRIBUTE_VALUE:
    251251            ve = (sdp_query_attribute_value_event_t*) event;
    252252           // log_info("handle_sdp_parser_event [ AID, ALen, DOff, Data] : [%x, %u, %u] BYTE %02x",
    … …  
    254254
    255255            switch (ve->attribute_id){
    256                 case SDP_ProtocolDescriptorList:
     256                case BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST:
    257257                    // find rfcomm channel
    258258                    handleProtocolDescriptorListData(ve->attribute_length, ve->data_offset, ve->data);
    … …  
    267267            }
    268268            break;
    269         case SDP_QUERY_COMPLETE:
     269        case SDP_EVENT_QUERY_COMPLETE:
    270270            (*sdp_app_callback)(event, sdp_app_context);
    271271            break;

  • asp3_tinet_ecnl_rx/trunk/btstack/src/sdp_util.c

    r337 r374  
    9898            break;
    9999        case DE_SIZE_VAR_16:
    100             result = READ_NET_16(header,1);
     100            result = big_endian_read_16(header,1);
    101101            break;
    102102        case DE_SIZE_VAR_32:
    103             result = READ_NET_32(header,1);
     103            result = big_endian_read_32(header,1);
    104104            break;
    105105        default:
    … …  
    122122int de_element_get_uint16(uint8_t * element, uint16_t * value){
    123123    if (de_get_size_type(element) != DE_SIZE_16) return 0;
    124     *value = READ_NET_16(element, de_get_header_size(element));
     124    *value = big_endian_read_16(element, de_get_header_size(element));
    125125    return 1;
    126126}
    … …  
    134134    switch (uuidSize){
    135135        case DE_SIZE_16:
    136             shortUUID = READ_NET_16(element, 1);
     136            shortUUID = big_endian_read_16(element, 1);
    137137            break;
    138138        case DE_SIZE_32:
    139             shortUUID = READ_NET_32(element, 1);
     139            shortUUID = big_endian_read_32(element, 1);
    140140            break;
    141141        case DE_SIZE_128:
    … …  
    157157    hasBlueoothBaseUuid = sdp_has_blueooth_base_uuid(uuid128);
    158158    if (!hasBlueoothBaseUuid) return 0;
    159     return READ_NET_32(uuid128, 0);
     159    return big_endian_read_32(uuid128, 0);
    160160}
    161161
    … …  
    199199void de_pop_sequence(uint8_t * parent, uint8_t * child){
    200200    int child_len = de_get_len(child);
    201     int data_size_parent = READ_NET_16(parent,1);
     201    int data_size_parent = big_endian_read_16(parent,1);
    202202    net_store_16(parent, 1, data_size_parent + child_len);
    203203}
    … …  
    205205/* adds a single number value and 16+32 bit UUID to the sequence */
    206206void de_add_number(uint8_t *seq, de_type_t type, de_size_t size, uint32_t value){
    207     int data_size   = READ_NET_16(seq,1);
     207    int data_size   = big_endian_read_16(seq,1);
    208208    int element_size = 1;   // e.g. for DE_TYPE_NIL
    209209    de_store_descriptor(seq+3+data_size, type, size);
    … …  
    231231/* add a single block of data, e.g. as DE_STRING, DE_URL */
    232232void de_add_data( uint8_t *seq, de_type_t type, uint16_t size, uint8_t *data){
    233     int data_size   = READ_NET_16(seq,1);
     233    int data_size   = big_endian_read_16(seq,1);
    234234    if (size > 0xff) {
    235235        // use 16-bit lengh information (3 byte header)
    … …  
    247247
    248248void de_add_uuid128(uint8_t * seq, uint8_t * uuid){
    249     int data_size   = READ_NET_16(seq,1);
     249    int data_size   = big_endian_read_16(seq,1);
    250250    de_store_descriptor(seq+3+data_size, DE_UUID, DE_SIZE_128);
    251251    memcpy( seq + 4 + data_size, uuid, 16);
    … …  
    326326        uint8_t done;
    327327        if (idType != DE_UINT || idSize != DE_SIZE_16) break; // wrong type
    328         attribute_id = READ_NET_16(element, pos + 1);
     328        attribute_id = big_endian_read_16(element, pos + 1);
    329329        pos += 3;
    330330        if (pos >= end_pos) break; // array out of bounds
    … …  
    349349    switch (size) {
    350350        case DE_SIZE_16:
    351             if (READ_NET_16(element, 1) == context->attributeID) {
     351            if (big_endian_read_16(element, 1) == context->attributeID) {
    352352                context->result = 1;
    353353                return 1;
    … …  
    355355            break;
    356356        case DE_SIZE_32:
    357             if (READ_NET_16(element, 1) <= context->attributeID
    358             &&  context->attributeID <= READ_NET_16(element, 3)) {
     357            if (big_endian_read_16(element, 1) <= context->attributeID
     358            &&  context->attributeID <= big_endian_read_16(element, 3)) {
    359359                context->result = 1;
    360360                return 1;
    … …  
    388388    if (sdp_attribute_list_constains_id(context->attributeIDList, attributeID)) {
    389389        // DES_HEADER(3) + DES_DATA + (UINT16(3) + attribute)
    390         uint16_t data_size = READ_NET_16(context->buffer, 1);
     390        uint16_t data_size = big_endian_read_16(context->buffer, 1);
    391391        int attribute_len = de_get_len(attributeValue);
    392392        if (3 + data_size + (3 + attribute_len) <= context->maxBytes) {
    … …  
    662662                break;
    663663            case DE_SIZE_VAR_16:
    664                 len = READ_NET_16(element, 1);
     664                len = big_endian_read_16(element, 1);
    665665                break;
    666666            default:
    … …  
    678678                break;
    679679            case DE_SIZE_16:
    680                                 value = READ_NET_16(element,pos);
     680                                value = big_endian_read_16(element,pos);
    681681                break;
    682682            case DE_SIZE_32:
    683                                 value = READ_NET_32(element,pos);
     683                                value = big_endian_read_32(element,pos);
    684684                break;
    685685            default:
    … …  
    712712
    713713        // 0x0001 "Service Class ID List"
    714         de_add_number(service,  DE_UINT, DE_SIZE_16, SDP_ServiceClassIDList);
     714        de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
    715715        attribute = de_push_sequence(service);
    716716        {
    … …  
    720720
    721721        // 0x0004 "Protocol Descriptor List"
    722         de_add_number(service,  DE_UINT, DE_SIZE_16, SDP_ProtocolDescriptorList);
     722        de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
    723723        attribute = de_push_sequence(service);
    724724        {

  • asp3_tinet_ecnl_rx/trunk/btstack/src/utils.c

    r337 r374  
    4949#include "debug.h"
    5050
    51 void bt_store_16(uint8_t *buffer, uint16_t pos, uint16_t value){
     51void little_endian_store_16(uint8_t *buffer, uint16_t pos, uint16_t value){
    5252    buffer[pos++] = value;
    5353    buffer[pos++] = value >> 8;
    5454}
    5555
    56 void bt_store_32(uint8_t *buffer, uint16_t pos, uint32_t value){
     56void little_endian_store_32(uint8_t *buffer, uint16_t pos, uint32_t value){
    5757    buffer[pos++] = value;
    5858    buffer[pos++] = value >> 8;
    … …  
    7373}
    7474
    75 void bt_flip_addr(bd_addr_t dest, bd_addr_t src){
     75void reverse_bd_addr(bd_addr_t src, bd_addr_t dest){
    7676    dest[0] = src[5];
    7777    dest[1] = src[4];
Note: See TracChangeset for help on using the changeset viewer.