53#define LOG_MODULE "L2CAP"
54#define LOG_LEVEL LOG_LEVEL_MAC
56#define MS_TO_CLOCK_SECONDS(X) ((int)(((double)((X)*CLOCK_SECOND)) / 1000.0))
60static uint8_t ble_addr[BLE_ADDR_SIZE];
65 uint8_t sdu[BLE_L2CAP_NODE_MTU];
69 uint16_t current_index;
77} ble_mac_l2cap_channel_t;
80 ble_mac_l2cap_channel_t channel_own;
81 ble_mac_l2cap_channel_t channel_peer;
82 l2cap_buffer_t tx_buffer;
83 l2cap_buffer_t rx_buffer;
87static uint8_t l2cap_channel_count;
88static l2cap_channel_t l2cap_channels[L2CAP_CHANNELS];
89static process_event_t l2cap_tx_event;
91static l2cap_channel_t *
92get_channel_for_addr(
const linkaddr_t *peer_addr)
95 l2cap_channel_t *channel;
96 for(i = 0; i < l2cap_channel_count; i++) {
97 channel = &l2cap_channels[i];
105static l2cap_channel_t *
106get_channel_for_cid(uint16_t own_cid)
108 int16_t i = own_cid - L2CAP_FLOW_CHANNEL;
109 if(i >= 0 && i < l2cap_channel_count) {
110 return &l2cap_channels[i];
116PROCESS(ble_l2cap_tx_process,
"BLE L2CAP TX process");
119init_adv_data(
char *adv_data)
121 uint8_t adv_data_len = 0;
122 memset(adv_data, 0x00, BLE_ADV_DATA_LEN);
124 adv_data[adv_data_len++] = 2;
125 adv_data[adv_data_len++] = 0x01;
126 adv_data[adv_data_len++] = 0x05;
128 adv_data[adv_data_len++] = 2;
129 adv_data[adv_data_len++] = 0x0A;
130 adv_data[adv_data_len++] = 0;
132 adv_data[adv_data_len++] = 3;
133 adv_data[adv_data_len++] = 0x03;
134 adv_data[adv_data_len++] = 0x20;
135 adv_data[adv_data_len++] = 0x18;
137 adv_data[adv_data_len++] = 1;
138 adv_data[adv_data_len++] = 0x05;
140 adv_data[adv_data_len++] = 1;
141 adv_data[adv_data_len++] = 0x07;
146init_scan_resp_data(
char *scan_resp_data)
148 uint8_t scan_resp_data_len = 0;
149 memset(scan_resp_data, 0x00, BLE_SCAN_RESP_DATA_LEN);
151 scan_resp_data[scan_resp_data_len++] = 1 + strlen(BLE_DEVICE_NAME);
152 scan_resp_data[scan_resp_data_len++] = 0x09;
153 memcpy(&scan_resp_data[scan_resp_data_len],
154 BLE_DEVICE_NAME, strlen(BLE_DEVICE_NAME));
155 scan_resp_data_len += strlen(BLE_DEVICE_NAME);
157 scan_resp_data[scan_resp_data_len++] = 5;
158 scan_resp_data[scan_resp_data_len++] = 0x12;
159 scan_resp_data[scan_resp_data_len++] = (BLE_SLAVE_CONN_INTERVAL_MIN & 0xFF);
160 scan_resp_data[scan_resp_data_len++] = ((BLE_SLAVE_CONN_INTERVAL_MIN >> 8) & 0xFF);
161 scan_resp_data[scan_resp_data_len++] = (char)(BLE_SLAVE_CONN_INTERVAL_MAX & 0xFF);
162 scan_resp_data[scan_resp_data_len++] = ((BLE_SLAVE_CONN_INTERVAL_MAX >> 8) & 0xFF);
164 return scan_resp_data_len;
168input_l2cap_conn_req(uint8_t *data)
170 uint8_t identifier = data[0];
173 uint8_t resp_data[18];
174 l2cap_channel_t *channel;
176 memcpy(&len, &data[1], 2);
179 LOG_WARN(
"l2cap_conn_req: invalid len: %d\n", len);
184 if(l2cap_channel_count >= L2CAP_CHANNELS) {
185 LOG_WARN(
"l2cap_conn_req: maximum supported L2CAP channels reached\n");
189 channel = &l2cap_channels[l2cap_channel_count];
191 memcpy(&le_psm, &data[3], 2);
192 memset(&channel->channel_peer, 0x00,
sizeof(ble_mac_l2cap_channel_t));
193 memcpy(&channel->channel_peer.cid, &data[5], 2);
194 memcpy(&channel->channel_peer.mtu, &data[7], 2);
195 memcpy(&channel->channel_peer.mps, &data[9], 2);
196 memcpy(&channel->channel_peer.credits, &data[11], 2);
197 linkaddr_copy(&channel->peer_addr, packetbuf_addr(PACKETBUF_ADDR_SENDER));
199 LOG_INFO(
"recv CONN_REQ (MTU: %4d, MPS: %4d, credits: %4d)\n",
200 channel->channel_peer.mtu, channel->channel_peer.mps, channel->channel_peer.credits);
202 l2cap_channel_count++;
212 resp_data[4] = L2CAP_CODE_CONN_RSP;
214 resp_data[5] = identifier;
219 memcpy(&resp_data[8], &channel->channel_own.cid, 2);
220 memcpy(&resp_data[10], &channel->channel_own.mtu, 2);
221 memcpy(&resp_data[12], &channel->channel_own.mps, 2);
222 memcpy(&resp_data[14], &channel->channel_own.credits, 2);
224 memset(&resp_data[16], 0x00, 2);
228 packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &channel->peer_addr);
239 for(i = 0; i < L2CAP_CHANNELS; i++) {
240 l2cap_channels[i].channel_own.cid = L2CAP_FLOW_CHANNEL + i;
241 l2cap_channels[i].channel_own.credits = L2CAP_CREDIT_NEW;
242 l2cap_channels[i].channel_own.mps = (BLE_L2CAP_NODE_FRAG_LEN - L2CAP_SUBSEQ_HEADER_SIZE);
243 l2cap_channels[i].channel_own.mtu = BLE_L2CAP_NODE_MTU;
247 NETSTACK_RADIO.init();
248 NETSTACK_RADIO.get_object(RADIO_CONST_BLE_BD_ADDR, &ble_addr, BLE_ADDR_SIZE);
250 uint8_t adv_data_len, scan_resp_data_len;
251 char adv_data[BLE_ADV_DATA_LEN];
252 char scan_resp_data[BLE_SCAN_RESP_DATA_LEN];
254 NETSTACK_RADIO.set_value(RADIO_PARAM_BLE_ADV_INTERVAL, BLE_ADV_INTERVAL);
255 NETSTACK_RADIO.set_value(RADIO_PARAM_BLE_ADV_TYPE, BLE_ADV_DIR_IND_LDC);
256 NETSTACK_RADIO.set_value(RADIO_PARAM_BLE_ADV_OWN_ADDR_TYPE, BLE_ADDR_TYPE_PUBLIC);
257 NETSTACK_RADIO.set_value(RADIO_PARAM_BLE_ADV_CHANNEL_MAP, 0x01);
259 adv_data_len = init_adv_data(adv_data);
260 scan_resp_data_len = init_scan_resp_data(scan_resp_data);
263 NETSTACK_RADIO.set_object(RADIO_PARAM_BLE_ADV_PAYLOAD, adv_data, adv_data_len);
264 NETSTACK_RADIO.set_object(RADIO_PARAM_BLE_ADV_SCAN_RESPONSE, scan_resp_data, scan_resp_data_len);
267 NETSTACK_RADIO.set_value(RADIO_PARAM_BLE_ADV_ENABLE, 1);
273check_own_l2cap_credits(l2cap_channel_t *channel)
275 uint16_t credits_new = 0;
276 uint16_t credits_current;
278 credits_current = channel->channel_own.credits;
279 if(credits_current < L2CAP_CREDIT_THRESHOLD) {
280 credits_new = L2CAP_CREDIT_NEW;
282 LOG_DBG(
"check for new credits: current credits: %2d, new credits: %2d\n", credits_current, credits_new);
287send_l2cap_credit(l2cap_channel_t *channel, uint16_t credits)
299 data[4] = L2CAP_CODE_CREDIT;
306 memcpy(&data[8], &channel->channel_own.cid, 2);
307 data[10] = credits & 0xFF;
308 data[11] = credits >> 8;
310 channel->channel_own.credits += credits;
314 packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &channel->peer_addr);
319send(mac_callback_t sent_callback,
void *ptr)
322 l2cap_channel_t *channel;
324 LOG_DBG(
"send %d\n", data_len);
327 if(data_len > BLE_L2CAP_NODE_MTU) {
328 LOG_WARN(
"send message is too long\n");
329 mac_call_sent_callback(sent_callback, ptr,
MAC_TX_ERR, 0);
333 for(i = 0; i < l2cap_channel_count; i++) {
334 channel = &l2cap_channels[i];
336 || (
linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &channel->peer_addr) != 0)) {
337 if(channel->tx_buffer.sdu_length > 0) {
338 LOG_WARN(
"send() another L2CAP message active (trying to send %4d bytes)\n", data_len);
342 LOG_DBG(
"send() adding to L2CAP CID: %2d\n", channel->channel_own.cid);
343 channel->tx_buffer.sdu_length = data_len;
344 if(channel->tx_buffer.sdu_length > 0) {
347 process_post(&ble_l2cap_tx_process, l2cap_tx_event, (
void *)channel);
354input_l2cap_connection_udate_resp(uint8_t *data)
359 memcpy(&len, &data[1], 2);
362 LOG_WARN(
"input_l2cap_connection_update_resp: invalid len: %d\n", len);
366 memcpy(&result, &data[3], 2);
367 if(result != 0x0000) {
368 LOG_WARN(
"input_l2cap_connection_update_resp: result: 0x%04X\n", result);
374input_l2cap_credit(uint8_t *data)
379 l2cap_channel_t *channel = get_channel_for_addr(packetbuf_addr(PACKETBUF_ADDR_SENDER));
381 if(channel == NULL) {
382 LOG_WARN(
"input_l2cap_credit: no channel found for sender address\n");
387 memcpy(&len, &data[1], 2);
390 LOG_WARN(
"input_l2cap_credit: invalid len: %d\n", len);
395 memcpy(&cid, &data[3], 2);
396 memcpy(&credits, &data[5], 2);
398 channel->channel_peer.credits += credits;
402input_l2cap_frame_signal_channel(uint8_t *data, uint8_t data_len)
404 if(data[4] == L2CAP_CODE_CREDIT) {
405 input_l2cap_credit(&data[5]);
406 }
else if(data[4] == L2CAP_CODE_CONN_REQ) {
407 input_l2cap_conn_req(&data[5]);
408 }
else if(data[4] == L2CAP_CODE_CONN_UPDATE_RSP) {
409 input_l2cap_connection_udate_resp(&data[5]);
411 LOG_WARN(
"l2cap_frame_signal_channel: unknown signal channel code: %d\n", data[4]);
416input_l2cap_frame_flow_channel(l2cap_channel_t *channel, uint8_t *data, uint16_t data_len)
419 uint16_t payload_len;
422 LOG_WARN(
"l2cap_frame: illegal L2CAP frame data_len: %d\n", data_len);
427 if(channel->rx_buffer.sdu_length == 0) {
429 memcpy(&frame_len, &data[0], 2);
430 payload_len = frame_len - 2;
432 if(payload_len > BLE_L2CAP_NODE_MTU) {
433 LOG_WARN(
"l2cap_frame: illegal L2CAP frame payload_len: %d\n", payload_len);
438 memcpy(&channel->rx_buffer.sdu_length, &data[4], 2);
440 memcpy(channel->rx_buffer.sdu, &data[6], payload_len);
441 channel->rx_buffer.current_index = payload_len;
444 memcpy(&frame_len, &data[0], 2);
445 payload_len = frame_len;
447 if(payload_len > BLE_L2CAP_NODE_MTU - channel->rx_buffer.current_index) {
448 LOG_WARN(
"l2cap_frame: illegal L2CAP frame payload_len: %d\n", payload_len);
454 memcpy(&channel->rx_buffer.sdu[channel->rx_buffer.current_index], &data[4], payload_len);
455 channel->rx_buffer.current_index += payload_len;
458 if((channel->rx_buffer.sdu_length > 0) &&
459 (channel->rx_buffer.sdu_length == channel->rx_buffer.current_index)) {
461 LOG_WARN(
"l2cap_frame: illegal L2CAP frame sdu_length: %"PRIu16
"\n",
462 channel->rx_buffer.sdu_length);
468 memcpy(
packetbuf_dataptr(), channel->rx_buffer.sdu, channel->rx_buffer.sdu_length);
470 NETSTACK_NETWORK.input();
473 channel->rx_buffer.sdu_length = 0;
474 channel->rx_buffer.current_index = 0;
483 uint8_t frame_type = packetbuf_attr(PACKETBUF_ATTR_FRAME_TYPE);
485 l2cap_channel_t *channel;
488 if(frame_type == FRAME_BLE_RX_EVENT) {
489 memcpy(&channel_id, &data[2], 2);
490 channel = get_channel_for_cid(channel_id);
491 LOG_DBG(
"input %d bytes\n", len);
492 if(channel_id == L2CAP_SIGNAL_CHANNEL) {
493 input_l2cap_frame_signal_channel(data, len);
494 }
else if(channel == NULL) {
495 LOG_WARN(
"input (RX_EVENT): no channel found for CID: %d\n", channel_id);
498 input_l2cap_frame_flow_channel(channel, data, len);
499 channel->channel_own.credits--;
500 credits = check_own_l2cap_credits(channel);
502 send_l2cap_credit(channel, credits);
507 if(frame_type == FRAME_BLE_TX_EVENT) {
508 channel = get_channel_for_addr(packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
509 if(channel == NULL) {
510 LOG_WARN(
"input (TX_EVENT): no channel found for CID: %d\n", channel_id);
511 }
else if(channel->tx_buffer.sdu_length > 0) {
512 process_post(&ble_l2cap_tx_process, l2cap_tx_event, (
void *)channel);
536 return BLE_L2CAP_NODE_MTU;
554 l2cap_channel_t *channel = (l2cap_channel_t *)data;
555 uint8_t first_fragment;
560 LOG_DBG(
"starting ble_mac_tx_process\n");
564 if(channel != NULL) {
565 NETSTACK_RADIO.get_value(RADIO_CONST_BLE_BUFFER_AMOUNT, (
radio_value_t *)&num_buffer);
566 first_fragment = (channel->tx_buffer.current_index == 0);
567 used_mps = MIN(channel->channel_own.mps, channel->channel_peer.mps);
568 credits = channel->channel_peer.credits;
570 LOG_DBG(
"process: sending - first: %d, used_mps: %3d, num_buffers: %2d, credits: %2d\n",
571 first_fragment, used_mps, num_buffer, credits);
572 if((channel->tx_buffer.sdu_length > 0) && (num_buffer > 0) && (credits > 0)) {
576 used_mps -= L2CAP_FIRST_HEADER_SIZE;
577 data_len = MIN(channel->tx_buffer.sdu_length, used_mps);
578 frame_len = data_len + 2;
586 used_mps -= L2CAP_SUBSEQ_HEADER_SIZE;
587 data_len = MIN((channel->tx_buffer.sdu_length - channel->tx_buffer.current_index), used_mps);
588 frame_len = data_len;
597 LOG_WARN(
"Not enough packetbuf space to copy buffer\n");
601 &channel->tx_buffer.sdu[channel->tx_buffer.current_index],
604 channel->tx_buffer.current_index += data_len;
607 packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &channel->peer_addr);
610 channel->channel_peer.credits--;
613 if(channel->tx_buffer.current_index == channel->tx_buffer.sdu_length) {
614 channel->tx_buffer.current_index = 0;
615 channel->tx_buffer.sdu_length = 0;
619 LOG_WARN(
"process. channel is NULL\n");
624 LOG_DBG(
"stopped ble_mac_tx_process\n");
hardware abstraction for a BLE controller
MAC layer that implements BLE L2CAP credit-based flow control channels to support IPv6 over BLE (RFC ...
linkaddr_t linkaddr_node_addr
The link-layer address of the node.
void linkaddr_copy(linkaddr_t *dest, const linkaddr_t *src)
Copy a link-layer address.
bool linkaddr_cmp(const linkaddr_t *addr1, const linkaddr_t *addr2)
Compare two link-layer addresses.
const linkaddr_t linkaddr_null
The null link-layer address.
void packetbuf_set_datalen(uint16_t len)
Set the length of the data in the packetbuf.
void * packetbuf_dataptr(void)
Get a pointer to the data in the packetbuf.
uint16_t packetbuf_totlen(void)
Get the total length of the header and data in the packetbuf.
uint16_t packetbuf_datalen(void)
Get the length of the data in the packetbuf.
uint8_t packetbuf_hdrlen(void)
Get the length of the header in the packetbuf.
int packetbuf_copyfrom(const void *from, uint16_t len)
Copy from external data into the packetbuf.
void * packetbuf_hdrptr(void)
Get a pointer to the header in the packetbuf, for outbound packets.
#define PACKETBUF_SIZE
The size of the packetbuf, in bytes.
void packetbuf_clear(void)
Clear and reset the packetbuf.
int packetbuf_hdralloc(int size)
Extend the header of the packetbuf, for outbound packets.
uint16_t packetbuf_remaininglen(void)
Get the total length of the remaining space in the packetbuf.
#define PROCESS(name, strname)
Declare a process.
int process_post(struct process *p, process_event_t ev, process_data_t data)
Post an asynchronous event.
void process_exit(struct process *p)
Cause a process to exit.
process_event_t process_alloc_event(void)
Allocate a global event number.
#define PROCESS_BEGIN()
Define the beginning of a process.
#define PROCESS_END()
Define the end of a process.
void process_start(struct process *p, process_data_t data)
Start a process.
#define PROCESS_THREAD(name, ev, data)
Define the body of a process.
#define PROCESS_YIELD_UNTIL(c)
Yield the currently running process until a condition occurs.
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio.
Linked list manipulation routines.
Header file for the logging system.
@ MAC_TX_COLLISION
The MAC layer did not get an acknowledgement for the packet.
@ MAC_TX_DEFERRED
The MAC layer transmission could not be performed because of an error.
@ MAC_TX_ERR
The MAC layer transmission could not be performed because of a fatal error.
Memory block allocation routines.
Include file for the Contiki low-layer network stack (NETSTACK)
Header file for the Packet buffer (packetbuf) management.
The structure of a MAC protocol driver in Contiki.
int(* on)(void)
Turn the MAC layer on.
int(* max_payload)(void)
Read out estimated max payload size based on payload in packetbuf.
int(* off)(void)
Turn the MAC layer off.
void(* init)(void)
Initialize the MAC driver.
void(* input)(void)
Callback for getting notified of incoming packet.
void(* send)(mac_callback_t sent_callback, void *ptr)
Send a packet from the packetbuf