Repository: incubator-mynewt-core Updated Branches: refs/heads/develop 09e50c6a0 -> 33afb22a2
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/33afb22a/net/nimble/drivers/nrf51/src/ble_phy.c ---------------------------------------------------------------------- diff --git a/net/nimble/drivers/nrf51/src/ble_phy.c b/net/nimble/drivers/nrf51/src/ble_phy.c index 6c74fd4..4de8e83 100644 --- a/net/nimble/drivers/nrf51/src/ble_phy.c +++ b/net/nimble/drivers/nrf51/src/ble_phy.c @@ -32,7 +32,7 @@ #define NRF_RADIO_IRQ_MASK_ALL (0x34FF) /* - * We configure the nrf52 with a 1 byte S0 field, 8 bit length field, and + * We configure the nrf with a 1 byte S0 field, 8 bit length field, and * zero bit S1 field. The preamble is 8 bits long. */ #define NRF_LFLEN_BITS (8) @@ -103,8 +103,8 @@ STATS_NAME_END(ble_phy_stats) * NOTE: * Tested the following to see what would happen: * -> NVIC has radio irq enabled (interrupt # 1, mask 0x2). - * -> Set up nrf52 to receive. Clear ADDRESS event register. - * -> Enable ADDRESS interrupt on nrf52 by writing to INTENSET. + * -> Set up nrf to receive. Clear ADDRESS event register. + * -> Enable ADDRESS interrupt on nrf5 by writing to INTENSET. * -> Enable RX. * -> Disable interrupts globally using OS_ENTER_CRITICAL(). * -> Wait until a packet is received and the ADDRESS event occurs. @@ -159,7 +159,7 @@ ble_phy_rxpdu_get(void) } static void -nrf52_wait_disabled(void) +nrf_wait_disabled(void) { uint32_t state; @@ -438,7 +438,7 @@ int ble_phy_rx(void) { /* Check radio state */ - nrf52_wait_disabled(); + nrf_wait_disabled(); if (NRF_RADIO->STATE != RADIO_STATE_STATE_Disabled) { ble_phy_disable(); STATS_INC(ble_phy_stats, radio_state_errs); @@ -506,7 +506,7 @@ ble_phy_tx(struct os_mbuf *txpdu, uint8_t beg_trans, uint8_t end_trans) assert(txpdu != NULL); /* If radio is not disabled, */ - nrf52_wait_disabled(); + nrf_wait_disabled(); if (beg_trans == BLE_PHY_TRANSITION_RX_TX) { if ((NRF_RADIO->SHORTS & RADIO_SHORTS_DISABLED_TXEN_Msk) == 0) { @@ -661,7 +661,7 @@ ble_phy_setchan(uint8_t chan, uint32_t access_addr, uint32_t crcinit) return BLE_PHY_ERR_INV_PARAM; } - /* Get correct nrf52 frequency */ + /* Get correct frequency */ if (chan < BLE_PHY_NUM_DATA_CHANS) { if (chan < 11) { /* Data channel 0 starts at 2404. 0 - 10 are contiguous */ http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/33afb22a/net/nimble/drivers/nrf52/src/ble_hw.c ---------------------------------------------------------------------- diff --git a/net/nimble/drivers/nrf52/src/ble_hw.c b/net/nimble/drivers/nrf52/src/ble_hw.c index 36d5ac7..aacd983 100644 --- a/net/nimble/drivers/nrf52/src/ble_hw.c +++ b/net/nimble/drivers/nrf52/src/ble_hw.c @@ -6,7 +6,7 @@ * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, @@ -37,8 +37,8 @@ ble_rng_isr_cb_t g_ble_rng_isr_cb; /** * Clear the whitelist - * - * @return int + * + * @return int */ void ble_hw_whitelist_clear(void) @@ -48,11 +48,11 @@ ble_hw_whitelist_clear(void) } /** - * Add a device to the hw whitelist - * - * @param addr - * @param addr_type - * + * Add a device to the hw whitelist + * + * @param addr + * @param addr_type + * * @return int 0: success, BLE error code otherwise */ int @@ -80,11 +80,11 @@ ble_hw_whitelist_add(uint8_t *addr, uint8_t addr_type) } /** - * Remove a device from the hw whitelist - * - * @param addr - * @param addr_type - * + * Remove a device from the hw whitelist + * + * @param addr + * @param addr_type + * */ void ble_hw_whitelist_rmv(uint8_t *addr, uint8_t addr_type) @@ -126,8 +126,8 @@ ble_hw_whitelist_rmv(uint8_t *addr, uint8_t addr_type) } /** - * Returns the size of the whitelist in HW - * + * Returns the size of the whitelist in HW + * * @return int Number of devices allowed in whitelist */ uint8_t @@ -137,7 +137,7 @@ ble_hw_whitelist_size(void) } /** - * Enable the whitelisted devices + * Enable the whitelisted devices */ void ble_hw_whitelist_enable(void) @@ -147,7 +147,7 @@ ble_hw_whitelist_enable(void) } /** - * Disables the whitelisted devices + * Disables the whitelisted devices */ void ble_hw_whitelist_disable(void) @@ -157,10 +157,10 @@ ble_hw_whitelist_disable(void) } /** - * Boolean function which returns true ('1') if there is a match on the - * whitelist. - * - * @return int + * Boolean function which returns true ('1') if there is a match on the + * whitelist. + * + * @return int */ int ble_hw_whitelist_match(void) @@ -173,9 +173,12 @@ int ble_hw_encrypt_block(struct ble_encryption_block *ecb) { int rc; + uint32_t end; + uint32_t err; /* Stop ECB */ NRF_ECB->TASKS_STOPECB = 1; + /* XXX: does task stop clear these counters? Anyway to do this quicker? */ NRF_ECB->EVENTS_ENDECB = 0; NRF_ECB->EVENTS_ERRORECB = 0; NRF_ECB->ECBDATAPTR = (uint32_t)ecb; @@ -184,14 +187,14 @@ ble_hw_encrypt_block(struct ble_encryption_block *ecb) NRF_ECB->TASKS_STARTECB = 1; /* Wait till error or done */ + rc = 0; while (1) { - if (NRF_ECB->EVENTS_ENDECB != 0) { - rc = 0; - break; - } - - if (NRF_ECB->EVENTS_ERRORECB != 0) { - rc = -1; + end = NRF_ECB->EVENTS_ENDECB; + err = NRF_ECB->EVENTS_ERRORECB; + if (end || err) { + if (err) { + rc = -1; + } break; } } @@ -225,11 +228,11 @@ ble_rng_isr(void) /** * Initialize the random number generator - * - * @param cb - * @param bias - * - * @return int + * + * @param cb + * @param bias + * + * @return int */ int ble_hw_rng_init(ble_rng_isr_cb_t cb, int bias) @@ -254,8 +257,8 @@ ble_hw_rng_init(ble_rng_isr_cb_t cb, int bias) /** * Start the random number generator - * - * @return int + * + * @return int */ int ble_hw_rng_start(void) @@ -278,8 +281,8 @@ ble_hw_rng_start(void) /** * Stop the random generator - * - * @return int + * + * @return int */ int ble_hw_rng_stop(void) @@ -298,8 +301,8 @@ ble_hw_rng_stop(void) /** * Read the random number generator. - * - * @return uint8_t + * + * @return uint8_t */ uint8_t ble_hw_rng_read(void) http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/33afb22a/net/nimble/drivers/nrf52/src/ble_phy.c ---------------------------------------------------------------------- diff --git a/net/nimble/drivers/nrf52/src/ble_phy.c b/net/nimble/drivers/nrf52/src/ble_phy.c index 92bff8e..2c55d48 100644 --- a/net/nimble/drivers/nrf52/src/ble_phy.c +++ b/net/nimble/drivers/nrf52/src/ble_phy.c @@ -18,6 +18,7 @@ */ #include <stdint.h> +#include <string.h> #include <assert.h> #include "os/os.h" #include "bsp/cmsis_nvic.h" @@ -26,6 +27,11 @@ #include "controller/ble_ll.h" #include "mcu/nrf52_bitfields.h" +/* + * XXX: need to make the copy from mbuf into the PHY data structures 32-bit + * copies or we are screwed. + */ + /* XXX: 4) Make sure RF is higher priority interrupt than schedule */ /* To disable all radio interrupts */ @@ -55,6 +61,7 @@ struct ble_phy_obj uint8_t phy_state; uint8_t phy_transition; uint8_t phy_rx_started; + uint8_t phy_encrypted; uint32_t phy_access_address; struct os_mbuf *rxpdu; void *txend_arg; @@ -64,6 +71,9 @@ struct ble_phy_obj g_ble_phy_data; /* Global transmit/receive buffer */ static uint32_t g_ble_phy_txrx_buf[(BLE_PHY_MAX_PDU_LEN + 3) / 4]; +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION +static uint32_t g_ble_phy_enc_buf[(BLE_PHY_MAX_PDU_LEN + 3) / 4]; +#endif /* Statistics */ STATS_SECT_START(ble_phy_stats) @@ -128,6 +138,21 @@ STATS_NAME_END(ble_phy_stats) * bit in the NVIC just to be sure when we disable the PHY. */ +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION +/* NRF requires 43 bytes of scratch for encryption */ +/* XXX: align this? */ +uint32_t g_nrf_encrypt_scratchpad[100]; +struct nrf_ccm_data +{ + uint8_t key[16]; + uint64_t pkt_counter; + uint8_t dir_bit; + uint8_t iv[8]; +} __attribute__((packed)); + +struct nrf_ccm_data g_nrf_ccm_data; +#endif + /** * ble phy rxpdu get * @@ -185,6 +210,7 @@ ble_phy_isr(void) uint32_t irq_en; uint32_t state; uint32_t wfr_time; + uint8_t *dptr; struct os_mbuf *rxpdu; struct ble_mbuf_hdr *ble_hdr; @@ -197,7 +223,7 @@ ble_phy_isr(void) assert(g_ble_phy_data.phy_state == BLE_PHY_STATE_TX); ble_ll_log(BLE_LL_LOG_ID_PHY_TXEND, (g_ble_phy_txrx_buf[0] >> 8) & 0xFF, - 0, NRF_TIMER0->CC[2]); + g_ble_phy_data.phy_encrypted, NRF_TIMER0->CC[2]); /* Clear events and clear interrupt on disabled event */ NRF_RADIO->EVENTS_DISABLED = 0; @@ -205,6 +231,19 @@ ble_phy_isr(void) NRF_RADIO->EVENTS_END = 0; state = NRF_RADIO->SHORTS; +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + /* + * XXX: not sure what to do. We had a HW error during transmission. + * For now I just count a stat but continue on like all is good. + */ + if (g_ble_phy_data.phy_encrypted) { + if (NRF_CCM->EVENTS_ERROR) { + STATS_INC(ble_phy_stats, tx_hw_err); + NRF_CCM->EVENTS_ERROR = 0; + } + } +#endif + transition = g_ble_phy_data.phy_transition; if (transition == BLE_PHY_TRANSITION_TX_RX) { /* Clear the rx started flag */ @@ -212,7 +251,23 @@ ble_phy_isr(void) /* Packet pointer needs to be reset. */ if (g_ble_phy_data.rxpdu != NULL) { +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + if (g_ble_phy_data.phy_encrypted) { + NRF_RADIO->PACKETPTR = (uint32_t)&g_ble_phy_enc_buf[0]; + NRF_CCM->INPTR = (uint32_t)&g_ble_phy_enc_buf[0]; + NRF_CCM->OUTPTR = (uint32_t)g_ble_phy_data.rxpdu->om_data; + NRF_CCM->SCRATCHPTR = (uint32_t)&g_nrf_encrypt_scratchpad[0]; + NRF_CCM->MODE = CCM_MODE_LENGTH_Msk | CCM_MODE_MODE_Decryption; + NRF_CCM->CNFPTR = (uint32_t)&g_nrf_ccm_data; + NRF_CCM->SHORTS = 0; + NRF_CCM->EVENTS_ENDCRYPT = 0; + NRF_PPI->CHENSET = PPI_CHEN_CH24_Msk | PPI_CHEN_CH25_Msk; + } else { + NRF_RADIO->PACKETPTR = (uint32_t)g_ble_phy_data.rxpdu->om_data; + } +#else NRF_RADIO->PACKETPTR = (uint32_t)g_ble_phy_data.rxpdu->om_data; +#endif /* I want to know when 1st byte received (after address) */ NRF_RADIO->BCC = 8; /* in bits */ @@ -322,6 +377,7 @@ ble_phy_isr(void) assert(NRF_RADIO->EVENTS_RSSIEND != 0); ble_hdr->rxinfo.rssi = -1 * NRF_RADIO->RSSISAMPLE; ble_hdr->end_cputime = NRF_TIMER0->CC[2]; + dptr = g_ble_phy_data.rxpdu->om_data; /* Count PHY crc errors and valid packets */ crcok = (uint8_t)NRF_RADIO->CRCSTATUS; @@ -330,11 +386,50 @@ ble_phy_isr(void) } else { STATS_INC(ble_phy_stats, rx_valid); ble_hdr->rxinfo.flags |= BLE_MBUF_HDR_F_CRC_OK; +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + if (g_ble_phy_data.phy_encrypted) { + /* Only set MIC failure flag if frame is not zero length */ + if ((dptr[1] != 0) && (NRF_CCM->MICSTATUS == 0)) { + ble_hdr->rxinfo.flags |= BLE_MBUF_HDR_F_MIC_FAILURE; + } + + /* + * XXX: not sure how to deal with this. This should not + * be a MIC failure but we should not hand it up. I guess + * this is just some form of rx error and that is how we + * handle it? For now, just set CRC error flags + */ + if (NRF_CCM->EVENTS_ERROR) { + STATS_INC(ble_phy_stats, rx_hw_err); + ble_hdr->rxinfo.flags &= ~BLE_MBUF_HDR_F_CRC_OK; + } + + /* + * XXX: This is a total hack work-around for now but I dont + * know what else to do. If ENDCRYPT is not set and we are + * encrypted we need to not trust this frame and drop it. + */ + if (NRF_CCM->EVENTS_ENDCRYPT == 0) { + STATS_INC(ble_phy_stats, rx_hw_err); + ble_hdr->rxinfo.flags &= ~BLE_MBUF_HDR_F_CRC_OK; + } + } +#endif } /* Call Link Layer receive payload function */ rxpdu = g_ble_phy_data.rxpdu; g_ble_phy_data.rxpdu = NULL; + + /* + * XXX: This is a horrible ugly hack to deal with the RAM S1 byte + * that is not sent over the air but is present here. Simply move the + * data pointer to deal with it. Fix this later. Do this in the nrf52 + */ + dptr[2] = dptr[1]; + dptr[1] = dptr[0]; + rxpdu->om_data += 1; + rc = ble_ll_rx_end(rxpdu, ble_hdr); if (rc < 0) { /* Disable the PHY. */ @@ -389,8 +484,10 @@ ble_phy_init(void) /* Set configuration registers */ NRF_RADIO->MODE = RADIO_MODE_MODE_Ble_1Mbit; NRF_RADIO->PCNF0 = (NRF_LFLEN_BITS << RADIO_PCNF0_LFLEN_Pos) | + RADIO_PCNF0_S1INCL_Msk | (NRF_S0_LEN << RADIO_PCNF0_S0LEN_Pos) | (RADIO_PCNF0_PLEN_8bit << RADIO_PCNF0_PLEN_Pos); + /* XXX: should maxlen be 251 for encryption? */ NRF_RADIO->PCNF1 = NRF_MAXLEN | (RADIO_PCNF1_ENDIAN_Little << RADIO_PCNF1_ENDIAN_Pos) | (NRF_BALEN << RADIO_PCNF1_BALEN_Pos) | @@ -415,6 +512,14 @@ ble_phy_init(void) */ NRF_PPI->CHENSET = PPI_CHEN_CH27_Msk; +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + NRF_CCM->INTENCLR = 0xffffffff; + NRF_CCM->SHORTS = CCM_SHORTS_ENDKSGEN_CRYPT_Msk; + NRF_CCM->ENABLE = CCM_ENABLE_ENABLE_Enabled; + NRF_CCM->EVENTS_ERROR = 0; + memset(g_nrf_encrypt_scratchpad, 0, sizeof(g_nrf_encrypt_scratchpad)); +#endif + /* Set isr in vector table and enable interrupt */ NVIC_SetPriority(RADIO_IRQn, 0); NVIC_SetVector(RADIO_IRQn, (uint32_t)ble_phy_isr); @@ -452,7 +557,15 @@ ble_phy_rx(void) } /* Set packet pointer */ +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + if (g_ble_phy_data.phy_encrypted) { + NRF_RADIO->PACKETPTR = (uint32_t)&g_ble_phy_enc_buf[0]; + } else { + NRF_RADIO->PACKETPTR = (uint32_t)g_ble_phy_data.rxpdu->om_data; + } +#else NRF_RADIO->PACKETPTR = (uint32_t)g_ble_phy_data.rxpdu->om_data; +#endif /* Make sure all interrupts are disabled */ NRF_RADIO->INTENCLR = NRF_RADIO_IRQ_MASK_ALL; @@ -465,6 +578,22 @@ ble_phy_rx(void) NRF_RADIO->EVENTS_RSSIEND = 0; NRF_RADIO->EVENTS_DEVMATCH = 0; +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + if (g_ble_phy_data.phy_encrypted) { + NRF_CCM->INPTR = (uint32_t)&g_ble_phy_enc_buf[0]; + NRF_CCM->OUTPTR = (uint32_t)g_ble_phy_data.rxpdu->om_data; + NRF_CCM->SCRATCHPTR = (uint32_t)&g_nrf_encrypt_scratchpad[0]; + NRF_CCM->EVENTS_ERROR = 0; + NRF_CCM->EVENTS_ENDCRYPT = 0; + NRF_CCM->MODE = CCM_MODE_LENGTH_Msk | CCM_MODE_MODE_Decryption; + /* XXX: can I just set this once? (i.e per connection)? In other + words, only do this during encrypt enable? */ + NRF_CCM->CNFPTR = (uint32_t)&g_nrf_ccm_data; + NRF_CCM->SHORTS = 0; + NRF_PPI->CHENSET = PPI_CHEN_CH24_Msk | PPI_CHEN_CH25_Msk; + } +#endif + /* I want to know when 1st byte received (after address) */ NRF_RADIO->BCC = 8; /* in bits */ NRF_RADIO->SHORTS = RADIO_SHORTS_END_DISABLE_Msk | @@ -486,6 +615,46 @@ ble_phy_rx(void) return 0; } +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION +/** + * Called to enable encryption at the PHY. Note that this state will persist + * in the PHY; in other words, if you call this function you have to call + * disable so that future PHY transmits/receives will not be encrypted. + * + * @param pkt_counter + * @param iv + * @param key + * @param is_master + */ +void +ble_phy_encrypt_enable(uint64_t pkt_counter, uint8_t *iv, uint8_t *key, + uint8_t is_master) +{ + memcpy(g_nrf_ccm_data.key, key, 16); + g_nrf_ccm_data.pkt_counter = pkt_counter; + memcpy(g_nrf_ccm_data.iv, iv, 8); + g_nrf_ccm_data.dir_bit = is_master; + g_ble_phy_data.phy_encrypted = 1; +} + + +void +ble_phy_encrypt_set_pkt_cntr(uint64_t pkt_counter, int dir) +{ + g_nrf_ccm_data.pkt_counter = pkt_counter; + g_nrf_ccm_data.dir_bit = dir; +} + +void +ble_phy_encrypt_disable(void) +{ + NRF_PPI->CHENCLR = (PPI_CHEN_CH24_Msk | PPI_CHEN_CH25_Msk); + NRF_CCM->TASKS_STOP = 1; + NRF_CCM->EVENTS_ERROR = 0; + g_ble_phy_data.phy_encrypted = 0; +} +#endif + void ble_phy_set_txend_cb(ble_phy_tx_end_func txend_cb, void *arg) { @@ -526,15 +695,48 @@ ble_phy_tx(struct os_mbuf *txpdu, uint8_t beg_trans, uint8_t end_trans) return BLE_PHY_ERR_RADIO_STATE; } - /* Write LL header first */ +#ifdef BLE_LL_CFG_FEAT_LE_ENCRYPTION + if (g_ble_phy_data.phy_encrypted) { + /* RAM representation has S0, LENGTH and S1 fields. (3 bytes) */ + ble_hdr = BLE_MBUF_HDR_PTR(txpdu); + dptr = (uint8_t *)&g_ble_phy_enc_buf[0]; + dptr[0] = ble_hdr->txinfo.hdr_byte; + dptr[1] = ble_hdr->txinfo.pyld_len; + dptr[2] = 0; + dptr += 3; + + NRF_RADIO->PACKETPTR = (uint32_t)&g_ble_phy_txrx_buf[0]; + NRF_CCM->SHORTS = 1; + NRF_CCM->INPTR = (uint32_t)&g_ble_phy_enc_buf[0]; + NRF_CCM->OUTPTR = (uint32_t)&g_ble_phy_txrx_buf[0]; + NRF_CCM->SCRATCHPTR = (uint32_t)&g_nrf_encrypt_scratchpad[0]; + NRF_CCM->EVENTS_ERROR = 0; + NRF_CCM->MODE = CCM_MODE_LENGTH_Msk; + NRF_CCM->CNFPTR = (uint32_t)&g_nrf_ccm_data; + NRF_PPI->CHENCLR = PPI_CHEN_CH25_Msk; + NRF_PPI->CHENSET = PPI_CHEN_CH24_Msk; + } else { + /* RAM representation has S0, LENGTH and S1 fields. (3 bytes) */ + ble_hdr = BLE_MBUF_HDR_PTR(txpdu); + dptr = (uint8_t *)&g_ble_phy_txrx_buf[0]; + dptr[0] = ble_hdr->txinfo.hdr_byte; + dptr[1] = ble_hdr->txinfo.pyld_len; + dptr[2] = 0; + dptr += 3; + + NRF_RADIO->PACKETPTR = (uint32_t)&g_ble_phy_txrx_buf[0]; + } +#else + /* RAM representation has S0, LENGTH and S1 fields. (3 bytes) */ ble_hdr = BLE_MBUF_HDR_PTR(txpdu); dptr = (uint8_t *)&g_ble_phy_txrx_buf[0]; dptr[0] = ble_hdr->txinfo.hdr_byte; dptr[1] = ble_hdr->txinfo.pyld_len; - dptr += 2; + dptr[2] = 0; + dptr += 3; - /* Set radio transmit data pointer */ NRF_RADIO->PACKETPTR = (uint32_t)&g_ble_phy_txrx_buf[0]; +#endif /* Clear the ready, end and disabled events */ NRF_RADIO->EVENTS_READY = 0; http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/33afb22a/net/nimble/host/src/ble_l2cap_sm.c ---------------------------------------------------------------------- diff --git a/net/nimble/host/src/ble_l2cap_sm.c b/net/nimble/host/src/ble_l2cap_sm.c index 8ff79e0..74ddb91 100644 --- a/net/nimble/host/src/ble_l2cap_sm.c +++ b/net/nimble/host/src/ble_l2cap_sm.c @@ -6,7 +6,7 @@ * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, @@ -609,13 +609,13 @@ ble_l2cap_sm_confirm_prepare_args(struct ble_l2cap_sm_proc *proc, conn = ble_hs_conn_find(proc->fsm_proc.conn_handle); if (conn != NULL) { if (proc->flags & BLE_L2CAP_SM_PROC_F_INITIATOR) { - *iat = BLE_ADDR_TYPE_PUBLIC; /* XXX: Support random addresses. */ + *iat = BLE_ADDR_TYPE_RANDOM; /* XXX: Support random addresses. */ memcpy(ia, ble_hs_our_dev.public_addr, 6); *rat = conn->bhc_addr_type; memcpy(ra, conn->bhc_addr, 6); } else { - *rat = BLE_ADDR_TYPE_PUBLIC; /* XXX: Support random addresses. */ + *rat = BLE_ADDR_TYPE_RANDOM; /* XXX: Support random addresses. */ memcpy(ra, ble_hs_our_dev.public_addr, 6); *iat = conn->bhc_addr_type; http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/33afb22a/net/nimble/include/nimble/ble.h ---------------------------------------------------------------------- diff --git a/net/nimble/include/nimble/ble.h b/net/nimble/include/nimble/ble.h index 38343dc..894dff4 100644 --- a/net/nimble/include/nimble/ble.h +++ b/net/nimble/include/nimble/ble.h @@ -68,7 +68,7 @@ struct ble_mbuf_hdr_rxinfo /* Flag definitions for rxinfo */ #define BLE_MBUF_HDR_F_CRC_OK (0x80) #define BLE_MBUF_HDR_F_DEVMATCH (0x40) -#define BLE_MBUF_HDR_F_CONN_REQ_TXD (0x20) +#define BLE_MBUF_HDR_F_MIC_FAILURE (0x20) #define BLE_MBUF_HDR_F_SCAN_RSP_TXD (0x10) #define BLE_MBUF_HDR_F_SCAN_RSP_CHK (0x08) #define BLE_MBUF_HDR_F_RXSTATE_MASK (0x07) @@ -97,21 +97,24 @@ struct ble_mbuf_hdr */ #define BLE_MBUF_PAYLOAD_SIZE (260) -#define BLE_MBUF_HDR_CRC_OK(hdr) \ +#define BLE_MBUF_HDR_CRC_OK(hdr) \ ((hdr)->rxinfo.flags & BLE_MBUF_HDR_F_CRC_OK) -#define BLE_MBUF_HDR_RX_STATE(hdr) \ +#define BLE_MBUF_HDR_MIC_FAILURE(hdr) \ + ((hdr)->rxinfo.flags & BLE_MBUF_HDR_F_MIC_FAILURE) + +#define BLE_MBUF_HDR_RX_STATE(hdr) \ ((hdr)->rxinfo.flags & BLE_MBUF_HDR_F_RXSTATE_MASK) -#define BLE_MBUF_HDR_PTR(om) \ +#define BLE_MBUF_HDR_PTR(om) \ (struct ble_mbuf_hdr *)((uint8_t *)om + sizeof(struct os_mbuf) + \ sizeof(struct os_mbuf_pkthdr)) /* BLE mbuf overhead per packet header mbuf */ -#define BLE_MBUF_PKTHDR_OVERHEAD \ +#define BLE_MBUF_PKTHDR_OVERHEAD \ (sizeof(struct os_mbuf_pkthdr) + sizeof(struct ble_mbuf_hdr)) -#define BLE_MBUF_MEMBLOCK_OVERHEAD \ +#define BLE_MBUF_MEMBLOCK_OVERHEAD \ (sizeof(struct os_mbuf) + BLE_MBUF_PKTHDR_OVERHEAD) #define BLE_DEV_ADDR_LEN (6)
