Embed:
(wiki syntax)
Show/hide line numbers
mac_mlme.c
Go to the documentation of this file.
00001 /* 00002 * Copyright (c) 2013-2017, Arm Limited and affiliates. 00003 * SPDX-License-Identifier: Apache-2.0 00004 * 00005 * Licensed under the Apache License, Version 2.0 (the "License"); 00006 * you may not use this file except in compliance with the License. 00007 * You may obtain a copy of the License at 00008 * 00009 * http://www.apache.org/licenses/LICENSE-2.0 00010 * 00011 * Unless required by applicable law or agreed to in writing, software 00012 * distributed under the License is distributed on an "AS IS" BASIS, 00013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00014 * See the License for the specific language governing permissions and 00015 * limitations under the License. 00016 */ 00017 /** 00018 * 00019 * \file mac_mlme.c 00020 * \brief MLME API for MAC control 00021 * 00022 * MLME API for MAC certification. 00023 * 00024 */ 00025 00026 #include "nsconfig.h" 00027 #include <string.h> 00028 #include "ns_types.h" 00029 #include "eventOS_event.h" 00030 #include "eventOS_scheduler.h" 00031 #include "eventOS_callback_timer.h" 00032 #include "ns_trace.h" 00033 #include "randLIB.h" 00034 #include "nsdynmemLIB.h" 00035 #include "platform/arm_hal_interrupt.h" 00036 #include "common_functions.h" 00037 #include "sw_mac.h" 00038 #include "mlme.h" 00039 #include "mac_api.h" 00040 #include "fhss_api.h " 00041 00042 #include "MAC/IEEE802_15_4/sw_mac_internal.h" 00043 #include "MAC/IEEE802_15_4/mac_defines.h" 00044 #include "MAC/IEEE802_15_4/mac_header_helper_functions.h" 00045 #include "MAC/IEEE802_15_4/mac_indirect_data.h" 00046 #include "MAC/IEEE802_15_4/mac_security_mib.h" 00047 #include "MAC/IEEE802_15_4/mac_mlme.h" 00048 #include "MAC/IEEE802_15_4/mac_timer.h" 00049 #include "MAC/IEEE802_15_4/mac_pd_sap.h" 00050 #include "MAC/IEEE802_15_4/mac_mcps_sap.h" 00051 #include "MAC/virtual_rf/virtual_rf_defines.h" 00052 #include "MAC/rf_driver_storage.h" 00053 00054 #define TRACE_GROUP "mlme" 00055 00056 #define MAC_ACK_WAIT_DURATION 90 00057 00058 static int8_t mac_mlme_rf_disable(struct protocol_interface_rf_mac_setup *rf_mac_setup); 00059 static int8_t mac_mlme_rf_receiver_enable(struct protocol_interface_rf_mac_setup *rf_mac_setup); 00060 00061 static void mac_mlme_write_mac16(protocol_interface_rf_mac_setup_s *rf_setup, uint8_t *addrPtr); 00062 static void mac_mlme_write_mac64(struct protocol_interface_rf_mac_setup *rf_setup, uint8_t *addrPtr); 00063 static void mac_mlme_timers_disable(protocol_interface_rf_mac_setup_s *rf_ptr); 00064 static void mac_mlme_free_scan_temporary_data(protocol_interface_rf_mac_setup_s *rf_mac_setup); 00065 static int8_t mac_mlme_set_panid(struct protocol_interface_rf_mac_setup *rf_setup, uint16_t pan_id); 00066 static int8_t mac_mlme_set_mac16(struct protocol_interface_rf_mac_setup *rf_setup, uint16_t mac16); 00067 static int8_t mac_mlme_rf_channel_set(struct protocol_interface_rf_mac_setup *rf_setup, uint8_t new_channel); 00068 static void mac_mlme_timer_cb(int8_t timer_id, uint16_t slots); 00069 static void mac_mlme_start_confirm_handler(protocol_interface_rf_mac_setup_s *rf_ptr, const mlme_start_conf_t *conf); 00070 static void mac_mlme_scan_confirm_handler(protocol_interface_rf_mac_setup_s *rf_ptr, const mlme_scan_conf_t *conf); 00071 00072 static void mac_mlme_energy_scan_start(protocol_interface_rf_mac_setup_s *rf_mac_setup, uint8_t channel) 00073 { 00074 phy_device_driver_s *dev_driver = rf_mac_setup->dev_driver->phy_driver; 00075 rf_mac_setup->mac_channel = channel; 00076 if (rf_mac_setup->macRfRadioOn) { 00077 if (dev_driver->state_control) { 00078 dev_driver->state_control(PHY_INTERFACE_DOWN, 0); 00079 } 00080 } 00081 if (dev_driver->state_control) { 00082 dev_driver->state_control(PHY_INTERFACE_RX_ENERGY_STATE, channel); 00083 } 00084 rf_mac_setup->macRfRadioOn = true; 00085 rf_mac_setup->macRfRadioTxActive = false; 00086 } 00087 00088 static uint16_t mlme_scan_analyze_next_channel(protocol_interface_rf_mac_setup_s *rf_mac_setup) 00089 { 00090 uint8_t i, j = 0, k = 1; 00091 uint32_t mask = 1; 00092 uint32_t *channel_mask = rf_mac_setup->mac_channel_list.channel_mask; 00093 00094 if (rf_mac_setup->mac_channel_list.channel_page == CHANNEL_PAGE_9 || 00095 rf_mac_setup->mac_channel_list.channel_page == CHANNEL_PAGE_10) { 00096 k=8; 00097 } 00098 for(j=0; j<k; j++) 00099 { 00100 for (i=0; i<32; i++) 00101 { 00102 if (*channel_mask & mask) 00103 { 00104 *channel_mask &= ~mask; 00105 return (i+j*32); 00106 } 00107 mask <<= 1; 00108 } 00109 mask = 1; 00110 channel_mask++; 00111 } 00112 return 0xffff; 00113 } 00114 00115 static uint32_t mac_mlme_channel_symbol_rate(uint8_t channel_page, uint8_t channel) { 00116 00117 uint32_t symbol_rate; 00118 00119 // Gets symbol rate for channel 00120 switch (channel_page) { 00121 case CHANNEL_PAGE_0: 00122 // 868 Mhz BPSK 00123 if (channel == 0) { 00124 symbol_rate = 20000; 00125 // 915 Mhz BPSK 00126 } else if (channel >= 1 && channel <= 10) { 00127 symbol_rate = 40000; 00128 // 2450 Mhz O-QPSK 00129 } else { 00130 symbol_rate = 62500; 00131 } 00132 break; 00133 case CHANNEL_PAGE_1: 00134 // 868 MHz ASK 00135 if (channel == 0) { 00136 symbol_rate = 12500; 00137 // 915 MHz ASK 00138 } else { 00139 symbol_rate = 50000; 00140 } 00141 break; 00142 case CHANNEL_PAGE_2: 00143 // 868 MHz O-QPSK 00144 if (channel == 0) { 00145 symbol_rate = 25000; 00146 // 915 MHz O-QPSK 00147 } else { 00148 symbol_rate = 62500; 00149 } 00150 break; 00151 case CHANNEL_PAGE_3: 00152 // 2450 CSS 00153 symbol_rate = 167000; 00154 break; 00155 case CHANNEL_PAGE_6: 00156 // 950 MHz BPSK 00157 if (channel <= 9) { 00158 symbol_rate = 20000; 00159 // 950 MHz GFSK 00160 } else { 00161 symbol_rate = 100000; 00162 } 00163 break; 00164 default: 00165 symbol_rate = 62500; 00166 break; 00167 } 00168 00169 return symbol_rate; 00170 } 00171 00172 static void mac_mlme_calc_scan_duration(protocol_interface_rf_mac_setup_s *rf_mac_setup, uint8_t channel) 00173 { 00174 rf_mac_setup->mlme_ED_counter = 1; 00175 00176 if (rf_mac_setup->scan_duration) { 00177 rf_mac_setup->mlme_ED_counter <<= rf_mac_setup->scan_duration; 00178 } 00179 00180 rf_mac_setup->mlme_ED_counter++; 00181 00182 if (rf_mac_setup->scan_type == MAC_ED_SCAN_TYPE) { 00183 // Gets symbol rate for channel that is scanned 00184 uint32_t symbol_rate = mac_mlme_channel_symbol_rate( 00185 rf_mac_setup->mac_channel_list.channel_page, channel); 00186 00187 // Energy scan duration is aBaseSuperframeDuration * (2^n + 1) 00188 // aBaseSuperframeDuration is 960 symbols e.g for 2.4Ghz O-QPSK with 62.5 ksymbols/s -> 15,36ms. 00189 // ED scan timer timeout is 4.8ms 00190 uint16_t frame_duration = (uint32_t) 960 * 100000 / symbol_rate; 00191 rf_mac_setup->mlme_ED_counter = (uint32_t) rf_mac_setup->mlme_ED_counter * frame_duration / 480; 00192 } 00193 } 00194 00195 static void mac_mlme_start_request(protocol_interface_rf_mac_setup_s *rf_mac_setup) 00196 { 00197 mac_pre_build_frame_t *buf; 00198 platform_enter_critical(); 00199 00200 mac_mlme_rf_disable(rf_mac_setup); 00201 buf = rf_mac_setup->active_pd_data_request; 00202 rf_mac_setup->active_pd_data_request = NULL; 00203 mac_mlme_mac_radio_enable(rf_mac_setup); 00204 rf_mac_setup->macUpState = true; 00205 if (buf) { 00206 // Active packet is pushed back to queue and statistics will be cleared. They need to be updated here. 00207 sw_mac_stats_update(rf_mac_setup, STAT_MAC_TX_CCA_ATT, rf_mac_setup->mac_tx_status.cca_cnt); 00208 sw_mac_stats_update(rf_mac_setup, STAT_MAC_TX_RETRY, rf_mac_setup->mac_tx_status.retry); 00209 mcps_sap_pd_req_queue_write(rf_mac_setup, buf); 00210 } 00211 platform_exit_critical(); 00212 } 00213 00214 uint8_t mac_mlme_beacon_req_tx(protocol_interface_rf_mac_setup_s *rf_ptr) 00215 { 00216 00217 mac_pre_build_frame_t *buf = mcps_sap_prebuild_frame_buffer_get(0); 00218 00219 if (buf) { 00220 buf->fcf_dsn.DstAddrMode = MAC_ADDR_MODE_16_BIT; 00221 buf->fcf_dsn.SrcAddrMode = MAC_ADDR_MODE_NONE; 00222 buf->fcf_dsn.frametype = FC_CMD_FRAME; 00223 buf->DstPANId = 0xffff; 00224 buf->DstAddr[0] = 0xff; 00225 buf->DstAddr[1] = 0xff; 00226 buf->mac_command_id = MAC_BEACON_REQ; 00227 buf->mac_header_length_with_security = 7; 00228 buf->mac_payload = &buf->mac_command_id; 00229 buf->mac_payload_length = 1; 00230 buf->priority = MAC_PD_DATA_MEDIUM_PRIORITY; 00231 00232 tr_debug("BEA REQ tx"); 00233 mcps_sap_pd_req_queue_write(rf_ptr, buf); 00234 return 1; 00235 } 00236 return 0; 00237 } 00238 00239 static void mac_mlme_scan_init(uint8_t channel, protocol_interface_rf_mac_setup_s *rf_mac_setup) 00240 { 00241 mac_mlme_calc_scan_duration(rf_mac_setup, channel); 00242 00243 switch (rf_mac_setup->scan_type) { 00244 /* ED Scan */ 00245 case MAC_ED_SCAN_TYPE: 00246 //tr_debug("Energy Scan"); 00247 rf_mac_setup->max_ED = 0; 00248 mac_mlme_energy_scan_start(rf_mac_setup, channel); 00249 rf_mac_setup->mac_mlme_event = ARM_NWK_MAC_MLME_ED_ANALYZE; 00250 eventOS_callback_timer_start(rf_mac_setup->mlme_timer_id, 96); 00251 break; 00252 case MAC_PASSIVE_SCAN: 00253 case MAC_ACTIVE_SCAN: /*Active*/ 00254 tr_debug("Scan channel %u", channel); 00255 rf_mac_setup->mac_channel = channel; 00256 rf_mac_setup->macCapRxOnIdle = true; 00257 mac_mlme_start_request(rf_mac_setup); 00258 if (rf_mac_setup->scan_type == MAC_ACTIVE_SCAN) { 00259 mac_pre_build_frame_t *active_buf = rf_mac_setup->active_pd_data_request; 00260 /* If there is active data request, it must be Beacon request which were failed to send on previous channel. 00261 * Do not push new Beacon request to queue as the MAC will try to send the current active data request anyway. 00262 */ 00263 if (!active_buf || (active_buf && active_buf->fcf_dsn.frametype != FC_CMD_FRAME)) { 00264 mac_mlme_beacon_req_tx(rf_mac_setup); 00265 } 00266 } 00267 rf_mac_setup->mac_mlme_event = ARM_NWK_MAC_MLME_SCAN; 00268 rf_mac_setup->mlme_tick_count = rf_mac_setup->mlme_ED_counter; 00269 //tr_debug("mlme_tick_count: %x", rf_mac_setup->mlme_tick_count); 00270 eventOS_callback_timer_start(rf_mac_setup->mlme_timer_id, 300); 00271 break; 00272 case MAC_ORPHAN_SCAN: /*Orphan*/ 00273 break; 00274 } 00275 } 00276 00277 static void mac_mlme_scan_start(protocol_interface_rf_mac_setup_s *rf_mac_setup) 00278 { 00279 uint8_t channel; 00280 00281 channel = (uint8_t) mlme_scan_analyze_next_channel(rf_mac_setup); 00282 mac_mlme_scan_init(channel, rf_mac_setup); 00283 } 00284 00285 static bool mac_channel_list_validate(const channel_list_s *list, protocol_interface_rf_mac_setup_s *rf_mac_setup) 00286 { 00287 if (rf_mac_setup->dev_driver->phy_driver->link_type == PHY_LINK_15_4_2_4GHZ_TYPE && 00288 list->channel_page == 0) { 00289 //Accept only Channels channels 11-26 00290 if (list->channel_mask[0] & 0x7fff800) { 00291 return true; 00292 } 00293 return false; 00294 } 00295 else if (rf_mac_setup->dev_driver->phy_driver->link_type == PHY_LINK_15_4_SUBGHZ_TYPE && 00296 (list->channel_page == 0 || list->channel_page == 1 || list->channel_page == 2)) { 00297 if (list->channel_mask[0] & 0x000007ff) { 00298 return true; 00299 } 00300 00301 return false; 00302 } else { 00303 for (int i=0; i < 8; i++) { 00304 if (list->channel_mask[i]) { 00305 return true; 00306 } 00307 } 00308 } 00309 00310 return false; 00311 } 00312 00313 static int mac_mlme_generate_scan_confirmation(mlme_scan_conf_t *conf, const mlme_scan_t *msg, uint8_t status) 00314 { 00315 memset(conf, 0, sizeof(mlme_scan_conf_t)); 00316 conf->status = status; 00317 if (!msg) { 00318 return -1; 00319 } 00320 conf->ScanType = msg->ScanType; 00321 conf->ChannelPage = msg->ChannelPage; 00322 if (msg->ScanType == MAC_ACTIVE_SCAN) { 00323 /*If the scan is successful, this value will be modified properly in mlme_analyze_next_channel() 00324 and assigned in mlme_scan_operation()*/ 00325 conf->UnscannedChannels.channel_mask[0] = msg->ScanChannels.channel_mask[0]; 00326 } else if (msg->ScanType == MAC_ED_SCAN_TYPE) { 00327 conf->ED_values = ns_dyn_mem_temporary_alloc(MLME_MAC_RES_SIZE_MAX); 00328 if (!conf->ED_values) { 00329 tr_debug("Could not allocate memory for ED values"); 00330 conf->status = MLME_SUCCESS; 00331 return -2; 00332 } 00333 memset(conf->ED_values, 0, MLME_MAC_RES_SIZE_MAX); 00334 } 00335 return 0; 00336 } 00337 00338 void mac_mlme_scan_request(const mlme_scan_t *msg, protocol_interface_rf_mac_setup_s *rf_mac_setup) 00339 { 00340 if (rf_mac_setup->mac_mlme_scan_resp){ 00341 mlme_scan_conf_t conf; 00342 mac_mlme_generate_scan_confirmation(&conf, msg, MLME_SCAN_IN_PROGRESS); 00343 mac_mlme_scan_confirm_handler(rf_mac_setup, &conf); 00344 ns_dyn_mem_free(conf.ED_values); 00345 return; 00346 } 00347 00348 mlme_scan_conf_t *resp = ns_dyn_mem_temporary_alloc(sizeof(mlme_scan_conf_t)); 00349 if (!resp) { 00350 mlme_scan_conf_t conf; 00351 tr_error("Mac Scan request fail, no memory"); 00352 mac_mlme_generate_scan_confirmation(&conf, NULL, MLME_SUCCESS); 00353 mac_mlme_scan_confirm_handler(rf_mac_setup, &conf); 00354 ns_dyn_mem_free(conf.ED_values); 00355 return; 00356 } 00357 00358 rf_mac_setup->mac_mlme_scan_resp = resp; 00359 //Validate channel list 00360 tr_debug("chan page %u, mask %"PRIx32, msg->ScanChannels.channel_page, msg->ScanChannels.channel_mask[0]); 00361 if (!mac_channel_list_validate(&msg->ScanChannels, rf_mac_setup)) { 00362 tr_debug("Unsupported channel list"); 00363 mac_mlme_generate_scan_confirmation(resp, msg, MLME_INVALID_PARAMETER); 00364 mac_generic_event_trig(MAC_MLME_SCAN_CONFIRM_HANDLER, rf_mac_setup, false); 00365 return; 00366 } 00367 00368 if (mac_mlme_generate_scan_confirmation(resp, msg, MLME_SUCCESS) != 0) { 00369 return; 00370 } 00371 00372 tr_debug("MAC: Start MLME scan"); 00373 00374 if (mac_mlme_rf_disable(rf_mac_setup) == 0) { 00375 rf_mac_setup->macCapRxOnIdle = false; 00376 if (msg->ScanType == MAC_ACTIVE_SCAN) { 00377 rf_mac_setup->macUpState = true; 00378 } 00379 } else { 00380 tr_error("Failed to disable RF"); 00381 mac_generic_event_trig(MAC_MLME_SCAN_CONFIRM_HANDLER, rf_mac_setup, false); 00382 return; 00383 } 00384 00385 rf_mac_setup->scan_type = msg->ScanType; 00386 rf_mac_setup->scan_duration = msg->ScanDuration; 00387 rf_mac_setup->mac_channel_list = msg->ScanChannels; 00388 rf_mac_setup->mac_mlme_event = ARM_NWK_MAC_MLME_SCAN; 00389 rf_mac_setup->scan_active = true; 00390 mac_mlme_scan_start(rf_mac_setup); 00391 } 00392 00393 int8_t mac_mlme_start_req(const mlme_start_t *s, struct protocol_interface_rf_mac_setup *rf_mac_setup) 00394 { 00395 if (!s || !rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver) { 00396 return -1; 00397 } 00398 00399 tr_debug("MAC: Start network %u channel %x panid", s->LogicalChannel, s->PANId); 00400 mac_mlme_set_panid(rf_mac_setup, s->PANId); 00401 // Synchronize FHSS 00402 if (rf_mac_setup->fhss_api) { 00403 rf_mac_setup->fhss_api->synch_state_set(rf_mac_setup->fhss_api, FHSS_SYNCHRONIZED, s->PANId); 00404 } 00405 00406 if (!rf_mac_setup->fhss_api) { 00407 rf_mac_setup->mac_channel = s->LogicalChannel; 00408 } 00409 mac_mlme_start_request(rf_mac_setup); 00410 if (s->PANCoordinator) { 00411 //tr_debug("Cordinator"); 00412 rf_mac_setup->macCapCordinator = true; 00413 rf_mac_setup->macCapRxOnIdle = true; 00414 } else { 00415 rf_mac_setup->macCapCordinator = false; 00416 } 00417 00418 if (s->BatteryLifeExtension) { 00419 rf_mac_setup->macCapBatteryPowered = true; 00420 } else { 00421 rf_mac_setup->macCapBatteryPowered = false; 00422 } 00423 mlme_start_conf_t conf; 00424 conf.status = MLME_SUCCESS; 00425 mac_mlme_start_confirm_handler(rf_mac_setup, &conf); 00426 return 0; 00427 } 00428 00429 int8_t mac_mlme_reset(protocol_interface_rf_mac_setup_s *rf_mac_setup, const mlme_reset_t *reset) { 00430 if (!reset || !rf_mac_setup) { 00431 return -1; 00432 } 00433 00434 // Stop FHSS 00435 if (rf_mac_setup->fhss_api) { 00436 rf_mac_setup->fhss_api->synch_state_set(rf_mac_setup->fhss_api, FHSS_UNSYNCHRONIZED, 0); 00437 } 00438 00439 mac_mlme_timers_disable(rf_mac_setup); 00440 mac_mlme_mac_radio_disabled(rf_mac_setup); 00441 mac_mlme_set_active_state(rf_mac_setup, false); 00442 mac_mlme_free_scan_temporary_data(rf_mac_setup); 00443 mac_mcps_buffer_queue_free(rf_mac_setup); 00444 rf_mac_setup->macProminousMode = false; 00445 rf_mac_setup->macWaitingData = false; 00446 rf_mac_setup->macDataPollReq = false; 00447 rf_mac_setup->macRxDataAtPoll = false; 00448 //Clean MAC 00449 if (reset->SetDefaultPIB) { 00450 tr_debug("RESET MAC PIB"); 00451 rf_mac_setup->mac_short_address = 0xffff; 00452 rf_mac_setup->pan_id = 0xffff; 00453 rf_mac_setup->macCapRxOnIdle = true; 00454 rf_mac_setup->mac_security_enabled = false; 00455 rf_mac_setup->macCapCordinator = false; 00456 rf_mac_setup->mac_mlme_retry_max = MAC_DEFAULT_MAX_FRAME_RETRIES; 00457 } 00458 00459 return 0; 00460 } 00461 00462 00463 static int8_t mac_mlme_boolean_set(protocol_interface_rf_mac_setup_s *rf_mac_setup,mlme_attr_t attribute ,bool value) 00464 { 00465 switch (attribute) { 00466 case macSecurityEnabled: 00467 rf_mac_setup->mac_security_enabled = value; 00468 break; 00469 00470 case macRxOnWhenIdle: 00471 rf_mac_setup->macCapRxOnIdle = value; 00472 break; 00473 00474 case macPromiscuousMode: 00475 rf_mac_setup->macProminousMode = value; 00476 break; 00477 00478 case macGTSPermit: 00479 rf_mac_setup->macGTSPermit = value; 00480 break; 00481 00482 case macAssociationPermit: 00483 rf_mac_setup->macCapAssocationPermit = value; 00484 break; 00485 case macThreadForceLongAddressForBeacon: 00486 rf_mac_setup->beaconSrcAddressModeLong = value; 00487 break; 00488 00489 case macAssociatedPANCoord: 00490 00491 break; 00492 00493 case macTimestampSupported: 00494 00495 break; 00496 00497 case macBattLifeExt: 00498 00499 break; 00500 00501 case macAutoRequest: 00502 00503 break; 00504 00505 case macLoadBalancingAcceptAnyBeacon: 00506 rf_mac_setup->macAcceptAnyBeacon = value; 00507 if (rf_mac_setup->dev_driver->phy_driver->extension) { 00508 rf_mac_setup->dev_driver->phy_driver->extension(PHY_EXTENSION_ACCEPT_ANY_BEACON, (uint8_t*)&value); 00509 } 00510 break; 00511 00512 default: 00513 return -1; 00514 } 00515 return 0; 00516 } 00517 00518 static int8_t mac_mlme_16bit_set(protocol_interface_rf_mac_setup_s *rf_mac_setup,mlme_attr_t attribute, uint16_t value) 00519 { 00520 switch (attribute) { 00521 case macCoordShortAddress: 00522 rf_mac_setup->coord_short_address = value; 00523 break; 00524 case macPANId: 00525 mac_mlme_set_panid(rf_mac_setup, value); 00526 break; 00527 00528 case macShortAddress: 00529 mac_mlme_set_mac16(rf_mac_setup, value); 00530 break; 00531 00532 case macSyncSymbolOffset: 00533 //TODO: change this to return real error 00534 //This is read only 00535 break; 00536 00537 case macTransactionPersistenceTime: 00538 //TODO: check this also 00539 break; 00540 00541 default: 00542 return -1; 00543 } 00544 return 0; 00545 } 00546 00547 static int8_t mac_mlme_8bit_set(protocol_interface_rf_mac_setup_s *rf_mac_setup,mlme_attr_t attribute ,uint8_t value) 00548 { 00549 switch (attribute) { 00550 case phyCurrentChannel: 00551 mac_mlme_rf_channel_set(rf_mac_setup, value); 00552 break; 00553 case macBeaconPayloadLength: 00554 if (rf_mac_setup->max_beacon_payload_length < value) { 00555 return -1; 00556 } 00557 00558 rf_mac_setup->mac_beacon_payload_size = value; 00559 break; 00560 case macAutoRequestKeyIndex: 00561 rf_mac_setup->mac_auto_request.KeyIndex = value; 00562 break; 00563 00564 case macAutoRequestKeyIdMode: 00565 rf_mac_setup->mac_auto_request.KeyIdMode = value; 00566 break; 00567 00568 case macAutoRequestSecurityLevel: 00569 rf_mac_setup->mac_auto_request.SecurityLevel = value; 00570 break; 00571 case macMaxFrameRetries: 00572 if (value > 7) { 00573 return -1; 00574 } 00575 rf_mac_setup->mac_mlme_retry_max = value; 00576 break; 00577 00578 case macMinBE: 00579 if (value > rf_mac_setup->macMaxBE) { 00580 rf_mac_setup->macMinBE = value; 00581 } 00582 break; 00583 00584 case macMaxBE: 00585 if (value > 8 || value < 3) { 00586 return -1; 00587 } 00588 rf_mac_setup->macMaxBE = value; 00589 break; 00590 00591 case macMaxCSMABackoffs: 00592 if (value > 8 ) { 00593 return -1; 00594 } 00595 rf_mac_setup->macMaxCSMABackoffs = value; 00596 break; 00597 00598 default: 00599 return -1; 00600 } 00601 return 0; 00602 } 00603 00604 static int8_t mac_mlme_32bit_set(protocol_interface_rf_mac_setup_s *rf_mac_setup, mlme_attr_t attribute, uint32_t value) 00605 { 00606 (void)rf_mac_setup; 00607 (void) value; 00608 switch (attribute) { 00609 case macFrameCounter: 00610 rf_mac_setup->security_frame_counter = value; 00611 break; 00612 00613 default: 00614 return -1; 00615 } 00616 return 0; 00617 } 00618 00619 void mac_extended_mac_set(protocol_interface_rf_mac_setup_s *rf_mac_setup, const uint8_t *mac64) 00620 { 00621 if( !mac64 || !rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver ){ 00622 return; 00623 } 00624 phy_device_driver_s *dev_driver = rf_mac_setup->dev_driver->phy_driver; 00625 memcpy(rf_mac_setup->mac64, mac64, 8); //This should be random 00626 if (dev_driver->address_write) { 00627 dev_driver->address_write(PHY_MAC_64BIT, rf_mac_setup->mac64); 00628 } 00629 } 00630 00631 static int8_t mac_mlme_device_description_set(protocol_interface_rf_mac_setup_s *rf_mac_setup,const mlme_set_t *set_req) { 00632 00633 if (set_req->value_size != sizeof(mlme_device_descriptor_t)) { 00634 return -1; 00635 } 00636 00637 return mac_sec_mib_device_description_set(set_req->attr_index,(mlme_device_descriptor_t *) set_req->value_pointer , rf_mac_setup); 00638 } 00639 00640 static int8_t mac_mlme_key_description_set(protocol_interface_rf_mac_setup_s *rf_mac_setup,const mlme_set_t *set_req) { 00641 if (set_req->value_size != sizeof(mlme_key_descriptor_entry_t)) { 00642 return -1; 00643 } 00644 00645 return mac_sec_mib_key_description_set(set_req->attr_index,(mlme_key_descriptor_entry_t *) set_req->value_pointer , rf_mac_setup); 00646 } 00647 00648 static int8_t mac_mlme_default_key_source_set(protocol_interface_rf_mac_setup_s *rf_mac_setup,const mlme_set_t *set_req) { 00649 if (set_req->value_size != 8) { 00650 return -1; 00651 } 00652 if (set_req->attr == macDefaultKeySource) { 00653 memcpy(rf_mac_setup->mac_default_key_source, (uint8_t *)set_req->value_pointer, 8); 00654 } else { 00655 memcpy(rf_mac_setup->mac_auto_request.Keysource, (uint8_t *)set_req->value_pointer, 8); 00656 } 00657 return 0; 00658 } 00659 00660 static int8_t mac_mlme_beacon_payload_set(protocol_interface_rf_mac_setup_s *rf_mac_setup, const mlme_set_t *set_req) 00661 { 00662 if (set_req->value_size > rf_mac_setup->max_beacon_payload_length) { 00663 return -1; 00664 } 00665 00666 memcpy(rf_mac_setup->mac_beacon_payload, set_req->value_pointer, set_req->value_size); 00667 memset(rf_mac_setup->mac_beacon_payload + set_req->value_size, 0, rf_mac_setup->max_beacon_payload_length - set_req->value_size); 00668 00669 return 0; 00670 } 00671 00672 static int8_t mac_mlme_handle_set_values(protocol_interface_rf_mac_setup_s *rf_mac_setup,const mlme_set_t *set_req) 00673 { 00674 if (set_req->value_size == 1) { 00675 const bool *pbool = set_req->value_pointer; 00676 //Check first boolean 00677 if (mac_mlme_boolean_set(rf_mac_setup,set_req->attr, *pbool) == 0) { 00678 return 0; 00679 } 00680 const uint8_t *pu8 = set_req->value_pointer; 00681 return mac_mlme_8bit_set(rf_mac_setup,set_req->attr, *pu8); 00682 00683 } else if (set_req->value_size == 2) { 00684 const uint16_t *pu16 = set_req->value_pointer; 00685 return mac_mlme_16bit_set(rf_mac_setup,set_req->attr, *pu16); 00686 } else if (set_req->value_size == 4) { 00687 const uint32_t *pu32 = set_req->value_pointer; 00688 return mac_mlme_32bit_set(rf_mac_setup,set_req->attr, *pu32); 00689 } 00690 return -1; 00691 } 00692 00693 int8_t mac_mlme_set_req(protocol_interface_rf_mac_setup_s *rf_mac_setup,const mlme_set_t *set_req) 00694 { 00695 if (!set_req || !rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver ) { 00696 return -1; 00697 } 00698 00699 switch (set_req->attr) { 00700 case macDeviceTable: 00701 return mac_mlme_device_description_set(rf_mac_setup, set_req); 00702 case macKeyTable: 00703 return mac_mlme_key_description_set(rf_mac_setup, set_req); 00704 case macDefaultKeySource: 00705 case macAutoRequestKeySource: 00706 return mac_mlme_default_key_source_set(rf_mac_setup, set_req); 00707 case macBeaconPayload: 00708 return mac_mlme_beacon_payload_set(rf_mac_setup, set_req); 00709 case macLoadBalancingBeaconTx: 00710 return mac_mlme_beacon_tx(rf_mac_setup); 00711 case macCoordExtendedAddress: 00712 if( set_req->value_size == 8) { 00713 memcpy(rf_mac_setup->coord_long_address, set_req->value_pointer, 8); 00714 } 00715 return 0; 00716 default: 00717 return mac_mlme_handle_set_values(rf_mac_setup, set_req); 00718 } 00719 } 00720 00721 int8_t mac_mlme_get_req(struct protocol_interface_rf_mac_setup *rf_mac_setup, mlme_get_conf_t *get_req) 00722 { 00723 if (!get_req || !rf_mac_setup ) { 00724 return -1; 00725 } 00726 00727 switch (get_req->attr) { 00728 case macDeviceTable: 00729 get_req->value_pointer = mac_sec_mib_device_description_get_attribute_index(rf_mac_setup, get_req->attr_index); 00730 if (get_req->value_pointer) { 00731 get_req->value_size = sizeof(mlme_device_descriptor_t); 00732 } else { 00733 get_req->status = MLME_INVALID_INDEX; 00734 } 00735 break; 00736 00737 case macMaxFrameRetries: 00738 get_req->value_pointer = &rf_mac_setup->mac_mlme_retry_max; 00739 get_req->value_size = 1; 00740 break; 00741 00742 case macFrameCounter: 00743 get_req->value_pointer = &rf_mac_setup->security_frame_counter; 00744 get_req->value_size = 4; 00745 break; 00746 00747 default: 00748 get_req->status = MLME_UNSUPPORTED_ATTRIBUTE; 00749 break; 00750 00751 } 00752 return 0; 00753 } 00754 00755 static void mlme_scan_operation(protocol_interface_rf_mac_setup_s *rf_mac_setup) 00756 { 00757 uint16_t channel; 00758 mlme_scan_conf_t *resp = rf_mac_setup->mac_mlme_scan_resp; 00759 00760 if (rf_mac_setup->scan_type == MAC_ED_SCAN_TYPE) { 00761 resp->ED_values[resp->ResultListSize] = rf_mac_setup->max_ED; 00762 resp->ResultListSize++; 00763 } 00764 00765 channel = mlme_scan_analyze_next_channel(rf_mac_setup); 00766 if (channel > 0xff || rf_mac_setup->mac_mlme_scan_resp->ResultListSize == MLME_MAC_RES_SIZE_MAX) { 00767 resp->status = MLME_SUCCESS; 00768 tr_debug("Scan Complete..Halt MAC"); 00769 platform_enter_critical(); 00770 mac_mlme_mac_radio_disabled(rf_mac_setup); 00771 if (resp->ResultListSize == 0 && rf_mac_setup->scan_type == MAC_ACTIVE_SCAN) { 00772 resp->status = MLME_NO_BEACON; 00773 }else if( resp->ResultListSize == MLME_MAC_RES_SIZE_MAX ){ 00774 resp->status = MLME_LIMIT_REACHED; 00775 } 00776 resp->UnscannedChannels.channel_mask[0] = rf_mac_setup->mac_channel_list.channel_mask[0]; 00777 platform_exit_critical(); 00778 //Scan Confirmation 00779 mac_generic_event_trig(MAC_MLME_SCAN_CONFIRM_HANDLER, rf_mac_setup, false); 00780 tr_debug("Trig confirm"); 00781 rf_mac_setup->scan_active = false; 00782 } else { 00783 mac_mlme_scan_init((uint8_t) channel, rf_mac_setup); 00784 } 00785 } 00786 00787 void mac_frame_src_address_set_from_interface(uint8_t SrcAddrMode,protocol_interface_rf_mac_setup_s *rf_ptr, uint8_t *addressPtr) 00788 { 00789 if( !rf_ptr ){ 00790 return; 00791 } 00792 if (SrcAddrMode == MAC_ADDR_MODE_16_BIT) { 00793 mac_mlme_write_mac16(rf_ptr, addressPtr); 00794 } else if (SrcAddrMode == MAC_ADDR_MODE_64_BIT) { 00795 mac_mlme_write_mac64(rf_ptr, addressPtr); 00796 } 00797 } 00798 00799 void mac_mlme_active_scan_response_timer_start(void *interface) 00800 { 00801 if (interface) { 00802 protocol_interface_rf_mac_setup_s *rf_mac_setup = (protocol_interface_rf_mac_setup_s *)interface; 00803 if (rf_mac_setup) { 00804 if (rf_mac_setup->mac_mlme_event == ARM_NWK_MAC_MLME_SCAN) { 00805 eventOS_callback_timer_stop(rf_mac_setup->mlme_timer_id); 00806 rf_mac_setup->mac_mlme_event = ARM_NWK_MAC_MLME_SCAN; 00807 rf_mac_setup->mlme_tick_count = rf_mac_setup->mlme_ED_counter; 00808 00809 eventOS_callback_timer_start(rf_mac_setup->mlme_timer_id, 300); 00810 } 00811 } 00812 } 00813 } 00814 00815 static void mac_mlme_timers_disable(protocol_interface_rf_mac_setup_s *rf_ptr) 00816 { 00817 platform_enter_critical(); 00818 if (rf_ptr->mac_mlme_event != ARM_NWK_MAC_MLME_IDLE) { 00819 eventOS_callback_timer_stop(rf_ptr->mlme_timer_id); 00820 rf_ptr->mac_mlme_event = ARM_NWK_MAC_MLME_IDLE; 00821 } 00822 timer_mac_stop(rf_ptr); 00823 platform_exit_critical(); 00824 } 00825 00826 void mac_mlme_event_cb(void *mac_ptr) 00827 { 00828 protocol_interface_rf_mac_setup_s *rf_mac_setup = (protocol_interface_rf_mac_setup_s*) mac_ptr; 00829 if (!rf_mac_setup) { 00830 return; 00831 } 00832 arm_nwk_mlme_event_type_e event_type; 00833 event_type = rf_mac_setup->mac_mlme_event; 00834 rf_mac_setup->mac_mlme_event = ARM_NWK_MAC_MLME_IDLE; 00835 switch (event_type) { 00836 case ARM_NWK_MAC_MLME_SCAN: 00837 mlme_scan_operation(rf_mac_setup); 00838 break; 00839 00840 case ARM_NWK_MAC_MLME_INDIRECT_DATA_POLL: 00841 tr_debug("Data poll data wait TO"); 00842 mac_mlme_poll_process_confirm(rf_mac_setup, MLME_NO_DATA); 00843 break; 00844 00845 case ARM_NWK_MAC_MLME_INDIRECT_DATA_POLL_AFTER_DATA: 00846 mac_mlme_poll_process_confirm(rf_mac_setup, MLME_SUCCESS); 00847 break; 00848 00849 default: 00850 break; 00851 } 00852 } 00853 00854 static void mac_mcps_timer_cb(int8_t timer_id, uint16_t slots) 00855 { 00856 00857 protocol_interface_rf_mac_setup_s *rf_ptr = get_sw_mac_ptr_by_timer(timer_id, ARM_MCPS_TIMER); 00858 if (!rf_ptr || !rf_ptr->dev_driver || !rf_ptr->dev_driver->phy_driver) { 00859 return; 00860 } 00861 rf_ptr->mac_mcps_timer_event.event_data = slots; 00862 eventOS_event_send(&rf_ptr->mac_mcps_timer_event); 00863 00864 } 00865 00866 00867 static void mac_mlme_timer_cb(int8_t timer_id, uint16_t slots) 00868 { 00869 protocol_interface_rf_mac_setup_s *rf_ptr = get_sw_mac_ptr_by_timer(timer_id, ARM_NWK_MLME_TIMER); 00870 if (!rf_ptr || !rf_ptr->dev_driver || !rf_ptr->dev_driver->phy_driver) { 00871 return; 00872 } 00873 00874 if (rf_ptr->mlme_tick_count == 0) { 00875 if (rf_ptr->mac_mlme_event != ARM_NWK_MAC_MLME_IDLE) { 00876 if (rf_ptr->mac_mlme_event == ARM_NWK_MAC_MLME_ED_ANALYZE) { 00877 if (rf_ptr->mlme_ED_counter > 1) { 00878 uint8_t ed = 0; 00879 phy_device_driver_s *dev_driver = rf_ptr->dev_driver->phy_driver; 00880 rf_ptr->mlme_ED_counter--; 00881 if( dev_driver->extension ){ 00882 dev_driver->extension(PHY_EXTENSION_READ_CHANNEL_ENERGY, &ed); 00883 } 00884 if (ed > rf_ptr->max_ED) { 00885 rf_ptr->max_ED = ed; 00886 } 00887 00888 /*96 * 50us = 4.8ms*/ 00889 rf_ptr->mlme_tick_count = 0; 00890 rf_ptr->mac_mlme_event = ARM_NWK_MAC_MLME_ED_ANALYZE; 00891 eventOS_callback_timer_start(timer_id, slots); 00892 } else { 00893 mac_mlme_rf_disable(rf_ptr); 00894 rf_ptr->mac_mlme_event = ARM_NWK_MAC_MLME_SCAN; 00895 mac_generic_event_trig(MAC_MLME_EVENT_HANDLER, rf_ptr, false); 00896 } 00897 } else { 00898 mac_generic_event_trig(MAC_MLME_EVENT_HANDLER,rf_ptr, true); 00899 } 00900 } 00901 } else { 00902 rf_ptr->mlme_tick_count--; 00903 eventOS_callback_timer_start(timer_id, slots); 00904 } 00905 } 00906 00907 static void mac_mlme_free_scan_temporary_data(protocol_interface_rf_mac_setup_s *rf_mac_setup) 00908 { 00909 rf_mac_setup->scan_active = false; 00910 if (rf_mac_setup->mac_mlme_scan_resp) { 00911 mlme_scan_conf_t *r = rf_mac_setup->mac_mlme_scan_resp; 00912 tr_debug("%02x", r->ResultListSize); 00913 if( r->ED_values ){ 00914 ns_dyn_mem_free(r->ED_values); 00915 r->ED_values = NULL; 00916 } 00917 uint8_t i = 0; 00918 while (i < r->ResultListSize) { 00919 if (r->PAN_values[i]) { 00920 tr_debug("Free PAN result"); 00921 ns_dyn_mem_free(r->PAN_values[i]); 00922 } 00923 i++; 00924 } 00925 tr_debug("Free Response"); 00926 ns_dyn_mem_free(rf_mac_setup->mac_mlme_scan_resp); 00927 rf_mac_setup->mac_mlme_scan_resp = NULL; 00928 } 00929 } 00930 00931 void mac_mlme_set_active_state(protocol_interface_rf_mac_setup_s *entry, bool new_state) 00932 { 00933 if( entry ){ 00934 entry->macUpState = new_state; 00935 } 00936 } 00937 00938 void mac_mlme_data_base_deallocate(struct protocol_interface_rf_mac_setup *rf_mac) 00939 { 00940 if (rf_mac) { 00941 if( rf_mac->dev_driver ){ 00942 rf_mac->dev_driver->phy_sap_identifier = NULL; 00943 rf_mac->dev_driver->phy_sap_upper_cb = NULL; 00944 } 00945 00946 eventOS_callback_timer_unregister(rf_mac->mlme_timer_id); 00947 eventOS_callback_timer_unregister(rf_mac->mac_timer_id); 00948 eventOS_callback_timer_unregister(rf_mac->mac_mcps_timer); 00949 00950 ns_dyn_mem_free(rf_mac->dev_driver_tx_buffer.buf); 00951 ns_dyn_mem_free(rf_mac->mac_beacon_payload); 00952 00953 mac_sec_mib_deinit(rf_mac); 00954 ns_dyn_mem_free(rf_mac); 00955 } 00956 } 00957 00958 static uint8_t mac_backoff_ticks_calc(phy_device_driver_s * phy_driver) 00959 { 00960 //Calculate 20 symbol time which is typically 10 bytes 00961 const phy_device_channel_page_s *phy_channel_pages = phy_driver->phy_channel_pages; 00962 uint32_t datarate = dev_get_phy_datarate(phy_driver, phy_channel_pages->channel_page); 00963 if (datarate == 0) { 00964 datarate = 250000; 00965 } 00966 //How many 10us ticks backoff period is, assuming 4 bits per symbol (O-QPSK) 00967 unsigned int ticks = (2000000 / (datarate / 4)); 00968 if (ticks > 255) { 00969 ticks = 255; 00970 tr_warn("Backoff period too slow"); 00971 } 00972 return (uint8_t) ticks; 00973 } 00974 00975 protocol_interface_rf_mac_setup_s * mac_mlme_data_base_allocate(uint8_t *mac64, arm_device_driver_list_s *dev_driver, mac_description_storage_size_t *storage_sizes) 00976 { 00977 uint16_t total_length = 0; 00978 //allocate security 00979 if (!dev_driver || !mac64 || !dev_driver->phy_driver || !storage_sizes) { 00980 return NULL; 00981 } 00982 00983 protocol_interface_rf_mac_setup_s *entry = ns_dyn_mem_alloc(sizeof(protocol_interface_rf_mac_setup_s)); 00984 if (!entry) { 00985 return NULL; 00986 } 00987 //Init everything for 0, NULL or false 00988 memset(entry, 0, sizeof(protocol_interface_rf_mac_setup_s)); 00989 entry->ifs_timer_id = -1; 00990 entry->cca_timer_id = -1; 00991 entry->mlme_timer_id = -1; 00992 entry->mac_timer_id = -1; 00993 entry->bc_timer_id = -1; 00994 entry->mac_interface_id = -1; 00995 entry->dev_driver = dev_driver; 00996 00997 if (mac_sec_mib_init(entry, storage_sizes) != 0) { 00998 mac_mlme_data_base_deallocate(entry); 00999 return NULL; 01000 } 01001 01002 if (!dev_driver->phy_driver->phy_MTU) { 01003 mac_mlme_data_base_deallocate(entry); 01004 return NULL; 01005 } 01006 01007 //Allocate tx buffer by given MTU + header + tail 01008 total_length = dev_driver->phy_driver->phy_MTU; 01009 total_length += (dev_driver->phy_driver->phy_header_length + dev_driver->phy_driver->phy_tail_length); 01010 entry->dev_driver_tx_buffer.buf = ns_dyn_mem_alloc(total_length); 01011 if (!entry->dev_driver_tx_buffer.buf) { 01012 mac_mlme_data_base_deallocate(entry); 01013 return NULL; 01014 } 01015 01016 //allocate Beacon Payload buffer 01017 entry->max_beacon_payload_length = dev_driver->phy_driver->phy_MTU - MAC_IEEE_802_15_4_MAX_BEACON_OVERHEAD; 01018 entry->mac_beacon_payload = ns_dyn_mem_alloc(entry->max_beacon_payload_length); 01019 if (!entry->mac_beacon_payload) { 01020 mac_mlme_data_base_deallocate(entry); 01021 return NULL; 01022 } 01023 01024 entry->mac_tasklet_id = mac_mcps_sap_tasklet_init(); 01025 if (entry->mac_tasklet_id < 0) { 01026 mac_mlme_data_base_deallocate(entry); 01027 return NULL; 01028 } 01029 01030 entry->mlme_timer_id = eventOS_callback_timer_register(mac_mlme_timer_cb); 01031 entry->mac_timer_id = eventOS_callback_timer_register(timer_mac_interrupt); 01032 entry->mac_mcps_timer = eventOS_callback_timer_register(mac_mcps_timer_cb); 01033 if (entry->mlme_timer_id == -1 || entry->mac_timer_id == -1 || entry->mac_mcps_timer == -1) { 01034 mac_mlme_data_base_deallocate(entry); 01035 return NULL; 01036 } 01037 entry->macCapRxOnIdle = true; 01038 entry->macCapSecrutityCapability = true; 01039 entry->pan_id = entry->mac_short_address = 0xffff; 01040 mac_extended_mac_set(entry, mac64); 01041 entry->mac_ack_wait_duration = MAC_ACK_WAIT_DURATION; 01042 entry->mac_mlme_retry_max = MAC_DEFAULT_MAX_FRAME_RETRIES; 01043 memset(entry->mac_default_key_source, 0xff, 8); 01044 memset(entry->mac_auto_request.Keysource, 0xff, 8); 01045 memset(entry->mac_beacon_payload, 0, entry->max_beacon_payload_length); 01046 entry->mac_auto_request.SecurityLevel = 6; 01047 entry->mac_auto_request.KeyIndex = 0xff; 01048 mac_pd_sap_rf_low_level_function_set(entry, entry->dev_driver); 01049 entry->mac_sequence = randLIB_get_8bit(); 01050 entry->mac_bea_sequence = randLIB_get_8bit(); 01051 entry->fhss_api = NULL; 01052 entry->macMinBE = 3; 01053 entry->macMaxBE = 5; 01054 entry->macMaxCSMABackoffs = MAC_CCA_MAX; 01055 entry->mac_mcps_timer_event.priority = ARM_LIB_LOW_PRIORITY_EVENT; 01056 entry->mac_mcps_timer_event.event_type = MAC_MCPS_INDIRECT_TIMER_CB; 01057 entry->mac_mcps_timer_event.data_ptr = entry; 01058 entry->mac_mcps_timer_event.receiver = entry->mac_tasklet_id; 01059 entry->mac_mcps_timer_event.sender = 0; 01060 entry->mac_mcps_timer_event.event_id = 0; 01061 //How many 10us ticks backoff period is for waiting 20symbols which is typically 10 bytes time 01062 entry->backoff_period_in_10us = mac_backoff_ticks_calc(dev_driver->phy_driver); 01063 return entry; 01064 } 01065 01066 uint8_t mac_mlme_set_new_sqn(protocol_interface_rf_mac_setup_s *rf_setup) 01067 { 01068 uint8_t ret_val = 0; 01069 01070 if (rf_setup) { 01071 rf_setup->mac_sequence++; 01072 ret_val = rf_setup->mac_sequence; 01073 } 01074 return ret_val; 01075 } 01076 01077 uint8_t mac_mlme_set_new_beacon_sqn(protocol_interface_rf_mac_setup_s *rf_setup) 01078 { 01079 uint8_t ret_val = 0; 01080 01081 if (rf_setup) { 01082 rf_setup->mac_bea_sequence++; 01083 ret_val = rf_setup->mac_bea_sequence; 01084 } 01085 return ret_val; 01086 } 01087 01088 static int8_t mac_mlme_set_panid(struct protocol_interface_rf_mac_setup *rf_setup, uint16_t pan_id) 01089 { 01090 phy_device_driver_s *dev_driver = rf_setup->dev_driver->phy_driver; 01091 if (!dev_driver->address_write) { 01092 if (dev_driver->link_type == PHY_LINK_TUN) { 01093 rf_setup->pan_id = pan_id; 01094 return 0; 01095 } 01096 return -1; 01097 } 01098 01099 uint8_t temp_8[2]; 01100 rf_setup->pan_id = pan_id; 01101 common_write_16_bit(pan_id, temp_8); 01102 01103 return dev_driver->address_write(PHY_MAC_PANID, temp_8); 01104 } 01105 01106 static void mac_mle_write_mac16_to_phy(phy_device_driver_s *dev_driver, uint16_t mac16) 01107 { 01108 uint8_t temp[2]; 01109 common_write_16_bit(mac16, temp); 01110 if (dev_driver->address_write) { 01111 dev_driver->address_write(PHY_MAC_16BIT, temp); 01112 } 01113 } 01114 01115 static int8_t mac_mlme_set_mac16(struct protocol_interface_rf_mac_setup *rf_setup, uint16_t mac16) 01116 { 01117 int8_t ret_val = -1; 01118 if (rf_setup) { 01119 01120 rf_setup->mac_short_address = mac16; 01121 //SET RF 16-bit 01122 if (mac16 > 0xfffd) { 01123 rf_setup->shortAdressValid = false; 01124 } else { 01125 rf_setup->shortAdressValid = true; 01126 } 01127 mac_mle_write_mac16_to_phy(rf_setup->dev_driver->phy_driver, mac16); 01128 ret_val = 0; 01129 } 01130 return ret_val; 01131 } 01132 01133 static void mac_mlme_write_mac64(protocol_interface_rf_mac_setup_s *rf_setup, uint8_t *addrPtr) 01134 { 01135 memcpy(addrPtr, rf_setup->mac64, 8); 01136 } 01137 01138 static void mac_mlme_write_mac16(protocol_interface_rf_mac_setup_s *rf_setup, uint8_t *addrPtr) 01139 { 01140 common_write_16_bit(rf_setup->mac_short_address, addrPtr); 01141 } 01142 01143 uint16_t mac_mlme_get_panid(protocol_interface_rf_mac_setup_s *rf_setup) 01144 { 01145 uint16_t panId = 0xffff; 01146 if (rf_setup) { 01147 panId = rf_setup->pan_id; 01148 } 01149 return panId; 01150 } 01151 01152 static bool add_or_update_beacon(mlme_scan_conf_t* conf, mlme_beacon_ind_t *data, fhss_api_t *fhss_api) 01153 { 01154 bool found = false; 01155 bool update_beacon = false; 01156 for( int i=0; i < conf->ResultListSize; i++){ 01157 mlme_pan_descriptor_t *cur_desc = conf->PAN_values[i]; 01158 if( !cur_desc ){ //Not an active or passive scan 01159 break; 01160 } 01161 /* When FHSS is enabled, logical channel check is not valid 01162 * as the Beacon can be sent on any enabled channel */ 01163 if (fhss_api || (cur_desc->LogicalChannel == data->PANDescriptor.LogicalChannel)) { 01164 if (cur_desc->CoordPANId == data->PANDescriptor.CoordPANId) { 01165 if (cur_desc->LinkQuality < data->PANDescriptor.LinkQuality) { 01166 cur_desc->CoordAddrMode = data->PANDescriptor.CoordAddrMode; 01167 memcpy(cur_desc->CoordAddress, data->PANDescriptor.CoordAddress, 8); 01168 cur_desc->LinkQuality = data->PANDescriptor.LinkQuality; 01169 update_beacon = true; 01170 } 01171 found = true; 01172 } 01173 } 01174 } 01175 if(!found && conf->ResultListSize != MLME_MAC_RES_SIZE_MAX) { 01176 mlme_pan_descriptor_t *desc = ns_dyn_mem_temporary_alloc(sizeof(mlme_pan_descriptor_t)); 01177 if( !desc ){ 01178 return false; 01179 } 01180 memset(desc, 0, sizeof(mlme_pan_descriptor_t)); 01181 mlme_pan_descriptor_t *dat = &data->PANDescriptor; 01182 01183 desc->CoordAddrMode = dat->CoordAddrMode; 01184 desc->CoordPANId = dat->CoordPANId; 01185 memcpy(desc->CoordAddress, dat->CoordAddress, 8); 01186 desc->LogicalChannel = dat->LogicalChannel; 01187 desc->ChannelPage = dat->ChannelPage; 01188 memcpy(desc->SuperframeSpec, dat->SuperframeSpec, 2); 01189 desc->GTSPermit = dat->GTSPermit; 01190 desc->LinkQuality = dat->LinkQuality; 01191 desc->Timestamp = dat->Timestamp; 01192 desc->SecurityFailure = dat->SecurityFailure; 01193 01194 desc->Key.SecurityLevel = dat->Key.SecurityLevel; 01195 desc->Key.KeyIdMode = dat->Key.KeyIdMode; 01196 desc->Key.KeyIndex = dat->Key.KeyIndex; 01197 memcpy(desc->Key.Keysource, dat->Key.Keysource, 8); 01198 01199 conf->PAN_values[conf->ResultListSize] = desc; 01200 conf->ResultListSize++; 01201 update_beacon = true; 01202 } 01203 return update_beacon; 01204 } 01205 01206 int mac_mlme_beacon_notify(protocol_interface_rf_mac_setup_s *rf_mac_setup, mlme_beacon_ind_t *data) 01207 { 01208 bool update_beacon = true; 01209 bool contains_fhss_synch_info = false; 01210 if( !rf_mac_setup || !data){ 01211 return -1; 01212 } 01213 01214 /* Cut FHSS synchronization info from Beacon payload length. 01215 * Synchronization info is stored later in this function but 01216 * should not be delivered to upper layer as a part of Beacon payload. 01217 */ 01218 if (rf_mac_setup->fhss_api) { 01219 if (data->beacon_data_length > FHSS_SYNCH_INFO_START) { 01220 data->beacon_data_length -= FHSS_SYNCH_INFO_LENGTH; 01221 contains_fhss_synch_info = true; 01222 } else { 01223 // Received single channel Beacon when FHSS enabled. 01224 return 0; 01225 } 01226 } 01227 01228 mac_api_t *mac = get_sw_mac_api(rf_mac_setup); 01229 if (mac && mac->mlme_ind_cb) { 01230 mac->mlme_ind_cb(mac, MLME_BEACON_NOTIFY, data); 01231 } 01232 01233 tr_debug("Beacon Notify: %s", trace_array(data->beacon_data, data->beacon_data_length)); 01234 01235 if (rf_mac_setup->mac_mlme_scan_resp) { 01236 mlme_scan_conf_t* conf = rf_mac_setup->mac_mlme_scan_resp; 01237 update_beacon = add_or_update_beacon(conf, data, rf_mac_setup->fhss_api); 01238 } 01239 if (rf_mac_setup->fhss_api && (update_beacon == true)) { 01240 if (contains_fhss_synch_info == true) { 01241 // Assume synchronization info is found from the end of the Beacon payload 01242 uint8_t *synch_info_start = data->beacon_data + data->beacon_data_length; 01243 rf_mac_setup->fhss_api->receive_frame(rf_mac_setup->fhss_api, data->PANDescriptor.CoordPANId, data->PANDescriptor.CoordAddress, 01244 data->PANDescriptor.Timestamp, synch_info_start, FHSS_SYNCH_FRAME); 01245 } 01246 } 01247 01248 return 0; 01249 } 01250 01251 int8_t mac_mlme_virtual_confirmation_handle(int8_t driver_id, const uint8_t *data_ptr, uint16_t length) 01252 { 01253 (void) length; 01254 protocol_interface_rf_mac_setup_s *mac_setup = get_sw_mac_ptr_by_driver_id(driver_id); 01255 if (!mac_setup) { 01256 return -1; 01257 } 01258 mlme_primitive primitive = *data_ptr; 01259 if (primitive == MLME_SCAN) { 01260 mlme_scan_conf_t *resp = ns_dyn_mem_temporary_alloc(sizeof(mlme_scan_conf_t)); 01261 if (!resp) { 01262 return -1; 01263 } 01264 memset(resp, 0, sizeof(mlme_scan_conf_t)); 01265 resp->ScanType = MAC_ACTIVE_SCAN; 01266 mac_setup->mac_mlme_scan_resp = resp; 01267 mac_mlme_scan_confirmation_handle(mac_setup); 01268 } 01269 return 0; 01270 } 01271 01272 static void mac_mlme_start_confirm_handler(protocol_interface_rf_mac_setup_s *rf_ptr, const mlme_start_conf_t *conf) 01273 { 01274 if (rf_ptr->tun_extension_rf_driver) { 01275 virtual_data_req_t start_conf; 01276 uint8_t buf_temp[2]; 01277 uint8_t payload_buf[2]; 01278 // Add some random data as empty payload is not allowed 01279 payload_buf[0] = 0; 01280 payload_buf[1] = 0; 01281 01282 memset(&start_conf, 0, sizeof(virtual_data_req_t)); 01283 buf_temp[0] = NAP_MLME_CONFIRM; 01284 buf_temp[1] = MLME_START; 01285 start_conf.parameters = buf_temp; 01286 start_conf.parameter_length = sizeof(buf_temp); 01287 start_conf.msdu = payload_buf; 01288 start_conf.msduLength = sizeof(payload_buf); 01289 01290 rf_ptr->tun_extension_rf_driver->phy_driver->arm_net_virtual_tx_cb(&start_conf, rf_ptr->tun_extension_rf_driver->id); 01291 } else if (get_sw_mac_api(rf_ptr)) { 01292 if (get_sw_mac_api(rf_ptr)->mlme_conf_cb) { 01293 get_sw_mac_api(rf_ptr)->mlme_conf_cb(get_sw_mac_api(rf_ptr), MLME_START, conf); 01294 } 01295 } 01296 } 01297 01298 static void mac_mlme_scan_confirm_handler(protocol_interface_rf_mac_setup_s *rf_ptr, const mlme_scan_conf_t *conf) 01299 { 01300 if (conf->ScanType == MAC_ACTIVE_SCAN) { 01301 tr_debug("Active Scan Result"); 01302 } else if (conf->ScanType == MAC_ED_SCAN_TYPE) { 01303 tr_debug("ED Scan Result"); 01304 } 01305 if (rf_ptr->tun_extension_rf_driver) { 01306 virtual_data_req_t scan_conf; 01307 uint8_t buf_temp[2]; 01308 uint8_t payload_buf[2]; 01309 // Add some random data as empty payload is not allowed 01310 payload_buf[0] = 0; 01311 payload_buf[1] = 0; 01312 01313 memset(&scan_conf, 0, sizeof(virtual_data_req_t)); 01314 buf_temp[0] = NAP_MLME_CONFIRM; 01315 buf_temp[1] = MLME_SCAN; 01316 scan_conf.parameters = buf_temp; 01317 scan_conf.parameter_length = sizeof(buf_temp); 01318 scan_conf.msdu = payload_buf; 01319 scan_conf.msduLength = sizeof(payload_buf); 01320 01321 rf_ptr->tun_extension_rf_driver->phy_driver->arm_net_virtual_tx_cb(&scan_conf, rf_ptr->tun_extension_rf_driver->id); 01322 } else if (get_sw_mac_api(rf_ptr)) { 01323 if (get_sw_mac_api(rf_ptr)->mlme_conf_cb) { 01324 get_sw_mac_api(rf_ptr)->mlme_conf_cb(get_sw_mac_api(rf_ptr), MLME_SCAN, conf); 01325 } 01326 } 01327 } 01328 01329 void mac_mlme_scan_confirmation_handle(protocol_interface_rf_mac_setup_s *rf_ptr) 01330 { 01331 if( !rf_ptr ){ 01332 return; 01333 } 01334 mlme_scan_conf_t *r = rf_ptr->mac_mlme_scan_resp; 01335 01336 if (r) { 01337 mac_mlme_scan_confirm_handler(rf_ptr, r); 01338 } 01339 mac_mlme_free_scan_temporary_data(rf_ptr); 01340 } 01341 01342 void mac_mlme_mac_radio_disabled(protocol_interface_rf_mac_setup_s *rf_mac_setup) 01343 { 01344 if( !rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver ){ 01345 return; 01346 } 01347 platform_enter_critical(); 01348 timer_mac_stop(rf_mac_setup); 01349 mac_mlme_rf_disable(rf_mac_setup); 01350 platform_exit_critical(); 01351 } 01352 01353 void mac_mlme_mac_radio_enable(protocol_interface_rf_mac_setup_s *rf_mac_setup) 01354 { 01355 if( !rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver){ 01356 return; 01357 } 01358 platform_enter_critical(); 01359 mac_mlme_rf_receiver_enable(rf_mac_setup); 01360 platform_exit_critical(); 01361 } 01362 01363 static int8_t mac_mlme_rf_disable(protocol_interface_rf_mac_setup_s *rf_mac_setup) 01364 { 01365 int8_t ret_val = 0; 01366 phy_device_driver_s *dev_driver = rf_mac_setup->dev_driver->phy_driver; 01367 if (!dev_driver->state_control) { 01368 if (dev_driver->link_type == PHY_LINK_TUN) { 01369 rf_mac_setup->macRfRadioOn = false; 01370 rf_mac_setup->macRfRadioTxActive = false; 01371 return 0; 01372 } 01373 return -1; 01374 } 01375 if (rf_mac_setup->macRfRadioOn) { 01376 ret_val = dev_driver->state_control(PHY_INTERFACE_DOWN, 0); 01377 rf_mac_setup->macRfRadioOn = false; 01378 rf_mac_setup->macRfRadioTxActive = false; 01379 } 01380 01381 return ret_val; 01382 } 01383 01384 static int8_t mac_mlme_rf_receiver_enable(struct protocol_interface_rf_mac_setup *rf_mac_setup) 01385 { 01386 int8_t retval; 01387 01388 phy_device_driver_s *dev_driver = rf_mac_setup->dev_driver->phy_driver; 01389 if (!dev_driver->state_control) { 01390 if (dev_driver->link_type == PHY_LINK_TUN) { 01391 rf_mac_setup->macRfRadioOn = true; 01392 return 0; 01393 } 01394 return -1; 01395 } 01396 01397 if (rf_mac_setup->macRfRadioOn) { 01398 return 0; 01399 } 01400 01401 if (rf_mac_setup->macProminousMode) { 01402 tr_debug("Sniffer mode"); 01403 retval = dev_driver->state_control(PHY_INTERFACE_SNIFFER_STATE, rf_mac_setup->mac_channel); 01404 } else { 01405 retval = dev_driver->state_control(PHY_INTERFACE_UP, rf_mac_setup->mac_channel); 01406 } 01407 rf_mac_setup->macRfRadioOn = true; 01408 //tr_debug("Enable radio with channel %u", rf_mac_setup->mac_channel); 01409 return retval; 01410 } 01411 01412 /** 01413 * Initialize MAC channel selection sequence 01414 * 01415 * TODO: initialize channel select sequence 01416 * in coordinator mode 01417 * 01418 * \param new_channel channel to set 01419 * 01420 * \return 0 success 01421 * \return -1 HW error 01422 */ 01423 static int8_t mac_mlme_rf_channel_set(struct protocol_interface_rf_mac_setup *rf_setup, uint8_t new_channel) 01424 { 01425 if (new_channel == rf_setup->mac_channel) { 01426 return 0; 01427 } 01428 mac_pre_build_frame_t *buf; 01429 01430 //Disable allways 01431 mac_mlme_mac_radio_disabled(rf_setup); 01432 buf = rf_setup->active_pd_data_request; 01433 rf_setup->active_pd_data_request = NULL; 01434 //Set Channel 01435 rf_setup->mac_channel = new_channel; 01436 //Enable Radio 01437 mac_mlme_mac_radio_enable(rf_setup); 01438 if (buf) { 01439 mcps_sap_pd_req_queue_write(rf_setup, buf); 01440 } 01441 01442 return 0; 01443 } 01444 01445 /** 01446 * MAC channel change 01447 * 01448 * \param new_channel channel to set 01449 * 01450 * \return 0 success 01451 * \return -1 error 01452 */ 01453 int8_t mac_mlme_rf_channel_change(protocol_interface_rf_mac_setup_s *rf_mac_setup, uint8_t new_channel) 01454 { 01455 if (!rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver) { 01456 return -1; 01457 } 01458 01459 if (!rf_mac_setup->dev_driver->phy_driver->extension) { 01460 if (rf_mac_setup->dev_driver->phy_driver->link_type == PHY_LINK_TUN) { 01461 rf_mac_setup->mac_channel = new_channel; 01462 return 0; 01463 } 01464 return -1; 01465 } 01466 if (new_channel == rf_mac_setup->mac_channel) { 01467 return 0; 01468 } 01469 platform_enter_critical(); 01470 rf_mac_setup->mac_channel = new_channel; 01471 rf_mac_setup->dev_driver->phy_driver->extension(PHY_EXTENSION_SET_CHANNEL, &rf_mac_setup->mac_channel); 01472 platform_exit_critical(); 01473 return 0; 01474 } 01475 01476 void mac_mlme_poll_process_confirm(protocol_interface_rf_mac_setup_s *rf_mac_setup, uint8_t status) 01477 { 01478 if (!rf_mac_setup || !rf_mac_setup->dev_driver || !rf_mac_setup->dev_driver->phy_driver) { 01479 return; 01480 } 01481 01482 //Free active Data buffer 01483 if (rf_mac_setup->active_pd_data_request) { 01484 mcps_sap_prebuild_frame_buffer_free(rf_mac_setup->active_pd_data_request); 01485 rf_mac_setup->active_pd_data_request = NULL; 01486 } 01487 //Disable timer 01488 rf_mac_setup->macWaitingData = false; 01489 rf_mac_setup->macDataPollReq = false; 01490 rf_mac_setup->macRxDataAtPoll = false; 01491 01492 if (!rf_mac_setup->macCapRxOnIdle) { 01493 //Disable Radio If we are RX off at idle device 01494 //tr_debug("disbale by aceptance data"); 01495 if (!rf_mac_setup->macRfRadioTxActive ) { 01496 //Disable radio if no active TX and radio is enabled 01497 //tr_debug("RF disable"); 01498 mac_mlme_mac_radio_disabled(rf_mac_setup); 01499 } 01500 } 01501 01502 mac_api_t *mac_api = get_sw_mac_api(rf_mac_setup); 01503 if( mac_api ) { 01504 mlme_poll_conf_t confirm; 01505 confirm.status = status; 01506 mac_api->mlme_conf_cb(mac_api,MLME_POLL, &confirm); 01507 } 01508 //Trig Packet from queue 01509 mac_mcps_trig_buffer_from_queue(rf_mac_setup); 01510 01511 } 01512 01513 void mac_mlme_poll_req(protocol_interface_rf_mac_setup_s *cur, const mlme_poll_t *poll_req) 01514 { 01515 if( !cur || !poll_req ){ 01516 return; 01517 } 01518 if (cur->macDataPollReq ) { 01519 tr_debug("Poll Active do not start new"); 01520 return; 01521 } 01522 mac_pre_build_frame_t *buf = mcps_sap_prebuild_frame_buffer_get(0); 01523 if (!buf) { 01524 tr_debug("No mem for data Req"); 01525 //Confirmation call here 01526 return; 01527 } 01528 01529 buf->fcf_dsn.frametype = FC_CMD_FRAME; 01530 buf->fcf_dsn.ackRequested = true; 01531 buf->fcf_dsn.intraPan = true; 01532 01533 buf->DstPANId = poll_req->CoordPANId; 01534 buf->SrcPANId = poll_req->CoordPANId; 01535 buf->fcf_dsn.DstAddrMode = poll_req->CoordAddrMode; 01536 memcpy(buf->DstAddr, poll_req->CoordAddress, 8); 01537 01538 buf->mac_command_id = MAC_DATA_REQ; 01539 buf->mac_payload = &buf->mac_command_id; 01540 buf->mac_payload_length = 1; 01541 buf->mac_header_length_with_security = 3; 01542 01543 mac_header_security_parameter_set(&buf->aux_header, &poll_req->Key); 01544 01545 if (buf->aux_header.securityLevel) { 01546 buf->fcf_dsn.securityEnabled = true; 01547 buf->fcf_dsn.frameVersion = MAC_FRAME_VERSION_2006; 01548 01549 } 01550 cur->macDataPollReq = true; 01551 cur->macWaitingData = true; 01552 cur->macRxDataAtPoll = false; 01553 01554 buf->security_mic_len = mac_security_mic_length_get(buf->aux_header.securityLevel); 01555 buf->mac_header_length_with_security += mac_header_security_aux_header_length(buf->aux_header.securityLevel, buf->aux_header.KeyIdMode); 01556 01557 if ( cur->mac_short_address > 0xfffd ) { 01558 buf->fcf_dsn.SrcAddrMode = MAC_ADDR_MODE_64_BIT; 01559 } else { 01560 buf->fcf_dsn.SrcAddrMode = MAC_ADDR_MODE_16_BIT; 01561 } 01562 mac_frame_src_address_set_from_interface(buf->fcf_dsn.SrcAddrMode, cur, buf->SrcAddr); 01563 buf->mac_header_length_with_security += mac_header_address_length(&buf->fcf_dsn); 01564 buf->priority = MAC_PD_DATA_MEDIUM_PRIORITY; 01565 mcps_sap_pd_req_queue_write(cur, buf); 01566 } 01567 01568 static bool mac_mlme_beacon_at_queue(protocol_interface_rf_mac_setup_s *rf_ptr) { 01569 mac_pre_build_frame_t *buf = rf_ptr->active_pd_data_request; 01570 if (buf && buf->fcf_dsn.frametype == FC_BEACON_FRAME ) { 01571 return true; 01572 } 01573 01574 buf = rf_ptr->pd_data_request_queue_to_go; 01575 01576 while(buf) { 01577 if (buf->fcf_dsn.frametype == FC_BEACON_FRAME ) { 01578 return true; 01579 } 01580 buf = buf->next; 01581 } 01582 return false; 01583 } 01584 01585 int8_t mac_mlme_beacon_tx(protocol_interface_rf_mac_setup_s *rf_ptr) 01586 { 01587 if (!rf_ptr || !rf_ptr->macCapCordinator) { 01588 return -1; 01589 } 01590 01591 //Verify if beacon is already generated to queue 01592 if (mac_mlme_beacon_at_queue(rf_ptr)) { 01593 return -2; 01594 } 01595 01596 uint16_t length = 4; 01597 length += rf_ptr->mac_beacon_payload_size; 01598 // Add more space for FHSS synchronization info 01599 if (rf_ptr->fhss_api) { 01600 length += FHSS_SYNCH_INFO_LENGTH; 01601 } 01602 /* if (rf_ptr->beacon_join_priority_tx_cb_ptr) { 01603 length += 2; 01604 }*/ 01605 01606 mac_pre_build_frame_t *buf = mcps_sap_prebuild_frame_buffer_get(length); 01607 if(!buf) { 01608 return -1; 01609 } 01610 uint8_t sf_2 = 0x0f; 01611 01612 buf->fcf_dsn.frametype = FC_BEACON_FRAME; 01613 buf->fcf_dsn.DstAddrMode = MAC_ADDR_MODE_NONE; 01614 01615 if (rf_ptr->beaconSrcAddressModeLong) { 01616 buf->fcf_dsn.SrcAddrMode = MAC_ADDR_MODE_64_BIT; 01617 buf->mac_header_length_with_security = 13; 01618 } else { 01619 if (rf_ptr->shortAdressValid) { 01620 buf->fcf_dsn.SrcAddrMode = MAC_ADDR_MODE_16_BIT; 01621 buf->mac_header_length_with_security = 7; 01622 } else { 01623 buf->fcf_dsn.SrcAddrMode = MAC_ADDR_MODE_64_BIT; 01624 buf->mac_header_length_with_security = 13; 01625 } 01626 } 01627 buf->SrcPANId = mac_mlme_get_panid(rf_ptr); 01628 mac_frame_src_address_set_from_interface(buf->fcf_dsn.SrcAddrMode, rf_ptr, buf->SrcAddr); 01629 uint8_t *ptr = buf->mac_payload; 01630 01631 *ptr++ = 0xff;//Superframe disabled 01632 01633 if (rf_ptr->macCapCordinator) { 01634 sf_2 |= 0x40; //Cord 01635 } 01636 01637 if (rf_ptr->macCapBatteryPowered) { 01638 sf_2 |= 0x10; //Battery 01639 } 01640 01641 if (rf_ptr->macCapAssocationPermit) { 01642 sf_2 |= 0x80; //Permit 01643 } 01644 *ptr++ = sf_2; //Superframe desc MSB 01645 ptr = common_write_16_bit(0, ptr); //NO GTS Support 01646 01647 if (rf_ptr->mac_beacon_payload_size) { 01648 memcpy(ptr, rf_ptr->mac_beacon_payload, rf_ptr->mac_beacon_payload_size); 01649 01650 /*if (rf_ptr->beacon_join_priority_tx_cb_ptr) { 01651 uint8_t beacon_join_priority = rf_ptr->beacon_join_priority_tx_cb_ptr(rf_ptr->mac_interface_id); 01652 ptr[PLAIN_BEACON_PAYLOAD_SIZE] = BEACON_OPTION_JOIN_PRIORITY_TYPE_LEN; 01653 ptr[PLAIN_BEACON_PAYLOAD_SIZE + 1] = beacon_join_priority; 01654 ptr += BEACON_OPTION_JOIN_PRIORITY_LEN; 01655 }*/ 01656 } 01657 buf->priority = MAC_PD_DATA_HIGH_PRIOTITY; 01658 01659 tr_debug("BEA tx"); 01660 mcps_sap_pd_req_queue_write(rf_ptr, buf); 01661 sw_mac_stats_update(rf_ptr, STAT_MAC_BEA_TX_COUNT, 0); 01662 return 0; 01663 } 01664
Generated on Tue Jul 12 2022 12:22:03 by
1.7.2